diff --git a/.appveyor.yml b/.appveyor.yml
index 5110db03..033f7f4d 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -32,7 +32,7 @@ environment:
     PYTHON_DEF: "C:\\Python38-x64"
     PYTHON_VERSION: "3.8"
     # Python versions to build wheels for
-    PYTHONVERS: C:\Python36-x64 C:\Python37-x64 C:\Python38-x64 C:\Python39-x64 C:\Python310-x64
+    PYTHONVERS: C:\Python38-x64 C:\Python39-x64 C:\Python310-x64 C:\Python311-x64 C:\Python312-x64
     PYTHON_ARCH: "64"
     MSVC: "Visual Studio 16 2019"
 
@@ -46,7 +46,7 @@ install:
         https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
         Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
           throw "There are newer queued builds for this pull request, failing early." }
-  - set OPENSSL_DIR="C:\OpenSSL-v11-Win%PYTHON_ARCH%"
+  - set OPENSSL_DIR="C:\OpenSSL-v34-Win64"
   - set VCLIBDIR=%WINDIR%\System32
   - cp %VCLIBDIR%/vcruntime*.dll ssh2/
   - cp %VCLIBDIR%/msvcp*.dll ssh2/
@@ -65,27 +65,16 @@ install:
   - 7z x ci\appveyor\zlib1211.zip
 
 build_script:
+  - dir %OPENSSL_DIR%\lib\VC\x64\MD
   - ci\\appveyor\\build_zlib.bat
   - for %%I in (%PYTHONVERS%) do cp C:/zlib/lib/zlibstatic.lib %%I/libs/
   - for %%I in (%PYTHONVERS%) do ls %%I/libs/
   - ci\\appveyor\\build_ssh2.bat
   - for %%I in (%PYTHONVERS%) do cp build_dir/src/libssh2.lib %%I/libs/ || cp build_dir/src/Release/libssh2.lib %%I/libs/
   - rm -f ssh2/*.c
-  - ps: ls ssh2
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe -V
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py build_ext
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py build
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py install
-  - ps: ls ssh2
 
 test_script:
-  - cd dist
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe -c "from ssh2.session import Session; Session()"
-  - cd ..
-
-after_test:
-  - for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py bdist_wheel
-  - mv dist/* .
+  - ci\\appveyor\\build_package.bat
 
 artifacts:
   - path: "*.whl"
diff --git a/.circleci/config.yml b/.circleci/config.yml
index 63b4f237..7963ca08 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -15,33 +15,26 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 version: 2.1
 
-orbs:
-  python: circleci/python@0.3.2
 
 jobs:
   python_test:
     parameters:
       python_ver:
         type: string
-        default: "3.6"
+        default: "3.10"
     docker:
-      - image: circleci/python:<< parameters.python_ver >>
+      - image: cimg/python:<< parameters.python_ver >>
     steps:
       - checkout
-      - python/load-cache:
-          dependency-file: requirements_dev.txt
-          key: depsv3-{{ .Branch }}.{{ arch }}-PY<< parameters.python_ver >>
       - run:
           name: Deps
           command: |
             sudo apt-get update
             sudo apt-get install cmake openssh-server
             pip install -r requirements_dev.txt
-      - python/save-cache:
-          dependency-file: requirements_dev.txt
-          key: depsv3-{{ .Branch }}.{{ arch }}-PY<< parameters.python_ver >>
       - run:
           command: |
+            pip uninstall -y cython
             python setup.py build_ext --inplace
             eval "$(ssh-agent -s)"
           name: Build
@@ -50,20 +43,32 @@ jobs:
             set -x
             ls -lhtr ssh2/
             pwd
-            pytest tests
+            python -m pytest tests
+          name: Test
+      - run:
+          command: |
+            python -m pytest ci/integration_tests
+          name: Integration
+      - run:
+          command: |
             flake8 ssh2
+          name: Flake
+      - run:
+          command: |
             python setup.py sdist
             cd dist; pip install *; python -c 'from ssh2.session import Session; Session()'; cd ..
+          name: Sdist Install
+      - run:
+          command: |
             cd doc
             make html
             cd ..
-          name: Test
+          name: Docs
 
   osx:
     parameters:
       xcode_ver:
         type: string
-        default: "11.6.0"
     macos:
       xcode: << parameters.xcode_ver >>
     environment:
@@ -75,6 +80,8 @@ jobs:
           name: deps
           command: |
             brew install cmake git-lfs python libssh2
+            brew link --force openssl
+            brew link --force libssh2
             pip3 install twine
             which twine
       - run:
@@ -90,12 +97,9 @@ jobs:
 
   manylinux-x86_64:
     machine:
-      image: ubuntu-2004:202201-02
+      image: ubuntu-2004:current
     steps: &manylinux-steps
       - checkout
-      - python/load-cache:
-          key: manylinuxdepsv6-{{ .Branch }}.{{ arch }}
-          dependency-file: requirements_dev.txt
       - run:
           name: Git LFS
           command: |
@@ -110,11 +114,7 @@ jobs:
             pip install -U pip
             pip install twine
             which twine
-            which python
             which python3
-      - python/save-cache:
-          key: manylinuxdepsv6-{{ .Branch }}.{{ arch }}
-          dependency-file: requirements_dev.txt
       - run:
           name: Build Wheels
           command: |
@@ -134,22 +134,22 @@ jobs:
 
   manylinux2014-aarch64:
     machine:
-      image: ubuntu-2004:202101-01
+      image: ubuntu-2004:current
     resource_class: arm.medium
     steps: *manylinux-steps
 
 workflows:
-  version: 2.1
+  version: 2
   main:
     jobs:
       - python_test:
           matrix:
             parameters:
               python_ver:
-                - "3.6"
                 - "3.8"
-                - "3.9"
                 - "3.10"
+                - "3.11"
+                - "3.12"
           filters:
             tags:
               ignore: /.*/
@@ -166,7 +166,8 @@ workflows:
             parameters:
               xcode_ver:
                 - "14.0.0"
-                - "13.1.0"
+                - "15.0.0"
+                - "16.0.0"
           filters:
             tags:
               only: /.*/
diff --git a/.gitattributes b/.gitattributes
index 36d8e731..c09e4257 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -6,3 +6,4 @@ zlib1211.zip filter=lfs diff=lfs merge=lfs -text
 *.rpm filter=lfs diff=lfs merge=lfs -text
 ci/docker/manylinux/libssh2.tar.gz filter=lfs diff=lfs merge=lfs -text
 ci/docker/manylinux/cmake-2.8.11.1-5.4.x86_64.rpm filter=lfs diff=lfs merge=lfs -text
+ssh2/_version.py export-subst
diff --git a/Changelog.rst b/Changelog.rst
index 89346b24..1a023fd6 100644
--- a/Changelog.rst
+++ b/Changelog.rst
@@ -1,6 +1,24 @@
 Change Log
 =============
 
+1.1.0 (unreleased)
+++++++++++++++++++
+
+Changes
+--------
+
+* Support for Python >=3.12.
+* Upgraded embedded and wheel ``libssh2`` to ``1.11.1``.
+* Upgraded wheel OpenSSL to 3.4.0.
+* Removed testing for Python versions <3.8.
+
+Packaging
+----------
+
+* Added binary wheels for Python versions 3.11, 3.12.
+* Added OSX 12.0 and 13.0 wheels, Apple Silicon.
+
+
 1.0.0
 ++++++
 
diff --git a/MANIFEST.in b/MANIFEST.in
index fd1c671f..f3057f5c 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -3,7 +3,8 @@ recursive-exclude docker *
 include _setup_libssh2.py
 include versioneer.py
 include ssh2/_version.py
-recursive-exclude .circleci
+recursive-exclude .circleci *
+recursive-exclude ci *
 include LICENSE
 include ssh2/*.pyx
 include ssh2/*.pxd
diff --git a/_setup_libssh2.py b/_setup_libssh2.py
index 7245048e..6f4467c6 100644
--- a/_setup_libssh2.py
+++ b/_setup_libssh2.py
@@ -14,11 +14,11 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 import os
-
-from sys import stderr
-from subprocess import check_call
 from glob import glob
 from shutil import copy2
+from subprocess import check_call
+
+from sys import stderr
 
 
 def build_ssh2():
@@ -27,12 +27,14 @@ def build_ssh2():
         return
     if os.path.exists('/usr/local/opt/openssl'):
         os.environ['OPENSSL_ROOT_DIR'] = '/usr/local/opt/openssl'
+    if os.path.exists('/opt/homebrew/opt/openssl'):
+        os.environ['OPENSSL_ROOT_DIR'] = '/opt/homebrew/opt/openssl'
 
     if not os.path.exists('build_dir'):
         os.mkdir('build_dir')
 
     os.chdir('build_dir')
-    check_call('cmake ../libssh2/libssh2 -DBUILD_SHARED_LIBS=ON \
+    check_call('cmake ../libssh2 -DBUILD_SHARED_LIBS=ON \
     -DENABLE_ZLIB_COMPRESSION=ON -DENABLE_CRYPT_NONE=ON \
     -DENABLE_MAC_NONE=ON -DCRYPTO_BACKEND=OpenSSL',
                shell=True, env=os.environ)
diff --git a/ci/appveyor/build_package.bat b/ci/appveyor/build_package.bat
new file mode 100755
index 00000000..fb0d347f
--- /dev/null
+++ b/ci/appveyor/build_package.bat
@@ -0,0 +1,17 @@
+IF NOT "%APPVEYOR_REPO_TAG%" == "true" (exit 0)
+
+dir ssh2/
+
+for %%I in (%PYTHONVERS%) do %%I\python.exe -V
+for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py build_ext
+for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py build
+for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py install
+
+dir ssh2/
+
+cd dist
+for %%I in (%PYTHONVERS%) do %%I\python.exe -c "from ssh2.session import Session; Session()"
+cd ..
+
+for %%I in (%PYTHONVERS%) do %%I\python.exe setup.py bdist_wheel
+mv dist/* .
diff --git a/ci/appveyor/build_ssh2.bat b/ci/appveyor/build_ssh2.bat
index b1fbdd85..6e318cc7 100755
--- a/ci/appveyor/build_ssh2.bat
+++ b/ci/appveyor/build_ssh2.bat
@@ -2,7 +2,7 @@ mkdir build_dir
 cd build_dir
 
 ECHO "Building with platform %MSVC%"
-cmake ..\libssh2\libssh2 -G "NMake Makefiles" ^
+cmake ..\libssh2 -G "NMake Makefiles" ^
        -DCMAKE_BUILD_TYPE=Release             ^
        -DCRYPTO_BACKEND=OpenSSL               ^
        -G"%MSVC%"                             ^
@@ -16,8 +16,8 @@ cmake ..\libssh2\libssh2 -G "NMake Makefiles" ^
        -DOPENSSL_ROOT_DIR=%OPENSSL_DIR%
 )
 
-cp %OPENSSL_DIR%\lib\VC\libcrypto%PYTHON_ARCH%MD.lib %APPVEYOR_BUILD_FOLDER%
-cp %OPENSSL_DIR%\lib\VC\libssl%PYTHON_ARCH%MD.lib %APPVEYOR_BUILD_FOLDER%
+cp %OPENSSL_DIR%\lib\VC\x64\MD\libcrypto.lib %APPVEYOR_BUILD_FOLDER%
+cp %OPENSSL_DIR%\lib\VC\x64\MD\libssl.lib %APPVEYOR_BUILD_FOLDER%
 
 cmake --build . --config Release
 cd ..
diff --git a/ci/build-wheels.sh b/ci/build-wheels.sh
index 69165925..10f3dade 100755
--- a/ci/build-wheels.sh
+++ b/ci/build-wheels.sh
@@ -17,7 +17,7 @@
 
 # Compile wheels
 # For testing
-# for PYBIN in `ls -1d /opt/python/cp36-cp36m/bin | grep -v cpython`; do
+# for PYBIN in `ls -1d /opt/python/cp310-cp310/bin | grep -v cpython`; do
 for PYBIN in $(ls -1d /opt/python/*/bin | grep -v cpython); do
     "${PYBIN}/pip" wheel /io/ -w wheelhouse/
 done
@@ -29,6 +29,8 @@ done
 
 # Install packages and test
 for PYBIN in $(ls -1d /opt/python/*/bin | grep -v cpython); do
+# for PYBIN in `ls -1d /opt/python/cp310-cp310/bin | grep -v cpython`; do
   "${PYBIN}/pip" install ssh2-python --no-index -f /io/wheelhouse
-  (cd "$HOME"; "${PYBIN}/python" -c 'from ssh2.session import Session; Session()')
+  (cd "$HOME"; "${PYBIN}/python" -c 'from ssh2.session import Session; Session()' &&
+  echo "Import sanity check succeeded.")
 done
diff --git a/ci/docker/manylinux/Dockerfile b/ci/docker/manylinux/Dockerfile
index 333b9d6b..5af5aacf 100644
--- a/ci/docker/manylinux/Dockerfile
+++ b/ci/docker/manylinux/Dockerfile
@@ -15,11 +15,11 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 FROM quay.io/pypa/manylinux2010_x86_64
 
-ENV OPENSSL openssl-1.1.1q
+ENV OPENSSL openssl-3.4.0
 ENV SYSTEM_LIBSSH2 1
-ENV LIBSSH2_VERSION 1.10.0
+ENV LIBSSH2_VERSION 1.11.1
 
-RUN yum install zlib-devel -y
+RUN yum install zlib-devel perl-IPC-Cmd -y
 
 ADD libssh2-${LIBSSH2_VERSION}.tar.gz libssh2-${LIBSSH2_VERSION}.tar.gz
 ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz
diff --git a/ci/docker/manylinux/Dockerfile.2014_x86_64 b/ci/docker/manylinux/Dockerfile.2014_x86_64
index 4c6b7f7d..48a2aa34 100644
--- a/ci/docker/manylinux/Dockerfile.2014_x86_64
+++ b/ci/docker/manylinux/Dockerfile.2014_x86_64
@@ -15,11 +15,11 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 FROM quay.io/pypa/manylinux2014_x86_64
 
-ENV OPENSSL openssl-1.1.1q
+ENV OPENSSL openssl-3.4.0
 ENV SYSTEM_LIBSSH2 1
-ENV LIBSSH2_VERSION 1.10.0
+ENV LIBSSH2_VERSION 1.11.1
 
-RUN yum install zlib-devel -y
+RUN yum install zlib-devel perl-IPC-Cmd -y
 
 ADD libssh2-${LIBSSH2_VERSION}.tar.gz libssh2-${LIBSSH2_VERSION}.tar.gz
 ADD https://www.openssl.org/source/${OPENSSL}.tar.gz ${OPENSSL}.tar.gz
diff --git a/ci/docker/manylinux/Dockerfile.aarch64 b/ci/docker/manylinux/Dockerfile.aarch64
index 59c34a5d..a4770157 100644
--- a/ci/docker/manylinux/Dockerfile.aarch64
+++ b/ci/docker/manylinux/Dockerfile.aarch64
@@ -15,9 +15,9 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 FROM quay.io/pypa/manylinux2014_aarch64
 
-ENV OPENSSL openssl-1.1.1q
+ENV OPENSSL openssl-3.4.0
 ENV SYSTEM_LIBSSH2 1
-ENV LIBSSH2_VERSION 1.10.0
+ENV LIBSSH2_VERSION 1.11.1
 
 RUN yum install zlib-devel -y
 
diff --git a/ci/docker/manylinux/libssh2-1.10.0.tar.gz b/ci/docker/manylinux/libssh2-1.10.0.tar.gz
deleted file mode 100644
index 34c2f7df..00000000
--- a/ci/docker/manylinux/libssh2-1.10.0.tar.gz
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2d64e90f3ded394b91d3a2e774ca203a4179f69aebee03003e5a6fa621e41d51
-size 965044
diff --git a/ci/docker/manylinux/libssh2-1.11.1.tar.gz b/ci/docker/manylinux/libssh2-1.11.1.tar.gz
new file mode 100644
index 00000000..ac178979
--- /dev/null
+++ b/ci/docker/manylinux/libssh2-1.11.1.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9ec76cbe34db98eec3539fe2c899d26b0c837cb3eb466a56b0f109cabf658f7
+size 1093012
diff --git a/tests/embedded_server/__init__.py b/ci/integration_tests/__init__.py
similarity index 100%
rename from tests/embedded_server/__init__.py
rename to ci/integration_tests/__init__.py
diff --git a/ci/integration_tests/base_test.py b/ci/integration_tests/base_test.py
new file mode 100644
index 00000000..555918b4
--- /dev/null
+++ b/ci/integration_tests/base_test.py
@@ -0,0 +1,56 @@
+import os
+import pwd
+import socket
+import unittest
+from sys import version_info
+
+from ssh2.exceptions import SSH2Error
+from ssh2.session import Session
+
+from .embedded_server.openssh import OpenSSHServer
+
+PKEY_FILENAME = os.path.sep.join([os.path.dirname(__file__), 'unit_test_key'])
+PUB_FILE = "%s.pub" % (PKEY_FILENAME,)
+
+
+class SSH2TestCase(unittest.TestCase):
+
+    server = None
+
+    @classmethod
+    def setUpClass(cls):
+        _mask = int('0600') if version_info <= (2,) else 0o600
+        os.chmod(PKEY_FILENAME, _mask)
+        cls.server = OpenSSHServer()
+        cls.server.start_server()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.stop()
+        del cls.server
+
+    def setUp(self):
+        self.host = '127.0.0.1'
+        self.port = 2222
+        self.cmd = 'echo me'
+        self.resp = u'me'
+        self.user_key = PKEY_FILENAME
+        self.user_pub_key = PUB_FILE
+        self.user = pwd.getpwuid(os.geteuid()).pw_name
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((self.host, self.port))
+        self.sock = sock
+        self.session = Session()
+        self.session.handshake(self.sock)
+
+    def tearDown(self):
+        try:
+            self.session.disconnect()
+        except SSH2Error:
+            return
+        else:
+            self.sock.close()
+
+    def _auth(self):
+        return self.session.userauth_publickey_fromfile(
+            self.user, self.user_key)
diff --git a/ci/integration_tests/embedded_server/__init__.py b/ci/integration_tests/embedded_server/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/embedded_server/authorized_keys b/ci/integration_tests/embedded_server/authorized_keys
similarity index 100%
rename from tests/embedded_server/authorized_keys
rename to ci/integration_tests/embedded_server/authorized_keys
diff --git a/ci/integration_tests/embedded_server/ca_host_key b/ci/integration_tests/embedded_server/ca_host_key
new file mode 100644
index 00000000..769abf0c
--- /dev/null
+++ b/ci/integration_tests/embedded_server/ca_host_key
@@ -0,0 +1,40 @@
+-----BEGIN PRIVATE KEY-----
+MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQCphJViWy6xwUQn
+gUeHU2AmHaHj/kkDSI4dHQLoWhYwEQ85CowwDaJ7NhZBr6bpA0OTYBgXcfkQw8nc
+H2k6HybfeT9KXLogTS/hKwZIz1NY5bvVBHSXI8uzSX5OlBujPUxk99kc1Vm3OA9f
+KB0iCdufgmdXo+3c3JBG5EqO4H21u8zxwfHmVpigkERGxMYkOMWEjAF7i7kptG9d
+0Gtijw8GWYUmO7R2xkBWsLaZY3llOdCCH6EDYerfHdUOnkwvm0yhy4UqSt8Cu6Xo
+ErhdH4l+uF4Pbz+rWgmQ7GQlpSCgZqrIAyyQyTQOn+heFkGr407lFl+PkClXHK5N
+gZ90EgXSA+dRNl9Qjw3BO5tUN9jWALEURfT4CQemtSe+1JNMbxsA7+byW1YeLbVZ
+knBMieRhMoerXRvG9ENglkYeFzKeKKAj0pS5FzzegXP4QxK+XAkX1Mw3GTRGkrpw
+rd8b6FVWf/yFzCFkm//rCQiQ933om57Q3QQriJtABfBH0L9bg2sCAwEAAQKCAYEA
+i3Ld0INh7igmgLkAtnoH5lMKEhvkxCazgY+UDL/O8MuX0jyzBfSxbNoZhP+SNqzQ
+sjOinebMFNZ6//F3BrEJsVx0jB+rnVbhxEE4cjzbO44A7kM0BgEUWPBkTw/XjHmo
+loasu+NmYipjusus64tgd982VAouajmnFipGizJxN0a+WUJKVEl4VN1YzT6iILnz
+Ag6KSa+vKnecBXimXfWBTp/lwIXs9qgv1SCZlaUXAAaHWAPc2IN8Sv6nfdcKpT8C
+fDE9du146QvFlfvzxvyz5c5OwIlKHc/6+LSOcp+OJTE+8mrXqkYJGLuD8pdPVYQm
+NfpzHm7LKUNwS2v+lS9hviEwIGkZo4ZepFB4ij9wllngBY4j9jGPlakwUu0D9Vyf
+r+pHUrKfRVi8xqyZT9S20Z+3KkTqAVeblPWCxBGvyAl2JU/sY2LelfZo+P89uKqU
+12+uEha5WIyCgMyBuYS0LUgzkBLfQAsBj1RLcqvG3WLV1sSXL6q2U5OvdC3tTevB
+AoHBANjwpGuxibDk/UnKbVtOxJbpUJkM8BiZnV8NuPXvi/qHjfwrTK/UnRwC5ZCZ
+eetm5vWCxClspVewidR3HWa1kxTVcgSO2J3PlAgpKR8phdkFO68+heLExYamYUgu
+IYP3C0Kygcj9HLWueJtecq/ogUNYmJKCcI381iTbt2iqth/35nbe8l7Xa+XBfvhS
+ytVohlO3QZX/ubtosgNEwuxGDQj9YxEejt5t0f8CHVETvN+xzbWjnIpn3+KJLKRy
+DdHs3QKBwQDICiB8wImZFNnrDGpycng78P34CUrxaEmCN1/SiN2GJ5LYVS++K2Pc
+I/9a0x4TSGvDNCNt4RE8ebwWcTe0U8rEw99kUKNlI4ZvpVJvv0vH8IabGC3p0gBf
+OlGhoIYOqvDzkL58P48IbP43wfOGJqenkGx8SXWEGUnYTzSEoFJHv3RHE9b86q0b
+cm3NyyxBWPM9DBQ2e594ouVNKeLo6HT3j5ZW5ypFjWhCnIoyENabPAHWTYKUnu/f
+W7NN1W+5aOcCgcABQSsCQG2Wa0yXr6cAPy1d3g2MRQniaokBcrfeHDuIAF6u1aVE
+4wrhjZa8RlbxKJAvXUk7IBi4sBmr8+BkpqoqFa3qHtVb3EZz4aEOQBQ5FBGrSsZF
+cHPf+nhXjYS+GaCkCxo7ClOvLUofQ+WP5N1SgWGofz6dY5ftcKPX5BzXhHx9tX5b
+VA2Yr4zHbNslbsxQEaA8eNUfI1TcNfqWmTUcFzMKd03GNYZgXifDP0T5WjLhWQff
+uQgPbFGoxcwUqbUCgcBomYsFULRinJmao8Jhl+OxDEHw2gMbGnodohD0COc1CCpr
+/pdZbFzqNtSGzJAUazEWQIQqJ58YrVshrRAAtjP4EagVT2kxMJNSe/MQRco9gVMR
+dGJFuq7BHMCksEiJEO+vnMdONvn24O9Jfpx1UG8oWoevscXGTmbjuf7vPtnndIA7
+zm8Djz73dC1gh9XbUcTW7iL/nkL0FNGsOLPTMAJBlQ564KOk/N1Av5Qvu8hMIeOg
+CKW4SyeI9u1aTLoADI8CgcEA0zy4laBzjAlN6Uc7RTTiqd259R7vqlc95wPkLDS0
+jg+mfpNHyNdtAhHnFnKVYgu4qqshcjX4BwW1m15/lHZ3VTY71U0TYHGeD1F2WY7R
+ptMFo8iiUrY1qAS79dFutY5MGHD9htw11j52GgBz0dAB1Z9MtXblS+3QeS0m79g8
+srLhNUQPKrl61h2aT2nv2mROYZJ5lkDcByGcwSpXAAUXrJ7WQtcaQ5awq/Uqwfac
+niIHADTER1prOuXylm1pWZdk
+-----END PRIVATE KEY-----
diff --git a/tests/embedded_server/known_hosts b/ci/integration_tests/embedded_server/known_hosts
similarity index 100%
rename from tests/embedded_server/known_hosts
rename to ci/integration_tests/embedded_server/known_hosts
diff --git a/tests/embedded_server/openssh.py b/ci/integration_tests/embedded_server/openssh.py
similarity index 82%
rename from tests/embedded_server/openssh.py
rename to ci/integration_tests/embedded_server/openssh.py
index 90cc67e2..26e6332c 100644
--- a/tests/embedded_server/openssh.py
+++ b/ci/integration_tests/embedded_server/openssh.py
@@ -15,10 +15,12 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 import os
+import random
 import socket
+import string
 from subprocess import Popen
-from time import sleep
 from sys import version_info
+from time import sleep
 
 from jinja2 import Template
 
@@ -33,10 +35,13 @@
 
 class OpenSSHServer(object):
 
-    def __init__(self, port=2222):
+    def __init__(self, listen_ip='127.0.0.1', port=2222):
+        self.listen_ip = listen_ip
         self.port = port
         self.server_proc = None
         self._fix_masks()
+        self.random_server = ''.join(random.choice(string.ascii_lowercase + string.digits)
+                                     for _ in range(8))
         self.make_config()
 
     def _fix_masks(self):
@@ -51,7 +56,11 @@ def make_config(self):
             tmpl = fh.read()
         template = Template(tmpl)
         with open(SSHD_CONFIG, 'w') as fh:
-            fh.write(template.render(parent_dir=os.path.abspath(DIR_NAME)))
+            fh.write(template.render(
+                parent_dir=os.path.abspath(DIR_NAME),
+                listen_ip=self.listen_ip,
+                random_server=self.random_server,
+            ))
             fh.write(os.linesep)
 
     def start_server(self):
@@ -63,7 +72,7 @@ def start_server(self):
 
     def _wait_for_port(self):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        while sock.connect_ex(('127.0.0.1', self.port)) != 0:
+        while sock.connect_ex((self.listen_ip, self.port)) != 0:
             sleep(.1)
         sock.close()
 
diff --git a/tests/embedded_server/rsa.key b/ci/integration_tests/embedded_server/rsa.key
similarity index 100%
rename from tests/embedded_server/rsa.key
rename to ci/integration_tests/embedded_server/rsa.key
diff --git a/ci/integration_tests/embedded_server/sshd_config.tmpl b/ci/integration_tests/embedded_server/sshd_config.tmpl
new file mode 100644
index 00000000..5c930009
--- /dev/null
+++ b/ci/integration_tests/embedded_server/sshd_config.tmpl
@@ -0,0 +1,17 @@
+Protocol 2
+UsePAM no
+HostbasedAuthentication no
+IgnoreUserKnownHosts yes
+ListenAddress {{listen_ip}}
+HostKey {{parent_dir}}/ca_host_key
+
+MaxAuthTries 999
+MaxSessions 999
+MaxStartups 999
+# PerSourceMaxStartups 999
+# PerSourcePenaltyExemptList *.*.*.*
+
+AcceptEnv LANG LC_*
+Subsystem sftp internal-sftp
+AuthorizedKeysFile {{parent_dir}}/authorized_keys
+PidFile {{parent_dir}}/{{random_server}}.pid
diff --git a/ci/integration_tests/test_agent.py b/ci/integration_tests/test_agent.py
new file mode 100644
index 00000000..64a60c5f
--- /dev/null
+++ b/ci/integration_tests/test_agent.py
@@ -0,0 +1,25 @@
+from .base_test import SSH2TestCase
+from ssh2.agent import Agent
+
+
+class SessionTestCase(SSH2TestCase):
+
+    def test_agent_pyobject(self):
+        agent = Agent(self.session)
+        self.assertIsInstance(agent, Agent)
+
+    def test_agent_get_identities(self):
+        agent = Agent(self.session)
+        agent.connect()
+        ids = agent.get_identities()
+        self.assertIsInstance(ids, list)
+        agent.disconnect()
+
+    def test_agent_id_path(self):
+        agent = Agent(self.session)
+        agent.connect()
+        _path = b'my_path'
+        agent.set_identity_path(_path)
+        path = agent.get_identity_path()
+        self.assertEqual(_path, path)
+        agent.disconnect()
diff --git a/ci/integration_tests/test_channel.py b/ci/integration_tests/test_channel.py
new file mode 100644
index 00000000..afb0f57d
--- /dev/null
+++ b/ci/integration_tests/test_channel.py
@@ -0,0 +1,195 @@
+import os
+from subprocess import check_output
+from unittest import skipUnless
+
+from ssh2.channel import Channel
+from ssh2.exceptions import SocketSendError
+
+from .base_test import SSH2TestCase
+
+
+class ChannelTestCase(SSH2TestCase):
+
+    def test_execute(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertTrue(chan.execute(self.cmd) == 0)
+        size, data = chan.read()
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertTrue(size > 0)
+        self.assertTrue(lines, [self.resp])
+        self.assertEqual(chan.wait_eof(), 0)
+        self.assertEqual(chan.wait_closed(), 0)
+
+    def test_exit_code(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        chan.execute('exit 2')
+        chan.send_eof()
+        chan.wait_eof()
+        chan.close()
+        chan.wait_closed()
+        exit_code = chan.get_exit_status()
+        self.assertEqual(exit_code, 2)
+
+    def test_long_running_execute(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        chan.execute('sleep 1; exit 3')
+        self.assertTrue(chan.wait_eof() == 0)
+        self.assertTrue(chan.close() == 0)
+        self.assertTrue(chan.wait_closed() == 0)
+        self.assertEqual(chan.get_exit_status(), 3)
+
+    def test_read_stderr(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        expected = ['stderr output']
+        chan.execute('echo "stderr output" >&2')
+        size, data = chan.read_stderr()
+        self.assertTrue(size > 0)
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertListEqual(expected, lines)
+
+    def test_pty(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.assertTrue(chan.pty() == 0)
+        _out = u'stderr output'
+        expected = [_out]
+        chan.execute(u'echo "%s" >&2' % (_out,))
+        # stderr output gets redirected to stdout with a PTY
+        size, data = chan.read()
+        self.assertTrue(size > 0)
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertListEqual(expected, lines)
+
+    def test_pty_failure(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.sock.close()
+        self.assertRaises(SocketSendError, chan.pty)
+
+    def test_write_stdin(self):
+        self.assertEqual(self._auth(), 0)
+        _in = u'writing to stdin'
+        chan = self.session.open_session()
+        chan.execute('cat')
+        chan.write(_in + '\n')
+        self.assertEqual(chan.send_eof(), 0)
+        size, data = chan.read()
+        self.assertTrue(size > 0)
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertListEqual([_in], lines)
+        chan.close()
+        self.assertEqual(chan.wait_eof(), 0)
+        self.assertTrue(chan.eof())
+        self.assertEqual(chan.wait_closed(), 0)
+
+    def test_write_ex(self):
+        self.assertEqual(self._auth(), 0)
+        _in = u'writing to stdin'
+        chan = self.session.open_session()
+        chan.execute('cat')
+        chan.write_ex(0, _in + '\n')
+        self.assertEqual(chan.send_eof(), 0)
+        size, data = chan.read()
+        self.assertTrue(size > 0)
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertListEqual([_in], lines)
+
+    def test_write_stderr(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        chan.execute('echo something')
+        _in = u'stderr'
+        self.assertTrue(chan.write_stderr(_in + '\n')[0] > 0)
+        self.assertEqual(chan.close(), 0)
+
+    def test_setenv(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        _var = 'LC_MY_VAR'
+        _val = 'value'
+        self.assertEqual(chan.setenv('LC_MY_VAR', _val), 0)
+        chan.execute('env | grep LC_MY_VAR')
+        expected = u'%s=%s\n' % (_var, _val)
+        size, data = chan.read()
+        self.assertTrue(size > 0)
+        self.assertEqual(data.decode('utf-8'), expected)
+
+    def test_shell(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertEqual(chan.shell(), 0)
+        chan.write('echo me\n')
+        size, data = chan.read()
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertTrue(size > 0)
+        self.assertTrue(lines, [self.resp])
+        self.assertTrue(chan.close() == 0)
+        self.assertTrue(chan.wait_eof() == 0)
+
+    def test_process_startup(self):
+        self.assertEqual(self._auth(), 0)
+        # Shell
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertEqual(chan.process_startup('shell'), 0)
+        chan.write('echo me\n')
+        size, data = chan.read()
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertTrue(size > 0)
+        self.assertTrue(lines, [self.resp])
+        self.assertTrue(chan.close() == 0)
+        self.assertTrue(chan.wait_eof() == 0)
+        # Exec
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertEqual(chan.process_startup('exec', self.cmd), 0)
+        size, data = chan.read()
+        lines = [line.decode('utf-8') for line in data.splitlines()]
+        self.assertTrue(size > 0)
+        self.assertTrue(lines, [self.resp])
+        self.assertTrue(chan.close() == 0)
+        self.assertTrue(chan.wait_eof() == 0)
+
+    @skipUnless(hasattr(Channel, 'request_auth_agent'),
+                "No agent forwarding implementation")
+    def test_agent_forwarding(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.assertEqual(chan.request_auth_agent(), 0)
+
+    def test_read_file(self):
+        self._auth()
+        abs_file = os.sep.join([
+            os.path.dirname(__file__), '..', '..', 'setup.py',
+        ])
+        wc_output = check_output(['wc', '-l', abs_file]).split()[0]
+        chan = self.session.open_session()
+        cmd = 'cat %s' % (abs_file,)
+        chan.execute(cmd)
+        tot_data = b""
+        size, data = chan.read()
+        while size > 0:
+            tot_data += data
+            size, data = chan.read()
+        lines = [line for line in tot_data.splitlines()]
+        self.assertEqual(len(lines), int(wc_output))
+
+    def test_multi_execute(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertTrue(chan.execute(self.cmd) == 0)
+        size, data = chan.read()
+        self.assertTrue(size > 0)
+        self.assertEqual(chan.wait_eof(), 0)
+        chan = self.session.open_session()
+        self.assertTrue(chan is not None)
+        self.assertTrue(chan.execute(self.cmd) == 0)
+        size, data = chan.read()
+        self.assertTrue(size > 0)
diff --git a/ci/integration_tests/test_knownhost.py b/ci/integration_tests/test_knownhost.py
new file mode 100644
index 00000000..164b1a1b
--- /dev/null
+++ b/ci/integration_tests/test_knownhost.py
@@ -0,0 +1,32 @@
+import os
+
+from ssh2.exceptions import KnownHostCheckError
+from ssh2.knownhost import LIBSSH2_KNOWNHOST_TYPE_PLAIN, \
+    LIBSSH2_KNOWNHOST_KEYENC_RAW, LIBSSH2_KNOWNHOST_KEY_SSHRSA, LIBSSH2_KNOWNHOST_KEY_SSHDSS
+from ssh2.session import LIBSSH2_HOSTKEY_TYPE_RSA, LIBSSH2_HOSTKEY_HASH_SHA1
+
+from .base_test import SSH2TestCase
+
+
+class KnownHostTestCase(SSH2TestCase):
+    def test_check(self):
+        kh = self.session.knownhost_init()
+        host_key, key_type = self.session.hostkey()
+        key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA \
+            if key_type in (
+            LIBSSH2_HOSTKEY_TYPE_RSA,
+            LIBSSH2_HOSTKEY_HASH_SHA1,
+        ) else LIBSSH2_KNOWNHOST_KEY_SSHDSS
+        type_mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | \
+                    LIBSSH2_KNOWNHOST_KEYENC_RAW | \
+                    key_type
+        # Verification should fail before key is added
+        self.assertRaises(
+            KnownHostCheckError, kh.checkp, b'127.0.0.1', self.port,
+            host_key, type_mask)
+        server_known_hosts = os.sep.join([os.path.dirname(__file__),
+                                          'embedded_server',
+                                          'known_hosts'])
+        self.assertEqual(kh.readfile(server_known_hosts), 1)
+        entry = kh.checkp(b'127.0.0.1', self.port, host_key, type_mask)
+        self.assertTrue(entry is not None)
diff --git a/ci/integration_tests/test_session.py b/ci/integration_tests/test_session.py
new file mode 100644
index 00000000..06889e07
--- /dev/null
+++ b/ci/integration_tests/test_session.py
@@ -0,0 +1,337 @@
+import os
+import socket
+from unittest import skipUnless
+
+from ssh2.channel import Channel
+from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
+from ssh2.exceptions import AuthenticationError, AgentAuthenticationError, \
+    SCPProtocolError, InvalidRequestError, \
+    SocketSendError, FileError, MethodNotSupported
+from ssh2.listener import Listener
+from ssh2.session import Session, LIBSSH2_HOSTKEY_HASH_MD5, \
+    LIBSSH2_HOSTKEY_HASH_SHA1, LIBSSH2_METHOD_KEX, LIBSSH2_METHOD_CRYPT_CS
+from ssh2.sftp import SFTP
+from ssh2.utils import wait_socket
+
+from .base_test import SSH2TestCase
+
+
+class SessionTestCase(SSH2TestCase):
+
+    def _wait_eagain(self, func, *args):
+        rc = func(*args)
+        while rc == LIBSSH2_ERROR_EAGAIN:
+            wait_socket(self.sock, self.session)
+            rc = func(*args)
+        return rc
+
+    def test_pubkey_auth(self):
+        self.assertEqual(self.session.userauth_publickey_fromfile(
+            self.user, self.user_key, publickey=self.user_pub_key,
+            passphrase=''), 0)
+
+    def test_failed_password_auth(self):
+        self.assertRaises(
+            AuthenticationError,
+            self.session.userauth_password, 'FAKE USER', 'FAKE PASSWORD'
+        )
+
+    def test_failed_keyboard_interactive_auth(self):
+        self.assertRaises(
+            AuthenticationError,
+            self.session.userauth_keyboardinteractive, 'FAKE USER', 'FAKE PASSWORD'
+        )
+
+    def test_failed_keyboard_interactive_auth_valid_user(self):
+        self.assertRaises(
+            AuthenticationError,
+            self.session.userauth_keyboardinteractive, self.user, 'FAKE PASSWORD'
+        )
+
+    def test_failed_keyboard_interactive_auth_valid_user_no_pass(self):
+        self.assertRaises(
+            AuthenticationError,
+            self.session.userauth_keyboardinteractive, self.user, ''
+        )
+
+    def test_set_get_error(self):
+        msg = 'my error message'
+        self.assertEqual('', self.session.last_error())
+        self.assertEqual(self.session.set_last_error(255, msg), 255)
+        self.assertEqual(msg, self.session.last_error())
+
+    def test_fromfile_auth(self):
+        self.assertEqual(self._auth(), 0)
+        self.assertTrue(self.session.userauth_authenticated())
+
+    def test_get_auth_list(self):
+        auth_list = sorted(self.session.userauth_list(self.user))
+        expected = sorted(['publickey', 'password', 'keyboard-interactive'])
+        self.assertListEqual(auth_list, expected)
+
+    def test_direct_tcpip(self):
+        self.assertEqual(self._auth(), 0)
+        chan = self.session.direct_tcpip(self.host, self.port)
+        self.assertTrue(chan is not None)
+
+    def test_agent(self):
+        agent = self.session.agent_init()
+        self.assertTrue(agent.connect() == 0)
+
+    def test_session_get_set(self):
+        self.assertEqual(self._auth(), 0)
+        self.session.set_timeout(10)
+        self.assertEqual(self.session.get_timeout(), 10)
+        self.session.set_timeout(0)
+        self.assertEqual(self.session.get_timeout(), 0)
+        self.session.set_blocking(0)
+        self.assertEqual(self.session.get_blocking(), 0)
+        self.session.set_blocking(1)
+        self.assertEqual(self.session.get_blocking(), 1)
+
+    def test_failed_agent_auth(self):
+        self.assertRaises(AgentAuthenticationError,
+                          self.session.agent_auth, 'FAKE USER')
+
+    def test_failed_pkey_auth(self):
+        self.assertRaises(AuthenticationError,
+                          self.session.userauth_publickey_fromfile,
+                          'FAKE USER', self.user_key,
+                          publickey=self.user_pub_key)
+        self.assertRaises(FileError,
+                          self.session.userauth_publickey_fromfile,
+                          self.user, 'EVEN MORE FAKE FILE',
+                          publickey='FAKE FILE')
+
+    @skipUnless(hasattr(Session, 'scp_recv2'),
+                "Function not supported by libssh2")
+    def test_scp_recv2(self):
+        self.assertEqual(self._auth(), 0)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        try:
+            (file_chan, fileinfo) = self.session.scp_recv2(remote_filename)
+        except TypeError:
+            os.unlink(remote_filename)
+            raise
+        try:
+            total = 0
+            size, data = file_chan.read(size=fileinfo.st_size)
+            total += size
+            while total < fileinfo.st_size:
+                size, data = file_chan.read()
+                total += size
+            self.assertEqual(total, fileinfo.st_size)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+        self.assertRaises(SCPProtocolError, self.session.scp_recv2, remote_filename)
+
+    def test_scp_recv(self):
+        self.assertEqual(self._auth(), 0)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        try:
+            (file_chan, fileinfo) = self.session.scp_recv(remote_filename)
+        except TypeError:
+            os.unlink(remote_filename)
+            raise
+        try:
+            total = 0
+            size, data = file_chan.read(size=fileinfo.st_size)
+            total += size
+            while total < fileinfo.st_size:
+                total += size
+                size, data = file_chan.read()
+            self.assertEqual(total, fileinfo.st_size)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+        self.assertRaises(SCPProtocolError, self.session.scp_recv, remote_filename)
+
+    def test_scp_send(self):
+        self.assertEqual(self._auth(), 0)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        to_copy = os.sep.join([os.path.dirname(__file__),
+                               "copied"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        fileinfo = os.stat(remote_filename)
+        try:
+            chan = self.session.scp_send(
+                to_copy, fileinfo.st_mode & 777, fileinfo.st_size)
+            with open(remote_filename, 'rb') as local_fh:
+                for data in local_fh:
+                    chan.write(data)
+            chan.send_eof()
+            chan.wait_eof()
+            chan.wait_closed()
+            self.assertEqual(os.stat(to_copy).st_size,
+                             os.stat(remote_filename).st_size)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+            try:
+                os.unlink(to_copy)
+            except OSError:
+                pass
+        self.assertRaises(SCPProtocolError, self.session.scp_send,
+                          '/cannot_write', 1 & 777, 1)
+
+    @skipUnless(hasattr(Session, 'scp_send64'),
+                "Function not supported by libssh2")
+    def test_scp_send64(self):
+        self.assertEqual(self._auth(), 0)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        to_copy = os.sep.join([os.path.dirname(__file__),
+                               "copied"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        fileinfo = os.stat(remote_filename)
+        try:
+            chan = self.session.scp_send64(
+                to_copy, fileinfo.st_mode & 777, fileinfo.st_size,
+                fileinfo.st_mtime, fileinfo.st_atime)
+            with open(remote_filename, 'rb') as local_fh:
+                for data in local_fh:
+                    chan.write(data)
+            chan.send_eof()
+            chan.wait_eof()
+            chan.wait_closed()
+            self.assertEqual(os.stat(to_copy).st_size,
+                             os.stat(remote_filename).st_size)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+            try:
+                os.unlink(to_copy)
+            except OSError:
+                pass
+        self.assertRaises(SCPProtocolError, self.session.scp_send64,
+                          '/cannot_write', 0 & 777, 1, 1, 1)
+
+    def test_non_blocking(self):
+        self.assertEqual(self._auth(), 0)
+        self.session.set_blocking(False)
+        self.assertFalse(self.session.get_blocking())
+        sftp = self.session.sftp_init()
+        while sftp == LIBSSH2_ERROR_EAGAIN:
+            wait_socket(self.sock, self.session)
+            sftp = self.session.sftp_init()
+        self.assertIsNotNone(sftp)
+        self.assertIsInstance(sftp, SFTP)
+        chan = self.session.open_session()
+        while chan == LIBSSH2_ERROR_EAGAIN:
+            wait_socket(self.sock, self.session)
+            chan = self.session.open_session()
+        self.assertIsInstance(chan, Channel)
+
+    def test_non_blocking_handshake(self):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((self.host, self.port))
+        session = Session()
+        session.set_blocking(0)
+        while session.handshake(sock) == LIBSSH2_ERROR_EAGAIN:
+            continue
+
+    def test_hostkey(self):
+        self.assertEqual(self._auth(), 0)
+        for _type in [LIBSSH2_HOSTKEY_HASH_MD5, LIBSSH2_HOSTKEY_HASH_SHA1]:
+            hostkey = self.session.hostkey_hash(_type)
+            self.assertTrue(len(hostkey) > 0)
+
+    def test_forward_listen_ex(self):
+        self.assertEqual(self._auth(), 0)
+        listener, bound_port = self.session.forward_listen_ex(1)
+        self.assertIsInstance(listener, Listener)
+        self.assertIsInstance(bound_port, int)
+
+    def test_sftp_init_failure(self):
+        self.assertRaises(InvalidRequestError, self.session.sftp_init)
+
+    def test_open_channel_failure(self):
+        self.sock.close()
+        self.assertRaises(SocketSendError, self.session.open_session)
+
+    def test_direct_tcpip_failure(self):
+        self.sock.close()
+        self.assertRaises(SocketSendError, self.session.direct_tcpip,
+                          'localhost', 80)
+
+    def test_keepalive(self):
+        self.session.keepalive_config(False, 60)
+        seconds = self.session.keepalive_send()
+        self.assertTrue(seconds >= 59)
+        self.session.keepalive_config(False, 0)
+        self.assertEqual(self.session.keepalive_send(), 0)
+
+    def test_publickey_frommemory(self):
+
+        with open(self.user_key, 'rb') as pkey_f, \
+             open(self.user_pub_key, 'rb') as pubkey_f:
+            pkey = pkey_f.read()
+            pub_key = pubkey_f.read()
+        ret_val = self.session.userauth_publickey_frommemory(
+            self.user, pkey, publickeyfiledata=pub_key)
+        self.assertEqual(ret_val, 0)
+
+    def test_publickey_frommemory_no_publickey(self):
+        with open(self.user_key, 'rb') as pkey_f:
+            pkey = pkey_f.read()
+        ret_val = self.session.userauth_publickey_frommemory(
+            self.user, pkey)
+        self.assertEqual(ret_val, 0)
+
+    def test_publickey_frommemory_passphrase(self):
+        with open(self.user_key, 'rb') as pkey_f:
+            pkey = pkey_f.read()
+        ret_val = self.session.userauth_publickey_frommemory(
+            self.user, pkey,
+            passphrase="this still works when passphrase not required")
+        self.assertEqual(ret_val, 0)
+
+    def test_methods(self):
+        methods = self.session.methods(LIBSSH2_METHOD_KEX)
+        self.assertTrue(len(methods) > 0)
+        methods = self.session.methods(LIBSSH2_METHOD_CRYPT_CS)
+        self.assertEqual(self.session.method_pref(LIBSSH2_METHOD_CRYPT_CS, methods), 0)
+        algs = self.session.supported_algs(LIBSSH2_METHOD_CRYPT_CS)
+        self.assertTrue(len(algs) > 0)
+        alg = algs[0]
+        self.assertEqual(self.session.method_pref(LIBSSH2_METHOD_CRYPT_CS, alg), 0)
+
+    def test_invalid_methods(self):
+        self.assertRaises(
+            MethodNotSupported,
+            self.session.method_pref, LIBSSH2_METHOD_CRYPT_CS, 'invalid algorithm')
+        self.assertRaises(TypeError, self.session.method_pref, 0, 'fake')
+
+    def test_non_blocking_multi_chan(self):
+        self.assertEqual(self._auth(), 0)
+        self.session.set_blocking(False)
+        self.assertFalse(self.session.get_blocking())
+        chan = self._wait_eagain(self.session.open_session)
+        self.assertIsInstance(chan, Channel)
+        self._wait_eagain(chan.execute, self.cmd)
+        rc, buff = chan.read()
+        while rc == LIBSSH2_ERROR_EAGAIN:
+            wait_socket(self.sock, self.session)
+            rc, buff = chan.read()
+        self._wait_eagain(chan.close)
+        self._wait_eagain(chan.wait_closed)
+        chan = self._wait_eagain(self.session.open_session)
+        self.assertIsInstance(chan, Channel)
diff --git a/ci/integration_tests/test_sftp.py b/ci/integration_tests/test_sftp.py
new file mode 100644
index 00000000..32bdb1df
--- /dev/null
+++ b/ci/integration_tests/test_sftp.py
@@ -0,0 +1,324 @@
+import os
+import platform
+import shutil
+import stat
+from sys import version_info
+from unittest import skipUnless
+
+from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
+from ssh2.exceptions import SFTPProtocolError, BufferTooSmallError
+from ssh2.session import Session
+from ssh2.sftp import LIBSSH2_FXF_CREAT, LIBSSH2_FXF_WRITE, \
+    LIBSSH2_SFTP_S_IRUSR, LIBSSH2_SFTP_S_IRGRP, LIBSSH2_SFTP_S_IROTH, LIBSSH2_SFTP_S_IXUSR, SFTP, \
+    LIBSSH2_SFTP_S_IWUSR, LIBSSH2_SFTP_S_IWGRP, LIBSSH2_SFTP_S_IWOTH, \
+    LIBSSH2_SFTP_ATTR_PERMISSIONS
+from ssh2.sftp_handle import SFTPHandle, SFTPAttributes
+from ssh2.utils import wait_socket
+
+from .base_test import SSH2TestCase
+
+
+class SFTPTestCase(SSH2TestCase):
+
+    def test_init(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertIsInstance(sftp, SFTP)
+        self.assertIsInstance(sftp.session, Session)
+        self.assertEqual(sftp.session, self.session)
+
+    def test_sftp_read(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        if int(platform.python_version_tuple()[0]) >= 3:
+            test_file_data = b'test' + bytes(os.linesep, 'utf-8')
+        else:
+            test_file_data = b'test' + os.linesep
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       'remote_test_file'])
+        with open(remote_filename, 'wb') as test_fh:
+            test_fh.write(test_file_data)
+        with sftp.open(remote_filename, 0, 0) as remote_fh:
+            try:
+                self.assertTrue(remote_fh is not None)
+                remote_data = b""
+                for rc, data in remote_fh:
+                    remote_data += data
+                self.assertEqual(remote_fh.close(), 0)
+                self.assertEqual(remote_data, test_file_data)
+            finally:
+                os.unlink(remote_filename)
+
+    def test_sftp_write(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        data = b"test file data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        mode = LIBSSH2_SFTP_S_IRUSR | \
+               LIBSSH2_SFTP_S_IWUSR | \
+               LIBSSH2_SFTP_S_IRGRP | \
+               LIBSSH2_SFTP_S_IROTH
+        with sftp.open(remote_filename,
+                       LIBSSH2_FXF_CREAT | LIBSSH2_FXF_WRITE,
+                       mode) as remote_fh:
+            remote_fh.write(data)
+        with open(remote_filename, 'rb') as fh:
+            written_data = fh.read()
+        _stat = os.stat(remote_filename)
+        try:
+            self.assertTrue(stat.S_IMODE(_stat.st_mode) > 400)
+            self.assertTrue(fh.closed)
+            self.assertEqual(data, written_data)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+
+    def test_sftp_stat(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        _mask = 0o644
+        os.chmod(remote_filename, _mask)
+        _size = os.stat(remote_filename).st_size
+        try:
+            attrs = sftp.stat(remote_filename)
+            self.assertTrue(isinstance(attrs, SFTPAttributes))
+            self.assertEqual(attrs.uid, os.getuid())
+            self.assertEqual(attrs.gid, os.getgid())
+            self.assertEqual(stat.S_IMODE(attrs.permissions), 420)
+            self.assertTrue(attrs.atime > 0)
+            self.assertTrue(attrs.mtime > 0)
+            self.assertTrue(attrs.flags > 0)
+            self.assertEqual(attrs.filesize, _size)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+        self.assertRaises(SFTPProtocolError, sftp.stat, remote_filename)
+        self.assertNotEqual(sftp.last_error(), 0)
+
+    def test_sftp_fstat(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        try:
+            with sftp.open(remote_filename, 0, 0) as fh:
+                attrs = fh.fstat()
+                self.assertTrue(isinstance(attrs, SFTPAttributes))
+                self.assertEqual(attrs.uid, os.getuid())
+                self.assertEqual(attrs.gid, os.getgid())
+                self.assertTrue(attrs.flags > 0)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+
+    def test_sftp_setstat(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        rdonly_perms = LIBSSH2_SFTP_S_IRUSR |  LIBSSH2_SFTP_S_IRGRP | \
+            LIBSSH2_SFTP_S_IROTH
+        rw_perms = LIBSSH2_SFTP_S_IRUSR |  LIBSSH2_SFTP_S_IRGRP | \
+            LIBSSH2_SFTP_S_IROTH | LIBSSH2_SFTP_S_IWUSR |  \
+            LIBSSH2_SFTP_S_IWGRP | LIBSSH2_SFTP_S_IWOTH
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        _mask = 0o666
+        os.chmod(remote_filename, _mask)
+        attrs = sftp.stat(remote_filename)
+        attrs.permissions = LIBSSH2_SFTP_S_IRUSR
+        attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
+        try:
+            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
+            attrs = sftp.stat(remote_filename)
+            expected = '0100400L' if version_info.major <= 2 else '0o100400'
+            self.assertEqual(oct(attrs.permissions), expected)
+            attrs.permissions = rdonly_perms
+            attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
+            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
+            attrs = sftp.stat(remote_filename)
+            expected = '0100444L' if version_info.major <= 2 else '0o100444'
+            self.assertEqual(oct(attrs.permissions), expected)
+            attrs.permissions = rw_perms
+            attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
+            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
+            attrs = sftp.stat(remote_filename)
+            expected = '0100666L' if version_info.major <= 2 else '0o100666'
+            self.assertEqual(oct(attrs.permissions), expected)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+
+    def test_realpath_failure(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        self.assertRaises(
+            BufferTooSmallError, sftp.realpath, '/', max_len=0)
+
+    def test_realpath(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        self.assertIsNotNone(sftp.realpath('.'))
+
+    def test_sftp_symlink_realpath_lstat(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertTrue(sftp is not None)
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        symlink_target = os.sep.join([os.path.dirname(__file__),
+                                      'remote_symlink'])
+        try:
+            self.assertEqual(sftp.symlink(remote_filename, symlink_target), 0)
+            lstat = sftp.lstat(symlink_target)
+            self.assertTrue(lstat is not None)
+            self.assertEqual(lstat.filesize, os.lstat(symlink_target).st_size)
+            realpath = sftp.realpath(symlink_target)
+            self.assertTrue(realpath is not None)
+            self.assertEqual(realpath, remote_filename)
+        except Exception:
+            raise
+        finally:
+            os.unlink(symlink_target)
+            os.unlink(remote_filename)
+
+    def test_readdir(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        with sftp.opendir('.') as fh:
+            dir_data = list(fh.readdir())
+        self.assertTrue(len(dir_data) > 0)
+        self.assertTrue(b'..' in (_ls for (_, _ls, _) in dir_data))
+
+    def test_readdir_ex(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        with sftp.opendir('.') as fh:
+            dir_data = list(fh.readdir_ex())
+        self.assertTrue(len(dir_data) > 0)
+        self.assertTrue(b'..' in (_ls for (_, _ls, _, _) in dir_data))
+        self.assertTrue(len(dir_data[0][2].split(b' ')) > 0)
+
+    def test_readdir_failure(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        self.assertRaises(SFTPProtocolError, sftp.opendir, 'fakeyfakey')
+
+    @skipUnless(hasattr(SFTPHandle, 'fsync'),
+                "Function not supported by libssh2")
+    def test_fsync(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        try:
+            with sftp.open(remote_filename, 0, 0) as fh:
+                self.assertEqual(fh.fsync(), 0)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+
+    def test_statvfs(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        vfs = sftp.statvfs('.')
+        self.assertTrue(vfs is not None)
+        self.assertTrue(vfs.f_files >= 0)
+        self.assertTrue(vfs.f_bsize > 0)
+        self.assertTrue(vfs.f_namemax > 0)
+
+    def test_fstatvfs(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        test_data = b"data"
+        remote_filename = os.sep.join([os.path.dirname(__file__),
+                                       "remote_test_file"])
+        with open(remote_filename, 'wb') as fh:
+            fh.write(test_data)
+        try:
+            with sftp.open(remote_filename, 0, 0) as fh:
+                vfs = fh.fstatvfs()
+                self.assertTrue(vfs is not None)
+                self.assertTrue(vfs.f_files >= 0)
+                self.assertTrue(vfs.f_bsize > 0)
+                self.assertTrue(vfs.f_namemax > 0)
+        except Exception:
+            raise
+        finally:
+            os.unlink(remote_filename)
+
+    def test_readdir_nonblocking(self):
+        self.assertEqual(self._auth(), 0)
+        sftp = self.session.sftp_init()
+        with sftp.opendir('.') as fh:
+            self.session.set_blocking(False)
+            dir_data = []
+            for size, buf, attrs in fh.readdir():
+                if size == LIBSSH2_ERROR_EAGAIN:
+                    wait_socket(self.sock, self.session)
+                    continue
+                dir_data.append(buf)
+        self.assertTrue(len(dir_data) > 0)
+        self.assertTrue(b'..' in dir_data)
+
+    def test_mkdir(self):
+        mode = LIBSSH2_SFTP_S_IRUSR | \
+            LIBSSH2_SFTP_S_IWUSR | \
+            LIBSSH2_SFTP_S_IRGRP | \
+            LIBSSH2_SFTP_S_IROTH | \
+            LIBSSH2_SFTP_S_IXUSR
+        _path = 'tmp'
+        abspath = os.path.join(os.path.expanduser('~'), _path)
+        self._auth()
+        sftp = self.session.sftp_init()
+        try:
+            shutil.rmtree(abspath)
+        except OSError:
+            pass
+        sftp.mkdir(_path, mode)
+        try:
+            self.assertTrue(os.path.isdir(abspath))
+        finally:
+            shutil.rmtree(abspath)
+
+    def test_handle_open_nonblocking(self):
+        self._auth()
+        sftp = self.session.sftp_init()
+        self.session.set_blocking(False)
+        try:
+            fh = sftp.open('fakey fake fake', 0, 0)
+            while fh == LIBSSH2_ERROR_EAGAIN:
+                wait_socket(self.sock, self.session)
+                fh = sftp.open('fakey fake fake', 0, 0)
+        except SFTPProtocolError:
+            pass
+        else:
+            raise Exception("Should have raised SFTPProtocolError")
diff --git a/tests/unit_test_key b/ci/integration_tests/unit_test_key
similarity index 100%
rename from tests/unit_test_key
rename to ci/integration_tests/unit_test_key
diff --git a/tests/unit_test_key.pub b/ci/integration_tests/unit_test_key.pub
similarity index 100%
rename from tests/unit_test_key.pub
rename to ci/integration_tests/unit_test_key.pub
diff --git a/ci/osx-wheel.sh b/ci/osx-wheel.sh
index 8ac9fc12..8a963b98 100755
--- a/ci/osx-wheel.sh
+++ b/ci/osx-wheel.sh
@@ -14,6 +14,10 @@
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+LIBSSH2_DIR="/opt/homebrew/opt/libssh2/lib"
+LIBSSH2_INCLUDE_DIR="/opt/homebrew/opt/libssh2/include"
+export LDFLAGS="-L${LIBSSH2_DIR}"
+export CPPFLAGS="-I${LIBSSH2_INCLUDE_DIR}"
 
 pip3 install -U virtualenv
 python3 -m virtualenv -p "$(which python3)" venv
@@ -26,13 +30,13 @@ python -V
 pip3 install -U setuptools pip
 pip3 install -U delocate wheel
 SYSTEM_LIBSSH2=1 python3 setup.py bdist_wheel
-ls -lhtr /usr/local/lib/
+ls -lhtr ${LIBSSH2_DIR}
 delocate-listdeps dist/*.whl
 delocate-wheel -v -w wheels dist/*.whl
 delocate-listdeps wheels/*.whl
 
 ls -l wheels/*.whl
-rm -f /usr/local/lib/libssh2*
+rm -f ${LIBSSH2_DIR}/libssh2*
 pip3 install -v wheels/*.whl
 pwd; mkdir -p temp; cd temp; pwd
 python3 -c "from ssh2.session import Session; Session()" && echo "Import successful"
diff --git a/doc/conf.py b/doc/conf.py
index 9a91b8a1..c577bd87 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -176,5 +176,5 @@
 
 
 # Example configuration for intersphinx: refer to the Python standard library.
-intersphinx_mapping = {'https://docs.python.org/': None}
+intersphinx_mapping = {'python': ('https://docs.python.org/3', None)}
 autoclass_content = "both"
diff --git a/libssh2/CMakeLists.txt b/libssh2/CMakeLists.txt
index e6c95c88..6b51ac64 100644
--- a/libssh2/CMakeLists.txt
+++ b/libssh2/CMakeLists.txt
@@ -1,4 +1,5 @@
-# Copyright (c) 2014, 2015  Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Viktor Szakats
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,67 +33,424 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.7)
+message(STATUS "Using CMake version ${CMAKE_VERSION}")
 
-cmake_minimum_required(VERSION 2.8.11)
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+
+include(CheckFunctionExists)
+include(CheckSymbolExists)
+include(CheckIncludeFiles)
+include(CMakePushCheckState)
+include(FeatureSummary)
 
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+include(CheckFunctionExistsMayNeedLibrary)
+include(CheckNonblockingSocketSupport)
 
 project(libssh2 C)
-set(PROJECT_URL "https://www.libssh2.org/")
-set(PROJECT_DESCRIPTION "The SSH library")
 
-if (CMAKE_VERSION VERSION_LESS "3.1")
-  if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
-    set (CMAKE_C_FLAGS "--std=gnu90 ${CMAKE_C_FLAGS}")
-  endif()
-else()
-  set (CMAKE_C_STANDARD 90)
+function(libssh2_dumpvars)  # Dump all defined variables with their values
+  message("::group::CMake Variable Dump")
+  get_cmake_property(_vars VARIABLES)
+  foreach(_var ${_vars})
+    message("${_var} = ${${_var}}")
+  endforeach()
+  message("::endgroup::")
+endfunction()
+
+if(NOT DEFINED CMAKE_UNITY_BUILD_BATCH_SIZE)
+  set(CMAKE_UNITY_BUILD_BATCH_SIZE 0)
 endif()
 
-option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
+option(BUILD_STATIC_LIBS "Build static libraries" ON)
+add_feature_info("Static library" BUILD_STATIC_LIBS "creating libssh2 static library")
+
+option(BUILD_SHARED_LIBS "Build shared libraries" ON)
+add_feature_info("Shared library" BUILD_SHARED_LIBS "creating libssh2 shared library (.so/.dll)")
 
 # Parse version
 
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/include/libssh2.h _HEADER_CONTENTS)
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION[ \t]+\"([^\"]+)\".*" "\\1"
-  LIBSSH2_VERSION "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_MAJOR "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_MINOR "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_PATCH[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_PATCH "${_HEADER_CONTENTS}")
+file(READ "${PROJECT_SOURCE_DIR}/include/libssh2.h" _header_contents)
+string(REGEX REPLACE ".*#define LIBSSH2_VERSION[ \t]+\"([^\"]+)\".*" "\\1" LIBSSH2_VERSION "${_header_contents}")
+string(REGEX REPLACE ".*#define LIBSSH2_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" LIBSSH2_VERSION_MAJOR "${_header_contents}")
+string(REGEX REPLACE ".*#define LIBSSH2_VERSION_MINOR[ \t]+([0-9]+).*" "\\1" LIBSSH2_VERSION_MINOR "${_header_contents}")
+string(REGEX REPLACE ".*#define LIBSSH2_VERSION_PATCH[ \t]+([0-9]+).*" "\\1" LIBSSH2_VERSION_PATCH "${_header_contents}")
+unset(_header_contents)
 
 if(NOT LIBSSH2_VERSION OR
    NOT LIBSSH2_VERSION_MAJOR MATCHES "^[0-9]+$" OR
    NOT LIBSSH2_VERSION_MINOR MATCHES "^[0-9]+$" OR
    NOT LIBSSH2_VERSION_PATCH MATCHES "^[0-9]+$")
-  message(
-    FATAL_ERROR
-    "Unable to parse version from"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/libssh2.h")
+  message(FATAL_ERROR "Unable to parse version from ${PROJECT_SOURCE_DIR}/include/libssh2.h")
 endif()
 
 include(GNUInstallDirs)
 install(
-  FILES docs/AUTHORS COPYING docs/HACKING README RELEASE-NOTES NEWS
+  FILES
+    COPYING NEWS README RELEASE-NOTES
+    docs/AUTHORS docs/BINDINGS.md docs/HACKING.md
   DESTINATION ${CMAKE_INSTALL_DOCDIR})
 
-include(max_warnings)
-include(FeatureSummary)
+include(PickyWarnings)
 
-add_subdirectory(src)
+set(LIBSSH2_LIBS_SOCKET "")
+set(LIBSSH2_LIBS "")
+set(LIBSSH2_LIBDIRS "")
+set(LIBSSH2_PC_REQUIRES_PRIVATE "")
+
+# Add socket libraries
+if(WIN32)
+  list(APPEND LIBSSH2_LIBS_SOCKET "ws2_32")
+else()
+  check_function_exists_may_need_library("socket" HAVE_SOCKET "socket")
+  if(NEED_LIB_SOCKET)
+    list(APPEND LIBSSH2_LIBS_SOCKET "socket")
+  endif()
+  check_function_exists_may_need_library("inet_addr" HAVE_INET_ADDR "nsl")
+  if(NEED_LIB_NSL)
+    list(APPEND LIBSSH2_LIBS_SOCKET "nsl")
+  endif()
+endif()
 
 option(BUILD_EXAMPLES "Build libssh2 examples" ON)
+option(BUILD_TESTING "Build libssh2 test suite" ON)
+
+if(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
+  set(BUILD_STATIC_LIBS ON)
+endif()
+
+set(LIB_NAME "libssh2")
+set(LIB_STATIC "${LIB_NAME}_static")
+set(LIB_SHARED "${LIB_NAME}_shared")
+
+# lib flavour selected for example and test programs.
+if(BUILD_SHARED_LIBS)
+  set(LIB_SELECTED ${LIB_SHARED})
+else()
+  set(LIB_SELECTED ${LIB_STATIC})
+endif()
+
+# Symbol hiding
+
+option(HIDE_SYMBOLS "Hide all libssh2 symbols that are not officially external" ON)
+mark_as_advanced(HIDE_SYMBOLS)
+if(HIDE_SYMBOLS)
+  set(LIB_SHARED_DEFINITIONS "LIBSSH2_EXPORTS")
+  if(WIN32)
+  elseif((CMAKE_C_COMPILER_ID MATCHES "Clang") OR
+         (CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0) OR
+         (CMAKE_C_COMPILER_ID MATCHES "Intel" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1))
+    set(LIB_SHARED_C_FLAGS "-fvisibility=hidden")
+    set(LIBSSH2_API "__attribute__ ((__visibility__ (\"default\")))")
+  elseif(CMAKE_C_COMPILER_ID MATCHES "SunPro" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 8.0)
+    set(LIB_SHARED_C_FLAGS "-xldscope=hidden")
+    set(LIBSSH2_API "__global")
+  endif()
+endif()
+
+# Options
+
+# Enable debugging logging by default if the user configured a debug build
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(DEBUG_LOGGING_DEFAULT ON)
+else()
+  set(DEBUG_LOGGING_DEFAULT OFF)
+endif()
+option(ENABLE_DEBUG_LOGGING "Log execution with debug trace" ${DEBUG_LOGGING_DEFAULT})
+add_feature_info(Logging ENABLE_DEBUG_LOGGING "Logging of execution with debug trace")
+if(ENABLE_DEBUG_LOGGING)
+  # Must be visible to the library and tests using internals
+  add_definitions("-DLIBSSH2DEBUG")
+endif()
+
+option(LIBSSH2_NO_DEPRECATED "Build without deprecated APIs" OFF)
+add_feature_info("Without deprecated APIs" LIBSSH2_NO_DEPRECATED "")
+if(LIBSSH2_NO_DEPRECATED)
+  add_definitions("-DLIBSSH2_NO_DEPRECATED")
+endif()
+
+# Auto-detection
+
+# Prefill values with known detection results
+# Keep this synced with src/libssh2_setup.h
+if(WIN32)
+  if(MINGW)
+    set(HAVE_SNPRINTF 1)
+    set(HAVE_UNISTD_H 1)
+    set(HAVE_INTTYPES_H 1)
+    set(HAVE_SYS_TIME_H 1)
+    set(HAVE_GETTIMEOFDAY 1)
+    set(HAVE_STRTOLL 1)
+  elseif(MSVC)
+    set(HAVE_GETTIMEOFDAY 0)
+    if(NOT MSVC_VERSION LESS 1800)
+      set(HAVE_INTTYPES_H 1)
+      set(HAVE_STRTOLL 1)
+    else()
+      set(HAVE_INTTYPES_H 0)
+      set(HAVE_STRTOLL 0)
+      set(HAVE_STRTOI64 1)
+    endif()
+    if(NOT MSVC_VERSION LESS 1900)
+      set(HAVE_SNPRINTF 1)
+    else()
+      set(HAVE_SNPRINTF 0)
+    endif()
+  endif()
+endif()
+
+## Platform checks
+check_include_files("inttypes.h" HAVE_INTTYPES_H)
+if(NOT MSVC)
+  check_include_files("unistd.h" HAVE_UNISTD_H)
+  check_include_files("sys/time.h" HAVE_SYS_TIME_H)
+endif()
+if(NOT WIN32)
+  check_include_files("sys/select.h" HAVE_SYS_SELECT_H)
+  check_include_files("sys/uio.h" HAVE_SYS_UIO_H)
+  check_include_files("sys/socket.h" HAVE_SYS_SOCKET_H)
+  check_include_files("sys/ioctl.h" HAVE_SYS_IOCTL_H)
+  check_include_files("sys/un.h" HAVE_SYS_UN_H)
+  check_include_files("arpa/inet.h" HAVE_ARPA_INET_H)  # example and tests
+  check_include_files("netinet/in.h" HAVE_NETINET_IN_H)  # example and tests
+endif()
+
+# CMake uses C syntax in check_symbol_exists() that generates a warning with
+# MSVC. To not break detection with ENABLE_WERRROR, we disable it for the
+# duration of these tests.
+if(MSVC AND ENABLE_WERROR)
+  cmake_push_check_state()
+  set(CMAKE_REQUIRED_FLAGS "/WX-")
+endif()
+
+if(HAVE_SYS_TIME_H)
+  check_symbol_exists("gettimeofday" "sys/time.h" HAVE_GETTIMEOFDAY)
+else()
+  check_function_exists("gettimeofday" HAVE_GETTIMEOFDAY)
+endif()
+check_symbol_exists("strtoll" "stdlib.h" HAVE_STRTOLL)
+if(NOT HAVE_STRTOLL)
+  # Try _strtoi64() if strtoll() is not available
+  check_symbol_exists("_strtoi64" "stdlib.h" HAVE_STRTOI64)
+endif()
+check_symbol_exists("snprintf" "stdio.h" HAVE_SNPRINTF)
+if(NOT WIN32)
+  check_symbol_exists("explicit_bzero" "string.h" HAVE_EXPLICIT_BZERO)
+  check_symbol_exists("explicit_memset" "string.h" HAVE_EXPLICIT_MEMSET)
+  check_symbol_exists("memset_s" "string.h" HAVE_MEMSET_S)
+endif()
+
+if(MSVC AND ENABLE_WERROR)
+  cmake_pop_check_state()
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR
+   CMAKE_SYSTEM_NAME STREQUAL "Interix")
+  # poll() does not work on these platforms
+  #
+  # Interix: "does provide poll(), but the implementing developer must
+  # have been in a bad mood, because poll() only works on the /proc
+  # filesystem here"
+  #
+  # macOS poll() has funny behaviors, like:
+  # not being able to do poll on no filedescriptors (10.3?)
+  # not being able to poll on some files (like anything in /dev)
+  # not having reliable timeout support
+  # inconsistent return of POLLHUP where other implementations give POLLIN
+  message(STATUS "poll use is disabled on this platform")
+elseif(NOT WIN32)
+  check_function_exists("poll" HAVE_POLL)
+endif()
+if(WIN32)
+  set(HAVE_SELECT 1)
+else()
+  check_function_exists("select" HAVE_SELECT)
+endif()
+
+# Non-blocking socket support tests. Use a separate, yet unset variable
+# for the socket libraries to not link against the other configured
+# dependencies which might not have been built yet.
+if(NOT WIN32)
+  cmake_push_check_state()
+  set(CMAKE_REQUIRED_LIBRARIES ${LIBSSH2_LIBS_SOCKET})
+  check_nonblocking_socket_support()
+  cmake_pop_check_state()
+endif()
+
+# Config file
+
+add_definitions("-DHAVE_CONFIG_H")
+
+configure_file("src/libssh2_config_cmake.h.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/src/libssh2_config.h")
+
+## Cryptography backend choice
+
+set(CRYPTO_BACKEND "" CACHE
+  STRING "The backend to use for cryptography: OpenSSL, wolfSSL, Libgcrypt, WinCNG, mbedTLS, or empty to try any available")
+
+# If the crypto backend was given, rather than searching for the first
+# we are able to find, the find_package commands must abort configuration
+# and report to the user.
+if(CRYPTO_BACKEND)
+  set(_specific_crypto_requirement "REQUIRED")
+endif()
+
+if(CRYPTO_BACKEND STREQUAL "OpenSSL" OR NOT CRYPTO_BACKEND)
+
+  find_package(OpenSSL ${_specific_crypto_requirement})
+
+  if(OPENSSL_FOUND)
+    set(CRYPTO_BACKEND "OpenSSL")
+    set(CRYPTO_BACKEND_DEFINE "LIBSSH2_OPENSSL")
+    set(CRYPTO_BACKEND_INCLUDE_DIR ${OPENSSL_INCLUDE_DIR})
+    list(APPEND LIBSSH2_LIBS OpenSSL::Crypto)
+    list(APPEND LIBSSH2_PC_REQUIRES_PRIVATE "libcrypto")
+
+    if(WIN32)
+      # Statically linking to OpenSSL requires crypt32 for some Windows APIs.
+      # This should really be handled by FindOpenSSL.cmake.
+      list(APPEND LIBSSH2_LIBS "crypt32" "bcrypt")
+
+      #set(CMAKE_FIND_DEBUG_MODE ON)
+
+      find_file(DLL_LIBCRYPTO
+        NAMES "crypto.dll"
+          "libcrypto-1_1.dll" "libcrypto-1_1-x64.dll"
+          "libcrypto-3.dll" "libcrypto-3-x64.dll"
+        HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS}
+        PATH_SUFFIXES "bin" NO_DEFAULT_PATH)
+      if(DLL_LIBCRYPTO)
+        list(APPEND _RUNTIME_DEPENDENCIES ${DLL_LIBCRYPTO})
+        message(STATUS "Found libcrypto DLL: ${DLL_LIBCRYPTO}")
+      else()
+        message(WARNING "Unable to find OpenSSL libcrypto DLL, executables may not run")
+      endif()
+
+      #set(CMAKE_FIND_DEBUG_MODE OFF)
+    endif()
+
+    find_package(ZLIB)
+
+    if(ZLIB_FOUND)
+      list(APPEND LIBSSH2_LIBS ${ZLIB_LIBRARIES})
+    endif()
+  endif()
+endif()
+
+if(CRYPTO_BACKEND STREQUAL "wolfSSL" OR NOT CRYPTO_BACKEND)
+
+  find_package(WolfSSL ${_specific_crypto_requirement})
+
+  if(WOLFSSL_FOUND)
+    set(CRYPTO_BACKEND "wolfSSL")
+    set(CRYPTO_BACKEND_DEFINE "LIBSSH2_WOLFSSL")
+    set(CRYPTO_BACKEND_INCLUDE_DIR ${WOLFSSL_INCLUDE_DIRS})
+    list(APPEND LIBSSH2_LIBS ${WOLFSSL_LIBRARIES})
+    list(APPEND LIBSSH2_LIBDIRS ${WOLFSSL_LIBRARY_DIRS})
+    list(APPEND LIBSSH2_PC_REQUIRES_PRIVATE "wolfssl")
+    link_directories(${WOLFSSL_LIBRARY_DIRS})
+    if(WOLFSSL_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WOLFSSL_CFLAGS}")
+    endif()
+
+    if(WIN32)
+      list(APPEND LIBSSH2_LIBS "crypt32")
+    endif()
+
+    find_package(ZLIB)
+
+    if(ZLIB_FOUND)
+      list(APPEND CRYPTO_BACKEND_INCLUDE_DIR ${ZLIB_INCLUDE_DIR})  # Public wolfSSL headers require zlib headers
+      list(APPEND LIBSSH2_LIBS ${ZLIB_LIBRARIES})
+    endif()
+  endif()
+endif()
+
+if(CRYPTO_BACKEND STREQUAL "Libgcrypt" OR NOT CRYPTO_BACKEND)
+
+  find_package(Libgcrypt ${_specific_crypto_requirement})
+
+  if(LIBGCRYPT_FOUND)
+    set(CRYPTO_BACKEND "Libgcrypt")
+    set(CRYPTO_BACKEND_DEFINE "LIBSSH2_LIBGCRYPT")
+    set(CRYPTO_BACKEND_INCLUDE_DIR ${LIBGCRYPT_INCLUDE_DIRS})
+    list(APPEND LIBSSH2_LIBS ${LIBGCRYPT_LIBRARIES})
+    list(APPEND LIBSSH2_LIBDIRS ${LIBGCRYPT_LIBRARY_DIRS})
+    list(APPEND LIBSSH2_PC_REQUIRES_PRIVATE "libgcrypt")
+    link_directories(${LIBGCRYPT_LIBRARY_DIRS})
+    if(LIBGCRYPT_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBGCRYPT_CFLAGS}")
+    endif()
+  endif()
+endif()
+
+if(CRYPTO_BACKEND STREQUAL "mbedTLS" OR NOT CRYPTO_BACKEND)
+
+  find_package(MbedTLS ${_specific_crypto_requirement})
+
+  if(MBEDTLS_FOUND)
+    set(CRYPTO_BACKEND "mbedTLS")
+    set(CRYPTO_BACKEND_DEFINE "LIBSSH2_MBEDTLS")
+    set(CRYPTO_BACKEND_INCLUDE_DIR ${MBEDTLS_INCLUDE_DIRS})
+    list(APPEND LIBSSH2_LIBS ${MBEDTLS_LIBRARIES})
+    list(APPEND LIBSSH2_LIBDIRS ${MBEDTLS_LIBRARY_DIRS})
+    list(APPEND LIBSSH2_PC_REQUIRES_PRIVATE "mbedcrypto")
+    link_directories(${MBEDTLS_LIBRARY_DIRS})
+    if(MBEDTLS_CFLAGS)
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MBEDTLS_CFLAGS}")
+    endif()
+  endif()
+endif()
+
+# Detect platform-specific crypto-backends last:
+
+if(CRYPTO_BACKEND STREQUAL "WinCNG" OR NOT CRYPTO_BACKEND)
+  if(WIN32)
+    set(CRYPTO_BACKEND "WinCNG")
+    set(CRYPTO_BACKEND_DEFINE "LIBSSH2_WINCNG")
+    set(CRYPTO_BACKEND_INCLUDE_DIR "")
+    list(APPEND LIBSSH2_LIBS "crypt32" "bcrypt")
+
+    option(ENABLE_ECDSA_WINCNG "Enable WinCNG ECDSA support (requires Windows 10 or later)" OFF)
+    add_feature_info(WinCNG ENABLE_ECDSA_WINCNG "WinCNG ECDSA support")
+    if(ENABLE_ECDSA_WINCNG)
+      add_definitions("-DLIBSSH2_ECDSA_WINCNG")
+      if(MSVC)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SUBSYSTEM:WINDOWS,10")
+      elseif(MINGW)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--subsystem,windows:10")
+      endif()
+    endif()
+  elseif(_specific_crypto_requirement STREQUAL "REQUIRED")
+    message(FATAL_ERROR "WinCNG not available")
+  endif()
+endif()
+
+# Global functions
+
+# Convert GNU Make assignments into CMake ones.
+function(transform_makefile_inc _input_file _output_file)
+  file(READ ${_input_file} _makefile_inc_cmake)
+
+  string(REGEX REPLACE "\\\\\n" "" _makefile_inc_cmake ${_makefile_inc_cmake})
+  string(REGEX REPLACE "([A-Za-z_]+) *= *([^\n]*)" "set(\\1 \\2)" _makefile_inc_cmake ${_makefile_inc_cmake})
+
+  file(WRITE ${_output_file} ${_makefile_inc_cmake})
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_input_file}")
+endfunction()
+
+#
+
+add_subdirectory(src)
+
 if(BUILD_EXAMPLES)
   add_subdirectory(example)
 endif()
 
-option(BUILD_TESTING "Build libssh2 test suite" ON)
 if(BUILD_TESTING)
   enable_testing()
   add_subdirectory(tests)
@@ -100,10 +458,12 @@ endif()
 
 option(LINT "Check style while building" OFF)
 if(LINT)
-  add_custom_target(lint ALL
-    ./ci/checksrc.sh
-    WORKING_DIRECTORY ${libssh2_SOURCE_DIR})
-  add_dependencies(libssh2 lint)
+  add_custom_target(lint ALL "./ci/checksrc.sh" WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
+  if(BUILD_STATIC_LIBS)
+    add_dependencies(${LIB_STATIC} lint)
+  else()
+    add_dependencies(${LIB_SHARED} lint)
+  endif()
 endif()
 
 add_subdirectory(docs)
diff --git a/libssh2/COPYING b/libssh2/COPYING
index 937ed32e..6eb51468 100644
--- a/libssh2/COPYING
+++ b/libssh2/COPYING
@@ -1,11 +1,11 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005,2006 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2006-2007 The Written Word, Inc.
- * Copyright (c) 2007 Eli Fant <elifantu@mail.ru>
- * Copyright (c) 2009-2021 Daniel Stenberg
+/* Copyright (C) 2004-2007 Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) 2005,2006 Mikhail Gusarov <dottedmag@dottedmag.net>
+ * Copyright (C) 2006-2007 The Written Word, Inc.
+ * Copyright (C) 2007 Eli Fant <elifantu@mail.ru>
+ * Copyright (C) 2009-2023 Daniel Stenberg
  * Copyright (C) 2008, 2009 Simon Josefsson
- * Copyright (c) 2000 Markus Friedl
- * Copyright (c) 2015 Microsoft Corp.
+ * Copyright (C) 2000 Markus Friedl
+ * Copyright (C) 2015 Microsoft Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -41,4 +41,3 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  */
-
diff --git a/libssh2/Makefile.OpenSSL.inc b/libssh2/Makefile.OpenSSL.inc
deleted file mode 100644
index 1e4e8f0b..00000000
--- a/libssh2/Makefile.OpenSSL.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = openssl.c
-CRYPTO_HHEADERS = openssl.h
-CRYPTO_LTLIBS = $(LTLIBSSL)
diff --git a/libssh2/Makefile.WinCNG.inc b/libssh2/Makefile.WinCNG.inc
deleted file mode 100644
index bbcb82bf..00000000
--- a/libssh2/Makefile.WinCNG.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = wincng.c
-CRYPTO_HHEADERS = wincng.h
-CRYPTO_LTLIBS = $(LTLIBBCRYPT) $(LTLIBCRYPT32)
diff --git a/libssh2/Makefile.am b/libssh2/Makefile.am
index 986441bd..dfb03e65 100644
--- a/libssh2/Makefile.am
+++ b/libssh2/Makefile.am
@@ -1,6 +1,9 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
 
-SUBDIRS = src tests docs
+SUBDIRS = src docs
+SUBDIRS += tests
 if BUILD_EXAMPLES
 SUBDIRS += example
 endif
@@ -8,44 +11,35 @@ endif
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libssh2.pc
 
-include_HEADERS =			\
-	include/libssh2.h		\
-	include/libssh2_publickey.h	\
-	include/libssh2_sftp.h
-
-NETWAREFILES =  nw/keepscreen.c \
-	nw/nwlib.c \
-	nw/GNUmakefile \
-	nw/test/GNUmakefile
-
-DSP = win32/libssh2.dsp
-VCPROJ = win32/libssh2.vcproj
-
-DISTCLEANFILES = $(DSP)
-
-VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl	\
-vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c	\
-vms/readme.vms vms/libssh2_config.h
-
-WIN32FILES = win32/GNUmakefile win32/test/GNUmakefile		\
-win32/libssh2_config.h win32/config.mk win32/rules.mk		\
-win32/Makefile.Watcom win32/libssh2.dsw win32/tests.dsp $(DSP)	\
-win32/msvcproj.head win32/msvcproj.foot win32/libssh2.rc
-
-OS400FILES = os400/README400 os400/initscript.sh os400/make.sh		\
-os400/make-src.sh os400/make-rpg.sh os400/make-include.sh		\
-os400/os400sys.c os400/ccsid.c						\
-os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h		\
-os400/include/alloca.h os400/include/sys/socket.h os400/include/stdio.h	\
-os400/libssh2rpg/libssh2.rpgle.in					\
-os400/libssh2rpg/libssh2_ccsid.rpgle.in					\
-os400/libssh2rpg/libssh2_publickey.rpgle				\
-os400/libssh2rpg/libssh2_sftp.rpgle					\
-Makefile.os400qc3.inc
-
-EXTRA_DIST = $(WIN32FILES) $(NETWAREFILES) get_ver.awk \
- maketgz NMakefile RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
- CMakeLists.txt cmake $(OS400FILES)
+include_HEADERS = \
+  include/libssh2.h \
+  include/libssh2_publickey.h \
+  include/libssh2_sftp.h
+
+DISTCLEANFILES =
+
+VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl \
+  vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c \
+  vms/readme.vms vms/libssh2_config.h
+
+WIN32FILES = src/libssh2.rc
+
+OS400FILES = os400/README400 os400/initscript.sh os400/make.sh \
+  os400/make-src.sh os400/make-rpg.sh os400/make-include.sh \
+  os400/config400.default \
+  os400/os400sys.c os400/ccsid.c \
+  os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h \
+  os400/include/alloca.h os400/include/sys/socket.h \
+  os400/include/assert.h \
+  os400/libssh2rpg/libssh2.rpgle.in \
+  os400/libssh2rpg/libssh2_ccsid.rpgle.in \
+  os400/libssh2rpg/libssh2_publickey.rpgle \
+  os400/libssh2rpg/libssh2_sftp.rpgle \
+  os400/rpg-examples/SFTPXMPLE
+
+EXTRA_DIST = $(WIN32FILES) get_ver.awk \
+  maketgz RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
+  CMakeLists.txt cmake git2news.pl libssh2-style.el README.md $(OS400FILES)
 
 ACLOCAL_AMFLAGS = -I m4
 
@@ -60,7 +54,7 @@ dist-hook:
 	(distit=`find $(srcdir) -name "*.dist"`; \
 	for file in $$distit; do \
 	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
-	  cp $$file $(distdir)$$strip; \
+	  cp -p $$file $(distdir)$$strip; \
 	done)
 
 # Code Coverage
@@ -69,86 +63,22 @@ init-coverage:
 	make clean
 	lcov --directory . --zerocounters
 
-COVERAGE_CCOPTS ?= "-g --coverage"
-COVERAGE_OUT ?= docs/coverage
+COVERAGE_CCOPTS := "-g --coverage"
+COVERAGE_OUT := docs/coverage
 
 build-coverage:
 	make CFLAGS=$(COVERAGE_CCOPTS) check
 	mkdir -p $(COVERAGE_OUT)
 	lcov --directory . --output-file $(COVERAGE_OUT)/$(PACKAGE).info \
-		--capture
+	  --capture
 
 gen-coverage:
 	genhtml --output-directory $(COVERAGE_OUT) \
-		$(COVERAGE_OUT)/$(PACKAGE).info \
-		--highlight --frames --legend \
-		--title "$(PACKAGE_NAME)"
+	  $(COVERAGE_OUT)/$(PACKAGE).info \
+	  --highlight --frames --legend \
+	  --title "$(PACKAGE_NAME)"
 
 coverage: init-coverage build-coverage gen-coverage
 
-# DSP/VCPROJ generation adapted from libcurl
-# only OpenSSL and WinCNG are supported with this build system
-CRYPTO_CSOURCES = openssl.c wincng.c mbedtls.c
-CRYPTO_HHEADERS = openssl.h wincng.h mbedtls.h
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-include Makefile.inc
-
-WIN32SOURCES = $(CSOURCES)
-WIN32HEADERS = $(HHEADERS) libssh2_config.h
-
-$(DSP): win32/msvcproj.head win32/msvcproj.foot Makefile.am
-	echo "creating $(DSP)"
-	@( (cat $(srcdir)/win32/msvcproj.head; \
-	echo "# Begin Group \"Source Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"cpp;c;cxx\""; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		echo "SOURCE=..\\src\\"$$file; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	echo "# Begin Group \"Header Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"h;hpp;hxx\""; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		if [ "$$file" = "libssh2_config.h" ]; \
-		then \
-			echo "SOURCE=.\\"$$file; \
-		else \
-			echo "SOURCE=..\\src\\"$$file; \
-		fi; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	cat $(srcdir)/win32/msvcproj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-$(VCPROJ): win32/vc8proj.head win32/vc8proj.foot Makefile.am
-	echo "creating $(VCPROJ)"
-	@( (cat $(srcdir)/vc8proj.head; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	echo "</Filter><Filter	Name=\"Header Files\">"; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	cat $(srcdir)/vc8proj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
 checksrc:
-	perl src/checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF -ACOPYRIGHT \
-		-AFOPENMODE -Wsrc/libssh2_config.h src/*.[ch] include/*.h example/*.c \
-		tests/*.[ch]
+	ci/checksrc.sh
diff --git a/libssh2/Makefile.in b/libssh2/Makefile.in
index c60873ab..7776ff15 100644
--- a/libssh2/Makefile.in
+++ b/libssh2/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -92,12 +92,12 @@ host_triplet = @host@
 @BUILD_EXAMPLES_TRUE@am__append_1 = example
 subdir = .
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
@@ -191,11 +191,11 @@ am__define_uniq_tagged_files = \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
-DIST_SUBDIRS = src tests docs example
-am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
-	$(srcdir)/libssh2.pc.in COPYING ChangeLog NEWS README compile \
-	config.guess config.rpath config.sub depcomp install-sh \
-	ltmain.sh missing
+DIST_SUBDIRS = src docs tests example
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/libssh2.pc.in \
+	COPYING ChangeLog NEWS README compile config.guess \
+	config.rpath config.sub depcomp install-sh ltmain.sh missing \
+	tap-driver.sh
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
@@ -274,12 +274,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -290,30 +291,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -335,6 +340,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -395,70 +401,50 @@ target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
+
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
-SUBDIRS = src tests docs $(am__append_1)
+SUBDIRS = src docs tests $(am__append_1)
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libssh2.pc
 include_HEADERS = \
-	include/libssh2.h		\
-	include/libssh2_publickey.h	\
-	include/libssh2_sftp.h
-
-NETWAREFILES = nw/keepscreen.c \
-	nw/nwlib.c \
-	nw/GNUmakefile \
-	nw/test/GNUmakefile
-
-DSP = win32/libssh2.dsp
-VCPROJ = win32/libssh2.vcproj
-DISTCLEANFILES = $(DSP) ChangeLog
-VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl	\
-vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c	\
-vms/readme.vms vms/libssh2_config.h
-
-WIN32FILES = win32/GNUmakefile win32/test/GNUmakefile		\
-win32/libssh2_config.h win32/config.mk win32/rules.mk		\
-win32/Makefile.Watcom win32/libssh2.dsw win32/tests.dsp $(DSP)	\
-win32/msvcproj.head win32/msvcproj.foot win32/libssh2.rc
-
-OS400FILES = os400/README400 os400/initscript.sh os400/make.sh		\
-os400/make-src.sh os400/make-rpg.sh os400/make-include.sh		\
-os400/os400sys.c os400/ccsid.c						\
-os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h		\
-os400/include/alloca.h os400/include/sys/socket.h os400/include/stdio.h	\
-os400/libssh2rpg/libssh2.rpgle.in					\
-os400/libssh2rpg/libssh2_ccsid.rpgle.in					\
-os400/libssh2rpg/libssh2_publickey.rpgle				\
-os400/libssh2rpg/libssh2_sftp.rpgle					\
-Makefile.os400qc3.inc
-
-EXTRA_DIST = $(WIN32FILES) $(NETWAREFILES) get_ver.awk \
- maketgz NMakefile RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
- CMakeLists.txt cmake $(OS400FILES)
+  include/libssh2.h \
+  include/libssh2_publickey.h \
+  include/libssh2_sftp.h
+
+DISTCLEANFILES = ChangeLog
+VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl \
+  vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c \
+  vms/readme.vms vms/libssh2_config.h
+
+WIN32FILES = src/libssh2.rc
+OS400FILES = os400/README400 os400/initscript.sh os400/make.sh \
+  os400/make-src.sh os400/make-rpg.sh os400/make-include.sh \
+  os400/config400.default \
+  os400/os400sys.c os400/ccsid.c \
+  os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h \
+  os400/include/alloca.h os400/include/sys/socket.h \
+  os400/include/assert.h \
+  os400/libssh2rpg/libssh2.rpgle.in \
+  os400/libssh2rpg/libssh2_ccsid.rpgle.in \
+  os400/libssh2rpg/libssh2_publickey.rpgle \
+  os400/libssh2rpg/libssh2_sftp.rpgle \
+  os400/rpg-examples/SFTPXMPLE
+
+EXTRA_DIST = $(WIN32FILES) get_ver.awk \
+  maketgz RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
+  CMakeLists.txt cmake git2news.pl libssh2-style.el README.md $(OS400FILES)
 
 ACLOCAL_AMFLAGS = -I m4
-
-# DSP/VCPROJ generation adapted from libcurl
-# only OpenSSL and WinCNG are supported with this build system
-CRYPTO_CSOURCES = openssl.c wincng.c mbedtls.c
-CRYPTO_HHEADERS = openssl.h wincng.h mbedtls.h
-CSOURCES = channel.c comp.c crypt.c hostkey.c kex.c mac.c misc.c \
- packet.c publickey.c scp.c session.c sftp.c userauth.c transport.c \
- version.c knownhost.c agent.c $(CRYPTO_CSOURCES) pem.c keepalive.c global.c \
- blowfish.c bcrypt_pbkdf.c agent_win.c
-
-HHEADERS = libssh2_priv.h $(CRYPTO_HHEADERS) transport.h channel.h comp.h \
- mac.h misc.h packet.h userauth.h session.h sftp.h crypto.h blf.h agent.h
-
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-WIN32SOURCES = $(CSOURCES)
-WIN32HEADERS = $(HHEADERS) libssh2_config.h
+COVERAGE_CCOPTS := "-g --coverage"
+COVERAGE_OUT := docs/coverage
 all: all-recursive
 
 .SUFFIXES:
 am--refresh: Makefile
 	@:
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
@@ -480,7 +466,6 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
 	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
 	esac;
-$(srcdir)/Makefile.inc $(am__empty):
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 	$(SHELL) ./config.status --recheck
@@ -991,7 +976,7 @@ dist-hook:
 	(distit=`find $(srcdir) -name "*.dist"`; \
 	for file in $$distit; do \
 	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
-	  cp $$file $(distdir)$$strip; \
+	  cp -p $$file $(distdir)$$strip; \
 	done)
 
 # Code Coverage
@@ -1000,79 +985,22 @@ init-coverage:
 	make clean
 	lcov --directory . --zerocounters
 
-COVERAGE_CCOPTS ?= "-g --coverage"
-COVERAGE_OUT ?= docs/coverage
-
 build-coverage:
 	make CFLAGS=$(COVERAGE_CCOPTS) check
 	mkdir -p $(COVERAGE_OUT)
 	lcov --directory . --output-file $(COVERAGE_OUT)/$(PACKAGE).info \
-		--capture
+	  --capture
 
 gen-coverage:
 	genhtml --output-directory $(COVERAGE_OUT) \
-		$(COVERAGE_OUT)/$(PACKAGE).info \
-		--highlight --frames --legend \
-		--title "$(PACKAGE_NAME)"
+	  $(COVERAGE_OUT)/$(PACKAGE).info \
+	  --highlight --frames --legend \
+	  --title "$(PACKAGE_NAME)"
 
 coverage: init-coverage build-coverage gen-coverage
 
-$(DSP): win32/msvcproj.head win32/msvcproj.foot Makefile.am
-	echo "creating $(DSP)"
-	@( (cat $(srcdir)/win32/msvcproj.head; \
-	echo "# Begin Group \"Source Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"cpp;c;cxx\""; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		echo "SOURCE=..\\src\\"$$file; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	echo "# Begin Group \"Header Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"h;hpp;hxx\""; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		if [ "$$file" = "libssh2_config.h" ]; \
-		then \
-			echo "SOURCE=.\\"$$file; \
-		else \
-			echo "SOURCE=..\\src\\"$$file; \
-		fi; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	cat $(srcdir)/win32/msvcproj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-$(VCPROJ): win32/vc8proj.head win32/vc8proj.foot Makefile.am
-	echo "creating $(VCPROJ)"
-	@( (cat $(srcdir)/vc8proj.head; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	echo "</Filter><Filter	Name=\"Header Files\">"; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	cat $(srcdir)/vc8proj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
 checksrc:
-	perl src/checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF -ACOPYRIGHT \
-		-AFOPENMODE -Wsrc/libssh2_config.h src/*.[ch] include/*.h example/*.c \
-		tests/*.[ch]
+	ci/checksrc.sh
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
diff --git a/libssh2/Makefile.inc b/libssh2/Makefile.inc
deleted file mode 100644
index 20d2ebee..00000000
--- a/libssh2/Makefile.inc
+++ /dev/null
@@ -1,7 +0,0 @@
-CSOURCES = channel.c comp.c crypt.c hostkey.c kex.c mac.c misc.c \
- packet.c publickey.c scp.c session.c sftp.c userauth.c transport.c \
- version.c knownhost.c agent.c $(CRYPTO_CSOURCES) pem.c keepalive.c global.c \
- blowfish.c bcrypt_pbkdf.c agent_win.c
-
-HHEADERS = libssh2_priv.h $(CRYPTO_HHEADERS) transport.h channel.h comp.h \
- mac.h misc.h packet.h userauth.h session.h sftp.h crypto.h blf.h agent.h
diff --git a/libssh2/Makefile.libgcrypt.inc b/libssh2/Makefile.libgcrypt.inc
deleted file mode 100644
index 0a3aae9a..00000000
--- a/libssh2/Makefile.libgcrypt.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = libgcrypt.c
-CRYPTO_HHEADERS = libgcrypt.h
-CRYPTO_LTLIBS = $(LTLIBGCRYPT)
diff --git a/libssh2/Makefile.mbedTLS.inc b/libssh2/Makefile.mbedTLS.inc
deleted file mode 100644
index b9f19fce..00000000
--- a/libssh2/Makefile.mbedTLS.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = mbedtls.c
-CRYPTO_HHEADERS = mbedtls.h
-CRYPTO_LTLIBS = $(LTLIBMBEDCRYPTO)
diff --git a/libssh2/Makefile.os400qc3.inc b/libssh2/Makefile.os400qc3.inc
deleted file mode 100644
index e55094d9..00000000
--- a/libssh2/Makefile.os400qc3.inc
+++ /dev/null
@@ -1,2 +0,0 @@
-CRYPTO_CSOURCES = os400qc3.c
-CRYPTO_HHEADERS = os400qc3.h
diff --git a/libssh2/NEWS b/libssh2/NEWS
index 7e22b3dd..b3bd14cb 100644
--- a/libssh2/NEWS
+++ b/libssh2/NEWS
@@ -1,6831 +1,10896 @@
    Changelog for the libssh2 project. Generated with git2news.pl
 
-Daniel Stenberg (29 Aug 2021)
-- [Will Cosgrove brought this change]
+Daniel Stenberg (16 Oct 2024)
+- RELEASE-NOTES: 1.11.1
 
-  updated docs for 1.10.0 release
+Viktor Szakats (8 Oct 2024)
+- RELEASE-NOTES: sync [ci skip]
 
-Marc Hörsken (30 May 2021)
-- [Laurent Stacul brought this change]
+- [Anders Borum brought this change]
 
-  [tests] Try several times to connect the ssh server
+  session: support server banners up to 8192 bytes (was: 256)
   
-  Sometimes, as the OCI container is run in detached mode, it is possible
-  the actual server is not ready yet to handle SSH traffic. The goal of
-  this PR is to try several times (max 3). The mechanism is the same as
-  for the connection to the docker machine.
+  If server had banner exceeding 256 bytes there wasn't enough room in
+  `_LIBSSH2_SESSION.banner_TxRx_banner`. Only the first 256 bytes would be
+  read making the first packet read fail but also dooming key exchange as
+  `session->remote.banner` didn't include everything.
+  
+  This change bumps the banner buffer to 8KB to match OpenSSH.
+  
+  Fixes #1442
+  Closes #1443
 
-- [Laurent Stacul brought this change]
+- RELEASE-NOTES: sync [ci skip]
 
-  Remove openssh_server container on test exit
+- cmake: sync and improve Find modules, add `pkg-config` native detection
+  
+  - sync code between Find modules.
+  - wolfssl: replace `pkg-config` hints with native detection.
+  - libgcrypt, mbedtls: add `pkg-config`-based native detection.
+  - libgcrypt: add version detection.
+  - limit `pkg-config` use for `UNIX`, vcpkg, and non-cross MinGW builds,
+    and builds with no manual customization via `*_INCLUDE_DIR` or
+    `*_LIBRARY`.
+  - replace and sync Find module header comments.
+  - ci: delete manual mbedTLS config that's now redundant.
+  
+  Based on similar work done in curl.
+  
+  Second attempt at #1420
+  Closes #1445
 
-- [Laurent Stacul brought this change]
+- cmake: initialize `LIBSSH2_LIBDIRS` [ci skip]
+  
+  Follow-up to c87f12963037b22e6b60411c9c2d6513c06e2f03 #1466
 
-  Allow the tests to run inside a container
+- ci/appveyor: fix and bump OpenSSL 3 path, add path check
   
-  The current tests suite starts SSH server as OCI container. This commit
-  add the possibility to run the tests in a container provided that:
+  Follow-up to b5e68bdc37c6afa0dc777794dda8307167919d04 #1461
+  Closes #1468
+
+- cmake: link to OpenSSL::Crypto, not OpenSSL::SSL
   
-  * the docker client is installed builder container
-  * the host docker daemon unix socket has been mounted in the builder
-    container (with, if needed, the DOCKER_HOST environment variable
-    accordingly set, and the permission to write on this socket)
-  * the builder container is run on the default bridge network, or the
-    host network. This PR does not handle the case where the builder
-    container is on another network.
+  Follow-up to 82b09f9b3aae97f641fbcc2d746d2a6383abe857 #1322
+  Follow-up to c84745e34e53f863ffba997ceeee7d43d1c63a4b #1128
+  Cherry-picked from #1445
+  Closes #1467
 
-Marc Hoersken (28 May 2021)
-- CI/appveyor: run SSH server for tests on GitHub Actions (#607)
+- cmake: generate `LIBSSH2_PC_LIBS_PRIVATE` dynamically
   
-  No longer rely on DigitalOcean to host the Docker container.
+  Generate `LIBSSH2_PC_LIBS_PRIVATE` from `LIBSSH2_LIBS`.
   
-  Unfortunately we require a small dispatcher script that has
-  access to a GitHub access token with scope repo in order to
-  trigger the daemon workflow on GitHub Actions also for PRs.
+  Also add extra libdirs (`-L`) to `Libs` and `Libs.private`.
   
-  This script is hosted by myself for the time being until GitHub
-  provides a tighter scope to trigger the workflow_dispatch event.
+  Logic copied from curl.
+  
+  Closes #1466
 
-GitHub (26 May 2021)
-- [Will Cosgrove brought this change]
+- cmake: initialize `LIBSSH2_PC_REQUIRES_PRIVATE` [ci skip]
+  
+  Follow-up to 0fce9dcc2909ffff5f4a1a1bc3d359fc7f409299 #1464
 
-  openssl.c: guards around calling FIPS_mode() #596 (#603)
+- cmake: add comment about `ibssh2.pc.in` variables [ci skip]
+
+- cmake: support absolute `CMAKE_INSTALL_INCLUDEDIR`/`CMAKE_INSTALL_LIBDIR`
   
-  Notes:
-  FIPS_mode() is not implemented in LibreSSL and this API is removed in OpenSSL 3.0 and was introduced in 0.9.7. Added guards around making this call.
+  in `libssh2.pc`.
   
-  Credit:
-  Will Cosgrove
+  Also use `${exec_prefix}` (instead of `${prefix}`) as a base for `libdir`.
+  
+  Closes #1465
 
-- [Will Cosgrove brought this change]
+- cmake: rename two variables and initialize them
+  
+  - `LIBRARIES` -> `LIBSSH2_LIBS`
+  - `SOCKET_LIBRARIES` -> `LIBSSH2_LIBS_SOCKET`
+  
+  Also initialize them before use.
+  
+  Cherry-picked from #1445
+  Closes #1464
 
-  configure.ac: don't undefine scoped variable (#594)
+- ci/appveyor: reduce test runs (workaround for infrastructure permafails)
   
-  * configure.ac: don't undefine scoped variable
+  Jobs consistently fail to connect to the test server (run in GHA) since
+  2024-Aug-29:
+  https://ci.appveyor.com/project/libssh2org/libssh2/builds/50498393
   
-  To get this script to run with Autoconf 2.71 on macOS I had to remove the undefine of the backend for loop variable. It seems scoped to the for loop and also isn't referenced later in the script so it seems OK to remove it.
+  There was an earlier phase of failures one month before that, that got
+  fixed by increasing the wait for the server in
+  bf3af90b3f1bb14cf452df7a8eb55cc9088f3e7f.
   
-  * configure.ac: remove cygwin specific CFLAGS #598
+  Thus, skip running tests in AppVeyor CI jobs, except: After some
+  experiments, it seems that running tests with the last OpenSSL job and
+  the last WinCrypt job _work_, which still leaves some coverage.
+  It remains to be seen how stable this is.
   
-  Notes:
-  Remove cygwin specific Win32 CFLAGS and treat the build like a posix build
+  This is meant as a temporary fix till there is a solution to make all
+  jobs run tests reliable like up until a few months ago.
   
-  Credit:
-  Will Cosgrove, Brian Inglis
+  Closes #1461
 
-- [Laurent Stacul brought this change]
+- [Patrick Monnerat brought this change]
 
-  tests: Makefile.am: Add missing tests client keys in distribution tarball (#604)
+  os400: drop vsprintf() use
   
-  Notes:
-  Added missing test keys.
+  Follow-up to discussion in #1457
   
-  Credit:
-  Laurent Stacul
+  Plus e-mail address update.
+  
+  Closes #1462
 
-- [Laurent Stacul brought this change]
+- RELEASE-NOTES: sync [ci skip]
 
-  Makefile.am: Add missing test keys in the distribution tarball (#601)
+Daniel Stenberg (30 Sep 2024)
+- openssl: free allocated resources when using openssl3
   
-  Notes:
-  Fix tests missing key to build the OCI image
+  Reproduces consistently with curl test case 638
   
-  Credit:
-  Laurent Stacul
+  Closes #1459
 
-Daniel Stenberg (16 May 2021)
-- dist: add src/agent.h
+Viktor Szakats (28 Sep 2024)
+- checksrc: update, check all sources, fix fallouts
   
-  Fixes #597
-  Closes #599
-
-GitHub (12 May 2021)
-- [Will Cosgrove brought this change]
+  update from curl:
+  https://github.com/curl/curl/blob/cff75acfeca65738da8297aee0b30427b004b240/scripts/checksrc.pl
+  
+  Closes #1457
 
-  packet.c: Reset read timeout after received a packet (#576) (#586)
+- cmake: prefer `find_dependency()` in `libssh2-config.cmake`
   
-  File:
-  packet.c
+  CMake manual suggest using `find_dependency()` (over  `find_package()`)
+  in `config.cmake` scripts.
   
-  Notes:
-  Attempt keyboard interactive login (Azure AD 2FA login) and use more than 60 seconds to complete the login, the connection fails.
+  Ref: https://cmake.org/cmake/help/latest/module/CMakeFindDependencyMacro.html
   
-  The _libssh2_packet_require function does almost the same as _libssh2_packet_requirev but this function sets state->start = 0 before returning.
+  Closes #1460
+
+- ci: use Ninja with cmake
   
-  Credit:
-  teottin, Co-authored-by: Tor Erik Ottinsen <tor.ottinsen@kdi.kongsberg.com>
+  Closes #1458
 
-- [kkoenig brought this change]
+GitHub (27 Sep 2024)
+- [dksslq brought this change]
 
-  Support ECDSA certificate authentication (#570)
+  Fix memory leaks in _libssh2_ecdsa_curve_name_with_octal_new and _libssh2_ecdsa_verify (#1449)
   
-  Files: hostkey.c, userauth.c, test_public_key_auth_succeeds_with_correct_ecdsa_key.c
+  Better error handling in`_libssh2_ecdsa_curve_name_with_octal_new` and `_libssh2_ecdsa_verify` to prevent leaks.
   
-  Notes:
-  Support ECDSA certificate authentication
+  Credit: dksslq <dksslq@github.com>
+
+- [rolag brought this change]
+
+  Fix unstable connections over nonblocking sockets (#1454)
   
-  Add a test for:
-    - Existing ecdsa basic public key authentication
-    - ecdsa public key authentication with a signed public key
+  The `send_existing()` function allows partially sent packets to be sent
+  fully before any further packets are sent. Originally this returned
+  `LIBSSH2_ERROR_BAD_USE` when a different caller or thread tried to send
+  an existing packet created by a different caller or thread causing the
+  connection to disconnect. Commit 33dddd2f8ac3bc81 removed the return
+  allowing any caller to continue sending another caller's packet. This
+  caused connection instability as discussed in #1397 and confused the
+  client and server causing occasional duplicate packets to be sent and
+  giving the error `rcvd too much data` as discussed in #1431. We return
+  `LIBSSH2_ERROR_EAGAIN` instead to allow existing callers to finish
+  sending their own packets.
   
-  Credit:
-  kkoenig
+  Fixes #1397
+  Fixes #1431
+  Related #720
+  
+  Credit: klux21, rolag
 
-- [Gabriel Smith brought this change]
+- [Will Cosgrove brought this change]
 
-  agent.c: Add support for Windows OpenSSH agent (#517)
+  Prevent possible double free of hostkey (#1452)
   
-  Files: agent.c, agent.h, agent_win.c
+  NULL server hostkey based on fuzzer failure case.
+
+Viktor Szakats (7 Sep 2024)
+- cmake: tidy up syntax, minor improvements
   
-  Notes:
-  * agent: Add support for Windows OpenSSH agent
+  - make internal variables underscore-lowercase.
+  - unfold lines.
+  - fold lines setting header directories.
+  - fix indent.
+  - drop interim variable `EXAMPLES`.
+  - initialize some variables before populating them.
+  - clear a variable after use.
+  - add `libssh2_dumpvars()` function for debugging.
+  - allow to override default `CMAKE_UNITY_BUILD_BATCH_SIZE`.
+  - bump up default `CMAKE_UNITY_BUILD_BATCH_SIZE` to 0 (was 32).
+  - tidy up option descriptions.
   
-  The implementation was partially taken and modified from that found in
-  the Portable OpenSSH port to Win32 by the PowerShell team, but mostly
-  based on the existing Unix OpenSSH agent support.
+  Closes #1446
+
+- cmake: rename mbedTLS and wolfSSL Find modules
   
-  https://github.com/PowerShell/openssh-portable
+  To match the curl ones.
   
-  Regarding the partial transfer support implementation: partial transfers
-  are easy to deal with, but you need to track additional state when
-  non-blocking IO enters the picture. A tracker of how many bytes have
-  been transfered has been placed in the transfer context struct as that's
-  where it makes most sense. This tracker isn't placed behind a WIN32
-   #ifdef as it will probably be useful for other agent implementations.
+  Cherry-picked from #1445
+
+- RELEASE-NOTES: sync [ci skip]
+
+- cmake: fixup version detection in mbedTLS find module
   
-  * agent: win32 openssh: Disable overlapped IO
+  - avoid warning with 2.x versions about missing header file while
+    extracting the version number.
   
-  Non-blocking IO is not currently supported by the surrounding agent
-  code, despite a lot of the code having everything set up to handle it.
+  - clear temp variables.
   
-  Credit:
-  Co-authored-by: Gabriel Smith <gabriel.smith@precisionot.com>
+  Closes #1444
 
-- [Zenju brought this change]
+- buildconf: drop
+  
+  Use `autoreconf -fi` instead.
+  
+  Follow-up to fc5d77881eb6bb179f831e626d15f4f29179aad5
+  Closes #1441
 
-  Fix detailed _libssh2_error being overwritten (#473)
+- [Michael Buckley brought this change]
+
+  Implement chacha20-poly1305@openssh.com
   
-  Files: openssl.c, pem.c, userauth.c
+  Probably the biggest and potentially most controversial change we have
+  to upstream.
   
-  Notes:
-  * Fix detailed _libssh2_error being overwritten by generic errors
-  * Unified error handling
+  Because earlier versions of OpenSSL implemented the algorithm before
+  standardization, using an older version of OpenSSL can cause problems
+  connecting to OpenSSH servers. Because of this, we use the public domain
+  reference implementation instead of the crypto backends, just like
+  OpenSSH does.
   
-  Credit:
-  Zenju
+  We've been holding this one for a few years. We were about to upstream
+  it around the same time as aes128gcm landed upstream, and the two
+  changes were completely incompatible. Honestly, it took me weeks to
+  reconcile these two implementations, and it could be much better.
+  
+  Our original implementation changed every crypt method to decrypt the
+  entire message at once. the AESGCM implementation instead went with this
+  firstlast design, where a firstlast paramater indicates whether this is
+  the first or last call to the crypt method for each message. That added
+  a lot of bookkeeping overhead, and wasn't compatible with the chacha
+  public domain implementation.
+  
+  As far as I could tell, OpenSSH uses the technique of decrypting the
+  entire message in one go, and doesn't have anything like firstlast.
+  However, I could not get out aes128gcm implementation to work that way,
+  nor could I get the chacha implementation to work with firstlast, so I
+  split it down the middle and let each implementation work differently.
+  It's kind of a mess, and probably should be cleaned up, but I don't have
+  the time to spend on it anymore, and it's probably better to have
+  everything upstream.
+  
+  Fixes #584
+  Closes #1426
 
-- [Paul Capron brought this change]
+- tidy-up: do/while formatting
+  
+  Also fix an indentation and delete empty lines.
+  
+  Closes #1440
 
-  Fix _libssh2_random() silently discarding errors (#520)
+- wolfssl: drop header path hack
   
-  Notes:
-  * Make _libssh2_random return code consistent
+  The wolfSSL OpenSSL headers reside in `wolfssl/openssl/*.h`.
   
-  Previously, _libssh2_random was advertized in HACKING.CRYPTO as
-  returning `void` (and was implemented that way in os400qc3.c), but that
-  was in other crypto backends a lie; _libssh2_random is (a macro
-  expanding) to an int-value expression or function.
+  Before this patch the wolfSSL OpenSSL compatibilty header includes were
+  shared with the native OpenSSL codepath, and used `openssl/*h`. For
+  wolfSSL builds this required a hack to append the
+  `<wolfssl-prefix>/wolfssl` directory to the header search path, to find
+  the headers.
   
-  Moreover, that returned code was:
-    — 0 or success, -1 on error for the MbedTLS & WinCNG crypto backends
-  But also:
-    — 1 on success, -1 or 0 on error for the OpenSSL backend!
-    – 1 on success, error cannot happen for libgcrypt!
+  This patch changes the source to use the correct header references,
+  allowing to drop the header path hack.
   
-  This commit makes explicit that _libssh2_random can fail (because most of
-  the underlying crypto functions can indeed fail!), and it makes its result
-  code consistent: 0 on success, -1 on error.
+  Also fix to use the correct variable to set up the header path in CMake:
+  `WOLFSSL_INCLUDE_DIRS` (was: `WOLFSSL_INCLUDE_DIR`, without the `S`)
   
-  This is related to issue #519 https://github.com/libssh2/libssh2/issues/519
-  It fixes the first half of it.
+  Closes #1439
+
+- cmake: mbedTLS detection tidy-ups
   
-  * Don't silent errors of _libssh2_random
+  - set and use `MBEDTLS_INCLUDE_DIRS`.
+  - stop marking `MBEDTLS_LIBRARIES` as advanced.
   
-  Make sure to check the returned code of _libssh2_random(), and
-  propagates any failure.
+  Closes #1438
+
+- cmake: add quotes, delete ending dirseps
   
-  A new LIBSSH_ERROR_RANDGEN constant is added to libssh2.h
-  None of the existing error constants seemed fit.
+  Follow-up to 3fa5282d6284efba62dc591697e6a687152bdcb1 #1166
+  Closes #1437
+
+- CI/appveyor: increase wait for SSH server on GHA [ci skip]
   
-  This commit is related to d74285b68450c0e9ea6d5f8070450837fb1e74a7
-  and to https://github.com/libssh2/libssh2/issues/519 (see the issue
-  for more info.)  It closes #519.
+  Blind attempt to make AppVeyor CI tests work again.
+
+- disable DSA by default
   
-  Credit:
-  Paul Capron
+  Also:
+  - add `LIBSSH2_DSA_ENABLE` to enable it explicitly.
+  - test the above option in CI.
+  - say 'deprecated' in docs and public header.
+  - disable DSA in the CI server config.
+    (OpenSSH 9.8 no longer builds with it by default)
+    https://www.openssh.com/txt/release-9.8
+    Patch-by: Jose Quaresma
+  - disable more DSA code when not enabled.
+  
+  Fixes #1433
+  Closes #1435
+
+GitHub (30 Jul 2024)
+- [Viktor Szakats brought this change]
 
-- [Gabriel Smith brought this change]
+  tidy-up: link updates (#1434)
 
-  ci: Remove caching of docker image layers (#589)
+Marc Hoersken (27 Jul 2024)
+- ci/GHA: revert concurrency and improve permissions
   
-  Notes:
-  continued ci reliability work.
+  Statuses are per AppVeyor event and commit, not pull-request.
+  Also align permissions approach with curl, least priviledge.
   
-  Credit:
-  Gabriel Smith
+  Partially reverts b08cfbc99fa4df3459db4e1ccf4263fd260e9b15.
 
-- [Gabriel Smith brought this change]
+GitHub (23 Jul 2024)
+- [Will Cosgrove brought this change]
 
-  ci: Speed up docker builds for tests (#587)
-  
-  Notes:
-  The OpenSSH server docker image used for tests is pre-built to prevent
-  wasting time building it during a test, and unneeded rebuilds are
-  prevented by caching the image layers.
+  Always init mbedtls_pk_context (#1430)
   
-  Credit:
-  Gabriel Smith
+  In the failure case, mbedtls_pk_context could be free'd without first being initialized.
+
+- [Viktor Szakats brought this change]
+
+  mbedtls: tidy-up (#1429)
 
 - [Will Cosgrove brought this change]
 
-  userauth.c: don't error if using keys without RSA (#555)
+  Correctly initialize values (#1428)
   
-  file: userauth.c
+  Fix regression with commit from #1421
+
+Viktor Szakats (14 Jul 2024)
+- RELEASE-NOTES: sync [ci skip]
+
+- [Seo Suchan brought this change]
+
+  mbedtls: expose `mbedtls_pk_load_file()` for our use
   
-  notes: libssh2 now supports many other key types besides RSA, if the library is built without RSA support and a user attempts RSA auth it shouldn't be an automatic error
+  While it's moved to pk_internal, it won't removed in mbedTLS 3.6 LTS
+  so it's safe to redeclare it on our side to find it.
   
-  credit:
-  Will Cosgrove
+  This is implementing emergency fix suggested from
+  https://github.com/libssh2/libssh2/commit/2e4c5ec4627b3ecf4b6da16f365c011dec9a31b4#commitcomment-141379351
+  
+  Follow-up to e973493f992313b3be73f51d3f7ca6d52e288558 #1393
+  Follow-up to 2e4c5ec4627b3ecf4b6da16f365c011dec9a31b4 #1349
+  Closes #1421
 
-- [Marc brought this change]
+GitHub (13 Jul 2024)
+- [Viktor Szakats brought this change]
 
-  openssl.c: Avoid OpenSSL latent error in FIPS mode (#528)
+  ci/GHA: simplify mbedTLS build hack for autotools (#1425)
   
-  File:
-  openssl.c
-  
-  Notes:
-  Avoid initing MD5 digest, which is not permitted in OpenSSL FIPS certified cryptography mode.
+  Follow-up to e973493f992313b3be73f51d3f7ca6d52e288558 #1393
+
+- [Michael Buckley brought this change]
+
+  Always check for null pointers before calling _libssh2_bn_set_word (#1423)
+
+- [Viktor Szakats brought this change]
+
+  ci/GHA: FreeBSD 14.1, actions bump (#1424)
+
+- [Michael Buckley brought this change]
+
+  Increase SFTP_HANDLE_MAXLEN back to 4092 (#1422)
   
-  Credit:
-  Marc
+  Match OpenSSH for compatibility.
 
-- [Laurent Stacul brought this change]
+Viktor Szakats (10 Jul 2024)
+- ci/GHA: tidy up casing [ci skip]
 
-  openssl.c: Fix EVP_Cipher interface change in openssl 3 #463
+- REUSE: fix typo in comment
+
+- REUSE: shorten and improve
   
-  File:
-  openssl.c
+  Follow-up to 70b8bf314cf4566a7529c5d6eae63097a926abb0 #1419
+
+- REUSE: upgrade to `REUSE.toml`
   
-  Notes:
-  Fixes building with OpenSSL 3, #463.
+  Closes #1419
+
+- build: stop detecting `sys/param.h` header
   
-  The change is described there:
-  https://github.com/openssl/openssl/commit/f7397f0d58ce7ddf4c5366cd1846f16b341fbe43
+  This header is no longer used.
   
-  Credit:
-  Laurent Stacul, reported by Sergei
+  Follow-up to 12427f4fb8e789adcee4a6e30974932883915e88 #1415
+  Closes #1418
 
-- [Gabriel Smith brought this change]
+- [Nicolas Mora brought this change]
 
-  openssh_fixture.c: Fix potential overwrite of buffer when reading stdout of command (#580)
+  tests: avoid using `MAXPATHLEN`, for portability
   
-  File:
-  openssh_fixture.c
-  Notes:
-  If reading the full output from the executed command took multiple
-  passes (such as when reading multiple lines) the old code would read
-  into the buffer starting at the some position (the start) every time.
-  The old code only works if fgets updated p or had an offset parameter,
-  both of which are not true.
+  `MAXPATHLEN` is not present in some systems, e.g. GNU Hurd.
   
-  Credit:
-  Gabriel Smith
+  Co-authored-by: Viktor Szakats
+  Ref: 54bef4c5dad868a9d45fdbfca9729b191c0abab5 #198
+  Fixes #1414
+  Closes #1415
 
-- [Gabriel Smith brought this change]
+- cmake: sync formatting in `cmake/Find*` modules
 
-  ci: explicitly state the default branch (#585)
-  
-  Notes:
-  It looks like the $default-branch macro only works in templates, not
-  workflows. This is not explicitly stated anywhere except the linked PR
-  comment.
+- [Michael Buckley brought this change]
+
+  sftp: implement posix-rename@openssh.com
   
-  https://github.com/actions/starter-workflows/pull/590#issuecomment-672360634
+  Add a new function `libssh2_sftp_posix_rename_ex()` and
+  `libssh2_sftp_posix_rename()`, which implement
+  the posix-rename@openssh.com extension.
   
-  credit:
-  Gabriel Smith
-
-- [Gabriel Smith brought this change]
-
-  ci: Swap from Travis to Github Actions (#581)
+  If the server does not support this extension, the function returns
+  `LIBSSH2_FX_OP_UNSUPPORTED` and it's up to the user to recover, possibly
+  by calling `libssh2_sftp_rename()`.
   
-  Files: ci files
+  Co-authored-by: Viktor Szakats (bump to size_t)
+  Closes #1386
+
+- src: use `UINT32_MAX`
   
-  Notes:
-  Move Linux CI using Github Actions
+  Needs to be defined for platforms missing it, e.g. VS2008.
   
-  Credit:
-  Gabriel Smith, Marc Hörsken
+  Closes #1413
 
-- [Mary brought this change]
+GitHub (25 Jun 2024)
+- [Michael Buckley brought this change]
 
-  libssh2_priv.h: add iovec on 3ds (#575)
+  Fix a memory leak in key exchange. (#1412)
   
-  file: libssh2_priv.h
-  note: include iovec for 3DS
-  credit: Mary Mstrodl
+  Original fix submitted as a patch by Trzik.
+  
+  Co-authored-by: Michael Buckley <michael@panic.com>
 
-- [Laurent Stacul brought this change]
+Viktor Szakats (25 Jun 2024)
+- RELEASE-NOTES: sync [ci skip]
 
-  Tests: Fix unused variables warning (#561)
+- wolfssl: fix `EVP_Cipher()` use with v5.6.0 and older
   
-  file: test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
+  Add workaround for the wolfSSL `EVP_Cipher(*p, NULL, NULL, 0)` bug to
+  make libssh2 work with wolfSSL v5.6.0 and older.
   
-  notes: fixed unused vars
+  wolfSSL fixed this issue in v5.7.0:
+  https://github.com/wolfSSL/wolfssl/pull/7143
+  https://github.com/wolfSSL/wolfssl/commit/b0de0a1c95119786cf5651dd76dd7d7bdfac5a04
   
-  credit:
-  Laurent Stacul
+  Without our local workaround:
+  
+  - v5.3.0 and older fail most tests:
+    Ref: https://github.com/libssh2/libssh2/actions/runs/9646827522/job/26604211476#step:17:1263
+  
+  - v5.4.0, v5.5.x, v5.6.0 fail these:
+    ```
+    29 - test_read-aes128-cbc (Failed)
+    30 - test_read-aes128-ctr (Failed)
+    32 - test_read-aes192-cbc (Failed)
+    33 - test_read-aes192-ctr (Failed)
+    34 - test_read-aes256-cbc (Failed)
+    35 - test_read-aes256-ctr (Failed)
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/9646827522/job/26604233819#step:17:978
+  
+  Oddly enough the workaround breaks OpenSSL tests, so only enable it for
+  the affected wolfSSL versions.
+  
+  Also add new build-from-source wolfSSL CI job to test the new codepath.
+  
+  wolfSSL has a build bug where `wolfssl/options.h` and
+  `wolfssl/version.h` are not copied to the `install` destination with
+  autotools. With CMake it has a different bug where `wolfcrypt/sp_int.h`
+  is not copied (with v5.4.0). And another with CMake where `FIPS_mode()`
+  remains missing (with v5.6.0 and earlier.)
+  
+  Therefore use CMake with v5.5.4 and a workaround for `FIPS_mode()`.
+  Another option is autotools with v5.4.0 and a workaround for `install`,
+  but CMake builds quicker.
+  
+  Regression-from 3c953c05d67eb1ebcfd3316f279f12c4b1d600b4 #797
+  Fixes #1020
+  Fixes #1299
+  Assisted-by: Michael Buckley via #1394
+  Closes #1394 (another attempt to fix the mentioned wolfSSL bug)
+  Closes #1407
 
-- [Viktor Szakats brought this change]
+- wolfssl: bump version in upstream issue comment [ci skip]
 
-  bcrypt_pbkdf.c: fix clang10 false positive warning (#563)
-  
-  File: bcrypt_pbkdf.c
+- wolfssl: require v5.4.0 for AES-GCM
   
-  Notes:
-  blf_enc() takes a number of 64-bit blocks to encrypt, but using
-  sizeof(uint64_t) in the calculation triggers a warning with
-  clang 10 because the actual data type is uint32_t. Pass
-  BCRYPT_BLOCKS / 2 for the number of blocks like libc bcrypt(3)
-  does.
+  Earlier versions crash while running tests.
   
-  Ref: https://github.com/openbsd/src/commit/04a2240bd8f465bcae6b595d912af3e2965856de
+  This patch is part of a series of fixes to make wolfSSL AES-GCM support
+  work together with libssh2.
   
-  Fixes #562
+  Possibly related is this wolfSSL bugfix patch, released in v5.4.0:
+  https://github.com/wolfSSL/wolfssl/pull/5205
+  https://github.com/wolfSSL/wolfssl/commit/fb3c611275dfe454c331baa0818445a0406c208a
+  "Fix another AES-GCM EVP control command issue"
   
-  Credit:
-  Viktor Szakats
+  Ref: #1020
+  Ref: #1299
+  Cherry-picked from #1407
+  Closes #1411
 
-- [Will Cosgrove brought this change]
+- tests: fix excluding AES-GCM tests
+  
+  Replace hard-coded crypto backends and rely on `LIBSSH2_GCM` macro
+  to decide whether to run AES-GCM tests.
+  
+  Without this, build attempted to run AES-GCM tests (and failed)
+  for crypto backends that have conditional support for this feature, e.g.
+  wolfSSL without the necessary features built-in
+  (as in before Homewbrew wolfssl 5.7.0_1, or OpenSSL v1.1.0 and older).
+  
+  This patch is part of a series of fixes to make wolfSSL AES-GCM support
+  work together with libssh2.
+  
+  Cherry-picked from #1407
+  Closes #1410
 
-  transport.c: release payload on error (#554)
+- ci/GHA: fix wolfSSL-from-source AES-GCM tests
   
-  file: transport.c
-  notes: If the payload is invalid and there is an early return, we could leak the payload
-  credit:
-  Will Cosgrove
+  Turns out these tests:
+  ```
+  31 - test_read-aes128-gcm@openssh.com (Failed)
+  36 - test_read-aes256-gcm@openssh.com (Failed)
+  ```
+  were failing because AES-GCM wasn't enabled in libssh2. This in turn
+  happened because the `WOLFSSL_AESGCM_STREAM` macro wasn't enabled while
+  building wolfSSL. Which happened because this macro isn't enabled by
+  any CMake-level wolfSSL option. Passing it as `CPPFLAGS` fixes it.
+  
+  This allows enabling tests with wolfSSL 5.7.0.
+  
+  Follow-up to d4cea53f53c78febad14b4caa600e25d1aaf92fd #1408
+  Closes #1409
 
-- [Will Cosgrove brought this change]
+- ci/GHA: add Linux job with latest wolfSSL built from source
+  
+  After this patch it's possible to run tests with wolfSSL 5.7.0.
+  
+  wolfSSL 5.7.0 fixes this bug that affects open issues #1020 and #1299:
+  https://github.com/wolfSSL/wolfssl/pull/7143
+  
+  `-DWOLFSSL_OPENSSLALL=ON` is necessary for `wolfSSL_FIPS_mode()`
+  
+  Closes #1408
 
-  ssh2_client_fuzzer.cc: fixed building
+- ci/GHA: tidy up build-from-source steps [ci skip]
   
-  The GitHub web editor did some funky things
+  - make curl downloads less verbose.
+  
+  - fix cmake warning:
+    ```
+    CMake Warning:
+      No source or binary directory provided.  Both will be assumed to be the
+      same as the current working directory, but note that this warning will
+      become a fatal error in future CMake releases.
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/9509866494/job/26213472410#step:5:32
 
-- [Will Cosgrove brought this change]
+- [Adam brought this change]
 
-  ssh_client_fuzzer.cc: set blocking mode on (#553)
+  src: fix type warning in `libssh2_sftp_unlink` macro
   
-  file: ssh_client_fuzzer.cc
+  The `libssh2_sftp_unlink` macro was implicitly casting the `size_t`
+  returned by `strlen` to the `unsigned int` type expected by
+  `libssh2_sftp_unlink_ex`.
   
-  notes: the session needs blocking mode turned on to avoid EAGAIN being returned from libssh2_session_handshake()
+  This fix adds an explicit cast to match similar macro definitions in
+  the same file (e.g. `libssh2_sftp_rename`, `libssh2_sftp_mkdir`).
   
-  credit:
-  Will Cosgrove, reviewed by Michael Buckley
-
-- [Etienne Samson brought this change]
+  Closes #1406
 
-  Add a LINT option to CMake (#372)
+- libssh2.pc: reference mbedcrypto pkgconfig
   
-  * ci: make style-checking available locally
+  mbedtls 3.6.0 got pkgconfig support:
+  https://github.com/Mbed-TLS/mbedtls/commit/a4d17b34f354557838e05d2cb47200e8dcaaf59b
   
-  * cmake: add a linting target
+  Reference it from `libssh2.pc`.
   
-  * tests: check test suite syntax with checksrc.pl
+  Closes #1405
 
-- [Will Cosgrove brought this change]
+- tidy-up: typo in comment [ci skip]
 
-  kex.c: kex_agree_instr() improve string reading (#552)
+- RELEASE-NOTES: sync [ci skip]
   
-  * kex.c: kex_agree_instr() improve string reading
+  Also bump planned deprecation dates.
+
+- ci/GHA: show configure logs on failure and other tidy-ups
   
-  file: kex.c
-  notes: if haystack isn't null terminated we should use memchr() not strchar(). We should also make sure we don't walk off the end of the buffer.
-  credit:
-  Will Cosgrove, reviewed by Michael Buckley
+  - dump cmake error log on configure failure. (for cmake 3.26 and newer)
+  - dump `config.log` on autotools configure failure.
+  - convert specs filename to Windows format before passing to CMake.
+  - add missing quotes.
+  
+  Closes #1403
 
-- [Will Cosgrove brought this change]
+- ci/GHA: bump parallel jobs to nproc+1
+  
+  Ref: https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories
+  
+  Closes #1402
 
-  kex.c: use string_buf in ecdh_sha2_nistp (#551)
+- ci/GHA: show test logs on failure
   
-  * kex.c: use string_buf in ecdh_sha2_nistp
+  Closes #1401
+
+- ci/GHA: fix `Dockerfile` failing after Ubuntu package update
   
-  file: kex.c
+  Likely due an upstream Ubuntu package update (requiring an apt-get
+  install call beforehand), tests run via autotools started failing with
+  no change in the libssh2 repo:
+  ```
+  FAIL: test_aa_warmup
+  ====================
   
-  notes:
-  use string_buf in ecdh_sha2_nistp() to avoid attempting to parse malformed data
+  Error running command 'docker build --quiet -t libssh2/openssh_server %s' (exit 256): Dockerfile:10
+  --------------------
+     8 |      && apt-get clean \
+     9 |      && rm -rf /var/lib/apt/lists/*
+    10 | >>> RUN mkdir /var/run/sshd
+    11 |
+    12 |     # Chmodding because, when building on Windows, files are copied in with
+  --------------------
+  ERROR: failed to solve: process "/bin/sh -c mkdir /var/run/sshd" did not complete successfully: exit code: 1
+  
+  Failed to build docker image
+  Cannot stop session - none started
+  Cannot stop container - none started
+  Command: docker build --quiet -t libssh2/openssh_server ../../tests/openssh_server
+  FAIL test_aa_warmup (exit status: 1)
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/9322194756/job/25662748095#step:11:390
+  
+  Fix it by skipping `mkdir` if `/var/run/sshd` already exists.
+  
+  (Why cmake-based jobs aren't affected, I don't know.)
+  
+  Ref: https://github.com/libssh2/libssh2/commit/50143d5867d35df76a6cf589ca8a13b22105aa64#commitcomment-142560875
+  Closes #1400
 
-- [Will Cosgrove brought this change]
+- ci/GHA: use ubuntu-latest with OmniOS job
+  
+  It's the same as ubuntu-22.04.
+  
+  Also update OmniOS package search link.
 
-  kex.c: move EC macro outside of if check #549 (#550)
+- ci: disable dependency tracking in autotools builds
   
-  File: kex.c
+  For better build performance. Dependency tracking causes a build
+  overhead while compiling to help a subsequent build, but in CI there is
+  never one and the extra work is discarded.
   
-  Notes:
-  Moved the macro LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY outside of the LIBSSH2_ECDSA since it's also now used by the ED25519 code.
+  Closes #1396
+
+- mbedtls: fail to compile with v3.6.0 outside CI
   
-  Sha 256, 384 and 512 need to be defined for all backends now even if they aren't used directly. I believe this is already the case, but just a heads up.
+  A compile-time failure is preferred over an unexpected one at
+  runtime.
   
-  Credit:
-  Stefan-Ghinea
+  The problem is silenced with a macro in CI and this macro will have
+  to be added to more platforms when mbedTLS v3.6.0 reaches them.
+  
+  Follow-up to 2e4c5ec4627b3ecf4b6da16f365c011dec9a31b4 #1349
+  Closes #1393
 
-- [Tim Gates brought this change]
+- tests: drop default cygpath option `-u`
 
-  kex.c: fix simple typo, niumber -> number (#545)
+- tidy-up: fix typo found by codespell
   
-  File: kex.c
+  Ref: https://github.com/libssh2/libssh2/actions/runs/9224795055/job/25380857082?pr=1393#step:4:5
+
+- ci/GHA: shell syntax tidy-up
   
-  Notes:
-  There is a small typo in src/kex.c.
+  Closes #1390
+
+- RELEASE-NOTES: sync [ci skip]
+
+- ci/GHA: bump NetBSD/OpenBSD, add NetBSD arm64 job
   
-  Should read `number` rather than `niumber`.
+  OpenBSD arm64 jobs were very slow, so skipped that.
   
-  Credit:
-  Tim Gates
+  Closes #1388
 
-- [Tseng Jun brought this change]
+- autotools: fix to update `LDFLAGS` for each detected dependency
+  
+  autotools lib detection routine failed to extend LDFLAGS for each
+  detection. This could cause successful detection of a dependency, but
+  later failing to use it. This did not cause an issue as long as all
+  dependencies lived under the same prefix, but started breaking on macOS
+  ARM + Homebrew where this was no longer true for mbedTLS and zlib in
+  particular.
+  
+  Follow-up to 844115393bffb4e92c6569204cbe4cd8e553480d #1381
+  Follow-up to ae2770de25949bc7c74e60b4cc6a011bbe1d3d7c #1377
+  Closes #1384
 
-  session.c: Correct a typo which may lead to stack overflow (#533)
+GitHub (8 May 2024)
+- [Michael Buckley brought this change]
+
+  OpenSSL 3: Fix calculating DSA public key (#1380)
+
+Viktor Szakats (8 May 2024)
+- ci/GHA: tidy-up wolfSSL autotools config on macOS
   
-  File: session.c
+  Closes #1383
+
+- ci/GHA: shorter mbedTLS autotools workaround
   
-  Notes:
-  Seems the author intend to terminate banner_dup buffer, later, print it to the debug console.
+  Follow-up to 844115393bffb4e92c6569204cbe4cd8e553480d #1381
+  Closes #1382
+
+GitHub (8 May 2024)
+- [Michael Buckley brought this change]
+
+  ci: fix mbedtls runners on macOS (#1381)
   
-  Author:
-  Tseng Jun
+  Sets LDFLAGS while configuring the autoconf mbedTLS build for macOS.
 
-Marc Hoersken (10 Oct 2020)
-- wincng: fix random big number generation to match openssl
+Viktor Szakats (29 Apr 2024)
+- RELEASE-NOTES: sync [ci skip]
+
+- [binary1248 brought this change]
+
+  wincng: fix `DH_GEX_MAXGROUP` set higher than supported
   
-  The old function would set the least significant bits in
-  the most significant byte instead of the most significant bits.
+  In 1c3a03ebc3166cf69735111aba2b8cee57cdba51 #493,
+  `LIBSSH2_DH_GEX_MAXGROUP` was introduced to specify
+  crypto-backend-specific modulus sizes. Unfortunately, the max size for
+  the wincng DH modulus was defined to 8192, probably because this is the
+  value most other backends support.
   
-  The old function would also zero pad too much bits in the
-  most significant byte. This lead to a reduction of key space
-  in the most significant byte according to the following listing:
-  - 8 bits reduced to 0 bits => eg. 2048 bits to 2040 bits DH key
-  - 7 bits reduced to 1 bits => eg. 2047 bits to 2041 bits DH key
-  - 6 bits reduced to 2 bits => eg. 2046 bits to 2042 bits DH key
-  - 5 bits reduced to 3 bits => eg. 2045 bits to 2043 bits DH key
+  According to Microsoft documentation [1], `BCryptGenerateKeyPair`
+  currently only supports up to 4096-bit keys when the selected algorithm
+  is `BCRYPT_DH_ALGORITHM`. Requesting larger keys when calling
+  `BCryptGenerateKeyPair` in `_libssh2_dh_key_pair` always results in
+  `STATUS_INVALID_PARAMETER` being returned and ultimately key exchange
+  failing.
   
-  No change would occur for the case of 4 significant bits.
-  For 1 to 3 significant bits in the most significant byte
-  the DH key would actually be expanded instead of reduced:
-  - 3 bits expanded to 5 bits => eg. 2043 bits to 2045 bits DH key
-  - 2 bits expanded to 6 bits => eg. 2042 bits to 2046 bits DH key
-  - 1 bits expanded to 7 bits => eg. 2041 bits to 2047 bits DH key
+  When attempting to connect to any server that offers 8192 bit DH, this
+  causes key exchange to always fail when using the wincng backend.
+  Reducing `LIBSSH2_DH_GEX_MAXGROUP` to 4096 fixes the issue.
   
-  There is no case of 0 significant bits in the most significant byte
-  since this would be a case of 8 significant bits in the next byte.
+  [1] https://learn.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgeneratekeypair
   
-  At the moment only the following case applies due to a fixed
-  DH key size value currently being used in libssh2:
+  Closes #1372
+
+- build: silence warnings inside `FD_SET()`/`FD_ISSET()` macros
   
-  The DH group_order is fixed to 256 (bytes) which leads to a
-  2047 bits DH key size by calculating (256 * 8) - 1.
+  Use an ugly workaround to silence `-Wsign-conversion` warnings triggered
+  by the internals of `FD_SET()`/`FD_ISSET()` macros. They've been showing
+  up in OmniOS CI builds when compiling `example` programs. They also have
+  been seen with older Cygwin and other envs and configurations.
   
-  This means the DH keyspace was previously reduced from 2047 bits
-  to 2041 bits (while the top and bottom bits are always set), so the
-  keyspace is actually always reduced from 2045 bits to 2039 bits.
+  Also scope two related variables in examples.
   
-  All of this is only relevant for Windows versions supporting the
-  WinCNG backend (Vista or newer) before Windows 10 version 1903.
+  E.g.:
+  ```
+  ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+    251 |         FD_SET(forwardsock, &fds);
+        |         ^~~~~~
+  ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+  ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'long int' may change the sign of the result [-Wsign-conversion]
+  ../../example/direct_tcpip.c:251:9: warning: conversion to 'long int' from 'long unsigned int' may change the sign of the result [-Wsign-conversion]
+  ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+    259 |         if(rc && FD_ISSET(forwardsock, &fds)) {
+        |                  ^~~~~~~~
+  ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+  ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'long int' may change the sign of the result [-Wsign-conversion]
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/8854199687/job/24316762831#step:3:2020
   
-  Closes #521
+  Closes #1379
 
-Daniel Stenberg (28 Sep 2020)
-- libssh2_session_callback_set.3: explain the recv/send callbacks
+- autotools: use `AM_CFLAGS`
   
-  Describe how to actually use these callbacks.
+  Use `AM_CFLAGS` to pass custom, per-target C flags. This replaces using
+  `CFLAGS` which triggered this warning when running `autoreconf -fi`:
+  ```
+  tests/Makefile.am:8: warning: 'CFLAGS' is a user variable, you should not override it;
+  tests/Makefile.am:8: use 'AM_CFLAGS' instead
+  ```
+  (Only for `tests`, even though `example` and `src` also used this
+  method. The warning is also missing from curl, that also uses
+  `CFLAGS`.)
   
-  Closes #518
+  Follow-up to 3ec53f3ea26f61cbf2e0fbbeccb852fca7f9b156 #1286
+  Closes #1378
 
-GitHub (23 Sep 2020)
-- [Will Cosgrove brought this change]
+GitHub (25 Apr 2024)
+- [Viktor Szakats brought this change]
 
-  agent.c: formatting
+  ci/GHA: fix gcrypt with autotools/macOS/Homebrew/ARM64 (#1377)
   
-  Improved formatting of RECV_SEND_ALL macro.
+  mbedtls configure fails to detect anything due to this:
+  ```
+  configure:23101: gcc -o conftest -g -O2 -I/opt/homebrew/include  conftest.c  -lmbedcrypto -lz >&5
+  ld: library 'mbedcrypto' not found
+  clang: error: linker command failed with exit code 1 (use -v to see invocation)
+  ```
 
-- [Will Cosgrove brought this change]
+Viktor Szakats (25 Apr 2024)
+- autotools: delete bogus square bracket from help text [ci skip]
+  
+  Follow-up to 3f98bfb0900b5e68445a339cfebc60b307a24650 #1368
 
-  CMakeLists.txt: respect install lib dir #405 (#515)
+GitHub (25 Apr 2024)
+- [Viktor Szakats brought this change]
+
+  ci/GHA: fix verbose option for autotools jobs (#1376)
   
-  Files:
-  CMakeLists.txt
+  Also enable verbose for macOS `make` step.
+
+- [Viktor Szakats brought this change]
+
+  ci/GHA: dump `config.log` on failure for macOS autotools jobs (#1375)
+
+- [Viktor Szakats brought this change]
+
+  ci/GHA: fix `autoreconf` failure on macOS/Homebrew (#1374)
   
-  Notes:
-  Use CMAKE_INSTALL_LIBDIR directory
+  By manually installing `libtool`.
   
-  Credit: Arfrever
+  ```
+  autoreconf -fi
+    shell: /bin/bash -e {0}
+  configure.ac:75: error: possibly undefined macro: AC_LIBTOOL_WIN32_DLL
+        If this token and others are legitimate, please use m4_pattern_allow.
+        See the Autoconf documentation.
+  configure.ac:76: error: possibly undefined macro: AC_PROG_LIBTOOL
+  autoreconf: error: /opt/homebrew/Cellar/autoconf/2.72/bin/autoconf failed with exit status: 1
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/8833608758/job/24253334557#step:4:1
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  kex.c: group16-sha512 and group18-sha512 support #457 (#468)
+  ci/GHA: fixup Homebrew location (for ARM runners) (#1373)
   
-  Files: kex.c
+  GHA macOS runners became ARM64 machines. Make the Homebrew prefix
+  dynamic to adapt to these installations.
+
+Viktor Szakats (14 Apr 2024)
+- RELEASE-NOTES: sync [ci skip]
+
+- [Patrick Monnerat brought this change]
+
+  os400: Add two recent files to the distribution
   
-  Notes:
-  Added key exchange group16-sha512 and group18-sha512. As a result did the following:
+  Closes #1364
+
+- wincng: add to ci/GHA, add `./configure` option `--enable-ecdsa-wincng`
   
-  Abstracted diffie_hellman_sha256() to diffie_hellman_sha_algo() which is now algorithm agnostic and takes the algorithm as a parameter since we needed sha512 support. Unfortunately it required some helper functions but they are simple.
-  Deleted diffie_hellman_sha1()
-  Deleted diffie_hellman_sha1 specific macro
-  Cleaned up some formatting
-  Defined sha384 in os400 and wincng backends
-  Defined LIBSSH2_DH_MAX_MODULUS_BITS to abort the connection if we receive too large of p from the server doing sha1 key exchange.
-  Reorder the default key exchange list to match OpenSSH and improve security
+  - add `./configure` option `--enable-ecdsa-wincng`
   
-  Credit:
-  Will Cosgrove
+  - add WinCNG autotools jobs to GHA.
+  
+  - enable WinCNG ECDSA in some GHA jobs (both CMake and autotools).
+  
+  Follow-up to 3e72343737e5b17ac98236c03d5591d429b119ae #1315
+  Closes #1368
 
-- [Igor Klevanets brought this change]
+GitHub (14 Apr 2024)
+- [Johannes Passing brought this change]
 
-  agent.c: Recv and send all bytes via network in agent_transact_unix() (#510)
+  wincng: add ECDSA support for host and user authentication (#1315)
   
-  Files: agent.c
+  The WinCNG backend currently only supports DSA and RSA. This PR
+  adds ECDSA support for host and user authentication.
   
-  Notes:
-  Handle sending/receiving partial packet replies in agent.c API.
+  * Disable WinCNG ECDSA support by default to maintain backward
+    compatibility for projects that target versions below Windows 10.
   
-  Credit: Klevanets Igor <cerevra@yandex-team.ru>
+  * Add cmake option `ENABLE_ECDSA_WINCNG` to guard ECDSA support.
+  
+  * Update AppVeyor job matrix to only enable ECDSA on Server 2016+
 
-- [Daniel Stenberg brought this change]
+Viktor Szakats (14 Apr 2024)
+- ci: enable Unity mode for most CMake builds
+  
+  Ref: 7129ea9ca8cca86dac80a6bac2d63937987efe9d #1034
+  Closes #1367
 
-  Makefile.am: include all test files in the dist #379
+- os400: fix shellcheck warnings in scripts (fixups)
   
-  File:
-  Makefile.am
+  - Build scripts must be executed by the os/400 shell (sh), not bash which
+    is a PASE program: The `-ot` non-POSIX test extension works in os/400 as
+    well. Ref: https://github.com/libssh2/libssh2/pull/1364#issue-2241646754
   
-  Notes:
-  No longer conditionally include OpenSSL specific test files, they aren't run if we're not building against OpenSSL 1.1.x anyway.
+  - Drop/fixup mods trying to make some syntax highlighters happier.
   
-  Credit:
-  Daniel Stenberg
+  Follow-up to c6625707b94d9093f38f1a0a4d89c11b64f12ba8 #1358
+  Assisted-by: Patrick Monnerat
+  Closes #1364
+  Closes #1366
 
-- [Max Dymond brought this change]
+- cmake: style tidy-up (more)
+  
+  Follow-up to 3fa5282d6284efba62dc591697e6a687152bdcb1 #1166
+  Closes #1365
 
-  Add support for an OSS Fuzzer fuzzing target (#392)
+- RELEASE-NOTES: sync [ci skip]
+
+- os400: fix shellcheck warnings in scripts
   
-  Files:
-  .travis.yml, configure.ac, ossfuzz
+  - use `$()` instead of backticks, and re-arrange double-quotes inside.
+  - add missing `|| exit 1` to `cd` calls. (could be dropped by using `set -eu`.)
+  - add `-n` to a few `if`s.
+  - shorten redirections by using `{} >` (as shellcheck recommended).
+  - silence warnings where variables were detected as unused (SC2034).
+  - a couple misc updates to silence warnings.
+  - switch to bash shebang for `-ot` feature.
+  - split two lines to unbreak syntax highlighting in my editor. (`$(expr \`, `$(dirname \`)
   
-  Notes:
-  This adds support for an OSS-Fuzz fuzzing target in ssh2_client_fuzzer,
-  which is a cut down example of ssh2.c. Future enhancements can improve
-  coverage.
+  Also enable CI checks for OS/400 shell scripts.
   
-  Credit:
-  Max Dymond
+  Ref: d88b9bcdafe9d19aad2fb120d0a0acb3edab64f7
+  Closes #1358
 
-- [Sebastián Katzer brought this change]
+- RELEASE-NOTES: sync [ci skip]
 
-  mbedtls.c: ECDSA support for mbed TLS (#385)
+- ci: add shellcheck job and script
   
-  Files:
-  mbedtls.c, mbedtls.h, .travis.yml
+  Add FIXME for OS/400 scripts.
   
-  Notes:
-  This PR adds support for ECDSA for both key exchange and host key algorithms.
+  Cherry-picked from #1358
+
+- tests: fix shellcheck issues in `test_sshd.test`
   
-  The following elliptic curves are supported:
+  Cherry-picked from #1358
+
+- RELEASE-NOTES: sync [ci skip]
+
+GitHub (9 Apr 2024)
+- [Viktor Szakats brought this change]
+
+  ci/appveyor: re-enable OpenSSL 3, also bump to 3.2.1 (#1363)
   
-  256-bit curve defined by FIPS 186-4 and SEC1
-  384-bit curve defined by FIPS 186-4 and SEC1
-  521-bit curve defined by FIPS 186-4 and SEC1
+  Ref: 104744f4a523de574ce3767c50948d9b8385be4c #1348
+
+Viktor Szakats (9 Apr 2024)
+- ci: use a better test timestamp [ci skip]
   
-  Credit:
-  Sebastián Katzer
+  Mar 27 2024 08:00:00 GMT+0000
+  
+  Follow-up to 2d765e454d98b794a5e5bbc497b1fcba4a9b8c4b #1360
 
-Marc Hoersken (1 Sep 2020)
-- buildconf: exec autoreconf to avoid additional process (#512)
+GitHub (9 Apr 2024)
+- [Viktor Szakats brought this change]
+
+  ci: verify build and install from tarball (#1362)
   
-  Also make buildconf exit with the return code of autoreconf.
+  Install verification based on:
+  https://github.com/curl/curl/blob/28c5ddf13ac311d10bc4e8f9fc4ce0858a19b888/scripts/installcheck.sh
+
+Viktor Szakats (9 Apr 2024)
+- tidy-up: dir names, command-line [ci skip]
   
-  Follow up to #224
+  Follow-up to 2d765e454d98b794a5e5bbc497b1fcba4a9b8c4b #1360
 
-- scp.c: fix indentation in shell_quotearg documentation
+- cmake: tidy up function name casing in `CopyRuntimeDependencies.cmake`
+  
+  Use lowercase to match callers.
 
-- wincng: make more use of new helper functions (#496)
+GitHub (9 Apr 2024)
+- [Viktor Szakats brought this change]
 
-- wincng: make sure algorithm providers are closed once (#496)
+  ci: add reproducibility test for `maketgz` (#1360)
 
-GitHub (10 Jul 2020)
-- [David Benjamin brought this change]
+Viktor Szakats (9 Apr 2024)
+- maketgz: add reproducible dir entries to tarballs
+  
+  In the initial implementation of reproducible tarballs, they were
+  missing directory entries, while .zip archives had them. It meant
+  that on extracting the tarball, on-disk directory entries got the
+  current timestamp.
+  
+  This patch fixes this by including directory entries in the tarball,
+  with reproducible timestamps. It also moves sorting inside tar,
+  to ensure reproducible directory entry timestamps on extract
+  (without the need of `--delay-directory-restore` option, when
+  extracting with GNU tar. BSD tar got that right by default.)
+  
+  GNU tar 1.28 (2014-07-28) introduced `--sort=`.
+  
+  Follow-up to d52fe1b4358fab891037d86b5c73c098079567db #1357
+  Closes #1359
 
-  openssl.c: clean up curve25519 code (#499)
+- ci/GHA: improve version number in `maketgz` test
   
-  File: openssl.c, openssl.h, crypto.h, kex.c
+  Follow-up to cba7f97506c1b8e5ff131bbbc57b5796ac634c56 #1353
+
+GitHub (8 Apr 2024)
+- [Michael Buckley brought this change]
+
+  src: check the return value from `_libssh2_bn_*()` functions (#1354)
   
-  Notes:
-  This cleans up a few things in the curve25519 implementation:
+  Found by oss-fuzz. In `diffie_hellman_sha_algo()`, we were calling
+  `_libssh2_bn_from_bin()` with data recieved by the server without
+  checking whether that data was zero-length or ridiculously long.
+  In the OpenSSL backend, this would cause `_libssh2_bn_from_bin()`
+  to fail an allocation, which would eventually lead to a NULL
+  dereference when the bignum was used.
   
-  - There is no need to create X509_PUBKEYs or PKCS8_PRIV_KEY_INFOs to
-    extract key material. EVP_PKEY_get_raw_private_key and
-    EVP_PKEY_get_raw_public_key work fine.
+  Add the same check for `_libssh2_bn_set_word()` and
+  `_libssh2_bn_to_bin()`.
+
+Viktor Szakats (8 Apr 2024)
+- maketgz: reproducible tarballs/zip, display tarball hashes
   
-  - libssh2_x25519_ctx was never used (and occasionally mis-typedefed to
-    libssh2_ed25519_ctx). Remove it. The _libssh2_curve25519_new and
-    _libssh2_curve25519_gen_k interfaces use the bytes. Note, if it needs
-    to be added back, there is no need to roundtrip through
-    EVP_PKEY_new_raw_private_key. EVP_PKEY_keygen already generated an
-    EVP_PKEY.
+  - support `SOURCE_DATE_EPOCH` for reproducibility.
+  - make tarballs reproducible.
+  - make file timestamps in tarball/zip reproducible.
+  - make directory timestamps in zip reproducible.
+  - make timestamps of tarballs/zip reproducible.
+  - make file order in tarball/zip reproducible.
+  - use POSIX ustar tarball format to avoid supply chain vulnerability: https://seclists.org/oss-sec/2021/q4/0
+  - make uid/gid in tarball reproducible.
+  - omit owner user/group names from tarball for reproducibility and privacy.
+  - omit current timestamp from .gz header for reproducibility.
+  - display SHA-256 hashes of produced tarballs/zip. (Requires `sha256sum`)
+  - re-sync formatting with curl's `maketgz`.
   
-  - Add some missing error checks.
+  Closes #1357
+
+- maketgz: `set -eu`, reproducibility, improve zip, add CI test
   
-  Credit:
-  David Benjamin
+  - set bash `-eu`.
+  - fix bash `-eu` issues.
+  - apply `TZ=UTC` and `LC_ALL=C` for reproducibility.
+  - sort `.zip` entries for reproducibility.
+  - zip with `--no-extra` for reproducibliity.
+  - use maximum zip compression.
+  - add the gpg sign command-line. Copied from curl.
+  - add CI test for `maketgz`.
+  
+  Closes #1353
 
-- [Will Cosgrove brought this change]
+- RELEASE-NOTES: sync and cleanups [ci skip]
 
-  transport.c: socket is disconnected, return error (#500)
+GitHub (3 Apr 2024)
+- [Tejaswikandula brought this change]
+
+  Support RSA SHA2 cert-based authentication (rsa-sha2-512_cert and rsa-sha2-256_cert) (#1314)
   
-  File: transport.c
+  Replicating OpenSSH's behavior to handle RSA certificate authentication
+  differently based on the remote server version.
   
-  Notes:
-  This is to fix #102, instead of continuing to attempt to read a disconnected socket, it will now error out.
+  1. For OpenSSH versions >= 7.8, ascertain server's support for RSA Cert
+     types by checking if the certificate's signature type is present in
+     the `server-sig-algs`.
   
-  Credit:
-  TDi-jonesds
-
-- [Will Cosgrove brought this change]
+  2. For OpenSSH versions < 7.8, Set the "SSH_BUG_SIGTYPE" flag when the
+     RSA key in question is a certificate to ignore `server-sig-algs` and
+     only offer ssh-rsa signature algorithm for RSA certs.
+  
+  This arises from the fact that OpenSSH versions up to 7.7 accept
+  RSA-SHA2 keys but not RSA-SHA2 certificate types. Although OpenSSH <=7.7
+  includes RSA-SHA2 keys in the `server-sig-algs`, versions <=7.7 do not
+  actually support RSA certs. Therefore, server sending RSA-SHA2 keys in
+  `server-sig-algs` should not be interpreted as indicating support for
+  RSA-SHA2 certs. So, `server-sig-algs` are ignored when the RSA key in
+  question is a cert, and the remote server version is 7.7 or below.
+  
+  Relevant sections of the OpenSSH source code:
+  
+  <https://github.com/openssh/openssh-portable/blob/V_8_9_P1/sshconnect2.c#L1191-L1197>
+  <https://github.com/openssh/openssh-portable/blob/master/compat.c#L43>
+  
+  Assisted-by: Will Cosgrove
+  Reviewed-by: Viktor Szakats
 
-  stale.yml
+Viktor Szakats (3 Apr 2024)
+- RELEASE-NOTES: sync [ci skip]
   
-  Increasing stale values.
+  Also fix to include 3-digit issue/PR references.
 
-Marc Hoersken (6 Jul 2020)
-- wincng: try newer DH API first, fallback to legacy RSA API
+- mbedtls: add workaround + FIXME to build with 3.6.0
   
-  Avoid the use of RtlGetVersion or similar Win32 functions,
-  since these depend on version information from manifests.
+  This is just a stub to make `_libssh2_mbedtls_ecdsa_new_private`
+  compile.
   
-  This commit makes the WinCNG backend first try to use the
-  new DH algorithm API with the raw secret derivation feature.
-  In case this feature is not available the WinCNG backend
-  will fallback to the classic approach of using RSA-encrypt
-  to perform the required modular exponentiation of BigNums.
+  mbedtls 3.6.0 silently deleted its public API `mbedtls_pk_load_file`,
+  which this function relies on.
   
-  The feature availability test is done during the first handshake
-  and the result is stored in the crypto backends global state.
+  Closes #1349
+
+GitHub (3 Apr 2024)
+- [Viktor Szakats brought this change]
+
+  ci/appveyor: OpenSSL 3 no longer found by CMake, revert to 1.1.1 (#1348)
   
-  Follow up to #397
-  Closes #484
+  Ref: https://github.com/appveyor/build-images/commit/702e8cdca01f28f6a40687783f493c786cebbe2c
+  Ref: https://github.com/appveyor/build-images/pull/149
 
-- wincng: fix indentation of function arguments and comments
+Viktor Szakats (3 Apr 2024)
+- docs: improve `libssh2_userauth_publickey_from*` manpages
   
-  Follow up to #397
+  Reported-by: Lyndon Brown
+  Assisted-by: Ryan Kelley
+  Fixes #652
+  Closes #1308
+  Closes #xxxx
 
-- [Wez Furlong brought this change]
+- RELEASE-NOTES: sync [ci skip]
 
-  wincng: use newer DH API for Windows 8.1+
+GitHub (2 Apr 2024)
+- [Viktor Szakats brought this change]
+
+  test debian:testing-slim post xz backdoor removal (#1346)
   
-  Since Windows 1903 the approach used to perform DH kex with the CNG
-  API has been failing.
+  The unexplained CI fallouts are gone with the latest debian:testing (20240330).
   
-  This commit switches to using the `DH` algorithm provider to perform
-  generation of the key pair and derivation of the shared secret.
+  Ref #1328 #1329 #1338.
+  Closes #1346
+
+Viktor Szakats (30 Mar 2024)
+- ci: use Linux runner for BSDs, add arm64 FreeBSD 14 job
   
-  It uses a feature of CNG that is not yet documented.  The sources of
-  information that I've found on this are:
+  - bump cross-platform-actions to 0.23.0.
+    Ref: https://github.com/cross-platform-actions/action/releases/tag/v0.23.0
   
-  * https://stackoverflow.com/a/56378698/149111
-  * https://github.com/wbenny/mini-tor/blob/5d39011e632be8e2b6b1819ee7295e8bd9b7a769/mini/crypto/cng/dh.inl#L355
+  - switch to Linux runners (from macOS) for cross-platform-actions.
+    It's significantly faster.
   
-  With this change I am able to successfully connect from Windows 10 to my
-  ubuntu system.
+  - switch back FreeBSD 14 job to cross-platform-actions.
+    Also switch back to default shell.
   
-  Refs: https://github.com/alexcrichton/ssh2-rs/issues/122
-  Fixes: https://github.com/libssh2/libssh2/issues/388
-  Closes: https://github.com/libssh2/libssh2/pull/397
+  - add FreeBSD 14 arm64 job.
+  
+  Closes #1343
 
-GitHub (1 Jul 2020)
-- [Zenju brought this change]
+- ci: use single quotes in yaml [ci skip]
 
-  comp.c: Fix name clash with ZLIB macro "compress" (#418)
+- ci: tidy-up job order [ci skip]
+
+- build: drop `-Wformat-nonliteral` warning suppressions
   
-  File: comp.c
+  Also markup a vararg function as such.
   
-  Notes:
-  * Fix name clash with ZLIB macro "compress".
+  In functions marked up as vararg functions, there is no need to suppress
+  `-Wformat-nonliteral` warnings. It's done automatically by the compiler.
   
-  Credit:
-  Zenju
+  Closes #1342
 
-- [yann-morin-1998 brought this change]
+- ci: delete flaky FreeBSD 13.2 job
+  
+  Keep FreeBSD 14.
 
-  buildsystem: drop custom buildconf script, rely on autoreconf (#224)
+- RELEASE-NOTES: sync [ci skip]
+
+- example: restore `sys/time.h` for AIX
   
-  Notes:
-  The buildconf script is currently required, because we need to copy a
-  header around, because it is used both from the library and the examples
-  sources.
+  In AIX, `time.h` header file doesn't have definitions like
+  `fd_set`, `struct timeval`, which are found in `sys/time.h`.
   
-  However, having a custom 'buildconf'-like script is not needed if we can
-  ensure that the header exists by the time it is needed. For that, we can
-  just append the src/ directory to the headers search path for the
-  examples.
+  Add `sys/time.h` to files affected when available.
   
-  And then it means we no longer need to generate the same header twice,
-  so we remove the second one from configure.ac.
+  Regression from e53aae0e16dbf53ddd1a4fcfc50e365a15fcb8b9 #1001.
   
-  Now, we can just call "autoreconf -fi" to generate the autotools files,
-  instead of relying on the canned sequence in "buildconf", since
-  autoreconf has now long known what to do at the correct moment (future
-  versions of autotools, automake, autopoint, autoheader etc... may
-  require an other ordering, or other intermediate steps, etc...).
+  Reported-by: shubhamhii on GitHub
+  Assisted-by: shubhamhii on GitHub
+  Fixes #1334
+  Fixes #1335
+  Closes #1340
+
+- userauth: avoid oob with huge interactive kbd response
   
-  Eventually, get rid of buildconf now it is no longer needed. In fact, we
-  really keep it for legacy, but have it just call autoreconf (and print a
-  nice user-friendly warning). Don't include it in the release tarballs,
-  though.
+  - If the length of a response is `UINT_MAX - 3` or larger, an unsigned
+    integer overflow occurs on 64-bit systems. Avoid such truncation to
+    always allocate enough memory to avoid subsequent out of boundary
+    writes.
   
-  Update doc, gitignore, and travis-CI jobs accordingly.
+    Patch-by: Tobias Stoeckmann
   
-  Credit:
-  Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
-  Cc: Sam Voss <sam.voss@rockwellcollins.com>
+  - also add FIXME to bump up length field to `size_t` (ABI break)
+  
+  Closes #1337
 
-- [Will Cosgrove brought this change]
+GitHub (28 Mar 2024)
+- [Josef Cejka brought this change]
 
-  libssh2.h: Update Diffie Hellman group values (#493)
-  
-  File: libssh2.h
+  transport: check ETM on remote end when receiving (#1332)
   
-  Notes:
-  Update the min, preferred and max DH group values based on RFC 8270.
+  We should check if encrypt-then-MAC feature is enabled in remote end's
+  configuration.
   
-  Credit:
-  Will Cosgrove, noted from email list by Mitchell Holland
+  Fixes #1331
 
-Marc Hoersken (22 Jun 2020)
-- travis: use existing Makefile target to run checksrc
+- [Josef Cejka brought this change]
 
-- Makefile: also run checksrc on test source files
+  kex: always add extension indicators to kex_algorithms (#1327)
+  
+  KEX pseudo-methods "ext-info-c" and "kex-strict-c-v00@openssh.com"
+  are in default kex method list but they were lost after configuring
+  custom kex method list in libssh2_session_method_pref().
+  
+  Fixes #1326
 
-- tests: avoid use of deprecated function _sleep (#490)
+- [Jiwoo Park brought this change]
 
-- tests: avoid use of banned function strncat (#489)
+  cmake: use the imported target of FindOpenSSL module (#1322)
+  
+  * Use the imported target of FindOpenSSL module
+  * Build libssh2 before test runner
+  * Use find_package() in the CMake config file
+  * Use find_dependency() rather than find_package()
+  * Install CMake module files and use them in the config file
+  * Use elseif() to choose the crypto backend
 
-- tests: satisfy checksrc regarding max line length of 79 chars
+- [Andrei Augustin brought this change]
+
+  docs: update INSTALL_AUTOTOOLS (#1316)
   
-  Follow up to 2764bc8e06d51876b6796d6080c6ac51e20f3332
+  corrected --with-libmbedtls-prefix to current option --with-libmbedcrypto-prefix
 
-- tests: satisfy checksrc with whitespace only fixes
+Viktor Szakats (28 Mar 2024)
+- ci: don't parallelize `distcheck` job
   
-  checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF
-              -ACOPYRIGHT -AFOPENMODE tests/*.[ch]
+  A while ago the `distcheck` CI job became flaky. This continued after
+  switching to Debian stable (from testing). Try stabilzing it by running
+  it single-threaded.
+  
+  Closes #1339
 
-- tests: add support for ports published via Docker for Windows
+- Dockerfile: switch to Debian stable (from testing)
+  
+  This fixes flakiness experienced recently with two OpenSSL jobs and one
+  libgcrypt job, and/or intermittently causing all Docker-based tests to
+  fail.
+  
+  Reported-by: András Fekete
+  Fixes #1328
+  Fixes #1329
+  Closes #1338
 
-- tests: restore retry behaviour for docker-machine ip command
+GitHub (22 Feb 2024)
+- [Michael Buckley brought this change]
 
-- tests: fix mix of declarations and code failing C89 compliance
+  Supply empty hash functions for mac_method_hmac_aesgcm to avoid a crash when e.g. setting LIBSSH2_METHOD_CRYPT_CS (#1321)
 
-- wincng: add and improve checks in bit counting function
+- [Michael Buckley brought this change]
 
-- wincng: align bits to bytes calculation in all functions
+  gen_publickey_from_dsa: Initialize BIGNUMs to NULL for OpenSSL 3 (#1320)
 
-- wincng: do not disable key validation that can be enabled
+Viktor Szakats (23 Jan 2024)
+- RELEASE-NOTES: add algo deprecation notices [ci skip]
   
-  The modular exponentiation also works with key validation enabled.
+  Closes #1307
 
-- wincng: fix return value in _libssh2_dh_secret
-  
-  Do not ignore return value of modular exponentiation.
+- RELEASE-NOTES: sync [ci skip]
 
-- appveyor: build and run tests for WinCNG crypto backend
+GitHub (22 Jan 2024)
+- [Juliusz Sosinowicz brought this change]
 
-GitHub (1 Jun 2020)
-- [suryakalpo brought this change]
+  wolfssl: enable debug logging in wolfSSL when compiled in (#1310)
+  
+  Co-authored-by: Viktor Szakats
 
-  INSTALL_CMAKE.md: Update formatting (#481)
+- [monnerat brought this change]
+
+  os400: maintain up to date (#1309)
   
-  File: INSTALL_CMAKE.md
+  - Handle MD5 conditionals in os400qc3.
+  - Check for errors in os400qc3 pbkdf1.
+  - Implement an optional build options override file.
+  - Sync ILE/RPG copy files with current C header files.
+  - Allow a null session within a string conversion cache.
+  - Add an ILE/RPG example.
+  - Adjust outdated copyrights in changed files.
+
+Viktor Szakats (18 Jan 2024)
+- RELEASE-NOTES: sync
+
+- src: check hash update/final success
   
-  Notes:
-  Although the original text would be immediately clear to seasoned users of CMAKE and/or Unix shell, the lack of newlines may cause some confusion for newcomers. Hence, wrapping the texts in a md code-block such that the newlines appear as intended.
+  Also:
+  - delete unused internal macro `libssh2_md5()` where defined.
+  - prefix `libssh2_os400qc3_hash*()` function names with underscore.
+    These are public/visible, but internal.
+  - add FIXMEs to OS/400 code to verify update/final calls; some OS API,
+    some internal.
   
-  credit:
-  suryakalpo
+  Ref: https://github.com/libssh2/libssh2/pull/1301#discussion_r1446861650
+  Reviewed-by: Michael Buckley
+  Reviewed-by: Patrick Monnerat
+  Closes #1303
 
-Marc Hoersken (31 May 2020)
-- src: add new and align include guards in header files (#480)
-  
-  Make sure all include guards exist and follow the same format.
+- RELEASE-NOTES: sync [ci skip]
 
-- wincng: fix multiple definition of `_libssh2_wincng' (#479)
-  
-  Add missing include guard and move global state
-  from header to source file by using extern.
+GitHub (18 Jan 2024)
+- [Ryan Kelley brought this change]
 
-GitHub (28 May 2020)
-- [Will Cosgrove brought this change]
+  openssl: fix cppcheck found NULL dereferences (#1304)
+  
+  * Fix NULL dereference in gen_publickey_from_rsa_evp and
+    gen_publickey_from_dsa_evp.
+  * Add checks for en_publickey_from_ec_evp and en_publickey_from_ed_evp
 
-  transport.c: moving total_num check from #476 (#478)
+Viktor Szakats (12 Jan 2024)
+- openssl: delete internal `read_openssh_private_key_from_memory()`
   
-  file: transport.c
+  It was wrapping another internal function with no added logic.
   
-  notes:
-  moving total_num zero length check from #476 up to the prior bounds check which already includes a total_num check. Makes it slightly more readable.
+  Closes #1306
+
+- openssl: formatting/whitespace
   
-  credit:
-  Will Cosgrove
+  Also use `NULL` instead of `0` for pointers.
+  
+  Closes #1305
 
-- [lutianxiong brought this change]
+- HACKING-CRYPTO: more fixups [ci skip]
+  
+  Follow-up to f64885b6ab9bbdae2da9ebd70f4dd5cea56e838a #1297
 
-  transport.c: fix use-of-uninitialized-value (#476)
+- HACKING-CRYPTO: fixups [ci skip]
   
-  file:transport.c
+  Follow-up to f64885b6ab9bbdae2da9ebd70f4dd5cea56e838a #1297
+
+- RELEASE-NOTES: sync [ci skip]
+
+- src: check hash init success
   
-  notes:
-  return error if malloc(0)
+  Before this patch, SHA2 and SHA1 init function results were cast to
+  `void`. This patch makes sure to verify these values.
   
-  credit:
-  lutianxiong
+  Also:
+  - exclude an `assert(0)` from release builds in `_libssh2_sha_algo_ctx_init()`.
+    (return error instead)
+  - fix indentation / whitespace
+  
+  Reviewed-by: Michael Buckley
+  Closes #1301
+
+- mac: handle low-level errors
+  
+  - update low-level hmac functions from macros to functions.
+  - libgcrypt: propagate low-level hmac errors.
+  - libgcrypt: add error checks for hmac calls.
+  - os400qc3: add error checks, propagate them.
+    Assisted-by: Patrick Monnerat
+  - mbedtls: fix propagating low-level hmac errors.
+  - wincng: fix propagating low-level hmac errors.
+  - mac: verify success of low-level hmac functions.
+  - knownhost: verify success of low-level hmac functions.
+  - transport: verify success of MAC hash call.
+  - minor type cleanup in wincng.
+  - delete unused ripemd wrapper in wincng.
+  - delete unused SHA384 wrapper in mbedtls.
+  
+  Reported-by: Paul Howarth
+  Reviewed-by: Michael Buckley
+  Closes #1297
+
+GitHub (8 Jan 2024)
+- [Michael Buckley brought this change]
 
-- [Dr. Koutheir Attouchi brought this change]
+  Fix an out-of-bounds read in _libssh2_kex_agree_instr when searching for a KEX not in the server list (#1302)
 
-  libssh2_sftp.h: Changed type of LIBSSH2_FX_* constants to unsigned long, fixes #474
+Viktor Szakats (21 Dec 2023)
+- RELEASE-NOTES: sync [ci skip]
+
+- ci/appveyor: re-enable parallel mode
   
-  File:
-  libssh2_sftp.h
+  The comment cited earlier is no longer true with recent CMake versions.
+  This options does actually enable parallel builds with MSVC since CMake
+  v3.26.0: https://gitlab.kitware.com/cmake/cmake/-/issues/20564
   
-  Notes:
-  Error constants `LIBSSH2_FX_*` are only returned by `libssh2_sftp_last_error()` which returns `unsigned long`.
-  Therefore these constants should be defined as unsigned long literals, instead of int literals.
+  The effect isn't much for libssh2, because it spends most time in tests,
+  but let's enable it anyway for efficiency.
   
-  Credit:
-  Dr. Koutheir Attouchi
-
-- [monnerat brought this change]
+  Ref: 0d08974633cfc02641e6593db8d569ddb3644255 #884
+  Ref: 7a039d9a7a2945c10b4622f38eeed21ba6b4ec55 #867
+  
+  Closes #1294
 
-  os400qc3.c: constify libssh2_os400qc3_hash_update() data parameter. (#469)
+- ci/gha: review/fixup auto-cancel settings
   
-  Files: os400qc3.c, os400qc3.h
+  - use the group expression from `reuse.yml` (via curl).
+  - add auto-cancel for `ci` and `cifuzz`.
+  - add auto-cancel to `appveyor_docker`. I'm just guessing here.
+    The hope is that it fixes AppVeyor CI runs when re-pushing a PR.
+    This frequently caused the freshly pushed session to fail waiting for
+    a connection.
+  - sync group expression in `appveyor_status` with `reuse`.
   
-  Notes:
-  Fixes building on OS400. #426
+  Closes #1292
+
+- RELEASE-NOTES: fix casing in GitHub names [ci skip]
+
+- RELEASE-NOTES: synced [ci skip]
   
-  Credit:
-  Reported-by: hjindra on github, dev by Monnerat
+  Closes #1279
 
-- [monnerat brought this change]
+- [Michael Buckley brought this change]
 
-  HACKING.CRYPTO: keep up to date with new crypto definitions from code. (#466)
+  src: add 'strict KEX' to fix CVE-2023-48795 "Terrapin Attack"
   
-  File: HACKING.CRYPTO
+  Refs:
+  https://terrapin-attack.com/
+  https://seclists.org/oss-sec/2023/q4/292
+  https://osv.dev/list?ecosystem=&q=CVE-2023-48795
+  https://github.com/advisories/GHSA-45x7-px36-x8w8
+  https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-48795
   
-  Notes:
-  This commit updates the HACKING.CRYPTO documentation file in an attempt to make it in sync with current code.
-  New documented features are:
+  Fixes #1290
+  Closes #1291
+
+- session: add `libssh2_session_callback_set2()`
   
-  SHA384
-  SHA512
-  ECDSA
-  ED25519
+  Add new `libssh2_session_callback_set2()` API that deprecates
+  `libssh2_session_callback_set()`.
   
-  Credit:
-  monnerat
-
-- [Harry Sintonen brought this change]
+  The new implementation offers the same functionality, but accepts and
+  returns a generic function pointer (of type `libssh2_cb_generic *`), as
+  opposed to the old function that used data pointers (`void *`). The new
+  solution thus avoids data to function (and vice versa) pointer
+  conversions, which has undefined behaviour in standard C.
+  
+  About the name: It seems the `*2` suffix was used in the past for
+  replacement functions for deprecated ones. Let's stick with that.
+  `*_ex` was preferred for new functions that extend existing ones with
+  new features.
+  
+  Closes #1285
 
-  kex.c: Add diffie-hellman-group14-sha256 Key Exchange Method (#464)
+- build: enable `-pedantic-errors`
   
-  File: kex.c
+  According to the manual, this isn't the same as `-Werror -pedantic`.
+  Enable it together with `-Werror`.
   
-  Notes: Added diffie-hellman-group14-sha256 kex
+  https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-pedantic-errors-1
   
-  Credit: Harry Sintonen <sintonen@iki.fi>
-
-- [Will Cosgrove brought this change]
-
-  os400qc3.h: define sha512 macros (#465)
+  This option results in autotools feature detection going into crazies.
+  To avoid this, we add it to `CFLAGS` late. Idea copied from curl.
   
-  file: os400qc3.h
-  notes: fixes for building libssh2 1.9.x
-
-- [Will Cosgrove brought this change]
-
-  os400qc3.h: define EC types to fix building #426 (#462)
+  This option has an effect only with gcc 5.0 and newer as of this commit.
+  Let's enable it for clang and older versions too for simplicity. Ref:
+  https://github.com/curl/curl/commit/d5c0351055d5709da8f3e16c91348092fdb481aa
+  https://github.com/curl/curl/pull/2747
   
-  File: os400qc3.h
-  Notes: define missing EC types which prevents building
-  Credit: hjindra
+  Closes #1286
 
-- [Brendan Shanks brought this change]
+- build: add mingw-w64 support to `LIBSSH2_PRINTF()` attribute
+  
+  And fix the warning it detected.
+  
+  Closes #1287
 
-  hostkey.c: Fix 'unsigned int'/'uint32_t' mismatch (#461)
+- libssh2.h: add deprecated function warnings
   
-  File: hostkey.c
+  With deprecated-at versions and suggested replacement function.
   
-  Notes:
-  These types are the same size so most compilers are fine with it, but CodeWarrior (on classic MacOS) throws an ‘illegal implicit conversion’ error
+  It's possible to silence them by defining `LIBSSH2_DISABLE_DEPRECATION`.
   
-  Credit: Brendan Shanks
-
-- [Thomas Klausner brought this change]
-
-  Makefile.am: Fix unportable test(1) operator. (#459)
+  Also add depcreated-at versions to documentation, and unify wording.
   
-  file: Makefile.am
+  Ref: https://github.com/libssh2/libssh2/pull/1260#issuecomment-1837017987
+  Closes #1289
+
+- ci/spellcheck: delete redundant option [ci skip]
   
-  Notes:
-  The POSIX comparison operator for test(1) is =; bash supports == but not even test from GNU coreutils does.
+  `--check-hidden` not necessary when passing filenames explicitly.
   
-  Credit:
-  Thomas Klausner
+  Follow-up to a79218d3a058a333bb9de14079548a3511679a04
 
-- [Tseng Jun brought this change]
+- tidy-up: add empty line for clarity [ci skip]
 
-  openssl.c: minor changes of coding style (#454)
+- build: FIXME `-Wsign-conversion` to be errors [ci skip]
+
+- src: disable `-Wsign-conversion` warnings, add option to re-enable
   
-  File: openssl.c
+  To avoid the log noise till we fix those ~360 compiler warnings.
   
-  Notes:
-  minor changes of coding style and align preprocessor conditional for #439
+  Also add macro `LIBSSH2_WARN_SIGN_CONVERSION` to re-enable them.
   
-  Credit:
-  Tseng Jun
+  Follow-up to afa6b865604019ab27ec033294edfe3ded9ae0c0 #1257
+  
+  Closes #1284
 
-- [Hans Meier brought this change]
+- cmake: fix indentation [ci skip]
 
-  openssl.c: Fix for use of uninitialized aes_ctr_cipher.key_len (#453)
+- example, tests: call `WSACleanup()` for each `WSAStartup()`
   
-  File:
-  Openssl.c
+  On Windows.
   
-  Notes:
-  * Fix for use of uninitialized aes_ctr_cipher.key_len when using HAVE_OPAQUE_STRUCTS, regression from #439
+  Closes #1283
+
+- RELEASE-NOTES: update credits [ci skip]
   
-  Credit:
-  Hans Meirer, Tseng Jun
+  Ref: https://github.com/libssh2/libssh2/pull/1241#issuecomment-1830118584
 
-- [Zenju brought this change]
+- RELEASE-NOTES: avoid splitting names, fix typo, refine order [ci skip]
 
-  agent.c: Fix Unicode builds on Windows (#417)
+- RELEASE-NOTES: synced [ci skip]
+
+- add portable `LIBSSH2_SOCKET_CLOSE()` macro
   
-  File: agent.c
+  Add `LIBSSH2_SOCKET_CLOSE()` to the public `libssh2.h` header, for user
+  code. It translates to `closesocket()` on Windows and `close()` on other
+  platforms.
   
-  Notes:
-  Fixes unicode builds for Windows in Visual Studio 16.3.2.
+  Use it in example code.
   
-  Credit:
-  Zenju
-
-- [Hans Meier brought this change]
+  It makes them more readable by reducing the number of `_WIN32` guards.
+  
+  Closes #1278
 
-  openssl.c: Fix use-after-free crash in openssl backend without memory leak (#439)
+- ci: add FreeBSD 14 job, fix issues
   
-  Files: openssl.c
+  - install bash to fix error when running tests:
+    ```
+    ERROR: test_sshd.test - missing test plan
+    ERROR: test_sshd.test - exited with status 127 (command not found?)
+    =====================================
+    [...]
+    # TOTAL: 4
+    # PASS:  2
+    # SKIP:  0
+    # XFAIL: 0
+    # FAIL:  0
+    # XPASS: 0
+    # ERROR: 2
+    [...]
+    env: bash: No such file or directory
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7133852508/job/19427420687#step:3:3998
   
-  Notes:
-  Fixes memory leaks and use after free AES EVP_CIPHER contexts when using OpenSSL 1.0.x.
+  - fix sshd issue when running tests:
+    ```
+      # sshd log:
+      #  Server listening on :: port 4711.
+      #  Server listening on 0.0.0.0 port 4711.
+      #  Authentication refused: bad ownership or modes for file /home/runner/work/libssh2/libssh2/tests/key_rsa.pub
+      #  Authentication refused: bad ownership or modes for file /home/runner/work/libssh2/libssh2/tests/openssh_server/authorized_keys
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7134629175/job/19429828342#step:3:4059
   
-  Credit:
-  Hans Meier
+  Cherry-picked from #1277
+  Closes #1277
 
-- [Romain Geissler @ Amadeus brought this change]
-
-  Session.c: Fix undefined warning when mixing with LTO-enabled libcurl. (#449)
+- ci: add OmniOS job, fix issues
   
-  File: Session.c
+  - use GNU Make, to avoid errors:
+    ```
+    make: Fatal error in reader: Makefile, line 983: Badly formed macro assignment
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7134629175/job/19429838379#step:3:1956
   
-  Notes:
-  With gcc 9, libssh2, libcurl and LTO enabled for all binaries I see this
-  warning (error with -Werror):
+    Caused by `?=` in `Makefile.am`. Fix it just in case.
   
-  vssh/libssh2.c: In function ‘ssh_statemach_act’:
-  /data/mwrep/rgeissler/ospack/ssh2/BUILD/libssh2-libssh2-03c7c4a/src/session.c:579:9: error: ‘seconds_to_next’ is used uninitialized in this function [-Werror=uninitialized]
-    579 |     int seconds_to_next;
-        |         ^
-  lto1: all warnings being treated as errors
+    ```
+    make: Fatal error in reader: Makefile, line 438: Unexpected end of line seen
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7135524843/job/19432451767#step:3:1966
   
-  Gcc normally issues -Wuninitialized when it is sure there is a problem,
-  and -Wmaybe-uninitialized when it's not sure, but it's possible. Here
-  the compiler seems to have find a real case where this could happen. I
-  looked in your code and overall it seems you always check if the return
-  code is non null, not often that it's below zero. I think we should do
-  the same here. With this patch, gcc is fine.
+    It's around line 43 in `Makefile.am`, reason undiscovered.
   
-  Credit:
-  Romain-Geissler-1A
-
-- [Zenju brought this change]
-
-  transport.c: Fix crash with delayed compression (#443)
+  - fix error:
+    ```
+    ../../src/hostkey.c:1227:44: error: pointer targets in passing argument 5 of '_libssh2_ed25519_sign' differ in signedness [-Werror=pointer-sign]
+       1227 |                                  datavec[0].iov_base, datavec[0].iov_len);
+            |                                  ~~~~~~~~~~^~~~~~~~~
+            |                                            |
+            |                                            caddr_t {aka char *}
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7135102832/job/19431233967#step:3:2225
   
-  Files: transport.c
+    https://docs.oracle.com/cd/E36784_01/html/E36887/iovec-9s.html
   
-  Notes:
-  Fixes crash with delayed compression option using Bitvise server.
+  - FIXME: new `-Wsign-conversion` warnings appeared in examples:
+    ```
+    ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+      251 |         FD_SET(forwardsock, &fds);
+          |         ^~~~~~
+    ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+    ../../example/direct_tcpip.c:251:9: warning: conversion to 'long unsigned int' from 'long int' may change the sign of the result [-Wsign-conversion]
+    ../../example/direct_tcpip.c:251:9: warning: conversion to 'long int' from 'long unsigned int' may change the sign of the result [-Wsign-conversion]
+    ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+      259 |         if(rc && FD_ISSET(forwardsock, &fds)) {
+          |                  ^~~~~~~~
+    ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'libssh2_socket_t' {aka 'int'} may change the sign of the result [-Wsign-conversion]
+    ../../example/direct_tcpip.c:259:18: warning: conversion to 'long unsigned int' from 'long int' may change the sign of the result [-Wsign-conversion]
+    [...]
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/7136086865/job/19433997429#step:3:3450
   
-  Contributor:
-  Zenju
-
-- [Will Cosgrove brought this change]
+  Cherry-picked from #1277
 
-  Update INSTALL_MAKE path to INSTALL_MAKE.md (#446)
+- example: use `libssh2_socket_t` in X11 example
   
-  Included for #429
+  Cherry-picked from #1277
 
-- [Will Cosgrove brought this change]
+- [Aaron Stone brought this change]
 
-  Update INSTALL_CMAKE filename to INSTALL_CMAKE.md (#445)
+  Handle EINTR from send/recv/poll/select to try again as the error is not fatal
   
-  Fixing for #429
+  Integration-patches-by: Viktor Szakats
+  Fixes #955
+  Closes #1058
 
-- [Wallace Souza brought this change]
-
-  Rename INSTALL_CMAKE to INTALL_CMAKE.md (#429)
+- appveyor: delete UWP job broken since Visual Studio upgrade
   
-  Adding Markdown file extension in order to Github render the instructions properly
+  Few days ago UWP job started permafailing.
+  
+  fail: https://ci.appveyor.com/project/libssh2org/libssh2/builds/48678129/job/yb8n2pox8mfjwv6m
+  good: https://ci.appveyor.com/project/libssh2org/libssh2/builds/48673013
+  
+  Other projects also affected:
+  https://ci.appveyor.com/project/c-ares/c-ares/builds/48687390/job/l0fo4b0sijvqkw9r
+  
+  No related local update. Same CMake version. Same CI image.
+  
+  This seems to be the culprit, which could mean that this update broke
+  CMake detection, needs a different CMake configuration on our end, or
+  that this MSVC update pulled support for UWP apps:
+  
+  fail: -- The C compiler identification is MSVC 19.38.33130.0 (~ Visual Studio 2022 v17.8)
+  good: -- The C compiler identification is MSVC 19.37.32825.0 (~ Visual Studio 2022 v17.7)
+  
+  If this is v17.8, release notes don't readily suggest a feature removal:
+  https://learn.microsoft.com/en-us/visualstudio/releases/2022/release-notes-v17.8
+  
+  So it might just be UWP accidentally broken in this release.
+  
+  Closes #1275
 
-Will Cosgrove (17 Dec 2019)
-- [Daniel Stenberg brought this change]
+- checksrc: sync with curl
+  
+  Closes #1272
 
-  include/libssh2.h: fix comment: the known host key uses 4 bits (#438)
+- autotools: delete `--disable-tests` option, fix CI tests
+  
+  Originally added to improve build performance by skipping building
+  tests. But, there seems to be no point in this, because autotools
+  doesn't build tests by default, unless explicitly invoking
+  `make check`.
+  
+  Delete this option from Cygwin and FreeBSD CI tests, where it caused
+  `make check` to do nothing. Tests are built now, and runtime tests are
+  too, where supported.
+  
+  Also disable Docker-based tests for these, and add a missing `make -j3`
+  for FreeBSD.
+  
+  Reverts 7483edfada1f7e17cf8f9ac1c87ffa3d814c987e #715
+  
+  Closes #1271
 
-- [Zenju brought this change]
+GitHub (6 Dec 2023)
+- [ren mingshuai brought this change]
 
-  ssh-ed25519: Support PKIX + calc pubkey from private (#416)
+  build: add `LIBSSH2_NO_DEPRECATED` option (#1266)
   
-  Files: openssl.c/h
-  Author: Zenju
-  Notes:
-  Adds support for PKIX key reading by fixing:
+  The following APIs have been deprecated for over 10 years and
+  use `LIBSSH2_NO_DEPRECATED` to mark them as deprecated:
   
-  _libssh2_pub_priv_keyfile() is missing the code to extract the ed25519 public key from a given private key
+  libssh2_session_startup()
+  libssh2_banner_set()
+  libssh2_channel_receive_window_adjust()
+  libssh2_channel_handle_extended_data()
+  libssh2_scp_recv()
   
-  _libssh2_ed25519_new_private_frommemory is only parsing the openssh key format but does not understand PKIX (as retrieved via PEM_read_bio_PrivateKey)
+  Add these options to disable them:
+  - autotools: `--disable-deprecated`
+  - cmake: `-DLIBSSH2_NO_DEPRECATED=ON`
+  - `CPPFLAGS`: `-DLIBSSH2_NO_DEPRECATED`
+  
+  Fixes #1259
+  Replaces #1260
+  Co-authored-by: Viktor Szakats
+  Closes #1267
 
-GitHub (15 Oct 2019)
-- [Will Cosgrove brought this change]
+Viktor Szakats (5 Dec 2023)
+- autotools: show the default for `hidden-symbols` option
+  
+  Closes #1269
 
-  .travis.yml: Fix Chrome and 32 bit builds (#423)
+- tidy-up: bump casts from int to long for large C99 types in printfs
   
-  File: .travis.yml
+  Cast large integer types to avoid dealing with printf masks for
+  `size_t` and other C99 types. Some of existing code used `int`
+  for this, bump them to `long`.
   
-  Notes:
-  * Fix Chrome installing by using Travis build in directive
-  * Update to use libgcrypt20-dev package to fix 32 bit builds based on comments found here:
-  https://launchpad.net/ubuntu/xenial/i386/libgcrypt11-dev
-
-- [Will Cosgrove brought this change]
+  Ref: afa6b865604019ab27ec033294edfe3ded9ae0c0 #1257
+  
+  Closes #1264
 
-  packet.c: improved parsing in packet_x11_open (#410)
+- build: enable missing OpenSSF-recommended warnings, with fixes
   
-  Use new API to parse data in packet_x11_open() for better bounds checking.
+  Ref:
+  https://best.openssf.org/Compiler-Hardening-Guides/Compiler-Options-Hardening-Guide-for-C-and-C++.html
+  (2023-11-29)
+  
+  Enable new warnings:
+  
+  - replace `-Wno-sign-conversion` with `-Wsign-conversion`.
+  
+    Fix them in example, tests and wincng. There remain about 360 of these
+    warnings in `src`. Add a TODO item for those and disable `-Werror` for
+    this particular warning.
+  
+  - enable `-Wformat=2` for clang (in both cmake and autotools).
+  
+  - enable `__attribute__((format))` for `_libssh2_debug()`,
+    `_libssh2_snprintf()` and in tests for `run_command()`.
+  
+    `LIBSSH2_PRINTF()` copied from `CURL_TEMP_PRINTF()` in curl.
+  
+  - enable `-Wimplicit-fallthrough`.
+  
+  - enable `-Wtrampolines`.
+  
+  Fix them:
+  
+  - src: replace obsolete fall-through-comments with
+    `__attribute__((fallthrough))`.
+  
+  - wincng: fix `-Wsign-conversion` warnings.
+  
+  - tests: fix `-Wsign-conversion` warnings.
+  
+  - example: fix `-Wsign-conversion` warnings.
+  
+  - src: fix `-Wformat` issues in trace calls.
+  
+    Also, where necessary fix `int` and `unsigned char` casts to
+    `unsigned int` and adjust printf format strings. These were not
+    causing compiler warnings.
+  
+    Cast large types to `long` to avoid dealing with printf masks for
+    `size_t` and other C99 types. Existing code often used `int` for this.
+    I'll update them to `long` in an upcoming commit.
+  
+  - tests: fix `-Wformat` warning.
+  
+  - silence `-Wformat-nonliteral` warnings.
+  
+  - mbedtls: silence `-Wsign-conversion`/`-Warith-conversion`
+    in external header.
+  
+  Closes #1257
 
-Will Cosgrove (12 Sep 2019)
-- [Michael Buckley brought this change]
+- packet: whitespace fix
+  
+  Tested via #1257
 
-  knownhost.c: Double the static buffer size when reading and writing known hosts (#409)
+- tidy-up: unsigned -> unsigned int
   
-  Notes:
-  We had a user who was being repeatedly prompted to accept a server key repeatedly. It turns out the base64-encoded key was larger than the static buffers allocated to read and write known hosts. I doubled the size of these buffers.
+  In the `interval` argument of public `libssh2_keepalive_config()`.
   
-  Credit:
-  Michael Buckley
+  Tested via #1257
 
-GitHub (4 Sep 2019)
-- [Will Cosgrove brought this change]
+- tests: sync port number type with the rest of codebase
+  
+  Tested via #1257
 
-  packet.c: improved packet parsing in packet_queue_listener (#404)
+- autotools: enable `-Wunused-macros` with gcc
   
-  * improved bounds checking in packet_queue_listener
+  It works with gcc without the libtool warnings seen with clang
+  on Windows in 96682bd5e14c20828e18bf10ed5b4b5c7543924a #1227.
   
-  file: packet.c
+  Sync usage of of this macro with CMake and
+  autotools + clang + non-Windows. Making it enabled everywhere except
+  autotools + clang + Windows due to the libtool stub issue.
   
-  notes:
-  improved parsing packet in packet_queue_listener
+  Follow-up to 7ecc309cd10454c54814b478c4f85d0041da6721 #1224
+  
+  Closes #1262
 
-- [Will Cosgrove brought this change]
+- TODO: disable or drop weak algos [ci skip]
+  
+  Closes #1261
 
-  packet.c: improve message parsing (#402)
+- example, tests: fix/silence `-Wformat-truncation=2` gcc warnings
   
-  * packet.c: improve parsing of packets
+  Then sync this warning option with curl.
   
-  file: packet.c
+  Seems like a false positive and/or couldn't figure how to fix it, so silence:
+  ```
+  example/ssh2.c:227:38: error: '%s' directive output may be truncated writing likely 1 or more bytes into a region of size 0 [-Werror=format-truncation=]
+    227 |             snprintf(fn1, fn1sz, "%s/%s", h, pubkey);
+        |                                      ^~
+  example/ssh2.c:227:34: note: assuming directive output of 1 byte
+    227 |             snprintf(fn1, fn1sz, "%s/%s", h, pubkey);
+        |                                  ^~~~~~~
+  example/ssh2.c:227:13: note: 'snprintf' output 3 or more bytes (assuming 4) into a destination of size 2
+    227 |             snprintf(fn1, fn1sz, "%s/%s", h, pubkey);
+        |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  example/ssh2.c:228:38: error: '%s' directive output may be truncated writing likely 1 or more bytes into a region of size 0 [-Werror=format-truncation=]
+    228 |             snprintf(fn2, fn2sz, "%s/%s", h, privkey);
+        |                                      ^~
+  example/ssh2.c:228:34: note: assuming directive output of 1 byte
+    228 |             snprintf(fn2, fn2sz, "%s/%s", h, privkey);
+        |                                  ^~~~~~~
+  example/ssh2.c:228:13: note: 'snprintf' output 3 or more bytes (assuming 4) into a destination of size 2
+    228 |             snprintf(fn2, fn2sz, "%s/%s", h, privkey);
+        |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/7055480458/job/19205970397#step:10:98
   
-  notes:
-  Use _libssh2_get_string API in SSH_MSG_DEBUG/SSH_MSG_DISCONNECT. Additional uint32 bounds check in SSH_MSG_GLOBAL_REQUEST.
-
-- [Will Cosgrove brought this change]
+  Fix:
+  ```
+  tests/openssh_fixture.c:116:38: error: ' 2>&1' directive output may be truncated writing 5 bytes into a region of size between 1 and 1024 [-Werror=format-truncation=]
+  tests/openssh_fixture.c:116:11: note: 'snprintf' output between 6 and 1029 bytes into a destination of size 1024
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/7055480458/job/19205969221#step:10:51
+  
+  Tested via #1257
 
-  misc.c: _libssh2_ntohu32 cast bit shifting (#401)
+- example: fix indentation follow-up
   
-  To quite overly aggressive analyzers.
+  Fix long line and fix more indentations.
   
-  Note, the builds pass, Travis is having some issues with Docker images.
+  Follow-up to 9e896e1b80911a53d6aabb322e034e6ca51b6898
 
-- [Will Cosgrove brought this change]
+- example: fix indentation
+  
+  Tested via #1257
 
-  kex.c: improve bounds checking in kex_agree_methods() (#399)
+- autotools: fix missed `-pedantic` and `-Wall` options for gcc
   
-  file: kex.c
+  Follow-up to 5996fefe2bad80cfba85b2569ce6ab6ef575142c #1223
   
-  notes:
-  use _libssh2_get_string instead of kex_string_pair which does additional checks
+  Tested via #1257
 
-Will Cosgrove (23 Aug 2019)
-- [Fabrice Fontaine brought this change]
+- ci: show compiler in cross/cygwin job names
+  
+  Tested via #1257
 
-  acinclude.m4: add mbedtls to LIBS (#371)
+- mbedtls: further improve disabling `-Wredundant-decls`
   
-  Notes:
-  This is useful for static builds so that the Libs.private field in
-  libssh2.pc contains correct info for the benefit of pkg-config users.
-  Static link with libssh2 requires this information.
+  Move warning option suppression to `src/mbedtls.h` to surround the actual
+  external header #includes that need it.
   
-  Signed-off-by: Baruch Siach <baruch@tkos.co.il>
-  [Retrieved from:
-  https://git.buildroot.net/buildroot/tree/package/libssh2/0002-acinclude.m4-add-mbedtls-to-LIBS.patch]
-  Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+  Follow-up to ecec68a2c13a9c63fe8c2dc457ae785a513e157c #1226
+  Follow-up to 7ecc309cd10454c54814b478c4f85d0041da6721 #1224
   
-  Credit:
-  Fabrice Fontaine
+  Tested via #1257
 
-- [jethrogb brought this change]
+GitHub (1 Dec 2023)
+- [ren mingshuai brought this change]
 
-  Generate debug info when building with MSVC (#178)
+  example: replace remaining libssh2_scp_recv with libssh2_scp_recv2 in output messages (#1258)
   
-  files: CMakeLists.txt
-  
-  notes: Generate debug info when building with MSVC
+  libssh2_scp_recv is deprecated and has been replaced by libssh2_scp_recv2
+  in prior commit.
   
-  credit:
-  jethrogb
-
-- [Panos brought this change]
+  Follow-up to 6c84a426beb494980579e5c1d244ea54d3fc1a3f
 
-  Add agent forwarding implementation (#219)
+Viktor Szakats (27 Nov 2023)
+- openssl: use OpenSSL 3 HMAC API, add `no-deprecated` CI job
   
-  files: channel.c, test_agent_forward_succeeds.c, libssh2_priv.h, libssh2.h, ssh2_agent_forwarding.c
+  - use OpenSSL 3 API when available for HMAC.
+    This fixes building with OpenSSL 3 `no-deprecated` builds.
   
-  notes:
-  * Adding SSH agent forwarding.
-  * Fix agent forwarding message, updated example.
-  Added integration test code and cmake target. Added example to cmake list.
+  - ensure we support pure OpenSSL 3 API by adding a CI job using
+    OpenSSL 3 custom-built with `no-deprecated`.
   
-  credit:
-  pkittenis
+  Follow-up to b0ab005fe79260e6e9fe08f8d73b58dd4856943d #1207
+  
+  Fixes #1235
+  Closes #1243
 
-GitHub (2 Aug 2019)
-- [Will Cosgrove brought this change]
+- ci: restore lost comment for FreeBSD [ci skip]
+  
+  Follow-up to eee4e8055ab375c9f9061d4feb39086737f41a9c
 
-  Update EditorConfig
+- ci: add OpenBSD (v7.4) job + fix build error in example
   
-  Added max_line_length = 80
+  - Use CMake, LibreSSL and clang from the base install.
+  
+  - This uncovered a build error in `example/subsystem_netconf.c`, caused
+    by using the `%n` printf mask. This is a security risk and some
+    systems (notably OpenBSD) disable this feature.
+  
+    Fix it by applying this patch from OpenBSD ports (from 2021-09-11):
+    https://cvsweb.openbsd.org/ports/security/libssh2/patches/patch-example_subsystem_netconf_c?rev=1.1&content-type=text/x-cvsweb-markup
+    https://github.com/openbsd/ports/commit/2c5b2f3e94381914a3e8ade960ce8c997ca9d6d7
+    "The old code is also broken, as it passes a pointer to a variable
+    of a different size (on LP64).  There is no check for truncation,
+    but buf[] is 1MB in size."
+    Patch-by: naddy
+  
+    ```
+    /home/runner/work/libssh2/libssh2/example/subsystem_netconf.c:252:17: error: '%n' format specifier support is deactivated and will call abort(3) [-Werror]
+          "]]>]]>\n%n", (int *)&len);
+                   ~^
+    /home/runner/work/libssh2/libssh2/example/subsystem_netconf.c:270:17: error: '%n' format specifier support is deactivated and will call abort(3) [-Werror]
+          "]]>]]>\n%n", (int *)&len);
+                   ~^
+    2 errors generated.
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/6991449778/job/19022024280#step:3:420
+  
+  Also made tests with arm64, but it takes consistently almost 14m to
+  finish the job, vs. 2-3m for the native amd64:
+  https://github.com/libssh2/libssh2/actions/runs/6991648984/job/19022440525
+  https://github.com/libssh2/libssh2/actions/runs/6991551220/job/19022233651
+  
+  Cherry-picked from #1250
+  Closes #1250
+
+- ci: add NetBSD (v9.3) job
+  
+  Use CMake, OpenSSL (v1.1) and clang from the base install.
+  
+  Cherry-picked from #1250
+
+- ci: update and speed up FreeBSD job
+  
+  - switch to an alternate GitHub action. This one seems (more) actively
+    maintained, and runs faster:
+    https://github.com/cross-platform-actions/action
+  
+  - use clang instead of gcc. clang is already present in the base
+    install, saving install time and bandwidth.
+  
+  - stop installing `openssl-quictls` and use the OpenSSL (v1.1) from
+    the base system.
+    (I'm suspecting that quictls before this patch wasn't detected by
+    the build.)
+    https://wiki.freebsd.org/OpenSSL
+  
+  Cherry-picked from #1250
+
+- stop using leading underscores in macro names
+  
+  Underscored macros are reserved for the compiler / standard lib / etc.
+  Stop using them in user code.
+  
+  We used them as header guards in `src` and in `__FILESIZE` in `example`.
+  
+  Closes #1248
+
+- ci: use absolute path in `CMAKE_INSTALL_PREFIX`
+  
+  To make the installed locations unambiguous in the build logs.
+  
+  Closes #1247
+
+- openssl: make a function static, add `#ifdef` comments
+  
+  Follow-up to 03092292597ac601c3f9f0c267ecb145dda75e4e #248
+  where the function was added.
+  
+  Also add comments to make `#ifdef` branches easier to follow in
+  `openssl.h`.
+  
+  Closes #1246
+
+- ci: boost mbedTLS build speed
+  
+  Build times down to 4 seconds (from 18-20).
+  
+  Closes #1245
+
+- openssl: fix DSA code to use OpenSSL 3 API
+  
+  - fix missing `DSA` type when building for OpenSSL 3 `no-deprecated`.
+  - fix fallouts after fixing the above by switching away from `DSA`
+    with OpenSSL 3.
+  
+  Follow-up to b0ab005fe79260e6e9fe08f8d73b58dd4856943d #1207
+  
+  Closes #1244
+
+- openssl: formatting (delete empty lines) [ci skip]
+
+- tests: fall back to `$LOGNAME` for username
+  
+  If the `$USER` variable is empty, fall back to using `$LOGNAME` to
+  retrieve the logged-in username.
+  
+  In POSIX, `$LOGNAME` is a mandatory variable, while `$USER` isn't, and
+  on some systems it may not be set. Without this value, tests were unable
+  to provide the correct username when logging into the SSH server running
+  under the active user's session.
+  
+  Reported-by: Nicolas Mora
+  Suggested-by: Nicolas Mora
+  Ref: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1056348
+  Fixes #1240
+  Closes #1241
+
+- libssh2.h: use `_WIN32` for Windows detection instead of rolling our own
+  
+  Sync up `libssh2.h` Windows detection with the libssh2 source code.
+  
+  `libssh2.h` was using `WIN32` and `LIBSSH2_WIN32` for Windows detection,
+  next to the official `_WIN32`. After this patch it only uses `_WIN32`
+  for this. Also, make it stop defining `LIBSSH2_WIN32`.
+  
+  There is a slight chance these break compatibility with Windows
+  compilers that fail to define `_WIN32`. I'm not aware of any obsolete
+  or modern compiler affected, but in case there is one, one possible
+  solution is to define this macro manually.
+  
+  Closes #1238
+
+- openssl: fix `EC_KEY` reference with OpenSSL 3 `no-deprecated` build
+  
+  Fixes:
+  ```
+  src/openssl.c:650:5: error: use of undeclared identifier 'EC_KEY'
+      EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
+      ^
+  src/openssl.c:650:13: error: use of undeclared identifier 'ec_key'
+      EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
+              ^
+  src/openssl.c:650:22: error: implicit declaration of function 'EC_KEY_new_by_curve_name' is invalid in C99 [-Werror,-Wimplicit-function-declaration]
+      EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
+                       ^
+  src/openssl.c:650:22: note: did you mean 'EC_GROUP_new_by_curve_name'?
+  ./quictls/_a64-mac-sys/usr/include/openssl/ec.h:483:11: note: 'EC_GROUP_new_by_curve_name' declared here
+  EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
+            ^
+  In file included from ./_a64-mac-sys-bld/src/CMakeFiles/libssh2_static.dir/Unity/unity_0_c.c:19:
+  In file included from src/crypto.c:10:
+  src/openssl.c:652:8: error: use of undeclared identifier 'ec_key'
+      if(ec_key) {
+         ^
+  ```
+  Ref: https://github.com/curl/curl-for-win/actions/runs/6950001225/job/18909297867#step:3:4341
+  
+  Follow-up to b0ab005fe79260e6e9fe08f8d73b58dd4856943d #1207
+  
+  Bug #1235
+  Closes #1236
+
+- openssl: formatting
+  
+  Sync up these lines with the other two similar occurrences in the code.
+  
+  Cherry-picked from #1236
+
+GitHub (21 Nov 2023)
+- [Michael Buckley brought this change]
+
+  openssl: use non-deprecated APIs with OpenSSL 3.x (#1207)
+  
+  Assisted-by: Viktor Szakats
+
+Viktor Szakats (21 Nov 2023)
+- ci: add BoringSSL job (cmake, gcc, amd64)
+  
+  Closes #1233
+
+- autotools: fix dotless gcc and Apple clang version detections
+  
+  - fix parsing dotless (major-only) gcc versions.
+    Follow-up to 00a3b88c51cdb407fbbb347a2e38c5c7d89875ad #1187
+  
+  - sync gcc detection variable names with curl.
+  
+  - fix Apple clang version detection for releases between
+    'Apple LLVM version 7.3.0' and 'Apple LLVM version 10.0.1' where the
+    version was under-detected as 3.7 llvm/clang equivalent.
+  
+  - fix Apple clang version detection for 'Apple clang version 11.0.0'
+    and newer where the Apple clang version was detected, instead of its
+    llvm/clang equivalent.
+  
+  - revert to show `clang` instead of `Apple clang`, because we follow it
+    with an llvm/clang version number. (Apple-ness still visible in raw
+    version.)
+  
+  Used this collection for Apple clang / llvm/clang translation and test
+  inputs: https://gist.github.com/yamaya/2924292
+  
+  Closes #1232
+
+- acinclude.m4: revert accidental edit [ci skip]
+  
+  Follow-up to 8c320a93a48775b74f40415e46f84bf68b4d5ae8
+
+- autotools: show more clang/gcc version details
+  
+  Also:
+  - show if we detected Apple clang.
+  - delete duplicate version detection for clang.
+  
+  Closes #1230
+
+- acinclude.m4: re-sync with curl [ci skip]
+
+- autotools: avoid warnings in libtool stub code
+  
+  Seen on Windows with clang64, in libtool-generated stub code for
+  examples and tests.
+  
+  The error didn't break the CI job for some reason.
+  
+  msys2 (autotools, clang64, clang-x86_64:
+  ```
+  [...]
+  2023-11-17T20:14:17.8639574Z ./.libs/lt-test_read.c:91:10: error: macro is not used [-Werror,-Wunused-macros]
+  [...]
+  2023-11-17T20:14:39.8729255Z ./.libs/lt-sftp_write_nonblock.c:91:10: error: macro is not used [-Werror,-Wunused-macros]
+  [...]
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/6908585056/job/18798193405?pr=1226#step:8:474
+  
+  Follow-up to 7ecc309cd10454c54814b478c4f85d0041da6721 #1224
+  
+  Closes #1227
+
+- mbedtls: improve disabling `-Wredundant-decls`
+  
+  Disable these warnings specifically for the mbedTLS public headers
+  and leave it on for the the rest of the code. This also fixes this
+  issue for autotools. Previous solution was globally disabling this
+  warning for the whole code when using mbedTLS and only with CMake.
+  
+  Follow-up to 7ecc309cd10454c54814b478c4f85d0041da6721 #1224
+  
+  Closes #1226
+
+- cmake: rename picky warnings script
+  
+  To match the camel-case style used in other CMake scripts and also
+  to match the name used in curl.
+  
+  Closes #1225
+
+- build: enable more compiler warnings and fix them
+  
+  Enable more picky compiler warnings. I've found these options in the
+  nghttp3 project when implementing the CMake quick picky warning
+  functionality for it.
+  
+  Fix issues found along the way:
+  
+  - wincng, mbedtls: delete duplicate function declarations.
+    Most of this was due to re-#defining crypto functions to
+    crypto-backend specific implementations These redefines also remapped
+    the declarations in `crypto.h`, making the backend-specific
+    declarations duplicates.
+    This patch deletes the backend-specific declarations.
+  
+  - wincng mapped two crypto functions to the same local function.
+    Also causing double declarations.
+    Fix this by adding two disctinct wrappers and moving
+    the common function to a static one.
+  
+  - delete unreachable `break;` statements.
+  
+  - kex: disable macros when unused.
+  
+  - agent: disable unused constants.
+  
+  - mbedtls: disable double declaration warnings because public mbedTLS
+    headers trigger it. (with function `psa_set_key_domain_parameters`)
+  
+  - crypto.h: formatting.
+  
+  Ref: https://github.com/ngtcp2/nghttp3/blob/a70edb08e954d690e8fb2c1df999b5a056f8bf9f/cmake/PickyWarningsC.cmake
+  
+  Closes #1224
+
+- autotools: sync warning enabler code with curl
+  
+  Tiny changes and minor updates to bring this code closer
+  to curl's `m4/curl-compilers.m4`.
+  
+  Closes #1223
+
+- acinclude.m4: fix indentation [ci skip]
+  
+  Also match indentation of curl's `m4/curl-compilers.m4` for
+  easier syncing.
+
+- autotool: rename variable
+  
+  `WARN` -> `tmp_CFLAGS`
+  
+  To match curl and make syncing this code easier.
+  
+  Ref: https://github.com/curl/curl/blob/d1820768cce0e797d1f072343868ce1902170e93/m4/curl-compilers.m4#L479
+  
+  Closes #1222
+
+- autotools: picky warning options tidy-up
+  
+  - sync clang warning version limits with CMake.
+  - make `WARN=` vs. `CURL_ADD_COMPILER_WARNINGS()` consistent with curl
+    and between clang and gcc (`WARN=` is for `no-` options in general).
+  
+  Closes #1221
+
+- build: picky warning updates
+  
+  - cmake, autotools: sync picky gcc warnings with curl.
+  - cmake, autotools: add `-Wold-style-definition` for clang too.
+  - cmake, autotools: add comment for `-Wformat-truncation=1`.
+  - cmake: more precise version info for old clang options.
+  
+  Closes #1219
+
+- ci: fixup FreeBSD version, bump mbedtls
+  
+  We haven't been using the FreeBSD version. Also it turns out,
+  the single version supported is 13.2 at the moment:
+    https://github.com/vmactions/freebsd-vm/tree/main/conf
+  
+  Stop trying to set the version and instead rely on the action
+  providing the latest supported one automatically.
+  
+  Follow-up to a7d2a573be26238cc2b55e5ff6649bbe620cb8d9
+  
+  Also:
+  - add more details to the FreeBSD job description.
+  - bump mbedtls version while here.
+  
+  Closes #1217
+
+- cmake: fix multiple include of libssh2 package
+  
+  Also extend our integration test double inclusion. It will still not
+  catch this case, because that requires
+  `cmake_minimum_required(VERSION 3.18)` or higher.
+  
+  Fixes:
+  ```
+  CMake Error at .../lib/cmake/libssh2/libssh2-config.cmake:8 (add_library):
+    add_library cannot create ALIAS target "libssh2::libssh2" because another
+    target with the same name already exists.
+  Call Stack (most recent call first):
+    CMakeLists.txt:24 (find_package)
+  
+  CMake Error at .../lib/cmake/libssh2/libssh2-config.cmake:13 (add_library):
+    add_library cannot create ALIAS target "Libssh2::libssh2" because another
+    target with the same name already exists.
+  Call Stack (most recent call first):
+    CMakeLists.txt:24 (find_package)
+  ```
+  
+  Test to reproduce:
+  ```cmake
+  cmake_minimum_required(VERSION 3.18)  # must be 3.18 or higher
+  
+  project(test)
+  
+  find_package(libssh2 CONFIG)
+  find_package(libssh2 CONFIG)  # fails
+  
+  add_executable(test main.c)
+  target_link_libraries(test libssh2::libssh2)
+  ```
+  
+  Ref: https://cmake.org/cmake/help/latest/release/3.18.html#other-changes
+  Ref: https://cmake.org/cmake/help/v3.18/policy/CMP0107.html
+  
+  Assisted-by: Kai Pastor
+  Assisted-by: Harry Mallon
+  Ref: https://github.com/curl/curl/pull/11913
+  
+  Closes #1216
+
+- ci: add FreeBSD 13.2 job
+  
+  It runs over Linux via qemu. First two runs were (very) slow, then it
+  became (much) more performant at just 2x slower than a native Linux
+  build. Then got slow again, then fast again. Still seems acceptable
+  for the value this adds.
+  
+  The build uses autotools and quictls.
+  
+  Successful builds:
+  1. https://github.com/libssh2/libssh2/actions/runs/6802676786/job/18496286419 (13m59s, -j3)
+  2. https://github.com/libssh2/libssh2/actions/runs/6802976375/job/18497243225 (11m5s, -j2)
+  3. https://github.com/libssh2/libssh2/actions/runs/6803142201/job/18497785049 (3m6s, -j1)
+  4. https://github.com/libssh2/libssh2/actions/runs/6803194839/job/18497962766 (3m10s, -j2)
+  5. https://github.com/libssh2/libssh2/actions/runs/6803267201/job/18498208501 (3m13s)
+  6. https://github.com/libssh2/libssh2/actions/runs/6803510333/job/18498993698 (15m25s)
+  7. https://github.com/libssh2/libssh2/actions/runs/6813602863/job/18528571057 (3m13s)
+  
+  Similar solution exists for Solaris (over macOS via VirtualBox), but it
+  hangs forever at `Waiting for text: solaris console login`:
+  https://github.com/libssh2/libssh2/actions/runs/6802388128/job/18495391869#step:4:185
+  
+  Idea taken from LibreSSL.
+  
+  FIXME: Unrelated, the `distcheck` job became flaky in recent days:
+  https://github.com/libssh2/libssh2/actions/runs/6802976375/job/18497256437#step:10:536
+  ```
+  FAIL: test_auth_pubkey_ok_rsa_aes256gcm
+  ```
+  https://github.com/libssh2/libssh2/actions/runs/6813602863/job/18528588933#step:10:533
+  ```
+  FAIL: test_read
+  ```
+  
+  Closes #1215
+
+- reuse: fix duplicate copyright warning
+  
+  ```
+  PendingDeprecationWarning:
+  Copyright and licensing information for 'tests/openssh_server/Dockerfile'
+  has been found in both 'tests/openssh_server/Dockerfile' and in the DEP5
+  file located at '.reuse/dep5'. The information for these two sources has
+  been aggregated. In the future this behaviour will change, and you will
+  need to explicitly enable aggregation. [...]
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/6789274955/job/18456085964#step:4:4
+
+- Makefile.mk: delete Windows-focused raw GNU Make build
+  
+  We recommend using CMake instead. Especially in unity mode, it's faster
+  and probably more familiar for most. It's also easily portable.
+  
+  (`Makefile.mk` was also portable, but in practice only usable for
+  Windows. Other platforms required a manual config header.)
+  
+  Also:
+  - migrate `LIBSSH2_NO_*` option CI tests to CMake.
+  - make MSYS2 CMake builds verbose to show compilation options.
+  
+  Closes #1204
+
+- tidy-up: around `stdint.h`
+  
+  - os400: delete unused `HAVE_STDINT_H`.
+  
+  - fuzz: delete redundant `stdint.h` use.
+    `inttypes.h` is already included via `testinput.h`.
+  
+  - docs/TODO: adjust type in planned function.
+  
+  Closes #1212
+
+- cmake: show crypto backend in feature summary
+  
+  This was visible as an enabled package before this patch, but it missed
+  to show WinCNG.
+  
+  Closes #1211
+
+- man: fix double spaces and dash escaping
+  
+  - `-  ` -> `- `
+  - `.  ` -> `. `
+  - `\- ` -> `- `
+  - `-1` -> `\-1`
+  - fold long lines along the way
+  
+  This makes the minus sign come out as a Unicode minus sign
+  (0x2212), and title separator dashes as Unicode hyphen (0x2010),
+  with `groff -Tutf8` v1.23.0.
+  
+  Ref: https://lwn.net/Articles/947941/
+  
+  Closes #1210
+
+- src: fix gcc 13 `-Wconversion` warning on Darwin
+  
+  ```
+  src/session.c: In function 'libssh2_poll':
+  src/session.c:1776:22: warning: conversion from 'long int' to '__darwin_suseconds_t' {aka 'int'} may change value [-Wconversion]
+   1776 |         tv.tv_usec = (timeout_remaining % 1000) * 1000;
+        |                      ^
+  ```
+  Ref: https://github.com/curl/curl-for-win/actions/runs/6711735060/job/18239768548#step:3:4368
+  
+  Follow-up to 08354e0abbe86d4cc5088d210d53531be6d8981a
+  
+  Closes #1209
+
+- openssl: silence `-Wunused-value` warnings
+  
+  Seen with gcc 12.
+  
+  Manual: https://www.openssl.org/docs/man3.1/man3/BIO_reset.html
+  
+  ```
+  ./quictls/linux-a64-musl/usr/include/openssl/bio.h:555:34: warning: value computed is not used [-Wunused-value]
+    555 | # define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
+        |                                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ./libssh2/src/openssl.c:3518:5: note: in expansion of macro 'BIO_reset'
+  ./libssh2/src/openssl.c:3884:5: note: in expansion of macro 'BIO_reset'
+  ./libssh2/src/openssl.c:3995:5: note: in expansion of macro 'BIO_reset'
+  ```
+  Ref: https://github.com/curl/curl-for-win/actions/runs/6696392318/job/18194032712#step:3:5060
+  
+  Closes #1205
+
+- Makefile.am: fix `cp` to preserve attributes and timestamp
+
+- cmake: simplify showing CMake version
+  
+  Move it to `CMakeLists.txt`. Drop `cmake --version` commands.
+  
+  Credit to the `zlib-ng` project for the idea:
+  https://github.com/zlib-ng/zlib-ng/blob/61e181c8ae93dbf56040336179c9954078bd1399/CMakeLists.txt#L7
+  
+  Closes #1203
+
+- ci: mbedtls 3.5.0
+  
+  v3.5.0 needs extra compiler option for i386 to avoid:
+  ```
+  #error "Must use `-mpclmul -msse2 -maes` for MBEDTLS_AESNI_C"
+  ```
+  
+  Closes #1202
+
+- tests: show cmake version used in integration tests
+  
+  Closes #1201
+
+- readme.vms: fix typo [ci skip]
+  
+  Detected by codespell 2.2.6
+
+- appveyor: YAML/PowerShell formatting, shorten variable name
+  
+  - use single-quotes in yaml and PowerShell.
+  
+  - shorten a variable name.
+  
+  - use indentation 2 for scripts.
+  
+  - use C else-style in PowerShell.
+  
+  Closes #1200
+
+- ci: update actions, use shallow clones with appveyor
+  
+  - update GitHub Actions to their latest versions.
+  
+  - use shallow git clones in AppVeyor CI to save data over the wire.
+  
+  Closes #1199
+
+- appveyor: move to pure PowerShell
+  
+  - replace batch commands with PowerShell.
+  
+  - merge separate command entries into single PowerShell blocks.
+  
+  Closes #1197
+
+- windows: use built-in `_WIN32` macro to detect Windows
+  
+  Instead of `WIN32`.
+  
+  The compiler defines `_WIN32`. Windows SDK headers or build env defines
+  `WIN32`, or we have to take care of it. The agreement seems to be that
+  `_WIN32` is the preferred practice here.
+  
+  Minor downside is that CMake uses `WIN32` and we also adopted it in
+  `Makefile.mk`.
+  
+  In public libssh2 headers we stick with accepting either `_WIN32` or
+  `WIN32` and define our own namespaced `LIBSSH2_WIN32` based on them.
+  
+  grepping for `WIN32` remains useful to detect Windows-specific code.
+  
+  Closes #1195
+
+- cmake: cleanup mbedTLS version detection more
+  
+  - lowercase, underscored local variables.
+  - fix `find_library()` to use the multiple names passed.
+  - rely more on `find_package_handle_standard_args()`.
+    Logic based on our `Findwolfssl.cmake`.
+  - delete ignored/unused `MBEDTLS_LIBRARY_DIR`.
+  - revert CI configuration to use `MBEDCRTYPO_LIBRARY`.
+  - clarify inputs/outputs in comment header.
+  - use variable for regex.
+  - formatting.
+  
+  Follow-up to 41594675072c578294674230d4cf5f47fa828778 #1192
+  
+  Closes #1196
+
+- cmake: delete duplicate `include()`
+
+- cmake: improve/fix mbedTLS detection
+  
+  - libssh2 needs the crypto lib only, stop dealing with the rest.
+  
+  - simplify logic.
+  
+  - drop hard-wired toolchain specific options that broke with e.g. MSVC.
+  
+    Reported by: AR Visions
+    Fixes #1191
+  
+  - add mbedTLS version detection for recent releases.
+  
+  - merge custom detection results display into a single line.
+  
+  - shorten mbedTLS configuration in macOS CI job.
+  
+  Used the curl mbedTLS detection logic for ideas:
+  https://github.com/curl/curl/blob/a8c773845f4fdbfb09b08a6ec4b656c812568995/CMake/FindMbedTLS.cmake
+  
+  Closes #1192
+
+GitHub (24 Sep 2023)
+- [concussious brought this change]
+
+  libssh2_session_get_blocking.3: Add description (#1185)
+
+Viktor Szakats (21 Sep 2023)
+- autotools: fix selecting wincng in cross-builds (and more)
+  
+  - Fix explicitly selecting WinCNG in autotools cross-builds by moving
+    `windows.h` header check before the WinCNG availability check.
+    Follow-up to d43b8d9b0b9cd62668459fe5d582ed83aabf77e7
+  
+    Reported-by: Jack L
+    Fixes #1186
+  
+  - Add Linux -> mingw-w64 cross-builds for autotools and CMake. This
+    doesn't detect #1186, because that happened when explicitly specifying
+    WinCNG via `--with-crypto=wincng`, but not when falling back to WinCNG
+    by default.
+  
+  - autotools: fix to strip suffix from gcc version
+  
+    Before this patch we expected `n.n` `-dumpversion` output, but Ubuntu
+    may return `n-win32` (also with `-dumpfullversion`). Causing these
+    errors and failing to enable picky warnings:
+    ```
+    ../configure: line 23845: test: : integer expression expected
+    ```
+    Ref: https://github.com/libssh2/libssh2/actions/runs/6263453828/job/17007893718#step:5:143
+  
+    Fix that by stripping any dash-suffix.
+  
+    gcc version detection is still half broken because we translate '10'
+    to '10.10' because `cut -d. -f2` returns the first word if the
+    delimiter missing.
+  
+    More possible `-dumpversion` output: `10-posix`, `10-win32`,
+    `9.3-posix`, `9.3-win32`, `6`, `9.3.0`, `11`, `11.2`, `11.2.0`
+    Ref: https://github.com/mamedev/mame/pull/9767
+  
+  Closes #1187
+
+GitHub (28 Aug 2023)
+- [Michael Buckley brought this change]
+
+  Properly bounds check packet_authagent_open() (#1179)
+  
+  * Properly bounds check packet_authagent_open
+  * packet.c: use strlen instead of sizeof for strings
+  * Make LIBSSH_CHANNEL's channel_type_len a size_t
+  * packet_authagent_open: use size_t for offset
+  
+  Credit:
+  Michael Buckley, signed off by Will Cosgrove
+
+Viktor Szakats (28 Aug 2023)
+- os400qc3: move FIXME comment [ci skip]
+  
+  Follow-up to eb9f9de2c19ec67d12a444cce34bdd059fd26ddc
+
+- md5: allow disabling old-style encrypted private keys at build-time
+  
+  Before this patch, this happened at runtime when using an old (pre-3.0),
+  FIPS-enabled OpenSSL backend.
+  
+  This patch makes it possible to disable this via the build-time option
+  `LIBSSH2_NO_MD5_PEM`.
+  
+  Also:
+  - make sure to exclude all MD5 internal APIs when both the above and
+    `LIBSSH2_NO_MD5` are enabled.
+  - fix tests to support build with`LIBSSH2_NO_MD5`, `LIBSSH2_NO_MD5_PEM`
+    and `LIBSSH2_NO_3DES`.
+  - add FIXME to apply this change to `os400qc3.*`.
+  
+  Old-style encrypted private keys require MD5 and they look like this:
+  ```
+  -----BEGIN RSA PRIVATE KEY-----
+   Proc-Type: 4,ENCRYPTED
+   DEK-Info: AES-128-CBC,<MD5-hex>
+  
+   <base64>
+   -----END RSA PRIVATE KEY-----
+  ```
+  
+  E.g.: `tests/key_rsa_encrypted`
+  
+  Ref: https://github.com/libssh2/www/issues/20
+  Closes #1181
+
+- cmake: tidy-up `foreach()` syntax
+  
+  Use `IN LISTS` and `IN ITEMS`. This appears to be the preferred way
+  within CMake's own source code and possibly improves readability.
+  
+  Fixup a side-effect of `IN LISTS`, where it retains empty values at
+  the end of the list, as opposed to the syntax used before, which
+  dropped it. In our case this happened with lines read from a text
+  file via `file(READ)`.
+  
+  https://cmake.org/cmake/help/v3.7/command/foreach.html
+  
+  Closes #1180
+
+- ci: replace `mv` + `chmod` with `install` in `Dockerfile`
+  
+  Cherry-picked from #1175
+  Closes #1175
+
+- ci: set file mode early in `appveyor_docker.yml`
+  
+  Also:
+  - replace tab with spaces in generated config file
+  - formatting
+  
+  Cherry-picked from #1175
+
+- ci: add spellcheck (codespell)
+  
+  Also rename a variable in `src/os400qc3.c` to avoid a false positive.
+  
+  Cherry-picked from #1175
+
+- cmake: also test for `libssh2_VERSION`
+  
+  Cherry-picked from #1175
+
+- cmake: show cmake versions in ci
+  
+  Cherry-picked from #1175
+
+- tests: formatting and tidy-ups
+  
+  - Dockerfile: use standard sep with `sed`
+  - Dockerfile: use single quotes in shell command
+  - appveyor.yml: use long-form option with `choco`
+  - tests/cmake: add language to test project
+  - reuse.yml: fix indentation
+    ```
+    $ yamllint reuse.yml
+    reuse.yml
+      [...]
+      11:5      error    wrong indentation: expected 6 but found 4  (indentation)
+      15:5      error    wrong indentation: expected 6 but found 4  (indentation)
+      [...]
+      27:5      error    wrong indentation: expected 6 but found 4  (indentation)
+    ```
+  
+  Cherry-picked from #1175
+
+- openssl.c: whitespace fixes
+  
+  Cherry-picked from #1175
+
+- checksrc: fix spelling in comment [ci skip]
+
+- cmake: quote more strings
+  
+  Follow-up to 3fa5282d6284efba62dc591697e6a687152bdcb1
+  
+  Closes #1173
+
+- drop `www.` from `www.libssh2.org`
+  
+  <https://www.libssh2.org/*> is now a 301 permanent redirect to
+  <https://libssh2.org/*>.
+  
+  Update all references to point directly to the new destination.
+  
+  Ref: https://github.com/libssh2/www/commit/ccf4a7de7f702a8ee17e2c697bcbef47fcf485ed
+  
+  Closes #1172
+
+- cmake: add `ExternalProject` integration test
+  
+  - via `ExternalProject_Add()`:
+    https://cmake.org/cmake/help/latest/module/ExternalProject.html
+    (as documented in `docs/INSTALL_CMAKE.md`)
+  
+  - also make `FetchContent` fetch from local repo instead of live master.
+  
+  Closes #1171
+
+- cmake: add integration tests
+  
+  Add a small project to test dependent/downstream CMake build using
+  libssh2. Also added to the GHA CI, and you can also run it locally with
+  `tests/cmake/test.sh`.
+  
+  Test three methods of integrating libssh2 into a project:
+  - via `find_package()`:
+    https://cmake.org/cmake/help/latest/command/find_package.html
+  - via `add_subdirectory()`:
+    https://cmake.org/cmake/help/latest/command/add_subdirectory.html
+  - via `FetchContent`:
+    https://cmake.org/cmake/help/latest/module/FetchContent.html
+  
+  Closes #1170
+
+- cmake: (re-)add aliases for `add_subdirectory()` builds
+  
+  Add internal libssh2 library aliases to make these available for
+  downstream/dependent projects building libssh2 via `add_subdirectory()`:
+  
+  - `libssh2:libssh2_static`
+  - `libssh2:libssh2_shared`
+  - `libssh2:libssh2` (shared, or static when not building shared)
+  - `libssh2` (shared, or static when not building shared)
+  
+  Of these, `libssh2` was present in v1.10.0 and earlier releases, but
+  missing from v1.11.0.
+  
+  Closes #1169
+
+- cmake: delete empty line [ci skip]
+  
+  Follow-up to 3fa5282d6284efba62dc591697e6a687152bdcb1
+
+- cmake: reflect minimum version in docs [ci skip]
+  
+  Follow-up to 9cd18f4578baa41dfca197f60557063cad12cd59
+
+- cmake: style tidy up
+  
+  - quote text literals to improve readability.
+    (exceptions: `FILES` items, `add_subdirectory` names, `find_package`
+    names, literal target names, version numbers, 0/1, built-in CMake
+    values and CMake keywords, list items in `cmake/max_warnings.cmake`)
+  - quote standalone variables that could break syntax on empty values.
+  - replace `libssh2_SOURCE_DIR` with `PROJECT_SOURCE_DIR`.
+  - add missing mode to `message()` call.
+  - `TRUE`/`FALSE` → `ON`/`OFF`.
+  - add missing default value `OFF` to `option()` for clarity.
+  - unfold some lines.
+  - `INSTALL_CMAKE.md` fixes and updates. Show defaults.
+  
+  Closes #1166
+
+- wincng: prefer `ULONG`/`DWORD` over `unsigned long`
+  
+  To match with the types used by the `Crypt*()` (uses `DWORD`) and
+  `BCrypt*()` (uses `ULONG`) Windows APIs.
+  
+  This patch doesn't change data width or signedness.
+  
+  Closes #1165
+
+- wincng: tidy-ups
+  
+  - make `_libssh2_wincng_key_sha_verify` static.
+  
+  - prefer `unsigned long` over `size_t` in two static functions.
+  
+  - prefer `ULONG` over `DWORD` to match `BCryptImportKeyPair()`
+    and `BCryptGenerateKeyPair()`.
+  
+  - add a newline.
+  
+  Closes #1164
+
+- ci: add MSYS builds (autotools and cmake)
+  
+  Use existing MSYS2 section and extend it with builds for the MSYS
+  environment with both autotools and cmake.
+  
+  MSYS builds resemble Cygwin ones: The env is Unixy, where Windows
+  headers are all available but we don't use them.
+  
+  Also:
+  
+  - extend existing autotools logic for Cygwin to skip detecting
+    `windows.h` for MSYS targets too.
+  
+  - require `windows.h` for the WinCNG backend in autotools. Before this
+    patch, autotools allowed selecting WinCNG on the Cygwin and MSYS
+    platforms, but the builds then fell apart due to the resulting mixed
+    Unixy + Windowsy environment. The general expectation for Cygwin/MSYS
+    builds is not to use the Windows API directly in them.
+  
+  - stop manually selecting the `MSYS Makefiles` CMake generator for
+    MSYS2-based GHA CI builds. mingw-w64 builds work fine without it, but
+    it broke MSYS build which use `Unix Makefiles`. Deleting this setting
+    fixes all build flavours.
+  
+  Closes #1162
+
+- ci: cygwin job tidy-ups
+  
+  `CMAKE_C_COMPILER=gcc` not necessary, delete it.
+  
+  Follow-up to f1e96e733fefb495bc31b07f5c2a5845ff877c9c
+  
+  Cherry-picked from #1163
+  Closes #1163
+
+- ci: add Cygwin builds (autotools and cmake)
+  
+  To avoid builds picking up non-Cygwin components coming by default with
+  the CI machine, I used the solution recommended by Cygwin [1] and set
+  `PATH` manually. To avoid repeating this for each step, I merged steps
+  into a single one. Let us know if there is a more elegant way.
+  
+  Cygwin's Github Action uses cleartext HTTP. We upgrade this to HTTPS.
+  
+  autotools build seemed to take slightly longer than other jobs. To save
+  turnaround time I disabled building tests.
+  
+  Cygwin package search: https://cygwin.com/cgi-bin2/package-grep.cgi
+  
+  [1] https://github.com/cygwin/cygwin-install-action/tree/v4#path
+  
+  Closes #1161
+
+- cmake: add `LIB_NAME` variable
+  
+  It holds the name `libssh2`. Mainly to document its uses, and also
+  syncing up with the same variable in libcurl.
+  
+  Closes #1159
+
+- cmake: add one missed `PROJECT_NAME` variable
+  
+  Follow-up to 72fd25958a7dc6f8e68f2b2d5d72839a2da98f9c
+  
+  Closes #1158
+
+- cmake: tidy-up concatenation in `CMAKE_MODULE_PATH`
+  
+  Former solution was appending an empty element to the array if
+  `CMAKE_MODULE_PATH` was originally empty. The new syntax doesn't have
+  this side-effect.
+  
+  There is no known issue caused by this. Fixing it for good measure.
+  
+  Closes #1157
+
+- ci: add mingw-w64 UWP build
+  
+  Add a CI test for Windows UWP builds using mingw-w64. Before this patch
+  we had UWP builds tested with MSVC only.
+  
+  Alike existing UWP jobs, it's not possible to run the binaries due to
+  the missing UWP runtime DLL:
+  https://github.com/libssh2/libssh2/actions/runs/5821297010/job/15783475118#step:11:42
+  
+  We could install `winstorecompat-git` in the setup-msys2 step, but opted
+  to do it manually to avoid the overhead for every matrix job.
+  
+  All this would work smoother with llvm-mingw, which features an UWP
+  toolchain prefix and provides all necessary implibs by default.
+  
+  This also hit a CMake bug (with v3.26.4), where CMake gets confused and
+  sets up `windres.exe` to use the MSVC rc.exe-style command-line:
+  https://github.com/libssh2/libssh2/actions/runs/5819232677/job/15777236773#step:9:126
+  
+  Notice that MS "sunset" UWP in 2021:
+  https://github.com/microsoft/WindowsAppSDK/discussions/1615
+  
+  If this particular CI job turns out to be not worth the maintenance
+  burden or CPU time, or too much of a hack, feel free to delete it.
+  
+  Ref: https://github.com/libssh2/libssh2/pull/1147#issuecomment-1670850890
+  Closes #1155
+
+- cmake: replace `libssh2` literals with `PROJECT_NAME` variable
+  
+  Where applicable.
+  
+  This also makes it more obvious which `libssh2` uses were referring
+  to the project itself.
+  
+  Closes #1152
+
+- cmake: fix `STREQUAL` check in error branch
+  
+  This caused a CMake error instead of our custom error when manually
+  selecting the `WinCNG` crypto-backend for a non-Windows target.
+  
+  Also cleanup `STREQUAL` checks to use variable name without `${}` on
+  the left side and quoted string literals on the right.
+  
+  Closes #1151
+
+- misc: flatten `_libssh2_explicit_zero` if tree
+  
+  Closes #1149
+
+- src: drop a redundant `#include`
+  
+  We include `misc.h` via `libssh2_priv.h` already.
+  
+  Closes #1153
+
+- openssl: use automatic initialization with LibreSSL 2.7.0+
+  
+  Stop calling `OpenSSL_add_all_*()` for LibreSSL 2.7.0 and later.
+  
+  LibreSSL 2.7.0 (2018-03-21) introduced automatic initialization and
+  deprecated these functions. Stop calling these functions manually for
+  LibreSSL version that no longer need them.
+  
+  Ref: https://ftp.openbsd.org/pub/OpenBSD/LibreSSL/libressl-2.7.0-relnotes.txt
+  Ref: https://github.com/libressl/openbsd/commit/46f29f11977800547519ee65e2d1850f2483720b
+  Ref: https://github.com/libssh2/libssh2/issues/302
+  
+  Also stop calling `ENGINE_*()` functions when initialization is
+  automatic with LibreSSL 2.7.0+ and OpenSSL 1.1.0+. Engines are also
+  initializated automatically with these.
+  
+  Closes #1146
+
+- gha: restore curly braces in `if`
+  
+  Without curly braces it was less obvious which string is a GHA expression.
+  
+  Also fix an `if` expression that always missed its curly braces.
+  
+  Reverts cab3db588769d6deed97ba89ca9221fd7503405e
+  
+  Closes #1145
+
+- ci: bump mbedtls
+
+- [renmingshuai brought this change]
+
+  Add a new structure to separate memory read and file read.
+  We use different APIs when we read one private key from memory,
+  so it is improper to store the private key information in the
+  structure that stores the private key file information.
+  
+  Fixes https://github.com/libssh2/libssh2/issues/773
+  Reported-by: mike-jumper
+
+- tests: replace FIXME with comments
+  
+  `key_dsa_wrong` is the same kind of (valid) key as `key_dsa`, both with
+  an empty passphrase. Named "wrong" because it's intentionally not added
+  to our `openssh_server/authorized_keys` file.
+
+- tidy-up: delete duplicate word from comment
+
+- cmake: cache more config values on Windows
+  
+  Set two cases of non-detection to save the time dynamically detecting
+  these on each build init. Affects old MSVC versions.
+  
+  Before:
+  https://ci.appveyor.com/project/libssh2org/libssh2/builds/47668870/job/i17e0e9yx8rgpv4i
+  
+  After:
+  https://ci.appveyor.com/project/libssh2org/libssh2/builds/47674950/job/ysa1jq0pxtyhui3f
+  
+  Closes #1142
+
+- revert: build: respect autotools `DLL_EXPORT` in `libssh2.h`
+  
+  Revert fb1195cf88268a11e2709b9912ab9dca8c23739c #917
+  
+  On a second look this change did not improve anything with autotools
+  builds. autotools seems to handle the dll export matter without it.
+  
+  This patch also broke (e.g.) curl-for-win autotools builds, where the
+  curl build defines `DLL_EXPORT` while building libcurl DLL. `libssh2.h`
+  picks it up, resulting in unresolved symbols while trying to link a
+  static libssh2 on Windows. The best fix seems to be to revert this,
+  instead of adding extra tweaks to dependents.
+  
+  Fixes:
+  https://ci.appveyor.com/project/curlorg/curl-for-win/builds/47667412#L11035
+  ```
+  ld.lld-15: error: undefined symbol: __declspec(dllimport) libssh2_session_block_directions
+  >>> referenced by vssh/.libs/libcurl_la-libssh2.o:(ssh_do)
+  >>> referenced by vssh/.libs/libcurl_la-libssh2.o:(ssh_connect)
+  >>> referenced by vssh/.libs/libcurl_la-libssh2.o:(ssh_multi_statemach)
+  >>> referenced 8 more times
+  
+  ld.lld-15: error: undefined symbol: __declspec(dllimport) libssh2_session_init_ex
+  >>> referenced by vssh/.libs/libcurl_la-libssh2.o:(ssh_connect)
+  
+  ld.lld-15: error: undefined symbol: __declspec(dllimport) libssh2_session_set_read_timeout
+  [...]
+  ```
+  
+  Closes #1141
+
+- gha: simplify `if` strings
+  
+  Closes #1140
+
+- test_read: make it run without Docker
+  
+  Apply an existing fix to `test_read`, so that it falls back to use
+  the current username instead of the hardcoded `libssh2` when run
+  outside Docker.
+  
+  This allows to run algo tests with this command:
+  ```shell
+  cd tests
+  ./test_sshd.test ./test_read_algos.test
+  ```
+  
+  Closes #1139
+
+- cmake: streamline invocation
+  
+  Stop specifiying the current directory.
+  Simplify build instructions.
+  
+  Closes #1138
+
+- NMakefile: delete
+  
+  This make file was for long time unmaintained (last updated in 2014).
+  Despite best efforts to keep it working in the recent round of major
+  overhauls, it appears to be broken now. There is also no way to test it
+  without an actual MSVC env and it's also missing from our CI. Based on
+  our Issue tracker, it's also not widely used.
+  
+  Since its addition in 2005, libssh2 got support for CMake in 2014.
+  CMake should be able to generate NMake makefiles with the option
+  `-G "NMake Makefiles"`. (I haven't tested this.)
+  
+  Ref: https://github.com/libssh2/libssh2/discussions/1129
+  Closes #1134
+
+- tests: add aes256-gcm encrypted key test
+  
+  Follow-up to #1133
+  
+  Also update `tests/gen_keys.sh` to set `aes256-ctr` encryption method
+  for `key_ed25519_encrypted' explicitly.
+  
+  Closes #1135
+
+GitHub (26 Jul 2023)
+- [Jakob Egger brought this change]
+
+  Fix private keys encrypted with aes-gcm methods (#1133)
+  
+  libssh2 1.11.0 fails to decrypt private keys encrypted with
+  aes128-gcm@openssh.com and aes256-gcm@openssh.com ciphers.
+  
+  To reproduce the issue, you can create a test key with a command like
+  the following:
+  
+  ```bash
+  ssh-keygen -Z aes256-gcm@openssh.com -f id_aes256-gcm
+  ```
+  
+  If you attempt to use this key for authentication, libssh2 returns the
+  not-so-helpful error message "Wrong passphrase or invalid/unrecognized
+  private key file format".
+  
+  The problem is that OpenSSH encrypts keys differently than packets. It
+  does not include the length as AAD, and the 16 byte authentication tag
+  is appended after the encrypted key. The length of the authentication
+  tag is not included in the encrypted key length.
+  
+  I have not found any documentation for this behaviour -- I discovered it
+  by looking at the OpenSSH source. See the `private2_decrypt` function in
+  <https://github.com/openssh/openssh-portable/blob/master/sshkey.c>.
+  
+  This patch fixes the code for reading OpenSSH private keys encrypted
+  with AES-GCM methods.
+
+Viktor Szakats (26 Jul 2023)
+- ci: add missing timeout to 'autotools distcheck' step
+
+- cmake: merge `set_target_properties()` calls
+  
+  Also rename variable `LIBSSH2_VERSION` to `LIBSSH2_LIBVERSION` in
+  context of lib versioning to avoid collision with another use.
+  
+  Closes #1132
+
+- cmake: formatting [ci skip]
+
+- cmake: (re-)add zlib to `Libs.private` in `libssh2.pc`
+  
+  We mistakently added transitive zlib to `Requires.private` before, then
+  removed it. This patch re-adds zlib, but this time to `Libs.private`,
+  which is listing raw libs and should include transitive libs as well.
+  
+  Also add zlib when used as a direct dependency when zlib compression
+  support is enabled.
+  
+  Follow-up to ef538069a661a43134fe7b848b1fe66b2b43bdac
+  
+  Closes #1131
+
+- cmake: formatting [ci skip]
+
+- cmake: use `wolfssl/options.h` for detection, like autotools
+  
+  Closes #1130
+
+- build: stop requiring libssl from openssl
+  
+  libssh2 does not use or need the TLS/SSL library of OpenSSL.
+  It only needs libcrypto.
+  
+  Closes #1128
+
+- cmake: add openssl libs to `Libs.private` in `libssh2.pc`
+  
+  Also to sync up with autotools-generated `libssh2.pc`, that
+  already added them.
+  
+  Closes #1127
+
+- Makefile.mk: stop linking unused mbedtls libs
+  
+  Stop linking libmbedtls and libmbedx509 (similarly to autotools).
+  Only libmbedcrypto is necessary for libssh2.
+
+- cmake: bump minimum CMake version to v3.7.0
+  
+  Fixes the warning below, which appeared in CMake v3.27.0:
+  ```
+  CMake Deprecation Warning at CMakeLists.txt:39 (cmake_minimum_required):
+    Compatibility with CMake < 3.5 will be removed from a future version of
+    CMake.
+  
+    Update the VERSION argument <min> value or use a ...<max> suffix to tell
+    CMake that the project does not need compatibility with older versions.
+  ```
+  
+  Bump straight up to v3.7.0 to sync up with the curl project:
+  https://github.com/curl/curl/blob/2900c29218d2d24ab519853589da84caa850e8c7/CMakeLists.txt#L64
+  
+  CMake release dates:
+  v3.7.0 2016-11-11
+  v3.5.0 2016-03-08
+  v3.1.0 2014-12-17
+  
+  Closes #1126
+
+- build: tidy-up `libssh2.pc.in` variable names
+  
+  - prefix with `LIBSSH2_PC_`
+  
+  - match with the names of `pkg-config` values.
+  
+  - use the same names in autotools and CMake scripts.
+  
+  - use `LIBSSH2_VERSION` for the version number in autotools scripts,
+    to match the name used in CMake.
+  
+  Closes #1125
+
+- libssh2.pc: re-add & extend support for static-only libssh2 builds
+  
+  Adapted for libssh2 from the curl commit message by James Le Cuirot:
+  
+  "A project built entirely statically will call `pkg-config` with
+  `--static`, which utilises the `Libs.private:` field. Conversely it will
+  not use `--static` when not being built entirely statically, even if
+  there is only a static build of libssh2 available. This will most
+  likely cause the build to fail due to underlinking unless we merge the
+  `Libs:` fields.
+  
+  Consider that this is what the Meson build system does when it generates
+  `pkg-config` files."
+  
+  This patch extends the above to `Requires:`, to mirror `Libs:` with
+  `pkg-config` package names.
+  
+  Follow-up to 1209c16d93cba3c5e0f68c12fa4a5049f49c00d8 #1114
+  
+  Ref: https://github.com/libssh2/libssh2/pull/1114#issuecomment-1634334809
+  Ref: https://github.com/curl/curl/commit/98e5904165859679cd78825bcccb52306ee3bb66
+  Ref: https://github.com/curl/curl/pull/5373
+  Closes #1119
+
+GitHub (14 Jul 2023)
+- [Nursan Valeyev brought this change]
+
+  cmake: CMAKE_SOURCE_DIR -> PROJECT_SOURCE_DIR (#1121)
+  
+  Fixes compiling as dependency with FetchContent
+  
+  Co-authored-by: Viktor Szakats
+
+Viktor Szakats (14 Jul 2023)
+- autotools: use comma separator in `Requires.private` of `libssh2.pc`
+  
+  In `Requires*:`, the documented name separator is comma. We already used
+  it in the CMake-generated `libssh2.pc`. Adjust the autotools-generated
+  one to use it too, instead of spaces.
+  
+  Ref: https://linux.die.net/man/1/pkg-config
+  Ref: https://gitlab.freedesktop.org/pkg-config/pkg-config/-/blob/d97db4fae4c1cd099b506970b285dc2afd818ea2/pkg-config.1
+  
+  Closes #1124
+
+- build: add/fix `Requires.private` packages in `libssh2.pc`
+  
+  - autotools was using `libwolfssl`. CMake left it empty. wolfSSL
+    provides `wolfssl.pc`. This patch sets `Requires.private: wolfssl`
+    with both build tools.
+  
+  - add `libgcrypt` to `Requires.private` with both autotools and CMake.
+    Ref:
+      https://github.com/gpg/libgcrypt/blob/e76e88eef7811ada4c6e1d57520ba8c439139782/src/libgcrypt.pc.in
+    Present since 2005-04-22:
+      https://github.com/gpg/libgcrypt/commit/32bf3f13e8b45497322177645bebf0b5d0c9cb8e
+    Released in v1.3.0 2007-05-04:
+      https://github.com/gpg/libgcrypt/releases/tag/libgcrypt-1.3.0
+  
+  - also stop adding transitive `zlib` deps to `Requires.private`.
+    The referenced crypto package is adding it as nedded.
+    This makes deduplication of the list redundant, so stop doing it.
+    Follow-up to 2fc367900701e6149efc42bd674c4b69127756dd
+  
+  (`libssh2.pc` not tested as a project dependency.)
+  
+  Closes #1123
+
+- cmake: tidy-ups
+  
+  - dedupe `Requires.private` in `libssh2.pc`.
+    `zlib` could appear on the list twice:
+    ```
+    Requires.private: libssl,libcrypto,zlib,zlib
+    ```
+    According to CMake docs `list(REMOVE_DUPLICATES ...)`, is supported by
+    our minimum required CMake version (and by   earlier ones even):
+    https://cmake.org/cmake/help/v3.1/command/list.html#remove-duplicates
+  
+  - move `cmake_minimum_required()` to the top.
+  
+  - move `set(CMAKE_MODULE_PATH)` to the top.
+  
+  - delete duplicate `set(CMAKE_MODULE_PATH)`.
+  
+  - replace `CMAKE_CURRENT_SOURCE_DIR` with `PROJECT_SOURCE_DIR` in root
+    `CMakeLists.txt` for robustness.
+  
+  - replace `gcovr` option with long-form for readability/consistency.
+  
+  - rename `GCOV_OPTIONS` to `GCOV_CFLAGS`. These are C options we enable
+    when using gcov, not gcov tooling options.
+  
+  Closes #1122
+
+- openssl: add missing check for `LIBRESSL_VERSION_NUMBER` before use
+  
+  Fixes:
+  ```
+  openssl.h:101:5: warning: "LIBRESSL_VERSION_NUMBER" is not defined [-Wundef]
+       LIBRESSL_VERSION_NUMBER >= 0x3050000fL
+       ^
+  ```
+  
+  Ref: https://github.com/libssh2/libssh2/issues/1115#issuecomment-1631845640
+  Closes #1117
+
+- [Harmen Stoppels brought this change]
+
+  Don't put `@LIBS@` in pc file
+
+- misc: delete redundant NULL check and assignment
+  
+  Follow-up to 724effcb47ebb713d3ef1776684b8f6407b4b6a5 #1109
+  
+  Ref: https://github.com/libssh2/libssh2/pull/1109#discussion_r1246613274
+  Closes #1111
+
+- [renmingshuai brought this change]
+
+  We should check whether *key_method is a NULL pointer instead of key_method
+  
+  Signed-off-by: renmingshuai <renmingshuai@huawei.com>
+
+GitHub (30 Jun 2023)
+- [ren mingshuai brought this change]
+
+  Add NULL pointer check for outlen before use (#1109)
+  
+  Before assigning a value to the outlen, we need to check whether it is NULL.
+  
+  Credit: Ren Mingshuai <renmingshuai@huawei.com>
+
+Viktor Szakats (25 Jun 2023)
+- cmake: re-add `Libssh2:libssh2` for compatibiliy + lowercase namespace
+  
+  - add `libssh2:libssh2` target that selects the shared lib if built,
+    otherwise the static one.
+  
+  - re-add `Libssh2:libssh2` target for compatibility with v1.10.0 and
+    earlier. This is an alias for `libssh2:libssh2`.
+  
+  - keep `libssh2:libssh2_shared` and `libssh2_libssh2_static` targets.
+  
+  - allow using `find_package(libssh2)` in dependents as an alternative
+    to `find_package(Libssh2)`.
+  
+  Co-authored-by: Radek Brich
+  Suggested-by: Haowei Hsu
+  
+  Fixes #1103
+  Fixes #731
+  Closes #1104
+
+- example: fix regression in `ssh2_exec.c`
+  
+  Regression from b13936bd6a89993cd3bf4a18317ca5bd84bb08d7 #861 #846.
+  Update a variable name missed above.
+  
+  Reported-by: PewPewPew
+  Fixes #1105
+  Closes #1106
+
+- docs: replace SHA1 with SHA256 in CMake example
+
+- checksrc: modernise perl file open
+  
+  Use regular variables and separate file open modes from filenames.
+  
+  Suggested by perlcritic
+  
+  Copied from https://github.com/curl/curl/commit/7f669aa0f1d40ef5d64543981f22bdc5af1272f5
+  Copied from https://github.com/curl/trurl/commit/f2784a9240f47ee28a845
+
+- reuse: comply with 3.1 spec and 2.0.0 checker
+  
+  The checker tool was upgraded upstream to 2.0.0 and the REUSE
+  Specification to version 3.1 (from 3.0), causing these new errors:
+  ```
+  reuse.project - WARNING - Copyright and licensing information for 'docs/INSTALL_AUTOTOOLS' have been found in 'docs/INSTALL_AUTOTOOLS' and the DEP5 file located at '.reuse/dep5'. The information in the DEP5 file has been overridden. Please ensure that this is correct.
+  reuse.project - WARNING - Copyright and licensing information for 'tests/openssh_server/Dockerfile' have been found in 'tests/openssh_server/Dockerfile' and the DEP5 file located at '.reuse/dep5'. The information in the DEP5 file has been overridden. Please ensure that this is correct.
+  
+  The following files have no licensing information:
+  * docs/INSTALL_AUTOTOOLS
+  * tests/openssh_server/Dockerfile
+  ```
+  Via: https://github.com/libssh2/libssh2/actions/runs/5333572682/jobs/9664211341?pr=1098#step:4:4
+  
+  Ref: https://github.com/fsfe/reuse-tool/releases/tag/v2.0.0
+  Ref: https://git.fsfe.org/reuse/docs/src/branch/stable/CHANGELOG.md#3-1-2023-06-21
+  
+  Original discovery: https://github.com/libssh2/libssh2/pull/1098#issuecomment-1600719575
+  
+  Fixes #1101
+  Closes #1102
+
+- tests: trap signals in scripts
+  
+  Closes #1098
+
+- test_sshd.test: fixup to distcheck failure
+  
+  Fixes:
+  ```
+  ERROR: test_sshd.test - missing test plan
+  ERROR: test_sshd.test - exited with status 1
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/5322354271/jobs/9638694218#step:10:532
+  
+  Caused by trying to create the log file in a read-only directory.
+  
+  Follow-up to 299c2040625830d06ad757d687807a166b57d6de
+  Closes #1099
+
+GitHub (21 Jun 2023)
+- [Viktor Szakats brought this change]
+
+  test_sshd.test: show sshd and test connect logs on harness failure (#1097)
+
+- [Joel Depooter brought this change]
+
+  Fix incorrect byte offset in debug message (#1096)
+  
+  Fixes debug log message
+  
+  Credit:
+  Joel Depooter
+
+Viktor Szakats (16 Jun 2023)
+- tidy-up: delete whitespace at EOL [ci skip]
+
+- mbedtls: include `version.h` for `MBEDTLS_VERSION_NUMBER`
+  
+  Older (2021 or earlier?) mbedTLS releases require this.
+  
+  Reported-by: rahmanih on Github
+  Fixes #1094
+  Closes #1095
+
+- hostkey: do not advertise ssh-rsa when SHA1 is disabled
+  
+  Before this patch OpenSSL, mbedTLS, WinCNG and OS/400 advertised both
+  SHA2 and SHA1 host key algos, even when SHA1 was not supported by the
+  crypto backend or when forcefully disabled via `LIBSSH2_NO_RSA_SHA1`.
+  
+  Reported-by: João M. S. Silva
+  Fixes #1092
+  Closes #1093
+
+- openssl.h: whitespace tidy-up [ci skip]
+
+GitHub (14 Jun 2023)
+- [Dan Fandrich brought this change]
+
+  test_sshd.test: set a safe PID directory (#1089)
+  
+  The compiled in default to sshd can be a non-writable location since it
+  expects to be run as root.
+
+Viktor Szakats (13 Jun 2023)
+- mingw: fix printf mask for 64-bit integers
+  
+  Before 02f2700a61157ce5a264319bdb80754c92a40a24 #846 #876, we used
+  `%I64d'. That patch changed this to `%lld`. This patch uses `PRId64`
+  (defined in `inttypes.h`).
+  
+  Fixes #1090
+  Closes #1091
+
+- test_sshd.test: minor cleanups
+
+Daniel Stenberg (7 Jun 2023)
+- provide SPDX identifiers
+  
+  - All files have prominent copyright and SPDX identifier
+  - If not embedded in the file, in the .reuse/dep5 file
+  - All used licenses are in LICENSES/ (not shipped in tarballs)
+  - A new REUSE CI job verify that all files are OK
+  
+  Assisted-by: Viktor Szakats
+  
+  Closes #1084
+
+Viktor Szakats (6 Jun 2023)
+- src: improve MSVC C4701 warning fix
+  
+  Simplify the code to avoid this warning. This might also help avoiding
+  it with other compilers (e.g. gcc?).
+  
+  Improves 02f2700a61157ce5a264319bdb80754c92a40a24 #876
+  Might fix #1083
+  Closes #1086
+
+Daniel Stenberg (5 Jun 2023)
+- configure.ac: remove AB_INIT
+  
+  Not used. Remove m4/autobuild.m4 as well
+
+Viktor Szakats (4 Jun 2023)
+- copyright: remove years from copyright headers
+  
+  Also:
+  - uppercase `(C)`.
+  - add missing 'All rights reserved.' lines.
+  - drop duplicate 'Author' lines.
+  - add copyright headers where missing.
+  - enable copyright header check in checksrc.
+  
+  Reasons for deleting years (copied as-is from curl):
+  - they are mostly pointless in all major jurisdictions
+  - many big corporations and projects already don't use them
+  - saves us from pointless churn
+  - git keeps history for us
+  - the year range is kept in COPYING
+  
+  Closes #1082
+
+- tests: cast to avoid `-Wchar-subscripts` with Cygwin
+  
+  ```
+  In file included from $HOME/src/cygwin/libssh2/libssh2-1.11.0-1.x86_64/src/libssh2-1.11.0/tests/openssh_fixture.c:57:
+  $HOME/src/cygwin/libssh2/libssh2-1.11.0-1.x86_64/src/libssh2-1.11.0/tests/openssh_fixture.c: In function 'run_command_varg':
+  $HOME/src/cygwin/libssh2/libssh2-1.11.0-1.x86_64/src/libssh2-1.11.0/tests/openssh_fixture.c:136:37: warning: array subscript has type 'char' [-Wchar-subscripts]
+    136 |         while(end > 0 && isspace(buf[end - 1])) {
+        |                                  ~~~^~~~~~~~~
+  ```
+  Ref: https://github.com/libssh2/libssh2/files/11644340/cygwin-x86_64-libssh2-1.11.0-1-check.log
+  
+  Reported-by: Brian Inglis
+  Fixes #1080
+  Closes #1081
+
+- tidy-up: avoid exclamations, prefer single quotes, in outputs
+  
+  Closes #1079
+
+- autotools: improve libz position
+  
+  We repositioned crypto libs in 4f0f4bff5a92dce6a6cd7a5600a8ee5660402c3f
+  via #941 and subsequently in d4f58f03438e326b8696edd31acadd6f3e028763
+  from d93ccf4901ef26443707d341553994715414e207 via #1013.
+  
+  This patch moves libz accordingly, to unbreak certain build scenarios.
+  
+  Reported-by: Kenneth Davidson
+  Regression from 4f0f4bff5a92dce6a6cd7a5600a8ee5660402c3f #941
+  Fixes #1075
+  Closes #1077
+
+- src: bump `hash_len` to `size_t` in `LIBSSH2_HOSTKEY_METHOD`
+  
+  Follow-up to 7b8e02257f01a6dac5f65305b18bb74a157fb5c4
+  Closes #1076
+
+- ci: add non-static autotools i386 build, ignore GHA updates on AppVeyor
+  
+  Add a non-static autotools build to GitHub Actions. Make this build
+  target i386 and libgcrypt, to test a new build combination if we are at
+  it.
+  
+  Also:
+  - GHA: add necessary generic bits for i386 autotools builds.
+  - AppVeyor CI: teach it to ignore commits updating our GHA config.
+  
+  Follow-up to 572c57c9d8d4e89cfce19dde40125d55481256d1 #1072
+  Closes #1074
+
+GitHub (31 May 2023)
+- [Xi Ruoyao brought this change]
+
+  autotools: skip tests requiring static lib if `--disable-static` (#1072)
+  
+  Co-authored-by: Viktor Szakats
+  Regression from 83853f8aea0e2f739cacd491632eb7fd3d03ad2d #663
+  Fixes #1056
+
+Viktor Szakats (31 May 2023)
+- ci: prefer `=` operator in shell snippets
+  
+  Closes #1073
+
+- src: bump DSA and ECDSA sign `hash_len` to `size_t`
+  
+  Closes #1055
+
+- scp: fix missing cast for targets without large file support
+  
+  E.g. on 32-bit Linux. Issue revealed after adding i386 Linux CI build
+  in abdf40c741c575f94bdea1c67a9d1182ff813ccb #1057.
+  
+  ```
+  /home/runner/work/libssh2/libssh2/src/scp.c: In function 'scp_recv':
+  /home/runner/work/libssh2/libssh2/src/scp.c:765:23: error: conversion from 'libssh2_int64_t' {aka 'long long int'} to '__off_t' {aka 'long int'} may change value [-Werror=conversion]
+    765 |         sb->st_size = session->scpRecv_size;
+        |                       ^~~~~~~
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/5126803482/jobs/9221746299?pr=1054#step:12:51
+  
+  Regression from 5db836b2a829c6fff1e8c7acaa4b21b246ae1757 #1002
+  Closes #1060
+
+- mbedtls.h: formatting [ci skip]
+  
+  For consistency with `mbedtls.c`.
+  
+  Follow-up to 1153ebdeba563ac657b525edd6bf6da68b1fe5e2
+
+- libssh2.h: bump to 1.11.1_DEV [ci skip]
+
+- mbedtls: use more `size_t` to sync up with `crypto.h`
+  
+  Ref: 5a96f494ee0b00282afb2db2e091246fc5e1774a #846 #879
+  
+  Fixes #1053
+  Closes #1054
+
+- ci: drop redundant/unused vars, sync var names
+  
+  Closes #1059
+
+- ci: add i386 Linux build (with mbedTLS)
+  
+  Also:
+  - reorder Linux build matrix to make build tool more visible.
+  - hide apt-get progress bar.
+  - prepare package install step for i386 builds.
+  
+  Detects bug #1053
+  Closes #1057
+
+- checksrc: switch to dot file
+  
+  Closes #1052
+
+Version 1.11.0 (30 May 2023)
+
+Daniel Stenberg (30 May 2023)
+- libssh2.h: bump to 1.11.0 for release
+
+GitHub (30 May 2023)
+- [Will Cosgrove brought this change]
+
+  Libssh2 1.11 release notes, copyright (#1048)
+  
+  * Libssh2 1.11 release notes, copyright
+
+Viktor Szakats (29 May 2023)
+- add copyright/credits
+  
+  Closes #1050
+
+- ci: add LIBSSH2_NO_AES_CBC to GNU Make build
+  
+  Closes #1049
+
+- ci: add wolfSSL Linux builds
+  
+  Exclude wolfSSL builds from tests. All fail:
+  
+  ```
+  2/43 Test  #2: test_aa_warmup ............................***Failed    5.59 sec
+  libssh2_session_handshake failed (-44): Unable to ask for ssh-userauth service
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/5085775952/jobs/9139583212#step:12:942 (with logging)
+  Ref: https://github.com/libssh2/libssh2/actions/runs/5085586301/jobs/9139192562#step:12:225
+  
+  wolfSSL version:
+  ```
+  Get:1 http://azure.archive.ubuntu.com/ubuntu jammy/universe amd64 libwolfssl32 amd64 5.2.0-2 [818 kB]
+  Get:2 http://azure.archive.ubuntu.com/ubuntu jammy/universe amd64 libwolfssl-dev amd64 5.2.0-2 [1194 kB]
+  ```
+  
+  Cherry-picked from #1046
+  Closes #1046
+
+- ci: mbedTLS build config tidy-up
+  
+  Cherry-picked from #1046
+
+- wolfssl: fix detection of AES-GCM feature
+  
+  Follow-up to df513c0128e1a811ad863d153892618e728845f0
+  
+  Ref: https://github.com/libssh2/libssh2/issues/1020#issuecomment-1562069241
+  Closes #1045
+
+- build: fix 'unused' compiler warnings with all `NO` options set
+  
+  - add `LIBSSH2_NO_ED25519` build-time option to force-disable ED25519
+    support. Useful to replicate crypto-backend builds without ED25519,
+    such as wolfSSL.
+  
+  - openssl: fix unused variable and function warnings with all supported
+    `LIBSSH2_NO_*` options enabled.
+  
+  - mbedtls: fix misplaced `#endif` leaving out the required internal
+    public function `libssh2_supported_key_sign_algorithms()`.
+  
+  - mbedtls: add missing prototype for two internal public functions.
+  
+  - delete a redundant block.
+  
+  All `NO` options:
+  ```shell
+  CPPFLAGS='
+  -DLIBSSH2_NO_MD5 -DLIBSSH2_NO_HMAC_RIPEMD -DLIBSSH2_NO_DSA
+  -DLIBSSH2_NO_RSA -DLIBSSH2_NO_RSA_SHA1
+  -DLIBSSH2_NO_ECDSA -DLIBSSH2_NO_ED25519 -DLIBSSH2_NO_AES_CTR
+  -DLIBSSH2_NO_BLOWFISH -DLIBSSH2_NO_RC4 -DLIBSSH2_NO_CAST
+  -DLIBSSH2_NO_3DES'
+  ```
+  
+  Closes #1044
+
+- cmake: avoid `list(PREPEND)` for compatibility
+  
+  `list(PREPEND)` requires CMake v3.15, our minimum is v3.1. `APPEND`
+  should work fine for headers anyway.
+  
+  Also fix a wrongly placed comment.
+  
+  Ref: https://cmake.org/cmake/help/latest/command/list.html#prepend
+  
+  Regression from 1e3319a167d2f32d295603167486e9e88af9bb4e
+  
+  Closes #1043
+
+- checksrc: verify label indent, fix fallouts
+  
+  Also update two labels to match the rest of the source.
+  
+  checksrc update credit: Emanuele Torre @emanuele6
+  
+  Ref: https://github.com/curl/curl/pull/11134
+  
+  Closes #1042
+
+- tidy-up: minor nits
+
+- ci: drop default shared/static configuration options
+  
+  Both autotools and cmake build both shared and static lib by default.
+  
+  Ref: 896154bc17f000c0a1bb89b74bc879692ac0d47c
+  
+  Delete configuration enabling these explicitly in CI jobs.
+  
+  Cherry-picked from #1036
+  Closes #1036
+
+- cmake: enable shared libssh2 library by default
+  
+  This brings default behaviour in sync with autotools, which builds both
+  lib flavours by default.
+  
+  (Notice that on Windows, autotools includes the Windows Resource in the
+  static library, when building both at the same time. CMake doesn't have
+  this issue.)
+  
+  Enabling both lib flavours has a side-effect when using non-MinGW
+  toolchains (e.g. MSVC): to resolve the filename conflict between import
+  and static libraries, we add a suffix to the static lib, naming it
+  `libssh2_static.lib`. This can break dependent builds relying on
+  `libssh2.lib` for linking the static libssh2.
+  
+  Workarounds:
+  
+  - disable either shared or static libssh2 via
+    `-DBUILD_STATIC_LIBS=OFF` or
+    `-DBUILD_SHARED_LIBS=OFF`. This results in a libssh2 library (either
+    static or shared) without a prefix: `libssh2.lib`.
+  
+  - set a custom static library suffix via:
+    `-DSTATIC_LIB_SUFFIX=_my_static`. Resulting in
+    `libssh2_my_static.lib`, and import library
+    `libssh2.lib`.
+  
+  - set a custom import library suffix via:
+    `-DIMPORT_LIB_SUFFIX=_my_implib`. Resulting in
+    `libssh2_my_implib.lib` import library, and static library
+    `libssh2.lib`.
+  
+  - customize the default static/import library suffix (incl. extension)
+    via
+    `-DCMAKE_STATIC_LIBRARY_SUFFIX=_my_static_suffix.lib` or
+    `-DCMAKE_IMPORT_LIBRARY_SUFFIX=_my_import_suffix.lib`.
+  
+  Cherry-picked from #1036
+
+- cmake: tweak static/import lib name collision avoidance logic
+  
+  The collision issue affects (typically) MSVC, when building both shared
+  and static libssh2 in one go.
+  
+  Ref: https://stackoverflow.com/questions/2140129/what-is-proper-naming-convention-for-msvc-dlls-static-libraries-and-import-libr
+  
+  Initially we handled this by appending the `_imp` suffix to the import
+  library filename. This is how curl tackles this, but on a second look,
+  this solution seem to be accidental and has no widespread use.
+  
+  It seems more widely accepted to use the '_static' suffix for the static
+  library. This patch implements this.
+  
+  (MinGW, Cygwin and unixy platforms are not affected by this issue.)
+  
+  Follow-up to 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1
+  
+  Cherry-picked from #1036
+
+- cmake: add `IMPORT_LIB_SUFFIX` (like `STATIC_LIB_SUFFIX`)
+  
+  Allow resolving the import/static library name collision also by setting
+  a custom _import_ library name suffix.
+  
+  Follow-up to 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1
+  
+  Cherry-picked from #1036
+
+- ci: do not disable shared lib with msys2/autotools in GHA
+  
+  Cherry-picked from #1036
+
+- Makefile.mk: fix `DYN=1 test` by skipping tests needing static lib
+  
+  `DYN=1` means to build examples/tests against the shared libssh2.
+  
+  Before this patch this was broken for building tests. This patch skips
+  building tests that require the static libssh2 library, so the build now
+  succeeds.
+  
+  Also move the list of tests that require static lib from
+  `CMakeLists.txt` to `Makefile.inc`, so that we can reuse it in
+  `Makefile.mk`.
+  
+  Couldn't find a way to also reuse it in `Makefile.am`. Move the
+  `Makefile.am` specific definitions close to the shared list, to make it
+  easier to keep them synced.
+  
+  Cherry-picked from #1036
+
+- ci: make one of the AppVeyor CMake jobs shared-only
+  
+  This build combination did not have a CI test before.
+  
+  Cherry-picked from #1036
+
+- cmake: allow tests with `BUILD_STATIC_LIBS=OFF`
+  
+  Before this patch, the CMake build did not allow to disable static
+  libssh2 library while also building tests.
+  
+  This patch removes this constraint, and makes this combination possible.
+  In this case the 3 (at the moment) tests that require a static libssh2
+  library, are skipped from the build and test runs.
+  
+  Cherry-picked from #1036
+
+- build: fix to set `-DLIBSSH2DEBUG` for tests
+  
+  Required for tests using libssh2 internals. These are the ones
+  requiring the libssh2 _static_ lib.
+  
+  Before this patch, `src` and `tests` declared the `session` structure
+  differently, due to extra struct members added with the `LIBSSH2DEBUG`
+  macro set. But, the macro was only set for `src` when using CMake. At
+  runtime this caused struct members to be at different offsets between
+  lib and test code, resulting in the test failures below.
+  
+  Due to another bug in the affected test, these failures did not reflect
+  in the exit code, which always returned success, so this went unnoticed
+  for a good while. Fixed in: 84d31d0ca7b647ad4c2aa92bf8f4a94b233f5d3b
+  
+  ```
+       Start  5: test_auth_keyboard_info_request
+  [...]
+  5: Test case 1 passed
+  5: Test case 2 passed
+  5: Test case 3: expected return code to be 0 got -1
+  5: Test case 4: expected last error code to be "-6" got "-38"
+  5: Test case 5: expected last error code to be "-6" got "-38"
+  5: Test case 6: expected last error code to be "-6" got "-38"
+  5: Test case 7: expected last error message to be "Unable to decode keyboard-interactive number of keyboard prompts" got "userauth keyboard data buffer too small to get l
+  5: Test case 8: expected last error code to be "-41" got "-38"
+  5: Test case 9: expected return code to be 0 got -1
+  5: Test case 10: expected return code to be 0 got -1
+  5: Test case 11: expected last error code to be "-6" got "-38"
+  5: Test case 12: expected last error message to be "Unable to decode user auth keyboard prompt echo" got "userauth keyboard data buffer too small to get length"
+  5: Test case 13: expected return code to be 0 got -1
+  5: Test case 14: expected return code to be 0 got -1
+  5: Test case 15: expected last error code to be "-6" got "-38"
+  5: Test case 16: expected last error code to be "-6" got "-38"
+  5: Test case 17: expected last error code to be "-6" got "-38"
+  5: Test case 18: expected last error code to be "-6" got "-38"
+  ```
+  Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46925869/job/i9uasceu3coss0i2#L440
+  Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46983040/job/c3vag25c26a77lyr#L485
+  
+  Cherry-picked from #1037
+  Closes #1037
+
+- test_auth_keyboard_info_request: fix to return failure
+  
+  Before this patch, this test returned success even when one of its tests
+  failed. Fix it by returning 1 in case any of the tests fails.
+  
+  This issue masked a CMake build bug with logging enabled. Subject to an
+  upcoming patch.
+  
+  Cherry-picked from #1037
+
+- test_auth_keyboard_info_request: fix indentation
+  
+  Cherry-picked from #1037
+
+- tidy-up: move comment off from copyright header
+  
+  Cherry-picked from #1037
+
+- ci: enable shared libs in msys2/macOS cmake builds
+  
+  Shared libs improve example/tests build times. For "unity"
+  builds the overhead of building shared lib is negligible, so
+  this even reduced the overall build-time.
+  
+  Follow-up to 3d64a3f5100f7f4cf52202396eb4f1c3f3567771
+  Follow-up to d93ccf4901ef26443707d341553994715414e207
+  
+  Tests:
+  https://github.com/libssh2/libssh2/actions/runs/4906586658: unity builds enabled
+  https://github.com/libssh2/libssh2/actions/runs/4906925743: unity builds enabled + parallel msys2 builds
+  https://github.com/libssh2/libssh2/actions/runs/4906777629: unity + shared lib (this commit)
+  https://github.com/libssh2/libssh2/actions/runs/4906927190: unity + shared lib (this commit) + parallel msys2 builds
+  
+  Consider making shared libs enabled by default also in CMake, to sync it with autotools?
+  
+  Closes #1035
+
+- ci: add missed --parallel 3 from msys2 cmake builds
+  
+  Follow-up to 3d64a3f5100f7f4cf52202396eb4f1c3f3567771
+
+- cmake: add and test "unity" builds
+  
+  "Unity" (aka "jumbo", aka "amalgamation" builds concatenate source files
+  before compiling. It has these benefits for example: faster builds,
+  improved code optimization, cleaner code. Let's support and test this.
+  
+  - enable unity builds for some existing CI builds to test this build
+    scenario.
+  - tune `UNITY_BUILD_BATCH_SIZE` size.
+  - disable unity build for example and test programs (they use one source
+    each already).
+  
+  You can enable it by passing `-DCMAKE_UNITY_BUILD=ON` to cmake.
+  Supported by CMake 3.16 and newer.
+  
+  Ref: https://cmake.org/cmake/help/latest/prop_tgt/UNITY_BUILD.html
+  
+  Closes #1034
+
+- tests: simplify passing `srcdir` to tests
+  
+  Before this patch libssh2 used a variety of solutions to pass the source
+  directory to tests: `FIXTURE_WORKDIR` build-time macro (cmake),
+  `FIXTURE_WORKDIR` envvar (unused), setting `srcdir` manually
+  (autotools), setting current directory (cmake), and also `builddir`
+  envvar (autotools) for passing current working dir to `mansyntax.sh`.
+  
+  This patch reduces this to using existing `srcdir` with autotools and
+  setting it ourselves in CMake. This was mostly enabled by this recent
+  patch: 4c9ed51f962f542b98789b15bedaaa427f4029a2
+  
+  Details:
+  
+  - cmake: replace baked-in `FIXTURE_WORKDIR` macro with env.
+  
+    Added in 54bef4c5dad868a9d45fdbfca9729b191c0abab5 #198 (2018-03-21)
+  
+  - rename `FIXTURE_WORKDIR` to `srcdir`, to match autotools.
+  
+  - cmake: add missing `srcdir` for algo and sshd tests.
+  
+  - session_fixture: stop `chdir()`-ing, rely on prefixing with `srcdir`.
+  
+    Changing current directory should be unnecessary after
+      4c9ed51f962f542b98789b15bedaaa427f4029a2 #801 (2023-02-24),
+    that prefixes referenced input filenames with the `srcdir` envvar.
+  
+    The `srcdir` envvar was already exported by autotools, and now we're
+    also setting it from CMake.
+  
+  - cmake: stop setting `WORKING_DIRECTORY`, rely on `srcdir` env.
+  
+    `WORKING_DIRECTORY` is no longer necessary, after passing `srcdir` to
+    all tests, so they can find our source tree and keys/etc in it
+    regardless of the current directory.
+  
+    Also this past commit hints that `WORKING_DIRECTORY` wasn't always
+    working for this purpose as expected:
+      "tests: Xcode doesn't obey CMake's test working directory"
+    Ref: https://github.com/libssh2/libssh2/pull/198/commits/10a5cbf945abcc60153ee3d59284d09fc64ea152
+  
+  - autotools: delete explicit `srcdir` for test env.
+  
+    Added in 13f8addd1bc17e6c55d52491cc6304319ac38c6d (2015-07-02)
+  
+    automake documents `srcdir` as exported to the test environment:
+    https://github.com/autotools-mirror/automake/blob/c04c4e8856e3c933239959ce18e16599fcc04a8b/doc/automake.texi#L9302-L9304
+    https://www.gnu.org/software/automake/manual/html_node/Scripts_002dbased-Testsuites.html
+    It's mentioned in the docs back in 1997 and got a regression test in
+    2012. We can safely assume it to be available without setting it
+    ourselves.
+  
+  - autotools: delete explicit `builddir`.
+  
+    Added in 13f8addd1bc17e6c55d52491cc6304319ac38c6d (2015-07-02)
+  
+    It seems this wasn't necessary to make the above fix work, and
+    `mansyntax.sh` is able to figure out the build workdir by reading
+    `$PWD`. Our out-of-tree and `make distcheck` CI builds also work
+    without it.
+  
+    Let us know if there is a scenario we're missing and needs this.
+  
+  Closes #1032
+
+- src: fix `libssh2_store_*()` for >u32 inputs
+  
+  `_libssh2_store_str()` and `_libssh2_store_bignum2_bytes()` accept
+  inputs of `size_t` max, store the size as 32-bit unsigned integer, then
+  store the complete input buffer.
+  
+  With inputs larger than `UINT_MAX` this means the stored size is smaller
+  than the data that follows it.
+  
+  This patch truncates the stored data to the stored size, and now returns
+  a boolean with false if the stored length differs from the requested
+  one. Also add `assert()`s for this condition.
+  
+  This is still not a correct fix, as we now dump consistent, but still
+  truncated data which is not what the caller wants. In future steps we'll
+  need to update all callers that might pass large data to this function
+  to check the return value and handle an error, or make sure to not call
+  this function with more than UINT_MAX bytes of data.
+  
+  Ref: c3bcdd88a44c4636818407aeb894fabc90bb0ecd (2010-04-17)
+  Ref: ed439a29bb0b4d1c3f681f87ccfcd3e5a66c3ba0 (2022-09-29)
+  
+  Closes #1025
+
+- cmake: limit WinCNG to Windows
+  
+  After deleting the `bcrypt.h` check, no check remained. Restore
+  a `WIN32` check here to ensure WinCNG is not enabled outside Windows.
+  
+  Follow-up to 1289033598546ee5089ff0fc4369d24e1e2be81f
+  
+  Tested-in #1032
+
+- cmake: move `CMAKE_VS_GLOBALS` setting to CI configs
+  
+  To not force this setting for local builds where they might serve
+  a good purpose.
+  
+  It makes our CI runs slightly faster and we don't need to track
+  file changes in unattended, single, CI runs.
+  
+  Cherry-picked from #1031
+
+- cmake: prefill for faster config phase on Windows
+  
+  Prefill known detection results on Windows with MinGW and MSVC, to
+  avoid spending time on detecting these on every cmake configuration
+  run.
+  
+  With MinGW + clang and MSVC, this elminates all detections.
+  With MinGW + gcc, it reduces them to 3.
+  
+  Cherry-picked from #1031
+
+- libssh2_setup.h: set `HAVE_INTTYPES_H` for MSVC
+  
+  To sync up the hand-crafted config with actual detection results
+  by CMake and autotools. Sources compiled fine without it anyway.
+  
+  Cherry-picked from #1031
+
+- cmake: re-add `select()` detection (regression)
+  
+  `select()` detection suffered two regressions: First I accidentally
+  deleted it for non-Windows [1]. Then the Windows-specific setting got
+  missed from the generated `libssh2_config.h` after a rearrangement in
+  `CMakeLists.txt` files.
+  
+  [1] 31fb8860dbaae3e0b7d38f2a647ee527b4b2a95f (2023-03-07)
+  [2] 803f19f004eb6a5b525c48fff6f46a493d25775c (2023-04-18)
+  
+  This patch restores detection. For Windows, enable it unconditionally,
+  not only for speed reasons, but because detection needs `ws2_32`, and
+  even that is broken on the x86 platform. According to the original
+  `cmake/SocketLibraries.cmake`, caused by a calling convention mismatch.
+  FWIW autotools detects it correctly.
+  
+  Cherry-picked from #1031
+
+- ci: merge make job into msys2 section, enable zlib + openssl
+  
+  Follow up to dd625766271a0ba13f5ac661bdc2fa40bbfa580a
+  
+  Cherry-picked from #1030
+
+- ci: add missing timeouts for autotools tests
+  
+  Cherry-picked from #1030
+
+- ci: add mingw-w64 clang and gcc CMake jobs
+  
+  Cherry-picked from #1030
+
+- cmake: assume `bcrypt.h` with WinCNG
+  
+  autotools already didn't check for `bcrypt.h`, and such check is only
+  required for old/legacy mingw without obsolete/incomplete Windows
+  headers.
+  
+  curl deprecated old-mingw support just recently and will delete support
+  in September 2023.
+  
+  This patch saves some complexity and detection time by dropping this
+  check for CMake. Meaning that mingw-w64 is now required to compile
+  libssh2 when using the WinCNG backend for 32-bit builds. Other backends
+  and CPU platforms are not affected.
+  
+  Ref: https://github.com/curl/curl/commit/e4d5685cb5d6eb07e1b43156fd7e3ba3563afba5
+  
+  Closes #1026
+
+- cmake: do not check for `poll()` on Windows
+  
+  While it seems to exist on mingw in theory, it's not detected as of this
+  writing. It also has issues, and not ready for production use:
+  https://stackoverflow.com/questions/1671827/poll-c-function-on-windows
+  
+  On MSVC it's even less supported.
+  
+  Skip checking this to save CMake detection time.
+  
+  Closes #1027
+
+- agent_win: make a struct static and other build improvements
+  
+  Also:
+  - merge back `agent.h` into `agent.c` where it was earlier.
+    Ref: c998f79384116e9f6633cb69c2731c60d3a442bb
+  - introduce `HAVE_WIN32_AGENT` internal macro.
+  - fix two guards to exclude more code unused in UWP builds.
+  
+  Follow-up to 1c1317cb768688eee0e5496c72683190aaf63b29
+  
+  Closes #1028
+
+- tidy-up: formatting nits
+  
+  Whitespace and redundant parenthesis in `return`s.
+  
+  Closes #1029
+
+GitHub (3 May 2023)
+- [Nick Woodruff brought this change]
+
+  sftp: parse attribute extensions, if present, to avoid stream parsing errors (#1019)
+  
+  Prevents directory listing errors when attribute extensions are present
+  by advancing stream parsing past extensions.
+
+Viktor Szakats (3 May 2023)
+- tests: merge `sshd_fixture.sh` into `test_sshd.test`
+  
+  Merge the loop executing multiple tests and the script that actually
+  launches the tests into a single script. This same script is now called
+  from both autotools and CMake. autotools loads the list of tests from
+  `Makefile.inc`, CMake passes it via the command-line. It's also possible
+  to call the script manually with a custom list of tests or individual
+  ones.
+  
+  With this setup we're now launching a single sshd session for all tests,
+  instead of launching and killing it for each test. This did not improve
+  reliability of these test on CI machines, and it's easy to go back to
+  the previous behaviour if necessary.
+  
+  Also:
+  
+  - allow passing custom sshd options via `SSHD_FLAGS`.
+  
+  - add `SSHD_TESTS_LIMIT_TO` to limit the number of tests to its value.
+    E.g. `SSHD_TESTS_LIMIT_TO=1` executes the first test only. Meant for
+    debugging.
+  
+  - use `ssh` to test the connection (if available) instead of fixed
+    amount of wait. Made to also work on Windows.
+  
+  - set `PermitRootLogin yes` in `sshd`, to allow running tests as root.
+  
+  - show `sshd` path and version.
+  
+  Cherry-picked from #1017 (the last one)
+  Closes #1024
+
+- ci: make sure to run tests after all builds in GHA
+  
+  Whenever possible. Due to flakiness/hangs/timeouts, keep sshd
+  tests disabled on Windows and macOS.
+  
+  Also keep Docker tests disabled on these platforms, they do not work:
+  
+  GHA Windows:
+  ```
+  no matching manifest for windows/amd64 in the manifest list entries
+  ```
+  
+  GHA macOS:
+  ```
+  sh: docker: command not found
+  ```
+  
+  It's not possible to run UWP and ARM64 binaries:
+  UWP:
+  ```
+  Test #2: test_simple ......................Exit code 0xc0000135
+  ```
+  Needs but doesn't find: `VCRUNTIME140_APP.dll`.
+  
+  ARM64
+  ```
+  D:/a/libssh2/libssh2/bld/tests/Release/test_ssh2.exe: cannot execute binary file: Exec format error
+  ```
+  
+  Cherry-picked from #1017
+
+- tests: disable sshd tests on Windows via new options
+  
+  Instead of using hacks inside the build systems.
+  
+  `SSHD` variable added to GitHub Actions is not currently used.
+  Added there to make it easy to experiment with these tests and
+  the path is non-trivial to discover. Using the Windows built-in
+  sshd server is another option (haven't discovered its path yet).
+  
+  Cherry-picked from #1017
+
+- tests: add cmake/autotools options to disable running tests
+  
+  autotools:
+  - `--disable-docker-tests`
+  - `--disable-sshd-tests`
+  
+  cmake:
+  - `RUN_DOCKER_TESTS`
+  - `RUN_SSHD_TESTS`
+  
+  Update automake and ci to use this new flag and delete former logic
+  of relying on Windows detection and `HOST_WINDOWS`. Also fix honoring
+  this when running `test_read_algos.test`.
+  
+  This allows to disable these individually and on per-CI/local-job basis.
+  To run as much tests as the env allows.
+  
+  Cherry-picked from #1017
+
+- ci: add `make distcheck` job
+  
+  Cherry-picked from #1017
+
+- ci: switch to out-of-tree autotools builds
+  
+  Cherry-picked from #1017
+
+- ci: restore parallel builds with cmake
+  
+  Also add missing -j3 for macOS builds.
+  
+  Partial revert of 0d08974633cfc02641e6593db8d569ddb3644255
+  
+  Cherry-picked from #1017
+
+- ci: sync names, steps, syntax, build dirname between jobs
+  
+  Also:
+  
+  - delete an unused 64-bit option for Linux (all jobs are 64-bit).
+  
+  - fix to not install libgcrypt and openssl when doing mbedTLS builds.
+  
+  [ Empty lines after multiline run commands are solely to unbreak
+  my editor's syntax highlighting. They can be deleted in the future ]
+  
+  Cherry-picked from #1017
+
+- ci: add `Makefile.mk` test, with `LIBSSH2_NO_*` options
+  
+  Cherry-picked from #1017
+
+- Makefile.mk: use Makefile.inc from example and tests
+  
+  Instead of assembling the list using `$(wildcard ...)`.
+  
+  Also split off a `tests/Makefile.inc` from `tests/Makefile.am`. With its
+  simpler syntax, this also allows to delete some complexity from the
+  CMake loader.
+  
+  Cherry-picked from #1017
+
+- example, tests: fix ssh2 to correctly return failure
+  
+  Before this patch ssh2 and test_ssh2 returned success even if the session
+  failed at `libssh2_session_handshake()` or after.
+  
+  This patch depends on cda41f7cb87c3af5258ba48ccef19d3efdbd3d3b, that fixed
+  running test_ssh2 on Windows via sshd_fixture.
+  
+  Cherry-picked from #1017
+
+- tests: set -e -u in shell scripts
+  
+  Cherry-picked from #1017
+
+- cmake: use shared libs again in example and tests
+  
+  Re-sync with autotools and v1.10.0 behavior.
+  
+  This improves build times. It also allows to stop building our special
+  shared test target to test shared builds.
+  
+  Follow-up to 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1
+  
+  Cherry-picked from #1017
+  Closes #1022
+
+- tests: retry KEX failures when using the WinCNG backend
+  
+  Twice. This tests are flaky and we haven't figured out why. In the
+  meantime use this workaround to test and log these issues, but also
+  ensure that CI run aren't flagged red because of it.
+  
+  Also:
+  - kex: add debug message when hostkey `sig_verify` fails,
+    to help tracking WinCNG KEX failures.
+  - test_ssh2: also add retry logic.
+    I'm not quite sure this is correct. Please let me know.
+  - session_fixture: bump up `src_path` slots to fit retries and show
+    message when hitting the limit.
+  - session_fixture: clear `kbd_password` static variable after use.
+  - session_fixture: close and deinit socket after use.
+  - session_fixture: deinit libssh2 after use.
+  
+  Ref: #804 #846 #979 #1012 #1015
+  
+  Cherry-picked from #1017
+  Closes #1023
+
+- example, test_ssh2: shutdown socket before close
+  
+  Syncing them with `tests/session_fixture.c`.
+  
+  Cherry-picked from #1017
+
+- ci.yml: fix indentation [ci skip]
+  
+  Cherry-picked from #1017
+
+- Makefile.mk: make tests depend on runner lib
+  
+  Cherry-picked from #1017
+
+- build: compile agent_win.c via agent.c
+  
+  Silences these warnings on non-Windows:
+  ```
+  ranlib: file: libssh2.a(agent_win.c.o) has no symbols
+  ```
+  
+  Cherry-picked from #1017
+
+- cmake: delete obsolete comment
+  
+  Follow-up to 80175921638fa0a345237d23206a2ad1644cdd9b
+  
+  Cherry-picked from #1017
+
+- checksrc.sh: fix it to run from any current directory
+  
+  Also silence a shellcheck warning.
+  
+  Cherry-picked from #1017
+
+- ISSUE_TEMPLATE: ask for crypto backend version
+  
+  Also fix casing in backend names.
+  
+  Cherry-picked from #1017
+
+- tests: fix newlines in test keys for sshd on Windows
+  
+  Make sure these files get LF newlines on checkout. Before this patch
+  a checked out libssh2 Git repository may have used CRLF newlines in text
+  files, include test keys. Private keys with CRLF newlines could confuse
+  sshd on Windows:
+  
+  ```
+  # sshd version: 'OpenSSH_9.2, OpenSSL 1.1.1t  7 Feb 2023'
+  Unable to load host key "/d/a/libssh2/libssh2/tests/openssh_server/ssh_host_ed25519_key": invalid format
+  Unable to load host key: /d/a/libssh2/libssh2/tests/openssh_server/ssh_host_ed25519_key
+  ```
+  Ref: https://github.com/libssh2/libssh2/actions/runs/4846188677/jobs/8635575847#step:6:39
+  
+  Cherry-picked from #1017
+
+- cmake: move option descriptions next to definition
+  
+  Cherry-picked from #1017
+
+- checksrc: sync with curl
+  
+  There were no new issues detected.
+  
+  Cherry-picked from #1017
+
+- openssl: enable AES-GCM with wolfSSL
+  
+  Follow-up to 3c953c05d67eb1ebcfd3316f279f12c4b1d600b4 #797
+  
+  There is pending issue with wolfSSL, where encryption/decryption is not
+  working (both with and without this patch). Ref: #1020
+  
+  Cherry-picked from #1017
+
+- appveyor: add a UWP OpenSSL 3 build
+  
+  Cherry-picked from #1017
+
+- appveyor: skip `before_test` when not doing tests
+  
+  Also merge `before_test` section into `test_script`.
+  
+  Cherry-picked from #1017
+
+- docs: delete two stray characters
+  
+  Cherry-picked from #1017
+
+- tidy-up: avoid expression 'of course'
+  
+  Cherry-picked from #1017
+
+- tidy-up: avoid word 'just'
+  
+  Cherry-picked from #1017
+
+- tidy-up: avoid word 'simply'
+  
+  Cherry-picked from #1017
+
+- tests: teach to use the `USERNAME` envvar on Windows
+  
+  Necessary to pick the correct local username when run on Windows.
+  
+  Cherry-picked from #1017
+
+- test_ssh2: support `FIXTURE_TRACE_ALL*` envvars
+  
+  Cherry-picked from #1017
+
+- tidy-up: add missing newline to error msg, formatting
+  
+  Also:
+  - fix indent
+  - lowercase variables names
+  - fix formatting in `src/global.c`
+  
+  Cherry-picked from #1017
+
+- appveyor: wait more for SSH connection from GHA
+  
+  Cherry-picked from #1017
+
+- ci: restrict permissions in GitHub Actions
+  
+  Cherry-picked from #1017
+
+- build: fix autoreconf warnings
+  
+  - update `AC_HELP_STRING' to 'AS_HELP_STRING`:
+    ```
+    configure.ac:[...]: warning: The macro `AC_HELP_STRING' is obsolete.
+    ```
+    "AC_HELP_STRING is deprecated in 2.70+ and I believe AS_HELP_STRING works
+    already since 2.59 so bump the minimum required version to that."
+  
+    Ref: https://github.com/curl/curl/commit/a59f04611629f0db9ad8e768b9def73b9b4d9423
+  
+  - simplify to avoid:
+    ```
+    src/Makefile.inc:48: warning: variable 'EXTRA_DIST_SOURCES' is defined but no program or
+    src/Makefile.inc:48: library has 'DIST' as canonical name (possible typo)
+    ```
+    Regression from 2c18b6fc8df060c770fa7e5da704c32cf40a5757
+  
+  - `AC_TRY_LINK`/`AC_TRY_COMPILE`:
+    ```
+    configure.ac:335: warning: The macro `AC_TRY_COMPILE' is obsolete.
+    configure.ac:335: warning: The macro `AC_TRY_LINK' is obsolete.
+    ```
+  
+  - `libtool`-related ones:
+    ```
+    configure.ac:70: warning: The macro `AC_LIBTOOL_WIN32_DLL' is obsolete.
+    configure.ac:70: warning: AC_LIBTOOL_WIN32_DLL: Remove this warning and the call to _LT_SET_OPTION when you
+    configure.ac:70: put the 'win32-dll' option into LT_INIT's first parameter.
+    configure.ac:71: warning: The macro `AC_PROG_LIBTOOL' is obsolete.
+    ```
+    Using code copied from curl:
+    https://github.com/curl/curl/blob/9ce7eee07042605045dcfd02a6f5b38ad5c8a05d/m4/xc-lt-iface.m4#L157-L163
+  
+  - delete commented and obsolete `AC_HEADER_STDC`.
+  
+  - formatting.
+  
+  Most cherry-picked from `autoupdate` updates.
+  
+  Cherry-picked from #1017
+  Closes #1021
+
+- docker-bridge.ps1: use native newlines
+  
+  Also add a shebang and exec flag to ease testing/handling on *nix.
+  PowerShell accepts both LF and CRLF.
+  
+  Cherry-picked from #1017
+
+GitHub (1 May 2023)
+- [Zenju brought this change]
+
+  sftp: remove packet limit for directory reading (#791)
+  
+  Currently libssh2 cannot read huge directory listings when the package
+  size of `LIBSSH2_SFTP_PACKET_MAXLEN` (256KB) is hit. For example AWS
+  always sends a single package with all files of a directory, no matter
+  how big it is: https://freefilesync.org/forum/viewtopic.php?t=10020
+  Package size is probably around 7MB in this case!
+  
+  `LIBSSH2_SFTP_PACKET_MAXLEN` is a good idea in general, but there
+  doesn't seem to be a one size fits all. While almost all(?) SFTP
+  responses come in very small packages, I believe the `SSH_FXP_READDIR`
+  request should be exempted.
+  
+  The proposed patch, enhances the package size reading to include parsing
+  the full SFTP packet header. And in case a package is of type
+  `SSH_FXP_NAME` and matches an expected `readdir_request_id`, it does not
+  fail if `LIBSSH2_SFTP_PACKET_MAXLEN` is hit. The chances of accidentally
+  hiding data-corruption are pretty non-existent, because both SFTP
+  `request_id` and packet type must match. No change in behavior
+  otherwise.
+  
+  Best, Zenju
+  
+  Previous discussion: #268 #269
+  
+  With the above changes, the `LIBSSH2_SFTP_PACKET_MAXLEN` value could
+  (and should?) probably be set back to a small number again.
+  
+  Integration-patches-by: Viktor Szakats
+
+Viktor Szakats (28 Apr 2023)
+- checksrc: update and apply fixes
+  
+  Update to latest revision and fix new issues detected.
+  
+  Closes #1014
+
+- ci: add macOS CI jobs + fix issues revealed
+  
+  Add macOS CI jobs, both cmake and autotools for all supported crypto
+  backends (except BoringSSL), with debug, zlib enabled. Without running
+  tests. It also introduces OpenSSL 1.1 into the CI with a non-MSVC
+  compiler.
+  
+  Credits to curl's `macos.yml`, that I used as a base.
+  
+  Fix these issues uncovered by the new tests:
+  
+  - openssl: fix warning when built with wolfSSL, or OpenSSL 1.1 and
+    earlier. CI missed it because apparently the only OpenSSL 1.1 test
+    we had used MSVC, which did not complain.
+  
+    ```
+    ../src/openssl.c:3852:19: error: variable 'sslError' set but not used [-Werror,-Wunused-but-set-variable]
+        unsigned long sslError;
+                      ^
+    ```
+  
+    Regression from 097c8f0dae558643d43051947a1c35b65e1c5761
+  
+  - pem: add hack to build without MD5 crypto-backend support.
+  
+    The Homebrew wolfSSL build comes with MD5 support disabled. We can
+    expect this becoming the norm. FIPS also requires MD5 disabled.
+  
+    We deleted the same hack from `hostkey.c` a month ago:
+    ad6aae302aaec84afbfacf0c1dfdc446d46eaf21
+  
+    A better fix would be to guard the MD5 logic with our `LIBSSH2_MD5`
+    macro.
+  
+    ```
+    pem.c:214:32: error: use of undeclared identifier 'MD5_DIGEST_LENGTH'; did you mean 'SHA_DIGEST_LENGTH'?
+            unsigned char secret[2*MD5_DIGEST_LENGTH];
+                                   ^~~~~~~~~~~~~~~~~
+                                   SHA_DIGEST_LENGTH
+    ```
+  
+    Regression from 386e012292a96fcf0dc6861588397845df0aba2c
+  
+  - `configure.ac`: add crypto libs late.
+  
+    Fix it by adding crypto libs to `LIBS` at the end of the configuration
+    process.
+  
+    Otherwise `configure` links crypto libs while doing feature tests,
+    which can cause unwanted detections. For example LibreSSL publishes
+    the function `explicit_bzero()`, which masks the system alternative,
+    e.g. `memset_s()` on macOS. Then when trying to compile libssh2, its
+    declaration is missing:
+  
+    ```
+    bcrypt_pbkdf.c:93:5: error: implicit declaration of function 'explicit_bzero' is invalid in C99 [-Werror,-Wimplicit-function-declaration]
+        _libssh2_explicit_zero(ciphertext, sizeof(ciphertext));
+        ^
+    ../src/misc.h:50:43: note: expanded from macro '_libssh2_explicit_zero'
+                                              ^
+    ```
+  
+    Regression from 4f0f4bff5a92dce6a6cd7a5600a8ee5660402c3f
+  
+  - cmake: fix to list our own include directory before the crypto libs',
+    when building tests.
+  
+    Otherwise a global crypto header path, such as `/usr/local/include`,
+    containing an external `libssh2.h` of a different version, could cause
+    weird errors:
+  
+    ```
+    cc -DHAVE_CONFIG_H -DLIBSSH2_LIBGCRYPT \
+      -I../src -I../../src -I/usr/local/include -I[...]/libssh2/include \
+      -g -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX13.1.sdk  \
+      -mmacosx-version-min=12.6 -MD -MT  \
+      tests/CMakeFiles/test_aa_warmup.dir/test_aa_warmup.c.o \
+      -MF CMakeFiles/test_aa_warmup.dir/test_aa_warmup.c.o.d  \
+      -o CMakeFiles/test_aa_warmup.dir/test_aa_warmup.c.o -c \
+      [...]/libssh2/tests/test_aa_warmup.c
+    ```
+  
+    ```
+    [ 62%] Building C object tests/CMakeFiles/test_aa_warmup.dir/test_aa_warmup.c.o
+    In file included from /Users/runner/work/libssh2/libssh2/tests/test_aa_warmup.c:4:
+    In file included from /Users/runner/work/libssh2/libssh2/tests/runner.h:42:
+    In file included from /Users/runner/work/libssh2/libssh2/tests/session_fixture.h:43:
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:649:5: error: type name requires a specifier or qualifier
+        LIBSSH2_AUTHAGENT_FUNC((*authagent));
+        ^
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:649:30: error: type specifier missing, defaults to 'int' [-Werror,-Wimplicit-int]
+        LIBSSH2_AUTHAGENT_FUNC((*authagent));
+                                 ^
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:650:5: error: type name requires a specifier or qualifier
+        LIBSSH2_ADD_IDENTITIES_FUNC((*addLocalIdentities));
+        ^
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:650:35: error: type specifier missing, defaults to 'int' [-Werror,-Wimplicit-int]
+        LIBSSH2_ADD_IDENTITIES_FUNC((*addLocalIdentities));
+                                      ^
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:651:5: error: type name requires a specifier or qualifier
+        LIBSSH2_AUTHAGENT_SIGN_FUNC((*agentSignCallback));
+        ^
+    /Users/runner/work/libssh2/libssh2/tests/../src/libssh2_priv.h:651:35: error: type specifier missing, defaults to 'int' [-Werror,-Wimplicit-int]
+        LIBSSH2_AUTHAGENT_SIGN_FUNC((*agentSignCallback));
+                                      ^
+    6 errors generated.
+    ```
+  
+  - `tests/session_fixture.h`: delete duplicate `libssh2.h`,
+    `libssh2_priv.h` already includes it.
+  
+    Follow-up to a683133dfe96de126194f58f183131a84c7d36a2
+  
+  CI logs with these errors:
+  https://github.com/libssh2/libssh2/actions/runs/4824079094
+  https://github.com/libssh2/libssh2/actions/runs/4824270819
+  
+  curl's `macos.yml`: https://github.com/curl/curl/blob/da2470de96e94e1c8d276b9ae6e4c97c2cf54239/.github/workflows/macos.yml
+  
+  Tidying-up while here:
+  
+  - tests/session_fixture.h: delete duplicate `libssh2.h`.
+    `libssh2_priv.h` includes it already.
+  
+    Follow-up to a683133dfe96de126194f58f183131a84c7d36a2
+  
+  - ci.yml: yamllint warnings and formatting.
+  
+  - ci.yml: msvc section formatting and step-naming sync with macOS.
+  
+    Follow-up to f4a4c05dc3bcd62ecaa1b0cac5997faefe16c83f
+  
+  - ci.yml: enable `--enable-werror` for msys2 jobs.
+  
+    Follow-up to 71cae949d577fdd632a271da0bec89f977dc5dd2
+  
+  - appveyor.yml: show OpenSSL versions, link to image content.
+  
+  Closes #1013
+
+- ci: convert `docker-bridge.bat` to shell script
+  
+  Convert `ci/appveyor/docker-bridge.bat` to a POSIX shell script.
+  
+  Also bump the tunnel to use ed25519 (was RSA-2048).
+  
+  Closes #997
+
+- kex: use distinctive error strings
+  
+  Use unique error strings to help localize errors.
+  
+  Closes #1011
+
+- tidy-up: C header use
+  
+  - drop unused or duplicate C headers.
+  - add missing ones (that worked by chance).
+    (`string.h`, `stdlib.h`)
+  - mention the functions that need certain headers.
+  - move some headers from crypto header to crypto C source.
+  - reorder headers in some places.
+  - simplify the #if tree for `sys/select.h` in `libssh2_priv.h`.
+  - move scp-specific macros next to their header to `scp.c`
+    Follow-up to 5db836b2a829c6fff1e8c7acaa4b21b246ae1757
+  
+  Closes #999
+
+- tidy-up: text nits, English contractions [ci skip]
+  
+  In input/output text and docs mostly.
+
+- ci: add MSVC and UWP builds to GitHub Actions
+  
+  - add MSVC jobs to GitHub Actions. They are similar to the 'Build-only'
+    jobs we have on AppVeyor CI, though only the ARM64 Windows one is
+    identical. Major disadvantage is that we don't run tests here. Major
+    advantage is they only take a few minutes to complete, compared to
+    an hour on AppVeyor, so WinCNG build results now appear quicker.
+  
+    Docker tests might be possible, but my light attempts failed.
+    Finding ZLIB also failed, so we still miss an MSVC test with it.
+  
+    Tool versions as of now: Server 2022, VS2022, OpenSSL 1.1.1
+  
+  - add UWP builds for both ARM64 and x64. This hasn't been CI tested
+    before.
+  
+    (We could probably enable UWP on AppVeyor CI as well.
+    I haven't tried.)
+  
+  - fix two uncovered UWP issues in tests.
+  
+  - rename internal macro `LIBSSH2_WINDOWS_APP` to `LIBSSH2_WINDOWS_UWP`.
+  
+    Follow-up to 2addafb77b662e64248d156c71c69b91ba7b926e
+  
+  - fold long lines and quote truthy values in `.github/workflows/ci.yml`.
+  
+  Closes #1010
+
+- session_fixture: avoid no-op `chdir(getcwd())`
+  
+  If no `FIXTURE_WORKDIR` macro or envvar is present to set the cwd,
+  avoid querying the cwd and then calling chdir with the result.
+  
+  Ref: 54bef4c5dad868a9d45fdbfca9729b191c0abab5 (patch)
+  Ref: 10a5cbf945abcc60153ee3d59284d09fc64ea152 (individual commit)
+  
+  Closes #1009
+
+- tests/sshd_fixture.sh: convert back to POSIX
+  
+  There was no strong reason to require bash. Let's use POSIX shell
+  like before the recent overhaul.
+  
+  Follow-up to a459a25302a31f6e2aba3c4e15b1472b83b596fc
+  
+  Closes #1008
+
+GitHub (26 Apr 2023)
+- [Miguel de Icaza brought this change]
+
+  If SFTP fails to initialize, do not busy loop waiting for IO to happen (#720)
+  
+  Currently SFTP's init will busy loop waiting for the channel to close,
+  even if the underlying transport returns EAGAIN. While this works for
+  sockets, it might not work out if you have a different transport that
+  needs to do some additional processing on the side.
+  
+  Integration-patches-by: Viktor Szakats
+
+Viktor Szakats (26 Apr 2023)
+- docs: simplify `.TH` header & other cleanups [ci skip]
+  
+  - simplify `.TH` headers.
+  - delete empty lines before sections.
+  - update template with an `AVAILABILITY` section.
+  
+  Left libssh2 version number in the `.TH` header for entries without an
+  `AVAILABILITY` section, or where there was a different version number
+  there.
+
+- tidy-up: formatting nits [ci skip]
+
+- vms: fix to include `sys/socket.h`
+  
+  Due to a typo in the `HAVE_*` macro, this header was never included.
+  
+  A comment suggests that `socklen_t` is not defined on VMS and defines it
+  manually. This symbol is usually in `sys/socket.h`, so the typo may have
+  been the reason for it to be missing.
+  
+  Closes #1007
+
+- build: fix `make distcheck` regressions
+  
+  - add #included C files to `EXTRA_DIST`.
+  
+    Regression from 4f0f4bff5a92dce6a6cd7a5600a8ee5660402c3f
+  
+  - fix `tests/sshd_fixture.sh` to not write into the test dir, by using
+    a pre-assembled `TrustedUserCAKeys` file. Update `Dockerfile` too to
+    use this.
+  
+    Regression from a459a25302a31f6e2aba3c4e15b1472b83b596fc
+  
+  Also update `tests/sshd_fixture.sh` to use
+  `openssh_server/authorized_keys` like `Dockerfile` does. And a few more
+  cosmetic updates.
+  
+  Closes #1006
+
+- libssh2_priv.h: assume `HAVE_LONGLONG`
+  
+  Unless I'm missing something, it looks like `libssh2.h` has been using
+  `libssh2_int64_t` unconditionally since at least 2010-04-17 when
+  `libssh2_scp_send64()` landed via commit
+  be9ee7095e2d5021985f57d88f5f889d3c2b9d8f.
+  
+  This makes it redundant to detect `HAVE_LONGLONG` to fallback to a
+  32-bit `scpRecv_size` in `libssh2_priv.h`. Then deal with possible
+  combinations of this flag and `strtoll()` options, which was
+  error-prone.
+  
+  Instead, assume in `libssh2_priv.h` that we have `libssh2_int64_t`, and
+  use it always.
+  
+  For MSVC, this means `_MSC_VER` `1310` (from year 2003) is now
+  required. Based on the above, this was already so before this patch.
+  
+  If there happens to be no 64-bit `strtoll()` detected, fall back to the
+  32-bit `strtol()` (this should never happen with MSVC, and probably
+  neither with any other reasonably modern toolchain.)
+  
+  Also make sure to set `HAVE_STRTOI64` for older, non-CMake, MSVC builds
+  (e.g. `Makefile.mk` or `NMakefile` ones).
+  
+  Closes #1002
 
-- [Will Cosgrove brought this change]
+GitHub (26 Apr 2023)
+- [Miguel de Icaza brought this change]
 
-  global.c : fixed call to libssh2_crypto_exit #394 (#396)
+  fix a couple of small regressions (#1004)
   
-  * global.c : fixed call to libssh2_crypto_exit #394
+  - openssl: fix potentially missing `ERR_*` constants by including
+    `openssl/err.h`. This could happen with recent version of Xcode
+    or when building against OpenSSL built with the `OPENSSL_NO_ENGINE`
+    option.
   
-  File: global.c
+    Regression from 097c8f0dae558643d43051947a1c35b65e1c5761 (#789)
   
-  Notes: Don't call `libssh2_crypto_exit()` until `_libssh2_initialized` count is down to zero.
+  - channel: fix an issue that would corrupt the data stream when
+    attempting to initialize the agent in non-blocking mode, as it is
+    necessary to propagate the `EAGAIN` signal upstream when the transport
+    returns `EAGAIN`.
   
-  Credit: seba30
+    Regression from bc4e619e76071393e466c29220fc4ef5764c2820 (#752)
+  
+  - packet: the current code does not set the state machine upon reaching
+    this point which means that if the code is suspended due to the
+    transport returning an `EAGAIN`, this will re-initialize the structure
+    every time.
+  
+    The issue is that this keeps assigning a new channel-id downstream,
+    which does not match the initial channel-id that is initially
+    generated, causing a lookup later to fail as there is no matching
+    channel.
+  
+    Regression from bc4e619e76071393e466c29220fc4ef5764c2820 (#752)
 
-Will Cosgrove (30 Jul 2019)
-- [hlefebvre brought this change]
+Viktor Szakats (26 Apr 2023)
+- tidy-up: `gettimeofday()` fallback and use
+  
+  Simplify the way we handle `gettimeofday()` fallback for platforms
+  without native support or without any support. Make it similar to
+  how we handle `snprintf()`.
+  
+  In case of no native `gettimeofday()` support and a non-Windows
+  platform, our local fallback returns zero in `tv_usec` and `tv_sec`,
+  ending up with a zero `timeout_remaining` in `session.c`, same as
+  before this patch.
+  
+  Also:
+  - drop unused `sys/time.h` headers.
+  - fix our fallback code to compile with any Windows compilers
+    (not just MSVC)
+  - delete unnecessary casts.
+  
+  Closes #1001
 
-  misc.c : Add an EWOULDBLOCK check for better portability (#172)
+- libssh2_priv.h: fix checksrc warning [ci skip]
   
-  File: misc.c
+  Regression from 9ef75298fae0728305d9d38ba1e3c838ad0513f7
+
+- libssh2_priv.h: whitespace fixes cont. [ci skip]
+
+- libssh2_priv.h: whitespace fixes [ci skip]
+
+- cmake: use portable mkdir for tests/coverage target [ci skip]
   
-  Notes: Added support for all OS' that implement EWOULDBLOCK, not only VMS
+  Makes `make coverage` work without a POSIX mkdir.
   
-  Credit: hlefebvre
+  Tested locally.
+  
+  Ref: https://cmake.org/cmake/help/latest/manual/cmake.1.html#cmdoption-cmake-E-arg-make_directory
 
-- [Etienne Samson brought this change]
+- kex: fix overlapping memcpy() to memmove()
+  
+  Noticed this when libasan started kicking out errors when sending in
+  MACs preferences that were not supported yet.
+  
+  Reported-by: fourierules on github
+  Fixes #611
+  Closes #1000
 
-  userauth.c: fix off by one error when loading public keys with no id (#386)
+- test/CMakeLists.txt: reuse `Makefile.am` librunner source list
   
-  File: userauth.c
+  Follow-up to a459a25302a31f6e2aba3c4e15b1472b83b596fc
   
-  Credit:
-  Etienne Samson
+  Closes #998
+
+GitHub (25 Apr 2023)
+- [Zenju brought this change]
+
+  openssl: fix misleading error message if wrong passphrase (#789)
   
-  Notes:
-  Caught by ASAN:
+  Fixes #608
+
+Viktor Szakats (25 Apr 2023)
+- tidy-up: tiny nits [ci skip]
+
+- tests: improve running tests
   
-  =================================================================
-  ==73797==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60700001bcf0 at pc 0x00010026198d bp 0x7ffeefbfed30 sp 0x7ffeefbfe4d8
-  READ of size 69 at 0x60700001bcf0 thread T0
-  2019-07-04 08:35:30.292502+0200 atos[73890:2639175] examining /Users/USER/*/libssh2_clar [73797]
-      #0 0x10026198c in wrap_memchr (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c)
-      #1 0x1000f8e66 in file_read_publickey userauth.c:633
-      #2 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
-      #3 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
-      #4 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
-      #5 0x1000090c3 in clar_run_test clar.c:260
-      #6 0x1000038f3 in clar_run_suite clar.c:343
-      #7 0x100003272 in clar_test_run clar.c:522
-      #8 0x10000c3cc in main runner.c:60
-      #9 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
+  TL;DR: Sync test builds between autotools and CMake. Sync sshd
+  configuration between Docker and non-Docker fixtures. Bump up
+  sshd_config for recent OpenSSH releases.
   
-  0x60700001bcf0 is located 0 bytes to the right of 80-byte region [0x60700001bca0,0x60700001bcf0)
-  allocated by thread T0 here:
-      #0 0x10029e053 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5c053)
-      #1 0x1000b4978 in libssh2_default_alloc session.c:67
-      #2 0x1000f8aba in file_read_publickey userauth.c:597
-      #3 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
-      #4 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
-      #5 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
-      #6 0x1000090c3 in clar_run_test clar.c:260
-      #7 0x1000038f3 in clar_run_suite clar.c:343
-      #8 0x100003272 in clar_test_run clar.c:522
-      #9 0x10000c3cc in main runner.c:60
-      #10 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
+  This also opens up the path to have non-Docker tests that use a
+  local sshd process. Though sshd is practically unusable on Windows
+  CI machines out of the box, so this will need further efforts.
   
-  SUMMARY: AddressSanitizer: heap-buffer-overflow (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c) in wrap_memchr
-  Shadow bytes around the buggy address:
-    0x1c0e00003740: fd fd fd fd fd fd fd fd fd fd fa fa fa fa fd fd
-    0x1c0e00003750: fd fd fd fd fd fd fd fa fa fa fa fa 00 00 00 00
-    0x1c0e00003760: 00 00 00 00 00 00 fa fa fa fa 00 00 00 00 00 00
-    0x1c0e00003770: 00 00 00 fa fa fa fa fa fd fd fd fd fd fd fd fd
-    0x1c0e00003780: fd fd fa fa fa fa fd fd fd fd fd fd fd fd fd fa
-  =>0x1c0e00003790: fa fa fa fa 00 00 00 00 00 00 00 00 00 00[fa]fa
-    0x1c0e000037a0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-  Shadow byte legend (one shadow byte represents 8 application bytes):
-    Addressable:           00
-    Partially addressable: 01 02 03 04 05 06 07
-    Heap left redzone:       fa
-    Freed heap region:       fd
-    Stack left redzone:      f1
-    Stack mid redzone:       f2
-    Stack right redzone:     f3
-    Stack after return:      f5
-    Stack use after scope:   f8
-    Global redzone:          f9
-    Global init order:       f6
-    Poisoned by user:        f7
-    Container overflow:      fc
-    Array cookie:            ac
-    Intra object redzone:    bb
-    ASan internal:           fe
-    Left alloca redzone:     ca
-    Right alloca redzone:    cb
-    Shadow gap:              cc
+  Details:
+  
+  - cmake: run sshd fixture test just like autotool did already.
+  
+  - sync tests and their order between autotools and CMake.
+  
+    It makes `test_aa_warmup` the first test with both.
+  
+  - cmake: load test lists from `Makefile.am`.
+  
+    Needed to update the loader to throw away certain lines to keep the
+    converted output conform CMake syntax. Using regexp might be an
+    alternative way of doing this, but couldn't make it work.
+  
+  - cmake: use the official way to configure test environment variables.
+    Switch to syntax that's extendable.
+  
+  - cmake: allow to run the same test both under Docker and sshd fixture.
+  
+    Useful for testing the sshd fixture runner, or how the same test
+    behaves in each fixture.
+  
+  - update test fixture to read the username from `USER` envvar instead of
+    using the Dockfile-specific hardwired one, when running outside Docker.
+  
+  - rework `ssh2.sh` into `sshd_fixture.sh`, to:
+  
+    - allow running any tests (not just `test_ssh2`).
+    - configure Docker tests for running outside Docker.
+    - fixup `SSHD` path when running on Windows (e.g. in AppVeyor CI).
+      Fixes: `sshd re-exec requires execution with an absolute path`
+    - allow overriding `PUBKEY` and `PRIVKEY` envvars.
+    - allow overriding `ssh_config` via `SSHD_FIXTURE_CONFIG`.
+  
+  - prepare support for running multiple tests via sshd_fixture.
+  
+    Add a TAP runner for autotools and extend CMake logic. The TAP runner
+    loads the test list from `Makefile.am`.
+  
+    Notice however that on Windows, `sshd_fixture.sh` is very flaky with
+    GitHub Actions. And consistently broken for subsequent tests in
+    AppVeyor CI:
+      'libssh2_session_handshake failed (-43): Failed getting banner'
+  
+    Another way to try is a single sshd instance serving all tests.
+    For CMake this would probably mean using an external script.
+  
+  - ed25519 test keys were identical for auth and host. Regenerate the
+    auth keypair to make them distinct.
+  
+  - sync the sshd environment between Docker and sshd_fixture.
+  
+    - use common via `openssh_server/sshd_config`.
+    - accept same auth keys.
+    - offer the same host keys.
+    - sync TrustedUserCAKeys.
+    - delete now unused keypairs: `etc/host*`, `etc/user*`.
+    - bump up startup delay for Windows (randomly, to 5 secs, from 3).
+    - delete `UsePrivilegeSeparation no` to avoid deprecation warnings.
+      `command-line line 0: Deprecated option UsePrivilegeSeparation`
+    - delete `Protocol 2` to avoid deprecation warnings.
+      It has been the default since OpenSSH 3.0 (2001-11-06).
+    - delete `StrictModes no` (CI tests work without it, Docker tests
+      never used it).
+  
+  - bump `Dockerfile` base image to `testing-slim` (from `bullseye-slim`).
+  
+    It needed `sshd_config` updates to keep things working with
+    OpenSSH 9.2 (compared to bullseye's 8.4).
+  
+    - replace `ChallengeResponseAuthentication` alias with
+      `KbdInteractiveAuthentication`.
+      The former is no longer present in default `sshd_config` since
+      OpenSSH 8.7 (2021-08-20). This broke the `Dockerfile` script.
+      The new name is documented since OpenSSH 4.9 (2008-03-31)
+  
+    - add `PubkeyAcceptedKeyTypes +ssh-rsa,ssh-dss,ssh-rsa-cert-v01@openssh.com`
+      and `HostKeyAlgorithms +ssh-rsa`.
+  
+      Original-patch-by: Eric van Gyzen (@vangyzen on github)
+      Fixes #691
+  
+      There is a new name for `PubkeyAcceptedKeyTypes`:
+         `PubkeyAcceptedAlgorithms`.
+      It requires OpenSSH 8.5 (2021-03-03) and breaks some envs so we're
+      not using it just yet.
+  
+  - drop `rijndael-cbc@lysator.liu.se` tests and references from config.
+  
+    This is a draft alias for `aes256-cbc`. No need to test it twice.
+    Also this alias is no longer recognized by OpenSSH 8.5 (2021-03-03).
+  
+  - update `mansyntax.sh` and `sshd_fixture.sh` to not rely on `srcdir`.
+  
+    Hopefully this works with out-of-tree builds.
+  
+  - fix `test_read_algos.test` to honor CRLF EOLs in their inputs
+    (necessary when running on Windows.)
+  
+  - fix `test_read_algos.test` to honor `EXEEXT`. Might be useful when
+    running tests under cross-builds?
+  
+  - `test_ssh2.c`:
+  
+    - use libssh2 API to set blocking mode. This makes it support all
+      platforms.
+    - adapt socket open timeout logic from `openssh_fixture.c`.
+      Sadly this did not help fix flakiness on GHA Windows.
+  
+  - tests: delete unused C headers and variable initialization.
+  
+  - delete unused test files: `sshd_fixture.sh.in`, `sshdwrap`,
+    `etc/sshd_config`.
+  
+    Ref: cf80f2f4b5255cc85a04ee43b27a29c678c1edb1
+  
+  - autotools: delete stray `.c` test sources from `EXTRA_DIST` in tests.
+  
+  - `tests/.gitignore`: drop two stray tests.
+  
+  - autotools: fix passing `SSHD` containing space (Windows needs this).
+  
+  - autotools: sort `EXTRA_DIST` in tests.
+  
+  - cmake: fix to add `test_ssh2` to `TEST_TARGETS`.
+  
+  - fix `authorized_key` order in `tests/gen_keys.sh`.
+  
+  - silence shellcheck warning in `ci/checksrc.sh`.
+  
+  - set `SSHD` for autotools on GitHub Actions Windows. [skipped]
+  
+    Auto-detection doesn't work (maybe because sshd is installed via
+    Git for Windows and we're using MSYS2's shell.)
+  
+    It enables running sshd fixture (non-Docker) tests in these jobs.
+  
+    I did not include this in the final patch due to flakiness:
+    ```
+    Connection to 127.0.0.1:4711 attempt #0 failed: retrying...
+    Connection to 127.0.0.1:4711 attempt #1 failed: retrying...
+    Connection to 127.0.0.1:4711 attempt #2 failed: retrying...
+    Failure establishing SSH session: -43
+    ```
+  
+    Can be enabled with:
+    `export SSHD='C:/Program Files/Git/usr/bin/sshd.exe'`
+  
+  Closes #996
+
+- ci: reduce algo test runtime on AppVeyor
+  
+  Make the block count customizable in `test_read` via environment
+  `FIXTURE_XFER_COUNT`.
+  
+  Set the custom count lower than the default when running on AppVeyor.
+  
+  The goal is to reduce CI roundtrip times.
+  
+  Closes #995
+
+GitHub (22 Apr 2023)
+- [Michael Buckley brought this change]
+
+  Agent forwarding implementation (#752)
+  
+  This PR contains a series of patches that date back many years and I
+  believe were discussed on the mailing list, but never merged. We have
+  been using these in our local copy of libssh2 without issue since 2015,
+  if not earlier. I believe this is the full set of changes, as we tried
+  to use comments to mark where our copy of libssh2 differs from the
+  canonical version.
+  
+  This also contains changes I made earlier this year, but which were not
+  discussed on the mailing list, to support certificates and FIDO2 keys
+  with agent forwarding.
+  
+  Note that this is not a complete implementation of agent forwarding, as
+  that is outside the scope of libssh2. Clients still need to provide
+  their own implementation that parses ssh-agent methods after calling
+  libssh2_channel_read() and calls the appropriate callback messages in
+  libssh2. See the man page changes in this PR for more details.
+  
+  Integration-patches-by: Viktor Szakats
+  
+  * prefer size_t
+  * prefer unsigned int over u_int in public function
+  * add const
+  * docs, indent, checksrc, debug call, compiler warning fixes
+
+Viktor Szakats (21 Apr 2023)
+- ci: add Windows Server 2016 into the test mix
+  
+  We had Windows Server 2012 R2 (8.1) and Windows Server 2019 (10) before
+  this patch. After, we also have Windows Server 2016 (10).
+  
+  The WinCNG flakey tests should have a better chance when running on the
+  newer OS.
+  
+  This update does not change the compiler mix.
+  
+  Also change the test fixture to not use the `--quiet` option with the
+  `docker pull` commant. This option requires docker v19.03, and
+  AppVeyor's Visual Studio 2017 image doesn't support it. Log output did
+  not change without `--quiet`, so it seems safe to delete it. In case
+  we'd need it, another solution is to retry without `--quiet` if the
+  command fails. docker's exit status is 125 in that case.
+  
+  Ref: https://github.com/libssh2/libssh2/issues/804#issuecomment-1515232799
+  Ref: https://www.appveyor.com/docs/windows-images-software/
+  
+  Closes #994
+
+- build: add autotools test_read support and more
+  
+  Keep a single list for mac and crypt algos that we use in both CMake
+  and autotools. Use the same test names across build tools.
+  
+  Use the TAP protocol to track individual tests run from a single shell
+  script.
+  
+  Also:
+  
+  - enable the rest of our tests with autotools.
+  
+  - set `make check` verbose to see errors in case they happen.
+  
+  - silence stray 'command not found' error when running `mansyntax.sh`
+    on Windows.
+  
+  GitHub Actions Windows docker tests disabled due to:
+  ```
+  Command: docker build --quiet -t libssh2/openssh_server ../tests/openssh_server
+  Error running command 'docker build --quiet -t libssh2/openssh_server ../tests/openssh_server' (exit 1): Sending build context to Docker daemon  22.02kB
+  Step 1/42 : FROM debian:bullseye-slim
+  bullseye-slim: Pulling from library/debian
+  no matching manifest for windows/amd64 10.0.20348 in the manifest list entries
+  Failed to build docker image
+  ```
+  
+  Closes #993
+
+- cmake: restore a dash char in comment [ci skip]
+  
+  It's a CMake comment header convention.
+
+GitHub (21 Apr 2023)
+- [Dan Fandrich brought this change]
+
+  tests: add AES-GCM protocol read tests (#992)
+  
+  Closes #992
+
+- [Viktor Szakats brought this change]
+
+  support encrypt-then-mac (etm) MACs (#987)
+  
+  Support for calculating MAC (message authentication code) on encrypted
+  data instead of plain text data.
+  
+  This adds support for the following MACs:
+  - `hmac-sha1-etm@openssh.com`
+  - `hmac-sha2-256-etm@openssh.com`
+  - `hmac-sha2-512-etm@openssh.com`
+  
+  Integration-patches-by: Viktor Szakats
+  
+  * rebase on master
+  * fix checksec warnings
+  * fix compiler warning
+  * fix indent/whitespace/eol
+  * rebase/manual merge onto AES-GCM patch #797
+  * more manual merge of `libssh2_transport_send()` based
+    on dfandrich/shellfish
+  
+  Fixes #582
+  Closes #655
+  Closes #987
+
+Viktor Szakats (20 Apr 2023)
+- docs: fix typo in argument name [ci skip]
+
+- [Keith Dart brought this change]
+
+  channel: add support for "signal" message
+  
+  Can send specific signals to remote process. Allows for slightly
+  improved remote process management, if the server supports it.
+  
+  Integration-patches-by: Viktor Szakats
+  
+  * doc updates
+  * change `signame_len` to `size_t`
+  * variable scopes
+  * fix checksrc warnings
+  
+  Closes #672
+  Closes #991
+
+- crypto: add `LIBSSH2_NO_AES_CBC` option
+  
+  Also rename internal `LIBSSH2_AES` to `LIBSSH2_AES_CBC`.
+  
+  Follow-up to 857e431648df6edcb3e17138d877f2e65d2d769d
+  
+  Closes #990
+
+- tidy-up: indentation fixes [ci skip]
+
+GitHub (20 Apr 2023)
+- [Dan Fandrich brought this change]
+
+  Add support for AES-GCM crypto protocols (#797)
+  
+  Add support for aes256-gcm@openssh.com and aes128-gcm@openssh.com
+  ciphers, which are the OpenSSH implementations of AES-GCM cryptography.
+  It is similar to RFC5647 but has changes to the MAC protocol
+  negotiation.  These are implemented for recent versions of OpenSSL only.
+  
+  The ciphers work differently than most previous ones in two big areas:
+  the cipher includes its own integrated MAC, and the packet length field
+  in the SSH frame is left unencrypted.  The code changes necessary are
+  gated by flags in the LIBSSH2_CRYPT_METHOD configuration structure.
+  
+  These differences mean that both the first and last parts of a block
+  require special handling during encryption. The first part is where the
+  packet length field is, which must be kept out of the encryption path
+  but in the authenticated part (as AAD).  The last part is where the
+  Authentication Tag is found, which is calculated and appended during
+  encryption or removed and validated on decryption. As encryption/
+  decryption is performed on each packet in a loop, one block at a time,
+  flags indicating when the first and last blocks are being processed are
+  passed down to the encryption layers.
+  
+  The strict block-by-block encryption that occurs with other protocols is
+  inappropriate for AES-GCM, since the packet length shifts the first
+  encrypted byte 4 bytes into the block. Additionally, the final part of
+  the block must contain the AES-GCM's Authentication Tag, so it must be
+  presented to the lower encryption layer whole. These requirements mean
+  added code to consolidate blocks as they are passed down.
+  
+  When AES-GCM is negotiated as the cipher, its built-in MAC is
+  automatically used as the SSH MAC so further MAC negotiation is not
+  necessary.  The SSH negotiation is skipped when _libssh2_mac_override()
+  indicates that such a cipher is in use.  The virtual MAC configuration
+  block mac_method_hmac_aesgcm is then used as the MAC placeholder.
+  
+  This work was sponsored by Anders Borum.
+  
+  Integration-patches-by: Viktor Szakats
+  
+  * fix checksrc errors
+  * fix openssl.c warning
+  * fix transport.c warnings
+  * switch to `LIBSSH2_MIN/MAX()` from `MIN()`/`MAX()`
+  * fix indent
+  * fix libgcrypt unused warning
+  * fix mbedtls unused warning
+  * fix wincng unused warning
+  * fix old openssl unused variable warnings
+  * delete blank lines
+  * updates to help merging with the ETM patch
+
+Viktor Szakats (20 Apr 2023)
+- tidy-up: align comments [ci skip]
+
+- tidy-up: whitespace nits [ci skip]
+
+- crypto: add/fix algo guards and extend `NO` options
+  
+  Add new guard `LIBSSH2_RSA_SHA1`. Add missing guards for `LIBSSH2_RSA`,
+  `LIBSSH2_DSA`.
+  
+  Fix warnings when all options are disabled.
+  
+  This is still not complete and it's possible to break a build with
+  certain crypto backends (e.g. mbedTLS) and/or combination of options.
+  It's not guaranteed that all bits everywhere get disabled by these
+  settings. Consider this a "best effort".
+  
+  Add these new options to disable certain crypto elements:
+  - `LIBSSH2_NO_3DES`
+  - `LIBSSH2_NO_AES_CTR`
+  - `LIBSSH2_NO_BLOWFISH`
+  - `LIBSSH2_NO_CAST`
+  - `LIBSSH2_NO_ECDSA`
+  - `LIBSSH2_NO_RC4`
+  - `LIBSSH2_NO_RSA_SHA1`
+  - `LIBSSH2_NO_RSA`
+  
+  The goal is to offer a way to disable legacy/obsolete/insecure ones.
+  
+  See also: 146a25a06dd2365a4330dad34fefcdcee1a206aa `LIBSSH2_NO_HMAC_RIPEMD`
+  See also: 38015f4e46d8dbeea522dc7ee664522d4f47fc75 `LIBSSH2_NO_DSA`
+  See also: be31457f3071686b555a0f0b19e5dcf63d67fc27 `LIBSSH2_NO_MD5`
+  
+  Closes #986
+
+- scp: fix typo in comments [ci skip]
+  
+  Follow-up to 0a500b3554c29451708353279eefce750f4bca6c
+
+- base64: do not use `snprintf()` on encoding
+  
+  This also significantly (by 7-8x in my limited tests with a short
+  string) speeds up this function. The impact is still minor as this
+  function is only used in `knownhost.c` in release builds.
+  
+  Closes #985
+
+- wincng: constify data arg of `libssh2_wincng_hash()`
+  
+  Tested in #979
+
+- wincng: fix unused variables with `LIBSSH2_RSA_SHA2` disabled
+  
+  Tested in #979
+
+- ci: delete config elements for unused 32-bit Linux builds
+  
+  They have been disabled since d9b4222ef1c5ab9b9e499fe6234556e5cca7c4fe
+  
+  Tested in #979
+
+- ci: enable FIXTURE_TRACE_ALL_CONNECT for WinCNG tests
+  
+  To hopefully help finding the WinCNG hostkey verification
+  intermittent failure #804.
+  
+  Tested in #979
+
+- tests: add `FIXTURE_TRACE_ALL_CONNECT` option
+  
+  Works like the `FIXTURE_TRACE_ALL` envvar, but enables full trace for
+  the connection phase only.
+  
+  Also fix a possible NULL deref with `FIXTURE_TRACE_ALL` and a failed
+  `libssh2_session_init_ex()`.
+  
+  Tested in #979
+
+- ci: really enable logging in AppVeyor CMake builds
+  
+  `CONFIGURATION` was never passed to the cmake command, so it had
+  never enabled logging when set to `Debug`.
+  
+  Also `CONFIGURATION` is ambiguous depending on the "generator" used
+  by CMake. In case of Visual Studio, this is a build/ctest-time
+  setting, not a cmake-config parameter.
+  
+  So set this permanently to `Release` and enable logging via our
+  dedicated CMake option `ENABLE_DEBUG_LOGGING`.
+  
+  Tested in #979
+
+- HACKING-CRYPTO: fix stray whitespace
+
+- tidy-up: fix more nits
+  
+  - fix indentation errors.
+  - reformat `cmake/FindmbedTLS.cmake`
+  - replace a macro with a variable in `example/sftp_RW_nonblock.c`.
+  - delete macOS macro `_DARWIN_USE_64_BIT_INODE` from the
+    OS/400 config header, `os400/libssh2_config.h`.
+  - fix other minor nits.
+  
+  Closes #983
 
-- [Thilo Schulz brought this change]
+- mansyntax: make it work on macOS, check reqs locally
+  
+  - use `gman` alias if present. This makes it work when the correct `man`
+    command is provided via `brew` on macOS.
+  
+  - move CMake attempts to detect tools necessary to run `mansyntax.sh`
+    into the script itself.
+  
+  - delete CMake TODO to move more test logic into CMake. This would make
+    it CMake-specific and require maintaining it separately for each build
+    tool. Just use our external script when a POSIX shell is available.
+  
+  Closes #982
 
-  openssl.c : Fix use-after-free crash on reinitialization of openssl backend
+- cmake: dedupe setting `-DHAVE_CONFIG_H`
   
-  file : openssl.c
+  Move `libssh2_config.h` generation and setting `-DHAVE_CONFIG_H` to
+  the root `CMakeFile.txt`.
   
-  notes :
-  libssh2's openssl backend has a use-after-free condition if HAVE_OPAQUE_STRUCTS is defined and you call libssh2_init() again after prior initialisation/deinitialisation of libssh2
+  Also move symbol hiding setup there. It needs to be done before
+  generating the config file for `LIBSSH2_API` value to be set in it.
   
-  credit : Thilo Schulz
+  After this change the `HIDE_SYMBOLS` setting is accepted without an
+  annoying CMake warning when not actually building a shared libssh2 lib.
+  
+  Closes #981
 
-- [axjowa brought this change]
+- build: assume non-blocking I/O on Windows
+  
+  Drop checks from Windows builds and enable it based on `WIN32`.
+  
+  This saves detection time and also makes 3rd party builds simpler.
+  
+  Also:
+  
+  - delete `HAVE_DISABLED_NONBLOCKING`, that we used in build tools to
+    explicitly disable an explicit `#error` in `session.c`.
+  
+  - replace existing `WSAEWOULDBLOCK` check for Windows support with
+    `WIN32`. Cleaner with the same result.
+  
+  Follow-up to f1e80d8d8ce9570d81836da96ba02f4d4552a7b3
+  Follow-up to 5644eea2161b17f7c16e18f3a10465ebb217ca1f
+  
+  Closes #980
 
-  openssl.h : Use of ifdef where if should be used (#389)
+- ci: rename Logging to Debug in AppVeyor
+
+- switch to internal base64 decode that uses size_t
   
-  File : openssl.h
+  Make the public `libssh2_base64_decode()` a wrapper for that.
+  Bump up length sizes in callers.
   
-  Notes :
-  LIBSSH2_ECDSA and LIBSSH2_ED25519 are always defined so the #ifdef
-  checks would never be false.
+  Also fix output size calculation to first divide then multiply.
   
-  This change makes it possible to build libssh2 against OpenSSL built
-  without EC support.
+  Closes #978
+
+- tests: switch to debian:bullseye-slim in Dockerfile
   
-  Change-Id: I0a2f07c2d80178314dcb7d505d1295d19cf15afd
+  'slim' provides all we need, with less bloat.
   
-  Credit : axjowa
+  Tested in #976
+  
+  Follow-up to 78cb64a85955f2cd9700c4fbad3f02d589dd7169
 
-- [Zenju brought this change]
+- tests: build improvements and more
+  
+  - rename tests to have more succint names and a more useful natural
+    order.
+  
+  - rename `simple` and `ssh2` in tests to have the `test_` prefix.
+  
+    This avoids a name collisions with `ssh2` in examples.
+  
+  - cmake: drop the `example-` prefix for generated examples.
+  
+    Bringing their names in sync with other build tools, like autotools.
+  
+  - move common auth test code into the fixture and simplify tests by
+    using that.
+  
+  - move feature guards from CMake to preprocessor for auth tests.
+  
+    Now it works with all build tools and it's easier to keep it in sync
+    with the lib itself.
+  
+    For this we need to include `libssh2_priv.h` in tests, which in turn
+    needs tweaking on the trick we use to suppress extra MSVS warnings
+    when building tests and examples.
+  
+  - move mbedTLS blocklist for crypto tests from CMake to the test
+    fixture.
+  
+  - add ed25519 hostkey tests to `test_hostkey` and `test_hostkey_hash`.
+  
+  - add shell script to regenerate all test keys used for our tests.
+  
+  - alpha-sort tests.
+  
+  - rename `signed_*` keys to begin with `key` like the rest of the keys
+    do.
+  
+  - whitespace fixes.
+  
+  Closes #969
 
-  Agent.c : Preserve error info from agent_list_identities() (#374)
+- autotools: rename a variable
   
-  Files : agent.c
+  To match its counterpart we use for clang and to better match
+  the original code in curl.
   
-  Notes :
-  Currently the error details as returned by agent_transact_pageant() are overwritten by a generic "agent list id failed" message by int agent_list_identities(LIBSSH2_AGENT* agent).
+  Follow-up to ec0feae7920d695ce234a5aba13014bf29824c09
   
-  Credit :
-  Zenju
+  Closes #977
 
-- [Who? Me?! brought this change]
+- ssh2.sh: revert likely wrong quoting [ci skip]
+  
+  Follow-up to 50124428509ffc2f5d08d8d3c152fa36546c9a75
 
-  Channel.c: Make sure the error code is set in _libssh2_channel_open() (#381)
+- build: add `-Wbad-function-cast` picky warning
   
-  File : Channel.c
+  Also adjust minimum gcc versions in comment.
   
-  Notes :
-  if _libssh2_channel_open() fails, set the error code.
+  Closes #975
+
+- tests: restore debian:bullseye in Dockerfile
   
-  Credit :
-  mark-i-m
+  Follow-up to 78cb64a85955f2cd9700c4fbad3f02d589dd7169
 
-- [Orgad Shaneh brought this change]
+- session: simplify preprocessor logic
+  
+  - by using #elif
+  - by merging two blocks
+  
+  Closes #972
 
-  Kex.c, Remove unneeded call to strlen (#373)
+- tests: try debian:testing for Dockerfile
   
-  File : Kex.c
+  Follow-up to 78cb64a85955f2cd9700c4fbad3f02d589dd7169
+
+- src: add and use `LIBSSH2_MIN/MAX` macros
   
-  Notes :
-  Removed call to strlen
+  Also for #797
   
-  Credit :
-  Orgad Shaneh
+  Closes #974
 
-- [Pedro Monreal brought this change]
+- tests: switch Dockerfile to debian:testing-slim
+  
+  From debian:bullseye
+  
+  - doesn't need manual bumps.
+  - is ahead of stable and should be stable enough for our purpose.
+  - slim is saving resources.
+  
+  Closes #971
 
-  Spelling corrections (#380)
+- cmake: optimize non-blocking tests on WIN32/non-WIN32
   
-  Files :
-  libssh2.h, libssh2_sftp.h, bcrypt_pbkdf.c, mbedtls.c, sftp.c, ssh2.c
+  Skip testing unixy methods on Windows and vice versa.
   
-  Notes :
-  * Fixed misspellings
+  I continue to assume that CMake doesn't define `WIN32` with Cygwin
+  (as Cygwin doesn't define `_WIN32`/`WIN32` for C), though I haven't
+  tested this.
   
-  Credit :
-  Pedro Monreal
+  Closes #970
 
-- [Sebastián Katzer brought this change]
+GitHub (15 Apr 2023)
+- [Jörgen Sigvardsson brought this change]
 
-  Fix Potential typecast error for `_libssh2_ecdsa_key_get_curve_type` (#383)
+  scp: option to not quote paths (#803)
   
-  Issue : #383
+  A new flag named `LIBSSH2_FLAG_QUOTE_PATHS` has been added, to make
+  libssh2 not quote file paths sent to the remote's scp subsystem. Some
+  custom ssh daemons cannot handle quoted paths, and this makes this flag
+  useful.
   
-  Files : hostkey.c, crypto.h, openssl.c
+  Authored-by: Jörgen Sigvardsson <jorgen.sigvardsson@westermo.com>
+
+Viktor Szakats (15 Apr 2023)
+- cmake: make Windows builds initialize faster
   
-  Notes :
-  * Fix potential typecast error for `_libssh2_ecdsa_key_get_curve_type`
-  * Rename _libssh2_ecdsa_key_get_curve_type to _libssh2_ecdsa_get_curve_type
+  By skipping unixy header checks that always fail with
+  the MSVC toolchain or all Windows toolchains.
   
-  Credit :
-  Sebastián Katzer
+  Closes #968
 
-GitHub (20 Jun 2019)
-- [Will Cosgrove brought this change]
+- cmake: use a single build rule for all tests
+  
+  - use the complete filename of test sources in the input list.
+  
+  - build all tests with the ability to access libssh2 internals.
+  
+    This is necessary for `test_keyboard_interactive_auth_info_request`
+    now and might be necessary for others in the future, e.g. to avoid
+    the depreacted public base64 decoding API.
+  
+  - move `test_keyboard_interactive_auth_info_request` into the main
+    test build loop.
+  
+  - move `simple` into the main test build loop too.
+  
+  - build `ssh2` also in static mode.
+  
+  - cleanup the way we detect and enable gcov.
+  
+  - fix indentation.
+  
+  Closes #967
 
-  bump copyright date
+- tidy-up: more whitespace in src
+  
+  Closes #966
 
-Version 1.9.0 (19 Jun 2019)
+- checksrc: fix `EQUALSNULL` warnings
+  
+  `s/([a-z0-9._>*-]+) == NULL/!\1/g`
+  
+  Closes #964
 
-GitHub (19 Jun 2019)
-- [Will Cosgrove brought this change]
+- Makefile.am: add new OS400 header [ci skip]
+  
+  Follow-up to 6dc42e9d625deb816a051d312d09e68926959e78
 
-  1.9 Formatting
+- checksrc: fix `NOTEQUALSZERO` warnings
+  
+  Closes #963
 
-- [Will Cosgrove brought this change]
+- checksrc: fix `SIZEOFNOPAREN` warnings
+  
+  `s/sizeof ([a-z0-9._>*-]+)/sizeof(\1)/g`
+  
+  Closes #962
 
-  1.9 Release notes
+- crypto: add `LIBSSH2_NO_HMAC_RIPEMD` option
+  
+  See also: 38015f4e46d8dbeea522dc7ee664522d4f47fc75
+  See also: be31457f3071686b555a0f0b19e5dcf63d67fc27
+  
+  Ref: https://github.com/stribika/stribika.github.io/issues/46
+  
+  Closes #965
 
-Will Cosgrove (17 May 2019)
-- [Alexander Curtiss brought this change]
+- tidy-up: example, tests continued
+  
+  - fix skip auth if `userauthlist` is NULL.
+    Closes #836 (Reported-by: @sudipm-mukherjee on github)
+  - fix most silenced `checksrc` warnings.
+  - sync examples/tests code between each other.
+    (output messages, error handling, declaration order, comments)
+  - stop including unnecessary headers.
+  - always deinitialize in case of error.
+  - drop some redundant variables.
+  - add error handling where missing.
+  - show more error codes.
+  - switch `perror()` to `fprintf()`.
+  - fix some `printf()`s to be `fprintf()`.
+  - formatting.
+  
+  Closes #960
 
-  libgcrypt.c : Fixed _libssh2_rsa_sha1_sign memory leak. (#370)
+- src: fix indentation of macro definitions (follow-up)
   
-  File: libgcrypt.c
+  Follow-up to d5438f4ba9036e8028f35258dd1ab97cc2edb37c
+
+- src: fix indentation of macro definitions
   
-  Notes : Added calls to gcry_sexp_release to free memory allocated by gcry_sexp_find_token
+  And some comment cleanup.
   
-  Credit :
-  Reporter : beckmi
-  PR by: Alexander Curtiss
+  Closes #958
 
-- [Orivej Desh brought this change]
+- example/ssh2_exec: drop conditional code for deprecated API
 
-  libssh2_priv.h : Fix musl build warning on sys/poll.h (#346)
+GitHub (13 Apr 2023)
+- [monnerat brought this change]
+
+  Make OS/400 implementation work again (#953)
   
-  File : libssh2_priv.h
+  * os400: support QADRT development files in a non-standard directory
   
-  Notes :
-  musl prints `redirecting incorrect #include <sys/poll.h> to <poll.h>`
-  http://git.musl-libc.org/cgit/musl/commit/include/sys/poll.h?id=54446d730cfb17c5f7bcf57f139458678f5066cc
+  This enables the possibility to compile libssh2 even if the ascii
+  runtime development files are not installed system-wide.
   
-  poll is defined by POSIX to be in poll.h:
-  http://pubs.opengroup.org/onlinepubs/7908799/xsh/poll.html
+  * userauth_kbd_packet: fix a pointer target type mismatch.
   
-  Credit : Orivej Desh
-
-GitHub (1 May 2019)
-- [Will Cosgrove brought this change]
+  A temporary variable matching the parameter type is used before copying
+  to the real target and checking for overflow (that should not occur!).
+  
+  * os400qc3: move and fix big number procedures
+  
+  A bug added by a previous code style cleaning is fixed.
+  _libssh2_random() now checks and return the success status.
+  
+  * os400qc3: fix cipher definition block lengths
+  
+  They were wrongly set to the key size.
+  
+  * Diffie-Hellman min/max modulus sizes are dependent of crypto-backend
+  
+  In particular, os400qc3 limits the maximum group size to 2048-bits.
+  Move definitions of these parameters to crypto backend header files.
+  
+  * kex: return an error if Diffie-Hellman key pair generation fails
+  
+  * os400: add an ascii assert.h header file
+  
+  * os400qc3: implement RSA SHA2 256/512
 
-  kex.c : additional bounds checks in diffie_hellman_sha1/256 (#361)
+Viktor Szakats (13 Apr 2023)
+- sftp: add open functions with custom attribute support
   
-  Files : kex.c, misc.c, misc.h
+  Before this patch, libssh2 sent hardcoded `LIBSSH2_SFTP_ATTRIBUTES`
+  struct on handle open. This can be problematic on some special OS,
+  where the file size should be known on new file creation. I added
+  two new functions to resolve this issue.
   
-  Notes :
-  Fixed possible out of bounds memory access when reading malformed data in diffie_hellman_sha1() and diffie_hellman_sha256().
+  Patch-by: @vajdaakos on github via #506
   
-  Added _libssh2_copy_string() to misc.c to return an allocated and filled char buffer from a string_buf offset. Removed no longer needed s var in kmdhgGPshakex_state_t.
+  Changes compared to #506:
+  - drop attr size fixup in favour of #946.
+  - move `memcpy()` under the state where we need it.
+  - bump filename length type to `size_t`.
+  - fix filenames in documentation and other nits.
+  
+  Closes #506
+  Closes #947
 
-Will Cosgrove (26 Apr 2019)
-- [Tseng Jun brought this change]
+- build: speed up and extend picky compiler options
+  
+  Implement picky warnings with clang in autotools. Extend picky gcc
+  warnings, sync them between build tools and compilers and greatly
+  speed up detection in CMake.
+  
+  - autotools: enable clang compiler warnings with `--enable-debug`.
+  
+  - autotools: enable more gcc compiler warnings with `--enable-debug`.
+  
+  - autotools/cmake: sync compiler warning options between gcc and clang.
+  
+  - sync compiler warning options between autotools and cmake.
+  
+  - cmake: reduce option-checks to speed up the detection phase.
+    Bring them down to 3 (from 35). Leaving some checks to keep the
+    CMake logic alive and for an easy way to add new options.
+  
+    clang 3.0 (2011-11-29) and gcc 2.95 (1999-07-31) now required.
+  
+  - autotools logic copied from curl, with these differences:
+  
+    - delete `-Wimplicit-fallthrough=4` due to a false positive.
+  
+    - reduce `-Wformat-truncation=2` to `1` due to a false positive.
+  
+    - simplify MinGW detection for `-Wno-pedantic-ms-format`.
+  
+  - cmake: show enabled picky compiler options (like autotools).
+  
+  - cmake: do compile `tests/simple.c` and `tests/ssh2.c`.
+  
+  - fix new compiler warnings.
+  
+  - `tests/CMakeLists.txt`: fix indentation.
+  
+  Original source of autotools logic:
+  - https://github.com/curl/curl/blob/a8fbdb461cecbfe1ac6ecc5d8f6cf181e1507da8/acinclude.m4
+  - https://github.com/curl/curl/blob/a8fbdb461cecbfe1ac6ecc5d8f6cf181e1507da8/m4/curl-compilers.m4
+  
+  Notice that the autotools implementation considers Apple clang as
+  legacy clang 3.7. CMake detection works more accurately, at the same
+  time more error-prone and difficult to update due to the sparsely
+  documented nature of Apple clang option evolution.
+  
+  Closes #952
 
-  sftp.c : sftp_bin2attr() Correct attrs->gid assignment (#366)
+- include: delete leading underscore from macro name
   
-  Regression with fix for #339
+  It can cause compiler warnings in 3rd-party code.
   
-  Credit : Tseng Jun
+  Follow-up to 59666e03f04927e5fe3e8d8772d40729f63c570e
+  
+  Closes #957
 
-- [Tseng Jun brought this change]
+- ci: use OpenSSL 3 on AppVeyor VS2022 images
+  
+  Closes #954
 
-  kex.c : Correct type cast in curve25519_sha256() (#365)
+- build: be friendly with 3rd-party build tools
+  
+  After recent build changes, 3rd party build that took the list of
+  C source to compile them as-is, stopped working as expected, due to
+  `blowfish.c` and crypto-backend C sources no longer expected to compile
+  separately but via `bcrypt_pbkdf.c` and `crypto.c`, respectively.
+  
+  This patch ensures that compiling these files directly result in an
+  empty object instead of redundant code and duplicated symbols.
+  
+  Also:
+  - add a compile-time error if none of the supported crypto backends
+    are enabled.
+  - fix `libssh2_crypto_engine()` for wolfSSL and os400qc3.
+    Rearrange code to avoid a hard-to-find copy of crypto-backend
+    selection guards.
+  
+  Follow-up to 4f0f4bff5a92dce6a6cd7a5600a8ee5660402c3f
+  Follow-up to ff3c774e03585252b70a9ee0fcf254de7b14a767
+  
+  Closes #951
 
-GitHub (24 Apr 2019)
-- [Will Cosgrove brought this change]
+- sftp: calculate attr size based on attr content in `sftp_open()`
+  
+  Improve robustness by replacing constant argument of `sftp_attrsize()`
+  in `sftp_open()` with the actual `flag` value read from the `attr` we
+  plan to transfer. Restores state of this before
+  37624b61e3ec4aa65a608800613d00b55ced56d7.
+  
+  Prerequisite for #947, #506.
+  
+  Also improve readability a bit and link to SFTP specs. Delete comment
+  about version 6: The latest spec no longer features the mentioned
+  "DO NOT IMPLEMENT" notice.
+  
+  Closes #946
 
-  transport.c : scope local total_num var (#364)
+- man: fixups
   
-  file : transport.c
-  notes : move local `total_num` variable inside of if block to prevent scope access issues which caused #360.
+  - add missing `.fi` tags.
+  - fix misplaced `.nf` tags.
+  - add `.nf`/`.fi` tags `SYNOPSIS` where missing.
+  - fix missing/wrong function name from `SH NAME`.
+  - fix wrong function name in `TH`.
+  - keep return values in a separate line.
+  - indent.
+  - fold long lines.
+  - deleted `libssh2_channel_direct_streamlocal()`, there is no such function.
+  - add missing types.
+  - add missing headers.
+  
+  Closes #949
 
-Will Cosgrove (24 Apr 2019)
-- [doublex brought this change]
+- include: indentation fixes
 
-  transport.c : fixes bounds check if partial packet is read
+- tidy-up: misc & minor cmake MSVS fix
   
-  Files : transport.c
+  - `libssh2.rc`: document language/codepage codes.
   
-  Issue : #360
+    Ref: https://learn.microsoft.com/windows/win32/intl/code-page-identifiers
   
-  Notes :
-   'p->total_num' instead of local value total_num when doing bounds check.
+  - convert to Markdown: `docs/BINDINGS`, `docs/HACKING`
   
-  Credit : Doublex
-
-GitHub (23 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Editor config file for source files (#322)
+    Blind update for `vms/libssh2_make_help.dcl`. Please double-check.
   
-  Simple start to an editor config file when editing source files to make sure they are configured correctly.
+  - cmake: fix to recognize dash-style warning options (`-Wn`) with MSVC.
+  
+  - `NMakefile`: sync `rd` command with `Makefile.mk`.
+  
+  - delete a CVS header.
+  
+  - cmake: simplify a `LIBSSH2_HAVE_ZLIB` macro.
+  
+  - few other nits and whitespace mods.
+  
+  Closes #943
 
-- [Will Cosgrove brought this change]
+GitHub (10 Apr 2023)
+- [Viktor Szakats brought this change]
 
-  misc.c : String buffer API improvements (#332)
+  Support for direct-streamlocal@openssh.com UNIX socket connection (#945)
   
-  Files : misc.c, hostkey.c, kex.c, misc.h, openssl.c, sftp.c
+  This patch allow to use direct-streamlocal service from OpenSSH 6.7,
+  that allows UNIX socket connections.
   
-  Notes :
-  * updated _libssh2_get_bignum_bytes and _libssh2_get_string. Now pass in length as an argument instead of returning it to keep signedness correct. Now returns -1 for failure, 0 for success.
+  Mods:
+  - delete unrelated condition:
+    Ref: https://github.com/libssh2/libssh2/pull/216#discussion_r374748111
+  - rebase on master, whitespace updates.
   
-  _libssh2_check_length now returns 0 on success and -1 on failure to match the other string_buf functions. Added comment to _libssh2_check_length.
+  Patch-by: @gjalves Gustavo Junior Alves
   
-  Credit : Will Cosgrove
+  Closes #216
+  Closes #632
+  Closes #945
 
-Will Cosgrove (19 Apr 2019)
-- [doublex brought this change]
+Viktor Szakats (10 Apr 2023)
+- build: support `libssh2.rc` with autotools
+  
+  Caveat: When building `--enable-static` and `--enable-shared` at the
+  same time, the compiled Windows resource is also included in the
+  static library. This appears to be an autotools limitation, with no
+  way to have different input lists (or different custom options) for
+  shared and static libraries, even though it builds them separately.
+  
+  The workaround is to build static libraries in a separate
+  `./configure` + `make` pass.
+  
+  Closes #944
 
-  mbedtls.c : _libssh2_mbedtls_rsa_new_private_frommemory() allow private-key from memory (#359)
+- crypto: add `LIBSSH2_NO_DSA` to disable DSA support
   
-  File : mbedtls.c
+  See also: be31457f3071686b555a0f0b19e5dcf63d67fc27
   
-  Notes: _libssh2_mbedtls_rsa_new_private_frommemory() fixes private-key from memory reading to by adding NULL terminator before parsing; adds passphrase support.
+  Closes #942
+
+- build: unify source lists
   
-  Credit: doublex
+  - introduce `src/crypto.c` as an umbrella source that does nothing else
+    than include the selected crypto backend source. Moving this job from
+    the built-tool to the C preprocessor.
+  
+  - this allows dropping the various techniques to pick the correct crypto
+    backend sources in autotools, CMake and other build method. Including
+    the per-backend `Makefile.<crypto-backend>.inc` makefiles.
+  
+  - copy a trick from curl and instead of maintaining duplicate source
+    lists for CMake, convert the GNU Makefile kept for autotools
+    automatically. Do this in `docs`, `examples` and `src`.
+  
+    Ref: https://github.com/curl/curl/blob/dfabe8bca218d2524af052bd551aa87e13b8a10b/CMakeLists.txt#L1399-L1413
+  
+    Also fixes missing `libssh2_setup.h` from `src/CMakeFiles.txt` after
+    59666e03f04927e5fe3e8d8772d40729f63c570e.
+  
+  - move `Makefile.inc` from root to `src`.
+  
+  - reformat `src/Makefile.inc` to list each source in separate lines,
+    re-align the continuation character and sort the lists alphabetically.
+  
+  - update `docs/HACKING-CRYPTO` accordingly.
+  
+  - autotools: update the way we add crypto-backends to `LIBS`.
+  
+  - delete old CSV headers, indent, and merge two lines in
+    `docs/Makefile.am` and `src/Makefile.am`.
+  
+  - add `libssh2.pc` to `.gitignore`, while there.
+  
+  Closes #941
+
+GitHub (9 Apr 2023)
+- [Zenju brought this change]
 
-- [Ryan Kelley brought this change]
+  sftp: always clear protocol error (#787)
 
-  Session.c : banner_receive() from leaking when accessing non ssh ports (#356)
+Viktor Szakats (9 Apr 2023)
+- cmake: add `HIDE_SYMBOLS` option & do symbol hiding on *nix
   
-  File : session.c
+  - implement symbol hiding on non-Windows platforms.
   
-  Release previous banner in banner_receive() if the session is reused after a failed connection.
+    The essence of the detection logic was copied from:
+    https://github.com/curl/curl/blob/dfabe8bca218d2524af052bd551aa87e13b8a10b/CMake/CurlSymbolHiding.cmake
   
-  Credit : Ryan Kelley
-
-GitHub (11 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Formatting in agent.c
+    Then simplified and shortened. This method doesn't require a recent
+    CMake version, nor an external, auto-generated C header.
   
-  Removed whitespace.
-
-- [Will Cosgrove brought this change]
-
-  Fixed formatting in agent.c
+    Move `configure_file()` after `set(LIBSSH2_API ...)`, for the config
+    file to pick up `LIBSSH2_API`s value.
   
-  Quiet linter around a couple if blocks and pointer.
-
-Will Cosgrove (11 Apr 2019)
-- [Zhen-Huan HWANG brought this change]
-
-  sftp.c : discard and reset oversized packet in sftp_packet_read() (#269)
+    Closes #602
   
-  file : sftp.c
+  - add CMake option `HIDE_SYMBOLS`.
   
-  notes : when sftp_packet_read() encounters an sftp packet which exceeds SFTP max packet size it now resets the reading state so it can continue reading.
+    This setting means to hide non-public functions from the libssh2
+    dynamic library when set to `ON`. The default.
   
-  credit : Zhen-Huan HWANG
-
-GitHub (11 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Add agent functions libssh2_agent_get_identity_path() and libssh2_agent_set_identity_path() (#308)
+    When set to `OFF`, make all non-static/internal functions visible
+    in the dynamic library.
   
-  File : agent.c
+    This setting requires `BUILD_SHARED_LIBS=ON`.
   
-  Notes :
-  Libssh2 uses the SSH_AUTH_SOCK env variable to read the system agent location. However, when using a custom agent path you have to set this value using setenv which is not thread-safe. The new functions allow for a way to set a custom agent socket path in a thread safe manor.
+  - honor this setting on Windows.
+  
+    By setting the `LIBSSH2_EXPORTS` manual macro again, and stop
+    recognizing the automatic CMake macro for this purpose:
+    `libssh2_shared_EXPORT`.
+  
+  Closes #939
 
-- [Will Cosgrove brought this change]
+- build: make `windows.h` even leaner
+  
+  Disable GDI and NLS features in `windows.h`. libssh2 doesn't use these.
+  
+  Closes #940
 
-  Simplified _libssh2_check_length (#350)
+- blowfish: build improvements
   
-  * Simplified _libssh2_check_length
+  - include `blowfish.c` into `bcrypt_pbkdf.c`, instead of
+    compiling it as a distinct object.
   
-  misc.c : _libssh2_check_length()
+  - make low-level blowfish functions static. This prevents this symbols
+    to pollute the public namespace of libssh2. It also allows the
+    compiler to inline these functions.
   
-  Removed cast and improved bounds checking and format.
+  - integrate `blf.h` header into `bcrypt_pbkdf.c` as well.
   
-  Credit : Yuriy M. Kaminskiy
-
-- [Will Cosgrove brought this change]
-
-  _libssh2_check_length() : additional bounds check (#348)
+  - use `_DEBUG_BLOWFISH` instead of `#if 0`.
   
-  Misc.c : _libssh2_check_length()
+  - fix `_DEBUG_BLOWFISH` compiler warnings and other nits.
   
-  Ensure the requested length is less than the total length before doing the additional bounds check
-
-Daniel Stenberg (25 Mar 2019)
-- misc: remove 'offset' from string_buf
+  - `#undef` `inline` before redefining it in `libssh2_priv.h`.
+    (copied from `blowfish.c`)
   
-  It isn't necessary.
+  - delete unused `inline` redefinitions from `blowfish.c`.
   
-  Closes #343
+  - disable unused low-level blowfish functions.
+  
+  - formatting, header order.
+  
+  Closes #938
 
-- sftp: repair mtime from e1ead35e475
+- libssh2.rc: fix debug flag, other cleanups
   
-  A regression from e1ead35e4759 broke the SFTP mtime logic in
-  sftp_bin2attr
+  - fix to use `LIBSSH2DEBUG` macro to set the debug flag.
+    (was `DEBUGBUILD`, a curl-specific macro)
   
-  Also simplified the _libssh2_get_u32/u64 functions slightly.
+  - use manifest constants instead of literals
   
-  Closes #342
+  - change language to neutral
+  
+  Closes #937
 
-- session_disconnect: don't zero state, just clear the right bit
+- tidy-up: example, tests
   
-  If we clear the entire field, the freeing of data in session_free() is
-  skipped. Instead just clear the bit that risk making the code get stuck
-  in the transport functions.
+  - drop unnecessary `WIN32`-specific branches.
   
-  Regression from 4d66f6762ca3fc45d9.
+  - add `static`.
   
-  Reported-by: dimmaq on github
-  Fixes #338
-  Closes #340
-
-- libssh2_sftp.h: restore broken ABI
+  - sync header inclusion order.
   
-  Commit 41fbd44 changed variable sizes/types in a public struct which
-  broke the ABI, which breaks applications!
+  - sync some common code between examples/tests.
   
-  This reverts that change.
+  - fix formatting/indentation.
   
-  Closes #339
+  - fix some `checksrc` errors not caught by `checksrc`.
+  
+  Closes #936
 
-- style: make includes and examples code style strict
+- tests/mansyntax.sh: avoid `if !` for portability
   
-  make travis and the makefile rule verify them too
+  Ref: https://www.gnu.org/software/autoconf/manual/autoconf-2.69/html_node/Limitations-of-Builtins.html#Limitations-of-Builtins
   
-  Closes #334
+  Fixes #704
+  Closes #935
 
-GitHub (21 Mar 2019)
-- [Daniel Stenberg brought this change]
+- tidy-up: indentation in guarded #includes [ci skip]
 
-  create a github issue template
+- Makefile.mk: drop `PROOT` variable [ci skip]
 
-Daniel Stenberg (21 Mar 2019)
-- stale-bot: activated
+- build: hand-crafted config rework & header tidy-up
   
-  The stale bot will automatically mark stale issues (inactive for 90
-  days) and if still untouched after 21 more days, close them.
+  - introduce the concept of a project level setup header
+    `src/libssh2_setup.h`, that is used by `src`, `example` and `tests`
+    alike. Move there all common platform/compiler configuration from
+    `src/libssh2_priv.h`, individual sources and `CMakeFiles.txt` files.
+    Also move there our hand-crafted (= not auto-generated by CMake or
+    autotools) configuration `win32/libssh2-config.h`.
   
-  See https://probot.github.io/apps/stale/
-
-- libssh2_session_supported_algs.3: fix formatting mistakes
+  - `win32` directory is empty now, delete it.
   
-  Reported-by: Max Horn
-  Fixes #57
-
-- [Zenju brought this change]
-
-  libssh2.h: Fix Error C2371 'ssize_t': redefinition
+  - `Makefile.mk`: adapt to the above. Build-directory is the target
+    triplet, or any custom name set via `BLD_DIR`.
   
-  Closes #331
-
-- travis: add code style check
+  - sync header path order between build systems:
+    build/src -> source/src -> source/include
   
-  Closes #324
-
-- code style: unify code style
+  - delete redundant references to `windows.h`, `winsock2.h`,
+    `ws2tcpip.h`.
   
-  Indent-level: 4
-  Max columns: 79
-  No spaces after if/for/while
-  Unified brace positions
-  Unified white spaces
-
-- src/checksrc.pl: code style checker
+  - delete unnecessary #includes, update order (`libssh2_setup.h` first,
+    `winsock2.h` first), simplify where possible.
   
-  imported as-is from curl
-
-Will Cosgrove (19 Mar 2019)
-- Merge branch 'MichaelBuckley-michaelbuckley-security-fixes'
-
-- Silence unused var warnings (#329)
+    This makes the code warning-free without `WIN32_LEAN_AND_MEAN`.
+    At the same time this patch applies this macro globally, to avoid
+    header bloat.
   
-  Silence warnings about unused variables in this test
-
-- Removed unneeded > 0 check
+  - example: add missing *nix header guards.
   
-  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
-
-- [Matthew D. Fuller brought this change]
-
-  Spell OpenSS_H_ right when talking about their specific private key (#321)
+  - example: fix misindented `HAVE_UNISTD_H` `#ifdef`s.
   
-  Good catch, thanks.
-
-GitHub (19 Mar 2019)
-- [Will Cosgrove brought this change]
-
-  Silence unused var warnings (#329)
+  - set `WIN32` with all build-tools.
   
-  Silence warnings about unused variables in this test
-
-Michael Buckley (19 Mar 2019)
-- Fix more scope and printf warning errors
-
-- Silence unused variable warning
-
-GitHub (19 Mar 2019)
-- [Will Cosgrove brought this change]
-
-  Removed unneeded > 0 check
+  - set `HAVE_SYS_PARAM_H` in the hand-crafted config for MinGW.
+    To match auto-detection.
   
-  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
-
-Will Cosgrove (19 Mar 2019)
-- [Matthew D. Fuller brought this change]
-
-  Spell OpenSS_H_ right when talking about their specific private key (#321)
+  - move a source-specific macro to `misc.c` from `libssh2_priv.h`.
   
-  Good catch, thanks.
+  See the PR's individual commits for step-by-step updates.
+  
+  Closes #932
 
-Michael Buckley (18 Mar 2019)
-- Fix errors identified by the build process
+- Makefile.mk: build tests and other improvements [ci skip]
+  
+  - use `example` target for building examples (was: `test`).
+  
+  - add support for building tests via the `test` target.
+  
+  - accept lib-only options in a new `LIBSSH2_CPPFLAGS_LIB` variable.
+  
+    Useful to pass `-DLIBSSH2_EXPORTS` for correct `dllexport` in
+    `libssh2.dll`.
+  
+  - fix to put dynamic library in lib directory for non-Windows builds
+  
+  - fix to not delete lib objects on `testclean`
 
-- Fix casting errors after merge
+- test_warmup: re-implement as `test()`
+  
+  Instead of overriding `main()`. To align with the other tests.
+  
+  Overriding `main()` can cause duplicate symbols without using a lib for
+  the `runner` code.
+  
+  Follow-up to 40ac6b230a309d35c57aa65a8f6d7ab6654aa3d8
+  
+  Closes #934
 
-GitHub (18 Mar 2019)
-- [Michael Buckley brought this change]
+- NMakefile: drop `/DEBUG` linker option in release mode [ci skip]
 
-  Merge branch 'master' into michaelbuckley-security-fixes
+- NMakefile: simplify [ci skip]
 
-Michael Buckley (18 Mar 2019)
-- Move fallback SIZE_MAX and UINT_MAX to libssh2_priv.h
+- Makefile.mk: merge two rules [ci skip]
 
-- Fix type and logic issues with _libssh2_get_u64
+- TODO: update item about compiler warnings [ci skip]
+  
+  Follow-up to 08354e0abbe86d4cc5088d210d53531be6d8981a
+  Follow-up to 29347905721d2e7fbb97dabfb0071bee51db3013
+  Follow-up to 5a96f494ee0b00282afb2db2e091246fc5e1774a
+  Follow-up to 463449fb9ee7dbe5fbe71a28494579a9a6890d6d
+  Follow-up to 02f2700a61157ce5a264319bdb80754c92a40a24
 
-Daniel Stenberg (17 Mar 2019)
-- examples: fix various compiler warnings
+GitHub (5 Apr 2023)
+- [ihsinme brought this change]
 
-- lib: fix various compiler warnings
+  example/x11: Add null-termination (#749)
 
-- session: ignore pedantic warnings for funcpointer <=> void *
+Viktor Szakats (5 Apr 2023)
+- crypto: fix `LIBSSH2_NO_MD5` compiler warnings
+  
+  Follow-up to be31457f3071686b555a0f0b19e5dcf63d67fc27
+  
+  Closes #933
 
-- travis: add a build using configure
+- build: add new man pages
   
-  Closes #320
+  Follow-up to c20c81ab105cdf27f5a4e2604bd13085f46e21de
 
-- configure: provide --enable-werror
+GitHub (5 Apr 2023)
+- [Daniel Silverstone brought this change]
 
-- appveyor: remove old builds that mostly cause failures
+  Configurable session read timeout (#892)
   
-  ... and only run on master branch.
+  This set of changes provides a mechanism to runtime-configure the
+  previously #define'd timeout for reading packets from a session. The
+  intention here is to also extend libcurl to be able to use this
+  interface so that when fetching from sftp servers which are very slow
+  to return directory listings, connections do not time-out so much.
   
-  Closes #323
-
-- cmake: add two missing man pages to get installed too
+  * Add new field to session to hold configurable read timeout
   
-  Both libssh2_session_handshake.3 and
-  libssh2_userauth_publickey_frommemory.3 were installed by the configure
-  build already.
+  * Updated `_libssh2_packet_require()`, `_libssh2_packet_requirev()`,
+    and `sftp_packet_requirev()` to use new field in session structure
   
-  Reported-by: Arfrever on github
-  Fixes #278
-
-- include/libssh2.h: warning: "_WIN64" is not defined, evaluates to 0
+  * Updated docs for API functions to set/get read timeout field in
+    session structure
   
-  We don't use #if for defines that might not be defined.
+  * Updated `libssh2.h` to declare the get/set read timeout functions
+  
+  Co-authored-by: Jon Axtell <jon.axtell@codethink.co.uk>
+  Credit: Daniel Silverstone
 
-- pem: //-comments are not allowed
+Viktor Szakats (4 Apr 2023)
+- cmake: whitespace fixes [ci skip]
 
-Will Cosgrove (14 Mar 2019)
-- [Daniel Stenberg brought this change]
+- libssh2.h: bump LIBSSH2_COPYRIGHT year [ci skip]
 
-  userauth: fix "Function call argument is an uninitialized value" (#318)
+- Makefile.mk: move portable GNU Make file to the root
   
-  Detected by scan-build.
+  Move the GNU Make file formerly known as `win32/GNUmakefile` to the
+  root directory from `win32`. It now supports any platform with a
+  GCC-like toolchain, while also keeping support for win32.
+  
+  For non-Windows platforms it's necessary to provide a hand-crafted
+  `libssh2_config.h` header for now.
+  
+  Usage: `make -f Makefile.mk`
 
-- fixed unsigned/signed issue
+- src: include `limits.h` for `*_MAX` macros
+  
+  Follow-up to 5a96f494ee0b00282afb2db2e091246fc5e1774a
+  
+  Reported-by: OldWorldOrdr on github
+  Fixes #928
+  Closes #930
 
-Daniel Stenberg (15 Mar 2019)
-- session_disconnect: clear state
+- build: MSVS warning suppression option tidy-up
   
-  If authentication is started but not completed before the application
-  gives up and instead wants to shut down the session, the '->state' field
-  might still be set and thus effectively dead-lock session_disconnect.
+  - in `win32/libssh2_config.h` replace `_CRT_SECURE_NO_DEPRECATE` with
+    `_CRT_SECURE_NO_WARNINGS`, to use the official macro for this, like
+    in CMake.
   
-  This happens because both _libssh2_transport_send() and
-  _libssh2_transport_read() refuse to do anything as long as state is set
-  without the LIBSSH2_STATE_KEX_ACTIVE bit.
+    Also, it's now safe to move it back under `_MSC_VER`.
   
-  Reported in curl bug https://github.com/curl/curl/issues/3650
+    Suppressing:
   
-  Closes #310
-
-Will Cosgrove (14 Mar 2019)
-- Release notes from 1.8.1
-
-Michael Buckley (14 Mar 2019)
-- Use string_buf in sftp_init().
-
-- Guard against out-of-bounds reads in publickey.c
-
-- Guard against out-of-bounds reads in session.c
-
-- Guard against out-of-bounds reads in userauth.c
-
-- Use LIBSSH2_ERROR_BUFFER_TOO_SMALL instead of LIBSSH2_ERROR_OUT_OF_BOUNDARY in sftp.c
-
-- Additional bounds checking in sftp.c
-
-- Additional length checks to prevent out-of-bounds reads and writes in _libssh2_packet_add(). https://libssh2.org/CVE-2019-3862.html
-
-- Add a required_size parameter to sftp_packet_require et. al. to require callers of these functions to handle packets that are too short. https://libssh2.org/CVE-2019-3860.html
-
-- Check the length of data passed to sftp_packet_add() to prevent out-of-bounds reads.
-
-- Prevent zero-byte allocation in sftp_packet_read() which could lead to an out-of-bounds read. https://libssh2.org/CVE-2019-3858.html
-
-- Sanitize padding_length - _libssh2_transport_read(). https://libssh2.org/CVE-2019-3861.html
+    `warning C4996: 'fopen': This function or variable may be unsafe. Consider using fopen_s instead.`
+    `warning C4996: 'getenv': This function or variable may be unsafe. Consider using _dupenv_s instead.`
   
-  This prevents an underflow resulting in a potential out-of-bounds read if a server sends a too-large padding_length, possibly with malicious intent.
+  - move `_CRT_NONSTDC_NO_DEPRECATE` to `example` and `tests`.
+    Not needed for `src`.
+  
+    Suppressing:
+  
+    `warning C4996: 'strdup': The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name: _strdup.`
+    `warning C4996: 'write': The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name: _write.`
+  
+  - move `_WINSOCK_DEPRECATED_NO_WARNINGS` from source files to
+    CMake files, in `example` and `tests`. Also limit this to MSVC.
+  
+    Suppressing:
+  
+    `warning C4996: 'inet_addr': Use inet_pton() or InetPton() instead`
+  
+  TODO: try fixing these instead of suppressing.
+  
+  Closes #929
 
-- Defend against writing beyond the end of the payload in _libssh2_transport_read().
+- win32/GNUmakefile: make it movable [ci skip]
+  
+  - add `BLD_DIR` to customize the output directory (where libs, .zip,
+    obj subdir will go). This directory must exist.
+  
+    It remains `./win32` for Windows builds.
+  
+  - add `CONFIG_H_DIR` option to customize `libssh2_config.h` location.
+  
+    It remains `./win32` for Windows builds.
+  
+  - include `.def` in distro zip for Windows.
+  
+  - ready to move to the root directory.
 
-- Defend against possible integer overflows in comp_method_zlib_decomp.
+- win32/GNUmakefile: drop an unnecessary variable [ci skip]
 
-GitHub (14 Mar 2019)
-- [Will Cosgrove brought this change]
+- windows: re-add `libssh2.rc`
+  
+  Lost while moving it from the win32 directory
+  
+  Follow-up to 194cfc0f84192809c87f846140e5bf06b7a864af
 
-  Security fixes (#315)
+- crypto: add `LIBSSH2_NO_MD5` to disable MD5 support
   
-  * Bounds checks
+  Closes #927
+
+- hostkey: fix `hash_len` field constants
   
-  Fixes for CVEs
-  https://www.libssh2.org/CVE-2019-3863.html
-  https://www.libssh2.org/CVE-2019-3856.html
+  Replace incorrect `MD5_DIGEST_LENGTH` with `SHA_DIGEST_LENGTH` for these
+  hostkey algos:
   
-  * Packet length bounds check
+  - `ssh-rsa` and `ssh-dss`
   
-  CVE
-  https://www.libssh2.org/CVE-2019-3855.html
+    Ref: 7a5ffc8cee259bbde82ab92515cd8fea2166854b (2004-12-07 Initial)
   
-  * Response length check
+  - `ssh-rsa-cert-v01@openssh.com`
   
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
+    Ref: 4b21e49d9d2db74579b18804ed1f5eeb16578b2f (2022-07-28)
+    Ref: #710
   
-  * Bounds check
+  Also delete local fall-back definition of `MD5_DIGEST_LENGTH` (added
+  in 9af7eb48dc3854ce8ee0589f7e2beb944e064847). Macro is no longer used.
   
-  CVE
-  https://www.libssh2.org/CVE-2019-3857.html
+  Reported-by: Markus-Schmidt on github
+  Fixes #919
+  Closes #926
+
+- ci: add MSVS 2008/2010 build tests and fix warnings
   
-  * Bounds checking
+  Also:
   
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
+  - fix newly surfaced (bogus) warnings in examples with MSVS 2010:
   
-  and additional data validation
+    ```
+    ..\..\example\direct_tcpip.c(262): warning C4127: conditional expression is constant
+    ```
+    Happens for every `FD_SET()` macro reference.
   
-  * Check bounds before reading into buffers
+    Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46677835/job/ni4hs97bh18c14ap
   
-  * Bounds checking
+  - silence MSVS 2010 predefined Windows macro warnings:
   
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
+    ```
+    ..\..\src\wincng.c(867): warning C4306: 'type cast' : conversion from 'int' to 'LPCSTR' of greater size
+    ..\..\src\wincng.c(897): warning C4306: 'type cast' : conversion from 'int' to 'LPCSTR' of greater size
+    ..\..\src\wincng.c(1132): warning C4306: 'type cast' : conversion from 'int' to 'LPCSTR' of greater size
+    ```
   
-  * declare SIZE_MAX and UINT_MAX if needed
-
-- [Will Cosgrove brought this change]
-
-  fixed type warnings (#309)
-
-- [Will Cosgrove brought this change]
-
-  Bumping version number for pending 1.8.1 release
-
-Will Cosgrove (4 Mar 2019)
-- [Daniel Stenberg brought this change]
-
-  _libssh2_string_buf_free: use correct free (#304)
+    Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46678071/job/08t5ktvkcgdghp7r
   
-  Use LIBSSH2_FREE() here, not free(). We allow memory function
-  replacements so free() is rarely the right choice...
-
-GitHub (26 Feb 2019)
-- [Will Cosgrove brought this change]
+  Closes #925
 
-  Fix for building against libreSSL #302
+- transport: rename local `RANDOM_PADDING` macro
   
-  Changed to use the check we use elsewhere.
+  Rename `RANDOM_PADDING` macro used internally to enable some code.
+  
+  Committed in the initial version of `transport.c` in
+  9d55db6501aa4e21f0858cf36cdc2ddc11b96e83 (2007-02-02). libssh2 code
+  never defined it.
+  
+  The name happens to collide with a Windows macro in `wincrypt.h`.
+  `transport.c` doesn't include this header, but it includes `winsock2.h`,
+  and it turns out it can also define this macro in some cases, e.g.
+  when `WIN32_LEAN_AND_MEAN` is not set.
+  
+  To be on the safe side, prefix the name with `LIBSSH2_` to avoid
+  enabling it by accident.
+  
+  Q: Maybe it'd be best to delete it with the guarded code?
+  
+  Reported-by: Markus-Schmidt on github
+  Fixes #921
+  Closes #924
 
-- [Will Cosgrove brought this change]
+- windows: move `libssh2.rc` to the `src` directory
+  
+  Closes #918
 
-  Fix for when building against LibreSSL #302
+- autotools: delete unused conditional `HAVE_SYS_UN_H`
+  
+  No longer necessary after moving the disabling/enabling logic from
+  build tool to `example/x11.c`.
+  
+  Reverts 4774d500e724bc4e548f743a0cb644ab05599474
+  Follow-up to d245c66cc0029e480674394c23e8be1c9410f7ad
 
-Will Cosgrove (25 Feb 2019)
-- [gartens brought this change]
+- win32/GNUmakefile: update help & exit without crypto backend [ci skip]
+  
+  Follow-up to: 5bcd25c4c980e9765c00a2f20ac5348635063aad
+  Follow-up to: 68fd02fba002c8c6af3ba51a2780de46b47b3787
 
-  docs: update libssh2_hostkey_hash.3 [ci skip] (#301)
+- build: respect autotools `DLL_EXPORT` in `libssh2.h`
+  
+  The `DLL_EXPORT` macro is automatically set by autotools when building
+  the libssh2 DLL. Certain toolchains might require this to correctly
+  export symbols, so make sure to respect it in `libssh2.h` to enable
+  `declspec(dllexport)`.
+  
+  With this patch we have a manual macro for that (`LIBSSH2_EXPORT`),
+  this autotools one, the CMake one, and `_WINDLL` (added in
+  c355d31ff94a1622526c4988b9d09074f7f7605d), possibly defined by Visual
+  Studio.
+  
+  Closes #917
 
-GitHub (21 Feb 2019)
-- [Will Cosgrove brought this change]
+- build: make `HAVE_LIBCRYPT32` local to `wincng.c`
+  
+  libssh2 uses `wincrypt.h` aka the `crypt32` Windows system library
+  for the function `CryptDecodeObjectEx()` [1]. This function has been
+  available for Win32 (and UWP/WinRT apps) for a long while. Even old
+  MinGW supports it, and also Watcom 1.9, of the rare/old compilers
+  I checked.
+  
+  CMake had it permanently enabled, while it also did an extra check
+  for the header to add the lib to the lib list. Autotools did the
+  detection proper. Other builds had it permanently enabled.
+  
+  It seems safe to assume this function/header/lib is available in all
+  environments we support.
+  
+  In this patch we simplify by deleting these detections and feature
+  flags from all build tools.
+  
+  Keep the feature flag internal to `wincng.h`, and for extra safety add
+  the new macro `LIBSSH2_WINCNG_DISABLE_WINCRYPT` do disable it via
+  custom `CPPFLAGS`.
+  
+  WinCNG's other requirement is `bcrypt`. That also has been universally
+  available for a long time. Here the only known outlier is old/legacy
+  MinGW, which is missing support.
+  
+  [1] https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptdecodeobjectex
+  
+  Closes #916
 
-  fix malloc/free mismatches #296 (#297)
+- autotools: delete `src/libssh2.pc.in` reference [ci skip]
+  
+  Follow-up to 06f281921907fa077884c7020917661ca805b9d3
 
-- [Will Cosgrove brought this change]
+- tidy-up: null-mac/cipher documentation
+  
+  Move documentation for these deleted build-level options from
+  autotools/cmake docs to the source code itself.
+  
+  Follow-up to 50c9bf868e833258d23c5f55ed546d1fcd5687d0
+  
+  Closes #915
 
-  Replaced malloc with calloc #295
+- cmake: re-use existing `libssh2.pc` template
+  
+  Instead of maintaining a second copy of `libssh2.pc.in` in `src` just
+  for CMake, teach CMake to use the existing template in the root dir,
+  that we already use with autotools.
+  
+  Closes #914
 
-- [Will Cosgrove brought this change]
+- delete redundant `HAVE_STDLIB_H`
+  
+  libssh2 used this standard C89 header unconditionally before this patch.
+  
+  Delete the feature checks and all unnecessary header guards.
+  
+  Closes #913
 
-  Abstracted OpenSSL calls out of hostkey.c (#294)
+- NMakefile: drop redundant variable and assignments [ci skip]
 
-- [Will Cosgrove brought this change]
+- delete redundant `HAVE_WINSOCK2_H`
+  
+  `libssh2.h` required `winsock2.h` for `_WIN32` since
+  81d53de4dc5ee39bd6215958c7dce3b12731195e (2011-06-04).
+  
+  Apply that to the whole codebase. This makes it unnecessary to detect
+  `HAVE_WINSOCK2_H` and allows to drop all its uses.
+  
+  Completes TODO from b66d7317ca6c882afbe52fe426f68c119c40d348
+  
+  TODO: Straighten out the use a mixture of `HAVE_WINDOWS_H`,
+        `WIN32`, `_WIN32` to detect Windows.
 
-  Fix memory dealloc impedance mis-match #292 (#293)
+- cmake: detect WinCNG last
   
-  When using ed25519 host keys and a custom memory allocator.
+  This gives a chance to auto-detect mbedTLS on Windows with CMake.
 
-- [Will Cosgrove brought this change]
+- NMakefile: rename config variables, default to WinCNG [ci skip]
+  
+  - replace `OPENSSLINC` and `OPENSSLLIB` with `OPENSSL_PATH`.
+    Assume `include` and `lib` subdirs for headers and libs.
+  
+  - replace `WITH_ZLIB`, `ZLIBINC` and `ZLIBLIB` with `ZLIB_PATH`.
+    Assume `include` and `lib` subdirs for header and lib.
+  
+  - make WinCNG the default if `WITH_OPENSSL` is not set.
 
-  Added call to OpenSSL_add_all_digests() #288
+- win32/GNUmakefile: rename object dir and update .gitignore [ci skip]
   
-  For OpenSSL 1.0.x we need to call OpenSSL_add_all_digests().
+  From `<triplet>-{release|debug}` to `{release|debug}-<triplet>`.
+  
+  Follow-up to 68fd02fba002c8c6af3ba51a2780de46b47b3787
 
-Will Cosgrove (12 Feb 2019)
-- [Zhen-Huan HWANG brought this change]
+- win32/GNUmakefile: add libgcrypt support [ci skip]
+  
+  In the previous commit 969487113aae856e43d3d905c3f2260246d44f9b,
+  the commit message should read `win32/GNUmakefile: ` instead of
+  `libssh2-gnumake.sh: `. Sorry for the mixup.
 
-  SFTP: increase maximum packet size to 256K (#268)
+- libssh2-gnumake.sh: make variable names platform-agnostic [ci skip]
   
-  to match implementations like OpenSSH.
+  Also more consistent. Refer to DLL/SO/shared as 'dyn'.
+  
+  Also add comment on how to find customizable environment variables.
 
-- [Zenju brought this change]
+- win32/GNUmakefile: make it support non-Windows builds [ci skip]
+  
+  With 20-ish extra lines, make this Makefile support all GCC-like
+  toolchains.
+  
+  The temporary directory becomes `<triplet>-{release|debug}` from
+  the former `{release|debug}`.
+  
+  Also change the lib directory name in the `dist` package from
+  `win32` to `lib`, to match other packages and build tools.
 
-  Fix https://github.com/libssh2/libssh2/pull/271 (#284)
+- win32/GNUmakefile: default to WinCNG [ci skip]
+  
+  Also check for wolfSSL before mbedTLS to match CMake.
 
-GitHub (16 Jan 2019)
-- [Will Cosgrove brought this change]
+- win32/GNUmakefile: fixups to previous commit [ci skip]
+  
+  - `-lws2_32` is necessary when building examples.
+  
+  - drop a temporary variable.
+  
+  Follow-up to d245c66cc0029e480674394c23e8be1c9410f7ad
 
-  Agent NULL check in shutdown #281
+- delete redundant `HAVE_WS2TCPIP_H`
+  
+  It was used once in `src/libssh2_priv.h`, but without any effect.
+  The header included `ws2tcpip.h` twice, once guarded by
+  `HAVE_WS2TCPIP_H` and another time by `HAVE_WINSOCK2_H`.
+  
+  Dedupe these to not use `HAVE_WS2TCPIP_H`. Then delete detection
+  of this feature from all build methods.
+  
+  TODO: Replace `HAVE_WINSOCK2_H` with `_WIN32`/`WIN32`.
 
-Will Cosgrove (15 Jan 2019)
-- [Adrian Moran brought this change]
+- win32/libssh2_config.h: set `HAVE_LONGLONG` & `HAVE_STDLIB_H` [ci skip]
+  
+  - enable `HAVE_LONGLONG` for MinGW and MSVC versions supporting it.
+  
+    Necessary for `GNUmakefile`/`NMakefile` builds to create the same
+    binaries as CMake/autotools ones do.
+  
+  - enable `HAVE_STDLIB_H`. It has been universally available on
+    Windows for a long time.
+  
+    Fixes these clang-cl warnings:
+    ```
+    src\wincng.c(444,5) :  warning: implicit declaration of function 'free' is invalid in C99 [-Wimplicit-function-declaration]
+        free(buf);
+        ^
+    src\wincng.c(491,20) :  warning: implicitly declaring library function 'malloc' with type 'void *(unsigned long long)' [-Wimplicit-function-declaration]
+        pbHashObject = malloc(dwHashObject);
+                       ^
+    src\wincng.c(491,20) :  note: include the header <stdlib.h> or explicitly provide a declaration for 'malloc'
+    src\wincng.c(2106,14) :  warning: implicitly declaring library function 'realloc' with type 'void *(void *, unsigned long long)' [-Wimplicit-function-declaration]
+        bignum = realloc(bn->bignum, length);
+                 ^
+    src\wincng.c(2106,14) :  note: include the header <stdlib.h> or explicitly provide a declaration for 'realloc'
+    3 warnings generated.
+    ```
 
-  mbedtls: Fix leak of 12 bytes by each key exchange. (#280)
+- example: make `x11` exclusion build-tool-agnostic
   
-  Correctly free ducts by calling _libssh2_mbedtls_bignum_free() in dtor.
+  Whether to build the `x11` example or not was decided by each build
+  tool. CMake didn't build it even on supported platforms. GNUMakefile
+  used a specific blocklist for it, while autotools enabled it based on
+  feature-detection.
+  
+  Migrate the enabler logic to an #ifdef in source and build `x11`
+  unconditionally with all build tools.
+  
+  On unsupported platforms (=Windows) this program now displays a short
+  message stating that fact.
+  
+  Also:
+  
+  - fix `x11.c` warnings uncovered after CMake started building it.
+  
+  - use `libssh2_socket_t` type for portability in `x11.c` too.
+  
+  - use detected header guards in `x11.c`.
+  
+  - delete a duplicate reference to `-lws2_32` from `win32/GNUmakefile`
+    while there.
+  
+  Closes #909
 
-- [alex-weaver brought this change]
+- .gitignore updates [ci skip]
 
-  Fix error compiling on Win32 with STDCALL=ON (#275)
+- tidy-up: whitespace, sorting, comment and naming fixups
 
-GitHub (8 Nov 2018)
-- [Will Cosgrove brought this change]
+- cmake: add missing man pages
 
-  Allow default permissions to be used in sftp_mkdir (#271)
+- cmake: dedupe and merge config detection
   
-  Added constant LIBSSH2_SFTP_DEFAULT_MODE to use the server default permissions when making a new directory
-
-Will Cosgrove (13 Sep 2018)
-- [Giulio Benetti brought this change]
-
-  openssl: fix dereferencing ambiguity potentially causing build failure (#267)
+  Before this patch CMake did feature detections in three files:
+  `src/CMakefiles.txt`, `examples/CMakefiles.txt` and
+  `tests/CMakefiles.txt`.
   
-  When dereferencing from *aes_ctr_cipher, being a pointer itself,
-  ambiguity can occur; fixed possible build errors.
-
-Viktor Szakats (12 Sep 2018)
-- win32/GNUmakefile: define HAVE_WINDOWS_H
+  Merge and move them to the root `CMakefiles.txt`.
   
-  This macro was only used in test/example code before, now it is
-  also used in library code, but only defined automatically by
-  automake/cmake, so let's do the same for the standalone win32
-  make file.
+  After this patch we end up with a single `src/libssh2_config.h`. This
+  brings CMake in sync with autotools builds, which already worked with
+  a single config header.
   
-  It'd be probably better to just rely on the built-in _WIN32 macro
-  to detect the presence of windows.h though. It's already used
-  in most of libssh2 library code. There is a 3rd, similar macro
-  named LIBSSH2_WIN32, which might also be replaced with _WIN32.
+  This also prevents mistakes where feature detection went out of sync
+  between `src` & `tests` (see ae90a35d15d97154ac0c8554bce99ebfb18ee825).
+  `tests` do compile sources from `src` directly, so these should always
+  be in sync.
   
-  Ref: https://github.com/libssh2/libssh2/commit/8b870ad771cbd9cd29edbb3dbb0878e950f868ab
-  Closes https://github.com/libssh2/libssh2/pull/266
-
-Marc Hoersken (2 Sep 2018)
-- Fix conditional check for HAVE_DECL_SECUREZEROMEMORY
+  It also allows to better integrate hand-crafted, platform-specific
+  config headers into the builds, like the one currently residing in
+  the `win32` directory (and also in `vms` and `os400`). Subject to an
+  upcoming PR.
   
-  "Unlike the other `AC_CHECK_*S' macros, when a symbol is not declared,
-  HAVE_DECL_symbol is defined to `0' instead of leaving HAVE_DECL_symbol
-  undeclared. When you are sure that the check was performed,
-  use HAVE_DECL_symbol in #if."
+  Also fix a warning revealed after this patch made CMake correctly
+  enable `HAVE_GETTIMEOFDAY` for `example` programs.
   
-  Source: autoconf documentation for AC_CHECK_DECLS.
+  Closes #906
 
-- Fix implicit declaration of function 'SecureZeroMemory'
+- cmake: dedupe crypto-backend detection
   
-  Include window.h in order to use SecureZeroMemory on Windows.
-
-- Fix implicit declaration of function 'free' by including stdlib.h
-
-GitHub (27 Aug 2018)
-- [Will Cosgrove brought this change]
+  Before this patch CMake did crypto-backend detection in both
+  `src/CMakefiles.txt` and `tests/CMakefiles.txt`.
+  
+  Merge them and move it to the root `CMakefiles.txt`.
+  
+  While here, also add zlib for OpenSSL. Necessary when using OpenSSL
+  builds with zlib enabled.
+  
+  Closes #905
 
-  Use malloc abstraction function in pem parse
+- cmake: add missing #cmakedefines to src
   
-  Fix warning on WinCNG build.
+  - `HAVE_MEMSET_S` missing since
+    03092292597ac601c3f9f0c267ecb145dda75e4e (2018-08-02)
+  
+  - `HAVE_EXPLICIT_BZERO` and `HAVE_EXPLICIT_MEMSET` missing since
+    00005682f7b9a1aa42be50e269056ea873637047 (2023-03-28)
 
-- [Will Cosgrove brought this change]
+GitHub (31 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  Fixed possible junk memory read in sftp_stat #258
+  tidy-up: NMakefile (#903)
 
-- [Will Cosgrove brought this change]
+Viktor Szakats (30 Mar 2023)
+- GNUmakefile: adjust win32/.gitignore [ci skip]
 
-  removed INT64_C define (#260)
+- build: delete references to deleted NMake files [ci skip]
   
-  No longer used.
+  Follow-up to 057522bb0f15c10c33159e12899ecc60e40aa6ef
 
-- [Will Cosgrove brought this change]
+GitHub (30 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  Added conditional around engine.h include
+  NMakefile: merge them into a single file [ci skip] (#902)
+  
+  Also:
+  
+  - allow to override `AR` and `ARFLAGS`.
+  
+  - The extra `src` subdir in the target directory is no longer, to
+    simplify things.
+  
+  - gone the dynamically generated `objects.mk`. Now replaced with some
+    tricky logic to do that inline.
+  
+  - add necessary `LIBS` for WinCNG. (untested)
+  
+  Lightly tested via clang-cl.
 
-Will Cosgrove (6 Aug 2018)
-- [Alex Crichton brought this change]
+- [Viktor Szakats brought this change]
 
-  Fix OpenSSL link error with `no-engine` support (#259)
+  maketgz: tidy-up [ci skip] (#901)
   
-  This commit fixes linking against an OpenSSL library that was compiled with
-  `no-engine` support by bypassing the initialization routines as they won't be
-  available anyway.
+  - fix shellcheck warnings:
+    - use quotes
+    - use `$()`
+  - use `printf` (instead of calling perl).
+  - indent.
+  - copy/adapt header comment from curl to `maketgz`.
 
-GitHub (2 Aug 2018)
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  ED25519 Key Support #39 (#248)
+  ci: flatten AppVeyor jobs, add debug builds (#900)
   
-  OpenSSH Key and ED25519 support #39
-  Added _libssh2_explicit_zero() to explicitly zero sensitive data in memory #120
+  This results in better job names (now including CPU), avoiding the
+  complex exception rules, and fine-tuning the order and variation of
+  these tests.
   
-  * ED25519 Key file support - Requires OpenSSL 1.1.1 or later
-  * OpenSSH Key format reading support - Supports RSA/DSA/ECDSA/ED25519 types
-  * New string buffer reading functions - These add build-in bounds checking and convenance methods. Used for OpenSSL PEM file reading.
-  * Added new tests for OpenSSH formatted Keys
+  Enable `LIBSSH2DEBUG` for two of the existing jobs.
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  ECDSA key types are now explicit (#251)
+  ci: add VS2022 builds (incl. ARM64) to AppVeyor (#899)
   
-  * ECDSA key types are now explicit
+  - add MSVS 2022 WinCNG builds for x64 and ARM64,
+    replacing MSVS 2013 WinCNG builds for x64 and x86.
   
-  Issue was brough up in pull request #248
-
-Will Cosgrove (2 May 2018)
-- [Jakob Egger brought this change]
+  - add MSVS 2022 OpenSSL builds for x64.
+  
+  - fix a compiler warning uncovered by the new ARM64 build:
+  
+    ```
+    tests\openssh_fixture.c(393,17): warning C4477: 'fprintf' : format string '%d' requires an argument of type 'int', but variadic argument 1 has type 'libssh2_socket_t'
+    tests\openssh_fixture.c(393,17): message : consider using '%lld' in the format string
+    tests\openssh_fixture.c(393,17): message : consider using '%Id' in the format string
+    tests\openssh_fixture.c(393,17): message : consider using '%I64d' in the format string
+    ```
+  
+  - echo the actual CMake command-line.
+  
+  - cmake: echo the DLL filenames found by the OpenSSL DLL-finder
+    heuristics.
+  
+  - cmake: delete `libcrypto.dll` and `libssl.dll` names from the above
+    logic.
+  
+    I've added these in 19884e5055b6c65f0df93d7cc776a01c518a2f06. That
+    resulted in CMake picking up a rogue `libcrypto.dll` (with no
+    `libssl.dll` pair) from `C:\Windows\System32\` on the
+    `Visual Studio 2022` image, breaking tests.
+  
+    Turns out, OpenSSL v1.0.2 uses the "EAY" names, but let's not re-add
+    those either, because CMake mis-picks those up from
+    `C:/OpenSSL-Win64/bin/`, even while pointing `OPENSSL_ROOT_DIR` to a
+    v1.1.1 installation.
+  
+  - cmake: set `NO_DEFAULT_PATH` for OpenSSL DLL lookup to avoid picking
+    up all kinds of wrong DLLs. CMake considers not the first, but the
+    _last_ hit the valid one. This happened to be
+    `C:/Program Files/Meson/lib*-1_1.dll` when using the
+    `Visual Studio 2022` image.
+  
+    Ref: https://cmake.org/cmake/help/latest/command/find_file.html
+  
+  - cmake: leave two commented debug lines that will be useful next time
+    the DLL detection lookup goes wrong.
+  
+    Ref: https://cmake.org/cmake/help/latest/variable/CMAKE_FIND_DEBUG_MODE.html
+  
+  - on error, also dump `CMakeFiles/CMakeConfigureLog.yaml` if it exists
+    (requires CMake 3.26 and newer)
 
-  Add Instructions for building from Master (#249)
+- [Viktor Szakats brought this change]
 
-GitHub (27 Apr 2018)
-- [Will Cosgrove brought this change]
+  src: fix compiler warning on Darwin (#898)
+  
+  ```
+  src/session.c:675:52: warning: implicit conversion loses integer precision: 'long' to '__darwin_suseconds_t' (aka 'int') [-Wshorten-64-to-32]
+          tv.tv_usec = (ms_to_next - tv.tv_sec*1000) * 1000;
+                     ~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~
+  ```
 
-  Initialize sb_intl #226
+Viktor Szakats (29 Mar 2023)
+- tidy-up: tabs to spaces in Makefile.am [ci skip]
+  
+  Follow-up to 2f16d8105c9491beb2a02b3081f4f1c2a224fa62
 
-Will Cosgrove (19 Apr 2018)
-- [doublex brought this change]
+GitHub (29 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  buffer overflow (valgrind) (#159)
+  netware: delete support (#888)
+  
+  Last related commit happened 15 years ago.
+  NetWare had it last release in 2009.
+  
+  All links referenced from the make file are inaccessible.
 
-- [Brendan Shanks brought this change]
+- [Viktor Szakats brought this change]
 
-  mbedTLS: Remove some C99-style intermingled variable declarations (#196)
+  wolfssl: add workaround for HMAC_Update() len arg difference (#897)
+  
+  It's `int` in wolfSSL. `size_t` in OpenSSL/quictls/LibreSSL/BoringSSL.
+  
+  Ref: https://github.com/wolfSSL/wolfssl/blob/ba47562d182e10e59813da012e0ab8ef20892231/wolfssl/openssl/hmac.h#L60-L61
+  
+  /cc @wolfSSL
 
-GitHub (18 Apr 2018)
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  fix for #160
+  cmake: introduce variables for lib target names (#896)
+  
+  Make our CMake config more self-documenting by introducing variables
+  for the shared and static lib target names. Without this, it might be
+  non-trivial to find out which line is referring to a target name vs
+  libname, export name or other occurrences of `libssh2`.
+  
+  This allows to rename back the shared lib target name to the value used
+  before 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1:
+  `libssh2_shared` -> `libssh2`, if necessary for compatibility. Notice:
+  before that patch, `libssh2` name referred to either the static or
+  shared lib, depending on build settings.
 
-Will Cosgrove (18 Apr 2018)
-- [doublex brought this change]
+- [Viktor Szakats brought this change]
 
-  fix memory leak when using mbedtls backend (#158)
+  detect and use explicit_bzero() and explicit_memset() (#895)
   
-   _libssh2_bn_init_from_bin/_libssh2_bn_free would leak bignum from mbedtls_calloc().
+  Also skip detecting these and `memset_s()` for Windows targets in CMake,
+  to save detection time. On Windows we always use `SecureZeroMemory()`.
 
-- [Brendan Shanks brought this change]
+- [Viktor Szakats brought this change]
 
-  mbedTLS: Avoid multiple definition errors for context handles (#197)
+  ci: bump mbedtls (#894)
 
-- [Tseng Jun brought this change]
+- [Viktor Szakats brought this change]
 
-  Fix the EVP cipher meth memory leakage problem (#244)
-  
-  * Fix the EVP cipher meth memory leakage problem
+  GNUmakefile: minor fix for DYN mode [ci skip] (#893)
   
-  Looks good, thanks for the fixes.
+  Follow-up to b8762c1003d97e109efa587bdc760ff9873949eb
 
-Marc Hörsken (31 Mar 2018)
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Added ECDSA defines for WinCNG (#245)
+  build: delete MS Dev Studio build files (#891)
   
-  Fixed missing defines preventing building using WinCNG
+  Last updated in 2007.
+  
+  Also delete `VCPROJ` target remains (necessary files seem to have
+  been missing from the repo all along) for Visual Studio 2008.
 
-GitHub (30 Mar 2018)
-- [Will Cosgrove brought this change]
+Viktor Szakats (28 Mar 2023)
+- checksrc: fix reference in Makefile.am, update options [ci skip]
+
+GitHub (28 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  Fix for _libssh2_rsa_new with OpenSSL 1.0.x
+  build: delete native Watcom wmake support with Win32 (#889)
   
-  missing d value assignment.
+  CMake supports generating Watcom wmake files:
+  https://cmake.org/cmake/help/v3.1/generator/Watcom%20WMake.html
 
-Will Cosgrove (20 Mar 2018)
-- [Etienne Samson brought this change]
+- [Viktor Szakats brought this change]
 
-  A collection of small fixes (#198)
+  checksrc: update and fix warnings (#890)
   
-  * tests: Remove if-pyramids
+  Update from:
+  https://github.com/curl/curl/blob/5fec927374e4d9553205d861f2dcb39ec78002cc/scripts/checksrc.pl
   
-  * tests: Switch run_command arguments
+  - suppress these new checks:
   
-  * tests: Make run_command a vararg function
+    - EQUALSNULL: 320 warnings
+    - NOTEQUALSZERO: 142 warnings
+    - TYPEDEFSTRUCT: 16 warnings
   
-  * tests: Xcode doesn't obey CMake's test working directory
+    We can enabled them in the future.
   
-  * openssl: move manual AES-CTR cipher into crypto init
+  - fix all other new ones.
   
-  * cmake: Move our include dir before all other include paths
+  - also fix whitespace in two `NMakefile` files.
 
-GitHub (15 Mar 2018)
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Fixes incorrect indexing of KEX prefs string
-  
-  After stripping out an invalid KEX pref entry, it would incorrectly advance again leaving invalid values in the list.
+  tidy-up: fix/update URLs (#887)
 
-Viktor Szakats (13 Mar 2018)
-- tests: fix checksrc warnings
-  
-  Also:
-  * add 'static' qualifier to file-wide const buffers
-  * fix a non-ANSI C89 comment
-  * silence a mismatched fprintf() mask warning by adding a cast
+- [Viktor Szakats brought this change]
 
-- cmake: recognize OpenSSL 1.1 .dll names
+  tidy-up: fix typos (#886)
   
-  Also fix some comment typos and a stray tab.
+  detected by codespell 2.2.4.
 
-- docs: update an URL [ci skip]
-
-Daniel Stenberg (12 Mar 2018)
-- docs/SECURITY: the max embargo is 14 days now
+- [Viktor Szakats brought this change]
 
-Viktor Szakats (12 Mar 2018)
-- docs: spelling fixes [ci skip]
+  tidy-up: replace tabs and other whitespace (#885)
   
-  Closes https://github.com/libssh2/libssh2/pull/222
+  There are a few non-whitespace changes, see them here:
+  https://github.com/libssh2/libssh2/pull/885/files?w=1
 
-GitHub (12 Mar 2018)
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Fixed minor tabs/spacing issues
+  ci: drop cmake --parallel (#884)
+  
+  `--parallel 2` did not seem to make builds faster. Neither did 4 or 6.
+  
+  Delete this option from both GHA and AppVeyor jobs.
+  
+  On AppVeyor, with VS, it uses MSBuild under the hood where apparently
+  `--parallel` doesn't do much [1]. The suggested MSBuild-specific option
+  `/p:CL_MPcount=2` did not improve build times either.
+  
+  CMake spends significant time (comparable to building the project
+  itself) on feature detection, it'd be nice to execute those in parallel,
+  but I found not such CMake option.
+  
+  [1] https://discourse.cmake.org/t/parallel-does-not-really-enable-parallel-compiles-with-msbuild/964
+  
+  Partial revert of 7a039d9a7a2945c10b4622f38eeed21ba6b4ec55
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Update kex.c
+  rework how to enable insecure null-cipher/null-MAC (#873)
+  
+  Null-cipher and null-MAC are security footguns we want to avoid.
+  
+  Existing option names to toggle these were ambiguous and gave room for
+  misinterpretation. Some projects may have had these options enabled by
+  accident.
+  
+  This patch aims to make it more difficult to enable them, and making
+  sure that existing methods require an update to stay enabled.
+  
+  - delete CMake/autotools settings to enable the "none" cipher and MAC.
+  
+  - rename existing C macros that can enable them.
+  
+    To use them, pass them as custom `CPPFLAGS` to the build.
+  
+  - enable them only if `LIBSSH2DEBUG` is also enabled.
+  
+  Best would be to delete them, though they may have some use while
+  developing libssh2 itself, or debugging.
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Added basic bounds checking #206
+  delete old gex (SSH2_MSG_KEX_DH_GEX_REQUEST_OLD) build option (#872)
+  
+  libssh2 supports an "old" style KEX message
+  `SSH2_MSG_KEX_DH_GEX_REQUEST_OLD`, as an off-by-default build option.
+  
+  OpenSSH deprecated/disabled this feature in v6.9 (2015-07-01):
+  https://www.openssh.com/releasenotes.html#6.9
   
-  Basic bounds checking in ecdh_sha2_nistp()
+  This patch deletes this obsolete feature from libssh2, with no option
+  to enable it.
+  
+  Added to libssh2 in: cf8ca63ea0c9388c8ae9079961d7e6a91b72b5c8 (2004-12-31)
+  RFC: https://datatracker.ietf.org/doc/html/rfc4419 (2006-03)
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Fixed Clang warning #206
+  src: more tolerant snprintf() local override (#881)
+  
+  `#undef snprintf` before redefining it, when `HAVE_SNPRINTF` is not
+  defined, even though `snprintf` is available and it should have been.
+  Possibly with 3rd party builds.
   
-  Fixed possible garbage value for secret in an error case
+  Downside is that cases of missing `HAVE_SNPRINTF` are less trivially
+  detected at compile-time.
 
-- [Will Cosgrove brought this change]
+- [Viktor Szakats brought this change]
 
-  Fixed incorrect #if to #ifdef #206
+  ci: fix cmake warning with AppVeyor WinCNG builds (#883)
   
-  When checking HAVE_OPAQUE_STRUCTS.
-
-Viktor Szakats (12 Mar 2018)
-- src: suppress two checksrc warnings
+  ```
+  CMake Warning:
+    Manually-specified variables were not used by the project:
   
-  Ref: https://github.com/libssh2/libssh2/pull/235
-
-- src: address fopen() warnings, add missing copyright headers
+      OPENSSL_ROOT_DIR
+  ```
   
-  Ref: https://github.com/libssh2/libssh2/pull/235
+  Follow-up to 0834b9bcc85b90c78afff103f909b5a909b95e45
 
-- src: replace sprintf() with snprintf()
+- [Viktor Szakats brought this change]
+
+  ci: cmake `ENABLE_WERROR` -> `ON` (#877)
   
-  Ref: https://github.com/libssh2/libssh2/pull/235
+  Consider warnings as errors for CMake jobs in CI.
 
-- src: fix checksrc warnings
+Viktor Szakats (26 Mar 2023)
+- src: silence compiler warnings 4 (alignment in WinCNG)
   
-  Use checksrc.pl from the curl project, with (for now)
-  suppressed long line warnings and indentation set to
-  4 spaces. Fixes are whitespace for the most part.
+  Silence alignment warnings in WinCNG, by reworking the code.
   
-  Warning count went down from 2704 to 12.
+  Also add two unrelated casts to avoid gcc compiler warnings
+  in surrounding code.
   
-  Also fix codespell typos, two non-ANSI C89 comments
-  and a stray tab in include/libssh2.h.
+  `increases required alignment from 1 to 4 [-Wcast-align]`
+  `increases required alignment from 1 to 8 [-Wcast-align]`
   
-  Ref: https://github.com/libssh2/libssh2/pull/235
+  See warning details in the PR's individual commits.
+  
+  Reviewed-by: Marc Hörsken in <https://github.com/libssh2/libssh2/pull/846#pullrequestreview-1350253621>
+  Cherry-picked from #846
+  Closes #880
 
-- checksrc: add source style checker
+- src: silence compiler warnings 3 (change types)
   
-  This is a slightly extended version of this original source
-  from the curl project:
-  https://github.com/curl/curl/blob/8b754c430b9a4c51aa606c687ee5014faf7c7b06/lib/checksrc.pl
+  Apply type changes to avoid casts and warnings. In most cases this
+  means changing to a larger type, usually `size_t` or `ssize_t`.
   
-  This version adds the following options to customize it for
-  libssh2 (plus some whitespace formatting):
+  Change signedness in a few places.
   
-  `-i<n>`  to override indentation spaces (2)
-  `-m<n>`  to override maximum line length (79)
+  Also introduce new variables to avoid reusing them for multiple
+  purposes, to avoid casts and warnings.
   
-  Command-line used to check libssh2 sources:
+  - add FIXME for public `libssh2_sftp_readdir_ex()` return type.
   
-  $ ./checksrc.pl -i4 -m500 *.c *.h
+  - fix `_libssh2_mbedtls_rsa_sha2_verify()` to verify if `sig_len`
+    is large enough.
   
-  Closes https://github.com/libssh2/libssh2/pull/236
-
-- src: add static qualifier
+  - fix `_libssh2_dh_key_pair()` in `wincng.c` to return error if
+    `group_order` input is negative.
   
-  To private, const strings.
+    Maybe we should also reject zero?
   
-  Closes https://github.com/libssh2/libssh2/pull/237
-
-- [Will Cosgrove brought this change]
-
-  Add support for ECDSA keys and host keys (#41)
+  - bump `_libssh2_random()` size type `int` -> `size_t`. Add checks
+    for WinCNG and OpenSSL to return error if requested more than they
+    support (`ULONG_MAX`, `INT_MAX` respectively).
   
-  This commit lands full ECDSA key support when using the OpenSSL
-  backend. Which includes:
+  - change `_libssh2_ntohu32()` return value `unsigned int` -> `uint32_t`.
   
-  New KEX methods:
-  ecdsa-sha2-nistp256, ecdsa-sha2-nistp384, ecdsa-sha2-nistp521
+  - fix `_libssh2_mbedtls_bignum_random()` to check for a negative `top`
+    input.
   
-  Can now read OpenSSL formatted ECDSA key files.
+  - size down `_libssh2_wincng_key_sha_verify()` `hashlen` to match
+    Windows'.
   
-  Now supports known host keys of type ecdsa-sha2-nistp256.
+  - fix `session_disconnect()` to limit length of `lang_len`
+    (to 256 bytes).
   
-  New curve types:
-  NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1
+  - fix bad syntax in an `assert()`.
   
-  Default host key preferred ordering is now nistp256, nistp384,
-  nistp521, rsa, dss.
+  - add a few `const` to casts.
   
-  Ref: https://github.com/libssh2/libssh2/issues/41
+  - `while(1)` -> `for(;;)`.
   
-  Closes https://github.com/libssh2/libssh2/pull/206
-
-GitHub (15 Dec 2017)
-- [Will Cosgrove brought this change]
-
-  Fixed possible crash when decoding invalid data
+  - add casts that didn't fit into #876.
   
-  When trying to decode invalid data, it frees the buffer but doesn't nil it so the caller gets a junk memory pointer which they could potentially double free.
-
-- [Will Cosgrove brought this change]
-
-  Remove call to OpenSSL_add_all_ciphers()
+  - update `docs/HACKING-CRYPTO` with new sizes.
   
-  Now lives in libssh2 init() from PR #189
-
-- [Will Cosgrove brought this change]
-
-  Fixed incorrect reference to decrypted block
+  May need review for OS400QC3: /cc @monnerat @jonrumsey
   
-  Fixed incorrectly copied memory from p->buf into init instead of from the decrypted buffer block. The only reason this worked was because the crypt() function decrypts the value in-place and overwrites p->buf.  I'm working on a fork that no longer does this and exposed this bug.
-
-Will Cosgrove (20 Oct 2017)
-- [Pan brought this change]
-
-  Fix typo in crypt.c (#218)
+  See warning details in the PR's individual commits.
+  
+  Cherry-picked from #846
+  Closes #879
 
-Kamil Dudka (17 Oct 2017)
-- session: avoid printing misleading debug messages
+- src: silence compiler warnings 2 (ZLIB interface)
   
-  ... while throwing LIBSSH2_ERROR_EAGAIN out of session_startup()
+  Silence warnings in the ZLIB interface by adding casts and changing
+  types.
   
-  If the session runs in blocking mode, LIBSSH2_ERROR_EAGAIN never reaches
-  the libssh2 API boundary and, in non-blocking mode, these messages are
-  suppressed by the condition in _libssh2_error_flags() anyway.
+  See PR for individual commits.
   
-  Closes #211
+  Cherry-picked from #846
+  Closes #878
 
-Viktor Szakats (15 Oct 2017)
-- win32/GNUmakefile: allow customizing dll suffixes
+- src: silence compiler warnings 1
   
-  - New `LIBSSH2_DLL_SUFFIX` envvar will add a suffix to the generated
-    libssh2 dll name. Useful to add `-x64` to 64-bit builds so that
-    it can live in the same directory as the 32-bit one. By default
-    this is empty.
+  Most of the changes aim to silence warnings by adding casts.
   
-  - New `LIBSSH2_DLL_A_SUFFIX` envvar to customize the suffix of the
-    generated import library (implib) for libssh2 .dll. It defaults
-    to `dll`, and it's useful to modify that to `.dll` to have the
-    standard naming scheme for mingw-built .dlls, i.e. `libssh2.dll.a`.
+  An assortment of other issues, mainly compiler warnings, resolved:
   
-  Ref: https://github.com/curl/curl/commit/aaa16f80256abc1463fd9374815130a165222257
+  - unreachable code fixed by using `goto` in
+    `publickey_response_success()` in `publickey.c`.
   
-  Closes https://github.com/libssh2/libssh2/pull/215
-
-- makefile.m32: allow to override gcc, ar and ranlib
+  - potentially uninitialized variable in `sftp_open()`.
   
-  Allow to ovverride certain build tools, making it possible to
-  use LLVM/Clang to build libssh2. The default behavior is unchanged.
-  To build with clang (as offered by MSYS2), these settings can
-  be used:
+  - MSVS-specific bogus warnings with `nid_type` in `kex.c`.
   
-  LIBSSH2_CC=clang
-  LIBSSH2_AR=llvm-ar
-  LIBSSH2_RANLIB=llvm-ranlib
+  - check result of `kex_session_ecdh_curve_type()`.
   
-  Also adjust ranlib parameters to be compatible with LLVM/Clang's
-  ranlib tool.
+  - add missing function declarations.
   
-  Closes https://github.com/libssh2/libssh2/pull/214
-
-GitHub (27 Sep 2017)
-- [Will Cosgrove brought this change]
-
-  Fixes out of bounds memory access (#210)
+  - type changes to fit values without casts:
+    - `cmd_len` in `scp_recv()` and `scp_send()`: `int` -> `size_t`
+    - `Blowfish_expandstate()`, `Blowfish_expand0state()` loop counters:
+      `uint16_t` -> `int`
+    - `RECV_SEND_ALL()`: `int` -> `ssize_t`
+    - `shell_quotearg()` -> `unsigned` -> `size_t`
+    - `sig_len` in `_libssh2_mbedtls_rsa_sha2_sign()`:
+      `unsigned` -> `size_t`
+    - `prefs_len` in `libssh2_session_method_pref()`: `int` -> `size_t`
+    - `firstsec` in `_libssh2_debug_low()`: `int` -> `long`
+    - `method_len` in `libssh2_session_method_pref()`: `int` -> `size_t`
   
-  If an invalid PEM file is read and the lines are longer than 128 characters it will go out of bounds and crash on line 91.
-
-Will Cosgrove (11 Sep 2017)
-- [Kamil Dudka brought this change]
-
-  scp: do not NUL-terminate the command for remote exec (#208)
+  - simplify `_libssh2_ntohu64()`.
+  
+  - fix `LIBSSH2_INT64_T_FORMAT` for MinGW.
+  
+  - fix gcc warning by not using a bit field for
+    `burn_optimistic_kexinit`.
+  
+  - fix unused variable warning in `_libssh2_cipher_crypt()` in
+    `libgcrypt.c`.
   
-  It breaks SCP download/upload from/to certain server implementations.
+  - fix unused variables with `HAVE_DISABLED_NONBLOCKING`.
   
-  The bug does not manifest with OpenSSH, which silently drops the NUL
-  byte (eventually with any garbage that follows the NUL byte) before
-  executing it.
+  - avoid const stripping with `BIO_new_mem_buf()` and OpenSSL 1.0.2 and
+    newer.
   
-  Bug: https://bugzilla.redhat.com/1489736
+  - add a missing const in `wincng.h`.
+  
+  - FIXME added for public:
+    - `libssh2_channel_window_read_ex()` `read_avail` argument type.
+    - `libssh2_base64_decode()` `datalen` argument type.
+  
+  - fix possible overflow in `sftp_read()`.
+  
+    Ref: 4552c73cd58fccb1fc49cb0f25f86619133e560f
+  
+  - formatting in `wincng.h`.
+  
+  See warning details in the PR's individual commits.
+  
+  Cherry-picked from #846
+  Closes #876
 
-GitHub (21 Aug 2017)
+GitHub (24 Mar 2023)
 - [Viktor Szakats brought this change]
 
-  openssl.c: remove no longer used variable (#204)
+  cmake: automatic exports macro tidy-up (#875)
   
-  after e378d2e30a40bd9bcee06dc3a4250f269098e200
-
-- [Will Cosgrove brought this change]
-
-  Fix for #188 (#189)
+  In a recent CMake update I left the original CMake EXPORTS macro
+  unchanged (`libssh2_EXPORTS`) for compatibility.
   
-  * Update openssl.c
+  However, that macro was also recently added [1] and not present in an
+  official release yet, so we might as well just use the new native one
+  instead (`libssh2_shared_EXPORTS`), defined by CMake automatically.
+  This way we don't need to define the old macro manually.
   
-  * Create openssl.h
-
-Will Cosgrove (24 May 2017)
-- [Marcel Raad brought this change]
-
-  openssl: fix build with OpenSSL 1.1 API (#176)
+  CMake forms this macro from the lib's internal name as defined in
+  `add_library()` by appending `_EXPORTS`. That target name changed from
+  `libssh2` to `libssh2_shared` after introducing dual shared + static
+  builds in the recent update.
   
-  When building with OPENSSL_API_COMPAT=0x10100000L, OpenSSL_add_all_algorithms
-  and OpenSSL_add_all_ciphers don't exist. The corresponding functionality is
-  handled automatically with OpenSSL 1.1.
-
-- [Sune Bredahl brought this change]
-
-  Add support for SHA256 hostkey fingerprints (#180)
+  If we're here, add a new, stable, build-tool agnostic macro with the
+  same effect, for non-CMake use: `LIBSSH2_EXPORTS`
   
-  Looks good, thanks!
-
-GitHub (12 May 2017)
-- [Will Cosgrove brought this change]
-
-  Fix memory leak of crypt_ctx->h using openSSL 1.1+ (#177)
+  [1] 1f0fe7443a1ecddd320f2c693607b2afee9bbe2f (2021-10-26)
   
-  Need to use EVP_CIPHER_CTX_free instead of EVP_CIPHER_CTX_reset.
+  Follow-up to 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1
 
-Marc Hoersken (2 Mar 2017)
-- tests/openssh_server/authorized_keys: add key_rsa_encrypted.pub
-
-- tests: add simple test for passphrase-protected PEM file support
-
-- os400qc3: enable passphrase-protected PEM file support using pem.c
-
-- pem: fix indentation and replace assert after 386e012292
-
-- [Keno Fischer brought this change]
+- [Viktor Szakats brought this change]
 
-  pem: add passphrase-protected PEM file support for libgcrypt and wincng
+  maketgz: add .xz, .bz2, .zip source archive formats (#874)
   
-  Since they use our own PEM parser which did not support encrypted
-  PEM files, trying to use such files on these backends failed.
-  Fix that by augmenting the PEM parser to support encrypted PEM files.
-
-- [Thomas brought this change]
-
-  misc: use time constant implementation for AES CTR increment
-
-- [Thomas brought this change]
-
-  wincng: add AES CTR mode support (aes128-ctr, aes192-ctr, aes256-ctr)
-
-- [Thomas brought this change]
+  Copied from curl:
+  https://github.com/curl/curl/blob/4528690cd51e5445df74aef8f83470a602683797/maketgz#L174-L222
+  
+  [ci skip]
 
-  openssl: move shared AES-CTR code into misc
+Viktor Szakats (23 Mar 2023)
+- dist: delete reference to recently deleted file [ci skip]
+  
+  Follow-up to b8762c1003d97e109efa587bdc760ff9873949eb
 
-Daniel Stenberg (20 Dec 2016)
-- [Alex Crichton brought this change]
+GitHub (23 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  kex: acknowledge error code from libssh2_dh_key_pair()
+  cmake: separate compilation passes for shared/static (#871)
   
-  Fixes a segfault using ssh-agent on Windows
+  Before this patch, cmake did a single compilation pass when we enabled
+  both shared and static lib targets. This saves build time (esp. with
+  MinGW targets and cross-compiling), but has the disadvantage that static
+  libs built this way must have PIC enabled (offering slightly less
+  performance) and `dllexport` enabled also, which means that executables
+  linking the static libssh2 lib export its public symbols.
   
-  This commit fixes a segfault seen dereferencing a null pointer on
-  Windows when using ssh-agent. The problem ended up being that errors
-  weren't being communicated all the way through, causing null pointers to
-  be used when functions should have bailed out sooner.
+  To avoid these downsides, this patch separates the two passes and
+  creates a non-PIC, non-`dllexport` static lib, even when also building
+  the shared lib.
+
+- [Viktor Szakats brought this change]
+
+  ci: test with OpenSSL v1.1.1 on AppVeyor (#870)
   
-  The `_libssh2_dh_key_pair` function for WinCNG was modified to propagate
-  errors, and then the two callsites in kex.c of
-  `diffie_hellman_sha{1,256}` were updated to recognize this error and
-  bail out.
+  Was: v1.0.2.
   
-  Fixes #162
-  Closes #163
+  Keep using v1.0.2 with the static-only test. To make sure we don't break
+  support.
 
-Alexander Lamaison (27 Nov 2016)
-- [monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Implement Diffie-Hellman computations in crypto backends. (#149)
+  ci: speed up static-only build tests on AppVeyor (#868)
   
-  Not all backends feature the low level API needed to compute a Diffie-Hellman
-  secret, but some of them directly implement Diffie-Hellman support with opaque
-  private data. The later approach is now generalized and backends are
-  responsible for all Diffie Hellman computations.
-  As a side effect, procedures/macros _libssh2_bn_rand and _libssh2_bn_mod_exp
-  are no longer needed outside the backends.
-
-Peter Stuge (16 Nov 2016)
-- acinclude.m4: The mbedtls crypto backend actually requires libmbedcrypto
+  - limit static-only build to a single platform (x64).
   
-  Examples can't be linked with libmbedtls but need libmbedcrypto, and
-  any users of libssh2 which use libtool and libssh2.la would encounter
-  the same problem.
+  - skip running ctest for the static-only build.
   
-  This changes the mbedtls detection to search for libmbedcrypto, which
-  is the actual dependency for the backend.
-
-- acinclude.m4: Add CPPFLAGS=-I$prefix-dir/include in LIBSSH2_LIB_HAVE_LINKFLAGS
+  - use MSVS 2013 for static-only builds. It's faster.
   
-  This is absolutely neccessary for header files to be found when
-  AC_LIB_HAVE_LINKFLAGS searches for libraries.
+  - run static-only test before WinCNG ones. Otherwise it's often skipped
+    due to WinCNG failures (#804).
 
-- acinclude.m4: Make saved variables in LIBSSH2_LIB_HAVE_LINKFLAGS uniform
+- [Viktor Szakats brought this change]
 
-- docs/HACKING.CRYPTO: Improve documentation for autoconf build system
+  cmake: fix error with static lib off and example/tests on (#869)
+  
+  Regression from 4e2580628dd1f8dc51ac65ac747ebcf0e93fa3d1
 
-Alexander Lamaison (16 Nov 2016)
-- [Alex Arslan brought this change]
+- [Viktor Szakats brought this change]
 
-  Check for netinet/in.h in the tests cmake file (#148)
+  ci: parallelize more (#867)
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Define new Diffie-Hellman context for mbedTLS
+  cmake/src: move build options before target definitions (#864)
+  
+  To allow more flexibility when defining targets.
 
-- [monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Make libssh2 work again on os400. (#118)
+  ci: use static+shared builds to cut number of cmake jobs (#865)
   
-  * os400: minimum supported OS version is now V6R1.
-  Do not log compiler informational messages.
+  With CMake builds supporting static-shared libssh2 builds in a single
+  pass, we no longer need to run static and shared jobs separately. For
+  the same effect it's enough to run builds with both shared and static
+  builds enabled. Halving CI jobs.
   
-  * Implement crypto backend specific Diffie-Hellman computation.
+  We add an extra run to test the CMake config-path without shared builds
+  enabled.
   
-  This feature is now needed on os400 because the QC3 library does not
-  implement bn_mod_exp() natively. Up to now, this function was emulated using
-  an RSA encryption, but commits ca5222ea819cc5ed797860070b4c6c1aeeb28420 and
-  7934c9ce2a029c43e3642a492d3b9e494d1542be (CVE-2016-0787) broke the emulation
-  because QC3 only supports RSA exponents up to 512 bits.
+  This allows to add useful jobs, e.g. MSVS 2022 or ZLIB-enabled builds
+  for Windows, valgrind builds or other useful stuff, without stretching
+  CI run times further.
   
-  Happily, QC3 supports a native API for Diffie-Hellman computation, with
-  opaque random value: this commit implements the use of this API and, as a
-  side effect, enables support of this feature for any other crypto backend that
-  would use it.
+  Ref: #863
+
+Viktor Szakats (22 Mar 2023)
+- cmake: allow building static + shared libs in a single pass
   
-  A "generic" Diffie-Hellman computation internal API supports crypto backends
-  not implementing their own: this generic API uses the same functions as before.
+  - `BUILD_SHARED_LIBS=ON` no longer disables building static lib.
   
-  * Fix typos in docs/HACKING.CRYPTO.
-
-- [Peter Stuge brought this change]
-
-  acinclude.m4: Fixup OpenSSL EVP_aes_128_ctr() detection
-
-- [Peter Stuge brought this change]
-
-  configure.ac: Add --with-crypto= instead of many different --with-$backend
+    When set, we build the static lib with PIC enabled.
   
-  The new --with-crypto option replaces the previous backend-specific
-  --with-{openssl,libgcrypt,mbedtls,wincng} options and fixes some issues.
+    For shared lib only, set `BUILD_STATIC_LIBS=OFF`. For static lib
+    without PIC, leave this option disabled.
   
-  * libgcrypt or mbedtls would previously be used whenever found, even
-    if configure was passed --without-libgcrypt or --without-mbedtls.
+  - new setting: `BUILD_STATIC_LIBS`. `ON` by default.
   
-  * If --with-$backend was specified then configure would not fail even
-    if that library could not be found, and would instead use whichever
-    crypto library was found first.
+    Force-enabled when building examples or tests (we build those in
+    static mode always.)
   
-  The new option defaults to `auto`, which makes configure check for all
-  supported crypto libraries in turn, choosing the first one found, or
-  exiting with an error if none can be found.
-
-- [Tony Kelman brought this change]
-
-  Build mbedtls from source on Travis (#133)
+  - fix to exclude Windows Resource from the static lib.
   
-  * Revert "Revert "travis: Test mbedtls too""
+  - fix to not overwrite static lib with shared implib on Windows
+    platforms using identical suffix for them (MSVS). By using
+    `libssh2_imp<.ext>` implib filename.
   
-  This reverts commit c4c60eac5ca756333034b07dd9e0b97741493ed3.
+  - add support for `STATIC_LIB_SUFFIX` setting to set an optional suffix
+    (e.g. `_static`) for the static lib. (experimental, not documented).
+    Overrides the above when set.
   
-  * travis: Build mbedtls from source on Travis
+  - fix to set `dllexport` when building shared lib.
   
-  Use TOOLCHAIN_OPTION when calling cmake on mbedtls
+  - set `TrackFileAccess=false` for MSVS.
   
-  * tests: only run DSA tests for non-mbedtls
+    For faster builds, shorter verbose logs.
   
-  crypto backends
-
-- [Peter Stuge brought this change]
-
-  configure.ac src/Makefile.am: Remove dead AM_CONDITIONAL(OS400QC3)
+  - tests: new test linking against shared libssh2: `test_warmup_shared`
   
-  According to os400/README400 this backend can not be built
-  with configure+make, and the conditional is hard coded to false.
-
-- [Peter Stuge brought this change]
-
-  configure.ac: Add -DNDEBUG to CPPFLAGS in non-debug builds
+  - tests: simplify 'runner' lib by merging 3 libs into a single one.
   
-  There are a few uses of assert() in channel.c, sftp.c and transport.c.
-
-- [Peter Stuge brought this change]
-
-  src/global.c: Fix conditional AES-CTR support
+  - tests: drop hack from `test_keyboard_interactive_auth_info_request`
+    build.
   
-  Most of libssh2 already has conditional support for AES-CTR according to
-  the LIBSSH2_AES_CTR crypto backend #define, but global.c needed fixing.
-
-- [Peter Stuge brought this change]
-
-  src/crypto.h src/userauth.c: Fix conditional RSA support
+    We no longer need to compile `src/misc.c` because we always link
+    libssh2 statically.
   
-  Most of libssh2 already has conditional support for RSA according to
-  the LIBSSH2_RSA crypto backend #define, but crypto.h and userauth.c
-  needed a few small fixes.
-
-- [Peter Stuge brought this change]
-
-  src/kex.c: Cast libssh2_sha{1,256}_update data arguments properly
+  - tests: limit `FIXTURE_WORKDIR=` to the `runner` target.
   
-  The update functions take a const unsigned char * but were called
-  with (const) char * in some places, causing unneccessary warnings.
-
-- [Peter Stuge brought this change]
-
-  docs/HACKING.CRYPTO: Fix two type typos
-
-- [Sergei Trofimovich brought this change]
+  TL;DR: Default behavior unchanged: static (no-PIC), no shared.
+         Enabling shared unchanged, but now also builds a static (PIC)
+         lib by default.
+  
+  Based-on: b60dca8b6450a9729670986d2899cca54ccdbb6d #547 by berney on github
+  Fixes: #547
+  Fixes: #675
+  Closes: #863
 
-  acinclude.m4: fix ./configure --with-libgcrypt
+- include: silence warnings with casts in public `libssh2_sftp.h`
   
-  The change fixes passing of bogus gcrypt prefix.
-  Reproducible as:
+  Avoid triggering warnings in macros coming from public libssh2 headers.
   
-      $ ./configure --with-libgcrypt
-      $ make V=1
-      ...
-      /bin/sh ../libtool  --tag=CC   --mode=link gcc  -g -O2 -Iyes/include -version-info 1:1:0 -no-undefined -export-symbols-regex '^libssh2_.*' -lgcrypt  -lz -Lyes/lib -o libssh2.la -rpath /usr/local/lib channel.lo comp.lo crypt.lo hostkey.lo kex.lo mac.lo misc.lo packet.lo publickey.lo scp.lo session.lo sftp.lo userauth.lo transport.lo version.lo knownhost.lo agent.lo libgcrypt.lo pem.lo keepalive.lo global.lo   -lgcrypt
-      ../libtool: line 7475: cd: yes/lib: No such file or directory
-      libtool:   error: cannot determine absolute directory name of 'yes/lib'
+  Cherry-picked from: #846
+  Closes #862
+
+- example, tests: address compiler warnings
   
-  These
-      -Iyes/include
-      -Lyes/lib
-  come from libgcrypt code autodetection:
-    if test -n "$use_libgcrypt" && test "$use_libgcrypt" != "no"; then
-       LDFLAGS="$LDFLAGS -L$use_libgcrypt/lib"
-       CFLAGS="$CFLAGS -I$use_libgcrypt/include"
+  Fix or silence all C compiler warnings discovered with (or without)
+  `PICKY_COMPILER=ON` (in CMake). This means all warnings showing up in
+  CI (gcc, clang, MSVS 2013/2015), in local tests on macOS (clang 14) and
+  Windows cross-builds using gcc (12) and llvm/clang (14/15).
   
-  I assume it's a typo to use yes/no flag as a prefix and changed
-  it to '$with_libgcrypt_prefix'.
+  Also fix the expression `nread -= nread` in `sftp_RW_nonblock.c`.
   
-  Reported-by: Mikhail Pukhlikov <cynede@gentoo.org>
-  Signed-off-by: Sergei Trofimovich <siarheit@google.com>
-
-- [Zenju brought this change]
+  Cherry-picked from: #846
+  Closes #861
 
-  libssh2_sftp_init hang: last error not set
+- openssl: require `EVP_aes_128_ctr()` support
   
-  The problem is that the original if statement simply returns NULL, but does not set the session last error code. The consequence is that libssh2_sftp_init() also returns NULL and libssh2_session_last_errno(sshSession) == LIBSSH2_ERROR_NONE.
+  libssh2 built with OpenSSL and without its `EVP_aes_128_ctr()`, aka
+  `HAVE_EVP_AES_128_CTR`, option are working incorrectly. This option
+  wasn't always auto-detected by autotools up until recently (#811).
+  Non-cmake, non-autotools build methods never enabled it automatically.
   
-  In my test the LIBSSH2_ERROR_EAGAIN is coming from sftp.c row 337:
-              if(4 != sftp->partial_size_len)
-                  /* we got a short read for the length part */
-                  return LIBSSH2_ERROR_EAGAIN;
+  OpenSSL supports this options since at least v1.0.2, which is already
+  EOLed and considered obsolete. OpenSSL forks (LibreSSL, BoringSSL)
+  supported it all along.
   
-  with "partial_size_len == 0". Not sure if this is expected.
-
-- [Aidan Hobson Sayers brought this change]
-
-  docs: correctly describe channel_wait_eof
+  In this patch we enable this option unconditionally, now requiring
+  OpenSSL supporting this function, or one of its forks.
   
-  channel_wait_eof waits for channel->remote.eof, which is set on
-  receiving a `SSH_MSG_CHANNEL_EOF` message. This message is sent
-  when a party has no more data to send on a channel.
-
-- [Zenju brought this change]
+  Also modernize OpenSSL lib references to what 1.0.2 and newer versions
+  have been using.
+  
+  Fixes #739
 
-  Fix MSVC 14 compilation warning (#92)
+- wincng: fix memory leak in `_libssh2_dh_secret()`
   
-  1>  sftp.c
-  1>libssh2-files\src\sftp.c(3393): warning C4456: declaration of 'retcode' hides previous local declaration
-  1>  libssh2-files\src\sftp.c(3315): note: see declaration of 'retcode'
+  Patch-by: iruis on github
+  Assisted-by: Marc Hörsken
+  Bug #846, commit e3487092ef9553af67633c6747cb9ab2f86465e0.
+  Fixes #856
+  Closes #858
+
+GitHub (19 Mar 2023)
+- [Viktor Szakats brought this change]
 
-- [Salvador Fandino brought this change]
+  nw, os400, watcom: stop setting unused macros [ci skip] (#859)
 
-  LIBSSH2_ERROR_CHANNEL_WINDOW_FULL: add new error code
+Viktor Szakats (19 Mar 2023)
+- cmake: fix `ENABLE_WERROR=ON` breaking auto-detections
   
-  In order to signal that the requested operation can not succeed
-  because the receiving window had been exhausted, the error code
-  LIBSSH2_ERROR_BUFFER_TOO_SMALL has been reused but I have found
-  that in certain context it may be ambigous.
+  - cmake: fix compiler warnings in `CheckNonblockingSocketSupport`.
+    detection functions.
   
-  This patch introduces a new error code,
-  LIBSSH2_ERROR_CHANNEL_WINDOW_FULL, exclusive to signal that condition.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_eof: handle receive window exhaustion
+    Without this, these detections fail when `ENABLE_WERROR=ON`.
   
-  Until now, in blocking mode, if the remote receiving window is
-  exhausted this function hangs forever as data is not read and the
-  remote side just keeps waiting for the window to grow before sending
-  more data.
+  - cmake: disable ENABLE_WERROR for MSVC during symbol checks in `src`.
   
-  This patch, makes this function check for that condition and abort
-  with an error when it happens.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_closed: don't fail when unread data is queued
+    CMake's built-in symbol check function `check_symbol_exists()`
+    generate warnings with MSVC. With warnings considered errors, these
+    detections fail permanently. Our workaround is to disable
+    warnings-as-errors while running these checks.
   
-  This function was calling channel_wait_eof to ensure that the EOF
-  packet has already been received, but that function also checks that
-  the read data queue is empty before reporting the EOF. That caused
-  channel_wait_closed to fail with a LIBSSH2_ERROR_INVAL when some data
-  was queued even after a successful call to libssh2_channel_wait_eof.
+    ```
+    CheckSymbolExists.c(8): warning C4054: 'type cast': from function pointer '__int64 (__cdecl *)(const char *,char **,int)' to data pointer 'int *'
+    in `return ((int*)(&strtoll))[argc];`
+    ```
   
-  This patch changes libssh2_channel_wait_closed to look directly into
-  channel->remote.eof so that both libssh2_channel_wait_eof and
-  libssh2_channel_wait_closed bahave consistently.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_eof: fix debug message
-
-Daniel Stenberg (25 Oct 2016)
-- libssh2.h: start working on 1.8.1
-
-Version 1.8.0 (25 Oct 2016)
-
-Daniel Stenberg (25 Oct 2016)
-- RELEASE-NOTES: adjusted for 1.8.0
-
-Kamil Dudka (20 Oct 2016)
-- Revert "aes: the init function fails when OpenSSL has AES support"
+    Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46537222/job/4vg4yg333mu2lg9b
   
-  This partially reverts commit f4f2298ef3635acd031cc2ee0e71026cdcda5864
-  because it caused the compatibility code to call initialization routines
-  redundantly, leading to memory leakage with OpenSSL 1.1 and broken curl
-  test-suite in Fedora:
+  - example: replace `strcasecmp()` with C89 `strcmp()`.
   
-  88 bytes in 1 blocks are definitely lost in loss record 5 of 8
-     at 0x4C2DB8D: malloc (vg_replace_malloc.c:299)
-     by 0x72C607D: CRYPTO_zalloc (mem.c:100)
-     by 0x72A2480: EVP_CIPHER_meth_new (cmeth_lib.c:18)
-     by 0x4E5A550: make_ctr_evp.isra.0 (openssl.c:407)
-     by 0x4E5A8E8: _libssh2_init_aes_ctr (openssl.c:471)
-     by 0x4E5BB5A: libssh2_init (global.c:49)
-
-Daniel Stenberg (19 Oct 2016)
-- [Charles Collicutt brought this change]
-
-  libssh2_wait_socket: Fix comparison with api_timeout to use milliseconds (#134)
+    To avoid using CMake symbol checks in `example`.
   
-  Fixes #74
-
-- [Charles Collicutt brought this change]
-
-  Set err_msg on _libssh2_wait_socket errors (#135)
-
-- Revert "travis: Test mbedtls too"
+    Another option is to duplicate the `check_symbol_exists()` workaround
+    from `src`, but I figure it's not worth the complexity. We use
+    `strcasecmp()` solely to check optional command-line options for
+    example programs, and those are fine as lower-case.
   
-  This reverts commit 3e6de50a24815e72ec5597947f1831f6083b7da8.
+    Without this, these detections fail when `ENABLE_WERROR=ON`.
   
-  Travis doesn't seem to support the mbedtls-dev package
-
-- maketgz: support "only" to only update version number locally
+  - also delete `__function__` detection/use in `example`.
   
-  and fix the date output locale
-
-- configure: make the --with-* options override the OpenSSL default
+    To avoid the complexity for the sake of using it at a single place in
+    of the example's error branch. Replace that use with a literal name of
+    the function.
   
-  ... previously it would default to OpenSSL even with the --with-[crypto]
-  options used unless you specificly disabled OpenSSL. Now, enabling another
-  backend will automatically disable OpenSSL if the other one is found.
-
-- [Keno Fischer brought this change]
-
-  docs: Add documentation on new cmake/configure options
-
-- [Keno Fischer brought this change]
-
-  configure: Add support for building with mbedtls
-
-- [wildart brought this change]
-
-  travis: Test mbedtls too
-
-- [wildart brought this change]
-
-  crypto: add support for the mbedTLS backend
+  - cmake: also use `CMakePushCheckState` functions instead of manual
+    save/restore.
   
-  Closes #132
-
-- [wildart brought this change]
-
-  cmake: Add CLEAR_MEMORY option, analogously to that for autoconf
-
-- README.md: fix link typo
+  Closes #857
 
-- README: markdown version to look nicer on github
-
-Viktor Szakats (5 Sep 2016)
-- [Taylor Holberton brought this change]
-
-  openssl: add OpenSSL 1.1.0 compatibility
-
-Daniel Stenberg (4 Sep 2016)
-- [Antenore Gatta brought this change]
-
-  tests: HAVE_NETINET_IN_H was not defined correctly (#127)
+- build: improve a test build workaround with bcrypt
   
-  Fixes #125
-
-- SECURITY: fix web site typo
-
-- SECURITY: security process
-
-GitHub (14 Aug 2016)
-- [Alexander Lamaison brought this change]
-
-  Basic dockerised test suite.
+  - cmake: extend workaround for linking a test with shared libssh2.
   
-  This introduces a test suite for libssh2. It runs OpenSSH in a Docker
-  container because that works well on Windows (via docker-machine) as
-  well as Linux. Presumably it works on Mac too with docker-machine, but
-  I've not tested that.
+    One of the tests uses internal libssh2 functions, and with CMake it
+    compiles `src/misc.c` directly for this. `misc.c` references bcrypt /
+    blowfish code. This needs a workaround for build configs where libssh2
+    doesn't export these.
   
-  Because the test suite is docker-machine aware, you can also run it
-  against a cloud provider, for more realistic network testing, by setting
-  your cloud provider as your active docker machine. The Appveyor CI setup
-  in this commit does that because Appveyor doesn't support docker
-  locally.
-
-Kamil Dudka (3 Aug 2016)
-- [Viktor Szakats brought this change]
-
-  misc.c: Delete unused static variables
+    Before this patch, we enabled this workaround for MSVC.
   
-  Closes #114
-
-Daniel Stenberg (9 Apr 2016)
-- [Will Cosgrove brought this change]
-
-  Merge pull request #103 from willco007/patch-2
+    In the patch we extend this to all Windows. There is no CI test for
+    this, but gcc and llvm/clang + mingw64 builds also need it. This may
+    well apply to other configurations (it should, as shared libs are not
+    supposed to export internal functions), so also make it easy to enable
+    it at a single point.
   
-  Fix for security issue CVE-2016-0787
-
-Alexander Lamaison (2 Apr 2016)
-- [Zenju brought this change]
-
-  Fix MSVC 14 compilation errors
+    [ autotools builds force-link this one test against static libssh2. ]
   
-  For _MSC_VER == 1900 these macros are not needed and create problems:
+  - make `misc.c` not depend on bcrypt.
   
+    By moving out our `bcrypt_pbkdf()` wrapper into `bcrypt_pbkdf.c`
+    itself.
   
+    This allows to compile `misc.c` into tests without pulling in bcrypt /
+    blowfish functions, and simplify the above workaround.
   
-  1>C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt\stdio.h(1925): warning C4005: 'snprintf': macro redefinition (compiling source file libssh2-files\src\mac.c)
+    Source code uses `HAVE_BCRYPT_PBKDF`, a leftover from original bcrypt
+    source. We never define this inside libssh2. Defining it breaks the
+    build, and this patch doesn't change that.
   
-  1> \win32\libssh2_config.h(27): note: see previous definition of 'snprintf' (compiling source file libssh2-files\src\mac.c)
+  - make `bcrypt_pbkdf()` static.
   
-  1>C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt\stdio.h(1927): fatal error C1189: #error: Macro definition of snprintf conflicts with Standard Library function declaration (compiling source file libssh2-files\src\mac.c)
-
-Daniel Stenberg (26 Mar 2016)
-- [Brad Harder brought this change]
+    While here, make the low-level `bcrypt_pbkdf()` function static to
+    avoid namespace pollution.
+  
+  Closes #855
 
-  _libssh2_channel_open: speeling error fixed in channel error message
+GitHub (17 Mar 2023)
+- [Viktor Szakats brought this change]
 
-Alexander Lamaison (15 Mar 2016)
-- Link with crypt32.lib on Windows.
+  ci: more timeout adjustments (#853)
   
-  Makes linking with static OpenSSL work again.  Although it's not
-  required for dynamic OpenSSL, it does no harm.
+  - add timeout to SSH connection wait loop in AppVeyor test prep.
+    (2 minutes)
   
-  Fixes #98.
-
-- [Craig A. Berry brought this change]
-
-  Tweak VMS help file building.
+  - switch to per-step timeout for GitHub CI cmake/ctest runs.
+    (10 minutes)
   
-  Primarily this is handling cases where top-level files moved into
-  the docs/ directory.  I also corrected a typo and removed the
-  claim that libssh2 is public domain.
+    ctest timeout (of 450 seconds) didn't seem to make any difference.
 
-- [Craig A. Berry brought this change]
-
-  Build with standard stat structure on VMS.
+Viktor Szakats (17 Mar 2023)
+- ci: set timeout to ctest and GitHub CI jobs
   
-  This gets us large file support, is available on any VMS release
-  in the last decade and more, and gives stat other modern features
-  such as 64-bit ino_t.
-
-- [Craig A. Berry brought this change]
-
-  Update vms/libssh2_config.h.
+  - `ctest` shows a the default timeout '10000000' (turns out to be
+    in seconds), cause infinite waits e.g. in case the necessary server
+    worker is not available.
   
-  VMS does have stdlib.h, gettimeofday(), and OpenSSL.  The latter
-  is appropriate to hard-wire in the configuration because it's
-  installed by default as part of the base operating system and
-  there is currently no libgcrypt port.
-
-- [Craig A. Berry brought this change]
-
-  VMS can't use %zd for off_t format.
+    CMake CI tests take approx:
+    - GitHub   / Linux  : 125 seconds
+    - AppVeyor / Windows: 300 seconds
   
-  %z is a C99-ism that VMS doesn't currently have; even though the
-  compiler is C99-compliant, the library isn't quite.  The off_t used
-  for the st_size element of the stat can be 32-bit or 64-bit, so
-  detect what we've got and pick a format accordingly.
-
-- [Craig A. Berry brought this change]
-
-  Normalize line endings in libssh2_sftp_get_channel.3.
+    New timeouts are: 450 and 900 seconds respectively.
   
-  Somehow it got Windows-style CRLF endings so convert to just LF,
-  for consistency as well as not to confuse tools that will regard
-  the \r as content (e.g. the OpenVMS help librarian).
-
-Dan Fandrich (29 Feb 2016)
-- libgcrypt: Fixed a NULL pointer dereference on OOM
-
-Daniel Stenberg (24 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  url updates, HTTP => HTTPS
+  - set timeouts for style-check, fuzz, Linux and Windows GitHub CI
+    jobs to avoid hanging forever.
   
-  Closes #87
-
-Dan Fandrich (23 Feb 2016)
-- RELEASE-NOTES: removed some duplicated names
-
-Version 1.7.0 (23 Feb 2016)
-
-Daniel Stenberg (23 Feb 2016)
-- web: the site is now HTTPS
-
-- RELEASE-NOTES: 1.7.0 release
-
-- diffie_hellman_sha256: convert bytes to bits
+  Also:
   
-  As otherwise we get far too small numbers.
+  - move `choco install` to before_test to make builds start faster
+    in `appveyor.yml`.
   
-  Reported-by: Andreas Schneider
+  - fix some yamllint `ON`/`OFF`-confusion issue by quoting these
+    values in `appveyor.yml`.
   
-  CVE-2016-0787
-
-Alexander Lamaison (18 Feb 2016)
-- Allow CI failures with VS 2008 x64.
+  - fix indentation in `appveyor.yml`.
   
-  Appveyor doesn't support this combination.
-
-Daniel Stenberg (16 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  GNUmakefile: list system libs after user libs
+  - convert to GitHub workflows to LF line-ending.
   
-  Otherwise some referenced WinSock functions will fail to
-  resolve when linking against LibreSSL 2.3.x static libraries
-  with mingw.
+  Ref: https://github.com/libssh2/libssh2/pull/655#issuecomment-1472853493
   
-  Closes #80
+  Closes #851
 
+GitHub (17 Mar 2023)
 - [Viktor Szakats brought this change]
 
-  openssl: apply new HAVE_OPAQUE_STRUCTS macro
+  ci: update mbedTLS repo URL, delete Travis CI (#850)
+  
+  Last Travis CI session run on 2021-11-18.
   
-  Closes #81
+  Ref: https://app.travis-ci.com/github/libssh2/libssh2
+  Ref: https://travis-ci.org/github/libssh2/libssh2/builds
 
 - [Viktor Szakats brought this change]
 
-  openssl: fix LibreSSL support after OpenSSL 1.1.0-pre1/2 support
-
-Alexander Lamaison (14 Feb 2016)
-- sftp.h: Fix non-C90 type.
+  appveyor.yml: reorder tests to return relevant feedback earlier (#849)
   
-  uint64_t does not exist in C90.  Use libssh2_uint64_t instead.
-
-- Exclude sshd tests from AppVeyor.
+  - build x64 first
   
-  They fail complaining that sshd wasn't invoked with an absolute path.
-
-- Test on more versions of Visual Studio.
-
-- Fix Appveyor builds.
-
-Daniel Stenberg (14 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  openssl: add OpenSSL 1.1.0-pre3-dev compatibility
+    x64 is the more interesting target. Most type conversion issues are
+    revealed here. Also more commonly used by now.
   
-  by using API instead of accessing an internal structure.
+  - test VS 2013 earlier
   
-  Closes #83
-
-- RELEASE-NOTES: synced with 996b04ececdf
-
-- include/libssh2.h: next version is 1.7.0
-
-- configure: build "silent" if possible
-
-- sftp: re-indented some minor stuff
-
-- [Jakob Egger brought this change]
-
-  sftp.c: ensure minimum read packet size
+  - test WinCNG earlier
   
-  For optimum performance we need to ensure we don't request tiny packets.
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Explicit return values & sanity checks
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Check Read Packet File Offset
+  - delete reference to no longer used VS 2008
   
-  This commit adds a simple check to see if the offset of the read
-  request matches the expected file offset.
+  After this patch we end up starting with all Shared builds (2015, 2013,
+  OpenSSL, WinCNG), then continue with Static ones. Shared/Static makes
+  a minor if any difference in builds/tests compared to different VS
+  versions of TLS backends.
   
-  We could try to recover, from this condition at some point in the future.
-  Right now it is better to return an error instead of corrupted data.
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Don't return EAGAIN if data was written to buffer
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Send at least one read request before reading
+  --
+  
+  CI run times:
+  
+  Preparation + build takes:
+  8 x VS2015 4.5 mins -> total: 36
+  8 x VS2013 2   mins -> total: 16
+  Total: 52 mins
   
-  This commit ensures that we have sent at least one read request before
-  we try to read data in sftp_read().
+  with our 30 tests, it increases to:
+  8 x VS2015 8-10 mins -> total: 72
+  8 x VS2013 6- 9 mins -> total: 60
+  Total: 132 mins
   
-  Otherwise sftp_read() would return 0 bytes (indicating EOF) if the
-  socket is not ready for writing.
+  Without tests: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46475315
+  With    tests: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46480549
 
-- [Jakob Egger brought this change]
-
-  sftp.c: stop reading when buffer is full
+Dan Fandrich (14 Mar 2023)
+- src: check for NULL pointer passed to _libssh2_get_string
   
-  Since we can only store data from a single chunk in filep,
-  we have to stop receiving data as soon as the buffer is full.
+  Callers should be protecting against this, but it's prudent to check
+  here anyway.
   
-  This adresses the following bug report:
-  https://github.com/libssh2/libssh2/issues/50
+  Fixes #802
+  Closes #848
 
-Salvador Fandiño (21 Jan 2016)
-- agent_disconnect_unix: unset the agent fd after closing it
+Viktor Szakats (14 Mar 2023)
+- appveyor.yml: choco install improvements [ci skip]
   
-  "agent_disconnect_unix", called by "libssh2_agent_disconnect", was
-  leaving the file descriptor in the agent structure unchanged. Later,
-  "libssh2_agent_free" would call again "libssh2_agent_disconnect" under
-  the hood and it would try to close again the same file descriptor. In
-  most cases that resulted in just a harmless error, but it is also
-  possible that the file descriptor had been reused between the two
-  calls resulting in the closing of an unrelated file descriptor.
+  - avoid outputting 4000 log lines by hiding the progress bar.
+    Reduces log size by 5x.
   
-  This patch sets agent->fd to LIBSSH2_INVALID_SOCKET avoiding that
-  issue.
+  - decrease timeout (from the default 2700 seconds).
   
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
+  - omit unnecessary output.
+  
+  Tested as part of #846
 
-Daniel Stenberg (18 Jan 2016)
-- [Patrick Monnerat brought this change]
+GitHub (14 Mar 2023)
+- [Jakob Egger brought this change]
 
-  os400qc3: support encrypted private keys
+  build: update instructions for autoreconf (#847)
   
-  PKCS#8 EncryptedPrivateKeyinfo structures are recognized and decoded to get
-  values accepted by the Qc3 crypto library.
+  The "convenience script" talks about the "buildconf" file,
+  which is no longer recommended.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3: New PKCS#5 decoder
+  win32: set HAVE_STRTOLL with MSVS 2013 and newer (#845)
   
-  The Qc3 library is not able to handle PKCS#8 EncryptedPrivateKeyInfo structures
-  by itself. It is only capable of decrypting the (encrypted) PrivateKeyInfo
-  part, providing a key encryption key and an encryption algorithm are given.
-  Since the encryption key and algorithm description part in a PKCS#8
-  EncryptedPrivateKeyInfo is a PKCS#5 structure, such a decoder is needed to
-  get the derived key method and hash, as well as encryption algorith and
-  initialisation vector.
+  As in curl:
+  https://github.com/curl/curl/blob/7fa6e36583b52dd8f1e639b370c9a2849be81b54/lib/config-win32.h#L221
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3: force continuous update on non-final hash/hmac computation
+  GNUmakefile: move HAVE_STRTOLL to libssh2_config.h [ci skip] (#844)
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
+
+  src: silence unused variable warnings (#843)
+
+Viktor Szakats (13 Mar 2023)
+- GNUmakefile: add wolfSSL support + major rework
+  
+  - add wolfSSL support.
+  - reduce size and redundant logic.
+  - fix a bunch of small issues.
+  - rework configuration, now with: `CC`, `AR`, `RC`, `TRIPLET`, `CFLAGS`,
+    `CPPFLAGS`, `LDFLAGS`, `RCFLAGS`, `LIBS`, `LIBSSH2_DLL_SUFFIX`,
+    `LIBSSH2_LDFLAGS_LIB`, `LIBSSH2_LDFLAGS_BIN` (and more).
+  - merge examples build into the main Makefile.
+  - relative dependency paths are now the same for building libssh2 or
+    examples.
+  - drop detection for obsolete OpenSSL versions (can be configure via new
+    `OPENSSL_LIBS`).
+  - merge dev/dist distribution zip options.
+  - build libssh2 with `-DHAVE_STRTOLL`.
+  - tidy-up.
+  - build examples in static mode by default (use `DYN` to build them in
+    shared mode).
+  - drop forced (in non-debug mode) `-O2`.
+  - drop Win9x support.
+  - deprecate `ARCH` in favour of custom options and `TRIPLET`.
+  - drop Windows resources from examples for simplicity
+  - drop `WITH_ZLIB`. Default `ZLIB_PATH` to enable zlib support.
+  - drop `LIBSSH2_DLL_A_SUFFIX`, use standard value `.dll` (as in
+    `libssh2.dll.a`).
+  - always link `bcrypt` (for LibreSSL and OpenSSL) and `crypt32`
+    (for wolfSSL).
+  - unhide executed build commands.
+  - fix mbedTLS `lib` path
+  - drop specific options to force static linking. Custom options seems
+    a better way for this.
+  - based on similar work made for curl:
+    https://github.com/curl/curl/commit/a8861b6ccdd7ca35b6115588a578e36d765c9e38
+  
+  Closes #842
+
+GitHub (13 Mar 2023)
+- [Viktor Szakats brought this change]
 
-  os400qc3: Be sure hmac keys have a minimum length
+  wincng: fix memory leak in libssh2_dh_key_pair() (#829)
   
-  The Qc3 library requires a minimum key length depending on the target
-  hash algorithm. Append binary zeroes to the given key if not long enough.
-  This matches RFC 2104 specifications.
+  Fixes #722
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3: Slave descriptor for key encryption key
+  src: C89-compliant _libssh2_debug() macro (#831)
+  
+  Before this patch, with debug logging disabled, libssh2 code used a
+  variadic macro to catch `_libssh2_debug()` calls, and convert them to
+  no-ops. In certain conditions, it used an empty inline function instead.
   
-  The Qc3 library requires the key encryption key to exist as long as
-  the encrypted key is used. Its descriptor token is then kept as an
-  "encrypted key slave" for recursive release.
+  Variadic macro is a C99 feature. It means that depending on compiler,
+  and build settings, it littered the build log with warnings about this.
+  
+  The new solution uses the trick of passing the variable arg list as a
+  single argument and pass that down to the debug function with a regular
+  macro. When disabled, another regular C89-compatible macro converts it
+  to a no-op.
+  
+  This makes inlining, C99 variadic macros and maintaining the conditions
+  for each unnecessary and also makes the codebase compile more
+  consistently, e.g. with forced C standards and/or picky warnings.
+  
+  TL;DR: It makes this feature C89-compliant.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3.c: comment PEM/DER decoding
+  openssl: fix possible compiler warning in macro condition (#839)
+  
+  Building with wolfSSL or pre-OpenSSL v1.1.1 triggered it.
+  
+  ```
+  ../src/openssl.h:130:5: warning: 'LIBRESSL_VERSION_NUMBER' is not defined, evaluates to 0 [-Wundef]
+      LIBRESSL_VERSION_NUMBER >= 0x3070000fL
+      ^
+  ```
+  
+  Regression from 2e2812dde8c1fc9b48eca592823770ab2e601f7a
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3.c: improve ASN.1 header byte checks
+  GNUmakefile: cleanups [ci skip] (#840)
+  
+  - indent
+  - sync `test/GNUmakefile` with main
+  - delete `RANLIB`
+  - use `else if`
+  - use more `?=`
+  - use ASCII-7 copyright symbol (in test)
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400qc3.c: improve OID matching
+  win32: convert tabs to spaces [ci skip] (#838)
+  
+  Also strip stray newlines from `win32/rules.mk`.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: os400qc3.c: replace malloc by LIBSSH2_ALLOC or alloca where possible
+  ci: retry choco install on appveyor (#837)
+  
+  Trying to mitigate occasional intermittent failures while installing
+  docker.
+  
+  Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46460704/job/g3t7bro6ta6n3pk6#L52
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: asn1_new_from_bytes(): use data from a single element only
+  cmake: drop unnecessary exception for warmup build (#835)
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: fix an ILE/RPG prototype
+  cmake: reflect minimum version in docs (#834)
+  
+  Follow-up to 505ea626b6e125b7ce15caf453b522192008a884
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: implement character encoding conversion support
+  cmake: add wolfSSL support to tests (#833)
+  
+  wolfSSL supports building with zlib as a dependency, that's the reason
+  for the ZLIB logic in the patch.
+  
+  Also add it to `docs/INSTALL_CMAKE.md` and to the help text in
+  `src/CMakeLists.txt`.
+  
+  Running tests not actually tested.
+  
+  Follow-up to 9f217a17f6f3c2047c4a1668a5c037a75a02abfd
+  
+  Ref: #817
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: do not miss some external prototypes
+  tests: workaround for intermittent first test failures (#832)
   
-  Build procedure extproto() did not strip braces from header files, thus
-  possibly prepended them to true prototypes. This prevented the prototype to
-  be recognized as such.
-  The solution implemented here is to map braces to semicolons, effectively
-  considering them as potential prototype delimiters.
+  Flakiness got continously worse these last days. It didn't seem related
+  to recent commits. Flakiness also picked up in GitHub CI runs, something
+  rarely seen before. Manual restart consistently fixed them.
+  
+  The repeating pattern was the _first_ test (`test_hostkey`) failing,
+  with `libssh2_session_handshake failed (-13): Failed getting banner`.
+  Failures came after a lengthy wait, suggesting a timeout.
+  
+  I then reversed the order of the first two tests, and it turned out that
+  the _first_ test failed again (`test_hostkey_hash`). Also pointing to a
+  timeout issue.
+  
+  Then I added a dummy test to "warm up" whatever needs warming up in the
+  layers of CI + Docker + ssh server and their interconnects. This helped,
+  and GitHub CI tests run without failure right for the first time.
+  AppVeyor CI also improved a little.
+  
+  This patch adds a new first test called `test_warmup`, that creates a
+  new libssh2 session, and exits with success even if that attempt failed.
+  
+  A stop-gap solution at best, and there is no guarantee it will continue
+  to fix this or similar future issues, but it's also untenable to have
+  almost every CI run fail for intermittent reasons.
+  
+  In some [1] cases [2] it's not the first test failing intermittently.
+  That's a different issue, and this patch doesn't fix it.
+  
+  [1] #804
+  [2] https://ci.appveyor.com/project/libssh2org/libssh2/builds/46440828/job/8rej6cq6itg7vc4w#L500
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: Really add specific README
+  cmake: detect HAVE_SNPRINTF for tests (#830)
+  
+  Turns out `test_keyboard_interactive_auth_info_request.c` requires
+  `src/libssh2_priv.h`, which in turn requires a correctly set
+  `HAVE_SNPRINTF`.
+  
+  Follow-up to 4cdf785cd313c3272d04c2ef7458a35d44533d8b.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: Add specific README and include new files in dist tarball
+  cmake: unset forced CMAKE_C_STANDARD 90 (#822)
+  
+  Added in cf80f2f4b5255cc85a04ee43b27a29c678c1edb1 (on 2016-08-14),
+  with the title "Basic dockerised test suite".
+  
+  It's not clear why a C standard was explicitly set, but a side-effect
+  of this is that CMake-built binaries diverged from ones built with
+  autotools or GNU Make (using the same compiler and configuration).
+  
+  Another issue is that this may introduce ABI incompatibility with
+  binaries built with a different C standard flag, e.g. the C compiler
+  default or one used for other components of a final app.
+  
+  Seems unlikely, but if our tests require this option, we should set it
+  for the CI builds only?
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: add compilation scripts
+  example: silence MSVS 2013 C4127 warnings (#828)
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: include files for ILE/RPG
+  cmake: reposition ws2_32 to make binutils ld work again (#827)
+  
+  This restores socket libs to their pre-regression positions.
   
-  In addition, file os400/macros.h declares all procedures originally
-  defined as macros. It must not be used for real inclusion and is only
-  intended to be used as a `database' for macro wrapping procedures generation.
+  Without this, `ld` doesn't find `ws2_32` symbols when referenced
+  from TLS libs.
+  
+  Regression from 31fb8860dbaae3e0b7d38f2a647ee527b4b2a95f
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  os400: add supplementary header files/wrappers. Define configuration.
+  fix compiling with LIBSSH2_NO_CLEAR_MEMORY and OpenSSL (#825)
+  
+  Regression from a0e424a51c27cc27af611ba20d134f9a9ae35273
+  
+  Fixes #824
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Protect callback function calls from macro substitution
+  snprintf: add missing prototype for local replacement (#820)
   
-  Some structure fields holding callback addresses have the same name as the
-  underlying system function (connect, send, recv). Set parentheses around
-  their reference to suppress a possible macro substitution.
+  Should fix these warnings with MSVS 2013 and older:
+  `agent.c(294): warning C4013: '_libssh2_snprintf' undefined; assuming extern returning int`
   
-  Use a macro for connect() on OS/400 to resolve a const/nonconst parameter
-  problem.
+  Follow-up to 4cdf785cd313c3272d04c2ef7458a35d44533d8b.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Add interface for OS/400 crypto library QC3
+  build: set _FILE_OFFSET_BITS=64 for mingw-w64 (#821)
+  
+  autotools builds already did auto-detect and set this mingw-specific
+  macro, but CMake and GNU Make builds did not. This patch fixes that.
+  
+  Necessary for `src/scp.c`.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  misc: include stdarg.h for debug code
+  cmake: add os400qc3.c to SOURCES (#826)
+  
+  This re-syncs the list of compiled objects in cmake builds with
+  non-cmake builds.
+  
+  Follow-up to 16619a8eddec35bb8582d1c334db0fc13b0817c4.
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Document crypto library interface
+  build: silence bogus C4127 warnings with MSVS 2013 and earlier (#819)
+  
+  E.g.:
+  `channel.c(370): warning C4127: conditional expression is constant`
+  Ref:
+  https://ci.appveyor.com/project/libssh2org/libssh2/builds/46437333/job/5rak1vcl9hue31ei#L190
 
-- [Patrick Monnerat brought this change]
+- [Viktor Szakats brought this change]
 
-  Feature an optional crypto-specific macro to rsa sign a data fragment vector
+  cmake: use only needed socket libs when checking non-blocking sockets (#816)
   
-  OS/400 crypto library is unable to sign a precomputed SHA1 hash: however
-  it does support a procedure that hashes data fragments and rsa signs.
-  If defined, the new macro _libssh2_rsa_sha1_signv() implements this function
-  and disables use of _libssh2_rsa_sha1_sign().
+  Based on patch by Christian Beier.
   
-  The function described above requires that the struct iovec unused slacks are
-  cleared: for this reason, macro libssh2_prepare_iovec() has been introduced.
-  It should be defined as empty for crypto backends that are not sensitive
-  to struct iovec unused slack values.
-
-- [Patrick Monnerat brought this change]
-
-  Fold long lines in include files
+  Fixes #694
+  Closes #712
 
 - [Viktor Szakats brought this change]
 
-  kex.c: fix indentation
+  cmake: update openssl dll list (#818)
+  
+  Add OpenSSL 3 and versionless DLL names. Also modernize warning messages
+  and variable names.
   
-  Closes #71
+  Do we need the OpenSSL-Windows-specific check and the related
+  `RUNTIME_DEPENDENCIES` feature? The list of OpenSSL DLLs was out of date
+  for 1.5 years without anybody noticing. Keeping it fresh is a chore and
+  copying around DLL dependencies rarely helps as much as expected. This
+  check also results in unuseful warnings in certain build scenarios, e.g.
+  when linking to OpenSSL statically.
 
 - [Viktor Szakats brought this change]
 
-  add OpenSSL-1.1.0-pre2 compatibility
+  cmake: add wolfSSL support (#817)
+  
+  Implement wolfSSL support for libssh2 when building with CMake.
+  
+  Configuration example from curl-for-win:
+  ```
+  -DCRYPTO_BACKEND=wolfSSL
+  -DWOLFSSL_LIBRARY=/path-to/wolfssl/lib/libwolfssl.a
+  -DWOLFSSL_INCLUDE_DIR=/path-to/wolfssl/include
+  ```
   
-  Closes #70
+  Module `cmake/Findwolfssl.cmake` copied from:
+    https://github.com/ngtcp2/ngtcp2/blob/e4d920c4b7a350d63b6978c68b216b76faa12635/cmake/Findwolfssl.cmake
+  via commit:
+    https://github.com/ngtcp2/ngtcp2/commit/296396d3730b721ad97f9de22f525400f8524c0e
+  by Stefan Eissing
 
 - [Viktor Szakats brought this change]
 
-  add OpenSSL 1.1.0-pre1 compatibility
+  cmake: restore non-Windows socket lib detection (#815)
   
-  * close https://github.com/libssh2/libssh2/issues/69
-  * sync a declaration with the rest of similar ones
-  * handle EVP_MD_CTX_new() returning NULL with OpenSSL 1.1.0
-  * fix potential memory leak with OpenSSL 1.1.0 in
-    _libssh2_*_init() functions, when EVP_MD_CTX_new() succeeds,
-    but EVP_DigestInit() fails.
+  I mistakenly pruned some non-Windows logic, also missing the fact that
+  our local `check_function_exists_may_need_library()` set the `NEED_*`
+  variables. Oddly, only `src` imported this function, yet also `examples`
+  and `tests` called it indirectly. The referenced `HAVE_SOCKET` /
+  `HAVE_INET_ADDR` variables might be coming from an upstream CMake
+  project? Leaving those there also, just in case.
+  
+  Regression from 31fb8860dbaae3e0b7d38f2a647ee527b4b2a95f
 
-Marc Hoersken (22 Dec 2015)
-- wincng.c: fixed _libssh2_wincng_hash_final return value
+Viktor Szakats (7 Mar 2023)
+- build: more fixes and tidy-up (mostly for Windows)
   
-  _libssh2_wincng_hash_final was returning the internal BCRYPT
-  status code instead of a valid libssh2 return value (0 or -1).
+  - cmake: always link `ws2_32` on Windows. Also add it to `libssh2.pc`.
   
-  This also means that _libssh2_wincng_hash never returned 0.
-
-- wincng.c: fixed possible memory leak in _libssh2_wincng_hash
+     Fixes #745
   
-  If _libssh2_wincng_hash_update failed _libssh2_wincng_hash_final
-  would never have been called before.
+  - agent: fix gcc compiler warning:
+     `src/agent.c:296:35: warning: 'snprintf' output truncated before the last format character [-Wformat-truncation=]`
   
-  Reported by Zenju.
-
-Kamil Dudka (15 Dec 2015)
-- [Paul Howarth brought this change]
-
-  libssh2.pc.in: fix the output of pkg-config --libs
+  - autotools: fix `EVP_aes_128_ctr` detection with binutils `ld`
   
-  ... such that it does not include LDFLAGS used to build libssh2 itself.
-  There was a similar fix in the curl project long time ago:
+     The prerequisite for a successful detection is setting
+     `LIBS=-lbcrypt` if the chosen openssl-compatible library requires
+     it, e.g. libressl, or quictls/openssl built with
+     `-DUSE_BCRYPTGENRANDOM`.
   
-  https://github.com/bagder/curl/commit/curl-7_19_7-56-g4c8adc8
+     With llvm `lld`, detection works out of the box. With binutils `ld`,
+     it does not. The reason is `ld`s world-famous pickiness with lib
+     order.
   
-  Bug: https://bugzilla.redhat.com/1279966
-  Signed-off-by: Kamil Dudka <kdudka@redhat.com>
-
-Marc Hoersken (6 Dec 2015)
-- hostkey.c: align code path of ssh_rsa_init to ssh_dss_init
-
-- hostkey.c: fix invalid memory access if libssh2_dsa_new fails
+     To fix it, we pass all custom libs before and after the TLS libs.
+     This ugly hack makes `ld` happy and detection succeed.
   
-  Reported by dimmaq, fixes #66
-
-Daniel Stenberg (3 Nov 2015)
-- [Will Cosgrove brought this change]
-
-  gcrypt: define libssh2_sha256_ctx
+  - agent: fix Windows-specific warning:
+    `src/agent.c:318:10: warning: implicit conversion loses integer precision: 'LRESULT' (aka 'long long') to 'int' [-Wshorten-64-to-32]`
   
-  Looks like it didn't make it into the latest commit for whatever reason.
+  - src: fix llvm/clang compiler warning:
+    `src/libssh2_priv.h:987:28: warning: variadic macros are a C99 feature [-Wvariadic-macros]`
   
-  Closes #58
-
-- [Salvador Fandino brought this change]
-
-  libssh2_session_set_last_error: Add function
+  - src: support `inline` with `__GNUC__` (llvm/clang and gcc), fixing:
+    ```
+    src/libssh2_priv.h:990:8: warning: extension used [-Wlanguage-extension-token]
+    static inline void
+           ^
+    ```
   
-  Net::SSH2, the Perl wrapping module for libssh2 implements several features*
-  on top of libssh2 that can fail and so need some mechanism to report the error
-  condition to the user.
+  - blowfish: support `inline` keyword with MSVC.
   
-  Until now, besides the error state maintained internally by libssh2, another
-  error state was maintained at the Perl level for every session object and then
-  additional logic was used to merge both error states. That is a maintenance
-  nighmare, and actually there is no way to do it correctly and consistently.
+     Also switch to `__inline__` (from `__inline`) for `__GNUC__`:
+       https://gcc.gnu.org/onlinedocs/gcc/Inline.html
+       https://clang.llvm.org/docs/UsersManual.html#differences-between-various-standard-modes
   
-  In order to allow the high level language to add new features to the library
-  but still rely in its error reporting features the new function
-  libssh2_session_set_last_error (that just exposses _libssh2_error_flags) is
-  introduced.
+  - example/test: fix MSVC compiler warnings:
   
-  *) For instance, connecting to a remote SSH service giving the hostname and
-  port.
+    - `example\direct_tcpip.c(209): warning C4244: 'function': conversion from 'unsigned int' to 'u_short', possible loss of data`
+    - `tests\session_fixture.c(96): warning C4013: 'getcwd' undefined; assuming extern returning int`
+    - `tests\session_fixture.c(100): warning C4013: 'chdir' undefined; assuming extern returning int`
   
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
-
-- [Salvador Fandino brought this change]
+  - delete unused macros:
+    - `HAVE_SOCKET`
+    - `HAVE_INET_ADDR`
+    - `NEED_LIB_NSL`
+    - `NEED_LIB_SOCKET`
+    - `HAVE_NTSTATUS_H`
+    - `HAVE_NTDEF_H`
+  
+  - build: delete stale zlib/openssl version numbers from path defaults.
+  
+  - cmake: convert tabs to spaces, add newline at EOFs.
+  
+  Closes #811
 
-  _libssh2_error: Support allocating the error message
+- cmake: make `test_read` runs cross-build-friendly
   
-  Before this patch "_libssh2_error" required the error message to be a
-  static string.
+  Improve tests added in 7487dcf4b4ddae54b2a850737789b57b4251b0ae by
+  running `test_read` commands directly. This makes external shell/batch
+  files unnecessary, and is friendlier with cross-builds and when run
+  from non-default shells, like MSYS2.
   
-  This patch adds a new function "_libssh2_error_flags" accepting an
-  additional "flags" argument and specifically the flag
-  "LIBSSH2_ERR_FLAG_DUP" indicating that the passed string must be
-  duplicated into the heap.
+  Also extend CRYPT/MAC test error messages with the CRYPT/MAC name.
   
-  Then, the method "_libssh2_error" has been rewritten to use that new
-  function under the hood.
+  External runner shell scripts kept for future use.
   
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
-
-- [Will Cosgrove brought this change]
-
-  added engine.h include to fix warning
+  Closes #814
 
-- [sune brought this change]
-
-  kex.c: removed dupe entry from libssh2_kex_methods[]
+- src: enable clear memory on all platforms
+  
+  - convert `_libssh2_explicit_zero()` to macro. This allows inlining
+    where supported (e.g. `SecureZeroMemory()`).
+  
+  - replace `SecureZeroMemory()` (in `wincng.c`) and
+    `LIBSSH2_CLEAR_MEMORY`-guarded `memset()` (in `os400qc3.c`) with
+    `_libssh2_explicit_zero()` macro.
+  
+  - delete `LIBSSH2_CLEAR_MEMORY` guards, which enables secure-zeroing
+    universally.
+  
+  - add `LIBSSH2_NO_CLEAR_MEMORY` option to disable secure-zeroing.
+  
+  - while here, delete double/triple inclusion of `misc.h`.
+    `libssh2_priv.h` included it already.
   
-  Closes #51
+  Closes #810
 
-- [Salvador Fandiño brought this change]
+- cmake: bump minimum version to 3.1 (from 2.8.12)
+  
+  This allows to delete some fallback code.
+  
+  CMake release dates:
+  - 2014-12-15: 3.1
+  - 2013-10-07: 2.8.12
+  
+  Closes #813
 
-  userauth: Fix off by one error when reading public key file
+- snprintf: unify fallback logic
+  
+  Before this patch, the `snprintf()` fallback logic for envs not
+  supporting this function (i.e. Visual Studio 2013 and older) varied
+  depending on build tool, and used different techniques in examples,
+  tests and libssh2 itself.
+  
+  This patch aims to apply a common logic to libssh2 and examples/tests.
+  
+  - libssh2: use local `snprintf()` fallback with all build tools.
+  
+    We already had a local implementation, but only with CMake. Move that
+    to the library as `_libssh2_snprintf()`, and map `snprintf()` to it
+    when `HAVE_SNPRINTF` is not set.
+  
+    Also change the length type from `int` to `size_t`, and fix
+    formatting.
   
-  After reading the public key from file the size was incorrectly
-  decremented by one.
+  - set or detect `HAVE_SNPRINTF` in non-CMake builds.
   
-  This was usually a harmless error as the last character on the public
-  key file is an unimportant EOL. But if due to some error the public key
-  file is empty, the public key size becomes (uint)(0 - 1), resulting in
-  an unrecoverable out of memory error later.
+    Detect in autotools. Keep existing logic in `win32/libssh2_config.h`.
+    Always set for OS/400, NetWare and VMS, keeping existing behaviour.
+    (OS/400 builds use a different local implementation)
   
-  Signed-off-by: Salvador Fandi??o <sfandino-/E1597aS9LQAvxtiuMwx3w@public.gmane.org>
+  - examples/tests: drop the CMake-specific fallback logic and map
+    `snprintf()` to `_snprintf()` for old MSVC versions, like we did
+    before with other build tools. This is unsafe, but should be fine for
+    these uses.
+  
+  - `win32/libssh2_config.h`: make it easier to read.
+  
+  Closes #812
 
-- [Salvador Fandino brought this change]
+- cmake: build fixes with OpenSSL/LibreSSL on Windows
+  
+  - Link `bcrypt` for newer (non-fork) OpenSSL.
+  
+  - Link `bcrypt` and `ws2_32` when using (non-fork) OpenSSL or LibreSSL,
+    to allow `Looking for EVP_aes_128_ctr` detecting this feature.
+  
+    With the feature available, but not found by CMake, build failed with:
+    `openssl.c:636:21: error: incompatible integer to pointer conversion assigning to 'EVP_CIPHER *' (aka 'struct evp_cipher_st *') from 'int' [-Wint-conversion]`
+  
+  Closes #809
 
-  channel: Detect bad usage of libssh2_channel_process_startup
+- build fixes and improvements (mostly for Windows)
+  
+  - in `hostkey.c` check the result of `libssh2_sha256_init()` and
+    `libssh2_sha512_init()` calls. This avoid the warning that we're
+    ignoring the return values.
+  
+  - fix code using `int` (or `SOCKET`) for sockets. Use libssh2's
+    dedicated `libssh2_socket_t` and `LIBSSH2_INVALID_SOCKET` instead.
+  
+  - fix compiler warnings due to `STATUS_*` macro redefinitions between
+    `ntstatus.h` / `winnt.h`. Solve it by manually defining the single
+    `STATUS` value we need from `ntstatus.h` and stop including the whole
+    header.
+    Fixes #733
+  
+  - improve Windows UWP/WinRT builds by detecting it with code copied
+    from the curl project. Then excluding problematic libssh2 parts
+    according to PR by Dmitry Kostju�enko.
+    Fixes #734
+  
+  - always use `SecureZeroMemory()` on Windows.
+  
+    We can tweak this if not found or not inlined by a C compiler which
+    we otherwise support. Same if it causes issues with UWP apps.
+  
+    Ref: https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/aa366877(v=vs.85)
+    Ref: https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlsecurezeromemory
+  
+  - always enable `LIBSSH2_CLEAR_MEMORY` on Windows. CMake and
+    curl-for-win builds already did that. Delete `SecureZeroMemory()`
+    detection from autotools' WinCNG backend logic, that this
+    setting used to depend on.
+  
+    TODO: Enable it for all platforms in a separate PR.
+    TODO: For clearing buffers in WinCNG, call `_libssh2_explicit_zero()`,
+          insead of a local function or explicit `SecureZeroMemory()`.
+  
+  - Makefile.inc: move `os400qc3.h` to `HEADERS`. This fixes
+    compilation on non-unixy platforms. Recent regression.
+  
+  - `libssh2.rc`: replace copyright with plain ASCII, as in curl.
+  
+    Ref: curl/curl@1ca62bb
+    Ref: curl/curl#7765
+    Ref: curl/curl#7776
+  
+  - CMake fixes and improvements:
+  
+    - enable warnings with llvm/clang.
+    - enable more comprehensive warnings with gcc and llvm/clang.
+      Logic copied from curl:
+      https://github.com/curl/curl/blob/233810bb5f6c5e7bedfc10bdd36607b958c0cfe4/CMakeLists.txt#L131-L148
+    - fix `Policy CMP0080` CMake warning by deleting that reference.
+    - add `ENABLE_WERROR` (default: `OFF`) option. Ported from curl.
+    - add `PICKY_COMPILER` (default: `ON`) option, as known from curl.
+  
+      It controls both the newly added picky warnings for llvm/clang and
+      gcc, and also the pre-existing ones for MSVC.
+  
+  - `win32/GNUmakefile` fixes and improvements:
+  
+    - delete `_AMD64_` and add missing `-m64` for x64 builds under test.
+    - add support for `ARCH=custom`.
+      It disables hardcoded Intel 64-bit and Intel 32-bit options,
+      allowing ARM64 builds.
+    - add support for `LIBSSH2_RCFLAG_EXTRAS`.
+      To pass custom options to windres, e.g. in ARM64 builds.
+    - add support for `LIBSSH2_RC`. To override `windres`.
+    - delete support for Metrowerks C. Last released in 2004.
+  
+  - `win32/libssh2_config.h`: delete unnecessary socket #includes
+  
+    `src/libssh2_priv.h` includes `winsock2.h` and `ws2tcpip.h` further
+     down the line, triggered by `HAVE_WINSOCK2_H`.
+  
+    `mswsock.h` does not seem to be necessary anymore.
+  
+    Double-including these (before `windows.h`) caused compiler failures
+    when building against BoringSSL and warnings with LibreSSL. We could
+    work this around by passing `-DNOCRYPT`. Deleting the duplicates
+    fixes these issues.
+  
+    Timeline:
+    2013: c910cd382dfa07fed2adaabf688af9e4a084fa1d deleted `mswsock.h` from `src/libssh2_priv.h`
+    2008: 8c43bc52b1e3de2c8fc7899a80aec0e98de4e2d8 added `winsock2.h` and `ws2tcpip.h` to `src/libssh2_priv.h`
+    2005: dc4bb1af967d2c53e90349f2f37324c622e714f5 added the now deleted #includes
+  
+  - delete or replace `LIBSSH2_WIN32` with `WIN32`.
+  
+  - replace hand-rolled `HAVE_WINDOWS_H` macro with `WIN32`. Also delete
+    its detections/definitions.
+  
+  - delete unused `LIBSSH2_DARWIN` macro.
+  
+  - delete unused `writev()` Windows implementation
   
-  A common novice programmer error (at least among those using the
-  wrapping Perl module Net::SSH2), is to try to reuse channels.
+    There is no reference to `writev()` since 2007-02-02, commit
+    9d55db6501aa4e21f0858cf36cdc2ddc11b96e83.
   
-  This patchs detects that incorrect usage and fails with a
-  LIBSSH2_ERROR_BAD_USE error instead of hanging.
+  - fix a bunch of MSVC / llvm/clang / gcc compiler warnings:
   
-  Signed-off-by: Salvador Fandino <sfandino-/E1597aS9LQAvxtiuMwx3w@public.gmane.org>
+    - `warning C4100: '...': unreferenced formal parameter`
+    - using value of undefined PP macro `LIBSSH2DEBUG`
+    - missing void from function definition
+    - `if()` block missing in non-debug builds
+    - unreferenced variable in non-debug builds
+    - `warning: must specify at least one argument for '...' parameter of variadic macro [-Wgnu-zero-variadic-macro-arguments]`
+      in `_libssh2_debug()`
+    - `warning C4295: 'ciphertext' : array is too small to include a terminating null character`
+    - `warning C4706: assignment within conditional expression`
+    - `warning C4996: 'inet_addr': Use inet_pton() or InetPton() instead or
+        define _WINSOCK_DEPRECATED_NO_WARNINGS to disable deprecated API warnings`
+      By suppressning it. Would be best to use inet_pton() as suggested.
+      On Windows this needs Vista though.
+    - `warning C4152: nonstandard extension, function/data pointer conversion in expression`
+      (silenced locally)
+    - `warning C4068: unknown pragma`
+  
+    Ref: https://ci.appveyor.com/project/libssh2org/libssh2/builds/46354480/job/j7d0m34qgq8rag5w
+  
+  Closes #808
+
+Dan Fandrich (1 Mar 2023)
+- Add tests to check individual crypt & HMAC methods
+  
+  One specific crypt or hmac method is requested to be negotiated, then
+  several MB of data is transferred.
 
+- Add test to read lots of data over a channel
+  
+  Connects to the ssh server then downloads several MB of data.  This
+  tests the data transfer path as well as boundary cases in packet
+  handling as data is split into smaller SSH blocks.
+
+GitHub (27 Feb 2023)
 - [Will Cosgrove brought this change]
 
-  kex: Added diffie-hellman-group-exchange-sha256 support
+  Disable deprecated warnings for OpenSSL 3 #805 (#806)
   
-  ... and fixed HMAC_Init depricated usage
+  Disable deprecated warnings (for now) when building against OpenSSL 3 for a clean build.
   
-  Closes #48
+  Reported:
+  Daniel Stenberg
 
-Alexander Lamaison (21 Sep 2015)
-- Prefixed new #defines to prevent collisions.
+Dan Fandrich (24 Feb 2023)
+- Fix a couple of warnings of errors in MSVC builds
   
-  Other libraries might have their own USE_WIN32_*FILES.
+  Two warnings (in tests & examples) in particular would cause problems:
+  bad format causing invalid data output or a bad chdir due to out of
+  scope buffer use.
 
-- [keith-daigle brought this change]
+- tests: Support running tests in out-of-tree builds
+  
+  Various files are found by referencing the srcdir environment variable
+  in that case.
+  
+  Closes #801
 
-  Update examples/scp.c to fix bug where large files on win32 would cause got to wrap and go negative
+- Improve the ssh2 example program to run a command
+  
+  This performs better as an example since it shows more working code, and
+  in the simplest possible way. It also turns the program into an actually
+  useful tool out of the box, able to run an arbitrary command (with one
+  restriction) on a remote machine and return the response, without
+  needing to touch the source.
+  
+  Closes #800
 
-- [David Byron brought this change]
+GitHub (14 Feb 2023)
+- [Will Cosgrove brought this change]
 
-  add libssh2_scp_recv2 to support large (> 2GB) files on windows
+  Add NULL session check to _libssh2_error_flags() (#796)
+  
+  Don't dereference null if a null session happens to make it into _libssh2_error_flags()
 
-Daniel Stenberg (17 Sep 2015)
-- [sune brought this change]
+Dan Fandrich (7 Feb 2023)
+- Reorder AES crypt methods so stronger ones are first
+  
+  This make it more likely that a stronger one will be negotiated rather
+  than a weaker variant.
 
-  WinCNG: support for SHA256/512 HMAC
+- CI: update uses: dependencies to the latest versions
   
-  Closes #47
+  We were seeing some deprecation warning messages on some of the older
+  ones.
 
-- [brian m. carlson brought this change]
+- transport.c: Add some comments
 
-  Add support for HMAC-SHA-256 and HMAC-SHA-512.
+- Add missing files to automake makefiles & build tests
   
-  Implement support for these algorithms and wire them up to the libgcrypt
-  and OpenSSL backends.  Increase the maximum MAC buffer size to 64 bytes
-  to prevent buffer overflows.  Prefer HMAC-SHA-256 over HMAC-SHA-512, and
-  that over HMAC-SHA-1, as OpenSSH does.
+  Many files have been added to the cmake build files but not the automake
+  ones in recent years. Missing ones have been added so automake "make
+  dist" will now create a usable tar ball.
   
-  Closes #40
-
-- [Zenju brought this change]
+  The integration tests using Docker are now built with automake as well
+  (with "make check").  They are not run yet since they aren't working yet
+  on Linux.
 
-  kex: free server host key before allocating it (again)
+- tests: Fix gcc compile warnings
   
-  Fixes a memory leak when Synology server requests key exchange
-  
-  Closes #43
+  These were mostly due to missing and non-ANSI prototypes.
 
-- [Viktor Szakats brought this change]
+- Enable trace debugging in example/ssh2
+  
+  This is intended to be a test program, so debugging is likely to be
+  useful by default.
 
-  GNUmakefile: up OpenSSL version
+- Improve example/ssh2 to allow unmodified use of public key auth
   
-  closes #23
+  The previous hard-coded key file paths were not valid for normal users.
+  Make the paths relative to the user's home directory instead so they
+  can work out of the box.  Add a banner showing what connection will be
+  attempted to make it easier for the user to see what is being attempted.
+  Enable trace debugging since this is designed as a test program.
 
+GitHub (13 Dec 2022)
 - [Viktor Szakats brought this change]
 
-  GNUmakefile: add -m64 CFLAGS when targeting mingw64, add -m32/-m64 to LDFLAGS
+  openssl.h: enable ed25519 for LibreSSL 3.7.0 (#778)
   
-  libssh2 equivalent of curl patch https://github.com/bagder/curl/commit/d21b66835f2af781a3c2a685abc92ef9f0cd86be
+  This brings LibreSSL libssh2 builds on par with OpenSSL.
+
+Dan Fandrich (5 Dec 2022)
+- configure.ac: check for sys/param.h
   
-  This allows to build for the non-default target when using a multi-target mingw distro.
-  Also bump default OpenSSL dependency path to 1.0.2c.
+  This file is required by glibc for the test suite.
 
+GitHub (12 Nov 2022)
 - [Viktor Szakats brought this change]
 
-  GNUmakefile: add support for LIBSSH2_LDFLAG_EXTRAS
+  tests: add option to run tests without docker (#762)
   
-  It is similar to existing LIBSSH2_CFLAG_EXTRAS, but for
-  extra linker options.
+  via `export OPENSSH_NO_DOCKER=1`.
   
-  Also delete some line/file ending whitespace.
+  SSH server host can be set via:
+    `export OPENSSH_SERVER_HOST=127.0.0.1`
   
-  closes #27
+  SSH server port via existing:
+    `export OPENSSH_SERVER_PORT=4711`
+  
+  This requires more work to be usable out of the box. The necessery sshd
+  config is (partly) embedded into `tests/openssh_server/Dockerfile`.
+  
+  After this patch, it is possible to run tests in envs where docker is
+  not installed or not available, by running a preconfigured,
+  non-containerized sshd.
 
-- [nasacj brought this change]
+- [Michael Buckley brought this change]
 
-  hostkey.c: Fix compiling error when OPENSSL_NO_MD5 is defined
+  Skip leading \r and \n characters in banner_receive() (#769)
+  
+  Fixes #768
   
-  Closes #32
+  Credit:
+  Michael Buckley
 
-- [Mizunashi Mana brought this change]
+- [Zenju brought this change]
 
-  openssl.h: adjust the rsa/dsa includes
+  Fixed error handling of _libssh2_packet_requirev callers (#767)
   
-  ... to work when built without DSA support.
+  Notes:
   
-  Closes #36
-
-Alexander Lamaison (26 Jul 2015)
-- Let CMake build work as a subproject.
+  some callers of _libssh2_packet_requirev() fail to set _libssh2_error().
+  This creates the situation where e.g. libssh2_session_handshake() fails, but libssh2_session_last_error() confusingly returns LIBSSH2_ERROR_NONE.
   
-  Patch contributed by JasonHaslam.
+  Credit:
+  Zenju
 
-- Fix builds with Visual Studio 2015.
-  
-  VS2015 moved stdio functions to the header files as inline function.  That means check_function_exists can't detect them because it doesn't use header files - just does a link check.  Instead we need to use check_symbol_exists with the correct headers.
+- [Will Cosgrove brought this change]
 
-Kamil Dudka (2 Jul 2015)
-- cmake: include CMake files in the release tarballs
-  
-  Despite we announced the CMake support in libssh2-1.6.0 release notes,
-  the files required by the CMake build system were not included in the
-  release tarballs.  Hence, the only way to use CMake for build was the
-  upstream git repository.
+  Revert usage of EVP_CipherUpdate #764 #739 (#765)
   
-  This commit makes CMake actually supported in the release tarballs.
+  Revert usage of EVP_CipherUpdate from wolfSSL PR to fix #764 #739.
+
+- [Will Cosgrove brought this change]
 
-- tests/mansyntax.sh: fix 'make distcheck' with recent autotools
+  Fix regression with rsa_sha2_verify #758 (#763)
   
-  Do not create symbolic links off the build directory.  Recent autotools
-  verify that out-of-source build works even if the source directory tree
-  is not writable.
+  Fixes comparison with the result value coming from `mbedtls_rsa_pkcs1_verify`. Success is 0, not 1.
+
+Marc Hoersken (24 Oct 2022)
+- CI: fix AppVeyor status failing for starting jobs
+
+Viktor Szakats (24 Oct 2022)
+- delete cast5 - null-cipher mapping
+
+- more feature guard cleanup
+
+- indent
 
-- openssl: fix memleak in _libssh2_dsa_sha1_verify()
+- formatting
 
-Daniel Stenberg (12 Jun 2015)
-- openssl: make libssh2_sha1 return error code
+- fold long lines
+
+- cleanup
+
+- temporarily silence checksrc
+
+- add mbedTLS 3.x support
+  
+  Make libssh2 compile cleanly with mbedTLS 3.x and later.
   
-  - use the internal prefix _libssh2_ for non-exported functions
+  This patch makes use of `MBEDTLS_PRIVATE()`, which is not the
+  recommended, future-proof way to access mbedTLS data structures. This
+  method may break with a minor upgrade, according to the authors. This
+  is also the method used by libcurl.
   
-  - removed libssh2_md5() since it wasn't used
+  Also:
+  
+  - Fix a potentially uninitialized variable in
+    `libssh2_mbedtls_rsa_sha2_sign()`. This happened in an error path,
+    resulting in an unnecessary mbedTLS API call, with an uninitialized
+    `md_type`.
   
-  Reported-by: Kamil Dudka
+  - Bump mbedTLS version used in CI tests to 3.2.1.
+  
+  Fixes #751
 
-- [LarsNordin-LNdata brought this change]
+- tests: add option to enable all trace messages in fixture
+  
+  via `export FIXTURE_TRACE_ALL=1`.
 
-  SFTP: Increase speed and datasize in SFTP read
+- win32/GNUmakefile: add mbedTLS support
   
-  The function sftp_read never return more then 2000 bytes (as it should
-  when I asked Daniel). I increased the MAX_SFTP_READ_SIZE to 30000 but
-  didn't get the same speed as a sftp read in SecureSSH. I analyzed the
-  code and found that a return always was dona when a chunk has been read.
-  I changed it to a sliding buffer and worked on all available chunks. I
-  got an increase in speed and non of the test I have done has failed
-  (both local net and over Internet). Please review and test. I think
-  30000 is still not the optimal MAX_SFTP_READ_SIZE, my next goal is to
-  make an API to enable changing this value (The SecureSSH sftp_read has
-  more complete filled packages when comparing the network traffic)
+  via `export MBEDTLS_PATH=<mbedtls-root>`.
 
-- bump: start working on 1.6.1
+Marc Hoersken (21 Oct 2022)
+- CI: fix AppVeyor job links only working for most recent build
+  
+  Ref: https://github.com/curl/curl/pull/9768#issuecomment-1286675916
+  Reported-by: Daniel Stenberg
+  
+  Follow up to #754
 
-Version 1.6.0 (5 Jun 2015)
+- CI: add missing permission section to AppVeyor status workflow
+  
+  Follow up to #754
 
-Daniel Stenberg (5 Jun 2015)
-- RELEASE-NOTES: synced with 858930cae5c6a
+- Remove OSSFuzz integration which was replaced with CIFuzz (#756)
+  
+  Confirmed-by: Max Dymond
 
-Marc Hoersken (19 May 2015)
-- wincng.c: fixed indentation
+- Rename workflow file appveyor.yml to appveyor_docker.yml
 
-- [sbredahl brought this change]
+- Streamline names of CI workflow jobs
 
-  wincng.c: fixed memleak in (block) cipher destructor
+- [Jeroen Ooms brought this change]
 
-Alexander Lamaison (6 May 2015)
-- [Jakob Egger brought this change]
+  Add CI for mingw-w64 via msys2 (#742)
+  
+  Credit: Jeroen Ooms
 
-  libssh2_channel_open: more detailed error message
+- CI: report AppVeyor build status for each job (#754)
   
-  The error message returned by libssh2_channel_open in case of a server side channel open failure is now more detailed and includes the four standard error conditions in RFC 4254.
+  Also give each job on AppVeyor CI a human-readable name.
+  
+  This aims to make job and therefore build failures more visible.
 
-- [Hannes Domani brought this change]
+GitHub (29 Sep 2022)
+- [Michael Buckley brought this change]
 
-  kex: fix libgcrypt memory leaks of bignum
+  Support for sk-ecdsa-sha2-nistp256 and sk-ssh-ed25519 keys, FIDO (#698)
   
-  Fixes #168.
+  Notes:
+  Add support for sk-ecdsa-sha2-nistp256@openssh.com and sk-ssh-ed25519@openssh.com key exchange for FIDO auth using the OpenSSL backend. Stub API for other backends.
+  
+  Credit:
+  Michael Buckley
 
-Marc Hoersken (3 Apr 2015)
-- configure.ac: check for SecureZeroMemory for clear memory feature
+- [Y. Yang brought this change]
 
-- Revert "wincng.c: fix clear memory feature compilation with mingw"
+  Fix DLL import library name (#711)
   
-  This reverts commit 2d2744efdd0497b72b3e1ff6e732aa4c0037fc43.
+  Notes:
+  Fix DLL import library name
   
-  Autobuilds show that this did not solve the issue.
-  And it seems like RtlFillMemory is defined to memset,
-  which would be optimized out by some compilers.
-
-- wincng.c: fix clear memory feature compilation with mingw
+  https://aur.archlinux.org/packages/mingw-w64-libssh2
+  https://cmake.org/cmake/help/latest/prop_tgt/IMPORT_PREFIX.html
+  
+  Credit:
+  metab0t
+  Y. Yang
 
-Alexander Lamaison (1 Apr 2015)
-- [LarsNordin-LNdata brought this change]
+- [skundu07 brought this change]
 
-  Enable use of OpenSSL that doesn't have DSA.
+  Add RSA-SHA2 support for the WinCNG backend (#736)
   
-  Added #if LIBSSH2_DSA for all DSA functions.
+  Notes:
+  Added code to support RSA-SHA2 for WinCNG backend.
+  
+  Credit:
+  skundu07
 
-- [LarsNordin-LNdata brought this change]
+- [Gabriel Smith brought this change]
 
-  Use correct no-blowfish #define with OpenSSL.
+  sftp: Prevent files from being skipped if the output buffer is too small (#746)
   
-  The OpenSSL define is OPENSSL_NO_BF, not OPENSSL_NO_BLOWFISH.
-
-Marc Hoersken (25 Mar 2015)
-- configure: error if explicitly enabled clear-memory is not supported
+  Notes:
+  LIBSSH2_ERROR_BUFFER_TOO_SMALL is returned if the buffer is too small
+  to contain a returned directory entry. On this condition we jump to the
+  label `end`. At this point the number of names left is decremented
+  despite no name being returned.
   
-  This takes 22bd8d81d8fab956085e2079bf8c29872455ce59 and
-  b8289b625e291bbb785ed4add31f4759241067f3 into account,
-  but still makes it enabled by default if it is supported
-  and error out in case it is unsupported and was requested.
-
-Daniel Stenberg (25 Mar 2015)
-- configure: make clear-memory default but only WARN if backend unsupported
+  As suggested in #714, this commit moves the error label after the
+  decrement of `names_left`.
   
-  ... instead of previous ERROR.
-
-Marc Hoersken (24 Mar 2015)
-- wincng.h: fix warning about computed return value not being used
+  Fixes #714
+  
+  Credit:
+  Co-authored-by: Gabriel Smith <gabriel.smith@precisionot.com>
 
-- nonblocking examples: fix warning about unused tvdiff on Mac OS X
+- [bgermann brought this change]
 
-Daniel Stenberg (24 Mar 2015)
-- openssl: fix compiler warnings
+  Drop advertisement clause on Blowfish (#747)
+  
+  Originally driven by https://github.com/pyca/bcrypt/issues/169, OpenBSD
+  removed Niels Provos's BSD advertisement clause in version 7.1:
+  
+  https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/sys/lib/libsa/blowfish.c.diff?r1=1.1&r2=1.2
+  https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/sys/lib/libsa/blowfish.h.diff?r1=1.1&r2=1.2
+  
+  This enables using libssh2 in GPL software.
 
-- cofigure: fix --disable-clear-memory check
+- [zhaochongliu brought this change]
 
-Marc Hoersken (23 Mar 2015)
-- scp.c: improved command length calculation
+  Support building with gcc < version 8
   
-  Reduced number of calls to strlen, because shell_quotearg already
-  returns the length of the resulting string (e.q. quoted path)
-  which we can add to the existing and known cmd_len.
-  Removed obsolete call to memset again, because we can put a final
-  NULL-byte at the end of the string using the calculated length.
-
-- scp.c: improved and streamlined formatting
+  Files: CMakeLists.txt
+  
+  Notes: don't use gcc arguments that don't exist in gcc versions lower than 8 if building with older gcc.
+  
+  Credit:
+  zhaochongliu
 
-- scp.c: fix that scp_recv may transmit not initialised memory
+- [Miguel de Icaza brought this change]
 
-- scp.c: fix that scp_send may transmit not initialised memory
+  Document the obscure LIBSSH2_ERROR_BAD_USE when writing to a channel (#713)
   
-  Fixes ticket 244. Thanks Torsten.
-
-- kex: do not ignore failure of libssh2_sha1_init()
+  Document the obscure LIBSSH2_ERROR_BAD_USE when writing to a channel
   
-  Based upon 43b730ce56f010e9d33573fcb020df49798c1ed8.
-  Fixes ticket 290. Thanks for the suggestion, mstrsn.
+  Credit:
+  Miguel de Icaza
 
-- wincng.h: fix return code of libssh2_md5_init()
+- [Michael Buckley brought this change]
+
+  Don't erroneously log SSH_MSG_REQUEST_FAILURE packets from keepalive  (#727)
+  
+  Notes:
+  When setting a ServerAliveInterval using libssh2_keepalive_config() with want_reply set to true, some servers will reply to the keep-alive requests with a single SSH_MSG_REQUEST_FAILURE packet. This is an allowed behavior in RFC 4254, section 4.
+  
+  Credit:
+  Michael Buckley
 
-- openssl.c: fix possible segfault in case EVP_DigestInit fails
+- [Ryan Kelley brought this change]
 
-- wincng.c: fix possible use of uninitialized variables
+  Updating docs for libssh2_channel_flush_ex (#728)
+  
+  Notes:
+  In #614 it was identified the docs do not accurately show how libssh2_channel_flush_ex() return value is set. I have updated the doc's to correctly show what the function is returning.
+  
+  Credit:
+  Ryan Kelley
 
-- wincng.c: fix unused argument warning if clear memory is not enabled
+- [Sandeep Bansal brought this change]
 
-- wincng: Added explicit clear memory feature to WinCNG backend
+  Support RSA certificate authentication (#710)
   
-  This re-introduces the original feature proposed during
-  the development of the WinCNG crypto backend. It still needs
-  to be added to libssh2 itself and probably other backends.
+  * Adding support for signed RSA keys and unit test
   
-  Memory is cleared using the function SecureZeroMemory which is
-  available on Windows systems, just like the WinCNG backend.
-
-- wincng.c: fixed mixed line-endings
+  Credit:
+  Sandeep Bansal
 
-- wincng.c: fixed use of invalid parameter types in a8d14c5dcf
+Viktor Szakats (2 Jul 2022)
+- configure: add --disable-tests option
 
-- wincng.c: only try to load keys corresponding to the algorithm
+- cmake: do not add libssh2.rc to the static library
 
-- wincng.c: moved PEM headers into definitions
+GitHub (23 May 2022)
+- [AyushiN brought this change]
 
-- wincng.h: fixed invalid parameter name
+  Fixed typo #697 (#701)
+  
+  Credit:
+  AyushiN
 
-- wincng: fixed mismatch with declarations in crypto.h
+- [Viktor Szakats brought this change]
 
-- userauth.c: fixed warning C6001: using uninitialized sig and sig_len
+  Openssl: add support for LibreSSL 3.5.x (#700)
+  
+  LibreSSL 3.5.0 made more structures opaque, so let's enable existing
+  support for that when building against these LibreSSL versions.
+  
+  Ref: https://ftp.openbsd.org/pub/OpenBSD/LibreSSL/libressl-3.5.0-relnotes.txt
+  
+  Credit:
+  Viktor Szakats
 
-- pem.c: fixed warning C6269: possible incorrect order of operations
+- [Michael Buckley brought this change]
 
-- wincng: add support for authentication keys to be passed in memory
+  Ensure KEX replies don't include extra bytes (#696)
   
-  Based upon 18cfec8336e and daa2dfa2db.
-
-- pem.c: add _libssh2_pem_parse_memory to parse PEM from memory
+  Addresses #695
   
-  Requirement to implement 18cfec8336e for Libgcrypt and WinCNG.
+  Credit:
+  Michael Buckley, reported by Harry Sintonen
 
-- pem.c: fix copy and paste mistake from 55d030089b8
+- [Zenju brought this change]
 
-- userauth.c: fix another possible dereference of a null pointer
+  Fix buffer overflow during SSH_MSG_USERAUTH_BANNER (#693)
+  
+  File: userauth.c
+  Notes:
+  This patch fixes application crashes due to heap corruption. Turns out the null terminator is written one byte outside of the allocated area.
+  Credit:
+  Zenju
 
-- userauth.c: fix possible dereference of a null pointer
+- [Will Cosgrove brought this change]
 
-- pem.c: reduce number of calls to strlen in readline
+  Changed NULL check to avoid logic change
 
-Alexander Lamaison (17 Mar 2015)
 - [Will Cosgrove brought this change]
 
-  Initialise HMAC_CTX in more places.
-  
-  Missed a couple more places we init ctx to avoid openssl threading crash.
+  NULL check before calling session_handshake
+
+- [Harry Sintonen brought this change]
 
-- Build build breakage in WinCNG backend caused when adding libssh2_userauth_publickey_frommemory.
+  Fix build since openssl 1.1.0 when ECDSA and/or RIPEMD are disabled (#666)
   
-  The new feature isn't implemented for the WinCNG backend currently, but the WinCNG backend didn't contain any implementation of the required backend functions - even ones that returns an error.  That caused link errors.
+  File: openssl.h
   
-  This change fixes the problem by providing an implementation of the backend functions that returns an error.
-
-- Fix breakage in WinCNG backend caused by introducing libssh2_hmac_ctx_init.
+  Notes:
+  In openssl 1.1.0 and later openssl decided to change some of the defines used to check if certain features are not compiled in the libraries. This updates the define checks.
   
-  The macro was defined to nothing for the libgcrypt backend, but not for WinCNG.  This brings the latter into line with the former.
+  Credit:
+  Harry Sintonen
+  Co-authored-by: Harry Sintonen <sintonen@iki.fi>
 
-Daniel Stenberg (15 Mar 2015)
-- userauth_publickey_frommemory.3: add AVAILABILITY
+- [gbaraldi brought this change]
+
+  Add RSA-SHA2 support for the mbedtls backend (#688)
+  
+  File: mbedtls.c
   
-  ... it will be added in 1.6.0
+  Notes:
+  * Add sha2 support for RSA key upgrading to mbedTLS backend
+  
+  Credit:
+  gbaraldi
 
-- libssh2: next version will be called 1.6.0
+Daniel Stenberg (21 Mar 2022)
+- misc/libssh2_copy_string: avoid malloc zero bytes
+  
+  Avoids the inconsistent malloc return code for malloc(0)
   
-  ... since we just added a new function.
+  Closes #686
 
-- docs: add libssh2_userauth_publickey_frommemory.3 to dist
+Marc Hoersken (17 Mar 2022)
+- wincng: rename struct field referring to the DH private big number
   
-  The function and man page were added in commit 18cfec8336e
+  Closes #684
 
-- [Jakob Egger brought this change]
+- tests/openssh_fixture.c: print command after variable expansion
 
-  direct_tcpip: Fixed channel write
-  
-  There were 3 bugs in this loop:
-  1) Started from beginning after partial writes
-  2) Aborted when 0 bytes were sent
-  3) Ignored LIBSSH2_ERROR_EAGAIN
+- CI: store and reuse OpenSSH Server docker image used for tests
   
-  See also:
-  https://trac.libssh2.org/ticket/281
-  https://trac.libssh2.org/ticket/293
+  Supersedes #588
+  Fixes #665
+  Closes #685
 
-Alexander Lamaison (15 Mar 2015)
+GitHub (26 Feb 2022)
 - [Will Cosgrove brought this change]
 
-  Must init HMAC_CTX before using it.
-  
-  Must init ctx before using it or openssl will reuse the hmac which is not thread safe and causes a crash.
-  Added libssh2_hmac_ctx_init macro.
+  Added LibreSSL to crypto backend list
+
+- [Will Cosgrove brought this change]
 
-- Add continuous integration configurations.
+  Added crypto backend list to template
   
-  Linux-based CI is done by Travis CI.  Windows-based CI is done by Appveyor.
+  Added OS version as well
 
-- [David Calavera brought this change]
+- [Will Cosgrove brought this change]
 
-  Allow authentication keys to be passed in memory.
+  Revert "Option to build both static and shared libraries (#547)" (#675)
   
-  All credits go to Joe Turpin, I'm just reaplying and cleaning his patch:
-  http://www.libssh2.org/mail/libssh2-devel-archive-2012-01/0015.shtml
+  This reverts commit b60dca8b6450a9729670986d2899cca54ccdbb6d.
   
-  * Use an unimplemented error for extracting keys from memory with libgcrypt.
+  #547 doesn't build clean anymore with the keyboard interactive changes.
 
-Daniel Stenberg (14 Mar 2015)
-- docs: include the renamed INSTALL* files in dist
+- [berney brought this change]
 
-Alexander Lamaison (13 Mar 2015)
-- Prevent collisions between CMake and Autotools in examples/ and tests/.
-
-- Avoid clash between CMake build and Autotools.
+  Option to build both static and shared libraries (#547)
   
-  Autotools expects a configuration template file at src/libssh2_config.h.in, which buildconf generates.  But the CMake build system has its CMake-specific version of the file at this path.  This means that, if you don't run buildconf, the Autotools build will fail because it configured the wrong header template.
+  files: cmakelists.txt
   
-  See https://github.com/libssh2/libssh2/pull/8.
-
-- Merge pull request #8 from alamaison/cmake
+  Notes:
+  * Option to build both static and shared libraries when using CMake
   
-  CMake build system.
+  Credit:
+  berney
 
-- CMake build system.
+- [xalopp brought this change]
+
+  Use modern API in userauth_keyboard_interactive() (#663)
   
-  Tested:
-   - Windows:
-      - Visual C++ 2005/2008/2010/2012/2013/MinGW-w64
-      - static/shared
-      - 32/64-bit
-      - OpenSSL/WinCNG
-      - Without zlib
-   - Linux:
-      - GCC 4.6.3/Clang 3.4
-      - static/shared
-      - 32/64-bit
-      - OpenSSL/Libgcrypt
-      - With/Without zlib
-   - MacOS X
-      - AppleClang 6.0.0
-      - static
-      - 64-bit
-      - OpenSSL
-      - Without zlib
+  Files: userauth_kbd_packet.c, userauth_kbd_packet.h, test_keyboard_interactive_auth_info_request.c, userauth.c
   
-  Conflicts:
-          README
-
-- Man man syntax tests fail gracefully if man version is not suitable.
-
-- Return valid code from test fixture on failure.
+  Notes:
+  This refactors `SSH_MSG_USERAUTH_INFO_REQUEST` processing in `userauth_keyboard_interactive()` in order to improve robustness, correctness and readability or the code.
   
-  The sshd test fixture was returning -1 if an error occurred, but negative error codes aren't technically valid (google it).  Bash on Windows converted them to 0 which made setup failure look as though all tests were passing.
-
-- Let mansyntax.sh work regardless of where it is called from.
+  * Refactor userauth_keyboard_interactive to use new api for packet parsing
+  * add unit test for userauth_keyboard_interactive_parse_response()
+  * add _libssh2_get_boolean() and _libssh2_get_byte() utility functions
+  
+  Credit:
+  xalopp
 
-Daniel Stenberg (12 Mar 2015)
-- [Viktor Szakáts brought this change]
+- [xalopp brought this change]
 
-  mingw build: allow to pass custom CFLAGS
+  Fix formatting in manual page (#667)
   
-  Allow to pass custom `CFLAGS` options via environment variable
-  `LIBSSH2_CFLAG_EXTRAS`. Default and automatically added options of
-  `GNUmakefile` have preference over custom ones. This addition is useful
-  for passing f.e. custom CPU tuning or LTO optimization (`-flto
-  -ffat-lto-objects`) options. The only current way to do this is to edit
-  `GNUmakefile`. This patch makes it unnecessary.
+  Fixed formatting of `LIBSSH2_ERROR_AUTHENTICATION_FAILED` in the errors section.
   
-  This is a mirror of similar libcurl patch:
-  https://github.com/bagder/curl/pull/136
+  credit: xalopp
 
-- [Will Cosgrove brought this change]
+- [tihmstar brought this change]
 
-  userauth: Fixed prompt text no longer being copied to the prompts struct
+  NULL terminate server_sign_algorithms string (#669)
   
-  Regression from 031566f9c
-
-- README: update the git repo locations
-
-- wait_socket: wrong use of difftime()
+  files: packet.c, libssh2_priv.h
   
-  With reversed arguments it would always return a negative value...
+  notes:
+  * Fix heap buffer overflow in _libssh2_key_sign_algorithm
   
-  Bug: https://github.com/bagder/libssh2/issues/1
-
-- bump: start working toward 1.5.1 now
+  When allocating `session->server_sign_algorithms` which is a `char*` is is important to also allocate space for the string-terminating null byte at the end and make sure the string is actually null terminated.
+  
+  Without this fix, the `strchr()` call inside the `_libssh2_key_sign_algorithm` (line 1219) function will try to parse the string and go out of buffer on the last invocation.
+  
+  Credit: tihmstar
+  Co-authored-by: Will Cosgrove <will@panic.com>
 
-Version 1.5.0 (11 Mar 2015)
+- [Will Cosgrove brought this change]
 
-Daniel Stenberg (11 Mar 2015)
-- RELEASE-NOTES: 1.5.0 release
+  free RSA2 related memory (#664)
+  
+  Free `server_sign_algorithms` and `sign_algo_prefs`.
 
-- [Mariusz Ziulek brought this change]
+- [Will Cosgrove brought this change]
 
-  kex: bail out on rubbish in the incoming packet
+  Legacy Agent support for rsa2 key upgrading/downgrading #659 (#662)
   
-  CVE-2015-1782
+  Files: libssh2.h, agent.c, userauth.c
   
-  Bug: http://www.libssh2.org/adv_20150311.html
-
-- docs: move INSTALL, AUTHORS, HACKING and TODO to docs/
+  Notes:
+  Part 2 of the fix for #659. This adds rsa key downgrading for agents that don't support sha2 upgrading. It also adds better trace output for debugging/logging around key upgrading.
   
-  And with this, cleanup README to be shorter and mention the new source
-  code home.
-
-- .gitignore: don't ignore INSTALL
+  Credit:
+  Will Cosgrove (signed off by Michael Buckley)
 
-Dan Fandrich (4 Mar 2015)
-- examples/x11.c: include sys/select.h for improved portability
+- [Ian Hattendorf brought this change]
 
-Daniel Stenberg (4 Mar 2015)
-- RELEASE-NOTES: synced with a8473c819bc068
+  Support rsa-sha2 agent flags (#661)
+  
+  File: agent.c
+  Notes: implements rsa-sha2 flags used to tell the agent which signing algo to use.
+   https://tools.ietf.org/id/draft-miller-ssh-agent-01.html#rfc.section.4.5.1
   
-  In preparation for the upcoming 1.5.0 release.
+  Credit:
+  Ian Hattendorf
 
-Guenter Knauf (8 Jan 2015)
-- NetWare build: added some missing exports.
+Daniel Stenberg (13 Jan 2022)
+- [Sunil Nimmagadda brought this change]
 
-Marc Hoersken (29 Dec 2014)
-- knownhost.c: fix use of uninitialized argument variable wrote
+  ssh: Add support for userauth banner.
   
-  Detected by clang scan in       line 1195, column 18.
-
-- examples/x11.c: fix result of operation is garbage or undefined
+  The new libssh2_userauth_banner API allows to get an optional
+  userauth banner sent with SSH_MSG_USERAUTH_BANNER packet by the
+  server.
   
-  Fix use of uninitialized structure w_size_bck.
-  Detected by clang scan in       line 386, column 28.
+  Closes #610
 
-- examples/x11.c: remove dead assigments of some return values
-  
-  Detected by clang scan in line 212, column 9.
-  Detected by clang scan in line 222, column 13.
-  Detected by clang scan in       line 410, column 13.
+GitHub (6 Jan 2022)
+- [Michael Buckley brought this change]
 
-- examples/x11.c: fix possible memory leak if read fails
+  Fix a memcmp errors in code that was changed from memmem to memcmp (#656)
   
-  Detected by clang scan in line 224, column 21.
-
-- examples/x11.c: fix invalid removal of first list element
+  Notes:
+  Fixed supported algo prefs list check when upgrading rsa keys
   
-  Fix use of memory after it was being freed.
-  Detected by clang scan in line 56, column 12.
+  Credit: Michael Buckley
+
+- [Hayden Roche brought this change]
 
-- userauth.c: make sure that sp_len is positive and avoid overflows
+  Add support for a wolfSSL crypto backend. (#629)
   
-  ... if the pointer subtraction of sp1 - pubkey - 1 resulted in a
-  negative or larger value than pubkey_len, memchr would fail.
+  It uses wolfSSL's OpenSSL compatibility layer, so rather than introduce new
+  wolfssl.h/c files, the new backend just reuses openssl.h/c. Additionally,
+  replace EVP_Cipher() calls with EVP_CipherUpdate(), since EVP_Cipher() is not
+  recommended.
   
-  Reported by Coverity CID 89846.
+  Credit: Hayden Roche
 
-- channel.c: remove logically dead code, host cannot be NULL here
+- [Bastien Durel brought this change]
+
+  Runtime engine detection with libssh2_crypto_engine() (#643)
   
-  ... host cannot be NULL in line 525, because it is always
-  valid (e.g. at least set to "0.0.0.0") after lines 430 and 431.
+  File:
+  version.c, HACKING-CRYPTO, libssh2.h, libssh2_crypto_engine.3, makefile.
   
-  Reported by Coverity CID 89807.
-
-- session.c: check return value of session_nonblock during startup
+  Notes:
+  libssh2_crypto_engine() API to get crypto engine at runtime.
   
-  Reported by Coverity CID 89803.
+  Credit: Bastien Durel
 
-- session.c: check return value of session_nonblock in debug mode
+- [Will Cosgrove brought this change]
+
+  RSA SHA2 256/512 key upgrade support RFC 8332 #536 (#626)
+  
+  Notes:
+  * Host Key RSA 256/512 support #536
+  * Client side key hash upgrading for RFC 8332
+  * Support for server-sig-algs, ext-info-c server messages
+  * Customizing preferred server-sig-algs via the preference LIBSSH2_METHOD_SIGN_ALGO
   
-  Reported by Coverity CID 89805.
+  Credit: Anders Borum, Will Cosgrove
 
-- pem.c: fix mixed line-endings introduced with 8670f5da24
+- [xalopp brought this change]
 
-- pem.c: make sure there's a trailing zero and b64data is not NULL
+  fix: use userauth name length to check memory boundaries for userauth name, fixes #653 (#654)
   
-  ... if there is no base64 data between PEM header and footer.
-  Reported by Coverity CID 89823.
-
-- kex.c: make sure mlist is not set to NULL
+  File: userauth.c
   
-  ... if the currently unsupported LANG methods are called.
-  Reported by Coverity CID 89834.
-
-- packet.c: i < 256 was always true and i would overflow to 0
+  Notes:
+  Fixes `userauth_kybd_auth_name_len` length check
   
-  Visualize that the 0-termination is intentional, because the array
-  is later passed to strlen within _libssh2_packet_askv.
+  Co-authored-by: Xaver Lopenstedt <xaver@lopenstedt.de>
 
-- silence multiple data conversion warnings
-
-Daniel Stenberg (23 Dec 2014)
-- agent_connect_unix: make sure there's a trailing zero
-  
-  ... if the path name was too long. Reported by Coverity CID 89801.
+- [Daniel Stenberg brought this change]
 
-Marc Hoersken (22 Dec 2014)
-- examples on Windows: use native SOCKET-type instead of int
+  agent: handle overly large comment lengths (#651)
   
-  And check return values accordingly.
+  Reported-by: Harry Sintonen
 
-- userauth.c: improve readability and clarity of for-loops
+- [Daniel Stenberg brought this change]
 
-Daniel Stenberg (22 Dec 2014)
-- calloc: introduce LIBSSH2_CALLOC()
+  userauth: check for too large userauth_kybd_auth_name_len (#650)
   
-  A simple function using LIBSSH2_ALLOC + memset, since this pattern was
-  used in multiple places and this simplies code in general.
+  ... before using it.
+  
+  Reported-by: MarcoPoloPie
+  Fixes #649
 
-Marc Hoersken (15 Dec 2014)
-- libssh2_priv.h: Ignore session, context and format parameters
+Daniel Stenberg (17 Dec 2021)
+- .github/SECURITY.md: fix the URL
 
-- x11 example: check return value of socket function
+- .github/SECURITY.md: add security policy
 
-- examples: fixed mixed line-endings introduced with aedfba25b8
+GitHub (30 Nov 2021)
+- [Will Cosgrove brought this change]
 
-- wincng.c: explicitly ignore BCrypt*AlgorithmProvider return codes
+  hostkey_method_ssh_ed25519_init() check key bounds (#645)
   
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
-
-- wincng.c: fix possible invalid memory write access
+  * hostkey_method_ssh_ed25519_init() check key bounds
   
-  Fixes VS2012 code analysis warning C6386:
-  buffer overrun: accessing 'pbOutput', the writable size is
-  'cbOutput' bytes, but '3' bytes may be written: libssh2 wincng.c 610
-
-- tests on Windows: check for WSAStartup return code
+  File: hostkey.c
   
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
-
-- wincng.c: fix possible NULL pointer de-reference of bignum
+  Notes:
+  Additional key length checking before calling _libssh2_ed25519_new_public()
   
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'bignum'. libssh2 wincng.c 1567
+  Credit:
+  Will Cosgrove
 
-- wincng.c: fix possible use of uninitialized memory
-  
-  Fixes VS2012 code analysis warning C6001:
-  using uninitialized memory 'cbDecoded'. libssh2 wincng.c 553
+- [Will Cosgrove brought this change]
 
-- packet.c: fix possible NULL pointer de-reference within listen_state
+  Fix error message in memory_read_privatekey #636
   
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'listen_state->channel'. libssh2 packet.c 221
+  file: userauth.c
+  note: fix error message
+  credit:
+  volund
 
-- kex.c: fix possible NULL pointer de-reference with session->kex
-  
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'session->kex'. libssh2 kex.c 1761
+- [cntrump brought this change]
 
-- agent.c: check return code of MapViewOfFile
+  Update maketgz for macOS (#543)
   
-  Fixes VS2012 code analysis warning C6387: 'p+4' may be '0':
-  this does not adhere to the specification for the function
-  'memcpy': libssh2 agent.c 330
+  File:
+  maketgz
   
-  Fixes VS2012 code analysis warning C6387: 'p' may be '0':
-  this does not adhere to the specification for the function
-  'UnmapViewOfFile': libssh2 agent.c 333
-
-- examples on Windows: check for socket return code
+  Notes:
+  Fix error on macOS: sed: -e: No such file or directory
   
-  Fixes VS2012 code analysis warning C28193:
-  The variable holds a value that must be examined
+  Credit:
+  cntrump
 
-- examples on Windows: check for WSAStartup return code
-  
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
+- [Jun Tseng brought this change]
 
-Guenter Knauf (11 Dec 2014)
-- wincng.c: silent some more gcc compiler warnings.
+  CMake update minimum version to 2.8.12 (#639)
+  
+  File:
+  CMakeLists.txt
+  
+  Notes:
+  Following CMake's advice, Update the minimum required version.
+  
+  Credit:
+  Jun Tseng
 
-- wincng.c: silent gcc compiler warnings.
+Daniel Stenberg (8 Nov 2021)
+- [David Korczynski brought this change]
 
-- Watcom build: added support for WinCNG build.
+  ci: Add CIFuzz integration
+  
+  Notes:
+  Add CIFuzz integration to run fuzzer using the OSS-Fuzz infrastructure
+  at each PR.
+  
+  Signed-off-by: David Korczynski <david@adalogics.com>
+  Closes #635
 
-- build: updated dependencies in makefiles.
+GitHub (26 Oct 2021)
+- [Uwe L. Korn brought this change]
 
-Daniel Stenberg (4 Dec 2014)
-- configure: change LIBS not LDFLAGS when checking for libs
+  Use libssh2_EXPORTS as an alternative to _WINDLL (#470)
   
-  Closes #289
+  Files: libssh2.h
   
-  Patch-by: maurerpe
-
-Guenter Knauf (3 Dec 2014)
-- MinGW build: some more GNUMakefile tweaks.
+  Notes:
+  `_WINDLL` is only defined when a Visual Studio CMake generator is used, `libssh2_EXPORTS` is used though for all CMake generator if a shared libssh2 library is being built.
   
-  test/GNUmakefile: added architecture autodetection; added switches to
-  CFLAGS and RCFLAGS to make sure that the right architecture is used.
-  Added support to build with WinCNG.
+  Credit:
+  Uwe L. Korn
 
-- sftpdir.c: added authentication method detection.
+Viktor Szakats (1 Oct 2021)
+- windows: fix clang and WinCNG warnings
   
-  Stuff copied over from ssh2.c to make testing a bit easier.
-
-- NMake build: fixed LIBS settings.
-
-- NMake build: added support for WinCNG build.
-
-- MinGW build: some GNUMakefile tweaks.
+  Fix these categories of warning:
   
-  Added architecture autodetection; added switches to CFLAGS and
-  RCFLAGS to make sure that the right architecture is used.
-  Added support to build with WinCNG.
-
-- MinGW build: Fixed redefine warnings.
-
-- Updated copyright year.
-
-Daniel Stenberg (31 Aug 2014)
-- COPYING: bump the copyright year
-
-Dan Fandrich (28 Jul 2014)
-- docs: fixed a bunch of typos
-
-- docs: added missing libssh2_session_handshake.3 file
-
-Marc Hoersken (19 May 2014)
-- wincng.c: specify the required libraries for dependencies using MSVC
+  - in `wincng.c` disagreement in signed/unsigned char when passing around
+    the passphrase string:
+    `warning: pointer targets in passing argument [...] differ in signedness [-Wpointer-sign]`
+    Fixed by using `const unsigned char *` in all static functions and
+    applying/updating casts as necessary.
   
-  Initially reported by Bob Kast as "for MS VS builds, specify the
-  libraries that are required so they don't need to go into all
-  project files that may use this library". Thanks a lot.
-
-- [Bob Kast brought this change]
-
-  windows build: do not export externals from static library
+  - in each use of `libssh2_*_init()` macros where the result is not used:
+    `warning: value computed is not used [-Wunused-value]`
+    Fixed by using `(void)` casts.
   
-  If you are building a DLL, then you need to explicitly export each
-  entry point. When building a static library, you should not.
+  - `channel.c:1171:7: warning: 'rc' may be used uninitialized in this function [-Wmaybe-uninitialized]`
+    Fixed by initializing this variable with `LIBSSH2_ERROR_CHANNEL_UNKNOWN`.
+    While there I replaced a few 0 literals with `LIBSSH2_ERROR_NONE`.
   
-  libssh2 was exporting the entry points whether it was building a DLL or a
-  static library. To elaborate further, if libssh2 was used as a static
-  library, which was being linked into a DLL, the libssh2 API would be
-  exported from that separate DLL.
-
-Daniel Stenberg (19 May 2014)
-- [Mikhail Gusarov brought this change]
-
-  Fix typos in manpages
-
-Marc Hoersken (18 May 2014)
-- wincng.c: Fixed memory leak in case of an error during ASN.1 decoding
-
-- configure: Display individual crypto backends on separate lines
+  - in `sftp.c`, several of these two warnings:
+    `warning: 'data' may be used uninitialized in this function [-Wmaybe-uninitialized]`
+    `warning: 'data_len' may be used uninitialized in this function [-Wmaybe-uninitialized]`
+    Fixed by initializing these variables with NULL and 0 respectively.
   
-  This avoids line-wrapping in between parameters and makes the
-  error message look like the following:
+  - Also removed the exec attribute from `wincng.h`.
   
-  configure: error: No crypto library found!
-  Try --with-libssl-prefix=PATH
-   or --with-libgcrypt-prefix=PATH
-   or --with-wincng on Windows
-
-- [Bob Kast brought this change]
-
-  libssh2_priv.h: a 1 bit bit-field should be unsigned
+  Notes:
+  - There are many pre-existing checksrc issues.
+  - The `sftp.c` and `channel.c` warnings may apply to other platforms as well.
   
-  some compilers may not like this
-
-- knownhost.c: Fixed warning that pointer targets differ in signedness
-
-- wincng.c: Fixed warning about pointer targets differing in signedness
+  Closes #628
 
-- tcpip-forward.c: Fixed warning that pointer targets differ in signedness
-  
-  libssh2_channel_forward_listen_ex uses ints instead of unsigned ints.
+Daniel Stenberg (25 Sep 2021)
+- README: use www.libssh2.org for the license link
 
-- misc.c: Fixed warning about mixed declarations and code
+- libssh2.h: bump it to 1.10.1-dev
 
-- libgcrypt.h: Fixed warning about pointer targets differing in signedness
+- mailing list: moved to lists.haxx.se
 
-- wincng.h: Fixed warning about pointer targets differing in signedness
+GitHub (2 Sep 2021)
+- [Laurent Stacul brought this change]
 
-- misc.c: Fixed warning about unused parameter abstract
+  openssh_fixture.c: Fix openssh_server build not working (#616) (#620)
+  
+  File: openssh_fixture.c
+  
+  Notes:
+  fixes too long of output lines building docker image
+  
+  Credit:
+  Laurent Stacul
 
-- tcpip-forward.c: Removed unused variables shost, sport and sockopt
+- [Will Cosgrove brought this change]
 
-- wincng.h: Added forward declarations for all WinCNG functions
+  openssh_fixture.c: fix warning (#621)
   
-  Initially reported by Bob Kast as "Wincng - define function
-  prototypes for wincng routines". Thanks a lot.
+  File: openssh_fixture.c
   
-  Also replaced structure definitions with type definitions.
-
-- [Bob Kast brought this change]
+  Notes:
+  Fix `portable_sleep` return type warning
+  
+  Credit:
+  Will Cosgrove
 
-  libssh2.h: on Windows, a socket is of type SOCKET, not int
+- [Will Cosgrove brought this change]
 
-- win32: Added WinCNG targets to generated Visual Studio project
+  Update CI to use latest Ubuntu #624 (#625)
   
-  Inspired by Bob Kast's reports, this commit enables the compilation
-  of libssh2 with WinCNG using the generated Visual Studio project files.
-  This commit adds WinCNG support to parts of the existing Win32 build
-  infrastructure, until new build systems, like pre-defined VS project
-  files or CMake files may be added.
+  File: ci.yml
   
-  This commit and b20bfeb3e519119a48509a1099c06d65aa7da1d7 raise one
-  question: How to handle build systems, like VS project files, that
-  need to include all source files regardless of the desired target,
-  including all supported crypto backends? For now the mentioned commit
-  added a check for LIBSSH2_OPENSSL to openssl.c and with this commit
-  the supported crypto backends are hardcoded within Makefile.am.
-
-- libssh2_priv msvc: Removed redundant definition of inline keyword
+  Notes:
+  Update CI to use latest Ubuntu #624
   
-  Initially reported by Bob Kast as "Remove redundant 'inline' define".
-  Thanks a lot.
-
-- wincng: Made data parameter to hash update function constant
+  Also removed 32 bit building in the matrix.
   
-  Initially reported by Bob Kast as "formal parameter must be const
-  since it is used in contexts where the actual parameter may be const".
-  Thanks a lot.
-
-- wincng: fix cross-compilation against the w64 mingw-runtime package
+  Credit:
+  Will Cosgrove
 
-- openssl: Check for LIBSSH2_OPENSSL in order to compile with openssl
+- [Will Cosgrove brought this change]
 
-- wincng: Fixed use of possible uninitialized variable pPaddingInfo
+  Update .gitignore
   
-  Reported by Bob Kast, thanks a lot.
+  Add .DS_Store files for macOS
 
-- wincng: Added cast for double to unsigned long conversion
-
-- wincng: Cleaned up includes and check NTSTATUS using macro
-  
-  Removed header file combination that is not supported on a real
-  Windows platform and can only be compiled using MinGW. Replaced
-  custom NTSTATUS return code checks with BCRYPT_SUCCESS macro.
+- [Laurent Stacul brought this change]
 
-Daniel Stenberg (16 Mar 2014)
-- userauth_hostbased_fromfile: zero assign to avoid uninitialized use
+  Makefile.am: Add missing key in case openssl > 1.1.0 (#617)
   
-  Detected by clang-analyze
-
-- channel_receive_window_adjust: store windows size always
+  File: Makefile.am
   
-  Avoid it sometimes returning without storing it, leaving calling
-  functions with unknown content!
+  Notes: fix missing test keys
   
-  Detected by clang-analyzer
+  Credit:
+  Laurent Stacul
 
-- publickey_packet_receive: avoid junk in returned pointers
-  
-  clang-analyzer found this risk it would return a non-initialized pointer
-  in a success case
+Version 1.10.0 (29 Aug 2021)
 
-Peter Stuge (16 Mar 2014)
-- [Marc Hoersken brought this change]
+Daniel Stenberg (29 Aug 2021)
+- [Will Cosgrove brought this change]
 
-  Added Windows Cryptography API: Next Generation based backend
+  updated docs for 1.10.0 release
 
-- [Marc Hoersken brought this change]
+Marc Hörsken (30 May 2021)
+- [Laurent Stacul brought this change]
 
-  knownhost.c: fixed that 'key_type_len' may be used uninitialized
+  [tests] Try several times to connect the ssh server
   
-  ../src/knownhost.c: In function 'libssh2_knownhost_readline':
-  ../src/knownhost.c:651:16: warning: 'key_type_len' may be used
-  uninitialized in this function [-Wmaybe-uninitialized]
-               rc = knownhost_add(hosts, hostbuf, NULL,
-                  ^
-  ../src/knownhost.c:745:12: note: 'key_type_len' was declared here
-       size_t key_type_len;
-              ^
-
-- [Marc Hoersken brought this change]
+  Sometimes, as the OCI container is run in detached mode, it is possible
+  the actual server is not ready yet to handle SSH traffic. The goal of
+  this PR is to try several times (max 3). The mechanism is the same as
+  for the connection to the docker machine.
 
-  pem.c: always compile pem.c independently of crypto backend
+- [Laurent Stacul brought this change]
 
-- Fix non-autotools builds: Always define the LIBSSH2_OPENSSL CPP macro
-  
-  Commit d512b25f69a1b6778881f6b4b5ff9cfc6023be42 introduced a crypto
-  library abstraction in the autotools build system, to allow us to more
-  easily support new crypto libraries. In that process it was found that
-  all other build system which we support are hard-coded to build with
-  OpenSSL. Commit f5c1a0d98bd51aeb24aca3d49c7c81dcf8bd858d fixes automake
-  introduced into non-autotools build systems but still overlooked the
-  CPP macro saying that we are using OpenSSL.
-  
-  Thanks to Marc Hörsken for identifying this issue and proposing a fix
-  for win32/{GNUmakefile,config.mk}. This commit uses a slightly different
-  approach but the end result is the same.
+  Remove openssh_server container on test exit
 
-Dan Fandrich (15 Mar 2014)
-- channel_close: Close the channel even in the case of errors
+- [Laurent Stacul brought this change]
 
-- sftp_close_handle: ensure the handle is always closed
+  Allow the tests to run inside a container
+  
+  The current tests suite starts SSH server as OCI container. This commit
+  add the possibility to run the tests in a container provided that:
   
-  Errors are reported on return, but otherwise the close path is
-  completed as much as possible and the handle is freed on exit.
+  * the docker client is installed builder container
+  * the host docker daemon unix socket has been mounted in the builder
+    container (with, if needed, the DOCKER_HOST environment variable
+    accordingly set, and the permission to write on this socket)
+  * the builder container is run on the default bridge network, or the
+    host network. This PR does not handle the case where the builder
+    container is on another network.
 
-Alexander Lamaison (6 Mar 2014)
-- knownhost: Restore behaviour of `libssh2_knownhost_writeline` with short buffer.
+Marc Hoersken (28 May 2021)
+- CI/appveyor: run SSH server for tests on GitHub Actions (#607)
   
-  Commit 85c6627c changed the behaviour of `libssh2_knownhost_writeline` so that it stopped returning the number of bytes needed when the given buffer was too small.  Also, the function changed such that is might write to part of the buffer before realising it is too small.
+  No longer rely on DigitalOcean to host the Docker container.
   
-  This commit restores the original behaviour, whilst keeping the unknown-key-type functionality that 85c6627c.  Instead of writing to the buffer piecemeal, the length of the various parts is calculated up front and the buffer written only if there is enough space.  The calculated necessary size is output in `outlen` regardless of whether the buffer was written to.
+  Unfortunately we require a small dispatcher script that has
+  access to a GitHub access token with scope repo in order to
+  trigger the daemon workflow on GitHub Actions also for PRs.
   
-  The main use-case for the original behaviour that this commit restores is to allow passing in a NULL buffer to get the actual buffer size needed, before calling the function again with the buffer allocated to the exact size required.
+  This script is hosted by myself for the time being until GitHub
+  provides a tighter scope to trigger the workflow_dispatch event.
 
-- knownhost: Fix DSS keys being detected as unknown.
-  
-  I missing `else` meant ssh-dss format keys were being re-detected as unknown format.
+GitHub (26 May 2021)
+- [Will Cosgrove brought this change]
 
-Dan Fandrich (6 Mar 2014)
-- knownhosts: Abort if the hosts buffer is too small
+  openssl.c: guards around calling FIPS_mode() #596 (#603)
   
-  This could otherwise cause a match on the wrong host
-
-- agent_list_identities: Fixed memory leak on OOM
-
-- Fixed a few typos
-
-- userauth: Fixed an attempt to free from stack on error
+  Notes:
+  FIPS_mode() is not implemented in LibreSSL and this API is removed in OpenSSL 3.0 and was introduced in 0.9.7. Added guards around making this call.
+  
+  Credit:
+  Will Cosgrove
 
-- Fixed a few memory leaks in error paths
+- [Will Cosgrove brought this change]
 
-- Fixed two potential use-after-frees of the payload buffer
+  configure.ac: don't undefine scoped variable (#594)
+  
+  * configure.ac: don't undefine scoped variable
   
-  The first might occur if _libssh2_packet_add returns an error, as
-  fullpacket_state wasn't reset to idle so if it were possible for
-  fullpacket to be called again, it would return to the same state
-  handler and re-use the freed p->packet buffer.
+  To get this script to run with Autoconf 2.71 on macOS I had to remove the undefine of the backend for loop variable. It seems scoped to the for loop and also isn't referenced later in the script so it seems OK to remove it.
   
-  The second could occur if decrypt returned an error, as it freed the
-  packet buffer but did not clear total_num, meaning that freed buffer
-  could be written into again later.
-
-Alexander Lamaison (28 Nov 2013)
-- Fix missing `_libssh2_error` in `_libssh2_channel_write`.
+  * configure.ac: remove cygwin specific CFLAGS #598
   
-  In one case, the error code from `_libssh2_transport_read` was being returned from `_libssh2_channel_write` without setting it as the last error by calling `_libssh2_error`.  This commit fixes that.
+  Notes:
+  Remove cygwin specific Win32 CFLAGS and treat the build like a posix build
   
-  Found when using a session whose socket had been inadvertently destroyed.  The calling code got confused because via `libssh2_session_last_error` it appeared no error had occurred, despite one being returned from the previous function.
+  Credit:
+  Will Cosgrove, Brian Inglis
 
-Kamil Dudka (21 Nov 2013)
-- [Mark McPherson brought this change]
+- [Laurent Stacul brought this change]
 
-  openssl: initialise the digest context before calling EVP_DigestInit()
-  
-  When using the OpenSSL libraries in FIPS mode, the function call
-  EVP_DigestInit() is actually #defined to FIPS_digestinit().
-  Unfortunately wheres EVP_DigestInit() initialises the context and then
-  calls EVP_DigestInit_ex(), this function assumes that the context has
-  been pre-initialised and crashes when it isn't.
+  tests: Makefile.am: Add missing tests client keys in distribution tarball (#604)
   
-  Bug: https://trac.libssh2.org/ticket/279
+  Notes:
+  Added missing test keys.
   
-  Fixes #279
-
-- [Marc Hörsken brought this change]
+  Credit:
+  Laurent Stacul
 
-  .gitignore: Ignore files like src/libssh2_config.h.in~
+- [Laurent Stacul brought this change]
 
-Peter Stuge (13 Nov 2013)
-- Move automake conditionals added by commit d512b25f out of Makefile.inc
-  
-  Commit d512b25f69a1b6778881f6b4b5ff9cfc6023be42 added automake
-  conditionals to Makefile.inc but since Makefile.inc is included
-  from Makefile for all other build systems that does not work.
+  Makefile.am: Add missing test keys in the distribution tarball (#601)
   
-  This commit instead adds Makefile.OpenSSL.inc and Makefile.libgcrypt.inc
-  and moves the automake conditional to its proper place, src/Makefile.am.
+  Notes:
+  Fix tests missing key to build the OCI image
   
-  The automake conditional includes the correct Makefile.$name.inc per
-  the crypto library selection/detection done by configure.
+  Credit:
+  Laurent Stacul
+
+Daniel Stenberg (16 May 2021)
+- dist: add src/agent.h
   
-  All non-autotools build system files in libssh2 are hardcoded to use
-  OpenSSL and do not get a conditional but at least there is some reuse
-  because they can all include the new Makefile.OpenSSL.inc.
+  Fixes #597
+  Closes #599
 
-Daniel Stenberg (27 Oct 2013)
-- [Salvador Fandino brought this change]
+GitHub (12 May 2021)
+- [Will Cosgrove brought this change]
 
-  Set default window size to 2MB
-  
-  The default channel window size used until now was 256KB. This value is
-  too small and results on a bottleneck on real-life networks where
-  round-trip delays can easily reach 300ms.
-  
-  The issue was not visible because the configured channel window size
-  was being ignored and a hard-coded value of ~22MB being used instead,
-  but that was fixed on a previous commit.
+  packet.c: Reset read timeout after received a packet (#576) (#586)
   
-  This patch just changes the default window size
-  (LIBSSH2_CHANNEL_WINDOW_DEFAULT) to 2MB. It is the same value used by
-  OpenSSH and in our opinion represents a good compromise between memory
-  used and transfer speed.
+  File:
+  packet.c
   
-  Performance tests were run to determine the optimum value. The details
-  and related discussion are available from the following thread on the
-  libssh2 mailing-list:
+  Notes:
+  Attempt keyboard interactive login (Azure AD 2FA login) and use more than 60 seconds to complete the login, the connection fails.
   
-  http://www.libssh2.org/mail/libssh2-devel-archive-2013-10/0018.shtml
-  http://article.gmane.org/gmane.network.ssh.libssh2.devel/6543
+  The _libssh2_packet_require function does almost the same as _libssh2_packet_requirev but this function sets state->start = 0 before returning.
   
-  An excerpt follows:
+  Credit:
+  teottin, Co-authored-by: Tor Erik Ottinsen <tor.ottinsen@kdi.kongsberg.com>
+
+- [kkoenig brought this change]
+
+  Support ECDSA certificate authentication (#570)
   
-  "I have been running some transfer test and measuring their speed.
+  Files: hostkey.c, userauth.c, test_public_key_auth_succeeds_with_correct_ecdsa_key.c
   
-  My setup was composed of a quad-core Linux machine running Ubuntu 13.10
-  x86_64 with a LXC container inside. The data transfers were performed
-  from the container to the host (never crossing through a physical
-  network device).
+  Notes:
+  Support ECDSA certificate authentication
   
-  Network delays were simulated using the tc tool. And ping was used to
-  verify that they worked as intended during the tests.
+  Add a test for:
+    - Existing ecdsa basic public key authentication
+    - ecdsa public key authentication with a signed public key
   
-  The operation performed was the equivalent to the following ssh command:
+  Credit:
+  kkoenig
+
+- [Gabriel Smith brought this change]
+
+  agent.c: Add support for Windows OpenSSH agent (#517)
   
-    $ ssh container "dd bs=16K count=8K if=/dev/zero" >/dev/null
+  Files: agent.c, agent.h, agent_win.c
   
-  Though, establishment and closing of the SSH connection was excluded
-  from the timings.
+  Notes:
+  * agent: Add support for Windows OpenSSH agent
   
-  I run the tests several times transferring files of sizes up to 128MB
-  and the results were consistent between runs.
+  The implementation was partially taken and modified from that found in
+  the Portable OpenSSH port to Win32 by the PowerShell team, but mostly
+  based on the existing Unix OpenSSH agent support.
   
-  The results corresponding to the 128MB transfer are available here:
+  https://github.com/PowerShell/openssh-portable
   
-  https://docs.google.com/spreadsheet/ccc?key=0Ao1yRmX6PQQzdG5wSFlrZl9HRWNET3ZyN0hnaGo5ZFE&usp=sharing
+  Regarding the partial transfer support implementation: partial transfers
+  are easy to deal with, but you need to track additional state when
+  non-blocking IO enters the picture. A tracker of how many bytes have
+  been transfered has been placed in the transfer context struct as that's
+  where it makes most sense. This tracker isn't placed behind a WIN32
+   #ifdef as it will probably be useful for other agent implementations.
   
-  It clearly shows that 256KB is too small as the default window size.
-  Moving to a 512MB generates a great improvement and after the 1MB mark
-  the returns rapidly diminish. Other factors (TCP window size, probably)
-  become more limiting than the channel window size
+  * agent: win32 openssh: Disable overlapped IO
   
-  For comparison I also performed the same transfers using OpenSSH. Its
-  speed is usually on par with that of libssh2 using a window size of 1MB
-  (even if it uses a 2MB window, maybe it is less aggressive sending the
-  window adjust msgs)."
+  Non-blocking IO is not currently supported by the surrounding agent
+  code, despite a lot of the code having everything set up to handle it.
   
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
+  Credit:
+  Co-authored-by: Gabriel Smith <gabriel.smith@precisionot.com>
 
-- [Salvador brought this change]
+- [Zenju brought this change]
 
-  _libssh2_channel_read: Honour window_size_initial
-  
-  _libssh2_channel_read was using an arbitrary hard-coded limit to trigger
-  the window adjusting code. The adjustment used was also hard-coded and
-  arbitrary, 15MB actually, which would limit the usability of libssh2 on
-  systems with little RAM.
-  
-  This patch, uses the window_size parameter passed to
-  libssh2_channel_open_ex (stored as remote.window_size_initial) plus the
-  buflen as the base for the trigger and the adjustment calculation.
+  Fix detailed _libssh2_error being overwritten (#473)
   
-  The memory usage when using the default window size is reduced from 22MB
-  to 256KB per channel (actually, if compression is used, these numbers
-  should be incremented by ~50% to account for the errors between the
-  decompressed packet sizes and the predicted sizes).
+  Files: openssl.c, pem.c, userauth.c
   
-  My tests indicate that this change does not impact the performance of
-  transfers across localhost or a LAN, being it on par with that of
-  OpenSSH. On the other hand, it will probably slow down transfers on
-  networks with high bandwidth*delay when the default window size
-  (LIBSSH2_CHANNEL_WINDOW_DEFAULT=256KB) is used.
+  Notes:
+  * Fix detailed _libssh2_error being overwritten by generic errors
+  * Unified error handling
   
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
+  Credit:
+  Zenju
 
-- [Salvador Fandino brought this change]
+- [Paul Capron brought this change]
 
-  knownhosts: handle unknown key types
-  
-  Store but don't use keys of unsupported types on the known_hosts file.
+  Fix _libssh2_random() silently discarding errors (#520)
   
-  Currently, when libssh2 parses a known_host file containing keys of some
-  type it doesn't natively support, it stops reading the file and returns
-  an error.
+  Notes:
+  * Make _libssh2_random return code consistent
   
-  That means, that the known_host file can not be safely shared with other
-  software supporting other key types (i.e. OpenSSH).
+  Previously, _libssh2_random was advertized in HACKING.CRYPTO as
+  returning `void` (and was implemented that way in os400qc3.c), but that
+  was in other crypto backends a lie; _libssh2_random is (a macro
+  expanding) to an int-value expression or function.
   
-  This patch adds support for handling keys of unknown type. It can read
-  and write them, even if they are never going to be matched.
+  Moreover, that returned code was:
+    — 0 or success, -1 on error for the MbedTLS & WinCNG crypto backends
+  But also:
+    — 1 on success, -1 or 0 on error for the OpenSSL backend!
+    – 1 on success, error cannot happen for libgcrypt!
   
-  At the source level the patch does the following things:
+  This commit makes explicit that _libssh2_random can fail (because most of
+  the underlying crypto functions can indeed fail!), and it makes its result
+  code consistent: 0 on success, -1 on error.
   
-  - add a new unknown key type LIBSSH2_KNOWNHOST_KEY_UNKNOWN
+  This is related to issue #519 https://github.com/libssh2/libssh2/issues/519
+  It fixes the first half of it.
   
-  - add a new slot (key_type_name) on the known_host struct that is
-  used to store the key type in ascii form when it is not supported
+  * Don't silent errors of _libssh2_random
   
-  - parse correctly known_hosts entries with unknown key types and
-  populate the key_type_name slot
+  Make sure to check the returned code of _libssh2_random(), and
+  propagates any failure.
   
-  - print correctly known_hosts entries of unknown type
+  A new LIBSSH_ERROR_RANDGEN constant is added to libssh2.h
+  None of the existing error constants seemed fit.
   
-  - when checking a host key ignore keys that do not match the key
+  This commit is related to d74285b68450c0e9ea6d5f8070450837fb1e74a7
+  and to https://github.com/libssh2/libssh2/issues/519 (see the issue
+  for more info.)  It closes #519.
   
-  Fixes #276
+  Credit:
+  Paul Capron
 
-- windows build: fix build errors
-  
-  Fixes various link errors with VS2010
-  
-  Reported-by: "kdekker"
-  Fixes #272
+- [Gabriel Smith brought this change]
 
-- man page: add missing function argument
-  
-  for libssh2_userauth_publickey_fromfile_ex()
+  ci: Remove caching of docker image layers (#589)
   
-  Reported-by: "pastey"
+  Notes:
+  continued ci reliability work.
   
-  Fixes #262
+  Credit:
+  Gabriel Smith
 
-- [Salvador brought this change]
+- [Gabriel Smith brought this change]
 
-  Fix zlib deflate usage
-  
-  Deflate may return Z_OK even when not all data has been compressed
-  if the output buffer becomes full.
-  
-  In practice this is very unlikely to happen because the output buffer
-  size is always some KBs larger than the size of the data passed for
-  compression from the upper layers and I think that zlib never expands
-  the data so much, even on the worst cases.
+  ci: Speed up docker builds for tests (#587)
   
-  Anyway, this patch plays on the safe side checking that the output
-  buffer is not exhausted.
+  Notes:
+  The OpenSSH server docker image used for tests is pre-built to prevent
+  wasting time building it during a test, and unneeded rebuilds are
+  prevented by caching the image layers.
   
-  Signed-off-by: Salvador <sfandino@yahoo.com>
+  Credit:
+  Gabriel Smith
 
-- [Salvador brought this change]
+- [Will Cosgrove brought this change]
 
-  comp_method_zlib_decomp: Improve buffer growing algorithm
-  
-  The old algorithm was O(N^2), causing lots and lots of reallocations
-  when highly compressed data was transferred.
+  userauth.c: don't error if using keys without RSA (#555)
   
-  This patch implements a simpler one that just doubles the buffer size
-  everytime it is exhausted. It results in O(N) complexity.
+  file: userauth.c
   
-  Also a smaller inflate ratio is used to calculate the initial size (x4).
+  notes: libssh2 now supports many other key types besides RSA, if the library is built without RSA support and a user attempts RSA auth it shouldn't be an automatic error
   
-  Signed-off-by: Salvador <sfandino@yahoo.com>
+  credit:
+  Will Cosgrove
 
-- [Salvador brought this change]
+- [Marc brought this change]
 
-  Fix zlib usage
-  
-  Data may remain in zlib internal buffers when inflate() returns Z_OK
-  and avail_out == 0. In that case, inflate has to be called again.
-  
-  Also, once all the data has been inflated, it returns Z_BUF_ERROR to
-  signal that the input buffer has been exhausted.
-  
-  Until now, the way to detect that a packet payload had been completely
-  decompressed was to check that no data remained on the input buffer
-  but that didn't account for the case where data remained on the internal
-  zlib buffers.
+  openssl.c: Avoid OpenSSL latent error in FIPS mode (#528)
   
-  That resulted in packets not being completely decompressed and the
-  missing data reappearing on the next packet, though the bug was masked
-  by the buffer allocation algorithm most of the time and only manifested
-  when transferring highly compressible data.
+  File:
+  openssl.c
   
-  This patch fixes the zlib usage.
+  Notes:
+  Avoid initing MD5 digest, which is not permitted in OpenSSL FIPS certified cryptography mode.
   
-  Signed-off-by: Salvador <sfandino@yahoo.com>
+  Credit:
+  Marc
 
-- [Salvador brought this change]
+- [Laurent Stacul brought this change]
 
-  _libssh2_channel_read: fix data drop when out of window
-  
-  After filling the read buffer with data from the read queue, when the
-  window size was too small, "libssh2_channel_receive_window_adjust" was
-  called to increase it. In non-blocking mode that function could return
-  EAGAIN and, in that case, the EAGAIN was propagated upwards and the data
-  already read on the buffer lost.
-  
-  The function was also moving between the two read states
-  "libssh2_NB_state_idle" and "libssh2_NB_state_created" both of which
-  behave in the same way (excepting a debug statment).
+  openssl.c: Fix EVP_Cipher interface change in openssl 3 #463
   
-  This commit modifies "_libssh2_channel_read" so that the
-  "libssh2_channel_receive_window_adjust" call is performed first (when
-  required) and if everything goes well, then it reads the data from the
-  queued packets into the read buffer.
+  File:
+  openssl.c
   
-  It also removes the useless "libssh2_NB_state_created" read state.
+  Notes:
+  Fixes building with OpenSSL 3, #463.
   
-  Some rotted comments have also been updated.
+  The change is described there:
+  https://github.com/openssl/openssl/commit/f7397f0d58ce7ddf4c5366cd1846f16b341fbe43
   
-  Signed-off-by: Salvador <sfandino@yahoo.com>
+  Credit:
+  Laurent Stacul, reported by Sergei
 
-- [Salvador Fandino brought this change]
+- [Gabriel Smith brought this change]
 
-  window_size: redid window handling for flow control reasons
-  
-  Until now, the window size (channel->remote.window_size) was being
-  updated just after receiving the packet from the transport layer.
-  
-  That behaviour is wrong because the channel queue may grow uncontrolled
-  when data arrives from the network faster that the upper layer consumes
-  it.
-  
-  This patch adds a new counter, read_avail, which keeps a count of the
-  bytes available from the packet queue for reading. Also, now the window
-  size is adjusted when the data is actually read by an upper layer.
-  
-  That way, if the upper layer stops reading data, the window will
-  eventually fill and the remote host will stop sending data. When the
-  upper layers reads enough data, a window adjust packet is delivered and
-  the transfer resumes.
+  openssh_fixture.c: Fix potential overwrite of buffer when reading stdout of command (#580)
   
-  The read_avail counter is used to detect the situation when the remote
-  server tries to send data surpassing the window size. In that case, the
-  extra data is discarded.
+  File:
+  openssh_fixture.c
+  Notes:
+  If reading the full output from the executed command took multiple
+  passes (such as when reading multiple lines) the old code would read
+  into the buffer starting at the some position (the start) every time.
+  The old code only works if fgets updated p or had an offset parameter,
+  both of which are not true.
   
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-Peter Stuge (15 Sep 2013)
-- configure.ac: Call zlib zlib and not libz in text but keep option names
+  Credit:
+  Gabriel Smith
 
-- configure.ac: Reorder --with-* options in --help output
+- [Gabriel Smith brought this change]
 
-- configure.ac: Rework crypto library detection
+  ci: explicitly state the default branch (#585)
   
-  This further simplifies adding new crypto libraries.
-
-- Clean up crypto library abstraction in build system and source code
+  Notes:
+  It looks like the $default-branch macro only works in templates, not
+  workflows. This is not explicitly stated anywhere except the linked PR
+  comment.
   
-  libssh2 used to explicitly check for libgcrypt and default to OpenSSL.
+  https://github.com/actions/starter-workflows/pull/590#issuecomment-672360634
   
-  Now all possible crypto libraries are checked for explicitly, making
-  the addition of further crypto libraries both simpler and cleaner.
+  credit:
+  Gabriel Smith
 
-- configure.ac: Add zlib to Requires.private in libssh2.pc if using zlib
+- [Gabriel Smith brought this change]
 
-- Revert "Added Windows Cryptography API: Next Generation based backend"
+  ci: Swap from Travis to Github Actions (#581)
   
-  This reverts commit d385230e15715e67796f16f3e65fd899f21a638b.
-
-Daniel Stenberg (7 Sep 2013)
-- [Leif Salomonsson brought this change]
-
-  sftp_statvfs: fix for servers not supporting statfvs extension
+  Files: ci files
+  
+  Notes:
+  Move Linux CI using Github Actions
   
-  Fixes issue arising when server does not support statfvs and or fstatvfs
-  extensions. sftp_statvfs() and sftp_fstatvfs() after this patch will
-  handle the case when SSH_FXP_STATUS is returned from server.
+  Credit:
+  Gabriel Smith, Marc Hörsken
 
-- [Marc Hoersken brought this change]
+- [Mary brought this change]
 
-  Added Windows Cryptography API: Next Generation based backend
+  libssh2_priv.h: add iovec on 3ds (#575)
+  
+  file: libssh2_priv.h
+  note: include iovec for 3DS
+  credit: Mary Mstrodl
 
-- [Kamil Dudka brought this change]
+- [Laurent Stacul brought this change]
 
-  partially revert "window_size: explicit adjustments only"
+  Tests: Fix unused variables warning (#561)
   
-  This partially reverts commit 03ca9020756a4e16f0294e5b35e9826ee6af2364
-  in order to fix extreme slowdown when uploading to localhost via SFTP.
+  file: test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
   
-  I was able to repeat the issue on RHEL-7 on localhost only.  It did not
-  occur when uploading via network and it did not occur on a RHEL-6 box
-  with the same version of libssh2.
+  notes: fixed unused vars
   
-  The problem was that sftp_read() used a read-ahead logic to figure out
-  the window_size, but sftp_packet_read() called indirectly from
-  sftp_write() did not use any read-ahead logic.
+  credit:
+  Laurent Stacul
 
-- _libssh2_channel_write: client spins on write when window full
-  
-  When there's no window to "write to", there's no point in waiting for
-  the socket to become writable since it most likely just will continue to
-  be.
-  
-  Patch-by: ncm
-  Fixes #258
+- [Viktor Szakats brought this change]
 
-- _libssh2_channel_forward_cancel: avoid memory leaks on error
+  bcrypt_pbkdf.c: fix clang10 false positive warning (#563)
   
-  Fixes #257
-
-- _libssh2_packet_add: avoid using uninitialized memory
+  File: bcrypt_pbkdf.c
   
-  In _libssh2_packet_add, called by _libssh2_packet_read, a call to
-  _libssh2_packet_send that is supposed to send a one-byte message
-  SSH_MSG_REQUEST_FAILURE would send an uninitialized byte upon re-entry
-  if its call to _send returns _EAGAIN.
+  Notes:
+  blf_enc() takes a number of 64-bit blocks to encrypt, but using
+  sizeof(uint64_t) in the calculation triggers a warning with
+  clang 10 because the actual data type is uint32_t. Pass
+  BCRYPT_BLOCKS / 2 for the number of blocks like libc bcrypt(3)
+  does.
   
-  Fixes #259
-
-- _libssh2_channel_forward_cancel: accessed struct after free
+  Ref: https://github.com/openbsd/src/commit/04a2240bd8f465bcae6b595d912af3e2965856de
   
-  ... and the assignment was pointless anyway since the struct was about
-  to be freed. Bug introduced in dde2b094.
+  Fixes #562
   
-  Fixes #268
+  Credit:
+  Viktor Szakats
 
-Peter Stuge (2 Jun 2013)
-- [Marc Hoersken brought this change]
+- [Will Cosgrove brought this change]
 
-  Fixed compilation using mingw-w64
+  transport.c: release payload on error (#554)
+  
+  file: transport.c
+  notes: If the payload is invalid and there is an early return, we could leak the payload
+  credit:
+  Will Cosgrove
 
-- [Marc Hoersken brought this change]
+- [Will Cosgrove brought this change]
 
-  knownhost.c: use LIBSSH2_FREE macro instead of free
+  ssh2_client_fuzzer.cc: fixed building
   
-  Use LIBSSH2_FREE instead of free since
-  _libssh2_base64_encode uses LIBSSH2_ALLOC
+  The GitHub web editor did some funky things
 
-Daniel Stenberg (18 May 2013)
-- [Matthias Kerestesch brought this change]
+- [Will Cosgrove brought this change]
 
-  libssh2_agent_init: init ->fd to LIBSSH2_INVALID_SOCKET
+  ssh_client_fuzzer.cc: set blocking mode on (#553)
   
-  ... previously it was left at 0 which is a valid file descriptor!
+  file: ssh_client_fuzzer.cc
   
-  Bug: https://trac.libssh2.org/ticket/265
+  notes: the session needs blocking mode turned on to avoid EAGAIN being returned from libssh2_session_handshake()
   
-  Fixes #265
+  credit:
+  Will Cosgrove, reviewed by Michael Buckley
+
+- [Etienne Samson brought this change]
 
-- userauth_password: pass on the underlying error code
+  Add a LINT option to CMake (#372)
   
-  _libssh2_packet_requirev() may return different errors and we pass that
-  to the parent instead of rewriting it.
+  * ci: make style-checking available locally
   
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2013-04/0029.shtml
-  Reported by: Cosmin
-
-Peter Stuge (9 May 2013)
-- [Marc Hoersken brought this change]
-
-  libcrypt.c: Fix typo in _libssh2_rsa_sha1_sign() parameter type
-
-Kamil Dudka (4 May 2013)
-- configure.ac: replace AM_CONFIG_HEADER with AC_CONFIG_HEADERS
+  * cmake: add a linting target
   
-  Reported by: Quintus
-  Bug: https://trac.libssh2.org/ticket/261
-
-Guenter Knauf (12 Apr 2013)
-- Fixed copyright string for NetWare build.
+  * tests: check test suite syntax with checksrc.pl
 
-Daniel Stenberg (9 Apr 2013)
-- [Richard W.M. Jones brought this change]
+- [Will Cosgrove brought this change]
 
-  sftp: Add support for fsync (OpenSSH extension).
-  
-  The new libssh2_sftp_fsync API causes data and metadata in the
-  currently open file to be committed to disk at the server.
+  kex.c: kex_agree_instr() improve string reading (#552)
   
-  This is an OpenSSH extension to the SFTP protocol.  See:
+  * kex.c: kex_agree_instr() improve string reading
   
-  https://bugzilla.mindrot.org/show_bug.cgi?id=1798
-
-- [Richard W.M. Jones brought this change]
-
-  sftp: statvfs: Along error path, reset the correct 'state' variable.
+  file: kex.c
+  notes: if haystack isn't null terminated we should use memchr() not strchar(). We should also make sure we don't walk off the end of the buffer.
+  credit:
+  Will Cosgrove, reviewed by Michael Buckley
 
-- [Richard W.M. Jones brought this change]
+- [Will Cosgrove brought this change]
 
-  sftp: seek: Don't flush buffers on same offset
+  kex.c: use string_buf in ecdh_sha2_nistp (#551)
   
-  Signed-off-by: Richard W.M. Jones <rjones@redhat.com>
-
-Guenter Knauf (9 Feb 2013)
-- Updated dependency libs.
-
-- Fixed tool macro names.
-
-Daniel Stenberg (29 Nov 2012)
-- [Seth Willits brought this change]
-
-  compiler warnings: typecast strlen in macros
+  * kex.c: use string_buf in ecdh_sha2_nistp
   
-  ... in macro parameters to avoid compiler warnings about lost precision.
+  file: kex.c
   
-  Several macros in libssh2.h call strlen and pass the result directly to
-  unsigned int parameters of other functions, which warns about precision
-  loss because strlen returns size_t which is unsigned long on at least
-  some platforms (such as OS X). The fix is to simply typecast the
-  strlen() result to unsigned int.
-
-- libssh2.h: bump version to 1.4.4-DEV
-
-Version 1.4.3 (27 Nov 2012)
-
-Daniel Stenberg (27 Nov 2012)
-- RELEASE-NOTES: fixed for 1.4.3
-
-- sftp_read: return error if a too large package arrives
-
-Peter Stuge (13 Nov 2012)
-- Only define _libssh2_dsa_*() functions when building with DSA support
+  notes:
+  use string_buf in ecdh_sha2_nistp() to avoid attempting to parse malformed data
 
-Guenter Knauf (8 Nov 2012)
-- Added .def file to output.
+- [Will Cosgrove brought this change]
 
-Kamil Dudka (1 Nov 2012)
-- libssh2_hostkey_hash.3: update the description of return value
+  kex.c: move EC macro outside of if check #549 (#550)
   
-  The function returns NULL also if the hash algorithm is not available.
-
-Guenter Knauf (24 Oct 2012)
-- Fixed mode acciedently committed.
-
-- Ignore generated file.
-
-- Added hack to make use of Makefile.inc.
+  File: kex.c
   
-  This should avoid further maintainance of the objects list.
-
-- Fixed MSVC NMakefile.
+  Notes:
+  Moved the macro LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY outside of the LIBSSH2_ECDSA since it's also now used by the ED25519 code.
+  
+  Sha 256, 384 and 512 need to be defined for all backends now even if they aren't used directly. I believe this is already the case, but just a heads up.
   
-  Added missing source files; added resource for DLL.
+  Credit:
+  Stefan-Ghinea
 
-Kamil Dudka (22 Oct 2012)
-- examples: use stderr for messages, stdout for data
-  
-  Reported by: Karel Srot
-  Bug: https://bugzilla.redhat.com/867462
+- [Tim Gates brought this change]
 
-- openssl: do not leak memory when handling errors
+  kex.c: fix simple typo, niumber -> number (#545)
   
-  ,.. in aes_ctr_init().  Detected by Coverity.
-
-- channel: fix possible NULL dereference
+  File: kex.c
   
-  ... in libssh2_channel_get_exit_signal().  Detected by Coverity.
-
-- Revert "aes: the init function fails when OpenSSL has AES support"
+  Notes:
+  There is a small typo in src/kex.c.
   
-  This partially reverts commit f4f2298ef3635acd031cc2ee0e71026cdcda5864.
+  Should read `number` rather than `niumber`.
   
-  We need to use the EVP_aes_???_ctr() functions in FIPS mode.
-
-- crypt: use hard-wired cipher block sizes consistently
+  Credit:
+  Tim Gates
 
-- openssl: do not ignore failure of EVP_CipherInit()
+- [Tseng Jun brought this change]
 
-- kex: do not ignore failure of libssh2_md5_init()
+  session.c: Correct a typo which may lead to stack overflow (#533)
   
-  The MD5 algorithm is disabled when running in FIPS mode.
-
-Daniel Stenberg (21 Aug 2012)
-- [Peter Krempa brought this change]
-
-  known_hosts: Fail when parsing unknown keys in known_hosts file.
+  File: session.c
   
-  libssh2_knownhost_readfile() silently ignored problems when reading keys
-  in unsupported formats from the known hosts file. When the file is
-  written again from the internal structures of libssh2 it gets truntcated
-  to the point where the first unknown key was located.
+  Notes:
+  Seems the author intend to terminate banner_dup buffer, later, print it to the debug console.
   
-   * src/knownhost.c:libssh2_knownhost_readfile() - return error if key
-                                                    parsing fails
+  Author:
+  Tseng Jun
 
-- AUTHORS: synced with 42fec44c8a4
+Marc Hoersken (10 Oct 2020)
+- wincng: fix random big number generation to match openssl
   
-  31 recent authors added
-
-- [Dave Hayden brought this change]
-
-  compression: add support for zlib@openssh.com
+  The old function would set the least significant bits in
+  the most significant byte instead of the most significant bits.
   
-  Add a "use_in_auth" flag to the LIBSSH2_COMP_METHOD struct and a
-  separate "zlib@openssh.com" method, along with checking session->state
-  for LIBSSH2_STATE_AUTHENTICATED. Appears to work on the OpenSSH servers
-  I've tried against, and it should work as before with normal zlib
-  compression.
-
-- [Dmitry Smirnov brought this change]
-
-  configure: gcrypt doesn't come with pkg-config support
+  The old function would also zero pad too much bits in the
+  most significant byte. This lead to a reduction of key space
+  in the most significant byte according to the following listing:
+  - 8 bits reduced to 0 bits => eg. 2048 bits to 2040 bits DH key
+  - 7 bits reduced to 1 bits => eg. 2047 bits to 2041 bits DH key
+  - 6 bits reduced to 2 bits => eg. 2046 bits to 2042 bits DH key
+  - 5 bits reduced to 3 bits => eg. 2045 bits to 2043 bits DH key
   
-  ... so use plain old -lgcrypt to the linker to link with it.
+  No change would occur for the case of 4 significant bits.
+  For 1 to 3 significant bits in the most significant byte
+  the DH key would actually be expanded instead of reduced:
+  - 3 bits expanded to 5 bits => eg. 2043 bits to 2045 bits DH key
+  - 2 bits expanded to 6 bits => eg. 2042 bits to 2046 bits DH key
+  - 1 bits expanded to 7 bits => eg. 2041 bits to 2047 bits DH key
   
-  Fixes #225
-
-- sftp_read: Value stored to 'next' is never read
+  There is no case of 0 significant bits in the most significant byte
+  since this would be a case of 8 significant bits in the next byte.
   
-  Detected by clang-analyzer
-
-- publickey_init: errors are negative, fix check
+  At the moment only the following case applies due to a fixed
+  DH key size value currently being used in libssh2:
   
-  Detected by clang-analyzer.
-
-- [Maxime Larocque brought this change]
-
-  session_free: wrong variable used for keeping state
+  The DH group_order is fixed to 256 (bytes) which leads to a
+  2047 bits DH key size by calculating (256 * 8) - 1.
   
-  If libssh2_session_free is called without the channel being freed
-  previously by libssh2_channel_free a memory leak could occur.
+  This means the DH keyspace was previously reduced from 2047 bits
+  to 2041 bits (while the top and bottom bits are always set), so the
+  keyspace is actually always reduced from 2045 bits to 2039 bits.
   
-  A mismatch of states variables in session_free() prevent the call to
-  libssh2_channel_free function. session->state member is used instead of
-  session->free_state.
+  All of this is only relevant for Windows versions supporting the
+  WinCNG backend (Vista or newer) before Windows 10 version 1903.
   
-  It causes a leak of around 600 bytes on every connection on my systems
-  (Linux, x64 and PPC).
+  Closes #521
+
+Daniel Stenberg (28 Sep 2020)
+- libssh2_session_callback_set.3: explain the recv/send callbacks
   
-  (Debugging done under contract for Accedian Networks)
+  Describe how to actually use these callbacks.
   
-  Fixes #246
+  Closes #518
 
-Guenter Knauf (29 Jun 2012)
-- Small NetWare makefile tweak.
+GitHub (23 Sep 2020)
+- [Will Cosgrove brought this change]
 
-- Some small Win32 makefile fixes.
+  agent.c: formatting
+  
+  Improved formatting of RECV_SEND_ALL macro.
 
-Daniel Stenberg (19 Jun 2012)
-- libssh2_userauth_publickey_fromfile_ex.3: mention publickey == NULL
+- [Will Cosgrove brought this change]
 
-- comp_method_zlib_decomp: handle Z_BUF_ERROR when inflating
-  
-  When using libssh2 to perform an SFTP file transfer from the "JSCAPE MFT
-  Server" (http://www.jscape.com) the transfer failed. The default JSCAPE
-  configuration is to enforce zlib compression on SSH2 sessions so the
-  session was compressed. The relevant part of the debug trace contained:
+  CMakeLists.txt: respect install lib dir #405 (#515)
   
-   [libssh2] 1.052750 Transport: unhandled zlib error -5
-   [libssh2] 1.052750 Failure Event: -29 - decompression failure
+  Files:
+  CMakeLists.txt
   
-  The trace comes from comp_method_zlib_decomp() in comp.c. The "unhandled
-  zlib error -5" is the status returned from the zlib function
-  inflate(). The -5 status corresponds to "Z_BUF_ERROR".
+  Notes:
+  Use CMAKE_INSTALL_LIBDIR directory
   
-  The inflate() function takes a pointer to a z_stream structure and
-  "inflates" (decompresses) as much as it can. The relevant fields of the
-  z_stream structure are:
+  Credit: Arfrever
+
+- [Will Cosgrove brought this change]
+
+  kex.c: group16-sha512 and group18-sha512 support #457 (#468)
   
-    next_in - pointer to the input buffer containing compressed data
-    avail_in - the number of bytes available at next_in
-    next_out - pointer to the output buffer to be filled with uncompressed
-               data
-    avail_out - how much space available at next_out
+  Files: kex.c
   
-  To decompress data you set up a z_stream struct with the relevant fields
-  filled in and pass it to inflate(). On return the fields will have been
-  updated so next_in and avail_in show how much compressed data is yet to
-  be processed and next_out and avail_out show how much space is left in
-  the output buffer.
+  Notes:
+  Added key exchange group16-sha512 and group18-sha512. As a result did the following:
   
-  If the supplied output buffer is too small then on return there will be
-  compressed data yet to be processed (avail_in != 0) and inflate() will
-  return Z_OK. In this case the output buffer must be grown, avail_out
-  updated and inflate() called again.
+  Abstracted diffie_hellman_sha256() to diffie_hellman_sha_algo() which is now algorithm agnostic and takes the algorithm as a parameter since we needed sha512 support. Unfortunately it required some helper functions but they are simple.
+  Deleted diffie_hellman_sha1()
+  Deleted diffie_hellman_sha1 specific macro
+  Cleaned up some formatting
+  Defined sha384 in os400 and wincng backends
+  Defined LIBSSH2_DH_MAX_MODULUS_BITS to abort the connection if we receive too large of p from the server doing sha1 key exchange.
+  Reorder the default key exchange list to match OpenSSH and improve security
   
-  If the supplied output buffer was big enough then on return the
-  compressed data will have been exhausted (avail_in == 0) and inflate()
-  will return Z_OK, so the data has all been uncompressed.
+  Credit:
+  Will Cosgrove
+
+- [Igor Klevanets brought this change]
+
+  agent.c: Recv and send all bytes via network in agent_transact_unix() (#510)
   
-  There is a corner case where inflate() makes no progress. That is, there
-  may be unprocessed compressed data and space available in the output
-  buffer and yet the function does nothing. In this case inflate() will
-  return Z_BUF_ERROR. From the zlib documentation and the source code it
-  is not clear under what circumstances this happens. It could be that it
-  needs to write multiple bytes (all in one go) from its internal state to
-  the output buffer before processing the next chunk of input but but
-  can't because there is not enough space (though my guesses as to the
-  cause are not really relevant). Recovery from Z_BUF_ERROR is pretty
-  simple - just grow the output buffer, update avail_out and call
-  inflate() again.
+  Files: agent.c
   
-  The comp_method_zlib_decomp() function does not handle the case when
-  inflate() returns Z_BUF_ERROR. It treats it as a non-recoverable error
-  and basically aborts the session.
+  Notes:
+  Handle sending/receiving partial packet replies in agent.c API.
   
-  Fixes #240
+  Credit: Klevanets Igor <cerevra@yandex-team.ru>
 
-Guenter Knauf (12 Jun 2012)
-- MinGW makefile tweaks.
-  
-  Use GNU tools when compiling on Linux.
-  Fixed dist and dev targets.
+- [Daniel Stenberg brought this change]
 
-- NetWare makefile tweaks.
+  Makefile.am: include all test files in the dist #379
   
-  Changed to use Windows commandline tools instead of
-  GNU tools when compiling on Windows. Fixed dist and
-  dev targets. Enabled nlmconv error for unresolved
-  symbols.
-
-Daniel Stenberg (11 Jun 2012)
-- Revert "config.rpath: generated file, no need to keep in git"
+  File:
+  Makefile.am
   
-  This reverts commit 1ac7bd09cc685755577fb2c8829adcd081e7ab3c.
+  Notes:
+  No longer conditionally include OpenSSL specific test files, they aren't run if we're not building against OpenSSL 1.1.x anyway.
   
-  This file still used by lib/*m4 functions so we need to keep the file
-  around.
-
-- BINDINGS: added PySsh2, a Python-ctypes binding
+  Credit:
+  Daniel Stenberg
 
-Guenter Knauf (8 Jun 2012)
-- Fixed MinGW debug build.
+- [Max Dymond brought this change]
 
-Daniel Stenberg (5 Jun 2012)
-- BINDINGS: Added the Cocoa/Objective-C one
+  Add support for an OSS Fuzzer fuzzing target (#392)
   
-  ... and sorted the bindings after the languages, alphabetically
+  Files:
+  .travis.yml, configure.ac, ossfuzz
   
-  Reported by: Mike Abdullah
-
-- BINDINGS: document the bindings we know of
-
-Guenter Knauf (4 Jun 2012)
-- Fixed LIBSSH2_INT64_T_FORMAT macro.
+  Notes:
+  This adds support for an OSS-Fuzz fuzzing target in ssh2_client_fuzzer,
+  which is a cut down example of ssh2.c. Future enhancements can improve
+  coverage.
   
-  Usually a format macro should hold the whole format, otherwise
-  it should be named a prefix. Also fixed usage of this macro in
-  scp.c for a signed var where it was used as prefix for unsigned.
-
-- Removed obsolete define from makefiles.
-
-- Renamed NetWare makefiles.
-
-- Renamed NetWare makefiles.
+  Credit:
+  Max Dymond
 
-- Synced MinGW makefiles with 56c64a6..39e438f.
-  
-  Also synced MinGW test makefile with b092696..f8cb874.
+- [Sebastián Katzer brought this change]
 
-Peter Stuge (30 May 2012)
-- Revert "sftp: Don't send attrs.permissions on read-only SSH_FXP_OPEN"
+  mbedtls.c: ECDSA support for mbed TLS (#385)
   
-  This reverts commit 04e79e0c798674a0796be8a55f63dd92e6877790.
-
-- sftp: Don't send attrs.permissions on read-only SSH_FXP_OPEN
+  Files:
+  mbedtls.c, mbedtls.h, .travis.yml
   
-  This works around a protocol violation in the ProFTPD 1.3.4 mod_sftp
-  server, as reported by Will Cosgrove in:
+  Notes:
+  This PR adds support for ECDSA for both key exchange and host key algorithms.
   
-  http://libssh2.org/mail/libssh2-devel-archive-2012-05/0079.shtml
+  The following elliptic curves are supported:
   
-  Based on a suggested fix by TJ Saunders in:
+  256-bit curve defined by FIPS 186-4 and SEC1
+  384-bit curve defined by FIPS 186-4 and SEC1
+  521-bit curve defined by FIPS 186-4 and SEC1
   
-  http://libssh2.org/mail/libssh2-devel-archive-2012-05/0104.shtml
+  Credit:
+  Sebastián Katzer
 
-Guenter Knauf (28 May 2012)
-- Try to detect OpenSSL build type automatically.
+Marc Hoersken (1 Sep 2020)
+- buildconf: exec autoreconf to avoid additional process (#512)
   
-  Also fixed recently added libgdi32 linkage which is only
-  required when OpenSSL libs are linked statically.
-
-Daniel Stenberg (25 May 2012)
-- config.rpath: generated file, no need to keep in git
-
-Guenter Knauf (22 May 2012)
-- Updated dependency libary versions.
-
-Daniel Stenberg (18 May 2012)
-- 1.4.3: towards the future
+  Also make buildconf exit with the return code of autoreconf.
+  
+  Follow up to #224
 
-Version 1.4.2 (18 May 2012)
+- scp.c: fix indentation in shell_quotearg documentation
 
-Daniel Stenberg (18 May 2012)
-- RELEASE-NOTES: synced with 92a9f952794
+- wincng: make more use of new helper functions (#496)
 
-Alexander Lamaison (15 May 2012)
-- win32/libssh2_config.h: Remove hardcoded #define LIBSSH2_HAVE_ZLIB.
-  
-  Rationale: Everything else in this file states a fact about the win32
-  platform that is unconditional for that platform.  There is nothing
-  unconditional about the presence of zlib.  It is neither included with
-  Windows nor with the platform SDK.  Therefore, this is not an appropriate
-  place to assert its presence.  Especially as, once asserted, it cannot be
-  overridden using a compiler flag.
-  
-  In contrast, if it is omitted, then it can easily be reasserted by adding
-  a compiler flag defining LIBSSH2_HAVE_ZLIB.
+- wincng: make sure algorithm providers are closed once (#496)
 
-Daniel Stenberg (14 May 2012)
-- RELEASE-NOTES: synced with 69a3354467c
+GitHub (10 Jul 2020)
+- [David Benjamin brought this change]
 
-- _libssh2_packet_add: SSH_MSG_CHANNEL_REQUEST default to want_reply
+  openssl.c: clean up curve25519 code (#499)
   
-  RFC4254 says the default 'want_reply' is TRUE but the code defaulted to
-  FALSE. Now changed.
+  File: openssl.c, openssl.h, crypto.h, kex.c
   
-  Fixes #233
-
-- gettimeofday: no need for a replacement under cygwin
+  Notes:
+  This cleans up a few things in the curve25519 implementation:
   
-  Fixes #224
-
-Alexander Lamaison (13 May 2012)
-- Prevent sftp_packet_read accessing freed memory.
+  - There is no need to create X509_PUBKEYs or PKCS8_PRIV_KEY_INFOs to
+    extract key material. EVP_PKEY_get_raw_private_key and
+    EVP_PKEY_get_raw_public_key work fine.
   
-  sftp_packet_add takes ownership of the packet passed to it and (now that we
-  handle zombies) might free the packet.  sftp_packet_read uses the packet type
-  byte as its return code but by this point sftp_packet_add might have freed
-  it.  This change fixes the problem by caching the packet type before calling
-  sftp_packet_add.
+  - libssh2_x25519_ctx was never used (and occasionally mis-typedefed to
+    libssh2_ed25519_ctx). Remove it. The _libssh2_curve25519_new and
+    _libssh2_curve25519_gen_k interfaces use the bytes. Note, if it needs
+    to be added back, there is no need to roundtrip through
+    EVP_PKEY_new_raw_private_key. EVP_PKEY_keygen already generated an
+    EVP_PKEY.
   
-  I don't understand why sftp_packet_read uses the packet type as its return
-  code.  A future change might get rid of this entirely.
-
-Daniel Stenberg (12 May 2012)
-- sftp_packet_flush: flush zombies too
+  - Add some missing error checks.
   
-  As this function is called when the SFTP session is closed, it needs to
-  also kill all zombies left in the SFTP session to avoid leaking memory
-  just in case some zombie would still be in there.
+  Credit:
+  David Benjamin
 
-- sftp_packetlist_flush: zombies must not have responses already
-  
-  When flushing the packetlist, we must only add the request as a zombie
-  if no response has already been received. Otherwise we could wrongly
-  make it a zombie even though the response was already received and then
-  we'd get a zombie stuck there "forever"...
+- [Will Cosgrove brought this change]
 
-- sftp_read: on EOF remove packet before flush
+  transport.c: socket is disconnected, return error (#500)
   
-  Since the sftp_packetlist_flush() function will move all the existing
-  FXP_READ requests in this handle to the zombie list we must first remove
-  this just received packet as it is clearly not a zombie.
-
-- sftp_packet_require: sftp_packet_read() returning 0 is not an error
+  File: transport.c
   
-  Exactly as the comment in the code said, checking the return code from
-  sftp_packet_read() with <= was wrong and it should be < 0. With the new
-  filtering on incoming packets that are "zombies" we can now see this
-  getting zero returned.
-
-- sftp_packetlist_flush: only make it zombie if it was sent
+  Notes:
+  This is to fix #102, instead of continuing to attempt to read a disconnected socket, it will now error out.
   
-  The list of outgoing packets may also contain packets that never were
-  sent off and we better not make them zombies too.
+  Credit:
+  TDi-jonesds
 
-- [Alexander Lamaison brought this change]
+- [Will Cosgrove brought this change]
 
-  Mark outstanding read requests after EOF as zombies.
-  
-  In order to be fast, sftp_read sends many read requests at once.  With a small
-  file, this can mean that when EOF is received back, many of these requests are
-  still outstanding.  Responses arriving after we close the file and abandon the
-  file handle are queued in the SFTP packet queue and never collected.  This
-  causes transfer speed to drop as a progressively longer queue must be searched
-  for every packet.
+  stale.yml
   
-  This change introduces a zombie request-ID list in the SFTP session that is
-  used to recognise these outstanding requests and prevent them being added to
-  the queue.
-
-Peter Stuge (23 Apr 2012)
-- [Rafael Kitover brought this change]
+  Increasing stale values.
 
-  Update win32/GNUmakefile to use OpenSSL 1.0.1a
+Marc Hoersken (6 Jul 2020)
+- wincng: try newer DH API first, fallback to legacy RSA API
   
-  libcrypto on win32 now depends on gdi32.dll, so move the OpenSSL LDLIBS
-  block to before the compiler definitions, so that libcrypto gets added
-  first, and then add -lgdi32 into the following common LDLIBS for gcc.
-
-Guenter Knauf (23 Apr 2012)
-- Changed 'Requires' to 'Requires.private'.
+  Avoid the use of RtlGetVersion or similar Win32 functions,
+  since these depend on version information from manifests.
   
-  Only static builds need to link against the crypto libs.
-
-- Fixed 'Requires:' names.
+  This commit makes the WinCNG backend first try to use the
+  new DH algorithm API with the raw secret derivation feature.
+  In case this feature is not available the WinCNG backend
+  will fallback to the classic approach of using RSA-encrypt
+  to perform the required modular exponentiation of BigNums.
+  
+  The feature availability test is done during the first handshake
+  and the result is stored in the crypto backends global state.
   
-  The 'Requires:' line lists the names of the .pc files.
+  Follow up to #397
+  Closes #484
 
-- Added 'Requires:' line to libssh2.pc.
+- wincng: fix indentation of function arguments and comments
   
-  This is necessary so that other libs which lookup libssh2 info
-  via pkg-config can add the right crypto lib dependencies.
+  Follow up to #397
 
-- Updated dependency lib versions.
+- [Wez Furlong brought this change]
 
-Peter Stuge (18 Apr 2012)
-- configure.ac: Add option to disable build of the example applications
+  wincng: use newer DH API for Windows 8.1+
   
-  Examples are built by default. Any of the following options on the
-  configure command line will skip building them:
+  Since Windows 1903 the approach used to perform DH kex with the CNG
+  API has been failing.
   
-    --disable-examples-build
-    --enable-examples-build=no
-    --enable-examples-build=false
-
-- userauth.c: fread() from public key file to correctly detect any errors
+  This commit switches to using the `DH` algorithm provider to perform
+  generation of the key pair and derivation of the shared secret.
   
-  If the filename parameter for file_read_publickey() was the name of a
-  directory instead of a file then libssh2 would spin trying to fgetc()
-  from the FILE * for the opened directory when trying to determine the
-  length of the encoded public key, since fgetc() can't report errors.
+  It uses a feature of CNG that is not yet documented.  The sources of
+  information that I've found on this are:
   
-  Use fread() instead to correctly detect this error condition along
-  with many others.
+  * https://stackoverflow.com/a/56378698/149111
+  * https://github.com/wbenny/mini-tor/blob/5d39011e632be8e2b6b1819ee7295e8bd9b7a769/mini/crypto/cng/dh.inl#L355
   
-  This fixes the problem reported in
-  http://www.libssh2.org/mail/libssh2-devel-archive-2012-04/0021.shtml
+  With this change I am able to successfully connect from Windows 10 to my
+  ubuntu system.
   
-  Reported-by: Oleksiy Zagorskyi <zalex_ua@i.ua>
-
-- Return LIBSSH2_ERROR_SOCKET_DISCONNECT on EOF when reading banner
-
-Guenter Knauf (17 Apr 2012)
-- Fixed copyright year.
+  Refs: https://github.com/alexcrichton/ssh2-rs/issues/122
+  Fixes: https://github.com/libssh2/libssh2/issues/388
+  Closes: https://github.com/libssh2/libssh2/pull/397
 
-- Updated dependency lib versions in static makefiles.
+GitHub (1 Jul 2020)
+- [Zenju brought this change]
 
-Daniel Stenberg (6 Apr 2012)
-- version: bump to 1.4.2
+  comp.c: Fix name clash with ZLIB macro "compress" (#418)
   
-  We're on the 1.4.2 track now (at least)
-
-Version 1.4.1 (4 Apr 2012)
+  File: comp.c
+  
+  Notes:
+  * Fix name clash with ZLIB macro "compress".
+  
+  Credit:
+  Zenju
 
-Daniel Stenberg (4 Apr 2012)
-- RELEASE-NOTES: updated for 1.4.1 release
+- [yann-morin-1998 brought this change]
 
-- always do "forced" window updates
+  buildsystem: drop custom buildconf script, rely on autoreconf (#224)
+  
+  Notes:
+  The buildconf script is currently required, because we need to copy a
+  header around, because it is used both from the library and the examples
+  sources.
+  
+  However, having a custom 'buildconf'-like script is not needed if we can
+  ensure that the header exists by the time it is needed. For that, we can
+  just append the src/ directory to the headers search path for the
+  examples.
+  
+  And then it means we no longer need to generate the same header twice,
+  so we remove the second one from configure.ac.
   
-  When calling _libssh2_channel_receive_window_adjust() internally, we now
-  always use the 'force' option to prevent libssh2 to avoid sending the
-  update if the update isn't big enough.
+  Now, we can just call "autoreconf -fi" to generate the autotools files,
+  instead of relying on the canned sequence in "buildconf", since
+  autoreconf has now long known what to do at the correct moment (future
+  versions of autotools, automake, autopoint, autoheader etc... may
+  require an other ordering, or other intermediate steps, etc...).
   
-  It isn't fully analyzed but we have seen corner cases which made a
-  necessary window update not get send due to this and then the other side
-  doesn't send data our side then sits waiting for forever.
-
-- channel_read: force window adjusts!
+  Eventually, get rid of buildconf now it is no longer needed. In fact, we
+  really keep it for legacy, but have it just call autoreconf (and print a
+  nice user-friendly warning). Don't include it in the release tarballs,
+  though.
   
-  if there's not enough room to receive the data that's being requested,
-  the window adjustment needs to be sent to the remote and thus the force
-  option has to be used. _libssh2_channel_receive_window_adjust() would
-  otherwise "queue" small window adjustments for a later packet but that
-  is really terribly for the small buffer read that for example is the
-  final little piece of a very large file as then there is no logical next
-  packet!
+  Update doc, gitignore, and travis-CI jobs accordingly.
   
-  Reported by: Armen Babakhanian
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0130.shtml
+  Credit:
+  Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
+  Cc: Sam Voss <sam.voss@rockwellcollins.com>
 
-- [Paul Howarth brought this change]
+- [Will Cosgrove brought this change]
 
-  aes: the init function fails when OpenSSL has AES support
-  
-  The internal init function only worked fine when the configure script
-  didn't detect the OpenSSL AES_CTR function!
+  libssh2.h: Update Diffie Hellman group values (#493)
   
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0111.shtml
-  Reported by: Paul Howarth
-
-- [Matthew Booth brought this change]
-
-  transport_send: Finish in-progress key exchange before sending data
+  File: libssh2.h
   
-  _libssh2_channel_write() first reads outstanding packets before writing
-  new data. If it reads a key exchange request, it will immediately start
-  key re-exchange, which will require sending a response. If the output
-  socket is full, this will result in a return from
-  _libssh2_transport_read() of LIBSSH2_ERROR_EAGAIN. In order not to block
-  a write because there is no data to read, this error is explicitly
-  ignored and the code continues marshalling a packet for sending. When it
-  is sent, the remote end immediately drops the connection because it was
-  expecting a continuation of the key exchange, but got a data packet.
+  Notes:
+  Update the min, preferred and max DH group values based on RFC 8270.
   
-  This change adds the same check for key exchange to
-  _libssh2_transport_send() that is in _libssh2_transport_read(). This
-  ensures that key exchange is completed before any data packet is sent.
+  Credit:
+  Will Cosgrove, noted from email list by Mitchell Holland
 
-- channel_write: acknowledge transport errors
-  
-  When draining data off the socket with _libssh2_transport_read() (which
-  in turn has to be done so that we can be sure to have read any possible
-  window-increasing packets), this code previously ignored errors which
-  could lead to nasty loops. Now all error codes except EAGAIN will cause
-  the error to be returned at once.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0068.shtml
-  Reported by: Matthew Booth
+Marc Hoersken (22 Jun 2020)
+- travis: use existing Makefile target to run checksrc
 
-- [Steven Dake brought this change]
+- Makefile: also run checksrc on test source files
 
-  In examples/x11.c, Make sure sizeof passed to read operation is correct
-  
-  sizeof(buf) expands to 8 or 4 (since its a pointer).  This variable may
-  have been static in the past, leading to this error.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
+- tests: avoid use of deprecated function _sleep (#490)
 
-- [Steven Dake brought this change]
+- tests: avoid use of banned function strncat (#489)
 
-  Fix suspicious sizeof usage in examples/x11.c
-  
-  In the x11 example, sizeof(buf) = 8UL (on x86_64), when this should
-  probably represent the buffer size available.  I am not sure how to
-  test that this change is actually correct, however.
+- tests: satisfy checksrc regarding max line length of 79 chars
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
+  Follow up to 2764bc8e06d51876b6796d6080c6ac51e20f3332
 
-- sftp_packet_read: follow-up fix for EAGAIN/window adjust
+- tests: satisfy checksrc with whitespace only fixes
   
-  The commit in 7194a9bd7ba45 wasn't complete. This change makes sure
-  variables are initialized properly before used in the EAGAIN and window
-  adjust cases.
+  checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF
+              -ACOPYRIGHT -AFOPENMODE tests/*.[ch]
 
-- sftp_packet_add: use named error code instead of number
+- tests: add support for ports published via Docker for Windows
 
-- sftp_packet_add: verify the packet before accepting it
-  
-  In order to bail out as quickly as possible when things are wrong and
-  out of sync, make sure the SFTP message is one we understand.
+- tests: restore retry behaviour for docker-machine ip command
 
-- SFTP: preserve the original error code more
-  
-  Lots of places in the code translated the original error into the more
-  generic LIBSSH2_ERROR_SOCKET_TIMEOUT but this turns out to distort the
-  original error reason a lot and makes tracking down the real origin of a
-  problem really hard. This change makes the original error code be
-  preserved to a larger extent when return up to the parent function.
+- tests: fix mix of declarations and code failing C89 compliance
 
-- sftp_packet_read: adjust window size as necessary
-  
-  Commit 03ca9020756 tried to simplify the window sizing logic but broke
-  SFTP readdir as there was no window sizing code left there so large
-  directory listings no longer worked.
-  
-  This change introduces window sizing logic to the sftp_packet_read()
-  function so that it now tells the remote about the local size having a
-  window size that suffice when it is about to ask for directory data.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0069.shtml
-  Reported by: Eric
+- wincng: add and improve checks in bit counting function
 
-- [Steven Dake brought this change]
+- wincng: align bits to bytes calculation in all functions
 
-  Tell C compiler we don't care about return code of libssh2_init
-  
-  The call of libssh2_init returns a return code, but nothing could be done
-  within the _libssh2_init_if_needed execution path.
+- wincng: do not disable key validation that can be enabled
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
+  The modular exponentiation also works with key validation enabled.
 
-  Add comment indicating a resource leak is not really a resource leak
-  
-  While possibly obvious to those investigating the code, coverity complains
-  about this out of scope leak.
+- wincng: fix return value in _libssh2_dh_secret
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
+  Do not ignore return value of modular exponentiation.
 
-  Use safer snprintf rather then sprintf in scp_send()
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
+- appveyor: build and run tests for WinCNG crypto backend
 
-- [Steven Dake brought this change]
+GitHub (1 Jun 2020)
+- [suryakalpo brought this change]
 
-  Use safer snprintf rather then sprintf in scp_recv()
-  
-  While the buffer is indeed allocated to a safe length, better safe then sorry.
+  INSTALL_CMAKE.md: Update formatting (#481)
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  use snprintf in knownhost_writeline() rather then sprintf
+  File: INSTALL_CMAKE.md
   
-  Although the function checks the length, if the code was in error, there
-  could potentially be a buffer overrun with the use of sprintf.  Instead replace
-  with snprintf.
+  Notes:
+  Although the original text would be immediately clear to seasoned users of CMAKE and/or Unix shell, the lack of newlines may cause some confusion for newcomers. Hence, wrapping the texts in a md code-block such that the newlines appear as intended.
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
+  credit:
+  suryakalpo
 
-  Add tracing to print packets left on session at libssh2_session_free
+Marc Hoersken (31 May 2020)
+- src: add new and align include guards in header files (#480)
   
-  Signed-off-by: Steven Dake <sdake@redhat.com>
+  Make sure all include guards exist and follow the same format.
 
-Peter Stuge (2 Mar 2012)
-- Define and use LIBSSH2_INVALID_SOCKET instead of INVALID_SOCKET
-  
-  INVALID_SOCKET is a special value in Windows representing a
-  non-valid socket identifier. We were #defining this to -1 on
-  non-Windows platforms, causing unneccessary namespace pollution.
-  Let's have our own identifier instead.
+- wincng: fix multiple definition of `_libssh2_wincng' (#479)
   
-  Thanks to Matt Lawson for pointing this out.
+  Add missing include guard and move global state
+  from header to source file by using extern.
 
-- nw/Makefile.netware: Fix project name typo to avoid needless confusion
+GitHub (28 May 2020)
+- [Will Cosgrove brought this change]
 
-- example/x11: Set raw terminal mode manually instead of with cfmakeraw()
-  
-  OpenSolaris has no cfmakeraw() so to make the example more portable
-  we simply do the equivalent operations on struct termios ourselves.
+  transport.c: moving total_num check from #476 (#478)
   
-  Thanks to Tom Weber for reporting this problem, and finding a solution.
-
-Daniel Stenberg (17 Feb 2012)
-- sftp_write: cannot return acked data *and* EAGAIN
+  file: transport.c
   
-  Whenever we have acked data and is about to call a function that *MAY*
-  return EAGAIN we must return the number now and wait to get called
-  again. Our API only allows data *or* EAGAIN and we must never try to get
-  both.
-
-Peter Stuge (13 Feb 2012)
-- example/x11: Build only when sys/un.h is found by configure
+  notes:
+  moving total_num zero length check from #476 up to the prior bounds check which already includes a total_num check. Makes it slightly more readable.
   
-  The example can't be built on systems without AF_UNIX sockets.
+  credit:
+  Will Cosgrove
 
-Daniel Stenberg (10 Feb 2012)
-- [Alexander Lamaison brought this change]
+- [lutianxiong brought this change]
 
-  Simplified sftp_read.
-  
-  Removed the total_read variable that originally must have tracked how
-  much data had been written to the buffer.  With non-blocking reads, we
-  must return straight away once we have read data into the buffer so this
-  variable served not purpose.
+  transport.c: fix use-of-uninitialized-value (#476)
   
-  I think it was still hanging around in case the initial processing of
-  'leftover' data meant we wrote to the buffer but this case, like the
-  others, must return immediately.  Now that it does, the last remaining
-  need for the variable is gone.
-
-- [Alexander Lamaison brought this change]
-
-  Cleaned up sftp_read and added more explanation.
+  file:transport.c
   
-  Replaced the gotos which were implementing the state machine with
-  a switch statement which makes the states more explicit.
-
-- sftp_read: avoid data *and* EAGAIN
+  notes:
+  return error if malloc(0)
   
-  Whenever we have data and is about to call a function that *MAY* return
-  EAGAIN we must return the data now and wait to get called again. Our API
-  only allows data *or* EAGAIN and we must never try to get both.
-
-Peter Stuge (2 Feb 2012)
-- Add a tcpip-forward example which demonstrates remote port forwarding
+  credit:
+  lutianxiong
 
-- libssh2.h: Add missing prototype for libssh2_session_banner_set()
+- [Dr. Koutheir Attouchi brought this change]
 
-- example/subsystem_netconf.c: Return error when read buffer is too small
+  libssh2_sftp.h: Changed type of LIBSSH2_FX_* constants to unsigned long, fixes #474
   
-  Also remove a little redundancy in the read loop condition.
-
-- example/subsystem_netconf.c: Add a missing newline in an error message
-
-- Fix undefined reference to _libssh_error in libgcrypt backend
+  File:
+  libssh2_sftp.h
   
-  Commit 209de22299b4b58e582891dfba70f57e1e0492db introduced a function
-  call to a non-existing function, and since then the libgcrypt backend
-  has not been buildable.
-
-Version 1.4.0 (31 Jan 2012)
-
-Daniel Stenberg (31 Jan 2012)
-- RELEASE-NOTES: synced with 6bd584d29 for 1.4.0
-
-- s/1.3.1/1.4.0
+  Notes:
+  Error constants `LIBSSH2_FX_*` are only returned by `libssh2_sftp_last_error()` which returns `unsigned long`.
+  Therefore these constants should be defined as unsigned long literals, instead of int literals.
   
-  We're bumping the minor number
-
-- [Jernej Kovacic brought this change]
-
-  libssh2_session_supported_algs: fix compiler warning
-
-- [Jernej Kovacic brought this change]
-
-  session_supported_algs docs: added an example
+  Credit:
+  Dr. Koutheir Attouchi
 
-- [Gellule Xg brought this change]
+- [monnerat brought this change]
 
-  sftp-seek: clear EOF flag
+  os400qc3.c: constify libssh2_os400qc3_hash_update() data parameter. (#469)
   
-  Set the EOF flag to False when calling seek64 to be able to get some
-  data back on a following read
-
-- [Peter Krempa brought this change]
-
-  userauth: Provide more informations if ssh pub key extraction fails
+  Files: os400qc3.c, os400qc3.h
   
-  If the function that extracts/computes the public key from a private key
-  fails the errors it reports were masked by the function calling it. This
-  patch modifies the key extraction function to return errors using
-  _libssh_error() function.  The error messages are tweaked to contain
-  reference to the failed operaton in addition to the reason.
+  Notes:
+  Fixes building on OS400. #426
   
-   * AUTHORS: - add my name
-   * libgcrypt.c: _libssh2_pub_priv_keyfile(): - return a more verbose
-                                                 error using
-                                                 _libssh2_error() func.
-   * openssl.c: - modify call graph of _libssh2_pub_priv_keyfile() to use
-                  _libssh2_error for error reporting();
-   * userauth.c: - tweak functions calling _libssh2_pub_priv_keyfile() not
-                   to shadow error messages
+  Credit:
+  Reported-by: hjindra on github, dev by Monnerat
 
-- TODO: remove issues we (sort of) did already
+- [monnerat brought this change]
 
-- ssh2_exec: skip error outputs for EAGAIN
+  HACKING.CRYPTO: keep up to date with new crypto definitions from code. (#466)
   
-  Since the example uses non-blocking mode, it will just flood the output
-  with this "nonsense" error.
-
-Guenter Knauf (30 Nov 2011)
-- Some NetWare makefile tweaks.
-
-Daniel Stenberg (18 Nov 2011)
-- LIBSSH2_SFTP_PACKET_MAXLEN: increase to 80000
+  File: HACKING.CRYPTO
   
-  Some SFTP servers send SFTP packets larger than 40000. Since the limit
-  is only present to avoid insane sizes anyway, we can easily bump it.
+  Notes:
+  This commit updates the HACKING.CRYPTO documentation file in an attempt to make it in sync with current code.
+  New documented features are:
   
-  The define was formerly in the public header libssh2_sftp.h but served
-  no external purpose and was moved into the source dir.
+  SHA384
+  SHA512
+  ECDSA
+  ED25519
   
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-11/0004.shtml
-  Reported by: Michael Harris
+  Credit:
+  monnerat
 
-Alexander Lamaison (18 Nov 2011)
-- [Peter Krempa brought this change]
+- [Harry Sintonen brought this change]
 
-  knownhost_check(): Don't dereference ext if NULL is passed
+  kex.c: Add diffie-hellman-group14-sha256 Key Exchange Method (#464)
   
-  Documentation for libssh2_knownhost_checkp() and related functions
-  states that the last argument is filled with data if non-NULL.
+  File: kex.c
   
-  "knownhost if set to non-NULL, it must be a pointer to a 'struct
-  libssh2_knownhost' pointer that gets filled in to point to info about a
-  known host that matches or partially matches."
+  Notes: Added diffie-hellman-group14-sha256 kex
   
-  In this function ext is dereferenced even if set to NULL, causing
-  segfault in applications not needing the extra data.
+  Credit: Harry Sintonen <sintonen@iki.fi>
 
-Daniel Stenberg (11 Nov 2011)
-- [Peter Krempa brought this change]
+- [Will Cosgrove brought this change]
 
-  knownhost_add: Avoid dereferencing uninitialized memory on error path.
-  
-  In function knownhost_add, memory is alocated for a new entry. If normal
-  alocation is used, memory is not initialized to 0 right after, but a
-  check is done to verify if correct key type is passed. This test is done
-  BEFORE setting the memory to null, and on the error path function
-  free_host() is called, that tries to dereference unititialized memory,
-  resulting into a glibc abort().
+  os400qc3.h: define sha512 macros (#465)
   
-   * knownhost.c - knownhost_add(): - move typemask check before alloc
+  file: os400qc3.h
+  notes: fixes for building libssh2 1.9.x
 
-- windows build: add define to avoid compiler warning
-  
-  A recent mingw compiler has started to complain on "#warning Please
-  include winsock2.h before windows.h" unless the magic define is set
-  first.
+- [Will Cosgrove brought this change]
+
+  os400qc3.h: define EC types to fix building #426 (#462)
   
-  Reported by: Vincent Torri
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-10/0064.shtml
+  File: os400qc3.h
+  Notes: define missing EC types which prevents building
+  Credit: hjindra
 
-Henrik Nordstrom (31 Oct 2011)
-- [Vincent Torri brought this change]
+- [Brendan Shanks brought this change]
 
-  Correct Windows include file name case, simplifying cross-compilation
+  hostkey.c: Fix 'unsigned int'/'uint32_t' mismatch (#461)
   
-  When cross compiling to Windows, libssh2.h include Windows header files
-  with upper case filenames : BaseTsd.h and WinSock2.h.
+  File: hostkey.c
   
-  These files have lowercase names with mingw-w64 (iirc, it's the same with
-  mingw). And as on Windows, being lowercase or uppercase does not matter.
-
-Daniel Stenberg (25 Oct 2011)
-- [Jernej Kovacic brought this change]
-
-  libssh2_session_supported_algs: added
-
-- [Kamil Dudka brought this change]
-
-  example/sftp_RW_nonblock: do not ignore LIBSSH2_ERROR_EAGAIN
+  Notes:
+  These types are the same size so most compilers are fine with it, but CodeWarrior (on classic MacOS) throws an ‘illegal implicit conversion’ error
   
-  Bug: https://bugzilla.redhat.com/745420
+  Credit: Brendan Shanks
 
-Peter Stuge (5 Oct 2011)
-- example/ssh2_agent: Print host key fingerprint before authentication
-  
-  Also moves the comment about not being authenticated to before the
-  agent authentication takes place, so that it better matches the code.
+- [Thomas Klausner brought this change]
 
-Daniel Stenberg (29 Sep 2011)
-- OpenSSL EVP: fix threaded use of structs
+  Makefile.am: Fix unportable test(1) operator. (#459)
   
-  Make sure we don't clear or reset static structs after first init so
-  that they work fine even when used from multiple threads. Init the
-  structs in the global init.
+  file: Makefile.am
   
-  Help and assistance by: John Engstrom
+  Notes:
+  The POSIX comparison operator for test(1) is =; bash supports == but not even test from GNU coreutils does.
   
-  Fixes #229 (again)
+  Credit:
+  Thomas Klausner
+
+- [Tseng Jun brought this change]
 
-- openssl: don't init static structs differently
+  openssl.c: minor changes of coding style (#454)
   
-  make_ctr_evp() is changed to take a struct pointer, and then each
-  _libssh2_EVP_aes_[keylen]_ctr function is made to pass in their own
-  static struct
+  File: openssl.c
+  
+  Notes:
+  minor changes of coding style and align preprocessor conditional for #439
   
-  Reported by: John Engstrom
-  Fixes #229
+  Credit:
+  Tseng Jun
 
-Guenter Knauf (27 Sep 2011)
-- Removed obsolete include path.
+- [Hans Meier brought this change]
 
-Daniel Stenberg (21 Sep 2011)
-- read_state: clear the state variable better
+  openssl.c: Fix for use of uninitialized aes_ctr_cipher.key_len (#453)
   
-  Set read_state back to idle before trying to send anything so that if
-  the state somehow is wrongly set.
+  File:
+  Openssl.c
   
-  Also, avoid such a case of confusion by resetting the read_state when an
-  sftp handle is closed.
-
-- sftp_read: remove leftover fprintf
+  Notes:
+  * Fix for use of uninitialized aes_ctr_cipher.key_len when using HAVE_OPAQUE_STRUCTS, regression from #439
   
-  Reported by: Alexander Lamaison
-
-- sftp.h: fix the #ifdef to prevent multiple inclusions
+  Credit:
+  Hans Meirer, Tseng Jun
 
-- sftp_read: use a state variable to avoid bad writes
-  
-  When a channel_write call has gotten an EAGAIN back, we try harder to
-  continue the same write in the subsequent invoke.
+- [Zenju brought this change]
 
-- window_size: explicit adjustments only
+  agent.c: Fix Unicode builds on Windows (#417)
   
-  Removed the automatic window_size adjustments from
-  _libssh2_channel_read() and instead all channel readers must now make
-  sure to enlarge the window sizes properly themselves.
+  File: agent.c
   
-  libssh2_channel_read_ex() - the public function, now grows the window
-  size according to the requested buffer size. Applications can still opt
-  to grow the window more on demand. Larger windows tend to give higher
-  performance.
+  Notes:
+  Fixes unicode builds for Windows in Visual Studio 16.3.2.
   
-  sftp_read() now uses the read-ahead logic to figure out a window_size.
+  Credit:
+  Zenju
 
-- libssh2.h: bump the default window size to 256K
+- [Hans Meier brought this change]
 
-- libssh2_userauth_keyboard_interactive.3: fix man warning
+  openssl.c: Fix use-after-free crash in openssl backend without memory leak (#439)
   
-  It seemed to occur due to the excessive line length
-
-- [Mikhail Gusarov brought this change]
-
-  Add missing .gitignore entries
-
-- [Mikhail Gusarov brought this change]
-
-  Add manpage syntax checker to 'check' target
+  Files: openssl.c
   
-  In virtually every libssh2 release Debian's lintian catches syntax errors in
-  manpages. Prevent it by checking manpages as a part of testsuite.
-
-- libssh2_banner_set.3: fix nroff syntax mistake
-
-Guenter Knauf (10 Sep 2011)
-- Use predefined resource compiler macro.
-
-- Added casts to silent compiler warnings.
-
-- Fixed uint64_t printf.
-
-- Fixed macro function signatures.
-
-- NetWare makefile tweaks.
-
-- Removed unused var.
-
-- Added 2 samples not mentioned.
-
-- Dont build x11 sample with MinGW.
-
-- Fixed executable file description.
-
-- Removed unused var.
-
-- Kill stupid gcc 3.x uninitialized warning.
-
-- Build all examples.
-
-- More MinGW makefile tweaks.
+  Notes:
+  Fixes memory leaks and use after free AES EVP_CIPHER contexts when using OpenSSL 1.0.x.
   
-  Renamed *.mingw makefiles to GNUmakefile since GNU make picks these
-  up automatically, and therefore win32/Makefile removed.
+  Credit:
+  Hans Meier
 
-- Removed forgotten WINSOCK_VERSION defines.
+- [Romain Geissler @ Amadeus brought this change]
 
-Daniel Stenberg (9 Sep 2011)
-- libssh2_session_startup(3) => libssh2_session_handshake(3)
+  Session.c: Fix undefined warning when mixing with LTO-enabled libcurl. (#449)
   
-  Propagate for the current function in docs and examples.
-  libssh2_session_startup() is deprecated.
-
-- libssh2_banner_set => libssh2_session_banner_get
+  File: Session.c
   
-  Marked the old function as deprecated. Added the new name in the correct
-  name space with the same arguments and functionality.
-
-- new function: libssh2_session_banner_get
+  Notes:
+  With gcc 9, libssh2, libcurl and LTO enabled for all binaries I see this
+  warning (error with -Werror):
   
-  Returns the banner from the server handshake
+  vssh/libssh2.c: In function ‘ssh_statemach_act’:
+  /data/mwrep/rgeissler/ospack/ssh2/BUILD/libssh2-libssh2-03c7c4a/src/session.c:579:9: error: ‘seconds_to_next’ is used uninitialized in this function [-Werror=uninitialized]
+    579 |     int seconds_to_next;
+        |         ^
+  lto1: all warnings being treated as errors
   
-  Fixes #226
-
-- libssh2.h: bump version to 1.4.0 for new function(s)
-
-- remove embedded CVS/svn tags
+  Gcc normally issues -Wuninitialized when it is sure there is a problem,
+  and -Wmaybe-uninitialized when it's not sure, but it's possible. Here
+  the compiler seems to have find a real case where this could happen. I
+  looked in your code and overall it seems you always check if the return
+  code is non null, not often that it's below zero. I think we should do
+  the same here. With this patch, gcc is fine.
+  
+  Credit:
+  Romain-Geissler-1A
 
-- [liuzl brought this change]
+- [Zenju brought this change]
 
-  API add:libssh2_sftp_get_channel
+  transport.c: Fix crash with delayed compression (#443)
   
-  Return the channel of sftp, then caller can
-  control the channel's behavior.
+  Files: transport.c
   
-  Signed-off-by: liuzl <xieepp@gmail.com>
-
-- _libssh2_channel_read: react on errors from receive_window_adjust
+  Notes:
+  Fixes crash with delayed compression option using Bitvise server.
   
-  Previously the function would ignore all errors except for EAGAIN.
+  Contributor:
+  Zenju
 
-- sftp_read: extend and clarify the documentation
+- [Will Cosgrove brought this change]
 
-- sftp_read: cap the read ahead maximum amount
+  Update INSTALL_MAKE path to INSTALL_MAKE.md (#446)
   
-  Now we only go up to LIBSSH2_CHANNEL_WINDOW_DEFAULT*30 bytes SFTP read
-  ahead, which currently equals 64K*30 == 1966080 bytes.
+  Included for #429
 
-- _libssh2_channel_read: fix non-blocking window adjusting
-  
-  If EAGAIN is returned when adjusting the receive window, we must not
-  read from the transport directly until we've finished the adjusting.
+- [Will Cosgrove brought this change]
 
-Guenter Knauf (8 Sep 2011)
-- Fix for systems which need sys/select.h.
+  Update INSTALL_CMAKE filename to INSTALL_CMAKE.md (#445)
+  
+  Fixing for #429
 
-- The files were not gone but renamed ...
+- [Wallace Souza brought this change]
 
-Daniel Stenberg (6 Sep 2011)
-- sftp_read: added documenting comment
+  Rename INSTALL_CMAKE to INTALL_CMAKE.md (#429)
   
-  Taken from some recent email conversations I added some descriptions of
-  the logic in sftp_read() to aid readers.
-
-- 1.3.1: start the work
+  Adding Markdown file extension in order to Github render the instructions properly
 
-Version 1.3.0 (6 Sep 2011)
+Will Cosgrove (17 Dec 2019)
+- [Daniel Stenberg brought this change]
 
-Daniel Stenberg (6 Sep 2011)
-- Makefile.am: the Makefile.win32 files are gone
+  include/libssh2.h: fix comment: the known host key uses 4 bits (#438)
 
-- RELEASE-NOTES: updated for 1.3.0
+- [Zenju brought this change]
 
-- sftp_read: a short read is not end of file
+  ssh-ed25519: Support PKIX + calc pubkey from private (#416)
+  
+  Files: openssl.c/h
+  Author: Zenju
+  Notes:
+  Adds support for PKIX key reading by fixing:
   
-  A returned READ packet that is short will now only reduce the
-  offset.
+  _libssh2_pub_priv_keyfile() is missing the code to extract the ed25519 public key from a given private key
   
-  This is a temporary fix as it is slightly better than the previous
-  approach but still not very good.
+  _libssh2_ed25519_new_private_frommemory is only parsing the openssh key format but does not understand PKIX (as retrieved via PEM_read_bio_PrivateKey)
 
-- [liuzl brought this change]
+GitHub (15 Oct 2019)
+- [Will Cosgrove brought this change]
 
-  _libssh2_packet_add: adjust window size when truncating
+  .travis.yml: Fix Chrome and 32 bit builds (#423)
   
-  When receiving more data than what the window size allows on a
-  particular channel, make sure that the window size is adjusted in that
-  case too. Previously it would only adjust the window in the non-error
-  case.
+  File: .travis.yml
+  
+  Notes:
+  * Fix Chrome installing by using Travis build in directive
+  * Update to use libgcrypt20-dev package to fix 32 bit builds based on comments found here:
+  https://launchpad.net/ubuntu/xenial/i386/libgcrypt11-dev
 
-Guenter Knauf (29 Aug 2011)
-- Silent compiler warning with MinGW64.
+- [Will Cosgrove brought this change]
 
-- Fixed link to native Win32 awk tool.
+  packet.c: improved parsing in packet_x11_open (#410)
+  
+  Use new API to parse data in packet_x11_open() for better bounds checking.
 
-- Renamed MinGW makefiles.
+Will Cosgrove (12 Sep 2019)
+- [Michael Buckley brought this change]
 
-- Some MinGW makefile tweaks.
+  knownhost.c: Double the static buffer size when reading and writing known hosts (#409)
   
-  Enable build without GNU tools and with MinGW64 compiler.
-
-- Fixed aes_ctr_do_cipher() signature.
+  Notes:
+  We had a user who was being repeatedly prompted to accept a server key repeatedly. It turns out the base64-encoded key was larger than the static buffers allocated to read and write known hosts. I doubled the size of these buffers.
+  
+  Credit:
+  Michael Buckley
 
-Daniel Stenberg (26 Aug 2011)
-- [liuzl brought this change]
+GitHub (4 Sep 2019)
+- [Will Cosgrove brought this change]
 
-  libssh2_sftp_seek64: flush packetlist and buffered data
+  packet.c: improved packet parsing in packet_queue_listener (#404)
   
-  When seeking to a new position, flush the packetlist and buffered data
-  to prevent already received or pending data to wrongly get used when
-  sftp-reading from the new offset within the file.
-
-- sftp_read: advance offset correctly for buffered copies
+  * improved bounds checking in packet_queue_listener
   
-  In the case where a read packet has been received from the server, but
-  the entire contents couldn't be copied to the user-buffer, the data is
-  instead buffered and copied to the user's buffer in the next invocation
-  of sftp_read(). When that "extra" copy is made, the 'offset' pointer was
-  not advanced accordingly.
+  file: packet.c
   
-  The biggest impact of this flaw was that the 'already' variable at the
-  top of the function that figures out how much data "ahead" that has
-  already been asked for would slowly go more and more out of sync, which
-  could lead to the file not being read all the way to the end.
+  notes:
+  improved parsing packet in packet_queue_listener
+
+- [Will Cosgrove brought this change]
+
+  packet.c: improve message parsing (#402)
   
-  This problem was most noticable in cases where the application would
-  only try to read the exact file size amount, like curl does. In the
-  examples libssh2 provides the sftp read function is most often called
-  with a fixed size large buffer and then the bug would not appear as
-  easily.
+  * packet.c: improve parsing of packets
   
-  This bug was introduced in the SFTP rewrite in 1.2.8.
+  file: packet.c
   
-  Bug: http://curl.haxx.se/mail/lib-2011-08/0305.html
-       http://www.libssh2.org/mail/libssh2-devel-archive-2011-08/0085.shtml
-
-- wrap some long lines < 80 columns
-
-- LIBSSH2_RECV: fix typo, use the RECV_FD macro
-
-- subsystem_netconf.c: fix compiler warnings
-
-- [Henrik Nordstrom brought this change]
-
-  Custom callbacks for performing low level socket I/O
-
-- version bump: start working towards 1.3.0
-
-Version 1.2.9 (16 Aug 2011)
-
-Daniel Stenberg (16 Aug 2011)
-- RELEASE-NOTES: synced with 95d69d3a81261
-
-- [Henrik Nordstrom brought this change]
-
-  Document prototypes for macro defined functions
-
-- [Henrik Nordstrom brought this change]
+  notes:
+  Use _libssh2_get_string API in SSH_MSG_DEBUG/SSH_MSG_DISCONNECT. Additional uint32 bounds check in SSH_MSG_GLOBAL_REQUEST.
 
-  Avoid reuse after free when closing X11 channels
+- [Will Cosgrove brought this change]
 
-- _libssh2_channel_write: handle window_size == 0 better
+  misc.c: _libssh2_ntohu32 cast bit shifting (#401)
   
-  When about to send data on the channel and the window size is 0, we must
-  not just return 0 if the transport_read() function returned EAGAIN as it
-  then causes a busy-loop.
+  To quite overly aggressive analyzers.
   
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2011-08/0011.shtml
+  Note, the builds pass, Travis is having some issues with Docker images.
+
+- [Will Cosgrove brought this change]
 
-- gettimeofday: fix name space pollution
+  kex.c: improve bounds checking in kex_agree_methods() (#399)
   
-  For systems without its own gettimeofday() implementation, we still must
-  not provide one outside our namespace.
+  file: kex.c
   
-  Reported by: Bill Segall
-
-Dan Fandrich (5 Aug 2011)
-- libssh2.pc.in: Fixed spelling in pkgconfig file
-
-Peter Stuge (17 Jul 2011)
-- example/subsystem_netconf.c: Add missing #include <string.h>
-
-- example/subsystem_netconf.c: Discard ]]>]]> and return only XML response
+  notes:
+  use _libssh2_get_string instead of kex_string_pair which does additional checks
 
-- example/subsystem_netconf.c: Fix uninitialized variable bug
+Will Cosgrove (23 Aug 2019)
+- [Fabrice Fontaine brought this change]
 
-- example: Add subsystem_netconf.c
+  acinclude.m4: add mbedtls to LIBS (#371)
+  
+  Notes:
+  This is useful for static builds so that the Libs.private field in
+  libssh2.pc contains correct info for the benefit of pkg-config users.
+  Static link with libssh2 requires this information.
   
-  This example demonstrates how to use libssh2 to send a request to
-  the NETCONF subsystem available e.g. in JunOS.
+  Signed-off-by: Baruch Siach <baruch@tkos.co.il>
+  [Retrieved from:
+  https://git.buildroot.net/buildroot/tree/package/libssh2/0002-acinclude.m4-add-mbedtls-to-LIBS.patch]
+  Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
   
-  See also http://tools.ietf.org/html/draft-ietf-netconf-ssh-06
+  Credit:
+  Fabrice Fontaine
 
-Daniel Stenberg (16 Jul 2011)
-- man page cleanups: non-existing functions need no man pages
+- [jethrogb brought this change]
 
-- libssh2_new_host_entry.3: removed
+  Generate debug info when building with MSVC (#178)
   
-  This is just junk leftovers.
-
-- userauth_keyboard_interactive: fix buffer overflow
+  files: CMakeLists.txt
   
-  Partly reverse 566894494b4972ae12 which was simplifying the code far too
-  much and ended up overflowing a buffer within the LIBSSH2_SESSION
-  struct. Back to allocating the buffer properly like it used to do.
+  notes: Generate debug info when building with MSVC
   
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-06/0032.shtml
-  Reported by: Alfred Gebert
-
-- keyboard-interactive man page: cleaned up
+  credit:
+  jethrogb
 
-- [Alfred Gebert brought this change]
+- [Panos brought this change]
 
-  _libssh2_recv(): handle ENOENT error as EAGAIN
-  
-  A sftp session failed with error "failure establishing ssh session" on
-  Solaris and HP-UX. Sometimes the first recv() function call sets errno
-  to ENOENT. In the man pages for recv of Solaris and HP-UX the error
-  ENOENT is not documented.
+  Add agent forwarding implementation (#219)
   
-  I tested Solaris SPARC and x86, HP-UX i64, AIX, Windows and Linux.
-
-- agent_list_identities: fix out of scope access
+  files: channel.c, test_agent_forward_succeeds.c, libssh2_priv.h, libssh2.h, ssh2_agent_forwarding.c
   
-  An auto variable out of scope was being referenced and used.
+  notes:
+  * Adding SSH agent forwarding.
+  * Fix agent forwarding message, updated example.
+  Added integration test code and cmake target. Added example to cmake list.
   
-  fixes #220
+  credit:
+  pkittenis
 
-- _libssh2_wait_socket: fix timeouts for poll() uses
+GitHub (2 Aug 2019)
+- [Will Cosgrove brought this change]
 
-- windows: inclusion fix
+  Update EditorConfig
   
-  include winsock2.h for all windows compilers
+  Added max_line_length = 80
 
-- keyb-interactive: add the fixed buffer
-  
-  Belongs to commit 5668944
+- [Will Cosgrove brought this change]
 
-- code cleanup: don't use C99/c++ comments
+  global.c : fixed call to libssh2_crypto_exit #394 (#396)
   
-  We aim for C89 compliance
-
-- keyb-interactive: allow zero length fields
+  * global.c : fixed call to libssh2_crypto_exit #394
   
-  Allow zero length fields so they don't cause malloc(0) calls
+  File: global.c
   
-  Avoid free()ing NULL pointers
+  Notes: Don't call `libssh2_crypto_exit()` until `_libssh2_initialized` count is down to zero.
   
-  Avoid a malloc of a fixed 5 byte buffer.
+  Credit: seba30
 
-- libssh2_channel_process_startup.3: clean up
+Will Cosgrove (30 Jul 2019)
+- [hlefebvre brought this change]
+
+  misc.c : Add an EWOULDBLOCK check for better portability (#172)
   
-  Remove the references to the macro-fied shortcuts as they have their own
-  individual man pages.
+  File: misc.c
   
-  Made the prototype different and more readable.
-
-- man page: fix .BR lines
+  Notes: Added support for all OS' that implement EWOULDBLOCK, not only VMS
   
-  We don't use \fI etc on .BR lines
+  Credit: hlefebvre
 
-- userauth_keyboard_interactive: skip code on zero length auth
+- [Etienne Samson brought this change]
 
-- libssh2_channel_forward_accept.3: mention how to get error
+  userauth.c: fix off by one error when loading public keys with no id (#386)
   
-  Since this returns a pointer, libssh2_session_last_errno() must be used
-  to get the actual error code and it wasn't that clear before.
-
-- timeout docs: mention they're added in 1.2.9
-
-- sftp_write_sliding.c: indent fix
+  File: userauth.c
   
-  Use the standard indenting and removed CVS leftover comment
-
-- [zl liu brought this change]
-
-  sftp_write_sliding: send the complete file
+  Credit:
+  Etienne Samson
   
-  When reaching the end of file there can still be data left not sent.
-
-- [Douglas Masterson brought this change]
-
-  session_startup: init state properly
+  Notes:
+  Caught by ASAN:
+  
+  =================================================================
+  ==73797==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60700001bcf0 at pc 0x00010026198d bp 0x7ffeefbfed30 sp 0x7ffeefbfe4d8
+  READ of size 69 at 0x60700001bcf0 thread T0
+  2019-07-04 08:35:30.292502+0200 atos[73890:2639175] examining /Users/USER/*/libssh2_clar [73797]
+      #0 0x10026198c in wrap_memchr (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c)
+      #1 0x1000f8e66 in file_read_publickey userauth.c:633
+      #2 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
+      #3 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
+      #4 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
+      #5 0x1000090c3 in clar_run_test clar.c:260
+      #6 0x1000038f3 in clar_run_suite clar.c:343
+      #7 0x100003272 in clar_test_run clar.c:522
+      #8 0x10000c3cc in main runner.c:60
+      #9 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
   
-  libssh2_session_startup() didn't set the state correctly so it could get
-  confused.
+  0x60700001bcf0 is located 0 bytes to the right of 80-byte region [0x60700001bca0,0x60700001bcf0)
+  allocated by thread T0 here:
+      #0 0x10029e053 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5c053)
+      #1 0x1000b4978 in libssh2_default_alloc session.c:67
+      #2 0x1000f8aba in file_read_publickey userauth.c:597
+      #3 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
+      #4 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
+      #5 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
+      #6 0x1000090c3 in clar_run_test clar.c:260
+      #7 0x1000038f3 in clar_run_suite clar.c:343
+      #8 0x100003272 in clar_test_run clar.c:522
+      #9 0x10000c3cc in main runner.c:60
+      #10 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
   
-  Fixes #218
+  SUMMARY: AddressSanitizer: heap-buffer-overflow (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c) in wrap_memchr
+  Shadow bytes around the buggy address:
+    0x1c0e00003740: fd fd fd fd fd fd fd fd fd fd fa fa fa fa fd fd
+    0x1c0e00003750: fd fd fd fd fd fd fd fa fa fa fa fa 00 00 00 00
+    0x1c0e00003760: 00 00 00 00 00 00 fa fa fa fa 00 00 00 00 00 00
+    0x1c0e00003770: 00 00 00 fa fa fa fa fa fd fd fd fd fd fd fd fd
+    0x1c0e00003780: fd fd fa fa fa fa fd fd fd fd fd fd fd fd fd fa
+  =>0x1c0e00003790: fa fa fa fa 00 00 00 00 00 00 00 00 00 00[fa]fa
+    0x1c0e000037a0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+    0x1c0e000037b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+    0x1c0e000037c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+    0x1c0e000037d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+    0x1c0e000037e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  Shadow byte legend (one shadow byte represents 8 application bytes):
+    Addressable:           00
+    Partially addressable: 01 02 03 04 05 06 07
+    Heap left redzone:       fa
+    Freed heap region:       fd
+    Stack left redzone:      f1
+    Stack mid redzone:       f2
+    Stack right redzone:     f3
+    Stack after return:      f5
+    Stack use after scope:   f8
+    Global redzone:          f9
+    Global init order:       f6
+    Poisoned by user:        f7
+    Container overflow:      fc
+    Array cookie:            ac
+    Intra object redzone:    bb
+    ASan internal:           fe
+    Left alloca redzone:     ca
+    Right alloca redzone:    cb
+    Shadow gap:              cc
 
-- timeout: added man pages
+- [Thilo Schulz brought this change]
 
-- BLOCK_ADJUST_ERRNO: move rc to right level
+  openssl.c : Fix use-after-free crash on reinitialization of openssl backend
   
-  We can't declare the variable within the block and use it in the final
-  do-while() expression to be properly portable C89.
+  file : openssl.c
+  
+  notes :
+  libssh2's openssl backend has a use-after-free condition if HAVE_OPAQUE_STRUCTS is defined and you call libssh2_init() again after prior initialisation/deinitialisation of libssh2
+  
+  credit : Thilo Schulz
 
-- [Matt Lilley brought this change]
+- [axjowa brought this change]
 
-  adds a timeout to blocking calls
+  openssl.h : Use of ifdef where if should be used (#389)
   
-  Fixes bug #160 as per Daniel's suggestion
+  File : openssl.h
   
-  Adds libssh2_session_set_timeout() and libssh2_session_get_timeout()
-
-- SCP: fix incorrect error code
+  Notes :
+  LIBSSH2_ECDSA and LIBSSH2_ED25519 are always defined so the #ifdef
+  checks would never be false.
   
-  After an error occurs in libssh2_scp_recv() or libssh2_scp_send(), the
-  function libssh2_session_last_error() would return
-  LIBSSH2_ERROR_SOCKET_NONE on error.
+  This change makes it possible to build libssh2 against OpenSSL built
+  without EC support.
   
-  Bug: http://trac.libssh2.org/ticket/216
-  Patch by: "littlesavage"
+  Change-Id: I0a2f07c2d80178314dcb7d505d1295d19cf15afd
   
-  Fixes #216
+  Credit : axjowa
 
-Guenter Knauf (19 Apr 2011)
-- Updated default (recommended) dependency versions.
+- [Zenju brought this change]
 
-Daniel Stenberg (17 Apr 2011)
-- libssh2_session_block_directions: fix mistake
+  Agent.c : Preserve error info from agent_list_identities() (#374)
   
-  The last LIBSSH2_SESSION_BLOCK_INBOUND should be
-  LIBSSH2_SESSION_BLOCK_OUTBOUND
+  Files : agent.c
   
-  And I shortened the short description
+  Notes :
+  Currently the error details as returned by agent_transact_pageant() are overwritten by a generic "agent list id failed" message by int agent_list_identities(LIBSSH2_AGENT* agent).
   
-  Reported by: "drswinghead"
+  Credit :
+  Zenju
 
-- msvcproj: added libs and debug stuff
+- [Who? Me?! brought this change]
+
+  Channel.c: Make sure the error code is set in _libssh2_channel_open() (#381)
   
-  Added libraries needed to link whether using openssl dynamically or
-  statically
+  File : Channel.c
   
-  Added LIBSSH2DEBUG define to debug versions to enable tracing
+  Notes :
+  if _libssh2_channel_open() fails, set the error code.
   
-  URL: http://trac.libssh2.org/ticket/215
-  Patch by: Mark Smith
+  Credit :
+  mark-i-m
 
-- sftp_write: clean offsets on error
+- [Orgad Shaneh brought this change]
+
+  Kex.c, Remove unneeded call to strlen (#373)
+  
+  File : Kex.c
+  
+  Notes :
+  Removed call to strlen
   
-  When an error has occurred on FXP_WRITE, we must make sure that the
-  offset, sent offset and acked counter are reset properly.
+  Credit :
+  Orgad Shaneh
 
-- example/.gitignore: ignore built binaries
+- [Pedro Monreal brought this change]
 
-- sftp_write: flush the packetlist on error
+  Spelling corrections (#380)
   
-  When an error occurs during write, flush the entire list of pending
-  outgoing SFTP packets.
-
-- keepalive: add first basic man pages
+  Files :
+  libssh2.h, libssh2_sftp.h, bcrypt_pbkdf.c, mbedtls.c, sftp.c, ssh2.c
   
-  Someone on IRC pointed out that we don't have these documented so I
-  wrote up a first set based on the information in the wiki:
-  http://trac.libssh2.org/wiki/KeepAlive
-
-- scp_write_nonblock.c: remove pointless check
+  Notes :
+  * Fixed misspellings
   
-  libssh2_channel_write() cannot return a value that is larger than the
-  input length value
+  Credit :
+  Pedro Monreal
 
-Mikhail Gusarov (9 Apr 2011)
-- s/\.NF/.nf/ to fix wrong macro name caught by man --warnings
+- [Sebastián Katzer brought this change]
 
-Daniel Stenberg (6 Apr 2011)
-- version: bump to 1.2.9_dev
+  Fix Potential typecast error for `_libssh2_ecdsa_key_get_curve_type` (#383)
   
-  Also update the copyright year range to include 2011
-
-- configure: fix $VERSION
+  Issue : #383
   
-  Stop using the $VERSION variable as it seems to be magically used by
-  autoconfig itself and thus gets set to the value set in AC_INIT()
-  without us wanting that. $LIBSSH2VER is now the libssh2 version as
-  detected.
+  Files : hostkey.c, crypto.h, openssl.c
+  
+  Notes :
+  * Fix potential typecast error for `_libssh2_ecdsa_key_get_curve_type`
+  * Rename _libssh2_ecdsa_key_get_curve_type to _libssh2_ecdsa_get_curve_type
   
-  Reported by: Paul Howarth
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-04/0008.shtml
+  Credit :
+  Sebastián Katzer
 
-- maketgz: use git2news.pl by the correct name
+GitHub (20 Jun 2019)
+- [Will Cosgrove brought this change]
 
-Version 1.2.8 (4 Apr 2011)
+  bump copyright date
 
-Daniel Stenberg (4 Apr 2011)
-- RELEASE-NOTES: synced with fabf1a45ee
+Version 1.9.0 (19 Jun 2019)
 
-- NEWS: auto-generated from git
-  
-  Starting now, the NEWS file is generated from git using the git2news.pl
-  script. This makes it always accurate and up-to-date, even for daily
-  snapshots etc.
+GitHub (19 Jun 2019)
+- [Will Cosgrove brought this change]
 
-- sftp_write: handle FXP_WRITE errors
-  
-  When an sftp server returns an error back on write, make sure the
-  function bails out and returns the proper error.
+  1.9 Formatting
 
-- configure: stop using the deprecated AM_INIT_AUTOMAKE syntax
+- [Will Cosgrove brought this change]
 
-Alexander Lamaison (13 Mar 2011)
-- Support unlimited number of host names in a single line of the known_hosts file.
-  
-  Previously the code assumed either a single host name or a hostname,ip-address pair.  However, according to the spec [1], there can be any number of comma separated host names or IP addresses.
-  
-  [1] http://www.openbsd.org/cgi-bin/man.cgi?query=sshd&sektion=8
+  1.9 Release notes
 
-Daniel Stenberg (26 Feb 2011)
-- libssh2_knownhost_readfile.3: clarify return value
-  
-  This function returns the number of parsed hosts on success, not just
-  zero as previously documented.
+Will Cosgrove (17 May 2019)
+- [Alexander Curtiss brought this change]
 
-Peter Stuge (26 Feb 2011)
-- Don't save allocated packet size until it has actually been allocated
+  libgcrypt.c : Fixed _libssh2_rsa_sha1_sign memory leak. (#370)
   
-  The allocated packet size is internal state which needs to match reality
-  in order to avoid problems. This commit fixes #211.
+  File: libgcrypt.c
+  
+  Notes : Added calls to gcry_sexp_release to free memory allocated by gcry_sexp_find_token
+  
+  Credit :
+  Reporter : beckmi
+  PR by: Alexander Curtiss
 
-Daniel Stenberg (21 Feb 2011)
-- [Alfred Gebert brought this change]
+- [Orivej Desh brought this change]
 
-  session_startup: manage server data before server identification
+  libssh2_priv.h : Fix musl build warning on sys/poll.h (#346)
+  
+  File : libssh2_priv.h
   
-  Fix the bug that libssh2 could not connect if the sftp server
-  sends data before sending the version string.
+  Notes :
+  musl prints `redirecting incorrect #include <sys/poll.h> to <poll.h>`
+  http://git.musl-libc.org/cgit/musl/commit/include/sys/poll.h?id=54446d730cfb17c5f7bcf57f139458678f5066cc
   
-  http://tools.ietf.org/html/rfc4253#section-4.2
+  poll is defined by POSIX to be in poll.h:
+  http://pubs.opengroup.org/onlinepubs/7908799/xsh/poll.html
   
-  "The server MAY send other lines of data before sending the version
-  string.  Each line SHOULD be terminated by a Carriage Return and Line
-  Feed.  Such lines MUST NOT begin with "SSH-", and SHOULD be encoded
-  in ISO-10646 UTF-8 [RFC3629] (language is not specified).  Clients
-  MUST be able to process such lines."
+  Credit : Orivej Desh
 
-- [Alfred Gebert brought this change]
+GitHub (1 May 2019)
+- [Will Cosgrove brought this change]
 
-  fullpacket: decompression only after init
+  kex.c : additional bounds checks in diffie_hellman_sha1/256 (#361)
   
-  The buffer for the decompression (remote.comp_abstract) is initialised
-  in time when it is needed.  With this fix decompression is disabled when
-  the buffer (remote.comp_abstract) is not initialised.
+  Files : kex.c, misc.c, misc.h
   
-  Bug: http://trac.libssh2.org/ticket/200
-
-- _libssh2_channel_read: store last error
+  Notes :
+  Fixed possible out of bounds memory access when reading malformed data in diffie_hellman_sha1() and diffie_hellman_sha256().
   
-  When the transport layer returns EAGAIN this function didn't call
-  _libssh2_error() which made the last_error not get set.
+  Added _libssh2_copy_string() to misc.c to return an allocated and filled char buffer from a string_buf offset. Removed no longer needed s var in kmdhgGPshakex_state_t.
 
-- sftp_write: clarified the comment header
+Will Cosgrove (26 Apr 2019)
+- [Tseng Jun brought this change]
 
-- sftp_read: avoid wrapping counter to insanity
+  sftp.c : sftp_bin2attr() Correct attrs->gid assignment (#366)
   
-  As pointed out in bug #206, if a second invoke of libssh2_sftp_read()
-  would shrink the buffer size, libssh2 would go nuts and send out read
-  requests like crazy. This was due to an unsigned variable turning
-  "negative" by some wrong math, and that value would be the amount of
-  data attempt to pre-buffer!
+  Regression with fix for #339
   
-  Bug: http://trac.libssh2.org/ticket/206
+  Credit : Tseng Jun
 
-- sftp_packet_read: use 32bit variables for 32bit data
+- [Tseng Jun brought this change]
 
-- libssh2_sftp_stat_ex.3: cleaned up, extended
-  
-  Removed the macros from it as they have their own man pages.
-  
-  Added the LIBSSH2_SFTP_ATTRIBUTES struct in here for easier reference.
+  kex.c : Correct type cast in curve25519_sha256() (#365)
 
-- sftp_readdir: return error if buffer is too small
-  
-  If asked to read data into a buffer and the buffer is too small to hold
-  the data, this function now returns an error instead of as previously
-  just copy as much as fits.
+GitHub (24 Apr 2019)
+- [Will Cosgrove brought this change]
 
-- sftp_symlink: return error if receive buffer too small
-  
-  and clean up some variable type mismatches
+  transport.c : scope local total_num var (#364)
   
-  Discussion: http://www.libssh2.org/mail/libssh2-devel-archive-2011-01/0001.shtml
+  file : transport.c
+  notes : move local `total_num` variable inside of if block to prevent scope access issues which caused #360.
 
-- docs: clarify what happens with a too small buffer
-  
-  This flaw is subject to change, but I figured it might be valuable to
-  users of existing code to know how it works.
+Will Cosgrove (24 Apr 2019)
+- [doublex brought this change]
 
-- channel_request_pty_size: fix reqPTY_state
+  transport.c : fixes bounds check if partial packet is read
   
-  The state variable isn't properly set so every other call to the
-  function fails!
+  Files : transport.c
   
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2010-12/0096.shtml
-  Reported by: Steve Legg
-
-- data size: cleanup
+  Issue : #360
   
-  Fix 64bit warnings by using (s)size_t and dedicated uint32_t types more.
-
-- [Pierre Joye brought this change]
-
-  ssize_t: proper typedef with MSVC compilers
+  Notes :
+   'p->total_num' instead of local value total_num when doing bounds check.
   
-  As discussed on the mailing list, it was wrong for win64 and using the
-  VC-provided type is the safest approach instead of second- guessing
-  which one it should be.
+  Credit : Doublex
 
-Guenter Knauf (22 Dec 2010)
-- Updated OpenSSL version.
+GitHub (23 Apr 2019)
+- [Will Cosgrove brought this change]
 
-- Expanded tabs to spaces.
+  Editor config file for source files (#322)
+  
+  Simple start to an editor config file when editing source files to make sure they are configured correctly.
 
-Peter Stuge (21 Dec 2010)
-- [Joey Degges brought this change]
+- [Will Cosgrove brought this change]
 
-  _libssh2_ntohu64: fix conversion from network bytes to uint64
+  misc.c : String buffer API improvements (#332)
   
-  Cast individual bytes to uint64 to avoid overflow in arithmetic.
-
-Daniel Stenberg (20 Dec 2010)
-- libssh2_userauth_list: language fix
+  Files : misc.c, hostkey.c, kex.c, misc.h, openssl.c, sftp.c
   
-  "faily" is not a good English word, and I also cleaned up some other minor
-  mistakes
-
-- crypto: unify the generic functions
+  Notes :
+  * updated _libssh2_get_bignum_bytes and _libssh2_get_string. Now pass in length as an argument instead of returning it to keep signedness correct. Now returns -1 for failure, 0 for success.
+  
+  _libssh2_check_length now returns 0 on success and -1 on failure to match the other string_buf functions. Added comment to _libssh2_check_length.
   
-  Added crypto.h that is the unified header to include when using crypto
-  functionality. It should be the only header that needs to adapt to the
-  underlying crypto library in use. It provides the set of prototypes that
-  are library agnostic.
+  Credit : Will Cosgrove
 
-- [Mark Smith brought this change]
+Will Cosgrove (19 Apr 2019)
+- [doublex brought this change]
 
-  userauth: derive publickey from private
+  mbedtls.c : _libssh2_mbedtls_rsa_new_private_frommemory() allow private-key from memory (#359)
   
-  Pass a NULL pointer for the publickey parameter of
-  libssh2_userauth_publickey_fromfile and
-  libssh2_userauth_hostbased_fromfile functions.  In this case, the
-  functions recompute the public key from the private key file data.
+  File : mbedtls.c
   
-  This is work done by Jean-Louis CHARTON
-  <Jean-Louis.CHARTON@oikialog.com>, then adapted by Mark Smith and
-  slightly edited further by me Daniel.
+  Notes: _libssh2_mbedtls_rsa_new_private_frommemory() fixes private-key from memory reading to by adding NULL terminator before parsing; adds passphrase support.
   
-  WARNING: this does leave the feature NOT WORKING when libssh2 is built
-  to use libgcrypt instead of OpenSSL simply due to lack of
-  implementation.
+  Credit: doublex
 
-- ssh2_echo: Value stored to 'exitcode' is never read
+- [Ryan Kelley brought this change]
 
-- _libssh2_packet_add: fix SSH_MSG_DEBUG weirdness
+  Session.c : banner_receive() from leaking when accessing non ssh ports (#356)
   
-  I believe I may have caused this weird typo style error when I cleaned
-  up this function a while ago. Corrected now.
-
-- uint32: more longs converted to proper types
+  File : session.c
   
-  I also moved the MAC struct over to the mac.h header file and made sure
-  that the users of that struct include that file.
-
-- SFTP: more types to uint32_t
+  Release previous banner in banner_receive() if the session is reused after a failed connection.
   
-  The 'num_names' field in the SSH_FXP_NAME response is an unsigned 32bit
-  value so we make sure to treat it like that.
+  Credit : Ryan Kelley
 
-- SFTP: request_ids are uint32_t
-  
-  I went over the code and made sure we use uint32_t all over for the
-  request_id data. It is an unsigned 32bit value on the wire.
+GitHub (11 Apr 2019)
+- [Will Cosgrove brought this change]
 
-- SFTP: store request_id separately in packets
+  Formatting in agent.c
   
-  By using a new separate struct for incoming SFTP packets and not sharing
-  the generic packet struct, we can get rid of an unused field and add a
-  new one dedicated for holding the request_id for the incoming
-  package. As sftp_packet_ask() is called fairly often, a "mere" integer
-  comparison is MUCH faster than the previous memcmp() of (typically) 5
-  bytes.
+  Removed whitespace.
+
+- [Will Cosgrove brought this change]
 
-- libssh2_sftp_open_ex: man page extended and cleaned up
+  Fixed formatting in agent.c
   
-  I added the missing documentation for the 'flags' argument.
+  Quiet linter around a couple if blocks and pointer.
 
-- SFTP: unify the READ/WRITE chunk structs
+Will Cosgrove (11 Apr 2019)
+- [Zhen-Huan HWANG brought this change]
 
-- SFTP: fix memory leaks
-  
-  Make sure that we cleanup remainders when the handle is closed and when
-  the subsystem is shutdown.
+  sftp.c : discard and reset oversized packet in sftp_packet_read() (#269)
   
-  Existing flaw: if a single handle sends packets that haven't been
-  replied to yet at the time when the handle is closed, those packets will
-  arrive later and end up in the generic packet brigade queue and they
-  will remain in there until flushed. They will use unnecessary memory,
-  make things slower and they will ruin the SFTP handling if the
-  request_id counter ever wraps (highly unlikely to every happen).
-
-- sftp_close_handle: packet list is generic
+  file : sftp.c
   
-  Fix comment, simplify the loop logic
-
-- sftp_read: pipeline reads
+  notes : when sftp_packet_read() encounters an sftp packet which exceeds SFTP max packet size it now resets the reading state so it can continue reading.
   
-  The SFTP read function now does transfers the same way the SFTP write
-  function was made to recently: it creates a list of many outgoing
-  FXP_READ packets that each asks for a small data chunk. The code then
-  tries to keep sending read request while collecting the acks for the
-  previous requests and returns the received data.
+  credit : Zhen-Huan HWANG
 
-- sftp_write: removed unused variable
+GitHub (11 Apr 2019)
+- [Will Cosgrove brought this change]
 
-- _libssh2_channel_close: don't call transport read if disconnected
+  Add agent functions libssh2_agent_get_identity_path() and libssh2_agent_set_identity_path() (#308)
   
-  The loop that waits for remote.close to get set may end up looping
-  forever since session->socket_state gets set to
-  LIBSSH2_SOCKET_DISCONNECTED by the packet_add() function called from the
-  transport_read() function and after having been set to
-  LIBSSH2_SOCKET_DISCONNECTED, the transport_read() function will only
-  return 0.
+  File : agent.c
   
-  Bug: http://trac.libssh2.org/ticket/198
+  Notes :
+  Libssh2 uses the SSH_AUTH_SOCK env variable to read the system agent location. However, when using a custom agent path you have to set this value using setenv which is not thread-safe. The new functions allow for a way to set a custom agent socket path in a thread safe manor.
 
-- libssh2_sftp_seek64: new man page
-  
-  Split off libssh2_sftp_seek64 from the libssh2_sftp_seek man page, and
-  mentioned that we consider the latter deprecated. Also added a mention
-  about the dangers of doing seek during writing or reading.
+- [Will Cosgrove brought this change]
 
-- sftp_seek: fix
+  Simplified _libssh2_check_length (#350)
   
-  The new SFTP write code caused a regression as the seek function no
-  longer worked as it didn't set the write position properly.
+  * Simplified _libssh2_check_length
   
-  It should be noted that seeking is STRONGLY PROHIBITED during upload, as
-  the upload magic uses two different offset positions and the multiple
-  outstanding packets etc make them sensitive to change in the midst of
-  operations.
+  misc.c : _libssh2_check_length()
   
-  This functionality was just verified with the new example code
-  sftp_append. This bug was filed as bug #202:
+  Removed cast and improved bounds checking and format.
   
-  Bug: http://trac.libssh2.org/ticket/202
+  Credit : Yuriy M. Kaminskiy
 
-- sftp_append: new example doing SFTP append
+- [Will Cosgrove brought this change]
 
-- MAX_SFTP_OUTGOING_SIZE: 30000
+  _libssh2_check_length() : additional bounds check (#348)
   
-  I ran SFTP upload tests against localhost. It showed that to make the
-  app reach really good speeds, I needed to do a little code tweak and
-  change MAX_SFTP_OUTGOING_SIZE from 4000 to 30000. The tests I did before
-  with the high latency tests didn't show any real difference whatever I
-  had that size set to.
+  Misc.c : _libssh2_check_length()
   
-  This number is the size in bytes that libssh2 cuts off the large input
-  buffer and sends off as an individual sftp packet.
+  Ensure the requested length is less than the total length before doing the additional bounds check
 
-- sftp_write_sliding.c: new example
+Daniel Stenberg (25 Mar 2019)
+- misc: remove 'offset' from string_buf
   
-  This is an example that is very similar to sftp_write_nonblock.c, with
-  the exception that this uses
+  It isn't necessary.
   
-  1 - a larger upload buffer
+  Closes #343
+
+- sftp: repair mtime from e1ead35e475
   
-  2 - a sliding buffer mechnism to allow the app to keep sending lots of
-  data to libssh2 without having to first drain the buffer.
+  A regression from e1ead35e4759 broke the SFTP mtime logic in
+  sftp_bin2attr
   
-  These are two key issues to make libssh2 SFTP uploads really perform
-  well at this point in time.
-
-- cpp: s/#elsif/#elif
+  Also simplified the _libssh2_get_u32/u64 functions slightly.
   
-  This looks like a typo as #elsif is not really C...
+  Closes #342
 
-- _libssh2_channel_write: revert channel_write() use
-  
-  The attempts made to have _libssh2_channel_write() accept larger pieces
-  of data and split up the data by itself into 32700 byte chunks and pass
-  them on to channel_write() in a loop as a way to do faster operations on
-  larger data blocks was a failed attempt.
+- session_disconnect: don't zero state, just clear the right bit
   
-  The reason why it is difficult:
+  If we clear the entire field, the freeing of data in session_free() is
+  skipped. Instead just clear the bit that risk making the code get stuck
+  in the transport functions.
   
-  The API only allows EAGAIN or a length to be returned. When looping over
-  multiple blocks to get sent, one block can get sent and the next might
-  not. And yet: when transport_send() has returned EAGAIN we must not call
-  it again with new data until it has returned OK on the existing data it
-  is still working on. This makes it a mess and we do get a much easier
-  job by simply returning the bytes or EAGAIN at once, as in the EAGAIN
-  case we can assume that we will be called with the same arguments again
-  and transport_send() will be happy.
+  Regression from 4d66f6762ca3fc45d9.
   
-  Unfortunately, I think we take a small performance hit by not being able
-  to do this.
+  Reported-by: dimmaq on github
+  Fixes #338
+  Closes #340
 
-- ssh2_echo: new example
+- libssh2_sftp.h: restore broken ABI
   
-  This is a new example snippet. The code is largely based on ssh2_exec,
-  and is written by Tommy Lindgren. I edited it into C90 compliance and to
-  conform to libssh2 indent style and some more.
-
-- send_existing: return after send_existing
+  Commit 41fbd44 changed variable sizes/types in a public struct which
+  broke the ABI, which breaks applications!
   
-  When a piece of data is sent from the send_existing() function we must
-  make the parent function return afterwards. Otherwise we risk that the
-  parent function tries to send more data and ends up getting an EGAIN for
-  that more data and since it can only return one return code it doesn't
-  return info for the successfully sent data.
+  This reverts that change.
   
-  As this change is a regression I now added a larger comment explaining
-  why it has to work like this.
+  Closes #339
 
-- _libssh2_channel_write: count resent data as written
+- style: make includes and examples code style strict
   
-  In the logic that resends data that was kept for that purpose due to a
-  previous EAGAIN, the data was not counted as sent causing badness.
-
-Peter Stuge (13 Nov 2010)
-- Use fprintf(stderr, ) instead of write(2, ) for debugging
+  make travis and the makefile rule verify them too
+  
+  Closes #334
 
-- session/transport: Correctly handle when _libssh2_send() returns -EAGAIN
+GitHub (21 Mar 2019)
+- [Daniel Stenberg brought this change]
 
-- src/agent.c: Simplify _libssh2_send() error checking ever so slightly
+  create a github issue template
 
-Daniel Stenberg (12 Nov 2010)
-- send/recv: use _libssh2_recv and _libssh2_send now
+Daniel Stenberg (21 Mar 2019)
+- stale-bot: activated
   
-  Starting now, we unconditionally use the internal replacement functions
-  for send() and recv() - creatively named _libssh2_recv() and
-  _libssh2_send().
+  The stale bot will automatically mark stale issues (inactive for 90
+  days) and if still untouched after 21 more days, close them.
   
-  On errors, these functions return the negative 'errno' value instead of
-  the traditional -1. This design allows systems that have no "natural"
-  errno support to not have to invent it. It also means that no code
-  outside of these two transfer functions should use the errno variable.
+  See https://probot.github.io/apps/stale/
 
-- channel_write: move some logic to _libssh2_channel_write
+- libssh2_session_supported_algs.3: fix formatting mistakes
   
-  Some checks are better done in _libssh2_channel_write just once per
-  write instead of in channel_write() since the looping will call the
-  latter function multiple times per _libssh2_channel_write() invoke.
+  Reported-by: Max Horn
+  Fixes #57
 
-- sftp_write: handle "left over" acked data
-  
-  The SFTP handle struct now buffers number of acked bytes that haven't
-  yet been returned. The way this is used is as following:
-  
-  1. sftp_write() gets called with a buffer of let say size 32000. We
-  split 32000 into 8 smaller packets and send them off one by one. One of
-  them gets acked before the function returns so 4000 is returned.
-  
-  2. sftp_write() gets called again a short while after the previous one,
-  now with a much smaller size passed in to the function. Lets say 8000.
-  In the mean-time, all of the remaining packets from the previous call
-  have been acked (7*4000 = 28000). This function then returns 8000 as all
-  data passed in are already sent and it can't return any more than what
-  it got passed in. But we have 28000 bytes acked. We now store the
-  remaining 20000 in the handle->u.file.acked struct field to add up in
-  the next call.
-  
-  3. sftp_write() gets called again, and now there's a backlogged 20000
-  bytes to return as fine and that will get skipped from the beginning
-  of the buffer that is passed in.
+- [Zenju brought this change]
 
-- sftp_write: polished and simplified
-  
-  Removed unnecessary struct fields and state changes within the function.
+  libssh2.h: Fix Error C2371 'ssize_t': redefinition
   
-  Made the loop that checks for ACKs only check chunks that were fully
-  sent.
+  Closes #331
 
-- SCP: on failure, show the numerical error reason
+- travis: add code style check
   
-  By calling libssh2_session_last_errno()
+  Closes #324
 
-- SFTP: provide the numerical error reason on failure
+- code style: unify code style
+  
+  Indent-level: 4
+  Max columns: 79
+  No spaces after if/for/while
+  Unified brace positions
+  Unified white spaces
 
-- SCP: clean up failure treatment
+- src/checksrc.pl: code style checker
   
-  When SCP send or recv fails, it gets a special message from the server
-  with a warning or error message included. We have no current API to
-  expose that message but the foundation is there. Removed unnecessary use
-  of session struct fields.
+  imported as-is from curl
 
-- sftp_write: enlarge buffer to perform better
+Will Cosgrove (19 Mar 2019)
+- Merge branch 'MichaelBuckley-michaelbuckley-security-fixes'
 
-- packets: code cleanup
+- Silence unused var warnings (#329)
   
-  I added size checks in several places. I fixed the code flow to be easier
-  to read in some places.
+  Silence warnings about unused variables in this test
+
+- Removed unneeded > 0 check
   
-  I removed unnecessary zeroing of structs. I removed unused struct fields.
+  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
 
-- LIBSSH2_CALLBACK_MACERROR: clarify return code use
+- [Matthew D. Fuller brought this change]
 
-- _libssh2_userauth_publickey: avoid shadowing
+  Spell OpenSS_H_ right when talking about their specific private key (#321)
+  
+  Good catch, thanks.
 
-- packet: avoid shadowing global symbols
+GitHub (19 Mar 2019)
+- [Will Cosgrove brought this change]
 
-- sftp_readdir: avoid shadowing
+  Silence unused var warnings (#329)
+  
+  Silence warnings about unused variables in this test
 
-- shadowing: don't shadow the global compress
+Michael Buckley (19 Mar 2019)
+- Fix more scope and printf warning errors
 
-- _libssh2_packet_add: turn ifs into a single switch
+- Silence unused variable warning
 
-- _libssh2_packet_add: check SSH_MSG_GLOBAL_REQUEST packet
+GitHub (19 Mar 2019)
+- [Will Cosgrove brought this change]
 
-- _libssh2_packet_add: SSH_MSG_DEBUG length checks
+  Removed unneeded > 0 check
   
-  Verify lengths before using them. Read always_display from the correct
-  index. Don't copy stuff around just to provide zero-termination of the
-  strings.
+  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
 
-- _libssh2_packet_add: SSH_MSG_IGNORE skip memmove
-  
-  There's no promise of a zero termination of the data in the callback so
-  no longer perform ugly operation in order to provide it.
+Will Cosgrove (19 Mar 2019)
+- [Matthew D. Fuller brought this change]
 
-- _libssh2_packet_add: SSH_MSG_DISCONNECT length checks
+  Spell OpenSS_H_ right when talking about their specific private key (#321)
   
-  Verify lengths before trying to read data.
-
-- indent: break lines at 80 columns
+  Good catch, thanks.
 
-- SSH_MSG_CHANNEL_OPEN_FAILURE: used defined values
-  
-  We don't like magic numbers in the code. Now the acceptable failure
-  codes sent in the SSH_MSG_CHANNEL_OPEN_FAILURE message are added as
-  defined values in the private header file.
+Michael Buckley (18 Mar 2019)
+- Fix errors identified by the build process
 
-- sftp_write: don't return EAGAIN if no EAGAIN was received
-  
-  This function now only returns EAGAIN if a lower layer actually returned
-  EAGAIN to it. If nothing was acked and no EAGAIN was received, it will
-  now instead return 0.
+- Fix casting errors after merge
 
-- _libssh2_wait_socket: detect nothing-to-wait-for
-  
-  If _libssh2_wait_socket() gets called but there's no direction set to
-  wait for, this causes a "hang". This code now detects this situation,
-  set a 1 second timeout instead and outputs a debug output about it.
+GitHub (18 Mar 2019)
+- [Michael Buckley brought this change]
 
-- decomp: remove the free_dest argument
-  
-  Since the decompress function ALWAYS returns allocated memory we get a
-  lot simpler code by removing the ability to return data unallocated.
+  Merge branch 'master' into michaelbuckley-security-fixes
 
-- decomp: cleaned off old compression stuff
-  
-  I cleared off legacy code from when the compression and decompression
-  functions were a single unified function. Makes the code easier to read
-  too.
+Michael Buckley (18 Mar 2019)
+- Move fallback SIZE_MAX and UINT_MAX to libssh2_priv.h
 
-- [TJ Saunders brought this change]
+- Fix type and logic issues with _libssh2_get_u64
 
-  decomp: increase decompression buffer sizes
+Daniel Stenberg (17 Mar 2019)
+- examples: fix various compiler warnings
 
-- [TJ Saunders brought this change]
+- lib: fix various compiler warnings
 
-  zlib: Add debug tracing of zlib errors
+- session: ignore pedantic warnings for funcpointer <=> void *
 
-- sftp_packet_read: handle partial reads of the length field
+- travis: add a build using configure
   
-  SFTP packets come as [32 bit length][payload] and the code didn't
-  previously handle that the initial 32 bit field was read only partially
-  when it was read.
+  Closes #320
 
-- [Jasmeet Bagga brought this change]
+- configure: provide --enable-werror
 
-  kex_agree_hostkey: fix NULL pointer derefence
+- appveyor: remove old builds that mostly cause failures
   
-  While setting up the session, ssh tries to determine the type of
-  encryption method it can use for the session. This requires looking at
-  the keys offered by the remote host and comparing these with the methods
-  supported by libssh2 (rsa & dss). To do this there is an iteration over
-  the array containing the methods supported by libssh2.
+  ... and only run on master branch.
   
-  If there is no agreement on the type of encryption we come to the 3rd
-  entry of the hostkeyp array. Here hostkeyp is valid but *hostkep is
-  NULL. Thus when we dereference that in (*hostkeyp)->name there is a
-  crash
+  Closes #323
 
-- _libssh2_transport_send: remove dead assignment
+- cmake: add two missing man pages to get installed too
+  
+  Both libssh2_session_handshake.3 and
+  libssh2_userauth_publickey_frommemory.3 were installed by the configure
+  build already.
   
-  'data' isn't accessed beyond this point so there's no need to assign it.
+  Reported-by: Arfrever on github
+  Fixes #278
 
-- scp_recv: remove dead assignment
+- include/libssh2.h: warning: "_WIN64" is not defined, evaluates to 0
   
-  Instead of assigning a variable we won't read, we now use the more
-  explicit (void) prefix.
+  We don't use #if for defines that might not be defined.
 
-- sftp_write: removed superfluous assignment
+- pem: //-comments are not allowed
 
-- bugfix: avoid use of uninitialized value
+Will Cosgrove (14 Mar 2019)
+- [Daniel Stenberg brought this change]
 
-- sftp_packet_require: propagate error codes better
+  userauth: fix "Function call argument is an uninitialized value" (#318)
   
-  There were some chances that they would cause -1 to get returned by
-  public functions and as we're hunting down all such occurances and since
-  the underlying functions do return valuable information the code now
-  passes back proper return codes better.
-
-- [Alfred Gebert brought this change]
+  Detected by scan-build.
 
-  fix memory leaks (two times cipher_data) for each sftp session
+- fixed unsigned/signed issue
 
-- libssh2_userauth_authenticated: make it work as documented
+Daniel Stenberg (15 Mar 2019)
+- session_disconnect: clear state
   
-  The man page clearly says it returns 1 for "already authenticated" but
-  the code said non-zero. I changed the code to use 1 now, as that is also
-  non-zero but it gets the benefit that it now matches the documentation.
+  If authentication is started but not completed before the application
+  gives up and instead wants to shut down the session, the '->state' field
+  might still be set and thus effectively dead-lock session_disconnect.
+  
+  This happens because both _libssh2_transport_send() and
+  _libssh2_transport_read() refuse to do anything as long as state is set
+  without the LIBSSH2_STATE_KEX_ACTIVE bit.
   
-  Using 1 instead of non-zero is better for two reasons:
+  Reported in curl bug https://github.com/curl/curl/issues/3650
   
-  1. We have the opportunity to introduce other return codes in the future for
-     things like error and what not.
-  2. We don't expose the internal bitmask variable value.
+  Closes #310
 
-- userauth_keyboard_interactive: fix indent
+Will Cosgrove (14 Mar 2019)
+- Release notes from 1.8.1
 
-- [Alfred Gebert brought this change]
+Michael Buckley (14 Mar 2019)
+- Use string_buf in sftp_init().
 
-  fix memory leak in userauth_keyboard_interactive()
-  
-  First I wanted to free the memory in session_free() but then
-  I had still memory leaks because in my test case the function
-  userauth_keyboard_interactive() is called twice. It is called
-  twice perhaps because the server has this authentication
-  methods available: publickey,gssapi-with-mic,keyboard-interactive
-  The keyboard-interactive method is successful.
+- Guard against out-of-bounds reads in publickey.c
 
-- dist: include sftp.h in dist archives
+- Guard against out-of-bounds reads in session.c
 
-Simon Josefsson (27 Oct 2010)
-- Update header to match new function prototype, see c48840ba88.
+- Guard against out-of-bounds reads in userauth.c
 
-Daniel Stenberg (26 Oct 2010)
-- bugfixes: the transport rearrange left some subtle flaws now gone
+- Use LIBSSH2_ERROR_BUFFER_TOO_SMALL instead of LIBSSH2_ERROR_OUT_OF_BOUNDARY in sftp.c
 
-- libssh2_userauth_publickey_fromfile_ex.3: cleaned up looks
+- Additional bounds checking in sftp.c
 
-- libssh2_userauth_publickey: add man page
-  
-  I found an undocumented public function and we can't have it like
-  that. The description here is incomplete, but should serve as a template
-  to allow filling in...
+- Additional length checks to prevent out-of-bounds reads and writes in _libssh2_packet_add(). https://libssh2.org/CVE-2019-3862.html
 
-- libssh2_sftp_write.3: added blurb about the "write ahead"
-  
-  Documented the new SFTP write concept
+- Add a required_size parameter to sftp_packet_require et. al. to require callers of these functions to handle packets that are too short. https://libssh2.org/CVE-2019-3860.html
 
-- sftp_close_handle: free any trailing write chunks
+- Check the length of data passed to sftp_packet_add() to prevent out-of-bounds reads.
 
-- _libssh2_channel_write: fix warnings
+- Prevent zero-byte allocation in sftp_packet_read() which could lead to an out-of-bounds read. https://libssh2.org/CVE-2019-3858.html
 
-- SFTP: bufgix, move more sftp stuff to sftp.h
-  
-  The sftp_write function shouldn't assume that the buffer pointer will be
-  the same in subsequent calls, even if it assumes that the data already
-  passed in before haven't changed.
+- Sanitize padding_length - _libssh2_transport_read(). https://libssh2.org/CVE-2019-3861.html
   
-  The sftp structs are now moved to sftp.h (which I forgot to add before)
+  This prevents an underflow resulting in a potential out-of-bounds read if a server sends a too-large padding_length, possibly with malicious intent.
 
-- SFTP: use multiple outgoing packets when writing
-  
-  sftp_write was rewritten to split up outgoing data into multiple packets
-  and deal with the acks in a more asynchronous manner. This is meant to
-  help overcome latency and round-trip problems with the SFTP protocol.
+- Defend against writing beyond the end of the payload in _libssh2_transport_read().
 
-- TODO: implemented a lot of the ideas now
+- Defend against possible integer overflows in comp_method_zlib_decomp.
 
-- _libssh2_channel_write: removed 32500 size limit
-  
-  Neither _libssh2_channel_write nor sftp_write now have the 32500 size
-  limit anymore and instead the channel writing function now has its own
-  logic to send data in multiple calls until everything is sent.
+GitHub (14 Mar 2019)
+- [Will Cosgrove brought this change]
 
-- send_existing: don't tell parent to return when drained
+  Security fixes (#315)
   
-  That will just cause unnecessary code execution.
-
-- _libssh2_channel_write: general code cleanup
+  * Bounds checks
   
-  simplified the function and removed some unused struct fields
-
-- _libssh2_transport_send: replaces _libssh2_transport_write
+  Fixes for CVEs
+  https://www.libssh2.org/CVE-2019-3863.html
+  https://www.libssh2.org/CVE-2019-3856.html
   
-  The new function takes two data areas, combines them and sends them as a
-  single SSH packet. This allows several functions to allocate and copy
-  less data.
+  * Packet length bounds check
   
-  I also found and fixed a mixed up use of the compression function
-  arguments that I introduced in my rewrite in a recent commit.
-
-- scp_write_nonblock: use select() instead of busyloop
+  CVE
+  https://www.libssh2.org/CVE-2019-3855.html
   
-  Make this example nicer by not busylooping.
-
-- send_existing: clear olen when the data is sent off
-
-- _libssh2_transport_write: allow 256 extra bytes around the packet
-
-- _libssh2_transport_write: remade to send without malloc
-
-- compress: compression disabled by default
+  * Response length check
   
-  We now allow libssh2_session_flag() to enable compression with a new
-  flag and I added documentation for the previous LIBSSH2_FLAG_SIGPIPE
-  flag which I wasn't really aware of!
-
-- comp: split the compress function
+  CVE
+  https://www.libssh2.org/CVE-2019-3859.html
   
-  It is now made into two separate compress and decompress functions. In
-  preparation for upcoming further modficications.
-
-Dan Fandrich (20 Oct 2010)
-- Added header file to allow compiling in older environments
-
-Daniel Stenberg (20 Oct 2010)
-- TODO: add a possible new API for SFTP transfers
-
-- TODO: "New Transport API" added
-
-- TODO: add buffering plans
-
-Simon Josefsson (13 Oct 2010)
-- Mention libssh2_channel_get_exit_signal and give kudos.
-
-- [Tommy Lindgren brought this change]
-
-  Add libssh2_channel_get_exit_signal man page.
+  * Bounds check
   
-  Signed-off-by: Simon Josefsson <simon@josefsson.org>
-
-- [Tommy Lindgren brought this change]
-
-  Add libssh2_channel_get_exit_signal.
+  CVE
+  https://www.libssh2.org/CVE-2019-3857.html
   
-  Signed-off-by: Simon Josefsson <simon@josefsson.org>
-
-- Add libssh2_free man page and fix typo.
-
-- Add libssh2_free.
-
-Daniel Stenberg (11 Oct 2010)
-- scp_recv: improved treatment of channel_read() returning zero
+  * Bounds checking
   
-  As a zero return code from channel_read() is not an error we must make
-  sure that the SCP functions deal with that properly. channel_read()
-  always returns 0 if the channel is EOFed already so we check for EOF
-  after 0-reads to be able to return error properly.
-
-- libssh2_session_methods.3: detail what can be asked for
-
-- compression: send zlib before none
+  CVE
+  https://www.libssh2.org/CVE-2019-3859.html
   
-  As the list of algorithms in a preferred order we should send zlib
-  before none to increase the chances that the server will let us do
-  compression.
-
-- compress: faster check, better return codes
+  and additional data validation
   
-  In the transport functions we avoid a strcmp() now and just check a
-  boolean instead.
+  * Check bounds before reading into buffers
   
-  The compress/decompress function's return code is now acknowledged and
-  used as actual return code in case of failures.
-
-- libssh2_session_handshake: replaces libssh2_session_startup()
+  * Bounds checking
   
-  The function libssh2_session_startup() is now considered deprecated due
-  to the portability issue with the socket argument.
-  libssh2_session_handshake() is the name of the replacement.
-
-- libssh2_socket_t: now externally visible
+  CVE
+  https://www.libssh2.org/CVE-2019-3859.html
   
-  In preparation for upcominig changes, the libssh2_socket_t type is now
-  typedef'ed in the public header.
+  * declare SIZE_MAX and UINT_MAX if needed
 
-- _libssh2_transport_drain: removed
-  
-  This function proved not to be used nor useful.
+- [Will Cosgrove brought this change]
 
-- _libssh2_channel_write: don't iterate over transport writes
-  
-  When a call to _libssh2_transport_write() succeeds, we must return from
-  _libssh2_channel_write() to allow the caller to provide the next chunk
-  of data.
-  
-  We cannot move on to send the next piece of data that may already have
-  been provided in this same function call, as we risk getting EAGAIN for
-  that and we can't return information both about sent data as well as
-  EAGAIN. So, by returning short now, the caller will call this function
-  again with new data to send.
+  fixed type warnings (#309)
+
+- [Will Cosgrove brought this change]
 
-- _libssh2_transport_write: updated documentation blurb
+  Bumping version number for pending 1.8.1 release
 
-- _libssh2_transport_write: remove fprintf remainder
-  
-  Mistake from previous debugging
+Will Cosgrove (4 Mar 2019)
+- [Daniel Stenberg brought this change]
 
-- session: improved errors
-  
-  Replaced -1/SOCKET_NONE errors with appropriate error defines instead.
+  _libssh2_string_buf_free: use correct free (#304)
   
-  Made the verbose trace output during banner receiving less annoying for
-  non-blocking sessions.
+  Use LIBSSH2_FREE() here, not free(). We allow memory function
+  replacements so free() is rarely the right choice...
 
-- crypt_init: use correct error define
+GitHub (26 Feb 2019)
+- [Will Cosgrove brought this change]
 
-- _libssh2_error: hide EAGAIN for non-blocking sessions
+  Fix for building against libreSSL #302
   
-  In an attempt to make the trace output less cluttered for non-blocking
-  sessions the error function now avoids calling the debug function if the
-  error is the EAGAIN and the session is non-blocking.
+  Changed to use the check we use elsewhere.
 
-- agent: use better error defines
+- [Will Cosgrove brought this change]
 
-- comp_method_zlib_init: use correct error defines
+  Fix for when building against LibreSSL #302
 
-- transport: better error codes
-  
-  LIBSSH2_SOCKET_NONE (-1) should no longer be used as error code as it is
-  (too) generic and we should instead use specific and dedicated error
-  codes to better describe the error.
+Will Cosgrove (25 Feb 2019)
+- [gartens brought this change]
 
-- channel: return code and _libssh2_error cleanup
-  
-  Made sure that all transport_write() call failures get _libssh2_error
-  called.
+  docs: update libssh2_hostkey_hash.3 [ci skip] (#301)
 
-- _libssh2_channel_write: limit to 32700 bytes
-  
-  The well known and used ssh server Dropbear has a maximum SSH packet
-  length at 32768 by default. Since the libssh2 design current have a
-  fixed one-to-one mapping from channel_write() to the packet size created
-  by transport_write() the previous limit of 32768 in the channel layer
-  caused the transport layer to create larger packets than 32768 at times
-  which Dropbear rejected forcibly (by closing the connection).
-  
-  The long term fix is of course to remove the hard relation between the
-  outgoing SSH packet size and what the input length argument is in the
-  transport_write() function call.
+GitHub (21 Feb 2019)
+- [Will Cosgrove brought this change]
 
-- libssh.h: add more dedicated error codes
+  fix malloc/free mismatches #296 (#297)
 
-- SCP: allow file names with bytes > 126
-  
-  When parsing the SCP protocol and verifying that the data looks like a
-  valid file name, byte values over 126 must not be consider illegal since
-  UTF-8 file names will use such codes.
-  
-  Reported by: Uli Zappe
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2010-08/0112.shtml
+- [Will Cosgrove brought this change]
 
-Dan Fandrich (25 Aug 2010)
-- Document the three sftp stat constants
+  Replaced malloc with calloc #295
 
-Guenter Knauf (18 Aug 2010)
-- Fixed Win32 makefile which was now broken at resource build.
+- [Will Cosgrove brought this change]
 
-- It is sufficient to pipe stderr to NUL to get rid of the nasty messages.
+  Abstracted OpenSSL calls out of hostkey.c (#294)
 
-- [Author: Guenter Knauf brought this change]
+- [Will Cosgrove brought this change]
 
-  Removed Win32 ifdef completely for sys/uio.h.
+  Fix memory dealloc impedance mis-match #292 (#293)
   
-  No idea why we had this ifdef at all but MSVC, MingW32, Watcom
-  and Borland all have no sys/uio.h header; so if there's another
-  Win32 compiler which needs it then it should be added explicitely
-  instead of this negative list.
+  When using ed25519 host keys and a custom memory allocator.
+
+- [Will Cosgrove brought this change]
 
-- New files should also be added to Makefile.am.
+  Added call to OpenSSL_add_all_digests() #288
   
-  Otherwise they will never be included with release and snapshot tarballs ...
+  For OpenSSL 1.0.x we need to call OpenSSL_add_all_digests().
 
-Daniel Stenberg (18 Aug 2010)
-- version: bump to 1.2.8_DEV
+Will Cosgrove (12 Feb 2019)
+- [Zhen-Huan HWANG brought this change]
 
-Version 1.2.7 (17 Aug 2010)
+  SFTP: increase maximum packet size to 256K (#268)
+  
+  to match implementations like OpenSSH.
 
-Daniel Stenberg (17 Aug 2010)
-- release: updated to hold 1.2.7 info
+- [Zenju brought this change]
 
-Guenter Knauf (17 Aug 2010)
-- Use the new libssh2.rc file.
+  Fix https://github.com/libssh2/libssh2/pull/271 (#284)
 
-- Added resource file for libssh2.dll (shamelessly stolen from libcurl).
+GitHub (16 Jan 2019)
+- [Will Cosgrove brought this change]
 
-- Updated Win32 MSVC dependencies versions.
+  Agent NULL check in shutdown #281
 
-- Added include for sys/select.h to get fd.set on some platforms.
+Will Cosgrove (15 Jan 2019)
+- [Adrian Moran brought this change]
 
-- Added Watcom makefile borrowed from libcurl.
+  mbedtls: Fix leak of 12 bytes by each key exchange. (#280)
   
-  This makefile compiles already all files fine for static lib, but needs
-  final touch when I have OpenSSL fully working with shared libs and Watcom.
+  Correctly free ducts by calling _libssh2_mbedtls_bignum_free() in dtor.
 
-- Added copyright define to libssh2.h and use it for binary builds.
+- [alex-weaver brought this change]
 
-- Moved version defines up in order to include from .rc file.
-  
-  Blocked rest of header with ifndef so its possible to let
-  the rc compiler only use the version defines.
+  Fix error compiling on Win32 with STDCALL=ON (#275)
 
-- Some minor makefile tweaks.
+GitHub (8 Nov 2018)
+- [Will Cosgrove brought this change]
 
-Daniel Stenberg (2 Aug 2010)
-- example: treat the libssh2_channel_read() return code properly
+  Allow default permissions to be used in sftp_mkdir (#271)
   
-  A short read is not an error. Only negative values are errors!
+  Added constant LIBSSH2_SFTP_DEFAULT_MODE to use the server default permissions when making a new directory
+
+Will Cosgrove (13 Sep 2018)
+- [Giulio Benetti brought this change]
 
-- libssh2_wait_socket: reset error code to "leak" EAGAIN less
+  openssl: fix dereferencing ambiguity potentially causing build failure (#267)
   
-  Since libssh2 often sets LIBSSH2_ERROR_EAGAIN internally before
-  _libssh2_wait_socket is called, we can decrease some amount of
-  confusion in user programs by resetting the error code in this function
-  to reduce the risk of EAGAIN being stored as error when a blocking
-  function returns.
+  When dereferencing from *aes_ctr_cipher, being a pointer itself,
+  ambiguity can occur; fixed possible build errors.
 
-- _libssh2_wait_socket: poll needs milliseconds
+Viktor Szakats (12 Sep 2018)
+- win32/GNUmakefile: define HAVE_WINDOWS_H
   
-  As reported on the mailing list, the code path using poll() should
-  multiple seconds with 1000 to get milliseconds, not divide!
+  This macro was only used in test/example code before, now it is
+  also used in library code, but only defined automatically by
+  automake/cmake, so let's do the same for the standalone win32
+  make file.
   
-  Reported by: Jan Van Boghout
-
-- typedef: make ssize_t get typedef without LIBSSH2_WIN32
+  It'd be probably better to just rely on the built-in _WIN32 macro
+  to detect the presence of windows.h though. It's already used
+  in most of libssh2 library code. There is a 3rd, similar macro
+  named LIBSSH2_WIN32, which might also be replaced with _WIN32.
   
-  The condition around the ssize_t typedef depended on both LIBSSH2_WIN32
-  *and* _MSC_VER being defined when it should be enough to depend on
-  _MSC_VER only. It also makes it nicer so libssh2-using code builds fine
-  without having custom defines.
-
-- [John Little brought this change]
-
-  session_free: free more data to avoid memory leaks
+  Ref: https://github.com/libssh2/libssh2/commit/8b870ad771cbd9cd29edbb3dbb0878e950f868ab
+  Closes https://github.com/libssh2/libssh2/pull/266
 
-- channel_free: ignore problems with channel_close()
+Marc Hoersken (2 Sep 2018)
+- Fix conditional check for HAVE_DECL_SECUREZEROMEMORY
   
-  As was pointed out in bug #182, we must not return failure from
-  _libssh2_channel_free() when _libssh2_channel_close() returns an error
-  that isn't EAGAIN. It can effectively cause the function to never go
-  through, like it did now in the case where the socket was actually
-  closed but socket_state still said LIBSSH2_SOCKET_CONNECTED.
+  "Unlike the other `AC_CHECK_*S' macros, when a symbol is not declared,
+  HAVE_DECL_symbol is defined to `0' instead of leaving HAVE_DECL_symbol
+  undeclared. When you are sure that the check was performed,
+  use HAVE_DECL_symbol in #if."
   
-  I consider this fix the right thing as it now also survives other
-  errors, even if making sure socket_state isn't lying is also a good
-  idea.
+  Source: autoconf documentation for AC_CHECK_DECLS.
 
-- publickey_list_free: no return value from a void function
+- Fix implicit declaration of function 'SecureZeroMemory'
   
-  Fixed a compiler warning I introduced previously when checking input
-  arguments more. I also added a check for the other pointer to avoid NULL
-  pointer dereferences.
+  Include window.h in order to use SecureZeroMemory on Windows.
+
+- Fix implicit declaration of function 'free' by including stdlib.h
 
-- [Lars Nordin brought this change]
+GitHub (27 Aug 2018)
+- [Will Cosgrove brought this change]
 
-  openssl: make use of the EVP interface
+  Use malloc abstraction function in pem parse
   
-  Make use of the EVP interface for the AES-funktion. Using this method
-  supports the use of different ENGINES in OpenSSL for the AES function
-  (and the direct call to the AES_encrypt should not be used according to
-  openssl.org)
+  Fix warning on WinCNG build.
 
-Peter Stuge (23 Jun 2010)
-- [Tor Arntsen brought this change]
+- [Will Cosgrove brought this change]
 
-  Don't overflow MD5 server hostkey
-  
-  Use SHA_DIGEST_LENGTH and MD5_DIGEST_LENGTH in memcpy instead of hardcoded
-  values. An incorrect value was used for MD5.
+  Fixed possible junk memory read in sftp_stat #258
 
-- Fix message length bugs in libssh2_debug()
-  
-  There was a buffer overflow waiting to happen when a debug message was
-  longer than 1536 bytes.
-  
-  Thanks to Daniel who spotted that there was a problem with the message
-  length passed to a trace handler also after commit
-  0f0652a3093111fc7dac0205fdcf8d02bf16e89f.
+- [Will Cosgrove brought this change]
 
-- Make libssh2_debug() create a correctly terminated string
+  removed INT64_C define (#260)
   
-  Also use FILE *stderr rather than fd 2, which can very well be something
-  completely different.
+  No longer used.
 
-Daniel Stenberg (23 Jun 2010)
-- [TJ Saunders brought this change]
+- [Will Cosgrove brought this change]
 
-  handshake: Compression enabled at the wrong time
-  
-  In KEXINIT messages, the client and server agree on, among other
-  things, whether to use compression. This method agreement occurs
-  in src/kex.c's kex_agree_methods() function. However, if
-  compression is enabled (either client->server, server->client, or
-  both), then the compression layer is initialized in
-  kex_agree_methods() -- before NEWKEYS has been received.
-  
-  Instead, the initialization of the compression layer should
-  happen after NEWKEYS has been received. This looks to occur
-  insrc/kex.c's diffie_hellman_sha1(), which even has the comment:
-  
-      /* The first key exchange has been performed,
-  
-          switch to active crypt/comp/mac mode */
-  
-  There, after NEWKEYS is received, the cipher and mac algorithms
-  are initialized, and that is where the compression should be
-  initialized as well.
-  
-  The current implementation fails if server->client compression is
-  enabled because most server implementations follow OpenSSH's
-  lead, where compression is initialized after NEWKEYS. Since the
-  server initializes compression after NEWKEYS, but libssh2
-  initializes compression after KEXINIT (i.e. before NEWKEYS), they
-  are out of sync.
-  
-  Reported in bug report #180
+  Added conditional around engine.h include
 
-- [TJ Saunders brought this change]
+Will Cosgrove (6 Aug 2018)
+- [Alex Crichton brought this change]
 
-  userauth_hostbased_fromfile: packet length too short
-  
-  The packet length calculated in src/userauth.c's
-  userauth_hostbased_fromfile() function is too short by 4 bytes;
-  it forgets to add four bytes for the length of the hostname.
-  This causes hostbased authentication to fail, since the server
-  will read junk data.
+  Fix OpenSSL link error with `no-engine` support (#259)
   
-  verified against proftpd's mod_sftp module
+  This commit fixes linking against an OpenSSL library that was compiled with
+  `no-engine` support by bypassing the initialization routines as they won't be
+  available anyway.
+
+GitHub (2 Aug 2018)
+- [Will Cosgrove brought this change]
 
-- _libssh2_userauth_publickey: reject method names longer than the data
+  ED25519 Key Support #39 (#248)
   
-  This functions get the method length by looking at the first 32
-  bit of data, and I now made it not accept method lengths that are
-  longer than the whole data set is, as given in the dedicated
-  function argument.
+  OpenSSH Key and ED25519 support #39
+  Added _libssh2_explicit_zero() to explicitly zero sensitive data in memory #120
   
-  This was detected when the function was given bogus public key
-  data as an ascii string, which caused the first 32bits to create
-  a HUGE number.
+  * ED25519 Key file support - Requires OpenSSL 1.1.1 or later
+  * OpenSSH Key format reading support - Supports RSA/DSA/ECDSA/ED25519 types
+  * New string buffer reading functions - These add build-in bounds checking and convenance methods. Used for OpenSSL PEM file reading.
+  * Added new tests for OpenSSH formatted Keys
 
-- NULL resistance: make more public functions survive NULL pointer input
-  
-  Sending in NULL as the primary pointer is now dealt with by more
-  public functions. I also narrowed the userauth.c code somewhat to
-  stay within 80 columns better.
+- [Will Cosgrove brought this change]
 
-- agent: make libssh2_agent_userauth() work blocking properly
+  ECDSA key types are now explicit (#251)
   
-  previously it would always work in a non-blocking manner
-
-Peter Stuge (17 Jun 2010)
-- Fix underscore typo for 64-bit printf format specifiers on Windows
+  * ECDSA key types are now explicit
   
-  Commit 49ddf447ff4bd80285f926eac0115f4e595f9425 was missing underscores.
-
-Daniel Stenberg (16 Jun 2010)
-- libssh2_session_callback_set: extended the man page
+  Issue was brough up in pull request #248
diff --git a/libssh2/NMakefile b/libssh2/NMakefile
deleted file mode 100644
index 07bc2dda..00000000
--- a/libssh2/NMakefile
+++ /dev/null
@@ -1,33 +0,0 @@
-!include "win32/config.mk"
-
-!if "$(WITH_WINCNG)" == "1"
-!include "Makefile.WinCNG.inc"
-!else
-!include "Makefile.OpenSSL.inc"
-!endif
-!include "Makefile.inc"
-
-OBJECTS=$(CSOURCES:.c=.obj)
-
-# SUBDIRS=src example
-SUBDIRS=src
-
-all-sub: win32\objects.mk
-	-for %D in ($(SUBDIRS)) do $(MAKE) /nologo /f %D/NMakefile BUILD=$(BUILD) SUBDIR=%D all-sub
-
-clean: 
-	-rmdir 2>NUL /s/q $(TARGET)
-	-del 2>NUL win32\objects.mk
-
-real-clean vclean: clean
-	-del 2>NUL libssh2.dll
-	-del 2>NUL libssh2.exp
-	-del 2>NUL libssh2.ilk
-	-del 2>NUL libssh2.lib
-	-del 2>NUL *.pdb
-
-win32\objects.mk: Makefile.inc
-	@echo OBJECTS = \>$@
-	@for %O in ($(OBJECTS)) do @echo $$(INTDIR)\%O \>>$@
-	@echo $$(EOL)>>$@
-
diff --git a/libssh2/README b/libssh2/README
index 8a148568..fca539db 100644
--- a/libssh2/README
+++ b/libssh2/README
@@ -4,9 +4,9 @@ libssh2 - SSH2 library
 libssh2 is a library implementing the SSH2 protocol, available under
 the revised BSD license.
 
-Web site: https://www.libssh2.org/
+Web site: https://libssh2.org/
 
-Mailing list: https://cool.haxx.se/mailman/listinfo/libssh2-devel
+Mailing list: https://lists.haxx.se/listinfo/libssh2-devel
 
 License: see COPYING
 
diff --git a/libssh2/README.md b/libssh2/README.md
new file mode 100644
index 00000000..9d167c07
--- /dev/null
+++ b/libssh2/README.md
@@ -0,0 +1,16 @@
+# libssh2 - SSH2 library
+
+libssh2 is a library implementing the SSH2 protocol, available under
+the revised BSD license.
+
+[Web site](https://libssh2.org/)
+
+[Mailing list](https://lists.haxx.se/listinfo/libssh2-devel)
+
+[BSD Licensed](https://libssh2.org/license.html)
+
+[Web site source code](https://github.com/libssh2/www)
+
+Installation instructions:
+ - [for CMake](docs/INSTALL_CMAKE.md)
+ - [for autotools](docs/INSTALL_AUTOTOOLS)
diff --git a/libssh2/RELEASE-NOTES b/libssh2/RELEASE-NOTES
index 62064a9f..d9af1689 100644
--- a/libssh2/RELEASE-NOTES
+++ b/libssh2/RELEASE-NOTES
@@ -1,62 +1,325 @@
-libssh2 1.10
+libssh2 1.11.1
+
+Deprecation notices:
+
+- Starting October 2024, the following algos go deprecated and will be
+  disabled in default builds (with an option to enable them):
+
+  - DSA: `ssh-dss` hostkeys.
+      You can enable it now with `-DLIBSSH2_DSA_ENABLE`.
+      Disabled by default in OpenSSH 7.0 (2015-08-11).
+      Support to be removed by early 2025 from OpenSSH.
+  - MD5-based MACs and hashes: `hmac-md5`, `hmac-md5-96`,
+    `LIBSSH2_HOSTKEY_HASH_MD5`
+      You can disable it now with `-DLIBSSH2_NO_MD5`.
+      Disabled by default since OpenSSH 7.2 (2016-02-29).
+  - 3DES cipher: `3des-cbc`
+      You can disable it now with `-DLIBSSH2_NO_3DES`.
+      Disabled by default since OpenSSH 7.4 (2016-12-19).
+  - RIPEMD-160 MACs: `hmac-ripemd160`, `hmac-ripemd160@openssh.com`
+      You can disable it now with `-DLIBSSH2_NO_HMAC_RIPEMD`.
+      Removed in OpenSSH 7.6 (2017-10-03).
+  - Blowfish cipher: `blowfish-cbc`
+      You can disable it now with `-DLIBSSH2_NO_BLOWFISH`.
+      Removed in OpenSSH 7.6 (2017-10-03).
+  - RC4 ciphers: `arcfour`, `arcfour128`
+      You can disable it now with `-DLIBSSH2_NO_RC4`.
+      Removed in OpenSSH 7.6 (2017-10-03).
+  - CAST cipher: `cast128-cbc`
+      You can disable it now with `-DLIBSSH2_NO_CAST`.
+      Removed in OpenSSH 7.6 (2017-10-03).
+
+- Starting April 2025, above options will be deleted from the
+  libssh2 codebase.
+
+  - Default builds will also disable support for old-style, MD5-based
+    encrypted private keys.
+    You can disable it now with `-DLIBSSH2_NO_MD5_PEM`.
 
 This release includes the following enhancements and bugfixes:
 
- o adds agent forwarding support
- o adds OpenSSH Agent support on Windows
- o adds ECDSA key support using the Mbed TLS backend
- o adds ECDSA cert authentication
- o adds diffie-hellman-group14-sha256, diffie-hellman-group16-sha512,
-   diffie-hellman-group18-sha512 key exchanges
- o adds support for PKIX key reading when using ed25519 with OpenSSL
- o adds support for EWOULDBLOCK on VMS systems
- o adds support for building with OpenSSL 3
- o adds support for using FIPS mode in OpenSSL
- o adds debug symbols when building with MSVC
- o adds support for building on the 3DS
- o adds unicode build support on Windows
- o restores os400 building
- o increases min, max and opt Diffie Hellman group values
- o improves portiablity of the make file
- o improves timeout behavior with 2FA keyboard auth
- o various improvements to the Wincng backend
- o fixes reading parital packet replies when using an agent
- o fixes Diffie Hellman key exchange on Windows 1903+ builds
- o fixes building tests with older versions of OpenSSL
- o fixes possible multiple definition warnings
- o fixes potential cast issues _libssh2_ecdsa_key_get_curve_type()
- o fixes potential use after free if libssh2_init() is called twice
- o improved linking when using Mbed TLS
- o fixes call to libssh2_crypto_exit() if crypto hasn't been initialized
- o fixes crash when loading public keys with no id
- o fixes possible out of bounds read when exchanging keys
- o fixes possible out of bounds read when reading packets
- o fixes possible out of bounds read when opening an X11 connection
- o fixes possible out of bounds read when ecdh host keys
- o fixes possible hang when trying to read a disconnected socket
- o fixes a crash when using the delayed compression option
- o fixes read error with large known host entries
- o fixes various warnings
- o fixes various small memory leaks
- o improved error handling, various detailed errors will now be reported
- o builds are now using OSS-Fuzz
- o builds now use autoreconf instead of a custom build script
- o cmake now respects install directory
- o improved CI backend
- o updated HACKING-CRYPTO documentation
- o use markdown file extensions
- o improved unit tests
+- autotools: fix to update `LDFLAGS` for each detected dependency (d19b6190 #1384 #1381 #1377)
+- autotools: delete `--disable-tests` option, fix CI tests (e051ae34 #1271 #715 revert: 7483edfa)
+- autotools: show the default for `hidden-symbols` option (a3f5594a #1269)
+- autotools: enable `-Wunused-macros` with gcc (ecdf5199 #1262 #1227 #1224)
+- autotools: fix dotless gcc and Apple clang version detections (89ccc83c #1232 #1187)
+- autotools: show more clang/gcc version details (fb580161 #1230)
+- autotools: avoid warnings in libtool stub code (96682bd5 #1227 #1224)
+- autotools: sync warning enabler code with curl (5996fefe #1223)
+- autotools: rename variable (ce5f208a #1222)
+- autotools: picky warning options tidy-up (cdca8cff #1221)
+- autotools: fix `cp` to preserve attributes and timestamp in `Makefile.am` (f64e6318)
+- autotools: fix selecting WinCNG in cross-builds (and more) (00a3b88c #1187 #1186)
+- autotools: use comma separator in `Requires.private` of `libssh2.pc` (7f83de14 #1124)
+- autotools: remove `AB_INIT` from `configure.ac` (f4f52ccc)
+- autotools: improve libz position (c89174a7 #1077 #941 #1075 #1013 regr: 4f0f4bff)
+- autotools: skip tests requiring static lib if `--disable-static` (572c57c9 #1072 #663 #1056 regr: 83853f8a)
+- build: stop detecting `sys/param.h` header (2677d3b0 #1418 #1415)
+- build: silence warnings inside `FD_SET()`/`FD_ISSET()` macros (323a14b2 #1379)
+- build: drop `-Wformat-nonliteral` warning suppressions (c452c5cc #1342)
+- build: enable `-pedantic-errors` (3ec53f3e #1286)
+- build: add mingw-w64 support to `LIBSSH2_PRINTF()` attribute (f8c45794 #1287)
+- build: add `LIBSSH2_NO_DEPRECATED` option (b1414503 #1267 #1266 #1260 #1259)
+- build: enable missing OpenSSF-recommended warnings, with fixes (afa6b865 #1257)
+- build: enable more compiler warnings and fix them (7ecc309c #1224)
+- build: picky warning updates (328a96b3 #1219)
+- build: revert: respect autotools `DLL_EXPORT` in `libssh2.h` (481be044 #1141 #917 revert: fb1195cf)
+- build: stop requiring libssl from openssl (c84745e3 #1128)
+- build: tidy-up `libssh2.pc.in` variable names (5720dd9f #1125)
+- build: add/fix `Requires.private` packages in `libssh2.pc` (ef538069 #1123)
+- buildconf: drop (814a850c #1441 follow: fc5d7788)
+- checksrc: update, check all sources, fix fallouts (1117b677 #1457)
+- checksrc: sync with curl (8cd473c9 #1272)
+- checksrc: fix spelling in comment (a95d401f)
+- checksrc: modernise Perl file open (3d309f9b)
+- checksrc: switch to dot file (d67a91aa #1052)
+- ci: use Ninja with cmake (20ad047d #1458)
+- ci: disable dependency tracking in autotools builds (e44f0418 #1396)
+- ci: fix mbedtls runners on macOS (84411539 #1381)
+- ci: enable Unity mode for most CMake builds (1bfae57b #1367 #1034)
+- ci: add shellcheck job and script (d88b9bcd)
+- ci: verify build and install from tarball (a86e27e8 #1362)
+- ci: add reproducibility test for `maketgz` (2d765e45 #1360)
+- ci: use Linux runner for BSDs, add arm64 FreeBSD 14 job (6f86b196 #1343)
+- ci: do not parallelize `distcheck` job (5e65dd87 #1339)
+- ci: add FreeBSD 14 job, fix issues (46333adf #1277)
+- ci: add OmniOS job, fix issues (5e0ec991)
+- ci: show compiler in cross/cygwin job names (c9124088)
+- ci: add OpenBSD (v7.4) job + fix build error in example (0c9a8e35 #1250)
+- ci: add NetBSD (v9.3) job (65c7a7a5)
+- ci: update and speed up FreeBSD job (eee4e805)
+- ci: use absolute path in `CMAKE_INSTALL_PREFIX` (74948816 #1247)
+- ci: boost mbedTLS build speed (236e79a1 #1245)
+- ci: add BoringSSL job (cmake, gcc, amd64) (c9dd3566 #1233)
+- ci: fixup FreeBSD version, bump mbedTLS (fea6664e #1217)
+- ci: add FreeBSD 13.2 job (a7d2a573 #1215)
+- ci: mbedTLS 3.5.0 (5e190442 #1202)
+- ci: update actions, use shallow clones with appveyor (d468a33f #1199)
+- ci: replace `mv` + `chmod` with `install` in `Dockerfile` (5754fed6 #1175)
+- ci: set file mode early in `appveyor_docker.yml` (633db55f)
+- ci: add spellcheck (codespell) (a79218d3)
+- ci: add MSYS builds (autotools and cmake) (d43b8d9b #1162)
+- ci: add Cygwin builds (autotools and cmake) (f1e96e73 #1161)
+- ci: add mingw-w64 UWP build (1215aa5f #1155 #1147)
+- ci: add missing timeout to 'autotools distcheck' step (6265ffdb)
+- ci: add non-static autotools i386 build, ignore GHA updates on AppVeyor (c6e137f7 #1074 #1072)
+- ci: prefer `=` operator in shell snippets (e5c03043 #1073)
+- ci: drop redundant/unused vars, sync var names (ab8e95bc #1059)
+- ci: add i386 Linux build (with mbedTLS) (abdf40c7 #1057 #1053)
+- ci/appveyor: reduce test runs (workaround for infrastructure permafails) (b5e68bdc #1461)
+- ci/appveyor: increase wait for SSH server on GHA (bf3af90b)
+- ci/appveyor: bump to OpenSSL 3.2.1 (53d9c1a6 #1363 #1348)
+- ci/appveyor: re-enable parallel mode (e190e5b2 #1294 #884 #867)
+- ci/appveyor: delete UWP job broken since Visual Studio upgrade (d0a7f1da #1275)
+- ci/appveyor: YAML/PowerShell formatting, shorten variable name (06fd721f #1200)
+- ci/appveyor: move to pure PowerShell (8a081fd9 #1197)
+- ci/GHA: revert concurrency and improve permissions (e4c042f6)
+- ci/GHA: FreeBSD 14.1, actions bump (ae04b1b9 #1424)
+- ci/GHA: fix wolfSSL-from-source AES-GCM tests (1c0b07a7 #1409 #1408)
+- ci/GHA: add Linux job with latest wolfSSL built from source (d4cea53f #1408 #1299 #1020)
+- ci/GHA: tidy up build-from-source steps (2c633033)
+- ci/GHA: show configure logs on failure and other tidy-ups (dab48398 #1403)
+- ci/GHA: bump parallel jobs to nproc+1 (6f3d3bc8 #1402)
+- ci/GHA: show test logs on failure (b8ffa7a5 #1401)
+- ci/GHA: fix `Dockerfile` failing after Ubuntu package update (839bb84e #1400)
+- ci/GHA: use ubuntu-latest with OmniOS job (50143d58)
+- ci/GHA: shell syntax tidy-up (3b23e039 #1390)
+- ci/GHA: bump NetBSD/OpenBSD, add NetBSD arm64 job (e980af72 #1388)
+- ci/GHA: tidy up wolfSSL autotools config on macOS (5953c1f1 #1383)
+- ci/GHA: shorter mbedTLS autotools workaround (736e3d7d #1382 #1381)
+- ci/GHA: fix gcrypt with autotools/macOS/Homebrew/ARM64 (ae2770de #1377)
+- ci/GHA: fix verbose option for autotools jobs (499b27ae #1376)
+- ci/GHA: dump `config.log` on failure for macOS autotools jobs (4fa69214 #1375)
+- ci/GHA: fix `autoreconf` failure on macOS/Homebrew (0b64b30b #1374)
+- ci/GHA: fixup Homebrew location (for ARM runners) (6128aee0 #1373)
+- ci/GHA: review/fixup auto-cancel settings (b08cfbc9 #1292)
+- ci/GHA: restore curly braces in `if` (36748270 #1145)
+- ci/GHA: simplify `if` strings (cab3db58 #1140)
+- cmake: sync and improve Find modules, add `pkg-config` native detection (45064137 #1445 #1420)
+- cmake: generate `LIBSSH2_PC_LIBS_PRIVATE` dynamically (c87f1296 #1466)
+- cmake: add comment about `ibssh2.pc.in` variables (14b1b9d0)
+- cmake: support absolute `CMAKE_INSTALL_INCLUDEDIR`/`CMAKE_INSTALL_LIBDIR` (d70cee36 #1465)
+- cmake: rename two variables and initialize them (0fce9dcc #1464)
+- cmake: prefer `find_dependency()` in `libssh2-config.cmake` (d9c2e550 #1460)
+- cmake: tidy up syntax, minor improvements (9d9ee780 #1446)
+- cmake: rename mbedTLS and wolfSSL Find modules (570de0f2)
+- cmake: fixup version detection in mbedTLS Find module (8e3c40b2 #1444)
+- cmake: mbedTLS detection tidy-ups (6d1d13c2 #1438)
+- cmake: add quotes, delete ending dirseps (2bb46d44 #1437 #1166)
+- cmake: sync formatting in `cmake/Find*` modules (a0310699)
+- cmake: tidy up function name casing in `CopyRuntimeDependencies.cmake` (03547cb8)
+- cmake: use the imported target of FindOpenSSL module (82b09f9b #1322)
+- cmake: rename picky warnings script (64d6789f #1225)
+- cmake: fix multiple include of libssh2 package (932d6a32 #1216)
+- cmake: show crypto backend in feature summary (20387285 #1211)
+- cmake: simplify showing CMake version (fc00bdd7 #1203)
+- cmake: cleanup mbedTLS version detection more (4c241d5c #1196 #1192)
+- cmake: delete duplicate `include()` (30eef0a6)
+- cmake: improve/fix mbedTLS detection (41594675 #1192 #1191)
+- cmake: tidy-up `foreach()` syntax (4a64ca14 #1180)
+- cmake: verify `libssh2_VERSION` in integration tests (a20572e9)
+- cmake: show cmake versions in ci (87f5769b)
+- cmake: quote more strings (e9c7d3af #1173)
+- cmake: add `ExternalProject` integration test (aeaefaf6 #1171)
+- cmake: add integration tests (8715c3d5 #1170)
+- cmake: (re-)add aliases for `add_subdirectory()` builds (4ff64ae3 #1169)
+- cmake: style tidy-up (3fa5282d #1166)
+- cmake: add `LIB_NAME` variable (5453fc80 #1159)
+- cmake: tidy-up concatenation in `CMAKE_MODULE_PATH` (ae7d5108 #1157)
+- cmake: replace `libssh2` literals with `PROJECT_NAME` variable (72fd2595 #1152)
+- cmake: fix `STREQUAL` check in error branch (42d3bf13 #1151)
+- cmake: cache more config values on Windows (11a03690 #1142)
+- cmake: streamline invocation (f58f77b5 #1138)
+- cmake: merge `set_target_properties()` calls (a9091007 #1132)
+- cmake: (re-)add zlib to `Libs.private` in `libssh2.pc` (64643018 #1131)
+- cmake: use `wolfssl/options.h` for detection, like autotools (c5ec6c49 #1130)
+- cmake: add openssl libs to `Libs.private` in `libssh2.pc` (5cfa59d3 #1127)
+- cmake: bump minimum CMake version to v3.7.0 (9cd18f45 #1126)
+- cmake: CMAKE_SOURCE_DIR -> PROJECT_SOURCE_DIR (0f396aa9 #1121)
+- cmake: tidy-ups (2fc36790 #1122)
+- cmake: re-add `Libssh2:libssh2` for compatibility + lowercase namespace (2da13c13 #1104 #731 #1103)
+- copyright: remove years from copyright headers (187d89bb #1082)
+- disable DSA by default (b7ab0faa #1435 #1433)
+- docs: update `INSTALL_AUTOTOOLS` (2f0efde3 #1316)
+- docs: replace SHA1 with SHA256 in CMake example (766bde9f)
+- example: restore `sys/time.h` for AIX (24503cb9 #1340 #1335 #1334 #1001 regr: e53aae0e)
+- example: use `libssh2_socket_t` in X11 example (3f60ccb7)
+- example: replace remaining libssh2_scp_recv with libssh2_scp_recv2 in output messages (8d69e63d #1258 follow: 6c84a426)
+- example: fix regression in `ssh2_exec.c` (279a2e57 #1106 #861 #846 #1105 regr: b13936bd)
+- example, tests: call `WSACleanup()` for each `WSAStartup()` (94b6bad3 #1283)
+- example, tests: fix/silence `-Wformat-truncation=2` gcc warnings (744e059f)
+- hostkey: do not advertise ssh-rsa when SHA1 is disabled (82d1b8ff #1093 #1092)
+- kex: prevent possible double free of hostkey (b3465418 #1452)
+- kex: always check for null pointers before calling _libssh2_bn_set_word (9f23a3bb #1423)
+- kex: fix a memory leak in key exchange (19101843 #1412 #1404)
+- kex: always add extension indicators to kex_algorithms (00e2a07e #1327 #1326)
+- libssh2.h: add deprecated function warnings (9839ebe5 #1289 #1260)
+- libssh2.h: add portable `LIBSSH2_SOCKET_CLOSE()` macro (28dbf016 #1278)
+- libssh2.h: use `_WIN32` for Windows detection instead of rolling our own (631e7734 #1238)
+- libssh2.pc: reference mbedcrypto pkgconfig (c149a127 #1405)
+- libssh2.pc: re-add & extend support for static-only libssh2 builds (624abe27 #1119 #1114)
+- libssh2.pc: don't put `@LIBS@` in pc file (1209c16d)
+- mac: add empty hash functions for `mac_method_hmac_aesgcm` to not crash when e.g. setting `LIBSSH2_METHOD_CRYPT_CS` (b2738391 #1321)
+- mac: handle low-level errors (f64885b6 #1297)
+- Makefile.mk: delete Windows-focused raw GNU Make build (43485579 #1204)
+- maketgz: reproducible tarballs/zip, display tarball hashes (d52fe1b4 #1357 #1359)
+- maketgz: `set -eu`, reproducibility, improve zip, add CI test (cba7f975 #1353)
+- man: improve `libssh2_userauth_publickey_from*` manpages (581b72aa #1347 #1308 #652)
+- man: fix double spaces and dash escaping (a3ffc422 #1210)
+- man: add description to `libssh2_session_get_blocking.3` (67e39091 #1185)
+- mbedtls: always init ECDSA mbedtls_pk_context (a50d7deb #1430)
+- mbedtls: correctly initialize values (ECDSA) (1701d5c0 #1428 #1421)
+- mbedtls: expose `mbedtls_pk_load_file()` for our use (1628f6ca #1421 #1393 #1349 follow: e973493f)
+- mbedtls: add workaround + FIXME to build with 3.6.0 (2e4c5ec4 #1349)
+- mbedtls: improve disabling `-Wredundant-decls` (ecec68a2 #1226 #1224)
+- mbedtls: include `version.h` for `MBEDTLS_VERSION_NUMBER` (9d7bc253 #1095 #1094)
+- mbedtls: use more `size_t` to sync up with `crypto.h` (1153ebde #1054 #879 #846 #1053)
+- md5: allow disabling old-style encrypted private keys at build-time (eb9f9de2 #1181)
+- mingw: fix printf mask for 64-bit integers (36c1e1d1 #1091 #876 #846 #1090)
+- misc: flatten `_libssh2_explicit_zero` if tree (74e74288 #1149)
+- NMakefile: delete (c515eed3 #1134 #1129)
+- openssl: free allocated resources when using openssl3 (b942bad1 #1459)
+- openssl: fix memory leaks in `_libssh2_ecdsa_curve_name_with_octal_new` and `_libssh2_ecdsa_verify` (8d3bc19b #1449)
+- openssl: fix calculating DSA public key with OpenSSL 3 (8b3c6e9d #1380)
+- openssl: initialize BIGNUMs to NULL in `gen_publickey_from_dsa` for OpenSSL 3 (f1133c75 #1320)
+- openssl: fix cppcheck found NULL dereferences (f2945905 #1304)
+- openssl: delete internal `read_openssh_private_key_from_memory()` (34aff5ff #1306)
+- openssl: use OpenSSL 3 HMAC API, add `no-deprecated` CI job (363dcbf4 #1243 #1235 #1207)
+- openssl: make a function static, add `#ifdef` comments (efee9133 #1246 #248 follow: 03092292)
+- openssl: fix DSA code to use OpenSSL 3 API (82581941 #1244 #1207)
+- openssl: fix `EC_KEY` reference with OpenSSL 3 `no-deprecated` build (487152f4 #1236 #1235 #1207)
+- openssl: use non-deprecated APIs with OpenSSL 3.x (b0ab005f #1207)
+- openssl: silence `-Wunused-value` warnings (bf285500 #1205)
+- openssl: use automatic initialization with LibreSSL 2.7.0+ (d79047c9 #1146 #302)
+- openssl: add missing check for `LIBRESSL_VERSION_NUMBER` before use (4a42f42e #1117 #1115)
+- os400: drop vsprintf() use (40e817ff #1462 #1457)
+- os400: Add two recent files to the distribution (e4c65e5b #1364)
+- os400: fix shellcheck warnings in scripts (fixups) (81341e1e #1366 #1364 #1358)
+- os400: fix shellcheck warnings in scripts (c6625707 #1358)
+- os400: maintain up to date (8457c37a #1309)
+- packet: properly bounds check packet_authagent_open() (88a960a8 #1179)
+- pem: fix private keys encrypted with AES-GCM methods (e87bdefa #1133)
+- reuse: upgrade to `REUSE.toml` (70b8bf31 #1419)
+- reuse: fix duplicate copyright warning (b9a4ed83)
+- reuse: comply with 3.1 spec and 2.0.0 checker (fe6239a1 #1102 #1101 #1098)
+- reuse: provide SPDX identifiers (f6aa31f4 #1084)
+- scp: fix missing cast for targets without large file support (c317e06f #1060 #1057 #1002 regr: 5db836b2)
+- session: support server banners up to 8192 bytes (was: 256) (1a9e8811 #1443 #1442)
+- session: add `libssh2_session_callback_set2()` (c0f69548 #1285)
+- session: handle EINTR from send/recv/poll/select to try again as the error is not fatal (798ed4a7 #1058 #955)
+- sftp: increase SFTP_HANDLE_MAXLEN back to 4092 (75de6a37 #1422)
+- sftp: implement posix-rename@openssh.com (fb652746 #1386)
+- src: implement chacha20-poly1305@openssh.com (492bc543 #1426 #584)
+- src: use `UINT32_MAX` (dc206408 #1413)
+- src: fix type warning in `libssh2_sftp_unlink` macro (ac2e8c73 #1406)
+- src: check the return value from `_libssh2_bn_*()` functions (95c824d5 #1354)
+- src: support RSA-SHA2 cert-based authentication (rsa-sha2-512_cert and rsa-sha2-256_cert) (3a6ab70d #1314)
+- src: check hash update/final success (4718ede4 #1303 #1301)
+- src: check hash init success (2ed9eb92 #1301)
+- src: add 'strict KEX' to fix CVE-2023-48795 "Terrapin Attack" (d34d9258 #1291 #1290)
+- src: disable `-Wsign-conversion` warnings, add option to re-enable (6e451669 #1284 #1257)
+- src: fix gcc 13 `-Wconversion` warning on Darwin (8cca7b77 #1209 follow: 08354e0a)
+- src: drop a redundant `#include` (1f0174d0 #1153)
+- src: improve MSVC C4701 warning fix (8b924999 #1086 #876 #1083)
+- src: bump `hash_len` to `size_t` in `LIBSSH2_HOSTKEY_METHOD` (8b917d76 #1076)
+- src: bump DSA and ECDSA sign `hash_len` to `size_t` (7b8e0225 #1055)
+- tests: avoid using `MAXPATHLEN`, for portability (12427f4f #1415 #198 #1414)
+- tests: fix excluding AES-GCM tests (fbd9d192 #1410)
+- tests: drop default cygpath option `-u` (38e50aa0)
+- tests: fix shellcheck issues in `test_sshd.test` (a2ac8c55)
+- tests: sync port number type with the rest of codebase (eb996af8)
+- tests: fall back to `$LOGNAME` for username (5326a5ce #1241 #1240)
+- tests: show cmake version used in integration tests (2cd2f40e #1201)
+- tests: formatting and tidy-ups (e61987a3)
+- tests: replace FIXME with comments (1a99a86a)
+- tests: add aes256-gcm encrypted key test (802336cf #1135 #1133)
+- tests: trap signals in scripts (b2916b28 #1098)
+- tests: cast to avoid `-Wchar-subscripts` with Cygwin (43df6a46 #1081 #1080)
+- test_read: make it run without Docker (57e9d18e #1139)
+- test_sshd.test: show sshd and test connect logs on harness failure (299c2040 #1097)
+- test_sshd.test: set a safe PID directory (e8cabdcf #1089)
+- test_sshd.test: minor cleanups (d29eea1d)
+- tidy-up: link updates (c905bfd2 #1434)
+- tidy-up: typo in comment (792e1b6f)
+- tidy-up: fix typo found by codespell (706ec36d)
+- tidy-up: bump casts from int to long for large C99 types in printfs (2e5a8719 #1264 #1257)
+- tidy-up: `unsigned` -> `unsigned int` (b136c379)
+- tidy-up: stop using leading underscores in macro names (c6589b88 #1248)
+- tidy-up: around `stdint.h` (bfa00f1b #1212)
+- tidy-up: fix typo in `readme.vms` (a9a79e7a)
+- tidy-up: use built-in `_WIN32` macro to detect Windows (6fbc9505 #1195)
+- tidy-up: drop `www.` from `www.libssh2.org` (6e3e8839 #1172)
+- tidy-up: delete duplicate word from comment (76307435)
+- tidy-up: avoid exclamations, prefer single quotes, in outputs (003fb454 #1079)
+- TODO: disable or drop weak algos (0b4bdc85 #1261)
+- transport: fix unstable connections over non-blocking sockets (de004875 #1454 #720 #1431 #1397)
+- transport: check ETM on remote end when receiving (bde10825 #1332 #1331)
+- transport: fix incorrect byte offset in debug message (2388a3aa #1096)
+- userauth: avoid oob with huge interactive kbd response (f3a85cad #1337)
+- userauth: add a new structure to separate memory read and file read (63b4c20e #773)
+- userauth: check whether `*key_method` is a NULL pointer instead of `key_method` (bec57c40)
+- wincng: fix `DH_GEX_MAXGROUP` set higher than supported (48584671 #1372 #493)
+- wincng: add to ci/GHA, add `./configure` option `--enable-ecdsa-wincng` (3f98bfb0 #1368 #1315)
+- wincng: add ECDSA support for host and user authentication (3e723437 #1315)
+- wincng: prefer `ULONG`/`DWORD` over `unsigned long` (186c1d63 #1165)
+- wincng: tidy-ups (7bb669b5 #1164)
+- wolfssl: drop header path hack (8ae1b2d7 #1439)
+- wolfssl: fix `EVP_Cipher()` use with v5.6.0 and older (a5b0fac2 #1407 #1394 #797 #1299 #1020)
+- wolfssl: bump version in upstream issue comment (5cab802c)
+- wolfssl: require v5.4.0 for AES-GCM (260a721c #1411 #1299 #1020)
+- wolfssl: enable debug logging in wolfSSL when compiled in (76e7a68a #1310)
 
 This release would not have looked like this without help, code, reports and
 advice from friends like these:
 
-  katzer, Orgad Shaneh, mark-i-m, Zenju, axjowa, Thilo Schulz,
-  Etienne Samson, hlefebvre, seba30, Panos, jethrogb, Fabrice Fontaine,
-  Will Cosgrove, Daniel Stenberg, Michael Buckley, Wallace Souza Silva,
-  Romain-Geissler-1A, meierha, Tseng Jun, Thomas Klausner, Brendan Shanks,
-  Harry Sintonen, monnerat, Koutheir Attouchi, Marc Hörsken, yann-morin-1998,
-  Wez Furlong, TDi-jonesds, David Benjamin, Max Dymond, Igor Klevanets,
-  Viktor Szakats, Laurent Stacul, Mstrodl, Gabriel Smith, MarcT512,
-  Paul Capron, teottin, Tor Erik Ottinsen, Brian Inglis
-
-  (40 contributors)
+  Viktor Szakats, Michael Buckley, Patrick Monnerat, Ren Mingshuai,
+  Will Cosgrove, Daniel Stenberg, Josef Cejka, Nicolas Mora, Ryan Kelley,
+  Aaron Stone, Adam, Anders Borum, András Fekete, Andrei Augustin, binary1248,
+  Brian Inglis, brucsc on GitHub, concussious on github, Dan Fandrich,
+  dksslq on github, Haowei Hsu, Harmen Stoppels, Harry Mallon, Jack L,
+  Jakob Egger, Jiwoo Park, João M. S. Silva, Joel Depooter, Johannes Passing,
+  Jose Quaresma, Juliusz Sosinowicz, Kai Pastor, Kenneth Davidson,
+  klux21 on github, Lyndon Brown, Marc Hoersken, mike-jumper, naddy,
+  Nursan Valeyev, Paul Howarth, PewPewPew, Radek Brich, rahmanih on github,
+  rolag on github, Seo Suchan, shubhamhii on github, Steve McIntyre,
+  Tejaswi Kandula, Tobias Stoeckmann, Trzik, Xi Ruoyao
diff --git a/libssh2/acinclude.m4 b/libssh2/acinclude.m4
index 2066f0ec..e06476fd 100644
--- a/libssh2/acinclude.m4
+++ b/libssh2/acinclude.m4
@@ -1,3 +1,134 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+dnl CURL_CPP_P
+dnl
+dnl Check if $cpp -P should be used for extract define values due to gcc 5
+dnl splitting up strings and defines between line outputs. gcc by default
+dnl (without -P) will show TEST EINVAL TEST as
+dnl
+dnl # 13 "conftest.c"
+dnl TEST
+dnl # 13 "conftest.c" 3 4
+dnl     22
+dnl # 13 "conftest.c"
+dnl            TEST
+
+AC_DEFUN([CURL_CPP_P], [
+  AC_MSG_CHECKING([if cpp -P is needed])
+  AC_EGREP_CPP([TEST.*TEST], [
+ #include <errno.h>
+TEST EINVAL TEST
+  ], [cpp=no], [cpp=yes])
+  AC_MSG_RESULT([$cpp])
+
+  dnl we need cpp -P so check if it works then
+  if test "x$cpp" = "xyes"; then
+    AC_MSG_CHECKING([if cpp -P works])
+    OLDCPPFLAGS=$CPPFLAGS
+    CPPFLAGS="$CPPFLAGS -P"
+    AC_EGREP_CPP([TEST.*TEST], [
+ #include <errno.h>
+TEST EINVAL TEST
+    ], [cpp_p=yes], [cpp_p=no])
+    AC_MSG_RESULT([$cpp_p])
+
+    if test "x$cpp_p" = "xno"; then
+      AC_MSG_WARN([failed to figure out cpp -P alternative])
+      # without -P
+      CPPPFLAG=""
+    else
+      # with -P
+      CPPPFLAG="-P"
+    fi
+    dnl restore CPPFLAGS
+    CPPFLAGS=$OLDCPPFLAGS
+  else
+    # without -P
+    CPPPFLAG=""
+  fi
+])
+
+dnl CURL_CHECK_DEF (SYMBOL, [INCLUDES], [SILENT])
+dnl -------------------------------------------------
+dnl Use the C preprocessor to find out if the given object-style symbol
+dnl is defined and get its expansion. This macro will not use default
+dnl includes even if no INCLUDES argument is given. This macro will run
+dnl silently when invoked with three arguments. If the expansion would
+dnl result in a set of double-quoted strings the returned expansion will
+dnl actually be a single double-quoted string concatenating all them.
+
+AC_DEFUN([CURL_CHECK_DEF], [
+  AC_REQUIRE([CURL_CPP_P])dnl
+  OLDCPPFLAGS=$CPPFLAGS
+  # CPPPFLAG comes from CURL_CPP_P
+  CPPFLAGS="$CPPFLAGS $CPPPFLAG"
+  AS_VAR_PUSHDEF([ac_HaveDef], [curl_cv_have_def_$1])dnl
+  AS_VAR_PUSHDEF([ac_Def], [curl_cv_def_$1])dnl
+  if test -z "$SED"; then
+    AC_MSG_ERROR([SED not set. Cannot continue without SED being set.])
+  fi
+  if test -z "$GREP"; then
+    AC_MSG_ERROR([GREP not set. Cannot continue without GREP being set.])
+  fi
+  ifelse($3,,[AC_MSG_CHECKING([for preprocessor definition of $1])])
+  tmp_exp=""
+  AC_PREPROC_IFELSE([
+    AC_LANG_SOURCE(
+ifelse($2,,,[$2])[[
+#ifdef $1
+CURL_DEF_TOKEN $1
+#endif
+    ]])
+  ],[
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[[ ]][[ ]]*//' 2>/dev/null | \
+      "$SED" 's/[["]][[ ]]*[["]]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "$1"; then
+      tmp_exp=""
+    fi
+  ])
+  if test -z "$tmp_exp"; then
+    AS_VAR_SET(ac_HaveDef, no)
+    ifelse($3,,[AC_MSG_RESULT([no])])
+  else
+    AS_VAR_SET(ac_HaveDef, yes)
+    AS_VAR_SET(ac_Def, $tmp_exp)
+    ifelse($3,,[AC_MSG_RESULT([$tmp_exp])])
+  fi
+  AS_VAR_POPDEF([ac_Def])dnl
+  AS_VAR_POPDEF([ac_HaveDef])dnl
+  CPPFLAGS=$OLDCPPFLAGS
+])
+
+dnl CURL_CHECK_COMPILER_CLANG
+dnl -------------------------------------------------
+dnl Verify if compiler being used is clang.
+
+AC_DEFUN([CURL_CHECK_COMPILER_CLANG], [
+  AC_BEFORE([$0],[CURL_CHECK_COMPILER_GNU_C])dnl
+  AC_MSG_CHECKING([if compiler is clang])
+  CURL_CHECK_DEF([__clang__], [], [silent])
+  if test "$curl_cv_have_def___clang__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_MSG_CHECKING([if compiler is xlclang])
+    CURL_CHECK_DEF([__ibmxl__], [], [silent])
+    if test "$curl_cv_have_def___ibmxl__" = "yes" ; then
+      dnl IBM's almost-compatible clang version
+      AC_MSG_RESULT([yes])
+      compiler_id="XLCLANG"
+    else
+      AC_MSG_RESULT([no])
+      compiler_id="CLANG"
+    fi
+    flags_dbg_yes="-g"
+    flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
 
 dnl **********************************************************************
 dnl CURL_DETECT_ICC ([ACTION-IF-YES])
@@ -7,146 +138,490 @@ dnl sets the $ICC variable to "yes" or "no"
 dnl **********************************************************************
 AC_DEFUN([CURL_DETECT_ICC],
 [
-    ICC="no"
-    AC_MSG_CHECKING([for icc in use])
-    if test "$GCC" = "yes"; then
-       dnl check if this is icc acting as gcc in disguise
-       AC_EGREP_CPP([^__INTEL_COMPILER], [__INTEL_COMPILER],
-         dnl action if the text is found, this it has not been replaced by the
-         dnl cpp
-         ICC="no",
-         dnl the text was not found, it was replaced by the cpp
-         ICC="yes"
-         AC_MSG_RESULT([yes])
-         [$1]
-       )
-    fi
-    if test "$ICC" = "no"; then
-        # this is not ICC
-        AC_MSG_RESULT([no])
-    fi
+  ICC="no"
+  AC_MSG_CHECKING([for icc in use])
+  if test "$GCC" = "yes"; then
+    dnl check if this is icc acting as gcc in disguise
+    AC_EGREP_CPP([^__INTEL_COMPILER], [__INTEL_COMPILER],
+      dnl action if the text is found, this it has not been replaced by the
+      dnl cpp
+      ICC="no",
+      dnl the text was not found, it was replaced by the cpp
+      ICC="yes"
+      AC_MSG_RESULT([yes])
+      [$1]
+    )
+  fi
+  if test "$ICC" = "no"; then
+    # this is not ICC
+    AC_MSG_RESULT([no])
+  fi
 ])
 
 dnl We create a function for detecting which compiler we use and then set as
-dnl pendantic compiler options as possible for that particular compiler. The
+dnl pedantic compiler options as possible for that particular compiler. The
 dnl options are only used for debug-builds.
 
 AC_DEFUN([CURL_CC_DEBUG_OPTS],
 [
-    if test "z$ICC" = "z"; then
-      CURL_DETECT_ICC
+  if test "z$CLANG" = "z"; then
+    CURL_CHECK_COMPILER_CLANG
+    if test "z$compiler_id" = "zCLANG"; then
+      CLANG="yes"
+    else
+      CLANG="no"
     fi
+  fi
+  if test "z$ICC" = "z"; then
+    CURL_DETECT_ICC
+  fi
 
-    if test "$GCC" = "yes"; then
-
-       dnl figure out gcc version!
-       AC_MSG_CHECKING([gcc version])
-       gccver=`$CC -dumpversion`
-       num1=`echo $gccver | cut -d . -f1`
-       num2=`echo $gccver | cut -d . -f2`
-       gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`
-       AC_MSG_RESULT($gccver)
-
-       if test "$ICC" = "yes"; then
-         dnl this is icc, not gcc.
-
-         dnl ICC warnings we ignore:
-         dnl * 269 warns on our "%Od" printf formatters for curl_off_t output:
-         dnl   "invalid format string conversion"
-         dnl * 279 warns on static conditions in while expressions
-         dnl * 981 warns on "operands are evaluated in unspecified order"
-         dnl * 1418 "external definition with no prior declaration"
-         dnl * 1419 warns on "external declaration in primary source file"
-         dnl   which we know and do on purpose.
-
-         WARN="-wd279,269,981,1418,1419"
-
-         if test "$gccnum" -gt "600"; then
-            dnl icc 6.0 and older doesn't have the -Wall flag
-            WARN="-Wall $WARN"
-         fi
-       else dnl $ICC = yes
-         dnl this is a set of options we believe *ALL* gcc versions support:
-         WARN="-W -Wall -Wwrite-strings -pedantic -Wpointer-arith -Wnested-externs -Winline -Wmissing-prototypes"
-
-         dnl -Wcast-align is a bit too annoying on all gcc versions ;-)
-
-         if test "$gccnum" -ge "207"; then
-           dnl gcc 2.7 or later
-           WARN="$WARN -Wmissing-declarations"
-         fi
-
-         if test "$gccnum" -gt "295"; then
-           dnl only if the compiler is newer than 2.95 since we got lots of
-           dnl "`_POSIX_C_SOURCE' is not defined" in system headers with
-           dnl gcc 2.95.4 on FreeBSD 4.9!
-           WARN="$WARN -Wundef -Wno-long-long -Wsign-compare"
-         fi
-
-         if test "$gccnum" -ge "296"; then
-           dnl gcc 2.96 or later
-           WARN="$WARN -Wfloat-equal"
-         fi
-
-         if test "$gccnum" -gt "296"; then
-           dnl this option does not exist in 2.96
-           WARN="$WARN -Wno-format-nonliteral"
-         fi
-
-         dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
-         dnl on i686-Linux as it gives us heaps with false positives.
-         dnl Also, on gcc 4.0.X it is totally unbearable and complains all
-         dnl over making it unusable for generic purposes. Let's not use it.
-
-         if test "$gccnum" -ge "303"; then
-           dnl gcc 3.3 and later
-           WARN="$WARN -Wendif-labels -Wstrict-prototypes"
-         fi
-
-         if test "$gccnum" -ge "304"; then
-           # try these on gcc 3.4
-           WARN="$WARN -Wdeclaration-after-statement"
-         fi
-
-         for flag in $CPPFLAGS; do
-           case "$flag" in
-            -I*)
-              dnl Include path, provide a -isystem option for the same dir
-              dnl to prevent warnings in those dirs. The -isystem was not very
-              dnl reliable on earlier gcc versions.
-              add=`echo $flag | sed 's/^-I/-isystem /g'`
-              WARN="$WARN $add"
+  if test "$CLANG" = "yes"; then
+
+          # indentation to match curl's m4/curl-compilers.m4
+
+          dnl figure out clang version!
+          AC_MSG_CHECKING([compiler version])
+          fullclangver=`$CC -v 2>&1 | grep version`
+          if echo $fullclangver | grep 'Apple' >/dev/null; then
+            appleclang=1
+          else
+            appleclang=0
+          fi
+          clangver=`echo $fullclangver | grep "based on LLVM " | "$SED" 's/.*(based on LLVM \(@<:@0-9@:>@*\.@<:@0-9@:>@*\).*)/\1/'`
+          if test -z "$clangver"; then
+            clangver=`echo $fullclangver | "$SED" 's/.*version \(@<:@0-9@:>@*\.@<:@0-9@:>@*\).*/\1/'`
+            oldapple=0
+          else
+            oldapple=1
+          fi
+          clangvhi=`echo $clangver | cut -d . -f1`
+          clangvlo=`echo $clangver | cut -d . -f2`
+          compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
+          if test "$appleclang" = '1' && test "$oldapple" = '0'; then
+            dnl Starting with Xcode 7 / clang 3.7, Apple clang won't tell its upstream version
+            if   test "$compiler_num" -ge '1300'; then compiler_num='1200'
+            elif test "$compiler_num" -ge '1205'; then compiler_num='1101'
+            elif test "$compiler_num" -ge '1204'; then compiler_num='1000'
+            elif test "$compiler_num" -ge '1107'; then compiler_num='900'
+            elif test "$compiler_num" -ge '1103'; then compiler_num='800'
+            elif test "$compiler_num" -ge '1003'; then compiler_num='700'
+            elif test "$compiler_num" -ge '1001'; then compiler_num='600'
+            elif test "$compiler_num" -ge  '904'; then compiler_num='500'
+            elif test "$compiler_num" -ge  '902'; then compiler_num='400'
+            elif test "$compiler_num" -ge  '803'; then compiler_num='309'
+            elif test "$compiler_num" -ge  '703'; then compiler_num='308'
+            else                                       compiler_num='307'
+            fi
+          fi
+          AC_MSG_RESULT([clang '$compiler_num' (raw: '$fullclangver' / '$clangver')])
+
+          tmp_CFLAGS="-pedantic"
+          if test "$want_werror" = "yes"; then
+            LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -pedantic-errors"
+          fi
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [all extra])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [pointer-arith write-strings])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [shadow])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [inline nested-externs])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-declarations])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-prototypes])
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [float-equal])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [sign-compare])
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar"
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [undef])
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [endif-labels strict-prototypes])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [declaration-after-statement])
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [cast-align])
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [shorten-64-to-32])
+          #
+          dnl Only clang 1.1 or later
+          if test "$compiler_num" -ge "101"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused])
+          fi
+          #
+          dnl Only clang 2.7 or later
+          if test "$compiler_num" -ge "207"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [address])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [attributes])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [bad-function-cast])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [conversion])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [div-by-zero format-security])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [empty-body])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-field-initializers])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-noreturn])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [old-style-definition])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [redundant-decls])
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [switch-enum])       # Not used because this basically disallows default case
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [type-limits])
+            if test "x$have_windows_h" != "xyes"; then
+              CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused-macros])  # Seen to clash with libtool-generated stub code
+            fi
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unreachable-code unused-parameter])
+          fi
+          #
+          dnl Only clang 2.8 or later
+          if test "$compiler_num" -ge "208"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [ignored-qualifiers])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [vla])
+          fi
+          #
+          dnl Only clang 2.9 or later
+          if test "$compiler_num" -ge "209"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [sign-conversion])
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-error=sign-conversion"           # FIXME
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [shift-sign-overflow])
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [padded])  # Not used because we cannot change public structs
+          fi
+          #
+          dnl Only clang 3.0 or later
+          if test "$compiler_num" -ge "300"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [language-extension-token])
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat=2"
+          fi
+          #
+          dnl Only clang 3.2 or later
+          if test "$compiler_num" -ge "302"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [enum-conversion])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [sometimes-uninitialized])
+            case $host_os in
+            cygwin* | mingw*)
+              dnl skip missing-variable-declarations warnings for cygwin and
+              dnl mingw because the libtool wrapper executable causes them
               ;;
-           esac
-         done
-
-       fi dnl $ICC = no
-
-       CFLAGS="$CFLAGS $WARN"
-
-      AC_MSG_NOTICE([Added this set of compiler options: $WARN])
+            *)
+              CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-variable-declarations])
+              ;;
+            esac
+          fi
+          #
+          dnl Only clang 3.4 or later
+          if test "$compiler_num" -ge "304"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [header-guard])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused-const-variable])
+          fi
+          #
+          dnl Only clang 3.5 or later
+          if test "$compiler_num" -ge "305"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [pragmas])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unreachable-code-break])
+          fi
+          #
+          dnl Only clang 3.6 or later
+          if test "$compiler_num" -ge "306"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [double-promotion])
+          fi
+          #
+          dnl Only clang 3.9 or later
+          if test "$compiler_num" -ge "309"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [comma])
+            # avoid the varargs warning, fixed in 4.0
+            # https://bugs.llvm.org/show_bug.cgi?id=29140
+            if test "$compiler_num" -lt "400"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-varargs"
+            fi
+          fi
+          dnl clang 7 or later
+          if test "$compiler_num" -ge "700"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [assign-enum])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [extra-semi-stmt])
+          fi
+          dnl clang 10 or later
+          if test "$compiler_num" -ge "1000"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wimplicit-fallthrough"  # we have silencing markup for clang 10.0 and above only
+          fi
+
+          CFLAGS="$CFLAGS $tmp_CFLAGS"
+
+          AC_MSG_NOTICE([Added this set of compiler options: $tmp_CFLAGS])
+
+  elif test "$GCC" = "yes"; then
+
+        # indentation to match curl's m4/curl-compilers.m4
+
+        dnl figure out gcc version!
+        AC_MSG_CHECKING([compiler version])
+        # strip '-suffix' parts, e.g. Ubuntu Windows cross-gcc returns '10-win32'
+        gccver=`$CC -dumpversion | sed -E 's/-.+$//'`
+        gccvhi=`echo $gccver | cut -d . -f1`
+        if echo $gccver | grep -F "." >/dev/null; then
+          gccvlo=`echo $gccver | cut -d . -f2`
+        else
+          gccvlo="0"
+        fi
+        compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
+        AC_MSG_RESULT([gcc '$compiler_num' (raw: '$gccver')])
+
+        if test "$ICC" = "yes"; then
+          dnl this is icc, not gcc.
+
+          dnl ICC warnings we ignore:
+          dnl * 269 warns on our "%Od" printf formatters for curl_off_t output:
+          dnl   "invalid format string conversion"
+          dnl * 279 warns on static conditions in while expressions
+          dnl * 981 warns on "operands are evaluated in unspecified order"
+          dnl * 1418 "external definition with no prior declaration"
+          dnl * 1419 warns on "external declaration in primary source file"
+          dnl   which we know and do on purpose.
+
+          tmp_CFLAGS="-wd279,269,981,1418,1419"
+
+          if test "$compiler_num" -gt "600"; then
+             dnl icc 6.0 and older doesn't have the -Wall flag
+             tmp_CFLAGS="-Wall $tmp_CFLAGS"
+          fi
+        else dnl $ICC = yes
+          dnl this is a set of options we believe *ALL* gcc versions support:
+          tmp_CFLAGS="-pedantic"
+          if test "$want_werror" = "yes"; then
+            LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -pedantic-errors"
+          fi
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [all])
+          tmp_CFLAGS="$tmp_CFLAGS -W"
+          CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [pointer-arith write-strings])
+          #
+          dnl Only gcc 2.7 or later
+          if test "$compiler_num" -ge "207"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [inline nested-externs])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-declarations])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-prototypes])
+          fi
+          #
+          dnl Only gcc 2.95 or later
+          if test "$compiler_num" -ge "295"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [bad-function-cast])
+          fi
+          #
+          dnl Only gcc 2.96 or later
+          if test "$compiler_num" -ge "296"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [float-equal])
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar"
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [sign-compare])
+            dnl -Wundef used only if gcc is 2.96 or later since we get
+            dnl lots of "`_POSIX_C_SOURCE' is not defined" in system
+            dnl headers with gcc 2.95.4 on FreeBSD 4.9
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [undef])
+          fi
+          #
+          dnl Only gcc 2.97 or later
+          if test "$compiler_num" -ge "297"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          fi
+          #
+          dnl Only gcc 3.0 or later
+          if test "$compiler_num" -ge "300"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+            dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
+            dnl on i686-Linux as it gives us heaps with false positives.
+            dnl Also, on gcc 4.0.X it is totally unbearable and complains all
+            dnl over making it unusable for generic purposes. Let's not use it.
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused shadow])
+          fi
+          #
+          dnl Only gcc 3.3 or later
+          if test "$compiler_num" -ge "303"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [endif-labels strict-prototypes])
+          fi
+          #
+          dnl Only gcc 3.4 or later
+          if test "$compiler_num" -ge "304"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [declaration-after-statement])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [old-style-definition])
+          fi
+          #
+          dnl Only gcc 4.0 or later
+          if test "$compiler_num" -ge "400"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
+          fi
+          #
+          dnl Only gcc 4.1 or later (possibly earlier)
+          if test "$compiler_num" -ge "401"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [attributes])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [div-by-zero format-security])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-field-initializers])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-noreturn])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unreachable-code unused-parameter])
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [padded])           # Not used because we cannot change public structs
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [pragmas])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [redundant-decls])
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [switch-enum])      # Not used because this basically disallows default case
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused-macros])
+          fi
+          #
+          dnl Only gcc 4.2 or later
+          if test "$compiler_num" -ge "402"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [cast-align])
+          fi
+          #
+          dnl Only gcc 4.3 or later
+          if test "$compiler_num" -ge "403"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [address])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [type-limits old-style-declaration])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [missing-parameter-type empty-body])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [clobbered ignored-qualifiers])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [conversion trampolines])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [sign-conversion])
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-error=sign-conversion"          # FIXME
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [vla])
+            dnl required for -Warray-bounds, included in -Wall
+            tmp_CFLAGS="$tmp_CFLAGS -ftree-vrp"
+          fi
+          #
+          dnl Only gcc 4.5 or later
+          if test "$compiler_num" -ge "405"; then
+            dnl Only windows targets
+            case $host_os in
+            mingw*)
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
+              ;;
+            esac
+          fi
+          #
+          dnl Only gcc 4.6 or later
+          if test "$compiler_num" -ge "406"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [double-promotion])
+          fi
+          #
+          dnl only gcc 4.8 or later
+          if test "$compiler_num" -ge "408"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat=2"
+          fi
+          #
+          dnl Only gcc 5 or later
+          if test "$compiler_num" -ge "500"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Warray-bounds=2"
+          fi
+          #
+          dnl Only gcc 6 or later
+          if test "$compiler_num" -ge "600"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [shift-negative-value])
+            tmp_CFLAGS="$tmp_CFLAGS -Wshift-overflow=2"
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [null-dereference])
+            tmp_CFLAGS="$tmp_CFLAGS -fdelete-null-pointer-checks"
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [duplicated-cond])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [unused-const-variable])
+          fi
+          #
+          dnl Only gcc 7 or later
+          if test "$compiler_num" -ge "700"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [duplicated-branches])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [restrict])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [alloc-zero])
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat-overflow=2"
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat-truncation=2"
+            tmp_CFLAGS="$tmp_CFLAGS -Wimplicit-fallthrough"
+          fi
+          #
+          dnl Only gcc 10 or later
+          if test "$compiler_num" -ge "1000"; then
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [arith-conversion])
+            CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [enum-conversion])
+          fi
+
+          for flag in $CPPFLAGS; do
+            case "$flag" in
+             -I*)
+               dnl Include path, provide a -isystem option for the same dir
+               dnl to prevent warnings in those dirs. The -isystem was not very
+               dnl reliable on earlier gcc versions.
+               add=`echo $flag | sed 's/^-I/-isystem /g'`
+               tmp_CFLAGS="$tmp_CFLAGS $add"
+               ;;
+            esac
+          done
+
+    fi dnl $ICC = no
+
+    CFLAGS="$CFLAGS $tmp_CFLAGS"
+
+    AC_MSG_NOTICE([Added this set of compiler options: $tmp_CFLAGS])
+
+  else dnl $GCC = yes
+
+    AC_MSG_NOTICE([Added no extra compiler options])
+
+  fi dnl $GCC = yes
+
+  dnl strip off optimizer flags
+  NEWFLAGS=""
+  for flag in $CFLAGS; do
+    case "$flag" in
+    -O*)
+      dnl echo "cut off $flag"
+      ;;
+    *)
+      NEWFLAGS="$NEWFLAGS $flag"
+      ;;
+    esac
+  done
+  CFLAGS=$NEWFLAGS
 
-    else dnl $GCC = yes
+]) dnl end of AC_DEFUN()
 
-      AC_MSG_NOTICE([Added no extra compiler options])
+dnl CURL_ADD_COMPILER_WARNINGS (WARNING-LIST, NEW-WARNINGS)
+dnl -------------------------------------------------------
+dnl Contents of variable WARNING-LIST and NEW-WARNINGS are
+dnl handled as whitespace separated lists of words.
+dnl Add each compiler warning from NEW-WARNINGS that has not
+dnl been disabled via CFLAGS to WARNING-LIST.
+
+AC_DEFUN([CURL_ADD_COMPILER_WARNINGS], [
+  AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
+  ac_var_added_warnings=""
+  for warning in [$2]; do
+    CURL_VAR_MATCH(CFLAGS, [-Wno-$warning -W$warning])
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+  dnl squeeze whitespace out of result
+  [$1]="$[$1] $ac_var_added_warnings"
+  squeeze [$1]
+])
 
-    fi dnl $GCC = yes
+dnl CURL_SHFUNC_SQUEEZE
+dnl -------------------------------------------------
+dnl Declares a shell function squeeze() which removes
+dnl redundant whitespace out of a shell variable.
+
+AC_DEFUN([CURL_SHFUNC_SQUEEZE], [
+squeeze() {
+  _sqz_result=""
+  eval _sqz_input=\[$][$]1
+  for _sqz_token in $_sqz_input; do
+    if test -z "$_sqz_result"; then
+      _sqz_result="$_sqz_token"
+    else
+      _sqz_result="$_sqz_result $_sqz_token"
+    fi
+  done
+  eval [$]1=\$_sqz_result
+  return 0
+}
+])
 
-    dnl strip off optimizer flags
-    NEWFLAGS=""
-    for flag in $CFLAGS; do
-      case "$flag" in
-      -O*)
-        dnl echo "cut off $flag"
-        ;;
-      *)
-        NEWFLAGS="$NEWFLAGS $flag"
-        ;;
-      esac
+dnl CURL_VAR_MATCH (VARNAME, VALUE)
+dnl -------------------------------------------------
+dnl Verifies if shell variable VARNAME contains VALUE.
+dnl Contents of variable VARNAME and VALUE are handled
+dnl as whitespace separated lists of words. If at least
+dnl one word of VALUE is present in VARNAME the match
+dnl is considered positive, otherwise false.
+
+AC_DEFUN([CURL_VAR_MATCH], [
+  ac_var_match_word="no"
+  for word1 in $[$1]; do
+    for word2 in [$2]; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
     done
-    CFLAGS=$NEWFLAGS
-
-]) dnl end of AC_DEFUN()
+  done
+])
 
 dnl CURL_CHECK_NONBLOCKING_SOCKET
 dnl -------------------------------------------------
@@ -163,12 +638,12 @@ AC_DEFUN([CURL_CHECK_NONBLOCKING_SOCKET],
 [
   AC_MSG_CHECKING([non-blocking sockets style])
 
-  AC_TRY_COMPILE([
+  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 /* headers for O_NONBLOCK test */
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
-],[
+]], [[
 /* try to compile O_NONBLOCK */
 
 #if defined(sun) || defined(__sun__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
@@ -187,22 +662,22 @@ AC_DEFUN([CURL_CHECK_NONBLOCKING_SOCKET],
 #endif
   int socket;
   int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
-],[
+]])],[
 dnl the O_NONBLOCK test was fine
 nonblock="O_NONBLOCK"
 AC_DEFINE(HAVE_O_NONBLOCK, 1, [use O_NONBLOCK for non-blocking sockets])
 ],[
 dnl the code was bad, try a different program now, test 2
 
-  AC_TRY_COMPILE([
+  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 /* headers for FIONBIO test */
 #include <unistd.h>
 #include <stropts.h>
-],[
+]], [[
 /* FIONBIO source test (old-style unix) */
  int socket;
  int flags = ioctl(socket, FIONBIO, &flags);
-],[
+]])],[
 dnl FIONBIO test was good
 nonblock="FIONBIO"
 AC_DEFINE(HAVE_FIONBIO, 1, [use FIONBIO for non-blocking sockets])
@@ -210,67 +685,34 @@ AC_DEFINE(HAVE_FIONBIO, 1, [use FIONBIO for non-blocking sockets])
 dnl FIONBIO test was also bad
 dnl the code was bad, try a different program now, test 3
 
-  AC_TRY_COMPILE([
-/* headers for ioctlsocket test (Windows) */
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#endif
-],[
-/* ioctlsocket source code */
- SOCKET sd;
- unsigned long flags = 0;
- sd = socket(0, 0, 0);
- ioctlsocket(sd, FIONBIO, &flags);
-],[
-dnl ioctlsocket test was good
-nonblock="ioctlsocket"
-AC_DEFINE(HAVE_IOCTLSOCKET, 1, [use ioctlsocket() for non-blocking sockets])
-],[
-dnl ioctlsocket didnt compile!, go to test 4
-
-  AC_TRY_LINK([
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
 /* headers for IoctlSocket test (Amiga?) */
 #include <sys/ioctl.h>
-],[
+]], [[
 /* IoctlSocket source code */
  int socket;
  int flags = IoctlSocket(socket, FIONBIO, (long)1);
-],[
+]])],[
 dnl ioctlsocket test was good
 nonblock="IoctlSocket"
 AC_DEFINE(HAVE_IOCTLSOCKET_CASE, 1, [use Ioctlsocket() for non-blocking sockets])
 ],[
-dnl Ioctlsocket didnt compile, do test 5!
-  AC_TRY_COMPILE([
+dnl Ioctlsocket did not compile, do test 4!
+  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 /* headers for SO_NONBLOCK test (BeOS) */
 #include <socket.h>
-],[
+]], [[
 /* SO_NONBLOCK source code */
  long b = 1;
  int socket;
  int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-],[
+]])],[
 dnl the SO_NONBLOCK test was good
 nonblock="SO_NONBLOCK"
 AC_DEFINE(HAVE_SO_NONBLOCK, 1, [use SO_NONBLOCK for non-blocking sockets])
 ],[
-dnl test 5 didnt compile!
+dnl test 4 did not compile!
 nonblock="nada"
-AC_DEFINE(HAVE_DISABLED_NONBLOCKING, 1, [disabled non-blocking sockets])
-])
-dnl end of fifth test
-
 ])
 dnl end of forth test
 
@@ -390,7 +832,7 @@ dnl autoconf only checks $prefix/lib64 if gcc -print-search-dirs output
 dnl includes a directory named lib64. So, to find libraries in $prefix/lib
 dnl we append -L$prefix/lib to LDFLAGS before checking.
 dnl
-dnl For conveniece, $4 is expanded if [lib]$1 is found.
+dnl For convenience, $4 is expanded if [lib]$1 is found.
 
 AC_DEFUN([LIBSSH2_LIB_HAVE_LINKFLAGS], [
   libssh2_save_CPPFLAGS="$CPPFLAGS"
@@ -403,12 +845,11 @@ AC_DEFUN([LIBSSH2_LIB_HAVE_LINKFLAGS], [
 
   AC_LIB_HAVE_LINKFLAGS([$1], [$2], [$3])
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
   if test "$ac_cv_lib$1" = "yes"; then :
     $4
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
   fi
 ])
 
@@ -418,22 +859,24 @@ m4_case([$1],
 [openssl], [
   LIBSSH2_LIB_HAVE_LINKFLAGS([ssl], [crypto], [#include <openssl/ssl.h>], [
     AC_DEFINE(LIBSSH2_OPENSSL, 1, [Use $1])
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }libssl libcrypto"
-
-    # Not all OpenSSL have AES-CTR functions.
-    libssh2_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBSSL"
-    AC_CHECK_FUNCS(EVP_aes_128_ctr)
-    LIBS="$libssh2_save_LIBS"
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}libcrypto"
+    found_crypto="$1"
+    found_crypto_str="OpenSSL"
+  ])
+],
 
+[wolfssl], [
+  LIBSSH2_LIB_HAVE_LINKFLAGS([wolfssl], [], [#include <wolfssl/options.h>], [
+    AC_DEFINE(LIBSSH2_WOLFSSL, 1, [Use $1])
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}wolfssl"
     found_crypto="$1"
-    found_crypto_str="OpenSSL (AES-CTR: ${ac_cv_func_EVP_aes_128_ctr:-N/A})"
   ])
 ],
 
 [libgcrypt], [
   LIBSSH2_LIB_HAVE_LINKFLAGS([gcrypt], [], [#include <gcrypt.h>], [
     AC_DEFINE(LIBSSH2_LIBGCRYPT, 1, [Use $1])
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}libgcrypt"
     found_crypto="$1"
   ])
 ],
@@ -443,29 +886,25 @@ m4_case([$1],
     AC_DEFINE(LIBSSH2_MBEDTLS, 1, [Use $1])
     LIBS="$LIBS -lmbedcrypto"
     found_crypto="$1"
-    support_clear_memory=yes
   ])
 ],
 
 [wincng], [
-  # Look for Windows Cryptography API: Next Generation
-
-  AC_CHECK_HEADERS([ntdef.h ntstatus.h], [], [], [#include <windows.h>])
-  AC_CHECK_DECLS([SecureZeroMemory], [], [], [#include <windows.h>])
-
-  LIBSSH2_LIB_HAVE_LINKFLAGS([crypt32], [], [
-    #include <windows.h>
-    #include <wincrypt.h>
-  ])
-  LIBSSH2_LIB_HAVE_LINKFLAGS([bcrypt], [], [
-    #include <windows.h>
-    #include <bcrypt.h>
-  ], [
-    AC_DEFINE(LIBSSH2_WINCNG, 1, [Use $1])
-    found_crypto="$1"
-    found_crypto_str="Windows Cryptography API: Next Generation"
-    support_clear_memory="$ac_cv_have_decl_SecureZeroMemory"
-  ])
+  if test "x$have_windows_h" = "xyes"; then
+    # Look for Windows Cryptography API: Next Generation
+
+    LIBS="$LIBS -lcrypt32"
+
+    # Check necessary for old-MinGW
+    LIBSSH2_LIB_HAVE_LINKFLAGS([bcrypt], [], [
+      #include <windows.h>
+      #include <bcrypt.h>
+    ], [
+      AC_DEFINE(LIBSSH2_WINCNG, 1, [Use $1])
+      found_crypto="$1"
+      found_crypto_str="Windows Cryptography API: Next Generation"
+    ])
+  fi
 ],
 )
   test "$found_crypto" = "none" &&
@@ -486,8 +925,8 @@ AC_DEFUN([LIBSSH2_CHECK_OPTION_WERROR], [
   AC_MSG_CHECKING([whether to enable compiler warnings as errors])
   OPT_COMPILER_WERROR="default"
   AC_ARG_ENABLE(werror,
-AC_HELP_STRING([--enable-werror],[Enable compiler warnings as errors])
-AC_HELP_STRING([--disable-werror],[Disable compiler warnings as errors]),
+AS_HELP_STRING([--enable-werror],[Enable compiler warnings as errors])
+AS_HELP_STRING([--disable-werror],[Disable compiler warnings as errors]),
   OPT_COMPILER_WERROR=$enableval)
   case "$OPT_COMPILER_WERROR" in
     no)
@@ -506,7 +945,6 @@ AC_HELP_STRING([--disable-werror],[Disable compiler warnings as errors]),
   AC_MSG_RESULT([$want_werror])
 
   if test X"$want_werror" = Xyes; then
-    CFLAGS="$CFLAGS -Werror"
+    LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -Werror"
   fi
 ])
-
diff --git a/libssh2/aclocal.m4 b/libssh2/aclocal.m4
index fc56a693..390d9b40 100644
--- a/libssh2/aclocal.m4
+++ b/libssh2/aclocal.m4
@@ -1,4 +1,4 @@
-# generated automatically by aclocal 1.16.4 -*- Autoconf -*-
+# generated automatically by aclocal 1.16.5 -*- Autoconf -*-
 
 # Copyright (C) 1996-2021 Free Software Foundation, Inc.
 
@@ -14,8 +14,8 @@
 m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],,
-[m4_warning([this file was generated for autoconf 2.71.
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.72],,
+[m4_warning([this file was generated for autoconf 2.72.
 You have another version of autoconf.  It may work, but is not guaranteed to.
 If you have problems, you may need to regenerate the build system entirely.
 To do so, use the procedure documented by the package, typically 'autoreconf'.])])
@@ -35,7 +35,7 @@ AC_DEFUN([AM_AUTOMAKE_VERSION],
 [am__api_version='1.16'
 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
 dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.16.4], [],
+m4_if([$1], [1.16.5], [],
       [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
 ])
 
@@ -51,7 +51,7 @@ m4_define([_AM_AUTOCONF_VERSION], [])
 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.16.4])dnl
+[AM_AUTOMAKE_VERSION([1.16.5])dnl
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
 _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
@@ -428,6 +428,10 @@ m4_defn([AC_PROG_CC])
 # release and drop the old call support.
 AC_DEFUN([AM_INIT_AUTOMAKE],
 [AC_PREREQ([2.65])dnl
+m4_ifdef([_$0_ALREADY_INIT],
+  [m4_fatal([$0 expanded multiple times
+]m4_defn([_$0_ALREADY_INIT]))],
+  [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl
 dnl Autoconf wants to disallow AM_ names.  We explicitly allow
 dnl the ones we care about.
 m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
@@ -1180,7 +1184,6 @@ AC_SUBST([am__tar])
 AC_SUBST([am__untar])
 ]) # _AM_PROG_TAR
 
-m4_include([m4/autobuild.m4])
 m4_include([m4/lib-ld.m4])
 m4_include([m4/lib-link.m4])
 m4_include([m4/lib-prefix.m4])
diff --git a/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake b/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake
index 8ac61abe..d11b2019 100644
--- a/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake
+++ b/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,6 +32,8 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
 
 
 # - check_function_exists_maybe_need_library(<function> <var> [lib1 ... libn])
@@ -58,24 +60,22 @@
 include(CheckFunctionExists)
 include(CheckLibraryExists)
 
-function(check_function_exists_may_need_library function variable)
+function(check_function_exists_may_need_library _function _variable)
 
-  check_function_exists(${function} ${variable})
+  check_function_exists(${_function} ${_variable})
 
-  if(NOT ${variable})
-    foreach(lib ${ARGN})
-      string(TOUPPER ${lib} UP_LIB)
+  if(NOT ${_variable})
+    foreach(_lib IN LISTS ARGN)
+      string(TOUPPER ${_lib} _up_lib)
       # Use new variable to prevent cache from previous step shortcircuiting
       # new test
-      check_library_exists(${lib} ${function} "" HAVE_${function}_IN_${lib})
-      if(HAVE_${function}_IN_${lib})
-	set(${variable} 1 CACHE INTERNAL
-	  "Function ${function} found in library ${lib}")
-	set(NEED_LIB_${UP_LIB} 1 CACHE INTERNAL
-	  "Need to link ${lib}")
-	break()
+      check_library_exists(${_lib} ${_function} "" HAVE_${_function}_IN_${_lib})
+      if(HAVE_${_function}_IN_${_lib})
+        set(${_variable} 1 CACHE INTERNAL "Function ${_function} found in library ${_lib}")
+        set(NEED_LIB_${_up_lib} 1 CACHE INTERNAL "Need to link ${_lib}")
+        break()
       endif()
     endforeach()
   endif()
 
-endfunction()
\ No newline at end of file
+endfunction()
diff --git a/libssh2/cmake/CheckNonblockingSocketSupport.cmake b/libssh2/cmake/CheckNonblockingSocketSupport.cmake
index 74f4776a..bb3229cf 100644
--- a/libssh2/cmake/CheckNonblockingSocketSupport.cmake
+++ b/libssh2/cmake/CheckNonblockingSocketSupport.cmake
@@ -1,3 +1,5 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 include(CheckCSourceCompiles)
 
 # - check_nonblocking_socket_support()
@@ -11,10 +13,8 @@ include(CheckCSourceCompiles)
 # method (if any):
 #   HAVE_O_NONBLOCK
 #   HAVE_FIONBIO
-#   HAVE_IOCTLSOCKET
 #   HAVE_IOCTLSOCKET_CASE
 #   HAVE_SO_NONBLOCK
-#   HAVE_DISABLED_NONBLOCKING
 #
 # The following variables may be set before calling this macro to
 # modify the way the check is run:
@@ -47,73 +47,49 @@ macro(check_nonblocking_socket_support)
 #error \"O_NONBLOCK does not work on this platform\"
 #endif
 
-int main()
+int main(void)
 {
-    int socket;
-    int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
+    int socket = 0;
+    (void)fcntl(socket, F_SETFL, O_NONBLOCK);
 }"
-  HAVE_O_NONBLOCK)
+    HAVE_O_NONBLOCK)
 
   if(NOT HAVE_O_NONBLOCK)
     check_c_source_compiles("/* FIONBIO test (old-style unix) */
 #include <unistd.h>
 #include <stropts.h>
 
-int main()
+int main(void)
 {
-    int socket;
-    int flags = ioctl(socket, FIONBIO, &flags);
+    int socket = 0;
+    int flags = 0;
+    (void)ioctl(socket, FIONBIO, &flags);
 }"
-    HAVE_FIONBIO)
+      HAVE_FIONBIO)
 
     if(NOT HAVE_FIONBIO)
-      check_c_source_compiles("/* ioctlsocket test (Windows) */
-#undef inline
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <windows.h>
-#include <winsock2.h>
-
-int main()
-{
-    SOCKET sd;
-    unsigned long flags = 0;
-    sd = socket(0, 0, 0);
-    ioctlsocket(sd, FIONBIO, &flags);
-}"
-      HAVE_IOCTLSOCKET)
-
-      if(NOT HAVE_IOCTLSOCKET)
-	check_c_source_compiles("/* IoctlSocket test (Amiga?) */
+      check_c_source_compiles("/* IoctlSocket test (Amiga?) */
 #include <sys/ioctl.h>
 
-int main()
+int main(void)
 {
-    int socket;
-    int flags = IoctlSocket(socket, FIONBIO, (long)1);
+    int socket = 0;
+    (void)IoctlSocket(socket, FIONBIO, (long)1);
 }"
         HAVE_IOCTLSOCKET_CASE)
 
-        if(NOT HAVE_IOCTLSOCKET_CASE)
-	  check_c_source_compiles("/* SO_NONBLOCK test (BeOS) */
+      if(NOT HAVE_IOCTLSOCKET_CASE)
+        check_c_source_compiles("/* SO_NONBLOCK test (BeOS) */
 #include <socket.h>
 
-int main()
+int main(void)
 {
     long b = 1;
-    int socket;
-    int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
+    int socket = 0;
+    (void)setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
 }"
           HAVE_SO_NONBLOCK)
-
-	  if(NOT HAVE_SO_NONBLOCK)
-	    # No non-blocking socket method found
-	    set(HAVE_DISABLED_NONBLOCKING 1)
-	  endif()
-	endif()
       endif()
     endif()
   endif()
-endmacro()
\ No newline at end of file
+endmacro()
diff --git a/libssh2/cmake/CopyRuntimeDependencies.cmake b/libssh2/cmake/CopyRuntimeDependencies.cmake
index 083f7626..9181e4df 100644
--- a/libssh2/cmake/CopyRuntimeDependencies.cmake
+++ b/libssh2/cmake/CopyRuntimeDependencies.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,15 +32,16 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
 
 include(CMakeParseArguments)
 
-function(ADD_TARGET_TO_COPY_DEPENDENCIES)
+function(add_target_to_copy_dependencies)
   set(options)
   set(oneValueArgs TARGET)
   set(multiValueArgs DEPENDENCIES BEFORE_TARGETS)
-  cmake_parse_arguments(COPY
-    "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+  cmake_parse_arguments(COPY "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
   if(NOT COPY_DEPENDENCIES)
     return()
@@ -50,23 +51,18 @@ function(ADD_TARGET_TO_COPY_DEPENDENCIES)
   # parallel builds trying to kick off the commands at the same time
   add_custom_target(${COPY_TARGET})
 
-  foreach(target ${COPY_BEFORE_TARGETS})
-    add_dependencies(${target} ${COPY_TARGET})
+  foreach(_target IN LISTS COPY_BEFORE_TARGETS)
+    add_dependencies(${_target} ${COPY_TARGET})
   endforeach()
 
-  foreach(dependency ${COPY_DEPENDENCIES})
-
+  foreach(_dependency IN LISTS COPY_DEPENDENCIES)
     add_custom_command(
       TARGET ${COPY_TARGET}
-      DEPENDS ${dependency}
+      DEPENDS ${_dependency}
       # Make directory first otherwise file is copied in place of
       # directory instead of into it
-      COMMAND ${CMAKE_COMMAND}
-      ARGS -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
-      COMMAND ${CMAKE_COMMAND}
-      ARGS -E copy ${dependency} ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
+      COMMAND ${CMAKE_COMMAND} ARGS -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}"
+      COMMAND ${CMAKE_COMMAND} ARGS -E copy ${_dependency} "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}"
       VERBATIM)
-
   endforeach()
-
 endfunction()
diff --git a/libssh2/cmake/FindLibgcrypt.cmake b/libssh2/cmake/FindLibgcrypt.cmake
index 44a79873..4582ce9b 100644
--- a/libssh2/cmake/FindLibgcrypt.cmake
+++ b/libssh2/cmake/FindLibgcrypt.cmake
@@ -1,53 +1,59 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
-# Redistribution and use in source and binary forms,
-# with or without modification, are permitted provided
-# that the following conditions are met:
+###########################################################################
+# Find the libgcrypt library
 #
-#   Redistributions of source code must retain the above
-#   copyright notice, this list of conditions and the
-#   following disclaimer.
+# Input variables:
 #
-#   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.
+# LIBGCRYPT_INCLUDE_DIR   The libgcrypt include directory
+# LIBGCRYPT_LIBRARY       Path to libgcrypt library
 #
-#   Neither the name of the copyright holder nor the names
-#   of any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
+# Result variables:
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
+# LIBGCRYPT_FOUND         System has libgcrypt
+# LIBGCRYPT_INCLUDE_DIRS  The libgcrypt include directories
+# LIBGCRYPT_LIBRARIES     The libgcrypt library names
+# LIBGCRYPT_LIBRARY_DIRS  The libgcrypt library directories
+# LIBGCRYPT_CFLAGS        Required compiler flags
+# LIBGCRYPT_VERSION       Version of libgcrypt
 
-# - Try to find Libgcrypt
-# This will define all or none of:
-#  LIBGCRYPT_FOUND - if Libgcrypt headers and library was found
-#  LIBGCRYPT_INCLUDE_DIRS - The Libgcrypt include directories
-#  LIBGCRYPT_LIBRARIES - The libraries needed to use Libgcrypt
+if((UNIX OR VCPKG_TOOLCHAIN OR (MINGW AND NOT CMAKE_CROSSCOMPILING)) AND
+   NOT DEFINED LIBGCRYPT_INCLUDE_DIR AND
+   NOT DEFINED LIBGCRYPT_LIBRARY)
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(LIBGCRYPT "libgcrypt")
+endif()
 
-find_path(LIBGCRYPT_INCLUDE_DIR gcrypt.h)
+if(LIBGCRYPT_FOUND)
+  string(REPLACE ";" " " LIBGCRYPT_CFLAGS "${LIBGCRYPT_CFLAGS}")
+  message(STATUS "Found Libgcrypt (via pkg-config): ${LIBGCRYPT_INCLUDE_DIRS} (found version \"${LIBGCRYPT_VERSION}\")")
+else()
+  find_path(LIBGCRYPT_INCLUDE_DIR NAMES "gcrypt.h")
+  find_library(LIBGCRYPT_LIBRARY NAMES "gcrypt" "libgcrypt")
 
-find_library(LIBGCRYPT_LIBRARY NAMES gcrypt libgcrypt)
+  if(LIBGCRYPT_INCLUDE_DIR AND EXISTS "${LIBGCRYPT_INCLUDE_DIR}/gcrypt.h")
+    set(_version_regex "#[\t ]*define[\t ]+GCRYPT_VERSION[\t ]+\"([^\"]*)\"")
+    file(STRINGS "${LIBGCRYPT_INCLUDE_DIR}/gcrypt.h" _version_str REGEX "${_version_regex}")
+    string(REGEX REPLACE "${_version_regex}" "\\1" _version_str "${_version_str}")
+    set(LIBGCRYPT_VERSION "${_version_str}")
+    unset(_version_regex)
+    unset(_version_str)
+  endif()
 
-set(LIBGCRYPT_LIBRARIES ${LIBGCRYPT_LIBRARY})
-set(LIBGCRYPT_INCLUDE_DIRS ${LIBGCRYPT_INCLUDE_DIR})
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(Libgcrypt
+    REQUIRED_VARS
+      LIBGCRYPT_INCLUDE_DIR
+      LIBGCRYPT_LIBRARY
+    VERSION_VAR
+      LIBGCRYPT_VERSION
+  )
 
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libgcrypt DEFAULT_MSG
-                                  LIBGCRYPT_LIBRARY LIBGCRYPT_INCLUDE_DIR)
+  if(LIBGCRYPT_FOUND)
+    set(LIBGCRYPT_INCLUDE_DIRS ${LIBGCRYPT_INCLUDE_DIR})
+    set(LIBGCRYPT_LIBRARIES    ${LIBGCRYPT_LIBRARY})
+  endif()
 
-mark_as_advanced(LIBGCRYPT_INCLUDE_DIR LIBGCRYPT_LIBRARY)
\ No newline at end of file
+  mark_as_advanced(LIBGCRYPT_INCLUDE_DIR LIBGCRYPT_LIBRARY)
+endif()
diff --git a/libssh2/cmake/FindMbedTLS.cmake b/libssh2/cmake/FindMbedTLS.cmake
new file mode 100644
index 00000000..26bc5655
--- /dev/null
+++ b/libssh2/cmake/FindMbedTLS.cmake
@@ -0,0 +1,69 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+###########################################################################
+# Find the mbedtls library
+#
+# Input variables:
+#
+# MBEDTLS_INCLUDE_DIR   The mbedtls include directory
+# MBEDCRYPTO_LIBRARY    Path to mbedcrypto library
+#
+# Result variables:
+#
+# MBEDTLS_FOUND         System has mbedtls
+# MBEDTLS_INCLUDE_DIRS  The mbedtls include directories
+# MBEDTLS_LIBRARIES     The mbedtls library names
+# MBEDTLS_LIBRARY_DIRS  The mbedtls library directories
+# MBEDTLS_CFLAGS        Required compiler flags
+# MBEDTLS_VERSION       Version of mbedtls
+
+if((UNIX OR VCPKG_TOOLCHAIN OR (MINGW AND NOT CMAKE_CROSSCOMPILING)) AND
+   NOT DEFINED MBEDTLS_INCLUDE_DIR AND
+   NOT DEFINED MBEDCRYPTO_LIBRARY)
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(MBEDTLS "mbedcrypto")
+endif()
+
+if(MBEDTLS_FOUND)
+  string(REPLACE ";" " " MBEDTLS_CFLAGS "${MBEDTLS_CFLAGS}")
+  message(STATUS "Found MbedTLS (via pkg-config): ${MBEDTLS_INCLUDE_DIRS} (found version \"${MBEDTLS_VERSION}\")")
+else()
+  find_path(MBEDTLS_INCLUDE_DIR NAMES "mbedtls/version.h")
+  find_library(MBEDCRYPTO_LIBRARY NAMES "mbedcrypto" "libmbedcrypto")
+
+  if(MBEDTLS_INCLUDE_DIR)
+    if(EXISTS "${MBEDTLS_INCLUDE_DIR}/mbedtls/build_info.h")  # 3.x
+      set(_version_header "${MBEDTLS_INCLUDE_DIR}/mbedtls/build_info.h")
+    elseif(EXISTS "${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h")  # 2.x
+      set(_version_header "${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h")
+    else()
+      unset(_version_header)
+    endif()
+    if(_version_header)
+      set(_version_regex "#[\t ]*define[\t ]+MBEDTLS_VERSION_STRING[\t ]+\"([0-9.]+)\"")
+      file(STRINGS "${_version_header}" _version_str REGEX "${_version_regex}")
+      string(REGEX REPLACE "${_version_regex}" "\\1" _version_str "${_version_str}")
+      set(MBEDTLS_VERSION "${_version_str}")
+      unset(_version_regex)
+      unset(_version_str)
+      unset(_version_header)
+    endif()
+  endif()
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(MbedTLS
+    REQUIRED_VARS
+      MBEDTLS_INCLUDE_DIR
+      MBEDCRYPTO_LIBRARY
+    VERSION_VAR
+      MBEDTLS_VERSION
+  )
+
+  if(MBEDTLS_FOUND)
+    set(MBEDTLS_INCLUDE_DIRS ${MBEDTLS_INCLUDE_DIR})
+    set(MBEDTLS_LIBRARIES    ${MBEDCRYPTO_LIBRARY})
+  endif()
+
+  mark_as_advanced(MBEDTLS_INCLUDE_DIR MBEDCRYPTO_LIBRARY)
+endif()
diff --git a/libssh2/cmake/FindWolfSSL.cmake b/libssh2/cmake/FindWolfSSL.cmake
new file mode 100644
index 00000000..f66a59df
--- /dev/null
+++ b/libssh2/cmake/FindWolfSSL.cmake
@@ -0,0 +1,59 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+###########################################################################
+# Find the wolfssl library
+#
+# Input variables:
+#
+# WOLFSSL_INCLUDE_DIR   The wolfssl include directory
+# WOLFSSL_LIBRARY       Path to wolfssl library
+#
+# Result variables:
+#
+# WOLFSSL_FOUND         System has wolfssl
+# WOLFSSL_INCLUDE_DIRS  The wolfssl include directories
+# WOLFSSL_LIBRARIES     The wolfssl library names
+# WOLFSSL_LIBRARY_DIRS  The wolfssl library directories
+# WOLFSSL_CFLAGS        Required compiler flags
+# WOLFSSL_VERSION       Version of wolfssl
+
+if((UNIX OR VCPKG_TOOLCHAIN OR (MINGW AND NOT CMAKE_CROSSCOMPILING)) AND
+   NOT DEFINED WOLFSSL_INCLUDE_DIR AND
+   NOT DEFINED WOLFSSL_LIBRARY)
+  find_package(PkgConfig QUIET)
+  pkg_check_modules(WOLFSSL "wolfssl")
+endif()
+
+if(WOLFSSL_FOUND)
+  string(REPLACE ";" " " WOLFSSL_CFLAGS "${WOLFSSL_CFLAGS}")
+  message(STATUS "Found WolfSSL (via pkg-config): ${WOLFSSL_INCLUDE_DIRS} (found version \"${WOLFSSL_VERSION}\")")
+else()
+  find_path(WOLFSSL_INCLUDE_DIR NAMES "wolfssl/options.h")
+  find_library(WOLFSSL_LIBRARY NAMES "wolfssl")
+
+  if(WOLFSSL_INCLUDE_DIR AND EXISTS "${WOLFSSL_INCLUDE_DIR}/wolfssl/version.h")
+    set(_version_regex "#[\t ]*define[\t ]+LIBWOLFSSL_VERSION_STRING[\t ]+\"([^\"]*)\"")
+    file(STRINGS "${WOLFSSL_INCLUDE_DIR}/wolfssl/version.h" _version_str REGEX "${_version_regex}")
+    string(REGEX REPLACE "${_version_regex}" "\\1" _version_str "${_version_str}")
+    set(WOLFSSL_VERSION "${_version_str}")
+    unset(_version_regex)
+    unset(_version_str)
+  endif()
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(WolfSSL
+    REQUIRED_VARS
+      WOLFSSL_INCLUDE_DIR
+      WOLFSSL_LIBRARY
+    VERSION_VAR
+      WOLFSSL_VERSION
+  )
+
+  if(WOLFSSL_FOUND)
+    set(WOLFSSL_INCLUDE_DIRS ${WOLFSSL_INCLUDE_DIR})
+    set(WOLFSSL_LIBRARIES    ${WOLFSSL_LIBRARY})
+  endif()
+
+  mark_as_advanced(WOLFSSL_INCLUDE_DIR WOLFSSL_LIBRARY)
+endif()
diff --git a/libssh2/cmake/FindmbedTLS.cmake b/libssh2/cmake/FindmbedTLS.cmake
deleted file mode 100644
index 2f4adbc5..00000000
--- a/libssh2/cmake/FindmbedTLS.cmake
+++ /dev/null
@@ -1,64 +0,0 @@
-# - Try to find mbedTLS
-# Once done this will define
-#
-# Read-Only variables
-#  MBEDTLS_FOUND - system has mbedTLS
-#  MBEDTLS_INCLUDE_DIR - the mbedTLS include directory
-#  MBEDTLS_LIBRARY_DIR - the mbedTLS library directory
-#  MBEDTLS_LIBRARIES - Link these to use mbedTLS
-#  MBEDTLS_LIBRARY - path to mbedTLS library
-#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
-#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
-
-FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/version.h)
-
-IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
-    # Already in cache, be silent
-    SET(MBEDTLS_FIND_QUIETLY TRUE)
-ENDIF()
-
-FIND_LIBRARY(MBEDTLS_LIBRARY NAMES mbedtls libmbedtls libmbedx509)
-FIND_LIBRARY(MBEDX509_LIBRARY NAMES mbedx509 libmbedx509)
-FIND_LIBRARY(MBEDCRYPTO_LIBRARY NAMES mbedcrypto libmbedcrypto)
-
-IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
-     SET(MBEDTLS_FOUND TRUE)
-ENDIF()
-
-IF(MBEDTLS_FOUND)
-    # split mbedTLS into -L and -l linker options, so we can set them for pkg-config
-    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_DIR ${MBEDTLS_LIBRARY} PATH)
-    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY} NAME_WE)
-    GET_FILENAME_COMPONENT(MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY} NAME_WE)
-    GET_FILENAME_COMPONENT(MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY} NAME_WE)
-    STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
-    STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
-    STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
-    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
-
-    IF(NOT MBEDTLS_FIND_QUIETLY)
-        MESSAGE(STATUS "Found mbedTLS:")
-        FILE(READ ${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h MBEDTLSCONTENT)
-        STRING(REGEX MATCH "MBEDTLS_VERSION_STRING +\"[0-9|.]+\"" MBEDTLSMATCH ${MBEDTLSCONTENT})
-        IF (MBEDTLSMATCH)
-            STRING(REGEX REPLACE "MBEDTLS_VERSION_STRING +\"([0-9|.]+)\"" "\\1" MBEDTLS_VERSION ${MBEDTLSMATCH})
-            MESSAGE(STATUS "  version ${MBEDTLS_VERSION}")
-        ENDIF(MBEDTLSMATCH)
-        MESSAGE(STATUS "  TLS: ${MBEDTLS_LIBRARY}")
-        MESSAGE(STATUS "  X509: ${MBEDX509_LIBRARY}")
-        MESSAGE(STATUS "  Crypto: ${MBEDCRYPTO_LIBRARY}")
-    ENDIF(NOT MBEDTLS_FIND_QUIETLY)
-ELSE(MBEDTLS_FOUND)
-    IF(MBEDTLS_FIND_REQUIRED)
-        MESSAGE(FATAL_ERROR "Could not find mbedTLS")
-    ENDIF(MBEDTLS_FIND_REQUIRED)
-ENDIF(MBEDTLS_FOUND)
-
-MARK_AS_ADVANCED(
-    MBEDTLS_INCLUDE_DIR
-    MBEDTLS_LIBRARY_DIR
-    MBEDTLS_LIBRARIES
-    MBEDTLS_LIBRARY
-    MBEDX509_LIBRARY
-    MBEDCRYPTO_LIBRARY
-)
diff --git a/libssh2/cmake/PickyWarnings.cmake b/libssh2/cmake/PickyWarnings.cmake
new file mode 100644
index 00000000..94feee87
--- /dev/null
+++ b/libssh2/cmake/PickyWarnings.cmake
@@ -0,0 +1,247 @@
+# Copyright (C) Viktor Szakats
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(CheckCCompilerFlag)
+
+option(ENABLE_WERROR "Turn compiler warnings into errors" OFF)
+option(PICKY_COMPILER "Enable picky compiler options" ON)
+
+if(ENABLE_WERROR)
+  if(MSVC)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
+  else()  # llvm/clang and gcc style options
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+  endif()
+endif()
+
+if(MSVC)
+  # Use the highest warning level for Visual Studio.
+  if(PICKY_COMPILER)
+    if(CMAKE_CXX_FLAGS MATCHES "[/-]W[0-4]")
+      string(REGEX REPLACE "[/-]W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+    endif()
+    if(CMAKE_C_FLAGS MATCHES "[/-]W[0-4]")
+      string(REGEX REPLACE "[/-]W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    else()
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
+    endif()
+  endif()
+elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+
+  # https://clang.llvm.org/docs/DiagnosticsReference.html
+  # https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
+
+  if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+  endif()
+  if(NOT CMAKE_C_FLAGS MATCHES "-Wall")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
+  endif()
+
+  if(PICKY_COMPILER)
+
+    # WPICKY_ENABLE = Options we want to enable as-is.
+    # WPICKY_DETECT = Options we want to test first and enable if available.
+
+    # Prefer the -Wextra alias with clang.
+    if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+      set(WPICKY_ENABLE "-Wextra")
+    else()
+      set(WPICKY_ENABLE "-W")
+    endif()
+
+    list(APPEND WPICKY_ENABLE
+      -pedantic
+    )
+
+    if(ENABLE_WERROR)
+      list(APPEND WPICKY_ENABLE
+        -pedantic-errors
+      )
+    endif()
+
+    # ----------------------------------
+    # Add new options here, if in doubt:
+    # ----------------------------------
+    set(WPICKY_DETECT
+    )
+
+    # Assume these options always exist with both clang and gcc.
+    # Require clang 3.0 / gcc 2.95 or later.
+    list(APPEND WPICKY_ENABLE
+      -Wbad-function-cast                  # clang  2.7  gcc  2.95
+      -Wconversion                         # clang  2.7  gcc  2.95
+      -Winline                             # clang  1.0  gcc  1.0
+      -Wmissing-declarations               # clang  1.0  gcc  2.7
+      -Wmissing-prototypes                 # clang  1.0  gcc  1.0
+      -Wnested-externs                     # clang  1.0  gcc  2.7
+      -Wno-long-long                       # clang  1.0  gcc  2.95
+      -Wno-multichar                       # clang  1.0  gcc  2.95
+      -Wpointer-arith                      # clang  1.0  gcc  1.4
+      -Wshadow                             # clang  1.0  gcc  2.95
+      -Wsign-compare                       # clang  1.0  gcc  2.95
+      -Wundef                              # clang  1.0  gcc  2.95
+      -Wunused                             # clang  1.1  gcc  2.95
+      -Wwrite-strings                      # clang  1.0  gcc  1.4
+    )
+
+    # Always enable with clang, version dependent with gcc
+    set(WPICKY_COMMON_OLD
+      -Waddress                            # clang  2.7  gcc  4.3
+      -Wattributes                         # clang  2.7  gcc  4.1
+      -Wcast-align                         # clang  1.0  gcc  4.2
+      -Wdeclaration-after-statement        # clang  1.0  gcc  3.4
+      -Wdiv-by-zero                        # clang  2.7  gcc  4.1
+      -Wempty-body                         # clang  2.7  gcc  4.3
+      -Wendif-labels                       # clang  1.0  gcc  3.3
+      -Wfloat-equal                        # clang  1.0  gcc  2.96 (3.0)
+      -Wformat-security                    # clang  2.7  gcc  4.1
+      -Wignored-qualifiers                 # clang  2.8  gcc  4.3
+      -Wmissing-field-initializers         # clang  2.7  gcc  4.1
+      -Wmissing-noreturn                   # clang  2.7  gcc  4.1
+      -Wno-format-nonliteral               # clang  1.0  gcc  2.96 (3.0)
+      -Wno-system-headers                  # clang  1.0  gcc  3.0
+    # -Wpadded                             # clang  2.9  gcc  4.1               # Not used because we cannot change public structs
+      -Wold-style-definition               # clang  2.7  gcc  3.4
+      -Wredundant-decls                    # clang  2.7  gcc  4.1
+      -Wsign-conversion                    # clang  2.9  gcc  4.3
+        -Wno-error=sign-conversion                                              # FIXME
+      -Wstrict-prototypes                  # clang  1.0  gcc  3.3
+    # -Wswitch-enum                        # clang  2.7  gcc  4.1               # Not used because this basically disallows default case
+      -Wtype-limits                        # clang  2.7  gcc  4.3
+      -Wunreachable-code                   # clang  2.7  gcc  4.1
+      -Wunused-macros                      # clang  2.7  gcc  4.1
+      -Wunused-parameter                   # clang  2.7  gcc  4.1
+      -Wvla                                # clang  2.8  gcc  4.3
+    )
+
+    set(WPICKY_COMMON
+      -Wdouble-promotion                   # clang  3.6  gcc  4.6  appleclang  6.3
+      -Wenum-conversion                    # clang  3.2  gcc 10.0  appleclang  4.6  g++ 11.0
+      -Wpragmas                            # clang  3.5  gcc  4.1  appleclang  6.0
+      -Wunused-const-variable              # clang  3.4  gcc  6.0  appleclang  5.1
+    )
+
+    if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+      list(APPEND WPICKY_ENABLE
+        ${WPICKY_COMMON_OLD}
+        -Wshift-sign-overflow              # clang  2.9
+        -Wshorten-64-to-32                 # clang  1.0
+        -Wlanguage-extension-token         # clang  3.0
+        -Wformat=2                         # clang  3.0  gcc  4.8
+      )
+      # Enable based on compiler version
+      if((CMAKE_C_COMPILER_ID STREQUAL "Clang"      AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.6) OR
+         (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.3))
+        list(APPEND WPICKY_ENABLE
+          ${WPICKY_COMMON}
+          -Wunreachable-code-break         # clang  3.5            appleclang  6.0
+          -Wheader-guard                   # clang  3.4            appleclang  5.1
+          -Wsometimes-uninitialized        # clang  3.2            appleclang  4.6
+        )
+      endif()
+      if((CMAKE_C_COMPILER_ID STREQUAL "Clang"      AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 3.9) OR
+         (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 8.3))
+        list(APPEND WPICKY_ENABLE
+          -Wcomma                          # clang  3.9            appleclang  8.3
+          -Wmissing-variable-declarations  # clang  3.2            appleclang  4.6
+        )
+      endif()
+      if((CMAKE_C_COMPILER_ID STREQUAL "Clang"      AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 7.0) OR
+         (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 10.3))
+        list(APPEND WPICKY_ENABLE
+          -Wassign-enum                    # clang  7.0            appleclang 10.3
+          -Wextra-semi-stmt                # clang  7.0            appleclang 10.3
+        )
+      endif()
+      if((CMAKE_C_COMPILER_ID STREQUAL "Clang"      AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 10.0) OR
+         (CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 12.4))
+        list(APPEND WPICKY_ENABLE
+          -Wimplicit-fallthrough           # clang  4.0  gcc  7.0  appleclang 12.4  # we have silencing markup for clang 10.0 and above only
+        )
+      endif()
+    else()  # gcc
+      list(APPEND WPICKY_DETECT
+        ${WPICKY_COMMON}
+      )
+      # Enable based on compiler version
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.3)
+        list(APPEND WPICKY_ENABLE
+          ${WPICKY_COMMON_OLD}
+          -Wclobbered                      #             gcc  4.3
+          -Wmissing-parameter-type         #             gcc  4.3
+          -Wold-style-declaration          #             gcc  4.3
+          -Wstrict-aliasing=3              #             gcc  4.0
+          -Wtrampolines                    #             gcc  4.3
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.5 AND MINGW)
+        list(APPEND WPICKY_ENABLE
+          -Wno-pedantic-ms-format          #             gcc  4.5 (mingw-only)
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.8)
+        list(APPEND WPICKY_ENABLE
+          -Wformat=2                       # clang  3.0  gcc  4.8
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 5.0)
+        list(APPEND WPICKY_ENABLE
+          -Warray-bounds=2 -ftree-vrp      # clang  3.0  gcc  5.0 (clang default: -Warray-bounds)
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.0)
+        list(APPEND WPICKY_ENABLE
+          -Wduplicated-cond                #             gcc  6.0
+          -Wnull-dereference               # clang  3.0  gcc  6.0 (clang default)
+            -fdelete-null-pointer-checks
+          -Wshift-negative-value           # clang  3.7  gcc  6.0 (clang default)
+          -Wshift-overflow=2               # clang  3.0  gcc  6.0 (clang default: -Wshift-overflow)
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 7.0)
+        list(APPEND WPICKY_ENABLE
+          -Walloc-zero                     #             gcc  7.0
+          -Wduplicated-branches            #             gcc  7.0
+          -Wformat-overflow=2              #             gcc  7.0
+          -Wformat-truncation=2            #             gcc  7.0
+          -Wimplicit-fallthrough           # clang  4.0  gcc  7.0
+          -Wrestrict                       #             gcc  7.0
+        )
+      endif()
+      if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 10.0)
+        list(APPEND WPICKY_ENABLE
+          -Warith-conversion               #             gcc 10.0
+        )
+      endif()
+    endif()
+
+    #
+
+    unset(WPICKY)
+
+    foreach(_CCOPT IN LISTS WPICKY_ENABLE)
+      set(WPICKY "${WPICKY} ${_CCOPT}")
+    endforeach()
+
+    foreach(_CCOPT IN LISTS WPICKY_DETECT)
+      # surprisingly, CHECK_C_COMPILER_FLAG needs a new variable to store each new
+      # test result in.
+      string(MAKE_C_IDENTIFIER "OPT${_CCOPT}" _optvarname)
+      # GCC only warns about unknown -Wno- options if there are also other diagnostic messages,
+      # so test for the positive form instead
+      string(REPLACE "-Wno-" "-W" _CCOPT_ON "${_CCOPT}")
+      check_c_compiler_flag(${_CCOPT_ON} ${_optvarname})
+      if(${_optvarname})
+        set(WPICKY "${WPICKY} ${_CCOPT}")
+      endif()
+    endforeach()
+
+    message(STATUS "Picky compiler options:${WPICKY}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WPICKY}")
+  endif()
+endif()
diff --git a/libssh2/cmake/SocketLibraries.cmake b/libssh2/cmake/SocketLibraries.cmake
deleted file mode 100644
index bfbbd711..00000000
--- a/libssh2/cmake/SocketLibraries.cmake
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Some systems have their socket functions in a library.
-# (Solaris -lsocket/-lnsl, Windows -lws2_32).  This macro appends those
-# libraries to the given list
-macro(append_needed_socket_libraries LIBRARIES_LIST)
-  if(CMAKE_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-    # x86 Windows uses STDCALL for these functions, so their names are mangled,
-    # meaning the platform checks don't work. Hardcoding these until we get
-    # a better solution.
-    set(HAVE_SOCKET 1)
-    set(HAVE_SELECT 1)
-    set(HAVE_INET_ADDR 1)
-    set(NEED_LIB_WS2_32 1)
-  else()
-    check_function_exists_may_need_library(socket HAVE_SOCKET socket ws2_32)
-    check_function_exists_may_need_library(select HAVE_SELECT ws2_32)
-    check_function_exists_may_need_library(inet_addr HAVE_INET_ADDR nsl ws2_32)
-  endif()
-
-  if(NEED_LIB_SOCKET)
-    list(APPEND ${LIBRARIES_LIST} socket)
-  endif()
-  if(NEED_LIB_NSL)
-    list(APPEND ${LIBRARIES_LIST} nsl)
-  endif()
-  if(NEED_LIB_WS2_32)
-    list(APPEND ${LIBRARIES_LIST} ws2_32)
-  endif()
-
-endmacro()
\ No newline at end of file
diff --git a/libssh2/cmake/Toolchain-Linux-32.cmake b/libssh2/cmake/Toolchain-Linux-32.cmake
deleted file mode 100644
index 6aad9b1e..00000000
--- a/libssh2/cmake/Toolchain-Linux-32.cmake
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Cross-compile 32-bit binary on 64-bit linux host
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_VERSION 1)
-set(CMAKE_SYSTEM_PROCESSOR "i386")
-
-set(CMAKE_CXX_COMPILER_ARG1 "-m32")
-set(CMAKE_C_COMPILER_ARG1 "-m32")
\ No newline at end of file
diff --git a/libssh2/cmake/libssh2-config.cmake.in b/libssh2/cmake/libssh2-config.cmake.in
new file mode 100644
index 00000000..edc86d7c
--- /dev/null
+++ b/libssh2/cmake/libssh2-config.cmake.in
@@ -0,0 +1,31 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
+include(CMakeFindDependencyMacro)
+list(PREPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+
+if("@CRYPTO_BACKEND@" STREQUAL "OpenSSL")
+  find_dependency(OpenSSL)
+elseif("@CRYPTO_BACKEND@" STREQUAL "wolfSSL")
+  find_dependency(WolfSSL)
+elseif("@CRYPTO_BACKEND@" STREQUAL "Libgcrypt")
+  find_dependency(Libgcrypt)
+elseif("@CRYPTO_BACKEND@" STREQUAL "mbedTLS")
+  find_dependency(MbedTLS)
+endif()
+
+if(@ZLIB_FOUND@)
+  find_dependency(ZLIB)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
+
+# Alias for either shared or static library
+if(NOT TARGET @PROJECT_NAME@::@LIB_NAME@)
+  add_library(@PROJECT_NAME@::@LIB_NAME@ ALIAS @PROJECT_NAME@::@LIB_SELECTED@)
+endif()
+
+# Compatibility alias
+if(NOT TARGET Libssh2::@LIB_NAME@)
+  add_library(Libssh2::@LIB_NAME@ ALIAS @PROJECT_NAME@::@LIB_SELECTED@)
+endif()
diff --git a/libssh2/cmake/max_warnings.cmake b/libssh2/cmake/max_warnings.cmake
deleted file mode 100644
index b176d302..00000000
--- a/libssh2/cmake/max_warnings.cmake
+++ /dev/null
@@ -1,23 +0,0 @@
-if(MSVC)
-  # Use the highest warning level for visual studio.
-  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
-  endif()
-  if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-  else()
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
-  endif()
-
-  # Disable broken warnings
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
-elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-  if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-  endif()
-  if(NOT CMAKE_C_FLAGS MATCHES "-Wall")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-  endif()
-endif()
diff --git a/libssh2/compile b/libssh2/compile
index 23fcba01..df363c8f 100755
--- a/libssh2/compile
+++ b/libssh2/compile
@@ -3,7 +3,7 @@
 
 scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1999-2020 Free Software Foundation, Inc.
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
 # Written by Tom Tromey <tromey@cygnus.com>.
 #
 # This program is free software; you can redistribute it and/or modify
diff --git a/libssh2/config.guess b/libssh2/config.guess
index f50dcdb6..7f76b622 100755
--- a/libssh2/config.guess
+++ b/libssh2/config.guess
@@ -1,12 +1,14 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
+#   Copyright 1992-2022 Free Software Foundation, Inc.
 
-timestamp='2018-02-24'
+# shellcheck disable=SC2006,SC2268 # see below for rationale
+
+timestamp='2022-01-09'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
@@ -27,11 +29,19 @@ timestamp='2018-02-24'
 # Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
 #
 # You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
 #
 # Please send patches to <config-patches@gnu.org>.
 
 
+# The "shellcheck disable" line above the timestamp inhibits complaints
+# about features and limitations of the classic Bourne shell that were
+# superseded or lifted in POSIX.  However, this script identifies a wide
+# variety of pre-POSIX systems that do not have POSIX shells at all, and
+# even some reasonably current systems (Solaris 10 as case-in-point) still
+# have a pre-POSIX /bin/sh.
+
+
 me=`echo "$0" | sed -e 's,.*/,,'`
 
 usage="\
@@ -50,7 +60,7 @@ version="\
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright 1992-2018 Free Software Foundation, Inc.
+Copyright 1992-2022 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -84,7 +94,8 @@ if test $# != 0; then
   exit 1
 fi
 
-trap 'exit 1' 1 2 15
+# Just in case it came from the environment.
+GUESS=
 
 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a
 # compiler to aid in system detection is discouraged as it requires
@@ -96,73 +107,90 @@ trap 'exit 1' 1 2 15
 
 # Portable tmp directory creation inspired by the Autoconf team.
 
-set_cc_for_build='
-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
-: ${TMPDIR=/tmp} ;
- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
-dummy=$tmp/dummy ;
-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > "$dummy.c" ;
-	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-	     CC_FOR_BUILD="$c"; break ;
-	  fi ;
-	done ;
-	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found ;
-	fi
-	;;
- ,,*)   CC_FOR_BUILD=$CC ;;
- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac ; set_cc_for_build= ;'
+tmp=
+# shellcheck disable=SC2172
+trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15
+
+set_cc_for_build() {
+    # prevent multiple calls if $tmp is already set
+    test "$tmp" && return 0
+    : "${TMPDIR=/tmp}"
+    # shellcheck disable=SC2039,SC3028
+    { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } ||
+	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; }
+    dummy=$tmp/dummy
+    case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in
+	,,)    echo "int x;" > "$dummy.c"
+	       for driver in cc gcc c89 c99 ; do
+		   if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
+		       CC_FOR_BUILD=$driver
+		       break
+		   fi
+	       done
+	       if test x"$CC_FOR_BUILD" = x ; then
+		   CC_FOR_BUILD=no_compiler_found
+	       fi
+	       ;;
+	,,*)   CC_FOR_BUILD=$CC ;;
+	,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+    esac
+}
 
 # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
 # (ghazi@noc.rutgers.edu 1994-08-24)
-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+if test -f /.attbin/uname ; then
 	PATH=$PATH:/.attbin ; export PATH
 fi
 
 UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
 UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
 UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 
-case "$UNAME_SYSTEM" in
+case $UNAME_SYSTEM in
 Linux|GNU|GNU/*)
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	LIBC=gnu
+	LIBC=unknown
 
-	eval "$set_cc_for_build"
+	set_cc_for_build
 	cat <<-EOF > "$dummy.c"
 	#include <features.h>
 	#if defined(__UCLIBC__)
 	LIBC=uclibc
 	#elif defined(__dietlibc__)
 	LIBC=dietlibc
-	#else
+	#elif defined(__GLIBC__)
 	LIBC=gnu
+	#else
+	#include <stdarg.h>
+	/* First heuristic to detect musl libc.  */
+	#ifdef __DEFINED_va_list
+	LIBC=musl
+	#endif
 	#endif
 	EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
+	cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
+	eval "$cc_set_libc"
 
-	# If ldd exists, use it to detect musl libc.
-	if command -v ldd >/dev/null && \
-		ldd --version 2>&1 | grep -q ^musl
-	then
-	    LIBC=musl
+	# Second heuristic to detect musl libc.
+	if [ "$LIBC" = unknown ] &&
+	   command -v ldd >/dev/null &&
+	   ldd --version 2>&1 | grep -q ^musl; then
+		LIBC=musl
+	fi
+
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	if [ "$LIBC" = unknown ]; then
+		LIBC=gnu
 	fi
 	;;
 esac
 
 # Note: order is significant - the case branches are not exclusive.
 
-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
+case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in
     *:NetBSD:*:*)
 	# NetBSD (nbsd) targets should (where applicable) match one or
 	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
@@ -174,12 +202,12 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	#
 	# Note: NetBSD doesn't particularly care about the vendor
 	# portion of the name.  We always set it to "unknown".
-	sysctl="sysctl -n hw.machine_arch"
 	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    "/sbin/$sysctl" 2>/dev/null || \
-	    "/usr/sbin/$sysctl" 2>/dev/null || \
+	    /sbin/sysctl -n hw.machine_arch 2>/dev/null || \
+	    /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
 	    echo unknown)`
-	case "$UNAME_MACHINE_ARCH" in
+	case $UNAME_MACHINE_ARCH in
+	    aarch64eb) machine=aarch64_be-unknown ;;
 	    armeb) machine=armeb-unknown ;;
 	    arm*) machine=arm-unknown ;;
 	    sh3el) machine=shl-unknown ;;
@@ -188,18 +216,18 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	    earmv*)
 		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
 		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
-		machine="${arch}${endian}"-unknown
+		machine=${arch}${endian}-unknown
 		;;
-	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
+	    *) machine=$UNAME_MACHINE_ARCH-unknown ;;
 	esac
 	# The Operating System including object format, if it has switched
 	# to ELF recently (or will in the future) and ABI.
-	case "$UNAME_MACHINE_ARCH" in
+	case $UNAME_MACHINE_ARCH in
 	    earm*)
 		os=netbsdelf
 		;;
 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval "$set_cc_for_build"
+		set_cc_for_build
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 			| grep -q __ELF__
 		then
@@ -215,7 +243,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 		;;
 	esac
 	# Determine ABI tags.
-	case "$UNAME_MACHINE_ARCH" in
+	case $UNAME_MACHINE_ARCH in
 	    earm*)
 		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
 		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
@@ -226,7 +254,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	# thus, need a distinct triplet. However, they do not need
 	# kernel version information, so it can be replaced with a
 	# suitable tag, in the style of linux-gnu.
-	case "$UNAME_VERSION" in
+	case $UNAME_VERSION in
 	    Debian*)
 		release='-gnu'
 		;;
@@ -237,45 +265,57 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
 	# contains redundant information, the shorter form:
 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "$machine-${os}${release}${abi}"
-	exit ;;
+	GUESS=$machine-${os}${release}${abi-}
+	;;
     *:Bitrig:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE
+	;;
     *:OpenBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE
+	;;
+    *:SecBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'`
+	GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE
+	;;
     *:LibertyBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE
+	;;
     *:MidnightBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE
+	;;
     *:ekkoBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE
+	;;
     *:SolidBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE
+	;;
+    *:OS108:*:*)
+	GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE
+	;;
     macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE
+	;;
     *:MirBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE
+	;;
     *:Sortix:*:*)
-	echo "$UNAME_MACHINE"-unknown-sortix
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-sortix
+	;;
+    *:Twizzler:*:*)
+	GUESS=$UNAME_MACHINE-unknown-twizzler
+	;;
     *:Redox:*:*)
-	echo "$UNAME_MACHINE"-unknown-redox
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-redox
+	;;
     mips:OSF1:*.*)
-        echo mips-dec-osf1
-        exit ;;
+	GUESS=mips-dec-osf1
+	;;
     alpha:OSF1:*:*)
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	trap '' 0
 	case $UNAME_RELEASE in
 	*4.0)
 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
@@ -289,7 +329,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	# covers most systems running today.  This code pipes the CPU
 	# types through head -n 1, so we only detect the type of CPU 0.
 	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case "$ALPHA_CPU_TYPE" in
+	case $ALPHA_CPU_TYPE in
 	    "EV4 (21064)")
 		UNAME_MACHINE=alpha ;;
 	    "EV4.5 (21064)")
@@ -326,117 +366,121 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
 	# A Tn.n version is a released field test version.
 	# A Xn.n version is an unreleased experimental baselevel.
 	# 1.2 uses "1.2" for uname -r.
-	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
+	OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	GUESS=$UNAME_MACHINE-dec-osf$OSF_REL
+	;;
     Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
+	GUESS=m68k-unknown-sysv4
+	;;
     *:[Aa]miga[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-amigaos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-amigaos
+	;;
     *:[Mm]orph[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-morphos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-morphos
+	;;
     *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
+	GUESS=i370-ibm-openedition
+	;;
     *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
+	GUESS=s390-ibm-zvmoe
+	;;
     *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
+	GUESS=powerpc-ibm-os400
+	;;
     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix"$UNAME_RELEASE"
-	exit ;;
+	GUESS=arm-acorn-riscix$UNAME_RELEASE
+	;;
     arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
+	GUESS=arm-unknown-riscos
+	;;
     SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
+	GUESS=hppa1.1-hitachi-hiuxmpp
+	;;
     Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
 	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "`(/bin/universe) 2>/dev/null`" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
+	case `(/bin/universe) 2>/dev/null` in
+	    att) GUESS=pyramid-pyramid-sysv3 ;;
+	    *)   GUESS=pyramid-pyramid-bsd   ;;
+	esac
+	;;
     NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
+	GUESS=pyramid-pyramid-svr4
+	;;
     DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
+	GUESS=sparc-icl-nx6
+	;;
     DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
 	case `/usr/bin/uname -p` in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
+	    sparc) GUESS=sparc-icl-nx7 ;;
+	esac
+	;;
     s390x:SunOS:*:*)
-	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL
+	;;
     sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-hal-solaris2$SUN_REL
+	;;
     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-sun-solaris2$SUN_REL
+	;;
     i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=i386-pc-auroraux$UNAME_RELEASE
+	;;
     i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval "$set_cc_for_build"
+	set_cc_for_build
 	SUN_ARCH=i386
 	# If there is a compiler, see if it is configured for 64-bit objects.
 	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
 	# This test works for both compilers.
-	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
 	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		(CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \
 		grep IS_64BIT_ARCH >/dev/null
 	    then
 		SUN_ARCH=x86_64
 	    fi
 	fi
-	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=$SUN_ARCH-pc-solaris2$SUN_REL
+	;;
     sun4*:SunOS:6*:*)
 	# According to config.sub, this is the proper way to canonicalize
 	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
 	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=sparc-sun-solaris3$SUN_REL
+	;;
     sun4*:SunOS:*:*)
-	case "`/usr/bin/arch -k`" in
+	case `/usr/bin/arch -k` in
 	    Series*|S4*)
 		UNAME_RELEASE=`uname -v`
 		;;
 	esac
 	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'`
+	GUESS=sparc-sun-sunos$SUN_REL
+	;;
     sun3*:SunOS:*:*)
-	echo m68k-sun-sunos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-sun-sunos$UNAME_RELEASE
+	;;
     sun*:*:4.2BSD:*)
 	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
 	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case "`/bin/arch`" in
+	case `/bin/arch` in
 	    sun3)
-		echo m68k-sun-sunos"$UNAME_RELEASE"
+		GUESS=m68k-sun-sunos$UNAME_RELEASE
 		;;
 	    sun4)
-		echo sparc-sun-sunos"$UNAME_RELEASE"
+		GUESS=sparc-sun-sunos$UNAME_RELEASE
 		;;
 	esac
-	exit ;;
+	;;
     aushp:SunOS:*:*)
-	echo sparc-auspex-sunos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sparc-auspex-sunos$UNAME_RELEASE
+	;;
     # The situation for MiNT is a little confusing.  The machine name
     # can be virtually everything (everything which is not
     # "atarist" or "atariste" at least should have a processor
@@ -446,43 +490,43 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
     # MiNT.  But MiNT is downward compatible to TOS, so this should
     # be no problem.
     atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-atari-mint$UNAME_RELEASE
+	;;
     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-milan-mint$UNAME_RELEASE
+	;;
     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-hades-mint$UNAME_RELEASE
+	;;
     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-unknown-mint$UNAME_RELEASE
+	;;
     m68k:machten:*:*)
-	echo m68k-apple-machten"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-apple-machten$UNAME_RELEASE
+	;;
     powerpc:machten:*:*)
-	echo powerpc-apple-machten"$UNAME_RELEASE"
-	exit ;;
+	GUESS=powerpc-apple-machten$UNAME_RELEASE
+	;;
     RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
+	GUESS=mips-dec-mach_bsd4.3
+	;;
     RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
+	GUESS=mips-dec-ultrix$UNAME_RELEASE
+	;;
     VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
+	GUESS=vax-dec-ultrix$UNAME_RELEASE
+	;;
     2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix"$UNAME_RELEASE"
-	exit ;;
+	GUESS=clipper-intergraph-clix$UNAME_RELEASE
+	;;
     mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval "$set_cc_for_build"
+	set_cc_for_build
 	sed 's/^	//' << EOF > "$dummy.c"
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
@@ -508,78 +552,79 @@ EOF
 	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
 	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
 	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=mips-mips-riscos$UNAME_RELEASE
+	;;
     Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
+	GUESS=powerpc-motorola-powermax
+	;;
     Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
+	GUESS=powerpc-harris-powermax
+	;;
     Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
+	GUESS=powerpc-harris-powermax
+	;;
     Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
+	GUESS=powerpc-harris-powerunix
+	;;
     m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
+	GUESS=m88k-harris-cxux7
+	;;
     m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
+	GUESS=m88k-motorola-sysv4
+	;;
     m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
+	GUESS=m88k-motorola-sysv3
+	;;
     AViiON:dgux:*:*)
 	# DG/UX returns AViiON for all architectures
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ]
+	if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110
 	then
-	    if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \
-	       [ "$TARGET_BINARY_INTERFACE"x = x ]
+	    if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \
+	       test "$TARGET_BINARY_INTERFACE"x = x
 	    then
-		echo m88k-dg-dgux"$UNAME_RELEASE"
+		GUESS=m88k-dg-dgux$UNAME_RELEASE
 	    else
-		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
+		GUESS=m88k-dg-dguxbcs$UNAME_RELEASE
 	    fi
 	else
-	    echo i586-dg-dgux"$UNAME_RELEASE"
+	    GUESS=i586-dg-dgux$UNAME_RELEASE
 	fi
-	exit ;;
+	;;
     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
+	GUESS=m88k-dolphin-sysv3
+	;;
     M88*:*:R3*:*)
 	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
+	GUESS=m88k-motorola-sysv3
+	;;
     XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
+	GUESS=m88k-tektronix-sysv3
+	;;
     Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
+	GUESS=m68k-tektronix-bsd
+	;;
     *:IRIX*:*:*)
-	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
-	exit ;;
+	IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'`
+	GUESS=mips-sgi-irix$IRIX_REL
+	;;
     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+	GUESS=romp-ibm-aix    # uname -m gives an 8 hex-code CPU id
+	;;                    # Note that: echo "'`uname -s`'" gives 'AIX '
     i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
+	GUESS=i386-ibm-aix
+	;;
     ia64:AIX:*:*)
-	if [ -x /usr/bin/oslevel ] ; then
+	if test -x /usr/bin/oslevel ; then
 		IBM_REV=`/usr/bin/oslevel`
 	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
 	fi
-	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
-	exit ;;
+	GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV
+	;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval "$set_cc_for_build"
+		set_cc_for_build
 		sed 's/^		//' << EOF > "$dummy.c"
 		#include <sys/systemcfg.h>
 
@@ -593,16 +638,16 @@ EOF
 EOF
 		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
 		then
-			echo "$SYSTEM_NAME"
+			GUESS=$SYSTEM_NAME
 		else
-			echo rs6000-ibm-aix3.2.5
+			GUESS=rs6000-ibm-aix3.2.5
 		fi
 	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
+		GUESS=rs6000-ibm-aix3.2.4
 	else
-		echo rs6000-ibm-aix3.2
+		GUESS=rs6000-ibm-aix3.2
 	fi
-	exit ;;
+	;;
     *:AIX:*:[4567])
 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
 	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
@@ -610,57 +655,57 @@ EOF
 	else
 		IBM_ARCH=powerpc
 	fi
-	if [ -x /usr/bin/lslpp ] ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+	if test -x /usr/bin/lslpp ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \
 			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
 	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+		IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
 	fi
-	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
-	exit ;;
+	GUESS=$IBM_ARCH-ibm-aix$IBM_REV
+	;;
     *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
+	GUESS=rs6000-ibm-aix
+	;;
     ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
+	GUESS=romp-ibm-bsd4.4
+	;;
     ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
+	GUESS=romp-ibm-bsd$UNAME_RELEASE    # 4.3 with uname added to
+	;;                                  # report: romp-ibm BSD 4.3
     *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
+	GUESS=rs6000-bull-bosx
+	;;
     DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
+	GUESS=m68k-bull-sysv3
+	;;
     9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
+	GUESS=m68k-hp-bsd
+	;;
     hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
+	GUESS=m68k-hp-bsd4.4
+	;;
     9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	case "$UNAME_MACHINE" in
+	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
+	case $UNAME_MACHINE in
 	    9000/31?)            HP_ARCH=m68000 ;;
 	    9000/[34]??)         HP_ARCH=m68k ;;
 	    9000/[678][0-9][0-9])
-		if [ -x /usr/bin/getconf ]; then
+		if test -x /usr/bin/getconf; then
 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
 		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "$sc_cpu_version" in
+		    case $sc_cpu_version in
 		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
 		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
 		      532)                      # CPU_PA_RISC2_0
-			case "$sc_kernel_bits" in
+			case $sc_kernel_bits in
 			  32) HP_ARCH=hppa2.0n ;;
 			  64) HP_ARCH=hppa2.0w ;;
 			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
 			esac ;;
 		    esac
 		fi
-		if [ "$HP_ARCH" = "" ]; then
-		    eval "$set_cc_for_build"
+		if test "$HP_ARCH" = ""; then
+		    set_cc_for_build
 		    sed 's/^		//' << EOF > "$dummy.c"
 
 		#define _HPUX_SOURCE
@@ -698,9 +743,9 @@ EOF
 		    test -z "$HP_ARCH" && HP_ARCH=hppa
 		fi ;;
 	esac
-	if [ "$HP_ARCH" = hppa2.0w ]
+	if test "$HP_ARCH" = hppa2.0w
 	then
-	    eval "$set_cc_for_build"
+	    set_cc_for_build
 
 	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
 	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
@@ -719,14 +764,14 @@ EOF
 		HP_ARCH=hppa64
 	    fi
 	fi
-	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
-	exit ;;
+	GUESS=$HP_ARCH-hp-hpux$HPUX_REV
+	;;
     ia64:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	echo ia64-hp-hpux"$HPUX_REV"
-	exit ;;
+	HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
+	GUESS=ia64-hp-hpux$HPUX_REV
+	;;
     3050*:HI-UX:*:*)
-	eval "$set_cc_for_build"
+	set_cc_for_build
 	sed 's/^	//' << EOF > "$dummy.c"
 	#include <unistd.h>
 	int
@@ -754,36 +799,36 @@ EOF
 EOF
 	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
 		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
+	GUESS=unknown-hitachi-hiuxwe2
+	;;
     9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	echo hppa1.1-hp-bsd
-	exit ;;
+	GUESS=hppa1.1-hp-bsd
+	;;
     9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
+	GUESS=hppa1.0-hp-bsd
+	;;
     *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
+	GUESS=hppa1.0-hp-mpeix
+	;;
     hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	echo hppa1.1-hp-osf
-	exit ;;
+	GUESS=hppa1.1-hp-osf
+	;;
     hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
+	GUESS=hppa1.0-hp-osf
+	;;
     i*86:OSF1:*:*)
-	if [ -x /usr/sbin/sysversion ] ; then
-	    echo "$UNAME_MACHINE"-unknown-osf1mk
+	if test -x /usr/sbin/sysversion ; then
+	    GUESS=$UNAME_MACHINE-unknown-osf1mk
 	else
-	    echo "$UNAME_MACHINE"-unknown-osf1
+	    GUESS=$UNAME_MACHINE-unknown-osf1
 	fi
-	exit ;;
+	;;
     parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
+	GUESS=hppa1.1-hp-lites
+	;;
     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
+	GUESS=c1-convex-bsd
+	;;
     C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
 	if getsysinfo -f scalar_acc
 	then echo c32-convex-bsd
@@ -791,17 +836,18 @@ EOF
 	fi
 	exit ;;
     C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
+	GUESS=c34-convex-bsd
+	;;
     C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
+	GUESS=c38-convex-bsd
+	;;
     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
+	GUESS=c4-convex-bsd
+	;;
     CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=ymp-cray-unicos$CRAY_REL
+	;;
     CRAY*[A-Z]90:*:*:*)
 	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
@@ -809,103 +855,129 @@ EOF
 	      -e 's/\.[^.]*$/.X/'
 	exit ;;
     CRAY*TS:*:*:*)
-	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=t90-cray-unicos$CRAY_REL
+	;;
     CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=alphaev5-cray-unicosmk$CRAY_REL
+	;;
     CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=sv1-cray-unicos$CRAY_REL
+	;;
     *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
+	CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
+	GUESS=craynv-cray-unicosmp$CRAY_REL
+	;;
     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
 	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
 	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
 	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
+	GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
+	;;
     5000:UNIX_System_V:4.*:*)
 	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
 	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
+	GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
+	;;
     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE
+	;;
     sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sparc-unknown-bsdi$UNAME_RELEASE
+	;;
     *:BSD/OS:*:*)
-	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE
+	;;
+    arm:FreeBSD:*:*)
+	UNAME_PROCESSOR=`uname -p`
+	set_cc_for_build
+	if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_PCS_VFP
+	then
+	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi
+	else
+	    FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	    GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf
+	fi
+	;;
     *:FreeBSD:*:*)
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case "$UNAME_PROCESSOR" in
+	case $UNAME_PROCESSOR in
 	    amd64)
 		UNAME_PROCESSOR=x86_64 ;;
 	    i386)
 		UNAME_PROCESSOR=i586 ;;
 	esac
-	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
+	FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL
+	;;
     i*:CYGWIN*:*)
-	echo "$UNAME_MACHINE"-pc-cygwin
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-cygwin
+	;;
     *:MINGW64*:*)
-	echo "$UNAME_MACHINE"-pc-mingw64
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-mingw64
+	;;
     *:MINGW*:*)
-	echo "$UNAME_MACHINE"-pc-mingw32
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-mingw32
+	;;
     *:MSYS*:*)
-	echo "$UNAME_MACHINE"-pc-msys
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-msys
+	;;
     i*:PW*:*)
-	echo "$UNAME_MACHINE"-pc-pw32
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-pw32
+	;;
+    *:SerenityOS:*:*)
+        GUESS=$UNAME_MACHINE-pc-serenity
+        ;;
     *:Interix*:*)
-	case "$UNAME_MACHINE" in
+	case $UNAME_MACHINE in
 	    x86)
-		echo i586-pc-interix"$UNAME_RELEASE"
-		exit ;;
+		GUESS=i586-pc-interix$UNAME_RELEASE
+		;;
 	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
+		GUESS=x86_64-unknown-interix$UNAME_RELEASE
+		;;
 	    IA64)
-		echo ia64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
+		GUESS=ia64-unknown-interix$UNAME_RELEASE
+		;;
 	esac ;;
     i*:UWIN*:*)
-	echo "$UNAME_MACHINE"-pc-uwin
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-uwin
+	;;
     amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-unknown-cygwin
-	exit ;;
+	GUESS=x86_64-pc-cygwin
+	;;
     prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
+	SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
+	GUESS=powerpcle-unknown-solaris2$SUN_REL
+	;;
     *:GNU:*:*)
 	# the GNU system
-	echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
-	exit ;;
+	GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'`
+	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'`
+	GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL
+	;;
     *:GNU/*:*:*)
 	# other systems with GNU libc and userland
-	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC"
-	exit ;;
-    i*86:Minix:*:*)
-	echo "$UNAME_MACHINE"-pc-minix
-	exit ;;
+	GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"`
+	GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC
+	;;
+    *:Minix:*:*)
+	GUESS=$UNAME_MACHINE-unknown-minix
+	;;
     aarch64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     aarch64_be:Linux:*:*)
 	UNAME_MACHINE=aarch64_be
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in
 	  EV5)   UNAME_MACHINE=alphaev5 ;;
 	  EV56)  UNAME_MACHINE=alphaev56 ;;
 	  PCA56) UNAME_MACHINE=alphapca56 ;;
@@ -916,187 +988,225 @@ EOF
 	esac
 	objdump --private-headers /bin/sh | grep -q ld.so.1
 	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
+    arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     arm*:Linux:*:*)
-	eval "$set_cc_for_build"
+	set_cc_for_build
 	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
 	    | grep -q __ARM_EABI__
 	then
-	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	    GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
 	else
 	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
 		| grep -q __ARM_PCS_VFP
 	    then
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
+		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi
 	    else
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
+		GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf
 	    fi
 	fi
-	exit ;;
+	;;
     avr32*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     cris:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
+	;;
     crisv32:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-axis-linux-$LIBC
+	;;
     e2k:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     frv:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     hexagon:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     i*86:Linux:*:*)
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-linux-$LIBC
+	;;
     ia64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     k1om:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
+    loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     m32r*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     m68*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     mips:Linux:*:* | mips64:Linux:*:*)
-	eval "$set_cc_for_build"
+	set_cc_for_build
+	IS_GLIBC=0
+	test x"${LIBC}" = xgnu && IS_GLIBC=1
 	sed 's/^	//' << EOF > "$dummy.c"
 	#undef CPU
-	#undef ${UNAME_MACHINE}
-	#undef ${UNAME_MACHINE}el
+	#undef mips
+	#undef mipsel
+	#undef mips64
+	#undef mips64el
+	#if ${IS_GLIBC} && defined(_ABI64)
+	LIBCABI=gnuabi64
+	#else
+	#if ${IS_GLIBC} && defined(_ABIN32)
+	LIBCABI=gnuabin32
+	#else
+	LIBCABI=${LIBC}
+	#endif
+	#endif
+
+	#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
+	CPU=mipsisa64r6
+	#else
+	#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
+	CPU=mipsisa32r6
+	#else
+	#if defined(__mips64)
+	CPU=mips64
+	#else
+	CPU=mips
+	#endif
+	#endif
+	#endif
+
 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=${UNAME_MACHINE}el
+	MIPS_ENDIAN=el
 	#else
 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=${UNAME_MACHINE}
+	MIPS_ENDIAN=
 	#else
-	CPU=
+	MIPS_ENDIAN=
 	#endif
 	#endif
 EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
-	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
+	cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'`
+	eval "$cc_set_vars"
+	test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; }
 	;;
     mips64el:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=or1k-unknown-linux-$LIBC
+	;;
     or32:Linux:*:* | or1k*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     padre:Linux:*:*)
-	echo sparc-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=sparc-unknown-linux-$LIBC
+	;;
     parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=hppa64-unknown-linux-$LIBC
+	;;
     parisc:Linux:*:* | hppa:Linux:*:*)
 	# Look for CPU level
 	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
-	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
-	  *)    echo hppa-unknown-linux-"$LIBC" ;;
+	  PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;;
+	  PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;;
+	  *)    GUESS=hppa-unknown-linux-$LIBC ;;
 	esac
-	exit ;;
+	;;
     ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=powerpc64-unknown-linux-$LIBC
+	;;
     ppc:Linux:*:*)
-	echo powerpc-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=powerpc-unknown-linux-$LIBC
+	;;
     ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=powerpc64le-unknown-linux-$LIBC
+	;;
     ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-"$LIBC"
-	exit ;;
-    riscv32:Linux:*:* | riscv64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=powerpcle-unknown-linux-$LIBC
+	;;
+    riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     s390:Linux:*:* | s390x:Linux:*:*)
-	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-ibm-linux-$LIBC
+	;;
     sh64*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     sh*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     tile*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     vax:Linux:*:*)
-	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-dec-linux-$LIBC
+	;;
     x86_64:Linux:*:*)
-	if objdump -f /bin/sh | grep -q elf32-x86-64; then
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
-	else
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	set_cc_for_build
+	LIBCABI=$LIBC
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
+	    if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_X32 >/dev/null
+	    then
+		LIBCABI=${LIBC}x32
+	    fi
 	fi
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI
+	;;
     xtensa*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
+	;;
     i*86:DYNIX/ptx:4*:*)
 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
 	# earlier versions are messed up and put the nodename in both
 	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
+	GUESS=i386-sequent-sysv4
+	;;
     i*86:UNIX_SV:4.2MP:2.*)
 	# Unixware is an offshoot of SVR4, but it has its own version
 	# number series starting with 2...
 	# I am not positive that other SVR4 systems won't match this,
 	# I just have to hope.  -- rms.
 	# Use sysv4.2uw... so that sysv4* matches it.
-	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION
+	;;
     i*86:OS/2:*:*)
 	# If we were able to find `uname', then EMX Unix compatibility
 	# is probably installed.
-	echo "$UNAME_MACHINE"-pc-os2-emx
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-os2-emx
+	;;
     i*86:XTS-300:*:STOP)
-	echo "$UNAME_MACHINE"-unknown-stop
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-stop
+	;;
     i*86:atheos:*:*)
-	echo "$UNAME_MACHINE"-unknown-atheos
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-atheos
+	;;
     i*86:syllable:*:*)
-	echo "$UNAME_MACHINE"-pc-syllable
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-syllable
+	;;
     i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=i386-unknown-lynxos$UNAME_RELEASE
+	;;
     i*86:*DOS:*:*)
-	echo "$UNAME_MACHINE"-pc-msdosdjgpp
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-msdosdjgpp
+	;;
     i*86:*:4.*:*)
 	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
+		GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL
 	else
-		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
+		GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL
 	fi
-	exit ;;
+	;;
     i*86:*:5:[678]*)
 	# UnixWare 7.x, OpenUNIX and OpenServer 6.
 	case `/bin/uname -X | grep "^Machine"` in
@@ -1104,12 +1214,12 @@ EOF
 	    *Pentium)	     UNAME_MACHINE=i586 ;;
 	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
 	esac
-	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	;;
     i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
+		GUESS=$UNAME_MACHINE-pc-isc$UNAME_REL
 	elif /bin/uname -X 2>/dev/null >/dev/null ; then
 		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
 		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
@@ -1119,11 +1229,11 @@ EOF
 			&& UNAME_MACHINE=i686
 		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
 			&& UNAME_MACHINE=i686
-		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
+		GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL
 	else
-		echo "$UNAME_MACHINE"-pc-sysv32
+		GUESS=$UNAME_MACHINE-pc-sysv32
 	fi
-	exit ;;
+	;;
     pc:*:*:*)
 	# Left here for compatibility:
 	# uname -m prints for DJGPP always 'pc', but it prints nothing about
@@ -1131,31 +1241,31 @@ EOF
 	# Note: whatever this is, it MUST be the same as what config.sub
 	# prints for the "djgpp" host, or else GDB configure will decide that
 	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
+	GUESS=i586-pc-msdosdjgpp
+	;;
     Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
+	GUESS=i386-pc-mach3
+	;;
     paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
+	GUESS=i860-intel-osf1
+	;;
     i860:*:4.*:*) # i860-SVR4
 	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
+	  GUESS=i860-stardent-sysv$UNAME_RELEASE    # Stardent Vistra i860-SVR4
 	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
+	  GUESS=i860-unknown-sysv$UNAME_RELEASE     # Unknown i860-SVR4
 	fi
-	exit ;;
+	;;
     mini*:CTIX:SYS*5:*)
 	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
+	GUESS=m68010-convergent-sysv
+	;;
     mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
+	GUESS=m68k-convergent-sysv
+	;;
     M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
+	GUESS=m68k-diab-dnix
+	;;
     M68*:*:R3V[5678]*:*)
 	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
     3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
@@ -1180,249 +1290,404 @@ EOF
 	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
 	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-unknown-lynxos$UNAME_RELEASE
+	;;
     mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
+	GUESS=m68k-atari-sysv4
+	;;
     TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sparc-unknown-lynxos$UNAME_RELEASE
+	;;
     rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=rs6000-unknown-lynxos$UNAME_RELEASE
+	;;
     PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
+	GUESS=powerpc-unknown-lynxos$UNAME_RELEASE
+	;;
     SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv"$UNAME_RELEASE"
-	exit ;;
+	GUESS=mips-dde-sysv$UNAME_RELEASE
+	;;
     RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
+	GUESS=mips-sni-sysv4
+	;;
     RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
+	GUESS=mips-sni-sysv4
+	;;
     *:SINIX-*:*:*)
 	if uname -p 2>/dev/null >/dev/null ; then
 		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo "$UNAME_MACHINE"-sni-sysv4
+		GUESS=$UNAME_MACHINE-sni-sysv4
 	else
-		echo ns32k-sni-sysv
+		GUESS=ns32k-sni-sysv
 	fi
-	exit ;;
+	;;
     PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
 			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
+	GUESS=i586-unisys-sysv4
+	;;
     *:UNIX_System_V:4*:FTX*)
 	# From Gerald Hewes <hewes@openmarket.com>.
 	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
+	GUESS=hppa1.1-stratus-sysv4
+	;;
     *:*:*:FTX*)
 	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
+	GUESS=i860-stratus-sysv4
+	;;
     i*86:VOS:*:*)
 	# From Paul.Green@stratus.com.
-	echo "$UNAME_MACHINE"-stratus-vos
-	exit ;;
+	GUESS=$UNAME_MACHINE-stratus-vos
+	;;
     *:VOS:*:*)
 	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
+	GUESS=hppa1.1-stratus-vos
+	;;
     mc68*:A/UX:*:*)
-	echo m68k-apple-aux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=m68k-apple-aux$UNAME_RELEASE
+	;;
     news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
+	GUESS=mips-sony-newsos6
+	;;
     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if [ -d /usr/nec ]; then
-		echo mips-nec-sysv"$UNAME_RELEASE"
+	if test -d /usr/nec; then
+		GUESS=mips-nec-sysv$UNAME_RELEASE
 	else
-		echo mips-unknown-sysv"$UNAME_RELEASE"
+		GUESS=mips-unknown-sysv$UNAME_RELEASE
 	fi
-	exit ;;
+	;;
     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
+	GUESS=powerpc-be-beos
+	;;
     BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
+	GUESS=powerpc-apple-beos
+	;;
     BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
+	GUESS=i586-pc-beos
+	;;
     BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
+	GUESS=i586-pc-haiku
+	;;
     x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
+	GUESS=x86_64-unknown-haiku
+	;;
     SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx4-nec-superux$UNAME_RELEASE
+	;;
     SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx5-nec-superux$UNAME_RELEASE
+	;;
     SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx6-nec-superux$UNAME_RELEASE
+	;;
     SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx7-nec-superux$UNAME_RELEASE
+	;;
     SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx8-nec-superux$UNAME_RELEASE
+	;;
     SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sx8r-nec-superux$UNAME_RELEASE
+	;;
     SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=sxace-nec-superux$UNAME_RELEASE
+	;;
     Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
+	GUESS=powerpc-apple-rhapsody$UNAME_RELEASE
+	;;
     *:Rhapsody:*:*)
-	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE
+	;;
+    arm64:Darwin:*:*)
+	GUESS=aarch64-apple-darwin$UNAME_RELEASE
+	;;
     *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval "$set_cc_for_build"
-	if test "$UNAME_PROCESSOR" = unknown ; then
-	    UNAME_PROCESSOR=powerpc
+	UNAME_PROCESSOR=`uname -p`
+	case $UNAME_PROCESSOR in
+	    unknown) UNAME_PROCESSOR=powerpc ;;
+	esac
+	if command -v xcode-select > /dev/null 2> /dev/null && \
+		! xcode-select --print-path > /dev/null 2> /dev/null ; then
+	    # Avoid executing cc if there is no toolchain installed as
+	    # cc will be a stub that puts up a graphical alert
+	    # prompting the user to install developer tools.
+	    CC_FOR_BUILD=no_compiler_found
+	else
+	    set_cc_for_build
 	fi
-	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
-	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_64BIT_ARCH >/dev/null
-		then
-		    case $UNAME_PROCESSOR in
-			i386) UNAME_PROCESSOR=x86_64 ;;
-			powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		    esac
-		fi
-		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_PPC >/dev/null
-		then
-		    UNAME_PROCESSOR=powerpc
-		fi
+	if test "$CC_FOR_BUILD" != no_compiler_found; then
+	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		   grep IS_64BIT_ARCH >/dev/null
+	    then
+		case $UNAME_PROCESSOR in
+		    i386) UNAME_PROCESSOR=x86_64 ;;
+		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		esac
+	    fi
+	    # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+	    if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+		   (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		   grep IS_PPC >/dev/null
+	    then
+		UNAME_PROCESSOR=powerpc
 	    fi
 	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # Avoid executing cc on OS X 10.9, as it ships with a stub
-	    # that puts up a graphical alert prompting to install
-	    # developer tools.  Any system running Mac OS X 10.7 or
-	    # later (Darwin 11 and later) is required to have a 64-bit
-	    # processor. This is not true of the ARM version of Darwin
-	    # that Apple uses in portable devices.
-	    UNAME_PROCESSOR=x86_64
+	    # uname -m returns i386 or x86_64
+	    UNAME_PROCESSOR=$UNAME_MACHINE
 	fi
-	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE
+	;;
     *:procnto*:*:* | *:QNX:[0123456789]*:*)
 	UNAME_PROCESSOR=`uname -p`
 	if test "$UNAME_PROCESSOR" = x86; then
 		UNAME_PROCESSOR=i386
 		UNAME_MACHINE=pc
 	fi
-	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE
+	;;
     *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
+	GUESS=i386-pc-qnx
+	;;
     NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
+	GUESS=neo-tandem-nsk$UNAME_RELEASE
+	;;
     NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
+	GUESS=nse-tandem-nsk$UNAME_RELEASE
+	;;
     NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
+	GUESS=nsr-tandem-nsk$UNAME_RELEASE
+	;;
     NSV-*:NONSTOP_KERNEL:*:*)
-	echo nsv-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
+	GUESS=nsv-tandem-nsk$UNAME_RELEASE
+	;;
     NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
+	GUESS=nsx-tandem-nsk$UNAME_RELEASE
+	;;
     *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
+	GUESS=mips-compaq-nonstopux
+	;;
     BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
+	GUESS=bs2000-siemens-sysv
+	;;
     DS/*:UNIX_System_V:*:*)
-	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
-	exit ;;
+	GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE
+	;;
     *:Plan9:*:*)
 	# "uname -m" is not consistent, so use $cputype instead. 386
 	# is converted to i386 for consistency with other x86
 	# operating systems.
-	if test "$cputype" = 386; then
+	if test "${cputype-}" = 386; then
 	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
+	elif test "x${cputype-}" != x; then
+	    UNAME_MACHINE=$cputype
 	fi
-	echo "$UNAME_MACHINE"-unknown-plan9
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-plan9
+	;;
     *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
+	GUESS=pdp10-unknown-tops10
+	;;
     *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
+	GUESS=pdp10-unknown-tenex
+	;;
     KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
+	GUESS=pdp10-dec-tops20
+	;;
     XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
+	GUESS=pdp10-xkl-tops20
+	;;
     *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
+	GUESS=pdp10-unknown-tops20
+	;;
     *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
+	GUESS=pdp10-unknown-its
+	;;
     SEI:*:*:SEIUX)
-	echo mips-sei-seiux"$UNAME_RELEASE"
-	exit ;;
+	GUESS=mips-sei-seiux$UNAME_RELEASE
+	;;
     *:DragonFly:*:*)
-	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
+	DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
+	GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL
+	;;
     *:*VMS:*:*)
 	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "$UNAME_MACHINE" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
+	case $UNAME_MACHINE in
+	    A*) GUESS=alpha-dec-vms ;;
+	    I*) GUESS=ia64-dec-vms ;;
+	    V*) GUESS=vax-dec-vms ;;
 	esac ;;
     *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
+	GUESS=i386-pc-xenix
+	;;
     i*86:skyos:*:*)
-	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
-	exit ;;
+	SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`
+	GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL
+	;;
     i*86:rdos:*:*)
-	echo "$UNAME_MACHINE"-pc-rdos
-	exit ;;
-    i*86:AROS:*:*)
-	echo "$UNAME_MACHINE"-pc-aros
-	exit ;;
+	GUESS=$UNAME_MACHINE-pc-rdos
+	;;
+    i*86:Fiwix:*:*)
+	GUESS=$UNAME_MACHINE-pc-fiwix
+	;;
+    *:AROS:*:*)
+	GUESS=$UNAME_MACHINE-unknown-aros
+	;;
     x86_64:VMkernel:*:*)
-	echo "$UNAME_MACHINE"-unknown-esx
-	exit ;;
+	GUESS=$UNAME_MACHINE-unknown-esx
+	;;
     amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
+	GUESS=x86_64-unknown-onefs
+	;;
+    *:Unleashed:*:*)
+	GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE
+	;;
 esac
 
+# Do we have a guess based on uname results?
+if test "x$GUESS" != x; then
+    echo "$GUESS"
+    exit
+fi
+
+# No uname command or uname output not recognized.
+set_cc_for_build
+cat > "$dummy.c" <<EOF
+#ifdef _SEQUENT_
+#include <sys/types.h>
+#include <sys/utsname.h>
+#endif
+#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
+#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
+#include <signal.h>
+#if defined(_SIZE_T_) || defined(SIGLOST)
+#include <sys/utsname.h>
+#endif
+#endif
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+  "4"
+#else
+  ""
+#endif
+  ); exit (0);
+#endif
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+  struct utsname un;
+
+  uname(&un);
+  if (strncmp(un.version, "V2", 2) == 0) {
+    printf ("i386-sequent-ptx2\n"); exit (0);
+  }
+  if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+    printf ("i386-sequent-ptx1\n"); exit (0);
+  }
+  printf ("i386-sequent-ptx\n"); exit (0);
+#endif
+
+#if defined (vax)
+#if !defined (ultrix)
+#include <sys/param.h>
+#if defined (BSD)
+#if BSD == 43
+  printf ("vax-dec-bsd4.3\n"); exit (0);
+#else
+#if BSD == 199006
+  printf ("vax-dec-bsd4.3reno\n"); exit (0);
+#else
+  printf ("vax-dec-bsd\n"); exit (0);
+#endif
+#endif
+#else
+  printf ("vax-dec-bsd\n"); exit (0);
+#endif
+#else
+#if defined(_SIZE_T_) || defined(SIGLOST)
+  struct utsname un;
+  uname (&un);
+  printf ("vax-dec-ultrix%s\n", un.release); exit (0);
+#else
+  printf ("vax-dec-ultrix\n"); exit (0);
+#endif
+#endif
+#endif
+#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
+#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
+#if defined(_SIZE_T_) || defined(SIGLOST)
+  struct utsname *un;
+  uname (&un);
+  printf ("mips-dec-ultrix%s\n", un.release); exit (0);
+#else
+  printf ("mips-dec-ultrix\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` &&
+	{ echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; }
+
 echo "$0: unable to guess system type" >&2
 
-case "$UNAME_MACHINE:$UNAME_SYSTEM" in
+case $UNAME_MACHINE:$UNAME_SYSTEM in
     mips:Linux | mips64:Linux)
 	# If we got here on MIPS GNU/Linux, output extra information.
 	cat >&2 <<EOF
@@ -1439,9 +1704,17 @@ This script (version $timestamp), has failed to recognize the
 operating system you are using. If your script is old, overwrite *all*
 copies of config.guess and config.sub with the latest versions from:
 
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+  https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
 and
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+  https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
+EOF
+
+our_year=`echo $timestamp | sed 's,-.*,,'`
+thisyear=`date +%Y`
+# shellcheck disable=SC2003
+script_age=`expr "$thisyear" - "$our_year"`
+if test "$script_age" -lt 3 ; then
+   cat >&2 <<EOF
 
 If $0 has already been updated, send the following data and any
 information you think might be pertinent to config-patches@gnu.org to
@@ -1469,11 +1742,12 @@ UNAME_RELEASE = "$UNAME_RELEASE"
 UNAME_SYSTEM  = "$UNAME_SYSTEM"
 UNAME_VERSION = "$UNAME_VERSION"
 EOF
+fi
 
 exit 1
 
 # Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "timestamp='"
 # time-stamp-format: "%:y-%02m-%02d"
 # time-stamp-end: "'"
diff --git a/libssh2/config.rpath b/libssh2/config.rpath
index e082db6b..5e39f28d 100755
--- a/libssh2/config.rpath
+++ b/libssh2/config.rpath
@@ -24,6 +24,8 @@
 #   than 256 bytes, otherwise the compiler driver will dump core. The only
 #   known workaround is to choose shorter directory names for the build
 #   directory and/or the installation directory.
+#
+# SPDX-License-Identifier: FSFULLR
 
 # All known linkers require a `.a' archive for static linking (except MSVC,
 # which needs '.lib').
diff --git a/libssh2/config.sub b/libssh2/config.sub
index 1d8e98bc..dba16e84 100755
--- a/libssh2/config.sub
+++ b/libssh2/config.sub
@@ -1,12 +1,14 @@
 #! /bin/sh
 # Configuration validation subroutine script.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
+#   Copyright 1992-2022 Free Software Foundation, Inc.
 
-timestamp='2018-02-22'
+# shellcheck disable=SC2006,SC2268 # see below for rationale
+
+timestamp='2022-01-03'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
@@ -33,7 +35,7 @@ timestamp='2018-02-22'
 # Otherwise, we print the canonical config type on stdout and succeed.
 
 # You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub
 
 # This file is supposed to be the same for all GNU packages
 # and recognize all the CPU types, system types and aliases
@@ -50,6 +52,13 @@ timestamp='2018-02-22'
 #	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
 # It is wrong to echo any other type of specification.
 
+# The "shellcheck disable" line above the timestamp inhibits complaints
+# about features and limitations of the classic Bourne shell that were
+# superseded or lifted in POSIX.  However, this script identifies a wide
+# variety of pre-POSIX systems that do not have POSIX shells at all, and
+# even some reasonably current systems (Solaris 10 as case-in-point) still
+# have a pre-POSIX /bin/sh.
+
 me=`echo "$0" | sed -e 's,.*/,,'`
 
 usage="\
@@ -67,7 +76,7 @@ Report bugs and patches to <config-patches@gnu.org>."
 version="\
 GNU config.sub ($timestamp)
 
-Copyright 1992-2018 Free Software Foundation, Inc.
+Copyright 1992-2022 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -89,7 +98,7 @@ while test $# -gt 0 ; do
     - )	# Use stdin as input.
        break ;;
     -* )
-       echo "$me: invalid option $1$help"
+       echo "$me: invalid option $1$help" >&2
        exit 1 ;;
 
     *local*)
@@ -110,1223 +119,1186 @@ case $# in
     exit 1;;
 esac
 
-# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
-# Here we must recognize all the valid KERNEL-OS combinations.
-maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
-case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | cloudabi*-eabi* | \
-  storm-chaos* | os2-emx* | rtmk-nova*)
-    os=-$maybe_os
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
-    ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
-  *)
-    basic_machine=`echo "$1" | sed 's/-[^-]*$//'`
-    if [ "$basic_machine" != "$1" ]
-    then os=`echo "$1" | sed 's/.*-/-/'`
-    else os=; fi
-    ;;
-esac
+# Split fields of configuration type
+# shellcheck disable=SC2162
+saved_IFS=$IFS
+IFS="-" read field1 field2 field3 field4 <<EOF
+$1
+EOF
+IFS=$saved_IFS
 
-### Let's recognize common machines as not being operating systems so
-### that things like config.sub decstation-3100 work.  We also
-### recognize some manufacturers as not being operating systems, so we
-### can provide default operating systems below.
-case $os in
-	-sun*os*)
-		# Prevent following clause from handling this invalid input.
-		;;
-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
-		os=
-		basic_machine=$1
-		;;
-	-bluegene*)
-		os=-cnk
-		;;
-	-sim | -cisco | -oki | -wec | -winbond)
-		os=
-		basic_machine=$1
-		;;
-	-scout)
-		;;
-	-wrs)
-		os=-vxworks
-		basic_machine=$1
-		;;
-	-chorusos*)
-		os=-chorusos
-		basic_machine=$1
-		;;
-	-chorusrdb)
-		os=-chorusrdb
-		basic_machine=$1
-		;;
-	-hiux*)
-		os=-hiuxwe2
-		;;
-	-sco6)
-		os=-sco5v6
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5)
-		os=-sco3.2v5
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco4)
-		os=-sco3.2v4
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2.[4-9]*)
-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2v[4-9]*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco*)
-		os=-sco3.2v2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-udk*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-isc)
-		os=-isc2.2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-clix*)
-		basic_machine=clipper-intergraph
-		;;
-	-isc*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
+# Separate into logical components for further validation
+case $1 in
+	*-*-*-*-*)
+		echo Invalid configuration \`"$1"\': more than four components >&2
+		exit 1
 		;;
-	-lynx*)
-		os=-lynxos
+	*-*-*-*)
+		basic_machine=$field1-$field2
+		basic_os=$field3-$field4
 		;;
-	-ptx*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'`
+	*-*-*)
+		# Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two
+		# parts
+		maybe_os=$field2-$field3
+		case $maybe_os in
+			nto-qnx* | linux-* | uclinux-uclibc* \
+			| uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \
+			| netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \
+			| storm-chaos* | os2-emx* | rtmk-nova*)
+				basic_machine=$field1
+				basic_os=$maybe_os
+				;;
+			android-linux)
+				basic_machine=$field1-unknown
+				basic_os=linux-android
+				;;
+			*)
+				basic_machine=$field1-$field2
+				basic_os=$field3
+				;;
+		esac
 		;;
-	-psos*)
-		os=-psos
+	*-*)
+		# A lone config we happen to match not fitting any pattern
+		case $field1-$field2 in
+			decstation-3100)
+				basic_machine=mips-dec
+				basic_os=
+				;;
+			*-*)
+				# Second component is usually, but not always the OS
+				case $field2 in
+					# Prevent following clause from handling this valid os
+					sun*os*)
+						basic_machine=$field1
+						basic_os=$field2
+						;;
+					zephyr*)
+						basic_machine=$field1-unknown
+						basic_os=$field2
+						;;
+					# Manufacturers
+					dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \
+					| att* | 7300* | 3300* | delta* | motorola* | sun[234]* \
+					| unicom* | ibm* | next | hp | isi* | apollo | altos* \
+					| convergent* | ncr* | news | 32* | 3600* | 3100* \
+					| hitachi* | c[123]* | convex* | sun | crds | omron* | dg \
+					| ultra | tti* | harris | dolphin | highlevel | gould \
+					| cbm | ns | masscomp | apple | axis | knuth | cray \
+					| microblaze* | sim | cisco \
+					| oki | wec | wrs | winbond)
+						basic_machine=$field1-$field2
+						basic_os=
+						;;
+					*)
+						basic_machine=$field1
+						basic_os=$field2
+						;;
+				esac
+			;;
+		esac
 		;;
-	-mint | -mint[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
+	*)
+		# Convert single-component short-hands not valid as part of
+		# multi-component configurations.
+		case $field1 in
+			386bsd)
+				basic_machine=i386-pc
+				basic_os=bsd
+				;;
+			a29khif)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			adobe68k)
+				basic_machine=m68010-adobe
+				basic_os=scout
+				;;
+			alliant)
+				basic_machine=fx80-alliant
+				basic_os=
+				;;
+			altos | altos3068)
+				basic_machine=m68k-altos
+				basic_os=
+				;;
+			am29k)
+				basic_machine=a29k-none
+				basic_os=bsd
+				;;
+			amdahl)
+				basic_machine=580-amdahl
+				basic_os=sysv
+				;;
+			amiga)
+				basic_machine=m68k-unknown
+				basic_os=
+				;;
+			amigaos | amigados)
+				basic_machine=m68k-unknown
+				basic_os=amigaos
+				;;
+			amigaunix | amix)
+				basic_machine=m68k-unknown
+				basic_os=sysv4
+				;;
+			apollo68)
+				basic_machine=m68k-apollo
+				basic_os=sysv
+				;;
+			apollo68bsd)
+				basic_machine=m68k-apollo
+				basic_os=bsd
+				;;
+			aros)
+				basic_machine=i386-pc
+				basic_os=aros
+				;;
+			aux)
+				basic_machine=m68k-apple
+				basic_os=aux
+				;;
+			balance)
+				basic_machine=ns32k-sequent
+				basic_os=dynix
+				;;
+			blackfin)
+				basic_machine=bfin-unknown
+				basic_os=linux
+				;;
+			cegcc)
+				basic_machine=arm-unknown
+				basic_os=cegcc
+				;;
+			convex-c1)
+				basic_machine=c1-convex
+				basic_os=bsd
+				;;
+			convex-c2)
+				basic_machine=c2-convex
+				basic_os=bsd
+				;;
+			convex-c32)
+				basic_machine=c32-convex
+				basic_os=bsd
+				;;
+			convex-c34)
+				basic_machine=c34-convex
+				basic_os=bsd
+				;;
+			convex-c38)
+				basic_machine=c38-convex
+				basic_os=bsd
+				;;
+			cray)
+				basic_machine=j90-cray
+				basic_os=unicos
+				;;
+			crds | unos)
+				basic_machine=m68k-crds
+				basic_os=
+				;;
+			da30)
+				basic_machine=m68k-da30
+				basic_os=
+				;;
+			decstation | pmax | pmin | dec3100 | decstatn)
+				basic_machine=mips-dec
+				basic_os=
+				;;
+			delta88)
+				basic_machine=m88k-motorola
+				basic_os=sysv3
+				;;
+			dicos)
+				basic_machine=i686-pc
+				basic_os=dicos
+				;;
+			djgpp)
+				basic_machine=i586-pc
+				basic_os=msdosdjgpp
+				;;
+			ebmon29k)
+				basic_machine=a29k-amd
+				basic_os=ebmon
+				;;
+			es1800 | OSE68k | ose68k | ose | OSE)
+				basic_machine=m68k-ericsson
+				basic_os=ose
+				;;
+			gmicro)
+				basic_machine=tron-gmicro
+				basic_os=sysv
+				;;
+			go32)
+				basic_machine=i386-pc
+				basic_os=go32
+				;;
+			h8300hms)
+				basic_machine=h8300-hitachi
+				basic_os=hms
+				;;
+			h8300xray)
+				basic_machine=h8300-hitachi
+				basic_os=xray
+				;;
+			h8500hms)
+				basic_machine=h8500-hitachi
+				basic_os=hms
+				;;
+			harris)
+				basic_machine=m88k-harris
+				basic_os=sysv3
+				;;
+			hp300 | hp300hpux)
+				basic_machine=m68k-hp
+				basic_os=hpux
+				;;
+			hp300bsd)
+				basic_machine=m68k-hp
+				basic_os=bsd
+				;;
+			hppaosf)
+				basic_machine=hppa1.1-hp
+				basic_os=osf
+				;;
+			hppro)
+				basic_machine=hppa1.1-hp
+				basic_os=proelf
+				;;
+			i386mach)
+				basic_machine=i386-mach
+				basic_os=mach
+				;;
+			isi68 | isi)
+				basic_machine=m68k-isi
+				basic_os=sysv
+				;;
+			m68knommu)
+				basic_machine=m68k-unknown
+				basic_os=linux
+				;;
+			magnum | m3230)
+				basic_machine=mips-mips
+				basic_os=sysv
+				;;
+			merlin)
+				basic_machine=ns32k-utek
+				basic_os=sysv
+				;;
+			mingw64)
+				basic_machine=x86_64-pc
+				basic_os=mingw64
+				;;
+			mingw32)
+				basic_machine=i686-pc
+				basic_os=mingw32
+				;;
+			mingw32ce)
+				basic_machine=arm-unknown
+				basic_os=mingw32ce
+				;;
+			monitor)
+				basic_machine=m68k-rom68k
+				basic_os=coff
+				;;
+			morphos)
+				basic_machine=powerpc-unknown
+				basic_os=morphos
+				;;
+			moxiebox)
+				basic_machine=moxie-unknown
+				basic_os=moxiebox
+				;;
+			msdos)
+				basic_machine=i386-pc
+				basic_os=msdos
+				;;
+			msys)
+				basic_machine=i686-pc
+				basic_os=msys
+				;;
+			mvs)
+				basic_machine=i370-ibm
+				basic_os=mvs
+				;;
+			nacl)
+				basic_machine=le32-unknown
+				basic_os=nacl
+				;;
+			ncr3000)
+				basic_machine=i486-ncr
+				basic_os=sysv4
+				;;
+			netbsd386)
+				basic_machine=i386-pc
+				basic_os=netbsd
+				;;
+			netwinder)
+				basic_machine=armv4l-rebel
+				basic_os=linux
+				;;
+			news | news700 | news800 | news900)
+				basic_machine=m68k-sony
+				basic_os=newsos
+				;;
+			news1000)
+				basic_machine=m68030-sony
+				basic_os=newsos
+				;;
+			necv70)
+				basic_machine=v70-nec
+				basic_os=sysv
+				;;
+			nh3000)
+				basic_machine=m68k-harris
+				basic_os=cxux
+				;;
+			nh[45]000)
+				basic_machine=m88k-harris
+				basic_os=cxux
+				;;
+			nindy960)
+				basic_machine=i960-intel
+				basic_os=nindy
+				;;
+			mon960)
+				basic_machine=i960-intel
+				basic_os=mon960
+				;;
+			nonstopux)
+				basic_machine=mips-compaq
+				basic_os=nonstopux
+				;;
+			os400)
+				basic_machine=powerpc-ibm
+				basic_os=os400
+				;;
+			OSE68000 | ose68000)
+				basic_machine=m68000-ericsson
+				basic_os=ose
+				;;
+			os68k)
+				basic_machine=m68k-none
+				basic_os=os68k
+				;;
+			paragon)
+				basic_machine=i860-intel
+				basic_os=osf
+				;;
+			parisc)
+				basic_machine=hppa-unknown
+				basic_os=linux
+				;;
+			psp)
+				basic_machine=mipsallegrexel-sony
+				basic_os=psp
+				;;
+			pw32)
+				basic_machine=i586-unknown
+				basic_os=pw32
+				;;
+			rdos | rdos64)
+				basic_machine=x86_64-pc
+				basic_os=rdos
+				;;
+			rdos32)
+				basic_machine=i386-pc
+				basic_os=rdos
+				;;
+			rom68k)
+				basic_machine=m68k-rom68k
+				basic_os=coff
+				;;
+			sa29200)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			sei)
+				basic_machine=mips-sei
+				basic_os=seiux
+				;;
+			sequent)
+				basic_machine=i386-sequent
+				basic_os=
+				;;
+			sps7)
+				basic_machine=m68k-bull
+				basic_os=sysv2
+				;;
+			st2000)
+				basic_machine=m68k-tandem
+				basic_os=
+				;;
+			stratus)
+				basic_machine=i860-stratus
+				basic_os=sysv4
+				;;
+			sun2)
+				basic_machine=m68000-sun
+				basic_os=
+				;;
+			sun2os3)
+				basic_machine=m68000-sun
+				basic_os=sunos3
+				;;
+			sun2os4)
+				basic_machine=m68000-sun
+				basic_os=sunos4
+				;;
+			sun3)
+				basic_machine=m68k-sun
+				basic_os=
+				;;
+			sun3os3)
+				basic_machine=m68k-sun
+				basic_os=sunos3
+				;;
+			sun3os4)
+				basic_machine=m68k-sun
+				basic_os=sunos4
+				;;
+			sun4)
+				basic_machine=sparc-sun
+				basic_os=
+				;;
+			sun4os3)
+				basic_machine=sparc-sun
+				basic_os=sunos3
+				;;
+			sun4os4)
+				basic_machine=sparc-sun
+				basic_os=sunos4
+				;;
+			sun4sol2)
+				basic_machine=sparc-sun
+				basic_os=solaris2
+				;;
+			sun386 | sun386i | roadrunner)
+				basic_machine=i386-sun
+				basic_os=
+				;;
+			sv1)
+				basic_machine=sv1-cray
+				basic_os=unicos
+				;;
+			symmetry)
+				basic_machine=i386-sequent
+				basic_os=dynix
+				;;
+			t3e)
+				basic_machine=alphaev5-cray
+				basic_os=unicos
+				;;
+			t90)
+				basic_machine=t90-cray
+				basic_os=unicos
+				;;
+			toad1)
+				basic_machine=pdp10-xkl
+				basic_os=tops20
+				;;
+			tpf)
+				basic_machine=s390x-ibm
+				basic_os=tpf
+				;;
+			udi29k)
+				basic_machine=a29k-amd
+				basic_os=udi
+				;;
+			ultra3)
+				basic_machine=a29k-nyu
+				basic_os=sym1
+				;;
+			v810 | necv810)
+				basic_machine=v810-nec
+				basic_os=none
+				;;
+			vaxv)
+				basic_machine=vax-dec
+				basic_os=sysv
+				;;
+			vms)
+				basic_machine=vax-dec
+				basic_os=vms
+				;;
+			vsta)
+				basic_machine=i386-pc
+				basic_os=vsta
+				;;
+			vxworks960)
+				basic_machine=i960-wrs
+				basic_os=vxworks
+				;;
+			vxworks68)
+				basic_machine=m68k-wrs
+				basic_os=vxworks
+				;;
+			vxworks29k)
+				basic_machine=a29k-wrs
+				basic_os=vxworks
+				;;
+			xbox)
+				basic_machine=i686-pc
+				basic_os=mingw32
+				;;
+			ymp)
+				basic_machine=ymp-cray
+				basic_os=unicos
+				;;
+			*)
+				basic_machine=$1
+				basic_os=
+				;;
+		esac
 		;;
 esac
 
-# Decode aliases for certain CPU-COMPANY combinations.
+# Decode 1-component or ad-hoc basic machines
 case $basic_machine in
-	# Recognize the basic CPU types without company name.
-	# Some are omitted here because they have special meanings below.
-	1750a | 580 \
-	| a29k \
-	| aarch64 | aarch64_be \
-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
-	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| ba \
-	| be32 | be64 \
-	| bfin \
-	| c4x | c8051 | clipper \
-	| d10v | d30v | dlx | dsp16xx \
-	| e2k | epiphany \
-	| fido | fr30 | frv | ft32 \
-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
-	| i370 | i860 | i960 | ia16 | ia64 \
-	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
-	| mips | mipsbe | mipseb | mipsel | mipsle \
-	| mips16 \
-	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
-	| mips64vr | mips64vrel \
-	| mips64vr4100 | mips64vr4100el \
-	| mips64vr4300 | mips64vr4300el \
-	| mips64vr5000 | mips64vr5000el \
-	| mips64vr5900 | mips64vr5900el \
-	| mipsisa32 | mipsisa32el \
-	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
-	| mipsisa64 | mipsisa64el \
-	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
-	| mipsisa64sb1 | mipsisa64sb1el \
-	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
-	| mipstx39 | mipstx39el \
-	| mn10200 | mn10300 \
-	| moxie \
-	| mt \
-	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
-	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
-	| pdp10 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
-	| pru \
-	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
-	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
-	| sh64 | sh64le \
-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
-	| wasm32 \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
-		basic_machine=$basic_machine-unknown
-		;;
-	c54x)
-		basic_machine=tic54x-unknown
-		;;
-	c55x)
-		basic_machine=tic55x-unknown
-		;;
-	c6x)
-		basic_machine=tic6x-unknown
-		;;
-	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
-		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
-		basic_machine=$basic_machine-unknown
-		os=-none
+	# Here we handle the default manufacturer of certain CPU types.  It is in
+	# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		cpu=hppa1.1
+		vendor=winbond
 		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65)
+	op50n)
+		cpu=hppa1.1
+		vendor=oki
 		;;
-	ms1)
-		basic_machine=mt-unknown
+	op60c)
+		cpu=hppa1.1
+		vendor=oki
 		;;
-
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
+	ibm*)
+		cpu=i370
+		vendor=ibm
 		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
+	orion105)
+		cpu=clipper
+		vendor=highlevel
 		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
+	mac | mpw | mac-mpw)
+		cpu=m68k
+		vendor=apple
 		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
+	pmac | pmac-mpw)
+		cpu=powerpc
+		vendor=apple
 		;;
 
-	# We use `pc' rather than `unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-	  basic_machine=$basic_machine-pc
-	  ;;
-	# Object if more than one company name word.
-	*-*-*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-	# Recognize the basic CPU types with company name.
-	580-* \
-	| a29k-* \
-	| aarch64-* | aarch64_be-* \
-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
-	| avr-* | avr32-* \
-	| ba-* \
-	| be32-* | be64-* \
-	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
-	| d10v-* | d30v-* | dlx-* \
-	| e2k-* | elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
-	| h8300-* | h8500-* \
-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
-	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
-	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
-	| m32c-* | m32r-* | m32rle-* \
-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
-	| mips16-* \
-	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
-	| mips64vr-* | mips64vrel-* \
-	| mips64vr4100-* | mips64vr4100el-* \
-	| mips64vr4300-* | mips64vr4300el-* \
-	| mips64vr5000-* | mips64vr5000el-* \
-	| mips64vr5900-* | mips64vr5900el-* \
-	| mipsisa32-* | mipsisa32el-* \
-	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
-	| mipsisa64-* | mipsisa64el-* \
-	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
-	| mipsisa64sb1-* | mipsisa64sb1el-* \
-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
-	| mipstx39-* | mipstx39el-* \
-	| mmix-* \
-	| mt-* \
-	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
-	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
-	| orion-* \
-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
-	| pru-* \
-	| pyramid-* \
-	| riscv32-* | riscv64-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
-	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
-	| tahoe-* \
-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
-	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
-	| wasm32-* \
-	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
-	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
-		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
-	386bsd)
-		basic_machine=i386-pc
-		os=-bsd
-		;;
 	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		basic_machine=m68000-att
+		cpu=m68000
+		vendor=att
 		;;
 	3b*)
-		basic_machine=we32k-att
-		;;
-	a29khif)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	abacus)
-		basic_machine=abacus-unknown
-		;;
-	adobe68k)
-		basic_machine=m68010-adobe
-		os=-scout
-		;;
-	alliant | fx80)
-		basic_machine=fx80-alliant
-		;;
-	altos | altos3068)
-		basic_machine=m68k-altos
-		;;
-	am29k)
-		basic_machine=a29k-none
-		os=-bsd
-		;;
-	amd64)
-		basic_machine=x86_64-pc
-		;;
-	amd64-*)
-		basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	amdahl)
-		basic_machine=580-amdahl
-		os=-sysv
-		;;
-	amiga | amiga-*)
-		basic_machine=m68k-unknown
-		;;
-	amigaos | amigados)
-		basic_machine=m68k-unknown
-		os=-amigaos
-		;;
-	amigaunix | amix)
-		basic_machine=m68k-unknown
-		os=-sysv4
-		;;
-	apollo68)
-		basic_machine=m68k-apollo
-		os=-sysv
-		;;
-	apollo68bsd)
-		basic_machine=m68k-apollo
-		os=-bsd
-		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
-	asmjs)
-		basic_machine=asmjs-unknown
-		;;
-	aux)
-		basic_machine=m68k-apple
-		os=-aux
-		;;
-	balance)
-		basic_machine=ns32k-sequent
-		os=-dynix
-		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
+		cpu=we32k
+		vendor=att
 		;;
 	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c90)
-		basic_machine=c90-cray
-		os=-unicos
-		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
-	convex-c1)
-		basic_machine=c1-convex
-		os=-bsd
-		;;
-	convex-c2)
-		basic_machine=c2-convex
-		os=-bsd
-		;;
-	convex-c32)
-		basic_machine=c32-convex
-		os=-bsd
-		;;
-	convex-c34)
-		basic_machine=c34-convex
-		os=-bsd
-		;;
-	convex-c38)
-		basic_machine=c38-convex
-		os=-bsd
-		;;
-	cray | j90)
-		basic_machine=j90-cray
-		os=-unicos
-		;;
-	craynv)
-		basic_machine=craynv-cray
-		os=-unicosmp
-		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
-		os=-elf
-		;;
-	crds | unos)
-		basic_machine=m68k-crds
-		;;
-	crisv32 | crisv32-* | etraxfs*)
-		basic_machine=crisv32-axis
-		;;
-	cris | cris-* | etrax*)
-		basic_machine=cris-axis
-		;;
-	crx)
-		basic_machine=crx-unknown
-		os=-elf
-		;;
-	da30 | da30-*)
-		basic_machine=m68k-da30
-		;;
-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
-		basic_machine=mips-dec
+		cpu=powerpc
+		vendor=ibm
+		basic_os=cnk
 		;;
 	decsystem10* | dec10*)
-		basic_machine=pdp10-dec
-		os=-tops10
+		cpu=pdp10
+		vendor=dec
+		basic_os=tops10
 		;;
 	decsystem20* | dec20*)
-		basic_machine=pdp10-dec
-		os=-tops20
+		cpu=pdp10
+		vendor=dec
+		basic_os=tops20
 		;;
 	delta | 3300 | motorola-3300 | motorola-delta \
 	      | 3300-motorola | delta-motorola)
-		basic_machine=m68k-motorola
-		;;
-	delta88)
-		basic_machine=m88k-motorola
-		os=-sysv3
-		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
-	djgpp)
-		basic_machine=i586-pc
-		os=-msdosdjgpp
-		;;
-	dpx20 | dpx20-*)
-		basic_machine=rs6000-bull
-		os=-bosx
+		cpu=m68k
+		vendor=motorola
 		;;
 	dpx2*)
-		basic_machine=m68k-bull
-		os=-sysv3
-		;;
-	e500v[12])
-		basic_machine=powerpc-unknown
-		os=$os"spe"
-		;;
-	e500v[12]-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=$os"spe"
-		;;
-	ebmon29k)
-		basic_machine=a29k-amd
-		os=-ebmon
-		;;
-	elxsi)
-		basic_machine=elxsi-elxsi
-		os=-bsd
+		cpu=m68k
+		vendor=bull
+		basic_os=sysv3
 		;;
 	encore | umax | mmax)
-		basic_machine=ns32k-encore
+		cpu=ns32k
+		vendor=encore
 		;;
-	es1800 | OSE68k | ose68k | ose | OSE)
-		basic_machine=m68k-ericsson
-		os=-ose
+	elxsi)
+		cpu=elxsi
+		vendor=elxsi
+		basic_os=${basic_os:-bsd}
 		;;
 	fx2800)
-		basic_machine=i860-alliant
+		cpu=i860
+		vendor=alliant
 		;;
 	genix)
-		basic_machine=ns32k-ns
-		;;
-	gmicro)
-		basic_machine=tron-gmicro
-		os=-sysv
-		;;
-	go32)
-		basic_machine=i386-pc
-		os=-go32
+		cpu=ns32k
+		vendor=ns
 		;;
 	h3050r* | hiux*)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	h8300hms)
-		basic_machine=h8300-hitachi
-		os=-hms
-		;;
-	h8300xray)
-		basic_machine=h8300-hitachi
-		os=-xray
-		;;
-	h8500hms)
-		basic_machine=h8500-hitachi
-		os=-hms
-		;;
-	harris)
-		basic_machine=m88k-harris
-		os=-sysv3
-		;;
-	hp300-*)
-		basic_machine=m68k-hp
-		;;
-	hp300bsd)
-		basic_machine=m68k-hp
-		os=-bsd
-		;;
-	hp300hpux)
-		basic_machine=m68k-hp
-		os=-hpux
+		cpu=hppa1.1
+		vendor=hitachi
+		basic_os=hiuxwe2
 		;;
 	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		basic_machine=hppa1.0-hp
+		cpu=hppa1.0
+		vendor=hp
 		;;
 	hp9k2[0-9][0-9] | hp9k31[0-9])
-		basic_machine=m68000-hp
+		cpu=m68000
+		vendor=hp
 		;;
 	hp9k3[2-9][0-9])
-		basic_machine=m68k-hp
+		cpu=m68k
+		vendor=hp
 		;;
 	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		basic_machine=hppa1.0-hp
+		cpu=hppa1.0
+		vendor=hp
 		;;
 	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		basic_machine=hppa1.1-hp
+		cpu=hppa1.1
+		vendor=hp
 		;;
 	hp9k78[0-9] | hp78[0-9])
 		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
+		cpu=hppa1.1
+		vendor=hp
 		;;
 	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
 		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
+		cpu=hppa1.1
+		vendor=hp
 		;;
 	hp9k8[0-9][13679] | hp8[0-9][13679])
-		basic_machine=hppa1.1-hp
+		cpu=hppa1.1
+		vendor=hp
 		;;
 	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hppaosf)
-		basic_machine=hppa1.1-hp
-		os=-osf
-		;;
-	hppro)
-		basic_machine=hppa1.1-hp
-		os=-proelf
-		;;
-	i370-ibm* | ibm*)
-		basic_machine=i370-ibm
+		cpu=hppa1.0
+		vendor=hp
 		;;
 	i*86v32)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv32
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv32
 		;;
 	i*86v4*)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv4
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv4
 		;;
 	i*86v)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=sysv
 		;;
 	i*86sol2)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-solaris2
-		;;
-	i386mach)
-		basic_machine=i386-mach
-		os=-mach
+		cpu=`echo "$1" | sed -e 's/86.*/86/'`
+		vendor=pc
+		basic_os=solaris2
 		;;
-	vsta)
-		basic_machine=i386-unknown
-		os=-vsta
+	j90 | j90-cray)
+		cpu=j90
+		vendor=cray
+		basic_os=${basic_os:-unicos}
 		;;
 	iris | iris4d)
-		basic_machine=mips-sgi
-		case $os in
-		    -irix*)
+		cpu=mips
+		vendor=sgi
+		case $basic_os in
+		    irix*)
 			;;
 		    *)
-			os=-irix4
+			basic_os=irix4
 			;;
 		esac
 		;;
-	isi68 | isi)
-		basic_machine=m68k-isi
-		os=-sysv
-		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	magnum | m3230)
-		basic_machine=mips-mips
-		os=-sysv
-		;;
-	merlin)
-		basic_machine=ns32k-utek
-		os=-sysv
-		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
-	mingw32)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
 	miniframe)
-		basic_machine=m68000-convergent
-		;;
-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-	mips3*-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`
-		;;
-	mips3*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown
-		;;
-	monitor)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	morphos)
-		basic_machine=powerpc-unknown
-		os=-morphos
-		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
+		cpu=m68000
+		vendor=convergent
 		;;
-	msdos)
-		basic_machine=i386-pc
-		os=-msdos
-		;;
-	ms1-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'`
-		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
-	mvs)
-		basic_machine=i370-ibm
-		os=-mvs
-		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
-	ncr3000)
-		basic_machine=i486-ncr
-		os=-sysv4
-		;;
-	netbsd386)
-		basic_machine=i386-unknown
-		os=-netbsd
-		;;
-	netwinder)
-		basic_machine=armv4l-rebel
-		os=-linux
-		;;
-	news | news700 | news800 | news900)
-		basic_machine=m68k-sony
-		os=-newsos
-		;;
-	news1000)
-		basic_machine=m68030-sony
-		os=-newsos
+	*mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		cpu=m68k
+		vendor=atari
+		basic_os=mint
 		;;
 	news-3600 | risc-news)
-		basic_machine=mips-sony
-		os=-newsos
-		;;
-	necv70)
-		basic_machine=v70-nec
-		os=-sysv
+		cpu=mips
+		vendor=sony
+		basic_os=newsos
 		;;
 	next | m*-next)
-		basic_machine=m68k-next
-		case $os in
-		    -nextstep* )
+		cpu=m68k
+		vendor=next
+		case $basic_os in
+		    openstep*)
+		        ;;
+		    nextstep*)
 			;;
-		    -ns2*)
-		      os=-nextstep2
+		    ns2*)
+		      basic_os=nextstep2
 			;;
 		    *)
-		      os=-nextstep3
+		      basic_os=nextstep3
 			;;
 		esac
 		;;
-	nh3000)
-		basic_machine=m68k-harris
-		os=-cxux
-		;;
-	nh[45]000)
-		basic_machine=m88k-harris
-		os=-cxux
-		;;
-	nindy960)
-		basic_machine=i960-intel
-		os=-nindy
-		;;
-	mon960)
-		basic_machine=i960-intel
-		os=-mon960
-		;;
-	nonstopux)
-		basic_machine=mips-compaq
-		os=-nonstopux
-		;;
 	np1)
-		basic_machine=np1-gould
-		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
-	nsr-tandem)
-		basic_machine=nsr-tandem
-		;;
-	nsv-tandem)
-		basic_machine=nsv-tandem
-		;;
-	nsx-tandem)
-		basic_machine=nsx-tandem
+		cpu=np1
+		vendor=gould
 		;;
 	op50n-* | op60c-*)
-		basic_machine=hppa1.1-oki
-		os=-proelf
-		;;
-	openrisc | openrisc-*)
-		basic_machine=or32-unknown
-		;;
-	os400)
-		basic_machine=powerpc-ibm
-		os=-os400
-		;;
-	OSE68000 | ose68000)
-		basic_machine=m68000-ericsson
-		os=-ose
-		;;
-	os68k)
-		basic_machine=m68k-none
-		os=-os68k
+		cpu=hppa1.1
+		vendor=oki
+		basic_os=proelf
 		;;
 	pa-hitachi)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	paragon)
-		basic_machine=i860-intel
-		os=-osf
-		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
+		cpu=hppa1.1
+		vendor=hitachi
+		basic_os=hiuxwe2
 		;;
 	pbd)
-		basic_machine=sparc-tti
+		cpu=sparc
+		vendor=tti
 		;;
 	pbb)
-		basic_machine=m68k-tti
-		;;
-	pc532 | pc532-*)
-		basic_machine=ns32k-pc532
-		;;
-	pc98)
-		basic_machine=i386-pc
+		cpu=m68k
+		vendor=tti
 		;;
-	pc98-*)
-		basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium | p5 | k5 | k6 | nexgen | viac3)
-		basic_machine=i586-pc
-		;;
-	pentiumpro | p6 | 6x86 | athlon | athlon_*)
-		basic_machine=i686-pc
-		;;
-	pentiumii | pentium2 | pentiumiii | pentium3)
-		basic_machine=i686-pc
-		;;
-	pentium4)
-		basic_machine=i786-pc
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium4-*)
-		basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+	pc532)
+		cpu=ns32k
+		vendor=pc532
 		;;
 	pn)
-		basic_machine=pn-gould
-		;;
-	power)	basic_machine=power-ibm
-		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
+		cpu=pn
+		vendor=gould
 		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppcle | powerpclittle)
-		basic_machine=powerpcle-unknown
+	power)
+		cpu=power
+		vendor=ibm
 		;;
-	ppcle-* | powerpclittle-*)
-		basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+	ps2)
+		cpu=i386
+		vendor=ibm
 		;;
-	ppc64)	basic_machine=powerpc64-unknown
+	rm[46]00)
+		cpu=mips
+		vendor=siemens
 		;;
-	ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+	rtpc | rtpc-*)
+		cpu=romp
+		vendor=ibm
 		;;
-	ppc64le | powerpc64little)
-		basic_machine=powerpc64le-unknown
+	sde)
+		cpu=mipsisa32
+		vendor=sde
+		basic_os=${basic_os:-elf}
 		;;
-	ppc64le-* | powerpc64little-*)
-		basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+	simso-wrs)
+		cpu=sparclite
+		vendor=wrs
+		basic_os=vxworks
 		;;
-	ps2)
-		basic_machine=i386-ibm
+	tower | tower-32)
+		cpu=m68k
+		vendor=ncr
 		;;
-	pw32)
-		basic_machine=i586-unknown
-		os=-pw32
+	vpp*|vx|vx-*)
+		cpu=f301
+		vendor=fujitsu
 		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
+	w65)
+		cpu=w65
+		vendor=wdc
 		;;
-	rdos32)
-		basic_machine=i386-pc
-		os=-rdos
+	w89k-*)
+		cpu=hppa1.1
+		vendor=winbond
+		basic_os=proelf
 		;;
-	rom68k)
-		basic_machine=m68k-rom68k
-		os=-coff
+	none)
+		cpu=none
+		vendor=none
 		;;
-	rm[46]00)
-		basic_machine=mips-siemens
+	leon|leon[3-9])
+		cpu=sparc
+		vendor=$basic_machine
 		;;
-	rtpc | rtpc-*)
-		basic_machine=romp-ibm
+	leon-*|leon[3-9]-*)
+		cpu=sparc
+		vendor=`echo "$basic_machine" | sed 's/-.*//'`
 		;;
-	s390 | s390-*)
-		basic_machine=s390-ibm
+
+	*-*)
+		# shellcheck disable=SC2162
+		saved_IFS=$IFS
+		IFS="-" read cpu vendor <<EOF
+$basic_machine
+EOF
+		IFS=$saved_IFS
 		;;
-	s390x | s390x-*)
-		basic_machine=s390x-ibm
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i*86 | x86_64)
+		cpu=$basic_machine
+		vendor=pc
 		;;
-	sa29200)
-		basic_machine=a29k-amd
-		os=-udi
+	# These rules are duplicated from below for sake of the special case above;
+	# i.e. things that normalized to x86 arches should also default to "pc"
+	pc98)
+		cpu=i386
+		vendor=pc
 		;;
-	sb1)
-		basic_machine=mipsisa64sb1-unknown
+	x64 | amd64)
+		cpu=x86_64
+		vendor=pc
 		;;
-	sb1el)
-		basic_machine=mipsisa64sb1el-unknown
+	# Recognize the basic CPU types without company name.
+	*)
+		cpu=$basic_machine
+		vendor=unknown
 		;;
-	sde)
-		basic_machine=mipsisa32-sde
-		os=-elf
+esac
+
+unset -v basic_machine
+
+# Decode basic machines in the full and proper CPU-Company form.
+case $cpu-$vendor in
+	# Here we handle the default manufacturer of certain CPU types in canonical form. It is in
+	# some cases the only manufacturer, in others, it is the most popular.
+	craynv-unknown)
+		vendor=cray
+		basic_os=${basic_os:-unicosmp}
 		;;
-	sei)
-		basic_machine=mips-sei
-		os=-seiux
+	c90-unknown | c90-cray)
+		vendor=cray
+		basic_os=${Basic_os:-unicos}
 		;;
-	sequent)
-		basic_machine=i386-sequent
+	fx80-unknown)
+		vendor=alliant
 		;;
-	sh5el)
-		basic_machine=sh5le-unknown
+	romp-unknown)
+		vendor=ibm
 		;;
-	simso-wrs)
-		basic_machine=sparclite-wrs
-		os=-vxworks
+	mmix-unknown)
+		vendor=knuth
 		;;
-	sps7)
-		basic_machine=m68k-bull
-		os=-sysv2
+	microblaze-unknown | microblazeel-unknown)
+		vendor=xilinx
 		;;
-	spur)
-		basic_machine=spur-unknown
+	rs6000-unknown)
+		vendor=ibm
 		;;
-	st2000)
-		basic_machine=m68k-tandem
+	vax-unknown)
+		vendor=dec
 		;;
-	stratus)
-		basic_machine=i860-stratus
-		os=-sysv4
+	pdp11-unknown)
+		vendor=dec
 		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'`
+	we32k-unknown)
+		vendor=att
 		;;
-	sun2)
-		basic_machine=m68000-sun
+	cydra-unknown)
+		vendor=cydrome
 		;;
-	sun2os3)
-		basic_machine=m68000-sun
-		os=-sunos3
+	i370-ibm*)
+		vendor=ibm
 		;;
-	sun2os4)
-		basic_machine=m68000-sun
-		os=-sunos4
+	orion-unknown)
+		vendor=highlevel
 		;;
-	sun3os3)
-		basic_machine=m68k-sun
-		os=-sunos3
+	xps-unknown | xps100-unknown)
+		cpu=xps100
+		vendor=honeywell
 		;;
-	sun3os4)
-		basic_machine=m68k-sun
-		os=-sunos4
+
+	# Here we normalize CPU types with a missing or matching vendor
+	armh-unknown | armh-alt)
+		cpu=armv7l
+		vendor=alt
+		basic_os=${basic_os:-linux-gnueabihf}
 		;;
-	sun4os3)
-		basic_machine=sparc-sun
-		os=-sunos3
+	dpx20-unknown | dpx20-bull)
+		cpu=rs6000
+		vendor=bull
+		basic_os=${basic_os:-bosx}
 		;;
-	sun4os4)
-		basic_machine=sparc-sun
-		os=-sunos4
+
+	# Here we normalize CPU types irrespective of the vendor
+	amd64-*)
+		cpu=x86_64
 		;;
-	sun4sol2)
-		basic_machine=sparc-sun
-		os=-solaris2
+	blackfin-*)
+		cpu=bfin
+		basic_os=linux
 		;;
-	sun3 | sun3-*)
-		basic_machine=m68k-sun
+	c54x-*)
+		cpu=tic54x
 		;;
-	sun4)
-		basic_machine=sparc-sun
+	c55x-*)
+		cpu=tic55x
 		;;
-	sun386 | sun386i | roadrunner)
-		basic_machine=i386-sun
+	c6x-*)
+		cpu=tic6x
 		;;
-	sv1)
-		basic_machine=sv1-cray
-		os=-unicos
+	e500v[12]-*)
+		cpu=powerpc
+		basic_os=${basic_os}"spe"
 		;;
-	symmetry)
-		basic_machine=i386-sequent
-		os=-dynix
+	mips3*-*)
+		cpu=mips64
 		;;
-	t3e)
-		basic_machine=alphaev5-cray
-		os=-unicos
+	ms1-*)
+		cpu=mt
 		;;
-	t90)
-		basic_machine=t90-cray
-		os=-unicos
+	m68knommu-*)
+		cpu=m68k
+		basic_os=linux
 		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
+	m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*)
+		cpu=s12z
 		;;
-	tx39)
-		basic_machine=mipstx39-unknown
+	openrisc-*)
+		cpu=or32
 		;;
-	tx39el)
-		basic_machine=mipstx39el-unknown
+	parisc-*)
+		cpu=hppa
+		basic_os=linux
 		;;
-	toad1)
-		basic_machine=pdp10-xkl
-		os=-tops20
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+		cpu=i586
 		;;
-	tower | tower-32)
-		basic_machine=m68k-ncr
+	pentiumpro-* | p6-* | 6x86-* | athlon-* | athalon_*-*)
+		cpu=i686
 		;;
-	tpf)
-		basic_machine=s390x-ibm
-		os=-tpf
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		cpu=i686
 		;;
-	udi29k)
-		basic_machine=a29k-amd
-		os=-udi
+	pentium4-*)
+		cpu=i786
 		;;
-	ultra3)
-		basic_machine=a29k-nyu
-		os=-sym1
+	pc98-*)
+		cpu=i386
 		;;
-	v810 | necv810)
-		basic_machine=v810-nec
-		os=-none
+	ppc-* | ppcbe-*)
+		cpu=powerpc
 		;;
-	vaxv)
-		basic_machine=vax-dec
-		os=-sysv
+	ppcle-* | powerpclittle-*)
+		cpu=powerpcle
 		;;
-	vms)
-		basic_machine=vax-dec
-		os=-vms
+	ppc64-*)
+		cpu=powerpc64
 		;;
-	vpp*|vx|vx-*)
-		basic_machine=f301-fujitsu
+	ppc64le-* | powerpc64little-*)
+		cpu=powerpc64le
 		;;
-	vxworks960)
-		basic_machine=i960-wrs
-		os=-vxworks
+	sb1-*)
+		cpu=mipsisa64sb1
 		;;
-	vxworks68)
-		basic_machine=m68k-wrs
-		os=-vxworks
+	sb1el-*)
+		cpu=mipsisa64sb1el
 		;;
-	vxworks29k)
-		basic_machine=a29k-wrs
-		os=-vxworks
+	sh5e[lb]-*)
+		cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'`
 		;;
-	w65*)
-		basic_machine=w65-wdc
-		os=-none
+	spur-*)
+		cpu=spur
 		;;
-	w89k-*)
-		basic_machine=hppa1.1-winbond
-		os=-proelf
+	strongarm-* | thumb-*)
+		cpu=arm
 		;;
-	x64)
-		basic_machine=x86_64-pc
+	tx39-*)
+		cpu=mipstx39
 		;;
-	xbox)
-		basic_machine=i686-pc
-		os=-mingw32
+	tx39el-*)
+		cpu=mipstx39el
 		;;
-	xps | xps100)
-		basic_machine=xps100-honeywell
+	x64-*)
+		cpu=x86_64
 		;;
 	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'`
-		;;
-	ymp)
-		basic_machine=ymp-cray
-		os=-unicos
+		cpu=`echo "$cpu" | sed 's/^xscale/arm/'`
 		;;
-	none)
-		basic_machine=none-none
-		os=-none
+	arm64-* | aarch64le-*)
+		cpu=aarch64
 		;;
 
-# Here we handle the default manufacturer of certain CPU types.  It is in
-# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		basic_machine=hppa1.1-winbond
-		;;
-	op50n)
-		basic_machine=hppa1.1-oki
-		;;
-	op60c)
-		basic_machine=hppa1.1-oki
-		;;
-	romp)
-		basic_machine=romp-ibm
-		;;
-	mmix)
-		basic_machine=mmix-knuth
+	# Recognize the canonical CPU Types that limit and/or modify the
+	# company names they are paired with.
+	cr16-*)
+		basic_os=${basic_os:-elf}
 		;;
-	rs6000)
-		basic_machine=rs6000-ibm
+	crisv32-* | etraxfs*-*)
+		cpu=crisv32
+		vendor=axis
 		;;
-	vax)
-		basic_machine=vax-dec
+	cris-* | etrax*-*)
+		cpu=cris
+		vendor=axis
 		;;
-	pdp11)
-		basic_machine=pdp11-dec
+	crx-*)
+		basic_os=${basic_os:-elf}
 		;;
-	we32k)
-		basic_machine=we32k-att
+	neo-tandem)
+		cpu=neo
+		vendor=tandem
 		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
-		basic_machine=sh-unknown
+	nse-tandem)
+		cpu=nse
+		vendor=tandem
 		;;
-	cydra)
-		basic_machine=cydra-cydrome
+	nsr-tandem)
+		cpu=nsr
+		vendor=tandem
 		;;
-	orion)
-		basic_machine=orion-highlevel
+	nsv-tandem)
+		cpu=nsv
+		vendor=tandem
 		;;
-	orion105)
-		basic_machine=clipper-highlevel
+	nsx-tandem)
+		cpu=nsx
+		vendor=tandem
 		;;
-	mac | mpw | mac-mpw)
-		basic_machine=m68k-apple
+	mipsallegrexel-sony)
+		cpu=mipsallegrexel
+		vendor=sony
 		;;
-	pmac | pmac-mpw)
-		basic_machine=powerpc-apple
-		;;
-	*-unknown)
-		# Make sure to match an already-canonicalized machine name.
+	tile*-*)
+		basic_os=${basic_os:-linux-gnu}
 		;;
+
 	*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
+		# Recognize the canonical CPU types that are allowed with any
+		# company name.
+		case $cpu in
+			1750a | 580 \
+			| a29k \
+			| aarch64 | aarch64_be \
+			| abacus \
+			| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] \
+			| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] \
+			| alphapca5[67] | alpha64pca5[67] \
+			| am33_2.0 \
+			| amdgcn \
+			| arc | arceb | arc32 | arc64 \
+			| arm | arm[lb]e | arme[lb] | armv* \
+			| avr | avr32 \
+			| asmjs \
+			| ba \
+			| be32 | be64 \
+			| bfin | bpf | bs2000 \
+			| c[123]* | c30 | [cjt]90 | c4x \
+			| c8051 | clipper | craynv | csky | cydra \
+			| d10v | d30v | dlx | dsp16xx \
+			| e2k | elxsi | epiphany \
+			| f30[01] | f700 | fido | fr30 | frv | ft32 | fx80 \
+			| h8300 | h8500 \
+			| hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+			| hexagon \
+			| i370 | i*86 | i860 | i960 | ia16 | ia64 \
+			| ip2k | iq2000 \
+			| k1om \
+			| le32 | le64 \
+			| lm32 \
+			| loongarch32 | loongarch64 | loongarchx32 \
+			| m32c | m32r | m32rle \
+			| m5200 | m68000 | m680[012346]0 | m68360 | m683?2 | m68k \
+			| m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x \
+			| m88110 | m88k | maxq | mb | mcore | mep | metag \
+			| microblaze | microblazeel \
+			| mips | mipsbe | mipseb | mipsel | mipsle \
+			| mips16 \
+			| mips64 | mips64eb | mips64el \
+			| mips64octeon | mips64octeonel \
+			| mips64orion | mips64orionel \
+			| mips64r5900 | mips64r5900el \
+			| mips64vr | mips64vrel \
+			| mips64vr4100 | mips64vr4100el \
+			| mips64vr4300 | mips64vr4300el \
+			| mips64vr5000 | mips64vr5000el \
+			| mips64vr5900 | mips64vr5900el \
+			| mipsisa32 | mipsisa32el \
+			| mipsisa32r2 | mipsisa32r2el \
+			| mipsisa32r3 | mipsisa32r3el \
+			| mipsisa32r5 | mipsisa32r5el \
+			| mipsisa32r6 | mipsisa32r6el \
+			| mipsisa64 | mipsisa64el \
+			| mipsisa64r2 | mipsisa64r2el \
+			| mipsisa64r3 | mipsisa64r3el \
+			| mipsisa64r5 | mipsisa64r5el \
+			| mipsisa64r6 | mipsisa64r6el \
+			| mipsisa64sb1 | mipsisa64sb1el \
+			| mipsisa64sr71k | mipsisa64sr71kel \
+			| mipsr5900 | mipsr5900el \
+			| mipstx39 | mipstx39el \
+			| mmix \
+			| mn10200 | mn10300 \
+			| moxie \
+			| mt \
+			| msp430 \
+			| nds32 | nds32le | nds32be \
+			| nfp \
+			| nios | nios2 | nios2eb | nios2el \
+			| none | np1 | ns16k | ns32k | nvptx \
+			| open8 \
+			| or1k* \
+			| or32 \
+			| orion \
+			| picochip \
+			| pdp10 | pdp11 | pj | pjl | pn | power \
+			| powerpc | powerpc64 | powerpc64le | powerpcle | powerpcspe \
+			| pru \
+			| pyramid \
+			| riscv | riscv32 | riscv32be | riscv64 | riscv64be \
+			| rl78 | romp | rs6000 | rx \
+			| s390 | s390x \
+			| score \
+			| sh | shl \
+			| sh[1234] | sh[24]a | sh[24]ae[lb] | sh[23]e | she[lb] | sh[lb]e \
+			| sh[1234]e[lb] |  sh[12345][lb]e | sh[23]ele | sh64 | sh64le \
+			| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet \
+			| sparclite \
+			| sparcv8 | sparcv9 | sparcv9b | sparcv9v | sv1 | sx* \
+			| spu \
+			| tahoe \
+			| thumbv7* \
+			| tic30 | tic4x | tic54x | tic55x | tic6x | tic80 \
+			| tron \
+			| ubicom32 \
+			| v70 | v850 | v850e | v850e1 | v850es | v850e2 | v850e2v3 \
+			| vax \
+			| visium \
+			| w65 \
+			| wasm32 | wasm64 \
+			| we32k \
+			| x86 | x86_64 | xc16x | xgate | xps100 \
+			| xstormy16 | xtensa* \
+			| ymp \
+			| z8k | z80)
+				;;
+
+			*)
+				echo Invalid configuration \`"$1"\': machine \`"$cpu-$vendor"\' not recognized 1>&2
+				exit 1
+				;;
+		esac
 		;;
 esac
 
 # Here we canonicalize certain aliases for manufacturers.
-case $basic_machine in
-	*-digital*)
-		basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'`
+case $vendor in
+	digital*)
+		vendor=dec
 		;;
-	*-commodore*)
-		basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'`
+	commodore*)
+		vendor=cbm
 		;;
 	*)
 		;;
@@ -1334,203 +1306,215 @@ esac
 
 # Decode manufacturer-specific aliases for certain operating systems.
 
-if [ x"$os" != x"" ]
+if test x$basic_os != x
 then
+
+# First recognize some ad-hoc cases, or perhaps split kernel-os, or else just
+# set os.
+case $basic_os in
+	gnu/linux*)
+		kernel=linux
+		os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'`
+		;;
+	os2-emx)
+		kernel=os2
+		os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'`
+		;;
+	nto-qnx*)
+		kernel=nto
+		os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'`
+		;;
+	*-*)
+		# shellcheck disable=SC2162
+		saved_IFS=$IFS
+		IFS="-" read kernel os <<EOF
+$basic_os
+EOF
+		IFS=$saved_IFS
+		;;
+	# Default OS when just kernel was specified
+	nto*)
+		kernel=nto
+		os=`echo "$basic_os" | sed -e 's|nto|qnx|'`
+		;;
+	linux*)
+		kernel=linux
+		os=`echo "$basic_os" | sed -e 's|linux|gnu|'`
+		;;
+	*)
+		kernel=
+		os=$basic_os
+		;;
+esac
+
+# Now, normalize the OS (knowing we just have one component, it's not a kernel,
+# etc.)
 case $os in
 	# First match some system type aliases that might get confused
 	# with valid system types.
-	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
+	# solaris* is a basic system type, with this one exception.
+	auroraux)
+		os=auroraux
 		;;
-	-solaris1 | -solaris1.*)
-		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+	bluegene*)
+		os=cnk
 		;;
-	-solaris)
-		os=-solaris2
+	solaris1 | solaris1.*)
+		os=`echo "$os" | sed -e 's|solaris1|sunos4|'`
 		;;
-	-unixware*)
-		os=-sysv4.2uw
+	solaris)
+		os=solaris2
 		;;
-	-gnu/linux*)
-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+	unixware*)
+		os=sysv4.2uw
 		;;
 	# es1800 is here to avoid being matched by es* (a different OS)
-	-es1800*)
-		os=-ose
+	es1800*)
+		os=ose
 		;;
-	# Now accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST end in a * to match a version number.
-	# -sysv* is not here because it comes later, after sysvr4.
-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* | -cloudabi* | -sortix* \
-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
-	      | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \
-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
-	      | -morphos* | -superux* | -rtmk* | -windiss* \
-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \
-	      | -midnightbsd*)
-	# Remember, each alternative MUST END IN *, to match a version number.
-		;;
-	-qnx*)
-		case $basic_machine in
-		    x86-* | i*86-*)
-			;;
-		    *)
-			os=-nto$os
-			;;
-		esac
+	# Some version numbers need modification
+	chorusos*)
+		os=chorusos
 		;;
-	-nto-qnx*)
+	isc)
+		os=isc2.2
 		;;
-	-nto*)
-		os=`echo $os | sed -e 's|nto|nto-qnx|'`
+	sco6)
+		os=sco5v6
 		;;
-	-sim | -xray | -os68k* | -v88r* \
-	      | -windows* | -osx | -abug | -netware* | -os9* \
-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+	sco5)
+		os=sco3.2v5
 		;;
-	-mac*)
-		os=`echo "$os" | sed -e 's|mac|macos|'`
+	sco4)
+		os=sco3.2v4
 		;;
-	-linux-dietlibc)
-		os=-linux-dietlibc
+	sco3.2.[4-9]*)
+		os=`echo "$os" | sed -e 's/sco3.2./sco3.2v/'`
 		;;
-	-linux*)
-		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+	sco*v* | scout)
+		# Don't match below
 		;;
-	-sunos5*)
-		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
+	sco*)
+		os=sco3.2v2
 		;;
-	-sunos6*)
-		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
+	psos*)
+		os=psos
 		;;
-	-opened*)
-		os=-openedition
+	qnx*)
+		os=qnx
 		;;
-	-os400*)
-		os=-os400
+	hiux*)
+		os=hiuxwe2
 		;;
-	-wince*)
-		os=-wince
+	lynx*178)
+		os=lynxos178
 		;;
-	-utek*)
-		os=-bsd
+	lynx*5)
+		os=lynxos5
 		;;
-	-dynix*)
-		os=-bsd
+	lynxos*)
+		# don't get caught up in next wildcard
 		;;
-	-acis*)
-		os=-aos
+	lynx*)
+		os=lynxos
 		;;
-	-atheos*)
-		os=-atheos
+	mac[0-9]*)
+		os=`echo "$os" | sed -e 's|mac|macos|'`
 		;;
-	-syllable*)
-		os=-syllable
+	opened*)
+		os=openedition
 		;;
-	-386bsd)
-		os=-bsd
+	os400*)
+		os=os400
 		;;
-	-ctix* | -uts*)
-		os=-sysv
+	sunos5*)
+		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
 		;;
-	-nova*)
-		os=-rtmk-nova
+	sunos6*)
+		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
 		;;
-	-ns2)
-		os=-nextstep2
+	wince*)
+		os=wince
 		;;
-	-nsk*)
-		os=-nsk
+	utek*)
+		os=bsd
 		;;
-	# Preserve the version number of sinix5.
-	-sinix5.*)
-		os=`echo $os | sed -e 's|sinix|sysv|'`
+	dynix*)
+		os=bsd
 		;;
-	-sinix*)
-		os=-sysv4
+	acis*)
+		os=aos
 		;;
-	-tpf*)
-		os=-tpf
+	atheos*)
+		os=atheos
 		;;
-	-triton*)
-		os=-sysv3
+	syllable*)
+		os=syllable
+		;;
+	386bsd)
+		os=bsd
+		;;
+	ctix* | uts*)
+		os=sysv
+		;;
+	nova*)
+		os=rtmk-nova
+		;;
+	ns2)
+		os=nextstep2
+		;;
+	# Preserve the version number of sinix5.
+	sinix5.*)
+		os=`echo "$os" | sed -e 's|sinix|sysv|'`
 		;;
-	-oss*)
-		os=-sysv3
+	sinix*)
+		os=sysv4
 		;;
-	-svr4*)
-		os=-sysv4
+	tpf*)
+		os=tpf
 		;;
-	-svr3)
-		os=-sysv3
+	triton*)
+		os=sysv3
 		;;
-	-sysvr4)
-		os=-sysv4
+	oss*)
+		os=sysv3
 		;;
-	# This must come after -sysvr4.
-	-sysv*)
+	svr4*)
+		os=sysv4
 		;;
-	-ose*)
-		os=-ose
+	svr3)
+		os=sysv3
 		;;
-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-		os=-mint
+	sysvr4)
+		os=sysv4
 		;;
-	-zvmoe)
-		os=-zvmoe
+	ose*)
+		os=ose
 		;;
-	-dicos*)
-		os=-dicos
+	*mint | mint[0-9]* | *MiNT | MiNT[0-9]*)
+		os=mint
 		;;
-	-pikeos*)
+	dicos*)
+		os=dicos
+		;;
+	pikeos*)
 		# Until real need of OS specific support for
 		# particular features comes up, bare metal
 		# configurations are quite functional.
-		case $basic_machine in
+		case $cpu in
 		    arm*)
-			os=-eabi
+			os=eabi
 			;;
 		    *)
-			os=-elf
+			os=elf
 			;;
 		esac
 		;;
-	-nacl*)
-		;;
-	-ios)
-		;;
-	-none)
-		;;
 	*)
-		# Get rid of the `-' at the beginning of $os.
-		os=`echo $os | sed 's/[^-]*-//'`
-		echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2
-		exit 1
+		# No normalization, but not necessarily accepted, that comes below.
 		;;
 esac
+
 else
 
 # Here we handle the default operating systems that come with various machines.
@@ -1543,258 +1527,363 @@ else
 # will signal an error saying that MANUFACTURER isn't an operating
 # system, and we'll never get to this point.
 
-case $basic_machine in
+kernel=
+case $cpu-$vendor in
 	score-*)
-		os=-elf
+		os=elf
 		;;
 	spu-*)
-		os=-elf
+		os=elf
 		;;
 	*-acorn)
-		os=-riscix1.2
+		os=riscix1.2
 		;;
 	arm*-rebel)
-		os=-linux
+		kernel=linux
+		os=gnu
 		;;
 	arm*-semi)
-		os=-aout
+		os=aout
 		;;
 	c4x-* | tic4x-*)
-		os=-coff
+		os=coff
 		;;
 	c8051-*)
-		os=-elf
+		os=elf
+		;;
+	clipper-intergraph)
+		os=clix
 		;;
 	hexagon-*)
-		os=-elf
+		os=elf
 		;;
 	tic54x-*)
-		os=-coff
+		os=coff
 		;;
 	tic55x-*)
-		os=-coff
+		os=coff
 		;;
 	tic6x-*)
-		os=-coff
+		os=coff
 		;;
 	# This must come before the *-dec entry.
 	pdp10-*)
-		os=-tops20
+		os=tops20
 		;;
 	pdp11-*)
-		os=-none
+		os=none
 		;;
 	*-dec | vax-*)
-		os=-ultrix4.2
+		os=ultrix4.2
 		;;
 	m68*-apollo)
-		os=-domain
+		os=domain
 		;;
 	i386-sun)
-		os=-sunos4.0.2
+		os=sunos4.0.2
 		;;
 	m68000-sun)
-		os=-sunos3
+		os=sunos3
 		;;
 	m68*-cisco)
-		os=-aout
+		os=aout
 		;;
 	mep-*)
-		os=-elf
+		os=elf
 		;;
 	mips*-cisco)
-		os=-elf
+		os=elf
 		;;
 	mips*-*)
-		os=-elf
+		os=elf
 		;;
 	or32-*)
-		os=-coff
+		os=coff
 		;;
 	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=-sysv3
+		os=sysv3
 		;;
 	sparc-* | *-sun)
-		os=-sunos4.1.1
+		os=sunos4.1.1
 		;;
 	pru-*)
-		os=-elf
+		os=elf
 		;;
 	*-be)
-		os=-beos
+		os=beos
 		;;
 	*-ibm)
-		os=-aix
+		os=aix
 		;;
 	*-knuth)
-		os=-mmixware
+		os=mmixware
 		;;
 	*-wec)
-		os=-proelf
+		os=proelf
 		;;
 	*-winbond)
-		os=-proelf
+		os=proelf
 		;;
 	*-oki)
-		os=-proelf
+		os=proelf
 		;;
 	*-hp)
-		os=-hpux
+		os=hpux
 		;;
 	*-hitachi)
-		os=-hiux
+		os=hiux
 		;;
 	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=-sysv
+		os=sysv
 		;;
 	*-cbm)
-		os=-amigaos
+		os=amigaos
 		;;
 	*-dg)
-		os=-dgux
+		os=dgux
 		;;
 	*-dolphin)
-		os=-sysv3
+		os=sysv3
 		;;
 	m68k-ccur)
-		os=-rtu
+		os=rtu
 		;;
 	m88k-omron*)
-		os=-luna
+		os=luna
 		;;
 	*-next)
-		os=-nextstep
+		os=nextstep
 		;;
 	*-sequent)
-		os=-ptx
+		os=ptx
 		;;
 	*-crds)
-		os=-unos
+		os=unos
 		;;
 	*-ns)
-		os=-genix
+		os=genix
 		;;
 	i370-*)
-		os=-mvs
+		os=mvs
 		;;
 	*-gould)
-		os=-sysv
+		os=sysv
 		;;
 	*-highlevel)
-		os=-bsd
+		os=bsd
 		;;
 	*-encore)
-		os=-bsd
+		os=bsd
 		;;
 	*-sgi)
-		os=-irix
+		os=irix
 		;;
 	*-siemens)
-		os=-sysv4
+		os=sysv4
 		;;
 	*-masscomp)
-		os=-rtu
+		os=rtu
 		;;
 	f30[01]-fujitsu | f700-fujitsu)
-		os=-uxpv
+		os=uxpv
 		;;
 	*-rom68k)
-		os=-coff
+		os=coff
 		;;
 	*-*bug)
-		os=-coff
+		os=coff
 		;;
 	*-apple)
-		os=-macos
+		os=macos
 		;;
 	*-atari*)
-		os=-mint
+		os=mint
+		;;
+	*-wrs)
+		os=vxworks
 		;;
 	*)
-		os=-none
+		os=none
 		;;
 esac
+
 fi
 
+# Now, validate our (potentially fixed-up) OS.
+case $os in
+	# Sometimes we do "kernel-libc", so those need to count as OSes.
+	musl* | newlib* | relibc* | uclibc*)
+		;;
+	# Likewise for "kernel-abi"
+	eabi* | gnueabi*)
+		;;
+	# VxWorks passes extra cpu info in the 4th filed.
+	simlinux | simwindows | spe)
+		;;
+	# Now accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST end in a * to match a version number.
+	gnu* | android* | bsd* | mach* | minix* | genix* | ultrix* | irix* \
+	     | *vms* | esix* | aix* | cnk* | sunos | sunos[34]* \
+	     | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \
+	     | sym* |  plan9* | psp* | sim* | xray* | os68k* | v88r* \
+	     | hiux* | abug | nacl* | netware* | windows* \
+	     | os9* | macos* | osx* | ios* \
+	     | mpw* | magic* | mmixware* | mon960* | lnews* \
+	     | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \
+	     | aos* | aros* | cloudabi* | sortix* | twizzler* \
+	     | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \
+	     | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \
+	     | mirbsd* | netbsd* | dicos* | openedition* | ose* \
+	     | bitrig* | openbsd* | secbsd* | solidbsd* | libertybsd* | os108* \
+	     | ekkobsd* | freebsd* | riscix* | lynxos* | os400* \
+	     | bosx* | nextstep* | cxux* | aout* | elf* | oabi* \
+	     | ptx* | coff* | ecoff* | winnt* | domain* | vsta* \
+	     | udi* | lites* | ieee* | go32* | aux* | hcos* \
+	     | chorusrdb* | cegcc* | glidix* | serenity* \
+	     | cygwin* | msys* | pe* | moss* | proelf* | rtems* \
+	     | midipix* | mingw32* | mingw64* | mint* \
+	     | uxpv* | beos* | mpeix* | udk* | moxiebox* \
+	     | interix* | uwin* | mks* | rhapsody* | darwin* \
+	     | openstep* | oskit* | conix* | pw32* | nonstopux* \
+	     | storm-chaos* | tops10* | tenex* | tops20* | its* \
+	     | os2* | vos* | palmos* | uclinux* | nucleus* | morphos* \
+	     | scout* | superux* | sysv* | rtmk* | tpf* | windiss* \
+	     | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \
+	     | skyos* | haiku* | rdos* | toppers* | drops* | es* \
+	     | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \
+	     | midnightbsd* | amdhsa* | unleashed* | emscripten* | wasi* \
+	     | nsk* | powerunix* | genode* | zvmoe* | qnx* | emx* | zephyr* \
+	     | fiwix* )
+		;;
+	# This one is extra strict with allowed versions
+	sco3.2v2 | sco3.2v[4-9]* | sco5v6*)
+		# Don't forget version if it is 3.2v4 or newer.
+		;;
+	none)
+		;;
+	*)
+		echo Invalid configuration \`"$1"\': OS \`"$os"\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# As a final step for OS-related things, validate the OS-kernel combination
+# (given a valid OS), if there is a kernel.
+case $kernel-$os in
+	linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* \
+		   | linux-musl* | linux-relibc* | linux-uclibc* )
+		;;
+	uclinux-uclibc* )
+		;;
+	-dietlibc* | -newlib* | -musl* | -relibc* | -uclibc* )
+		# These are just libc implementations, not actual OSes, and thus
+		# require a kernel.
+		echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2
+		exit 1
+		;;
+	kfreebsd*-gnu* | kopensolaris*-gnu*)
+		;;
+	vxworks-simlinux | vxworks-simwindows | vxworks-spe)
+		;;
+	nto-qnx*)
+		;;
+	os2-emx)
+		;;
+	*-eabi* | *-gnueabi*)
+		;;
+	-*)
+		# Blank kernel with real OS is always fine.
+		;;
+	*-*)
+		echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2
+		exit 1
+		;;
+esac
+
 # Here we handle the case where we know the os, and the CPU type, but not the
 # manufacturer.  We pick the logical manufacturer.
-vendor=unknown
-case $basic_machine in
-	*-unknown)
-		case $os in
-			-riscix*)
+case $vendor in
+	unknown)
+		case $cpu-$os in
+			*-riscix*)
 				vendor=acorn
 				;;
-			-sunos*)
+			*-sunos*)
 				vendor=sun
 				;;
-			-cnk*|-aix*)
+			*-cnk* | *-aix*)
 				vendor=ibm
 				;;
-			-beos*)
+			*-beos*)
 				vendor=be
 				;;
-			-hpux*)
+			*-hpux*)
 				vendor=hp
 				;;
-			-mpeix*)
+			*-mpeix*)
 				vendor=hp
 				;;
-			-hiux*)
+			*-hiux*)
 				vendor=hitachi
 				;;
-			-unos*)
+			*-unos*)
 				vendor=crds
 				;;
-			-dgux*)
+			*-dgux*)
 				vendor=dg
 				;;
-			-luna*)
+			*-luna*)
 				vendor=omron
 				;;
-			-genix*)
+			*-genix*)
 				vendor=ns
 				;;
-			-mvs* | -opened*)
+			*-clix*)
+				vendor=intergraph
+				;;
+			*-mvs* | *-opened*)
+				vendor=ibm
+				;;
+			*-os400*)
 				vendor=ibm
 				;;
-			-os400*)
+			s390-* | s390x-*)
 				vendor=ibm
 				;;
-			-ptx*)
+			*-ptx*)
 				vendor=sequent
 				;;
-			-tpf*)
+			*-tpf*)
 				vendor=ibm
 				;;
-			-vxsim* | -vxworks* | -windiss*)
+			*-vxsim* | *-vxworks* | *-windiss*)
 				vendor=wrs
 				;;
-			-aux*)
+			*-aux*)
 				vendor=apple
 				;;
-			-hms*)
+			*-hms*)
 				vendor=hitachi
 				;;
-			-mpw* | -macos*)
+			*-mpw* | *-macos*)
 				vendor=apple
 				;;
-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+			*-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)
 				vendor=atari
 				;;
-			-vos*)
+			*-vos*)
 				vendor=stratus
 				;;
 		esac
-		basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"`
 		;;
 esac
 
-echo "$basic_machine$os"
+echo "$cpu-$vendor-${kernel:+$kernel-}$os"
 exit
 
 # Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "timestamp='"
 # time-stamp-format: "%:y-%02m-%02d"
 # time-stamp-end: "'"
diff --git a/libssh2/configure b/libssh2/configure
index 1cbf782b..bbf00d4c 100755
--- a/libssh2/configure
+++ b/libssh2/configure
@@ -1,11 +1,11 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.71 for libssh2 -.
+# Generated by GNU Autoconf 2.72 for libssh2 -.
 #
-# Report bugs to <libssh2-devel@cool.haxx.se>.
+# Report bugs to <libssh2-devel@lists.haxx.se>.
 #
 #
-# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,
+# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation,
 # Inc.
 #
 #
@@ -17,7 +17,6 @@
 
 # Be more Bourne compatible
 DUALCASE=1; export DUALCASE # for MKS sh
-as_nop=:
 if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
 then :
   emulate sh
@@ -26,12 +25,13 @@ then :
   # is contrary to our usage.  Disable this feature.
   alias -g '${1+"$@"}'='"$@"'
   setopt NO_GLOB_SUBST
-else $as_nop
-  case `(set -o) 2>/dev/null` in #(
+else case e in #(
+  e) case `(set -o) 2>/dev/null` in #(
   *posix*) :
     set -o posix ;; #(
   *) :
      ;;
+esac ;;
 esac
 fi
 
@@ -103,7 +103,7 @@ IFS=$as_save_IFS
 
      ;;
 esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
+# We did not find ourselves, most probably we were run as 'sh COMMAND'
 # in which case we are not to be found in the path.
 if test "x$as_myself" = x; then
   as_myself=$0
@@ -133,15 +133,14 @@ case $- in # ((((
 esac
 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 # Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
+# out after a failed 'exec'.
 printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
 exit 255
   fi
   # We don't want this to propagate to other subprocesses.
           { _as_can_reexec=; unset _as_can_reexec;}
 if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="as_nop=:
-if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
+  as_bourne_compatible="if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
 then :
   emulate sh
   NULLCMD=:
@@ -149,12 +148,13 @@ then :
   # is contrary to our usage.  Disable this feature.
   alias -g '\${1+\"\$@\"}'='\"\$@\"'
   setopt NO_GLOB_SUBST
-else \$as_nop
-  case \`(set -o) 2>/dev/null\` in #(
+else case e in #(
+  e) case \`(set -o) 2>/dev/null\` in #(
   *posix*) :
     set -o posix ;; #(
   *) :
      ;;
+esac ;;
 esac
 fi
 "
@@ -172,8 +172,9 @@ as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
 if ( set x; as_fn_ret_success y && test x = \"\$1\" )
 then :
 
-else \$as_nop
-  exitcode=1; echo positional parameters were not saved.
+else case e in #(
+  e) exitcode=1; echo positional parameters were not saved. ;;
+esac
 fi
 test x\$exitcode = x0 || exit 1
 blah=\$(echo \$(echo blah))
@@ -195,14 +196,15 @@ test \$(( 1 + 1 )) = 2 || exit 1"
   if (eval "$as_required") 2>/dev/null
 then :
   as_have_required=yes
-else $as_nop
-  as_have_required=no
+else case e in #(
+  e) as_have_required=no ;;
+esac
 fi
   if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
 then :
 
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+else case e in #(
+  e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 as_found=false
 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 do
@@ -235,12 +237,13 @@ IFS=$as_save_IFS
 if $as_found
 then :
 
-else $as_nop
-  if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+else case e in #(
+  e) if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
 	      as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
 then :
   CONFIG_SHELL=$SHELL as_have_required=yes
-fi
+fi ;;
+esac
 fi
 
 
@@ -262,7 +265,7 @@ case $- in # ((((
 esac
 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
 # Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
+# out after a failed 'exec'.
 printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
 exit 255
 fi
@@ -276,13 +279,14 @@ then :
     printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
   else
     printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and
-$0: libssh2-devel@cool.haxx.se about your system, including
-$0: any error possibly output before this message. Then
-$0: install a modern shell, or manually run the script
-$0: under such a shell if you do have one."
+$0: libssh2-devel@lists.haxx.se about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
   fi
   exit 1
-fi
+fi ;;
+esac
 fi
 fi
 SHELL=${CONFIG_SHELL-/bin/sh}
@@ -321,14 +325,6 @@ as_fn_exit ()
   as_fn_set_status $1
   exit $1
 } # as_fn_exit
-# as_fn_nop
-# ---------
-# Do nothing but, unlike ":", preserve the value of $?.
-as_fn_nop ()
-{
-  return $?
-}
-as_nop=as_fn_nop
 
 # as_fn_mkdir_p
 # -------------
@@ -397,11 +393,12 @@ then :
   {
     eval $1+=\$2
   }'
-else $as_nop
-  as_fn_append ()
+else case e in #(
+  e) as_fn_append ()
   {
     eval $1=\$$1\$2
-  }
+  } ;;
+esac
 fi # as_fn_append
 
 # as_fn_arith ARG...
@@ -415,21 +412,14 @@ then :
   {
     as_val=$(( $* ))
   }'
-else $as_nop
-  as_fn_arith ()
+else case e in #(
+  e) as_fn_arith ()
   {
     as_val=`expr "$@" || test $? -eq 1`
-  }
+  } ;;
+esac
 fi # as_fn_arith
 
-# as_fn_nop
-# ---------
-# Do nothing but, unlike ":", preserve the value of $?.
-as_fn_nop ()
-{
-  return $?
-}
-as_nop=as_fn_nop
 
 # as_fn_error STATUS ERROR [LINENO LOG_FD]
 # ----------------------------------------
@@ -503,6 +493,8 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
     /[$]LINENO/=
   ' <$as_myself |
     sed '
+      t clear
+      :clear
       s/[$]LINENO.*/&-/
       t lineno
       b
@@ -551,7 +543,6 @@ esac
 as_echo='printf %s\n'
 as_echo_n='printf %s'
 
-
 rm -f conf$$ conf$$.exe conf$$.file
 if test -d conf$$.dir; then
   rm -f conf$$.dir/conf$$.file
@@ -563,9 +554,9 @@ if (echo >conf$$.file) 2>/dev/null; then
   if ln -s conf$$.file conf$$ 2>/dev/null; then
     as_ln_s='ln -s'
     # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
+    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
+    # In both cases, we have to default to 'cp -pR'.
     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
       as_ln_s='cp -pR'
   elif ln conf$$.file conf$$ 2>/dev/null; then
@@ -590,10 +581,12 @@ as_test_x='test -x'
 as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
+as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
 
 # Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
+as_tr_sh="eval sed '$as_sed_sh'" # deprecated
 
 SHELL=${CONFIG_SHELL-/bin/sh}
 
@@ -623,7 +616,7 @@ PACKAGE_NAME='libssh2'
 PACKAGE_TARNAME='libssh2'
 PACKAGE_VERSION='-'
 PACKAGE_STRING='libssh2 -'
-PACKAGE_BUGREPORT='libssh2-devel@cool.haxx.se'
+PACKAGE_BUGREPORT='libssh2-devel@lists.haxx.se'
 PACKAGE_URL=''
 
 ac_unique_file="src"
@@ -659,13 +652,19 @@ ac_includes_default="\
 #endif"
 
 ac_header_c_list=
+enable_year2038=no
 ac_subst_vars='am__EXEEXT_FALSE
 am__EXEEXT_TRUE
 LTLIBOBJS
 LIBOBJS
+LIBSSH2_PC_LIBS
+LIBSSH2_PC_REQUIRES
+LIBSSH2_PC_LIBS_PRIVATE
+HAVE_LIB_STATIC_FALSE
+HAVE_LIB_STATIC_TRUE
+HAVE_WINDRES_FALSE
+HAVE_WINDRES_TRUE
 ALLOCA
-HAVE_SYS_UN_H_FALSE
-HAVE_SYS_UN_H_TRUE
 USE_OSSFUZZ_STATIC_FALSE
 USE_OSSFUZZ_STATIC_TRUE
 USE_OSSFUZZ_FLAG_FALSE
@@ -675,28 +674,25 @@ USE_OSSFUZZERS_FALSE
 USE_OSSFUZZERS_TRUE
 BUILD_EXAMPLES_FALSE
 BUILD_EXAMPLES_TRUE
+RUN_SSHD_TESTS_FALSE
+RUN_SSHD_TESTS_TRUE
+RUN_DOCKER_TESTS_FALSE
+RUN_DOCKER_TESTS_TRUE
+LIBSSH2_CFLAG_EXTRAS
 CPP
-LIBSREQUIRED
+LIBSSH2_PC_REQUIRES_PRIVATE
 LIBZ_PREFIX
 LTLIBZ
 LIBZ
 HAVE_LIBZ
-WINCNG_FALSE
-WINCNG_TRUE
-MBEDTLS_FALSE
-MBEDTLS_TRUE
-LIBGCRYPT_FALSE
-LIBGCRYPT_TRUE
-OPENSSL_FALSE
-OPENSSL_TRUE
+LIBWOLFSSL_PREFIX
+LTLIBWOLFSSL
+LIBWOLFSSL
+HAVE_LIBWOLFSSL
 LIBBCRYPT_PREFIX
 LTLIBBCRYPT
 LIBBCRYPT
 HAVE_LIBBCRYPT
-LIBCRYPT32_PREFIX
-LTLIBCRYPT32
-LIBCRYPT32
-HAVE_LIBCRYPT32
 LIBMBEDCRYPTO_PREFIX
 LTLIBMBEDCRYPTO
 LIBMBEDCRYPTO
@@ -709,6 +705,7 @@ LIBSSL_PREFIX
 LTLIBSSL
 LIBSSL
 HAVE_LIBSSL
+RC
 CXXCPP
 LT_SYS_LIBRARY_PATH
 OTOOL64
@@ -720,6 +717,7 @@ MANIFEST_TOOL
 RANLIB
 ac_ct_AR
 AR
+FILECMD
 NM
 ac_ct_DUMPBIN
 DUMPBIN
@@ -765,7 +763,7 @@ build_os
 build_vendor
 build_cpu
 build
-LIBSSH2VER
+LIBSSH2_VERSION
 CSCOPE
 ETAGS
 CTAGS
@@ -860,19 +858,21 @@ enable_rpath
 with_libssl_prefix
 with_libgcrypt_prefix
 with_libmbedcrypto_prefix
-with_libcrypt32_prefix
 with_libbcrypt_prefix
+with_libwolfssl_prefix
+enable_ecdsa_wincng
 with_libz
 with_libz_prefix
-enable_crypt_none
-enable_mac_none
-enable_gex_new
 enable_clear_memory
+enable_werror
 enable_debug
 enable_hidden_symbols
+enable_deprecated
+enable_docker_tests
+enable_sshd_tests
 enable_examples_build
 enable_ossfuzzers
-enable_werror
+enable_year2038
 '
       ac_precious_vars='build_alias
 host_alias
@@ -996,7 +996,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: \`$ac_useropt'"
+      as_fn_error $? "invalid feature name: '$ac_useropt'"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -1022,7 +1022,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: \`$ac_useropt'"
+      as_fn_error $? "invalid feature name: '$ac_useropt'"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -1235,7 +1235,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: \`$ac_useropt'"
+      as_fn_error $? "invalid package name: '$ac_useropt'"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -1251,7 +1251,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: \`$ac_useropt'"
+      as_fn_error $? "invalid package name: '$ac_useropt'"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -1281,8 +1281,8 @@ do
   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
     x_libraries=$ac_optarg ;;
 
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
+  -*) as_fn_error $? "unrecognized option: '$ac_option'
+Try '$0 --help' for more information"
     ;;
 
   *=*)
@@ -1290,7 +1290,7 @@ Try \`$0 --help' for more information"
     # Reject names that are not valid shell variable names.
     case $ac_envvar in #(
       '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+      as_fn_error $? "invalid variable name: '$ac_envvar'" ;;
     esac
     eval $ac_envvar=\$ac_optarg
     export $ac_envvar ;;
@@ -1340,7 +1340,7 @@ do
   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
 done
 
-# There might be people who depend on the old broken behavior: `$host'
+# There might be people who depend on the old broken behavior: '$host'
 # used to hold the argument of --host etc.
 # FIXME: To remove some day.
 build=$build_alias
@@ -1408,7 +1408,7 @@ if test ! -r "$srcdir/$ac_unique_file"; then
   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
 fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_msg="sources are in $srcdir, but 'cd $srcdir' does not work"
 ac_abs_confdir=`(
 	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
 	pwd)`
@@ -1436,7 +1436,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures libssh2 - to adapt to many kinds of systems.
+'configure' configures libssh2 - to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1450,11 +1450,11 @@ Configuration:
       --help=short        display options specific to this package
       --help=recursive    display the short help of all the included packages
   -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
+  -q, --quiet, --silent   do not print 'checking ...' messages
       --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -C, --config-cache      alias for '--cache-file=config.cache'
   -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+      --srcdir=DIR        find the sources in DIR [configure dir or '..']
 
 Installation directories:
   --prefix=PREFIX         install architecture-independent files in PREFIX
@@ -1462,10 +1462,10 @@ Installation directories:
   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                           [PREFIX]
 
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
+By default, 'make install' will install all the files in
+'$ac_default_prefix/bin', '$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than '$ac_default_prefix' using '--prefix',
+for instance '--prefix=\$HOME'.
 
 For better control, use the options below.
 
@@ -1531,22 +1531,24 @@ Optional Features:
   --disable-libtool-lock  avoid locking (might break parallel builds)
   --disable-largefile     omit support for large files
   --disable-rpath         do not hardcode runtime library paths
-  --enable-crypt-none     Permit "none" cipher -- NOT RECOMMENDED
-  --enable-mac-none       Permit "none" MAC -- NOT RECOMMENDED
-  --disable-gex-new       Disable "new" diffie-hellman-group-exchange-sha1
-                          method
+  --enable-ecdsa-wincng   WinCNG ECDSA support (requires Windows 10 or later)
   --disable-clear-memory  Disable clearing of memory before being freed
+  --enable-werror         Enable compiler warnings as errors
+  --disable-werror        Disable compiler warnings as errors
   --enable-debug          Enable pedantic and debug options
   --disable-debug         Disable debug options
   --enable-hidden-symbols Hide internal symbols in library
   --disable-hidden-symbols
                           Leave all symbols with default visibility in library
+                          (default)
+  --disable-deprecated    Build without deprecated APIs [default=no]
+  --disable-docker-tests  Do not run tests requiring Docker
+  --disable-sshd-tests    Do not run tests requiring sshd
   --enable-examples-build Build example applications (this is the default)
   --disable-examples-build
                           Do not build example applications
   --enable-ossfuzzers     Whether to generate the fuzzers for OSS-Fuzz
-  --enable-werror         Enable compiler warnings as errors
-  --disable-werror        Disable compiler warnings as errors
+  --enable-year2038       support timestamps after 2038
 
 Optional Packages:
   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
@@ -1559,7 +1561,7 @@ Optional Packages:
   --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
   --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
                           compiler's sysroot if not specified).
-  --with-crypto=auto|openssl|libgcrypt|mbedtls|wincng
+  --with-crypto=auto|openssl|libgcrypt|mbedtls|wincng|wolfssl
                           Select crypto backend (default: auto)
   --with-gnu-ld           assume the C compiler uses GNU ld default=no
   --with-libssl-prefix[=DIR]  search for libssl in DIR/include and DIR/lib
@@ -1568,10 +1570,10 @@ Optional Packages:
   --without-libgcrypt-prefix     don't search for libgcrypt in includedir and libdir
   --with-libmbedcrypto-prefix[=DIR]  search for libmbedcrypto in DIR/include and DIR/lib
   --without-libmbedcrypto-prefix     don't search for libmbedcrypto in includedir and libdir
-  --with-libcrypt32-prefix[=DIR]  search for libcrypt32 in DIR/include and DIR/lib
-  --without-libcrypt32-prefix     don't search for libcrypt32 in includedir and libdir
   --with-libbcrypt-prefix[=DIR]  search for libbcrypt in DIR/include and DIR/lib
   --without-libbcrypt-prefix     don't search for libbcrypt in includedir and libdir
+  --with-libwolfssl-prefix[=DIR]  search for libwolfssl in DIR/include and DIR/lib
+  --without-libwolfssl-prefix     don't search for libwolfssl in includedir and libdir
   --with-libz             Use libz for compression
   --with-libz-prefix[=DIR]  search for libz in DIR/include and DIR/lib
   --without-libz-prefix     don't search for libz in includedir and libdir
@@ -1591,10 +1593,10 @@ Some influential environment variables:
   CXXCPP      C++ preprocessor
   CPP         C preprocessor
 
-Use these variables to override the choices made by `configure' or to help
+Use these variables to override the choices made by 'configure' or to help
 it to find libraries and programs with nonstandard names/locations.
 
-Report bugs to <libssh2-devel@cool.haxx.se>.
+Report bugs to <libssh2-devel@lists.haxx.se>.
 _ACEOF
 ac_status=$?
 fi
@@ -1659,9 +1661,9 @@ test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
 libssh2 configure -
-generated by GNU Autoconf 2.71
+generated by GNU Autoconf 2.72
 
-Copyright (C) 2021 Free Software Foundation, Inc.
+Copyright (C) 2023 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 _ACEOF
@@ -1700,107 +1702,18 @@ printf "%s\n" "$ac_try_echo"; } >&5
        } && test -s conftest.$ac_objext
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-	ac_retval=1
+	ac_retval=1 ;;
+esac
 fi
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_c_try_compile
 
-# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
-# -------------------------------------------
-# Tests whether TYPE exists after having included INCLUDES, setting cache
-# variable VAR accordingly.
-ac_fn_c_check_type ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-printf %s "checking for $2... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  eval "$3=no"
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-if (sizeof ($2))
-	 return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-if (sizeof (($2)))
-	    return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-else $as_nop
-  eval "$3=yes"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_c_check_type
-
-# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
-# -------------------------------------------------------
-# Tests whether HEADER exists and can be compiled using the include files in
-# INCLUDES, setting the cache variable VAR accordingly.
-ac_fn_c_check_header_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-printf %s "checking for $2... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-#include <$2>
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  eval "$3=yes"
-else $as_nop
-  eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_c_check_header_compile
-
 # ac_fn_c_try_link LINENO
 # -----------------------
 # Try to link conftest.$ac_ext, and return whether this succeeded.
@@ -1832,11 +1745,12 @@ printf "%s\n" "$ac_try_echo"; } >&5
        }
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-	ac_retval=1
+	ac_retval=1 ;;
+esac
 fi
   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
@@ -1876,17 +1790,53 @@ printf "%s\n" "$ac_try_echo"; } >&5
        } && test -s conftest.$ac_objext
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-	ac_retval=1
+	ac_retval=1 ;;
+esac
 fi
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_cxx_try_compile
 
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+printf %s "checking for $2... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  eval "$3=yes"
+else case e in #(
+  e) eval "$3=no" ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
 # ac_fn_c_check_func LINENO FUNC VAR
 # ----------------------------------
 # Tests whether FUNC exists, setting the cache variable VAR accordingly
@@ -1898,15 +1848,15 @@ printf %s "checking for $2... " >&6; }
 if eval test \${$3+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 #define $2 innocuous_$2
 
 /* System header to define __stub macros and hopefully few prototypes,
-   which can conflict with char $2 (); below.  */
+   which can conflict with char $2 (void); below.  */
 
 #include <limits.h>
 #undef $2
@@ -1917,7 +1867,7 @@ else $as_nop
 #ifdef __cplusplus
 extern "C"
 #endif
-char $2 ();
+char $2 (void);
 /* The GNU C library defines this for functions which it implements
     to always fail with ENOSYS.  Some functions are actually named
     something starting with __ and the normal name is an alias.  */
@@ -1936,11 +1886,13 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   eval "$3=yes"
-else $as_nop
-  eval "$3=no"
+else case e in #(
+  e) eval "$3=no" ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
+    conftest$ac_exeext conftest.$ac_ext ;;
+esac
 fi
 eval ac_res=\$$3
 	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
@@ -1976,11 +1928,12 @@ printf "%s\n" "$ac_try_echo"; } >&5
        }
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-    ac_retval=1
+    ac_retval=1 ;;
+esac
 fi
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
@@ -2018,11 +1971,12 @@ printf "%s\n" "$ac_try_echo"; } >&5
        }
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-	ac_retval=1
+	ac_retval=1 ;;
+esac
 fi
   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
@@ -2064,12 +2018,13 @@ printf "%s\n" "$ac_try_echo"; } >&5
   test $ac_status = 0; }; }
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: program exited with status $ac_status" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5
        printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-       ac_retval=$ac_status
+       ac_retval=$ac_status ;;
+esac
 fi
   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
@@ -2077,58 +2032,6 @@ fi
 
 } # ac_fn_c_try_run
 
-# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR
-# ------------------------------------------------------------------
-# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR
-# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR.
-ac_fn_check_decl ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  as_decl_name=`echo $2|sed 's/ *(.*//'`
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
-printf %s "checking whether $as_decl_name is declared... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
-  eval ac_save_FLAGS=\$$6
-  as_fn_append $6 " $5"
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-#ifndef $as_decl_name
-#ifdef __cplusplus
-  (void) $as_decl_use;
-#else
-  (void) $as_decl_name;
-#endif
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  eval "$3=yes"
-else $as_nop
-  eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  eval $6=\$ac_save_FLAGS
-
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_check_decl
-
 # ac_fn_c_try_cpp LINENO
 # ----------------------
 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
@@ -2156,16 +2059,76 @@ printf "%s\n" "$ac_try_echo"; } >&5
        }
 then :
   ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-    ac_retval=1
+    ac_retval=1 ;;
+esac
 fi
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
   as_fn_set_status $ac_retval
 
 } # ac_fn_c_try_cpp
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+printf %s "checking for $2... " >&6; }
+if eval test \${$3+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main (void)
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main (void)
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+else case e in #(
+  e) eval "$3=yes" ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
+fi
+eval ac_res=\$$3
+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf "%s\n" "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_type
 ac_configure_args_raw=
 for ac_arg
 do
@@ -2191,7 +2154,7 @@ This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
 It was created by libssh2 $as_me -, which was
-generated by GNU Autoconf 2.71.  Invocation command line was
+generated by GNU Autoconf 2.72.  Invocation command line was
 
   $ $0$ac_configure_args_raw
 
@@ -2437,10 +2400,10 @@ esac
 printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
     sed 's/^/| /' "$ac_site_file" >&5
     . "$ac_site_file" \
-      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; }
   fi
 done
 
@@ -2476,9 +2439,7 @@ struct stat;
 /* Most of the following tests are stolen from RCS 5.7 src/conf.sh.  */
 struct buf { int x; };
 struct buf * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
+static char *e (char **p, int i)
 {
   return p[i];
 }
@@ -2492,6 +2453,21 @@ static char *f (char * (*g) (char **, int), char **p, ...)
   return s;
 }
 
+/* C89 style stringification. */
+#define noexpand_stringify(a) #a
+const char *stringified = noexpand_stringify(arbitrary+token=sequence);
+
+/* C89 style token pasting.  Exercises some of the corner cases that
+   e.g. old MSVC gets wrong, but not very hard. */
+#define noexpand_concat(a,b) a##b
+#define expand_concat(a,b) noexpand_concat(a,b)
+extern int vA;
+extern int vbee;
+#define aye A
+#define bee B
+int *pvA = &expand_concat(v,aye);
+int *pvbee = &noexpand_concat(v,bee);
+
 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
    function prototypes and stuff, but not \xHH hex character constants.
    These do not provoke an error unfortunately, instead are silently treated
@@ -2519,16 +2495,19 @@ ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
 
 # Test code for whether the C compiler supports C99 (global declarations)
 ac_c_conftest_c99_globals='
-// Does the compiler advertise C99 conformance?
+/* Does the compiler advertise C99 conformance? */
 #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
 # error "Compiler does not advertise C99 conformance"
 #endif
 
+// See if C++-style comments work.
+
 #include <stdbool.h>
 extern int puts (const char *);
 extern int printf (const char *, ...);
 extern int dprintf (int, const char *, ...);
 extern void *malloc (size_t);
+extern void free (void *);
 
 // Check varargs macros.  These examples are taken from C99 6.10.3.5.
 // dprintf is used instead of fprintf to avoid needing to declare
@@ -2578,7 +2557,6 @@ typedef const char *ccp;
 static inline int
 test_restrict (ccp restrict text)
 {
-  // See if C++-style comments work.
   // Iterate through items via the restricted pointer.
   // Also check for declarations in for loops.
   for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
@@ -2644,6 +2622,8 @@ ac_c_conftest_c99_main='
   ia->datasize = 10;
   for (int i = 0; i < ia->datasize; ++i)
     ia->data[i] = i * 1.234;
+  // Work around memory leak warnings.
+  free (ia);
 
   // Check named initializers.
   struct named_init ni = {
@@ -2665,7 +2645,7 @@ ac_c_conftest_c99_main='
 
 # Test code for whether the C compiler supports C11 (global declarations)
 ac_c_conftest_c11_globals='
-// Does the compiler advertise C11 conformance?
+/* Does the compiler advertise C11 conformance? */
 #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
 # error "Compiler does not advertise C11 conformance"
 #endif
@@ -2769,15 +2749,6 @@ main (int argc, char **argv)
 }
 "
 
-as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H"
-as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H"
-as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H"
-as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
-as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H"
-as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H"
-as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
-as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
-as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H"
 # Test code for whether the C++ compiler supports C++98 (global declarations)
 ac_cxx_conftest_cxx98_globals='
 // Does the compiler advertise C++98 conformance?
@@ -2994,9 +2965,18 @@ main (int argc, char **argv)
 }
 "
 
+as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H"
+as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H"
+as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H"
+as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
+as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H"
+as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H"
+as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
+as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
+as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H"
 
 # Auxiliary files required by this configure script.
-ac_aux_files="config.rpath ltmain.sh compile config.guess config.sub missing install-sh"
+ac_aux_files="config.rpath ltmain.sh compile config.guess config.sub missing install-sh tap-driver.sh"
 
 # Locations in which to look for auxiliary files.
 ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.."
@@ -3073,8 +3053,9 @@ IFS=$as_save_IFS
 if $as_found
 then :
 
-else $as_nop
-  as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5
+else case e in #(
+  e) as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 ;;
+esac
 fi
 
 
@@ -3102,12 +3083,12 @@ for ac_var in $ac_precious_vars; do
   eval ac_new_val=\$ac_env_${ac_var}_value
   case $ac_old_set,$ac_new_set in
     set,)
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5
+printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,set)
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5
+printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,);;
     *)
@@ -3116,18 +3097,18 @@ printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
 	ac_old_val_w=`echo x $ac_old_val`
 	ac_new_val_w=`echo x $ac_new_val`
 	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5
+printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;}
 	  ac_cache_corrupted=:
 	else
-	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5
+printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;}
 	  eval $ac_var=\$ac_old_val
 	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-printf "%s\n" "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-printf "%s\n" "$as_me:   current value: \`$ac_new_val'" >&2;}
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  '$ac_old_val'" >&5
+printf "%s\n" "$as_me:   former value:  '$ac_old_val'" >&2;}
+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: '$ac_new_val'" >&5
+printf "%s\n" "$as_me:   current value: '$ac_new_val'" >&2;}
       fi;;
   esac
   # Pass precious variables to config.status.
@@ -3143,11 +3124,11 @@ printf "%s\n" "$as_me:   current value: \`$ac_new_val'" >&2;}
   fi
 done
 if $ac_cache_corrupted; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
 printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file'
+  as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file'
 	    and start over" "$LINENO" 5
 fi
 ## -------------------- ##
@@ -3166,14 +3147,18 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 ac_config_headers="$ac_config_headers src/libssh2_config.h"
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
 printf %s "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
     # Check whether --enable-maintainer-mode was given.
 if test ${enable_maintainer_mode+y}
 then :
   enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
-else $as_nop
-  USE_MAINTAINER_MODE=no
+else case e in #(
+  e) USE_MAINTAINER_MODE=no ;;
+esac
 fi
 
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
@@ -3206,8 +3191,8 @@ printf %s "checking whether $am_make supports nested variables... " >&6; }
 if test ${am_cv_make_support_nested_variables+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if printf "%s\n" 'TRUE=$(BAR$(V))
+else case e in #(
+  e) if printf "%s\n" 'TRUE=$(BAR$(V))
 BAR0=false
 BAR1=true
 V=1
@@ -3217,7 +3202,8 @@ am__doit:
   am_cv_make_support_nested_variables=yes
 else
   am_cv_make_support_nested_variables=no
-fi
+fi ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
 printf "%s\n" "$am_cv_make_support_nested_variables" >&6; }
@@ -3238,8 +3224,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_path_SED+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  case $SED in
+else case e in #(
+  e) case $SED in
   [\\/]* | ?:[\\/]*)
   ac_cv_path_SED="$SED" # Let the user override the test with a path.
   ;;
@@ -3266,6 +3252,7 @@ IFS=$as_save_IFS
 
   test -z "$ac_cv_path_SED" && ac_cv_path_SED="sed-was-not-found-by-configure"
   ;;
+esac ;;
 esac
 fi
 SED=$ac_cv_path_SED
@@ -3285,11 +3272,10 @@ if test "x$SED" = "xsed-was-not-found-by-configure"; then
 printf "%s\n" "$as_me: WARNING: sed was not found, this may ruin your chances to build fine" >&2;}
 fi
 
-LIBSSH2VER=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
+LIBSSH2_VERSION=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
 am__api_version='1.16'
 
 
-
   # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
 # incompatible versions:
@@ -3310,8 +3296,8 @@ if test -z "$INSTALL"; then
 if test ${ac_cv_path_install+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+else case e in #(
+  e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
@@ -3365,7 +3351,8 @@ esac
 IFS=$as_save_IFS
 
 rm -rf conftest.one conftest.two conftest.dir
-
+ ;;
+esac
 fi
   if test ${ac_cv_path_install+y}; then
     INSTALL=$ac_cv_path_install
@@ -3461,7 +3448,7 @@ test "$program_prefix" != NONE &&
 test "$program_suffix" != NONE &&
   program_transform_name="s&\$&$program_suffix&;$program_transform_name"
 # Double any \ or $.
-# By default was `s,x,x', remove it if useless.
+# By default was 's,x,x', remove it if useless.
 ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
 program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"`
 
@@ -3504,8 +3491,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_STRIP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$STRIP"; then
+else case e in #(
+  e) if test -n "$STRIP"; then
   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -3527,7 +3514,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 STRIP=$ac_cv_prog_STRIP
 if test -n "$STRIP"; then
@@ -3549,8 +3537,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_STRIP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_STRIP"; then
+else case e in #(
+  e) if test -n "$ac_ct_STRIP"; then
   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -3572,7 +3560,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
 if test -n "$ac_ct_STRIP"; then
@@ -3608,8 +3597,8 @@ if test -z "$MKDIR_P"; then
   if test ${ac_cv_path_mkdir+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+else case e in #(
+  e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
 do
   IFS=$as_save_IFS
@@ -3623,7 +3612,7 @@ do
 	   as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue
 	   case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #(
 	     'mkdir ('*'coreutils) '* | \
-	     'BusyBox '* | \
+	     *'BusyBox '* | \
 	     'mkdir (fileutils) '4.1*)
 	       ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext
 	       break 3;;
@@ -3632,18 +3621,17 @@ do
        done
   done
 IFS=$as_save_IFS
-
+ ;;
+esac
 fi
 
   test -d ./--version && rmdir ./--version
   if test ${ac_cv_path_mkdir+y}; then
     MKDIR_P="$ac_cv_path_mkdir -p"
   else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for MKDIR_P within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    MKDIR_P="$ac_install_sh -d"
+    # As a last resort, use plain mkdir -p,
+    # in the hope it doesn't have the bugs of ancient mkdir.
+    MKDIR_P='mkdir -p'
   fi
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
@@ -3658,8 +3646,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_AWK+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AWK"; then
+else case e in #(
+  e) if test -n "$AWK"; then
   ac_cv_prog_AWK="$AWK" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -3681,7 +3669,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 AWK=$ac_cv_prog_AWK
 if test -n "$AWK"; then
@@ -3703,8 +3692,8 @@ ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
 if eval test \${ac_cv_prog_make_${ac_make}_set+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat >conftest.make <<\_ACEOF
+else case e in #(
+  e) cat >conftest.make <<\_ACEOF
 SHELL = /bin/sh
 all:
 	@echo '@@@%%%=$(MAKE)=@@@%%%'
@@ -3716,7 +3705,8 @@ case `${MAKE-make} -f conftest.make 2>/dev/null` in
   *)
     eval ac_cv_prog_make_${ac_make}_set=no;;
 esac
-rm -f conftest.make
+rm -f conftest.make ;;
+esac
 fi
 if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
@@ -3864,13 +3854,14 @@ fi
 
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking libssh2 version" >&5
 printf %s "checking libssh2 version... " >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBSSH2VER" >&5
-printf "%s\n" "$LIBSSH2VER" >&6; }
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBSSH2_VERSION" >&5
+printf "%s\n" "$LIBSSH2_VERSION" >&6; }
 
 
 
-AB_VERSION=$LIBSSH2VER
-
+# Check for the OS.
+# Daniel's note: this should not be necessary and we need to work to
+# get this removed.
 
 
   # Make sure we can run config.sub.
@@ -3882,15 +3873,16 @@ printf %s "checking build system type... " >&6; }
 if test ${ac_cv_build+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_build_alias=$build_alias
+else case e in #(
+  e) ac_build_alias=$build_alias
 test "x$ac_build_alias" = x &&
   ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
 test "x$ac_build_alias" = x &&
   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
 ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
   as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
 printf "%s\n" "$ac_cv_build" >&6; }
@@ -3917,14 +3909,15 @@ printf %s "checking host system type... " >&6; }
 if test ${ac_cv_host+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test "x$host_alias" = x; then
+else case e in #(
+  e) if test "x$host_alias" = x; then
   ac_cv_host=$ac_cv_build
 else
   ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
     as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
 fi
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
 printf "%s\n" "$ac_cv_host" >&6; }
@@ -3946,51 +3939,11 @@ IFS=$ac_save_IFS
 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
 
 
-
-
-
-
-	if test -z "$AB_PACKAGE"; then
-	   AB_PACKAGE=${PACKAGE_NAME:-$PACKAGE}
-	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild project... $AB_PACKAGE" >&5
-printf "%s\n" "$as_me: autobuild project... $AB_PACKAGE" >&6;}
-
-	if test -z "$AB_VERSION"; then
-	   AB_VERSION=${PACKAGE_VERSION:-$VERSION}
-	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild revision... $AB_VERSION" >&5
-printf "%s\n" "$as_me: autobuild revision... $AB_VERSION" >&6;}
-
-	hostname=`hostname`
-	if test "$hostname"; then
-	   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild hostname... $hostname" >&5
-printf "%s\n" "$as_me: autobuild hostname... $hostname" >&6;}
-	fi
-
-
-
-	date=`date +%Y%m%d-%H%M%S`
-	if test "$?" != 0; then
-	   date=`date`
-	fi
-	if test "$date"; then
-	   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild timestamp... $date" >&5
-printf "%s\n" "$as_me: autobuild timestamp... $date" >&6;}
-	fi
-
-
-# Check for the OS.
-# Daniel's note: this should not be necessary and we need to work to
-# get this removed.
-
 case "$host" in
     *-mingw*)
-    CFLAGS="$CFLAGS -DLIBSSH2_WIN32"
     LIBS="$LIBS -lws2_32"
     ;;
     *darwin*)
-    CFLAGS="$CFLAGS -DLIBSSH2_DARWIN"
     ;;
     *hpux*)
     ;;
@@ -4087,8 +4040,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4110,7 +4063,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -4132,8 +4086,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4155,7 +4109,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -4190,8 +4145,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4213,7 +4168,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -4235,8 +4191,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   ac_prog_rejected=no
@@ -4275,7 +4231,8 @@ if test $ac_prog_rejected = yes; then
     ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
   fi
 fi
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -4299,8 +4256,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4322,7 +4279,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -4348,8 +4306,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4371,7 +4329,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -4409,8 +4368,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4432,7 +4391,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -4454,8 +4414,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -4477,7 +4437,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -4506,10 +4467,10 @@ fi
 fi
 
 
-test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; }
 
 # Provide some information about the compiler.
 printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
@@ -4581,8 +4542,8 @@ printf "%s\n" "$ac_try_echo"; } >&5
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }
 then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+  # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'.
+# So ignore a value of 'no', otherwise this would lead to 'EXEEXT = no'
 # in a Makefile.  We should not override ac_cv_exeext if it was cached,
 # so that the user can short-circuit this test for compilers unknown to
 # Autoconf.
@@ -4602,7 +4563,7 @@ do
 	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 	fi
 	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
+	# safe: cross compilers may not add the suffix if given an '-o'
 	# argument, so we may need to know it at that point already.
 	# Even if this section looks crufty: it has the advantage of
 	# actually working.
@@ -4613,8 +4574,9 @@ do
 done
 test "$ac_cv_exeext" = no && ac_cv_exeext=
 
-else $as_nop
-  ac_file=''
+else case e in #(
+  e) ac_file='' ;;
+esac
 fi
 if test -z "$ac_file"
 then :
@@ -4623,13 +4585,14 @@ printf "%s\n" "no" >&6; }
 printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+See 'config.log' for more details" "$LINENO" 5; }
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; } ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
 printf %s "checking for C compiler default output file name... " >&6; }
@@ -4653,10 +4616,10 @@ printf "%s\n" "$ac_try_echo"; } >&5
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }
 then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
+  # If both 'conftest.exe' and 'conftest' are 'present' (well, observable)
+# catch 'conftest.exe'.  For instance with Cygwin, 'ls conftest' will
+# work properly (i.e., refer to 'conftest.exe'), while it won't with
+# 'rm'.
 for ac_file in conftest.exe conftest conftest.*; do
   test -f "$ac_file" || continue
   case $ac_file in
@@ -4666,11 +4629,12 @@ for ac_file in conftest.exe conftest conftest.*; do
     * ) break;;
   esac
 done
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+else case e in #(
+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; } ;;
+esac
 fi
 rm -f conftest conftest$ac_cv_exeext
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
@@ -4686,6 +4650,8 @@ int
 main (void)
 {
 FILE *f = fopen ("conftest.out", "w");
+ if (!f)
+  return 1;
  return ferror (f) || fclose (f) != 0;
 
   ;
@@ -4725,26 +4691,27 @@ printf "%s\n" "$ac_try_echo"; } >&5
     if test "$cross_compiling" = maybe; then
 	cross_compiling=yes
     else
-	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error 77 "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
+If you meant to cross compile, use '--host'.
+See 'config.log' for more details" "$LINENO" 5; }
     fi
   fi
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
 printf "%s\n" "$cross_compiling" >&6; }
 
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+rm -f conftest.$ac_ext conftest$ac_cv_exeext \
+  conftest.o conftest.obj conftest.out
 ac_clean_files=$ac_clean_files_save
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
 printf %s "checking for suffix of object files... " >&6; }
 if test ${ac_cv_objext+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -4776,16 +4743,18 @@ then :
        break;;
   esac
 done
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
+else case e in #(
+  e) printf "%s\n" "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; } ;;
+esac
 fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
+rm -f conftest.$ac_cv_objext conftest.$ac_ext ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
 printf "%s\n" "$ac_cv_objext" >&6; }
@@ -4796,8 +4765,8 @@ printf %s "checking whether the compiler supports GNU C... " >&6; }
 if test ${ac_cv_c_compiler_gnu+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -4814,12 +4783,14 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
+else case e in #(
+  e) ac_compiler_gnu=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
@@ -4837,8 +4808,8 @@ printf %s "checking whether $CC accepts -g... " >&6; }
 if test ${ac_cv_prog_cc_g+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_save_c_werror_flag=$ac_c_werror_flag
+else case e in #(
+  e) ac_save_c_werror_flag=$ac_c_werror_flag
    ac_c_werror_flag=yes
    ac_cv_prog_cc_g=no
    CFLAGS="-g"
@@ -4856,8 +4827,8 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_prog_cc_g=yes
-else $as_nop
-  CFLAGS=""
+else case e in #(
+  e) CFLAGS=""
       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -4872,8 +4843,8 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
 
-else $as_nop
-  ac_c_werror_flag=$ac_save_c_werror_flag
+else case e in #(
+  e) ac_c_werror_flag=$ac_save_c_werror_flag
 	 CFLAGS="-g"
 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -4890,12 +4861,15 @@ if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_prog_cc_g=yes
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
+   ac_c_werror_flag=$ac_save_c_werror_flag ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
 printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
@@ -4922,8 +4896,8 @@ printf %s "checking for $CC option to enable C11 features... " >&6; }
 if test ${ac_cv_prog_cc_c11+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c11=no
+else case e in #(
+  e) ac_cv_prog_cc_c11=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -4940,25 +4914,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c11" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c11" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c11" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c11" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
-     CC="$CC $ac_cv_prog_cc_c11"
+     CC="$CC $ac_cv_prog_cc_c11" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
-  ac_prog_cc_stdc=c11
+  ac_prog_cc_stdc=c11 ;;
+esac
 fi
 fi
 if test x$ac_prog_cc_stdc = xno
@@ -4968,8 +4945,8 @@ printf %s "checking for $CC option to enable C99 features... " >&6; }
 if test ${ac_cv_prog_cc_c99+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c99=no
+else case e in #(
+  e) ac_cv_prog_cc_c99=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -4986,25 +4963,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c99" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c99" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c99" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c99" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
-     CC="$CC $ac_cv_prog_cc_c99"
+     CC="$CC $ac_cv_prog_cc_c99" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-  ac_prog_cc_stdc=c99
+  ac_prog_cc_stdc=c99 ;;
+esac
 fi
 fi
 if test x$ac_prog_cc_stdc = xno
@@ -5014,8 +4994,8 @@ printf %s "checking for $CC option to enable C89 features... " >&6; }
 if test ${ac_cv_prog_cc_c89+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c89=no
+else case e in #(
+  e) ac_cv_prog_cc_c89=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -5032,25 +5012,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c89" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c89" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c89" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c89" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
-     CC="$CC $ac_cv_prog_cc_c89"
+     CC="$CC $ac_cv_prog_cc_c89" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-  ac_prog_cc_stdc=c89
+  ac_prog_cc_stdc=c89 ;;
+esac
 fi
 fi
 
@@ -5071,8 +5054,8 @@ printf %s "checking whether $CC understands -c and -o together... " >&6; }
 if test ${am_cv_prog_cc_c_o+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -5102,7 +5085,8 @@ _ACEOF
     fi
   done
   rm -f core conftest*
-  unset am_i
+  unset am_i ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
@@ -5128,8 +5112,8 @@ printf %s "checking dependency style of $depcc... " >&6; }
 if test ${am_cv_CC_dependencies_compiler_type+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+else case e in #(
+  e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
   # We make a subdir and do the tests there.  Otherwise we can end up
   # making bogus files that we don't know about and never remove.  For
   # instance it was reported that on HP-UX the gcc test will end up
@@ -5233,7 +5217,8 @@ else $as_nop
 else
   am_cv_CC_dependencies_compiler_type=none
 fi
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
@@ -5251,46 +5236,6 @@ fi
 
 
 
-ac_header= ac_cache=
-for ac_item in $ac_header_c_list
-do
-  if test $ac_cache; then
-    ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
-    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
-      printf "%s\n" "#define $ac_item 1" >> confdefs.h
-    fi
-    ac_header= ac_cache=
-  elif test $ac_header; then
-    ac_cache=$ac_item
-  else
-    ac_header=$ac_item
-  fi
-done
-
-
-
-
-
-
-
-
-if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
-then :
-
-printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
-
-fi
-ac_fn_c_check_type "$LINENO" "long long" "ac_cv_type_long_long" "$ac_includes_default"
-if test "x$ac_cv_type_long_long" = xyes
-then :
-
-printf "%s\n" "#define HAVE_LONGLONG 1" >>confdefs.h
-
-   longlong="yes"
-
-fi
-
-
 
     #
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is already defined" >&5
@@ -5322,12 +5267,13 @@ then :
 printf "%s\n" "yes" >&6; }
     tmp_reentrant_initially_defined="yes"
 
-else $as_nop
-
+else case e in #(
+  e)
     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
     tmp_reentrant_initially_defined="no"
-
+   ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
   #
@@ -5383,15 +5329,21 @@ printf %s "checking for library containing socket... " >&6; }
 if test ${ac_cv_search_socket+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_func_search_save_LIBS=$LIBS
+else case e in #(
+  e) ac_func_search_save_LIBS=$LIBS
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char socket ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char socket (void);
 int
 main (void)
 {
@@ -5422,11 +5374,13 @@ done
 if test ${ac_cv_search_socket+y}
 then :
 
-else $as_nop
-  ac_cv_search_socket=no
+else case e in #(
+  e) ac_cv_search_socket=no ;;
+esac
 fi
 rm conftest.$ac_ext
-LIBS=$ac_func_search_save_LIBS
+LIBS=$ac_func_search_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
 printf "%s\n" "$ac_cv_search_socket" >&6; }
@@ -5444,15 +5398,21 @@ printf %s "checking for library containing inet_addr... " >&6; }
 if test ${ac_cv_search_inet_addr+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_func_search_save_LIBS=$LIBS
+else case e in #(
+  e) ac_func_search_save_LIBS=$LIBS
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char inet_addr ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char inet_addr (void);
 int
 main (void)
 {
@@ -5483,11 +5443,13 @@ done
 if test ${ac_cv_search_inet_addr+y}
 then :
 
-else $as_nop
-  ac_cv_search_inet_addr=no
+else case e in #(
+  e) ac_cv_search_inet_addr=no ;;
+esac
 fi
 rm conftest.$ac_ext
-LIBS=$ac_func_search_save_LIBS
+LIBS=$ac_func_search_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_inet_addr" >&5
 printf "%s\n" "$ac_cv_search_inet_addr" >&6; }
@@ -5514,8 +5476,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5537,7 +5499,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -5559,8 +5522,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5582,7 +5545,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -5617,8 +5581,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5640,7 +5604,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -5662,8 +5627,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   ac_prog_rejected=no
@@ -5702,7 +5667,8 @@ if test $ac_prog_rejected = yes; then
     ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
   fi
 fi
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -5726,8 +5692,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5749,7 +5715,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -5775,8 +5742,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5798,7 +5765,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -5836,8 +5804,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
+else case e in #(
+  e) if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5859,7 +5827,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
@@ -5881,8 +5850,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
+else case e in #(
+  e) if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -5904,7 +5873,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
@@ -5933,10 +5903,10 @@ fi
 fi
 
 
-test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; }
 
 # Provide some information about the compiler.
 printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
@@ -5968,8 +5938,8 @@ printf %s "checking whether the compiler supports GNU C... " >&6; }
 if test ${ac_cv_c_compiler_gnu+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -5986,12 +5956,14 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
+else case e in #(
+  e) ac_compiler_gnu=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
@@ -6009,8 +5981,8 @@ printf %s "checking whether $CC accepts -g... " >&6; }
 if test ${ac_cv_prog_cc_g+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_save_c_werror_flag=$ac_c_werror_flag
+else case e in #(
+  e) ac_save_c_werror_flag=$ac_c_werror_flag
    ac_c_werror_flag=yes
    ac_cv_prog_cc_g=no
    CFLAGS="-g"
@@ -6028,8 +6000,8 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_prog_cc_g=yes
-else $as_nop
-  CFLAGS=""
+else case e in #(
+  e) CFLAGS=""
       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -6044,8 +6016,8 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
 
-else $as_nop
-  ac_c_werror_flag=$ac_save_c_werror_flag
+else case e in #(
+  e) ac_c_werror_flag=$ac_save_c_werror_flag
 	 CFLAGS="-g"
 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6062,12 +6034,15 @@ if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_prog_cc_g=yes
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
+   ac_c_werror_flag=$ac_save_c_werror_flag ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
 printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
@@ -6094,8 +6069,8 @@ printf %s "checking for $CC option to enable C11 features... " >&6; }
 if test ${ac_cv_prog_cc_c11+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c11=no
+else case e in #(
+  e) ac_cv_prog_cc_c11=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6112,25 +6087,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c11" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c11" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c11" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c11" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
-     CC="$CC $ac_cv_prog_cc_c11"
+     CC="$CC $ac_cv_prog_cc_c11" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
-  ac_prog_cc_stdc=c11
+  ac_prog_cc_stdc=c11 ;;
+esac
 fi
 fi
 if test x$ac_prog_cc_stdc = xno
@@ -6140,8 +6118,8 @@ printf %s "checking for $CC option to enable C99 features... " >&6; }
 if test ${ac_cv_prog_cc_c99+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c99=no
+else case e in #(
+  e) ac_cv_prog_cc_c99=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6158,25 +6136,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c99" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c99" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c99" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c99" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
-     CC="$CC $ac_cv_prog_cc_c99"
+     CC="$CC $ac_cv_prog_cc_c99" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-  ac_prog_cc_stdc=c99
+  ac_prog_cc_stdc=c99 ;;
+esac
 fi
 fi
 if test x$ac_prog_cc_stdc = xno
@@ -6186,8 +6167,8 @@ printf %s "checking for $CC option to enable C89 features... " >&6; }
 if test ${ac_cv_prog_cc_c89+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c89=no
+else case e in #(
+  e) ac_cv_prog_cc_c89=no
 ac_save_CC=$CC
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6204,25 +6185,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cc_c89" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CC=$ac_save_CC
+CC=$ac_save_CC ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cc_c89" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c89" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cc_c89" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
-     CC="$CC $ac_cv_prog_cc_c89"
+     CC="$CC $ac_cv_prog_cc_c89" ;;
+esac
 fi
   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-  ac_prog_cc_stdc=c89
+  ac_prog_cc_stdc=c89 ;;
+esac
 fi
 fi
 
@@ -6243,8 +6227,8 @@ printf %s "checking whether $CC understands -c and -o together... " >&6; }
 if test ${am_cv_prog_cc_c_o+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -6274,7 +6258,8 @@ _ACEOF
     fi
   done
   rm -f core conftest*
-  unset am_i
+  unset am_i ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
@@ -6300,8 +6285,8 @@ printf %s "checking dependency style of $depcc... " >&6; }
 if test ${am_cv_CC_dependencies_compiler_type+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+else case e in #(
+  e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
   # We make a subdir and do the tests there.  Otherwise we can end up
   # making bogus files that we don't know about and never remove.  For
   # instance it was reported that on HP-UX the gcc test will end up
@@ -6405,7 +6390,8 @@ else $as_nop
 else
   am_cv_CC_dependencies_compiler_type=none
 fi
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
@@ -6447,8 +6433,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CXX"; then
+else case e in #(
+  e) if test -n "$CXX"; then
   ac_cv_prog_CXX="$CXX" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -6470,7 +6456,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 CXX=$ac_cv_prog_CXX
 if test -n "$CXX"; then
@@ -6496,8 +6483,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CXX"; then
+else case e in #(
+  e) if test -n "$ac_ct_CXX"; then
   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -6519,7 +6506,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 if test -n "$ac_ct_CXX"; then
@@ -6579,8 +6567,8 @@ printf %s "checking whether the compiler supports GNU C++... " >&6; }
 if test ${ac_cv_cxx_compiler_gnu+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -6597,12 +6585,14 @@ _ACEOF
 if ac_fn_cxx_try_compile "$LINENO"
 then :
   ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
+else case e in #(
+  e) ac_compiler_gnu=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
 printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; }
@@ -6620,8 +6610,8 @@ printf %s "checking whether $CXX accepts -g... " >&6; }
 if test ${ac_cv_prog_cxx_g+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+else case e in #(
+  e) ac_save_cxx_werror_flag=$ac_cxx_werror_flag
    ac_cxx_werror_flag=yes
    ac_cv_prog_cxx_g=no
    CXXFLAGS="-g"
@@ -6639,8 +6629,8 @@ _ACEOF
 if ac_fn_cxx_try_compile "$LINENO"
 then :
   ac_cv_prog_cxx_g=yes
-else $as_nop
-  CXXFLAGS=""
+else case e in #(
+  e) CXXFLAGS=""
       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -6655,8 +6645,8 @@ _ACEOF
 if ac_fn_cxx_try_compile "$LINENO"
 then :
 
-else $as_nop
-  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+else case e in #(
+  e) ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 	 CXXFLAGS="-g"
 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6673,12 +6663,15 @@ if ac_fn_cxx_try_compile "$LINENO"
 then :
   ac_cv_prog_cxx_g=yes
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
 printf "%s\n" "$ac_cv_prog_cxx_g" >&6; }
@@ -6702,11 +6695,11 @@ if test x$ac_prog_cxx_stdcxx = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5
 printf %s "checking for $CXX option to enable C++11 features... " >&6; }
-if test ${ac_cv_prog_cxx_11+y}
+if test ${ac_cv_prog_cxx_cxx11+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cxx_11=no
+else case e in #(
+  e) ac_cv_prog_cxx_cxx11=no
 ac_save_CXX=$CXX
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6723,36 +6716,39 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cxx_cxx11" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CXX=$ac_save_CXX
+CXX=$ac_save_CXX ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cxx_cxx11" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cxx_cxx11" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cxx_cxx11" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
 printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; }
-     CXX="$CXX $ac_cv_prog_cxx_cxx11"
+     CXX="$CXX $ac_cv_prog_cxx_cxx11" ;;
+esac
 fi
   ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
-  ac_prog_cxx_stdcxx=cxx11
+  ac_prog_cxx_stdcxx=cxx11 ;;
+esac
 fi
 fi
 if test x$ac_prog_cxx_stdcxx = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5
 printf %s "checking for $CXX option to enable C++98 features... " >&6; }
-if test ${ac_cv_prog_cxx_98+y}
+if test ${ac_cv_prog_cxx_cxx98+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cxx_98=no
+else case e in #(
+  e) ac_cv_prog_cxx_cxx98=no
 ac_save_CXX=$CXX
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -6769,25 +6765,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam
   test "x$ac_cv_prog_cxx_cxx98" != "xno" && break
 done
 rm -f conftest.$ac_ext
-CXX=$ac_save_CXX
+CXX=$ac_save_CXX ;;
+esac
 fi
 
 if test "x$ac_cv_prog_cxx_cxx98" = xno
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
 printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cxx_cxx98" = x
+else case e in #(
+  e) if test "x$ac_cv_prog_cxx_cxx98" = x
 then :
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
 printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
 printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; }
-     CXX="$CXX $ac_cv_prog_cxx_cxx98"
+     CXX="$CXX $ac_cv_prog_cxx_cxx98" ;;
+esac
 fi
   ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98
-  ac_prog_cxx_stdcxx=cxx98
+  ac_prog_cxx_stdcxx=cxx98 ;;
+esac
 fi
 fi
 
@@ -6804,8 +6803,8 @@ printf %s "checking dependency style of $depcc... " >&6; }
 if test ${am_cv_CXX_dependencies_compiler_type+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+else case e in #(
+  e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
   # We make a subdir and do the tests there.  Otherwise we can end up
   # making bogus files that we don't know about and never remove.  For
   # instance it was reported that on HP-UX the gcc test will end up
@@ -6909,7 +6908,8 @@ else $as_nop
 else
   am_cv_CXX_dependencies_compiler_type=none
 fi
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
 printf "%s\n" "$am_cv_CXX_dependencies_compiler_type" >&6; }
@@ -6945,8 +6945,8 @@ ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
 if eval test \${ac_cv_prog_make_${ac_make}_set+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat >conftest.make <<\_ACEOF
+else case e in #(
+  e) cat >conftest.make <<\_ACEOF
 SHELL = /bin/sh
 all:
 	@echo '@@@%%%=$(MAKE)=@@@%%%'
@@ -6958,7 +6958,8 @@ case `${MAKE-make} -f conftest.make 2>/dev/null` in
   *)
     eval ac_cv_prog_make_${ac_make}_set=no;;
 esac
-rm -f conftest.make
+rm -f conftest.make ;;
+esac
 fi
 if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
@@ -6979,8 +6980,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_path_SSHD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  case $SSHD in
+else case e in #(
+  e) case $SSHD in
   [\\/]* | ?:[\\/]*)
   ac_cv_path_SSHD="$SSHD" # Let the user override the test with a path.
   ;;
@@ -7005,6 +7006,7 @@ done
 IFS=$as_save_IFS
 
   ;;
+esac ;;
 esac
 fi
 SSHD=$ac_cv_path_SSHD
@@ -7028,125 +7030,117 @@ else
   SSHD_FALSE=
 fi
 
-enable_win32_dll=yes
+case `pwd` in
+  *\ * | *\	*)
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
 
-case $host in
-*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
-set dummy ${ac_tool_prefix}as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_AS+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AS"; then
-  ac_cv_prog_AS="$AS" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AS="${ac_tool_prefix}as"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
 
-fi
-fi
-AS=$ac_cv_prog_AS
-if test -n "$AS"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-printf "%s\n" "$AS" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
 
+macro_version='2.4.7'
+macro_revision='2.4.7'
 
-fi
-if test -z "$ac_cv_prog_AS"; then
-  ac_ct_AS=$AS
-  # Extract the first word of "as", so it can be a program name with args.
-set dummy as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_AS+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_AS"; then
-  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_AS="as"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
 
-fi
-fi
-ac_ct_AS=$ac_cv_prog_ac_ct_AS
-if test -n "$ac_ct_AS"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
-printf "%s\n" "$ac_ct_AS" >&6; }
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+printf %s "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
 else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
 fi
 
-  if test "x$ac_ct_AS" = x; then
-    AS="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO ""
+}
+
+case $ECHO in
+  printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+printf "%s\n" "printf" >&6; } ;;
+  print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+printf "%s\n" "print -r" >&6; } ;;
+  *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+printf "%s\n" "cat" >&6; } ;;
 esac
-    AS=$ac_ct_AS
-  fi
-else
-  AS="$ac_cv_prog_AS"
-fi
 
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
-set dummy ${ac_tool_prefix}dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DLLTOOL+y}
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+printf %s "checking for a sed that does not truncate output... " >&6; }
+if test ${ac_cv_path_SED+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DLLTOOL"; then
-  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+else case e in #(
+  e)           ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
@@ -7155,44 +7149,83 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
+    for ac_prog in sed gsed
+   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
+      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
   done
-IFS=$as_save_IFS
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
 
-fi
-fi
-DLLTOOL=$ac_cv_prog_DLLTOOL
-if test -n "$DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
-printf "%s\n" "$DLLTOOL" >&6; }
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
 else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+  ac_cv_path_SED=$SED
+fi
+ ;;
+esac
 fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+printf "%s\n" "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
 
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
 
-fi
-if test -z "$ac_cv_prog_DLLTOOL"; then
-  ac_ct_DLLTOOL=$DLLTOOL
-  # Extract the first word of "dlltool", so it can be a program name with args.
-set dummy dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
+
+
+
+
+
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+printf %s "checking for grep that handles long lines and -e... " >&6; }
+if test ${ac_cv_path_GREP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DLLTOOL"; then
-  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
+else case e in #(
+  e) if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
 do
   IFS=$as_save_IFS
   case $as_dir in #(((
@@ -7200,56 +7233,73 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
+    for ac_prog in grep ggrep
+   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
+      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
   done
-IFS=$as_save_IFS
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
 
-fi
-fi
-ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
-if test -n "$ac_ct_DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
-printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
 else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+  ac_cv_path_GREP=$GREP
 fi
-
-  if test "x$ac_ct_DLLTOOL" = x; then
-    DLLTOOL="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
+ ;;
 esac
-    DLLTOOL=$ac_ct_DLLTOOL
-  fi
-else
-  DLLTOOL="$ac_cv_prog_DLLTOOL"
 fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+printf "%s\n" "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
 
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
-set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OBJDUMP+y}
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+printf %s "checking for egrep... " >&6; }
+if test ${ac_cv_path_EGREP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OBJDUMP"; then
-  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
+else case e in #(
+  e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
 do
   IFS=$as_save_IFS
   case $as_dir in #(((
@@ -7257,44 +7307,76 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
+    for ac_prog in egrep
+   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
+      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
   done
-IFS=$as_save_IFS
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
 
-fi
-fi
-OBJDUMP=$ac_cv_prog_OBJDUMP
-if test -n "$OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
 else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+  ac_cv_path_EGREP=$EGREP
 fi
 
-
+   fi ;;
+esac
 fi
-if test -z "$ac_cv_prog_OBJDUMP"; then
-  ac_ct_OBJDUMP=$OBJDUMP
-  # Extract the first word of "objdump", so it can be a program name with args.
-set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+         EGREP_TRADITIONAL=$EGREP
+ ac_cv_path_EGREP_TRADITIONAL=$EGREP
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+printf %s "checking for fgrep... " >&6; }
+if test ${ac_cv_path_FGREP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OBJDUMP"; then
-  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
+else case e in #(
+  e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+   then ac_cv_path_FGREP="$GREP -F"
+   else
+     if test -z "$FGREP"; then
+  ac_path_FGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
 do
   IFS=$as_save_IFS
   case $as_dir in #(((
@@ -7302,58 +7384,67 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
+    for ac_prog in fgrep
+   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OBJDUMP="objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
+      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'FGREP' >> "conftest.nl"
+    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_FGREP="$ac_path_FGREP"
+      ac_path_FGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
   done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
-if test -n "$ac_ct_OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OBJDUMP" = x; then
-    OBJDUMP="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
 esac
-    OBJDUMP=$ac_ct_OBJDUMP
+
+      $ac_path_FGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_FGREP"; then
+    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
   fi
 else
-  OBJDUMP="$ac_cv_prog_OBJDUMP"
+  ac_cv_path_FGREP=$FGREP
 fi
 
-  ;;
+   fi ;;
 esac
-
-test -z "$AS" && AS=as
-
-
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+printf "%s\n" "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
 
 
+test -z "$GREP" && GREP=grep
 
-test -z "$DLLTOOL" && DLLTOOL=dlltool
 
 
 
 
 
-test -z "$OBJDUMP" && OBJDUMP=objdump
 
 
 
@@ -7361,88 +7452,120 @@ test -z "$OBJDUMP" && OBJDUMP=objdump
 
 
 
-case `pwd` in
-  *\ * | *\	*)
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
-printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
-esac
 
 
 
-macro_version='2.4.6'
-macro_revision='2.4.6'
 
 
 
+# Check whether --with-gnu-ld was given.
+if test ${with_gnu_ld+y}
+then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else case e in #(
+  e) with_gnu_ld=no ;;
+esac
+fi
 
-
-
-
-
-
-
-
-
-
-
-ltmain=$ac_aux_dir/ltmain.sh
-
-# Backslashify metacharacters that are still active within
-# double-quoted strings.
-sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
-
-# Same as above, but do not quote variable references.
-double_quote_subst='s/\(["`\\]\)/\\\1/g'
-
-# Sed substitution to delay expansion of an escaped shell variable in a
-# double_quote_subst'ed string.
-delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
-
-# Sed substitution to delay expansion of an escaped single quote.
-delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
-
-# Sed substitution to avoid accidental globbing in evaled expressions
-no_glob_subst='s/\*/\\\*/g'
-
-ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
-printf %s "checking how to print strings... " >&6; }
-# Test print first, because it will be a builtin if present.
-if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
-   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='print -r --'
-elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='printf %s\n'
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+printf %s "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+printf %s "checking for GNU ld... " >&6; }
 else
-  # Use this function as a fallback that always works.
-  func_fallback_echo ()
-  {
-    eval 'cat <<_LTECHO_EOF
-$1
-_LTECHO_EOF'
-  }
-  ECHO='func_fallback_echo'
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+printf %s "checking for non-GNU ld... " >&6; }
 fi
-
-# func_echo_all arg...
-# Invoke $ECHO with all args, space-separated.
-func_echo_all ()
-{
-    $ECHO ""
-}
-
-case $ECHO in
-  printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5
-printf "%s\n" "printf" >&6; } ;;
-  print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
-printf "%s\n" "print -r" >&6; } ;;
-  *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5
-printf "%s\n" "cat" >&6; } ;;
+if test ${lt_cv_path_LD+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi ;;
 esac
+fi
 
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+printf "%s\n" "$LD" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
+if test ${lt_cv_prog_gnu_ld+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
 
 
 
@@ -7452,26 +7575,86 @@ esac
 
 
 
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
-printf %s "checking for a sed that does not truncate output... " >&6; }
-if test ${ac_cv_path_SED+y}
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if test ${lt_cv_path_NM+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-     for ac_i in 1 2 3 4 5 6 7; do
-       ac_script="$ac_script$as_nl$ac_script"
-     done
-     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
-     { ac_script=; unset ac_script;}
-     if test -z "$SED"; then
-  ac_path_SED_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+else case e in #(
+  e) if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM=$NM
+else
+  lt_nm_to_check=${ac_tool_prefix}nm
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS=$lt_save_ifs
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | $SED '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break 2
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | $SED '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break 2
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS=$lt_save_ifs
+  done
+  : ${lt_cv_path_NM=no}
+fi ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+printf "%s\n" "$lt_cv_path_NM" >&6; }
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in dumpbin "link -dump"
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DUMPBIN+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$DUMPBIN"; then
+  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
@@ -7480,81 +7663,49 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
-    for ac_prog in sed gsed
-   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_SED" || continue
-# Check for GNU ac_path_SED and select it if it is found.
-  # Check for GNU $ac_path_SED
-case `"$ac_path_SED" --version 2>&1` in
-*GNU*)
-  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" '' >> "conftest.nl"
-    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_SED_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_SED="$ac_path_SED"
-      ac_path_SED_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_SED_found && break 3
-    done
-  done
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
   done
 IFS=$as_save_IFS
-  if test -z "$ac_cv_path_SED"; then
-    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
-  fi
-else
-  ac_cv_path_SED=$SED
-fi
 
+fi ;;
+esac
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+printf "%s\n" "$DUMPBIN" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-printf "%s\n" "$ac_cv_path_SED" >&6; }
- SED="$ac_cv_path_SED"
-  rm -f conftest.sed
-
-test -z "$SED" && SED=sed
-Xsed="$SED -e 1s/^X//"
-
-
-
-
-
-
-
-
-
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-printf %s "checking for grep that handles long lines and -e... " >&6; }
-if test ${ac_cv_path_GREP+y}
+    test -n "$DUMPBIN" && break
+  done
+fi
+if test -z "$DUMPBIN"; then
+  ac_ct_DUMPBIN=$DUMPBIN
+  for ac_prog in dumpbin "link -dump"
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DUMPBIN+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$GREP"; then
-  ac_path_GREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+else case e in #(
+  e) if test -n "$ac_ct_DUMPBIN"; then
+  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
 do
   IFS=$as_save_IFS
   case $as_dir in #(((
@@ -7562,214 +7713,264 @@ do
     */) ;;
     *) as_dir=$as_dir/ ;;
   esac
-    for ac_prog in grep ggrep
-   do
     for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_GREP" || continue
-# Check for GNU ac_path_GREP and select it if it is found.
-  # Check for GNU $ac_path_GREP
-case `"$ac_path_GREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'GREP' >> "conftest.nl"
-    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_GREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_GREP="$ac_path_GREP"
-      ac_path_GREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_GREP_found && break 3
-    done
-  done
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
   done
 IFS=$as_save_IFS
-  if test -z "$ac_cv_path_GREP"; then
-    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
+
+fi ;;
+esac
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+printf "%s\n" "$ac_ct_DUMPBIN" >&6; }
 else
-  ac_cv_path_GREP=$GREP
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
 
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-printf "%s\n" "$ac_cv_path_GREP" >&6; }
- GREP="$ac_cv_path_GREP"
 
+  test -n "$ac_ct_DUMPBIN" && break
+done
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
-printf %s "checking for egrep... " >&6; }
-if test ${ac_cv_path_EGREP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-   then ac_cv_path_EGREP="$GREP -E"
-   else
-     if test -z "$EGREP"; then
-  ac_path_EGREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in egrep
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_EGREP" || continue
-# Check for GNU ac_path_EGREP and select it if it is found.
-  # Check for GNU $ac_path_EGREP
-case `"$ac_path_EGREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'EGREP' >> "conftest.nl"
-    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_EGREP="$ac_path_EGREP"
-      ac_path_EGREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+  if test "x$ac_ct_DUMPBIN" = x; then
+    DUMPBIN=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
 esac
-
-      $ac_path_EGREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_EGREP"; then
-    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+    DUMPBIN=$ac_ct_DUMPBIN
   fi
-else
-  ac_cv_path_EGREP=$EGREP
 fi
 
-   fi
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | $SED '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols -headers"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
+  fi
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
-printf "%s\n" "$ac_cv_path_EGREP" >&6; }
- EGREP="$ac_cv_path_EGREP"
+test -z "$NM" && NM=nm
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
-printf %s "checking for fgrep... " >&6; }
-if test ${ac_cv_path_FGREP+y}
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+printf %s "checking the name lister ($NM) interface... " >&6; }
+if test ${lt_cv_nm_interface+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-   then ac_cv_path_FGREP="$GREP -F"
-   else
-     if test -z "$FGREP"; then
-  ac_path_FGREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in fgrep
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_FGREP" || continue
-# Check for GNU ac_path_FGREP and select it if it is found.
-  # Check for GNU $ac_path_FGREP
-case `"$ac_path_FGREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'FGREP' >> "conftest.nl"
-    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_FGREP="$ac_path_FGREP"
-      ac_path_FGREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+else case e in #(
+  e) lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+  cat conftest.out >&5
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest* ;;
 esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+printf "%s\n" "$lt_cv_nm_interface" >&6; }
 
-      $ac_path_FGREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_FGREP"; then
-    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_FGREP=$FGREP
+# find the maximum length of command line arguments
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+printf %s "checking the maximum length of command line arguments... " >&6; }
+if test ${lt_cv_sys_max_cmd_len+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e)   i=0
+  teststring=ABCD
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  bitrig* | darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  os2*)
+    # The test takes a long time on OS/2.
+    lt_cv_sys_max_cmd_len=8192
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | $SED 's/.*[	 ]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test 17 != "$i" # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+ ;;
+esac
 fi
 
-   fi
+if test -n "$lt_cv_sys_max_cmd_len"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5
+printf "%s\n" "none" >&6; }
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
-printf "%s\n" "$ac_cv_path_FGREP" >&6; }
- FGREP="$ac_cv_path_FGREP"
+max_cmd_len=$lt_cv_sys_max_cmd_len
 
 
-test -z "$GREP" && GREP=grep
 
 
 
 
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
 
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
 
 
 
 
 
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
 
 
 
@@ -7779,111 +7980,115 @@ test -z "$GREP" && GREP=grep
 
 
 
-# Check whether --with-gnu-ld was given.
-if test ${with_gnu_ld+y}
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+printf %s "checking how to convert $build file names to $host format... " >&6; }
+if test ${lt_cv_to_host_file_cmd+y}
 then :
-  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
+  printf %s "(cached) " >&6
+else case e in #(
+  e) case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+        ;;
+    esac
+    ;;
+  *-*-cygwin* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_noop
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+        ;;
+    esac
+    ;;
+  * ) # unhandled hosts (and "normal" native builds)
+    lt_cv_to_host_file_cmd=func_convert_file_noop
+    ;;
+esac
+ ;;
+esac
 fi
 
-ac_prog=ld
-if test yes = "$GCC"; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
-printf %s "checking for ld used by $CC... " >&6; }
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return, which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [\\/]* | ?:[\\/]*)
-      re_direlt='/[^/][^/]*/\.\./'
-      # Canonicalize the pathname of ld
-      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
-      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD=$ac_prog
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test yes = "$with_gnu_ld"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
-printf %s "checking for GNU ld... " >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
-printf %s "checking for non-GNU ld... " >&6; }
-fi
-if test ${lt_cv_path_LD+y}
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; }
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+printf %s "checking how to convert $build file names to toolchain format... " >&6; }
+if test ${lt_cv_to_tool_file_cmd+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  for ac_dir in $PATH; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD=$ac_dir/$ac_prog
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some variants of GNU ld only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
-      *GNU* | *'with BFD'*)
-	test no != "$with_gnu_ld" && break
-	;;
-      *)
-	test yes != "$with_gnu_ld" && break
-	;;
-      esac
-    fi
-  done
-  IFS=$lt_save_ifs
-else
-  lt_cv_path_LD=$LD # Let the user override the test with a path.
-fi
+else case e in #(
+  e) #assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+        ;;
+    esac
+    ;;
+esac
+ ;;
+esac
 fi
 
-LD=$lt_cv_path_LD
-if test -n "$LD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
-printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
-if test ${lt_cv_prog_gnu_ld+y}
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; }
+
+
+
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+printf %s "checking for $LD option to reload object files... " >&6; }
+if test ${lt_cv_ld_reload_flag+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU lds only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  lt_cv_prog_gnu_ld=yes
-  ;;
-*)
-  lt_cv_prog_gnu_ld=no
-  ;;
+else case e in #(
+  e) lt_cv_ld_reload_flag='-r' ;;
 esac
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
-printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
-with_gnu_ld=$lt_cv_prog_gnu_ld
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+printf "%s\n" "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    if test yes != "$GCC"; then
+      reload_cmds=false
+    fi
+    ;;
+  darwin*)
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
 
 
 
@@ -7893,83 +8098,17 @@ with_gnu_ld=$lt_cv_prog_gnu_ld
 
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
-printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
-if test ${lt_cv_path_NM+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$NM"; then
-  # Let the user override the test.
-  lt_cv_path_NM=$NM
-else
-  lt_nm_to_check=${ac_tool_prefix}nm
-  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
-    lt_nm_to_check="$lt_nm_to_check nm"
-  fi
-  for lt_tmp_nm in $lt_nm_to_check; do
-    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
-      IFS=$lt_save_ifs
-      test -z "$ac_dir" && ac_dir=.
-      tmp_nm=$ac_dir/$lt_tmp_nm
-      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
-	# Check to see if the nm accepts a BSD-compat flag.
-	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
-	#   nm: unknown option "B" ignored
-	# Tru64's nm complains that /dev/null is an invalid object file
-	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
-	case $build_os in
-	mingw*) lt_bad_file=conftest.nm/nofile ;;
-	*) lt_bad_file=/dev/null ;;
-	esac
-	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
-	*$lt_bad_file* | *'Invalid file or object type'*)
-	  lt_cv_path_NM="$tmp_nm -B"
-	  break 2
-	  ;;
-	*)
-	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
-	  */dev/null*)
-	    lt_cv_path_NM="$tmp_nm -p"
-	    break 2
-	    ;;
-	  *)
-	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
-	    continue # so that we can try to find one that supports BSD flags
-	    ;;
-	  esac
-	  ;;
-	esac
-      fi
-    done
-    IFS=$lt_save_ifs
-  done
-  : ${lt_cv_path_NM=no}
-fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
-printf "%s\n" "$lt_cv_path_NM" >&6; }
-if test no != "$lt_cv_path_NM"; then
-  NM=$lt_cv_path_NM
-else
-  # Didn't find any BSD compatible name lister, look for dumpbin.
-  if test -n "$DUMPBIN"; then :
-    # Let the user override the test.
-  else
-    if test -n "$ac_tool_prefix"; then
-  for ac_prog in dumpbin "link -dump"
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}file", so it can be a program name with args.
+set dummy ${ac_tool_prefix}file; ac_word=$2
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DUMPBIN+y}
+if test ${ac_cv_prog_FILECMD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DUMPBIN"; then
-  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else case e in #(
+  e) if test -n "$FILECMD"; then
+  ac_cv_prog_FILECMD="$FILECMD" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
@@ -7982,7 +8121,7 @@ do
   esac
     for ac_exec_ext in '' $ac_executable_extensions; do
   if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    ac_cv_prog_FILECMD="${ac_tool_prefix}file"
     printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -7990,35 +8129,32 @@ done
   done
 IFS=$as_save_IFS
 
+fi ;;
+esac
 fi
-fi
-DUMPBIN=$ac_cv_prog_DUMPBIN
-if test -n "$DUMPBIN"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
-printf "%s\n" "$DUMPBIN" >&6; }
+FILECMD=$ac_cv_prog_FILECMD
+if test -n "$FILECMD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILECMD" >&5
+printf "%s\n" "$FILECMD" >&6; }
 else
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
 fi
 
 
-    test -n "$DUMPBIN" && break
-  done
 fi
-if test -z "$DUMPBIN"; then
-  ac_ct_DUMPBIN=$DUMPBIN
-  for ac_prog in dumpbin "link -dump"
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
+if test -z "$ac_cv_prog_FILECMD"; then
+  ac_ct_FILECMD=$FILECMD
+  # Extract the first word of "file", so it can be a program name with args.
+set dummy file; ac_word=$2
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DUMPBIN+y}
+if test ${ac_cv_prog_ac_ct_FILECMD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DUMPBIN"; then
-  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else case e in #(
+  e) if test -n "$ac_ct_FILECMD"; then
+  ac_cv_prog_ac_ct_FILECMD="$ac_ct_FILECMD" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
@@ -8031,7 +8167,7 @@ do
   esac
     for ac_exec_ext in '' $ac_executable_extensions; do
   if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    ac_cv_prog_ac_ct_FILECMD="file"
     printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -8039,23 +8175,20 @@ done
   done
 IFS=$as_save_IFS
 
+fi ;;
+esac
 fi
-fi
-ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
-if test -n "$ac_ct_DUMPBIN"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
-printf "%s\n" "$ac_ct_DUMPBIN" >&6; }
+ac_ct_FILECMD=$ac_cv_prog_ac_ct_FILECMD
+if test -n "$ac_ct_FILECMD"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FILECMD" >&5
+printf "%s\n" "$ac_ct_FILECMD" >&6; }
 else
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
 fi
 
-
-  test -n "$ac_ct_DUMPBIN" && break
-done
-
-  if test "x$ac_ct_DUMPBIN" = x; then
-    DUMPBIN=":"
+  if test "x$ac_ct_FILECMD" = x; then
+    FILECMD=":"
   else
     case $cross_compiling:$ac_tool_warned in
 yes:)
@@ -8063,467 +8196,136 @@ yes:)
 printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 ac_tool_warned=yes ;;
 esac
-    DUMPBIN=$ac_ct_DUMPBIN
+    FILECMD=$ac_ct_FILECMD
   fi
+else
+  FILECMD="$ac_cv_prog_FILECMD"
 fi
 
-    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
-    *COFF*)
-      DUMPBIN="$DUMPBIN -symbols -headers"
-      ;;
-    *)
-      DUMPBIN=:
-      ;;
-    esac
-  fi
-
-  if test : != "$DUMPBIN"; then
-    NM=$DUMPBIN
-  fi
-fi
-test -z "$NM" && NM=nm
 
 
 
 
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
-printf %s "checking the name lister ($NM) interface... " >&6; }
-if test ${lt_cv_nm_interface+y}
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OBJDUMP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_nm_interface="BSD nm"
-  echo "int some_variable = 0;" > conftest.$ac_ext
-  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
-  (eval "$ac_compile" 2>conftest.err)
-  cat conftest.err >&5
-  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
-  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
-  cat conftest.err >&5
-  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
-  cat conftest.out >&5
-  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
-    lt_cv_nm_interface="MS dumpbin"
+else case e in #(
+  e) if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
   fi
-  rm -f conftest*
+done
+  done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf "%s\n" "$OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
-printf "%s\n" "$lt_cv_nm_interface" >&6; }
 
-# find the maximum length of command line arguments
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
-printf %s "checking the maximum length of command line arguments... " >&6; }
-if test ${lt_cv_sys_max_cmd_len+y}
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-    i=0
-  teststring=ABCD
-
-  case $build_os in
-  msdosdjgpp*)
-    # On DJGPP, this test can blow up pretty badly due to problems in libc
-    # (any single argument exceeding 2000 bytes causes a buffer overrun
-    # during glob expansion).  Even if it were fixed, the result of this
-    # check would be larger than it should be.
-    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
-    ;;
-
-  gnu*)
-    # Under GNU Hurd, this test is not required because there is
-    # no limit to the length of command line arguments.
-    # Libtool will interpret -1 as no limit whatsoever
-    lt_cv_sys_max_cmd_len=-1;
-    ;;
-
-  cygwin* | mingw* | cegcc*)
-    # On Win9x/ME, this test blows up -- it succeeds, but takes
-    # about 5 minutes as the teststring grows exponentially.
-    # Worse, since 9x/ME are not pre-emptively multitasking,
-    # you end up with a "frozen" computer, even though with patience
-    # the test eventually succeeds (with a max line length of 256k).
-    # Instead, let's just punt: use the minimum linelength reported by
-    # all of the supported platforms: 8192 (on NT/2K/XP).
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  mint*)
-    # On MiNT this can take a long time and run out of memory.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  amigaos*)
-    # On AmigaOS with pdksh, this test takes hours, literally.
-    # So we just punt and use a minimum line length of 8192.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
-    # This has been around since 386BSD, at least.  Likely further.
-    if test -x /sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
-    elif test -x /usr/sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
-    else
-      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
-    fi
-    # And add a safety zone
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    ;;
-
-  interix*)
-    # We know the value 262144 and hardcode it with a safety zone (like BSD)
-    lt_cv_sys_max_cmd_len=196608
-    ;;
-
-  os2*)
-    # The test takes a long time on OS/2.
-    lt_cv_sys_max_cmd_len=8192
-    ;;
-
-  osf*)
-    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
-    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
-    # nice to cause kernel panics so lets avoid the loop below.
-    # First set a reasonable default.
-    lt_cv_sys_max_cmd_len=16384
-    #
-    if test -x /sbin/sysconfig; then
-      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
-        *1*) lt_cv_sys_max_cmd_len=-1 ;;
-      esac
-    fi
-    ;;
-  sco3.2v5*)
-    lt_cv_sys_max_cmd_len=102400
-    ;;
-  sysv5* | sco5v6* | sysv4.2uw2*)
-    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
-    if test -n "$kargmax"; then
-      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
-    else
-      lt_cv_sys_max_cmd_len=32768
-    fi
-    ;;
-  *)
-    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
-    if test -n "$lt_cv_sys_max_cmd_len" && \
-       test undefined != "$lt_cv_sys_max_cmd_len"; then
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    else
-      # Make teststring a little bigger before we do anything with it.
-      # a 1K string should be a reasonable start.
-      for i in 1 2 3 4 5 6 7 8; do
-        teststring=$teststring$teststring
-      done
-      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
-      # If test is not a shell built-in, we'll probably end up computing a
-      # maximum length that is only half of the actual maximum length, but
-      # we can't tell.
-      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
-	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
-	      test 17 != "$i" # 1/2 MB should be enough
-      do
-        i=`expr $i + 1`
-        teststring=$teststring$teststring
-      done
-      # Only check the string length outside the loop.
-      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
-      teststring=
-      # Add a significant safety factor because C++ compilers can tack on
-      # massive amounts of additional arguments before passing them to the
-      # linker.  It appears as though 1/2 is a usable value.
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
-    fi
-    ;;
+else case e in #(
+  e) if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
   esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
+fi ;;
+esac
 fi
-
-if test -n "$lt_cv_sys_max_cmd_len"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
-printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; }
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
 else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5
-printf "%s\n" "none" >&6; }
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
-max_cmd_len=$lt_cv_sys_max_cmd_len
-
-
-
-
-
 
-: ${CP="cp -f"}
-: ${MV="mv -f"}
-: ${RM="rm -f"}
-
-if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
-  lt_unset=unset
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
 else
-  lt_unset=false
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
 fi
 
-
-
-
-
-# test EBCDIC or ASCII
-case `echo X|tr X '\101'` in
- A) # ASCII based system
-    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
-  lt_SP2NL='tr \040 \012'
-  lt_NL2SP='tr \015\012 \040\040'
-  ;;
- *) # EBCDIC based system
-  lt_SP2NL='tr \100 \n'
-  lt_NL2SP='tr \r\n \100\100'
-  ;;
-esac
-
-
-
+test -z "$OBJDUMP" && OBJDUMP=objdump
 
 
 
 
 
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
-printf %s "checking how to convert $build file names to $host format... " >&6; }
-if test ${lt_cv_to_host_file_cmd+y}
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+printf %s "checking how to recognize dependent libraries... " >&6; }
+if test ${lt_cv_deplibs_check_method+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
-        ;;
-    esac
-    ;;
-  *-*-cygwin* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_noop
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
-        ;;
-    esac
-    ;;
-  * ) # unhandled hosts (and "normal" native builds)
-    lt_cv_to_host_file_cmd=func_convert_file_noop
-    ;;
-esac
-
-fi
-
-to_host_file_cmd=$lt_cv_to_host_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; }
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
-printf %s "checking how to convert $build file names to toolchain format... " >&6; }
-if test ${lt_cv_to_tool_file_cmd+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  #assume ordinary cross tools, or native build.
-lt_cv_to_tool_file_cmd=func_convert_file_noop
-case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
-        ;;
-    esac
-    ;;
-esac
-
-fi
-
-to_tool_file_cmd=$lt_cv_to_tool_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; }
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
-printf %s "checking for $LD option to reload object files... " >&6; }
-if test ${lt_cv_ld_reload_flag+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_reload_flag='-r'
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
-printf "%s\n" "$lt_cv_ld_reload_flag" >&6; }
-reload_flag=$lt_cv_ld_reload_flag
-case $reload_flag in
-"" | " "*) ;;
-*) reload_flag=" $reload_flag" ;;
-esac
-reload_cmds='$LD$reload_flag -o $output$reload_objs'
-case $host_os in
-  cygwin* | mingw* | pw32* | cegcc*)
-    if test yes != "$GCC"; then
-      reload_cmds=false
-    fi
-    ;;
-  darwin*)
-    if test yes = "$GCC"; then
-      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
-    else
-      reload_cmds='$LD$reload_flag -o $output$reload_objs'
-    fi
-    ;;
-esac
-
-
-
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
-set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OBJDUMP"; then
-  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-OBJDUMP=$ac_cv_prog_OBJDUMP
-if test -n "$OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_OBJDUMP"; then
-  ac_ct_OBJDUMP=$OBJDUMP
-  # Extract the first word of "objdump", so it can be a program name with args.
-set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OBJDUMP"; then
-  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OBJDUMP="objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
-if test -n "$ac_ct_OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OBJDUMP" = x; then
-    OBJDUMP="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    OBJDUMP=$ac_ct_OBJDUMP
-  fi
-else
-  OBJDUMP="$ac_cv_prog_OBJDUMP"
-fi
-
-test -z "$OBJDUMP" && OBJDUMP=objdump
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
-printf %s "checking how to recognize dependent libraries... " >&6; }
-if test ${lt_cv_deplibs_check_method+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_file_magic_cmd='$MAGIC_CMD'
+else case e in #(
+  e) lt_cv_file_magic_cmd='$MAGIC_CMD'
 lt_cv_file_magic_test_file=
 lt_cv_deplibs_check_method='unknown'
 # Need to set the preceding variable on all platforms that support
@@ -8548,7 +8350,7 @@ beos*)
 
 bsdi[45]*)
   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
-  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_cmd='$FILECMD -L'
   lt_cv_file_magic_test_file=/shlib/libc.so
   ;;
 
@@ -8582,14 +8384,14 @@ darwin* | rhapsody*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     case $host_cpu in
     i*86 )
       # Not sure whether the presence of OpenBSD here was a mistake.
       # Let's accept both of them until this is cleared up.
       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
-      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_cmd=$FILECMD
       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
       ;;
     esac
@@ -8603,7 +8405,7 @@ haiku*)
   ;;
 
 hpux10.20* | hpux11*)
-  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_cmd=$FILECMD
   case $host_cpu in
   ia64*)
     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
@@ -8650,7 +8452,7 @@ netbsd* | netbsdelf*-gnu)
 
 newos6*)
   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
-  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_cmd=$FILECMD
   lt_cv_file_magic_test_file=/usr/lib/libnls.so
   ;;
 
@@ -8716,7 +8518,8 @@ os2*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 esac
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
 printf "%s\n" "$lt_cv_deplibs_check_method" >&6; }
@@ -8768,8 +8571,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_DLLTOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DLLTOOL"; then
+else case e in #(
+  e) if test -n "$DLLTOOL"; then
   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -8791,7 +8594,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 DLLTOOL=$ac_cv_prog_DLLTOOL
 if test -n "$DLLTOOL"; then
@@ -8813,8 +8617,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DLLTOOL"; then
+else case e in #(
+  e) if test -n "$ac_ct_DLLTOOL"; then
   ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -8836,7 +8640,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
 if test -n "$ac_ct_DLLTOOL"; then
@@ -8875,8 +8680,8 @@ printf %s "checking how to associate runtime and link libraries... " >&6; }
 if test ${lt_cv_sharedlib_from_linklib_cmd+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_sharedlib_from_linklib_cmd='unknown'
+else case e in #(
+  e) lt_cv_sharedlib_from_linklib_cmd='unknown'
 
 case $host_os in
 cygwin* | mingw* | pw32* | cegcc*)
@@ -8896,7 +8701,8 @@ cygwin* | mingw* | pw32* | cegcc*)
   lt_cv_sharedlib_from_linklib_cmd=$ECHO
   ;;
 esac
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
 printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
@@ -8919,8 +8725,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_AR+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AR"; then
+else case e in #(
+  e) if test -n "$AR"; then
   ac_cv_prog_AR="$AR" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -8942,7 +8748,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 AR=$ac_cv_prog_AR
 if test -n "$AR"; then
@@ -8968,8 +8775,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_AR+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_AR"; then
+else case e in #(
+  e) if test -n "$ac_ct_AR"; then
   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -8991,7 +8798,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_AR=$ac_cv_prog_ac_ct_AR
 if test -n "$ac_ct_AR"; then
@@ -9020,13 +8828,29 @@ esac
 fi
 
 : ${AR=ar}
-: ${AR_FLAGS=cr}
 
 
 
 
 
 
+# Use ARFLAGS variable as AR's operation code to sync the variable naming with
+# Automake.  If both AR_FLAGS and ARFLAGS are specified, AR_FLAGS should have
+# higher priority because thats what people were doing historically (setting
+# ARFLAGS for automake and AR_FLAGS for libtool).  FIXME: Make the AR_FLAGS
+# variable obsoleted/removed.
+
+test ${AR_FLAGS+y} || AR_FLAGS=${ARFLAGS-cr}
+lt_ar_flags=$AR_FLAGS
+
+
+
+
+
+
+# Make AR_FLAGS overridable by 'make ARFLAGS='.  Don't try to run-time override
+# by AR_FLAGS because that was never working and AR_FLAGS is about to die.
+
 
 
 
@@ -9037,8 +8861,8 @@ printf %s "checking for archiver @FILE support... " >&6; }
 if test ${lt_cv_ar_at_file+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ar_at_file=no
+else case e in #(
+  e) lt_cv_ar_at_file=no
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -9075,7 +8899,8 @@ then :
 
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
+   ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
 printf "%s\n" "$lt_cv_ar_at_file" >&6; }
@@ -9100,8 +8925,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_STRIP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$STRIP"; then
+else case e in #(
+  e) if test -n "$STRIP"; then
   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -9123,7 +8948,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 STRIP=$ac_cv_prog_STRIP
 if test -n "$STRIP"; then
@@ -9145,8 +8971,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_STRIP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_STRIP"; then
+else case e in #(
+  e) if test -n "$ac_ct_STRIP"; then
   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -9168,7 +8994,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
 if test -n "$ac_ct_STRIP"; then
@@ -9209,8 +9036,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_RANLIB+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$RANLIB"; then
+else case e in #(
+  e) if test -n "$RANLIB"; then
   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -9232,7 +9059,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 RANLIB=$ac_cv_prog_RANLIB
 if test -n "$RANLIB"; then
@@ -9254,8 +9082,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_RANLIB+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_RANLIB"; then
+else case e in #(
+  e) if test -n "$ac_ct_RANLIB"; then
   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -9277,7 +9105,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
 if test -n "$ac_ct_RANLIB"; then
@@ -9388,8 +9217,8 @@ printf %s "checking command to parse $NM output from $compiler object... " >&6;
 if test ${lt_cv_sys_global_symbol_pipe+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
 # These are sane defaults that work on at least a few old systems.
 # [They come from Ultrix.  What could be older than Ultrix?!! ;)]
 
@@ -9443,7 +9272,7 @@ esac
 
 if test "$lt_cv_nm_interface" = "MS dumpbin"; then
   # Gets list of data symbols to import.
-  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \(.*\)$/\1/p'"
   # Adjust the below global symbol transforms to fixup imported variables.
   lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
   lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
@@ -9461,20 +9290,20 @@ fi
 # Transform an extracted symbol line into a proper C declaration.
 # Some systems (esp. on ia64) link data and code symbols differently,
 # so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+lt_cv_sys_global_symbol_to_cdecl="$SED -n"\
 $lt_cdecl_hook\
 " -e 's/^T .* \(.*\)$/extern int \1();/p'"\
 " -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
 
 # Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+lt_cv_sys_global_symbol_to_c_name_address="$SED -n"\
 $lt_c_name_hook\
 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
 " -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
 
 # Transform an extracted symbol line into symbol name with lib prefix and
 # symbol address.
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="$SED -n"\
 $lt_c_name_lib_hook\
 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
 " -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
@@ -9498,7 +9327,7 @@ for ac_symprfx in "" "_"; do
   if test "$lt_cv_nm_interface" = "MS dumpbin"; then
     # Fake it for dumpbin and say T for any non-static function,
     # D for any global variable and I for any imported variable.
-    # Also find C++ and __fastcall symbols from MSVC++,
+    # Also find C++ and __fastcall symbols from MSVC++ or ICC,
     # which start with @ or ?.
     lt_cv_sys_global_symbol_pipe="$AWK '"\
 "     {last_section=section; section=\$ 3};"\
@@ -9516,9 +9345,9 @@ for ac_symprfx in "" "_"; do
 "     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
 "     ' prfx=^$ac_symprfx"
   else
-    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+    lt_cv_sys_global_symbol_pipe="$SED -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
   fi
-  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | $SED '/ __gnu_lto/d'"
 
   # Check to see that the pipe works correctly.
   pipe_works=no
@@ -9641,7 +9470,8 @@ _LT_EOF
     lt_cv_sys_global_symbol_pipe=
   fi
 done
-
+ ;;
+esac
 fi
 
 if test -z "$lt_cv_sys_global_symbol_pipe"; then
@@ -9705,8 +9535,9 @@ printf %s "checking for sysroot... " >&6; }
 if test ${with_sysroot+y}
 then :
   withval=$with_sysroot;
-else $as_nop
-  with_sysroot=no
+else case e in #(
+  e) with_sysroot=no ;;
+esac
 fi
 
 
@@ -9718,7 +9549,7 @@ case $with_sysroot in #(
    fi
    ;; #(
  /*)
-   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   lt_sysroot=`echo "$with_sysroot" | $SED -e "$sed_quote_subst"`
    ;; #(
  no|'')
    ;; #(
@@ -9741,8 +9572,8 @@ printf %s "checking for a working dd... " >&6; }
 if test ${ac_cv_path_lt_DD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  printf 0123456789abcdef0123456789abcdef >conftest.i
+else case e in #(
+  e) printf 0123456789abcdef0123456789abcdef >conftest.i
 cat conftest.i conftest.i >conftest2.i
 : ${lt_DD:=$DD}
 if test -z "$lt_DD"; then
@@ -9778,7 +9609,8 @@ else
   ac_cv_path_lt_DD=$lt_DD
 fi
 
-rm -f conftest.i conftest2.i conftest.out
+rm -f conftest.i conftest2.i conftest.out ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
 printf "%s\n" "$ac_cv_path_lt_DD" >&6; }
@@ -9789,8 +9621,8 @@ printf %s "checking how to truncate binary pipes... " >&6; }
 if test ${lt_cv_truncate_bin+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  printf 0123456789abcdef0123456789abcdef >conftest.i
+else case e in #(
+  e) printf 0123456789abcdef0123456789abcdef >conftest.i
 cat conftest.i conftest.i >conftest2.i
 lt_cv_truncate_bin=
 if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
@@ -9798,7 +9630,8 @@ if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; the
   && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
 fi
 rm -f conftest.i conftest2.i conftest.out
-test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
 printf "%s\n" "$lt_cv_truncate_bin" >&6; }
@@ -9843,7 +9676,7 @@ ia64-*-hpux*)
   ac_status=$?
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *ELF-32*)
 	HPUX_IA64_MODE=32
 	;;
@@ -9864,7 +9697,7 @@ ia64-*-hpux*)
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
     if test yes = "$lt_cv_prog_gnu_ld"; then
-      case `/usr/bin/file conftest.$ac_objext` in
+      case `$FILECMD conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -melf32bsmip"
 	  ;;
@@ -9876,7 +9709,7 @@ ia64-*-hpux*)
 	;;
       esac
     else
-      case `/usr/bin/file conftest.$ac_objext` in
+      case `$FILECMD conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -32"
 	  ;;
@@ -9902,7 +9735,7 @@ mips64*-*linux*)
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
     emul=elf
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *32-bit*)
 	emul="${emul}32"
 	;;
@@ -9910,7 +9743,7 @@ mips64*-*linux*)
 	emul="${emul}64"
 	;;
     esac
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *MSB*)
 	emul="${emul}btsmip"
 	;;
@@ -9918,7 +9751,7 @@ mips64*-*linux*)
 	emul="${emul}ltsmip"
 	;;
     esac
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *N32*)
 	emul="${emul}n32"
 	;;
@@ -9942,14 +9775,14 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
   ac_status=$?
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.o` in
+    case `$FILECMD conftest.o` in
       *32-bit*)
 	case $host in
 	  x86_64-*kfreebsd*-gnu)
 	    LD="${LD-ld} -m elf_i386_fbsd"
 	    ;;
 	  x86_64-*linux*)
-	    case `/usr/bin/file conftest.o` in
+	    case `$FILECMD conftest.o` in
 	      *x86-64*)
 		LD="${LD-ld} -m elf32_x86_64"
 		;;
@@ -10008,8 +9841,8 @@ printf %s "checking whether the C compiler needs -belf... " >&6; }
 if test ${lt_cv_cc_needs_belf+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_ext=c
+else case e in #(
+  e) ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
@@ -10029,8 +9862,9 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   lt_cv_cc_needs_belf=yes
-else $as_nop
-  lt_cv_cc_needs_belf=no
+else case e in #(
+  e) lt_cv_cc_needs_belf=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
@@ -10039,7 +9873,8 @@ ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
 printf "%s\n" "$lt_cv_cc_needs_belf" >&6; }
@@ -10057,7 +9892,7 @@ printf "%s\n" "$lt_cv_cc_needs_belf" >&6; }
   ac_status=$?
   printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
   test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.o` in
+    case `$FILECMD conftest.o` in
     *64-bit*)
       case $lt_cv_prog_gnu_ld in
       yes*)
@@ -10097,8 +9932,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_MANIFEST_TOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$MANIFEST_TOOL"; then
+else case e in #(
+  e) if test -n "$MANIFEST_TOOL"; then
   ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10120,7 +9955,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
 if test -n "$MANIFEST_TOOL"; then
@@ -10142,8 +9978,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_MANIFEST_TOOL"; then
+else case e in #(
+  e) if test -n "$ac_ct_MANIFEST_TOOL"; then
   ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10165,7 +10001,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
 if test -n "$ac_ct_MANIFEST_TOOL"; then
@@ -10197,15 +10034,16 @@ printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
 if test ${lt_cv_path_mainfest_tool+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_path_mainfest_tool=no
+else case e in #(
+  e) lt_cv_path_mainfest_tool=no
   echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
   $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
   cat conftest.err >&5
   if $GREP 'Manifest Tool' conftest.out > /dev/null; then
     lt_cv_path_mainfest_tool=yes
   fi
-  rm -f conftest*
+  rm -f conftest* ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
 printf "%s\n" "$lt_cv_path_mainfest_tool" >&6; }
@@ -10228,8 +10066,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_DSYMUTIL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DSYMUTIL"; then
+else case e in #(
+  e) if test -n "$DSYMUTIL"; then
   ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10251,7 +10089,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 DSYMUTIL=$ac_cv_prog_DSYMUTIL
 if test -n "$DSYMUTIL"; then
@@ -10273,8 +10112,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_DSYMUTIL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DSYMUTIL"; then
+else case e in #(
+  e) if test -n "$ac_ct_DSYMUTIL"; then
   ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10296,7 +10135,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
 if test -n "$ac_ct_DSYMUTIL"; then
@@ -10330,8 +10170,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_NMEDIT+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$NMEDIT"; then
+else case e in #(
+  e) if test -n "$NMEDIT"; then
   ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10353,7 +10193,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 NMEDIT=$ac_cv_prog_NMEDIT
 if test -n "$NMEDIT"; then
@@ -10375,8 +10216,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_NMEDIT+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_NMEDIT"; then
+else case e in #(
+  e) if test -n "$ac_ct_NMEDIT"; then
   ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10398,7 +10239,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
 if test -n "$ac_ct_NMEDIT"; then
@@ -10432,8 +10274,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_LIPO+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$LIPO"; then
+else case e in #(
+  e) if test -n "$LIPO"; then
   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10455,7 +10297,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 LIPO=$ac_cv_prog_LIPO
 if test -n "$LIPO"; then
@@ -10477,8 +10320,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_LIPO+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_LIPO"; then
+else case e in #(
+  e) if test -n "$ac_ct_LIPO"; then
   ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10500,7 +10343,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
 if test -n "$ac_ct_LIPO"; then
@@ -10534,8 +10378,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_OTOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OTOOL"; then
+else case e in #(
+  e) if test -n "$OTOOL"; then
   ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10557,7 +10401,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 OTOOL=$ac_cv_prog_OTOOL
 if test -n "$OTOOL"; then
@@ -10579,8 +10424,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_OTOOL+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OTOOL"; then
+else case e in #(
+  e) if test -n "$ac_ct_OTOOL"; then
   ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10602,7 +10447,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
 if test -n "$ac_ct_OTOOL"; then
@@ -10636,8 +10482,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_OTOOL64+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OTOOL64"; then
+else case e in #(
+  e) if test -n "$OTOOL64"; then
   ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10659,7 +10505,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 OTOOL64=$ac_cv_prog_OTOOL64
 if test -n "$OTOOL64"; then
@@ -10681,8 +10528,8 @@ printf %s "checking for $ac_word... " >&6; }
 if test ${ac_cv_prog_ac_ct_OTOOL64+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OTOOL64"; then
+else case e in #(
+  e) if test -n "$ac_ct_OTOOL64"; then
   ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
 else
 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
@@ -10704,7 +10551,8 @@ done
   done
 IFS=$as_save_IFS
 
-fi
+fi ;;
+esac
 fi
 ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
 if test -n "$ac_ct_OTOOL64"; then
@@ -10761,8 +10609,8 @@ printf %s "checking for -single_module linker flag... " >&6; }
 if test ${lt_cv_apple_cc_single_mod+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_apple_cc_single_mod=no
+else case e in #(
+  e) lt_cv_apple_cc_single_mod=no
       if test -z "$LT_MULTI_MODULE"; then
 	# By default we will add the -single_module flag. You can override
 	# by either setting the environment variable LT_MULTI_MODULE
@@ -10788,7 +10636,8 @@ else $as_nop
 	fi
 	rm -rf libconftest.dylib*
 	rm -f conftest.*
-      fi
+      fi ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
 printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; }
@@ -10798,8 +10647,8 @@ printf %s "checking for -exported_symbols_list linker flag... " >&6; }
 if test ${lt_cv_ld_exported_symbols_list+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_exported_symbols_list=no
+else case e in #(
+  e) lt_cv_ld_exported_symbols_list=no
       save_LDFLAGS=$LDFLAGS
       echo "_main" > conftest.sym
       LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
@@ -10817,13 +10666,15 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   lt_cv_ld_exported_symbols_list=yes
-else $as_nop
-  lt_cv_ld_exported_symbols_list=no
+else case e in #(
+  e) lt_cv_ld_exported_symbols_list=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
 	LDFLAGS=$save_LDFLAGS
-
+     ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
 printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; }
@@ -10833,15 +10684,15 @@ printf %s "checking for -force_load linker flag... " >&6; }
 if test ${lt_cv_ld_force_load+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_force_load=no
+else case e in #(
+  e) lt_cv_ld_force_load=no
       cat > conftest.c << _LT_EOF
 int forced_loaded() { return 2;}
 _LT_EOF
       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
-      echo "$AR cr libconftest.a conftest.o" >&5
-      $AR cr libconftest.a conftest.o 2>&5
+      echo "$AR $AR_FLAGS libconftest.a conftest.o" >&5
+      $AR $AR_FLAGS libconftest.a conftest.o 2>&5
       echo "$RANLIB libconftest.a" >&5
       $RANLIB libconftest.a 2>&5
       cat > conftest.c << _LT_EOF
@@ -10859,7 +10710,8 @@ _LT_EOF
       fi
         rm -f conftest.err libconftest.a conftest conftest.c
         rm -rf conftest.dSYM
-
+     ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
 printf "%s\n" "$lt_cv_ld_force_load" >&6; }
@@ -10868,17 +10720,12 @@ printf "%s\n" "$lt_cv_ld_force_load" >&6; }
       _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
     darwin1.*)
       _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[912]*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.[012][,.]*)
-	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-	10.*|11.*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+    darwin*)
+      case $MACOSX_DEPLOYMENT_TARGET,$host in
+        10.[012],*|,*powerpc*-darwin[5-8]*)
+          _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+        *)
+          _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
       esac
     ;;
   esac
@@ -10933,6 +10780,35 @@ func_munge_path_list ()
     esac
 }
 
+ac_header= ac_cache=
+for ac_item in $ac_header_c_list
+do
+  if test $ac_cache; then
+    ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
+    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
+      printf "%s\n" "#define $ac_item 1" >> confdefs.h
+    fi
+    ac_header= ac_cache=
+  elif test $ac_header; then
+    ac_cache=$ac_item
+  else
+    ac_header=$ac_item
+  fi
+done
+
+
+
+
+
+
+
+
+if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
+then :
+
+printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
 ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
 "
 if test "x$ac_cv_header_dlfcn_h" = xyes
@@ -10957,80 +10833,418 @@ func_stripname_cnf ()
 
 
 # Set options
+enable_win32_dll=yes
 
-
-
-        enable_dlopen=no
-
-
-
-            # Check whether --enable-shared was given.
-if test ${enable_shared+y}
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
+set dummy ${ac_tool_prefix}as; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_AS+y}
 then :
-  enableval=$enable_shared; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_shared=yes ;;
-    no) enable_shared=no ;;
-    *)
-      enable_shared=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_shared=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  enable_shared=yes
-fi
-
-
-
-
-
-
-
-
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$AS"; then
+  ac_cv_prog_AS="$AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AS="${ac_tool_prefix}as"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
-  # Check whether --enable-static was given.
-if test ${enable_static+y}
-then :
-  enableval=$enable_static; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_static=yes ;;
-    no) enable_static=no ;;
-    *)
-     enable_static=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_static=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  enable_static=yes
+fi ;;
+esac
+fi
+AS=$ac_cv_prog_AS
+if test -n "$AS"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+printf "%s\n" "$AS" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
 
 
+fi
+if test -z "$ac_cv_prog_AS"; then
+  ac_ct_AS=$AS
+  # Extract the first word of "as", so it can be a program name with args.
+set dummy as; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_AS+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$ac_ct_AS"; then
+  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AS="as"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
+fi ;;
+esac
+fi
+ac_ct_AS=$ac_cv_prog_ac_ct_AS
+if test -n "$ac_ct_AS"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
+printf "%s\n" "$ac_ct_AS" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
 
+  if test "x$ac_ct_AS" = x; then
+    AS="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AS=$ac_ct_AS
+  fi
+else
+  AS="$ac_cv_prog_AS"
+fi
 
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
+fi ;;
+esac
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+printf "%s\n" "$DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
 
 
-
-
-# Check whether --with-pic was given.
-if test ${with_pic+y}
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf "%s\n" "$OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+  ;;
+esac
+
+test -z "$AS" && AS=as
+
+
+
+
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+        enable_dlopen=no
+
+
+
+            # Check whether --enable-shared was given.
+if test ${enable_shared+y}
+then :
+  enableval=$enable_shared; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else case e in #(
+  e) enable_shared=yes ;;
+esac
+fi
+
+
+
+
+
+
+
+
+
+  # Check whether --enable-static was given.
+if test ${enable_static+y}
+then :
+  enableval=$enable_static; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else case e in #(
+  e) enable_static=yes ;;
+esac
+fi
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test ${with_pic+y}
 then :
   withval=$with_pic; lt_p=${PACKAGE-default}
     case $withval in
@@ -11048,8 +11262,9 @@ then :
       IFS=$lt_save_ifs
       ;;
     esac
-else $as_nop
-  pic_mode=default
+else case e in #(
+  e) pic_mode=default ;;
+esac
 fi
 
 
@@ -11079,8 +11294,9 @@ then :
       IFS=$lt_save_ifs
       ;;
     esac
-else $as_nop
-  enable_fast_install=yes
+else case e in #(
+  e) enable_fast_install=yes ;;
+esac
 fi
 
 
@@ -11107,15 +11323,17 @@ then :
       ;;
     esac
     lt_cv_with_aix_soname=$with_aix_soname
-else $as_nop
-  if test ${lt_cv_with_aix_soname+y}
+else case e in #(
+  e) if test ${lt_cv_with_aix_soname+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_with_aix_soname=aix
+else case e in #(
+  e) lt_cv_with_aix_soname=aix ;;
+esac
 fi
 
-    with_aix_soname=$lt_cv_with_aix_soname
+    with_aix_soname=$lt_cv_with_aix_soname ;;
+esac
 fi
 
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
@@ -11206,8 +11424,8 @@ printf %s "checking for objdir... " >&6; }
 if test ${lt_cv_objdir+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  rm -f .libs 2>/dev/null
+else case e in #(
+  e) rm -f .libs 2>/dev/null
 mkdir .libs 2>/dev/null
 if test -d .libs; then
   lt_cv_objdir=.libs
@@ -11215,7 +11433,8 @@ else
   # MS-DOS does not allow filenames that begin with a dot.
   lt_cv_objdir=_libs
 fi
-rmdir .libs 2>/dev/null
+rmdir .libs 2>/dev/null ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
 printf "%s\n" "$lt_cv_objdir" >&6; }
@@ -11246,8 +11465,8 @@ esac
 ofile=libtool
 can_build_shared=yes
 
-# All known linkers require a '.a' archive for static linking (except MSVC,
-# which needs '.lib').
+# All known linkers require a '.a' archive for static linking (except MSVC and
+# ICC, which need '.lib').
 libext=a
 
 with_gnu_ld=$lt_cv_prog_gnu_ld
@@ -11276,8 +11495,8 @@ printf %s "checking for ${ac_tool_prefix}file... " >&6; }
 if test ${lt_cv_path_MAGIC_CMD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  case $MAGIC_CMD in
+else case e in #(
+  e) case $MAGIC_CMD in
 [\\/*] |  ?:[\\/]*)
   lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
   ;;
@@ -11320,6 +11539,7 @@ _LT_EOF
   IFS=$lt_save_ifs
   MAGIC_CMD=$lt_save_MAGIC_CMD
   ;;
+esac ;;
 esac
 fi
 
@@ -11343,8 +11563,8 @@ printf %s "checking for file... " >&6; }
 if test ${lt_cv_path_MAGIC_CMD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  case $MAGIC_CMD in
+else case e in #(
+  e) case $MAGIC_CMD in
 [\\/*] |  ?:[\\/]*)
   lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
   ;;
@@ -11387,6 +11607,7 @@ _LT_EOF
   IFS=$lt_save_ifs
   MAGIC_CMD=$lt_save_MAGIC_CMD
   ;;
+esac ;;
 esac
 fi
 
@@ -11486,8 +11707,8 @@ printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
 if test ${lt_cv_prog_compiler_rtti_exceptions+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_rtti_exceptions=no
+else case e in #(
+  e) lt_cv_prog_compiler_rtti_exceptions=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
@@ -11515,7 +11736,8 @@ else $as_nop
      fi
    fi
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
 printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
@@ -11765,7 +11987,7 @@ lt_prog_compiler_static=
 	lt_prog_compiler_static='-qstaticlink'
 	;;
       *)
-	case `$CC -V 2>&1 | sed 5q` in
+	case `$CC -V 2>&1 | $SED 5q` in
 	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
 	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
 	  lt_prog_compiler_pic='-KPIC'
@@ -11886,8 +12108,9 @@ printf %s "checking for $compiler option to produce PIC... " >&6; }
 if test ${lt_cv_prog_compiler_pic+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
+else case e in #(
+  e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
 printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; }
@@ -11902,8 +12125,8 @@ printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6;
 if test ${lt_cv_prog_compiler_pic_works+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_works=no
+else case e in #(
+  e) lt_cv_prog_compiler_pic_works=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
@@ -11931,7 +12154,8 @@ else $as_nop
      fi
    fi
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
 printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; }
@@ -11967,8 +12191,8 @@ printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6;
 if test ${lt_cv_prog_compiler_static_works+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_static_works=no
+else case e in #(
+  e) lt_cv_prog_compiler_static_works=no
    save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
@@ -11989,7 +12213,8 @@ else $as_nop
    fi
    $RM -r conftest*
    LDFLAGS=$save_LDFLAGS
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
 printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; }
@@ -12011,8 +12236,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
 if test ${lt_cv_prog_compiler_c_o+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o=no
+else case e in #(
+  e) lt_cv_prog_compiler_c_o=no
    $RM -r conftest 2>/dev/null
    mkdir conftest
    cd conftest
@@ -12052,7 +12277,8 @@ else $as_nop
    cd ..
    $RM -r conftest
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
 printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
@@ -12067,8 +12293,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
 if test ${lt_cv_prog_compiler_c_o+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o=no
+else case e in #(
+  e) lt_cv_prog_compiler_c_o=no
    $RM -r conftest 2>/dev/null
    mkdir conftest
    cd conftest
@@ -12108,7 +12334,8 @@ else $as_nop
    cd ..
    $RM -r conftest
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
 printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
@@ -12188,15 +12415,15 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries
 
   case $host_os in
   cygwin* | mingw* | pw32* | cegcc*)
-    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # FIXME: the MSVC++ and ICC port hasn't been tested in a loooong time
     # When not using gcc, we currently assume that we are using
-    # Microsoft Visual C++.
+    # Microsoft Visual C++ or Intel C++ Compiler.
     if test yes != "$GCC"; then
       with_gnu_ld=no
     fi
     ;;
   interix*)
-    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    # we just hope/assume this is gcc and not c89 (= MSVC++ or ICC)
     with_gnu_ld=yes
     ;;
   openbsd* | bitrig*)
@@ -12251,7 +12478,7 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries
       whole_archive_flag_spec=
     fi
     supports_anon_versioning=no
-    case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
+    case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in
       *GNU\ gold*) supports_anon_versioning=yes ;;
       *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
@@ -12363,6 +12590,7 @@ _LT_EOF
 	emximp -o $lib $output_objdir/$libname.def'
       old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
       enable_shared_with_static_runtimes=yes
+      file_list_spec='@'
       ;;
 
     interix[3-9]*)
@@ -12377,7 +12605,7 @@ _LT_EOF
       # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
       # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
       archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
       ;;
 
     gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
@@ -12420,7 +12648,7 @@ _LT_EOF
 	  compiler_needs_object=yes
 	  ;;
 	esac
-	case `$CC -V 2>&1 | sed 5q` in
+	case `$CC -V 2>&1 | $SED 5q` in
 	*Sun\ C*)			# Sun C 5.9
 	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  compiler_needs_object=yes
@@ -12432,13 +12660,14 @@ _LT_EOF
 
         if test yes = "$supports_anon_versioning"; then
           archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
             echo "local: *; };" >> $output_objdir/$libname.ver~
             $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
         fi
 
 	case $cc_basename in
 	tcc*)
+	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
 	  export_dynamic_flag_spec='-rdynamic'
 	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
@@ -12448,7 +12677,7 @@ _LT_EOF
 	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
 	  if test yes = "$supports_anon_versioning"; then
 	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
               echo "local: *; };" >> $output_objdir/$libname.ver~
               $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
 	  fi
@@ -12580,7 +12809,7 @@ _LT_EOF
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
 	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
@@ -12705,8 +12934,8 @@ else
   if test ${lt_cv_aix_libpath_+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -12738,7 +12967,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
   if test -z "$lt_cv_aix_libpath_"; then
     lt_cv_aix_libpath_=/usr/lib:/lib
   fi
-
+   ;;
+esac
 fi
 
   aix_libpath=$lt_cv_aix_libpath_
@@ -12760,8 +12990,8 @@ else
   if test ${lt_cv_aix_libpath_+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -12793,7 +13023,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
   if test -z "$lt_cv_aix_libpath_"; then
     lt_cv_aix_libpath_=/usr/lib:/lib
   fi
-
+   ;;
+esac
 fi
 
   aix_libpath=$lt_cv_aix_libpath_
@@ -12851,12 +13082,12 @@ fi
 
     cygwin* | mingw* | pw32* | cegcc*)
       # When not using gcc, we currently assume that we are using
-      # Microsoft Visual C++.
+      # Microsoft Visual C++ or Intel C++ Compiler.
       # hardcode_libdir_flag_spec is actually meaningless, as there is
       # no search path for DLLs.
       case $cc_basename in
-      cl*)
-	# Native MSVC
+      cl* | icl*)
+	# Native MSVC or ICC
 	hardcode_libdir_flag_spec=' '
 	allow_undefined_flag=unsupported
 	always_export_symbols=yes
@@ -12897,7 +13128,7 @@ fi
           fi'
 	;;
       *)
-	# Assume MSVC wrapper
+	# Assume MSVC and ICC wrapper
 	hardcode_libdir_flag_spec=' '
 	allow_undefined_flag=unsupported
 	# Tell ltmain to make .lib files, not .a files.
@@ -12938,8 +13169,8 @@ fi
     output_verbose_link_cmd=func_echo_all
     archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
     module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+    archive_expsym_cmds="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds="$SED -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
 
   else
   ld_shlibs=no
@@ -12973,7 +13204,7 @@ fi
       ;;
 
     # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
+    freebsd* | dragonfly* | midnightbsd*)
       archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
       hardcode_libdir_flag_spec='-R$libdir'
       hardcode_direct=yes
@@ -13044,8 +13275,8 @@ printf %s "checking if $CC understands -b... " >&6; }
 if test ${lt_cv_prog_compiler__b+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler__b=no
+else case e in #(
+  e) lt_cv_prog_compiler__b=no
    save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS -b"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
@@ -13066,7 +13297,8 @@ else $as_nop
    fi
    $RM -r conftest*
    LDFLAGS=$save_LDFLAGS
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
 printf "%s\n" "$lt_cv_prog_compiler__b" >&6; }
@@ -13114,8 +13346,8 @@ printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&
 if test ${lt_cv_irix_exported_symbol+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  save_LDFLAGS=$LDFLAGS
+else case e in #(
+  e) save_LDFLAGS=$LDFLAGS
 	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
 	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -13124,12 +13356,14 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   lt_cv_irix_exported_symbol=yes
-else $as_nop
-  lt_cv_irix_exported_symbol=no
+else case e in #(
+  e) lt_cv_irix_exported_symbol=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-           LDFLAGS=$save_LDFLAGS
+           LDFLAGS=$save_LDFLAGS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
 printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
@@ -13154,6 +13388,7 @@ printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
 	# Fabrice Bellard et al's Tiny C Compiler
 	ld_shlibs=yes
 	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
 	;;
       esac
       ;;
@@ -13225,6 +13460,7 @@ printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
 	emximp -o $lib $output_objdir/$libname.def'
       old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
       enable_shared_with_static_runtimes=yes
+      file_list_spec='@'
       ;;
 
     osf3*)
@@ -13455,8 +13691,8 @@ printf %s "checking whether -lc should be explicitly linked in... " >&6; }
 if test ${lt_cv_archive_cmds_need_lc+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  $RM conftest*
+else case e in #(
+  e) $RM conftest*
 	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
 	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
@@ -13492,7 +13728,8 @@ else $as_nop
 	  cat conftest.err 1>&5
 	fi
 	$RM conftest*
-
+	 ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
 printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; }
@@ -13917,7 +14154,7 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
 
       sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
       ;;
@@ -13927,14 +14164,14 @@ cygwin* | mingw* | pw32* | cegcc*)
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      library_names_spec='`echo $libname | $SED -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
     ;;
 
-  *,cl*)
-    # Native MSVC
+  *,cl* | *,icl*)
+    # Native MSVC or ICC
     libname_spec='$name'
     soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
     library_names_spec='$libname.dll.lib'
@@ -13953,7 +14190,7 @@ cygwin* | mingw* | pw32* | cegcc*)
       done
       IFS=$lt_save_ifs
       # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
       ;;
     cygwin*)
       # Convert to unix form, then to dos form, then back to unix form
@@ -13990,7 +14227,7 @@ cygwin* | mingw* | pw32* | cegcc*)
     ;;
 
   *)
-    # Assume MSVC wrapper
+    # Assume MSVC and ICC wrapper
     library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
@@ -14023,7 +14260,7 @@ dgux*)
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -14219,8 +14456,8 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   if test ${lt_cv_shlibpath_overrides_runpath+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_shlibpath_overrides_runpath=no
+else case e in #(
+  e) lt_cv_shlibpath_overrides_runpath=no
     save_LDFLAGS=$LDFLAGS
     save_libdir=$libdir
     eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
@@ -14247,7 +14484,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LDFLAGS=$save_LDFLAGS
     libdir=$save_libdir
-
+     ;;
+esac
 fi
 
   shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
@@ -14684,16 +14922,22 @@ printf %s "checking for dlopen in -ldl... " >&6; }
 if test ${ac_cv_lib_dl_dlopen+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
+else case e in #(
+  e) ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldl  $LIBS"
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen (void);
 int
 main (void)
 {
@@ -14705,24 +14949,27 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_lib_dl_dlopen=yes
-else $as_nop
-  ac_cv_lib_dl_dlopen=no
+else case e in #(
+  e) ac_cv_lib_dl_dlopen=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+LIBS=$ac_check_lib_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
 printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
 if test "x$ac_cv_lib_dl_dlopen" = xyes
 then :
   lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
-else $as_nop
-
+else case e in #(
+  e)
     lt_cv_dlopen=dyld
     lt_cv_dlopen_libs=
     lt_cv_dlopen_self=yes
-
+     ;;
+esac
 fi
 
     ;;
@@ -14740,22 +14987,28 @@ fi
 if test "x$ac_cv_func_shl_load" = xyes
 then :
   lt_cv_dlopen=shl_load
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
 printf %s "checking for shl_load in -ldld... " >&6; }
 if test ${ac_cv_lib_dld_shl_load+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
+else case e in #(
+  e) ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldld  $LIBS"
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char shl_load ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load (void);
 int
 main (void)
 {
@@ -14767,39 +15020,47 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_lib_dld_shl_load=yes
-else $as_nop
-  ac_cv_lib_dld_shl_load=no
+else case e in #(
+  e) ac_cv_lib_dld_shl_load=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+LIBS=$ac_check_lib_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
 printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; }
 if test "x$ac_cv_lib_dld_shl_load" = xyes
 then :
   lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
-else $as_nop
-  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+else case e in #(
+  e) ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
 if test "x$ac_cv_func_dlopen" = xyes
 then :
   lt_cv_dlopen=dlopen
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
 printf %s "checking for dlopen in -ldl... " >&6; }
 if test ${ac_cv_lib_dl_dlopen+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
+else case e in #(
+  e) ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldl  $LIBS"
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen (void);
 int
 main (void)
 {
@@ -14811,34 +15072,42 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_lib_dl_dlopen=yes
-else $as_nop
-  ac_cv_lib_dl_dlopen=no
+else case e in #(
+  e) ac_cv_lib_dl_dlopen=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+LIBS=$ac_check_lib_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
 printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
 if test "x$ac_cv_lib_dl_dlopen" = xyes
 then :
   lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
 printf %s "checking for dlopen in -lsvld... " >&6; }
 if test ${ac_cv_lib_svld_dlopen+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
+else case e in #(
+  e) ac_check_lib_save_LIBS=$LIBS
 LIBS="-lsvld  $LIBS"
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen (void);
 int
 main (void)
 {
@@ -14850,34 +15119,42 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_lib_svld_dlopen=yes
-else $as_nop
-  ac_cv_lib_svld_dlopen=no
+else case e in #(
+  e) ac_cv_lib_svld_dlopen=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+LIBS=$ac_check_lib_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
 printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; }
 if test "x$ac_cv_lib_svld_dlopen" = xyes
 then :
   lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
 printf %s "checking for dld_link in -ldld... " >&6; }
 if test ${ac_cv_lib_dld_dld_link+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
+else case e in #(
+  e) ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldld  $LIBS"
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 /* Override any GCC internal prototype to avoid an error.
    Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dld_link ();
+   builtin and then its argument prototype would still apply.
+   The 'extern "C"' is for builds by C++ compilers;
+   although this is not generally supported in C code supporting it here
+   has little cost and some practical benefit (sr 110532).  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link (void);
 int
 main (void)
 {
@@ -14889,12 +15166,14 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_lib_dld_dld_link=yes
-else $as_nop
-  ac_cv_lib_dld_dld_link=no
+else case e in #(
+  e) ac_cv_lib_dld_dld_link=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
+LIBS=$ac_check_lib_save_LIBS ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
 printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; }
@@ -14903,19 +15182,24 @@ then :
   lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
 fi
 
-
+	       ;;
+esac
 fi
 
-
+	     ;;
+esac
 fi
 
-
+	   ;;
+esac
 fi
 
-
+	 ;;
+esac
 fi
 
-
+       ;;
+esac
 fi
 
     ;;
@@ -14943,8 +15227,8 @@ printf %s "checking whether a program can dlopen itself... " >&6; }
 if test ${lt_cv_dlopen_self+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  	  if test yes = "$cross_compiling"; then :
+else case e in #(
+  e) 	  if test yes = "$cross_compiling"; then :
   lt_cv_dlopen_self=cross
 else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
@@ -15038,7 +15322,8 @@ _LT_EOF
 fi
 rm -fr conftest*
 
-
+     ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
 printf "%s\n" "$lt_cv_dlopen_self" >&6; }
@@ -15050,8 +15335,8 @@ printf %s "checking whether a statically linked program can dlopen itself... " >
 if test ${lt_cv_dlopen_self_static+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  	  if test yes = "$cross_compiling"; then :
+else case e in #(
+  e) 	  if test yes = "$cross_compiling"; then :
   lt_cv_dlopen_self_static=cross
 else
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
@@ -15145,7 +15430,8 @@ _LT_EOF
 fi
 rm -fr conftest*
 
-
+       ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
 printf "%s\n" "$lt_cv_dlopen_self_static" >&6; }
@@ -15188,30 +15474,41 @@ striplib=
 old_striplib=
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
 printf %s "checking whether stripping libraries is possible... " >&6; }
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+if test -z "$STRIP"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP"; then
+  if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+    old_striplib="$STRIP --strip-debug"
+    striplib="$STRIP --strip-unneeded"
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+  else
+    case $host_os in
+    darwin*)
+      # FIXME - insert some real tests, host_os isn't really good enough
       striplib="$STRIP -x"
       old_striplib="$STRIP -S"
       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 printf "%s\n" "yes" >&6; }
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+      ;;
+    freebsd*)
+      if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then
+        old_striplib="$STRIP --strip-debug"
+        striplib="$STRIP --strip-unneeded"
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      else
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
-    fi
-    ;;
-  *)
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+      fi
+      ;;
+    *)
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
-    ;;
-  esac
+      ;;
+    esac
+  fi
 fi
 
 
@@ -15292,8 +15589,8 @@ if test -z "$CXXCPP"; then
   if test ${ac_cv_prog_CXXCPP+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-      # Double quotes because $CXX needs to be expanded
+else case e in #(
+  e)     # Double quotes because $CXX needs to be expanded
     for CXXCPP in "$CXX -E" cpp /lib/cpp
     do
       ac_preproc_ok=false
@@ -15311,9 +15608,10 @@ _ACEOF
 if ac_fn_cxx_try_cpp "$LINENO"
 then :
 
-else $as_nop
-  # Broken: fails on valid input.
-continue
+else case e in #(
+  e) # Broken: fails on valid input.
+continue ;;
+esac
 fi
 rm -f conftest.err conftest.i conftest.$ac_ext
 
@@ -15327,15 +15625,16 @@ if ac_fn_cxx_try_cpp "$LINENO"
 then :
   # Broken: success on invalid input.
 continue
-else $as_nop
-  # Passes both tests.
+else case e in #(
+  e) # Passes both tests.
 ac_preproc_ok=:
-break
+break ;;
+esac
 fi
 rm -f conftest.err conftest.i conftest.$ac_ext
 
 done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 rm -f conftest.i conftest.err conftest.$ac_ext
 if $ac_preproc_ok
 then :
@@ -15344,7 +15643,8 @@ fi
 
     done
     ac_cv_prog_CXXCPP=$CXXCPP
-
+   ;;
+esac
 fi
   CXXCPP=$ac_cv_prog_CXXCPP
 else
@@ -15367,9 +15667,10 @@ _ACEOF
 if ac_fn_cxx_try_cpp "$LINENO"
 then :
 
-else $as_nop
-  # Broken: fails on valid input.
-continue
+else case e in #(
+  e) # Broken: fails on valid input.
+continue ;;
+esac
 fi
 rm -f conftest.err conftest.i conftest.$ac_ext
 
@@ -15383,24 +15684,26 @@ if ac_fn_cxx_try_cpp "$LINENO"
 then :
   # Broken: success on invalid input.
 continue
-else $as_nop
-  # Passes both tests.
+else case e in #(
+  e) # Passes both tests.
 ac_preproc_ok=:
-break
+break ;;
+esac
 fi
 rm -f conftest.err conftest.i conftest.$ac_ext
 
 done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 rm -f conftest.i conftest.err conftest.$ac_ext
 if $ac_preproc_ok
 then :
 
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+else case e in #(
+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; } ;;
+esac
 fi
 
 ac_ext=c
@@ -15537,8 +15840,9 @@ cc_basename=$func_cc_basename_result
 if test ${with_gnu_ld+y}
 then :
   withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
+else case e in #(
+  e) with_gnu_ld=no ;;
+esac
 fi
 
 ac_prog=ld
@@ -15583,8 +15887,8 @@ fi
 if test ${lt_cv_path_LD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
+else case e in #(
+  e) if test -z "$LD"; then
   lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
     IFS=$lt_save_ifs
@@ -15607,7 +15911,8 @@ else $as_nop
   IFS=$lt_save_ifs
 else
   lt_cv_path_LD=$LD # Let the user override the test with a path.
-fi
+fi ;;
+esac
 fi
 
 LD=$lt_cv_path_LD
@@ -15624,8 +15929,8 @@ printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
 if test ${lt_cv_prog_gnu_ld+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+else case e in #(
+  e) # I'd rather use --version here, but apparently some GNU lds only accept -v.
 case `$LD -v 2>&1 </dev/null` in
 *GNU* | *'with BFD'*)
   lt_cv_prog_gnu_ld=yes
@@ -15633,6 +15938,7 @@ case `$LD -v 2>&1 </dev/null` in
 *)
   lt_cv_prog_gnu_ld=no
   ;;
+esac ;;
 esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
@@ -15832,8 +16138,8 @@ else
   if test ${lt_cv_aix_libpath__CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -15865,7 +16171,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
   if test -z "$lt_cv_aix_libpath__CXX"; then
     lt_cv_aix_libpath__CXX=/usr/lib:/lib
   fi
-
+   ;;
+esac
 fi
 
   aix_libpath=$lt_cv_aix_libpath__CXX
@@ -15888,8 +16195,8 @@ else
   if test ${lt_cv_aix_libpath__CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -15921,7 +16228,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
   if test -z "$lt_cv_aix_libpath__CXX"; then
     lt_cv_aix_libpath__CXX=/usr/lib:/lib
   fi
-
+   ;;
+esac
 fi
 
   aix_libpath=$lt_cv_aix_libpath__CXX
@@ -15981,8 +16289,8 @@ fi
 
       cygwin* | mingw* | pw32* | cegcc*)
 	case $GXX,$cc_basename in
-	,cl* | no,cl*)
-	  # Native MSVC
+	,cl* | no,cl* | ,icl* | no,icl*)
+	  # Native MSVC or ICC
 	  # hardcode_libdir_flag_spec is actually meaningless, as there is
 	  # no search path for DLLs.
 	  hardcode_libdir_flag_spec_CXX=' '
@@ -16073,11 +16381,11 @@ fi
     output_verbose_link_cmd=func_echo_all
     archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
     module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    module_expsym_cmds_CXX="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+    archive_expsym_cmds_CXX="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds_CXX="$SED -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
        if test yes != "$lt_cv_apple_cc_single_mod"; then
       archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
-      archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+      archive_expsym_cmds_CXX="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
     fi
 
   else
@@ -16112,6 +16420,7 @@ fi
 	  emximp -o $lib $output_objdir/$libname.def'
 	old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
 	enable_shared_with_static_runtimes_CXX=yes
+	file_list_spec_CXX='@'
 	;;
 
       dgux*)
@@ -16142,7 +16451,7 @@ fi
         archive_cmds_need_lc_CXX=no
         ;;
 
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
         # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
         # conventions
         ld_shlibs_CXX=yes
@@ -16279,7 +16588,7 @@ fi
 	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
 	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	archive_expsym_cmds_CXX='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	archive_expsym_cmds_CXX='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 	;;
       irix5* | irix6*)
         case $cc_basename in
@@ -16419,13 +16728,13 @@ fi
 	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 	    if test yes = "$supports_anon_versioning"; then
 	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
-                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
                 echo "local: *; };" >> $output_objdir/$libname.ver~
                 $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
 	    fi
 	    ;;
 	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
+	    case `$CC -V 2>&1 | $SED 5q` in
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      no_undefined_flag_CXX=' -zdefs'
@@ -17082,7 +17391,7 @@ lt_prog_compiler_static_CXX=
 	    ;;
 	esac
 	;;
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
 	# FreeBSD uses GNU C++
 	;;
       hpux9* | hpux10* | hpux11*)
@@ -17165,7 +17474,7 @@ lt_prog_compiler_static_CXX=
 	    lt_prog_compiler_static_CXX='-qstaticlink'
 	    ;;
 	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
+	    case `$CC -V 2>&1 | $SED 5q` in
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      lt_prog_compiler_pic_CXX='-KPIC'
@@ -17292,8 +17601,9 @@ printf %s "checking for $compiler option to produce PIC... " >&6; }
 if test ${lt_cv_prog_compiler_pic_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
+else case e in #(
+  e) lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
 printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; }
@@ -17308,8 +17618,8 @@ printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >
 if test ${lt_cv_prog_compiler_pic_works_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_works_CXX=no
+else case e in #(
+  e) lt_cv_prog_compiler_pic_works_CXX=no
    ac_outfile=conftest.$ac_objext
    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"  ## exclude from sc_useless_quotes_in_assignment
@@ -17337,7 +17647,8 @@ else $as_nop
      fi
    fi
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
 printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
@@ -17367,8 +17678,8 @@ printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6;
 if test ${lt_cv_prog_compiler_static_works_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_static_works_CXX=no
+else case e in #(
+  e) lt_cv_prog_compiler_static_works_CXX=no
    save_LDFLAGS=$LDFLAGS
    LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
    echo "$lt_simple_link_test_code" > conftest.$ac_ext
@@ -17389,7 +17700,8 @@ else $as_nop
    fi
    $RM -r conftest*
    LDFLAGS=$save_LDFLAGS
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
 printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; }
@@ -17408,8 +17720,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
 if test ${lt_cv_prog_compiler_c_o_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o_CXX=no
+else case e in #(
+  e) lt_cv_prog_compiler_c_o_CXX=no
    $RM -r conftest 2>/dev/null
    mkdir conftest
    cd conftest
@@ -17449,7 +17761,8 @@ else $as_nop
    cd ..
    $RM -r conftest
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
 printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
@@ -17461,8 +17774,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
 if test ${lt_cv_prog_compiler_c_o_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o_CXX=no
+else case e in #(
+  e) lt_cv_prog_compiler_c_o_CXX=no
    $RM -r conftest 2>/dev/null
    mkdir conftest
    cd conftest
@@ -17502,7 +17815,8 @@ else $as_nop
    cd ..
    $RM -r conftest
    $RM conftest*
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
 printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
@@ -17552,7 +17866,7 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
       export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
@@ -17560,7 +17874,7 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries
     ;;
   cygwin* | mingw* | cegcc*)
     case $cc_basename in
-    cl*)
+    cl* | icl*)
       exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
       ;;
     *)
@@ -17610,8 +17924,8 @@ printf %s "checking whether -lc should be explicitly linked in... " >&6; }
 if test ${lt_cv_archive_cmds_need_lc_CXX+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  $RM conftest*
+else case e in #(
+  e) $RM conftest*
 	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
 	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
@@ -17647,7 +17961,8 @@ else $as_nop
 	  cat conftest.err 1>&5
 	fi
 	$RM conftest*
-
+	 ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
 printf "%s\n" "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
@@ -17911,7 +18226,7 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
 
       ;;
     mingw* | cegcc*)
@@ -17920,14 +18235,14 @@ cygwin* | mingw* | pw32* | cegcc*)
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
+      library_names_spec='`echo $libname | $SED -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
     ;;
 
-  *,cl*)
-    # Native MSVC
+  *,cl* | *,icl*)
+    # Native MSVC or ICC
     libname_spec='$name'
     soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
     library_names_spec='$libname.dll.lib'
@@ -17946,7 +18261,7 @@ cygwin* | mingw* | pw32* | cegcc*)
       done
       IFS=$lt_save_ifs
       # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
       ;;
     cygwin*)
       # Convert to unix form, then to dos form, then back to unix form
@@ -17983,7 +18298,7 @@ cygwin* | mingw* | pw32* | cegcc*)
     ;;
 
   *)
-    # Assume MSVC wrapper
+    # Assume MSVC and ICC wrapper
     library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
@@ -18015,7 +18330,7 @@ dgux*)
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -18211,8 +18526,8 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
   if test ${lt_cv_shlibpath_overrides_runpath+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_shlibpath_overrides_runpath=no
+else case e in #(
+  e) lt_cv_shlibpath_overrides_runpath=no
     save_LDFLAGS=$LDFLAGS
     save_libdir=$libdir
     eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
@@ -18239,7 +18554,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LDFLAGS=$save_LDFLAGS
     libdir=$save_libdir
-
+     ;;
+esac
 fi
 
   shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
@@ -18630,13 +18946,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 # Only expand once:
 
 
+
  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
 printf %s "checking whether byte ordering is bigendian... " >&6; }
 if test ${ac_cv_c_bigendian+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_c_bigendian=unknown
+else case e in #(
+  e) ac_cv_c_bigendian=unknown
     # See if we're dealing with a universal compiler.
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -18682,8 +18999,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 int
 main (void)
 {
-#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
-		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
+#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \\
+		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \\
 		     && LITTLE_ENDIAN)
 	      bogus endian macros
 	     #endif
@@ -18714,8 +19031,9 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_c_bigendian=yes
-else $as_nop
-  ac_cv_c_bigendian=no
+else case e in #(
+  e) ac_cv_c_bigendian=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
@@ -18759,8 +19077,9 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_c_bigendian=yes
-else $as_nop
-  ac_cv_c_bigendian=no
+else case e in #(
+  e) ac_cv_c_bigendian=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 fi
@@ -18787,22 +19106,23 @@ unsigned short int ascii_mm[] =
 		int use_ebcdic (int i) {
 		  return ebcdic_mm[i] + ebcdic_ii[i];
 		}
-		extern int foo;
-
-int
-main (void)
-{
-return use_ascii (foo) == use_ebcdic (foo);
-  ;
-  return 0;
-}
+		int
+		main (int argc, char **argv)
+		{
+		  /* Intimidate the compiler so that it does not
+		     optimize the arrays away.  */
+		  char *p = argv[0];
+		  ascii_mm[1] = *p++; ebcdic_mm[1] = *p++;
+		  ascii_ii[1] = *p++; ebcdic_ii[1] = *p++;
+		  return use_ascii (argc) == use_ebcdic (*p);
+		}
 _ACEOF
-if ac_fn_c_try_compile "$LINENO"
+if ac_fn_c_try_link "$LINENO"
 then :
-  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
+  if grep BIGenDianSyS conftest$ac_exeext >/dev/null; then
 	      ac_cv_c_bigendian=yes
 	    fi
-	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
+	    if grep LiTTleEnDian conftest$ac_exeext >/dev/null ; then
 	      if test "$ac_cv_c_bigendian" = unknown; then
 		ac_cv_c_bigendian=no
 	      else
@@ -18811,9 +19131,10 @@ then :
 	      fi
 	    fi
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 $ac_includes_default
 int
@@ -18836,14 +19157,17 @@ _ACEOF
 if ac_fn_c_try_run "$LINENO"
 then :
   ac_cv_c_bigendian=no
-else $as_nop
-  ac_cv_c_bigendian=yes
+else case e in #(
+  e) ac_cv_c_bigendian=yes ;;
+esac
 fi
 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
-  conftest.$ac_objext conftest.beam conftest.$ac_ext
+  conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
 
-    fi
+    fi ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
 printf "%s\n" "$ac_cv_c_bigendian" >&6; }
@@ -18864,110 +19188,243 @@ printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
  esac
 
 
-# Check whether --enable-largefile was given.
-if test ${enable_largefile+y}
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}windres", so it can be a program name with args.
+set dummy ${ac_tool_prefix}windres; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_RC+y}
 then :
-  enableval=$enable_largefile;
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -n "$RC"; then
+  ac_cv_prog_RC="$RC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RC="${ac_tool_prefix}windres"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+RC=$ac_cv_prog_RC
+if test -n "$RC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
+printf "%s\n" "$RC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
 
-if test "$enable_largefile" != no; then
 
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
-printf %s "checking for special C compiler options needed for large files... " >&6; }
-if test ${ac_cv_sys_largefile_CC+y}
+fi
+if test -z "$ac_cv_prog_RC"; then
+  ac_ct_RC=$RC
+  # Extract the first word of "windres", so it can be a program name with args.
+set dummy windres; ac_word=$2
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_RC+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_sys_largefile_CC=no
-     if test "$GCC" != yes; then
-       ac_save_CC=$CC
-       while :; do
-	 # IRIX 6.2 and later do not support large files by default,
-	 # so use the C compiler's -n32 option if that helps.
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
+else case e in #(
+  e) if test -n "$ac_ct_RC"; then
+  ac_cv_prog_ac_ct_RC="$ac_ct_RC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RC="windres"
+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
 
-  ;
-  return 0;
-}
-_ACEOF
-	 if ac_fn_c_try_compile "$LINENO"
-then :
-  break
+fi ;;
+esac
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-	 CC="$CC -n32"
-	 if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_largefile_CC=' -n32'; break
+ac_ct_RC=$ac_cv_prog_ac_ct_RC
+if test -n "$ac_ct_RC"; then
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RC" >&5
+printf "%s\n" "$ac_ct_RC" >&6; }
+else
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-	 break
-       done
-       CC=$ac_save_CC
-       rm -f conftest.$ac_ext
-    fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
-printf "%s\n" "$ac_cv_sys_largefile_CC" >&6; }
-  if test "$ac_cv_sys_largefile_CC" != no; then
-    CC=$CC$ac_cv_sys_largefile_CC
+
+  if test "x$ac_ct_RC" = x; then
+    RC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RC=$ac_ct_RC
   fi
+else
+  RC="$ac_cv_prog_RC"
+fi
+
+
+
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+objext_RC=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code=$lt_simple_compile_test_code
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=
+CC=${RC-"windres"}
+CFLAGS=
+compiler=$CC
+compiler_RC=$CC
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+lt_cv_prog_compiler_c_o_RC=yes
+
+if test -n "$compiler"; then
+  :
+
+
+
+fi
+
+GCC=$lt_save_GCC
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+
 
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
-printf %s "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
-if test ${ac_cv_sys_file_offset_bits+y}
+case $host in
+  *-*-msys | *-*-cygwin* | *-*-cegcc*)
+    # These are POSIX-like systems using BSD-like sockets API.
+    ;;
+  *)
+           for ac_header in windows.h
+do :
+  ac_fn_c_check_header_compile "$LINENO" "windows.h" "ac_cv_header_windows_h" "$ac_includes_default"
+if test "x$ac_cv_header_windows_h" = xyes
 then :
-  printf %s "(cached) " >&6
-else $as_nop
-  while :; do
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
+  printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
+ have_windows_h=yes
+else case e in #(
+  e) have_windows_h=no ;;
+esac
+fi
 
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
+done
+    ;;
+esac
+
+# Check whether --enable-largefile was given.
+if test ${enable_largefile+y}
 then :
-  ac_cv_sys_file_offset_bits=no; break
+  enableval=$enable_largefile;
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+if test "$enable_largefile,$enable_year2038" != no,no
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable large file support" >&5
+printf %s "checking for $CC option to enable large file support... " >&6; }
+if test ${ac_cv_sys_largefile_opts+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) ac_save_CC="$CC"
+  ac_opt_found=no
+  for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1" "-n32"; do
+    if test x"$ac_opt" != x"none needed"
+then :
+  CC="$ac_save_CC $ac_opt"
+fi
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#define _FILE_OFFSET_BITS 64
 #include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+#ifndef FTYPE
+# define FTYPE off_t
+#endif
+ /* Check that FTYPE can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_FTYPE to be 9223372036854775807,
     since some C++ compilers masquerading as C compilers
     incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
+#define LARGE_FTYPE (((FTYPE) 1 << 31 << 31) - 1 + ((FTYPE) 1 << 31 << 31))
+  int FTYPE_is_large[(LARGE_FTYPE % 2147483629 == 721
+		       && LARGE_FTYPE % 2147483647 == 1)
 		      ? 1 : -1];
 int
 main (void)
@@ -18979,66 +19436,86 @@ main (void)
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
-  ac_cv_sys_file_offset_bits=64; break
+  if test x"$ac_opt" = x"none needed"
+then :
+  # GNU/Linux s390x and alpha need _FILE_OFFSET_BITS=64 for wide ino_t.
+	 CC="$CC -DFTYPE=ino_t"
+	 if ac_fn_c_try_compile "$LINENO"
+then :
+
+else case e in #(
+  e) CC="$CC -D_FILE_OFFSET_BITS=64"
+	    if ac_fn_c_try_compile "$LINENO"
+then :
+  ac_opt='-D_FILE_OFFSET_BITS=64'
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+fi
+      ac_cv_sys_largefile_opts=$ac_opt
+      ac_opt_found=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  ac_cv_sys_file_offset_bits=unknown
-  break
-done
+    test $ac_opt_found = no || break
+  done
+  CC="$ac_save_CC"
+
+  test $ac_opt_found = yes || ac_cv_sys_largefile_opts="support not detected" ;;
+esac
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
-printf "%s\n" "$ac_cv_sys_file_offset_bits" >&6; }
-case $ac_cv_sys_file_offset_bits in #(
-  no | unknown) ;;
-  *)
-printf "%s\n" "#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits" >>confdefs.h
-;;
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5
+printf "%s\n" "$ac_cv_sys_largefile_opts" >&6; }
+
+ac_have_largefile=yes
+case $ac_cv_sys_largefile_opts in #(
+  "none needed") :
+     ;; #(
+  "supported through gnulib") :
+     ;; #(
+  "support not detected") :
+    ac_have_largefile=no ;; #(
+  "-D_FILE_OFFSET_BITS=64") :
+
+printf "%s\n" "#define _FILE_OFFSET_BITS 64" >>confdefs.h
+ ;; #(
+  "-D_LARGE_FILES=1") :
+
+printf "%s\n" "#define _LARGE_FILES 1" >>confdefs.h
+ ;; #(
+  "-n32") :
+    CC="$CC -n32" ;; #(
+  *) :
+    as_fn_error $? "internal error: bad value for \$ac_cv_sys_largefile_opts" "$LINENO" 5 ;;
 esac
-rm -rf conftest*
-  if test $ac_cv_sys_file_offset_bits = unknown; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
-printf %s "checking for _LARGE_FILES value needed for large files... " >&6; }
-if test ${ac_cv_sys_large_files+y}
+
+if test "$enable_year2038" != no
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option for timestamps after 2038" >&5
+printf %s "checking for $CC option for timestamps after 2038... " >&6; }
+if test ${ac_cv_sys_year2038_opts+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  while :; do
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
+else case e in #(
+  e) ac_save_CPPFLAGS="$CPPFLAGS"
+  ac_opt_found=no
+  for ac_opt in "none needed" "-D_TIME_BITS=64" "-D__MINGW_USE_VC2005_COMPAT" "-U_USE_32_BIT_TIME_T -D__MINGW_USE_VC2005_COMPAT"; do
+    if test x"$ac_opt" != x"none needed"
 then :
-  ac_cv_sys_large_files=no; break
+  CPPFLAGS="$ac_save_CPPFLAGS $ac_opt"
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#define _LARGE_FILES 1
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
+
+  #include <time.h>
+  /* Check that time_t can represent 2**32 - 1 correctly.  */
+  #define LARGE_TIME_T \\
+    ((time_t) (((time_t) 1 << 30) - 1 + 3 * ((time_t) 1 << 30)))
+  int verify_time_t_range[(LARGE_TIME_T / 65537 == 65535
+                           && LARGE_TIME_T % 65537 == 0)
+                          ? 1 : -1];
+
 int
 main (void)
 {
@@ -19049,31 +19526,52 @@ main (void)
 _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
-  ac_cv_sys_large_files=1; break
+  ac_cv_sys_year2038_opts="$ac_opt"
+      ac_opt_found=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  ac_cv_sys_large_files=unknown
-  break
-done
+    test $ac_opt_found = no || break
+  done
+  CPPFLAGS="$ac_save_CPPFLAGS"
+  test $ac_opt_found = yes || ac_cv_sys_year2038_opts="support not detected" ;;
+esac
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
-printf "%s\n" "$ac_cv_sys_large_files" >&6; }
-case $ac_cv_sys_large_files in #(
-  no | unknown) ;;
-  *)
-printf "%s\n" "#define _LARGE_FILES $ac_cv_sys_large_files" >>confdefs.h
-;;
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5
+printf "%s\n" "$ac_cv_sys_year2038_opts" >&6; }
+
+ac_have_year2038=yes
+case $ac_cv_sys_year2038_opts in #(
+  "none needed") :
+     ;; #(
+  "support not detected") :
+    ac_have_year2038=no ;; #(
+  "-D_TIME_BITS=64") :
+
+printf "%s\n" "#define _TIME_BITS 64" >>confdefs.h
+ ;; #(
+  "-D__MINGW_USE_VC2005_COMPAT") :
+
+printf "%s\n" "#define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h
+ ;; #(
+  "-U_USE_32_BIT_TIME_T"*) :
+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+as_fn_error $? "the 'time_t' type is currently forced to be 32-bit. It
+will stop working after mid-January 2038. Remove
+_USE_32BIT_TIME_T from the compiler flags.
+See 'config.log' for more details" "$LINENO" 5; } ;; #(
+  *) :
+    as_fn_error $? "internal error: bad value for \$ac_cv_sys_year2038_opts" "$LINENO" 5 ;;
 esac
-rm -rf conftest*
-  fi
+
 fi
 
+fi
 
 # Crypto backends
 
 found_crypto=none
 found_crypto_str=""
-support_clear_memory=no
 crypto_errors=""
 
 
@@ -19082,18 +19580,20 @@ crypto_errors=""
 
 
 
+
 # Check whether --with-crypto was given.
 if test ${with_crypto+y}
 then :
   withval=$with_crypto; use_crypto=$withval
-else $as_nop
-  use_crypto=auto
-
+else case e in #(
+  e) use_crypto=auto
+ ;;
+esac
 fi
 
 
 case "${use_crypto}" in
-  auto|openssl|libgcrypt|mbedtls|wincng)
+  auto|openssl|libgcrypt|mbedtls|wincng|wolfssl)
 
       if test "X$prefix" = "XNONE"; then
     acl_final_prefix="$ac_default_prefix"
@@ -19115,8 +19615,9 @@ case "${use_crypto}" in
 if test ${with_gnu_ld+y}
 then :
   withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
+else case e in #(
+  e) with_gnu_ld=no ;;
+esac
 fi
 
 # Prepare PATH_SEPARATOR.
@@ -19151,7 +19652,7 @@ printf %s "checking for ld used by GCC... " >&6; }
       # Canonicalize the path of ld
       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
+        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
       done
       test -z "$LD" && LD="$ac_prog"
       ;;
@@ -19174,8 +19675,8 @@ fi
 if test ${acl_cv_path_LD+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
+else case e in #(
+  e) if test -z "$LD"; then
   IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
   for ac_dir in $PATH; do
     test -z "$ac_dir" && ac_dir=.
@@ -19186,16 +19687,17 @@ else $as_nop
       # Break only if it was the GNU/non-GNU ld that we prefer.
       case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
       *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break ;;
+        test "$with_gnu_ld" != no && break ;;
       *)
-	test "$with_gnu_ld" != yes && break ;;
+        test "$with_gnu_ld" != yes && break ;;
       esac
     fi
   done
   IFS="$ac_save_ifs"
 else
   acl_cv_path_LD="$LD" # Let the user override the test with a path.
-fi
+fi ;;
+esac
 fi
 
 LD="$acl_cv_path_LD"
@@ -19212,13 +19714,14 @@ printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
 if test ${acl_cv_prog_gnu_ld+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
+else case e in #(
+  e) # I'd rather use --version here, but apparently some GNU ld's only accept -v.
 case `$LD -v 2>&1 </dev/null` in
 *GNU* | *'with BFD'*)
   acl_cv_prog_gnu_ld=yes ;;
 *)
   acl_cv_prog_gnu_ld=no ;;
+esac ;;
 esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_prog_gnu_ld" >&5
@@ -19234,14 +19737,15 @@ printf %s "checking for shared library run path origin... " >&6; }
 if test ${acl_cv_rpath+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
     ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
     . ./conftest.sh
     rm -f ./conftest.sh
     acl_cv_rpath=done
-
+   ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5
 printf "%s\n" "$acl_cv_rpath" >&6; }
@@ -19258,8 +19762,9 @@ printf "%s\n" "$acl_cv_rpath" >&6; }
 if test ${enable_rpath+y}
 then :
   enableval=$enable_rpath; :
-else $as_nop
-  enable_rpath=yes
+else case e in #(
+  e) enable_rpath=yes ;;
+esac
 fi
 
 
@@ -19767,8 +20272,8 @@ printf %s "checking for libssl... " >&6; }
 if test ${ac_cv_libssl+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     ac_save_LIBS="$LIBS"
     LIBS="$LIBS $LIBSSL"
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -19785,13 +20290,15 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_libssl=yes
-else $as_nop
-  ac_cv_libssl=no
+else case e in #(
+  e) ac_cv_libssl=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LIBS="$ac_save_LIBS"
-
+   ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libssl" >&5
 printf "%s\n" "$ac_cv_libssl" >&6; }
@@ -19819,32 +20326,18 @@ printf "%s\n" "$LIBSSL" >&6; }
 
 
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
   if test "$ac_cv_libssl" = "yes"; then :
 
 
 printf "%s\n" "#define LIBSSH2_OPENSSL 1" >>confdefs.h
 
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }libssl libcrypto"
-
-    # Not all OpenSSL have AES-CTR functions.
-    libssh2_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBSSL"
-    ac_fn_c_check_func "$LINENO" "EVP_aes_128_ctr" "ac_cv_func_EVP_aes_128_ctr"
-if test "x$ac_cv_func_EVP_aes_128_ctr" = xyes
-then :
-  printf "%s\n" "#define HAVE_EVP_AES_128_CTR 1" >>confdefs.h
-
-fi
-
-    LIBS="$libssh2_save_LIBS"
-
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}libcrypto"
     found_crypto="openssl"
-    found_crypto_str="OpenSSL (AES-CTR: ${ac_cv_func_EVP_aes_128_ctr:-N/A})"
+    found_crypto_str="OpenSSL"
 
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
   fi
 
 
@@ -20337,8 +20830,8 @@ printf %s "checking for libgcrypt... " >&6; }
 if test ${ac_cv_libgcrypt+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     ac_save_LIBS="$LIBS"
     LIBS="$LIBS $LIBGCRYPT"
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -20355,13 +20848,15 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_libgcrypt=yes
-else $as_nop
-  ac_cv_libgcrypt=no
+else case e in #(
+  e) ac_cv_libgcrypt=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LIBS="$ac_save_LIBS"
-
+   ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libgcrypt" >&5
 printf "%s\n" "$ac_cv_libgcrypt" >&6; }
@@ -20389,17 +20884,17 @@ printf "%s\n" "$LIBGCRYPT" >&6; }
 
 
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
   if test "$ac_cv_libgcrypt" = "yes"; then :
 
 
 printf "%s\n" "#define LIBSSH2_LIBGCRYPT 1" >>confdefs.h
 
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}libgcrypt"
     found_crypto="libgcrypt"
 
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
   fi
 
 
@@ -20892,8 +21387,8 @@ printf %s "checking for libmbedcrypto... " >&6; }
 if test ${ac_cv_libmbedcrypto+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     ac_save_LIBS="$LIBS"
     LIBS="$LIBS $LIBMBEDCRYPTO"
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
@@ -20910,13 +21405,15 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_libmbedcrypto=yes
-else $as_nop
-  ac_cv_libmbedcrypto=no
+else case e in #(
+  e) ac_cv_libmbedcrypto=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LIBS="$ac_save_LIBS"
-
+   ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libmbedcrypto" >&5
 printf "%s\n" "$ac_cv_libmbedcrypto" >&6; }
@@ -20944,8 +21441,6 @@ printf "%s\n" "$LIBMBEDCRYPTO" >&6; }
 
 
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
   if test "$ac_cv_libmbedcrypto" = "yes"; then :
 
 
@@ -20953,10 +21448,10 @@ printf "%s\n" "#define LIBSSH2_MBEDTLS 1" >>confdefs.h
 
     LIBS="$LIBS -lmbedcrypto"
     found_crypto="mbedtls"
-    support_clear_memory=yes
 
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
   fi
 
 
@@ -20964,125 +21459,23 @@ printf "%s\n" "#define LIBSSH2_MBEDTLS 1" >>confdefs.h
     crypto_errors="${crypto_errors}No mbedtls crypto library found!
 "
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5
-printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; }
-if test ${ac_cv_c_undeclared_builtin_options+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_save_CFLAGS=$CFLAGS
-   ac_cv_c_undeclared_builtin_options='cannot detect'
-   for ac_arg in '' -fno-builtin; do
-     CFLAGS="$ac_save_CFLAGS $ac_arg"
-     # This test program should *not* compile successfully.
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
 
-int
-main (void)
-{
-(void) strchr;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
+if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "wincng"; then
 
-else $as_nop
-  # This test program should compile successfully.
-        # No library function is consistently available on
-        # freestanding implementations, so test against a dummy
-        # declaration.  Include always-available headers on the
-        # off chance that they somehow elicit warnings.
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <float.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-extern void ac_decl (int, char *);
+  if test "x$have_windows_h" = "xyes"; then
+    # Look for Windows Cryptography API: Next Generation
 
-int
-main (void)
-{
-(void) ac_decl (0, (char *) 0);
-  (void) ac_decl;
+    LIBS="$LIBS -lcrypt32"
 
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  if test x"$ac_arg" = x
-then :
-  ac_cv_c_undeclared_builtin_options='none needed'
-else $as_nop
-  ac_cv_c_undeclared_builtin_options=$ac_arg
-fi
-          break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    done
-    CFLAGS=$ac_save_CFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
-printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; }
-  case $ac_cv_c_undeclared_builtin_options in #(
-  'cannot detect') :
-    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot make $CC report undeclared builtins
-See \`config.log' for more details" "$LINENO" 5; } ;; #(
-  'none needed') :
-    ac_c_undeclared_builtin_options='' ;; #(
-  *) :
-    ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;;
-esac
+    # Check necessary for old-MinGW
 
+  libssh2_save_CPPFLAGS="$CPPFLAGS"
+  libssh2_save_LDFLAGS="$LDFLAGS"
 
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "wincng"; then
-
-  # Look for Windows Cryptography API: Next Generation
-
-  ac_fn_c_check_header_compile "$LINENO" "ntdef.h" "ac_cv_header_ntdef_h" "#include <windows.h>
-"
-if test "x$ac_cv_header_ntdef_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_NTDEF_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "ntstatus.h" "ac_cv_header_ntstatus_h" "#include <windows.h>
-"
-if test "x$ac_cv_header_ntstatus_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_NTSTATUS_H 1" >>confdefs.h
-
-fi
-
-  ac_fn_check_decl "$LINENO" "SecureZeroMemory" "ac_cv_have_decl_SecureZeroMemory" "#include <windows.h>
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
-if test "x$ac_cv_have_decl_SecureZeroMemory" = xyes
-then :
-  ac_have_decl=1
-else $as_nop
-  ac_have_decl=0
-fi
-printf "%s\n" "#define HAVE_DECL_SECUREZEROMEMORY $ac_have_decl" >>confdefs.h
-
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libcrypt32_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libcrypt32_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libcrypt32_prefix}/lib"
-  fi
+  if test "${with_libbcrypt_prefix+set}" = set; then
+    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libbcrypt_prefix}/include"
+    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libbcrypt_prefix}/lib"
+  fi
 
 
 
@@ -21108,10 +21501,10 @@ printf "%s\n" "#define HAVE_DECL_SECUREZEROMEMORY $ac_have_decl" >>confdefs.h
   prefix="$acl_save_prefix"
 
 
-# Check whether --with-libcrypt32-prefix was given.
-if test ${with_libcrypt32_prefix+y}
+# Check whether --with-libbcrypt-prefix was given.
+if test ${with_libbcrypt_prefix+y}
 then :
-  withval=$with_libcrypt32_prefix;
+  withval=$with_libbcrypt_prefix;
     if test "X$withval" = "Xno"; then
       use_additional=no
     else
@@ -21136,14 +21529,14 @@ then :
 
 fi
 
-      LIBCRYPT32=
-  LTLIBCRYPT32=
-  INCCRYPT32=
-  LIBCRYPT32_PREFIX=
+      LIBBCRYPT=
+  LTLIBBCRYPT=
+  INCBCRYPT=
+  LIBBCRYPT_PREFIX=
   rpathdirs=
   ltrpathdirs=
   names_already_handled=
-  names_next_round='crypt32 '
+  names_next_round='bcrypt '
   while test -n "$names_next_round"; do
     names_this_round="$names_next_round"
     names_next_round=
@@ -21162,9 +21555,9 @@ fi
         if test -n "$value"; then
           if test "$value" = yes; then
             eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$value"
+            test -z "$value" || LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$value"
             eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }$value"
+            test -z "$value" || LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$value"
           else
                                     :
           fi
@@ -21221,7 +21614,7 @@ fi
             fi
           fi
           if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBCRYPT32; do
+            for x in $LDFLAGS $LTLIBBCRYPT; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21280,10 +21673,10 @@ fi
             done
           fi
           if test "X$found_dir" != "X"; then
-                        LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-L$found_dir -l$name"
+                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$found_dir -l$name"
             if test "X$found_so" != "X"; then
                                                         if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
+                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
               else
                                                                                 haveit=
                 for x in $ltrpathdirs; do
@@ -21296,10 +21689,10 @@ fi
                   ltrpathdirs="$ltrpathdirs $found_dir"
                 fi
                                 if test "$acl_hardcode_direct" = yes; then
-                                                      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
+                                                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
                 else
                   if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
+                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
                                                             haveit=
                     for x in $rpathdirs; do
                       if test "X$x" = "X$found_dir"; then
@@ -21312,7 +21705,7 @@ fi
                     fi
                   else
                                                                                 haveit=
-                    for x in $LDFLAGS $LIBCRYPT32; do
+                    for x in $LDFLAGS $LIBBCRYPT; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21328,28 +21721,28 @@ fi
                       fi
                     done
                     if test -z "$haveit"; then
-                      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$found_dir"
+                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir"
                     fi
                     if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
+                                                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
                     else
-                                                                                                                                                                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-l$name"
+                                                                                                                                                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
                     fi
                   fi
                 fi
               fi
             else
               if test "X$found_a" != "X"; then
-                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_a"
+                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_a"
               else
-                                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$found_dir -l$name"
+                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir -l$name"
               fi
             fi
                         additional_includedir=
             case "$found_dir" in
               */$acl_libdirstem | */$acl_libdirstem/)
                 basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBCRYPT32_PREFIX="$basedir"
+                LIBBCRYPT_PREFIX="$basedir"
                 additional_includedir="$basedir/include"
                 ;;
             esac
@@ -21364,7 +21757,7 @@ fi
                   fi
                 fi
                 if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCCRYPT32; do
+                  for x in $CPPFLAGS $INCBCRYPT; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21381,7 +21774,7 @@ fi
                   done
                   if test -z "$haveit"; then
                     if test -d "$additional_includedir"; then
-                                            INCCRYPT32="${INCCRYPT32}${INCCRYPT32:+ }-I$additional_includedir"
+                                            INCBCRYPT="${INCBCRYPT}${INCBCRYPT:+ }-I$additional_includedir"
                     fi
                   fi
                 fi
@@ -21409,7 +21802,7 @@ fi
                       fi
                       if test -z "$haveit"; then
                         haveit=
-                        for x in $LDFLAGS $LIBCRYPT32; do
+                        for x in $LDFLAGS $LIBBCRYPT; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21426,11 +21819,11 @@ fi
                         done
                         if test -z "$haveit"; then
                           if test -d "$additional_libdir"; then
-                                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$additional_libdir"
+                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$additional_libdir"
                           fi
                         fi
                         haveit=
-                        for x in $LDFLAGS $LTLIBCRYPT32; do
+                        for x in $LDFLAGS $LTLIBBCRYPT; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21447,7 +21840,7 @@ fi
                         done
                         if test -z "$haveit"; then
                           if test -d "$additional_libdir"; then
-                                                        LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-L$additional_libdir"
+                                                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$additional_libdir"
                           fi
                         fi
                       fi
@@ -21485,15 +21878,15 @@ fi
                                                                                 names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                     ;;
                   *)
-                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$dep"
-                    LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }$dep"
+                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$dep"
+                    LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$dep"
                     ;;
                 esac
               done
             fi
           else
-                                                            LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-l$name"
-            LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-l$name"
+                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
+            LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-l$name"
           fi
         fi
       fi
@@ -21509,27 +21902,27 @@ fi
       libdir="$alldirs"
       eval flag=\"$acl_hardcode_libdir_flag_spec\"
       libdir="$acl_save_libdir"
-      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$flag"
+      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
     else
             for found_dir in $rpathdirs; do
         acl_save_libdir="$libdir"
         libdir="$found_dir"
         eval flag=\"$acl_hardcode_libdir_flag_spec\"
         libdir="$acl_save_libdir"
-        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$flag"
+        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
       done
     fi
   fi
   if test "X$ltrpathdirs" != "X"; then
             for found_dir in $ltrpathdirs; do
-      LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-R$found_dir"
+      LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-R$found_dir"
     done
   fi
 
 
         ac_save_CPPFLAGS="$CPPFLAGS"
 
-  for element in $INCCRYPT32; do
+  for element in $INCBCRYPT; do
     haveit=
     for x in $CPPFLAGS; do
 
@@ -21552,20 +21945,20 @@ fi
   done
 
 
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libcrypt32" >&5
-printf %s "checking for libcrypt32... " >&6; }
-if test ${ac_cv_libcrypt32+y}
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libbcrypt" >&5
+printf %s "checking for libbcrypt... " >&6; }
+if test ${ac_cv_libbcrypt+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBCRYPT32"
+    LIBS="$LIBS $LIBBCRYPT"
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-    #include <windows.h>
-    #include <wincrypt.h>
+      #include <windows.h>
+      #include <bcrypt.h>
 
 int
 main (void)
@@ -21577,32 +21970,34 @@ main (void)
 _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
-  ac_cv_libcrypt32=yes
-else $as_nop
-  ac_cv_libcrypt32=no
+  ac_cv_libbcrypt=yes
+else case e in #(
+  e) ac_cv_libbcrypt=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LIBS="$ac_save_LIBS"
-
+   ;;
+esac
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libcrypt32" >&5
-printf "%s\n" "$ac_cv_libcrypt32" >&6; }
-  if test "$ac_cv_libcrypt32" = yes; then
-    HAVE_LIBCRYPT32=yes
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libbcrypt" >&5
+printf "%s\n" "$ac_cv_libbcrypt" >&6; }
+  if test "$ac_cv_libbcrypt" = yes; then
+    HAVE_LIBBCRYPT=yes
 
-printf "%s\n" "#define HAVE_LIBCRYPT32 1" >>confdefs.h
+printf "%s\n" "#define HAVE_LIBBCRYPT 1" >>confdefs.h
 
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libcrypt32" >&5
-printf %s "checking how to link with libcrypt32... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBCRYPT32" >&5
-printf "%s\n" "$LIBCRYPT32" >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libbcrypt" >&5
+printf %s "checking how to link with libbcrypt... " >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBBCRYPT" >&5
+printf "%s\n" "$LIBBCRYPT" >&6; }
   else
-    HAVE_LIBCRYPT32=no
+    HAVE_LIBBCRYPT=no
             CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBCRYPT32=
-    LTLIBCRYPT32=
-    LIBCRYPT32_PREFIX=
+    LIBBCRYPT=
+    LTLIBBCRYPT=
+    LIBBCRYPT_PREFIX=
   fi
 
 
@@ -21612,21 +22007,35 @@ printf "%s\n" "$LIBCRYPT32" >&6; }
 
 
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
+  if test "$ac_cv_libbcrypt" = "yes"; then :
+
+
+printf "%s\n" "#define LIBSSH2_WINCNG 1" >>confdefs.h
 
-  if test "$ac_cv_libcrypt32" = "yes"; then :
+      found_crypto="wincng"
+      found_crypto_str="Windows Cryptography API: Next Generation"
 
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
+  fi
+
   fi
 
+  test "$found_crypto" = "none" &&
+    crypto_errors="${crypto_errors}No wincng crypto library found!
+"
+fi
+
+if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "wolfssl"; then
+
 
   libssh2_save_CPPFLAGS="$CPPFLAGS"
   libssh2_save_LDFLAGS="$LDFLAGS"
 
-  if test "${with_libbcrypt_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libbcrypt_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libbcrypt_prefix}/lib"
+  if test "${with_libwolfssl_prefix+set}" = set; then
+    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libwolfssl_prefix}/include"
+    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libwolfssl_prefix}/lib"
   fi
 
 
@@ -21653,10 +22062,10 @@ printf "%s\n" "$LIBCRYPT32" >&6; }
   prefix="$acl_save_prefix"
 
 
-# Check whether --with-libbcrypt-prefix was given.
-if test ${with_libbcrypt_prefix+y}
+# Check whether --with-libwolfssl-prefix was given.
+if test ${with_libwolfssl_prefix+y}
 then :
-  withval=$with_libbcrypt_prefix;
+  withval=$with_libwolfssl_prefix;
     if test "X$withval" = "Xno"; then
       use_additional=no
     else
@@ -21681,14 +22090,14 @@ then :
 
 fi
 
-      LIBBCRYPT=
-  LTLIBBCRYPT=
-  INCBCRYPT=
-  LIBBCRYPT_PREFIX=
+      LIBWOLFSSL=
+  LTLIBWOLFSSL=
+  INCWOLFSSL=
+  LIBWOLFSSL_PREFIX=
   rpathdirs=
   ltrpathdirs=
   names_already_handled=
-  names_next_round='bcrypt '
+  names_next_round='wolfssl '
   while test -n "$names_next_round"; do
     names_this_round="$names_next_round"
     names_next_round=
@@ -21707,9 +22116,9 @@ fi
         if test -n "$value"; then
           if test "$value" = yes; then
             eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$value"
+            test -z "$value" || LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$value"
             eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$value"
+            test -z "$value" || LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }$value"
           else
                                     :
           fi
@@ -21766,7 +22175,7 @@ fi
             fi
           fi
           if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBBCRYPT; do
+            for x in $LDFLAGS $LTLIBWOLFSSL; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21825,10 +22234,10 @@ fi
             done
           fi
           if test "X$found_dir" != "X"; then
-                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$found_dir -l$name"
+                        LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }-L$found_dir -l$name"
             if test "X$found_so" != "X"; then
                                                         if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
+                                LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$found_so"
               else
                                                                                 haveit=
                 for x in $ltrpathdirs; do
@@ -21841,10 +22250,10 @@ fi
                   ltrpathdirs="$ltrpathdirs $found_dir"
                 fi
                                 if test "$acl_hardcode_direct" = yes; then
-                                                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
+                                                      LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$found_so"
                 else
                   if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
+                                                            LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$found_so"
                                                             haveit=
                     for x in $rpathdirs; do
                       if test "X$x" = "X$found_dir"; then
@@ -21857,7 +22266,7 @@ fi
                     fi
                   else
                                                                                 haveit=
-                    for x in $LDFLAGS $LIBBCRYPT; do
+                    for x in $LDFLAGS $LIBWOLFSSL; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21873,28 +22282,28 @@ fi
                       fi
                     done
                     if test -z "$haveit"; then
-                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir"
+                      LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }-L$found_dir"
                     fi
                     if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
+                                                                                        LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$found_so"
                     else
-                                                                                                                                                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
+                                                                                                                                                                                LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }-l$name"
                     fi
                   fi
                 fi
               fi
             else
               if test "X$found_a" != "X"; then
-                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_a"
+                                LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$found_a"
               else
-                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir -l$name"
+                                                LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }-L$found_dir -l$name"
               fi
             fi
                         additional_includedir=
             case "$found_dir" in
               */$acl_libdirstem | */$acl_libdirstem/)
                 basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBBCRYPT_PREFIX="$basedir"
+                LIBWOLFSSL_PREFIX="$basedir"
                 additional_includedir="$basedir/include"
                 ;;
             esac
@@ -21909,7 +22318,7 @@ fi
                   fi
                 fi
                 if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCBCRYPT; do
+                  for x in $CPPFLAGS $INCWOLFSSL; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21926,7 +22335,7 @@ fi
                   done
                   if test -z "$haveit"; then
                     if test -d "$additional_includedir"; then
-                                            INCBCRYPT="${INCBCRYPT}${INCBCRYPT:+ }-I$additional_includedir"
+                                            INCWOLFSSL="${INCWOLFSSL}${INCWOLFSSL:+ }-I$additional_includedir"
                     fi
                   fi
                 fi
@@ -21954,7 +22363,7 @@ fi
                       fi
                       if test -z "$haveit"; then
                         haveit=
-                        for x in $LDFLAGS $LIBBCRYPT; do
+                        for x in $LDFLAGS $LIBWOLFSSL; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21971,11 +22380,11 @@ fi
                         done
                         if test -z "$haveit"; then
                           if test -d "$additional_libdir"; then
-                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$additional_libdir"
+                                                        LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }-L$additional_libdir"
                           fi
                         fi
                         haveit=
-                        for x in $LDFLAGS $LTLIBBCRYPT; do
+                        for x in $LDFLAGS $LTLIBWOLFSSL; do
 
   acl_save_prefix="$prefix"
   prefix="$acl_final_prefix"
@@ -21992,7 +22401,7 @@ fi
                         done
                         if test -z "$haveit"; then
                           if test -d "$additional_libdir"; then
-                                                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$additional_libdir"
+                                                        LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }-L$additional_libdir"
                           fi
                         fi
                       fi
@@ -22030,15 +22439,15 @@ fi
                                                                                 names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                     ;;
                   *)
-                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$dep"
-                    LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$dep"
+                                        LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$dep"
+                    LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }$dep"
                     ;;
                 esac
               done
             fi
           else
-                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
-            LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-l$name"
+                                                            LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }-l$name"
+            LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }-l$name"
           fi
         fi
       fi
@@ -22054,27 +22463,27 @@ fi
       libdir="$alldirs"
       eval flag=\"$acl_hardcode_libdir_flag_spec\"
       libdir="$acl_save_libdir"
-      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
+      LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$flag"
     else
             for found_dir in $rpathdirs; do
         acl_save_libdir="$libdir"
         libdir="$found_dir"
         eval flag=\"$acl_hardcode_libdir_flag_spec\"
         libdir="$acl_save_libdir"
-        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
+        LIBWOLFSSL="${LIBWOLFSSL}${LIBWOLFSSL:+ }$flag"
       done
     fi
   fi
   if test "X$ltrpathdirs" != "X"; then
             for found_dir in $ltrpathdirs; do
-      LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-R$found_dir"
+      LTLIBWOLFSSL="${LTLIBWOLFSSL}${LTLIBWOLFSSL:+ }-R$found_dir"
     done
   fi
 
 
         ac_save_CPPFLAGS="$CPPFLAGS"
 
-  for element in $INCBCRYPT; do
+  for element in $INCWOLFSSL; do
     haveit=
     for x in $CPPFLAGS; do
 
@@ -22097,21 +22506,18 @@ fi
   done
 
 
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libbcrypt" >&5
-printf %s "checking for libbcrypt... " >&6; }
-if test ${ac_cv_libbcrypt+y}
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libwolfssl" >&5
+printf %s "checking for libwolfssl... " >&6; }
+if test ${ac_cv_libwolfssl+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-
+else case e in #(
+  e)
     ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBBCRYPT"
+    LIBS="$LIBS $LIBWOLFSSL"
     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-
-    #include <windows.h>
-    #include <bcrypt.h>
-
+#include <wolfssl/options.h>
 int
 main (void)
 {
@@ -22122,32 +22528,34 @@ main (void)
 _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
-  ac_cv_libbcrypt=yes
-else $as_nop
-  ac_cv_libbcrypt=no
+  ac_cv_libwolfssl=yes
+else case e in #(
+  e) ac_cv_libwolfssl=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
     LIBS="$ac_save_LIBS"
-
+   ;;
+esac
 fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libbcrypt" >&5
-printf "%s\n" "$ac_cv_libbcrypt" >&6; }
-  if test "$ac_cv_libbcrypt" = yes; then
-    HAVE_LIBBCRYPT=yes
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libwolfssl" >&5
+printf "%s\n" "$ac_cv_libwolfssl" >&6; }
+  if test "$ac_cv_libwolfssl" = yes; then
+    HAVE_LIBWOLFSSL=yes
 
-printf "%s\n" "#define HAVE_LIBBCRYPT 1" >>confdefs.h
+printf "%s\n" "#define HAVE_LIBWOLFSSL 1" >>confdefs.h
 
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libbcrypt" >&5
-printf %s "checking how to link with libbcrypt... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBBCRYPT" >&5
-printf "%s\n" "$LIBBCRYPT" >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libwolfssl" >&5
+printf %s "checking how to link with libwolfssl... " >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBWOLFSSL" >&5
+printf "%s\n" "$LIBWOLFSSL" >&6; }
   else
-    HAVE_LIBBCRYPT=no
+    HAVE_LIBWOLFSSL=no
             CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBBCRYPT=
-    LTLIBBCRYPT=
-    LIBBCRYPT_PREFIX=
+    LIBWOLFSSL=
+    LTLIBWOLFSSL=
+    LIBWOLFSSL_PREFIX=
   fi
 
 
@@ -22157,81 +22565,60 @@ printf "%s\n" "$LIBBCRYPT" >&6; }
 
 
 
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libbcrypt" = "yes"; then :
+  if test "$ac_cv_libwolfssl" = "yes"; then :
 
 
-printf "%s\n" "#define LIBSSH2_WINCNG 1" >>confdefs.h
+printf "%s\n" "#define LIBSSH2_WOLFSSL 1" >>confdefs.h
 
-    found_crypto="wincng"
-    found_crypto_str="Windows Cryptography API: Next Generation"
-    support_clear_memory="$ac_cv_have_decl_SecureZeroMemory"
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}wolfssl"
+    found_crypto="wolfssl"
 
   else
     CPPFLAGS="$libssh2_save_CPPFLAGS"
+    LDFLAGS="$libssh2_save_LDFLAGS"
   fi
 
 
   test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No wincng crypto library found!
+    crypto_errors="${crypto_errors}No wolfssl crypto library found!
 "
 fi
 
     ;;
   yes|"")
-    crypto_errors="No crypto backend specified!"
+    crypto_errors="No crypto backend specified."
     ;;
   *)
-    crypto_errors="Unknown crypto backend '${use_crypto}' specified!"
+    crypto_errors="Unknown crypto backend '${use_crypto}' specified."
     ;;
 esac
 
 if test "$found_crypto" = "none"; then
   crypto_errors="${crypto_errors}
-Specify --with-crypto=\$backend and/or the neccessary library search prefix.
+Specify --with-crypto=\$backend and/or the necessary library search prefix.
 
-Known crypto backends: auto, openssl, libgcrypt, mbedtls, wincng"
+Known crypto backends: auto, openssl, libgcrypt, mbedtls, wincng, wolfssl"
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: ${crypto_errors}" >&5
 printf "%s\n" "$as_me: ERROR: ${crypto_errors}" >&6;}
 else
   test "$found_crypto_str" = "" && found_crypto_str="$found_crypto"
 fi
 
- if test "$found_crypto" = "openssl"; then
-  OPENSSL_TRUE=
-  OPENSSL_FALSE='#'
-else
-  OPENSSL_TRUE='#'
-  OPENSSL_FALSE=
+# ECDSA support with WinCNG
+# Check whether --enable-ecdsa-wincng was given.
+if test ${enable_ecdsa_wincng+y}
+then :
+  enableval=$enable_ecdsa_wincng; wincng_ecdsa=$enableval
 fi
 
- if test "$found_crypto" = "libgcrypt"; then
-  LIBGCRYPT_TRUE=
-  LIBGCRYPT_FALSE='#'
-else
-  LIBGCRYPT_TRUE='#'
-  LIBGCRYPT_FALSE=
-fi
+if test "$wincng_ecdsa" = yes; then
 
- if test "$found_crypto" = "mbedtls"; then
-  MBEDTLS_TRUE=
-  MBEDTLS_FALSE='#'
-else
-  MBEDTLS_TRUE='#'
-  MBEDTLS_FALSE=
-fi
+printf "%s\n" "#define LIBSSH2_ECDSA_WINCNG 1" >>confdefs.h
 
- if test "$found_crypto" = "wincng"; then
-  WINCNG_TRUE=
-  WINCNG_FALSE='#'
 else
-  WINCNG_TRUE='#'
-  WINCNG_FALSE=
+  wincng_ecdsa=no
 fi
 
-
-
 # libz
 
 
@@ -22239,8 +22626,9 @@ fi
 if test ${with_libz+y}
 then :
   withval=$with_libz; use_libz=$withval
-else $as_nop
-  use_libz=auto
+else case e in #(
+  e) use_libz=auto ;;
+esac
 fi
 
 
@@ -22659,480 +23047,2617 @@ fi
                                                             LIBZ="${LIBZ}${LIBZ:+ }-l$name"
             LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-l$name"
           fi
-        fi
+        fi
+      fi
+    done
+  done
+  if test "X$rpathdirs" != "X"; then
+    if test -n "$acl_hardcode_libdir_separator"; then
+                        alldirs=
+      for found_dir in $rpathdirs; do
+        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
+      done
+            acl_save_libdir="$libdir"
+      libdir="$alldirs"
+      eval flag=\"$acl_hardcode_libdir_flag_spec\"
+      libdir="$acl_save_libdir"
+      LIBZ="${LIBZ}${LIBZ:+ }$flag"
+    else
+            for found_dir in $rpathdirs; do
+        acl_save_libdir="$libdir"
+        libdir="$found_dir"
+        eval flag=\"$acl_hardcode_libdir_flag_spec\"
+        libdir="$acl_save_libdir"
+        LIBZ="${LIBZ}${LIBZ:+ }$flag"
+      done
+    fi
+  fi
+  if test "X$ltrpathdirs" != "X"; then
+            for found_dir in $ltrpathdirs; do
+      LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-R$found_dir"
+    done
+  fi
+
+
+        ac_save_CPPFLAGS="$CPPFLAGS"
+
+  for element in $INCZ; do
+    haveit=
+    for x in $CPPFLAGS; do
+
+  acl_save_prefix="$prefix"
+  prefix="$acl_final_prefix"
+  acl_save_exec_prefix="$exec_prefix"
+  exec_prefix="$acl_final_exec_prefix"
+  eval x=\"$x\"
+  exec_prefix="$acl_save_exec_prefix"
+  prefix="$acl_save_prefix"
+
+      if test "X$x" = "X$element"; then
+        haveit=yes
+        break
+      fi
+    done
+    if test -z "$haveit"; then
+      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
+    fi
+  done
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libz" >&5
+printf %s "checking for libz... " >&6; }
+if test ${ac_cv_libz+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e)
+    ac_save_LIBS="$LIBS"
+    LIBS="$LIBS $LIBZ"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <zlib.h>
+int
+main (void)
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+  ac_cv_libz=yes
+else case e in #(
+  e) ac_cv_libz=no ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+    conftest$ac_exeext conftest.$ac_ext
+    LIBS="$ac_save_LIBS"
+   ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libz" >&5
+printf "%s\n" "$ac_cv_libz" >&6; }
+  if test "$ac_cv_libz" = yes; then
+    HAVE_LIBZ=yes
+
+printf "%s\n" "#define HAVE_LIBZ 1" >>confdefs.h
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libz" >&5
+printf %s "checking how to link with libz... " >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBZ" >&5
+printf "%s\n" "$LIBZ" >&6; }
+  else
+    HAVE_LIBZ=no
+            CPPFLAGS="$ac_save_CPPFLAGS"
+    LIBZ=
+    LTLIBZ=
+    LIBZ_PREFIX=
+  fi
+
+
+
+
+
+
+
+  if test "$ac_cv_libz" != yes; then
+    if test "$use_libz" = auto; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot find libz, disabling compression" >&5
+printf "%s\n" "$as_me: Cannot find libz, disabling compression" >&6;}
+      found_libz="disabled; no libz found"
+    else
+      libz_errors="No libz found.
+Try --with-libz-prefix=PATH if you know that you have it."
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: $libz_errors" >&5
+printf "%s\n" "$as_me: ERROR: $libz_errors" >&6;}
+    fi
+  else
+
+printf "%s\n" "#define LIBSSH2_HAVE_ZLIB 1" >>confdefs.h
+
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}zlib"
+    found_libz="yes"
+  fi
+fi
+
+
+
+#
+# Optional Settings
+#
+# Check whether --enable-clear-memory was given.
+if test ${enable_clear_memory+y}
+then :
+  enableval=$enable_clear_memory; CLEAR_MEMORY=$enableval
+fi
+
+if test "$CLEAR_MEMORY" = "no"; then
+
+printf "%s\n" "#define LIBSSH2_NO_CLEAR_MEMORY 1" >>confdefs.h
+
+  enable_clear_memory=no
+else
+  enable_clear_memory=yes
+fi
+
+LIBSSH2_CFLAG_EXTRAS=""
+
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable compiler warnings as errors" >&5
+printf %s "checking whether to enable compiler warnings as errors... " >&6; }
+  OPT_COMPILER_WERROR="default"
+  # Check whether --enable-werror was given.
+if test ${enable_werror+y}
+then :
+  enableval=$enable_werror; OPT_COMPILER_WERROR=$enableval
+fi
+
+  case "$OPT_COMPILER_WERROR" in
+    no)
+            want_werror="no"
+      ;;
+    default)
+            want_werror="no"
+      ;;
+    *)
+            want_werror="yes"
+      ;;
+  esac
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_werror" >&5
+printf "%s\n" "$want_werror" >&6; }
+
+  if test X"$want_werror" = Xyes; then
+    LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -Werror"
+  fi
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable pedantic and debug compiler options" >&5
+printf %s "checking whether to enable pedantic and debug compiler options... " >&6; }
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+printf %s "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test ${ac_cv_prog_CPP+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e)     # Double quotes because $CC needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+else case e in #(
+  e) # Broken: fails on valid input.
+continue ;;
+esac
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else case e in #(
+  e) # Passes both tests.
+ac_preproc_ok=:
+break ;;
+esac
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+   ;;
+esac
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+printf "%s\n" "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <limits.h>
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+else case e in #(
+  e) # Broken: fails on valid input.
+continue ;;
+esac
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+  # Broken: success on invalid input.
+continue
+else case e in #(
+  e) # Passes both tests.
+ac_preproc_ok=:
+break ;;
+esac
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok
+then :
+
+else case e in #(
+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See 'config.log' for more details" "$LINENO" 5; } ;;
+esac
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep -e" >&5
+printf %s "checking for egrep -e... " >&6; }
+if test ${ac_cv_path_EGREP_TRADITIONAL+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) if test -z "$EGREP_TRADITIONAL"; then
+  ac_path_EGREP_TRADITIONAL_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in grep ggrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP_TRADITIONAL="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP_TRADITIONAL" || continue
+# Check for GNU ac_path_EGREP_TRADITIONAL and select it if it is found.
+  # Check for GNU $ac_path_EGREP_TRADITIONAL
+case `"$ac_path_EGREP_TRADITIONAL" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_EGREP_TRADITIONAL="$ac_path_EGREP_TRADITIONAL" ac_path_EGREP_TRADITIONAL_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl"
+    "$ac_path_EGREP_TRADITIONAL" -E 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_TRADITIONAL_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP_TRADITIONAL="$ac_path_EGREP_TRADITIONAL"
+      ac_path_EGREP_TRADITIONAL_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_TRADITIONAL_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP_TRADITIONAL"; then
+    :
+  fi
+else
+  ac_cv_path_EGREP_TRADITIONAL=$EGREP_TRADITIONAL
+fi
+
+    if test "$ac_cv_path_EGREP_TRADITIONAL"
+then :
+  ac_cv_path_EGREP_TRADITIONAL="$ac_cv_path_EGREP_TRADITIONAL -E"
+else case e in #(
+  e) if test -z "$EGREP_TRADITIONAL"; then
+  ac_path_EGREP_TRADITIONAL_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  case $as_dir in #(((
+    '') as_dir=./ ;;
+    */) ;;
+    *) as_dir=$as_dir/ ;;
+  esac
+    for ac_prog in egrep
+   do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP_TRADITIONAL="$as_dir$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP_TRADITIONAL" || continue
+# Check for GNU ac_path_EGREP_TRADITIONAL and select it if it is found.
+  # Check for GNU $ac_path_EGREP_TRADITIONAL
+case `"$ac_path_EGREP_TRADITIONAL" --version 2>&1` in #(
+*GNU*)
+  ac_cv_path_EGREP_TRADITIONAL="$ac_path_EGREP_TRADITIONAL" ac_path_EGREP_TRADITIONAL_found=:;;
+#(
+*)
+  ac_count=0
+  printf %s 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl"
+    "$ac_path_EGREP_TRADITIONAL" 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_TRADITIONAL_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP_TRADITIONAL="$ac_path_EGREP_TRADITIONAL"
+      ac_path_EGREP_TRADITIONAL_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_TRADITIONAL_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP_TRADITIONAL"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP_TRADITIONAL=$EGREP_TRADITIONAL
+fi
+ ;;
+esac
+fi ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP_TRADITIONAL" >&5
+printf "%s\n" "$ac_cv_path_EGREP_TRADITIONAL" >&6; }
+ EGREP_TRADITIONAL=$ac_cv_path_EGREP_TRADITIONAL
+
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if cpp -P is needed" >&5
+printf %s "checking if cpp -P is needed... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+ #include <errno.h>
+TEST EINVAL TEST
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP_TRADITIONAL "TEST.*TEST" >/dev/null 2>&1
+then :
+  cpp=no
+else case e in #(
+  e) cpp=yes ;;
+esac
+fi
+rm -rf conftest*
+
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cpp" >&5
+printf "%s\n" "$cpp" >&6; }
+
+    if test "x$cpp" = "xyes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if cpp -P works" >&5
+printf %s "checking if cpp -P works... " >&6; }
+    OLDCPPFLAGS=$CPPFLAGS
+    CPPFLAGS="$CPPFLAGS -P"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+ #include <errno.h>
+TEST EINVAL TEST
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP_TRADITIONAL "TEST.*TEST" >/dev/null 2>&1
+then :
+  cpp_p=yes
+else case e in #(
+  e) cpp_p=no ;;
+esac
+fi
+rm -rf conftest*
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cpp_p" >&5
+printf "%s\n" "$cpp_p" >&6; }
+
+    if test "x$cpp_p" = "xno"; then
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: failed to figure out cpp -P alternative" >&5
+printf "%s\n" "$as_me: WARNING: failed to figure out cpp -P alternative" >&2;}
+      # without -P
+      CPPPFLAG=""
+    else
+      # with -P
+      CPPPFLAG="-P"
+    fi
+        CPPFLAGS=$OLDCPPFLAGS
+  else
+    # without -P
+    CPPPFLAG=""
+  fi
+
+
+squeeze() {
+  _sqz_result=""
+  eval _sqz_input=\$$1
+  for _sqz_token in $_sqz_input; do
+    if test -z "$_sqz_result"; then
+      _sqz_result="$_sqz_token"
+    else
+      _sqz_result="$_sqz_result $_sqz_token"
+    fi
+  done
+  eval $1=\$_sqz_result
+  return 0
+}
+
+# Check whether --enable-debug was given.
+if test ${enable_debug+y}
+then :
+  enableval=$enable_debug;  case "$enable_debug" in
+  no)
+       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+       CPPFLAGS="$CPPFLAGS -DNDEBUG"
+       ;;
+  *)   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    enable_debug=yes
+    CPPFLAGS="$CPPFLAGS -DLIBSSH2DEBUG"
+    CFLAGS="$CFLAGS -g"
+
+
+  if test "z$CLANG" = "z"; then
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is clang" >&5
+printf %s "checking if compiler is clang... " >&6; }
+
+    OLDCPPFLAGS=$CPPFLAGS
+  # CPPPFLAG comes from CURL_CPP_P
+  CPPFLAGS="$CPPFLAGS $CPPPFLAG"
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __clang__
+CURL_DEF_TOKEN __clang__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__clang__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___clang__=no
+
+  else
+    curl_cv_have_def___clang__=yes
+    curl_cv_def___clang__=$tmp_exp
+
+  fi
+      CPPFLAGS=$OLDCPPFLAGS
+
+  if test "$curl_cv_have_def___clang__" = "yes"; then
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if compiler is xlclang" >&5
+printf %s "checking if compiler is xlclang... " >&6; }
+
+    OLDCPPFLAGS=$CPPFLAGS
+  # CPPPFLAG comes from CURL_CPP_P
+  CPPFLAGS="$CPPFLAGS $CPPPFLAG"
+      if test -z "$SED"; then
+    as_fn_error $? "SED not set. Cannot continue without SED being set." "$LINENO" 5
+  fi
+  if test -z "$GREP"; then
+    as_fn_error $? "GREP not set. Cannot continue without GREP being set." "$LINENO" 5
+  fi
+
+  tmp_exp=""
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+#ifdef __ibmxl__
+CURL_DEF_TOKEN __ibmxl__
+#endif
+
+
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"
+then :
+
+    tmp_exp=`eval "$ac_cpp conftest.$ac_ext" 2>/dev/null | \
+      "$GREP" CURL_DEF_TOKEN 2>/dev/null | \
+      "$SED" 's/.*CURL_DEF_TOKEN[ ][ ]*//' 2>/dev/null | \
+      "$SED" 's/["][ ]*["]//g' 2>/dev/null`
+    if test -z "$tmp_exp" || test "$tmp_exp" = "__ibmxl__"; then
+      tmp_exp=""
+    fi
+
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+  if test -z "$tmp_exp"; then
+    curl_cv_have_def___ibmxl__=no
+
+  else
+    curl_cv_have_def___ibmxl__=yes
+    curl_cv_def___ibmxl__=$tmp_exp
+
+  fi
+      CPPFLAGS=$OLDCPPFLAGS
+
+    if test "$curl_cv_have_def___ibmxl__" = "yes" ; then
+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+      compiler_id="XLCLANG"
+    else
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+      compiler_id="CLANG"
+    fi
+    flags_dbg_yes="-g"
+    flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+    if test "z$compiler_id" = "zCLANG"; then
+      CLANG="yes"
+    else
+      CLANG="no"
+    fi
+  fi
+  if test "z$ICC" = "z"; then
+
+  ICC="no"
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for icc in use" >&5
+printf %s "checking for icc in use... " >&6; }
+  if test "$GCC" = "yes"; then
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+__INTEL_COMPILER
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP_TRADITIONAL "^__INTEL_COMPILER" >/dev/null 2>&1
+then :
+              ICC="no"
+else case e in #(
+  e)       ICC="yes"
+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+
+     ;;
+esac
+fi
+rm -rf conftest*
+
+  fi
+  if test "$ICC" = "no"; then
+    # this is not ICC
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+  fi
+
+  fi
+
+  if test "$CLANG" = "yes"; then
+
+          # indentation to match curl's m4/curl-compilers.m4
+
+                    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking compiler version" >&5
+printf %s "checking compiler version... " >&6; }
+          fullclangver=`$CC -v 2>&1 | grep version`
+          if echo $fullclangver | grep 'Apple' >/dev/null; then
+            appleclang=1
+          else
+            appleclang=0
+          fi
+          clangver=`echo $fullclangver | grep "based on LLVM " | "$SED" 's/.*(based on LLVM \([0-9]*\.[0-9]*\).*)/\1/'`
+          if test -z "$clangver"; then
+            clangver=`echo $fullclangver | "$SED" 's/.*version \([0-9]*\.[0-9]*\).*/\1/'`
+            oldapple=0
+          else
+            oldapple=1
+          fi
+          clangvhi=`echo $clangver | cut -d . -f1`
+          clangvlo=`echo $clangver | cut -d . -f2`
+          compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
+          if test "$appleclang" = '1' && test "$oldapple" = '0'; then
+                        if   test "$compiler_num" -ge '1300'; then compiler_num='1200'
+            elif test "$compiler_num" -ge '1205'; then compiler_num='1101'
+            elif test "$compiler_num" -ge '1204'; then compiler_num='1000'
+            elif test "$compiler_num" -ge '1107'; then compiler_num='900'
+            elif test "$compiler_num" -ge '1103'; then compiler_num='800'
+            elif test "$compiler_num" -ge '1003'; then compiler_num='700'
+            elif test "$compiler_num" -ge '1001'; then compiler_num='600'
+            elif test "$compiler_num" -ge  '904'; then compiler_num='500'
+            elif test "$compiler_num" -ge  '902'; then compiler_num='400'
+            elif test "$compiler_num" -ge  '803'; then compiler_num='309'
+            elif test "$compiler_num" -ge  '703'; then compiler_num='308'
+            else                                       compiler_num='307'
+            fi
+          fi
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: clang '$compiler_num' (raw: '$fullclangver' / '$clangver')" >&5
+printf "%s\n" "clang '$compiler_num' (raw: '$fullclangver' / '$clangver')" >&6; }
+
+          tmp_CFLAGS="-pedantic"
+          if test "$want_werror" = "yes"; then
+            LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -pedantic-errors"
+          fi
+
+    ac_var_added_warnings=""
+  for warning in all extra; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in pointer-arith write-strings; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in shadow; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in inline nested-externs; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-declarations; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-prototypes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+
+    ac_var_added_warnings=""
+  for warning in float-equal; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in sign-compare; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar"
+
+    ac_var_added_warnings=""
+  for warning in undef; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+
+    ac_var_added_warnings=""
+  for warning in endif-labels strict-prototypes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in declaration-after-statement; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in cast-align; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+
+    ac_var_added_warnings=""
+  for warning in shorten-64-to-32; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          #
+                    if test "$compiler_num" -ge "101"; then
+
+    ac_var_added_warnings=""
+  for warning in unused; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "207"; then
+
+    ac_var_added_warnings=""
+  for warning in address; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in attributes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in bad-function-cast; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in conversion; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in div-by-zero format-security; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in empty-body; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-field-initializers; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-noreturn; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in old-style-definition; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in redundant-decls; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [switch-enum])       # Not used because this basically disallows default case
+
+    ac_var_added_warnings=""
+  for warning in type-limits; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            if test "x$have_windows_h" != "xyes"; then
+
+    ac_var_added_warnings=""
+  for warning in unused-macros; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+  # Seen to clash with libtool-generated stub code
+            fi
+
+    ac_var_added_warnings=""
+  for warning in unreachable-code unused-parameter; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "208"; then
+
+    ac_var_added_warnings=""
+  for warning in ignored-qualifiers; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in vla; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "209"; then
+
+    ac_var_added_warnings=""
+  for warning in sign-conversion; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-error=sign-conversion"           # FIXME
+
+    ac_var_added_warnings=""
+  for warning in shift-sign-overflow; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [padded])  # Not used because we cannot change public structs
+          fi
+          #
+                    if test "$compiler_num" -ge "300"; then
+
+    ac_var_added_warnings=""
+  for warning in language-extension-token; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat=2"
+          fi
+          #
+                    if test "$compiler_num" -ge "302"; then
+
+    ac_var_added_warnings=""
+  for warning in enum-conversion; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in sometimes-uninitialized; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            case $host_os in
+            cygwin* | mingw*)
+                                          ;;
+            *)
+
+    ac_var_added_warnings=""
+  for warning in missing-variable-declarations; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+              ;;
+            esac
+          fi
+          #
+                    if test "$compiler_num" -ge "304"; then
+
+    ac_var_added_warnings=""
+  for warning in header-guard; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in unused-const-variable; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "305"; then
+
+    ac_var_added_warnings=""
+  for warning in pragmas; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in unreachable-code-break; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "306"; then
+
+    ac_var_added_warnings=""
+  for warning in double-promotion; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "309"; then
+
+    ac_var_added_warnings=""
+  for warning in comma; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            # avoid the varargs warning, fixed in 4.0
+            # https://bugs.llvm.org/show_bug.cgi?id=29140
+            if test "$compiler_num" -lt "400"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-varargs"
+            fi
+          fi
+                    if test "$compiler_num" -ge "700"; then
+
+    ac_var_added_warnings=""
+  for warning in assign-enum; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in extra-semi-stmt; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+                    if test "$compiler_num" -ge "1000"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wimplicit-fallthrough"  # we have silencing markup for clang 10.0 and above only
+          fi
+
+          CFLAGS="$CFLAGS $tmp_CFLAGS"
+
+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added this set of compiler options: $tmp_CFLAGS" >&5
+printf "%s\n" "$as_me: Added this set of compiler options: $tmp_CFLAGS" >&6;}
+
+  elif test "$GCC" = "yes"; then
+
+        # indentation to match curl's m4/curl-compilers.m4
+
+                { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking compiler version" >&5
+printf %s "checking compiler version... " >&6; }
+        # strip '-suffix' parts, e.g. Ubuntu Windows cross-gcc returns '10-win32'
+        gccver=`$CC -dumpversion | sed -E 's/-.+$//'`
+        gccvhi=`echo $gccver | cut -d . -f1`
+        if echo $gccver | grep -F "." >/dev/null; then
+          gccvlo=`echo $gccver | cut -d . -f2`
+        else
+          gccvlo="0"
+        fi
+        compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: gcc '$compiler_num' (raw: '$gccver')" >&5
+printf "%s\n" "gcc '$compiler_num' (raw: '$gccver')" >&6; }
+
+        if test "$ICC" = "yes"; then
+
+
+          tmp_CFLAGS="-wd279,269,981,1418,1419"
+
+          if test "$compiler_num" -gt "600"; then
+                          tmp_CFLAGS="-Wall $tmp_CFLAGS"
+          fi
+        else                     tmp_CFLAGS="-pedantic"
+          if test "$want_werror" = "yes"; then
+            LIBSSH2_CFLAG_EXTRAS="$LIBSSH2_CFLAG_EXTRAS -pedantic-errors"
+          fi
+
+    ac_var_added_warnings=""
+  for warning in all; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          tmp_CFLAGS="$tmp_CFLAGS -W"
+
+    ac_var_added_warnings=""
+  for warning in pointer-arith write-strings; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          #
+                    if test "$compiler_num" -ge "207"; then
+
+    ac_var_added_warnings=""
+  for warning in inline nested-externs; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-declarations; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-prototypes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "295"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+
+    ac_var_added_warnings=""
+  for warning in bad-function-cast; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "296"; then
+
+    ac_var_added_warnings=""
+  for warning in float-equal; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar"
+
+    ac_var_added_warnings=""
+  for warning in sign-compare; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in undef; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "297"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          fi
+          #
+                    if test "$compiler_num" -ge "300"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+
+    ac_var_added_warnings=""
+  for warning in unused shadow; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "303"; then
+
+    ac_var_added_warnings=""
+  for warning in endif-labels strict-prototypes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "304"; then
+
+    ac_var_added_warnings=""
+  for warning in declaration-after-statement; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in old-style-definition; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "400"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
+          fi
+          #
+                    if test "$compiler_num" -ge "401"; then
+
+    ac_var_added_warnings=""
+  for warning in attributes; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
       fi
     done
   done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBZ="${LIBZ}${LIBZ:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBZ="${LIBZ}${LIBZ:+ }$flag"
-      done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-R$found_dir"
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in div-by-zero format-security; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
     done
-  fi
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-        ac_save_CPPFLAGS="$CPPFLAGS"
 
-  for element in $INCZ; do
-    haveit=
-    for x in $CPPFLAGS; do
+    ac_var_added_warnings=""
+  for warning in missing-field-initializers; do
 
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in missing-noreturn; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
       fi
     done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
   done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
 
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libz" >&5
-printf %s "checking for libz... " >&6; }
-if test ${ac_cv_libz+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
+    ac_var_added_warnings=""
+  for warning in unreachable-code unused-parameter; do
 
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBZ"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <zlib.h>
-int
-main (void)
-{
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libz=yes
-else $as_nop
-  ac_cv_libz=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libz" >&5
-printf "%s\n" "$ac_cv_libz" >&6; }
-  if test "$ac_cv_libz" = yes; then
-    HAVE_LIBZ=yes
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [padded])           # Not used because we cannot change public structs
 
-printf "%s\n" "#define HAVE_LIBZ 1" >>confdefs.h
+    ac_var_added_warnings=""
+  for warning in pragmas; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libz" >&5
-printf %s "checking how to link with libz... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBZ" >&5
-printf "%s\n" "$LIBZ" >&6; }
-  else
-    HAVE_LIBZ=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBZ=
-    LTLIBZ=
-    LIBZ_PREFIX=
-  fi
 
+    ac_var_added_warnings=""
+  for warning in redundant-decls; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
+          # CURL_ADD_COMPILER_WARNINGS([tmp_CFLAGS], [switch-enum])      # Not used because this basically disallows default case
 
+    ac_var_added_warnings=""
+  for warning in unused-macros; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-  if test "$ac_cv_libz" != yes; then
-    if test "$use_libz" = auto; then
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot find libz, disabling compression" >&5
-printf "%s\n" "$as_me: Cannot find libz, disabling compression" >&6;}
-      found_libz="disabled; no libz found"
-    else
-      libz_errors="No libz found!
-Try --with-libz-prefix=PATH if you know that you have it."
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: $libz_errors" >&5
-printf "%s\n" "$as_me: ERROR: $libz_errors" >&6;}
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
-  else
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-printf "%s\n" "#define LIBSSH2_HAVE_ZLIB 1" >>confdefs.h
+          fi
+          #
+                    if test "$compiler_num" -ge "402"; then
 
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }zlib"
-    found_libz="yes"
-  fi
-fi
+    ac_var_added_warnings=""
+  for warning in cast-align; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-#
-# Optional Settings
-#
-# Check whether --enable-crypt-none was given.
-if test ${enable_crypt_none+y}
-then :
-  enableval=$enable_crypt_none;
-printf "%s\n" "#define LIBSSH2_CRYPT_NONE 1" >>confdefs.h
+          fi
+          #
+                    if test "$compiler_num" -ge "403"; then
 
-fi
+    ac_var_added_warnings=""
+  for warning in address; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-# Check whether --enable-mac-none was given.
-if test ${enable_mac_none+y}
-then :
-  enableval=$enable_mac_none;
-printf "%s\n" "#define LIBSSH2_MAC_NONE 1" >>confdefs.h
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-fi
 
+    ac_var_added_warnings=""
+  for warning in type-limits old-style-declaration; do
 
-# Check whether --enable-gex-new was given.
-if test ${enable_gex_new+y}
-then :
-  enableval=$enable_gex_new; GEX_NEW=$enableval
-fi
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-if test "$GEX_NEW" != "no"; then
 
-printf "%s\n" "#define LIBSSH2_DH_GEX_NEW 1" >>confdefs.h
+    ac_var_added_warnings=""
+  for warning in missing-parameter-type empty-body; do
 
-fi
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-# Check whether --enable-clear-memory was given.
-if test ${enable_clear_memory+y}
-then :
-  enableval=$enable_clear_memory; CLEAR_MEMORY=$enableval
-fi
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-if test "$CLEAR_MEMORY" != "no"; then
-  if test "$support_clear_memory" = "yes"; then
 
-printf "%s\n" "#define LIBSSH2_CLEAR_MEMORY 1" >>confdefs.h
+    ac_var_added_warnings=""
+  for warning in clobbered ignored-qualifiers; do
 
-    enable_clear_memory=yes
-  else
-    if test "$CLEAR_MEMORY" = "yes"; then
-      as_fn_error $? "secure clearing/zeroing of memory is not supported by the selected crypto backend" "$LINENO" 5
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&5
-printf "%s\n" "$as_me: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&2;}
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
-    enable_clear_memory=unsupported
-  fi
-else
-  if test "$support_clear_memory" = "yes"; then
-    enable_clear_memory=no
-  else
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&5
-printf "%s\n" "$as_me: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&2;}
-    enable_clear_memory=unsupported
-  fi
-fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable pedantic and debug compiler options" >&5
-printf %s "checking whether to enable pedantic and debug compiler options... " >&6; }
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-printf %s "checking how to run the C preprocessor... " >&6; }
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  if test ${ac_cv_prog_CPP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-      # Double quotes because $CC needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
-    do
-      ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
 
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
+    ac_var_added_warnings=""
+  for warning in conversion trampolines; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in sign-conversion; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-error=sign-conversion"          # FIXME
+
+    ac_var_added_warnings=""
+  for warning in vla; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
+                        tmp_CFLAGS="$tmp_CFLAGS -ftree-vrp"
+          fi
+          #
+                    if test "$compiler_num" -ge "405"; then
+                        case $host_os in
+            mingw*)
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
+              ;;
+            esac
+          fi
+          #
+                    if test "$compiler_num" -ge "406"; then
 
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
-  break
-fi
+    ac_var_added_warnings=""
+  for warning in double-promotion; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
     done
-    ac_cv_prog_CPP=$CPP
-
-fi
-  CPP=$ac_cv_prog_CPP
-else
-  ac_cv_prog_CPP=$CPP
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-printf "%s\n" "$CPP" >&6; }
-ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
+  done
 
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
+          fi
+          #
+                    if test "$compiler_num" -ge "408"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat=2"
+          fi
+          #
+                    if test "$compiler_num" -ge "500"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Warray-bounds=2"
+          fi
+          #
+                    if test "$compiler_num" -ge "600"; then
 
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
+    ac_var_added_warnings=""
+  for warning in shift-negative-value; do
 
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
+            tmp_CFLAGS="$tmp_CFLAGS -Wshift-overflow=2"
 
-# Check whether --enable-debug was given.
-if test ${enable_debug+y}
-then :
-  enableval=$enable_debug;  case "$enable_debug" in
-  no)
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-       CPPFLAGS="$CPPFLAGS -DNDEBUG"
-       ;;
-  *)   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-    enable_debug=yes
-    CPPFLAGS="$CPPFLAGS -DLIBSSH2DEBUG"
-    CFLAGS="$CFLAGS -g"
+    ac_var_added_warnings=""
+  for warning in null-dereference; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-    if test "z$ICC" = "z"; then
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-    ICC="no"
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for icc in use" >&5
-printf %s "checking for icc in use... " >&6; }
-    if test "$GCC" = "yes"; then
-              cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-__INTEL_COMPILER
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "^__INTEL_COMPILER" >/dev/null 2>&1
-then :
-                    ICC="no"
-else $as_nop
-           ICC="yes"
-         { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+            tmp_CFLAGS="$tmp_CFLAGS -fdelete-null-pointer-checks"
 
+    ac_var_added_warnings=""
+  for warning in duplicated-cond; do
 
-fi
-rm -rf conftest*
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
-    if test "$ICC" = "no"; then
-        # this is not ICC
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+
+    ac_var_added_warnings=""
+  for warning in unused-const-variable; do
+
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
+
+          fi
+          #
+                    if test "$compiler_num" -ge "700"; then
+
+    ac_var_added_warnings=""
+  for warning in duplicated-branches; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
     fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-    if test "$GCC" = "yes"; then
 
-              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5
-printf %s "checking gcc version... " >&6; }
-       gccver=`$CC -dumpversion`
-       num1=`echo $gccver | cut -d . -f1`
-       num2=`echo $gccver | cut -d . -f2`
-       gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gccver" >&5
-printf "%s\n" "$gccver" >&6; }
+    ac_var_added_warnings=""
+  for warning in restrict; do
 
-       if test "$ICC" = "yes"; then
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-         WARN="-wd279,269,981,1418,1419"
 
-         if test "$gccnum" -gt "600"; then
-                        WARN="-Wall $WARN"
-         fi
-       else                   WARN="-W -Wall -Wwrite-strings -pedantic -Wpointer-arith -Wnested-externs -Winline -Wmissing-prototypes"
+    ac_var_added_warnings=""
+  for warning in alloc-zero; do
 
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-         if test "$gccnum" -ge "207"; then
-                      WARN="$WARN -Wmissing-declarations"
-         fi
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-         if test "$gccnum" -gt "295"; then
-                                            WARN="$WARN -Wundef -Wno-long-long -Wsign-compare"
-         fi
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat-overflow=2"
+            tmp_CFLAGS="$tmp_CFLAGS -Wformat-truncation=2"
+            tmp_CFLAGS="$tmp_CFLAGS -Wimplicit-fallthrough"
+          fi
+          #
+                    if test "$compiler_num" -ge "1000"; then
 
-         if test "$gccnum" -ge "296"; then
-                      WARN="$WARN -Wfloat-equal"
-         fi
+    ac_var_added_warnings=""
+  for warning in arith-conversion; do
 
-         if test "$gccnum" -gt "296"; then
-                      WARN="$WARN -Wno-format-nonliteral"
-         fi
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-         if test "$gccnum" -ge "303"; then
-                      WARN="$WARN -Wendif-labels -Wstrict-prototypes"
-         fi
 
-         if test "$gccnum" -ge "304"; then
-           # try these on gcc 3.4
-           WARN="$WARN -Wdeclaration-after-statement"
-         fi
+    ac_var_added_warnings=""
+  for warning in enum-conversion; do
 
-         for flag in $CPPFLAGS; do
-           case "$flag" in
-            -I*)
-                                                        add=`echo $flag | sed 's/^-I/-isystem /g'`
-              WARN="$WARN $add"
-              ;;
-           esac
-         done
+  ac_var_match_word="no"
+  for word1 in $CFLAGS; do
+    for word2 in -Wno-$warning -W$warning; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
 
-       fi
-       CFLAGS="$CFLAGS $WARN"
+    if test "$ac_var_match_word" = "no"; then
+      ac_var_added_warnings="$ac_var_added_warnings -W$warning"
+    fi
+  done
+    tmp_CFLAGS="$tmp_CFLAGS $ac_var_added_warnings"
+  squeeze tmp_CFLAGS
 
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added this set of compiler options: $WARN" >&5
-printf "%s\n" "$as_me: Added this set of compiler options: $WARN" >&6;}
+          fi
 
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added no extra compiler options" >&5
-printf "%s\n" "$as_me: Added no extra compiler options" >&6;}
+          for flag in $CPPFLAGS; do
+            case "$flag" in
+             -I*)
+                                                            add=`echo $flag | sed 's/^-I/-isystem /g'`
+               tmp_CFLAGS="$tmp_CFLAGS $add"
+               ;;
+            esac
+          done
 
     fi
-        NEWFLAGS=""
-    for flag in $CFLAGS; do
-      case "$flag" in
-      -O*)
-                ;;
-      *)
-        NEWFLAGS="$NEWFLAGS $flag"
-        ;;
-      esac
-    done
-    CFLAGS=$NEWFLAGS
+    CFLAGS="$CFLAGS $tmp_CFLAGS"
+
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added this set of compiler options: $tmp_CFLAGS" >&5
+printf "%s\n" "$as_me: Added this set of compiler options: $tmp_CFLAGS" >&6;}
+
+  else
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added no extra compiler options" >&5
+printf "%s\n" "$as_me: Added no extra compiler options" >&6;}
+
+  fi
+    NEWFLAGS=""
+  for flag in $CFLAGS; do
+    case "$flag" in
+    -O*)
+            ;;
+    *)
+      NEWFLAGS="$NEWFLAGS $flag"
+      ;;
+    esac
+  done
+  CFLAGS=$NEWFLAGS
 
 
        ;;
   esac
 
-else $as_nop
-  enable_debug=no
+else case e in #(
+  e) enable_debug=no
        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
-
+ ;;
+esac
 fi
 
 
+
+
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable hidden symbols in the library" >&5
 printf %s "checking whether to enable hidden symbols in the library... " >&6; }
 # Check whether --enable-hidden-symbols was given.
@@ -23174,10 +25699,64 @@ printf "%s\n" "no" >&6; }
        fi
        ;;
   esac
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+else case e in #(
+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
+ ;;
+esac
+fi
+
+
+# Check whether --enable-deprecated was given.
+if test ${enable_deprecated+y}
+then :
+  enableval=$enable_deprecated; case "$enableval" in
+    *)
+      with_deprecated="no"
+      CPPFLAGS="$CPPFLAGS -DLIBSSH2_NO_DEPRECATED"
+      ;;
+  esac
+else case e in #(
+  e) with_deprecated="yes" ;;
+esac
+fi
 
+
+# Run Docker tests?
+# Check whether --enable-docker-tests was given.
+if test ${enable_docker_tests+y}
+then :
+  enableval=$enable_docker_tests; run_docker_tests=no
+else case e in #(
+  e) run_docker_tests=yes ;;
+esac
+fi
+
+ if test "x$run_docker_tests" != "xno"; then
+  RUN_DOCKER_TESTS_TRUE=
+  RUN_DOCKER_TESTS_FALSE='#'
+else
+  RUN_DOCKER_TESTS_TRUE='#'
+  RUN_DOCKER_TESTS_FALSE=
+fi
+
+
+# Run sshd tests?
+# Check whether --enable-sshd-tests was given.
+if test ${enable_sshd_tests+y}
+then :
+  enableval=$enable_sshd_tests; run_sshd_tests=no
+else case e in #(
+  e) run_sshd_tests=yes ;;
+esac
+fi
+
+ if test "x$run_sshd_tests" != "xno"; then
+  RUN_SSHD_TESTS_TRUE=
+  RUN_SSHD_TESTS_FALSE='#'
+else
+  RUN_SSHD_TESTS_TRUE='#'
+  RUN_SSHD_TESTS_FALSE=
 fi
 
 
@@ -23195,8 +25774,9 @@ then :
     build_examples='yes'
     ;;
 esac
-else $as_nop
-  build_examples='yes'
+else case e in #(
+  e) build_examples='yes' ;;
+esac
 fi
 
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $build_examples" >&5
@@ -23216,8 +25796,9 @@ fi
 if test ${enable_ossfuzzers+y}
 then :
   enableval=$enable_ossfuzzers; have_ossfuzzers=yes
-else $as_nop
-  have_ossfuzzers=no
+else case e in #(
+  e) have_ossfuzzers=no ;;
+esac
 fi
 
  if test "x$have_ossfuzzers" = "xyes"; then
@@ -23251,7 +25832,6 @@ fi
 
 
 # Checks for header files.
-# AC_HEADER_STDC
 ac_fn_c_check_header_compile "$LINENO" "errno.h" "ac_cv_header_errno_h" "$ac_includes_default"
 if test "x$ac_cv_header_errno_h" = xyes
 then :
@@ -23269,12 +25849,6 @@ if test "x$ac_cv_header_stdio_h" = xyes
 then :
   printf "%s\n" "#define HAVE_STDIO_H 1" >>confdefs.h
 
-fi
-ac_fn_c_check_header_compile "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
-if test "x$ac_cv_header_stdlib_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_STDLIB_H 1" >>confdefs.h
-
 fi
 ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$ac_includes_default"
 if test "x$ac_cv_header_unistd_h" = xyes
@@ -23327,53 +25901,13 @@ then :
 
 fi
 
-       for ac_header in sys/un.h
-do :
-  ac_fn_c_check_header_compile "$LINENO" "sys/un.h" "ac_cv_header_sys_un_h" "$ac_includes_default"
+ac_fn_c_check_header_compile "$LINENO" "sys/un.h" "ac_cv_header_sys_un_h" "$ac_includes_default"
 if test "x$ac_cv_header_sys_un_h" = xyes
 then :
   printf "%s\n" "#define HAVE_SYS_UN_H 1" >>confdefs.h
- have_sys_un_h=yes
-else $as_nop
-  have_sys_un_h=no
-fi
-
-done
- if test "x$have_sys_un_h" = xyes; then
-  HAVE_SYS_UN_H_TRUE=
-  HAVE_SYS_UN_H_FALSE='#'
-else
-  HAVE_SYS_UN_H_TRUE='#'
-  HAVE_SYS_UN_H_FALSE=
-fi
-
-
-case $host in
-  *-*-cygwin* | *-*-cegcc*)
-    # These are POSIX-like systems using BSD-like sockets API.
-    ;;
-  *)
-    ac_fn_c_check_header_compile "$LINENO" "windows.h" "ac_cv_header_windows_h" "$ac_includes_default"
-if test "x$ac_cv_header_windows_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
-if test "x$ac_cv_header_winsock2_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WINSOCK2_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "ws2tcpip.h" "ac_cv_header_ws2tcpip_h" "$ac_includes_default"
-if test "x$ac_cv_header_ws2tcpip_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WS2TCPIP_H 1" >>confdefs.h
 
 fi
 
-    ;;
-esac
 
 case $host in
   *darwin*|*interix*)
@@ -23408,6 +25942,18 @@ if test "x$ac_cv_func_strtoll" = xyes
 then :
   printf "%s\n" "#define HAVE_STRTOLL 1" >>confdefs.h
 
+fi
+ac_fn_c_check_func "$LINENO" "explicit_bzero" "ac_cv_func_explicit_bzero"
+if test "x$ac_cv_func_explicit_bzero" = xyes
+then :
+  printf "%s\n" "#define HAVE_EXPLICIT_BZERO 1" >>confdefs.h
+
+fi
+ac_fn_c_check_func "$LINENO" "explicit_memset" "ac_cv_func_explicit_memset"
+if test "x$ac_cv_func_explicit_memset" = xyes
+then :
+  printf "%s\n" "#define HAVE_EXPLICIT_MEMSET 1" >>confdefs.h
+
 fi
 ac_fn_c_check_func "$LINENO" "memset_s" "ac_cv_func_memset_s"
 if test "x$ac_cv_func_memset_s" = xyes
@@ -23415,6 +25961,12 @@ then :
   printf "%s\n" "#define HAVE_MEMSET_S 1" >>confdefs.h
 
 fi
+ac_fn_c_check_func "$LINENO" "snprintf" "ac_cv_func_snprintf"
+if test "x$ac_cv_func_snprintf" = xyes
+then :
+  printf "%s\n" "#define HAVE_SNPRINTF 1" >>confdefs.h
+
+fi
 
 
 if test "$ac_cv_func_select" != "yes"; then
@@ -23423,7 +25975,7 @@ printf %s "checking for select in ws2_32... " >&6; }
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-#ifdef HAVE_WINSOCK2_H
+#ifdef HAVE_WINDOWS_H
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
@@ -23450,11 +26002,12 @@ printf "%s\n" "yes" >&6; }
 printf "%s\n" "#define HAVE_SELECT 1" >>confdefs.h
 
 
-else $as_nop
-
+else case e in #(
+  e)
       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
 printf "%s\n" "no" >&6; }
-
+   ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
@@ -23464,10 +26017,11 @@ ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
 if test "x$ac_cv_type_size_t" = xyes
 then :
 
-else $as_nop
-
+else case e in #(
+  e)
 printf "%s\n" "#define size_t unsigned int" >>confdefs.h
-
+ ;;
+esac
 fi
 
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
@@ -23477,8 +26031,8 @@ printf %s "checking for working alloca.h... " >&6; }
 if test ${ac_cv_working_alloca_h+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <alloca.h>
 int
@@ -23493,11 +26047,13 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_working_alloca_h=yes
-else $as_nop
-  ac_cv_working_alloca_h=no
+else case e in #(
+  e) ac_cv_working_alloca_h=no ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
+    conftest$ac_exeext conftest.$ac_ext ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5
 printf "%s\n" "$ac_cv_working_alloca_h" >&6; }
@@ -23512,10 +26068,10 @@ printf %s "checking for alloca... " >&6; }
 if test ${ac_cv_func_alloca_works+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test $ac_cv_working_alloca_h = yes; then
-  ac_cv_func_alloca_works=yes
-else
+else case e in #(
+  e) ac_cv_func_alloca_works=$ac_cv_working_alloca_h
+if test "$ac_cv_func_alloca_works" != yes
+then :
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <stdlib.h>
@@ -23546,15 +26102,14 @@ _ACEOF
 if ac_fn_c_try_link "$LINENO"
 then :
   ac_cv_func_alloca_works=yes
-else $as_nop
-  ac_cv_func_alloca_works=no
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
+fi ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5
 printf "%s\n" "$ac_cv_func_alloca_works" >&6; }
-fi
 
 if test $ac_cv_func_alloca_works = yes; then
 
@@ -23576,12 +26131,12 @@ printf %s "checking stack direction for C alloca... " >&6; }
 if test ${ac_cv_c_stack_direction+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  if test "$cross_compiling" = yes
+else case e in #(
+  e) if test "$cross_compiling" = yes
 then :
   ac_cv_c_stack_direction=0
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 $ac_includes_default
 int
@@ -23604,13 +26159,16 @@ _ACEOF
 if ac_fn_c_try_run "$LINENO"
 then :
   ac_cv_c_stack_direction=1
-else $as_nop
-  ac_cv_c_stack_direction=-1
+else case e in #(
+  e) ac_cv_c_stack_direction=-1 ;;
+esac
 fi
 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
-  conftest.$ac_objext conftest.beam conftest.$ac_ext
+  conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5
 printf "%s\n" "$ac_cv_c_stack_direction" >&6; }
@@ -23626,8 +26184,8 @@ printf %s "checking for an ANSI C-conforming const... " >&6; }
 if test ${ac_cv_c_const+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
 int
@@ -23691,10 +26249,12 @@ _ACEOF
 if ac_fn_c_try_compile "$LINENO"
 then :
   ac_cv_c_const=yes
-else $as_nop
-  ac_cv_c_const=no
+else case e in #(
+  e) ac_cv_c_const=no ;;
+esac
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
 printf "%s\n" "$ac_cv_c_const" >&6; }
@@ -23709,8 +26269,8 @@ printf %s "checking for inline... " >&6; }
 if test ${ac_cv_c_inline+y}
 then :
   printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_c_inline=no
+else case e in #(
+  e) ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -23728,7 +26288,8 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
   test "$ac_cv_c_inline" != no && break
 done
-
+ ;;
+esac
 fi
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
 printf "%s\n" "$ac_cv_c_inline" >&6; }
@@ -23796,8 +26357,8 @@ nonblock="O_NONBLOCK"
 printf "%s\n" "#define HAVE_O_NONBLOCK 1" >>confdefs.h
 
 
-else $as_nop
-
+else case e in #(
+  e)
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -23826,52 +26387,8 @@ nonblock="FIONBIO"
 printf "%s\n" "#define HAVE_FIONBIO 1" >>confdefs.h
 
 
-else $as_nop
-
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for ioctlsocket test (Windows) */
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#endif
-
-int
-main (void)
-{
-
-/* ioctlsocket source code */
- SOCKET sd;
- unsigned long flags = 0;
- sd = socket(0, 0, 0);
- ioctlsocket(sd, FIONBIO, &flags);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-nonblock="ioctlsocket"
-
-printf "%s\n" "#define HAVE_IOCTLSOCKET 1" >>confdefs.h
-
-
-else $as_nop
-
+else case e in #(
+  e)
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
@@ -23899,8 +26416,8 @@ nonblock="IoctlSocket"
 printf "%s\n" "#define HAVE_IOCTLSOCKET_CASE 1" >>confdefs.h
 
 
-else $as_nop
-
+else case e in #(
+  e)
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
@@ -23928,30 +26445,27 @@ nonblock="SO_NONBLOCK"
 printf "%s\n" "#define HAVE_SO_NONBLOCK 1" >>confdefs.h
 
 
-else $as_nop
-
+else case e in #(
+  e)
 nonblock="nada"
-
-printf "%s\n" "#define HAVE_DISABLED_NONBLOCKING 1" >>confdefs.h
-
-
+ ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 
-
+ ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam \
     conftest$ac_exeext conftest.$ac_ext
 
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
-
+ ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
 
-
+ ;;
+esac
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $nonblock" >&5
@@ -23978,37 +26492,55 @@ printf "%s\n" "$as_me: ERROR: ${crypto_errors}" >&6;}
 fi
 
 if test $missing_required_deps = 1; then
-  as_fn_error $? "Required dependencies are missing!" "$LINENO" 5
+  as_fn_error $? "Required dependencies are missing." "$LINENO" 5
+fi
+
+ if test "x$have_windows_h" = "xyes" && test "x${enable_shared}" = "xyes" && test -n "${RC}"; then
+  HAVE_WINDRES_TRUE=
+  HAVE_WINDRES_FALSE='#'
+else
+  HAVE_WINDRES_TRUE='#'
+  HAVE_WINDRES_FALSE=
+fi
+
+
+ if test "x$enable_static" != "xno"; then
+  HAVE_LIB_STATIC_TRUE=
+  HAVE_LIB_STATIC_FALSE='#'
+else
+  HAVE_LIB_STATIC_TRUE='#'
+  HAVE_LIB_STATIC_FALSE=
 fi
 
+
 # Configure parameters
 
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable compiler warnings as errors" >&5
-printf %s "checking whether to enable compiler warnings as errors... " >&6; }
-  OPT_COMPILER_WERROR="default"
-  # Check whether --enable-werror was given.
-if test ${enable_werror+y}
-then :
-  enableval=$enable_werror; OPT_COMPILER_WERROR=$enableval
+# Append crypto lib
+if   test "$found_crypto" = "openssl"; then
+  LIBS="${LIBS} ${LTLIBSSL}"
+elif test "$found_crypto" = "wolfssl"; then
+  LIBS="${LIBS} ${LTLIBWOLFSSL}"
+elif test "$found_crypto" = "libgcrypt"; then
+  LIBS="${LIBS} ${LTLIBGCRYPT}"
+elif test "$found_crypto" = "wincng"; then
+  LIBS="${LIBS} ${LTLIBBCRYPT}"
+elif test "$found_crypto" = "mbedtls"; then
+  LIBS="${LIBS} ${LTLIBMBEDCRYPTO}"
 fi
 
-  case "$OPT_COMPILER_WERROR" in
-    no)
-            want_werror="no"
-      ;;
-    default)
-            want_werror="no"
-      ;;
-    *)
-            want_werror="yes"
-      ;;
-  esac
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_werror" >&5
-printf "%s\n" "$want_werror" >&6; }
+LIBS="${LIBS} ${LTLIBZ}"
+
+LIBSSH2_PC_LIBS_PRIVATE=$LIBS
+
+
+if test "x$enable_shared" = "xyes"; then
+  LIBSSH2_PC_REQUIRES=
+  LIBSSH2_PC_LIBS=
+else
+  LIBSSH2_PC_REQUIRES=$LIBSSH2_PC_REQUIRES_PRIVATE
+  LIBSSH2_PC_LIBS=$LIBSSH2_PC_LIBS_PRIVATE
+fi
 
-  if test X"$want_werror" = Xyes; then
-    CFLAGS="$CFLAGS -Werror"
-  fi
 
 
 ac_config_files="$ac_config_files Makefile src/Makefile tests/Makefile tests/ossfuzz/Makefile example/Makefile docs/Makefile libssh2.pc"
@@ -24023,8 +26555,8 @@ cat >confcache <<\_ACEOF
 # config.status only pays attention to the cache file if you give it
 # the --recheck option to rerun configure.
 #
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# 'ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* 'ac_cv_foo' will be assigned the
 # following values.
 
 _ACEOF
@@ -24054,14 +26586,14 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;}
   (set) 2>&1 |
     case $as_nl`(ac_space=' '; set) 2>&1` in #(
     *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
+      # 'set' does not quote correctly, so add quotes: double-quote
       # substitution turns \\\\ into \\, and sed turns \\ into \.
       sed -n \
 	"s/'/'\\\\''/g;
 	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
       ;; #(
     *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      # 'set' quotes correctly as required by POSIX, so do not add quotes.
       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
       ;;
     esac |
@@ -24163,20 +26695,18 @@ if test -z "${SSHD_TRUE}" && test -z "${SSHD_FALSE}"; then
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
 
-if test -z "${OPENSSL_TRUE}" && test -z "${OPENSSL_FALSE}"; then
-  as_fn_error $? "conditional \"OPENSSL\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${LIBGCRYPT_TRUE}" && test -z "${LIBGCRYPT_FALSE}"; then
-  as_fn_error $? "conditional \"LIBGCRYPT\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
+# Check whether --enable-year2038 was given.
+if test ${enable_year2038+y}
+then :
+  enableval=$enable_year2038;
 fi
-if test -z "${MBEDTLS_TRUE}" && test -z "${MBEDTLS_FALSE}"; then
-  as_fn_error $? "conditional \"MBEDTLS\" was never defined.
+
+if test -z "${RUN_DOCKER_TESTS_TRUE}" && test -z "${RUN_DOCKER_TESTS_FALSE}"; then
+  as_fn_error $? "conditional \"RUN_DOCKER_TESTS\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
-if test -z "${WINCNG_TRUE}" && test -z "${WINCNG_FALSE}"; then
-  as_fn_error $? "conditional \"WINCNG\" was never defined.
+if test -z "${RUN_SSHD_TESTS_TRUE}" && test -z "${RUN_SSHD_TESTS_FALSE}"; then
+  as_fn_error $? "conditional \"RUN_SSHD_TESTS\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
 if test -z "${BUILD_EXAMPLES_TRUE}" && test -z "${BUILD_EXAMPLES_FALSE}"; then
@@ -24195,8 +26725,12 @@ if test -z "${USE_OSSFUZZ_STATIC_TRUE}" && test -z "${USE_OSSFUZZ_STATIC_FALSE}"
   as_fn_error $? "conditional \"USE_OSSFUZZ_STATIC\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
-if test -z "${HAVE_SYS_UN_H_TRUE}" && test -z "${HAVE_SYS_UN_H_FALSE}"; then
-  as_fn_error $? "conditional \"HAVE_SYS_UN_H\" was never defined.
+if test -z "${HAVE_WINDRES_TRUE}" && test -z "${HAVE_WINDRES_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_WINDRES\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_LIB_STATIC_TRUE}" && test -z "${HAVE_LIB_STATIC_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_LIB_STATIC\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
 
@@ -24228,7 +26762,6 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
 
 # Be more Bourne compatible
 DUALCASE=1; export DUALCASE # for MKS sh
-as_nop=:
 if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
 then :
   emulate sh
@@ -24237,12 +26770,13 @@ then :
   # is contrary to our usage.  Disable this feature.
   alias -g '${1+"$@"}'='"$@"'
   setopt NO_GLOB_SUBST
-else $as_nop
-  case `(set -o) 2>/dev/null` in #(
+else case e in #(
+  e) case `(set -o) 2>/dev/null` in #(
   *posix*) :
     set -o posix ;; #(
   *) :
      ;;
+esac ;;
 esac
 fi
 
@@ -24314,7 +26848,7 @@ IFS=$as_save_IFS
 
      ;;
 esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
+# We did not find ourselves, most probably we were run as 'sh COMMAND'
 # in which case we are not to be found in the path.
 if test "x$as_myself" = x; then
   as_myself=$0
@@ -24343,7 +26877,6 @@ as_fn_error ()
 } # as_fn_error
 
 
-
 # as_fn_set_status STATUS
 # -----------------------
 # Set $? to STATUS, without forking.
@@ -24383,11 +26916,12 @@ then :
   {
     eval $1+=\$2
   }'
-else $as_nop
-  as_fn_append ()
+else case e in #(
+  e) as_fn_append ()
   {
     eval $1=\$$1\$2
-  }
+  } ;;
+esac
 fi # as_fn_append
 
 # as_fn_arith ARG...
@@ -24401,11 +26935,12 @@ then :
   {
     as_val=$(( $* ))
   }'
-else $as_nop
-  as_fn_arith ()
+else case e in #(
+  e) as_fn_arith ()
   {
     as_val=`expr "$@" || test $? -eq 1`
-  }
+  } ;;
+esac
 fi # as_fn_arith
 
 
@@ -24488,9 +27023,9 @@ if (echo >conf$$.file) 2>/dev/null; then
   if ln -s conf$$.file conf$$ 2>/dev/null; then
     as_ln_s='ln -s'
     # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
+    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
+    # In both cases, we have to default to 'cp -pR'.
     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
       as_ln_s='cp -pR'
   elif ln conf$$.file conf$$ 2>/dev/null; then
@@ -24571,10 +27106,12 @@ as_test_x='test -x'
 as_executable_p=as_fn_executable_p
 
 # Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
+as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
 
 # Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
+as_tr_sh="eval sed '$as_sed_sh'" # deprecated
 
 
 exec 6>&1
@@ -24590,7 +27127,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # values after options handling.
 ac_log="
 This file was extended by libssh2 $as_me -, which was
-generated by GNU Autoconf 2.71.  Invocation command line was
+generated by GNU Autoconf 2.72.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
   CONFIG_HEADERS  = $CONFIG_HEADERS
@@ -24622,7 +27159,7 @@ _ACEOF
 
 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
+'$as_me' instantiates files and other configuration actions
 from templates according to the current configuration.  Unless the files
 and actions are specified as TAGs, all are instantiated by default.
 
@@ -24649,7 +27186,7 @@ $config_headers
 Configuration commands:
 $config_commands
 
-Report bugs to <libssh2-devel@cool.haxx.se>."
+Report bugs to <libssh2-devel@lists.haxx.se>."
 
 _ACEOF
 ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
@@ -24658,10 +27195,10 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config='$ac_cs_config_escaped'
 ac_cs_version="\\
 libssh2 config.status -
-configured by $0, generated by GNU Autoconf 2.71,
+configured by $0, generated by GNU Autoconf 2.72,
   with options \\"\$ac_cs_config\\"
 
-Copyright (C) 2021 Free Software Foundation, Inc.
+Copyright (C) 2023 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it."
 
@@ -24723,8 +27260,8 @@ do
     ac_need_defaults=false;;
   --he | --h)
     # Conflict between --help and --header
-    as_fn_error $? "ambiguous option: \`$1'
-Try \`$0 --help' for more information.";;
+    as_fn_error $? "ambiguous option: '$1'
+Try '$0 --help' for more information.";;
   --help | --hel | -h )
     printf "%s\n" "$ac_cs_usage"; exit ;;
   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
@@ -24732,8 +27269,8 @@ Try \`$0 --help' for more information.";;
     ac_cs_silent=: ;;
 
   # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
+  -*) as_fn_error $? "unrecognized option: '$1'
+Try '$0 --help' for more information." ;;
 
   *) as_fn_append ac_config_targets " $1"
      ac_need_defaults=false ;;
@@ -24786,11 +27323,11 @@ AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
 sed_quote_subst='$sed_quote_subst'
 double_quote_subst='$double_quote_subst'
 delay_variable_subst='$delay_variable_subst'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
 AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`'
 DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
 OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
-macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
-macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
 enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
 enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
 pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
@@ -24823,12 +27360,14 @@ lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_q
 lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
 reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
 reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+FILECMD='`$ECHO "$FILECMD" | $SED "$delay_single_quote_subst"`'
 deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
 file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
 file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
 want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
 sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
 AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+lt_ar_flags='`$ECHO "$lt_ar_flags" | $SED "$delay_single_quote_subst"`'
 AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
 archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
 STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
@@ -24929,53 +27468,101 @@ predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
 postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
 compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
 LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
+LD_RC='`$ECHO "$LD_RC" | $SED "$delay_single_quote_subst"`'
 reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
+reload_flag_RC='`$ECHO "$reload_flag_RC" | $SED "$delay_single_quote_subst"`'
 reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+reload_cmds_RC='`$ECHO "$reload_cmds_RC" | $SED "$delay_single_quote_subst"`'
 old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds_RC='`$ECHO "$old_archive_cmds_RC" | $SED "$delay_single_quote_subst"`'
 compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_RC='`$ECHO "$compiler_RC" | $SED "$delay_single_quote_subst"`'
 GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
+GCC_RC='`$ECHO "$GCC_RC" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag_RC='`$ECHO "$lt_prog_compiler_no_builtin_flag_RC" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic_RC='`$ECHO "$lt_prog_compiler_pic_RC" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl_RC='`$ECHO "$lt_prog_compiler_wl_RC" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static_RC='`$ECHO "$lt_prog_compiler_static_RC" | $SED "$delay_single_quote_subst"`'
 lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o_RC='`$ECHO "$lt_cv_prog_compiler_c_o_RC" | $SED "$delay_single_quote_subst"`'
 archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc_RC='`$ECHO "$archive_cmds_need_lc_RC" | $SED "$delay_single_quote_subst"`'
 enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes_RC='`$ECHO "$enable_shared_with_static_runtimes_RC" | $SED "$delay_single_quote_subst"`'
 export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec_RC='`$ECHO "$export_dynamic_flag_spec_RC" | $SED "$delay_single_quote_subst"`'
 whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec_RC='`$ECHO "$whole_archive_flag_spec_RC" | $SED "$delay_single_quote_subst"`'
 compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object_RC='`$ECHO "$compiler_needs_object_RC" | $SED "$delay_single_quote_subst"`'
 old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds_RC='`$ECHO "$old_archive_from_new_cmds_RC" | $SED "$delay_single_quote_subst"`'
 old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds_RC='`$ECHO "$old_archive_from_expsyms_cmds_RC" | $SED "$delay_single_quote_subst"`'
 archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_RC='`$ECHO "$archive_cmds_RC" | $SED "$delay_single_quote_subst"`'
 archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds_RC='`$ECHO "$archive_expsym_cmds_RC" | $SED "$delay_single_quote_subst"`'
 module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_cmds_RC='`$ECHO "$module_cmds_RC" | $SED "$delay_single_quote_subst"`'
 module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds_RC='`$ECHO "$module_expsym_cmds_RC" | $SED "$delay_single_quote_subst"`'
 with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld_RC='`$ECHO "$with_gnu_ld_RC" | $SED "$delay_single_quote_subst"`'
 allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag_RC='`$ECHO "$allow_undefined_flag_RC" | $SED "$delay_single_quote_subst"`'
 no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag_RC='`$ECHO "$no_undefined_flag_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec_RC='`$ECHO "$hardcode_libdir_flag_spec_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator_RC='`$ECHO "$hardcode_libdir_separator_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_RC='`$ECHO "$hardcode_direct_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute_RC='`$ECHO "$hardcode_direct_absolute_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L_RC='`$ECHO "$hardcode_minus_L_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var_RC='`$ECHO "$hardcode_shlibpath_var_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic_RC='`$ECHO "$hardcode_automatic_RC" | $SED "$delay_single_quote_subst"`'
 inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
+inherit_rpath_RC='`$ECHO "$inherit_rpath_RC" | $SED "$delay_single_quote_subst"`'
 link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs_RC='`$ECHO "$link_all_deplibs_RC" | $SED "$delay_single_quote_subst"`'
 always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
+always_export_symbols_RC='`$ECHO "$always_export_symbols_RC" | $SED "$delay_single_quote_subst"`'
 export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds_RC='`$ECHO "$export_symbols_cmds_RC" | $SED "$delay_single_quote_subst"`'
 exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms_RC='`$ECHO "$exclude_expsyms_RC" | $SED "$delay_single_quote_subst"`'
 include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+include_expsyms_RC='`$ECHO "$include_expsyms_RC" | $SED "$delay_single_quote_subst"`'
 prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+prelink_cmds_RC='`$ECHO "$prelink_cmds_RC" | $SED "$delay_single_quote_subst"`'
 postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+postlink_cmds_RC='`$ECHO "$postlink_cmds_RC" | $SED "$delay_single_quote_subst"`'
 file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
+file_list_spec_RC='`$ECHO "$file_list_spec_RC" | $SED "$delay_single_quote_subst"`'
 hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_action_RC='`$ECHO "$hardcode_action_RC" | $SED "$delay_single_quote_subst"`'
 compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs_RC='`$ECHO "$compiler_lib_search_dirs_RC" | $SED "$delay_single_quote_subst"`'
 predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+predep_objects_RC='`$ECHO "$predep_objects_RC" | $SED "$delay_single_quote_subst"`'
 postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+postdep_objects_RC='`$ECHO "$postdep_objects_RC" | $SED "$delay_single_quote_subst"`'
 predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
+predeps_RC='`$ECHO "$predeps_RC" | $SED "$delay_single_quote_subst"`'
 postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
+postdeps_RC='`$ECHO "$postdeps_RC" | $SED "$delay_single_quote_subst"`'
 compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path_RC='`$ECHO "$compiler_lib_search_path_RC" | $SED "$delay_single_quote_subst"`'
 
 LTCC='$LTCC'
 LTCFLAGS='$LTCFLAGS'
@@ -25006,13 +27593,13 @@ LN_S \
 lt_SP2NL \
 lt_NL2SP \
 reload_flag \
+FILECMD \
 deplibs_check_method \
 file_magic_cmd \
 file_magic_glob \
 want_nocaseglob \
 sharedlib_from_linklib_cmd \
 AR \
-AR_FLAGS \
 archiver_list_spec \
 STRIP \
 RANLIB \
@@ -25066,30 +27653,55 @@ predeps \
 postdeps \
 compiler_lib_search_path \
 LD_CXX \
+LD_RC \
 reload_flag_CXX \
+reload_flag_RC \
 compiler_CXX \
+compiler_RC \
 lt_prog_compiler_no_builtin_flag_CXX \
+lt_prog_compiler_no_builtin_flag_RC \
 lt_prog_compiler_pic_CXX \
+lt_prog_compiler_pic_RC \
 lt_prog_compiler_wl_CXX \
+lt_prog_compiler_wl_RC \
 lt_prog_compiler_static_CXX \
+lt_prog_compiler_static_RC \
 lt_cv_prog_compiler_c_o_CXX \
+lt_cv_prog_compiler_c_o_RC \
 export_dynamic_flag_spec_CXX \
+export_dynamic_flag_spec_RC \
 whole_archive_flag_spec_CXX \
+whole_archive_flag_spec_RC \
 compiler_needs_object_CXX \
+compiler_needs_object_RC \
 with_gnu_ld_CXX \
+with_gnu_ld_RC \
 allow_undefined_flag_CXX \
+allow_undefined_flag_RC \
 no_undefined_flag_CXX \
+no_undefined_flag_RC \
 hardcode_libdir_flag_spec_CXX \
+hardcode_libdir_flag_spec_RC \
 hardcode_libdir_separator_CXX \
+hardcode_libdir_separator_RC \
 exclude_expsyms_CXX \
+exclude_expsyms_RC \
 include_expsyms_CXX \
+include_expsyms_RC \
 file_list_spec_CXX \
+file_list_spec_RC \
 compiler_lib_search_dirs_CXX \
+compiler_lib_search_dirs_RC \
 predep_objects_CXX \
+predep_objects_RC \
 postdep_objects_CXX \
+postdep_objects_RC \
 predeps_CXX \
+predeps_RC \
 postdeps_CXX \
-compiler_lib_search_path_CXX; do
+postdeps_RC \
+compiler_lib_search_path_CXX \
+compiler_lib_search_path_RC; do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[\\\\\\\`\\"\\\$]*)
       eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
@@ -25122,16 +27734,27 @@ sys_lib_search_path_spec \
 configure_time_dlsearch_path \
 configure_time_lt_sys_library_path \
 reload_cmds_CXX \
+reload_cmds_RC \
 old_archive_cmds_CXX \
+old_archive_cmds_RC \
 old_archive_from_new_cmds_CXX \
+old_archive_from_new_cmds_RC \
 old_archive_from_expsyms_cmds_CXX \
+old_archive_from_expsyms_cmds_RC \
 archive_cmds_CXX \
+archive_cmds_RC \
 archive_expsym_cmds_CXX \
+archive_expsym_cmds_RC \
 module_cmds_CXX \
+module_cmds_RC \
 module_expsym_cmds_CXX \
+module_expsym_cmds_RC \
 export_symbols_cmds_CXX \
+export_symbols_cmds_RC \
 prelink_cmds_CXX \
-postlink_cmds_CXX; do
+prelink_cmds_RC \
+postlink_cmds_CXX \
+postlink_cmds_RC; do
     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
     *[\\\\\\\`\\"\\\$]*)
       eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
@@ -25161,6 +27784,8 @@ fi
 
 
 
+
+
 _ACEOF
 
 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
@@ -25180,7 +27805,7 @@ do
     "docs/Makefile") CONFIG_FILES="$CONFIG_FILES docs/Makefile" ;;
     "libssh2.pc") CONFIG_FILES="$CONFIG_FILES libssh2.pc" ;;
 
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  *) as_fn_error $? "invalid argument: '$ac_config_target'" "$LINENO" 5;;
   esac
 done
 
@@ -25200,7 +27825,7 @@ fi
 # creating and moving files from /tmp can sometimes cause problems.
 # Hook for its removal unless debugging.
 # Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
+# after its creation but before its name has been assigned to '$tmp'.
 $debug ||
 {
   tmp= ac_tmp=
@@ -25224,7 +27849,7 @@ ac_tmp=$tmp
 
 # Set up the scripts for CONFIG_FILES section.
 # No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
+# This happens for instance with './config.status config.h'.
 if test -n "$CONFIG_FILES"; then
 
 
@@ -25382,13 +28007,13 @@ fi # test -n "$CONFIG_FILES"
 
 # Set up the scripts for CONFIG_HEADERS section.
 # No need to generate them if there are no CONFIG_HEADERS.
-# This happens for instance with `./config.status Makefile'.
+# This happens for instance with './config.status Makefile'.
 if test -n "$CONFIG_HEADERS"; then
 cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
 BEGIN {
 _ACEOF
 
-# Transform confdefs.h into an awk script `defines.awk', embedded as
+# Transform confdefs.h into an awk script 'defines.awk', embedded as
 # here-document in config.status, that substitutes the proper values into
 # config.h.in to produce config.h.
 
@@ -25498,7 +28123,7 @@ do
   esac
   case $ac_mode$ac_tag in
   :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :L* | :C*:*) as_fn_error $? "invalid tag '$ac_tag'" "$LINENO" 5;;
   :[FH]-) ac_tag=-:-;;
   :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
   esac
@@ -25520,19 +28145,19 @@ do
       -) ac_f="$ac_tmp/stdin";;
       *) # Look for the file first in the build tree, then in the source tree
 	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
+	 # because $ac_f cannot contain ':'.
 	 test -f "$ac_f" ||
 	   case $ac_f in
 	   [\\/$]*) false;;
 	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
 	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+	   as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;;
       esac
       case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
       as_fn_append ac_file_inputs " '$ac_f'"
     done
 
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # Let's still pretend it is 'configure' which instantiates (i.e., don't
     # use $as_me), people would be surprised to read:
     #    /* config.h.  Generated by config.status.  */
     configure_input='Generated from '`
@@ -25665,7 +28290,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 esac
 _ACEOF
 
-# Neutralize VPATH when `$srcdir' = `.'.
+# Neutralize VPATH when '$srcdir' = '.'.
 # Shell code in configure.ac might set extrasub.
 # FIXME: do we really want to maintain this feature?
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
@@ -25696,9 +28321,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
   { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
   { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
       "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir'
 which seems to be undefined.  Please make sure it is defined" >&5
-printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir'
 which seems to be undefined.  Please make sure it is defined" >&2;}
 
   rm -f "$ac_tmp/stdin"
@@ -25853,15 +28478,15 @@ printf "%s\n" X/"$am_mf" |
    (exit $ac_status); } || am_rc=$?
   done
   if test $am_rc -ne 0; then
-    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
 as_fn_error $? "Something went wrong bootstrapping makefile fragments
     for automatic dependency tracking.  If GNU make was not used, consider
     re-running the configure script with MAKE=\"gmake\" (or whatever is
     necessary).  You can also try re-running configure with the
     '--disable-dependency-tracking' option to at least be able to build
     the package (albeit without support for automatic dependency tracking).
-See \`config.log' for more details" "$LINENO" 5; }
+See 'config.log' for more details" "$LINENO" 5; }
   fi
   { am_dirpart=; unset am_dirpart;}
   { am_filepart=; unset am_filepart;}
@@ -25914,13 +28539,17 @@ See \`config.log' for more details" "$LINENO" 5; }
 
 
 # The names of the tagged configurations supported by this script.
-available_tags='CXX '
+available_tags='CXX RC '
 
 # Configured defaults for sys_lib_dlsearch_path munging.
 : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
 
 # ### BEGIN LIBTOOL CONFIG
 
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
 # Assembler program.
 AS=$lt_AS
 
@@ -25930,10 +28559,6 @@ DLLTOOL=$lt_DLLTOOL
 # Object dumper program.
 OBJDUMP=$lt_OBJDUMP
 
-# Which release of libtool.m4 was used?
-macro_version=$macro_version
-macro_revision=$macro_revision
-
 # Whether or not to build shared libraries.
 build_libtool_libs=$enable_shared
 
@@ -26013,6 +28638,9 @@ to_host_file_cmd=$lt_cv_to_host_file_cmd
 # convert \$build files to toolchain format.
 to_tool_file_cmd=$lt_cv_to_tool_file_cmd
 
+# A file(cmd) program that detects file types.
+FILECMD=$lt_FILECMD
+
 # Method to check whether dependent libraries are shared objects.
 deplibs_check_method=$lt_deplibs_check_method
 
@@ -26031,8 +28659,11 @@ sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
 # The archiver.
 AR=$lt_AR
 
+# Flags to create an archive (by configure).
+lt_ar_flags=$lt_ar_flags
+
 # Flags to create an archive.
-AR_FLAGS=$lt_AR_FLAGS
+AR_FLAGS=\${ARFLAGS-"\$lt_ar_flags"}
 
 # How to feed a file listing to the archiver.
 archiver_list_spec=$lt_archiver_list_spec
@@ -26422,7 +29053,7 @@ ltmain=$ac_aux_dir/ltmain.sh
   # if finds mixed CR/LF and LF-only lines.  Since sed operates in
   # text mode, it properly converts lines to CR/LF.  This bash problem
   # is reportedly fixed, but why not run on old versions too?
-  sed '$q' "$ltmain" >> "$cfgfile" \
+  $SED '$q' "$ltmain" >> "$cfgfile" \
      || (rm -f "$cfgfile"; exit 1)
 
    mv -f "$cfgfile" "$ofile" ||
@@ -26582,6 +29213,159 @@ compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
 # ### END LIBTOOL TAG CONFIG: CXX
 _LT_EOF
 
+
+    cat <<_LT_EOF >> "$ofile"
+
+# ### BEGIN LIBTOOL TAG CONFIG: RC
+
+# The linker used to build libraries.
+LD=$lt_LD_RC
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag_RC
+reload_cmds=$lt_reload_cmds_RC
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds_RC
+
+# A language specific compiler.
+CC=$lt_compiler_RC
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC_RC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_RC
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_RC
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_RC
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_RC
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_RC
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_RC
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_RC
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_RC
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_RC
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object_RC
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_RC
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_RC
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds_RC
+archive_expsym_cmds=$lt_archive_expsym_cmds_RC
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds_RC
+module_expsym_cmds=$lt_module_expsym_cmds_RC
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld_RC
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_RC
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_RC
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_RC
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_RC
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct_RC
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute_RC
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L_RC
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_RC
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic_RC
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath_RC
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_RC
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols_RC
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_RC
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_RC
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_RC
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds_RC
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds_RC
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec_RC
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_RC
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_RC
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects_RC
+postdep_objects=$lt_postdep_objects_RC
+predeps=$lt_predeps_RC
+postdeps=$lt_postdeps_RC
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_RC
+
+# ### END LIBTOOL TAG CONFIG: RC
+_LT_EOF
+
  ;;
 
   esac
@@ -26624,32 +29408,40 @@ fi
 
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: summary of build options:
 
-  version:          ${LIBSSH2VER}
+  version:          ${LIBSSH2_VERSION}
   Host type:        ${host}
   Install prefix:   ${prefix}
   Compiler:         ${CC}
   Compiler flags:   ${CFLAGS}
   Library types:    Shared=${enable_shared}, Static=${enable_static}
   Crypto library:   ${found_crypto_str}
+  WinCNG ECDSA:     $wincng_ecdsa
+  zlib compression: ${found_libz}
   Clear memory:     $enable_clear_memory
+  Deprecated APIs:  $with_deprecated
   Debug build:      $enable_debug
   Build examples:   $build_examples
+  Run Docker tests: $run_docker_tests
+  Run sshd tests:   $run_sshd_tests
   Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
 " >&5
 printf "%s\n" "$as_me: summary of build options:
 
-  version:          ${LIBSSH2VER}
+  version:          ${LIBSSH2_VERSION}
   Host type:        ${host}
   Install prefix:   ${prefix}
   Compiler:         ${CC}
   Compiler flags:   ${CFLAGS}
   Library types:    Shared=${enable_shared}, Static=${enable_static}
   Crypto library:   ${found_crypto_str}
+  WinCNG ECDSA:     $wincng_ecdsa
+  zlib compression: ${found_libz}
   Clear memory:     $enable_clear_memory
+  Deprecated APIs:  $with_deprecated
   Debug build:      $enable_debug
   Build examples:   $build_examples
+  Run Docker tests: $run_docker_tests
+  Run sshd tests:   $run_sshd_tests
   Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
 " >&6;}
 
diff --git a/libssh2/configure.ac b/libssh2/configure.ac
index c4fc3e4e..21ae4413 100644
--- a/libssh2/configure.ac
+++ b/libssh2/configure.ac
@@ -1,8 +1,14 @@
-# AC_PREREQ(2.57)
-AC_INIT(libssh2, [-], libssh2-devel@cool.haxx.se)
+# Copyright (C) The libssh2 project and its contributors.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+# AC_PREREQ(2.59)
+AC_INIT([libssh2],[-],[libssh2-devel@lists.haxx.se])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([src])
 AC_CONFIG_HEADERS([src/libssh2_config.h])
+AC_REQUIRE_AUX_FILE([tap-driver.sh])
 AM_MAINTAINER_MODE
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
@@ -16,16 +22,12 @@ if test "x$SED" = "xsed-was-not-found-by-configure"; then
 fi
 
 dnl figure out the libssh2 version
-LIBSSH2VER=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
+LIBSSH2_VERSION=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
 AM_INIT_AUTOMAKE
 AC_MSG_CHECKING([libssh2 version])
-AC_MSG_RESULT($LIBSSH2VER)
-
-AC_SUBST(LIBSSH2VER)
+AC_MSG_RESULT($LIBSSH2_VERSION)
 
-AB_VERSION=$LIBSSH2VER
-
-AB_INIT
+AC_SUBST(LIBSSH2_VERSION)
 
 # Check for the OS.
 # Daniel's note: this should not be necessary and we need to work to
@@ -33,11 +35,9 @@ AB_INIT
 AC_CANONICAL_HOST
 case "$host" in
     *-mingw*)
-    CFLAGS="$CFLAGS -DLIBSSH2_WIN32"
     LIBS="$LIBS -lws2_32"
     ;;
     *darwin*)
-    CFLAGS="$CFLAGS -DLIBSSH2_DARWIN"
     ;;
     *hpux*)
     ;;
@@ -48,12 +48,6 @@ case "$host" in
     ;;
 esac
 
-AC_CHECK_TYPE(long long,
-   [AC_DEFINE(HAVE_LONGLONG, 1,
-      [Define to 1 if the compiler supports the 'long long' data type.])]
-   longlong="yes"
-)
-
 dnl Our configure and build reentrant settings
 CURL_CONFIGURE_REENTRANT
 
@@ -74,10 +68,27 @@ AC_PATH_PROGS(SSHD, [sshd], [],
      [$PATH$PATH_SEPARATOR/usr/libexec$PATH_SEPARATOR]dnl
      [/usr/sbin$PATH_SEPARATOR/usr/etc$PATH_SEPARATOR/etc])
 AM_CONDITIONAL(SSHD, test -n "$SSHD")
+m4_ifdef([LT_INIT],
+[dnl
+LT_INIT([win32-dll])
+],[dnl
 AC_LIBTOOL_WIN32_DLL
 AC_PROG_LIBTOOL
+])
 AC_C_BIGENDIAN
 
+LT_LANG([Windows Resource])
+
+dnl check for windows.h
+case $host in
+  *-*-msys | *-*-cygwin* | *-*-cegcc*)
+    # These are POSIX-like systems using BSD-like sockets API.
+    ;;
+  *)
+    AC_CHECK_HEADERS([windows.h], [have_windows_h=yes], [have_windows_h=no])
+    ;;
+esac
+
 dnl check for how to do large files
 AC_SYS_LARGEFILE
 
@@ -85,16 +96,16 @@ AC_SYS_LARGEFILE
 
 found_crypto=none
 found_crypto_str=""
-support_clear_memory=no
 crypto_errors=""
 
 m4_set_add([crypto_backends], [openssl])
 m4_set_add([crypto_backends], [libgcrypt])
 m4_set_add([crypto_backends], [mbedtls])
 m4_set_add([crypto_backends], [wincng])
+m4_set_add([crypto_backends], [wolfssl])
 
 AC_ARG_WITH([crypto],
-  AC_HELP_STRING([--with-crypto=auto|]m4_set_contents([crypto_backends], [|]),
+  AS_HELP_STRING([--with-crypto=auto|]m4_set_contents([crypto_backends], [|]),
     [Select crypto backend (default: auto)]),
   use_crypto=$withval,
   use_crypto=auto
@@ -105,16 +116,16 @@ case "${use_crypto}" in
     m4_set_map([crypto_backends], [LIBSSH2_CHECK_CRYPTO])
     ;;
   yes|"")
-    crypto_errors="No crypto backend specified!"
+    crypto_errors="No crypto backend specified."
     ;;
   *)
-    crypto_errors="Unknown crypto backend '${use_crypto}' specified!"
+    crypto_errors="Unknown crypto backend '${use_crypto}' specified."
     ;;
 esac
 
 if test "$found_crypto" = "none"; then
   crypto_errors="${crypto_errors}
-Specify --with-crypto=\$backend and/or the neccessary library search prefix.
+Specify --with-crypto=\$backend and/or the necessary library search prefix.
 
 Known crypto backends: auto, m4_set_contents([crypto_backends], [, ])"
   AS_MESSAGE([ERROR: ${crypto_errors}])
@@ -122,14 +133,21 @@ else
   test "$found_crypto_str" = "" && found_crypto_str="$found_crypto"
 fi
 
-m4_set_foreach([crypto_backends], [backend],
-  [AM_CONDITIONAL(m4_toupper(backend), test "$found_crypto" = "backend")]
-)
+# ECDSA support with WinCNG
+AC_ARG_ENABLE(ecdsa-wincng,
+  AS_HELP_STRING([--enable-ecdsa-wincng],
+    WinCNG ECDSA support (requires Windows 10 or later)),
+  [wincng_ecdsa=$enableval])
+if test "$wincng_ecdsa" = yes; then
+  AC_DEFINE(LIBSSH2_ECDSA_WINCNG, 1, [Enable WinCNG ECDSA support])
+else
+  wincng_ecdsa=no
+fi
 
 # libz
 
 AC_ARG_WITH([libz],
-  AC_HELP_STRING([--with-libz],[Use libz for compression]),
+  AS_HELP_STRING([--with-libz],[Use libz for compression]),
   use_libz=$withval,
   use_libz=auto)
 
@@ -143,68 +161,43 @@ if test "$use_libz" != no; then
       AC_MSG_NOTICE([Cannot find libz, disabling compression])
       found_libz="disabled; no libz found"
     else
-      libz_errors="No libz found!
+      libz_errors="No libz found.
 Try --with-libz-prefix=PATH if you know that you have it."
       AS_MESSAGE([ERROR: $libz_errors])
     fi
   else
     AC_DEFINE(LIBSSH2_HAVE_ZLIB, 1, [Compile in zlib support])
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }zlib"
+    LIBSSH2_PC_REQUIRES_PRIVATE="$LIBSSH2_PC_REQUIRES_PRIVATE${LIBSSH2_PC_REQUIRES_PRIVATE:+,}zlib"
     found_libz="yes"
   fi
 fi
 
-AC_SUBST(LIBSREQUIRED)
+AC_SUBST(LIBSSH2_PC_REQUIRES_PRIVATE)
 
 #
 # Optional Settings
 #
-AC_ARG_ENABLE(crypt-none,
-  AC_HELP_STRING([--enable-crypt-none],[Permit "none" cipher -- NOT RECOMMENDED]),
-  [AC_DEFINE(LIBSSH2_CRYPT_NONE, 1, [Enable "none" cipher -- NOT RECOMMENDED])])
-
-AC_ARG_ENABLE(mac-none,
-  AC_HELP_STRING([--enable-mac-none],[Permit "none" MAC -- NOT RECOMMENDED]),
-  [AC_DEFINE(LIBSSH2_MAC_NONE, 1, [Enable "none" MAC -- NOT RECOMMENDED])])
-
-AC_ARG_ENABLE(gex-new,
-  AC_HELP_STRING([--disable-gex-new],[Disable "new" diffie-hellman-group-exchange-sha1 method]),
-  [GEX_NEW=$enableval])
-if test "$GEX_NEW" != "no"; then
-  AC_DEFINE(LIBSSH2_DH_GEX_NEW, 1, [Enable newer diffie-hellman-group-exchange-sha1 syntax])
-fi
-
 AC_ARG_ENABLE(clear-memory,
-  AC_HELP_STRING([--disable-clear-memory],[Disable clearing of memory before being freed]),
+  AS_HELP_STRING([--disable-clear-memory],[Disable clearing of memory before being freed]),
   [CLEAR_MEMORY=$enableval])
-if test "$CLEAR_MEMORY" != "no"; then
-  if test "$support_clear_memory" = "yes"; then
-    AC_DEFINE(LIBSSH2_CLEAR_MEMORY, 1, [Enable clearing of memory before being freed])
-    enable_clear_memory=yes
-  else
-    if test "$CLEAR_MEMORY" = "yes"; then
-      AC_MSG_ERROR([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    else
-      AC_MSG_WARN([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    fi
-    enable_clear_memory=unsupported
-  fi
+if test "$CLEAR_MEMORY" = "no"; then
+  AC_DEFINE(LIBSSH2_NO_CLEAR_MEMORY, 1, [Disable clearing of memory before being freed])
+  enable_clear_memory=no
 else
-  if test "$support_clear_memory" = "yes"; then
-    enable_clear_memory=no
-  else
-    AC_MSG_WARN([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    enable_clear_memory=unsupported
-  fi
+  enable_clear_memory=yes
 fi
 
+LIBSSH2_CFLAG_EXTRAS=""
+
+LIBSSH2_CHECK_OPTION_WERROR
+
 dnl ************************************************************
 dnl option to switch on compiler debug options
 dnl
 AC_MSG_CHECKING([whether to enable pedantic and debug compiler options])
 AC_ARG_ENABLE(debug,
-AC_HELP_STRING([--enable-debug],[Enable pedantic and debug options])
-AC_HELP_STRING([--disable-debug],[Disable debug options]),
+AS_HELP_STRING([--enable-debug],[Enable pedantic and debug options])
+AS_HELP_STRING([--disable-debug],[Disable debug options]),
 [ case "$enable_debug" in
   no)
        AC_MSG_RESULT(no)
@@ -225,6 +218,8 @@ AC_HELP_STRING([--disable-debug],[Disable debug options]),
        AC_MSG_RESULT(no)
 )
 
+AC_SUBST(LIBSSH2_CFLAG_EXTRAS)
+
 dnl ************************************************************
 dnl Enable hiding of internal symbols in library to reduce its size and
 dnl speed dynamic linking of applications.  This currently is only supported
@@ -232,8 +227,8 @@ dnl on gcc >= 4.0 and SunPro C.
 dnl
 AC_MSG_CHECKING([whether to enable hidden symbols in the library])
 AC_ARG_ENABLE(hidden-symbols,
-AC_HELP_STRING([--enable-hidden-symbols],[Hide internal symbols in library])
-AC_HELP_STRING([--disable-hidden-symbols],[Leave all symbols with default visibility in library]),
+AS_HELP_STRING([--enable-hidden-symbols],[Hide internal symbols in library])
+AS_HELP_STRING([--disable-hidden-symbols],[Leave all symbols with default visibility in library (default)]),
 [ case "$enableval" in
   no)
        AC_MSG_RESULT(no)
@@ -264,11 +259,36 @@ AC_HELP_STRING([--disable-hidden-symbols],[Leave all symbols with default visibi
        AC_MSG_RESULT(no)
 )
 
+dnl Build without deprecated APIs?
+AC_ARG_ENABLE([deprecated],
+  [AS_HELP_STRING([--disable-deprecated], [Build without deprecated APIs @<:@default=no@:>@])],
+  [case "$enableval" in
+    *)
+      with_deprecated="no"
+      CPPFLAGS="$CPPFLAGS -DLIBSSH2_NO_DEPRECATED"
+      ;;
+  esac],
+  [with_deprecated="yes"])
+
+# Run Docker tests?
+AC_ARG_ENABLE([docker-tests],
+  [AS_HELP_STRING([--disable-docker-tests],
+    [Do not run tests requiring Docker])],
+  [run_docker_tests=no], [run_docker_tests=yes])
+AM_CONDITIONAL([RUN_DOCKER_TESTS], [test "x$run_docker_tests" != "xno"])
+
+# Run sshd tests?
+AC_ARG_ENABLE([sshd-tests],
+  [AS_HELP_STRING([--disable-sshd-tests],
+    [Do not run tests requiring sshd])],
+  [run_sshd_tests=no], [run_sshd_tests=yes])
+AM_CONDITIONAL([RUN_SSHD_TESTS], [test "x$run_sshd_tests" != "xno"])
+
 # Build example applications?
 AC_MSG_CHECKING([whether to build example applications])
 AC_ARG_ENABLE([examples-build],
-AC_HELP_STRING([--enable-examples-build], [Build example applications (this is the default)])
-AC_HELP_STRING([--disable-examples-build], [Do not build example applications]),
+AS_HELP_STRING([--enable-examples-build], [Build example applications (this is the default)])
+AS_HELP_STRING([--disable-examples-build], [Do not build example applications]),
 [case "$enableval" in
   no | false)
     build_examples='no'
@@ -296,21 +316,10 @@ AM_CONDITIONAL([USE_OSSFUZZ_STATIC], [test -f "$LIB_FUZZING_ENGINE"])
 
 
 # Checks for header files.
-# AC_HEADER_STDC
-AC_CHECK_HEADERS([errno.h fcntl.h stdio.h stdlib.h unistd.h sys/uio.h])
+AC_CHECK_HEADERS([errno.h fcntl.h stdio.h unistd.h sys/uio.h])
 AC_CHECK_HEADERS([sys/select.h sys/socket.h sys/ioctl.h sys/time.h])
 AC_CHECK_HEADERS([arpa/inet.h netinet/in.h])
-AC_CHECK_HEADERS([sys/un.h], [have_sys_un_h=yes], [have_sys_un_h=no])
-AM_CONDITIONAL([HAVE_SYS_UN_H], test "x$have_sys_un_h" = xyes)
-
-case $host in
-  *-*-cygwin* | *-*-cegcc*)
-    # These are POSIX-like systems using BSD-like sockets API.
-    ;;
-  *)
-    AC_CHECK_HEADERS([windows.h winsock2.h ws2tcpip.h])
-    ;;
-esac
+AC_CHECK_HEADERS([sys/un.h])
 
 case $host in
   *darwin*|*interix*)
@@ -318,7 +327,7 @@ case $host in
     dnl Interix: "does provide poll(), but the implementing developer must
     dnl have been in a bad mood, because poll() only works on the /proc
     dnl filesystem here"
-    dnl Mac OS X's poll has funny behaviors, like:
+    dnl macOS poll() has funny behaviors, like:
     dnl not being able to do poll on no fildescriptors (10.3?)
     dnl not being able to poll on some files (like anything in /dev)
     dnl not having reliable timeout support
@@ -330,21 +339,21 @@ case $host in
     ;;
 esac
 
-AC_CHECK_FUNCS(gettimeofday select strtoll memset_s)
+AC_CHECK_FUNCS(gettimeofday select strtoll explicit_bzero explicit_memset memset_s snprintf)
 
 dnl Check for select() into ws2_32 for Msys/Mingw
 if test "$ac_cv_func_select" != "yes"; then
   AC_MSG_CHECKING([for select in ws2_32])
-  AC_TRY_LINK([
-#ifdef HAVE_WINSOCK2_H
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+#ifdef HAVE_WINDOWS_H
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <winsock2.h>
 #endif
-    ],[
+    ]], [[
       select(0,(fd_set *)NULL,(fd_set *)NULL,(fd_set *)NULL,(struct timeval *)NULL);
-    ],[
+    ]])],[
       AC_MSG_RESULT([yes])
       HAVE_SELECT="1"
       AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
@@ -375,11 +384,44 @@ if test "$found_crypto" = "none"; then
 fi
 
 if test $missing_required_deps = 1; then
-  AC_MSG_ERROR([Required dependencies are missing!])
+  AC_MSG_ERROR([Required dependencies are missing.])
 fi
 
+AM_CONDITIONAL([HAVE_WINDRES],
+  [test "x$have_windows_h" = "xyes" && test "x${enable_shared}" = "xyes" && test -n "${RC}"])
+
+AM_CONDITIONAL([HAVE_LIB_STATIC], [test "x$enable_static" != "xno"])
+
 # Configure parameters
-LIBSSH2_CHECK_OPTION_WERROR
+
+# Append crypto lib
+if   test "$found_crypto" = "openssl"; then
+  LIBS="${LIBS} ${LTLIBSSL}"
+elif test "$found_crypto" = "wolfssl"; then
+  LIBS="${LIBS} ${LTLIBWOLFSSL}"
+elif test "$found_crypto" = "libgcrypt"; then
+  LIBS="${LIBS} ${LTLIBGCRYPT}"
+elif test "$found_crypto" = "wincng"; then
+  LIBS="${LIBS} ${LTLIBBCRYPT}"
+elif test "$found_crypto" = "mbedtls"; then
+  LIBS="${LIBS} ${LTLIBMBEDCRYPTO}"
+fi
+
+LIBS="${LIBS} ${LTLIBZ}"
+
+LIBSSH2_PC_LIBS_PRIVATE=$LIBS
+AC_SUBST(LIBSSH2_PC_LIBS_PRIVATE)
+
+dnl merge the pkg-config private fields into public ones when static-only
+if test "x$enable_shared" = "xyes"; then
+  LIBSSH2_PC_REQUIRES=
+  LIBSSH2_PC_LIBS=
+else
+  LIBSSH2_PC_REQUIRES=$LIBSSH2_PC_REQUIRES_PRIVATE
+  LIBSSH2_PC_LIBS=$LIBSSH2_PC_LIBS_PRIVATE
+fi
+AC_SUBST(LIBSSH2_PC_REQUIRES)
+AC_SUBST(LIBSSH2_PC_LIBS)
 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
@@ -392,16 +434,20 @@ AC_OUTPUT
 
 AC_MSG_NOTICE([summary of build options:
 
-  version:          ${LIBSSH2VER}
+  version:          ${LIBSSH2_VERSION}
   Host type:        ${host}
   Install prefix:   ${prefix}
   Compiler:         ${CC}
   Compiler flags:   ${CFLAGS}
   Library types:    Shared=${enable_shared}, Static=${enable_static}
   Crypto library:   ${found_crypto_str}
+  WinCNG ECDSA:     $wincng_ecdsa
+  zlib compression: ${found_libz}
   Clear memory:     $enable_clear_memory
+  Deprecated APIs:  $with_deprecated
   Debug build:      $enable_debug
   Build examples:   $build_examples
+  Run Docker tests: $run_docker_tests
+  Run sshd tests:   $run_sshd_tests
   Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
 ])
diff --git a/libssh2/depcomp b/libssh2/depcomp
index 6b391623..715e3431 100755
--- a/libssh2/depcomp
+++ b/libssh2/depcomp
@@ -3,7 +3,7 @@
 
 scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1999-2020 Free Software Foundation, Inc.
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/libssh2/docs/AUTHORS b/libssh2/docs/AUTHORS
index 5c7445bf..e94299fc 100644
--- a/libssh2/docs/AUTHORS
+++ b/libssh2/docs/AUTHORS
@@ -1,5 +1,5 @@
  libssh2 is the result of many friendly people. This list is an attempt to
- mention all contributors. If we've missed anyone, tell us!
+ mention all contributors. If we have missed anyone, tell us!
 
  This list of names is a-z sorted.
 
@@ -71,6 +71,7 @@ Steven Van Ingelgem
 TJ Saunders
 Tommy Lindgren
 Tor Arntsen
+Viktor Szakats
 Vincent Jaulin
 Vincent Torri
 Vlad Grachov
diff --git a/libssh2/docs/BINDINGS b/libssh2/docs/BINDINGS
deleted file mode 100644
index 471f9be8..00000000
--- a/libssh2/docs/BINDINGS
+++ /dev/null
@@ -1,29 +0,0 @@
-
-Creative people have written bindings or interfaces for various environments
-and programming languages. Using one of these bindings allows you to take
-advantage of libssh2 directly from within your favourite language.
-
-The bindings listed below are not part of the libssh2 distribution archives,
-but must be downloaded and installed separately.
-
-Cocoa/Objective-C
-  https://github.com/karelia/libssh2_sftp-Cocoa-wrapper
-
-Haskell
-  FFI bindings - https://hackage.haskell.org/package/libssh2
-
-Perl
-  Net::SSH2 - https://metacpan.org/pod/Net::SSH2
-
-PHP
-  ssh2 - https://pecl.php.net/package/ssh2
-
-Python
-  pylibssh2 - https://pypi.python.org/pypi/pylibssh2
-
-Python-ctypes
-
-  PySsh2 - https://github.com/gellule/PySsh2
-
-Ruby
-  libssh2-ruby - https://github.com/mitchellh/libssh2-ruby
diff --git a/libssh2/docs/BINDINGS.md b/libssh2/docs/BINDINGS.md
new file mode 100644
index 00000000..63ad1b0d
--- /dev/null
+++ b/libssh2/docs/BINDINGS.md
@@ -0,0 +1,25 @@
+libssh2 bindings
+================
+
+Creative people have written bindings or interfaces for various environments
+and programming languages. Using one of these bindings allows you to take
+advantage of libssh2 directly from within your favourite language.
+
+The bindings listed below are not part of the libssh2 distribution archives,
+but must be downloaded and installed separately.
+
+<!-- markdown-link-check-disable -->
+
+[Cocoa/Objective-C](https://github.com/karelia/libssh2_sftp-Cocoa-wrapper)
+
+[Haskell FFI bindings](https://hackage.haskell.org/package/libssh2)
+
+[Perl Net::SSH2](https://metacpan.org/pod/Net::SSH2)
+
+[PHP ssh2](https://pecl.php.net/package/ssh2)
+
+[Python pylibssh2](https://pypi.python.org/pypi/pylibssh2)
+
+[Python-ctypes PySsh2](https://github.com/gellule/PySsh2)
+
+[Ruby libssh2-ruby](https://github.com/mitchellh/libssh2-ruby)
diff --git a/libssh2/docs/CMakeLists.txt b/libssh2/docs/CMakeLists.txt
index 6abf0e49..a3af0461 100644
--- a/libssh2/docs/CMakeLists.txt
+++ b/libssh2/docs/CMakeLists.txt
@@ -1,4 +1,5 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Viktor Szakats
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,179 +33,12 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
 
-set(MAN_PAGES
-  libssh2_agent_connect.3
-  libssh2_agent_disconnect.3
-  libssh2_agent_free.3
-  libssh2_agent_get_identity.3
-  libssh2_agent_get_identity_path.3
-  libssh2_agent_init.3
-  libssh2_agent_list_identities.3
-  libssh2_agent_set_identity_path.3
-  libssh2_agent_userauth.3
-  libssh2_banner_set.3
-  libssh2_base64_decode.3
-  libssh2_channel_close.3
-  libssh2_channel_direct_tcpip.3
-  libssh2_channel_direct_tcpip_ex.3
-  libssh2_channel_eof.3
-  libssh2_channel_exec.3
-  libssh2_channel_flush.3
-  libssh2_channel_flush_ex.3
-  libssh2_channel_flush_stderr.3
-  libssh2_channel_forward_accept.3
-  libssh2_channel_forward_cancel.3
-  libssh2_channel_forward_listen.3
-  libssh2_channel_forward_listen_ex.3
-  libssh2_channel_free.3
-  libssh2_channel_get_exit_signal.3
-  libssh2_channel_get_exit_status.3
-  libssh2_channel_handle_extended_data.3
-  libssh2_channel_handle_extended_data2.3
-  libssh2_channel_ignore_extended_data.3
-  libssh2_channel_open_ex.3
-  libssh2_channel_open_session.3
-  libssh2_channel_process_startup.3
-  libssh2_channel_read.3
-  libssh2_channel_read_ex.3
-  libssh2_channel_read_stderr.3
-  libssh2_channel_receive_window_adjust.3
-  libssh2_channel_receive_window_adjust2.3
-  libssh2_channel_request_pty.3
-  libssh2_channel_request_pty_ex.3
-  libssh2_channel_request_pty_size.3
-  libssh2_channel_request_pty_size_ex.3
-  libssh2_channel_send_eof.3
-  libssh2_channel_set_blocking.3
-  libssh2_channel_setenv.3
-  libssh2_channel_setenv_ex.3
-  libssh2_channel_shell.3
-  libssh2_channel_subsystem.3
-  libssh2_channel_wait_closed.3
-  libssh2_channel_wait_eof.3
-  libssh2_channel_window_read.3
-  libssh2_channel_window_read_ex.3
-  libssh2_channel_window_write.3
-  libssh2_channel_window_write_ex.3
-  libssh2_channel_write.3
-  libssh2_channel_write_ex.3
-  libssh2_channel_write_stderr.3
-  libssh2_channel_x11_req.3
-  libssh2_channel_x11_req_ex.3
-  libssh2_exit.3
-  libssh2_free.3
-  libssh2_hostkey_hash.3
-  libssh2_init.3
-  libssh2_keepalive_config.3
-  libssh2_keepalive_send.3
-  libssh2_knownhost_add.3
-  libssh2_knownhost_addc.3
-  libssh2_knownhost_check.3
-  libssh2_knownhost_checkp.3
-  libssh2_knownhost_del.3
-  libssh2_knownhost_free.3
-  libssh2_knownhost_get.3
-  libssh2_knownhost_init.3
-  libssh2_knownhost_readfile.3
-  libssh2_knownhost_readline.3
-  libssh2_knownhost_writefile.3
-  libssh2_knownhost_writeline.3
-  libssh2_poll.3
-  libssh2_poll_channel_read.3
-  libssh2_publickey_add.3
-  libssh2_publickey_add_ex.3
-  libssh2_publickey_init.3
-  libssh2_publickey_list_fetch.3
-  libssh2_publickey_list_free.3
-  libssh2_publickey_remove.3
-  libssh2_publickey_remove_ex.3
-  libssh2_publickey_shutdown.3
-  libssh2_scp_recv.3
-  libssh2_scp_recv2.3
-  libssh2_scp_send.3
-  libssh2_scp_send64.3
-  libssh2_scp_send_ex.3
-  libssh2_session_abstract.3
-  libssh2_session_banner_get.3
-  libssh2_session_banner_set.3
-  libssh2_session_block_directions.3
-  libssh2_session_callback_set.3
-  libssh2_session_disconnect.3
-  libssh2_session_disconnect_ex.3
-  libssh2_session_flag.3
-  libssh2_session_free.3
-  libssh2_session_get_blocking.3
-  libssh2_session_get_timeout.3
-  libssh2_session_handshake.3
-  libssh2_session_hostkey.3
-  libssh2_session_init.3
-  libssh2_session_init_ex.3
-  libssh2_session_last_errno.3
-  libssh2_session_last_error.3
-  libssh2_session_set_last_error.3
-  libssh2_session_method_pref.3
-  libssh2_session_methods.3
-  libssh2_session_set_blocking.3
-  libssh2_session_set_timeout.3
-  libssh2_session_startup.3
-  libssh2_session_supported_algs.3
-  libssh2_sftp_close.3
-  libssh2_sftp_close_handle.3
-  libssh2_sftp_closedir.3
-  libssh2_sftp_fsetstat.3
-  libssh2_sftp_fstat.3
-  libssh2_sftp_fstat_ex.3
-  libssh2_sftp_fstatvfs.3
-  libssh2_sftp_fsync.3
-  libssh2_sftp_get_channel.3
-  libssh2_sftp_init.3
-  libssh2_sftp_last_error.3
-  libssh2_sftp_lstat.3
-  libssh2_sftp_mkdir.3
-  libssh2_sftp_mkdir_ex.3
-  libssh2_sftp_open.3
-  libssh2_sftp_open_ex.3
-  libssh2_sftp_opendir.3
-  libssh2_sftp_read.3
-  libssh2_sftp_readdir.3
-  libssh2_sftp_readdir_ex.3
-  libssh2_sftp_readlink.3
-  libssh2_sftp_realpath.3
-  libssh2_sftp_rename.3
-  libssh2_sftp_rename_ex.3
-  libssh2_sftp_rewind.3
-  libssh2_sftp_rmdir.3
-  libssh2_sftp_rmdir_ex.3
-  libssh2_sftp_seek.3
-  libssh2_sftp_seek64.3
-  libssh2_sftp_setstat.3
-  libssh2_sftp_shutdown.3
-  libssh2_sftp_stat.3
-  libssh2_sftp_stat_ex.3
-  libssh2_sftp_statvfs.3
-  libssh2_sftp_symlink.3
-  libssh2_sftp_symlink_ex.3
-  libssh2_sftp_tell.3
-  libssh2_sftp_tell64.3
-  libssh2_sftp_unlink.3
-  libssh2_sftp_unlink_ex.3
-  libssh2_sftp_write.3
-  libssh2_trace.3
-  libssh2_trace_sethandler.3
-  libssh2_userauth_authenticated.3
-  libssh2_userauth_hostbased_fromfile.3
-  libssh2_userauth_hostbased_fromfile_ex.3
-  libssh2_userauth_keyboard_interactive.3
-  libssh2_userauth_keyboard_interactive_ex.3
-  libssh2_userauth_list.3
-  libssh2_userauth_password.3
-  libssh2_userauth_password_ex.3
-  libssh2_userauth_publickey.3
-  libssh2_userauth_publickey_fromfile.3
-  libssh2_userauth_publickey_fromfile_ex.3
-  libssh2_userauth_publickey_frommemory.3
-  libssh2_version.3)
+transform_makefile_inc("Makefile.am" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.am.cmake")
+# Get 'dist_man_MANS' variable
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.am.cmake")
 
 include(GNUInstallDirs)
-install(FILES ${MAN_PAGES} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
+install(FILES ${dist_man_MANS} DESTINATION "${CMAKE_INSTALL_MANDIR}/man3")
diff --git a/libssh2/docs/HACKING b/libssh2/docs/HACKING
deleted file mode 100644
index 5da8e66c..00000000
--- a/libssh2/docs/HACKING
+++ /dev/null
@@ -1,13 +0,0 @@
-
-libssh2 source code style guide:
-
- - 4 level indent
- - spaces-only (no tabs)
- - open braces on the if/for line:
-
-     if (banana) {
-         go_nuts();
-     }
-
- - keep source lines shorter than 80 columns
- - See libssh2-style.el for how to achieve this within Emacs
diff --git a/libssh2/docs/HACKING-CRYPTO b/libssh2/docs/HACKING-CRYPTO
index ca947728..1ef6c449 100644
--- a/libssh2/docs/HACKING-CRYPTO
+++ b/libssh2/docs/HACKING-CRYPTO
@@ -31,19 +31,18 @@ LIBSSH2_LIB_HAVE_LINKFLAGS from LIBSSH2_CRYPTO_CHECK, which automatically
 creates and handles a --with-$newname-prefix option and sets an
 LTLIBNEWNAME variable on success.
 
-0.3) Create Makefile.newname.inc in the top-level directory
+0.3) Add new header to src/Makefile.inc
 
-This must set CRYPTO_CSOURCES, CRYPTO_HHEADERS and CRYPTO_LTLIBS.
-Set CRYPTO_CSOURCES and CRYPTO_HHEADERS to the new backend source files
-and set CRYPTO_LTLIBS to the required library linking parameters, e.g.
-$(LTLIBNEWNAME) as generated by by LIBSSH2_LIB_HAVE_LINKFLAGS.
+0.4) Include new source in src/crypto.c
 
-0.4) Add a new block in src/Makefile.am
+0.5) Add a new block in configure.ac
 
-if NEWNAME
-include ../Makefile.newname.inc
-endif
+```
+elif test "$found_crypto" = "newname"; then
+  LIBS="${LIBS} ${LTLIBNEWNAME}"
+```
 
+0.6) Add CMake detection logic to CMakeLists.txt
 
 1) Crypto library initialization/termination.
 
@@ -53,6 +52,10 @@ Initializes the crypto library. May be an empty macro if not needed.
 void libssh2_crypto_exit(void);
 Terminates the crypto library use. May be an empty macro if not needed.
 
+1.1) Crypto runtime detection
+
+The libssh2_crypto_engine_t enum must include the new engine, and
+libssh2_crypto_engine() must return it when it is built in.
 
 2) HMAC
 
@@ -60,27 +63,23 @@ libssh2_hmac_ctx
 Type of an HMAC computation context. Generally a struct.
 Used for all hash algorithms.
 
-void libssh2_hmac_ctx_init(libssh2_hmac_ctx ctx);
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx);
 Initializes the HMAC computation context ctx.
 Called before setting-up the hash algorithm.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_hmac_update(libssh2_hmac_ctx ctx,
-                         const unsigned char *data,
-                         int datalen);
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, int datalen);
 Continue computation of an HMAC on datalen bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_hmac_final(libssh2_hmac_ctx ctx,
-                        unsigned char output[]);
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx,
+                        void output[]);
 Get the computed HMAC from context ctx into the output buffer. The
 minimum data buffer size depends on the HMAC hash algorithm.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx);
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx);
 Releases the HMAC computation context at ctx.
 
 
@@ -99,26 +98,29 @@ int libssh2_sha1_init(libssh2_sha1_ctx *x);
 Initializes the SHA-1 computation context at x.
 Returns 1 for success and 0 for failure
 
-void libssh2_sha1_update(libssh2_sha1_ctx ctx,
-                         const unsigned char *data,
-                         size_t len);
+int libssh2_sha1_update(libssh2_sha1_ctx ctx,
+                        const unsigned char *data,
+                        size_t len);
 Continue computation of SHA-1 on len bytes at data using context ctx.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_sha1_final(libssh2_sha1_ctx ctx,
-                        unsigned char output[SHA_DIGEST_LEN]);
+int libssh2_sha1_final(libssh2_sha1_ctx ctx,
+                       unsigned char output[SHA_DIGEST_LEN]);
 Get the computed SHA-1 signature from context ctx and store it into the
 output buffer.
 Release the context.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
-                            const void *key,
-                            int keylen);
+int libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                           const void *key,
+                           int keylen);
 Setup the HMAC computation context ctx for an HMAC-SHA-1 computation using the
 keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
+Returns 1 for success and 0 for failure.
 
 3.2) SHA-256
 Must always be implemented.
@@ -133,22 +135,24 @@ int libssh2_sha256_init(libssh2_sha256_ctx *x);
 Initializes the SHA-256 computation context at x.
 Returns 1 for success and 0 for failure
 
-void libssh2_sha256_update(libssh2_sha256_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
+int libssh2_sha256_update(libssh2_sha256_ctx ctx,
+                          const unsigned char *data,
+                          size_t len);
 Continue computation of SHA-256 on len bytes at data using context ctx.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_sha256_final(libssh2_sha256_ctx ctx,
-                          unsigned char output[SHA256_DIGEST_LENGTH]);
+int libssh2_sha256_final(libssh2_sha256_ctx ctx,
+                         unsigned char output[SHA256_DIGEST_LENGTH]);
 Gets the computed SHA-256 signature from context ctx into the output buffer.
 Release the context.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
 int libssh2_sha256(const unsigned char *message,
-                   unsigned long len,
+                   size_t len,
                    unsigned char output[SHA256_DIGEST_LENGTH]);
 Computes the SHA-256 signature over the given message of length len and
 store the result into the output buffer.
@@ -159,11 +163,12 @@ LIBSSH2_HMAC_SHA256
 #define as 1 if the crypto library supports HMAC-SHA-256, else 0.
 If defined as 0, the rest of this section can be omitted.
 
-void libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
-                              const void *key,
-                              int keylen);
+int libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                             const void *key,
+                             int keylen);
 Setup the HMAC computation context ctx for an HMAC-256 computation using the
 keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
+Returns 1 for success and 0 for failure.
 
 3.3) SHA-384
 Mandatory if ECDSA is implemented. Can be omitted otherwise.
@@ -178,22 +183,24 @@ int libssh2_sha384_init(libssh2_sha384_ctx *x);
 Initializes the SHA-384 computation context at x.
 Returns 1 for success and 0 for failure
 
-void libssh2_sha384_update(libssh2_sha384_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
+int libssh2_sha384_update(libssh2_sha384_ctx ctx,
+                          const unsigned char *data,
+                          size_t len);
 Continue computation of SHA-384 on len bytes at data using context ctx.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_sha384_final(libssh2_sha384_ctx ctx,
-                          unsigned char output[SHA384_DIGEST_LENGTH]);
+int libssh2_sha384_final(libssh2_sha384_ctx ctx,
+                         unsigned char output[SHA384_DIGEST_LENGTH]);
 Gets the computed SHA-384 signature from context ctx into the output buffer.
 Release the context.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
 int libssh2_sha384(const unsigned char *message,
-                   unsigned long len,
+                   size_t len,
                    unsigned char output[SHA384_DIGEST_LENGTH]);
 Computes the SHA-384 signature over the given message of length len and
 store the result into the output buffer.
@@ -212,22 +219,24 @@ int libssh2_sha512_init(libssh2_sha512_ctx *x);
 Initializes the SHA-512 computation context at x.
 Returns 1 for success and 0 for failure
 
-void libssh2_sha512_update(libssh2_sha512_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
+int libssh2_sha512_update(libssh2_sha512_ctx ctx,
+                          const unsigned char *data,
+                          size_t len);
 Continue computation of SHA-512 on len bytes at data using context ctx.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_sha512_final(libssh2_sha512_ctx ctx,
-                          unsigned char output[SHA512_DIGEST_LENGTH]);
+int libssh2_sha512_final(libssh2_sha512_ctx ctx,
+                         unsigned char output[SHA512_DIGEST_LENGTH]);
 Gets the computed SHA-512 signature from context ctx into the output buffer.
 Release the context.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
 int libssh2_sha512(const unsigned char *message,
-                   unsigned long len,
+                   size_t len,
                    unsigned char output[SHA512_DIGEST_LENGTH]);
 Computes the SHA-512 signature over the given message of length len and
 store the result into the output buffer.
@@ -238,11 +247,12 @@ LIBSSH2_HMAC_SHA512
 #define as 1 if the crypto library supports HMAC-SHA-512, else 0.
 If defined as 0, the rest of this section can be omitted.
 
-void libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
-                              const void *key,
-                              int keylen);
+int libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                             const void *key,
+                             int keylen);
 Setup the HMAC computation context ctx for an HMAC-512 computation using the
 keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
+Returns 1 for success and 0 for failure.
 
 3.5) MD5
 LIBSSH2_MD5
@@ -259,35 +269,38 @@ int libssh2_md5_init(libssh2_md5_ctx *x);
 Initializes the MD5 computation context at x.
 Returns 1 for success and 0 for failure
 
-void libssh2_md5_update(libssh2_md5_ctx ctx,
-                        const unsigned char *data,
-                        size_t len);
+int libssh2_md5_update(libssh2_md5_ctx ctx,
+                       const unsigned char *data,
+                       size_t len);
 Continues computation of MD5 on len bytes at data using context ctx.
 Returns 1 for success and 0 for failure.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_md5_final(libssh2_md5_ctx ctx,
-                       unsigned char output[MD5_DIGEST_LENGTH]);
+int libssh2_md5_final(libssh2_md5_ctx ctx,
+                      unsigned char output[MD5_DIGEST_LENGTH]);
 Gets the computed MD5 signature from context ctx into the output buffer.
 Release the context.
 Note: if the ctx parameter is modified by the underlying code,
 this procedure must be implemented as a macro to map ctx --> &ctx.
+Must return 1 for success and 0 for failure.
 
-void libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
-                           const void *key,
-                           int keylen);
+int libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                          const void *key,
+                          int keylen);
 Setup the HMAC computation context ctx for an HMAC-MD5 computation using the
 keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
+Returns 1 for success and 0 for failure.
 
 3.6) RIPEMD-160
 LIBSSH2_HMAC_RIPEMD
 #define as 1 if the crypto library supports HMAC-RIPEMD-160, else 0.
 If defined as 0, the rest of this section can be omitted.
 
-void libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
-                                 const void *key,
-                                 int keylen);
+int libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
+                                const void *key,
+                                int keylen);
 Setup the HMAC computation context ctx for an HMAC-RIPEMD-160 computation using
 the keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
 Returns 1 for success and 0 for failure.
@@ -317,7 +330,8 @@ int _libssh2_cipher_crypt(_libssh2_cipher_ctx *ctx,
                           _libssh2_cipher_type(algo),
                           int encrypt,
                           unsigned char *block,
-                          size_t blocksize);
+                          size_t blocksize,
+                          int firstlast);
 Encrypt or decrypt in-place data at (block, blocksize) using the given
 context and/or algorithm.
 Return 0 if OK, else -1.
@@ -388,7 +402,7 @@ _libssh2_cipher_cast5
 CAST5-CBC algorithm identifier initializer.
 #define with constant value of type _libssh2_cipher_type().
 
-4.5) Tripple DES in CBC block mode.
+4.5) Triple DES in CBC block mode.
 LIBSSH2_3DES
 #define as 1 if the crypto library supports TripleDES in CBC mode, else 0.
 If defined as 0, the rest of this section can be omitted.
@@ -400,6 +414,21 @@ TripleDES-CBC algorithm identifier initializer.
 
 5) Diffie-Hellman support.
 
+LIBSSH2_DH_GEX_MINGROUP
+The minimum Diffie-Hellman group length in bits supported by the backend.
+Usually defined as 2048.
+
+LIBSSH2_DH_GEX_OPTGROUP
+The preferred Diffie-Hellman group length in bits. Usually defined as 4096.
+
+LIBSSH2_DH_GEX_MAXGROUP
+The maximum Diffie-Hellman group length in bits supported by the backend.
+Usually defined as 8192.
+
+LIBSSH2_DH_MAX_MODULUS_BITS
+The maximum Diffie-Hellman modulus bit count accepted from the server. This
+value must be supported by the backend.  Usually 16384.
+
 5.1) Diffie-Hellman context.
 _libssh2_dh_ctx
 Type of a Diffie-Hellman computation context.
@@ -595,7 +624,7 @@ This procedure is already prototyped in crypto.h.
 int _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
                                         LIBSSH2_SESSION *session,
                                         const char *data,
-          size_t data_len,
+                                        size_t data_len,
                                         unsigned const char *passphrase);
 Gets an RSA private key from data into a new RSA context.
 Must call _libssh2_init_if_needed().
@@ -604,8 +633,8 @@ This procedure is already prototyped in crypto.h.
 
 int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
                              const unsigned char *sig,
-                             unsigned long sig_len,
-                             const unsigned char *m, unsigned long m_len);
+                             size_t sig_len,
+                             const unsigned char *m, size_t m_len);
 Verify (sig, sig_len) signature of (m, m_len) using an SHA-1 hash and the
 RSA context.
 Return 0 if OK, else -1.
@@ -637,6 +666,53 @@ Note: this procedure is not used if macro _libssh2_rsa_sha1_signv() is defined.
 void _libssh2_rsa_free(libssh2_rsa_ctx *rsactx);
 Releases the RSA computation context at rsactx.
 
+LIBSSH2_RSA_SHA2
+#define as 1 if the crypto library supports RSA SHA2 256/512, else 0.
+If defined as 0, the rest of this section can be omitted.
+
+int _libssh2_rsa_sha2_sign(LIBSSH2_SESSION * session,
+                           libssh2_rsa_ctx * rsactx,
+                           const unsigned char *hash,
+                           size_t hash_len,
+                           unsigned char **signature,
+                           size_t *signature_len);
+RSA signs the (hash, hashlen) SHA-2 hash bytes based on hash length and stores
+the allocated signature at (signature, signature_len).
+Signature buffer must be allocated from the given session.
+Returns 0 if OK, else -1.
+This procedure is already prototyped in crypto.h.
+Note: this procedure is not used if both macros _libssh2_rsa_sha2_256_signv()
+and _libssh2_rsa_sha2_512_signv are defined.
+
+int _libssh2_rsa_sha2_256_signv(LIBSSH2_SESSION *session,
+                                unsigned char **sig, size_t *siglen,
+                                int count, const struct iovec vector[],
+                                libssh2_rsa_ctx *ctx);
+RSA signs the SHA-256 hash computed over the count data chunks in vector.
+Signature is stored at (sig, siglen).
+Signature buffer must be allocated from the given session.
+Returns 0 if OK, else -1.
+Note: this procedure is optional: if provided, it MUST be defined as a macro.
+
+int _libssh2_rsa_sha2_512_signv(LIBSSH2_SESSION *session,
+                                unsigned char **sig, size_t *siglen,
+                                int count, const struct iovec vector[],
+                                libssh2_rsa_ctx *ctx);
+RSA signs the SHA-512 hash computed over the count data chunks in vector.
+Signature is stored at (sig, siglen).
+Signature buffer must be allocated from the given session.
+Returns 0 if OK, else -1.
+Note: this procedure is optional: if provided, it MUST be defined as a macro.
+
+int _libssh2_rsa_sha2_verify(libssh2_rsa_ctx * rsa,
+                             size_t hash_len,
+                             const unsigned char *sig,
+                             size_t sig_len,
+                             const unsigned char *m, size_t m_len);
+Verify (sig, sig_len) signature of (m, m_len) using an SHA-2 hash based on
+hash length and the RSA context.
+Return 0 if OK, else -1.
+This procedure is already prototyped in crypto.h.
 
 7.2) DSA
 LIBSSH2_DSA
@@ -687,7 +763,7 @@ This procedure is already prototyped in crypto.h.
 
 int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx *dsactx,
                              const unsigned char *sig,
-                             const unsigned char *m, unsigned long m_len);
+                             const unsigned char *m, size_t m_len);
 Verify (sig, siglen) signature of (m, m_len) using an SHA-1 hash and the
 DSA context.
 Returns 0 if OK, else -1.
@@ -695,7 +771,7 @@ This procedure is already prototyped in crypto.h.
 
 int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx *dsactx,
                            const unsigned char *hash,
-                           unsigned long hash_len, unsigned char *sig);
+                           size_t hash_len, unsigned char *sig);
 DSA signs the (hash, hash_len) data using SHA-1 and store the signature at sig.
 Returns 0 if OK, else -1.
 This procedure is already prototyped in crypto.h.
@@ -844,7 +920,7 @@ This procedure is already prototyped in crypto.h.
 int _libssh2_ed25519_new_public(libssh2_ed25519_ctx **ed_ctx,
                                 LIBSSH2_SESSION *session,
                                 const unsigned char *raw_pub_key,
-                                const uint8_t key_len);
+                                const size_t key_len);
 Stores at ed_ctx a new ED25519 key context for raw public key (raw_pub_key,
 key_len).
 Return 0 if OK, else -1.
@@ -897,6 +973,17 @@ In example, this is needed to preset unused structure slacks on platforms
 requiring it.
 If this is not needed, it should be defined as an empty macro.
 
-int _libssh2_random(unsigned char *buf, int len);
+int _libssh2_random(unsigned char *buf, size_t len);
 Store len random bytes at buf.
 Returns 0 if OK, else -1.
+
+const char * _libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                                    unsigned char *key_method,
+                                                    size_t key_method_len);
+
+This function is for implementing key hash upgrading as defined in RFC 8332.
+
+Based on the incoming key_method value, this function will return a
+list of supported algorithms that can upgrade the original key method algorithm
+as a comma separated list, if there is no upgrade option this function should
+return NULL.
diff --git a/libssh2/docs/HACKING.md b/libssh2/docs/HACKING.md
new file mode 100644
index 00000000..11ddbd30
--- /dev/null
+++ b/libssh2/docs/HACKING.md
@@ -0,0 +1,14 @@
+# libssh2 source code style guide
+
+- 4 level indent
+- spaces-only (no tabs)
+- open braces on the if/for line:
+
+  ```
+  if (banana) {
+      go_nuts();
+  }
+  ```
+
+- keep source lines shorter than 80 columns
+- See `libssh2-style.el` for how to achieve this within Emacs
diff --git a/libssh2/docs/INSTALL_AUTOTOOLS b/libssh2/docs/INSTALL_AUTOTOOLS
index a75b5181..46584d76 100644
--- a/libssh2/docs/INSTALL_AUTOTOOLS
+++ b/libssh2/docs/INSTALL_AUTOTOOLS
@@ -7,12 +7,13 @@ Software Foundation, Inc.
 This file is free documentation; the Free Software Foundation gives
 unlimited permission to copy, distribute and modify it.
 
+SPDX-License-Identifier: FSFULLR
+
 When Building directly from Master
 ==================================
 
 If you want to build directly from the git repository, you must first
-generate the configure script and Makefile using autotools. There is
-a convenience script that calls all tools in the correct order. Make
+generate the configure script and Makefile using autotools. Make
 sure that autoconf, automake and libtool are installed on your system,
 then execute:
 
@@ -38,7 +39,7 @@ file `config.log' containing compiler output (useful mainly for
 debugging `configure').
 
    It can also use an optional file (typically called `config.cache'
-and enabled with `--cache-file=config.cache' or simply `-C') that saves
+and enabled with `--cache-file=config.cache' or shortly `-C') that saves
 the results of its tests to speed up reconfiguring.  (Caching is
 disabled by default to prevent problems with accidental use of stale
 cache files.)
@@ -47,7 +48,7 @@ cache files.)
 to figure out how `configure' could check whether to do them, and mail
 diffs or instructions to the address given in the `README' so they can
 be considered for the next release.  If you are using the cache, and at
-some point `config.cache' contains results you don't want to keep, you
+some point `config.cache' contains results you do not want to keep, you
 may remove or edit it.
 
    The file `configure.ac' (or `configure.in') is used to create
@@ -58,7 +59,7 @@ a newer version of `autoconf'.
 The simplest way to compile this package is:
 
   1. `cd' to the directory containing the package's source code and type
-     `./configure' to configure the package for your system.  If you're
+     `./configure' to configure the package for your system.  If you are
      using `csh' on an old version of System V, you might need to type
      `sh ./configure' instead to prevent `csh' from trying to execute
      `configure' itself.
@@ -149,7 +150,7 @@ is something like `gnu-as' or `x' (for the X Window System).  The
 package recognizes.
 
    For packages that use the X Window System, `configure' can usually
-find the X include and library files automatically, but if it doesn't,
+find the X include and library files automatically, but if it does not,
 you can use the `configure' options `--x-includes=DIR' and
 `--x-libraries=DIR' to specify their locations.
 
@@ -171,7 +172,7 @@ where SYSTEM can have one of these forms:
      OS KERNEL-OS
 
    See the file `config.sub' for the possible values of each field.  If
-`config.sub' isn't included in this package, then this package doesn't
+`config.sub' is not included in this package, then this package does not
 need to know the machine type.
 
    If you are _building_ compiler tools for cross-compiling, you should
@@ -255,77 +256,37 @@ More configure options
 
 Some ./configure options deserve additional comments:
 
- * --enable-crypt-none
-
-	The SSH2 Transport allows for unencrypted data
-	transmission using the "none" cipher.  Because this is
-	such a huge security hole, it is typically disabled on
-	SSH2 implementations and is disabled in libssh2 by
-	default as well.
-
-	Enabling this option will allow for "none" as a
-	negotiable method, however it still requires that the
-	method be advertized by the remote end and that no
-	more-preferable methods are available.
-
- * --enable-mac-none
-
-	The SSH2 Transport also allows implementations to
-	forego a message authentication code.  While this is
-	less of a security risk than using a "none" cipher, it
-	is still not recommended as disabling MAC hashes
-	removes a layer of security.
-
-	Enabling this option will allow for "none" as a
-	negotiable method, however it still requires that the
-	method be advertized by the remote end and that no
-	more-preferable methods are available.
-
- * --disable-gex-new
-
-	The diffie-hellman-group-exchange-sha1 (dh-gex) key
-	exchange method originally defined an exchange
-	negotiation using packet type 30 to request a
-	generation pair based on a single target value.  Later
-	refinement of dh-gex provided for range and target
-	values.  By default libssh2 will use the newer range
-	method.
-
-	If you experience trouble connecting to an old SSH
-	server using dh-gex, try this option to fallback on
-	the older more reliable method.
-
  * --with-libgcrypt
  * --without-libgcrypt
  * --with-libgcrypt-prefix=DIR
 
-	libssh2 can use the Libgcrypt library
-	(https://www.gnupg.org/) for cryptographic operations.
+        libssh2 can use the Libgcrypt library
+        (https://www.gnupg.org/) for cryptographic operations.
         One of the cryptographic libraries is required.
 
-	Configure will attempt to locate Libgcrypt
-	automatically.
+        Configure will attempt to locate Libgcrypt
+        automatically.
 
-	If your installation of Libgcrypt is in another
-	location, specify it using --with-libgcrypt-prefix.
+        If your installation of Libgcrypt is in another
+        location, specify it using --with-libgcrypt-prefix.
 
  * --with-openssl
  * --without-openssl
  * --with-libssl-prefix=[DIR]
 
-	libssh2 can use the OpenSSL library
-	(https://www.openssl.org) for cryptographic operations.
+        libssh2 can use the OpenSSL library
+        (https://www.openssl-library.org/) for cryptographic operations.
         One of the cryptographic libraries is required.
 
-	Configure will attempt to locate OpenSSL in the
-	default location.
+        Configure will attempt to locate OpenSSL in the
+        default location.
 
-	If your installation of OpenSSL is in another
-	location, specify it using --with-libssl-prefix.
+        If your installation of OpenSSL is in another
+        location, specify it using --with-libssl-prefix.
 
  * --with-mbedtls
  * --without-mbedtls
- * --with-libmbedtls-prefix=[DIR]
+ * --with-libmbedcrypto-prefix=[DIR]
 
         libssh2 can use the mbedTLS library
         (https://tls.mbed.org) for cryptographic operations.
@@ -335,21 +296,21 @@ Some ./configure options deserve additional comments:
         default location.
 
         If your installation of mbedTLS is in another
-        location, specify it using --with-libmbedtls-prefix.
+        location, specify it using --with-libmbedcrypto-prefix.
 
  * --with-libz
  * --without-libz
  * --with-libz-prefix=[DIR]
 
-	If present, libssh2 will attempt to use the zlib
-	(http://www.zlib.org) for payload compression, however
-	zlib is not required.
+        If present, libssh2 will attempt to use the zlib
+        (https://zlib.net/) for payload compression, however
+        zlib is not required.
 
-	If your installation of Libz is in another location,
-	specify it using --with-libz-prefix.
+        If your installation of Libz is in another location,
+        specify it using --with-libz-prefix.
 
  * --enable-debug
 
-	Will make the build use more pedantic and strict compiler
-	options as well as enable the libssh2_trace() function (for
-	showing debug traces).
+        Will make the build use more pedantic and strict compiler
+        options as well as enable the libssh2_trace() function (for
+        showing debug traces).
diff --git a/libssh2/docs/INSTALL_CMAKE.md b/libssh2/docs/INSTALL_CMAKE.md
index c136fdce..5b494db6 100644
--- a/libssh2/docs/INSTALL_CMAKE.md
+++ b/libssh2/docs/INSTALL_CMAKE.md
@@ -6,10 +6,11 @@ Web site source code: https://github.com/libssh2/www
 
 Installation instructions are in docs/INSTALL
 =======
-To build libssh2 you will need CMake v2.8 or later [1] and one of the
+To build libssh2 you will need CMake v3.7 or later [1] and one of the
 following cryptography libraries:
 
 * OpenSSL
+* wolfSSL
 * Libgcrypt
 * WinCNG
 * mbedTLS
@@ -21,8 +22,14 @@ If you are happy with the default options, make a new build directory,
 change to it, configure the build environment and build the project:
 
 ```
-  mkdir bin
-  cd bin
+  cmake -B bld
+  cmake --build bld
+```
+
+Use this with CMake 3.12.x or older:
+```
+  mkdir bld
+  cd bld
   cmake ..
   cmake --build .
 ```
@@ -35,8 +42,8 @@ cryptography library available.  The library binary will be put in
 Customising the build
 ---------------------
 
-Of course, you might want to customise the build options.  You can
-pass the options to CMake on the command line:
+You might want to customise the build options.  You can pass the options
+to CMake on the command line:
 
   cmake -D<option>=<value> ..
 
@@ -44,70 +51,44 @@ The following options are available:
 
  * `LINT=ON`
 
-    Enables running the source code linter when building. Can be `ON` or `OFF`.
+    Enables running the source code linter when building.
+    Can be `ON` or `OFF`. Default: `OFF`
+
+ * `BUILD_STATIC_LIBS=OFF`
 
+    Determines whether to build a libssh2 static library.
+    Can be `ON` or `OFF`. Default: `ON`
 
  * `BUILD_SHARED_LIBS=OFF`
 
-    Determines whether libssh2 is built as a static library or as a
-    shared library (.dll/.so).  Can be `ON` or `OFF`.
+    Determines whether to build a libssh2 shared library (.dll/.so).
+    Can be `ON` or `OFF`. Default: `ON`
 
  * `CRYPTO_BACKEND=`
 
     Chooses a specific cryptography library to use for cryptographic
-    operations.  Can be `OpenSSL` (https://www.openssl.org),
+    operations.  Can be `OpenSSL` (https://www.openssl-library.org/),
     `Libgcrypt` (https://www.gnupg.org/), `WinCNG` (Windows Vista+),
-    `mbedTLS` (https://tls.mbed.org/) or blank to use any library available.
+    `mbedTLS` (https://www.trustedfirmware.org/projects/mbed-tls/) or
+    blank to use any library available.
 
     CMake will attempt to locate the libraries automatically.  See [2]
     for more information.
 
- * `ENABLE_ZLIB_COMPRESSION=OFF`
-
-    Will use zlib (http://www.zlib.org) for payload compression.  Can
-    be `ON` or `OFF`.
-
- * `ENABLE_CRYPT_NONE=OFF`
-
-    The SSH2 Transport allows for unencrypted data transmission using
-    the "none" cipher.  Because this is such a huge security hole, it
-    is typically disabled on SSH2 implementations and is disabled in
-    libssh2 by default as well.
-
-    Enabling this option will allow for "none" as a negotiable method,
-    however it still requires that the method be advertized by the
-    remote end and that no more-preferable methods are available.
-
- * `ENABLE_MAC_NONE=OFF`
-
-    The SSH2 Transport also allows implementations to forego a message
-    authentication code.  While this is less of a security risk than
-    using a "none" cipher, it is still not recommended as disabling
-    MAC hashes removes a layer of security.
-
-    Enabling this option will allow for "none" as a negotiable method,
-    however it still requires that the method be advertized by the
-    remote end and that no more-preferable methods are available.
-
- * `ENABLE_GEX_NEW=ON`
-
-    The diffie-hellman-group-exchange-sha1 (dh-gex) key exchange
-    method originally defined an exchange negotiation using packet
-    type 30 to request a generation pair based on a single target
-    value.  Later refinement of dh-gex provided for range and target
-    values.  By default libssh2 will use the newer range method.
+ * `ENABLE_ZLIB_COMPRESSION=ON`
 
-    If you experience trouble connecting to an old SSH server using
-    dh-gex, try this option to fallback on the older more reliable
-    method.
+    Use zlib (https://zlib.net/) for payload compression.
+    Can be `ON` or `OFF`. Default: `OFF`
 
- * `ENABLE_DEBUG_LOGGING=ON` in Debug, `=OFF` in Release
+ * `ENABLE_DEBUG_LOGGING=ON`
 
-    Will enable the libssh2_trace() function for showing debug traces.
+    Enable the libssh2_trace() function for showing debug traces.
+    Can be `ON` or `OFF`. Default: `OFF` in Release, `ON` in `Debug`
 
- * `CLEAR_MEMORY=ON`
+ * `CLEAR_MEMORY=OFF`
 
-    Securely zero memory before freeing it (if the backend supports this).
+    Disable secure zero memory before freeing it (not recommended).
+    Can be `ON` or `OFF`. Default: `ON`
 
 Build tools
 -----------
@@ -116,8 +97,8 @@ The previous examples used CMake to start the build using:
 
   cmake --build .
 
-Alternatively, once CMake has configured your project, you can just
-use your own build tool, e.g GNU make, Visual Studio, etc., from that
+Alternatively, once CMake has configured your project, you can use
+your own build tool, e.g GNU make, Visual Studio, etc., from that
 point onwards.
 
 Tests
@@ -134,7 +115,7 @@ or
   cmake --build . --target RUN_TESTS
 ```
 
-How do I use libssh2 in my project if my project doesn't use CMake?
+How do I use libssh2 in my project if my project does not use CMake?
 -------------------------------------------------------------------
 
 If you are not using CMake for your own project, install libssh2
@@ -149,26 +130,25 @@ or
 ```
 
 and then specify the install location to your project in the normal
-way for your build environment.  If you don't like the default install
+way for your build environment.  If you do not like the default install
 location, add `-DCMAKE_INSTALL_PREFIX=<chosen prefix>` when initially
 configuring the project.
 
 How can I use libssh2 in my project if it also uses CMake?
 ----------------------------------------------------------
 
-If your own project also uses CMake, you don't need to worry about
-setting it up with libssh2's location.  Just add just the following
-lines and CMake will find libssh2 on your system, set up the necessary
-paths and link the library with your binary.
+If your own project also uses CMake, you do not need to worry about
+setting it up with libssh2's location. Add the following lines and
+CMake will find libssh2 on your system, set up the necessary paths and
+link the library with your binary.
 
-    find_package(Libssh2 REQUIRED CONFIG)
-    target_link_libraries(my_project_target Libssh2::libssh2)
+    find_package(libssh2 REQUIRED CONFIG)
+    target_link_libraries(my_project_target libssh2::libssh2)
 
-Of course, you still have to make libssh2 available on your system
-first.  You can install it in the traditional way shown above, but you
-don't have to.  Instead you can just build it, which will export its
-location to the user package registry [3] where `find_package` will
-find it.
+You still have to make libssh2 available on your system first.  You can
+install it in the traditional way shown above, but you do not have to.
+Instead you can build it, which will export its location to the user
+package registry [3] where `find_package` will find it.
 
 You can even combine the two steps using a so-called 'superbuild'
 project [4] that downloads, builds and exports libssh2, and then
@@ -177,13 +157,13 @@ builds your project:
     include(ExternalProject)
 
     ExternalProject_Add(
-        Libssh2
+        libssh2
         URL <libssh2 download location>
-        URL_HASH SHA1=<libssh2 archive SHA1>
+        URL_HASH SHA256=<libssh2 archive SHA256>
         INSTALL_COMMAND "")
 
     ExternalProject_Add(
-        MyProject DEPENDS Libssh2
+        MyProject DEPENDS libssh2
         SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src
         INSTALL_COMMAND "")
 
diff --git a/libssh2/docs/Makefile.am b/libssh2/docs/Makefile.am
index a8094312..f330b601 100644
--- a/libssh2/docs/Makefile.am
+++ b/libssh2/docs/Makefile.am
@@ -1,177 +1,190 @@
-# $Id: Makefile.am,v 1.37 2009/03/26 15:41:15 bagder Exp $
-
-EXTRA_DIST = template.3 BINDINGS INSTALL_AUTOTOOLS INSTALL_CMAKE.md HACKING TODO \
- AUTHORS CMakeLists.txt HACKING-CRYPTO SECURITY.md
+EXTRA_DIST = template.3 AUTHORS BINDINGS.md HACKING.md HACKING-CRYPTO \
+  INSTALL_AUTOTOOLS INSTALL_CMAKE.md SECURITY.md TODO CMakeLists.txt
 
 dist_man_MANS = \
-	libssh2_agent_connect.3 \
-	libssh2_agent_disconnect.3 \
-	libssh2_agent_free.3 \
-	libssh2_agent_get_identity.3 \
-	libssh2_agent_get_identity_path.3 \
-	libssh2_agent_init.3 \
-	libssh2_agent_list_identities.3 \
-	libssh2_agent_set_identity_path.3 \
-	libssh2_agent_userauth.3 \
-	libssh2_banner_set.3 \
-	libssh2_base64_decode.3 \
-	libssh2_channel_close.3 \
-	libssh2_channel_direct_tcpip.3 \
-	libssh2_channel_direct_tcpip_ex.3 \
-	libssh2_channel_eof.3 \
-	libssh2_channel_exec.3 \
-	libssh2_channel_flush.3 \
-	libssh2_channel_flush_ex.3 \
-	libssh2_channel_flush_stderr.3 \
-	libssh2_channel_forward_accept.3 \
-	libssh2_channel_forward_cancel.3 \
-	libssh2_channel_forward_listen.3 \
-	libssh2_channel_forward_listen_ex.3 \
-	libssh2_channel_free.3 \
-	libssh2_channel_get_exit_signal.3 \
-	libssh2_channel_get_exit_status.3 \
-	libssh2_channel_handle_extended_data.3 \
-	libssh2_channel_handle_extended_data2.3 \
-	libssh2_channel_ignore_extended_data.3 \
-	libssh2_channel_open_ex.3 \
-	libssh2_channel_open_session.3 \
-	libssh2_channel_process_startup.3 \
-	libssh2_channel_read.3 \
-	libssh2_channel_read_ex.3 \
-	libssh2_channel_read_stderr.3 \
-	libssh2_channel_receive_window_adjust.3 \
-	libssh2_channel_receive_window_adjust2.3 \
-	libssh2_channel_request_pty.3 \
-	libssh2_channel_request_pty_ex.3 \
-	libssh2_channel_request_pty_size.3 \
-	libssh2_channel_request_pty_size_ex.3 \
-	libssh2_channel_send_eof.3 \
-	libssh2_channel_set_blocking.3 \
-	libssh2_channel_setenv.3 \
-	libssh2_channel_setenv_ex.3 \
-	libssh2_channel_shell.3 \
-	libssh2_channel_subsystem.3 \
-	libssh2_channel_wait_closed.3 \
-	libssh2_channel_wait_eof.3 \
-	libssh2_channel_window_read.3 \
-	libssh2_channel_window_read_ex.3 \
-	libssh2_channel_window_write.3 \
-	libssh2_channel_window_write_ex.3 \
-	libssh2_channel_write.3 \
-	libssh2_channel_write_ex.3 \
-	libssh2_channel_write_stderr.3 \
-	libssh2_channel_x11_req.3 \
-	libssh2_channel_x11_req_ex.3 \
-	libssh2_exit.3 \
-	libssh2_free.3 \
-	libssh2_hostkey_hash.3 \
-	libssh2_init.3 \
-	libssh2_keepalive_config.3 \
-	libssh2_keepalive_send.3 \
-	libssh2_knownhost_add.3 \
-	libssh2_knownhost_addc.3 \
-	libssh2_knownhost_check.3 \
-	libssh2_knownhost_checkp.3 \
-	libssh2_knownhost_del.3 \
-	libssh2_knownhost_free.3 \
-	libssh2_knownhost_get.3 \
-	libssh2_knownhost_init.3 \
-	libssh2_knownhost_readfile.3 \
-	libssh2_knownhost_readline.3 \
-	libssh2_knownhost_writefile.3 \
-	libssh2_knownhost_writeline.3 \
-	libssh2_poll.3 \
-	libssh2_poll_channel_read.3 \
-	libssh2_publickey_add.3 \
-	libssh2_publickey_add_ex.3 \
-	libssh2_publickey_init.3 \
-	libssh2_publickey_list_fetch.3 \
-	libssh2_publickey_list_free.3 \
-	libssh2_publickey_remove.3 \
-	libssh2_publickey_remove_ex.3 \
-	libssh2_publickey_shutdown.3 \
-	libssh2_scp_recv.3 \
-	libssh2_scp_recv2.3 \
-	libssh2_scp_send.3 \
-	libssh2_scp_send64.3 \
-	libssh2_scp_send_ex.3 \
-	libssh2_session_abstract.3 \
-	libssh2_session_banner_get.3 \
-	libssh2_session_banner_set.3 \
-	libssh2_session_block_directions.3 \
-	libssh2_session_callback_set.3 \
-	libssh2_session_disconnect.3 \
-	libssh2_session_disconnect_ex.3 \
-	libssh2_session_flag.3 \
-	libssh2_session_free.3 \
-	libssh2_session_get_blocking.3 \
-	libssh2_session_get_timeout.3 \
-	libssh2_session_handshake.3 \
-	libssh2_session_hostkey.3 \
-	libssh2_session_init.3 \
-	libssh2_session_init_ex.3 \
-	libssh2_session_last_errno.3 \
-	libssh2_session_last_error.3 \
-	libssh2_session_set_last_error.3 \
-	libssh2_session_method_pref.3 \
-	libssh2_session_methods.3 \
-	libssh2_session_set_blocking.3 \
-	libssh2_session_set_timeout.3 \
-	libssh2_session_startup.3 \
-	libssh2_session_supported_algs.3 \
-	libssh2_sftp_close.3 \
-	libssh2_sftp_close_handle.3 \
-	libssh2_sftp_closedir.3 \
-	libssh2_sftp_fsetstat.3 \
-	libssh2_sftp_fstat.3 \
-	libssh2_sftp_fstat_ex.3 \
-	libssh2_sftp_fstatvfs.3 \
-	libssh2_sftp_fsync.3 \
-	libssh2_sftp_get_channel.3 \
-	libssh2_sftp_init.3 \
-	libssh2_sftp_last_error.3 \
-	libssh2_sftp_lstat.3 \
-	libssh2_sftp_mkdir.3 \
-	libssh2_sftp_mkdir_ex.3 \
-	libssh2_sftp_open.3 \
-	libssh2_sftp_open_ex.3 \
-	libssh2_sftp_opendir.3 \
-	libssh2_sftp_read.3 \
-	libssh2_sftp_readdir.3 \
-	libssh2_sftp_readdir_ex.3 \
-	libssh2_sftp_readlink.3 \
-	libssh2_sftp_realpath.3 \
-	libssh2_sftp_rename.3 \
-	libssh2_sftp_rename_ex.3 \
-	libssh2_sftp_rewind.3 \
-	libssh2_sftp_rmdir.3 \
-	libssh2_sftp_rmdir_ex.3 \
-	libssh2_sftp_seek.3 \
-	libssh2_sftp_seek64.3 \
-	libssh2_sftp_setstat.3 \
-	libssh2_sftp_shutdown.3 \
-	libssh2_sftp_stat.3 \
-	libssh2_sftp_stat_ex.3 \
-	libssh2_sftp_statvfs.3 \
-	libssh2_sftp_symlink.3 \
-	libssh2_sftp_symlink_ex.3 \
-	libssh2_sftp_tell.3 \
-	libssh2_sftp_tell64.3 \
-	libssh2_sftp_unlink.3 \
-	libssh2_sftp_unlink_ex.3 \
-	libssh2_sftp_write.3 \
-	libssh2_trace.3 \
-	libssh2_trace_sethandler.3 \
-	libssh2_userauth_authenticated.3 \
-	libssh2_userauth_hostbased_fromfile.3 \
-	libssh2_userauth_hostbased_fromfile_ex.3 \
-	libssh2_userauth_keyboard_interactive.3 \
-	libssh2_userauth_keyboard_interactive_ex.3 \
-	libssh2_userauth_list.3 \
-	libssh2_userauth_password.3 \
-	libssh2_userauth_password_ex.3 \
-	libssh2_userauth_publickey.3 \
-	libssh2_userauth_publickey_fromfile.3 \
-	libssh2_userauth_publickey_fromfile_ex.3 \
-	libssh2_userauth_publickey_frommemory.3 \
-	libssh2_version.3
+  libssh2_agent_connect.3 \
+  libssh2_agent_disconnect.3 \
+  libssh2_agent_free.3 \
+  libssh2_agent_get_identity.3 \
+  libssh2_agent_get_identity_path.3 \
+  libssh2_agent_init.3 \
+  libssh2_agent_list_identities.3 \
+  libssh2_agent_set_identity_path.3 \
+  libssh2_agent_sign.3 \
+  libssh2_agent_userauth.3 \
+  libssh2_banner_set.3 \
+  libssh2_base64_decode.3 \
+  libssh2_channel_close.3 \
+  libssh2_channel_direct_streamlocal_ex.3 \
+  libssh2_channel_direct_tcpip.3 \
+  libssh2_channel_direct_tcpip_ex.3 \
+  libssh2_channel_eof.3 \
+  libssh2_channel_exec.3 \
+  libssh2_channel_flush.3 \
+  libssh2_channel_flush_ex.3 \
+  libssh2_channel_flush_stderr.3 \
+  libssh2_channel_forward_accept.3 \
+  libssh2_channel_forward_cancel.3 \
+  libssh2_channel_forward_listen.3 \
+  libssh2_channel_forward_listen_ex.3 \
+  libssh2_channel_free.3 \
+  libssh2_channel_get_exit_signal.3 \
+  libssh2_channel_get_exit_status.3 \
+  libssh2_channel_handle_extended_data.3 \
+  libssh2_channel_handle_extended_data2.3 \
+  libssh2_channel_ignore_extended_data.3 \
+  libssh2_channel_open_ex.3 \
+  libssh2_channel_open_session.3 \
+  libssh2_channel_process_startup.3 \
+  libssh2_channel_read.3 \
+  libssh2_channel_read_ex.3 \
+  libssh2_channel_read_stderr.3 \
+  libssh2_channel_receive_window_adjust.3 \
+  libssh2_channel_receive_window_adjust2.3 \
+  libssh2_channel_request_auth_agent.3 \
+  libssh2_channel_request_pty.3 \
+  libssh2_channel_request_pty_ex.3 \
+  libssh2_channel_request_pty_size.3 \
+  libssh2_channel_request_pty_size_ex.3 \
+  libssh2_channel_send_eof.3 \
+  libssh2_channel_set_blocking.3 \
+  libssh2_channel_setenv.3 \
+  libssh2_channel_setenv_ex.3 \
+  libssh2_channel_shell.3 \
+  libssh2_channel_signal_ex.3 \
+  libssh2_channel_subsystem.3 \
+  libssh2_channel_wait_closed.3 \
+  libssh2_channel_wait_eof.3 \
+  libssh2_channel_window_read.3 \
+  libssh2_channel_window_read_ex.3 \
+  libssh2_channel_window_write.3 \
+  libssh2_channel_window_write_ex.3 \
+  libssh2_channel_write.3 \
+  libssh2_channel_write_ex.3 \
+  libssh2_channel_write_stderr.3 \
+  libssh2_channel_x11_req.3 \
+  libssh2_channel_x11_req_ex.3 \
+  libssh2_crypto_engine.3 \
+  libssh2_exit.3 \
+  libssh2_free.3 \
+  libssh2_hostkey_hash.3 \
+  libssh2_init.3 \
+  libssh2_keepalive_config.3 \
+  libssh2_keepalive_send.3 \
+  libssh2_knownhost_add.3 \
+  libssh2_knownhost_addc.3 \
+  libssh2_knownhost_check.3 \
+  libssh2_knownhost_checkp.3 \
+  libssh2_knownhost_del.3 \
+  libssh2_knownhost_free.3 \
+  libssh2_knownhost_get.3 \
+  libssh2_knownhost_init.3 \
+  libssh2_knownhost_readfile.3 \
+  libssh2_knownhost_readline.3 \
+  libssh2_knownhost_writefile.3 \
+  libssh2_knownhost_writeline.3 \
+  libssh2_poll.3 \
+  libssh2_poll_channel_read.3 \
+  libssh2_publickey_add.3 \
+  libssh2_publickey_add_ex.3 \
+  libssh2_publickey_init.3 \
+  libssh2_publickey_list_fetch.3 \
+  libssh2_publickey_list_free.3 \
+  libssh2_publickey_remove.3 \
+  libssh2_publickey_remove_ex.3 \
+  libssh2_publickey_shutdown.3 \
+  libssh2_scp_recv.3 \
+  libssh2_scp_recv2.3 \
+  libssh2_scp_send.3 \
+  libssh2_scp_send64.3 \
+  libssh2_scp_send_ex.3 \
+  libssh2_session_abstract.3 \
+  libssh2_session_banner_get.3 \
+  libssh2_session_banner_set.3 \
+  libssh2_session_block_directions.3 \
+  libssh2_session_callback_set.3 \
+  libssh2_session_callback_set2.3 \
+  libssh2_session_disconnect.3 \
+  libssh2_session_disconnect_ex.3 \
+  libssh2_session_flag.3 \
+  libssh2_session_free.3 \
+  libssh2_session_get_blocking.3 \
+  libssh2_session_get_read_timeout.3 \
+  libssh2_session_get_timeout.3 \
+  libssh2_session_handshake.3 \
+  libssh2_session_hostkey.3 \
+  libssh2_session_init.3 \
+  libssh2_session_init_ex.3 \
+  libssh2_session_last_errno.3 \
+  libssh2_session_last_error.3 \
+  libssh2_session_method_pref.3 \
+  libssh2_session_methods.3 \
+  libssh2_session_set_blocking.3 \
+  libssh2_session_set_last_error.3 \
+  libssh2_session_set_read_timeout.3 \
+  libssh2_session_set_timeout.3 \
+  libssh2_session_startup.3 \
+  libssh2_session_supported_algs.3 \
+  libssh2_sftp_close.3 \
+  libssh2_sftp_close_handle.3 \
+  libssh2_sftp_closedir.3 \
+  libssh2_sftp_fsetstat.3 \
+  libssh2_sftp_fstat.3 \
+  libssh2_sftp_fstat_ex.3 \
+  libssh2_sftp_fstatvfs.3 \
+  libssh2_sftp_fsync.3 \
+  libssh2_sftp_get_channel.3 \
+  libssh2_sftp_init.3 \
+  libssh2_sftp_last_error.3 \
+  libssh2_sftp_lstat.3 \
+  libssh2_sftp_mkdir.3 \
+  libssh2_sftp_mkdir_ex.3 \
+  libssh2_sftp_open.3 \
+  libssh2_sftp_open_ex.3 \
+  libssh2_sftp_open_ex_r.3 \
+  libssh2_sftp_open_r.3 \
+  libssh2_sftp_opendir.3 \
+  libssh2_sftp_posix_rename.3 \
+  libssh2_sftp_posix_rename_ex.3 \
+  libssh2_sftp_read.3 \
+  libssh2_sftp_readdir.3 \
+  libssh2_sftp_readdir_ex.3 \
+  libssh2_sftp_readlink.3 \
+  libssh2_sftp_realpath.3 \
+  libssh2_sftp_rename.3 \
+  libssh2_sftp_rename_ex.3 \
+  libssh2_sftp_rewind.3 \
+  libssh2_sftp_rmdir.3 \
+  libssh2_sftp_rmdir_ex.3 \
+  libssh2_sftp_seek.3 \
+  libssh2_sftp_seek64.3 \
+  libssh2_sftp_setstat.3 \
+  libssh2_sftp_shutdown.3 \
+  libssh2_sftp_stat.3 \
+  libssh2_sftp_stat_ex.3 \
+  libssh2_sftp_statvfs.3 \
+  libssh2_sftp_symlink.3 \
+  libssh2_sftp_symlink_ex.3 \
+  libssh2_sftp_tell.3 \
+  libssh2_sftp_tell64.3 \
+  libssh2_sftp_unlink.3 \
+  libssh2_sftp_unlink_ex.3 \
+  libssh2_sftp_write.3 \
+  libssh2_sign_sk.3 \
+  libssh2_trace.3 \
+  libssh2_trace_sethandler.3 \
+  libssh2_userauth_authenticated.3 \
+  libssh2_userauth_banner.3 \
+  libssh2_userauth_hostbased_fromfile.3 \
+  libssh2_userauth_hostbased_fromfile_ex.3 \
+  libssh2_userauth_keyboard_interactive.3 \
+  libssh2_userauth_keyboard_interactive_ex.3 \
+  libssh2_userauth_list.3 \
+  libssh2_userauth_password.3 \
+  libssh2_userauth_password_ex.3 \
+  libssh2_userauth_publickey.3 \
+  libssh2_userauth_publickey_fromfile.3 \
+  libssh2_userauth_publickey_fromfile_ex.3 \
+  libssh2_userauth_publickey_frommemory.3 \
+  libssh2_userauth_publickey_sk.3 \
+  libssh2_version.3
diff --git a/libssh2/docs/Makefile.in b/libssh2/docs/Makefile.in
index 40143ed1..1e1f2b0d 100644
--- a/libssh2/docs/Makefile.in
+++ b/libssh2/docs/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -13,8 +13,6 @@
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
-
-# $Id: Makefile.am,v 1.37 2009/03/26 15:41:15 bagder Exp $
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
@@ -91,12 +89,12 @@ build_triplet = @build@
 host_triplet = @host@
 subdir = docs
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
@@ -191,12 +189,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -207,30 +206,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -252,6 +255,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -312,181 +316,196 @@ target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
-EXTRA_DIST = template.3 BINDINGS INSTALL_AUTOTOOLS INSTALL_CMAKE.md HACKING TODO \
- AUTHORS CMakeLists.txt HACKING-CRYPTO SECURITY.md
+EXTRA_DIST = template.3 AUTHORS BINDINGS.md HACKING.md HACKING-CRYPTO \
+  INSTALL_AUTOTOOLS INSTALL_CMAKE.md SECURITY.md TODO CMakeLists.txt
 
 dist_man_MANS = \
-	libssh2_agent_connect.3 \
-	libssh2_agent_disconnect.3 \
-	libssh2_agent_free.3 \
-	libssh2_agent_get_identity.3 \
-	libssh2_agent_get_identity_path.3 \
-	libssh2_agent_init.3 \
-	libssh2_agent_list_identities.3 \
-	libssh2_agent_set_identity_path.3 \
-	libssh2_agent_userauth.3 \
-	libssh2_banner_set.3 \
-	libssh2_base64_decode.3 \
-	libssh2_channel_close.3 \
-	libssh2_channel_direct_tcpip.3 \
-	libssh2_channel_direct_tcpip_ex.3 \
-	libssh2_channel_eof.3 \
-	libssh2_channel_exec.3 \
-	libssh2_channel_flush.3 \
-	libssh2_channel_flush_ex.3 \
-	libssh2_channel_flush_stderr.3 \
-	libssh2_channel_forward_accept.3 \
-	libssh2_channel_forward_cancel.3 \
-	libssh2_channel_forward_listen.3 \
-	libssh2_channel_forward_listen_ex.3 \
-	libssh2_channel_free.3 \
-	libssh2_channel_get_exit_signal.3 \
-	libssh2_channel_get_exit_status.3 \
-	libssh2_channel_handle_extended_data.3 \
-	libssh2_channel_handle_extended_data2.3 \
-	libssh2_channel_ignore_extended_data.3 \
-	libssh2_channel_open_ex.3 \
-	libssh2_channel_open_session.3 \
-	libssh2_channel_process_startup.3 \
-	libssh2_channel_read.3 \
-	libssh2_channel_read_ex.3 \
-	libssh2_channel_read_stderr.3 \
-	libssh2_channel_receive_window_adjust.3 \
-	libssh2_channel_receive_window_adjust2.3 \
-	libssh2_channel_request_pty.3 \
-	libssh2_channel_request_pty_ex.3 \
-	libssh2_channel_request_pty_size.3 \
-	libssh2_channel_request_pty_size_ex.3 \
-	libssh2_channel_send_eof.3 \
-	libssh2_channel_set_blocking.3 \
-	libssh2_channel_setenv.3 \
-	libssh2_channel_setenv_ex.3 \
-	libssh2_channel_shell.3 \
-	libssh2_channel_subsystem.3 \
-	libssh2_channel_wait_closed.3 \
-	libssh2_channel_wait_eof.3 \
-	libssh2_channel_window_read.3 \
-	libssh2_channel_window_read_ex.3 \
-	libssh2_channel_window_write.3 \
-	libssh2_channel_window_write_ex.3 \
-	libssh2_channel_write.3 \
-	libssh2_channel_write_ex.3 \
-	libssh2_channel_write_stderr.3 \
-	libssh2_channel_x11_req.3 \
-	libssh2_channel_x11_req_ex.3 \
-	libssh2_exit.3 \
-	libssh2_free.3 \
-	libssh2_hostkey_hash.3 \
-	libssh2_init.3 \
-	libssh2_keepalive_config.3 \
-	libssh2_keepalive_send.3 \
-	libssh2_knownhost_add.3 \
-	libssh2_knownhost_addc.3 \
-	libssh2_knownhost_check.3 \
-	libssh2_knownhost_checkp.3 \
-	libssh2_knownhost_del.3 \
-	libssh2_knownhost_free.3 \
-	libssh2_knownhost_get.3 \
-	libssh2_knownhost_init.3 \
-	libssh2_knownhost_readfile.3 \
-	libssh2_knownhost_readline.3 \
-	libssh2_knownhost_writefile.3 \
-	libssh2_knownhost_writeline.3 \
-	libssh2_poll.3 \
-	libssh2_poll_channel_read.3 \
-	libssh2_publickey_add.3 \
-	libssh2_publickey_add_ex.3 \
-	libssh2_publickey_init.3 \
-	libssh2_publickey_list_fetch.3 \
-	libssh2_publickey_list_free.3 \
-	libssh2_publickey_remove.3 \
-	libssh2_publickey_remove_ex.3 \
-	libssh2_publickey_shutdown.3 \
-	libssh2_scp_recv.3 \
-	libssh2_scp_recv2.3 \
-	libssh2_scp_send.3 \
-	libssh2_scp_send64.3 \
-	libssh2_scp_send_ex.3 \
-	libssh2_session_abstract.3 \
-	libssh2_session_banner_get.3 \
-	libssh2_session_banner_set.3 \
-	libssh2_session_block_directions.3 \
-	libssh2_session_callback_set.3 \
-	libssh2_session_disconnect.3 \
-	libssh2_session_disconnect_ex.3 \
-	libssh2_session_flag.3 \
-	libssh2_session_free.3 \
-	libssh2_session_get_blocking.3 \
-	libssh2_session_get_timeout.3 \
-	libssh2_session_handshake.3 \
-	libssh2_session_hostkey.3 \
-	libssh2_session_init.3 \
-	libssh2_session_init_ex.3 \
-	libssh2_session_last_errno.3 \
-	libssh2_session_last_error.3 \
-	libssh2_session_set_last_error.3 \
-	libssh2_session_method_pref.3 \
-	libssh2_session_methods.3 \
-	libssh2_session_set_blocking.3 \
-	libssh2_session_set_timeout.3 \
-	libssh2_session_startup.3 \
-	libssh2_session_supported_algs.3 \
-	libssh2_sftp_close.3 \
-	libssh2_sftp_close_handle.3 \
-	libssh2_sftp_closedir.3 \
-	libssh2_sftp_fsetstat.3 \
-	libssh2_sftp_fstat.3 \
-	libssh2_sftp_fstat_ex.3 \
-	libssh2_sftp_fstatvfs.3 \
-	libssh2_sftp_fsync.3 \
-	libssh2_sftp_get_channel.3 \
-	libssh2_sftp_init.3 \
-	libssh2_sftp_last_error.3 \
-	libssh2_sftp_lstat.3 \
-	libssh2_sftp_mkdir.3 \
-	libssh2_sftp_mkdir_ex.3 \
-	libssh2_sftp_open.3 \
-	libssh2_sftp_open_ex.3 \
-	libssh2_sftp_opendir.3 \
-	libssh2_sftp_read.3 \
-	libssh2_sftp_readdir.3 \
-	libssh2_sftp_readdir_ex.3 \
-	libssh2_sftp_readlink.3 \
-	libssh2_sftp_realpath.3 \
-	libssh2_sftp_rename.3 \
-	libssh2_sftp_rename_ex.3 \
-	libssh2_sftp_rewind.3 \
-	libssh2_sftp_rmdir.3 \
-	libssh2_sftp_rmdir_ex.3 \
-	libssh2_sftp_seek.3 \
-	libssh2_sftp_seek64.3 \
-	libssh2_sftp_setstat.3 \
-	libssh2_sftp_shutdown.3 \
-	libssh2_sftp_stat.3 \
-	libssh2_sftp_stat_ex.3 \
-	libssh2_sftp_statvfs.3 \
-	libssh2_sftp_symlink.3 \
-	libssh2_sftp_symlink_ex.3 \
-	libssh2_sftp_tell.3 \
-	libssh2_sftp_tell64.3 \
-	libssh2_sftp_unlink.3 \
-	libssh2_sftp_unlink_ex.3 \
-	libssh2_sftp_write.3 \
-	libssh2_trace.3 \
-	libssh2_trace_sethandler.3 \
-	libssh2_userauth_authenticated.3 \
-	libssh2_userauth_hostbased_fromfile.3 \
-	libssh2_userauth_hostbased_fromfile_ex.3 \
-	libssh2_userauth_keyboard_interactive.3 \
-	libssh2_userauth_keyboard_interactive_ex.3 \
-	libssh2_userauth_list.3 \
-	libssh2_userauth_password.3 \
-	libssh2_userauth_password_ex.3 \
-	libssh2_userauth_publickey.3 \
-	libssh2_userauth_publickey_fromfile.3 \
-	libssh2_userauth_publickey_fromfile_ex.3 \
-	libssh2_userauth_publickey_frommemory.3 \
-	libssh2_version.3
+  libssh2_agent_connect.3 \
+  libssh2_agent_disconnect.3 \
+  libssh2_agent_free.3 \
+  libssh2_agent_get_identity.3 \
+  libssh2_agent_get_identity_path.3 \
+  libssh2_agent_init.3 \
+  libssh2_agent_list_identities.3 \
+  libssh2_agent_set_identity_path.3 \
+  libssh2_agent_sign.3 \
+  libssh2_agent_userauth.3 \
+  libssh2_banner_set.3 \
+  libssh2_base64_decode.3 \
+  libssh2_channel_close.3 \
+  libssh2_channel_direct_streamlocal_ex.3 \
+  libssh2_channel_direct_tcpip.3 \
+  libssh2_channel_direct_tcpip_ex.3 \
+  libssh2_channel_eof.3 \
+  libssh2_channel_exec.3 \
+  libssh2_channel_flush.3 \
+  libssh2_channel_flush_ex.3 \
+  libssh2_channel_flush_stderr.3 \
+  libssh2_channel_forward_accept.3 \
+  libssh2_channel_forward_cancel.3 \
+  libssh2_channel_forward_listen.3 \
+  libssh2_channel_forward_listen_ex.3 \
+  libssh2_channel_free.3 \
+  libssh2_channel_get_exit_signal.3 \
+  libssh2_channel_get_exit_status.3 \
+  libssh2_channel_handle_extended_data.3 \
+  libssh2_channel_handle_extended_data2.3 \
+  libssh2_channel_ignore_extended_data.3 \
+  libssh2_channel_open_ex.3 \
+  libssh2_channel_open_session.3 \
+  libssh2_channel_process_startup.3 \
+  libssh2_channel_read.3 \
+  libssh2_channel_read_ex.3 \
+  libssh2_channel_read_stderr.3 \
+  libssh2_channel_receive_window_adjust.3 \
+  libssh2_channel_receive_window_adjust2.3 \
+  libssh2_channel_request_auth_agent.3 \
+  libssh2_channel_request_pty.3 \
+  libssh2_channel_request_pty_ex.3 \
+  libssh2_channel_request_pty_size.3 \
+  libssh2_channel_request_pty_size_ex.3 \
+  libssh2_channel_send_eof.3 \
+  libssh2_channel_set_blocking.3 \
+  libssh2_channel_setenv.3 \
+  libssh2_channel_setenv_ex.3 \
+  libssh2_channel_shell.3 \
+  libssh2_channel_signal_ex.3 \
+  libssh2_channel_subsystem.3 \
+  libssh2_channel_wait_closed.3 \
+  libssh2_channel_wait_eof.3 \
+  libssh2_channel_window_read.3 \
+  libssh2_channel_window_read_ex.3 \
+  libssh2_channel_window_write.3 \
+  libssh2_channel_window_write_ex.3 \
+  libssh2_channel_write.3 \
+  libssh2_channel_write_ex.3 \
+  libssh2_channel_write_stderr.3 \
+  libssh2_channel_x11_req.3 \
+  libssh2_channel_x11_req_ex.3 \
+  libssh2_crypto_engine.3 \
+  libssh2_exit.3 \
+  libssh2_free.3 \
+  libssh2_hostkey_hash.3 \
+  libssh2_init.3 \
+  libssh2_keepalive_config.3 \
+  libssh2_keepalive_send.3 \
+  libssh2_knownhost_add.3 \
+  libssh2_knownhost_addc.3 \
+  libssh2_knownhost_check.3 \
+  libssh2_knownhost_checkp.3 \
+  libssh2_knownhost_del.3 \
+  libssh2_knownhost_free.3 \
+  libssh2_knownhost_get.3 \
+  libssh2_knownhost_init.3 \
+  libssh2_knownhost_readfile.3 \
+  libssh2_knownhost_readline.3 \
+  libssh2_knownhost_writefile.3 \
+  libssh2_knownhost_writeline.3 \
+  libssh2_poll.3 \
+  libssh2_poll_channel_read.3 \
+  libssh2_publickey_add.3 \
+  libssh2_publickey_add_ex.3 \
+  libssh2_publickey_init.3 \
+  libssh2_publickey_list_fetch.3 \
+  libssh2_publickey_list_free.3 \
+  libssh2_publickey_remove.3 \
+  libssh2_publickey_remove_ex.3 \
+  libssh2_publickey_shutdown.3 \
+  libssh2_scp_recv.3 \
+  libssh2_scp_recv2.3 \
+  libssh2_scp_send.3 \
+  libssh2_scp_send64.3 \
+  libssh2_scp_send_ex.3 \
+  libssh2_session_abstract.3 \
+  libssh2_session_banner_get.3 \
+  libssh2_session_banner_set.3 \
+  libssh2_session_block_directions.3 \
+  libssh2_session_callback_set.3 \
+  libssh2_session_callback_set2.3 \
+  libssh2_session_disconnect.3 \
+  libssh2_session_disconnect_ex.3 \
+  libssh2_session_flag.3 \
+  libssh2_session_free.3 \
+  libssh2_session_get_blocking.3 \
+  libssh2_session_get_read_timeout.3 \
+  libssh2_session_get_timeout.3 \
+  libssh2_session_handshake.3 \
+  libssh2_session_hostkey.3 \
+  libssh2_session_init.3 \
+  libssh2_session_init_ex.3 \
+  libssh2_session_last_errno.3 \
+  libssh2_session_last_error.3 \
+  libssh2_session_method_pref.3 \
+  libssh2_session_methods.3 \
+  libssh2_session_set_blocking.3 \
+  libssh2_session_set_last_error.3 \
+  libssh2_session_set_read_timeout.3 \
+  libssh2_session_set_timeout.3 \
+  libssh2_session_startup.3 \
+  libssh2_session_supported_algs.3 \
+  libssh2_sftp_close.3 \
+  libssh2_sftp_close_handle.3 \
+  libssh2_sftp_closedir.3 \
+  libssh2_sftp_fsetstat.3 \
+  libssh2_sftp_fstat.3 \
+  libssh2_sftp_fstat_ex.3 \
+  libssh2_sftp_fstatvfs.3 \
+  libssh2_sftp_fsync.3 \
+  libssh2_sftp_get_channel.3 \
+  libssh2_sftp_init.3 \
+  libssh2_sftp_last_error.3 \
+  libssh2_sftp_lstat.3 \
+  libssh2_sftp_mkdir.3 \
+  libssh2_sftp_mkdir_ex.3 \
+  libssh2_sftp_open.3 \
+  libssh2_sftp_open_ex.3 \
+  libssh2_sftp_open_ex_r.3 \
+  libssh2_sftp_open_r.3 \
+  libssh2_sftp_opendir.3 \
+  libssh2_sftp_posix_rename.3 \
+  libssh2_sftp_posix_rename_ex.3 \
+  libssh2_sftp_read.3 \
+  libssh2_sftp_readdir.3 \
+  libssh2_sftp_readdir_ex.3 \
+  libssh2_sftp_readlink.3 \
+  libssh2_sftp_realpath.3 \
+  libssh2_sftp_rename.3 \
+  libssh2_sftp_rename_ex.3 \
+  libssh2_sftp_rewind.3 \
+  libssh2_sftp_rmdir.3 \
+  libssh2_sftp_rmdir_ex.3 \
+  libssh2_sftp_seek.3 \
+  libssh2_sftp_seek64.3 \
+  libssh2_sftp_setstat.3 \
+  libssh2_sftp_shutdown.3 \
+  libssh2_sftp_stat.3 \
+  libssh2_sftp_stat_ex.3 \
+  libssh2_sftp_statvfs.3 \
+  libssh2_sftp_symlink.3 \
+  libssh2_sftp_symlink_ex.3 \
+  libssh2_sftp_tell.3 \
+  libssh2_sftp_tell64.3 \
+  libssh2_sftp_unlink.3 \
+  libssh2_sftp_unlink_ex.3 \
+  libssh2_sftp_write.3 \
+  libssh2_sign_sk.3 \
+  libssh2_trace.3 \
+  libssh2_trace_sethandler.3 \
+  libssh2_userauth_authenticated.3 \
+  libssh2_userauth_banner.3 \
+  libssh2_userauth_hostbased_fromfile.3 \
+  libssh2_userauth_hostbased_fromfile_ex.3 \
+  libssh2_userauth_keyboard_interactive.3 \
+  libssh2_userauth_keyboard_interactive_ex.3 \
+  libssh2_userauth_list.3 \
+  libssh2_userauth_password.3 \
+  libssh2_userauth_password_ex.3 \
+  libssh2_userauth_publickey.3 \
+  libssh2_userauth_publickey_fromfile.3 \
+  libssh2_userauth_publickey_fromfile_ex.3 \
+  libssh2_userauth_publickey_frommemory.3 \
+  libssh2_userauth_publickey_sk.3 \
+  libssh2_version.3
 
 all: all-am
 
diff --git a/libssh2/docs/SECURITY.md b/libssh2/docs/SECURITY.md
index 6f442eb6..449ce534 100644
--- a/libssh2/docs/SECURITY.md
+++ b/libssh2/docs/SECURITY.md
@@ -8,7 +8,7 @@ Publishing Information
 ----------------------
 
 All known and public libssh2 vulnerabilities will be listed on [the libssh2
-web site](https://www.libssh2.org/).
+web site](https://libssh2.org/).
 
 Security vulnerabilities should not be entered in the project's public bug
 tracker unless the necessary configuration is in place to limit access to the
@@ -28,8 +28,8 @@ reference to the security nature of the commit if done prior to the public
 announcement.
 
 - The person discovering the issue, the reporter, reports the vulnerability
-  privately to `libssh2-security@haxx.se`. That's an email alias that reaches a
-  handful of selected and trusted people.
+  privately to `libssh2-security@haxx.se`. That is an email alias that reaches
+  a handful of selected and trusted people.
 
 - Messages that do not relate to the reporting or managing of an undisclosed
   security vulnerability in libssh2 are ignored and no further action is
@@ -61,10 +61,10 @@ announcement.
   contributors properly.
 
 - Request a CVE number from
-  [distros@openwall](http://oss-security.openwall.org/wiki/mailing-lists/distros)
+  [distros@openwall](https://oss-security.openwall.org/wiki/mailing-lists/distros)
   when also informing and preparing them for the upcoming public security
   vulnerability announcement - attach the advisory draft for information. Note
-  that 'distros' won't accept an embargo longer than 14 days.
+  that 'distros' will not accept an embargo longer than 14 days.
 
 - Update the "security advisory" with the CVE number.
 
@@ -90,10 +90,10 @@ LIBSSH2-SECURITY (at haxx dot se)
 --------------------------------
 
 Who is on this list? There are a couple of criteria you must meet, and then we
-might ask you to join the list or you can ask to join it. It really isn't very
+might ask you to join the list or you can ask to join it. It really is not very
 formal. We basically only require that you have a long-term presence in the
 libssh2 project and you have shown an understanding for the project and its way
-of working. You must've been around for a good while and you should have no
+of working. You must have been around for a good while and you should have no
 plans in vanishing in the near future.
 
 We do not make the list of participants public mostly because it tends to vary
diff --git a/libssh2/docs/TODO b/libssh2/docs/TODO
index cae1afa7..256a2333 100644
--- a/libssh2/docs/TODO
+++ b/libssh2/docs/TODO
@@ -1,36 +1,42 @@
 Things TODO
 ===========
 
+* Fix -Wsign-conversion warnings in src
+
 * Fix the numerous malloc+copy operations for sending data, see "Buffering
   Improvements" below for details
 
 * make sure the windowing code adapts better to slow situations so that it
-  doesn't then use as much memory as today. Possibly by an app-controllable
+  does not then use as much memory as today. Possibly by an app-controllable
   "Window mode"?
 
 * Decrease the number of mallocs. Everywhere. Will get easier once the
   buffering improvements have been done.
 
-* Use SO_NOSIGPIPE for Mac OS/BSD systems where MSG_NOSIGNAL doesn't
+* Use SO_NOSIGPIPE for Mac OS/BSD systems where MSG_NOSIGNAL does not
   exist/work
 
 * Extend the test suite to actually test lots of aspects of libssh2
 
-* Fix all compiler warnings (some can't be done without API changes)
+* Update public API to drop casts added to fix compiler warnings
 
 * Expose error messages sent by the server
 
 * select() is troublesome with libssh2 when using multiple channels over
   the same session. See "New Transport API" below for more details.
 
+* for obsolete/weak/insecure algorithms: either stop enabling them by default
+  at build-time, or delete support for them completely.
+
 At next SONAME bump
 ===================
 
 * stop using #defined macros as part of the official API. The macros should
   either be turned into real functions or discarded from the API.
 
-* fix the parts of the API where object pointers and function pointers are
-  mixed like libssh2_session_callback_set()
+* delete or deprecate libssh2_session_callback_set()
+
+* bump length arguments in callback functions to size_t/ssize_t
 
 * remove the following functions from the API/ABI
 
@@ -41,7 +47,7 @@ At next SONAME bump
   libssh2_poll()
   libssh2_poll_channel_read()
   libssh2_session_startup() (libssh2_session_handshake() is the replacement)
-  libssh2_banner_set() (libssh2_session_banner_set() is the repacement)
+  libssh2_banner_set() (libssh2_session_banner_set() is the replacement)
 
 * Rename a few function:
 
@@ -60,7 +66,7 @@ At next SONAME bump
 * remove the existing libssh2_scp_send_ex() function and rename
   libssh2_scp_send64 to become the new libssh2_scp_send instead.
 
-* remove the existing libssh2_knownhost_check() functin and rename
+* remove the existing libssh2_knownhost_check() function and rename
   libssh2_knownhost_checkp() to become the new libssh2_knownhost_check instead
 
 Buffering Improvements
@@ -119,7 +125,7 @@ I suggest we introduce two new helper functions:
    short return, nothing more should be attempted to get sent until select()
    (or equivalent) has been used on the master socket again.
 
-I haven't yet figured out a sensible API for how these functions should return
+I have not yet figured out a sensible API for how these functions should return
 that info, but if we agree on the general principles I guess we can work that
 out.
 
@@ -145,7 +151,7 @@ API
  New functions:
 
     LIBSSH2_SFTP_HANDLE *libssh2_sftp_send(SFTP_SESSION *sftp,
-                                           uint64_t filesize,
+                                           libssh2_uint64_t filesize,
                                            char *remote_path,
                                            size_t remote_path_len,
                                            long mode);
diff --git a/libssh2/docs/libssh2_agent_connect.3 b/libssh2/docs/libssh2_agent_connect.3
index 1c6ff6d9..081ec39e 100644
--- a/libssh2/docs/libssh2_agent_connect.3
+++ b/libssh2/docs/libssh2_agent_connect.3
@@ -1,18 +1,20 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_connect 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_connect 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_connect - connect to an ssh-agent
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_agent_connect(LIBSSH2_AGENT *agent);
+int
+libssh2_agent_connect(LIBSSH2_AGENT *agent);
+.fi
 .SH DESCRIPTION
 Connect to an ssh-agent running on the system.
 
 Call \fBlibssh2_agent_disconnect(3)\fP to close the connection after
-you're doing using it.
+you are doing using it.
 .SH RETURN VALUE
 Returns 0 if succeeded, or a negative value for error.
 .SH AVAILABILITY
@@ -20,4 +22,3 @@ Added in libssh2 1.2
 .SH SEE ALSO
 .BR libssh2_agent_init(3)
 .BR libssh2_agent_disconnect(3)
-
diff --git a/libssh2/docs/libssh2_agent_disconnect.3 b/libssh2/docs/libssh2_agent_disconnect.3
index f9f9ef07..136a6e19 100644
--- a/libssh2/docs/libssh2_agent_disconnect.3
+++ b/libssh2/docs/libssh2_agent_disconnect.3
@@ -1,13 +1,15 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_disconnect 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_disconnect 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_disconnect - close a connection to an ssh-agent
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_agent_disconnect(LIBSSH2_AGENT *agent);
+int
+libssh2_agent_disconnect(LIBSSH2_AGENT *agent);
+.fi
 .SH DESCRIPTION
 Close a connection to an ssh-agent.
 
diff --git a/libssh2/docs/libssh2_agent_free.3 b/libssh2/docs/libssh2_agent_free.3
index 197f87eb..1011f444 100644
--- a/libssh2/docs/libssh2_agent_free.3
+++ b/libssh2/docs/libssh2_agent_free.3
@@ -1,15 +1,17 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_free 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_free 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_free - free an ssh-agent handle
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void libssh2_agent_free(LIBSSH2_AGENT *agent);
+void
+libssh2_agent_free(LIBSSH2_AGENT *agent);
+.fi
 .SH DESCRIPTION
-Free an ssh-agent handle.  This function also frees the internal
+Free an ssh-agent handle. This function also frees the internal
 collection of public keys.
 .SH RETURN VALUE
 None.
diff --git a/libssh2/docs/libssh2_agent_get_identity.3 b/libssh2/docs/libssh2_agent_get_identity.3
index a9441656..2372e9c0 100644
--- a/libssh2/docs/libssh2_agent_get_identity.3
+++ b/libssh2/docs/libssh2_agent_get_identity.3
@@ -1,15 +1,17 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_get_identity 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_get_identity 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_get_identity - get a public key off the collection of public keys managed by ssh-agent
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
-                               struct libssh2_agent_publickey **store,
-                               struct libssh2_agent_publickey *prev);
+int
+libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
+                           struct libssh2_agent_publickey **store,
+                           struct libssh2_agent_publickey *prev);
+.fi
 .SH DESCRIPTION
 \fIlibssh2_agent_get_identity(3)\fP allows an application to iterate
 over all public keys in the collection managed by ssh-agent.
diff --git a/libssh2/docs/libssh2_agent_get_identity_path.3 b/libssh2/docs/libssh2_agent_get_identity_path.3
index 58d6dd56..703d04ab 100644
--- a/libssh2/docs/libssh2_agent_get_identity_path.3
+++ b/libssh2/docs/libssh2_agent_get_identity_path.3
@@ -1,14 +1,15 @@
-.\"
-.\" Copyright (c) 2019 by Will Cosgrove
-.\"
-.TH libssh2_agent_get_identity_path 3 "6 Mar 2019" "libssh2 1.9" "libssh2 manual"
+.\" Copyright (C) Will Cosgrove
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_get_identity_path 3 "6 Mar 2019" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_get_identity_path - gets the custom ssh-agent socket path
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 const char *
 libssh2_agent_get_identity_path(LIBSSH2_AGENT *agent);
+.fi
 .SH DESCRIPTION
 Returns the custom agent identity socket path if set using libssh2_agent_set_identity_path()
 
@@ -19,4 +20,3 @@ Added in libssh2 1.9
 .SH SEE ALSO
 .BR libssh2_agent_init(3)
 .BR libssh2_agent_set_identity_path(3)
-
diff --git a/libssh2/docs/libssh2_agent_init.3 b/libssh2/docs/libssh2_agent_init.3
index 26e891e4..c3653617 100644
--- a/libssh2/docs/libssh2_agent_init.3
+++ b/libssh2/docs/libssh2_agent_init.3
@@ -1,20 +1,22 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_init 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_init 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_init - init an ssh-agent handle
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-LIBSSH2_AGENT *libssh2_agent_init(LIBSSH2_SESSION *session);
+LIBSSH2_AGENT *
+libssh2_agent_init(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Init an ssh-agent handle. Returns the handle to an internal
-representation of an ssh-agent connection.  After the successful
+representation of an ssh-agent connection. After the successful
 initialization, an application can call \fBlibssh2_agent_connect(3)\fP
 to connect to a running ssh-agent.
 
-Call \fBlibssh2_agent_free(3)\fP to free the handle again after you're
+Call \fBlibssh2_agent_free(3)\fP to free the handle again after you are
 doing using it.
 .SH RETURN VALUE
 Returns a handle pointer or NULL if something went wrong. The returned handle
diff --git a/libssh2/docs/libssh2_agent_list_identities.3 b/libssh2/docs/libssh2_agent_list_identities.3
index e1e4b545..bac2c735 100644
--- a/libssh2/docs/libssh2_agent_list_identities.3
+++ b/libssh2/docs/libssh2_agent_list_identities.3
@@ -1,16 +1,18 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_list_identities 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_list_identities 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_list_identities - request an ssh-agent to list of public keys.
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
+int
+libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
+.fi
 .SH DESCRIPTION
 Request an ssh-agent to list of public keys, and stores them in the
-internal collection of the handle.  Call
+internal collection of the handle. Call
 \fIlibssh2_agent_get_identity(3)\fP to get a public key off the
 collection.
 
@@ -21,4 +23,3 @@ Added in libssh2 1.2
 .SH SEE ALSO
 .BR libssh2_agent_connect(3)
 .BR libssh2_agent_get_identity(3)
-
diff --git a/libssh2/docs/libssh2_agent_set_identity_path.3 b/libssh2/docs/libssh2_agent_set_identity_path.3
index 73e1266d..5a1a237d 100644
--- a/libssh2/docs/libssh2_agent_set_identity_path.3
+++ b/libssh2/docs/libssh2_agent_set_identity_path.3
@@ -1,14 +1,15 @@
-.\"
-.\" Copyright (c) 2019 by Will Cosgrove
-.\"
-.TH libssh2_agent_set_identity_path 3 "6 Mar 2019" "libssh2 1.9" "libssh2 manual"
+.\" Copyright (C) Will Cosgrove
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_set_identity_path 3 "6 Mar 2019" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_set_identity_path - set an ssh-agent socket path on disk
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 void
 libssh2_agent_set_identity_path(LIBSSH2_AGENT *agent, const char *path);
+.fi
 .SH DESCRIPTION
 Allows a custom agent identity socket path instead of the default SSH_AUTH_SOCK env value
 
@@ -19,4 +20,3 @@ Added in libssh2 1.9
 .SH SEE ALSO
 .BR libssh2_agent_init(3)
 .BR libssh2_agent_get_identity_path(3)
-
diff --git a/libssh2/docs/libssh2_agent_sign.3 b/libssh2/docs/libssh2_agent_sign.3
new file mode 100644
index 00000000..c4ba95b3
--- /dev/null
+++ b/libssh2/docs/libssh2_agent_sign.3
@@ -0,0 +1,54 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_sign 3 "1 Oct 2022" "libssh2" "libssh2"
+.SH NAME
+libssh2_agent_sign - sign data, with the help of ssh-agent
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_agent_sign(LIBSSH2_AGENT *agent,
+                   struct libssh2_agent_publickey *identity,
+                   unsigned char **sig,
+                   size_t *s_len,
+                   const unsigned char *data,
+                   size_t d_len,
+                   const char *method,
+                   unsigned int method_len);
+.fi
+.SH DESCRIPTION
+\fIagent\fP - ssh-agent handle as returned by
+.BR libssh2_agent_init(3)
+
+\fIidentity\fP - Public key to authenticate with, as returned by
+.BR libssh2_agent_get_identity(3)
+
+\fIsig\fP - A pointer to a buffer in which to place the signature. The caller
+is responsible for freeing the signature with LIBSSH2_FREE.
+
+\fIs_len\fP - A pointer to the length of the sig parameter.
+
+\fIdata\fP - The data to sign.
+
+\fId_len\fP - The length of the data parameter.
+
+\fImethod\fP - A buffer indicating the signing method. This should match the
+string at the start of identity->blob.
+
+\fImethod_len\fP - The length of the method parameter.
+
+Sign data using an ssh-agent. This function can be used in a callback
+registered with libssh2_session_callback_set2(3) using
+LIBSSH2_CALLBACK_AUTHAGENT_SIGN to sign an authentication challenge from a
+server. However, the client is responsible for implementing the code that calls
+this callback in response to a SSH2_AGENTC_SIGN_REQUEST message.
+.SH RETURN VALUE
+Returns 0 if succeeded, or a negative value for error.
+.SH AVAILABILITY
+Added in libssh2 1.11.0
+.SH SEE ALSO
+.BR libssh2_agent_init(3)
+.BR libssh2_agent_get_identity(3)
+.BR libssh2_agent_userauth(3)
+.BR libssh2_session_callback_set2(3)
diff --git a/libssh2/docs/libssh2_agent_userauth.3 b/libssh2/docs/libssh2_agent_userauth.3
index 3c956fec..82a344c0 100644
--- a/libssh2/docs/libssh2_agent_userauth.3
+++ b/libssh2/docs/libssh2_agent_userauth.3
@@ -1,22 +1,24 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_userauth 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daiki Ueno
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_agent_userauth 3 "23 Dec 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_agent_userauth - authenticate a session with a public key, with the help of ssh-agent
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_agent_userauth(LIBSSH2_AGENT *agent,
-                           const char *username,
-                           struct libssh2_agent_publickey *identity);
+int
+libssh2_agent_userauth(LIBSSH2_AGENT *agent,
+                       const char *username,
+                       struct libssh2_agent_publickey *identity);
+.fi
 .SH DESCRIPTION
-\fIagent\fP - ssh-agent handle as returned by 
+\fIagent\fP - ssh-agent handle as returned by
 .BR libssh2_agent_init(3)
 
 \fIusername\fP - Remote user name to authenticate as.
 
-\fIidentity\fP - Public key to authenticate with, as returned by 
+\fIidentity\fP - Public key to authenticate with, as returned by
 .BR libssh2_agent_get_identity(3)
 
 Attempt public key authentication with the help of ssh-agent.
@@ -27,3 +29,4 @@ Added in libssh2 1.2
 .SH SEE ALSO
 .BR libssh2_agent_init(3)
 .BR libssh2_agent_get_identity(3)
+.BR libssh2_agent_sign(3)
diff --git a/libssh2/docs/libssh2_banner_set.3 b/libssh2/docs/libssh2_banner_set.3
index 2baa121e..5f687e5a 100644
--- a/libssh2/docs/libssh2_banner_set.3
+++ b/libssh2/docs/libssh2_banner_set.3
@@ -1,32 +1,36 @@
-.TH libssh2_banner_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_banner_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_banner_set - set the SSH protocol banner for the local client
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_banner_set(LIBSSH2_SESSION *session, const char *banner);
-
+.fi
 .SH DESCRIPTION
-This function is \fBDEPRECATED\fP. Use \fIlibssh2_session_banner_set(3)\fP
-instead!
+This function is \fBDEPRECATED\fP in 1.4.0. Use the
+\fIlibssh2_session_banner_set(3)\fP function instead!
 
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIbanner\fP - A pointer to a user defined banner
 
-Set the banner that will be sent to the remote host when the SSH session is 
-started with 
+Set the banner that will be sent to the remote host when the SSH session is
+started with
 .BR libssh2_session_handshake(3)
-  This is optional; a banner corresponding to the protocol and libssh2 version will be sent by default.
+This is optional; a banner corresponding to the protocol and libssh2 version
+will be sent by default.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH AVAILABILITY
 Marked as deprecated since 1.4.0
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 .SH SEE ALSO
 .BR libssh2_session_handshake(3)
diff --git a/libssh2/docs/libssh2_base64_decode.3 b/libssh2/docs/libssh2_base64_decode.3
index 932f03a8..e46db823 100644
--- a/libssh2/docs/libssh2_base64_decode.3
+++ b/libssh2/docs/libssh2_base64_decode.3
@@ -1,15 +1,20 @@
-.TH libssh2_base64_decode 3 "23 Dec 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_base64_decode 3 "23 Dec 2008" "libssh2 1.0" "libssh2"
 .SH NAME
 libssh2_base64_decode - decode a base64 encoded string
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
-                          unsigned int *dest_len, const char *src,
-                          unsigned int src_len);
+int
+libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
+                      unsigned int *dest_len, const char *src,
+                      unsigned int src_len);
+.fi
 .SH DESCRIPTION
 This function is deemed DEPRECATED and will be removed from libssh2 in a
-future version. Don't use it!
+future version. Do not use it!
 
 Decode a base64 chunk and store it into a newly allocated buffer. 'dest_len'
 will be set to hold the length of the returned buffer that '*dest' will point
@@ -19,7 +24,7 @@ The returned buffer is allocated by this function, but it is not clear how to
 free that memory!
 .SH BUGS
 The memory that *dest points to is allocated by the malloc function libssh2
-uses, but there's no way for an application to free this data in a safe and
+uses, but there is no way for an application to free this data in a safe and
 reliable way!
 .SH RETURN VALUE
 0 if successful, \-1 if any error occurred.
diff --git a/libssh2/docs/libssh2_channel_close.3 b/libssh2/docs/libssh2_channel_close.3
index 2fe0a0d4..fd9d0001 100644
--- a/libssh2/docs/libssh2_channel_close.3
+++ b/libssh2/docs/libssh2_channel_close.3
@@ -1,29 +1,29 @@
-.TH libssh2_channel_close 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_close 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_close - close a channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_close(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - active channel stream to set closed status on.
 
-Close an active data channel. In practice this means sending an SSH_MSG_CLOSE 
-packet to the remote host which serves as instruction that no further data 
-will be sent to it. The remote host may still send data back until it sends 
-its own close message in response. To wait for the remote end to close its 
-connection as well, follow this command with 
+Close an active data channel. In practice this means sending an SSH_MSG_CLOSE
+packet to the remote host which serves as instruction that no further data
+will be sent to it. The remote host may still send data back until it sends
+its own close message in response. To wait for the remote end to close its
+connection as well, follow this command with
 .BR libssh2_channel_wait_closed(3)
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
diff --git a/libssh2/docs/libssh2_channel_direct_streamlocal_ex.3 b/libssh2/docs/libssh2_channel_direct_streamlocal_ex.3
new file mode 100644
index 00000000..c2c3d5ca
--- /dev/null
+++ b/libssh2/docs/libssh2_channel_direct_streamlocal_ex.3
@@ -0,0 +1,34 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_direct_streamlocal_ex 3 "10 Apr 2023" "libssh2 1.11.0" "libssh2"
+.SH NAME
+libssh2_channel_direct_streamlocal_ex - Tunnel a UNIX socket connection through an SSH session
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+LIBSSH2_CHANNEL *
+libssh2_channel_direct_streamlocal_ex(LIBSSH2_SESSION *session,
+                                      const char *socket_path,
+                                      const char *shost, int sport);
+.fi
+.SH DESCRIPTION
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIsocket_path\fP - UNIX socket to connect to using the SSH host as a proxy.
+
+\fIshost\fP - Host to tell the SSH server the connection originated on.
+
+\fIsport\fP - Port to tell the SSH server the connection originated from.
+
+Tunnel a UNIX socket connection through the SSH transport via the remote host to
+a third party. Communication from the client to the SSH server remains
+encrypted, communication from the server to the 3rd party host travels
+in cleartext.
+.SH RETURN VALUE
+Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
+.SH ERRORS
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
+.SH SEE ALSO
+.BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_channel_direct_tcpip.3 b/libssh2/docs/libssh2_channel_direct_tcpip.3
index 742769df..02033fc0 100644
--- a/libssh2/docs/libssh2_channel_direct_tcpip.3
+++ b/libssh2/docs/libssh2_channel_direct_tcpip.3
@@ -1,12 +1,16 @@
-.TH libssh2_channel_direct_tcpip 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_direct_tcpip 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_direct_tcpip - convenience macro for \fIlibssh2_channel_direct_tcpip_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int port);
-
+libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session,
+                             const char *host, int port);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_direct_tcpip_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_direct_tcpip_ex.3 b/libssh2/docs/libssh2_channel_direct_tcpip_ex.3
index 481c55ce..02e8f84b 100644
--- a/libssh2/docs/libssh2_channel_direct_tcpip_ex.3
+++ b/libssh2/docs/libssh2_channel_direct_tcpip_ex.3
@@ -1,17 +1,23 @@
-.TH libssh2_channel_direct_tcpip_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_direct_tcpip_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_direct_tcpip_ex - Tunnel a TCP connection through an SSH session
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-LIBSSH2_CHANNEL * 
-libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host, int port, const char *shost, int sport);
-
-LIBSSH2_CHANNEL * 
-libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int port);
+LIBSSH2_CHANNEL *
+libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session,
+                                const char *host, int port,
+                                const char *shost, int sport);
 
+LIBSSH2_CHANNEL *
+libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session,
+                             const char *host, int port);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIhost\fP - Third party host to connect to using the SSH host as a proxy.
@@ -22,14 +28,13 @@ libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int por
 
 \fIsport\fP - Port to tell the SSH server the connection originated from.
 
-Tunnel a TCP/IP connection through the SSH transport via the remote host to 
-a third party. Communication from the client to the SSH server remains 
-encrypted, communication from the server to the 3rd party host travels 
+Tunnel a TCP/IP connection through the SSH transport via the remote host to
+a third party. Communication from the client to the SSH server remains
+encrypted, communication from the server to the 3rd party host travels
 in cleartext.
-
 .SH RETURN VALUE
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_channel_eof.3 b/libssh2/docs/libssh2_channel_eof.3
index ed4a074b..9d9fd745 100644
--- a/libssh2/docs/libssh2_channel_eof.3
+++ b/libssh2/docs/libssh2_channel_eof.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_eof - check a channel's EOF status
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - active channel stream to set closed status on.
 
diff --git a/libssh2/docs/libssh2_channel_exec.3 b/libssh2/docs/libssh2_channel_exec.3
index 3ab069d7..08644d5e 100644
--- a/libssh2/docs/libssh2_channel_exec.3
+++ b/libssh2/docs/libssh2_channel_exec.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_exec 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_exec 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_exec - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);
-
+int
+libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_process_startup(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_flush.3 b/libssh2/docs/libssh2_channel_flush.3
index b449945b..79a7750b 100644
--- a/libssh2/docs/libssh2_channel_flush.3
+++ b/libssh2/docs/libssh2_channel_flush.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_flush 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_flush 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_flush - convenience macro for \fIlibssh2_channel_flush_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
-
+int
+libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_flush_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_flush_ex.3 b/libssh2/docs/libssh2_channel_flush_ex.3
index 1885176b..4a445ba4 100644
--- a/libssh2/docs/libssh2_channel_flush_ex.3
+++ b/libssh2/docs/libssh2_channel_flush_ex.3
@@ -1,32 +1,34 @@
-.TH libssh2_channel_flush_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_flush_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_flush_ex - flush a channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid);
 
-int 
+int
 libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
 
-int 
+int
 libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Active channel stream to flush.
 
-\fIstreamid\fP - Specific substream number to flush. Groups of substreams may 
+\fIstreamid\fP - Specific substream number to flush. Groups of substreams may
 be flushed by passing on of the following Constants.
 .br
 \fBLIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA\fP: Flush all extended data substreams
 .br
 \fBLIBSSH2_CHANNEL_FLUSH_ALL\fP: Flush all substreams
 
-Flush the read buffer for a given channel instance. Individual substreams may 
+Flush the read buffer for a given channel instance. Individual substreams may
 be flushed by number or using one of the provided macros.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+Return the number of bytes flushed or negative on failure.
+It returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
diff --git a/libssh2/docs/libssh2_channel_flush_stderr.3 b/libssh2/docs/libssh2_channel_flush_stderr.3
index 156bb06f..6cd8ade6 100644
--- a/libssh2/docs/libssh2_channel_flush_stderr.3
+++ b/libssh2/docs/libssh2_channel_flush_stderr.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_flush_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_flush_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_flush_stderr - convenience macro for \fIlibssh2_channel_flush_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
-
+int
+libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_flush_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_forward_accept.3 b/libssh2/docs/libssh2_channel_forward_accept.3
index 176ac1cd..e6e57e21 100644
--- a/libssh2/docs/libssh2_channel_forward_accept.3
+++ b/libssh2/docs/libssh2_channel_forward_accept.3
@@ -1,12 +1,15 @@
-.TH libssh2_channel_forward_accept 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_forward_accept 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_forward_accept - accept a queued connection
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
 libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);
-
+.fi
 .SH DESCRIPTION
 \fIlistener\fP is a forwarding listener instance as returned by
 \fBlibssh2_channel_forward_listen_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_forward_cancel.3 b/libssh2/docs/libssh2_channel_forward_cancel.3
index 16f826fb..0e11f518 100644
--- a/libssh2/docs/libssh2_channel_forward_cancel.3
+++ b/libssh2/docs/libssh2_channel_forward_cancel.3
@@ -1,27 +1,28 @@
-.TH libssh2_channel_forward_cancel 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_forward_cancel 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_forward_cancel - cancel a forwarded TCP port
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
-
+.fi
 .SH DESCRIPTION
-\fIlistener\fP - Forwarding listener instance as returned by 
+\fIlistener\fP - Forwarding listener instance as returned by
 .BR libssh2_channel_forward_listen_ex(3)
 
-Instruct the remote host to stop listening for new connections on a previously requested host/port.
-
+Instruct the remote host to stop listening for new connections on a previously
+requested host/port.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
 .SH SEE ALSO
 .BR libssh2_channel_forward_listen_ex(3)
diff --git a/libssh2/docs/libssh2_channel_forward_listen.3 b/libssh2/docs/libssh2_channel_forward_listen.3
index 6cb54e73..ab1739cf 100644
--- a/libssh2/docs/libssh2_channel_forward_listen.3
+++ b/libssh2/docs/libssh2_channel_forward_listen.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_forward_listen 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_forward_listen 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_forward_listen - convenience macro for \fIlibssh2_channel_forward_listen_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
-
+int
+libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_forward_listen_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_forward_listen_ex.3 b/libssh2/docs/libssh2_channel_forward_listen_ex.3
index a358f6ce..c33115e6 100644
--- a/libssh2/docs/libssh2_channel_forward_listen_ex.3
+++ b/libssh2/docs/libssh2_channel_forward_listen_ex.3
@@ -1,21 +1,26 @@
-.TH libssh2_channel_forward_listen_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_forward_listen_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_forward_listen_ex - listen to inbound connections
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-LIBSSH2_LISTENER * 
-libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, char *host, int port, int *bound_port, int queue_maxsize);
+LIBSSH2_LISTENER *
+libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session,
+                                  char *host, int port,
+                                  int *bound_port, int queue_maxsize);
 
-LIBSSH2_LISTENER * 
+LIBSSH2_LISTENER *
 libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
-
+.fi
 .SH DESCRIPTION
 Instruct the remote SSH server to begin listening for inbound TCP/IP
 connections. New connections will be queued by the library until accepted by
 \fIlibssh2_channel_forward_accept(3)\fP.
 
-\fIsession\fP - instance as returned by libssh2_session_init(). 
+\fIsession\fP - instance as returned by libssh2_session_init().
 
 \fIhost\fP - specific address to bind to on the remote host. Binding to
 0.0.0.0 (default when NULL is passed) will bind to all available addresses.
diff --git a/libssh2/docs/libssh2_channel_free.3 b/libssh2/docs/libssh2_channel_free.3
index fc76f5a8..66fddc06 100644
--- a/libssh2/docs/libssh2_channel_free.3
+++ b/libssh2/docs/libssh2_channel_free.3
@@ -1,25 +1,26 @@
-.TH libssh2_channel_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_free - free all resources associated with a channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_free(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Channel stream to free.
 
-Release all resources associated with a channel stream. If the channel has 
-not yet been closed with 
+Release all resources associated with a channel stream. If the channel has
+not yet been closed with
 .BR libssh2_channel_close(3)
-, it will be called automatically so that the remote end may know that it 
+, it will be called automatically so that the remote end may know that it
 can safely free its own resources.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_channel_close(3)
diff --git a/libssh2/docs/libssh2_channel_get_exit_signal.3 b/libssh2/docs/libssh2_channel_get_exit_signal.3
index 138e7c72..e1ce01fd 100644
--- a/libssh2/docs/libssh2_channel_get_exit_signal.3
+++ b/libssh2/docs/libssh2_channel_get_exit_signal.3
@@ -1,22 +1,28 @@
-.TH libssh2_channel_get_exit_signal 3 "4 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_get_exit_signal 3 "4 Oct 2010" "libssh2 1.2.8" "libssh2"
 .SH NAME
 libssh2_channel_get_exit_signal - get the remote exit signal
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
-libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel, char **exitsignal, size_t *exitsignal_len, char **errmsg, size_t *errmsg_len, char **langtag, size_t *langtag_len);
-
+int
+libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel,
+                                char **exitsignal, size_t *exitsignal_len,
+                                char **errmsg, size_t *errmsg_len,
+                                char **langtag, size_t *langtag_len);
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Closed channel stream to retrieve exit signal from.
 
 \fIexitsignal\fP - If not NULL, is populated by reference with the exit signal
 (without leading "SIG"). Note that the string is stored in a newly allocated
 buffer. If the remote program exited cleanly, the referenced string pointer
-will be set to NULL. 
+will be set to NULL.
 
 \fIexitsignal_len\fP - If not NULL, is populated by reference with the length
-of exitsignal. 
+of exitsignal.
 
 \fIerrmsg\fP - If not NULL, is populated by reference with the error message
 (if provided by remote server, if not it will be set to NULL). Note that the
@@ -24,11 +30,10 @@ string is stored in a newly allocated buffer.
 
 \fIerrmsg_len\fP - If not NULL, is populated by reference with the length of errmsg.
 
-\fIlangtag\fP - If not NULL, is populated by reference with the language tag 
+\fIlangtag\fP - If not NULL, is populated by reference with the language tag
 (if provided by remote server, if not it will be set to NULL). Note that the
 string is stored in a newly allocated buffer.
 
 \fIlangtag_len\fP - If not NULL, is populated by reference with the length of langtag.
-
 .SH RETURN VALUE
 Numeric error code corresponding to the the Error Code constants.
diff --git a/libssh2/docs/libssh2_channel_get_exit_status.3 b/libssh2/docs/libssh2_channel_get_exit_status.3
index 4a8c9e2f..7171b657 100644
--- a/libssh2/docs/libssh2_channel_get_exit_status.3
+++ b/libssh2/docs/libssh2_channel_get_exit_status.3
@@ -1,18 +1,20 @@
-.TH libssh2_channel_get_exit_status 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_get_exit_status 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_get_exit_status - get the remote exit code
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel)
-
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Closed channel stream to retrieve exit status from.
 
-Returns the exit code raised by the process running on the remote host at 
-the other end of the named channel. Note that the exit status may not be 
+Returns the exit code raised by the process running on the remote host at
+the other end of the named channel. Note that the exit status may not be
 available if the remote end has not yet set its status to closed.
-
 .SH RETURN VALUE
 Returns 0 on failure, otherwise the \fIExit Status\fP reported by remote host
diff --git a/libssh2/docs/libssh2_channel_handle_extended_data.3 b/libssh2/docs/libssh2_channel_handle_extended_data.3
index 8ab24883..ff494383 100644
--- a/libssh2/docs/libssh2_channel_handle_extended_data.3
+++ b/libssh2/docs/libssh2_channel_handle_extended_data.3
@@ -1,21 +1,25 @@
-.TH libssh2_channel_handle_extended_data 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_handle_extended_data 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_handle_extended_data - set extended data handling mode
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void 
-libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);
-
+void
+libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
+                                     int ignore_mode);
+.fi
 .SH DESCRIPTION
-This function is deprecated. Use the
+This function is \fBDEPRECATED\fP in 1.1.0. Use the
 \fIlibssh2_channel_handle_extended_data2(3)\fP function instead!
 
 \fIchannel\fP - Active channel stream to change extended data handling on.
 
 \fIignore_mode\fP - One of the three LIBSSH2_CHANNEL_EXTENDED_DATA_* Constants.
 .br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual 
+\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual
 reading
 .br
 \fBLIBSSH2_CHANNEL_EXTENDED_DATA_MERGE\fP: Treat extended data and ordinary
@@ -23,7 +27,7 @@ data the same. Merge all substreams such that calls to
 \fIlibssh2_channel_read(3)\fP will pull from all substreams on a
 first-in/first-out basis.
 .br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it 
+\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it
 arrives.
 
 Change how a channel deals with extended data packets. By default all extended
diff --git a/libssh2/docs/libssh2_channel_handle_extended_data2.3 b/libssh2/docs/libssh2_channel_handle_extended_data2.3
index 8910d8ce..ac970fcb 100644
--- a/libssh2/docs/libssh2_channel_handle_extended_data2.3
+++ b/libssh2/docs/libssh2_channel_handle_extended_data2.3
@@ -1,35 +1,37 @@
-.TH libssh2_channel_handle_extended_data2 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_handle_extended_data2 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_handle_extended_data2 - set extended data handling mode
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
-libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel, int ignore_mode);
-
+int
+libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
+                                      int ignore_mode);
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Active channel stream to change extended data handling on.
 
 \fIignore_mode\fP - One of the three LIBSSH2_CHANNEL_EXTENDED_DATA_* Constants.
 .br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual 
+\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual
 reading
 .br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_MERGE\fP: Treat extended data and ordinary 
-data the same. Merge all substreams such that calls to 
+\fBLIBSSH2_CHANNEL_EXTENDED_DATA_MERGE\fP: Treat extended data and ordinary
+data the same. Merge all substreams such that calls to
 .BR libssh2_channel_read(3)
 will pull from all substreams on a first-in/first-out basis.
 .br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it 
+\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it
 arrives.
 
-Change how a channel deals with extended data packets. By default all 
-extended data is queued until read by 
+Change how a channel deals with extended data packets. By default all
+extended data is queued until read by
 .BR libssh2_channel_read_ex(3)
-
 .SH RETURN VALUE
 Return 0 on success or LIBSSH2_ERROR_EAGAIN when it would otherwise block.
-
 .SH SEE ALSO
 .BR libssh2_channel_handle_extended_data(3)
 .BR libssh2_channel_read_ex(3)
diff --git a/libssh2/docs/libssh2_channel_ignore_extended_data.3 b/libssh2/docs/libssh2_channel_ignore_extended_data.3
index 342c6208..ff8f4900 100644
--- a/libssh2/docs/libssh2_channel_ignore_extended_data.3
+++ b/libssh2/docs/libssh2_channel_ignore_extended_data.3
@@ -1,13 +1,18 @@
-.TH libssh2_channel_ignore_extended_data 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_ignore_extended_data 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_ignore_extended_data - convenience macro for \fIlibssh2_channel_handle_extended_data(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_channel_ignore_extended_data(arguments)
-
+void
+libssh2_channel_ignore_extended_data(LIBSSH2_CHANNEL *channel,
+                                     int ignore_mode);
+.fi
 .SH DESCRIPTION
-This function is deprecated. Use the
+This function is \fBDEPRECATED\fP in 0.3.0. Use the
 \fIlibssh2_channel_handle_extended_data2(3)\fP function instead!
 
 This is a macro defined in a public libssh2 header file that is using the
diff --git a/libssh2/docs/libssh2_channel_open_ex.3 b/libssh2/docs/libssh2_channel_open_ex.3
index 7dec2945..66fd8022 100644
--- a/libssh2/docs/libssh2_channel_open_ex.3
+++ b/libssh2/docs/libssh2_channel_open_ex.3
@@ -1,54 +1,58 @@
-.TH libssh2_channel_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_open_ex - establish a generic session channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
-libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type, unsigned int channel_type_len, unsigned int window_size, unsigned int packet_size, const char *message, unsigned int message_len);
+libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type,
+                        unsigned int channel_type_len,
+                        unsigned int window_size,
+                        unsigned int packet_size,
+                        const char *message, unsigned int message_len);
 
 LIBSSH2_CHANNEL *
 libssh2_channel_open_session(session);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
-\fIchannel_type\fP - Channel type to open. Typically one of session, 
-direct-tcpip, or tcpip-forward. The SSH2 protocol allowed for additional 
+\fIchannel_type\fP - Channel type to open. Typically one of session,
+direct-tcpip, or tcpip-forward. The SSH2 protocol allowed for additional
 types including local, custom channel types.
 
 \fIchannel_type_len\fP - Length of channel_type
 
-\fIwindow_size\fP - Maximum amount of unacknowledged data remote host is 
+\fIwindow_size\fP - Maximum amount of unacknowledged data remote host is
 allowed to send before receiving an SSH_MSG_CHANNEL_WINDOW_ADJUST packet.
 
-\fIpacket_size\fP - Maximum number of bytes remote host is allowed to send 
+\fIpacket_size\fP - Maximum number of bytes remote host is allowed to send
 in a single SSH_MSG_CHANNEL_DATA or SSG_MSG_CHANNEL_EXTENDED_DATA packet.
 
 \fImessage\fP - Additional data as required by the selected channel_type.
 
 \fImessage_len\fP - Length of message parameter.
 
-Allocate a new channel for exchanging data with the server. This method is 
-typically called through its macroized form: 
+Allocate a new channel for exchanging data with the server. This method is
+typically called through its macroized form:
 .BR libssh2_channel_open_session(3)
-or via 
+or via
 .BR libssh2_channel_direct_tcpip(3)
 or
 .BR libssh2_channel_forward_listen(3)
-
 .SH RETURN VALUE
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_CHANNEL_FAILURE\fP - 
+\fILIBSSH2_ERROR_CHANNEL_FAILURE\fP -
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-
 .SH SEE ALSO
 Add related functions
diff --git a/libssh2/docs/libssh2_channel_open_session.3 b/libssh2/docs/libssh2_channel_open_session.3
index 4306f4cc..89039ea3 100644
--- a/libssh2/docs/libssh2_channel_open_session.3
+++ b/libssh2/docs/libssh2_channel_open_session.3
@@ -1,12 +1,15 @@
-.TH libssh2_channel_open_session 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_open_session 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_open_session - convenience macro for \fIlibssh2_channel_open_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
 libssh2_channel_open_session(LIBSSH2_SESSION *session);
-
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_open_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_process_startup.3 b/libssh2/docs/libssh2_channel_process_startup.3
index 7c279820..5f827db1 100644
--- a/libssh2/docs/libssh2_channel_process_startup.3
+++ b/libssh2/docs/libssh2_channel_process_startup.3
@@ -1,19 +1,23 @@
-.TH libssh2_channel_process_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_process_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_process_startup - request a shell on a channel
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                    const char *request,
-                                    unsigned int request_len,
-                                    const char *message,
-                                    unsigned int message_len);
+int
+libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
+                                const char *request,
+                                unsigned int request_len,
+                                const char *message,
+                                unsigned int message_len);
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - Active session channel instance.
 
-\fIrequest\fP - Type of process to startup. The SSH2 protocol currently 
+\fIrequest\fP - Type of process to startup. The SSH2 protocol currently
 defines shell, exec, and subsystem as standard process services.
 
 \fIrequest_len\fP - Length of request parameter.
@@ -22,17 +26,17 @@ defines shell, exec, and subsystem as standard process services.
 
 \fImessage_len\fP - Length of message parameter.
 
-Initiate a request on a session type channel such as returned by 
+Initiate a request on a session type channel such as returned by
 .BR libssh2_channel_open_ex(3)
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
+\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP -
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
diff --git a/libssh2/docs/libssh2_channel_read.3 b/libssh2/docs/libssh2_channel_read.3
index f1857167..0644e185 100644
--- a/libssh2/docs/libssh2_channel_read.3
+++ b/libssh2/docs/libssh2_channel_read.3
@@ -1,11 +1,16 @@
-.TH libssh2_channel_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_read - convenience macro for \fIlibssh2_channel_read_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-ssize_t libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
+ssize_t
+libssh2_channel_read(LIBSSH2_CHANNEL *channel,
+                     char *buf, size_t buflen);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_read_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_read_ex.3 b/libssh2/docs/libssh2_channel_read_ex.3
index 83d7c3e0..200fe800 100644
--- a/libssh2/docs/libssh2_channel_read_ex.3
+++ b/libssh2/docs/libssh2_channel_read_ex.3
@@ -1,27 +1,33 @@
-.TH libssh2_channel_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_read_ex - read data from a channel stream
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 ssize_t
-libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);
+libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
+                        char *buf, size_t buflen);
 
 ssize_t
-libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
+libssh2_channel_read(LIBSSH2_CHANNEL *channel,
+                     char *buf, size_t buflen);
 
 ssize_t
-libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
+libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel,
+                            char *buf, size_t buflen);
+.fi
 .SH DESCRIPTION
 Attempt to read data from an active channel stream. All channel streams have
 one standard I/O substream (stream_id == 0), and may have up to 2^32 extended
 data streams as identified by the selected \fIstream_id\fP. The SSH2 protocol
 currently defines a stream ID of 1 to be the stderr substream.
 
-\fIchannel\fP - active channel stream to read from. 
+\fIchannel\fP - active channel stream to read from.
 
-\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR) 
+\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR)
 
 \fIbuf\fP - pointer to storage buffer to read data into
 
@@ -32,7 +38,7 @@ macros.
 .SH RETURN VALUE
 Actual number of bytes read or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 
 Note that a return value of zero (0) can in fact be a legitimate value and
 only signals that no payload data was read. It is not an error.
@@ -40,6 +46,5 @@ only signals that no payload data was read. It is not an error.
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
 \fILIBSSH2_ERROR_CHANNEL_CLOSED\fP - The channel has been closed.
-
 .SH SEE ALSO
 .BR libssh2_poll_channel_read(3)
diff --git a/libssh2/docs/libssh2_channel_read_stderr.3 b/libssh2/docs/libssh2_channel_read_stderr.3
index 9324410b..25b5ba72 100644
--- a/libssh2/docs/libssh2_channel_read_stderr.3
+++ b/libssh2/docs/libssh2_channel_read_stderr.3
@@ -1,11 +1,16 @@
-.TH libssh2_channel_read_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_read_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_read_stderr - convenience macro for \fIlibssh2_channel_read_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-ssize_t libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
+ssize_t
+libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel,
+                            char *buf, size_t buflen);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_read_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_receive_window_adjust.3 b/libssh2/docs/libssh2_channel_receive_window_adjust.3
index a7288118..af0df2e2 100644
--- a/libssh2/docs/libssh2_channel_receive_window_adjust.3
+++ b/libssh2/docs/libssh2_channel_receive_window_adjust.3
@@ -1,17 +1,20 @@
-.TH libssh2_channel_receive_window_adjust 3 "15 Mar 2009" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_receive_window_adjust 3 "15 Mar 2009" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_receive_window_adjust - adjust the channel window
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 unsigned long
 libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
                                       unsigned long adjustment,
                                       unsigned char force);
-
+.fi
 .SH DESCRIPTION
-This function is deprecated in 1.1. Use
-\fIlibssh2_channel_receive_window_adjust2(3)\fP!
+This function is \fBDEPRECATED\fP in 1.1.0. Use the
+\fIlibssh2_channel_receive_window_adjust2(3)\fP function instead!
 
 Adjust the receive window for a channel by adjustment bytes. If the amount to
 be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
diff --git a/libssh2/docs/libssh2_channel_receive_window_adjust2.3 b/libssh2/docs/libssh2_channel_receive_window_adjust2.3
index dd2fcc1e..730889af 100644
--- a/libssh2/docs/libssh2_channel_receive_window_adjust2.3
+++ b/libssh2/docs/libssh2_channel_receive_window_adjust2.3
@@ -1,7 +1,10 @@
-.TH libssh2_channel_receive_window_adjust2 3 "26 Mar 2009" "libssh2 1.1" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_receive_window_adjust2 3 "26 Mar 2009" "libssh2 1.1" "libssh2"
 .SH NAME
 libssh2_channel_receive_window_adjust2 - adjust the channel window
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
@@ -9,7 +12,7 @@ libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL * channel,
                                        unsigned long adjustment,
                                        unsigned char force,
                                        unsigned int *window);
-
+.fi
 .SH DESCRIPTION
 Adjust the receive window for a channel by adjustment bytes. If the amount to
 be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
diff --git a/libssh2/docs/libssh2_channel_request_auth_agent.3 b/libssh2/docs/libssh2_channel_request_auth_agent.3
new file mode 100644
index 00000000..8f9ab62b
--- /dev/null
+++ b/libssh2/docs/libssh2_channel_request_auth_agent.3
@@ -0,0 +1,24 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_request_auth_agent 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
+.SH NAME
+libssh2_channel_request_auth_agent - request agent forwarding for a session
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel);
+.fi
+.SH DESCRIPTION
+Request that agent forwarding be enabled for this SSH session. This sends the
+request over this specific channel, which causes the agent listener to be
+started on the remote side upon success. This agent listener will then run
+for the duration of the SSH session.
+
+\fIchannel\fP - Previously opened channel instance such as returned by
+.BR libssh2_channel_open_ex(3)
+.SH RETURN VALUE
+Return 0 on success or negative on failure. It returns
+LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
diff --git a/libssh2/docs/libssh2_channel_request_pty.3 b/libssh2/docs/libssh2_channel_request_pty.3
index f57352b2..7a3b75ea 100644
--- a/libssh2/docs/libssh2_channel_request_pty.3
+++ b/libssh2/docs/libssh2_channel_request_pty.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_request_pty 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_request_pty 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_request_pty - convenience macro for \fIlibssh2_channel_request_pty_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_request_pty(LIBSSH2_SESSION *session, const char *term);
-
+int
+libssh2_channel_request_pty(LIBSSH2_SESSION *session, const char *term);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_request_pty_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_request_pty_ex.3 b/libssh2/docs/libssh2_channel_request_pty_ex.3
index 35b5840a..30ad750c 100644
--- a/libssh2/docs/libssh2_channel_request_pty_ex.3
+++ b/libssh2/docs/libssh2_channel_request_pty_ex.3
@@ -1,17 +1,24 @@
-.TH libssh2_channel_request_pty_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_request_pty_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_request_pty_ex - short function description
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
-libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term, unsigned int term_len, const char *modes, unsigned int modes_len, int width, int height, int width_px, int height_px);
-
-int 
-libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, char *term);
+int
+libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term,
+                               unsigned int term_len,
+                               const char *modes, unsigned int modes_len,
+                               int width, int height,
+                               int width_px, int height_px);
 
+int
+libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, const char *term);
+.fi
 .SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
+\fIchannel\fP - Previously opened channel instance such as returned by
 .BR libssh2_channel_open_ex(3)
 
 \fIterm\fP - Terminal emulation (e.g. vt102, ansi, etc...)
@@ -30,18 +37,18 @@ libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, char *term);
 
 \fIheight_px\fP - Height of pty in pixels
 
-Request a PTY on an established channel. Note that this does not make sense 
-for all channel types and may be ignored by the server despite returning 
+Request a PTY on an established channel. Note that this does not make sense
+for all channel types and may be ignored by the server despite returning
 success.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
+\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP -
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
diff --git a/libssh2/docs/libssh2_channel_request_pty_size.3 b/libssh2/docs/libssh2_channel_request_pty_size.3
index 4b0c12df..7de31d61 100644
--- a/libssh2/docs/libssh2_channel_request_pty_size.3
+++ b/libssh2/docs/libssh2_channel_request_pty_size.3
@@ -1,11 +1,16 @@
-.TH libssh2_channel_request_pty_size 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_request_pty_size 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_request_pty_size - convenience macro for \fIlibssh2_channel_request_pty_size_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel, int width, int height);
-
+int
+libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel,
+                                 int width, int height);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_request_pty_size_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_request_pty_size_ex.3 b/libssh2/docs/libssh2_channel_request_pty_size_ex.3
index b3cd6197..54daf4f5 100644
--- a/libssh2/docs/libssh2_channel_request_pty_size_ex.3
+++ b/libssh2/docs/libssh2_channel_request_pty_size_ex.3
@@ -1,12 +1,12 @@
-.TH libssh2_channel_request_pty_size_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_request_pty_size_ex 3 "1 Jun 2007" "libssh2" "libssh2"
 .SH NAME
 libssh2_channel_request_pty_size_ex - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_channel_send_eof.3 b/libssh2/docs/libssh2_channel_send_eof.3
index 0e5975ac..d4bf52e5 100644
--- a/libssh2/docs/libssh2_channel_send_eof.3
+++ b/libssh2/docs/libssh2_channel_send_eof.3
@@ -1,24 +1,24 @@
-.TH libssh2_channel_send_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_send_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_send_eof - send EOF to remote server
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
-Tell the remote host that no further data will be sent on the specified 
+Tell the remote host that no further data will be sent on the specified
 channel. Processes typically interpret this as a closed stdin descriptor.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
 .SH SEE ALSO
 .BR libssh2_channel_wait_eof(3)
 .BR libssh2_channel_eof(3)
diff --git a/libssh2/docs/libssh2_channel_set_blocking.3 b/libssh2/docs/libssh2_channel_set_blocking.3
index 55ee4ff0..07a1049a 100644
--- a/libssh2/docs/libssh2_channel_set_blocking.3
+++ b/libssh2/docs/libssh2_channel_set_blocking.3
@@ -1,18 +1,22 @@
-.TH libssh2_channel_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_set_blocking - set or clear blocking mode on channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void 
+void
 libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);
+.fi
 .SH DESCRIPTION
 \fIchannel\fP - channel stream to set or clean blocking status on.
 
 \fIblocking\fP - Set to a non-zero value to make the channel block, or zero to
 make it non-blocking.
 
-Currently this is just a short cut call to 
+Currently this is a short cut call to
 .BR libssh2_session_set_blocking(3)
 and therefore will affect the session and all channels.
 .SH RETURN VALUE
diff --git a/libssh2/docs/libssh2_channel_setenv.3 b/libssh2/docs/libssh2_channel_setenv.3
index b30d4710..0fa097b5 100644
--- a/libssh2/docs/libssh2_channel_setenv.3
+++ b/libssh2/docs/libssh2_channel_setenv.3
@@ -1,11 +1,16 @@
-.TH libssh2_channel_setenv 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_setenv 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_setenv - convenience macro for \fIlibssh2_channel_setenv_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_setenv(LIBSSH2_CHANNEL *channel, const char *varname, const char *value);
-
+int
+libssh2_channel_setenv(LIBSSH2_CHANNEL *channel,
+                       const char *varname, const char *value);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_setenv_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_setenv_ex.3 b/libssh2/docs/libssh2_channel_setenv_ex.3
index 4a5fd3e9..692d9f8e 100644
--- a/libssh2/docs/libssh2_channel_setenv_ex.3
+++ b/libssh2/docs/libssh2_channel_setenv_ex.3
@@ -1,20 +1,26 @@
-.TH libssh2_channel_setenv_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_setenv_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_setenv_ex - set an environment variable on the channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
-libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varname, unsigned int varname_len, const char *value, unsigned int value_len);
+libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel,
+                          char *varname, unsigned int varname_len,
+                          const char *value, unsigned int value_len);
 
 int
-libssh2_channel_setenv(LIBSSH2_CHANNEL *channel, char *varname, const char *value);
-
+libssh2_channel_setenv(LIBSSH2_CHANNEL *channel,
+                       char *varname, const char *value);
+.fi
 .SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
+\fIchannel\fP - Previously opened channel instance such as returned by
 .BR libssh2_channel_open_ex(3)
 
-\fIvarname\fP - Name of environment variable to set on the remote 
+\fIvarname\fP - Name of environment variable to set on the remote
 channel instance.
 
 \fIvarname_len\fP - Length of passed varname parameter.
@@ -27,15 +33,15 @@ Set an environment variable in the remote channel's process space. Note that
 this does not make sense for all channel types and may be ignored by the
 server despite returning success.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
+\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP -
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
diff --git a/libssh2/docs/libssh2_channel_shell.3 b/libssh2/docs/libssh2_channel_shell.3
index 4ba6e69d..70ba6d45 100644
--- a/libssh2/docs/libssh2_channel_shell.3
+++ b/libssh2/docs/libssh2_channel_shell.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_shell 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_shell 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_shell - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_shell(LIBSSH2_CHANNEL *channel);
-
+int
+libssh2_channel_shell(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_process_startup(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_signal_ex.3 b/libssh2/docs/libssh2_channel_signal_ex.3
new file mode 100644
index 00000000..aadea41b
--- /dev/null
+++ b/libssh2/docs/libssh2_channel_signal_ex.3
@@ -0,0 +1,32 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_signal_ex 3 "20 Apr 2023" "libssh2 1.11.0" "libssh2"
+.SH NAME
+libssh2_channel_signal_ex -- Send a signal to process previously opened on channel.
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_channel_signal_ex(LIBSSH2_CHANNEL *channel,
+                          const char *signame,
+                          size_t signame_len)
+.fi
+.SH DESCRIPTION
+A signal can be delivered to the remote process/service. Some servers or
+systems may not implement signals, in which case they will probably ignore this
+message.
+
+\fIchannel\fP - Previously opened channel instance such as returned by
+.BR libssh2_channel_open_ex(3)
+
+\fIsigname\fP - The signal name is the same as the signal name constant, without the leading "SIG".
+
+\fIsigname_len\fP - Length of passed signal name parameter.
+
+There is also a macro \fIlibssh2_channel_signal(channel, signame)\fP that supplies the strlen of the signame.
+.SH RETURN VALUE
+Normal channel error codes.
+LIBSSH2_ERROR_EAGAIN when it would block.
+.SH SEE ALSO
+.BR libssh2_channel_get_exit_signal(3)
diff --git a/libssh2/docs/libssh2_channel_subsystem.3 b/libssh2/docs/libssh2_channel_subsystem.3
index dd29f2c9..31d0b333 100644
--- a/libssh2/docs/libssh2_channel_subsystem.3
+++ b/libssh2/docs/libssh2_channel_subsystem.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_subsystem 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_subsystem 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_subsystem - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);
-
+int
+libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_process_startup(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_wait_closed.3 b/libssh2/docs/libssh2_channel_wait_closed.3
index 44717368..7ef058cf 100644
--- a/libssh2/docs/libssh2_channel_wait_closed.3
+++ b/libssh2/docs/libssh2_channel_wait_closed.3
@@ -1,12 +1,15 @@
-.TH libssh2_channel_wait_closed 3 "29 Nov 2007" "libssh2 0.19" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_wait_closed 3 "29 Nov 2007" "libssh2 0.19" "libssh2"
 .SH NAME
 libssh2_channel_wait_closed - wait for the remote to close the channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
 Enter a temporary blocking state until the remote host closes the named
 channel. Typically sent after \fIlibssh2_channel_close(3)\fP in order to
@@ -15,7 +18,7 @@ examine the exit status.
 .SH RETURN VALUE
 Return 0 on success or negative on failure. It returns LIBSSH2_ERROR_EAGAIN
 when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
+number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_channel_send_eof(3)
 .BR libssh2_channel_eof(3)
diff --git a/libssh2/docs/libssh2_channel_wait_eof.3 b/libssh2/docs/libssh2_channel_wait_eof.3
index 8a3dc475..dcd1f5d5 100644
--- a/libssh2/docs/libssh2_channel_wait_eof.3
+++ b/libssh2/docs/libssh2_channel_wait_eof.3
@@ -1,19 +1,22 @@
-.TH libssh2_channel_wait_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_wait_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_wait_eof - wait for the remote to reply to an EOF request
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);
-
+.fi
 .SH DESCRIPTION
 Wait for the remote end to send EOF.
 
 .SH RETURN VALUE
 Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_channel_send_eof(3)
 .BR libssh2_channel_eof(3)
diff --git a/libssh2/docs/libssh2_channel_window_read.3 b/libssh2/docs/libssh2_channel_window_read.3
index 70938d30..f6218cb6 100644
--- a/libssh2/docs/libssh2_channel_window_read.3
+++ b/libssh2/docs/libssh2_channel_window_read.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_window_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_window_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_window_read - convenience macro for \fIlibssh2_channel_window_read_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-unsigned long libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);
-
+unsigned long
+libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_window_read_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_window_read_ex.3 b/libssh2/docs/libssh2_channel_window_read_ex.3
index b5280960..3e1eebce 100644
--- a/libssh2/docs/libssh2_channel_window_read_ex.3
+++ b/libssh2/docs/libssh2_channel_window_read_ex.3
@@ -1,13 +1,17 @@
-.TH libssh2_channel_window_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_window_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_window_read_ex - Check the status of the read window
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 unsigned long
 libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
                                unsigned long *read_avail,
                                unsigned long *window_size_initial)
+.fi
 .SH DESCRIPTION
 Check the status of the read window. Returns the number of bytes which the
 remote end may send without overflowing the window limit read_avail (if
@@ -18,7 +22,6 @@ window_size_initial as defined by the channel_open request
 The number of bytes which the remote end may send without overflowing the
 window limit
 .SH ERRORS
-
 .SH SEE ALSO
 .BR libssh2_channel_receive_window_adjust(3),
 .BR libssh2_channel_window_write_ex(3)
diff --git a/libssh2/docs/libssh2_channel_window_write.3 b/libssh2/docs/libssh2_channel_window_write.3
index d8c39930..aa20d02d 100644
--- a/libssh2/docs/libssh2_channel_window_write.3
+++ b/libssh2/docs/libssh2_channel_window_write.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_window_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_window_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_window_write - convenience macro for \fIlibssh2_channel_window_write_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-unsigned long libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);
-
+unsigned long
+libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_window_write_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_window_write_ex.3 b/libssh2/docs/libssh2_channel_window_write_ex.3
index d34cd408..7e8ff5fe 100644
--- a/libssh2/docs/libssh2_channel_window_write_ex.3
+++ b/libssh2/docs/libssh2_channel_window_write_ex.3
@@ -1,12 +1,16 @@
-.TH libssh2_channel_window_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_window_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_window_write_ex - Check the status of the write window
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 unsigned long
 libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
                                 unsigned long *window_size_initial)
+.fi
 .SH DESCRIPTION
 Check the status of the write window Returns the number of bytes which may be
 safely written on the channel without blocking. 'window_size_initial' (if
@@ -15,7 +19,6 @@ the channel_open request
 .SH RETURN VALUE
 Number of bytes which may be safely written on the channel without blocking.
 .SH ERRORS
-
 .SH SEE ALSO
 .BR libssh2_channel_window_read_ex(3),
 .BR libssh2_channel_receive_window_adjust(3)
diff --git a/libssh2/docs/libssh2_channel_write.3 b/libssh2/docs/libssh2_channel_write.3
index b9de747f..6ced72d9 100644
--- a/libssh2/docs/libssh2_channel_write.3
+++ b/libssh2/docs/libssh2_channel_write.3
@@ -1,12 +1,16 @@
-.TH libssh2_channel_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_write - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-ssize_t libssh2_channel_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
-
+ssize_t
+libssh2_channel_write(LIBSSH2_CHANNEL *channel,
+                      const char *buf, size_t buflen);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_write_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_write_ex.3 b/libssh2/docs/libssh2_channel_write_ex.3
index 4ef7df17..934a79c2 100644
--- a/libssh2/docs/libssh2_channel_write_ex.3
+++ b/libssh2/docs/libssh2_channel_write_ex.3
@@ -1,22 +1,26 @@
-.TH libssh2_channel_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_write_ex - write data to a channel stream blocking
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
-                                 int stream_id, char *buf,
-                                 size_t buflen);
+ssize_t
+libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
+                         int stream_id, char *buf,
+                         size_t buflen);
+.fi
 .SH DESCRIPTION
 Write data to a channel stream. All channel streams have one standard I/O
 substream (stream_id == 0), and may have up to 2^32 extended data streams as
 identified by the selected \fIstream_id\fP. The SSH2 protocol currently
 defines a stream ID of 1 to be the stderr substream.
 
-\fIchannel\fP - active channel stream to write to. 
+\fIchannel\fP - active channel stream to write to.
 
-\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR) 
+\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR)
 
 \fIbuf\fP - pointer to buffer to write
 
@@ -32,7 +36,7 @@ least 32K of data to this function.
 .SH RETURN VALUE
 Actual number of bytes written or negative on failure.
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
 \fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
@@ -41,6 +45,11 @@ LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
 \fILIBSSH2_ERROR_CHANNEL_CLOSED\fP - The channel has been closed.
 
 \fILIBSSH2_ERROR_CHANNEL_EOF_SENT\fP - The channel has been requested to be
+
+\fILIBSSH2_ERROR_BAD_USE\fP - This can be returned if you ignored a previous
+return for LIBSSH2_ERROR_EAGAIN and rather than sending the original buffer with
+the original size, you sent a new buffer with a different size.
+
 closed.
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
diff --git a/libssh2/docs/libssh2_channel_write_stderr.3 b/libssh2/docs/libssh2_channel_write_stderr.3
index ac4d3874..832a5c26 100644
--- a/libssh2/docs/libssh2_channel_write_stderr.3
+++ b/libssh2/docs/libssh2_channel_write_stderr.3
@@ -1,12 +1,16 @@
-.TH libssh2_channel_write_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_write_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_write_stderr - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-ssize_t libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
-
+ssize_t
+libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel,
+                             const char *buf, size_t buflen);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_write_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_x11_req.3 b/libssh2/docs/libssh2_channel_x11_req.3
index c558e408..15300a22 100644
--- a/libssh2/docs/libssh2_channel_x11_req.3
+++ b/libssh2/docs/libssh2_channel_x11_req.3
@@ -1,11 +1,15 @@
-.TH libssh2_channel_x11_req 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_x11_req 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_channel_x11_req - convenience macro for \fIlibssh2_channel_x11_req_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
-
+int
+libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_x11_req_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_channel_x11_req_ex.3 b/libssh2/docs/libssh2_channel_x11_req_ex.3
index e0121bd1..a87e40ee 100644
--- a/libssh2/docs/libssh2_channel_x11_req_ex.3
+++ b/libssh2/docs/libssh2_channel_x11_req_ex.3
@@ -1,17 +1,23 @@
-.TH libssh2_channel_x11_req_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_channel_x11_req_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_channel_x11_req_ex - request an X11 forwarding channel
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
-libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number);
+libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection,
+                           const char *auth_proto, const char *auth_cookie,
+                           int screen_number);
 
 int
-libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
-
+libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel,
+                        int screen_number);
+.fi
 .SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
+\fIchannel\fP - Previously opened channel instance such as returned by
 .BR libssh2_channel_open_ex(3)
 
 \fIsingle_connection\fP - non-zero to only forward a single connection.
@@ -22,23 +28,20 @@ libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
 
 \fIscreen_number\fP - the XLL screen to forward
 
-Request an X11 forwarding on \fIchannel\fP. To use X11 forwarding, 
-.BR libssh2_session_callback_set(3)
+Request an X11 forwarding on \fIchannel\fP. To use X11 forwarding,
+.BR libssh2_session_callback_set2(3)
 must first be called to set \fBLIBSSH2_CALLBACK_X11\fP. This callback will be
 invoked when the remote host accepts the X11 forwarding.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
-
+\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP -
 .SH SEE ALSO
 .BR libssh2_channel_open_ex(3)
-.BR libssh2_session_callback_set(3)
+.BR libssh2_session_callback_set2(3)
diff --git a/libssh2/docs/libssh2_crypto_engine.3 b/libssh2/docs/libssh2_crypto_engine.3
new file mode 100644
index 00000000..591a84ac
--- /dev/null
+++ b/libssh2/docs/libssh2_crypto_engine.3
@@ -0,0 +1,16 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_crypto_engine 3 "22 Nov 2021" "libssh2" "libssh2"
+.SH NAME
+libssh2_crypto_engine - retrieve used crypto engine
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+libssh2_crypto_engine_t
+libssh2_crypto_engine(void);
+.fi
+.SH DESCRIPTION
+Returns currently used crypto engine, as en enum value.
+.SH AVAILABILITY
+Added in libssh2 1.11
diff --git a/libssh2/docs/libssh2_exit.3 b/libssh2/docs/libssh2_exit.3
index 2e7afd73..cc5f158f 100644
--- a/libssh2/docs/libssh2_exit.3
+++ b/libssh2/docs/libssh2_exit.3
@@ -1,13 +1,17 @@
-.TH libssh2_exit 3 "19 Mar 2010" "libssh2 1.2.5" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_exit 3 "19 Mar 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_exit - global library deinitialization
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 void
 libssh2_exit(void);
+.fi
 .SH DESCRIPTION
-Exit the libssh2 functions and free's all memory used internal.
+Exit the libssh2 functions and frees all memory used internal.
 .SH AVAILABILITY
 Added in libssh2 1.2.5
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_free.3 b/libssh2/docs/libssh2_free.3
index 30176d58..3aeed4af 100644
--- a/libssh2/docs/libssh2_free.3
+++ b/libssh2/docs/libssh2_free.3
@@ -1,15 +1,19 @@
-.TH libssh2_exit 3 "13 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_free 3 "13 Oct 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_free - deallocate libssh2 memory
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 void
 libssh2_free(LIBSSH2_SESSION *session, void *ptr);
+.fi
 .SH DESCRIPTION
-Deallocate memory allocated by earlier call to libssh2 functions.  It
-uses the memory allocation callbacks provided by the application, if
-any.  Otherwise, this will just call free().
+Deallocate memory allocated by earlier call to libssh2 functions. It
+uses the memory allocation callbacks provided by the application, if any.
+Otherwise, this will call free().
 
 This function is mostly useful under Windows when libssh2 is linked to
 one run-time library and the application to another.
diff --git a/libssh2/docs/libssh2_hostkey_hash.3 b/libssh2/docs/libssh2_hostkey_hash.3
index d57fc0dd..a33edac0 100644
--- a/libssh2/docs/libssh2_hostkey_hash.3
+++ b/libssh2/docs/libssh2_hostkey_hash.3
@@ -1,21 +1,24 @@
-.TH libssh2_hostkey_hash 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_hostkey_hash 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_hostkey_hash - return a hash of the remote host's key
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 const char *
 libssh2_hostkey_hash(LIBSSH2_SESSION *session, int hash_type);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
-\fIhash_type\fP - One of: \fBLIBSSH2_HOSTKEY_HASH_MD5\fP, 
+\fIhash_type\fP - One of: \fBLIBSSH2_HOSTKEY_HASH_MD5\fP,
 \fBLIBSSH2_HOSTKEY_HASH_SHA1\fP or \fBLIBSSH2_HOSTKEY_HASH_SHA256\fP.
 
-Returns the computed digest of the remote system's hostkey. The length of 
-the returned string is hash_type specific (e.g. 16 bytes for MD5, 
+Returns the computed digest of the remote system's hostkey. The length of
+the returned string is hash_type specific (e.g. 16 bytes for MD5,
 20 bytes for SHA1, 32 bytes for SHA256).
 .SH RETURN VALUE
 Computed hostkey hash value, or NULL if the information is not available
diff --git a/libssh2/docs/libssh2_init.3 b/libssh2/docs/libssh2_init.3
index 416a7893..5631d7f7 100644
--- a/libssh2/docs/libssh2_init.3
+++ b/libssh2/docs/libssh2_init.3
@@ -1,16 +1,20 @@
-.TH libssh2_init 3 "19 Mar 2010" "libssh2 1.2.5" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_init 3 "19 Mar 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_init - global library initialization
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 #define LIBSSH2_INIT_NO_CRYPTO 0x0001
 
 int
 libssh2_init(int flags);
+.fi
 .SH DESCRIPTION
-Initialize the libssh2 functions.  This typically initialize the
-crypto library.  It uses a global state, and is not thread safe -- you
+Initialize the libssh2 functions. This typically initialize the
+crypto library. It uses a global state, and is not thread safe -- you
 must make sure this function is not called concurrently.
 .SH RETURN VALUE
 Returns 0 if succeeded, or a negative value for error.
diff --git a/libssh2/docs/libssh2_keepalive_config.3 b/libssh2/docs/libssh2_keepalive_config.3
index 15e3ab96..c78053e9 100644
--- a/libssh2/docs/libssh2_keepalive_config.3
+++ b/libssh2/docs/libssh2_keepalive_config.3
@@ -1,19 +1,22 @@
-.TH libssh2_keepalive_config 3 "12 Apr 2011" "libssh2 1.2.5" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_keepalive_config 3 "12 Apr 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_keepalive_config - short function description
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
+#include <libssh2.h>
 
-void libssh2_keepalive_config(LIBSSH2_SESSION *session,
-                              int want_reply,
-                              unsigned interval);
+void
+libssh2_keepalive_config(LIBSSH2_SESSION *session,
+                         int want_reply,
+                         unsigned int interval);
 .fi
 .SH DESCRIPTION
 Set how often keepalive messages should be sent. \fBwant_reply\fP indicates
 whether the keepalive messages should request a response from the server.
 \fBinterval\fP is number of seconds that can pass without any I/O, use 0 (the
-default) to disable keepalives.  To avoid some busy-loop corner-cases, if you
+default) to disable keepalives. To avoid some busy-loop corner-cases, if you
 specify an interval of 1 it will be treated as 2.
 
 Note that non-blocking applications are responsible for sending the keepalive
@@ -24,4 +27,3 @@ Nothing
 Added in libssh2 1.2.5
 .SH SEE ALSO
 .BR libssh2_keepalive_send(3)
-
diff --git a/libssh2/docs/libssh2_keepalive_send.3 b/libssh2/docs/libssh2_keepalive_send.3
index f4f19d1a..b660d461 100644
--- a/libssh2/docs/libssh2_keepalive_send.3
+++ b/libssh2/docs/libssh2_keepalive_send.3
@@ -1,14 +1,18 @@
-.TH libssh2_keepalive_send 3 "13 Apr 2011" "libssh2 1.2.5" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_keepalive_send 3 "13 Apr 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_keepalive_send - short function description
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
+#include <libssh2.h>
 
-int libssh2_keepalive_send(LIBSSH2_SESSION *session,
-                           int *seconds_to_next);
+int
+libssh2_keepalive_send(LIBSSH2_SESSION *session,
+                       int *seconds_to_next);
+.fi
 .SH DESCRIPTION
-Send a keepalive message if needed.  \fBseconds_to_next\fP indicates how many
+Send a keepalive message if needed. \fBseconds_to_next\fP indicates how many
 seconds you can sleep after this call before you need to call it again.
 .SH RETURN VALUE
 Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on I/O errors.
diff --git a/libssh2/docs/libssh2_knownhost_add.3 b/libssh2/docs/libssh2_knownhost_add.3
index 00a69e0d..c881e36f 100644
--- a/libssh2/docs/libssh2_knownhost_add.3
+++ b/libssh2/docs/libssh2_knownhost_add.3
@@ -1,18 +1,19 @@
-
-.\" Copyright (c) 2009, 2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_add 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_add 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_add - add a known host
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-int libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
-                          char *host, char *salt,
-                          char *key, size_t keylen,
-                          int typemask,
-                          struct libssh2_knownhost **store);
+int
+libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
+                      char *host, char *salt,
+                      char *key, size_t keylen,
+                      int typemask,
+                      struct libssh2_knownhost **store);
+.fi
 .SH DESCRIPTION
 We discourage use of this function as of libssh2 1.2.5. Instead we strongly
 urge users to use \fIlibssh2_knownhost_addc(3)\fP instead, which as a more
@@ -48,10 +49,10 @@ LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
 
 The key is using one of these algorithms:
 LIBSSH2_KNOWNHOST_KEY_RSA1, LIBSSH2_KNOWNHOST_KEY_SSHRSA or
-LIBSSH2_KNOWNHOST_KEY_SSHDSS.
+LIBSSH2_KNOWNHOST_KEY_SSHDSS (deprecated).
 
 \fIstore\fP should point to a pointer that gets filled in to point to the
-known host data after the addition. NULL can be passed if you don't care about
+known host data after the addition. NULL can be passed if you do not care about
 this pointer.
 .SH RETURN VALUE
 Returns a regular libssh2 error code, where negative values are error codes
diff --git a/libssh2/docs/libssh2_knownhost_addc.3 b/libssh2/docs/libssh2_knownhost_addc.3
index 73e262a4..5a1b8c56 100644
--- a/libssh2/docs/libssh2_knownhost_addc.3
+++ b/libssh2/docs/libssh2_knownhost_addc.3
@@ -1,18 +1,20 @@
-
-.\" Copyright (c) 2009, 2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_add 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_addc 3 "28 May 2009" "libssh2 1.2" "libssh2"
 .SH NAME
-libssh2_knownhost_add - add a known host
+libssh2_knownhost_addc - add a known host
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
-                           char *host, char *salt,
-                           char *key, size_t keylen,
-                           const char *comment, size_t commentlen,
-                           int typemask,
-                           struct libssh2_knownhost **store);
+int
+libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
+                       char *host, char *salt,
+                       char *key, size_t keylen,
+                       const char *comment, size_t commentlen,
+                       int typemask,
+                       struct libssh2_knownhost **store);
+.fi
 .SH DESCRIPTION
 Adds a known host to the collection of known hosts identified by the 'hosts'
 handle.
@@ -52,10 +54,10 @@ LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
 
 The key is using one of these algorithms:
 LIBSSH2_KNOWNHOST_KEY_RSA1, LIBSSH2_KNOWNHOST_KEY_SSHRSA or
-LIBSSH2_KNOWNHOST_KEY_SSHDSS.
+LIBSSH2_KNOWNHOST_KEY_SSHDSS (deprecated).
 
 \fIstore\fP should point to a pointer that gets filled in to point to the
-known host data after the addition. NULL can be passed if you don't care about
+known host data after the addition. NULL can be passed if you do not care about
 this pointer.
 .SH RETURN VALUE
 Returns a regular libssh2 error code, where negative values are error codes
diff --git a/libssh2/docs/libssh2_knownhost_check.3 b/libssh2/docs/libssh2_knownhost_check.3
index 889392cb..37d5c230 100644
--- a/libssh2/docs/libssh2_knownhost_check.3
+++ b/libssh2/docs/libssh2_knownhost_check.3
@@ -1,17 +1,19 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_check 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_check 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_check - check a host+key against the list of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
-                            const char *host,
-                            const char *key, size_t keylen,
-                            int typemask,
-                            struct libssh2_knownhost **knownhost);
+int
+libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
+                        const char *host,
+                        const char *key, size_t keylen,
+                        int typemask,
+                        struct libssh2_knownhost **knownhost);
+.fi
 .SH DESCRIPTION
 Checks a host and its associated key against the collection of known hosts,
 and returns info back about the (partially) matched entry.
@@ -47,7 +49,7 @@ LIBSSH2_KNOWNHOST_CHECK_NOTFOUND - no host match was found
 
 LIBSSH2_KNOWNHOST_CHECK_MATCH - hosts and keys match.
 
-LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys didn't match!
+LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys did not match!
 .SH AVAILABILITY
 Added in libssh2 1.2
 .SH EXAMPLE
diff --git a/libssh2/docs/libssh2_knownhost_checkp.3 b/libssh2/docs/libssh2_knownhost_checkp.3
index 434ed7b3..de603909 100644
--- a/libssh2/docs/libssh2_knownhost_checkp.3
+++ b/libssh2/docs/libssh2_knownhost_checkp.3
@@ -1,17 +1,19 @@
-.\"
-.\" Copyright (c) 2009-2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_check 3 "1 May 2010" "libssh2 1.2.6" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_checkp 3 "1 May 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_checkp - check a host+key against the list of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
-                             const char *host, int port,
-                             const char *key, size_t keylen,
-                             int typemask,
-                             struct libssh2_knownhost **knownhost);
+int
+libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
+                         const char *host, int port,
+                         const char *key, size_t keylen,
+                         int typemask,
+                         struct libssh2_knownhost **knownhost);
+.fi
 .SH DESCRIPTION
 Checks a host and its associated key against the collection of known hosts,
 and returns info back about the (partially) matched entry.
@@ -52,7 +54,7 @@ LIBSSH2_KNOWNHOST_CHECK_NOTFOUND - no host match was found
 
 LIBSSH2_KNOWNHOST_CHECK_MATCH - hosts and keys match.
 
-LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys didn't match!
+LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys did not match!
 .SH AVAILABILITY
 Added in libssh2 1.2.6
 .SH EXAMPLE
diff --git a/libssh2/docs/libssh2_knownhost_del.3 b/libssh2/docs/libssh2_knownhost_del.3
index 75a8eaf5..9efc4c67 100644
--- a/libssh2/docs/libssh2_knownhost_del.3
+++ b/libssh2/docs/libssh2_knownhost_del.3
@@ -1,14 +1,16 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_del 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_del 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_del - delete a known host entry
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
-                          struct libssh2_knownhost *entry);
+int
+libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
+                      struct libssh2_knownhost *entry);
+.fi
 .SH DESCRIPTION
 Delete a known host entry from the collection of known hosts.
 
diff --git a/libssh2/docs/libssh2_knownhost_free.3 b/libssh2/docs/libssh2_knownhost_free.3
index 8d8bcc29..f9e17344 100644
--- a/libssh2/docs/libssh2_knownhost_free.3
+++ b/libssh2/docs/libssh2_knownhost_free.3
@@ -1,13 +1,15 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_free 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_free 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_free - free a collection of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts);
+void
+libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts);
+.fi
 .SH DESCRIPTION
 Free a collection of known hosts.
 .SH RETURN VALUE
diff --git a/libssh2/docs/libssh2_knownhost_get.3 b/libssh2/docs/libssh2_knownhost_get.3
index d725f8dc..318a7fc4 100644
--- a/libssh2/docs/libssh2_knownhost_get.3
+++ b/libssh2/docs/libssh2_knownhost_get.3
@@ -1,15 +1,17 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_get 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_get 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_get - get a known host off the collection of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
-                          struct libssh2_knownhost **store,
-                          struct libssh2_knownhost *prev):
+int
+libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
+                      struct libssh2_knownhost **store,
+                      struct libssh2_knownhost *prev):
+.fi
 .SH DESCRIPTION
 \fIlibssh2_knownhost_get(3)\fP allows an application to iterate over all known
 hosts in the collection.
diff --git a/libssh2/docs/libssh2_knownhost_init.3 b/libssh2/docs/libssh2_knownhost_init.3
index 145f10ca..95b7c62e 100644
--- a/libssh2/docs/libssh2_knownhost_init.3
+++ b/libssh2/docs/libssh2_knownhost_init.3
@@ -1,18 +1,20 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_init 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_init 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_init - init a collection of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-LIBSSH2_KNOWNHOSTS *libssh2_knownhost_init(LIBSSH2_SESSION *session);
+LIBSSH2_KNOWNHOSTS *
+libssh2_knownhost_init(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Init a collection of known hosts for this session. Returns the handle to an
 internal representation of a known host collection.
 
-Call \fBlibssh2_knownhost_free(3)\fP to free the collection again after you're
+Call \fBlibssh2_knownhost_free(3)\fP to free the collection again after you are
 doing using it.
 .SH RETURN VALUE
 Returns a handle pointer or NULL if something went wrong. The returned handle
diff --git a/libssh2/docs/libssh2_knownhost_readfile.3 b/libssh2/docs/libssh2_knownhost_readfile.3
index 68aa9402..c5a46970 100644
--- a/libssh2/docs/libssh2_knownhost_readfile.3
+++ b/libssh2/docs/libssh2_knownhost_readfile.3
@@ -1,14 +1,16 @@
-.\"
-.\" Copyright (c) 2009-2011 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_readfile 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_readfile 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_readfile - parse a file of known hosts
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
-                               const char *filename, int type);
+int
+libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
+                           const char *filename, int type);
+.fi
 .SH DESCRIPTION
 Reads a collection of known hosts from a specified file and adds them to the
 collection of known hosts.
diff --git a/libssh2/docs/libssh2_knownhost_readline.3 b/libssh2/docs/libssh2_knownhost_readline.3
index a5881c44..24184942 100644
--- a/libssh2/docs/libssh2_knownhost_readline.3
+++ b/libssh2/docs/libssh2_knownhost_readline.3
@@ -1,14 +1,16 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_readline 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_readline 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_readline - read a known host line
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
-                               const char *line, size_t len, int type):
+int
+libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
+                           const char *line, size_t len, int type):
+.fi
 .SH DESCRIPTION
 Tell libssh2 to read a buffer as it if is a line from a known hosts file.
 
diff --git a/libssh2/docs/libssh2_knownhost_writefile.3 b/libssh2/docs/libssh2_knownhost_writefile.3
index 48335a01..2e2b0a2f 100644
--- a/libssh2/docs/libssh2_knownhost_writefile.3
+++ b/libssh2/docs/libssh2_knownhost_writefile.3
@@ -1,14 +1,16 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_writefile 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_writefile 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_writefile - write a collection of known hosts to a file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
-                                const char *filename, int type);
+int
+libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
+                            const char *filename, int type);
+.fi
 .SH DESCRIPTION
 Writes all the known hosts to the specified file using the specified file
 format.
@@ -26,4 +28,3 @@ Added in libssh2 1.2
 .SH SEE ALSO
 .BR libssh2_knownhost_readfile(3)
 .BR libssh2_knownhost_add(3)
-
diff --git a/libssh2/docs/libssh2_knownhost_writeline.3 b/libssh2/docs/libssh2_knownhost_writeline.3
index c014a6a3..03023f72 100644
--- a/libssh2/docs/libssh2_knownhost_writeline.3
+++ b/libssh2/docs/libssh2_knownhost_writeline.3
@@ -1,17 +1,19 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_writeline 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
+.\" Copyright (C) Daniel Stenberg
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_knownhost_writeline 3 "28 May 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_knownhost_writeline - convert a known host to a line for storage
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
+int
 libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
                             struct libssh2_knownhost *known,
                             char *buffer, size_t buflen,
                             size_t *outlen,
                             int type);
+.fi
 .SH DESCRIPTION
 Converts a single known host to a single line of output for storage, using
 the 'type' output format.
@@ -43,4 +45,3 @@ Added in libssh2 1.2
 .BR libssh2_knownhost_get(3)
 .BR libssh2_knownhost_readline(3)
 .BR libssh2_knownhost_writefile(3)
-
diff --git a/libssh2/docs/libssh2_poll.3 b/libssh2/docs/libssh2_poll.3
index 6656945c..7bda2f2a 100644
--- a/libssh2/docs/libssh2_poll.3
+++ b/libssh2/docs/libssh2_poll.3
@@ -1,10 +1,15 @@
-.TH libssh2_poll 3 "14 Dec 2006" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_poll 3 "14 Dec 2006" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_poll - poll for activity on a socket, channel or listener
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds, long timeout);
+int
+libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds, long timeout);
+.fi
 .SH DESCRIPTION
 This function is deprecated. Do note use. We encourage users to instead use
 the \fIpoll(3)\fP or \fIselect(3)\fP functions to check for socket activity or
diff --git a/libssh2/docs/libssh2_poll_channel_read.3 b/libssh2/docs/libssh2_poll_channel_read.3
index 207275b5..9878c3b1 100644
--- a/libssh2/docs/libssh2_poll_channel_read.3
+++ b/libssh2/docs/libssh2_poll_channel_read.3
@@ -1,10 +1,15 @@
-.TH libssh2_poll_channel_read 3 "14 Dec 2006" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_poll_channel_read 3 "14 Dec 2006" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_poll_channel_read - check if data is available
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended);
+int
+libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended);
+.fi
 .SH DESCRIPTION
 This function is deprecated. Do note use.
 
diff --git a/libssh2/docs/libssh2_publickey_add.3 b/libssh2/docs/libssh2_publickey_add.3
index 666cd942..75abb115 100644
--- a/libssh2/docs/libssh2_publickey_add.3
+++ b/libssh2/docs/libssh2_publickey_add.3
@@ -1,14 +1,19 @@
-.TH libssh2_publickey_add 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_add 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_publickey_add - convenience macro for \fIlibssh2_publickey_add_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_publickey_add(LIBSSH2_PUBLICKEY *pkey,
-			  const unsigned char *name,
-                          const unsigned char *blob, unsigned long blob_len, char overwrite,
-                          unsigned long num_attrs, const libssh2_publickey_attribute attrs[]);
-
+int
+libssh2_publickey_add(LIBSSH2_PUBLICKEY *pkey,
+                      const unsigned char *name,
+                      const unsigned char *blob, unsigned long blob_len,
+                      char overwrite, unsigned long num_attrs,
+                      const libssh2_publickey_attribute attrs[]);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_publickey_add_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_publickey_add_ex.3 b/libssh2/docs/libssh2_publickey_add_ex.3
index 5c01d234..2446915b 100644
--- a/libssh2/docs/libssh2_publickey_add_ex.3
+++ b/libssh2/docs/libssh2_publickey_add_ex.3
@@ -1,16 +1,19 @@
-.TH libssh2_publickey_add_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_add_ex 3 "1 Jun 2007" "libssh2" "libssh2"
 .SH NAME
 libssh2_publickey_add_ex - Add a public key entry
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
-libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-                         unsigned long name_len, const unsigned char *blob,
-                         unsigned long blob_len, char overwrite,
-                         unsigned long num_attrs,
+libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey,
+                         const unsigned char *name, unsigned long name_len,
+                         const unsigned char *blob, unsigned long blob_len,
+                         char overwrite, unsigned long num_attrs,
                          const libssh2_publickey_attribute attrs[])
-
+.fi
 .SH DESCRIPTION
 TBD
 .SH RETURN VALUE
diff --git a/libssh2/docs/libssh2_publickey_init.3 b/libssh2/docs/libssh2_publickey_init.3
index 448eb714..6703ebe3 100644
--- a/libssh2/docs/libssh2_publickey_init.3
+++ b/libssh2/docs/libssh2_publickey_init.3
@@ -1,12 +1,14 @@
-.TH libssh2_publickey_init 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_init 3 "1 Jun 2007" "libssh2" "libssh2"
 .SH NAME
 libssh2_publickey_init - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_publickey_list_fetch.3 b/libssh2/docs/libssh2_publickey_list_fetch.3
index 07a7024b..aa23b7c5 100644
--- a/libssh2/docs/libssh2_publickey_list_fetch.3
+++ b/libssh2/docs/libssh2_publickey_list_fetch.3
@@ -1,12 +1,14 @@
-.TH libssh2_publickey_list_fetch 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_list_fetch 3 "1 Jun 2007" "libssh2" "libssh2"
 .SH NAME
 libssh2_publickey_list_fetch - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_publickey_list_free.3 b/libssh2/docs/libssh2_publickey_list_free.3
index d50e935d..17c15304 100644
--- a/libssh2/docs/libssh2_publickey_list_free.3
+++ b/libssh2/docs/libssh2_publickey_list_free.3
@@ -1,12 +1,14 @@
-.TH libssh2_publickey_list_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_list_free 3 "1 Jun 2007" "libssh2" "libssh2"
 .SH NAME
 libssh2_publickey_list_free - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_publickey_remove.3 b/libssh2/docs/libssh2_publickey_remove.3
index 874fdbed..a07c9b2b 100644
--- a/libssh2/docs/libssh2_publickey_remove.3
+++ b/libssh2/docs/libssh2_publickey_remove.3
@@ -1,13 +1,17 @@
-.TH libssh2_publickey_remove 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_remove 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_publickey_remove - convenience macro for \fIlibssh2_publickey_remove_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_publickey_remove(LIBSSH2_PUBLICKEY *pkey,
-			     const unsigned char *name, unsigned long name_len,
-			     const unsigned char *blob, unsigned long blob_len);
-
+int
+libssh2_publickey_remove(LIBSSH2_PUBLICKEY *pkey,
+                         const unsigned char *name, unsigned long name_len,
+                         const unsigned char *blob, unsigned long blob_len);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_publickey_remove_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_publickey_remove_ex.3 b/libssh2/docs/libssh2_publickey_remove_ex.3
index a6cba50c..8a2ce834 100644
--- a/libssh2/docs/libssh2_publickey_remove_ex.3
+++ b/libssh2/docs/libssh2_publickey_remove_ex.3
@@ -1,12 +1,14 @@
-.TH libssh2_publickey_list_remove_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_list_remove_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_publickey_list_remove_ex - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_publickey_shutdown.3 b/libssh2/docs/libssh2_publickey_shutdown.3
index fe67a763..6ad80196 100644
--- a/libssh2/docs/libssh2_publickey_shutdown.3
+++ b/libssh2/docs/libssh2_publickey_shutdown.3
@@ -1,12 +1,14 @@
-.TH libssh2_publickey_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_publickey_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_publickey_shutdown - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_scp_recv.3 b/libssh2/docs/libssh2_scp_recv.3
index 2edcdd48..93bcee86 100644
--- a/libssh2/docs/libssh2_scp_recv.3
+++ b/libssh2/docs/libssh2_scp_recv.3
@@ -1,17 +1,20 @@
-.TH libssh2_scp_recv 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_scp_recv 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_scp_recv - request a remote file via SCP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
 libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat *sb);
-
+.fi
 .SH DESCRIPTION
-This function is \fBDEPRECATED\fP. Use \fIlibssh2_scp_recv2(3)\fP
-instead!
+This function is \fBDEPRECATED\fP in 1.7.0. Use the
+\fIlibssh2_scp_recv2(3)\fP function instead!
 
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIpath\fP - Full path and filename of file to transfer. That is the remote
@@ -23,13 +26,12 @@ Request a file from the remote host via SCP.
 .SH RETURN VALUE
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
+\fILIBSSH2_ERROR_SCP_PROTOCOL\fP -
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
 .BR libssh2_channel_open_ex(3)
-
diff --git a/libssh2/docs/libssh2_scp_recv2.3 b/libssh2/docs/libssh2_scp_recv2.3
index 6b48fd14..c3a27c2c 100644
--- a/libssh2/docs/libssh2_scp_recv2.3
+++ b/libssh2/docs/libssh2_scp_recv2.3
@@ -1,14 +1,17 @@
-.TH libssh2_scp_recv2 3 "29 Jun 2015" "libssh2 1.6.1" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_scp_recv2 3 "29 Jun 2015" "libssh2 1.6.1" "libssh2"
 .SH NAME
 libssh2_scp_recv2 - request a remote file via SCP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
 libssh2_scp_recv2(LIBSSH2_SESSION *session, const char *path, struct_stat *sb);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIpath\fP - Full path and filename of file to transfer. That is the remote
@@ -20,13 +23,12 @@ Request a file from the remote host via SCP.
 .SH RETURN VALUE
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
+\fILIBSSH2_ERROR_SCP_PROTOCOL\fP -
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
 .BR libssh2_channel_open_ex(3)
-
diff --git a/libssh2/docs/libssh2_scp_send.3 b/libssh2/docs/libssh2_scp_send.3
index 5e29347b..128a24c6 100644
--- a/libssh2/docs/libssh2_scp_send.3
+++ b/libssh2/docs/libssh2_scp_send.3
@@ -1,12 +1,16 @@
-.TH libssh2_scp_send 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_scp_send 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_scp_send - convenience macro for \fIlibssh2_scp_send_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_CHANNEL *
-libssh2_scp_send(LIBSSH2_SESSION *session, const char *path, int mode, size_t size);
-
+libssh2_scp_send(LIBSSH2_SESSION *session, const char *path,
+                 int mode, size_t size);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_scp_send_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_scp_send64.3 b/libssh2/docs/libssh2_scp_send64.3
index 98d7e74f..65611037 100644
--- a/libssh2/docs/libssh2_scp_send64.3
+++ b/libssh2/docs/libssh2_scp_send64.3
@@ -1,4 +1,6 @@
-.TH libssh2_scp_send64 3 "17 Apr 2010" "libssh2 1.2.6" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_scp_send64 3 "17 Apr 2010" "libssh2 1.2.6" "libssh2"
 .SH NAME
 libssh2_scp_send64 - Send a file via SCP
 .SH SYNOPSIS
@@ -8,8 +10,9 @@ libssh2_scp_send64 - Send a file via SCP
 LIBSSH2_CHANNEL *
 libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
                    libssh2_uint64_t size, time_t mtime, time_t atime);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIpath\fP - Full path and filename of file to transfer to. That is the remote
@@ -24,7 +27,7 @@ compilers.
 
 \fImtime\fP - mtime to assign to file being created
 
-\fIatime\fP - atime to assign to file being created (Set this and 
+\fIatime\fP - atime to assign to file being created (Set this and
 mtime to zero to instruct remote host to use current time).
 
 Send a file to the remote host via SCP.
@@ -32,11 +35,11 @@ Send a file to the remote host via SCP.
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
 
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
+\fILIBSSH2_ERROR_SCP_PROTOCOL\fP -
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
diff --git a/libssh2/docs/libssh2_scp_send_ex.3 b/libssh2/docs/libssh2_scp_send_ex.3
index 8de7083d..cc3a723e 100644
--- a/libssh2/docs/libssh2_scp_send_ex.3
+++ b/libssh2/docs/libssh2_scp_send_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_scp_send_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_scp_send_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_scp_send_ex - Send a file via SCP
 .SH SYNOPSIS
@@ -8,11 +10,12 @@ libssh2_scp_send_ex - Send a file via SCP
 LIBSSH2_CHANNEL *
 libssh2_scp_send_ex(LIBSSH2_SESSION *session, const char *path, int mode,
                     size_t size, long mtime, long atime);
+.fi
 .SH DESCRIPTION
 This function has been deemed deprecated since libssh2 1.2.6. See
 \fIlibssh2_scp_send64(3)\fP.
 
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIpath\fP - Full path and filename of file to transfer to. That is the remote
@@ -20,12 +23,12 @@ file name.
 
 \fImode\fP - File access mode to create file with
 
-\fIsize\fP - Size of file being transmitted (Must be known 
+\fIsize\fP - Size of file being transmitted (Must be known
 ahead of time precisely)
 
 \fImtime\fP - mtime to assign to file being created
 
-\fIatime\fP - atime to assign to file being created (Set this and 
+\fIatime\fP - atime to assign to file being created (Set this and
 mtime to zero to instruct remote host to use current time).
 
 Send a file to the remote host via SCP.
@@ -33,11 +36,11 @@ Send a file to the remote host via SCP.
 Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
 
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
+\fILIBSSH2_ERROR_SCP_PROTOCOL\fP -
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
diff --git a/libssh2/docs/libssh2_session_abstract.3 b/libssh2/docs/libssh2_session_abstract.3
index d880b09b..09f0e4de 100644
--- a/libssh2/docs/libssh2_session_abstract.3
+++ b/libssh2/docs/libssh2_session_abstract.3
@@ -1,24 +1,25 @@
-.TH libssh2_session_abstract 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_abstract 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_abstract - return a pointer to a session's abstract pointer
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 void **
 libssh2_session_abstract(LIBSSH2_SESSION *session);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 Return a pointer to where the abstract pointer provided to
 \fBlibssh2_session_init_ex(3)\fP is stored. By providing a doubly
 de-referenced pointer, the internal storage of the session instance may be
 modified in place.
-
 .SH RETURN VALUE
-A pointer to session internal storage who's contents point to previously
+A pointer to session internal storage whose contents point to previously
 provided abstract data.
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_session_banner_get.3 b/libssh2/docs/libssh2_session_banner_get.3
index e253aa13..88f23995 100644
--- a/libssh2/docs/libssh2_session_banner_get.3
+++ b/libssh2/docs/libssh2_session_banner_get.3
@@ -1,10 +1,15 @@
-.TH libssh2_session_banner_get 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_banner_get 3 "9 Sep 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_banner_get - get the remote banner
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-const char *libssh2_session_banner_get(oLIBSSH2_SESSION *session);
+const char *
+libssh2_session_banner_get(oLIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Once the session has been setup and \fIlibssh2_session_handshake(3)\fP has
 completed successfully, this function can be used to get the server id from
diff --git a/libssh2/docs/libssh2_session_banner_set.3 b/libssh2/docs/libssh2_session_banner_set.3
index 5e4161ea..037a4d6a 100644
--- a/libssh2/docs/libssh2_session_banner_set.3
+++ b/libssh2/docs/libssh2_session_banner_set.3
@@ -1,14 +1,17 @@
-.TH libssh2_session_banner_set 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_banner_set 3 "9 Sep 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_banner_set - set the SSH protocol banner for the local client
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_session_banner_set(LIBSSH2_SESSION *session, const char *banner);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIbanner\fP - A pointer to a zero-terminated string holding the user defined
@@ -18,11 +21,11 @@ Set the banner that will be sent to the remote host when the SSH session is
 started with \fIlibssh2_session_handshake(3)\fP This is optional; a banner
 corresponding to the protocol and libssh2 version will be sent by default.
 .SH RETURN VALUE
-Returns 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
+Returns 0 on success or negative on failure. It returns LIBSSH2_ERROR_EAGAIN
 when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
+number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 .SH AVAILABILITY
 Added in 1.4.0.
 
diff --git a/libssh2/docs/libssh2_session_block_directions.3 b/libssh2/docs/libssh2_session_block_directions.3
index 48ffca3d..106de221 100644
--- a/libssh2/docs/libssh2_session_block_directions.3
+++ b/libssh2/docs/libssh2_session_block_directions.3
@@ -1,11 +1,15 @@
-.TH libssh2_session_block_directions 3 "1 Oct 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_block_directions 3 "1 Oct 2008" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_block_directions - get directions to wait for
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
 libssh2_session_block_directions(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 \fIsession\fP - Session instance as returned by \fBlibssh2_session_init_ex(3)\fP
 
@@ -23,7 +27,7 @@ LIBSSH2_SESSION_BLOCK_OUTBOUND: Outbound direction blocked.
 
 Application should wait for data to be available for socket prior to calling a
 libssh2 function again. If \fBLIBSSH2_SESSION_BLOCK_INBOUND\fP is set select
-should contain the session socket in readfds set.  Correspondingly in case of
+should contain the session socket in readfds set. Correspondingly in case of
 \fBLIBSSH2_SESSION_BLOCK_OUTBOUND\fP writefds set should contain the socket.
 .SH AVAILABILITY
 Added in 1.0
diff --git a/libssh2/docs/libssh2_session_callback_set.3 b/libssh2/docs/libssh2_session_callback_set.3
index 6a075cbf..70c94c13 100644
--- a/libssh2/docs/libssh2_session_callback_set.3
+++ b/libssh2/docs/libssh2_session_callback_set.3
@@ -1,76 +1,31 @@
-.TH libssh2_session_callback_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_callback_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_callback_set - set a callback function
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
-                                   int cbtype, void *callback);
-.SH DESCRIPTION
-Sets a custom callback handler for a previously initialized session
-object. Callbacks are triggered by the receipt of special packets at the
-Transport layer. To disable a callback, set it to NULL.
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIcbtype\fP - Callback type. One of the types listed in Callback Types.
-
-\fIcallback\fP - Pointer to custom callback function. The prototype for 
-this function must match the associated callback declaration macro.
-.SH CALLBACK TYPES
-.IP LIBSSH2_CALLBACK_IGNORE
-Called when a SSH_MSG_IGNORE message is received
-.IP LIBSSH2_CALLBACK_DEBUG
-Called when a SSH_MSG_DEBUG message is received
-.IP LIBSSH2_CALLBACK_DISCONNECT
-Called when a SSH_MSG_DISCONNECT message is received
-.IP LIBSSH2_CALLBACK_MACERROR
-Called when a mismatched MAC has been detected in the transport layer. If the
-function returns 0, the packet will be accepted nonetheless.
-.IP LIBSSH2_CALLBACK_X11
-Called when an X11 connection has been accepted
-.IP LIBSSH2_CALLBACK_SEND
-Called when libssh2 wants to send data on the connection.  Can be set to a
-custom function to handle I/O your own way.
-
-The prototype of the callback:
-
-.nf
-ssize_t sendcb(libssh2_socket_t sockfd, const void *buffer,
-               size_t length, int flags, void **abstract);
+void *
+libssh2_session_callback_set(LIBSSH2_SESSION *session,
+                             int cbtype, void *callback);
 .fi
+.SH DESCRIPTION
+This function is \fBDEPRECATED\fP in 1.11.1. Use the
+\fIlibssh2_session_callback_set2(3)\fP function instead!
 
-\fBsockfd\fP is the socket to write to, \fBbuffer\fP points to the data to
-send, \fBlength\fP is the size of the data, \fBflags\fP is the flags that
-would've been used to a \fIsend()\fP call and \fBabstract\fP is a pointer to
-the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
-
-The callback returns the number of bytes sent, or -1 for error. The special
-return code \fB-EAGAIN\fP can be returned to signal that the send was aborted
-to prevent getting blocked and it needs to be called again.
-.IP LIBSSH2_CALLBACK_RECV
-Called when libssh2 wants to read data from the connection. Can be set to a
-custom function to handle I/O your own way.
-
-The prototype of the callback:
-
-.nf
-ssize_t recvcb(libssh2_socket_t sockfd, void *buffer,
-               size_t length, int flags, void **abstract);
-.fi
+This implementation is expecting and returning a data pointer for callback
+functions.
 
-\fBsockfd\fP is the socket to read from, \fBbuffer\fP where to store received
-data into, \fBlength\fP is the size of the buffer, \fBflags\fP is the flags
-that would've been used to a \fIrecv()\fP call and \fBabstract\fP is a pointer
-to the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
+For the details about the replacement function, see
+.BR libssh2_session_callback_set2(3)
+which is expecting and returning a function pointer.
 
-The callback returns the number of bytes read, or -1 for error. The special
-return code \fB-EAGAIN\fP can be returned to signal that the read was aborted
-to prevent getting blocked and it needs to be called again.
 .SH RETURN VALUE
 Pointer to previous callback handler. Returns NULL if no prior callback
 handler was set or the callback type was unknown.
 .SH SEE ALSO
+.BR libssh2_session_callback_set2(3)
 .BR libssh2_session_init_ex(3)
+.BR libssh2_agent_sign(3)
diff --git a/libssh2/docs/libssh2_session_callback_set2.3 b/libssh2/docs/libssh2_session_callback_set2.3
new file mode 100644
index 00000000..ee55af94
--- /dev/null
+++ b/libssh2/docs/libssh2_session_callback_set2.3
@@ -0,0 +1,139 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_callback_set2 3 "13 Dec 2023" "libssh2 1.11.1" "libssh2"
+.SH NAME
+libssh2_session_callback_set2 - set a callback function
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+libssh2_cb_generic *
+libssh2_session_callback_set2(LIBSSH2_SESSION *session, int cbtype,
+                              libssh2_cb_generic *callback);
+.fi
+.SH DESCRIPTION
+Sets a custom callback handler for a previously initialized session
+object. Callbacks are triggered by the receipt of special packets at the
+Transport layer. To disable a callback, set it to NULL.
+
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIcbtype\fP - Callback type. One of the types listed in Callback Types.
+
+\fIcallback\fP - Pointer to custom callback function. The prototype for
+this function must match the associated callback declaration macro.
+.SH CALLBACK TYPES
+.IP LIBSSH2_CALLBACK_IGNORE
+Called when a SSH_MSG_IGNORE message is received
+.IP LIBSSH2_CALLBACK_DEBUG
+Called when a SSH_MSG_DEBUG message is received
+.IP LIBSSH2_CALLBACK_DISCONNECT
+Called when a SSH_MSG_DISCONNECT message is received
+.IP LIBSSH2_CALLBACK_MACERROR
+Called when a mismatched MAC has been detected in the transport layer. If the
+function returns 0, the packet will be accepted nonetheless.
+.IP LIBSSH2_CALLBACK_X11
+Called when an X11 connection has been accepted
+.IP LIBSSH2_CALLBACK_SEND
+Called when libssh2 wants to send data on the connection. Can be set to a
+custom function to handle I/O your own way.
+
+The prototype of the callback:
+
+.nf
+ssize_t sendcb(libssh2_socket_t sockfd, const void *buffer,
+               size_t length, int flags, void **abstract);
+.fi
+
+\fBsockfd\fP is the socket to write to, \fBbuffer\fP points to the data to
+send, \fBlength\fP is the size of the data, \fBflags\fP is the flags that
+would have been used to a \fIsend()\fP call and \fBabstract\fP is a pointer
+to the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
+
+The callback returns the number of bytes sent, or \-1 for error. The special
+return code \fB-EAGAIN\fP can be returned to signal that the send was aborted
+to prevent getting blocked and it needs to be called again.
+.IP LIBSSH2_CALLBACK_RECV
+Called when libssh2 wants to read data from the connection. Can be set to a
+custom function to handle I/O your own way.
+
+The prototype of the callback:
+
+.nf
+ssize_t recvcb(libssh2_socket_t sockfd, void *buffer,
+               size_t length, int flags, void **abstract);
+.fi
+
+\fBsockfd\fP is the socket to read from, \fBbuffer\fP where to store received
+data into, \fBlength\fP is the size of the buffer, \fBflags\fP is the flags
+that would have been used to a \fIrecv()\fP call and \fBabstract\fP is a pointer
+to the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
+
+The callback returns the number of bytes read, or \-1 for error. The special
+return code \fB-EAGAIN\fP can be returned to signal that the read was aborted
+to prevent getting blocked and it needs to be called again.
+.IP LIBSSH2_CALLBACK_AUTHAGENT
+Called during authentication process to allow the client to connect to the
+ssh-agent and perform any setup, such as configuring the agent or adding keys.
+
+The prototype of the callback:
+
+.nf
+void authagent(LIBSSH2_SESSION* session, LIBSSH2_CHANNEL *channel,
+               void **abstract);
+.fi
+.IP LIBSSH2_CALLBACK_AUTHAGENT_IDENTITIES
+Not called by libssh2. The client is responsible for calling this method when
+a SSH2_AGENTC_REQUEST_IDENTITIES message has been received.
+
+The prototype of the callback:
+
+.nf
+void identities(LIBSSH2_SESSION* session, void *buffer,
+                const char *agent_path,
+                void **abstract)
+.fi
+
+\fBbuffer\fP must be filled in by the callback. Different clients may implement
+this differently. For example, one client may pass in an unsigned char ** for
+this parameter, while another may pass in a pointer to a struct.
+
+Regardless of the type of buffer used, the client will need to send back a list
+of identities in the following format.
+
+uint32 buffer length
+uint32 number of entries
+entries
+
+Where each entry in the entries list is of the format:
+
+string data
+cstring comment
+
+\fBagent_path\fP The path to a running ssh-agent on the client machine, from
+which identities can be listed.
+.IP LIBSSH2_CALLBACK_AUTHAGENT_SIGN
+Not called by libssh2. The client is responsible for calling this method when
+a SSH2_AGENTC_SIGN_REQUEST message has been received.
+
+The prototype of the callback:
+
+.nf
+void sign(LIBSSH2_SESSION* session,
+          unsigned char *blob, unsigned int blen,
+          const unsigned char *data, unsigned int dlen,
+          unsigned char **sig, unsigned int *sig_len,
+          const char *agent_path,
+          void **abstract);
+.fi
+
+When interfacing with an ssh-agent installed on the client system, this method
+can call libssh2_agent_sign(3) to perform signing.
+
+.SH RETURN VALUE
+Pointer to previous callback handler. Returns NULL if no prior callback
+handler was set or the callback type was unknown.
+.SH SEE ALSO
+.BR libssh2_session_init_ex(3)
+.BR libssh2_agent_sign(3)
diff --git a/libssh2/docs/libssh2_session_disconnect.3 b/libssh2/docs/libssh2_session_disconnect.3
index 32d5e878..85e14199 100644
--- a/libssh2/docs/libssh2_session_disconnect.3
+++ b/libssh2/docs/libssh2_session_disconnect.3
@@ -1,11 +1,15 @@
-.TH libssh2_session_disconnect 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_disconnect 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_session_disconnect - convenience macro for \fIlibssh2_session_disconnect_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
-
+int
+libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_session_disconnect_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_session_disconnect_ex.3 b/libssh2/docs/libssh2_session_disconnect_ex.3
index 82174f9b..b1674eb6 100644
--- a/libssh2/docs/libssh2_session_disconnect_ex.3
+++ b/libssh2/docs/libssh2_session_disconnect_ex.3
@@ -1,17 +1,23 @@
-.TH libssh2_session_disconnect_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_disconnect_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_disconnect_ex - terminate transport layer
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
-libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason, const char *description, const char *lang);
-
-int 
-libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
+int
+libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason,
+                              const char *description,
+                              const char *lang);
 
+int
+libssh2_session_disconnect(LIBSSH2_SESSION *session,
+                           const char *description);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIreason\fP - One of the Disconnect Reason constants.
@@ -20,19 +26,18 @@ libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
 
 \fIlang\fP - Localization string describing the language/encoding of the description provided.
 
-Send a disconnect message to the remote host associated with \fIsession\fP, 
+Send a disconnect message to the remote host associated with \fIsession\fP,
 along with a \fIreason\fP symbol and a verbose \fIdescription\fP.
 
-As a convenience, the macro 
+As a convenience, the macro
 .BR libssh2_session_disconnect(3)
 is provided. It calls
 .BR libssh2_session_disconnect_ex(3)
-with \fIreason\fP set to SSH_DISCONNECT_BY_APPLICATION 
+with \fIreason\fP set to SSH_DISCONNECT_BY_APPLICATION
 and \fIlang\fP set to an empty string.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_session_flag.3 b/libssh2/docs/libssh2_session_flag.3
index 3a9e5e55..b8e8fec8 100644
--- a/libssh2/docs/libssh2_session_flag.3
+++ b/libssh2/docs/libssh2_session_flag.3
@@ -1,9 +1,15 @@
-.TH libssh2_session_flag 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_flag 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_flag - TODO
 .SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
 int
 libssh2_session_flag(LIBSSH2_SESSION *session, int flag, int value);
+.fi
 .SH DESCRIPTION
 Set options for the created session. \fIflag\fP is the option to set, while
 \fIvalue\fP is typically set to 1 or 0 to enable or disable the option.
diff --git a/libssh2/docs/libssh2_session_free.3 b/libssh2/docs/libssh2_session_free.3
index 96eff0cb..618653ac 100644
--- a/libssh2/docs/libssh2_session_free.3
+++ b/libssh2/docs/libssh2_session_free.3
@@ -1,18 +1,22 @@
-.TH libssh2_session_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_free - frees resources associated with a session instance
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_session_free(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Frees all resources associated with a session instance. Typically called after
 .BR libssh2_session_disconnect_ex(3)
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
 .BR libssh2_session_disconnect_ex(3)
diff --git a/libssh2/docs/libssh2_session_get_blocking.3 b/libssh2/docs/libssh2_session_get_blocking.3
index 8d98fa33..2d3b793e 100644
--- a/libssh2/docs/libssh2_session_get_blocking.3
+++ b/libssh2/docs/libssh2_session_get_blocking.3
@@ -1,8 +1,15 @@
-.TH libssh2_session_get_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_get_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
-libssh2_session_get_blocking - TODO
+libssh2_session_get_blocking - evaluate blocking mode on session
 .SH SYNOPSIS
-int libssh2_session_get_blocking(LIBSSH2_SESSION *session);
+.nf
+#include <libssh2.h>
+
+int
+libssh2_session_get_blocking(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Returns 0 if the state of the session has previously be set to non-blocking
 and it returns 1 if the state was set to blocking.
diff --git a/libssh2/docs/libssh2_session_get_read_timeout.3 b/libssh2/docs/libssh2_session_get_read_timeout.3
new file mode 100644
index 00000000..81b0cb1f
--- /dev/null
+++ b/libssh2/docs/libssh2_session_get_read_timeout.3
@@ -0,0 +1,24 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_get_read_timeout 3 "13 Jan 2023" "libssh2" "libssh2"
+.SH NAME
+libssh2_session_get_read_timeout - get the timeout for packet read functions
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+long
+libssh2_session_get_read_timeout(LIBSSH2_SESSION *session);
+.fi
+.SH DESCRIPTION
+Returns the \fBtimeout\fP (in seconds) for how long the ssh2 packet receive
+function calls may wait until they consider the situation an error and
+return LIBSSH2_ERROR_TIMEOUT.
+
+By default the timeout is 60 seconds.
+.SH RETURN VALUE
+The value of the timeout setting.
+.SH AVAILABILITY
+Added in 1.10.1
+.SH SEE ALSO
+.BR libssh2_session_set_read_timeout(3)
diff --git a/libssh2/docs/libssh2_session_get_timeout.3 b/libssh2/docs/libssh2_session_get_timeout.3
index 94aacd65..4a57cedf 100644
--- a/libssh2/docs/libssh2_session_get_timeout.3
+++ b/libssh2/docs/libssh2_session_get_timeout.3
@@ -1,10 +1,15 @@
-.TH libssh2_session_get_timeout 3 "4 May 2011" "libssh2 1.2.9" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_get_timeout 3 "4 May 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_get_timeout - get the timeout for blocking functions
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
-long libssh2_session_get_timeout(LIBSSH2_SESSION *session);
+#include <libssh2.h>
+
+long
+libssh2_session_get_timeout(LIBSSH2_SESSION *session);
+.fi
 .SH DESCRIPTION
 Returns the \fBtimeout\fP (in milliseconds) for how long a blocking the
 libssh2 function calls may wait until they consider the situation an error and
diff --git a/libssh2/docs/libssh2_session_handshake.3 b/libssh2/docs/libssh2_session_handshake.3
index 33908c64..4d5cc511 100644
--- a/libssh2/docs/libssh2_session_handshake.3
+++ b/libssh2/docs/libssh2_session_handshake.3
@@ -1,11 +1,15 @@
-.TH libssh2_session_handshake 3 "7 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_handshake 3 "7 Oct 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_handshake - perform the SSH handshake
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
 libssh2_session_handshake(LIBSSH2_SESSION *session, libssh2_socket_t socket);
+.fi
 .SH DESCRIPTION
 \fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
@@ -22,7 +26,7 @@ Returns 0 on success, negative on failure.
 
 \fILIBSSH2_ERROR_BANNER_SEND\fP - Unable to send banner to remote host.
 
-\fILIBSSH2_ERROR_KEX_FAILURE\fP - >Encryption key exchange with the remote
+\fILIBSSH2_ERROR_KEX_FAILURE\fP - Encryption key exchange with the remote
 host failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
diff --git a/libssh2/docs/libssh2_session_hostkey.3 b/libssh2/docs/libssh2_session_hostkey.3
index 5d044407..4190843d 100644
--- a/libssh2/docs/libssh2_session_hostkey.3
+++ b/libssh2/docs/libssh2_session_hostkey.3
@@ -1,17 +1,22 @@
-.TH libssh2_session_hostkey 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_hostkey 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_hostkey - get the remote key
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-const char *libssh2_session_hostkey(LIBSSH2_SESSION *session,
-                                    size_t *len, int *type);
+const char *
+libssh2_session_hostkey(LIBSSH2_SESSION *session,
+                        size_t *len, int *type);
+.fi
 .SH DESCRIPTION
 Returns a pointer to the current host key, the value \fIlen\fP points to will
 get the length of the key.
 
 The value \fItype\fP points to the type of hostkey which is one of:
-LIBSSH2_HOSTKEY_TYPE_RSA, LIBSSH2_HOSTKEY_TYPE_DSS, or
+LIBSSH2_HOSTKEY_TYPE_RSA, LIBSSH2_HOSTKEY_TYPE_DSS (deprecated), or
 LIBSSH2_HOSTKEY_TYPE_UNKNOWN.
 
 .SH RETURN VALUE
diff --git a/libssh2/docs/libssh2_session_init.3 b/libssh2/docs/libssh2_session_init.3
index 476a3b42..88f1fa8c 100644
--- a/libssh2/docs/libssh2_session_init.3
+++ b/libssh2/docs/libssh2_session_init.3
@@ -1,12 +1,15 @@
-.TH libssh2_session_init 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_init 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_session_init - convenience macro for \fIlibssh2_session_init_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 LIBSSH2_SESSION *
 libssh2_session_init(void);
-
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_session_init_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_session_init_ex.3 b/libssh2/docs/libssh2_session_init_ex.3
index 5e4ef06c..3a79e786 100644
--- a/libssh2/docs/libssh2_session_init_ex.3
+++ b/libssh2/docs/libssh2_session_init_ex.3
@@ -1,30 +1,36 @@
-.TH libssh2_session_init_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_init_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_init_ex - initializes an SSH session object
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-LIBSSH2_SESSION * 
-libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*myalloc)), LIBSSH2_FREE_FUNC((*myfree)), LIBSSH2_REALLOC_FUNC((*myrealloc)), void *abstract);
+LIBSSH2_SESSION *
+libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*myalloc)),
+                        LIBSSH2_FREE_FUNC((*myfree)),
+                        LIBSSH2_REALLOC_FUNC((*myrealloc)),
+                        void *abstract);
 
 LIBSSH2_SESSION *
 libssh2_session_init(void);
-
+.fi
 .SH DESCRIPTION
-\fImyalloc\fP - Custom allocator function. Refer to the section on Callbacks 
-for implementing an allocator callback. Pass a value of NULL to use the 
+\fImyalloc\fP - Custom allocator function. Refer to the section on Callbacks
+for implementing an allocator callback. Pass a value of NULL to use the
 default system allocator.
 
-\fImyfree\fP - Custom de-allocator function. Refer to the section on Callbacks 
-for implementing a deallocator callback. Pass a value of NULL to use the 
+\fImyfree\fP - Custom de-allocator function. Refer to the section on Callbacks
+for implementing a deallocator callback. Pass a value of NULL to use the
 default system deallocator.
 
-\fImyrealloc\fP - Custom re-allocator function. Refer to the section on 
-Callbacks for implementing a reallocator callback. Pass a value of NULL to 
+\fImyrealloc\fP - Custom re-allocator function. Refer to the section on
+Callbacks for implementing a reallocator callback. Pass a value of NULL to
 use the default system reallocator.
 
-\fIabstract\fP - Arbitrary pointer to application specific callback data. 
-This value will be passed to any callback function associated with the named 
+\fIabstract\fP - Arbitrary pointer to application specific callback data.
+This value will be passed to any callback function associated with the named
 session instance.
 
 Initializes an SSH session object. By default system memory allocators
diff --git a/libssh2/docs/libssh2_session_last_errno.3 b/libssh2/docs/libssh2_session_last_errno.3
index f9172cbc..029f49c2 100644
--- a/libssh2/docs/libssh2_session_last_errno.3
+++ b/libssh2/docs/libssh2_session_last_errno.3
@@ -1,21 +1,22 @@
-.TH libssh2_session_last_errno 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_last_errno 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_last_errno - get the most recent error number
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
 libssh2_session_last_errno(LIBSSH2_SESSION *session);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 Determine the most recent error condition.
-
 .SH RETURN VALUE
 Numeric error code corresponding to the the Error Code constants.
-
 .SH SEE ALSO
 .BR libssh2_session_last_error(3)
 .BR libssh2_session_set_last_error(3)
diff --git a/libssh2/docs/libssh2_session_last_error.3 b/libssh2/docs/libssh2_session_last_error.3
index 2a64dbb7..f11d65ff 100644
--- a/libssh2/docs/libssh2_session_last_error.3
+++ b/libssh2/docs/libssh2_session_last_error.3
@@ -1,32 +1,34 @@
-.TH libssh2_session_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_last_error - get the most recent error
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
-libssh2_session_last_error(LIBSSH2_SESSION *session, char **errmsg, int *errmsg_len, int want_buf);
-
+libssh2_session_last_error(LIBSSH2_SESSION *session,
+                           char **errmsg, int *errmsg_len, int want_buf);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
-\fIerrmsg\fP - If not NULL, is populated by reference with the human 
+\fIerrmsg\fP - If not NULL, is populated by reference with the human
 readable form of the most recent error message.
 
-\fIerrmsg_len\fP - If not NULL, is populated by reference with the length 
-of errmsg. (The string is NUL-terminated, so the length is only useful as 
+\fIerrmsg_len\fP - If not NULL, is populated by reference with the length
+of errmsg. (The string is NUL-terminated, so the length is only useful as
 an optimization, to avoid calling strlen.)
 
-\fIwant_buf\fP - If set to a non-zero value, "ownership" of the errmsg 
-buffer will be given to the calling scope. If necessary, the errmsg buffer 
+\fIwant_buf\fP - If set to a non-zero value, "ownership" of the errmsg
+buffer will be given to the calling scope. If necessary, the errmsg buffer
 will be duplicated.
 
 Determine the most recent error condition and its cause.
-
 .SH RETURN VALUE
 Numeric error code corresponding to the the Error Code constants.
-
 .SH SEE ALSO
 .BR libssh2_session_last_errno(3)
 .BR libssh2_session_set_last_error(3)
diff --git a/libssh2/docs/libssh2_session_method_pref.3 b/libssh2/docs/libssh2_session_method_pref.3
index dcf77f6d..310d5026 100644
--- a/libssh2/docs/libssh2_session_method_pref.3
+++ b/libssh2/docs/libssh2_session_method_pref.3
@@ -1,40 +1,41 @@
-.TH libssh2_session_method_pref 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_method_pref 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_method_pref - set preferred key exchange method
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
-libssh2_session_method_pref(LIBSSH2_SESSION *session, int method_type, const char *prefs);
-
+int
+libssh2_session_method_pref(LIBSSH2_SESSION *session,
+                            int method_type, const char *prefs);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fImethod_type\fP - One of the Method Type constants.
 
-\fIprefs\fP - Coma delimited list of preferred methods to use with 
-the most preferred listed first and the least preferred listed last. 
-If a method is listed which is not supported by libssh2 it will be 
+\fIprefs\fP - Coma delimited list of preferred methods to use with
+the most preferred listed first and the least preferred listed last.
+If a method is listed which is not supported by libssh2 it will be
 ignored and not sent to the remote host during protocol negotiation.
 
-Set preferred methods to be negotiated. These 
+Set preferred methods to be negotiated. These
 preferences must be set prior to calling
 .BR libssh2_session_handshake(3)
 as they are used during the protocol initiation phase.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
 \fILIBSSH2_ERROR_INVAL\fP - The requested method type was invalid.
 
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_METHOD_NOT_SUPPORTED\fP - The requested method is not supported.
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
 .BR libssh2_session_handshake(3)
diff --git a/libssh2/docs/libssh2_session_methods.3 b/libssh2/docs/libssh2_session_methods.3
index cc4f6d49..5748626d 100644
--- a/libssh2/docs/libssh2_session_methods.3
+++ b/libssh2/docs/libssh2_session_methods.3
@@ -1,20 +1,24 @@
-.TH libssh2_session_methods 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_methods 3 "8 Nov 2021" "libssh2 1.11" "libssh2"
 .SH NAME
 libssh2_session_methods - return the currently active algorithms
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 const char *
 libssh2_session_methods(LIBSSH2_SESSION *session, int method_type);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fImethod_type\fP - one of the method type constants: LIBSSH2_METHOD_KEX,
 LIBSSH2_METHOD_HOSTKEY, LIBSSH2_METHOD_CRYPT_CS, LIBSSH2_METHOD_CRYPT_SC,
 LIBSSH2_METHOD_MAC_CS, LIBSSH2_METHOD_MAC_SC, LIBSSH2_METHOD_COMP_CS,
-LIBSSH2_METHOD_COMP_SC, LIBSSH2_METHOD_LANG_CS, LIBSSH2_METHOD_LANG_SC.
+LIBSSH2_METHOD_COMP_SC, LIBSSH2_METHOD_LANG_CS, LIBSSH2_METHOD_LANG_SC,
+LIBSSH2_METHOD_SIGN_ALGO.
 
 Returns the actual method negotiated for a particular transport parameter.
 .SH RETURN VALUE
diff --git a/libssh2/docs/libssh2_session_set_blocking.3 b/libssh2/docs/libssh2_session_set_blocking.3
index b16e0091..db596481 100644
--- a/libssh2/docs/libssh2_session_set_blocking.3
+++ b/libssh2/docs/libssh2_session_set_blocking.3
@@ -1,30 +1,31 @@
-.TH libssh2_session_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_set_blocking - set or clear blocking mode on session
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void 
+void
 libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - session instance as returned by 
+\fIsession\fP - session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIblocking\fP - Set to a non-zero value to make the channel block, or zero to
 make it non-blocking.
 
-Set or clear blocking mode on the selected on the session.  This will
+Set or clear blocking mode on the selected on the session. This will
 instantly affect any channels associated with this session. If a read is
 performed on a session with no data currently available, a blocking session
-will wait for data to arrive and return what it receives.  A non-blocking
-session will return immediately with an empty buffer.  If a write is performed
+will wait for data to arrive and return what it receives. A non-blocking
+session will return immediately with an empty buffer. If a write is performed
 on a session with no room for more data, a blocking session will wait for
-room.  A non-blocking session will return immediately without writing
+room. A non-blocking session will return immediately without writing
 anything.
-
 .SH RETURN VALUE
 None
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_session_set_last_error.3 b/libssh2/docs/libssh2_session_set_last_error.3
index fca6d1df..7a5bdaa9 100644
--- a/libssh2/docs/libssh2_session_set_last_error.3
+++ b/libssh2/docs/libssh2_session_set_last_error.3
@@ -1,12 +1,16 @@
-.TH libssh2_session_set_last_error 3 "26 Oct 2015" "libssh2 1.6.1" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_set_last_error 3 "26 Oct 2015" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_set_last_error - sets the internal error state
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
-libssh2_session_set_last_error(LIBSSH2_SESSION *session, int errcode, const char *errmsg)
-
+libssh2_session_set_last_error(LIBSSH2_SESSION *session,
+                               int errcode, const char *errmsg)
+.fi
 .SH DESCRIPTION
 \fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
@@ -21,13 +25,10 @@ This function is provided for high level language wrappers
 (i.e. Python or Perl) and other libraries that may extend libssh2 with
 additional features while still relying on its error reporting
 mechanism.
-
 .SH RETURN VALUE
 Numeric error code corresponding to the the Error Code constants.
-
 .SH AVAILABILITY
 Added in 1.6.1
-
 .SH SEE ALSO
 .BR libssh2_session_last_error(3)
 .BR libssh2_session_last_errno(3)
diff --git a/libssh2/docs/libssh2_session_set_read_timeout.3 b/libssh2/docs/libssh2_session_set_read_timeout.3
new file mode 100644
index 00000000..487c2890
--- /dev/null
+++ b/libssh2/docs/libssh2_session_set_read_timeout.3
@@ -0,0 +1,25 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_set_read_timeout 3 "13 Jan 2023" "libssh2" "libssh2"
+.SH NAME
+libssh2_session_set_read_timeout - set timeout for packet read functions
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+void
+libssh2_session_set_read_timeout(LIBSSH2_SESSION *session, long timeout);
+.fi
+.SH DESCRIPTION
+Set the \fBtimeout\fP in seconds for how long libssh2 packet read
+function calls may wait until they consider the situation an error and return
+LIBSSH2_ERROR_TIMEOUT.
+
+By default or if you set the timeout to zero, the timeout will be set to
+60 seconds.
+.SH RETURN VALUE
+Nothing
+.SH AVAILABILITY
+Added in 1.10.1
+.SH SEE ALSO
+.BR libssh2_session_get_read_timeout(3)
diff --git a/libssh2/docs/libssh2_session_set_timeout.3 b/libssh2/docs/libssh2_session_set_timeout.3
index 2d4f10f1..27326851 100644
--- a/libssh2/docs/libssh2_session_set_timeout.3
+++ b/libssh2/docs/libssh2_session_set_timeout.3
@@ -1,10 +1,15 @@
-.TH libssh2_session_set_timeout 3 "4 May 2011" "libssh2 1.2.9" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_set_timeout 3 "4 May 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_set_timeout - set timeout for blocking functions
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
-void libssh2_session_set_timeout(LIBSSH2_SESSION *session, long timeout);
+#include <libssh2.h>
+
+void
+libssh2_session_set_timeout(LIBSSH2_SESSION *session, long timeout);
+.fi
 .SH DESCRIPTION
 Set the \fBtimeout\fP in milliseconds for how long a blocking the libssh2
 function calls may wait until they consider the situation an error and return
diff --git a/libssh2/docs/libssh2_session_startup.3 b/libssh2/docs/libssh2_session_startup.3
index b59056f7..53e95266 100644
--- a/libssh2/docs/libssh2_session_startup.3
+++ b/libssh2/docs/libssh2_session_startup.3
@@ -1,20 +1,24 @@
-.TH libssh2_session_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_session_startup - begin transport layer
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_session_startup(LIBSSH2_SESSION *session, int socket);
+.fi
 .SH DESCRIPTION
 Starting in libssh2 version 1.2.8 this function is considered deprecated. Use
 \fIlibssh2_session_handshake(3)\fP instead.
 
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
-\fIsocket\fP - Connected socket descriptor. Typically a TCP connection 
-though the protocol allows for any reliable transport and the library will 
+\fIsocket\fP - Connected socket descriptor. Typically a TCP connection
+though the protocol allows for any reliable transport and the library will
 attempt to use any berkeley socket.
 
 Begin transport layer protocol negotiation with the connected host.
@@ -25,18 +29,17 @@ Returns 0 on success, negative on failure.
 
 \fILIBSSH2_ERROR_BANNER_SEND\fP - Unable to send banner to remote host.
 
-\fILIBSSH2_ERROR_KEX_FAILURE\fP - >Encryption key exchange with the remote 
+\fILIBSSH2_ERROR_KEX_FAILURE\fP - Encryption key exchange with the remote
 host failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
 \fILIBSSH2_ERROR_SOCKET_DISCONNECT\fP - The socket was disconnected.
 
-\fILIBSSH2_ERROR_PROTO\fP - An invalid SSH protocol response was received on 
+\fILIBSSH2_ERROR_PROTO\fP - An invalid SSH protocol response was received on
 the socket.
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-
 .SH SEE ALSO
 .BR libssh2_session_free(3)
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_session_supported_algs.3 b/libssh2/docs/libssh2_session_supported_algs.3
index 6e414a90..c17d53d5 100644
--- a/libssh2/docs/libssh2_session_supported_algs.3
+++ b/libssh2/docs/libssh2_session_supported_algs.3
@@ -1,17 +1,21 @@
-.TH libssh2_session_supported_algs 3 "23 Oct 2011" "libssh2 1.4.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_session_supported_algs 3 "23 Oct 2011" "libssh2" "libssh2"
 .SH NAME
 libssh2_session_supported_algs - get list of supported algorithms
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 
-int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
-                                   int method_type,
-                                   const char*** algs);
+int
+libssh2_session_supported_algs(LIBSSH2_SESSION* session,
+                               int method_type,
+                               const char*** algs);
+.fi
 .SH DESCRIPTION
 \fIsession\fP - An instance of initialized LIBSSH2_SESSION (the function will
-use its pointer to the memory allocation function).  \fImethod_type\fP -
-Method type. See \fIlibssh2_session_method_pref(3)\fP.  \fIalgs\fP - Address
+use its pointer to the memory allocation function). \fImethod_type\fP -
+Method type. See \fIlibssh2_session_method_pref(3)\fP. \fIalgs\fP - Address
 of a pointer that will point to an array of returned algorithms
 
 Get a list of supported algorithms for the given \fImethod_type\fP. The
@@ -26,7 +30,7 @@ libssh2_session_flag(session, LIBSSH2_FLAG_COMPRESS, 1) must be called before
 calling this function, otherwise only "none" will be returned.
 
 If successful, the function will allocate and fill the array with supported
-algorithms (the same names as defined in RFC 4253).  The array is not NULL
+algorithms (the same names as defined in RFC 4253). The array is not NULL
 terminated.
 .SH EXAMPLE
 .nf
@@ -41,11 +45,11 @@ session = libssh2_session_init();
 rc = libssh2_session_supported_algs(session,
                                     LIBSSH2_METHOD_CRYPT_CS,
                                     &algorithms);
-if (rc>0) {
+if(rc > 0) {
     /* the call succeeded, do sth. with the list of algorithms
        (e.g. list them)... */
     printf("Supported symmetric algorithms:\\n");
-    for ( i=0; i<rc; i++ )
+    for(i = 0; i < rc; i++)
         printf("\\t%s\\n", algorithms[i]);
 
     /* ... and free the allocated memory when not needed anymore */
@@ -54,14 +58,15 @@ if (rc>0) {
 else {
     /* call failed, error handling */
 }
+.fi
 .SH RETURN VALUE
 On success, a number of returned algorithms (i.e a positive number will be
-returned).  In case of a failure, an error code (a negative number, see below)
-is returned.  0 should never be returned.
+returned). In case of a failure, an error code (a negative number, see below)
+is returned. 0 should never be returned.
 .SH ERRORS
 \fILIBSSH2_ERROR_BAD_USE\fP - Invalid address of algs.
 
-\fILIBSSH2_ERROR_METHOD_NOT_SUPPORTED\fP -  Unknown method type.
+\fILIBSSH2_ERROR_METHOD_NOT_SUPPORTED\fP - Unknown method type.
 
 \fILIBSSH2_ERROR_INVAL\fP - Internal error (normally should not occur).
 
diff --git a/libssh2/docs/libssh2_sftp_close.3 b/libssh2/docs/libssh2_sftp_close.3
index b169b1ba..bf9c4c7f 100644
--- a/libssh2/docs/libssh2_sftp_close.3
+++ b/libssh2/docs/libssh2_sftp_close.3
@@ -1,11 +1,16 @@
-.TH libssh2_sftp_close 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_close 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_close - convenience macro for \fIlibssh2_sftp_close_handle(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
-
+int
+libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_close_handle(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_close_handle.3 b/libssh2/docs/libssh2_sftp_close_handle.3
index 30e299cf..30794d4d 100644
--- a/libssh2/docs/libssh2_sftp_close_handle.3
+++ b/libssh2/docs/libssh2_sftp_close_handle.3
@@ -1,19 +1,22 @@
-.TH libssh2_sftp_close_handle 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_close_handle 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_close_handle - close filehandle
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle);
 
-int 
+int
 libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
 
-int 
+int
 libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle);
-
+.fi
 .SH DESCRIPTION
 \fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP
 or \fBlibssh2_sftp_opendir(3)\fP (which is a macro).
@@ -22,22 +25,19 @@ Close an active LIBSSH2_SFTP_HANDLE. Because files and directories share the
 same underlying storage mechanism these methods may be used
 interchangeably. \fBlibssh2_sftp_close(3)\fP and \fBlibssh2_sftp_closedir(3)\fP
 are macros for \fBlibssh2_sftp_close_handle(3)\fP.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
-
 .SH SEE ALSO
 .BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/docs/libssh2_sftp_closedir.3 b/libssh2/docs/libssh2_sftp_closedir.3
index 3e032a77..c1913d2d 100644
--- a/libssh2/docs/libssh2_sftp_closedir.3
+++ b/libssh2/docs/libssh2_sftp_closedir.3
@@ -1,11 +1,16 @@
-.TH libssh2_sftp_closedir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_closedir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_closedir - convenience macro for \fIlibssh2_sftp_close_handle(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle)
-
+int
+libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle)
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_close_handle(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_fsetstat.3 b/libssh2/docs/libssh2_sftp_fsetstat.3
index e77dd214..c3d8dabc 100644
--- a/libssh2/docs/libssh2_sftp_fsetstat.3
+++ b/libssh2/docs/libssh2_sftp_fsetstat.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_fsetstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_fsetstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_fsetstat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_fsetstat(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
+int
+libssh2_sftp_fsetstat(LIBSSH2_SFTP_HANDLE *handle,
+                      LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_fstat.3 b/libssh2/docs/libssh2_sftp_fstat.3
index 66116a39..b2dfacd9 100644
--- a/libssh2/docs/libssh2_sftp_fstat.3
+++ b/libssh2/docs/libssh2_sftp_fstat.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_fstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_fstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_fstat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_fstat(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
+int
+libssh2_sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
+                   LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_fstat_ex.3 b/libssh2/docs/libssh2_sftp_fstat_ex.3
index 107594cf..65051e58 100644
--- a/libssh2/docs/libssh2_sftp_fstat_ex.3
+++ b/libssh2/docs/libssh2_sftp_fstat_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_fstat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_fstat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_fstat_ex - get or set attributes on an SFTP file handle
 .SH SYNOPSIS
@@ -6,7 +8,7 @@ libssh2_sftp_fstat_ex - get or set attributes on an SFTP file handle
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle,
                       LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat)
 
@@ -16,14 +18,14 @@ libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle,
     libssh2_sftp_fstat_ex((handle), (attrs), 1)
 .fi
 .SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by 
+\fIhandle\fP - SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
 
 \fIattrs\fP - Pointer to an LIBSSH2_SFTP_ATTRIBUTES structure to set file
 metadata from or into depending on the value of setstat.
 
-\fIsetstat\fP - When non-zero, the file's metadata will be updated 
-with the data found in attrs according to the values of attrs->flags 
+\fIsetstat\fP - When non-zero, the file's metadata will be updated
+with the data found in attrs according to the values of attrs->flags
 and other relevant member attributes.
 
 Get or Set statbuf type data for a given LIBSSH2_SFTP_HANDLE instance.
@@ -83,18 +85,18 @@ Test for a pipe or FIFO special file
 .IP LIBSSH2_SFTP_S_ISSOCK
 Test for a socket
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
 .SH AVAILABILITY
 This function has been around since forever, but most of the
diff --git a/libssh2/docs/libssh2_sftp_fstatvfs.3 b/libssh2/docs/libssh2_sftp_fstatvfs.3
index 934d2a10..1546b974 100644
--- a/libssh2/docs/libssh2_sftp_fstatvfs.3
+++ b/libssh2/docs/libssh2_sftp_fstatvfs.3
@@ -1 +1,3 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
 .so man3/libssh2_sftp_statvfs.3
diff --git a/libssh2/docs/libssh2_sftp_fsync.3 b/libssh2/docs/libssh2_sftp_fsync.3
index 646760a0..e9cf3f3f 100644
--- a/libssh2/docs/libssh2_sftp_fsync.3
+++ b/libssh2/docs/libssh2_sftp_fsync.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_fsync 3 "8 Apr 2013" "libssh2 1.4.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_fsync 3 "8 Apr 2013" "libssh2" "libssh2"
 .SH NAME
 libssh2_sftp_fsync - synchronize file to disk
 .SH SYNOPSIS
@@ -17,22 +19,20 @@ For this to work requires fsync@openssh.com support on the server.
 
 \fIhandle\fP - SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
-
 .SH RETURN VALUE
 Returns 0 on success or negative on failure. If used in non-blocking mode, it
 returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
 \fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response
 was received on the socket, or an SFTP operation caused an errorcode
-to be returned by the server.  In particular, this can be returned if
+to be returned by the server. In particular, this can be returned if
 the SSH server does not support the fsync operation: the SFTP subcode
 \fILIBSSH2_FX_OP_UNSUPPORTED\fP will be returned in this case.
-
 .SH AVAILABILITY
 Added in libssh2 1.4.4 and OpenSSH 6.3.
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_sftp_get_channel.3 b/libssh2/docs/libssh2_sftp_get_channel.3
index d1d82bc7..0da7cdac 100644
--- a/libssh2/docs/libssh2_sftp_get_channel.3
+++ b/libssh2/docs/libssh2_sftp_get_channel.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_get_channel 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_get_channel 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2"
 .SH NAME
 libssh2_sftp_get_channel - return the channel of sftp
 .SH SYNOPSIS
@@ -6,8 +8,9 @@ libssh2_sftp_get_channel - return the channel of sftp
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
+LIBSSH2_CHANNEL *
+libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp);
 .fi
-LIBSSH2_CHANNEL *libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp);
 .SH DESCRIPTION
 \fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_init.3 b/libssh2/docs/libssh2_sftp_init.3
index a59d0300..dab613d6 100644
--- a/libssh2/docs/libssh2_sftp_init.3
+++ b/libssh2/docs/libssh2_sftp_init.3
@@ -1,15 +1,18 @@
-.TH libssh2_sftp_init 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_init 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_init - open SFTP channel for the given SSH session.
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
 LIBSSH2_SFTP *
 libssh2_sftp_init(LIBSSH2_SESSION *session);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 Open a channel and initialize the SFTP subsystem. Although the SFTP subsystem
@@ -22,14 +25,14 @@ function.
 .SH RETURN VALUE
 A pointer to the newly allocated SFTP instance or NULL on failure.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to be
 returned by the server.
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
diff --git a/libssh2/docs/libssh2_sftp_last_error.3 b/libssh2/docs/libssh2_sftp_last_error.3
index aadbd5d1..f5993b4d 100644
--- a/libssh2/docs/libssh2_sftp_last_error.3
+++ b/libssh2/docs/libssh2_sftp_last_error.3
@@ -1,24 +1,25 @@
-.TH libssh2_sftp_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_last_error - return the last SFTP-specific error code
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-unsigned long 
+unsigned long
 libssh2_sftp_last_error(LIBSSH2_SFTP *sftp);
-
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 Returns the last error code produced by the SFTP layer. Note that this only
 returns a sensible error code if libssh2 returned LIBSSH2_ERROR_SFTP_PROTOCOL
 in a previous call. Using \fBlibssh2_sftp_last_error(3)\fP without a
 preceding SFTP protocol error, it will return an unspecified value.
-
 .SH RETURN VALUE
 Current error code state of the SFTP instance.
-
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_lstat.3 b/libssh2/docs/libssh2_sftp_lstat.3
index 78c90577..8165cdb8 100644
--- a/libssh2/docs/libssh2_sftp_lstat.3
+++ b/libssh2/docs/libssh2_sftp_lstat.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_lstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_lstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_lstat - convenience macro for \fIlibssh2_sftp_stat_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_lstat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
+int
+libssh2_sftp_lstat(LIBSSH2_SFTP *sftp, const char *path,
+                   LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_stat_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_mkdir.3 b/libssh2/docs/libssh2_sftp_mkdir.3
index 999bd016..193ec09e 100644
--- a/libssh2/docs/libssh2_sftp_mkdir.3
+++ b/libssh2/docs/libssh2_sftp_mkdir.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_mkdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_mkdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_mkdir - convenience macro for \fIlibssh2_sftp_mkdir_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path, long mode);
-
+int
+libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
+                   long mode);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_mkdir_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_mkdir_ex.3 b/libssh2/docs/libssh2_sftp_mkdir_ex.3
index 20df03c3..3e5759dc 100644
--- a/libssh2/docs/libssh2_sftp_mkdir_ex.3
+++ b/libssh2/docs/libssh2_sftp_mkdir_ex.3
@@ -1,20 +1,28 @@
-.TH libssh2_sftp_mkdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_mkdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_mkdir_ex - create a directory on the remote file system
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
-libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len, long mode);
+int
+libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp,
+                      const char *path, unsigned int path_len,
+                      long mode);
 
-int 
-libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path, long mode);
+int
+libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp,
+                   const char *path,
+                   long mode);
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
-\fIpath\fP - full path of the new directory to create. Note that the new 
+\fIpath\fP - full path of the new directory to create. Note that the new
 directory's parents must all exist prior to making this call.
 
 \fIpath_len\fP - length of the full path of the new directory to create.
@@ -25,16 +33,16 @@ Create a directory on the remote file system.
 .SH RETURN VALUE
 Return 0 on success or negative on failure.
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to be
 returned by the server.
 .SH SEE ALSO
 .BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/docs/libssh2_sftp_open.3 b/libssh2/docs/libssh2_sftp_open.3
index 90969860..7918b506 100644
--- a/libssh2/docs/libssh2_sftp_open.3
+++ b/libssh2/docs/libssh2_sftp_open.3
@@ -1,12 +1,18 @@
-.TH libssh2_sftp_open 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_open 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_open - convenience macro for \fIlibssh2_sftp_open_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open(LIBSSH2_SFTP *sftp, const char *path, unsigned long flags, long mode);
-
+libssh2_sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
+                  unsigned long flags,
+                  long mode);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_open_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_open_ex.3 b/libssh2/docs/libssh2_sftp_open_ex.3
index 32cc23fb..f0dced8c 100644
--- a/libssh2/docs/libssh2_sftp_open_ex.3
+++ b/libssh2/docs/libssh2_sftp_open_ex.3
@@ -1,6 +1,8 @@
-.TH libssh2_sftp_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
-libssh2_sftp_open - open filehandle for file on SFTP.
+libssh2_sftp_open_ex - open filehandle for file on SFTP.
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
@@ -8,21 +10,24 @@ libssh2_sftp_open - open filehandle for file on SFTP.
 
 LIBSSH2_SFTP_HANDLE *
 libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, const char *filename,
-                     unsigned int filename_len, unsigned long flags,
-                     long mode, int open_type);
+                     unsigned int filename_len,
+                     unsigned long flags,
+                     long mode,
+                     int open_type);
+.fi
 .SH DESCRIPTION
 \fIsftp\fP - SFTP instance as returned by \fIlibssh2_sftp_init(3)\fP
 
-\fIfilename\fP - Remote file/directory resource to open 
+\fIfilename\fP - Remote file/directory resource to open
 
-\fIfilename_len\fP - Length of filename 
+\fIfilename_len\fP - Length of filename
 
 \fIflags\fP - Any reasonable combination of the LIBSSH2_FXF_* constants:
 .RS
 .IP LIBSSH2_FXF_READ
 Open the file for reading.
 .IP LIBSSH2_FXF_WRITE
-Open the file for writing.  If both this and LIBSSH2_FXF_READ are specified,
+Open the file for writing. If both this and LIBSSH2_FXF_READ are specified,
 the file is opened for both reading and writing.
 .IP LIBSSH2_FXF_APPEND
 Force all writes to append data at the end of the file.
@@ -48,18 +53,17 @@ LIBSSH2_SFTP_OPENDIR (to open a directory).
 A pointer to the newly created LIBSSH2_SFTP_HANDLE instance or NULL on
 failure.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to be
 returned by the server.
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
 .SH SEE ALSO
 .BR libssh2_sftp_close_handle(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_sftp_open_ex.3 b/libssh2/docs/libssh2_sftp_open_ex_r.3
similarity index 64%
rename from libssh2/libssh2/docs/libssh2_sftp_open_ex.3
rename to libssh2/docs/libssh2_sftp_open_ex_r.3
index 32cc23fb..11bb6c17 100644
--- a/libssh2/libssh2/docs/libssh2_sftp_open_ex.3
+++ b/libssh2/docs/libssh2_sftp_open_ex_r.3
@@ -1,28 +1,34 @@
-.TH libssh2_sftp_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_open_ex_r 3 "10 Apr 2023" "libssh2" "libssh2"
 .SH NAME
-libssh2_sftp_open - open filehandle for file on SFTP.
+libssh2_sftp_open_ex_r - open filehandle for file on SFTP.
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
 LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, const char *filename,
-                     unsigned int filename_len, unsigned long flags,
-                     long mode, int open_type);
+libssh2_sftp_open_ex_r(LIBSSH2_SFTP *sftp, const char *filename,
+                       size_t filename_len,
+                       unsigned long flags,
+                       long mode,
+                       int open_type,
+                       LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 \fIsftp\fP - SFTP instance as returned by \fIlibssh2_sftp_init(3)\fP
 
-\fIfilename\fP - Remote file/directory resource to open 
+\fIfilename\fP - Remote file/directory resource to open
 
-\fIfilename_len\fP - Length of filename 
+\fIfilename_len\fP - Length of filename
 
 \fIflags\fP - Any reasonable combination of the LIBSSH2_FXF_* constants:
 .RS
 .IP LIBSSH2_FXF_READ
 Open the file for reading.
 .IP LIBSSH2_FXF_WRITE
-Open the file for writing.  If both this and LIBSSH2_FXF_READ are specified,
+Open the file for writing. If both this and LIBSSH2_FXF_READ are specified,
 the file is opened for both reading and writing.
 .IP LIBSSH2_FXF_APPEND
 Force all writes to append data at the end of the file.
@@ -44,22 +50,28 @@ created. See the LIBSSH2_SFTP_S_* convenience defines in <libssh2_sftp.h>
 
 \fIopen_type\fP - Either of LIBSSH2_SFTP_OPENFILE (to open a file) or
 LIBSSH2_SFTP_OPENDIR (to open a directory).
+
+\fIattrs\fP - Pointer to LIBSSH2_SFTP_ATTRIBUTES struct. See
+libssh2_sftp_fstat_ex for detailed usage.
+
 .SH RETURN VALUE
 A pointer to the newly created LIBSSH2_SFTP_HANDLE instance or NULL on
 failure.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to be
 returned by the server.
 
 \fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
 block.
+.SH AVAILABILITY
+Added in libssh2 1.11.0
 .SH SEE ALSO
 .BR libssh2_sftp_close_handle(3)
-
+.BR libssh2_sftp_fstat_ex(3)
diff --git a/libssh2/docs/libssh2_sftp_open_r.3 b/libssh2/docs/libssh2_sftp_open_r.3
new file mode 100644
index 00000000..2627c9d7
--- /dev/null
+++ b/libssh2/docs/libssh2_sftp_open_r.3
@@ -0,0 +1,25 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_open_r 3 "10 Apr 2023" "libssh2 1.11.0" "libssh2"
+.SH NAME
+libssh2_sftp_open_r - convenience macro for \fIlibssh2_sftp_open_ex_r(3)\fP calls
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+#include <libssh2_sftp.h>
+
+LIBSSH2_SFTP_HANDLE *
+libssh2_sftp_open_r(LIBSSH2_SFTP *sftp, const char *filename,
+                    unsigned long flags,
+                    long mode,
+                    LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
+.SH DESCRIPTION
+This is a macro defined in a public libssh2 header file that is using the
+underlying function \fIlibssh2_sftp_open_ex_r(3)\fP.
+.SH RETURN VALUE
+See \fIlibssh2_sftp_open_ex_r(3)\fP
+.SH ERRORS
+See \fIlibssh2_sftp_open_ex_r(3)\fP
+.SH SEE ALSO
+.BR libssh2_sftp_open_ex_r(3)
diff --git a/libssh2/docs/libssh2_sftp_opendir.3 b/libssh2/docs/libssh2_sftp_opendir.3
index d3451031..fbba5948 100644
--- a/libssh2/docs/libssh2_sftp_opendir.3
+++ b/libssh2/docs/libssh2_sftp_opendir.3
@@ -1,12 +1,16 @@
-.TH libssh2_sftp_opendir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_opendir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_opendir - convenience macro for \fIlibssh2_sftp_open_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 LIBSSH2_SFTP_HANDLE *
 libssh2_sftp_opendir(LIBSSH2_SFTP *sftp, const char *path);
-
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_open_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_posix_rename.3 b/libssh2/docs/libssh2_sftp_posix_rename.3
new file mode 100644
index 00000000..95cbd4de
--- /dev/null
+++ b/libssh2/docs/libssh2_sftp_posix_rename.3
@@ -0,0 +1,24 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_posix_rename 3 "9 May 2024" "libssh2 1.11.1" "libssh2"
+.SH NAME
+libssh2_sftp_rename - convenience macro for \fIlibssh2_sftp_posix_rename_ex(3)\fP calls
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+#include <libssh2_sftp.h>
+
+int
+libssh2_sftp_posix_rename(LIBSSH2_SFTP *sftp,
+                          const char *source_filename,
+                          const char *destination_filename);
+.fi
+.SH DESCRIPTION
+This is a macro defined in a public libssh2 header file that is using the
+underlying function \fIlibssh2_sftp_posix_rename_ex(3)\fP.
+.SH RETURN VALUE
+See \fIlibssh2_sftp_posix_rename_ex(3)\fP
+.SH ERRORS
+See \fIlibssh2_sftp_posix_rename_ex(3)\fP
+.SH SEE ALSO
+.BR libssh2_sftp_posix_rename_ex(3)
diff --git a/libssh2/docs/libssh2_sftp_posix_rename_ex.3 b/libssh2/docs/libssh2_sftp_posix_rename_ex.3
new file mode 100644
index 00000000..03b6c39f
--- /dev/null
+++ b/libssh2/docs/libssh2_sftp_posix_rename_ex.3
@@ -0,0 +1,58 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_posix_rename_ex 3 "9 May 2024" "libssh2 1.11.1" "libssh2"
+.SH NAME
+libssh2_sftp_posix_rename_ex - rename an SFTP file using POSIX semantics
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+#include <libssh2_sftp.h>
+
+int
+libssh2_sftp_posix_rename_ex(LIBSSH2_SFTP *sftp,
+                             const char *source_filename,
+                             size_t source_filename_len,
+                             const char *dest_filename,
+                             size_t dest_filename_len);
+.fi
+.SH DESCRIPTION
+\fIsftp\fP - SFTP instance as returned by
+.BR libssh2_sftp_init(3)
+
+\fIsourcefile\fP - Path and name of the existing filesystem entry
+
+\fIsourcefile_len\fP - Length of the path and name of the existing
+filesystem entry
+
+\fIdestfile\fP - Path and name of the target filesystem entry
+
+\fIdestfile_len\fP - Length of the path and name of the target
+filesystem entry
+
+This function implements the posix-rename@openssh.com extension, which is
+useful when, for example, moving files across filesystems on a remote server.
+SSH_FXP_RENAME does not specify a specific implementation, but many servers
+will attempt to user hard links when moving files using SSH_FXP_RENAME.
+
+If the server does not support posix-rename@openssh.com, this function will
+return LIBSSH2_FX_OP_UNSUPPORTED and you can call libssh2_sftp_rename_ex (3) as
+a backup.
+.SH RETURN VALUE
+Return 0 on success or negative on failure. It returns
+LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
+.SH ERRORS
+\fILIBSSH2_FX_OP_UNSUPPORTED\fP - Server does not support
+posix-rename@openssh.com
+
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
+
+\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
+
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
+
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
+be returned by the server.
+.SH SEE ALSO
+.BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_read.3 b/libssh2/docs/libssh2_sftp_read.3
index 36bc9794..86df3e2b 100644
--- a/libssh2/docs/libssh2_sftp_read.3
+++ b/libssh2/docs/libssh2_sftp_read.3
@@ -1,15 +1,19 @@
-.TH libssh2_sftp_read 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_read 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_read - read data from an SFTP handle
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-ssize_t 
-libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxlen);
-
+ssize_t
+libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle,
+                  char *buffer, size_t buffer_maxlen);
+.fi
 .SH DESCRIPTION
-\fIhandle\fP is the SFTP File Handle as returned by 
+\fIhandle\fP is the SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
 
 \fIbuffer\fP is a pointer to a pre-allocated buffer of at least
@@ -17,23 +21,23 @@ libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxle
 \fIbuffer_maxlen\fP bytes to read data into.
 
 Reads a block of data from an LIBSSH2_SFTP_HANDLE. This method is modelled
-after the POSIX 
+after the POSIX
 .BR read(2)
-function and uses the same calling semantics. 
+function and uses the same calling semantics.
 .BR libssh2_sftp_read(3)
 will attempt to read as much as possible however it may not fill all of buffer
 if the file pointer reaches the end or if further reads would cause the socket
 to block.
 .SH RETURN VALUE
-Number of bytes actually populated into buffer, or negative on failure.  
+Number of bytes actually populated into buffer, or negative on failure.
 It returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
 \fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
 received on the socket, or an SFTP operation caused an errorcode to be
diff --git a/libssh2/docs/libssh2_sftp_readdir.3 b/libssh2/docs/libssh2_sftp_readdir.3
index adecbcbe..9764a8b0 100644
--- a/libssh2/docs/libssh2_sftp_readdir.3
+++ b/libssh2/docs/libssh2_sftp_readdir.3
@@ -1,11 +1,18 @@
-.TH libssh2_sftp_readdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_readdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_readdir - convenience macro for \fIlibssh2_sftp_readdir_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxlen, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
+int
+libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle,
+                     char *buffer, size_t buffer_maxlen,
+                     LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_readdir_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_readdir_ex.3 b/libssh2/docs/libssh2_sftp_readdir_ex.3
index a40e4df8..ef8d7576 100644
--- a/libssh2/docs/libssh2_sftp_readdir_ex.3
+++ b/libssh2/docs/libssh2_sftp_readdir_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_readdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_readdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_readdir_ex - read directory data from an SFTP handle
 .SH SYNOPSIS
@@ -6,55 +8,56 @@ libssh2_sftp_readdir_ex - read directory data from an SFTP handle
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *handle,
                         char *buffer, size_t buffer_maxlen,
                         char *longentry, size_t longentry_maxlen,
                         LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 Reads a block of data from a LIBSSH2_SFTP_HANDLE and returns file entry
 information for the next entry, if any.
 
-\fIhandle\fP - is the SFTP File Handle as returned by 
+\fIhandle\fP - is the SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
 
 \fIbuffer\fP - is a pointer to a pre-allocated buffer of at least
 \fIbuffer_maxlen\fP bytes to read data into.
 
-\fIbuffer_maxlen\fP - is the length of buffer in bytes. If the length of the 
-filename is longer than the space provided by buffer_maxlen it will be 
+\fIbuffer_maxlen\fP - is the length of buffer in bytes. If the length of the
+filename is longer than the space provided by buffer_maxlen it will be
 truncated to fit.
 
 \fIlongentry\fP - is a pointer to a pre-allocated buffer of at least
 \fIlongentry_maxlen\fP bytes to read data into. The format of the `longname'
 field is unspecified by SFTP protocol. It MUST be suitable for use in the
 output of a directory listing command (in fact, the recommended operation for
-a directory listing command is to simply display this data).
+a directory listing command is to display this data).
 
 \fIlongentry_maxlen\fP - is the length of longentry in bytes. If the length of
 the full directory entry is longer than the space provided by
 \fIlongentry_maxlen\fP it will be truncated to fit.
 
-\fIattrs\fP - is a pointer to LIBSSH2_SFTP_ATTRIBUTES storage to populate 
+\fIattrs\fP - is a pointer to LIBSSH2_SFTP_ATTRIBUTES storage to populate
 statbuf style data into.
 .SH RETURN VALUE
 Number of bytes actually populated into buffer (not counting the terminating
-zero), or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN when it would
-otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it isn't
+zero), or negative on failure. It returns LIBSSH2_ERROR_EAGAIN when it would
+otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it is not
 really a failure per se.
 .SH BUG
 Passing in a too small buffer for 'buffer' or 'longentry' when receiving data
 only results in libssh2 1.2.7 or earlier to not copy the entire data amount,
 and it is not possible for the application to tell when it happens!
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to be
 returned by the server.
 
 From 1.2.8, LIBSSH2_ERROR_BUFFER_TOO_SMALL is returned if any of the
diff --git a/libssh2/docs/libssh2_sftp_readlink.3 b/libssh2/docs/libssh2_sftp_readlink.3
index 7425074e..f48da0c1 100644
--- a/libssh2/docs/libssh2_sftp_readlink.3
+++ b/libssh2/docs/libssh2_sftp_readlink.3
@@ -1,13 +1,18 @@
-.TH libssh2_sftp_readlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_readlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_readlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 #define libssh2_sftp_readlink(sftp, path, target, maxlen) \\
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
-    LIBSSH2_SFTP_READLINK)
+    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), \\
+                            (target), (maxlen), \\
+                            LIBSSH2_SFTP_READLINK)
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_realpath.3 b/libssh2/docs/libssh2_sftp_realpath.3
index 33f0fa82..1685622d 100644
--- a/libssh2/docs/libssh2_sftp_realpath.3
+++ b/libssh2/docs/libssh2_sftp_realpath.3
@@ -1,13 +1,18 @@
-.TH libssh2_sftp_realpath 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_realpath 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_realpath - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 #define libssh2_sftp_realpath(sftp, path, target, maxlen) \\
-  libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
-                          LIBSSH2_SFTP_REALPATH)
+    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), \\
+                            (target), (maxlen), \\
+                            LIBSSH2_SFTP_REALPATH)
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_rename.3 b/libssh2/docs/libssh2_sftp_rename.3
index 4939e3c1..7207780b 100644
--- a/libssh2/docs/libssh2_sftp_rename.3
+++ b/libssh2/docs/libssh2_sftp_rename.3
@@ -1,11 +1,18 @@
-.TH libssh2_sftp_rename 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_rename 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_rename - convenience macro for \fIlibssh2_sftp_rename_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename, const char *destination_filename);
-
+int
+libssh2_sftp_rename(LIBSSH2_SFTP *sftp,
+                    const char *source_filename,
+                    const char *destination_filename);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_rename_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_rename_ex.3 b/libssh2/docs/libssh2_sftp_rename_ex.3
index 20a3b9db..8feb4d21 100644
--- a/libssh2/docs/libssh2_sftp_rename_ex.3
+++ b/libssh2/docs/libssh2_sftp_rename_ex.3
@@ -1,56 +1,63 @@
-.TH libssh2_sftp_rename_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_rename_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_rename_ex - rename an SFTP file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
-libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename, unsigned int source_filename_len, const char *dest_filename, unsigned int dest_filename_len, long flags);
-
-int 
-libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename, const char *dest_filename);
-
+int
+libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp,
+                       const char *source_filename,
+                       unsigned int source_filename_len,
+                       const char *dest_filename,
+                       unsigned int dest_filename_len,
+                       long flags);
+
+int
+libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp,
+                       const char *source_filename,
+                       const char *dest_filename);
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 \fIsourcefile\fP - Path and name of the existing filesystem entry
 
-\fIsourcefile_len\fP - Length of the path and name of the existing 
+\fIsourcefile_len\fP - Length of the path and name of the existing
 filesystem entry
 
 \fIdestfile\fP - Path and name of the target filesystem entry
 
-\fIdestfile_len\fP - Length of the path and name of the target 
+\fIdestfile_len\fP - Length of the path and name of the target
 filesystem entry
 
-\fIflags\fP - 
+\fIflags\fP -
 Bitmask flags made up of LIBSSH2_SFTP_RENAME_* constants.
 
-Rename a filesystem object on the remote filesystem. The semantics of 
-this command typically include the ability to move a filesystem object 
-between folders and/or filesystem mounts. If the LIBSSH2_SFTP_RENAME_OVERWRITE 
-flag is not set and the destfile entry already exists, the operation 
-will fail. Use of the other two flags indicate a preference (but not a 
-requirement) for the remote end to perform an atomic rename operation 
+Rename a filesystem object on the remote filesystem. The semantics of
+this command typically include the ability to move a filesystem object
+between folders and/or filesystem mounts. If the LIBSSH2_SFTP_RENAME_OVERWRITE
+flag is not set and the destfile entry already exists, the operation
+will fail. Use of the other two flags indicate a preference (but not a
+requirement) for the remote end to perform an atomic rename operation
 and/or using native system calls when possible.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
-
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_rewind.3 b/libssh2/docs/libssh2_sftp_rewind.3
index 92d99e2b..5e4ddde4 100644
--- a/libssh2/docs/libssh2_sftp_rewind.3
+++ b/libssh2/docs/libssh2_sftp_rewind.3
@@ -1,11 +1,16 @@
-.TH libssh2_sftp_rewind 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_rewind 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_rewind - convenience macro for \fIlibssh2_sftp_seek64(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_rewind(LIBSSH2_SFTP_HANDLE *handle);
-
+int
+libssh2_sftp_rewind(LIBSSH2_SFTP_HANDLE *handle);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_seek64(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_rmdir.3 b/libssh2/docs/libssh2_sftp_rmdir.3
index 0d4b67f2..523534ac 100644
--- a/libssh2/docs/libssh2_sftp_rmdir.3
+++ b/libssh2/docs/libssh2_sftp_rmdir.3
@@ -1,12 +1,16 @@
-.TH libssh2_sftp_rmdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_rmdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_rmdir - convenience macro for \fIlibssh2_sftp_rmdir_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 #define libssh2_sftp_rmdir(sftp, path) \\
     libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_rmdir_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_rmdir_ex.3 b/libssh2/docs/libssh2_sftp_rmdir_ex.3
index daa85cf0..79a73bfa 100644
--- a/libssh2/docs/libssh2_sftp_rmdir_ex.3
+++ b/libssh2/docs/libssh2_sftp_rmdir_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_rmdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_rmdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_rmdir_ex - remove an SFTP directory
 .SH SYNOPSIS
@@ -6,12 +8,14 @@ libssh2_sftp_rmdir_ex - remove an SFTP directory
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
-                          unsigned int path_len);
+int
+libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
+                      unsigned int path_len);
+.fi
 .SH DESCRIPTION
 Remove a directory from the remote file system.
 
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 \fIsourcefile\fP - Full path of the existing directory to remove.
@@ -19,18 +23,18 @@ Remove a directory from the remote file system.
 \fIsourcefile_len\fP - Length of the full path of the existing directory to
 remove.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_seek.3 b/libssh2/docs/libssh2_sftp_seek.3
index ccf5e106..87782de1 100644
--- a/libssh2/docs/libssh2_sftp_seek.3
+++ b/libssh2/docs/libssh2_sftp_seek.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_seek 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_seek 3 "22 Dec 2008" "libssh2 1.0" "libssh2"
 .SH NAME
 libssh2_sftp_seek - set the read/write position indicator within a file
 .SH SYNOPSIS
@@ -6,20 +8,23 @@ libssh2_sftp_seek - set the read/write position indicator within a file
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset);
+void
+libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle,
+                  size_t offset);
+.fi
 .SH DESCRIPTION
 Deprecated function. Use \fIlibssh2_sftp_seek64(3)\fP instead!
 
-\fIhandle\fP - SFTP File Handle as returned by 
+\fIhandle\fP - SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
 
 \fIoffset\fP - Number of bytes from the beginning of file to seek to.
 
-Move the file handle's internal pointer to an arbitrary location. 
-Note that libssh2 implements file pointers as a localized concept to make 
-file access appear more POSIX like. No packets are exchanged with the server 
-during a seek operation. The localized file pointer is simply used as a 
-convenience offset during read/write operations.
+Move the file handle's internal pointer to an arbitrary location.
+Note that libssh2 implements file pointers as a localized concept to make
+file access appear more POSIX like. No packets are exchanged with the server
+during a seek operation. The localized file pointer is used as a convenience
+offset during read/write operations.
 .SH SEE ALSO
 .BR libssh2_sftp_open_ex(3),
 .BR libssh2_sftp_seek64(3)
diff --git a/libssh2/docs/libssh2_sftp_seek64.3 b/libssh2/docs/libssh2_sftp_seek64.3
index 57c9a485..d40cc84b 100644
--- a/libssh2/docs/libssh2_sftp_seek64.3
+++ b/libssh2/docs/libssh2_sftp_seek64.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_seek64 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_seek64 3 "22 Dec 2008" "libssh2" "libssh2"
 .SH NAME
 libssh2_sftp_seek64 - set the read/write position within a file
 .SH SYNOPSIS
@@ -6,10 +8,12 @@ libssh2_sftp_seek64 - set the read/write position within a file
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle,
-                         libssh2_uint64_t offset);
+void
+libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle,
+                    libssh2_uint64_t offset);
+.fi
 .SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by 
+\fIhandle\fP - SFTP File Handle as returned by
 .BR libssh2_sftp_open_ex(3)
 
 \fIoffset\fP - Number of bytes from the beginning of file to seek to.
@@ -17,8 +21,8 @@ void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle,
 Move the file handle's internal pointer to an arbitrary location. libssh2
 implements file pointers as a localized concept to make file access appear
 more POSIX like. No packets are exchanged with the server during a seek
-operation. The localized file pointer is simply used as a convenience offset
-during read/write operations.
+operation. The localized file pointer is used as a convenience offset during
+read/write operations.
 
 You MUST NOT seek during writing or reading a file with SFTP, as the internals
 use outstanding packets and changing the "file position" during transit will
diff --git a/libssh2/docs/libssh2_sftp_setstat.3 b/libssh2/docs/libssh2_sftp_setstat.3
index 198703e0..3bd42f5f 100644
--- a/libssh2/docs/libssh2_sftp_setstat.3
+++ b/libssh2/docs/libssh2_sftp_setstat.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_setstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_setstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_setstat - convenience macro for \fIlibssh2_sftp_stat_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_setstat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attr);
-
+int
+libssh2_sftp_setstat(LIBSSH2_SFTP *sftp, const char *path,
+                     LIBSSH2_SFTP_ATTRIBUTES *attr);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_stat_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_shutdown.3 b/libssh2/docs/libssh2_sftp_shutdown.3
index 42cc1c49..d0f097ba 100644
--- a/libssh2/docs/libssh2_sftp_shutdown.3
+++ b/libssh2/docs/libssh2_sftp_shutdown.3
@@ -1,24 +1,25 @@
-.TH libssh2_sftp_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_shutdown - shut down an SFTP session
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp);
-
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
-Destroys a previously initialized SFTP session and frees all resources 
+Destroys a previously initialized SFTP session and frees all resources
 associated with it.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_stat.3 b/libssh2/docs/libssh2_sftp_stat.3
index 96cb2a5a..30e28a24 100644
--- a/libssh2/docs/libssh2_sftp_stat.3
+++ b/libssh2/docs/libssh2_sftp_stat.3
@@ -1,11 +1,17 @@
-.TH libssh2_sftp_stat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_stat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_stat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_stat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
+int
+libssh2_sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
+                  LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_stat_ex.3 b/libssh2/docs/libssh2_sftp_stat_ex.3
index 2fd9507f..3ba536e0 100644
--- a/libssh2/docs/libssh2_sftp_stat_ex.3
+++ b/libssh2/docs/libssh2_sftp_stat_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_stat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_stat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_stat_ex - get status about an SFTP file
 .SH SYNOPSIS
@@ -6,19 +8,21 @@ libssh2_sftp_stat_ex - get status about an SFTP file
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path,
-                         unsigned int path_len, int stat_type,
-                         LIBSSH2_SFTP_ATTRIBUTES *attrs);
+int
+libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path,
+                     unsigned int path_len, int stat_type,
+                     LIBSSH2_SFTP_ATTRIBUTES *attrs);
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 \fIpath\fP - Remote filesystem object to stat/lstat/setstat.
 
-\fIpath_len\fP - Length of the name of the remote filesystem object 
+\fIpath_len\fP - Length of the name of the remote filesystem object
 to stat/lstat/setstat.
 
-\fIstat_type\fP - One of the three constants specifying the type of 
+\fIstat_type\fP - One of the three constants specifying the type of
 stat operation to perform:
 
 .br
@@ -34,9 +38,9 @@ metadata from or into depending on the value of stat_type.
 Get or Set statbuf type data on a remote filesystem object. When getting
 statbuf data,
 .BR libssh2_sftp_stat(3)
-will follow all symlinks, while 
+will follow all symlinks, while
 .BR libssh2_sftp_lstat(3)
-will return data about the object encountered, even if that object 
+will return data about the object encountered, even if that object
 happens to be a symlink.
 
 The LIBSSH2_SFTP_ATTRIBUTES struct looks like this:
@@ -57,18 +61,18 @@ struct LIBSSH2_SFTP_ATTRIBUTES {
 };
 .fi
 .SH RETURN VALUE
-Returns 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
+Returns 0 on success or negative on failure. It returns LIBSSH2_ERROR_EAGAIN
 when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
+number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_statvfs.3 b/libssh2/docs/libssh2_sftp_statvfs.3
index 6327030a..75b23847 100644
--- a/libssh2/docs/libssh2_sftp_statvfs.3
+++ b/libssh2/docs/libssh2_sftp_statvfs.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_statvfs 3 "22 May 2010" "libssh2 1.2.6" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_statvfs 3 "22 May 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_sftp_statvfs, libssh2_sftp_fstatvfs - get file system statistics
 .SH SYNOPSIS
@@ -30,7 +32,6 @@ statvfs@openssh.com and fstatvfs@openssh.com extension support on the server.
 
 \fIst\fP - Pointer to a LIBSSH2_SFTP_STATVFS structure to place file system
 statistics into.
-
 .SH DATA TYPES
 LIBSSH2_SFTP_STATVFS is a typedefed struct that is defined as below
 
@@ -58,17 +59,16 @@ The field \fIf_flag\fP is a bit mask. Bits are defined as follows:
 Read-only file system.
 .IP LIBSSH2_SFTP_ST_NOSUID
 Set-user-ID/set-group-ID bits are ignored by \fBexec\fP(3).
-
 .SH RETURN VALUE
 Returns 0 on success or negative on failure. If used in non-blocking mode, it
 returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
 \fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
 received on the socket, or an SFTP operation caused an errorcode to be returned
diff --git a/libssh2/docs/libssh2_sftp_symlink.3 b/libssh2/docs/libssh2_sftp_symlink.3
index 3de7b290..8fb70df0 100644
--- a/libssh2/docs/libssh2_sftp_symlink.3
+++ b/libssh2/docs/libssh2_sftp_symlink.3
@@ -1,13 +1,17 @@
-.TH libssh2_sftp_symlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_symlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_symlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
 .nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
 #define libssh2_sftp_symlink(sftp, orig, linkpath) \\
     libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), \\
                             strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_symlink_ex.3 b/libssh2/docs/libssh2_sftp_symlink_ex.3
index fc0bc936..e4dad4be 100644
--- a/libssh2/docs/libssh2_sftp_symlink_ex.3
+++ b/libssh2/docs/libssh2_sftp_symlink_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_symlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_symlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_symlink_ex - read or set a symbolic link
 .SH SYNOPSIS
@@ -6,19 +8,20 @@ libssh2_sftp_symlink_ex - read or set a symbolic link
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
                         unsigned int path_len, char *target,
                         unsigned int target_len, int link_type);
+.fi
 .SH DESCRIPTION
 Create a symlink or read out symlink information from the remote side.
 
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 \fIpath\fP - Remote filesystem object to create a symlink from or resolve.
 
-\fIpath_len\fP - Length of the name of the remote filesystem object to 
+\fIpath_len\fP - Length of the name of the remote filesystem object to
 create a symlink from or resolve.
 
 \fItarget\fP - a pointer to a buffer. The buffer has different uses depending
@@ -34,7 +37,7 @@ into.
 
 \fItarget_len\fP - Length of the name of the remote filesystem target object.
 
-\fIlink_type\fP - One of the three previously mentioned constants which 
+\fIlink_type\fP - One of the three previously mentioned constants which
 determines the resulting behavior of this function.
 
 These are convenience macros:
@@ -56,7 +59,7 @@ number of bytes it copied to the target buffer (not including the terminating
 zero) or negative on failure.
 
 It returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 
 From 1.2.8, LIBSSH2_ERROR_BUFFER_TOO_SMALL is returned if the given 'target'
 buffer is too small to fit the requested object name.
@@ -65,15 +68,14 @@ Passing in a too small buffer when receiving data only results in libssh2
 1.2.7 or earlier to not copy the entire data amount, and it is not possible
 for the application to tell when it happens!
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
-
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_tell.3 b/libssh2/docs/libssh2_sftp_tell.3
index 2ff1fbad..88b65370 100644
--- a/libssh2/docs/libssh2_sftp_tell.3
+++ b/libssh2/docs/libssh2_sftp_tell.3
@@ -1,13 +1,16 @@
-.TH libssh2_sftp_tell 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_tell 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_tell - get the current read/write position indicator for a file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-size_t 
+size_t
 libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle);
-
+.fi
 .SH DESCRIPTION
 \fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP.
 
diff --git a/libssh2/docs/libssh2_sftp_tell64.3 b/libssh2/docs/libssh2_sftp_tell64.3
index 827601f1..013e7dad 100644
--- a/libssh2/docs/libssh2_sftp_tell64.3
+++ b/libssh2/docs/libssh2_sftp_tell64.3
@@ -1,13 +1,16 @@
-.TH libssh2_sftp_tell64 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_tell64 3 "22 Dec 2008" "libssh2 1.0" "libssh2"
 .SH NAME
 libssh2_sftp_tell64 - get the current read/write position indicator for a file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
 libssh2_uint64_t
 libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle);
-
+.fi
 .SH DESCRIPTION
 \fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP
 
diff --git a/libssh2/docs/libssh2_sftp_unlink.3 b/libssh2/docs/libssh2_sftp_unlink.3
index 32bbbf96..da4874c1 100644
--- a/libssh2/docs/libssh2_sftp_unlink.3
+++ b/libssh2/docs/libssh2_sftp_unlink.3
@@ -1,11 +1,16 @@
-.TH libssh2_sftp_unlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_unlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_sftp_unlink - convenience macro for \fIlibssh2_sftp_unlink_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
+#include <libssh2_sftp.h>
 
-int libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
-
+int
+libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_unlink_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_sftp_unlink_ex.3 b/libssh2/docs/libssh2_sftp_unlink_ex.3
index 6672a8c3..e92df5f6 100644
--- a/libssh2/docs/libssh2_sftp_unlink_ex.3
+++ b/libssh2/docs/libssh2_sftp_unlink_ex.3
@@ -1,42 +1,42 @@
-.TH libssh2_sftp_unlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_unlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_unlink_ex - unlink an SFTP file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int
 libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename, unsigned int filename_len);
 
-int 
+int
 libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
-
+.fi
 .SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
+\fIsftp\fP - SFTP instance as returned by
 .BR libssh2_sftp_init(3)
 
 \fIfilename\fP - Path and name of the existing filesystem entry
 
-\fIfilename_len\fP - Length of the path and name of the existing 
+\fIfilename_len\fP - Length of the path and name of the existing
 filesystem entry
 
 Unlink (delete) a file from the remote filesystem.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
-
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)
diff --git a/libssh2/docs/libssh2_sftp_write.3 b/libssh2/docs/libssh2_sftp_write.3
index 8d819129..81802216 100644
--- a/libssh2/docs/libssh2_sftp_write.3
+++ b/libssh2/docs/libssh2_sftp_write.3
@@ -1,4 +1,6 @@
-.TH libssh2_sftp_write 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sftp_write 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_sftp_write - write SFTP data
 .SH SYNOPSIS
@@ -6,9 +8,11 @@ libssh2_sftp_write - write SFTP data
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle,
-                           const char *buffer,
-                           size_t count);
+ssize_t
+libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle,
+                   const char *buffer,
+                   size_t count);
+.fi
 .SH DESCRIPTION
 \fBlibssh2_sftp_write(3)\fP writes a block of data to the SFTP server. This
 method is modeled after the POSIX write() function and uses the same calling
@@ -25,22 +29,21 @@ possible to write all bytes as requested.
 put it into a single SFTP protocol packet. This means that to get maximum
 performance when sending larger files, you should try to always pass in at
 least 32K of data to this function.
-
 .SH WRITE AHEAD
 Starting in libssh2 version 1.2.8, the default behavior of libssh2 is to
 create several smaller outgoing packets for all data you pass to this function
 and it will return a positive number as soon as the first packet is
 acknowledged from the server.
 
-This has the effect that sometimes more data has been sent off but isn't acked
+This has the effect that sometimes more data has been sent off but is not acked
 yet when this function returns, and when this function is subsequently called
 again to write more data, libssh2 will immediately figure out that the data is
 already received remotely.
 
 In most normal situation this should not cause any problems, but it should be
-noted that if you've once called libssh2_sftp_write() with data and it returns
-short, you MUST still assume that the rest of the data might've been cached so
-you need to make sure you don't alter that data and think that the version you
+noted that if you have once called libssh2_sftp_write() with data and it returns
+short, you MUST still assume that the rest of the data might have been cached so
+you need to make sure you do not alter that data and think that the version you
 have in your next function invoke will be detected or used.
 
 The reason for this funny behavior is that SFTP can only send 32K data in each
@@ -51,21 +54,20 @@ latency connections. And we want that.
 Actual number of bytes written or negative on failure.
 
 If used in non-blocking mode, it returns LIBSSH2_ERROR_EAGAIN when it would
-otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it isn't
+otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it is not
 really a failure per se.
 
 If this function returns 0 (zero) it should not be considered an error, but
-simply that there was no error but yet no payload data got sent to the other
-end.
+that there was no error but yet no payload data got sent to the other end.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
+\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
+received on the socket, or an SFTP operation caused an errorcode to
 be returned by the server.
 .SH SEE ALSO
 .BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/docs/libssh2_sign_sk.3 b/libssh2/docs/libssh2_sign_sk.3
new file mode 100644
index 00000000..57b742b1
--- /dev/null
+++ b/libssh2/docs/libssh2_sign_sk.3
@@ -0,0 +1,87 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_sign_sk 3 "1 Jun 2022" "libssh2 1.10.0" "libssh2"
+.SH NAME
+libssh2_sign_sk - Create a signature from a FIDO2 authenticator.
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_sign_sk(LIBSSH2_SESSION *session,
+                unsigned char **sig,
+                size_t *sig_len,
+                const unsigned char *data,
+                size_t data_len,
+                void **abstract);
+
+typedef struct _LIBSSH2_PRIVKEY_SK {
+    int algorithm;
+    uint8_t flags;
+    const char *application;
+    const unsigned char *key_handle;
+    size_t handle_len;
+    LIBSSH2_USERAUTH_SK_SIGN_FUNC((*sign_callback));
+    void **orig_abstract;
+} LIBSSH2_PRIVKEY_SK;
+.fi
+.SH DESCRIPTION
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIsig\fP - A pointer to a buffer in which to place the signature. The caller
+is responsible for freeing the signature with LIBSSH2_FREE.
+
+\fIsig_len\fP - A pointer to the length of the sig parameter.
+
+\fIdata\fP - The data to sign.
+
+\fIdata_len\fP - The length of the data parameter.
+
+\fIabstract\fP - A pointer to a pointer to a LIBSSH2_PRIVKEY_SK. See
+description below.
+
+Create a signature from a FIDO2 authenticator, using either the
+sk-ssh-ed25519@openssh.com or sk-ecdsa-sha2-nistp256@openssh.com key
+exchange algorithms.
+
+The abstract parameter is a pointer to a pointer due to the internal workings
+of libssh2. The LIBSSH2_PRIVKEY_SK must be completely filled out, and the
+caller is responsible for all memory management of its fields.
+
+\fIalgorithm\fP - The signing algorithm to use. Possible values are
+LIBSSH2_HOSTKEY_TYPE_ED25519 and LIBSSH2_HOSTKEY_TYPE_ECDSA_256.
+
+\fIflags\fP - A bitmask specifying options for the authenticator. When
+LIBSSH2_SK_PRESENCE_REQUIRED is set, the authenticator requires a touch. When
+LIBSSH2_SK_VERIFICATION_REQUIRED is set, the authenticator requires a PIN.
+Many servers and authenticators do not work properly when
+LIBSSH2_SK_PRESENCE_REQUIRED is not set.
+
+\fIapplication\fP - A user-defined string to use as the RP name for the
+authenticator. Usually "ssh:".
+
+\fIkey_handle\fP - The key handle to use for the authenticator's allow list.
+
+\fIhandle_len\fP - The length of the key_handle parameter.
+
+\fIabstract\fP - User-defined data. When a PIN is required, use this to pass in
+the PIN, or a function pointer to retrieve the PIN.
+
+\fIkey_handle\fP The decoded key handle from the private key file.
+
+\fIhandle_len\fP The length of the key_handle parameter.
+
+\fIsign_callback\fP - Responsible for communicating with the hardware
+authenticator to generate a signature. On success, the signature information
+must be placed in the `\fIsig_info\fP sig_info parameter and the callback must
+return 0. On failure, it should return a negative number. See
+.BR libssh2_userauth_publickey_sk(3)
+ for more information.
+
+\fIorig_abstract\fP - User-defined data. When a PIN is required, use this to
+pass in the PIN, or a function pointer to retrieve the PIN.
+.SH RETURN VALUE
+Return 0 on success or negative on failure.
+.SH SEE ALSO
+.BR libssh2_userauth_publickey_sk(3)
diff --git a/libssh2/docs/libssh2_trace.3 b/libssh2/docs/libssh2_trace.3
index 4d01bf7e..c3be3877 100644
--- a/libssh2/docs/libssh2_trace.3
+++ b/libssh2/docs/libssh2_trace.3
@@ -1,11 +1,15 @@
-.TH libssh2_trace 3 "26 Dec 2008" "libssh2 1.0" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_trace 3 "26 Dec 2008" "libssh2 1.0" "libssh2"
 .SH NAME
 libssh2_trace - enable debug info from inside libssh2
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
-
+void
+libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
+.fi
 .SH DESCRIPTION
 This is a function present in the library that can be used to get debug info
 from within libssh2 when it is running. Helpful when trying to trace or debug
diff --git a/libssh2/docs/libssh2_trace_sethandler.3 b/libssh2/docs/libssh2_trace_sethandler.3
index 57d84ba9..453d468a 100644
--- a/libssh2/docs/libssh2_trace_sethandler.3
+++ b/libssh2/docs/libssh2_trace_sethandler.3
@@ -1,4 +1,6 @@
-.TH libssh2_trace_sethandler 3 "15 Jan 2010" "libssh2 1.2.3" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_trace_sethandler 3 "15 Jan 2010" "libssh2" "libssh2"
 .SH NAME
 libssh2_trace_sethandler - set a trace output handler
 .SH SYNOPSIS
@@ -6,19 +8,21 @@ libssh2_trace_sethandler - set a trace output handler
 #include <libssh2.h>
 
 typedef void (*libssh2_trace_handler_func)(LIBSSH2_SESSION *session,
-                                           void* context,
+                                           void *context,
                                            const char *data,
                                            size_t length);
 
-int libssh2_trace_sethandler(LIBSSH2_SESSION *session,
-                             void* context,
-                             libssh2_trace_handler_func callback);
+int
+libssh2_trace_sethandler(LIBSSH2_SESSION *session,
+                         void *context,
+                         libssh2_trace_handler_func callback);
+.fi
 .SH DESCRIPTION
 libssh2_trace_sethandler installs a trace output handler for your application.
 By default, when tracing has been switched on via a call to libssh2_trace(),
-all output is written to stderr.  By calling this method and passing a
+all output is written to stderr. By calling this method and passing a
 function pointer that matches the libssh2_trace_handler_func prototype,
-libssh2 will call back as it generates trace output.  This can be used to
+libssh2 will call back as it generates trace output. This can be used to
 capture the trace output and put it into a log file or diagnostic window.
 This function has no effect unless libssh2 was built to support this option,
 and a typical "release build" might not.
diff --git a/libssh2/docs/libssh2_userauth_authenticated.3 b/libssh2/docs/libssh2_userauth_authenticated.3
index 786e0f0e..11568c46 100644
--- a/libssh2/docs/libssh2_userauth_authenticated.3
+++ b/libssh2/docs/libssh2_userauth_authenticated.3
@@ -1,20 +1,21 @@
-.TH libssh2_userauth_authenticated 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_authenticated 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_userauth_authenticated - return authentication status
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int 
+int
 libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
-
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 Indicates whether or not the named session has been successfully authenticated.
-
 .SH RETURN VALUE
 Returns 1 if authenticated and 0 if not.
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_userauth_banner.3 b/libssh2/docs/libssh2_userauth_banner.3
new file mode 100644
index 00000000..1369fa5f
--- /dev/null
+++ b/libssh2/docs/libssh2_userauth_banner.3
@@ -0,0 +1,33 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_banner 3 "1 Jun 2021" "libssh2 1.9.0" "libssh2"
+.SH NAME
+libssh2_userauth_banner - get the server's userauth banner message
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_userauth_banner(LIBSSH2_SESSION *session, char **banner);
+.fi
+.SH DESCRIPTION
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIbanner\fP - Should point to a pointer that gets filled with banner message.
+
+After an authentication has been attempted, such as a
+\fBSSH_USERAUTH_NONE\fP request sent by
+.BR libssh2_userauth_list(3) ,
+this function can be called to retrieve the userauth banner sent by
+the server. If no such banner is sent, or if an authentication has not
+yet been attempted, returns LIBSSH2_ERROR_MISSING_USERAUTH_BANNER.
+.SH RETURN VALUE
+On success returns 0 and an UTF-8 NUL-terminated string is stored in the
+\fIbanner\fP. This string is internally managed by libssh2 and will be
+deallocated upon session termination.
+On failure returns
+LIBSSH2_ERROR_MISSING_USERAUTH_BANNER.
+.SH SEE ALSO
+.BR libssh2_session_init_ex(3),
+.BR libssh2_userauth_list(3)
diff --git a/libssh2/docs/libssh2_userauth_hostbased_fromfile.3 b/libssh2/docs/libssh2_userauth_hostbased_fromfile.3
index 21153561..e29880f0 100644
--- a/libssh2/docs/libssh2_userauth_hostbased_fromfile.3
+++ b/libssh2/docs/libssh2_userauth_hostbased_fromfile.3
@@ -1,11 +1,20 @@
-.TH libssh2_userauth_hostbased_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_hostbased_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_userauth_hostbased_fromfile - convenience macro for \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_userauth_hostbased_fromfile(LIBSSH2_SESSION *session, const char *username, const char *publickey, const char *privatekey, const char *passphrase, const char *hostname);
-
+int
+libssh2_userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
+                                    const char *username,
+                                    const char *publickey,
+                                    const char *privatekey,
+                                    const char *passphrase,
+                                    const char *hostname);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3 b/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3
index a65f8029..c37f5561 100644
--- a/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3
+++ b/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3
@@ -1,12 +1,12 @@
-.TH libssh2_userauth_hostbased_fromfile_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_hostbased_fromfile_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_userauth_hostbased_fromfile_ex - TODO
 .SH SYNOPSIS
-
+.nf
+.fi
 .SH DESCRIPTION
-
 .SH RETURN VALUE
-
 .SH ERRORS
-
 .SH SEE ALSO
diff --git a/libssh2/docs/libssh2_userauth_keyboard_interactive.3 b/libssh2/docs/libssh2_userauth_keyboard_interactive.3
index a85de321..902cc5d2 100644
--- a/libssh2/docs/libssh2_userauth_keyboard_interactive.3
+++ b/libssh2/docs/libssh2_userauth_keyboard_interactive.3
@@ -1,14 +1,17 @@
-.TH libssh2_userauth_keyboard_interactive 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_keyboard_interactive 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_userauth_keyboard_interactive - convenience macro for \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP calls
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
+#include <libssh2.h>
 
 int
 libssh2_userauth_keyboard_interactive(LIBSSH2_SESSION* session,
                                       const char *username,
-           LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*response_callback)));
+                 LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*response_callback)));
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3 b/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3
index ada012a2..91b0e72e 100644
--- a/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3
+++ b/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3
@@ -1,4 +1,6 @@
-.TH libssh2_userauth_keyboard_interactive_ex 3 "8 Mar 2008" "libssh2 0.19" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_keyboard_interactive_ex 3 "8 Mar 2008" "libssh2 0.19" "libssh2"
 .SH NAME
 libssh2_userauth_keyboard_interactive_ex - authenticate a session using
 keyboard-interactive authentication
@@ -10,7 +12,8 @@ int
 libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *session,
                                          const char *username,
                                          unsigned int username_len,
-            LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(*response_callback));
+                   LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(*response_callback));
+.fi
 .SH DESCRIPTION
 \fIsession\fP - Session instance as returned by
 \fIlibssh2_session_init_ex(3)\fP.
@@ -28,13 +31,13 @@ control. Responses will be sent to the host. String values will be free(3)ed
 by the library. The callback prototype must match this:
 
 .nf
- void response(const char *name,
-               int name_len, const char *instruction,
-               int instruction_len,
-               int num_prompts,
-               const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-               LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-               void **abstract);
+void response(const char *name,
+              int name_len, const char *instruction,
+              int instruction_len,
+              int num_prompts,
+              const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
+              LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
+              void **abstract);
 .fi
 
 Attempts keyboard-interactive (challenge/response) authentication.
@@ -44,15 +47,15 @@ requesting actual password as response, but it is not required by the
 protocol, and various authentication schemes, such as smartcard authentication
 may use keyboard-interactive authentication type too.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
+Return 0 on success or negative on failure. It returns LIBSSH2_ERROR_EAGAIN
 when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
+number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fLIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
+\fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
 or public/private key.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_userauth_list.3 b/libssh2/docs/libssh2_userauth_list.3
index de349f10..e4d23f8a 100644
--- a/libssh2/docs/libssh2_userauth_list.3
+++ b/libssh2/docs/libssh2_userauth_list.3
@@ -1,4 +1,6 @@
-.TH libssh2_userauth_list 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_list 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_userauth_list - list supported authentication methods
 .SH SYNOPSIS
@@ -6,10 +8,12 @@ libssh2_userauth_list - list supported authentication methods
 #include <libssh2.h>
 
 char *
-libssh2_userauth_list(LIBSSH2_SESSION *session, const char *username,
+libssh2_userauth_list(LIBSSH2_SESSION *session,
+                      const char *username,
                       unsigned int username_len);
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIusername\fP - Username which will be used while authenticating. Note that
@@ -27,10 +31,10 @@ authentication succeeds, this method with return NULL. This case may be
 distinguished from a failing case by examining
 \fIlibssh2_userauth_authenticated(3)\fP.
 .SH RETURN VALUE
-On success a comma delimited list of supported authentication schemes.  This
-list is internally managed by libssh2.  On failure returns NULL.
+On success a comma delimited list of supported authentication schemes. This
+list is internally managed by libssh2. On failure returns NULL.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
diff --git a/libssh2/docs/libssh2_userauth_password.3 b/libssh2/docs/libssh2_userauth_password.3
index 15e55118..61fcdbb1 100644
--- a/libssh2/docs/libssh2_userauth_password.3
+++ b/libssh2/docs/libssh2_userauth_password.3
@@ -1,13 +1,17 @@
-.TH libssh2_userauth_password 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_password 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_userauth_password - convenience macro for \fIlibssh2_userauth_password_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-int libssh2_userauth_password(LIBSSH2_SESSION *session,
-                              const char *username,
-                              const char *password);
-
+int
+libssh2_userauth_password(LIBSSH2_SESSION *session,
+                          const char *username,
+                          const char *password);
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_userauth_password_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_userauth_password_ex.3 b/libssh2/docs/libssh2_userauth_password_ex.3
index dc9e1083..e2bd20f2 100644
--- a/libssh2/docs/libssh2_userauth_password_ex.3
+++ b/libssh2/docs/libssh2_userauth_password_ex.3
@@ -1,22 +1,27 @@
-.TH libssh2_userauth_password_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_password_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_userauth_password_ex - authenticate a session with username and password
 .SH SYNOPSIS
-#include <libssh2.h>
 .nf
-int libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
-                    const char *username,
-                    unsigned int username_len,
-                    const char *password,
-                    unsigned int password_len,
-                    LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)));
+#include <libssh2.h>
+
+int
+libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
+                             const char *username,
+                             unsigned int username_len,
+                             const char *password,
+                             unsigned int password_len,
+                           LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)));
 
 #define libssh2_userauth_password(session, username, password) \\
- libssh2_userauth_password_ex((session), (username), \\
-                              strlen(username), \\
-                              (password), strlen(password), NULL)
+     libssh2_userauth_password_ex((session), (username), \\
+                                  strlen(username), \\
+                                  (password), strlen(password), NULL)
+.fi
 .SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
+\fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
 \fIusername\fP - Name of user to attempt plain password authentication for.
@@ -27,31 +32,29 @@ int libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
 
 \fIpassword_len\fP - Length of password parameter.
 
-\fIpasswd_change_cb\fP - If the host accepts authentication but 
-requests that the password be changed, this callback will be issued. 
-If no callback is defined, but server required password change, 
+\fIpasswd_change_cb\fP - If the host accepts authentication but
+requests that the password be changed, this callback will be issued.
+If no callback is defined, but server required password change,
 authentication will fail.
 
-Attempt basic password authentication. Note that many SSH servers 
-which appear to support ordinary password authentication actually have 
-it disabled and use Keyboard Interactive authentication (routed via 
+Attempt basic password authentication. Note that many SSH servers
+which appear to support ordinary password authentication actually have
+it disabled and use Keyboard Interactive authentication (routed via
 PAM or another authentication backed) instead.
-
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
 Some of the errors this function may return include:
 
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_PASSWORD_EXPIRED\fP - 
+\fILIBSSH2_ERROR_PASSWORD_EXPIRED\fP -
 
-\fLIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
+\fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
 or public/private key.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_userauth_publickey.3 b/libssh2/docs/libssh2_userauth_publickey.3
index 0081a248..ea282b19 100644
--- a/libssh2/docs/libssh2_userauth_publickey.3
+++ b/libssh2/docs/libssh2_userauth_publickey.3
@@ -1,16 +1,20 @@
-.TH libssh2_userauth_publickey 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_publickey 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
 libssh2_userauth_publickey - authenticate using a callback function
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-.nf
-int libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                               const char *user,
-                               const unsigned char *pubkeydata,
-                               size_t pubkeydata_len,
-                               sign_callback,
-                               void **abstract);
+int
+libssh2_userauth_publickey(LIBSSH2_SESSION *session,
+                           const char *user,
+                           const unsigned char *pubkeydata,
+                           size_t pubkeydata_len,
+                           sign_callback,
+                           void **abstract);
+.fi
 .SH DESCRIPTION
 Authenticate with the \fIsign_callback\fP callback that matches the prototype
 below
diff --git a/libssh2/docs/libssh2_userauth_publickey_fromfile.3 b/libssh2/docs/libssh2_userauth_publickey_fromfile.3
index f4799a1c..7614c9e6 100644
--- a/libssh2/docs/libssh2_userauth_publickey_fromfile.3
+++ b/libssh2/docs/libssh2_userauth_publickey_fromfile.3
@@ -1,7 +1,10 @@
-.TH libssh2_userauth_publickey_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_publickey_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2"
 .SH NAME
 libssh2_userauth_publickey_fromfile - convenience macro for \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP calls
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 int
@@ -10,7 +13,7 @@ libssh2_userauth_publickey_fromfile(LIBSSH2_SESSION *session,
                                     const char *publickey,
                                     const char *privatekey,
                                     const char *passphrase);
-
+.fi
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP.
diff --git a/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3 b/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3
index 0d77c9a3..dcd5db36 100644
--- a/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3
+++ b/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3
@@ -1,16 +1,20 @@
-.TH libssh2_userauth_publickey_fromfile 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_publickey_fromfile_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2"
 .SH NAME
-libssh2_userauth_publickey_fromfile - authenticate a session with a public key, read from a file
+libssh2_userauth_publickey_fromfile_ex - authenticate a session with a public key, read from a file
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-.nf
-int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
-                                           const char *username,
-                                           unsigned int ousername_len,
-                                           const char *publickey,
-                                           const char *privatekey,
-                                           const char *passphrase);
+int
+libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
+                                       const char *username,
+                                       unsigned int username_len,
+                                       const char *publickey,
+                                       const char *privatekey,
+                                       const char *passphrase);
+.fi
 .SH DESCRIPTION
 \fIsession\fP - Session instance as returned by
 \fBlibssh2_session_init_ex(3)\fP
@@ -27,26 +31,27 @@ can be set to NULL.
 
 \fIpassphrase\fP - Passphrase to use when decoding \fIprivatekey\fP.
 
-Attempt public key authentication using a PEM encoded private key file stored
-on disk
-
+Attempt public key authentication using either a public key file or a PEM
+encoded private key file stored on disk. When providing a private key, the
+public key is automatically extracted from it. When providing both, the
+passed public key takes precedence.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_FILE\fP - An issue opening, reading or parsing the disk file.
+
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
 \fILIBSSH2_ERROR_PUBLICKEY_UNVERIFIED\fP - The username/public key
 combination was invalid.
 
 \fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - Authentication using the supplied
 public key was not accepted.
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_userauth_publickey_frommemory.3 b/libssh2/docs/libssh2_userauth_publickey_frommemory.3
index 685bd591..e6ced003 100644
--- a/libssh2/docs/libssh2_userauth_publickey_frommemory.3
+++ b/libssh2/docs/libssh2_userauth_publickey_frommemory.3
@@ -1,21 +1,23 @@
-.TH libssh2_userauth_publickey_frommemory 3 "1 Sep 2014" "libssh2 1.5" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_publickey_frommemory 3 "1 Sep 2014" "libssh2" "libssh2"
 .SH NAME
 libssh2_userauth_publickey_frommemory - authenticate a session with a public key, read from memory
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-.nf
-int libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
-                                           const char *username,
-                                           size_t username_len,
-                                           const char *publickeydata,
-                                           size_t publickeydata_len,
-                                           const char *privatekeydata,
-                                           size_t privatekeydata_len,
-                                           const char *passphrase);
+int
+libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
+                                      const char *username,
+                                      size_t username_len,
+                                      const char *publickeydata,
+                                      size_t publickeydata_len,
+                                      const char *privatekeydata,
+                                      size_t privatekeydata_len,
+                                      const char *passphrase);
+.fi
 .SH DESCRIPTION
-This function allows to authenticate a session with a public key read from memory.
-It's only supported when libssh2 is backed by OpenSSL.
 \fIsession\fP - Session instance as returned by
 .BR libssh2_session_init_ex(3)
 
@@ -33,17 +35,20 @@ It's only supported when libssh2 is backed by OpenSSL.
 
 \fIpassphrase\fP - Passphrase to use when decoding private key file.
 
-Attempt public key authentication using a PEM encoded private key file stored in memory.
+Attempt public key authentication using either a public key file or a PEM
+encoded private key file stored in memory. When providing a private key, the
+public key is automatically extracted from it. When providing both, the
+passed public key takes precedence.
 .SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
+Return 0 on success or negative on failure. It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
 .SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
 
 \fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
 
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
+\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP -
 
 \fILIBSSH2_ERROR_PUBLICKEY_UNVERIFIED\fP - The username/public key
 combination was invalid.
@@ -52,5 +57,6 @@ combination was invalid.
 public key was not accepted.
 .SH AVAILABILITY
 libssh2_userauth_publickey_frommemory was added in libssh2 1.6.0
+Supported with OpenSSL, WinCNG, mbedTLS, OS/400 crypto backends.
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_userauth_publickey_sk.3 b/libssh2/docs/libssh2_userauth_publickey_sk.3
new file mode 100644
index 00000000..e2eff8f2
--- /dev/null
+++ b/libssh2/docs/libssh2_userauth_publickey_sk.3
@@ -0,0 +1,144 @@
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_userauth_publickey_sk 3 "1 Jun 2022" "libssh2" "libssh2"
+.SH NAME
+libssh2_userauth_publickey_sk - authenticate a session with a FIDO2 authenticator
+.SH SYNOPSIS
+.nf
+#include <libssh2.h>
+
+int
+libssh2_userauth_publickey_sk(LIBSSH2_SESSION *session,
+                              const char *username,
+                              size_t username_len,
+                              const unsigned char *publickeydata,
+                              size_t publickeydata_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase,
+                              LIBSSH2_USERAUTH_SK_SIGN_FUNC((*sign_callback)),
+                              void **abstract);
+.fi
+.SH CALLBACK
+.nf
+#define LIBSSH2_SK_PRESENCE_REQUIRED     0x01
+#define LIBSSH2_SK_VERIFICATION_REQUIRED 0x04
+
+typedef struct _LIBSSH2_SK_SIG_INFO {
+    uint8_t flags;
+    uint32_t counter;
+    unsigned char *sig_r;
+    size_t sig_r_len;
+    unsigned char *sig_s;
+    size_t sig_s_len;
+} LIBSSH2_SK_SIG_INFO;
+
+int name(LIBSSH2_SESSION *session, LIBSSH2_SK_SIG_INFO *sig_info,
+         const unsigned char *data, size_t data_len, int algorithm,
+         uint8_t flags, const char *application,
+         const unsigned char *key_handle, size_t handle_len,
+         void **abstract);
+.fi
+.SH DESCRIPTION
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIusername\fP - Name of user to attempt authentication for.
+
+\fIusername_len\fP - Length of username parameter.
+
+\fIpublickeydata\fP - Buffer containing the contents of a public key file. If
+NULL, the public key will be extracted from the privatekeydata. When using
+certificate authentication, this buffer should contain the public certificate
+data.
+
+\fIpublickeydata_len\fP - Length of public key data.
+
+\fIprivatekeydata\fP - Buffer containing the contents of a private key file.
+
+\fIprivatekeydata_len\fP - Length of private key data.
+
+\fIpassphrase\fP - Passphrase to use when decoding private key file.
+
+\fIsign_callback\fP - Callback to communicate with FIDO2 authenticator.
+
+\fIabstract\fP - User-provided data to pass to callback.
+
+Attempt FIDO2 authentication. using either the sk-ssh-ed25519@openssh.com or
+sk-ecdsa-sha2-nistp256@openssh.com key exchange algorithms.
+
+This function is only supported when libssh2 is backed by OpenSSL.
+
+.SH CALLBACK DESCRIPTION
+\fIsession\fP - Session instance as returned by
+.BR libssh2_session_init_ex(3)
+
+\fIsig_info\fP - Filled in by the callback with the signature and accompanying
+information from the authenticator.
+
+\fIdata\fP - The data to sign.
+
+\fIdata_len\fP - The length of the data parameter.
+
+\fIalgorithm\fP - The signing algorithm to use. Possible values are
+LIBSSH2_HOSTKEY_TYPE_ED25519 and LIBSSH2_HOSTKEY_TYPE_ECDSA_256.
+
+\fIflags\fP - A bitmask specifying options for the authenticator. When
+LIBSSH2_SK_PRESENCE_REQUIRED is set, the authenticator requires a touch. When
+LIBSSH2_SK_VERIFICATION_REQUIRED is set, the authenticator requires a PIN.
+Many servers and authenticators do not work properly when
+LIBSSH2_SK_PRESENCE_REQUIRED is not set.
+
+\fIapplication\fP - A user-defined string to use as the RP name for the
+authenticator. Usually "ssh:".
+
+\fIkey_handle\fP - The key handle to use for the authenticator's allow list.
+
+\fIhandle_len\fP - The length of the key_handle parameter.
+
+\fIabstract\fP - User-defined data. When a PIN is required, use this to pass in
+the PIN, or a function pointer to retrieve the PIN.
+
+The \fIsign_callback\fP is responsible for communicating with the hardware
+authenticator to generate a signature. On success, the signature information
+must be placed in the `\fIsig_info\fP sig_info parameter and the callback must
+return 0. On failure, it should return a negative number.
+
+The fields of the LIBSSH2_SK_SIG_INFO are as follows.
+
+\fIflags\fP - A bitmask specifying options for the authenticator. This should
+be read from the authenticator and not merely copied from the flags parameter
+to the callback.
+
+\fIcounter\fP - A value returned from the authenticator.
+
+\fIsig_r\fP - For Ed25519 signatures, this contains the entire signature, as
+returned directly from the authenticator. For ECDSA signatures, this contains
+the r component of the signature in a big-endian binary representation. For
+both algorithms, use LIBSSH2_ALLOC to allocate memory. It will be freed by the
+caller.
+
+\fIsig_r_len\fP - The length of the sig_r parameter.
+
+\fIsig_s\fP - For ECDSA signatures, this contains the s component of the
+signature in a big-endian binary representation. Use LIBSSH2_ALLOC to allocate
+memory. It will be freed by the caller. For Ed25519 signatures, set this to
+NULL.
+
+\fIsig_s_len\fP - The length of the sig_s parameter.
+.SH RETURN VALUE
+Return 0 on success or negative on failure. It returns
+LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
+LIBSSH2_ERROR_EAGAIN is a negative number, it is not really a failure per se.
+.SH ERRORS
+Some of the errors this function may return include:
+
+\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
+
+\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
+
+\fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/key.
+.SH AVAILABILITY
+Added in libssh2 1.10.0
+.SH SEE ALSO
+.BR libssh2_session_init_ex(3)
diff --git a/libssh2/docs/libssh2_version.3 b/libssh2/docs/libssh2_version.3
index f98ca967..3f36d717 100644
--- a/libssh2/docs/libssh2_version.3
+++ b/libssh2/docs/libssh2_version.3
@@ -1,11 +1,15 @@
-.TH libssh2_version 3 "23 Feb 2009" "libssh2 1.1" "libssh2 manual"
+.\" Copyright (C) The libssh2 project and its contributors.
+.\" SPDX-License-Identifier: BSD-3-Clause
+.TH libssh2_version 3 "23 Feb 2009" "libssh2" "libssh2"
 .SH NAME
 libssh2_version - return the libssh2 version number
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
 const char *
 libssh2_version(int required_version);
+.fi
 .SH DESCRIPTION
 If \fIrequired_version\fP is lower than or equal to the version number of the
 libssh2 in use, the version number of libssh2 is returned as a pointer to a
@@ -17,20 +21,22 @@ bit number in the 0xMMmmpp format. MM for major, mm for minor and pp for patch
 number.
 .SH RETURN VALUE
 The version number of libssh2 is returned as a pointer to a zero terminated
-string or NULL if the \fIrequired_version\fP isn't fulfilled.
+string or NULL if the \fIrequired_version\fP is not fulfilled.
 .SH EXAMPLE
 To make sure you run with the correct libssh2 version:
 
 .nf
-if (!libssh2_version(LIBSSH2_VERSION_NUM)) {
-  fprintf (stderr, \&"Runtime libssh2 version too old!\&");
+if(!libssh2_version(LIBSSH2_VERSION_NUM)) {
+  fprintf(stderr, \&"Runtime libssh2 version too old.\&");
   exit(1);
 }
 .fi
 
 Unconditionally get the version number:
 
-printf(\&"libssh2 version: %s\&", libssh2_version(0) );
+.nf
+printf(\&"libssh2 version: %s\&", libssh2_version(0));
+.fi
 .SH AVAILABILITY
 This function was added in libssh2 1.1, in previous versions there way no way
 to extract this info in run-time.
diff --git a/libssh2/docs/template.3 b/libssh2/docs/template.3
index d5b4473c..473e0bd3 100644
--- a/libssh2/docs/template.3
+++ b/libssh2/docs/template.3
@@ -1,20 +1,20 @@
-.TH libssh2_template 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
+.TH libssh2_template 3 "1 Jun 2022" "libssh2" "libssh2"
 .SH NAME
 libssh2_template - short function description
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void 
+void
 libssh2_template(void);
-
+.fi
 .SH DESCRIPTION
 Long text describing the function and its input arguments.
-
 .SH RETURN VALUE
 Describe what the function returns.
-
 .SH ERRORS
 Add error codes
-
+.SH AVAILABILITY
+Added in libssh2 ?.?.?
 .SH SEE ALSO
 Add related functions
diff --git a/libssh2/example/CMakeLists.txt b/libssh2/example/CMakeLists.txt
index 3dc115ef..a5b0980c 100644
--- a/libssh2/example/CMakeLists.txt
+++ b/libssh2/example/CMakeLists.txt
@@ -1,4 +1,5 @@
-# Copyright (c) 2014, 2015 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Viktor Szakats
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,70 +33,29 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
 
-include(CheckIncludeFiles)
-include(CheckSymbolExists)
 include(CopyRuntimeDependencies)
-include(SocketLibraries)
 
-set(EXAMPLES
-  direct_tcpip
-  ssh2
-  scp
-  scp_nonblock
-  scp_write
-  scp_write_nonblock
-  sftp
-  sftp_nonblock
-  sftp_write
-  sftp_write_nonblock
-  sftp_mkdir
-  sftp_mkdir_nonblock
-  sftp_RW_nonblock
-  sftp_write_sliding
-  sftpdir
-  sftpdir_nonblock
-  ssh2_exec
-  ssh2_agent
-  ssh2_agent_forwarding
-  ssh2_echo
-  sftp_append
-  subsystem_netconf
-  tcpip-forward)
+list(APPEND LIBSSH2_LIBS ${LIBSSH2_LIBS_SOCKET})
 
-append_needed_socket_libraries(LIBRARIES)
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+# Get 'noinst_PROGRAMS' variable
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
 
-foreach(example ${EXAMPLES})
-  add_executable(example-${example} ${example}.c)
-  list(APPEND EXAMPLE_TARGETS example-${example})
+foreach(_example IN LISTS noinst_PROGRAMS)
+  add_executable(${_example} "${_example}.c")
+  list(APPEND _example_targets ${_example})
   # to find generated header
-  target_include_directories(example-${example} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-  target_link_libraries(example-${example} libssh2 ${LIBRARIES})
+  target_include_directories(${_example} PRIVATE
+    "${CMAKE_CURRENT_BINARY_DIR}/../src"
+    "../src")
+  target_link_libraries(${_example} ${LIB_SELECTED} ${LIBSSH2_LIBS})
+  set_target_properties(${_example} PROPERTIES UNITY_BUILD OFF)
 endforeach()
+
 add_target_to_copy_dependencies(
   TARGET copy_example_dependencies
   DEPENDENCIES ${RUNTIME_DEPENDENCIES}
-  BEFORE_TARGETS ${EXAMPLE_TARGETS})
-
-## Platform checks
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(stdlib.h HAVE_STDLIB_H)
-check_include_files(sys/select.h HAVE_SYS_SELECT_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(sys/time.h HAVE_SYS_TIME_H)
-check_include_files(arpa/inet.h HAVE_ARPA_INET_H)
-check_include_files(netinet/in.h HAVE_NETINET_IN_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-
-check_symbol_exists(strcasecmp strings.h HAVE_STRCASECMP)
-check_symbol_exists(_stricmp string.h HAVE__STRICMP)
-check_symbol_exists(snprintf stdio.h HAVE_SNPRINTF)
-check_symbol_exists(_snprintf stdio.h HAVE__SNPRINTF)
-
-check_symbol_exists(__func__ "" HAVE___FUNC__)
-check_symbol_exists(__FUNCTION__ "" HAVE___FUNCTION__)
-
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h)
+  BEFORE_TARGETS ${_example_targets})
diff --git a/libssh2/example/Makefile.am b/libssh2/example/Makefile.am
index ec542cd1..0682588a 100644
--- a/libssh2/example/Makefile.am
+++ b/libssh2/example/Makefile.am
@@ -1,17 +1,14 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
 
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in CMakeLists.txt
+EXTRA_DIST = CMakeLists.txt
 
-# samples
-noinst_PROGRAMS = direct_tcpip ssh2 scp scp_nonblock scp_write		\
- scp_write_nonblock sftp sftp_nonblock sftp_write sftp_write_nonblock	\
- sftp_mkdir sftp_mkdir_nonblock sftp_RW_nonblock sftp_write_sliding	\
- sftpdir sftpdir_nonblock ssh2_exec ssh2_agent ssh2_agent_forwarding \
- ssh2_echo sftp_append subsystem_netconf tcpip-forward
+# Get noing_PROGRAMS
+include Makefile.inc
 
-if HAVE_SYS_UN_H
-noinst_PROGRAMS += x11
-endif
-
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/example -I../src
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src -I$(top_srcdir)/include
 LDADD = $(top_builddir)/src/libssh2.la
+
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
diff --git a/libssh2/example/Makefile.in b/libssh2/example/Makefile.in
index ff86a2e4..8c1f52a9 100644
--- a/libssh2/example/Makefile.in
+++ b/libssh2/example/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -14,6 +14,9 @@
 
 @SET_MAKE@
 
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
@@ -88,27 +91,25 @@ PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
-noinst_PROGRAMS = direct_tcpip$(EXEEXT) ssh2$(EXEEXT) scp$(EXEEXT) \
+noinst_PROGRAMS = direct_tcpip$(EXEEXT) scp$(EXEEXT) \
 	scp_nonblock$(EXEEXT) scp_write$(EXEEXT) \
 	scp_write_nonblock$(EXEEXT) sftp$(EXEEXT) \
+	sftp_RW_nonblock$(EXEEXT) sftp_append$(EXEEXT) \
+	sftp_mkdir$(EXEEXT) sftp_mkdir_nonblock$(EXEEXT) \
 	sftp_nonblock$(EXEEXT) sftp_write$(EXEEXT) \
-	sftp_write_nonblock$(EXEEXT) sftp_mkdir$(EXEEXT) \
-	sftp_mkdir_nonblock$(EXEEXT) sftp_RW_nonblock$(EXEEXT) \
-	sftp_write_sliding$(EXEEXT) sftpdir$(EXEEXT) \
-	sftpdir_nonblock$(EXEEXT) ssh2_exec$(EXEEXT) \
+	sftp_write_nonblock$(EXEEXT) sftp_write_sliding$(EXEEXT) \
+	sftpdir$(EXEEXT) sftpdir_nonblock$(EXEEXT) ssh2$(EXEEXT) \
 	ssh2_agent$(EXEEXT) ssh2_agent_forwarding$(EXEEXT) \
-	ssh2_echo$(EXEEXT) sftp_append$(EXEEXT) \
-	subsystem_netconf$(EXEEXT) tcpip-forward$(EXEEXT) \
-	$(am__EXEEXT_1)
-@HAVE_SYS_UN_H_TRUE@am__append_1 = x11
+	ssh2_echo$(EXEEXT) ssh2_exec$(EXEEXT) \
+	subsystem_netconf$(EXEEXT) tcpip-forward$(EXEEXT) x11$(EXEEXT)
 subdir = example
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
@@ -116,7 +117,6 @@ mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
-@HAVE_SYS_UN_H_TRUE@am__EXEEXT_1 = x11$(EXEEXT)
 PROGRAMS = $(noinst_PROGRAMS)
 direct_tcpip_SOURCES = direct_tcpip.c
 direct_tcpip_OBJECTS = direct_tcpip.$(OBJEXT)
@@ -301,7 +301,8 @@ am__define_uniq_tagged_files = \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
-am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
+	$(top_srcdir)/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 ALLOCA = @ALLOCA@
@@ -337,12 +338,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -353,30 +355,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -398,6 +404,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -458,15 +465,23 @@ target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
+
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in CMakeLists.txt
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/example -I../src
+EXTRA_DIST = CMakeLists.txt
+
+# Get noing_PROGRAMS
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src -I$(top_srcdir)/include
 LDADD = $(top_builddir)/src/libssh2.la
+
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
 all: all-am
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .o .obj
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
@@ -486,6 +501,7 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
 	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
+$(srcdir)/Makefile.inc $(am__empty):
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
diff --git a/libssh2/example/Makefile.inc b/libssh2/example/Makefile.inc
new file mode 100644
index 00000000..19ea38cf
--- /dev/null
+++ b/libssh2/example/Makefile.inc
@@ -0,0 +1,28 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
+noinst_PROGRAMS = \
+  direct_tcpip \
+  scp \
+  scp_nonblock \
+  scp_write \
+  scp_write_nonblock \
+  sftp \
+  sftp_RW_nonblock \
+  sftp_append \
+  sftp_mkdir \
+  sftp_mkdir_nonblock \
+  sftp_nonblock \
+  sftp_write \
+  sftp_write_nonblock \
+  sftp_write_sliding \
+  sftpdir \
+  sftpdir_nonblock \
+  ssh2 \
+  ssh2_agent \
+  ssh2_agent_forwarding \
+  ssh2_echo \
+  ssh2_exec \
+  subsystem_netconf \
+  tcpip-forward \
+  x11
diff --git a/libssh2/example/direct_tcpip.c b/libssh2/example/direct_tcpip.c
index 4e1d90f4..45787286 100644
--- a/libssh2/example/direct_tcpip.c
+++ b/libssh2/example/direct_tcpip.c
@@ -1,85 +1,87 @@
-#include "libssh2_config.h"
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
+#ifdef _WIN32
+#include <ws2tcpip.h>  /* for socklen_t */
+#define recv(s, b, l, f)  recv((s), (b), (int)(l), (f))
+#define send(s, b, l, f)  send((s), (b), (int)(l), (f))
 #endif
 
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #ifndef INADDR_NONE
-#define INADDR_NONE (in_addr_t)-1
+#define INADDR_NONE (in_addr_t)~0
 #endif
 
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "";
 
-const char *server_ip = "127.0.0.1";
+static const char *server_ip = "127.0.0.1";
 
-const char *local_listenip = "127.0.0.1";
-unsigned int local_listenport = 2222;
+static const char *local_listenip = "127.0.0.1";
+static int local_listenport = 2222;
 
-const char *remote_desthost = "localhost"; /* resolved by the server */
-unsigned int remote_destport = 22;
+static const char *remote_desthost = "localhost"; /* resolved by the server */
+static int remote_destport = 22;
 
 enum {
     AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
+    AUTH_PASSWORD = 1,
+    AUTH_PUBLICKEY = 2
 };
 
 int main(int argc, char *argv[])
 {
-    int rc, i, auth = AUTH_NONE;
+    int i, auth = AUTH_NONE;
     struct sockaddr_in sin;
     socklen_t sinlen;
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel = NULL;
     const char *shost;
-    unsigned int sport;
-    fd_set fds;
+    int sport;
     struct timeval tv;
     ssize_t len, wr;
     char buf[16384];
+    libssh2_socket_t sock;
+    libssh2_socket_t listensock = LIBSSH2_INVALID_SOCKET;
+    libssh2_socket_t forwardsock = LIBSSH2_INVALID_SOCKET;
 
-#ifdef WIN32
+#ifdef _WIN32
     char sockopt;
-    SOCKET sock = INVALID_SOCKET;
-    SOCKET listensock = INVALID_SOCKET, forwardsock = INVALID_SOCKET;
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #else
-    int sockopt, sock = -1;
-    int listensock = -1, forwardsock = -1;
+    int sockopt;
 #endif
 
     if(argc > 1)
@@ -105,36 +107,28 @@ int main(int argc, char *argv[])
 
     /* Connect to SSH server */
     sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open socket.\n");
+        goto shutdown;
     }
-#endif
 
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = inet_addr(server_ip);
     if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        return -1;
+        fprintf(stderr, "inet_addr: Invalid IP address '%s'\n", server_ip);
+        goto shutdown;
     }
     sin.sin_port = htons(22);
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "Failed to connect to %s.\n", inet_ntoa(sin.sin_addr));
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
     if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
     }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
@@ -143,10 +137,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -158,58 +152,57 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 8) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[8], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[8], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password"))
+            auth |= AUTH_PASSWORD;
+        if(strstr(userauthlist, "publickey"))
+            auth |= AUTH_PUBLICKEY;
+
+        /* check for options */
+        if(argc > 8) {
+            if((auth & AUTH_PASSWORD) && !strcmp(argv[8], "-p"))
+                auth = AUTH_PASSWORD;
+            if((auth & AUTH_PUBLICKEY) && !strcmp(argv[8], "-k"))
+                auth = AUTH_PUBLICKEY;
+        }
 
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
+        if(auth & AUTH_PASSWORD) {
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
         }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
+        else if(auth & AUTH_PUBLICKEY) {
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
+        }
+        else {
+            fprintf(stderr, "No supported authentication methods found.\n");
             goto shutdown;
         }
-        fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
     }
 
     listensock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(listensock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open listen socket!\n");
-        return -1;
-    }
-#else
-    if(listensock == -1) {
-        perror("socket");
-        return -1;
+    if(listensock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open listen socket.\n");
+        goto shutdown;
     }
-#endif
 
     sin.sin_family = AF_INET;
-    sin.sin_port = htons(local_listenport);
+    sin.sin_port = htons((unsigned short)local_listenport);
     sin.sin_addr.s_addr = inet_addr(local_listenip);
     if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
+        fprintf(stderr, "failed in inet_addr().\n");
         goto shutdown;
     }
     sockopt = 1;
@@ -217,127 +210,149 @@ int main(int argc, char *argv[])
                sizeof(sockopt));
     sinlen = sizeof(sin);
     if(-1 == bind(listensock, (struct sockaddr *)&sin, sinlen)) {
-        perror("bind");
+        fprintf(stderr, "failed to bind().\n");
         goto shutdown;
     }
     if(-1 == listen(listensock, 2)) {
-        perror("listen");
+        fprintf(stderr, "failed to listen().\n");
         goto shutdown;
     }
 
     fprintf(stderr, "Waiting for TCP connection on %s:%d...\n",
-        inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
+            inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
 
     forwardsock = accept(listensock, (struct sockaddr *)&sin, &sinlen);
-#ifdef WIN32
-    if(forwardsock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to accept forward socket!\n");
+    if(forwardsock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to accept forward socket.\n");
         goto shutdown;
     }
-#else
-    if(forwardsock == -1) {
-        perror("accept");
-        goto shutdown;
-    }
-#endif
 
     shost = inet_ntoa(sin.sin_addr);
     sport = ntohs(sin.sin_port);
 
     fprintf(stderr, "Forwarding connection from %s:%d here to remote %s:%d\n",
-        shost, sport, remote_desthost, remote_destport);
+            shost, sport, remote_desthost, remote_destport);
 
     channel = libssh2_channel_direct_tcpip_ex(session, remote_desthost,
-        remote_destport, shost, sport);
+                                              remote_destport, shost, sport);
     if(!channel) {
-        fprintf(stderr, "Could not open the direct-tcpip channel!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
+        fprintf(stderr, "Could not open the direct-tcpip channel.\n"
+                        "(Note that this can be a problem at the server."
+                        " Please review the server logs.)\n");
         goto shutdown;
     }
 
     /* Must use non-blocking IO hereafter due to the current libssh2 API */
     libssh2_session_set_blocking(session, 0);
 
-    while(1) {
+    for(;;) {
+        fd_set fds;
         FD_ZERO(&fds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         FD_SET(forwardsock, &fds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
         tv.tv_sec = 0;
         tv.tv_usec = 100000;
-        rc = select(forwardsock + 1, &fds, NULL, NULL, &tv);
+        rc = select((int)(forwardsock + 1), &fds, NULL, NULL, &tv);
         if(-1 == rc) {
-            perror("select");
+            fprintf(stderr, "failed to select().\n");
             goto shutdown;
         }
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         if(rc && FD_ISSET(forwardsock, &fds)) {
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
             len = recv(forwardsock, buf, sizeof(buf), 0);
             if(len < 0) {
-                perror("read");
+                fprintf(stderr, "failed to recv().\n");
                 goto shutdown;
             }
-            else if(0 == len) {
-                fprintf(stderr, "The client at %s:%d disconnected!\n", shost,
-                    sport);
+            else if(len == 0) {
+                fprintf(stderr, "The client at %s:%d disconnected.\n", shost,
+                        sport);
                 goto shutdown;
             }
             wr = 0;
             while(wr < len) {
-                i = libssh2_channel_write(channel, buf + wr, len - wr);
-                if(LIBSSH2_ERROR_EAGAIN == i) {
+                ssize_t nwritten = libssh2_channel_write(channel,
+                                                         buf + wr,
+                                                         (size_t)(len - wr));
+                if(nwritten == LIBSSH2_ERROR_EAGAIN) {
                     continue;
                 }
-                if(i < 0) {
-                    fprintf(stderr, "libssh2_channel_write: %d\n", i);
+                if(nwritten < 0) {
+                    fprintf(stderr, "libssh2_channel_write: %ld\n",
+                            (long)nwritten);
                     goto shutdown;
                 }
-                wr += i;
+                wr += nwritten;
             }
         }
-        while(1) {
+        for(;;) {
             len = libssh2_channel_read(channel, buf, sizeof(buf));
             if(LIBSSH2_ERROR_EAGAIN == len)
                 break;
             else if(len < 0) {
-                fprintf(stderr, "libssh2_channel_read: %d", (int)len);
+                fprintf(stderr, "libssh2_channel_read: %ld", (long)len);
                 goto shutdown;
             }
             wr = 0;
             while(wr < len) {
-                i = send(forwardsock, buf + wr, len - wr, 0);
-                if(i <= 0) {
-                    perror("write");
+                ssize_t nsent = send(forwardsock, buf + wr,
+                                     (size_t)(len - wr), 0);
+                if(nsent <= 0) {
+                    fprintf(stderr, "failed to send().\n");
                     goto shutdown;
                 }
-                wr += i;
+                wr += nsent;
             }
             if(libssh2_channel_eof(channel)) {
-                fprintf(stderr, "The server at %s:%d disconnected!\n",
-                    remote_desthost, remote_destport);
+                fprintf(stderr, "The server at %s:%d disconnected.\n",
+                        remote_desthost, remote_destport);
                 goto shutdown;
             }
         }
     }
 
 shutdown:
-#ifdef WIN32
-    closesocket(forwardsock);
-    closesocket(listensock);
-#else
-    close(forwardsock);
-    close(listensock);
-#endif
+
+    if(forwardsock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(forwardsock, 2);
+        LIBSSH2_SOCKET_CLOSE(forwardsock);
+    }
+
+    if(listensock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(listensock, 2);
+        LIBSSH2_SOCKET_CLOSE(listensock);
+    }
+
     if(channel)
         libssh2_channel_free(channel);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/libssh2_config.h.in b/libssh2/example/libssh2_config.h.in
deleted file mode 100644
index 307c6255..00000000
--- a/libssh2/example/libssh2_config.h.in
+++ /dev/null
@@ -1,264 +0,0 @@
-/* src/libssh2_config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define if building universal (internal helper macro) */
-#undef AC_APPLE_UNIVERSAL_BUILD
-
-/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
-   systems. This function is required for `alloca.c' support on those systems.
-   */
-#undef CRAY_STACKSEG_END
-
-/* Define to 1 if using `alloca.c'. */
-#undef C_ALLOCA
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#undef HAVE_ALLOCA
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
-   */
-#undef HAVE_ALLOCA_H
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#undef HAVE_ARPA_INET_H
-
-/* Define to 1 if you have the declaration of `SecureZeroMemory', and to 0 if
-   you don't. */
-#undef HAVE_DECL_SECUREZEROMEMORY
-
-/* disabled non-blocking sockets */
-#undef HAVE_DISABLED_NONBLOCKING
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#undef HAVE_ERRNO_H
-
-/* Define to 1 if you have the `EVP_aes_128_ctr' function. */
-#undef HAVE_EVP_AES_128_CTR
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#undef HAVE_FCNTL_H
-
-/* use FIONBIO for non-blocking sockets */
-#undef HAVE_FIONBIO
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#undef HAVE_GETTIMEOFDAY
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* use ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET
-
-/* use Ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET_CASE
-
-/* Define if you have the bcrypt library. */
-#undef HAVE_LIBBCRYPT
-
-/* Define if you have the crypt32 library. */
-#undef HAVE_LIBCRYPT32
-
-/* Define if you have the gcrypt library. */
-#undef HAVE_LIBGCRYPT
-
-/* Define if you have the mbedcrypto library. */
-#undef HAVE_LIBMBEDCRYPTO
-
-/* Define if you have the ssl library. */
-#undef HAVE_LIBSSL
-
-/* Define if you have the z library. */
-#undef HAVE_LIBZ
-
-/* Define to 1 if the compiler supports the 'long long' data type. */
-#undef HAVE_LONGLONG
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the `memset_s' function. */
-#undef HAVE_MEMSET_S
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#undef HAVE_NETINET_IN_H
-
-/* Define to 1 if you have the <ntdef.h> header file. */
-#undef HAVE_NTDEF_H
-
-/* Define to 1 if you have the <ntstatus.h> header file. */
-#undef HAVE_NTSTATUS_H
-
-/* use O_NONBLOCK for non-blocking sockets */
-#undef HAVE_O_NONBLOCK
-
-/* Define to 1 if you have the `poll' function. */
-#undef HAVE_POLL
-
-/* Define to 1 if you have the select function. */
-#undef HAVE_SELECT
-
-/* use SO_NONBLOCK for non-blocking sockets */
-#undef HAVE_SO_NONBLOCK
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the `strtoll' function. */
-#undef HAVE_STRTOLL
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#undef HAVE_SYS_IOCTL_H
-
-/* Define to 1 if you have the <sys/select.h> header file. */
-#undef HAVE_SYS_SELECT_H
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#undef HAVE_SYS_SOCKET_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#undef HAVE_SYS_TIME_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <sys/uio.h> header file. */
-#undef HAVE_SYS_UIO_H
-
-/* Define to 1 if you have the <sys/un.h> header file. */
-#undef HAVE_SYS_UN_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Define to 1 if you have the <windows.h> header file. */
-#undef HAVE_WINDOWS_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to 1 if you have the <ws2tcpip.h> header file. */
-#undef HAVE_WS2TCPIP_H
-
-/* to make a symbol visible */
-#undef LIBSSH2_API
-
-/* Enable clearing of memory before being freed */
-#undef LIBSSH2_CLEAR_MEMORY
-
-/* Enable "none" cipher -- NOT RECOMMENDED */
-#undef LIBSSH2_CRYPT_NONE
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#undef LIBSSH2_DH_GEX_NEW
-
-/* Compile in zlib support */
-#undef LIBSSH2_HAVE_ZLIB
-
-/* Use libgcrypt */
-#undef LIBSSH2_LIBGCRYPT
-
-/* Enable "none" MAC -- NOT RECOMMENDED */
-#undef LIBSSH2_MAC_NONE
-
-/* Use mbedtls */
-#undef LIBSSH2_MBEDTLS
-
-/* Use openssl */
-#undef LIBSSH2_OPENSSL
-
-/* Use wincng */
-#undef LIBSSH2_WINCNG
-
-/* Define to the sub-directory where libtool stores uninstalled libraries. */
-#undef LT_OBJDIR
-
-/* Define to 1 if _REENTRANT preprocessor symbol must be defined. */
-#undef NEED_REENTRANT
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at runtime.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown */
-#undef STACK_DIRECTION
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* Version number of package */
-#undef VERSION
-
-/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
-   significant byte first (like Motorola and SPARC, unlike Intel). */
-#if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
-#else
-# ifndef WORDS_BIGENDIAN
-#  undef WORDS_BIGENDIAN
-# endif
-#endif
-
-/* Enable large inode numbers on Mac OS X 10.5.  */
-#ifndef _DARWIN_USE_64_BIT_INODE
-# define _DARWIN_USE_64_BIT_INODE 1
-#endif
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
diff --git a/libssh2/example/libssh2_config_cmake.h.in b/libssh2/example/libssh2_config_cmake.h.in
deleted file mode 100644
index 12264f7f..00000000
--- a/libssh2/example/libssh2_config_cmake.h.in
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#cmakedefine HAVE_UNISTD_H
-#cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_STDLIB_H
-#cmakedefine HAVE_SYS_SELECT_H
-#cmakedefine HAVE_SYS_SOCKET_H
-#cmakedefine HAVE_SYS_TIME_H
-#cmakedefine HAVE_ARPA_INET_H
-#cmakedefine HAVE_NETINET_IN_H
-#cmakedefine HAVE_WINSOCK2_H
-
-/* Functions */
-#cmakedefine HAVE_STRCASECMP
-#cmakedefine HAVE__STRICMP
-#cmakedefine HAVE_SNPRINTF
-#cmakedefine HAVE__SNPRINTF
-
-/* Workaround for platforms without POSIX strcasecmp (e.g. Windows) */
-#ifndef HAVE_STRCASECMP
-# ifdef HAVE__STRICMP
-# define strcasecmp _stricmp
-# define HAVE_STRCASECMP
-# endif
-#endif
-
-/* Symbols */
-#cmakedefine HAVE___FUNC__
-#cmakedefine HAVE___FUNCTION__
-
-/* Workaround for platforms without C90 __func__ */
-#ifndef HAVE___FUNC__
-# ifdef HAVE___FUNCTION__
-# define __func__ __FUNCTION__
-# define HAVE___FUNC__
-# endif
-#endif
diff --git a/libssh2/example/scp.c b/libssh2/example/scp.c
index 9ad1e7d4..e5fc1a09 100644
--- a/libssh2/example/scp.c
+++ b/libssh2/example/scp.c
@@ -1,57 +1,57 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do a simple SCP transfer.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
+#ifdef _WIN32
+#define write(f, b, c)  write((f), (b), (unsigned int)(c))
 #endif
+
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *scppath = "/tmp/TEST";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *scppath = "/tmp/TEST";
     libssh2_struct_stat fileinfo;
-    int rc;
     libssh2_struct_stat_size got = 0;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -78,26 +78,29 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -105,10 +108,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -129,12 +132,10 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-#define HOME_DIR "/home/username/"
         if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME_DIR ".ssh/id_rsa.pub",
-                                               HOME_DIR ".ssh/id_rsa",
+                                               pubkey, privkey,
                                                password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -148,43 +149,49 @@ int main(int argc, char *argv[])
         goto shutdown;
     }
 
-
     while(got < fileinfo.st_size) {
         char mem[1024];
         int amount = sizeof(mem);
+        ssize_t nread;
 
-        if((fileinfo.st_size -got) < amount) {
-            amount = (int)(fileinfo.st_size -got);
+        if((fileinfo.st_size - got) < amount) {
+            amount = (int)(fileinfo.st_size - got);
         }
 
-        rc = libssh2_channel_read(channel, mem, amount);
-        if(rc > 0) {
-            write(1, mem, rc);
+        nread = libssh2_channel_read(channel, mem, (size_t)amount);
+        if(nread > 0) {
+            write(1, mem, (size_t)nread);
         }
-        else if(rc < 0) {
-            fprintf(stderr, "libssh2_channel_read() failed: %d\n", rc);
+        else if(nread < 0) {
+            fprintf(stderr, "libssh2_channel_read() failed: %ld\n",
+                    (long)nread);
             break;
         }
-        got += rc;
+        got += nread;
     }
 
     libssh2_channel_free(channel);
     channel = NULL;
 
- shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/scp_nonblock.c b/libssh2/example/scp_nonblock.c
index bc5bdb3d..4a39546b 100644
--- a/libssh2/example/scp_nonblock.c
+++ b/libssh2/example/scp_nonblock.c
@@ -1,53 +1,56 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SCP transfers in a non-blocking manner.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "scp_nonblock 192.168.0.1 user password /tmp/secrets"
+ * $ ./scp_nonblock 192.168.0.1 user password /tmp/secrets
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
+#ifdef _WIN32
+#define write(f, b, c)  write((f), (b), (unsigned int)(c))
 #endif
+
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *scppath = "/tmp/TEST";
 
 #ifdef HAVE_GETTIMEOFDAY
 /* diff in ms */
 static long tvdiff(struct timeval newer, struct timeval older)
 {
-  return (newer.tv_sec-older.tv_sec)*1000+
-      (newer.tv_usec-older.tv_usec)/1000;
+    return (newer.tv_sec - older.tv_sec) * 1000 +
+        (newer.tv_usec - older.tv_usec) / 1000;
 }
 #endif
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -61,7 +64,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -72,40 +82,37 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *scppath = "/tmp/TEST";
     libssh2_struct_stat fileinfo;
 #ifdef HAVE_GETTIMEOFDAY
     struct timeval start;
     struct timeval end;
     long time_ms;
 #endif
-    int rc;
     int spin = 0;
     libssh2_struct_stat_size got = 0;
     libssh2_struct_stat_size total = 0;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -127,29 +134,34 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
     if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -165,14 +177,14 @@ int main(int argc, char *argv[])
           LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
-        * is check the hostkey's fingerprint against our known hosts Your app
-        * may have it hard coded, may go to a file, may present it to the
-        * user, that's your call
-        */
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
+     */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
     for(i = 0; i < 20; i++) {
@@ -192,14 +204,11 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        "/home/username/"
-                                                        ".ssh/id_rsa.pub",
-                                                        "/home/username/"
-                                                        ".ssh/id_rsa",
+                                                        pubkey, privkey,
                                                         password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -209,7 +218,7 @@ int main(int argc, char *argv[])
 #endif
 
     /* Request a file via SCP */
-    fprintf(stderr, "libssh2_scp_recv2()!\n");
+    fprintf(stderr, "libssh2_scp_recv2().\n");
     do {
         channel = libssh2_scp_recv2(session, scppath, &fileinfo);
 
@@ -222,34 +231,34 @@ int main(int argc, char *argv[])
                 goto shutdown;
             }
             else {
-                fprintf(stderr, "libssh2_scp_recv() spin\n");
+                fprintf(stderr, "libssh2_scp_recv2() spin\n");
                 waitsocket(sock, session);
             }
         }
     } while(!channel);
-    fprintf(stderr, "libssh2_scp_recv() is done, now receive data!\n");
+    fprintf(stderr, "libssh2_scp_recv2() is done, now receive data.\n");
 
     while(got < fileinfo.st_size) {
-        char mem[1024*24];
-        int rc;
+        char mem[1024 * 24];
+        ssize_t nread;
 
         do {
             int amount = sizeof(mem);
 
-            if((fileinfo.st_size -got) < amount) {
+            if((fileinfo.st_size - got) < amount) {
                 amount = (int)(fileinfo.st_size - got);
             }
 
             /* loop until we block */
-            rc = libssh2_channel_read(channel, mem, amount);
-            if(rc > 0) {
-                write(1, mem, rc);
-                got += rc;
-                total += rc;
+            nread = libssh2_channel_read(channel, mem, (size_t)amount);
+            if(nread > 0) {
+                write(1, mem, (size_t)nread);
+                got += nread;
+                total += nread;
             }
-        } while(rc > 0);
+        } while(nread > 0);
 
-        if((rc == LIBSSH2_ERROR_EAGAIN) && (got < fileinfo.st_size)) {
+        if(nread == LIBSSH2_ERROR_EAGAIN && got < fileinfo.st_size) {
             /* this is due to blocking that would occur otherwise
             so we loop on this condition */
 
@@ -265,8 +274,8 @@ int main(int argc, char *argv[])
 
     time_ms = tvdiff(end, start);
     fprintf(stderr, "Got %ld bytes in %ld ms = %.1f bytes/sec spin: %d\n",
-            (long)total,
-            time_ms, total/(time_ms/1000.0), spin);
+            (long)total, time_ms,
+            (double)total / ((double)time_ms / 1000.0), spin);
 #else
     fprintf(stderr, "Got %ld bytes spin: %d\n", (long)total, spin);
 #endif
@@ -276,18 +285,23 @@ int main(int argc, char *argv[])
 
 shutdown:
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/scp_write.c b/libssh2/example/scp_write.c
index 030232ec..55cf6250 100644
--- a/libssh2/example/scp_write.c
+++ b/libssh2/example/scp_write.c
@@ -1,61 +1,57 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do an SCP upload.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "scp_write.c";
+static const char *scppath = "/tmp/TEST";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
+    int rc;
     LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "scp_write.c";
-    const char *scppath = "/tmp/TEST";
     FILE *local;
-    int rc;
     char mem[1024];
     size_t nread;
     char *ptr;
     struct stat fileinfo;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -80,43 +76,42 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     stat(loclfile, &fileinfo);
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(-1 == sock) {
-        fprintf(stderr, "failed to create socket!\n");
-        return -1;
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
     }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -124,10 +119,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -148,24 +143,23 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-#define HOME "/home/username/"
         if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME ".ssh/id_rsa.pub",
-                                               HOME ".ssh/id_rsa",
+                                               pubkey, privkey,
                                                password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
     /* Send a file via scp. The mode parameter must only have permissions! */
     channel = libssh2_scp_send(session, scppath, fileinfo.st_mode & 0777,
-                               (unsigned long)fileinfo.st_size);
+                               (size_t)fileinfo.st_size);
 
     if(!channel) {
         char *errmsg;
         int errlen;
-        int err = libssh2_session_last_error(session, &errmsg, &errlen, 0);
+        int err;
+        err = libssh2_session_last_error(session, &errmsg, &errlen, 0);
         fprintf(stderr, "Unable to open a session: (%d) %s\n", err, errmsg);
         goto shutdown;
     }
@@ -180,19 +174,19 @@ int main(int argc, char *argv[])
         ptr = mem;
 
         do {
+            ssize_t nwritten;
             /* write the same data over and over, until error or completion */
-            rc = libssh2_channel_write(channel, ptr, nread);
-            if(rc < 0) {
-                fprintf(stderr, "ERROR %d\n", rc);
+            nwritten = libssh2_channel_write(channel, ptr, nread);
+            if(nwritten < 0) {
+                fprintf(stderr, "ERROR %ld\n", (long)nwritten);
                 break;
             }
             else {
-                /* rc indicates how many bytes were written this time */
-                ptr += rc;
-                nread -= rc;
+                /* nwritten indicates how many bytes were written this time */
+                ptr += nwritten;
+                nread -= (size_t)nwritten;
             }
         } while(nread);
-
     } while(1);
 
     fprintf(stderr, "Sending EOF\n");
@@ -207,22 +201,28 @@ int main(int argc, char *argv[])
     libssh2_channel_free(channel);
     channel = NULL;
 
- shutdown:
+shutdown:
 
     if(session) {
         libssh2_session_disconnect(session, "Normal Shutdown");
         libssh2_session_free(session);
     }
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
+
     if(local)
         fclose(local);
+
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/scp_write_nonblock.c b/libssh2/example/scp_write_nonblock.c
index 9226322e..f3d2b480 100644
--- a/libssh2/example/scp_write_nonblock.c
+++ b/libssh2/example/scp_write_nonblock.c
@@ -1,41 +1,40 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do an SCP non-blocking upload transfer.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
-
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-#include <time.h>
+#include <time.h>  /* for time() */
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "scp_write.c";
+static const char *scppath = "/tmp/TEST";
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -49,7 +48,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -60,41 +66,37 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
+    int rc;
     LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "scp_write.c";
-    const char *scppath = "/tmp/TEST";
     FILE *local;
-    int rc;
-    char mem[1024*100];
+    char mem[1024 * 100];
     size_t nread;
     char *ptr;
     struct stat fileinfo;
     time_t start;
-    long total = 0;
+    libssh2_struct_stat_size total = 0;
     int duration;
     size_t prev;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -119,39 +121,42 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     stat(loclfile, &fileinfo);
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -159,14 +164,14 @@ int main(int argc, char *argv[])
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
      */
-    while((rc = libssh2_session_handshake(session, sock))
-          == LIBSSH2_ERROR_EAGAIN);
+    while((rc = libssh2_session_handshake(session, sock)) ==
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -189,14 +194,12 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-#define HOME "/home/username/"
         while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        HOME ".ssh/id_rsa.pub",
-                                                        HOME ".ssh/id_rsa",
+                                                        pubkey, privkey,
                                                         password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -204,10 +207,10 @@ int main(int argc, char *argv[])
     /* Send a file via scp. The mode parameter must only have permissions! */
     do {
         channel = libssh2_scp_send(session, scppath, fileinfo.st_mode & 0777,
-                                   (unsigned long)fileinfo.st_size);
+                                   (size_t)fileinfo.st_size);
 
-        if((!channel) && (libssh2_session_last_errno(session) !=
-                          LIBSSH2_ERROR_EAGAIN)) {
+        if(!channel &&
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
             char *err_msg;
 
             libssh2_session_last_error(session, &err_msg, NULL, 0);
@@ -226,34 +229,36 @@ int main(int argc, char *argv[])
         }
         ptr = mem;
 
-        total += nread;
+        total += (libssh2_struct_stat_size)nread;
 
         prev = 0;
         do {
-            while((rc = libssh2_channel_write(channel, ptr, nread)) ==
+            ssize_t nwritten;
+            while((nwritten = libssh2_channel_write(channel, ptr, nread)) ==
                   LIBSSH2_ERROR_EAGAIN) {
                 waitsocket(sock, session);
                 prev = 0;
             }
-            if(rc < 0) {
-                fprintf(stderr, "ERROR %d total %ld / %d prev %d\n", rc,
-                        total, (int)nread, (int)prev);
+            if(nwritten < 0) {
+                fprintf(stderr, "ERROR %ld total %ld / %lu prev %lu\n",
+                        (long)nwritten, (long)total,
+                        (unsigned long)nread, (unsigned long)prev);
                 break;
             }
             else {
                 prev = nread;
 
-                /* rc indicates how many bytes were written this time */
-                nread -= rc;
-                ptr += rc;
+                /* nwritten indicates how many bytes were written this time */
+                ptr += nwritten;
+                nread -= (size_t)nwritten;
             }
         } while(nread);
     } while(!nread); /* only continue if nread was drained */
 
-    duration = (int)(time(NULL)-start);
+    duration = (int)(time(NULL) - start);
 
     fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
+           (long)total, duration, (double)total / duration);
 
     fprintf(stderr, "Sending EOF\n");
     while(libssh2_channel_send_eof(channel) == LIBSSH2_ERROR_EAGAIN);
@@ -267,21 +272,26 @@ int main(int argc, char *argv[])
     libssh2_channel_free(channel);
     channel = NULL;
 
- shutdown:
+shutdown:
 
-    while(libssh2_session_disconnect(session,
-                                     "Normal Shutdown,") ==
-          LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
+    if(session) {
+        while(libssh2_session_disconnect(session, "Normal Shutdown") ==
+              LIBSSH2_ERROR_EAGAIN);
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp.c b/libssh2/example/sftp.c
index 8f67244a..67eeddf7 100644
--- a/libssh2/example/sftp.c
+++ b/libssh2/example/sftp.c
@@ -1,48 +1,44 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP transfers.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password /tmp/secrets -p|-i|-k"
+ * $ ./sftp 192.168.0.1 user password /tmp/secrets -p|-i|-k
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
+#ifdef _WIN32
+#define write(f, b, c)  write((f), (b), (unsigned int)(c))
 #endif
+
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-
-
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
-const char *sftppath = "/tmp/TEST";
+#include <string.h>
 
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/TEST";
 
 static void kbd_callback(const char *name, int name_len,
                          const char *instruction, int instruction_len,
@@ -59,11 +55,11 @@ static void kbd_callback(const char *name, int name_len,
     fprintf(stderr, "Performing keyboard-interactive authentication.\n");
 
     fprintf(stderr, "Authentication name: '");
-    fwrite(name, 1, name_len, stderr);
+    fwrite(name, 1, (size_t)name_len, stderr);
     fprintf(stderr, "'\n");
 
     fprintf(stderr, "Authentication instruction: '");
-    fwrite(instruction, 1, instruction_len, stderr);
+    fwrite(instruction, 1, (size_t)instruction_len, stderr);
     fprintf(stderr, "'\n");
 
     fprintf(stderr, "Number of prompts: %d\n\n", num_prompts);
@@ -77,11 +73,11 @@ static void kbd_callback(const char *name, int name_len,
         fgets(buf, sizeof(buf), stdin);
         n = strlen(buf);
         while(n > 0 && strchr("\r\n", buf[n - 1]))
-          n--;
+            n--;
         buf[n] = 0;
 
         responses[i].text = strdup(buf);
-        responses[i].length = n;
+        responses[i].length = (unsigned int)n;
 
         fprintf(stderr, "Response %d from user is '", i);
         fwrite(responses[i].text, 1, responses[i].length, stderr);
@@ -92,26 +88,25 @@ static void kbd_callback(const char *name, int name_len,
         "Done. Sending keyboard-interactive responses to server now.\n");
 }
 
-
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 0;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 0;
     struct sockaddr_in sin;
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
     int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -122,7 +117,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -134,7 +128,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -144,21 +138,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are blocking */
     libssh2_session_set_blocking(session, 1);
@@ -169,10 +167,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -185,68 +183,72 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 4. argument we set this option if supported */
-    if(argc > 5) {
-        if((auth_pw & 1) && !strcasecmp(argv[5], "-p")) {
-            auth_pw = 1;
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password")) {
+            auth_pw |= 1;
         }
-        if((auth_pw & 2) && !strcasecmp(argv[5], "-i")) {
-            auth_pw = 2;
+        if(strstr(userauthlist, "keyboard-interactive")) {
+            auth_pw |= 2;
         }
-        if((auth_pw & 4) && !strcasecmp(argv[5], "-k")) {
-            auth_pw = 4;
+        if(strstr(userauthlist, "publickey")) {
+            auth_pw |= 4;
         }
-    }
 
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
+        /* check for options */
+        if(argc > 5) {
+            if((auth_pw & 1) && !strcmp(argv[5], "-p")) {
+                auth_pw = 1;
+            }
+            if((auth_pw & 2) && !strcmp(argv[5], "-i")) {
+                auth_pw = 2;
+            }
+            if((auth_pw & 4) && !strcmp(argv[5], "-k")) {
+                auth_pw = 4;
+            }
         }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
+
+        if(auth_pw & 1) {
+            /* We could authenticate via password */
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
         }
-        else {
-            fprintf(stderr,
-                "\tAuthentication by keyboard-interactive succeeded.\n");
+        else if(auth_pw & 2) {
+            /* Or via keyboard-interactive */
+            if(libssh2_userauth_keyboard_interactive(session, username,
+                                                     &kbd_callback) ) {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive succeeded.\n");
+            }
         }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
+        else if(auth_pw & 4) {
+            /* Or by public key */
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
         }
         else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
+            fprintf(stderr, "No supported authentication methods found.\n");
+            goto shutdown;
         }
     }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     sftp_session = libssh2_sftp_init(session);
 
     if(!sftp_session) {
@@ -254,25 +256,26 @@ int main(int argc, char *argv[])
         goto shutdown;
     }
 
-    fprintf(stderr, "libssh2_sftp_open()!\n");
+    fprintf(stderr, "libssh2_sftp_open().\n");
     /* Request a file via SFTP */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath, LIBSSH2_FXF_READ, 0);
-
+    sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
+                                    LIBSSH2_FXF_READ, 0);
     if(!sftp_handle) {
         fprintf(stderr, "Unable to open file with SFTP: %ld\n",
                 libssh2_sftp_last_error(sftp_session));
         goto shutdown;
     }
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
+
+    fprintf(stderr, "libssh2_sftp_open() is done, now receive data.\n");
     do {
         char mem[1024];
+        ssize_t nread;
 
         /* loop until we fail */
-        fprintf(stderr, "libssh2_sftp_read()!\n");
-        rc = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
-        if(rc > 0) {
-            write(1, mem, rc);
+        fprintf(stderr, "libssh2_sftp_read().\n");
+        nread = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
+        if(nread > 0) {
+            write(1, mem, (size_t)nread);
         }
         else {
             break;
@@ -282,19 +285,25 @@ int main(int argc, char *argv[])
     libssh2_sftp_close(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);
 
-  shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_RW_nonblock.c b/libssh2/example/sftp_RW_nonblock.c
index 70d87db3..776a7d6c 100644
--- a/libssh2/example/sftp_RW_nonblock.c
+++ b/libssh2/example/sftp_RW_nonblock.c
@@ -1,49 +1,48 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP transfers in a non-blocking manner.
  *
  * It will first download a given source file, store it locally and then
  * upload the file again to a given destination file.
  *
  * Using the SFTP server running on 127.0.0.1
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
+#ifdef _WIN32
+#define write(f, b, c)  write((f), (b), (unsigned int)(c))
 #endif
+
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
 
-#define STORAGE "/tmp/sftp-storage" /* this is the local file name this
-                                       example uses to store the downloaded
-                                       file in */
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/TEST"; /* source path */
+static const char *dest = "/tmp/TEST2";    /* destination path */
+static const char *storage = "/tmp/sftp-storage"; /* local file name to store
+                                                     the downloaded file in */
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -57,7 +56,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -68,67 +74,79 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    int sock, i, auth_pw = 1;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/TEST"; /* source path */
-    const char *dest = "/tmp/TEST2";    /* destination path */
     int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
-    FILE *tempstorage;
+    FILE *tempstorage = NULL;
     char mem[1000];
     struct timeval timeout;
     fd_set fd;
     fd_set fd2;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
 
+    if(argc > 1) {
+        username = argv[1];
+    }
+    if(argc > 2) {
+        password = argv[2];
+    }
+    if(argc > 3) {
+        sftppath = argv[3];
+    }
+    if(argc > 4) {
+        dest = argv[4];
+    }
+
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * The application is responsible for creating the socket establishing
-     * the connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = htonl(0x7F000001);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -136,12 +154,12 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
     libssh2_session_set_blocking(session, 0);
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -153,29 +171,16 @@ int main(int argc, char *argv[])
     }
     fprintf(stderr, "\n");
 
-    if(argc > 1) {
-        username = argv[1];
-    }
-    if(argc > 2) {
-        password = argv[2];
-    }
-    if(argc > 3) {
-        sftppath = argv[3];
-    }
-    if(argc > 4) {
-        dest = argv[4];
-    }
-
-    tempstorage = fopen(STORAGE, "wb");
+    tempstorage = fopen(storage, "wb");
     if(!tempstorage) {
-        fprintf(stderr, "Can't open temp storage file %s\n", STORAGE);
+        fprintf(stderr, "Cannot open temp storage file %s\n", storage);
         goto shutdown;
     }
 
     if(auth_pw) {
         /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password))
-               == LIBSSH2_ERROR_EAGAIN);
+        while((rc = libssh2_userauth_password(session, username, password)) ==
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
             fprintf(stderr, "Authentication by password failed.\n");
             goto shutdown;
@@ -184,15 +189,12 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         while((rc =
-               libssh2_userauth_publickey_fromfile(session, username,
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa.pub",
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa",
-                                                   password)) ==
+              libssh2_userauth_publickey_fromfile(session, username,
+                                                  pubkey, privkey,
+                                                  password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -201,8 +203,7 @@ int main(int argc, char *argv[])
         sftp_session = libssh2_sftp_init(session);
 
         if(!sftp_session) {
-            if(libssh2_session_last_errno(session) ==
-               LIBSSH2_ERROR_EAGAIN) {
+            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
                 fprintf(stderr, "non-blocking init\n");
                 waitsocket(sock, session); /* now we wait */
             }
@@ -217,10 +218,10 @@ int main(int argc, char *argv[])
     do {
         sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
                                         LIBSSH2_FXF_READ, 0);
-
         if(!sftp_handle) {
             if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "Unable to open file with SFTP\n");
+                fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                        libssh2_sftp_last_error(sftp_session));
                 goto shutdown;
             }
             else {
@@ -230,23 +231,24 @@ int main(int argc, char *argv[])
         }
     } while(!sftp_handle);
 
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
+    fprintf(stderr, "libssh2_sftp_open() is done, now receive data.\n");
     do {
+        ssize_t nread;
         do {
             /* read in a loop until we block */
-            rc = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
-            fprintf(stderr, "libssh2_sftp_read returned %d\n",
-                    rc);
+            nread = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
+            fprintf(stderr, "libssh2_sftp_read returned %ld\n",
+                    (long)nread);
 
-            if(rc > 0) {
+            if(nread > 0) {
                 /* write to stderr */
-                write(2, mem, rc);
+                write(2, mem, (size_t)nread);
                 /* write to temporary storage area */
-                fwrite(mem, rc, 1, tempstorage);
+                fwrite(mem, (size_t)nread, 1, tempstorage);
             }
-        } while(rc > 0);
+        } while(nread > 0);
 
-        if(rc != LIBSSH2_ERROR_EAGAIN) {
+        if(nread != LIBSSH2_ERROR_EAGAIN) {
             /* error or end of file */
             break;
         }
@@ -256,41 +258,50 @@ int main(int argc, char *argv[])
 
         FD_ZERO(&fd);
         FD_ZERO(&fd2);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         FD_SET(sock, &fd);
         FD_SET(sock, &fd2);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
         /* wait for readable or writeable */
-        rc = select(sock + 1, &fd, &fd2, NULL, &timeout);
+        rc = select((int)(sock + 1), &fd, &fd2, NULL, &timeout);
         if(rc <= 0) {
             /* negative is error
                0 is timeout */
             fprintf(stderr, "SFTP download timed out: %d\n", rc);
             break;
         }
-
     } while(1);
 
     libssh2_sftp_close(sftp_handle);
     fclose(tempstorage);
 
-    tempstorage = fopen(STORAGE, "rb");
+    tempstorage = fopen(storage, "rb");
     if(!tempstorage) {
-        /* weird, we can't read the file we just wrote to... */
-        fprintf(stderr, "can't open %s for reading\n", STORAGE);
+        /* weird, we cannot read the file we just wrote to... */
+        fprintf(stderr, "Cannot open %s for reading\n", storage);
         goto shutdown;
     }
 
     /* we're done downloading, now reverse the process and upload the
        temporarily stored data to the destination path */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, dest,
-                          LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT,
-                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
+    sftp_handle = libssh2_sftp_open(sftp_session, dest,
+                                    LIBSSH2_FXF_WRITE |
+                                    LIBSSH2_FXF_CREAT,
+                                    LIBSSH2_SFTP_S_IRUSR |
+                                    LIBSSH2_SFTP_S_IWUSR |
+                                    LIBSSH2_SFTP_S_IRGRP |
+                                    LIBSSH2_SFTP_S_IROTH);
     if(sftp_handle) {
         size_t nread;
         char *ptr;
         do {
+            ssize_t nwritten;
             nread = fread(mem, 1, sizeof(mem), tempstorage);
             if(nread <= 0) {
                 /* end of file */
@@ -300,13 +311,15 @@ int main(int argc, char *argv[])
 
             do {
                 /* write data in a loop until we block */
-                rc = libssh2_sftp_write(sftp_handle, ptr,
-                                        nread);
-                ptr += rc;
-                nread -= nread;
-            } while(rc >= 0);
-
-            if(rc != LIBSSH2_ERROR_EAGAIN) {
+                nwritten = libssh2_sftp_write(sftp_handle, ptr,
+                                              nread);
+                if(nwritten < 0)
+                    break;
+                ptr += nwritten;
+                nread -= (size_t)nwritten;
+            } while(nwritten >= 0);
+
+            if(nwritten != LIBSSH2_ERROR_EAGAIN) {
                 /* error or end of file */
                 break;
             }
@@ -316,20 +329,26 @@ int main(int argc, char *argv[])
 
             FD_ZERO(&fd);
             FD_ZERO(&fd2);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
             FD_SET(sock, &fd);
             FD_SET(sock, &fd2);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
             /* wait for readable or writeable */
-            rc = select(sock + 1, &fd, &fd2, NULL, &timeout);
+            rc = select((int)(sock + 1), &fd, &fd2, NULL, &timeout);
             if(rc <= 0) {
                 /* negative is error
                    0 is timeout */
-                fprintf(stderr, "SFTP upload timed out: %d\n",
-                        rc);
+                fprintf(stderr, "SFTP upload timed out: %d\n", rc);
                 break;
             }
         } while(1);
-        fprintf(stderr, "SFTP upload done!\n");
+        fprintf(stderr, "SFTP upload done.\n");
     }
     else {
         fprintf(stderr, "SFTP failed to open destination path: %s\n",
@@ -338,21 +357,28 @@ int main(int argc, char *argv[])
 
     libssh2_sftp_shutdown(sftp_session);
 
-  shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     if(tempstorage)
         fclose(tempstorage);
+
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_append.c b/libssh2/example/sftp_append.c
index bfea1f72..df73c9c5 100644
--- a/libssh2/example/sftp_append.c
+++ b/libssh2/example/sftp_append.c
@@ -1,65 +1,65 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP append of a local file onto a remote one.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * sftp_append 192.168.0.1 user password localfile /tmp/remotefile
+ * $ ./sftp_append 192.168.0.1 user password localfile /tmp/remotefile
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "sftp_write.c";
+static const char *sftppath = "/tmp/TEST";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write.c";
-    const char *sftppath = "/tmp/TEST";
     int rc;
-    FILE *local;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
     LIBSSH2_SFTP_ATTRIBUTES attrs;
-    char mem[1024*100];
+    char mem[1024 * 100];
+    FILE *local;
     size_t nread;
+    ssize_t nwritten;
     char *ptr;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -70,7 +70,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -92,8 +91,8 @@ int main(int argc, char *argv[])
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     /*
@@ -101,21 +100,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are blocking */
     libssh2_session_set_blocking(session, 1);
@@ -126,10 +129,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -150,17 +153,15 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-#define HOME "/home/username/"
         if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME ".ssh/id_rsa.pub",
-                                               HOME ".ssh/id_rsa",
+                                               pubkey, privkey,
                                                password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     sftp_session = libssh2_sftp_init(session);
 
     if(!sftp_session) {
@@ -168,16 +169,18 @@ int main(int argc, char *argv[])
         goto shutdown;
     }
 
-    fprintf(stderr, "libssh2_sftp_open() for READ and WRITE!\n");
+    fprintf(stderr, "libssh2_sftp_open() for READ and WRITE.\n");
     /* Request a file via SFTP */
-
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath,
-                          LIBSSH2_FXF_WRITE|LIBSSH2_FXF_READ,
-                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
+    sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
+                                    LIBSSH2_FXF_WRITE |
+                                    LIBSSH2_FXF_READ,
+                                    LIBSSH2_SFTP_S_IRUSR |
+                                    LIBSSH2_SFTP_S_IWUSR |
+                                    LIBSSH2_SFTP_S_IRGRP |
+                                    LIBSSH2_SFTP_S_IROTH);
     if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
+        fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                libssh2_sftp_last_error(sftp_session));
         goto shutdown;
     }
 
@@ -190,12 +193,13 @@ int main(int argc, char *argv[])
     fprintf(stderr, "Did a seek to position %ld\n", (long) attrs.filesize);
 
     fprintf(stderr, "libssh2_sftp_open() a handle for APPEND\n");
-
     if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
+        fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                libssh2_sftp_last_error(sftp_session));
         goto shutdown;
     }
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
+
+    fprintf(stderr, "libssh2_sftp_open() is done, now send data.\n");
     do {
         nread = fread(mem, 1, sizeof(mem), local);
         if(nread <= 0) {
@@ -206,33 +210,39 @@ int main(int argc, char *argv[])
 
         do {
             /* write data in a loop until we block */
-            rc = libssh2_sftp_write(sftp_handle, ptr, nread);
-            if(rc < 0)
+            nwritten = libssh2_sftp_write(sftp_handle, ptr, nread);
+            if(nwritten < 0)
                 break;
-            ptr += rc;
-            nread -= rc;
+            ptr += nwritten;
+            nread -= (size_t)nwritten;
         } while(nread);
-
-    } while(rc > 0);
+    } while(nwritten > 0);
 
     libssh2_sftp_close(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);
 
 shutdown:
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
+
     if(local)
         fclose(local);
+
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_mkdir.c b/libssh2/example/sftp_mkdir.c
index 2347abe4..3099a255 100644
--- a/libssh2/example/sftp_mkdir.c
+++ b/libssh2/example/sftp_mkdir.c
@@ -1,58 +1,57 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP mkdir
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password /tmp/sftp_mkdir"
+ * $ ./sftp_mkdir 192.168.0.1 user password /tmp/sftp_mkdir
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/sftp_mkdir";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/sftp_mkdir";
     int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -63,7 +62,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -75,7 +73,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -85,21 +83,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -107,10 +109,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -132,10 +134,9 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         if(libssh2_userauth_publickey_fromfile(session, username,
-                            "/home/username/.ssh/id_rsa.pub",
-                            "/home/username/.ssh/id_rsa",
-                            password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+                                               pubkey, privkey,
+                                               password)) {
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -152,28 +153,35 @@ int main(int argc, char *argv[])
 
     /* Make a directory via SFTP */
     rc = libssh2_sftp_mkdir(sftp_session, sftppath,
-                            LIBSSH2_SFTP_S_IRWXU|
-                            LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IXGRP|
-                            LIBSSH2_SFTP_S_IROTH|LIBSSH2_SFTP_S_IXOTH);
-
+                            LIBSSH2_SFTP_S_IRWXU |
+                            LIBSSH2_SFTP_S_IRGRP |
+                            LIBSSH2_SFTP_S_IXGRP |
+                            LIBSSH2_SFTP_S_IROTH |
+                            LIBSSH2_SFTP_S_IXOTH);
     if(rc)
         fprintf(stderr, "libssh2_sftp_mkdir failed: %d\n", rc);
 
     libssh2_sftp_shutdown(sftp_session);
 
- shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_mkdir_nonblock.c b/libssh2/example/sftp_mkdir_nonblock.c
index 217cc4b3..40c1f4a2 100644
--- a/libssh2/example/sftp_mkdir_nonblock.c
+++ b/libssh2/example/sftp_mkdir_nonblock.c
@@ -1,58 +1,57 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP non-blocking mkdir.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password /tmp/sftp_write_nonblock.c"
+ * $ ./sftp_mkdir_nonblock 192.168.0.1 user password /tmp/sftp_write_nonblock.c
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/sftp_mkdir_nonblock";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/sftp_mkdir_nonblock";
     int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -63,7 +62,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -75,7 +73,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -85,21 +83,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -107,10 +109,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -132,15 +134,13 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         if(libssh2_userauth_publickey_fromfile(session, username,
-                            "/home/username/.ssh/id_rsa.pub",
-                            "/home/username/.ssh/id_rsa",
-                            password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+                                               pubkey, privkey,
+                                               password)) {
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
     sftp_session = libssh2_sftp_init(session);
 
     if(!sftp_session) {
@@ -151,29 +151,36 @@ int main(int argc, char *argv[])
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
 
-    fprintf(stderr, "libssh2_sftp_mkdirnb()!\n");
     /* Make a directory via SFTP */
     while(libssh2_sftp_mkdir(sftp_session, sftppath,
-                              LIBSSH2_SFTP_S_IRWXU|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IXGRP|
-                              LIBSSH2_SFTP_S_IROTH|LIBSSH2_SFTP_S_IXOTH)
-           == LIBSSH2_ERROR_EAGAIN);
+                             LIBSSH2_SFTP_S_IRWXU |
+                             LIBSSH2_SFTP_S_IRGRP |
+                             LIBSSH2_SFTP_S_IXGRP |
+                             LIBSSH2_SFTP_S_IROTH |
+                             LIBSSH2_SFTP_S_IXOTH) ==
+          LIBSSH2_ERROR_EAGAIN);
 
     libssh2_sftp_shutdown(sftp_session);
 
- shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_nonblock.c b/libssh2/example/sftp_nonblock.c
index 8ef091e1..e375bce7 100644
--- a/libssh2/example/sftp_nonblock.c
+++ b/libssh2/example/sftp_nonblock.c
@@ -1,54 +1,57 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP non-blocking transfers.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp_nonblock 192.168.0.1 user password /tmp/secrets"
+ * $ ./sftp_nonblock 192.168.0.1 user password /tmp/secrets
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
+#ifdef _WIN32
+#define write(f, b, c)  write((f), (b), (unsigned int)(c))
 #endif
+
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/TEST";
 
 #ifdef HAVE_GETTIMEOFDAY
 /* diff in ms */
 static long tvdiff(struct timeval newer, struct timeval older)
 {
-  return (newer.tv_sec-older.tv_sec)*1000+
-      (newer.tv_usec-older.tv_usec)/1000;
+    return (newer.tv_sec - older.tv_sec) * 1000 +
+        (newer.tv_usec - older.tv_usec) / 1000;
 }
 #endif
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -62,7 +65,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -73,39 +83,36 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/TEST";
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
+    LIBSSH2_SFTP *sftp_session;
+    LIBSSH2_SFTP_HANDLE *sftp_handle;
 #ifdef HAVE_GETTIMEOFDAY
     struct timeval start;
     struct timeval end;
     long time_ms;
 #endif
-    int rc;
-    int total = 0;
+    libssh2_struct_stat_size total = 0;
     int spin = 0;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -116,7 +123,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -128,7 +134,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -138,20 +144,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -161,20 +172,20 @@ int main(int argc, char *argv[])
 #endif
 
     /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
+     * and setup crypto, compression, and MAC layers
+     */
     while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
-        * is check the hostkey's fingerprint against our known hosts Your app
-        * may have it hard coded, may go to a file, may present it to the
-        * user, that's your call
-        */
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
+     */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
     for(i = 0; i < 20; i++) {
@@ -184,8 +195,8 @@ int main(int argc, char *argv[])
 
     if(auth_pw) {
         /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password))
-               == LIBSSH2_ERROR_EAGAIN);
+        while((rc = libssh2_userauth_password(session, username, password)) ==
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
             fprintf(stderr, "Authentication by password failed.\n");
             goto shutdown;
@@ -194,28 +205,24 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         while((rc =
-               libssh2_userauth_publickey_fromfile(session, username,
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa.pub",
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa",
-                                                   password)) ==
+              libssh2_userauth_publickey_fromfile(session, username,
+                                                  pubkey, privkey,
+                                                  password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 #if 0
     libssh2_trace(session, LIBSSH2_TRACE_CONN);
 #endif
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     do {
         sftp_session = libssh2_sftp_init(session);
 
         if(!sftp_session) {
-            if(libssh2_session_last_errno(session) ==
-               LIBSSH2_ERROR_EAGAIN) {
+            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
                 fprintf(stderr, "non-blocking init\n");
                 waitsocket(sock, session); /* now we wait */
             }
@@ -226,15 +233,15 @@ int main(int argc, char *argv[])
         }
     } while(!sftp_session);
 
-    fprintf(stderr, "libssh2_sftp_open()!\n");
+    fprintf(stderr, "libssh2_sftp_open().\n");
     /* Request a file via SFTP */
     do {
         sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
                                         LIBSSH2_FXF_READ, 0);
-
         if(!sftp_handle) {
             if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "Unable to open file with SFTP\n");
+                fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                        libssh2_sftp_last_error(sftp_session));
                 goto shutdown;
             }
             else {
@@ -244,19 +251,20 @@ int main(int argc, char *argv[])
         }
     } while(!sftp_handle);
 
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
+    fprintf(stderr, "libssh2_sftp_open() is done, now receive data.\n");
     do {
-        char mem[1024*24];
+        char mem[1024 * 24];
+        ssize_t nread;
 
         /* loop until we fail */
-        while((rc = libssh2_sftp_read(sftp_handle, mem,
-                                       sizeof(mem))) == LIBSSH2_ERROR_EAGAIN) {
+        while((nread = libssh2_sftp_read(sftp_handle, mem, sizeof(mem))) ==
+              LIBSSH2_ERROR_EAGAIN) {
             spin++;
             waitsocket(sock, session); /* now we wait */
         }
-        if(rc > 0) {
-            total += rc;
-            write(1, mem, rc);
+        if(nread > 0) {
+            total += nread;
+            write(1, mem, (size_t)nread);
         }
         else {
             break;
@@ -266,11 +274,11 @@ int main(int argc, char *argv[])
 #ifdef HAVE_GETTIMEOFDAY
     gettimeofday(&end, NULL);
     time_ms = tvdiff(end, start);
-    fprintf(stderr, "Got %d bytes in %ld ms = %.1f bytes/sec spin: %d\n",
-            total,
-            time_ms, total/(time_ms/1000.0), spin);
+    fprintf(stderr, "Got %ld bytes in %ld ms = %.1f bytes/sec spin: %d\n",
+            (long)total, time_ms,
+            (double)total / ((double)time_ms / 1000.0), spin);
 #else
-    fprintf(stderr, "Got %d bytes spin: %d\n", total, spin);
+    fprintf(stderr, "Got %ld bytes spin: %d\n", (long)total, spin);
 #endif
 
     libssh2_sftp_close(sftp_handle);
@@ -278,20 +286,25 @@ int main(int argc, char *argv[])
 
 shutdown:
 
-    fprintf(stderr, "libssh2_session_disconnect\n");
-    while(libssh2_session_disconnect(session,
-                                      "Normal Shutdown, Thank you") ==
-           LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
+    if(session) {
+        fprintf(stderr, "libssh2_session_disconnect\n");
+        while(libssh2_session_disconnect(session, "Normal Shutdown") ==
+              LIBSSH2_ERROR_EAGAIN);
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_write.c b/libssh2/example/sftp_write.c
index c1350e9c..f1b6f0ae 100644
--- a/libssh2/example/sftp_write.c
+++ b/libssh2/example/sftp_write.c
@@ -1,64 +1,64 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP write transfers.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password sftp_write.c /tmp/secrets"
+ * $ ./sftp_write 192.168.0.1 user password sftp_write.c /tmp/secrets
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "sftp_write.c";
+static const char *sftppath = "/tmp/TEST";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write.c";
-    const char *sftppath = "/tmp/TEST";
     int rc;
-    FILE *local;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
-    char mem[1024*100];
+    FILE *local;
+    char mem[1024 * 100];
     size_t nread;
+    ssize_t nwritten;
     char *ptr;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -69,7 +69,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -84,15 +83,15 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     /*
@@ -100,21 +99,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are blocking */
     libssh2_session_set_blocking(session, 1);
@@ -125,10 +128,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -149,17 +152,15 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-        const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-        const char *privkey = "/home/username/.ssh/id_rsa.pub";
         if(libssh2_userauth_publickey_fromfile(session, username,
                                                pubkey, privkey,
                                                password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     sftp_session = libssh2_sftp_init(session);
 
     if(!sftp_session) {
@@ -167,19 +168,23 @@ int main(int argc, char *argv[])
         goto shutdown;
     }
 
-    fprintf(stderr, "libssh2_sftp_open()!\n");
+    fprintf(stderr, "libssh2_sftp_open().\n");
     /* Request a file via SFTP */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath,
-                      LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC,
-                      LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                      LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-
+    sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
+                                    LIBSSH2_FXF_WRITE |
+                                    LIBSSH2_FXF_CREAT |
+                                    LIBSSH2_FXF_TRUNC,
+                                    LIBSSH2_SFTP_S_IRUSR |
+                                    LIBSSH2_SFTP_S_IWUSR |
+                                    LIBSSH2_SFTP_S_IRGRP |
+                                    LIBSSH2_SFTP_S_IROTH);
     if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
+        fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                libssh2_sftp_last_error(sftp_session));
         goto shutdown;
     }
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
+
+    fprintf(stderr, "libssh2_sftp_open() is done, now send data.\n");
     do {
         nread = fread(mem, 1, sizeof(mem), local);
         if(nread <= 0) {
@@ -190,33 +195,39 @@ int main(int argc, char *argv[])
 
         do {
             /* write data in a loop until we block */
-            rc = libssh2_sftp_write(sftp_handle, ptr, nread);
-            if(rc < 0)
+            nwritten = libssh2_sftp_write(sftp_handle, ptr, nread);
+            if(nwritten < 0)
                 break;
-            ptr += rc;
-            nread -= rc;
+            ptr += nwritten;
+            nread -= (size_t)nwritten;
         } while(nread);
-
-    } while(rc > 0);
+    } while(nwritten > 0);
 
     libssh2_sftp_close(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);
 
 shutdown:
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
+
     if(local)
         fclose(local);
+
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_write_nonblock.c b/libssh2/example/sftp_write_nonblock.c
index 934749ea..d7671b64 100644
--- a/libssh2/example/sftp_write_nonblock.c
+++ b/libssh2/example/sftp_write_nonblock.c
@@ -1,46 +1,46 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP non-blocking write transfers.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password thisfile /tmp/storehere"
+ * $ ./sftp_write_nonblock 192.168.0.1 user password thisfile /tmp/storehere
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-#include <time.h>
+#include <time.h>  /* for time() */
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "sftp_write_nonblock.c";
+static const char *sftppath = "/tmp/sftp_write_nonblock.c";
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -54,7 +54,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -65,40 +72,37 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write_nonblock.c";
-    const char *sftppath = "/tmp/sftp_write_nonblock.c";
     int rc;
-    FILE *local;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
+    FILE *local;
     char mem[1024 * 100];
     size_t nread;
+    ssize_t nwritten;
     char *ptr;
     time_t start;
-    long total = 0;
+    libssh2_struct_stat_size total = 0;
     int duration;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -109,7 +113,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -124,15 +127,15 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     /*
@@ -140,39 +143,43 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-        */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
 
     /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
-    while((rc = libssh2_session_handshake(session, sock))
-           == LIBSSH2_ERROR_EAGAIN);
+     * and setup crypto, compression, and MAC layers
+     */
+    while((rc = libssh2_session_handshake(session, sock)) ==
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do is
-     * check the hostkey's fingerprint against our known hosts Your app may
-     * have it hard coded, may go to a file, may present it to the user,
-     * that's your call
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
      */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
@@ -184,7 +191,7 @@ int main(int argc, char *argv[])
     if(auth_pw) {
         /* We could authenticate via password */
         while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
             fprintf(stderr, "Authentication by password failed.\n");
             goto shutdown;
@@ -192,49 +199,48 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-        const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-        const char *privkey = "/home/username/.ssh/id_rsa";
         while((rc = libssh2_userauth_publickey_fromfile(session, username,
                                                         pubkey, privkey,
                                                         password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     do {
         sftp_session = libssh2_sftp_init(session);
 
         if(!sftp_session &&
-            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
             fprintf(stderr, "Unable to init SFTP session\n");
             goto shutdown;
         }
     } while(!sftp_session);
 
-    fprintf(stderr, "libssh2_sftp_open()!\n");
+    fprintf(stderr, "libssh2_sftp_open().\n");
     /* Request a file via SFTP */
     do {
-        sftp_handle =
-            libssh2_sftp_open(sftp_session, sftppath,
-                              LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|
-                              LIBSSH2_FXF_TRUNC,
-                              LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
+        sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
+                                        LIBSSH2_FXF_WRITE |
+                                        LIBSSH2_FXF_CREAT |
+                                        LIBSSH2_FXF_TRUNC,
+                                        LIBSSH2_SFTP_S_IRUSR |
+                                        LIBSSH2_SFTP_S_IWUSR |
+                                        LIBSSH2_SFTP_S_IRGRP |
+                                        LIBSSH2_SFTP_S_IROTH);
         if(!sftp_handle &&
-           (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to open file with SFTP\n");
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
+            fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                    libssh2_sftp_last_error(sftp_session));
             goto shutdown;
         }
     } while(!sftp_handle);
 
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-
+    fprintf(stderr, "libssh2_sftp_open() is done, now send data.\n");
     start = time(NULL);
-
     do {
         nread = fread(mem, 1, sizeof(mem), local);
         if(nread <= 0) {
@@ -243,27 +249,25 @@ int main(int argc, char *argv[])
         }
         ptr = mem;
 
-        total += nread;
+        total += (libssh2_struct_stat_size)nread;
 
         do {
             /* write data in a loop until we block */
-            while((rc = libssh2_sftp_write(sftp_handle, ptr, nread)) ==
-                   LIBSSH2_ERROR_EAGAIN) {
+            while((nwritten = libssh2_sftp_write(sftp_handle, ptr, nread)) ==
+                  LIBSSH2_ERROR_EAGAIN) {
                 waitsocket(sock, session);
             }
-            if(rc < 0)
+            if(nwritten < 0)
                 break;
-            ptr += rc;
-            nread -= rc;
-
+            ptr += nwritten;
+            nread -= (size_t)nwritten;
         } while(nread);
-    } while(rc > 0);
+    } while(nwritten > 0);
 
-    duration = (int)(time(NULL)-start);
+    duration = (int)(time(NULL) - start);
 
     fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
-
+            (long)total, duration, (double)total / duration);
 
     fclose(local);
     libssh2_sftp_close(sftp_handle);
@@ -271,18 +275,24 @@ int main(int argc, char *argv[])
 
 shutdown:
 
-    while(libssh2_session_disconnect(session, "Normal Shutdown")
-           == LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
+    if(session) {
+        while(libssh2_session_disconnect(session, "Normal Shutdown") ==
+              LIBSSH2_ERROR_EAGAIN);
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftp_write_sliding.c b/libssh2/example/sftp_write_sliding.c
index 9a72140f..4390246b 100644
--- a/libssh2/example/sftp_write_sliding.c
+++ b/libssh2/example/sftp_write_sliding.c
@@ -1,46 +1,47 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SFTP non-blocking write transfers.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "sftp 192.168.0.1 user password file /tmp/storehere"
+ * $ ./sftp_write_sliding 192.168.0.1 user password thisfile /tmp/storehere
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 #ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
+#include <sys/time.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-#include <time.h>
+#include <time.h>  /* for time() */
+#include <string.h>
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *loclfile = "sftp_write_nonblock.c";
+static const char *sftppath = "/tmp/sftp_write_nonblock.c";
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -54,7 +55,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -65,40 +73,37 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write_nonblock.c";
-    const char *sftppath = "/tmp/sftp_write_nonblock.c";
     int rc;
-    FILE *local;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
+    FILE *local;
     char mem[1024 * 1000];
     size_t nread;
+    ssize_t nwritten;
     size_t memuse;
     time_t start;
-    long total = 0;
+    libssh2_struct_stat_size total = 0;
     int duration;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -109,7 +114,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -124,15 +128,15 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     local = fopen(loclfile, "rb");
     if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
+        fprintf(stderr, "Cannot open local file %s\n", loclfile);
+        return 1;
     }
 
     /*
@@ -140,39 +144,43 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-        */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
 
     /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
-    while((rc = libssh2_session_handshake(session, sock))
-           == LIBSSH2_ERROR_EAGAIN);
+     * and setup crypto, compression, and MAC layers
+     */
+    while((rc = libssh2_session_handshake(session, sock)) ==
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do is
-     * check the hostkey's fingerprint against our known hosts Your app may
-     * have it hard coded, may go to a file, may present it to the user,
-     * that's your call
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
      */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
@@ -184,7 +192,7 @@ int main(int argc, char *argv[])
     if(auth_pw) {
         /* We could authenticate via password */
         while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
             fprintf(stderr, "Authentication by password failed.\n");
             goto shutdown;
@@ -192,53 +200,51 @@ int main(int argc, char *argv[])
     }
     else {
         /* Or by public key */
-#define PUBKEY "/home/username/.ssh/id_rsa.pub"
-#define PRIVKEY "/home/username/.ssh/id_rsa"
         while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        PUBKEY, PRIVKEY,
+                                                        pubkey, privkey,
                                                         password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     do {
         sftp_session = libssh2_sftp_init(session);
 
         if(!sftp_session &&
-            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
             fprintf(stderr, "Unable to init SFTP session\n");
             goto shutdown;
         }
     } while(!sftp_session);
 
-    fprintf(stderr, "libssh2_sftp_open()!\n");
+    fprintf(stderr, "libssh2_sftp_open().\n");
     /* Request a file via SFTP */
     do {
-        sftp_handle =
-            libssh2_sftp_open(sftp_session, sftppath,
-                              LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|
-                              LIBSSH2_FXF_TRUNC,
-                              LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-
+        sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
+                                        LIBSSH2_FXF_WRITE |
+                                        LIBSSH2_FXF_CREAT |
+                                        LIBSSH2_FXF_TRUNC,
+                                        LIBSSH2_SFTP_S_IRUSR |
+                                        LIBSSH2_SFTP_S_IWUSR |
+                                        LIBSSH2_SFTP_S_IRGRP |
+                                        LIBSSH2_SFTP_S_IROTH);
         if(!sftp_handle &&
-           (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to open file with SFTP\n");
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
+            fprintf(stderr, "Unable to open file with SFTP: %ld\n",
+                    libssh2_sftp_last_error(sftp_session));
             goto shutdown;
         }
     } while(!sftp_handle);
 
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-
+    fprintf(stderr, "libssh2_sftp_open() is done, now send data.\n");
     start = time(NULL);
-
-    memuse = 0; /* it starts blank */
+    memuse = 0;  /* it starts blank */
     do {
-        nread = fread(&mem[memuse], 1, sizeof(mem)-memuse, local);
+        nread = fread(&mem[memuse], 1, sizeof(mem) - memuse, local);
         if(nread <= 0) {
             /* end of file */
             if(memuse > 0)
@@ -248,32 +254,31 @@ int main(int argc, char *argv[])
                 break;
         }
         memuse += nread;
-        total += nread;
+        total += (libssh2_struct_stat_size)nread;
 
         /* write data in a loop until we block */
-        while((rc = libssh2_sftp_write(sftp_handle, mem, memuse)) ==
-               LIBSSH2_ERROR_EAGAIN) {
+        while((nwritten = libssh2_sftp_write(sftp_handle, mem, memuse)) ==
+              LIBSSH2_ERROR_EAGAIN) {
             waitsocket(sock, session);
         }
-        if(rc < 0)
+        if(nwritten < 0)
             break;
 
-        if(memuse - rc) {
+        if(memuse - (size_t)nwritten) {
             /* make room for more data at the end of the buffer */
-            memmove(&mem[0], &mem[rc], memuse - rc);
-            memuse -= rc;
+            memmove(&mem[0], &mem[nwritten], memuse - (size_t)nwritten);
+            memuse -= (size_t)nwritten;
         }
         else
             /* 'mem' was consumed fully */
             memuse = 0;
 
-    } while(rc > 0);
+    } while(nwritten > 0);
 
-    duration = (int)(time(NULL)-start);
+    duration = (int)(time(NULL) - start);
 
     fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
-
+            (long)total, duration, (double)total / duration);
 
     fclose(local);
     libssh2_sftp_close(sftp_handle);
@@ -281,18 +286,24 @@ int main(int argc, char *argv[])
 
 shutdown:
 
-    while(libssh2_session_disconnect(session, "Normal Shutdown")
-          == LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
+    if(session) {
+        while(libssh2_session_disconnect(session, "Normal Shutdown") ==
+              LIBSSH2_ERROR_EAGAIN);
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftpdir.c b/libssh2/example/sftpdir.c
index 8fb16b1e..815b452a 100644
--- a/libssh2/example/sftpdir.c
+++ b/libssh2/example/sftpdir.c
@@ -1,51 +1,46 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample doing an SFTP directory listing.
  *
  * The sample code has default values for host name, user name, password and
  * path, but you can specify them on the command line like:
  *
- * "sftpdir 192.168.0.1 user password /tmp/secretdir"
+ * $ ./sftpdir 192.168.0.1 user password /tmp/secretdir
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
 #ifdef HAVE_UNISTD_H
-# include <unistd.h>
+#include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+#include <string.h>
 
-#ifdef WIN32
-#define __FILESIZE "I64"
+#if defined(_MSC_VER)
+#define LIBSSH2_FILESIZE_MASK "I64u"
 #else
-#define __FILESIZE "llu"
+#define LIBSSH2_FILESIZE_MASK "llu"
 #endif
 
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/secretdir";
 
 static void kbd_callback(const char *name, int name_len,
                          const char *instruction, int instruction_len,
@@ -60,7 +55,7 @@ static void kbd_callback(const char *name, int name_len,
     (void)instruction_len;
     if(num_prompts == 1) {
         responses[0].text = strdup(password);
-        responses[0].length = strlen(password);
+        responses[0].length = (unsigned int)strlen(password);
     }
     (void)prompts;
     (void)abstract;
@@ -68,23 +63,23 @@ static void kbd_callback(const char *name, int name_len,
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int rc, sock, i, auth_pw = 0;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 0;
     struct sockaddr_in sin;
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
-    const char *sftppath = "/tmp/secretdir";
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -95,7 +90,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -107,7 +101,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -117,21 +111,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
      * and setup crypto, compression, and MAC layers
@@ -139,10 +137,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -155,71 +153,72 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 5. argument we set this option if supported */
-    if(argc > 5) {
-        if((auth_pw & 1) && !strcasecmp(argv[5], "-p")) {
-            auth_pw = 1;
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password")) {
+            auth_pw |= 1;
         }
-        if((auth_pw & 2) && !strcasecmp(argv[5], "-i")) {
-            auth_pw = 2;
+        if(strstr(userauthlist, "keyboard-interactive")) {
+            auth_pw |= 2;
         }
-        if((auth_pw & 4) && !strcasecmp(argv[5], "-k")) {
-            auth_pw = 4;
+        if(strstr(userauthlist, "publickey")) {
+            auth_pw |= 4;
         }
-    }
 
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "\tAuthentication by password failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by password succeeded.\n");
+        /* check for options */
+        if(argc > 5) {
+            if((auth_pw & 1) && !strcmp(argv[5], "-p")) {
+                auth_pw = 1;
+            }
+            if((auth_pw & 2) && !strcmp(argv[5], "-i")) {
+                auth_pw = 2;
+            }
+            if((auth_pw & 4) && !strcmp(argv[5], "-k")) {
+                auth_pw = 4;
+            }
         }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
+
+        if(auth_pw & 1) {
+            /* We could authenticate via password */
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
         }
-        else {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive succeeded.\n");
+        else if(auth_pw & 2) {
+            /* Or via keyboard-interactive */
+            if(libssh2_userauth_keyboard_interactive(session, username,
+                                                     &kbd_callback) ) {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive succeeded.\n");
+            }
         }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
+        else if(auth_pw & 4) {
+            /* Or by public key */
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
         }
         else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
+            fprintf(stderr, "No supported authentication methods found.\n");
+            goto shutdown;
         }
     }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     sftp_session = libssh2_sftp_init(session);
 
     if(!sftp_session) {
@@ -230,15 +229,15 @@ int main(int argc, char *argv[])
     /* Since we have not set non-blocking, tell libssh2 we are blocking */
     libssh2_session_set_blocking(session, 1);
 
-    fprintf(stderr, "libssh2_sftp_opendir()!\n");
+    fprintf(stderr, "libssh2_sftp_opendir().\n");
     /* Request a dir listing via SFTP */
     sftp_handle = libssh2_sftp_opendir(sftp_session, sftppath);
-
     if(!sftp_handle) {
         fprintf(stderr, "Unable to open dir with SFTP\n");
         goto shutdown;
     }
-    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing!\n");
+
+    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing.\n");
     do {
         char mem[512];
         char longentry[512];
@@ -272,33 +271,40 @@ int main(int argc, char *argv[])
                 }
 
                 if(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
-                    printf("%8" __FILESIZE " ", attrs.filesize);
+                    printf("%8" LIBSSH2_FILESIZE_MASK " ", attrs.filesize);
                 }
 
                 printf("%s\n", mem);
             }
         }
-        else
+        else {
             break;
+        }
 
     } while(1);
 
     libssh2_sftp_closedir(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);
 
- shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/sftpdir_nonblock.c b/libssh2/example/sftpdir_nonblock.c
index e9498d97..59b178c8 100644
--- a/libssh2/example/sftpdir_nonblock.c
+++ b/libssh2/example/sftpdir_nonblock.c
@@ -1,70 +1,64 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample doing an SFTP directory listing.
  *
  * The sample code has default values for host name, user name, password and
  * path, but you can specify them on the command line like:
  *
- * "sftpdir 192.168.0.1 user password /tmp/secretdir"
+ * $ ./sftpdir_nonblock 192.168.0.1 user password /tmp/secretdir
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
 
-#ifdef WIN32
-#define __FILESIZE "I64"
+#if defined(_MSC_VER)
+#define LIBSSH2_FILESIZE_MASK "I64u"
 #else
-#define __FILESIZE "llu"
+#define LIBSSH2_FILESIZE_MASK "llu"
 #endif
 
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
+static const char *sftppath = "/tmp/secretdir";
+
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 1;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/secretdir";
-    const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-    const char *privkey = "/home/username/.ssh/id_rsa";
     int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -75,7 +69,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -87,7 +80,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -97,21 +90,25 @@ int main(int argc, char *argv[])
      * and establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
-    /* Create a session instance
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* Since we have set non-blocking, tell libssh2 we are non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -123,10 +120,10 @@ int main(int argc, char *argv[])
           LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -154,44 +151,42 @@ int main(int argc, char *argv[])
                                                         password)) ==
               LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
 
-    fprintf(stderr, "libssh2_sftp_init()!\n");
+    fprintf(stderr, "libssh2_sftp_init().\n");
     do {
         sftp_session = libssh2_sftp_init(session);
 
-        if((!sftp_session) && (libssh2_session_last_errno(session) !=
-                               LIBSSH2_ERROR_EAGAIN)) {
+        if(!sftp_session &&
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
             fprintf(stderr, "Unable to init SFTP session\n");
             goto shutdown;
         }
     } while(!sftp_session);
 
-    fprintf(stderr, "libssh2_sftp_opendir()!\n");
+    fprintf(stderr, "libssh2_sftp_opendir().\n");
     /* Request a dir listing via SFTP */
     do {
         sftp_handle = libssh2_sftp_opendir(sftp_session, sftppath);
 
-        if((!sftp_handle) && (libssh2_session_last_errno(session) !=
-                              LIBSSH2_ERROR_EAGAIN)) {
+        if(!sftp_handle &&
+           libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
             fprintf(stderr, "Unable to open dir with SFTP\n");
             goto shutdown;
         }
     } while(!sftp_handle);
 
-    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing!\n");
+    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing.\n");
     do {
         char mem[512];
         LIBSSH2_SFTP_ATTRIBUTES attrs;
 
         /* loop until we fail */
         while((rc = libssh2_sftp_readdir(sftp_handle, mem, sizeof(mem),
-                                         &attrs)) == LIBSSH2_ERROR_EAGAIN) {
-            ;
-        }
+                                         &attrs)) == LIBSSH2_ERROR_EAGAIN);
         if(rc > 0) {
             /* rc is the length of the file name in the mem
                buffer */
@@ -213,7 +208,7 @@ int main(int argc, char *argv[])
             }
 
             if(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
-                printf("%8" __FILESIZE " ", attrs.filesize);
+                printf("%8" LIBSSH2_FILESIZE_MASK " ", attrs.filesize);
             }
 
             printf("%s\n", mem);
@@ -231,19 +226,25 @@ int main(int argc, char *argv[])
     libssh2_sftp_closedir(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);
 
-  shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/ssh2.c b/libssh2/example/ssh2.c
index fa86f551..d863eba2 100644
--- a/libssh2/example/ssh2.c
+++ b/libssh2/example/ssh2.c
@@ -1,47 +1,44 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SSH2 connect.
  *
  * The sample code has default values for host name, user name, password
  * and path to copy, but you can specify them on the command line like:
  *
- * "ssh2 host user password [-p|-i|-k]"
+ * $ ./ssh2 hostip user password [[-p|-i|-k] [command]]
+ *
+ *  -p authenticate using password
+ *  -i authenticate using keyboard-interactive
+ *  -k authenticate using public key (password argument decrypts keyfile)
+ *  command executes on the remote machine
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
-#include <libssh2_sftp.h>
 
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-# ifdef HAVE_ARPA_INET_H
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-
-
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
+#include <stdlib.h>
+#include <string.h>
 
+static const char *pubkey = ".ssh/id_rsa.pub";
+static const char *privkey = ".ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "password";
 
 static void kbd_callback(const char *name, int name_len,
                          const char *instruction, int instruction_len,
@@ -56,30 +53,30 @@ static void kbd_callback(const char *name, int name_len,
     (void)instruction_len;
     if(num_prompts == 1) {
         responses[0].text = strdup(password);
-        responses[0].length = strlen(password);
+        responses[0].length = (unsigned int)strlen(password);
     }
     (void)prompts;
     (void)abstract;
-} /* kbd_callback */
-
+}
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int rc, sock, i, auth_pw = 0;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 0;
     struct sockaddr_in sin;
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -90,7 +87,6 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
@@ -99,7 +95,7 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -108,29 +104,48 @@ int main(int argc, char *argv[])
      * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        rc = 1;
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+
+    fprintf(stderr, "Connecting to %s:%d as user %s\n",
+            inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), username);
+
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance and start it up. This will trade welcome
      * banners, exchange keys, and setup crypto, compression, and MAC layers
      */
     session = libssh2_session_init();
-    if(libssh2_session_handshake(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
     }
 
-    /* At this point we havn't authenticated. The first thing to do is check
-     * the hostkey's fingerprint against our known hosts Your app may have it
-     * hard coded, may go to a file, may present it to the user, that's your
-     * call
+    /* Enable all debugging when libssh2 was built with debugging enabled */
+    libssh2_trace(session, ~0);
+
+    rc = libssh2_session_handshake(session, sock);
+    if(rc) {
+        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
+        goto shutdown;
+    }
+
+    rc = 1;
+
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
      */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
@@ -140,71 +155,107 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 4. argument we set this option if supported */
-    if(argc > 4) {
-        if((auth_pw & 1) && !strcasecmp(argv[4], "-p")) {
-            auth_pw = 1;
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password")) {
+            auth_pw |= 1;
         }
-        if((auth_pw & 2) && !strcasecmp(argv[4], "-i")) {
-            auth_pw = 2;
+        if(strstr(userauthlist, "keyboard-interactive")) {
+            auth_pw |= 2;
         }
-        if((auth_pw & 4) && !strcasecmp(argv[4], "-k")) {
-            auth_pw = 4;
+        if(strstr(userauthlist, "publickey")) {
+            auth_pw |= 4;
         }
-    }
 
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "\tAuthentication by password failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by password succeeded.\n");
+        /* check for options */
+        if(argc > 4) {
+            if((auth_pw & 1) && !strcmp(argv[4], "-p")) {
+                auth_pw = 1;
+            }
+            if((auth_pw & 2) && !strcmp(argv[4], "-i")) {
+                auth_pw = 2;
+            }
+            if((auth_pw & 4) && !strcmp(argv[4], "-k")) {
+                auth_pw = 4;
+            }
         }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
+
+        if(auth_pw & 1) {
+            /* We could authenticate via password */
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by password succeeded.\n");
+            }
         }
-        else {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive succeeded.\n");
+        else if(auth_pw & 2) {
+            /* Or via keyboard-interactive */
+            if(libssh2_userauth_keyboard_interactive(session, username,
+                                                     &kbd_callback) ) {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr,
+                        "Authentication by keyboard-interactive succeeded.\n");
+            }
         }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
+        else if(auth_pw & 4) {
+            /* Or by public key */
+            size_t fn1sz, fn2sz;
+            char *fn1, *fn2;
+            char const *h = getenv("HOME");
+            if(!h || !*h)
+                h = ".";
+            fn1sz = strlen(h) + strlen(pubkey) + 2;
+            fn2sz = strlen(h) + strlen(privkey) + 2;
+            fn1 = malloc(fn1sz);
+            fn2 = malloc(fn2sz);
+            if(!fn1 || !fn2) {
+                free(fn2);
+                free(fn1);
+                fprintf(stderr, "out of memory\n");
+                goto shutdown;
+            }
+            /* Avoid false positives */
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic push
+#pragma GCC diagnostic warning "-Wformat-truncation=1"
+#endif
+            /* Using asprintf() here would be much cleaner,
+               but less portable */
+            snprintf(fn1, fn1sz, "%s/%s", h, pubkey);
+            snprintf(fn2, fn2sz, "%s/%s", h, privkey);
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic pop
+#endif
+
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   fn1, fn2,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                free(fn2);
+                free(fn1);
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
+            free(fn2);
+            free(fn1);
         }
         else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
+            fprintf(stderr, "No supported authentication methods found.\n");
+            goto shutdown;
         }
     }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
 
-    /* Request a shell */
+    /* Request a session channel on which to run a shell */
     channel = libssh2_channel_open_session(session);
     if(!channel) {
         fprintf(stderr, "Unable to open a session\n");
@@ -217,33 +268,67 @@ int main(int argc, char *argv[])
     libssh2_channel_setenv(channel, "FOO", "bar");
 
     /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
+     * See /etc/termcap for more options. This is useful when opening
+     * an interactive shell.
      */
+    #if 0
     if(libssh2_channel_request_pty(channel, "vanilla")) {
         fprintf(stderr, "Failed requesting pty\n");
-        goto skip_shell;
     }
+    #endif
 
-    /* Open a SHELL on that pty */
-    if(libssh2_channel_shell(channel)) {
-        fprintf(stderr, "Unable to request shell on allocated pty\n");
-        goto shutdown;
+    if(argc > 5) {
+        if(libssh2_channel_exec(channel, argv[5])) {
+            fprintf(stderr, "Unable to request command on channel\n");
+            goto shutdown;
+        }
+        /* Instead of just running a single command with libssh2_channel_exec,
+         * a shell can be opened on the channel instead, for interactive use.
+         * You usually want a pty allocated first in that case (see above). */
+        #if 0
+        if(libssh2_channel_shell(channel)) {
+            fprintf(stderr, "Unable to request shell on allocated pty\n");
+            goto shutdown;
+        }
+        #endif
+
+        /* At this point the shell can be interacted with using
+         * libssh2_channel_read()
+         * libssh2_channel_read_stderr()
+         * libssh2_channel_write()
+         * libssh2_channel_write_stderr()
+         *
+         * Blocking mode may be (en|dis)abled with:
+         *    libssh2_channel_set_blocking()
+         * If the server send EOF, libssh2_channel_eof() will return non-0
+         * To send EOF to the server use: libssh2_channel_send_eof()
+         * A channel can be closed with: libssh2_channel_close()
+         * A channel can be freed with: libssh2_channel_free()
+         */
+
+        /* Read and display all the data received on stdout (ignoring stderr)
+         * until the channel closes. This will eventually block if the command
+         * produces too much data on stderr; the loop must be rewritten to use
+         * non-blocking mode and include interspersed calls to
+         * libssh2_channel_read_stderr() to avoid this. See ssh2_echo.c for
+         * an idea of how such a loop might look.
+         */
+        while(!libssh2_channel_eof(channel)) {
+            char buf[1024];
+            ssize_t err = libssh2_channel_read(channel, buf, sizeof(buf));
+            if(err < 0)
+                fprintf(stderr, "Unable to read response: %ld\n", (long)err);
+            else {
+                fwrite(buf, 1, (size_t)err, stdout);
+            }
+        }
     }
 
-    /* At this point the shell can be interacted with using
-     * libssh2_channel_read()
-     * libssh2_channel_read_stderr()
-     * libssh2_channel_write()
-     * libssh2_channel_write_stderr()
-     *
-     * Blocking mode may be (en|dis)abled with: libssh2_channel_set_blocking()
-     * If the server send EOF, libssh2_channel_eof() will return non-0
-     * To send EOF to the server use: libssh2_channel_send_eof()
-     * A channel can be closed with: libssh2_channel_close()
-     * A channel can be freed with: libssh2_channel_free()
-     */
+    rc = libssh2_channel_get_exit_status(channel);
+
+    if(libssh2_channel_close(channel))
+        fprintf(stderr, "Unable to close channel\n");
 
-  skip_shell:
     if(channel) {
         libssh2_channel_free(channel);
         channel = NULL;
@@ -255,20 +340,25 @@ int main(int argc, char *argv[])
      * libssh2_channel_direct_tcpip()
      */
 
-  shutdown:
+shutdown:
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done!\n");
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
+
+    fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
-    return 0;
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
+    return rc;
 }
diff --git a/libssh2/example/ssh2_agent.c b/libssh2/example/ssh2_agent.c
index 1cc50844..d8b22440 100644
--- a/libssh2/example/ssh2_agent.c
+++ b/libssh2/example/ssh2_agent.c
@@ -1,62 +1,55 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to do SSH2 connect using ssh-agent.
  *
  * The sample code has default values for host name, user name:
  *
- * "ssh2_agent host user"
+ * $ ./ssh2_agent host user
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
-#include <libssh2_sftp.h>
 
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-# ifdef HAVE_ARPA_INET_H
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
 #endif
 
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
+#include <string.h>
 
-const char *username = "username";
+static const char *username = "username";
 
 int main(int argc, char *argv[])
 {
-    unsigned long hostaddr;
-    int sock = -1, i, rc;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i;
     struct sockaddr_in sin;
     const char *fingerprint;
     char *userauthlist;
+    int rc;
     LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
     LIBSSH2_AGENT *agent = NULL;
     struct libssh2_agent_publickey *identity, *prev_identity = NULL;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
@@ -67,13 +60,12 @@ int main(int argc, char *argv[])
     else {
         hostaddr = htonl(0x7F000001);
     }
-
     if(argc > 2) {
         username = argv[2];
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
@@ -82,8 +74,8 @@ int main(int argc, char *argv[])
      * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock == -1) {
-        fprintf(stderr, "failed to create socket!\n");
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
         rc = 1;
         goto shutdown;
     }
@@ -91,25 +83,28 @@ int main(int argc, char *argv[])
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
         goto shutdown;
     }
 
-    /* Create a session instance and start it up. This will trade welcome
-     * banners, exchange keys, and setup crypto, compression, and MAC layers
-     */
+    /* Create a session instance */
     session = libssh2_session_init();
-    if(libssh2_session_handshake(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return 1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
+
+    rc = libssh2_session_handshake(session, sock);
+    if(rc) {
+        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
+        goto shutdown;
     }
 
-    /* At this point we havn't authenticated. The first thing to do is check
-     * the hostkey's fingerprint against our known hosts Your app may have it
-     * hard coded, may go to a file, may present it to the user, that's your
-     * call
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
      */
     fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
     fprintf(stderr, "Fingerprint: ");
@@ -119,56 +114,59 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "publickey") == NULL) {
-        fprintf(stderr, "\"publickey\" authentication is not supported\n");
-        goto shutdown;
-    }
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(!strstr(userauthlist, "publickey")) {
+            fprintf(stderr, "'publickey' authentication is not supported\n");
+            goto shutdown;
+        }
 
-    /* Connect to the ssh-agent */
-    agent = libssh2_agent_init(session);
-    if(!agent) {
-        fprintf(stderr, "Failure initializing ssh-agent support\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_connect(agent)) {
-        fprintf(stderr, "Failure connecting to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_list_identities(agent)) {
-        fprintf(stderr, "Failure requesting identities to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    while(1) {
-        rc = libssh2_agent_get_identity(agent, &identity, prev_identity);
-        if(rc == 1)
-            break;
-        if(rc < 0) {
-            fprintf(stderr,
-                    "Failure obtaining identity from ssh-agent support\n");
+        /* Connect to the ssh-agent */
+        agent = libssh2_agent_init(session);
+        if(!agent) {
+            fprintf(stderr, "Failure initializing ssh-agent support\n");
+            rc = 1;
+            goto shutdown;
+        }
+        if(libssh2_agent_connect(agent)) {
+            fprintf(stderr, "Failure connecting to ssh-agent\n");
             rc = 1;
             goto shutdown;
         }
-        if(libssh2_agent_userauth(agent, username, identity)) {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s failed!\n",
-                   username, identity->comment);
+        if(libssh2_agent_list_identities(agent)) {
+            fprintf(stderr, "Failure requesting identities to ssh-agent\n");
+            rc = 1;
+            goto shutdown;
         }
-        else {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s succeeded!\n",
-                   username, identity->comment);
-            break;
+        for(;;) {
+            rc = libssh2_agent_get_identity(agent, &identity, prev_identity);
+            if(rc == 1)
+                break;
+            if(rc < 0) {
+                fprintf(stderr,
+                        "Failure obtaining identity from ssh-agent support\n");
+                rc = 1;
+                goto shutdown;
+            }
+            if(libssh2_agent_userauth(agent, username, identity)) {
+                fprintf(stderr, "Authentication with username %s and "
+                        "public key %s failed.\n",
+                        username, identity->comment);
+            }
+            else {
+                fprintf(stderr, "Authentication with username %s and "
+                        "public key %s succeeded.\n",
+                        username, identity->comment);
+                break;
+            }
+            prev_identity = identity;
+        }
+        if(rc) {
+            fprintf(stderr, "Could not continue authentication\n");
+            goto shutdown;
         }
-        prev_identity = identity;
-    }
-    if(rc) {
-        fprintf(stderr, "Couldn't continue authentication\n");
-        goto shutdown;
     }
 
     /* We're authenticated now. */
@@ -186,7 +184,8 @@ int main(int argc, char *argv[])
     libssh2_channel_setenv(channel, "FOO", "bar");
 
     /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
+     * See /etc/termcap for more options. This is useful when opening
+     * an interactive shell.
      */
     if(libssh2_channel_request_pty(channel, "vanilla")) {
         fprintf(stderr, "Failed requesting pty\n");
@@ -212,7 +211,8 @@ int main(int argc, char *argv[])
      * A channel can be freed with: libssh2_channel_free()
      */
 
-  skip_shell:
+skip_shell:
+
     if(channel) {
         libssh2_channel_free(channel);
         channel = NULL;
@@ -224,7 +224,7 @@ int main(int argc, char *argv[])
      * libssh2_channel_direct_tcpip()
      */
 
-  shutdown:
+shutdown:
 
     if(agent) {
         libssh2_agent_disconnect(agent);
@@ -232,22 +232,22 @@ int main(int argc, char *argv[])
     }
 
     if(session) {
-        libssh2_session_disconnect(session,
-                                   "Normal Shutdown, Thank you for playing");
+        libssh2_session_disconnect(session, "Normal Shutdown");
         libssh2_session_free(session);
     }
 
-    if(sock != -1) {
-#ifdef WIN32
-        closesocket(sock);
-#else
-        close(sock);
-#endif
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
     }
 
-    fprintf(stderr, "all done!\n");
+    fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return rc;
 }
diff --git a/libssh2/example/ssh2_agent_forwarding.c b/libssh2/example/ssh2_agent_forwarding.c
index b99fc95f..1be35216 100644
--- a/libssh2/example/ssh2_agent_forwarding.c
+++ b/libssh2/example/ssh2_agent_forwarding.c
@@ -1,4 +1,5 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to use libssh2 to request agent forwarding
  * on the remote host. The command executed will run with agent forwarded
  * so you should be able to do things like clone out protected git
@@ -7,45 +8,35 @@
  * The example uses agent authentication to ensure an agent to forward
  * is running.
  *
- * Run it like this:
- *
  * $ ./ssh2_agent_forwarding 127.0.0.1 user "uptime"
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
+#include <sys/socket.h>
 #endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
+#include <arpa/inet.h>
 #endif
 
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-#include <sys/types.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
-#include <ctype.h>
+#include <stdlib.h>
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *hostname = "127.0.0.1";
+static const char *commandline = "uptime";
+static const char *username;
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -59,7 +50,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -70,32 +68,35 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "uptime";
-    const char *username    = NULL;
-    unsigned long hostaddr;
-    int sock;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
     struct sockaddr_in sin;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
     LIBSSH2_AGENT *agent = NULL;
     struct libssh2_agent_publickey *identity, *prev_identity = NULL;
-    int rc;
     int exitcode;
     char *exitsignal = (char *)"none";
-    int bytecount = 0;
+    ssize_t bytecount = 0;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    WSAStartup(MAKEWORD(2, 0), &wsadata);
+
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
+        return 1;
+    }
 #endif
+
     if(argc < 2) {
         fprintf(stderr, "At least IP and username arguments are required.\n");
         return 1;
@@ -109,36 +110,40 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     hostaddr = inet_addr(hostname);
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     if(libssh2_session_handshake(session, sock) != 0) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
     /* Connect to the ssh-agent */
@@ -158,7 +163,7 @@ int main(int argc, char *argv[])
         rc = 1;
         goto shutdown;
     }
-    while(1) {
+    for(;;) {
         rc = libssh2_agent_get_identity(agent, &identity, prev_identity);
         if(rc == 1)
             break;
@@ -169,20 +174,20 @@ int main(int argc, char *argv[])
             goto shutdown;
         }
         if(libssh2_agent_userauth(agent, username, identity)) {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s failed!\n",
-                   username, identity->comment);
+            fprintf(stderr, "Authentication with username %s and "
+                    "public key %s failed.\n",
+                    username, identity->comment);
         }
         else {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s succeeded!\n",
-                   username, identity->comment);
+            fprintf(stderr, "Authentication with username %s and "
+                    "public key %s succeeded.\n",
+                    username, identity->comment);
             break;
         }
         prev_identity = identity;
     }
     if(rc) {
-        fprintf(stderr, "Couldn't continue authentication\n");
+        fprintf(stderr, "Could not continue authentication\n");
         goto shutdown;
     }
 
@@ -193,13 +198,16 @@ int main(int argc, char *argv[])
     /* Set session to non-blocking */
     libssh2_session_set_blocking(session, 0);
 
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
+    /* Exec non-blocking on the remote host */
+    do {
+        channel = libssh2_channel_open_session(session);
+        if(channel ||
+           libssh2_session_last_error(session, NULL, NULL, 0) !=
+           LIBSSH2_ERROR_EAGAIN)
+            break;
         waitsocket(sock, session);
-    }
-    if(channel == NULL) {
+    } while(1);
+    if(!channel) {
         fprintf(stderr, "Error\n");
         exit(1);
     }
@@ -207,47 +215,47 @@ int main(int argc, char *argv[])
           LIBSSH2_ERROR_EAGAIN) {
         waitsocket(sock, session);
     }
-    if(rc != 0) {
-        fprintf(stderr, "Error, couldn't request auth agent, error code %d.\n",
-                rc);
+    if(rc) {
+        fprintf(stderr, "Error, could not request auth agent, "
+                "error code %d.\n", rc);
         exit(1);
     }
     else {
-        fprintf(stdout, "\tAgent forwarding request succeeded!\n");
+        fprintf(stdout, "Agent forwarding request succeeded.\n");
     }
     while((rc = libssh2_channel_exec(channel, commandline)) ==
           LIBSSH2_ERROR_EAGAIN) {
         waitsocket(sock, session);
     }
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Error\n");
         exit(1);
     }
     for(;;) {
+        ssize_t nread;
         /* loop until we block */
-        int rc;
         do {
             char buffer[0x4000];
-            rc = libssh2_channel_read(channel, buffer, sizeof(buffer) );
-            if(rc > 0) {
-                int i;
-                bytecount += rc;
+            nread = libssh2_channel_read(channel, buffer, sizeof(buffer) );
+            if(nread > 0) {
+                ssize_t i;
+                bytecount += nread;
                 fprintf(stderr, "We read:\n");
-                for(i = 0; i < rc; ++i)
+                for(i = 0; i < nread; ++i)
                     fputc(buffer[i], stderr);
                 fprintf(stderr, "\n");
             }
             else {
-                if(rc != LIBSSH2_ERROR_EAGAIN)
+                if(nread != LIBSSH2_ERROR_EAGAIN)
                     /* no need to output this for the EAGAIN case */
-                    fprintf(stderr, "libssh2_channel_read returned %d\n", rc);
+                    fprintf(stderr, "libssh2_channel_read returned %ld\n",
+                            (long)nread);
             }
-        }
-        while(rc > 0);
+        } while(nread > 0);
 
         /* this is due to blocking that would occur otherwise so we loop on
            this condition */
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
+        if(nread == LIBSSH2_ERROR_EAGAIN) {
             waitsocket(sock, session);
         }
         else
@@ -264,10 +272,11 @@ int main(int argc, char *argv[])
     }
 
     if(exitsignal) {
-        printf("\nGot signal: %s\n", exitsignal);
+        fprintf(stderr, "\nGot signal: %s\n", exitsignal);
     }
     else {
-        printf("\nEXIT: %d bytecount: %d\n", exitcode, bytecount);
+        fprintf(stderr, "\nEXIT: %d bytecount: %ld\n",
+                exitcode, (long)bytecount);
     }
 
     libssh2_channel_free(channel);
@@ -275,18 +284,23 @@ int main(int argc, char *argv[])
 
 shutdown:
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/ssh2_echo.c b/libssh2/example/ssh2_echo.c
index eae41656..9b45c21a 100644
--- a/libssh2/example/ssh2_echo.c
+++ b/libssh2/example/ssh2_echo.c
@@ -1,47 +1,39 @@
-/*
- * Run it like this:
- *
- * $ ./ssh2_echo 127.0.0.1 user password
+/* Copyright (C) The libssh2 project and its contributors.
  *
  * The code sends a 'cat' command, and then writes a lot of data to it only to
  * check that reading the returned data sums up to the same amount.
  *
+ * $ ./ssh2_echo 127.0.0.1 user password
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#include <sys/types.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
-#include <fcntl.h>
-#include <errno.h>
+
 #include <stdio.h>
-#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *hostname = "127.0.0.1";
+static const char *commandline = "cat";
+static const char *username = "user";
+static const char *password = "password";
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -55,7 +47,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -66,7 +65,7 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
@@ -75,38 +74,32 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
 int main(int argc, char *argv[])
 {
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "cat";
-    const char *username    = "user";
-    const char *password    = "password";
-    unsigned long hostaddr;
-    int sock;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
     int rc;
+    LIBSSH2_SESSION *session = NULL;
+    LIBSSH2_CHANNEL *channel;
     int exitcode = 0;
     char *exitsignal = (char *)"none";
     size_t len;
     LIBSSH2_KNOWNHOSTS *nh;
     int type;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
 
-    if(argc > 1)
-        /* must be ip address only */
-        hostname = argv[1];
-
+    if(argc > 1) {
+        hostname = argv[1];  /* must be ip address only */
+    }
     if(argc > 2) {
         username = argv[2];
     }
@@ -115,32 +108,36 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     hostaddr = inet_addr(hostname);
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* tell libssh2 we want it all done non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -149,10 +146,10 @@ int main(int argc, char *argv[])
      * and setup crypto, compression, and MAC layers
      */
     while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
     nh = libssh2_knownhost_init(session);
@@ -179,8 +176,8 @@ int main(int argc, char *argv[])
                                              &host);
 
         fprintf(stderr, "Host check: %d, key: %s\n", check,
-                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
-                host->key:"<none>");
+                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) ?
+                host->key : "<none>");
 
         /*****
          * At this point, we could verify that 'check' tells us the key is
@@ -205,33 +202,35 @@ int main(int argc, char *argv[])
 
     libssh2_trace(session, LIBSSH2_TRACE_SOCKET);
 
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
+    /* Exec non-blocking on the remote host */
+    do {
+        channel = libssh2_channel_open_session(session);
+        if(channel ||
+           libssh2_session_last_error(session, NULL, NULL, 0) !=
+           LIBSSH2_ERROR_EAGAIN)
+            break;
         waitsocket(sock, session);
-    }
-    if(channel == NULL) {
+    } while(1);
+    if(!channel) {
         fprintf(stderr, "Error\n");
         exit(1);
     }
     while((rc = libssh2_channel_exec(channel, commandline)) ==
-          LIBSSH2_ERROR_EAGAIN)
+          LIBSSH2_ERROR_EAGAIN) {
         waitsocket(sock, session);
-
-    if(rc != 0) {
+    }
+    if(rc) {
         fprintf(stderr, "exec error\n");
         exit(1);
     }
     else {
         LIBSSH2_POLLFD *fds = NULL;
         int running = 1;
-        int bufsize = BUFSIZE;
+        size_t bufsize = BUFSIZE;
         char buffer[BUFSIZE];
-        int totsize = 1500000;
-        int totwritten = 0;
-        int totread = 0;
-        int partials = 0;
+        size_t totsize = 1500000;
+        size_t totwritten = 0;
+        size_t totread = 0;
         int rereads = 0;
         int rewrites = 0;
         int i;
@@ -239,7 +238,7 @@ int main(int argc, char *argv[])
         for(i = 0; i < BUFSIZE; i++)
             buffer[i] = 'A';
 
-        fds = malloc(sizeof (LIBSSH2_POLLFD));
+        fds = malloc(sizeof(LIBSSH2_POLLFD));
         if(!fds) {
             fprintf(stderr, "malloc failed\n");
             exit(1);
@@ -250,14 +249,15 @@ int main(int argc, char *argv[])
         fds[0].events = LIBSSH2_POLLFD_POLLIN | LIBSSH2_POLLFD_POLLOUT;
 
         do {
-            int rc = (libssh2_poll(fds, 1, 10));
             int act = 0;
+            rc = libssh2_poll(fds, 1, 10);
 
             if(rc < 1)
                 continue;
 
             if(fds[0].revents & LIBSSH2_POLLFD_POLLIN) {
-                int n = libssh2_channel_read(channel, buffer, sizeof(buffer));
+                ssize_t n = libssh2_channel_read(channel,
+                                                 buffer, sizeof(buffer));
                 act++;
 
                 if(n == LIBSSH2_ERROR_EAGAIN) {
@@ -269,9 +269,9 @@ int main(int argc, char *argv[])
                     exit(1);
                 }
                 else {
-                    totread += n;
-                    fprintf(stderr, "read %d bytes (%d in total)\n",
-                            n, totread);
+                    totread += (size_t)n;
+                    fprintf(stderr, "read %ld bytes (%lu in total)\n",
+                            (long)n, (unsigned long)totread);
                 }
             }
 
@@ -280,9 +280,10 @@ int main(int argc, char *argv[])
 
                 if(totwritten < totsize) {
                     /* we have not written all data yet */
-                    int left = totsize - totwritten;
-                    int size = (left < bufsize) ? left : bufsize;
-                    int n = libssh2_channel_write_ex(channel, 0, buffer, size);
+                    size_t left = totsize - totwritten;
+                    size_t size = (left < bufsize) ? left : bufsize;
+                    ssize_t n = libssh2_channel_write_ex(channel, 0,
+                                                         buffer, size);
 
                     if(n == LIBSSH2_ERROR_EAGAIN) {
                         rewrites++;
@@ -293,11 +294,10 @@ int main(int argc, char *argv[])
                         exit(1);
                     }
                     else {
-                        totwritten += n;
-                        fprintf(stderr, "wrote %d bytes (%d in total)",
-                                n, totwritten);
-                        if(left >= bufsize && n != bufsize) {
-                            partials++;
+                        totwritten += (size_t)n;
+                        fprintf(stderr, "wrote %ld bytes (%lu in total)",
+                                (long)n, (unsigned long)totwritten);
+                        if(left >= bufsize && (size_t)n != bufsize) {
                             fprintf(stderr, " PARTIAL");
                         }
                         fprintf(stderr, "\n");
@@ -317,7 +317,8 @@ int main(int argc, char *argv[])
                     else {
                         fprintf(stderr, "sent eof\n");
                         /* we're done writing, stop listening for OUT events */
-                        fds[0].events &= ~LIBSSH2_POLLFD_POLLOUT;
+                        fds[0].events &=
+                            ~(unsigned long)LIBSSH2_POLLFD_POLLOUT;
                     }
                 }
             }
@@ -344,28 +345,36 @@ int main(int argc, char *argv[])
         libssh2_channel_free(channel);
         channel = NULL;
 
-        fprintf(stderr, "\nrereads: %d rewrites: %d totwritten %d\n",
-                rereads, rewrites, totwritten);
+        fprintf(stderr, "\nrereads: %d rewrites: %d totwritten %lu\n",
+                rereads, rewrites, (unsigned long)totwritten);
 
         if(totwritten != totread) {
-            fprintf(stderr, "\n*** FAIL bytes written: %d bytes "
-                    "read: %d ***\n", totwritten, totread);
+            fprintf(stderr, "\n*** FAIL bytes written: "
+                    "%lu bytes read: %lu ***\n",
+                    (unsigned long)totwritten, (unsigned long)totread);
             exit(1);
         }
     }
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+shutdown:
+
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return exitcode;
 }
diff --git a/libssh2/example/ssh2_exec.c b/libssh2/example/ssh2_exec.c
index d33c6d9a..ee8d2fb9 100644
--- a/libssh2/example/ssh2_exec.c
+++ b/libssh2/example/ssh2_exec.c
@@ -1,49 +1,43 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
+ *
  * Sample showing how to use libssh2 to execute a command remotely.
  *
  * The sample code has fixed values for host name, user name, password
  * and command to run.
  *
- * Run it like this:
- *
  * $ ./ssh2_exec 127.0.0.1 user password "uptime"
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_config.h"
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
+#include <sys/socket.h>
 #endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
 #endif
-#include <sys/types.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
-#include <fcntl.h>
-#include <errno.h>
+
 #include <stdio.h>
-#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
 
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+static const char *hostname = "127.0.0.1";
+static const char *commandline = "uptime";
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "user";
+static const char *password = "password";
+
+static int waitsocket(libssh2_socket_t socket_fd, LIBSSH2_SESSION *session)
 {
     struct timeval timeout;
     int rc;
@@ -57,7 +51,14 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
 
     FD_ZERO(&fd);
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(socket_fd, &fd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     /* now make sure we wait in the correct direction */
     dir = libssh2_session_block_directions(session);
@@ -68,46 +69,40 @@ static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
     if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
         writefd = &fd;
 
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+    rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &timeout);
 
     return rc;
 }
 
 int main(int argc, char *argv[])
 {
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "uptime";
-    const char *username    = "user";
-    const char *password    = "password";
-    unsigned long hostaddr;
-    int sock;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
     struct sockaddr_in sin;
     const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
     int rc;
+    LIBSSH2_SESSION *session = NULL;
+    LIBSSH2_CHANNEL *channel;
     int exitcode;
     char *exitsignal = (char *)"none";
-    int bytecount = 0;
+    ssize_t bytecount = 0;
     size_t len;
     LIBSSH2_KNOWNHOSTS *nh;
     int type;
 
-#ifdef WIN32
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
 #endif
 
-    if(argc > 1)
-        /* must be ip address only */
-        hostname = argv[1];
-
+    if(argc > 1) {
+        hostname = argv[1];  /* must be ip address only */
+    }
     if(argc > 2) {
         username = argv[2];
     }
@@ -119,32 +114,36 @@ int main(int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     hostaddr = inet_addr(hostname);
 
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
+    /* Ultra basic "connect to port 22 on localhost".  Your code is
+     * responsible for creating the socket establishing the connection
      */
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
 
     sin.sin_family = AF_INET;
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "failed to connect.\n");
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
-    if(!session)
-        return -1;
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
 
     /* tell libssh2 we want it all done non-blocking */
     libssh2_session_set_blocking(session, 0);
@@ -153,10 +152,10 @@ int main(int argc, char *argv[])
      * and setup crypto, compression, and MAC layers
      */
     while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
+          LIBSSH2_ERROR_EAGAIN);
     if(rc) {
         fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
     nh = libssh2_knownhost_init(session);
@@ -176,24 +175,15 @@ int main(int argc, char *argv[])
     fingerprint = libssh2_session_hostkey(session, &len, &type);
     if(fingerprint) {
         struct libssh2_knownhost *host;
-#if LIBSSH2_VERSION_NUM >= 0x010206
-        /* introduced in 1.2.6 */
         int check = libssh2_knownhost_checkp(nh, hostname, 22,
                                              fingerprint, len,
                                              LIBSSH2_KNOWNHOST_TYPE_PLAIN|
                                              LIBSSH2_KNOWNHOST_KEYENC_RAW,
                                              &host);
-#else
-        /* 1.2.5 or older */
-        int check = libssh2_knownhost_check(nh, hostname,
-                                            fingerprint, len,
-                                            LIBSSH2_KNOWNHOST_TYPE_PLAIN|
-                                            LIBSSH2_KNOWNHOST_KEYENC_RAW,
-                                            &host);
-#endif
+
         fprintf(stderr, "Host check: %d, key: %s\n", check,
-                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
-                host->key:"<none>");
+                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) ?
+                host->key : "<none>");
 
         /*****
          * At this point, we could verify that 'check' tells us the key is
@@ -209,7 +199,7 @@ int main(int argc, char *argv[])
     if(strlen(password) != 0) {
         /* We could authenticate via password */
         while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
             fprintf(stderr, "Authentication by password failed.\n");
             goto shutdown;
@@ -218,14 +208,11 @@ int main(int argc, char *argv[])
     else {
         /* Or by public key */
         while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                         "/home/user/"
-                                                         ".ssh/id_rsa.pub",
-                                                         "/home/user/"
-                                                         ".ssh/id_rsa",
-                                                         password)) ==
-               LIBSSH2_ERROR_EAGAIN);
+                                                        pubkey, privkey,
+                                                        password)) ==
+              LIBSSH2_ERROR_EAGAIN);
         if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
+            fprintf(stderr, "Authentication by public key failed.\n");
             goto shutdown;
         }
     }
@@ -234,49 +221,52 @@ int main(int argc, char *argv[])
     libssh2_trace(session, ~0);
 #endif
 
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
+    /* Exec non-blocking on the remote host */
+    do {
+        channel = libssh2_channel_open_session(session);
+        if(channel ||
+           libssh2_session_last_error(session, NULL, NULL, 0) !=
+           LIBSSH2_ERROR_EAGAIN)
+            break;
         waitsocket(sock, session);
-    }
-    if(channel == NULL) {
+    } while(1);
+    if(!channel) {
         fprintf(stderr, "Error\n");
         exit(1);
     }
     while((rc = libssh2_channel_exec(channel, commandline)) ==
-           LIBSSH2_ERROR_EAGAIN) {
+          LIBSSH2_ERROR_EAGAIN) {
         waitsocket(sock, session);
     }
-    if(rc != 0) {
-        fprintf(stderr, "Error\n");
+    if(rc) {
+        fprintf(stderr, "exec error\n");
         exit(1);
     }
     for(;;) {
+        ssize_t nread;
         /* loop until we block */
-        int rc;
         do {
             char buffer[0x4000];
-            rc = libssh2_channel_read(channel, buffer, sizeof(buffer) );
-            if(rc > 0) {
-                int i;
-                bytecount += rc;
+            nread = libssh2_channel_read(channel, buffer, sizeof(buffer));
+            if(nread > 0) {
+                ssize_t i;
+                bytecount += nread;
                 fprintf(stderr, "We read:\n");
-                for(i = 0; i < rc; ++i)
+                for(i = 0; i < nread; ++i)
                     fputc(buffer[i], stderr);
                 fprintf(stderr, "\n");
             }
             else {
-                if(rc != LIBSSH2_ERROR_EAGAIN)
+                if(nread != LIBSSH2_ERROR_EAGAIN)
                     /* no need to output this for the EAGAIN case */
-                    fprintf(stderr, "libssh2_channel_read returned %d\n", rc);
+                    fprintf(stderr, "libssh2_channel_read returned %ld\n",
+                            (long)nread);
             }
-        }
-        while(rc > 0);
+        } while(nread > 0);
 
         /* this is due to blocking that would occur otherwise so we loop on
            this condition */
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
+        if(nread == LIBSSH2_ERROR_EAGAIN) {
             waitsocket(sock, session);
         }
         else
@@ -295,25 +285,31 @@ int main(int argc, char *argv[])
     if(exitsignal)
         fprintf(stderr, "\nGot signal: %s\n", exitsignal);
     else
-        fprintf(stderr, "\nEXIT: %d bytecount: %d\n", exitcode, bytecount);
+        fprintf(stderr, "\nEXIT: %d bytecount: %ld\n",
+                exitcode, (long)bytecount);
 
     libssh2_channel_free(channel);
     channel = NULL;
 
 shutdown:
 
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
     fprintf(stderr, "all done\n");
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/subsystem_netconf.c b/libssh2/example/subsystem_netconf.c
index cef25fee..47e29efb 100644
--- a/libssh2/example/subsystem_netconf.c
+++ b/libssh2/example/subsystem_netconf.c
@@ -1,64 +1,53 @@
-#include "libssh2_config.h"
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
+#ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
 #include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
-#include <sys/time.h>
 #endif
 
-#include <fcntl.h>
-#include <errno.h>
 #include <stdio.h>
 #include <string.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
 
 #ifndef INADDR_NONE
 #define INADDR_NONE (in_addr_t)~0
 #endif
 
-#ifndef HAVE_SNPRINTF
-# ifdef HAVE__SNPRINTF
-# define snprintf _snprintf
-# endif
-#endif
-
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "";
 
-const char *server_ip = "127.0.0.1";
+static const char *server_ip = "127.0.0.1";
 
 enum {
     AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
+    AUTH_PASSWORD = 1,
+    AUTH_PUBLICKEY = 2
 };
 
 static int netconf_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t len)
 {
-    int i;
+    ssize_t i;
     ssize_t wr = 0;
 
     do {
         i = libssh2_channel_write(channel, buf, len);
         if(i < 0) {
-            fprintf(stderr, "libssh2_channel_write: %d\n", i);
+            fprintf(stderr, "libssh2_channel_write: %ld\n", (long)i);
             return -1;
         }
         wr += i;
@@ -67,8 +56,8 @@ static int netconf_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t len)
     return 0;
 }
 
-static int netconf_read_until(LIBSSH2_CHANNEL *channel, const char *endtag,
-                              char *buf, size_t buflen)
+static ssize_t netconf_read_until(LIBSSH2_CHANNEL *channel, const char *endtag,
+                                  char *buf, size_t buflen)
 {
     ssize_t len;
     size_t rd = 0;
@@ -81,15 +70,15 @@ static int netconf_read_until(LIBSSH2_CHANNEL *channel, const char *endtag,
         if(LIBSSH2_ERROR_EAGAIN == len)
             continue;
         else if(len < 0) {
-            fprintf(stderr, "libssh2_channel_read: %d\n", (int)len);
+            fprintf(stderr, "libssh2_channel_read: %ld\n", (long)len);
             return -1;
         }
-        rd += len;
+        rd += (size_t)len;
 
         /* read more data until we see a rpc-reply closing tag followed by
          * the special sequence ]]>]]> */
 
-        /* really, this MUST be replaced with proper XML parsing! */
+        /* really, this MUST be replaced with proper XML parsing. */
 
         endreply = strstr(buf, endtag);
         if(endreply)
@@ -98,41 +87,39 @@ static int netconf_read_until(LIBSSH2_CHANNEL *channel, const char *endtag,
     } while(!specialsequence && rd < buflen);
 
     if(!specialsequence) {
-        fprintf(stderr, "%s: ]]>]]> not found! read buffer too small?\n",
-                __func__);
+        fprintf(stderr, "netconf_read_until(): ]]>]]> not found."
+                        " Read buffer too small?\n");
         return -1;
     }
 
     /* discard the special sequence so that only XML is returned */
-    rd = specialsequence - buf;
+    rd = (size_t)(specialsequence - buf);
     buf[rd] = 0;
 
-    return rd;
+    return (ssize_t)rd;
 }
 
 int main(int argc, char *argv[])
 {
-    int rc, i, auth = AUTH_NONE;
+    int i, auth = AUTH_NONE;
     struct sockaddr_in sin;
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel = NULL;
     char buf[1048576]; /* avoid any buffer reallocation for simplicity */
     ssize_t len;
+    libssh2_socket_t sock;
 
-#ifdef WIN32
-    SOCKET sock = INVALID_SOCKET;
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
-#else
-    int sock = -1;
 #endif
 
     if(argc > 1)
@@ -143,43 +130,35 @@ int main(int argc, char *argv[])
         password = argv[3];
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     /* Connect to SSH server */
     sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open socket.\n");
+        goto shutdown;
     }
-#endif
 
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = inet_addr(server_ip);
     if(INADDR_NONE == sin.sin_addr.s_addr) {
-        fprintf(stderr, "inet_addr: Invalid IP address \"%s\"\n", server_ip);
-        return -1;
+        fprintf(stderr, "inet_addr: Invalid IP address '%s'\n", server_ip);
+        goto shutdown;
     }
     sin.sin_port = htons(830);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "Failed to connect to %s!\n", inet_ntoa(sin.sin_addr));
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "Failed to connect to %s.\n", inet_ntoa(sin.sin_addr));
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
     if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
     }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
@@ -188,10 +167,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -203,69 +182,77 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 4) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[4], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[4], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password"))
+            auth |= AUTH_PASSWORD;
+        if(strstr(userauthlist, "publickey"))
+            auth |= AUTH_PUBLICKEY;
+
+        /* check for options */
+        if(argc > 4) {
+            if((auth & AUTH_PASSWORD) && !strcmp(argv[4], "-p"))
+                auth = AUTH_PASSWORD;
+            if((auth & AUTH_PUBLICKEY) && !strcmp(argv[4], "-k"))
+                auth = AUTH_PUBLICKEY;
+        }
 
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
+        if(auth & AUTH_PASSWORD) {
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
         }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                                keyfile2, password)) {
-            fprintf(stderr, "Authentication by public key failed!\n");
+        else if(auth & AUTH_PUBLICKEY) {
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
+        }
+        else {
+            fprintf(stderr, "No supported authentication methods found.\n");
             goto shutdown;
         }
-        fprintf(stderr, "Authentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
     }
 
     /* open a channel */
     channel = libssh2_channel_open_session(session);
     if(!channel) {
-        fprintf(stderr, "Could not open the channel!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
+        fprintf(stderr, "Could not open the channel.\n"
+                        "(Note that this can be a problem at the server."
+                        " Please review the server logs.)\n");
         goto shutdown;
     }
 
     /* execute the subsystem on our channel */
     if(libssh2_channel_subsystem(channel, "netconf")) {
-        fprintf(stderr, "Could not execute the \"netconf\" subsystem!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
+        fprintf(stderr, "Could not execute the 'netconf' subsystem.\n"
+                        "(Note that this can be a problem at the server."
+                        " Please review the server logs.)\n");
         goto shutdown;
     }
 
     /* NETCONF: https://tools.ietf.org/html/draft-ietf-netconf-ssh-06 */
 
     fprintf(stderr, "Sending NETCONF client <hello>\n");
-    snprintf(buf, sizeof(buf),
-      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-      "<hello>"
-      "<capabilities>"
-      "<capability>urn:ietf:params:xml:ns:netconf:base:1.0</capability>"
-      "</capabilities>"
-      "</hello>\n"
-      "]]>]]>\n%n", (int *)&len);
-    if(-1 == netconf_write(channel, buf, len))
+    len = snprintf(buf, sizeof(buf),
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        "<hello>"
+        "<capabilities>"
+        "<capability>urn:ietf:params:xml:ns:netconf:base:1.0</capability>"
+        "</capabilities>"
+        "</hello>\n"
+        "]]>]]>\n");
+    if(len < 0)
+        goto shutdown;
+    if(-1 == netconf_write(channel, buf, (size_t)len))
         goto shutdown;
 
     fprintf(stderr, "Reading NETCONF server <hello>\n");
@@ -273,17 +260,19 @@ int main(int argc, char *argv[])
     if(-1 == len)
         goto shutdown;
 
-    fprintf(stderr, "Got %d bytes:\n----------------------\n%s",
-            (int)len, buf);
+    fprintf(stderr, "Got %ld bytes:\n----------------------\n%s",
+            (long)len, buf);
 
     fprintf(stderr, "Sending NETCONF <rpc>\n");
-    snprintf(buf, sizeof(buf),
-      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-      "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">"
-      "<get-interface-information><terse/></get-interface-information>"
-      "</rpc>\n"
-      "]]>]]>\n%n", (int *)&len);
-    if(-1 == netconf_write(channel, buf, len))
+    len = snprintf(buf, sizeof(buf),
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+        "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">"
+        "<get-interface-information><terse/></get-interface-information>"
+        "</rpc>\n"
+        "]]>]]>\n");
+    if(len < 0)
+        goto shutdown;
+    if(-1 == netconf_write(channel, buf, (size_t)len))
         goto shutdown;
 
     fprintf(stderr, "Reading NETCONF <rpc-reply>\n");
@@ -291,22 +280,29 @@ int main(int argc, char *argv[])
     if(-1 == len)
         goto shutdown;
 
-    fprintf(stderr, "Got %d bytes:\n----------------------\n%s",
-            (int)len, buf);
+    fprintf(stderr, "Got %ld bytes:\n----------------------\n%s",
+            (long)len, buf);
 
 shutdown:
+
     if(channel)
         libssh2_channel_free(channel);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/tcpip-forward.c b/libssh2/example/tcpip-forward.c
index 51ca17ab..410988c5 100644
--- a/libssh2/example/tcpip-forward.c
+++ b/libssh2/example/tcpip-forward.c
@@ -1,82 +1,85 @@
-#include "libssh2_config.h"
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "libssh2_setup.h"
 #include <libssh2.h>
 
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
+#ifdef _WIN32
+#include <ws2tcpip.h>  /* for socklen_t */
+#define recv(s, b, l, f)  recv((s), (b), (int)(l), (f))
+#define send(s, b, l, f)  send((s), (b), (int)(l), (f))
 #endif
 
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
 #endif
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #ifndef INADDR_NONE
-#define INADDR_NONE (in_addr_t)-1
+#define INADDR_NONE (in_addr_t)~0
 #endif
 
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
+static const char *pubkey = "/home/username/.ssh/id_rsa.pub";
+static const char *privkey = "/home/username/.ssh/id_rsa";
+static const char *username = "username";
+static const char *password = "";
+
+static const char *server_ip = "127.0.0.1";
 
-const char *server_ip = "127.0.0.1";
+/* resolved by the server */
+static const char *remote_listenhost = "localhost";
 
-const char *remote_listenhost = "localhost"; /* resolved by the server */
-int remote_wantport = 2222;
-int remote_listenport;
+static int remote_wantport = 2222;
+static int remote_listenport;
 
-const char *local_destip = "127.0.0.1";
-int local_destport = 22;
+static const char *local_destip = "127.0.0.1";
+static int local_destport = 22;
 
 enum {
     AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
+    AUTH_PASSWORD = 1,
+    AUTH_PUBLICKEY = 2
 };
 
 int main(int argc, char *argv[])
 {
-    int rc, i, auth = AUTH_NONE;
+    int i, auth = AUTH_NONE;
     struct sockaddr_in sin;
     socklen_t sinlen = sizeof(sin);
     const char *fingerprint;
     char *userauthlist;
-    LIBSSH2_SESSION *session;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_LISTENER *listener = NULL;
     LIBSSH2_CHANNEL *channel = NULL;
-    fd_set fds;
     struct timeval tv;
     ssize_t len, wr;
     char buf[16384];
+    libssh2_socket_t sock;
+    libssh2_socket_t forwardsock = LIBSSH2_INVALID_SOCKET;
 
-#ifdef WIN32
-    SOCKET sock = INVALID_SOCKET, forwardsock = INVALID_SOCKET;
+#ifdef _WIN32
     WSADATA wsadata;
-    int err;
 
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
         return 1;
     }
-#else
-    int sock = -1, forwardsock = -1;
 #endif
 
     if(argc > 1)
@@ -95,43 +98,35 @@ int main(int argc, char *argv[])
         local_destport = atoi(argv[7]);
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     /* Connect to SSH server */
     sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open socket.\n");
+        goto shutdown;
     }
-#endif
 
     sin.sin_family = AF_INET;
     sin.sin_addr.s_addr = inet_addr(server_ip);
     if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        return -1;
+        fprintf(stderr, "inet_addr: Invalid IP address '%s'\n", server_ip);
+        goto shutdown;
     }
     sin.sin_port = htons(22);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "Failed to connect to %s.\n", inet_ntoa(sin.sin_addr));
+        goto shutdown;
     }
 
     /* Create a session instance */
     session = libssh2_session_init();
     if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
     }
 
     /* ... start it up. This will trade welcome banners, exchange keys,
@@ -140,10 +135,10 @@ int main(int argc, char *argv[])
     rc = libssh2_session_handshake(session, sock);
     if(rc) {
         fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
+        goto shutdown;
     }
 
-    /* At this point we havn't yet authenticated.  The first thing to do
+    /* At this point we have not yet authenticated.  The first thing to do
      * is check the hostkey's fingerprint against our known hosts Your app
      * may have it hard coded, may go to a file, may present it to the
      * user, that's your call
@@ -155,174 +150,202 @@ int main(int argc, char *argv[])
     fprintf(stderr, "\n");
 
     /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 8) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[8], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[8], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password"))
+            auth |= AUTH_PASSWORD;
+        if(strstr(userauthlist, "publickey"))
+            auth |= AUTH_PUBLICKEY;
+
+        /* check for options */
+        if(argc > 8) {
+            if((auth & AUTH_PASSWORD) && !strcmp(argv[8], "-p"))
+                auth = AUTH_PASSWORD;
+            if((auth & AUTH_PUBLICKEY) && !strcmp(argv[8], "-k"))
+                auth = AUTH_PUBLICKEY;
+        }
 
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
+        if(auth & AUTH_PASSWORD) {
+            if(libssh2_userauth_password(session, username, password)) {
+                fprintf(stderr, "Authentication by password failed.\n");
+                goto shutdown;
+            }
         }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
+        else if(auth & AUTH_PUBLICKEY) {
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
+        }
+        else {
+            fprintf(stderr, "No supported authentication methods found.\n");
             goto shutdown;
         }
-        fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
     }
 
     fprintf(stderr, "Asking server to listen on remote %s:%d\n",
-        remote_listenhost, remote_wantport);
+            remote_listenhost, remote_wantport);
 
     listener = libssh2_channel_forward_listen_ex(session, remote_listenhost,
-        remote_wantport, &remote_listenport, 1);
+                                                 remote_wantport,
+                                                 &remote_listenport, 1);
     if(!listener) {
-        fprintf(stderr, "Could not start the tcpip-forward listener!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
+        fprintf(stderr, "Could not start the tcpip-forward listener.\n"
+                        "(Note that this can be a problem at the server."
+                        " Please review the server logs.)\n");
         goto shutdown;
     }
 
     fprintf(stderr, "Server is listening on %s:%d\n", remote_listenhost,
-        remote_listenport);
+            remote_listenport);
 
     fprintf(stderr, "Waiting for remote connection\n");
     channel = libssh2_channel_forward_accept(listener);
     if(!channel) {
-        fprintf(stderr, "Could not accept connection!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
+        fprintf(stderr, "Could not accept connection.\n"
+                        "(Note that this can be a problem at the server."
+                        " Please review the server logs.)\n");
         goto shutdown;
     }
 
     fprintf(stderr,
-        "Accepted remote connection. Connecting to local server %s:%d\n",
-        local_destip, local_destport);
+            "Accepted remote connection. Connecting to local server %s:%d\n",
+            local_destip, local_destport);
     forwardsock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(forwardsock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open forward socket!\n");
-        goto shutdown;
-    }
-#else
-    if(forwardsock == -1) {
-        perror("socket");
+    if(forwardsock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open forward socket.\n");
         goto shutdown;
     }
-#endif
 
     sin.sin_family = AF_INET;
-    sin.sin_port = htons(local_destport);
+    sin.sin_port = htons((unsigned short)local_destport);
     sin.sin_addr.s_addr = inet_addr(local_destip);
     if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
+        fprintf(stderr, "failed in inet_addr().\n");
         goto shutdown;
     }
     if(-1 == connect(forwardsock, (struct sockaddr *)&sin, sinlen)) {
-        perror("connect");
+        fprintf(stderr, "failed to connect().\n");
         goto shutdown;
     }
 
     fprintf(stderr, "Forwarding connection from remote %s:%d to local %s:%d\n",
-        remote_listenhost, remote_listenport, local_destip, local_destport);
+            remote_listenhost, remote_listenport,
+            local_destip, local_destport);
 
     /* Must use non-blocking IO hereafter due to the current libssh2 API */
     libssh2_session_set_blocking(session, 0);
 
-    while(1) {
+    for(;;) {
+        fd_set fds;
         FD_ZERO(&fds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         FD_SET(forwardsock, &fds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
         tv.tv_sec = 0;
         tv.tv_usec = 100000;
-        rc = select(forwardsock + 1, &fds, NULL, NULL, &tv);
+        rc = select((int)(forwardsock + 1), &fds, NULL, NULL, &tv);
         if(-1 == rc) {
-            perror("select");
+            fprintf(stderr, "failed to select().\n");
             goto shutdown;
         }
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         if(rc && FD_ISSET(forwardsock, &fds)) {
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+            ssize_t nwritten;
             len = recv(forwardsock, buf, sizeof(buf), 0);
             if(len < 0) {
-                perror("read");
+                fprintf(stderr, "failed to recv().\n");
                 goto shutdown;
             }
-            else if(0 == len) {
-                fprintf(stderr, "The local server at %s:%d disconnected!\n",
-                    local_destip, local_destport);
+            else if(len == 0) {
+                fprintf(stderr, "The local server at %s:%d disconnected.\n",
+                        local_destip, local_destport);
                 goto shutdown;
             }
             wr = 0;
             do {
-                i = libssh2_channel_write(channel, buf, len);
-                if(i < 0) {
-                    fprintf(stderr, "libssh2_channel_write: %d\n", i);
+                nwritten = libssh2_channel_write(channel, buf, (size_t)len);
+                if(nwritten < 0) {
+                    fprintf(stderr, "libssh2_channel_write: %ld\n",
+                            (long)nwritten);
                     goto shutdown;
                 }
-                wr += i;
-            } while(i > 0 && wr < len);
+                wr += nwritten;
+            } while(nwritten > 0 && wr < len);
         }
-        while(1) {
+        for(;;) {
+            ssize_t nsent;
             len = libssh2_channel_read(channel, buf, sizeof(buf));
             if(LIBSSH2_ERROR_EAGAIN == len)
                 break;
             else if(len < 0) {
-                fprintf(stderr, "libssh2_channel_read: %d", (int)len);
+                fprintf(stderr, "libssh2_channel_read: %ld",
+                        (long)len);
                 goto shutdown;
             }
             wr = 0;
             while(wr < len) {
-                i = send(forwardsock, buf + wr, len - wr, 0);
-                if(i <= 0) {
-                    perror("write");
+                nsent = send(forwardsock, buf + wr, (size_t)(len - wr), 0);
+                if(nsent <= 0) {
+                    fprintf(stderr, "failed to send().\n");
                     goto shutdown;
                 }
-                wr += i;
+                wr += nsent;
             }
             if(libssh2_channel_eof(channel)) {
-                fprintf(stderr, "The remote client at %s:%d disconnected!\n",
-                    remote_listenhost, remote_listenport);
+                fprintf(stderr, "The remote client at %s:%d disconnected.\n",
+                        remote_listenhost, remote_listenport);
                 goto shutdown;
             }
         }
     }
 
 shutdown:
-#ifdef WIN32
-    closesocket(forwardsock);
-#else
-    close(forwardsock);
-#endif
+
+    if(forwardsock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(forwardsock, 2);
+        LIBSSH2_SOCKET_CLOSE(forwardsock);
+    }
+
     if(channel)
         libssh2_channel_free(channel);
+
     if(listener)
         libssh2_channel_forward_cancel(listener);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
 
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2);
+        LIBSSH2_SOCKET_CLOSE(sock);
+    }
 
     libssh2_exit();
 
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
     return 0;
 }
diff --git a/libssh2/example/x11.c b/libssh2/example/x11.c
index c49b64ea..57f8ee5b 100644
--- a/libssh2/example/x11.c
+++ b/libssh2/example/x11.c
@@ -1,28 +1,42 @@
-/*
+/* Copyright (C) The libssh2 project and its contributors.
  *
  * Sample showing how to makes SSH2 with X11 Forwarding works.
  *
- * Usage :
- * "ssh2 host user password [DEBUG]"
+ * $ ./x11 host user password [DEBUG]
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include <string.h>
+#include "libssh2_setup.h"
+#include <libssh2.h>
+
+#include <stdio.h>
+
+#ifdef HAVE_SYS_UN_H
+
+#ifdef HAVE_SYS_IOCTL_H
 #include <sys/ioctl.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
 #include <netinet/in.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
-#include <sys/select.h>
-#include <arpa/inet.h>
+#endif
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
-#include <sys/types.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_SYS_UN_H
 #include <sys/un.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
+#endif
+
 #include <stdlib.h>
-#include <termios.h>
+#include <string.h>
 
-#include <libssh2.h>
+#include <termios.h>
 
 #define _PATH_UNIX_X "/tmp/.X11-unix/X%d"
 
@@ -32,12 +46,12 @@
  */
 struct chan_X11_list {
     LIBSSH2_CHANNEL  *chan;
-    int               sock;
+    libssh2_socket_t  sock;
     struct chan_X11_list *next;
 };
 
-struct chan_X11_list * gp_x11_chan = NULL;
-struct termios         _saved_tio;
+static struct chan_X11_list * gp_x11_chan = NULL;
+static struct termios         _saved_tio;
 
 /*
  * Utility function to remove a Node of the chained list
@@ -54,7 +68,7 @@ static void remove_node(struct chan_X11_list *elem)
         return;
     }
 
-    while(current_node->next != NULL) {
+    while(current_node->next) {
         if(current_node->next == elem) {
             current_node->next = current_node->next->next;
             current_node = current_node->next;
@@ -67,8 +81,7 @@ static void remove_node(struct chan_X11_list *elem)
 
 static void session_shutdown(LIBSSH2_SESSION *session)
 {
-    libssh2_session_disconnect(session,
-                                "Session Shutdown, Thank you for playing");
+    libssh2_session_disconnect(session, "Normal Shutdown");
     libssh2_session_free(session);
 }
 
@@ -81,10 +94,11 @@ static int _raw_mode(void)
     if(rc != -1) {
         _saved_tio = tio;
         /* do the equivalent of cfmakeraw() manually, to build on Solaris */
-        tio.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
-        tio.c_oflag &= ~OPOST;
-        tio.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
-        tio.c_cflag &= ~(CSIZE|PARENB);
+        tio.c_iflag &= ~(tcflag_t)(IGNBRK|BRKINT|PARMRK|ISTRIP|
+                                   INLCR|IGNCR|ICRNL|IXON);
+        tio.c_oflag &= ~(tcflag_t)OPOST;
+        tio.c_lflag &= ~(tcflag_t)(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
+        tio.c_cflag &= ~(tcflag_t)(CSIZE|PARENB);
         tio.c_cflag |= CS8;
         rc = tcsetattr(fileno(stdin), TCSADRAIN, &tio);
     }
@@ -106,12 +120,12 @@ static int _normal_mode(void)
 static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
                          char *shost, int sport, void **abstract)
 {
-    const char *display = NULL;
-    char *ptr          = NULL;
-    char *temp_buff    = NULL;
-    int   display_port = 0;
-    int   sock         = 0;
-    int   rc           = 0;
+    const char *display;
+    char *ptr;
+    char *temp_buff;
+    int display_port;
+    int rc;
+    libssh2_socket_t sock = LIBSSH2_INVALID_SOCKET;
     struct sockaddr_un addr;
     struct chan_X11_list *new;
     struct chan_X11_list *chan_iter;
@@ -124,14 +138,14 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
      * Inspired by x11_connect_display in openssh
      */
     display = getenv("DISPLAY");
-    if(display != NULL) {
+    if(display) {
         if(strncmp(display, "unix:", 5) == 0 ||
             display[0] == ':') {
             /* Connect to the local unix domain */
             ptr = strrchr(display, ':');
-            temp_buff = (char *) calloc(strlen(ptr + 1), sizeof(char));
+            temp_buff = (char *)calloc(strlen(ptr + 1) + 1, sizeof(char));
             if(!temp_buff) {
-                perror("calloc");
+                fprintf(stderr, "failed to calloc().\n");
                 return;
             }
             memcpy(temp_buff, ptr + 1, strlen(ptr + 1));
@@ -139,7 +153,7 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
             free(temp_buff);
 
             sock = socket(AF_UNIX, SOCK_STREAM, 0);
-            if(sock < 0)
+            if(sock == LIBSSH2_INVALID_SOCKET)
                 return;
             memset(&addr, 0, sizeof(addr));
             addr.sun_family = AF_UNIX;
@@ -148,8 +162,8 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
             rc = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
 
             if(rc != -1) {
-                /* Connection Successfull */
-                if(gp_x11_chan == NULL) {
+                /* Connection Successful */
+                if(!gp_x11_chan) {
                     /* Calloc ensure that gp_X11_chan is full of 0 */
                     gp_x11_chan = (struct chan_X11_list *)
                         calloc(1, sizeof(struct chan_X11_list));
@@ -159,7 +173,7 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
                 }
                 else {
                     chan_iter = gp_x11_chan;
-                    while(chan_iter->next != NULL)
+                    while(chan_iter->next)
                         chan_iter = chan_iter->next;
                     /* Create the new Node */
                     new = (struct chan_X11_list *)
@@ -170,8 +184,10 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
                     chan_iter->next = new;
                 }
             }
-            else
-                close(sock);
+            else {
+                shutdown(sock, SHUT_RDWR);
+                LIBSSH2_SOCKET_CLOSE(sock);
+            }
         }
     }
     return;
@@ -181,27 +197,33 @@ static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
  * Send and receive Data for the X11 channel.
  * If the connection is closed, returns -1, 0 either.
  */
-static int x11_send_receive(LIBSSH2_CHANNEL *channel, int sock)
+static int x11_send_receive(LIBSSH2_CHANNEL *channel, libssh2_socket_t sock)
 {
-    char *buf          = NULL;
-    int   bufsize      = 8192;
-    int   rc           = 0;
-    int   nfds         = 1;
-    LIBSSH2_POLLFD  *fds      = NULL;
+    char *buf;
+    unsigned int bufsize = 8192;
+    int rc;
+    unsigned int nfds = 1;
+    LIBSSH2_POLLFD *fds = NULL;
     fd_set set;
     struct timeval timeval_out;
     timeval_out.tv_sec = 0;
     timeval_out.tv_usec = 0;
 
-
     FD_ZERO(&set);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
     FD_SET(sock, &set);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
     buf = calloc(bufsize, sizeof(char));
     if(!buf)
         return 0;
 
-    fds = malloc(sizeof (LIBSSH2_POLLFD));
+    fds = malloc(sizeof(LIBSSH2_POLLFD));
     if(!fds) {
         free(buf);
         return 0;
@@ -213,19 +235,23 @@ static int x11_send_receive(LIBSSH2_CHANNEL *channel, int sock)
     fds[0].revents = LIBSSH2_POLLFD_POLLIN;
 
     rc = libssh2_poll(fds, nfds, 0);
-    if(rc >0) {
-        rc = libssh2_channel_read(channel, buf, bufsize);
-        write(sock, buf, rc);
+    if(rc > 0) {
+        ssize_t nread;
+        nread = libssh2_channel_read(channel, buf, bufsize);
+        if(nread > 0)
+            write(sock, buf, (size_t)nread);
     }
 
-    rc = select(sock + 1, &set, NULL, NULL, &timeval_out);
+    rc = select((int)(sock + 1), &set, NULL, NULL, &timeval_out);
     if(rc > 0) {
-        memset((void *)buf, 0, bufsize);
+        ssize_t nread;
 
-        /* Data in sock*/
-        rc = read(sock, buf, bufsize);
-        if(rc > 0) {
-            libssh2_channel_write(channel, buf, rc);
+        memset(buf, 0, bufsize);
+
+        /* Data in sock */
+        nread = read(sock, buf, bufsize);
+        if(nread > 0) {
+            libssh2_channel_write(channel, buf, (size_t)nread);
         }
         else {
             free(buf);
@@ -244,21 +270,20 @@ static int x11_send_receive(LIBSSH2_CHANNEL *channel, int sock)
 /*
  * Main, more than inspired by ssh2.c by Bagder
  */
-int
-main (int argc, char *argv[])
+int main(int argc, char *argv[])
 {
-    unsigned long hostaddr = 0;
-    int sock = 0;
-    int rc = 0;
+    uint32_t hostaddr = 0;
+    int rc;
+    libssh2_socket_t sock = LIBSSH2_INVALID_SOCKET;
     struct sockaddr_in sin;
-    LIBSSH2_SESSION *session;
+    LIBSSH2_SESSION *session = NULL;
     LIBSSH2_CHANNEL *channel;
     char *username = NULL;
     char *password = NULL;
     size_t bufsiz = 8193;
     char *buf = NULL;
     int set_debug_on = 0;
-    int nfds = 1;
+    unsigned int nfds = 1;
     LIBSSH2_POLLFD *fds = NULL;
 
     /* Chan List struct */
@@ -274,7 +299,6 @@ main (int argc, char *argv[])
     timeval_out.tv_sec = 0;
     timeval_out.tv_usec = 10;
 
-
     if(argc > 3) {
         hostaddr = inet_addr(argv[1]);
         username = argv[2];
@@ -292,14 +316,14 @@ main (int argc, char *argv[])
     }
 
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
         return 1;
     }
 
     sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock == -1) {
-        perror("socket");
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to open socket.\n");
         return -1;
     }
 
@@ -307,16 +331,14 @@ main (int argc, char *argv[])
     sin.sin_port = htons(22);
     sin.sin_addr.s_addr = hostaddr;
 
-    rc = connect(sock, (struct sockaddr *) &sin,
-                 sizeof(struct sockaddr_in));
-    if(rc != 0) {
-        fprintf(stderr, "Failed to established connection!\n");
+    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
+        fprintf(stderr, "Failed to established connection.\n");
         return -1;
     }
     /* Open a session */
     session = libssh2_session_init();
     rc      = libssh2_session_handshake(session, sock);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed Start the SSH session\n");
         return -1;
     }
@@ -324,75 +346,83 @@ main (int argc, char *argv[])
     if(set_debug_on == 1)
         libssh2_trace(session, LIBSSH2_TRACE_CONN);
 
-    /* ignore pedantic warnings by gcc on the callback argument */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
     /* Set X11 Callback */
-    libssh2_session_callback_set(session, LIBSSH2_CALLBACK_X11,
-                                 (void *)x11_callback);
-#pragma GCC diagnostic pop
+    libssh2_session_callback_set2(session, LIBSSH2_CALLBACK_X11,
+                                  (libssh2_cb_generic *)x11_callback);
 
     /* Authenticate via password */
     rc = libssh2_userauth_password(session, username, password);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed to authenticate\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
     /* Open a channel */
-    channel  = libssh2_channel_open_session(session);
-    if(channel == NULL) {
+    channel = libssh2_channel_open_session(session);
+    if(!channel) {
         fprintf(stderr, "Failed to open a new channel\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
-
     /* Request a PTY */
     rc = libssh2_channel_request_pty(channel, "xterm");
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed to request a pty\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
     /* Request X11 */
     rc = libssh2_channel_x11_req(channel, 0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed to request X11 forwarding\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
     /* Request a shell */
     rc = libssh2_channel_shell(channel);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed to open a shell\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
     rc = _raw_mode();
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "Failed to entered in raw mode\n");
         session_shutdown(session);
-        close(sock);
+        shutdown(sock, SHUT_RDWR);
+        LIBSSH2_SOCKET_CLOSE(sock);
         return -1;
     }
 
     memset(&w_size, 0, sizeof(struct winsize));
     memset(&w_size_bck, 0, sizeof(struct winsize));
 
-    while(1) {
+    for(;;) {
 
         FD_ZERO(&set);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
         FD_SET(fileno(stdin), &set);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
         /* Search if a resize pty has to be send */
         ioctl(fileno(stdin), TIOCGWINSZ, &w_size);
@@ -406,11 +436,11 @@ main (int argc, char *argv[])
         }
 
         buf = calloc(bufsiz, sizeof(char));
-        if(buf == NULL)
+        if(!buf)
             break;
 
-        fds = malloc(sizeof (LIBSSH2_POLLFD));
-        if(fds == NULL) {
+        fds = malloc(sizeof(LIBSSH2_POLLFD));
+        if(!fds) {
             free(buf);
             break;
         }
@@ -421,45 +451,46 @@ main (int argc, char *argv[])
         fds[0].revents = LIBSSH2_POLLFD_POLLIN;
 
         rc = libssh2_poll(fds, nfds, 0);
-        if(rc >0) {
+        if(rc > 0) {
             libssh2_channel_read(channel, buf, sizeof(buf));
             fprintf(stdout, "%s", buf);
             fflush(stdout);
         }
 
         /* Looping on X clients */
-        if(gp_x11_chan != NULL) {
+        if(gp_x11_chan) {
             current_node = gp_x11_chan;
         }
         else
             current_node = NULL;
 
-        while(current_node != NULL) {
+        while(current_node) {
             struct chan_X11_list *next_node;
             rc = x11_send_receive(current_node->chan, current_node->sock);
             next_node = current_node->next;
             if(rc == -1) {
                 shutdown(current_node->sock, SHUT_RDWR);
-                close(current_node->sock);
+                LIBSSH2_SOCKET_CLOSE(current_node->sock);
                 remove_node(current_node);
             }
 
             current_node = next_node;
         }
 
-
-        rc = select(fileno(stdin) + 1, &set, NULL, NULL, &timeval_out);
+        rc = select((int)(fileno(stdin) + 1), &set, NULL, NULL, &timeval_out);
         if(rc > 0) {
-            /* Data in stdin*/
-            rc = read(fileno(stdin), buf, 1);
-            if(rc > 0)
+            ssize_t nread;
+
+            /* Data in stdin */
+            nread = read(fileno(stdin), buf, 1);
+            if(nread > 0)
                 libssh2_channel_write(channel, buf, sizeof(buf));
         }
 
         free(fds);
         free(buf);
 
-        if(libssh2_channel_eof (channel) == 1) {
+        if(libssh2_channel_eof(channel) == 1) {
             break;
         }
     }
@@ -474,3 +505,13 @@ main (int argc, char *argv[])
 
     return 0;
 }
+
+#else
+
+int main(void)
+{
+    fprintf(stderr, "Sorry, this platform is not supported.");
+    return 1;
+}
+
+#endif /* HAVE_SYS_UN_H */
diff --git a/libssh2/get_ver.awk b/libssh2/get_ver.awk
index 8253168e..2377ae85 100755
--- a/libssh2/get_ver.awk
+++ b/libssh2/get_ver.awk
@@ -1,4 +1,7 @@
 # fetch libssh2 version number from input file and write them to STDOUT
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
 BEGIN {
   while ((getline < ARGV[1]) > 0) {
     if (match ($0, /^#define LIBSSH2_COPYRIGHT "[^"]+"$/)) {
diff --git a/libssh2/git2news.pl b/libssh2/git2news.pl
new file mode 100755
index 00000000..3e368340
--- /dev/null
+++ b/libssh2/git2news.pl
@@ -0,0 +1,78 @@
+#!/usr/bin/env perl
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# git log --pretty=fuller --no-color --date=short --decorate=full
+
+my @mname = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+             'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' );
+
+sub nicedate {
+    my ($date)=$_;
+
+    if($date =~ /(\d\d\d\d)-(\d\d)-(\d\d)/) {
+        return sprintf("%d %s %4d", $3, $mname[$2-1], $1);
+    }
+    return $date;
+}
+
+print
+'   Changelog for the libssh2 project. Generated with git2news.pl
+';
+
+my $line;
+my $tag;
+while(<STDIN>) {
+    my $l = $_;
+
+    if($l =~/^commit ([[:xdigit:]]*) ?(.*)/) {
+        $co = $1;
+        my $ref = $2;
+        if ($ref =~ /refs\/tags\/(libssh2-|VERSION\.)([0-9._]*)/) {
+            $tag = $2;
+        } else {
+            $tag = '';
+        }
+    }
+    elsif($l =~ /^Author: *(.*) +</) {
+        $a = $1;
+    }
+    elsif($l =~ /^Commit: *(.*) +</) {
+        $c = $1;
+    }
+    elsif($l =~ /^CommitDate: (.*)/) {
+        $date = nicedate($1);
+    }
+    elsif($l =~ /^(    )(.*)/) {
+        my $extra;
+        if ($tag) {
+            # Version entries have a special format
+            print "\nVersion " . $tag." ($date)\n";
+            $oldc = "";
+            $tag = "";
+        }
+        if($a ne $c) {
+            $extra=sprintf("\n- [%s brought this change]\n\n  ", $a);
+        }
+        else {
+            $extra="\n- ";
+        }
+        if($co ne $oldco) {
+            if($c ne $oldc) {
+                print "\n$c ($date)$extra";
+            }
+            else {
+                print "$extra";
+            }
+            $line =0;
+        }
+
+        $oldco = $co;
+        $oldc = $c;
+        $olddate = $date;
+        if($line++) {
+            print "  ";
+        }
+        print $2."\n";
+    }
+}
diff --git a/libssh2/include/libssh2.h b/libssh2/include/libssh2.h
index 995d83ed..f47858ae 100644
--- a/libssh2/include/libssh2.h
+++ b/libssh2/include/libssh2.h
@@ -1,6 +1,6 @@
-/* Copyright (c) 2004-2009, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2015 Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson <simon@josefsson.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,27 +35,29 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_H
 #define LIBSSH2_H 1
 
-#define LIBSSH2_COPYRIGHT "2004-2019 The libssh2 project and its contributors."
+#define LIBSSH2_COPYRIGHT "The libssh2 project and its contributors."
 
 /* We use underscore instead of dash when appending DEV in dev versions just
    to make the BANNER define (used by src/session.c) be a valid SSH
    banner. Release versions have no appended strings and may of course not
    have dashes either. */
-#define LIBSSH2_VERSION "1.10.0"
+#define LIBSSH2_VERSION "1.11.1"
 
 /* The numeric version number is also available "in parts" by using these
    defines: */
 #define LIBSSH2_VERSION_MAJOR 1
-#define LIBSSH2_VERSION_MINOR 10
-#define LIBSSH2_VERSION_PATCH 0
+#define LIBSSH2_VERSION_MINOR 11
+#define LIBSSH2_VERSION_PATCH 1
 
 /* This is the numeric version of the libssh2 version number, meant for easier
-   parsing and comparions by programs. The LIBSSH2_VERSION_NUM define will
+   parsing and comparisons by programs. The LIBSSH2_VERSION_NUM define will
    always follow this syntax:
 
          0xXXYYZZ
@@ -69,7 +71,7 @@
    and it is always a greater number in a more recent release. It makes
    comparisons with greater than and less than work.
 */
-#define LIBSSH2_VERSION_NUM 0x010a00
+#define LIBSSH2_VERSION_NUM 0x010b01
 
 /*
  * This is the date and time when the full source package was created. The
@@ -80,13 +82,14 @@
  *
  * "Mon Feb 12 11:35:33 UTC 2007"
  */
-#define LIBSSH2_TIMESTAMP "Sun 29 Aug 2021 08:37:50 PM UTC"
+#define LIBSSH2_TIMESTAMP "Wed Oct 16 08:03:21 UTC 2024"
 
 #ifndef RC_INVOKED
 
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 #ifdef _WIN32
 # include <basetsd.h>
 # include <winsock2.h>
@@ -99,8 +102,8 @@ extern "C" {
 
 /* Allow alternate API prefix from CFLAGS or calling app */
 #ifndef LIBSSH2_API
-# ifdef LIBSSH2_WIN32
-#  ifdef _WINDLL
+# ifdef _WIN32
+#  if defined(LIBSSH2_EXPORTS) || defined(_WINDLL)
 #   ifdef LIBSSH2_LIBRARY
 #    define LIBSSH2_API __declspec(dllexport)
 #   else
@@ -109,25 +112,15 @@ extern "C" {
 #  else
 #   define LIBSSH2_API
 #  endif
-# else /* !LIBSSH2_WIN32 */
+# else /* !_WIN32 */
 #  define LIBSSH2_API
-# endif /* LIBSSH2_WIN32 */
+# endif /* _WIN32 */
 #endif /* LIBSSH2_API */
 
 #ifdef HAVE_SYS_UIO_H
 # include <sys/uio.h>
 #endif
 
-#if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
-# include <sys/bsdskt.h>
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-typedef unsigned int uint32_t;
-typedef int int32_t;
-typedef unsigned long long uint64_t;
-typedef long long int64_t;
-#endif
-
 #ifdef _MSC_VER
 typedef unsigned char uint8_t;
 typedef unsigned short int uint16_t;
@@ -147,13 +140,44 @@ typedef unsigned long long libssh2_uint64_t;
 typedef long long libssh2_int64_t;
 #endif
 
-#ifdef WIN32
+#ifdef _WIN32
 typedef SOCKET libssh2_socket_t;
 #define LIBSSH2_INVALID_SOCKET INVALID_SOCKET
-#else /* !WIN32 */
+#define LIBSSH2_SOCKET_CLOSE(s) closesocket(s)
+#else /* !_WIN32 */
 typedef int libssh2_socket_t;
 #define LIBSSH2_INVALID_SOCKET -1
-#endif /* WIN32 */
+#define LIBSSH2_SOCKET_CLOSE(s) close(s)
+#endif /* _WIN32 */
+
+/* Compile-time deprecation macros */
+#if !defined(LIBSSH2_DISABLE_DEPRECATION) && !defined(LIBSSH2_LIBRARY)
+#  if defined(_MSC_VER)
+#    if _MSC_VER >= 1400
+#      define LIBSSH2_DEPRECATED(version, message) \
+         __declspec(deprecated("since libssh2 " # version ". " message))
+#    elif _MSC_VER >= 1310
+#      define LIBSSH2_DEPRECATED(version, message) \
+         __declspec(deprecated)
+#   endif
+#  elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#    if (defined(__clang__) && __clang_major__ >= 3) || \
+        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#      define LIBSSH2_DEPRECATED(version, message) \
+         __attribute__((deprecated("since libssh2 " # version ". " message)))
+#    elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
+#      define LIBSSH2_DEPRECATED(version, message) \
+         __attribute__((deprecated))
+#    endif
+#  elif defined(__SUNPRO_C) && __SUNPRO_C >= 0x5130
+#    define LIBSSH2_DEPRECATED(version, message) \
+       __attribute__((deprecated))
+#  endif
+#endif
+
+#ifndef LIBSSH2_DEPRECATED
+#define LIBSSH2_DEPRECATED(version, message)
+#endif
 
 /*
  * Determine whether there is small or large file support on windows.
@@ -190,8 +214,6 @@ typedef int libssh2_socket_t;
 
 #ifdef LIBSSH2_USE_WIN32_LARGE_FILES
 #  include <io.h>
-#  include <sys/types.h>
-#  include <sys/stat.h>
 #  define LIBSSH2_STRUCT_STAT_SIZE_FORMAT    "%I64d"
 typedef struct _stati64 libssh2_struct_stat;
 typedef __int64 libssh2_struct_stat_size;
@@ -202,8 +224,6 @@ typedef __int64 libssh2_struct_stat_size;
  */
 
 #ifdef LIBSSH2_USE_WIN32_SMALL_FILES
-#  include <sys/types.h>
-#  include <sys/stat.h>
 #  ifndef _WIN32_WCE
 #    define LIBSSH2_STRUCT_STAT_SIZE_FORMAT    "%d"
 typedef struct _stat libssh2_struct_stat;
@@ -233,14 +253,6 @@ typedef off_t libssh2_struct_stat_size;
 #define LIBSSH2_SSH_DEFAULT_BANNER            LIBSSH2_SSH_BANNER
 #define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF  LIBSSH2_SSH_DEFAULT_BANNER "\r\n"
 
-/* Default generate and safe prime sizes for
-   diffie-hellman-group-exchange-sha1 */
-#define LIBSSH2_DH_GEX_MINGROUP     2048
-#define LIBSSH2_DH_GEX_OPTGROUP     4096
-#define LIBSSH2_DH_GEX_MAXGROUP     8192
-
-#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
-
 /* Defaults for pty requests */
 #define LIBSSH2_TERM_WIDTH      80
 #define LIBSSH2_TERM_HEIGHT     24
@@ -272,59 +284,102 @@ typedef off_t libssh2_struct_stat_size;
 
 typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT
 {
-    char *text;
-    unsigned int length;
+    unsigned char *text;
+    size_t length;
     unsigned char echo;
 } LIBSSH2_USERAUTH_KBDINT_PROMPT;
 
 typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
 {
     char *text;
-    unsigned int length;
+    unsigned int length;  /* FIXME: change type to size_t */
 } LIBSSH2_USERAUTH_KBDINT_RESPONSE;
 
+typedef struct _LIBSSH2_SK_SIG_INFO {
+    uint8_t flags;
+    uint32_t counter;
+    unsigned char *sig_r;
+    size_t sig_r_len;
+    unsigned char *sig_s;
+    size_t sig_s_len;
+} LIBSSH2_SK_SIG_INFO;
+
 /* 'publickey' authentication callback */
 #define LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC(name) \
-  int name(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, \
-           const unsigned char *data, size_t data_len, void **abstract)
+    int name(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, \
+             const unsigned char *data, size_t data_len, void **abstract)
 
 /* 'keyboard-interactive' authentication callback */
+/* FIXME: name_len, instruction_len -> size_t, num_prompts -> unsigned int? */
 #define LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(name_) \
- void name_(const char *name, int name_len, const char *instruction, \
-            int instruction_len, int num_prompts, \
-            const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,              \
-            LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses, void **abstract)
+    void name_(const char *name, int name_len, const char *instruction, \
+               int instruction_len, int num_prompts, \
+               const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts, \
+               LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses, void **abstract)
+
+/* SK authentication callback */
+#define LIBSSH2_USERAUTH_SK_SIGN_FUNC(name) \
+    int name(LIBSSH2_SESSION *session, LIBSSH2_SK_SIG_INFO *sig_info, \
+             const unsigned char *data, size_t data_len, \
+             int algorithm, uint8_t flags, \
+             const char *application, const unsigned char *key_handle, \
+             size_t handle_len, \
+             void **abstract)
+
+/* Flags for SK authentication */
+#define LIBSSH2_SK_PRESENCE_REQUIRED     0x01
+#define LIBSSH2_SK_VERIFICATION_REQUIRED 0x04
+
+/* FIXME: update lengths to size_t (or ssize_t): */
 
 /* Callbacks for special SSH packets */
 #define LIBSSH2_IGNORE_FUNC(name) \
- void name(LIBSSH2_SESSION *session, const char *message, int message_len, \
-           void **abstract)
+    void name(LIBSSH2_SESSION *session, const char *message, int message_len, \
+              void **abstract)
 
 #define LIBSSH2_DEBUG_FUNC(name) \
- void name(LIBSSH2_SESSION *session, int always_display, const char *message, \
-           int message_len, const char *language, int language_len, \
-           void **abstract)
+    void name(LIBSSH2_SESSION *session, int always_display, \
+              const char *message, int message_len, \
+              const char *language, int language_len, \
+              void **abstract)
 
 #define LIBSSH2_DISCONNECT_FUNC(name) \
- void name(LIBSSH2_SESSION *session, int reason, const char *message, \
-           int message_len, const char *language, int language_len, \
-           void **abstract)
+    void name(LIBSSH2_SESSION *session, int reason, \
+              const char *message, int message_len, \
+              const char *language, int language_len, \
+              void **abstract)
 
 #define LIBSSH2_PASSWD_CHANGEREQ_FUNC(name) \
- void name(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, \
-           void **abstract)
+    void name(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, \
+              void **abstract)
 
 #define LIBSSH2_MACERROR_FUNC(name) \
- int name(LIBSSH2_SESSION *session, const char *packet, int packet_len, \
-          void **abstract)
+    int name(LIBSSH2_SESSION *session, const char *packet, int packet_len, \
+             void **abstract)
 
 #define LIBSSH2_X11_OPEN_FUNC(name) \
- void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, \
-           const char *shost, int sport, void **abstract)
+    void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, \
+              const char *shost, int sport, void **abstract)
+
+#define LIBSSH2_AUTHAGENT_FUNC(name) \
+    void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, \
+              void **abstract)
+
+#define LIBSSH2_ADD_IDENTITIES_FUNC(name) \
+    void name(LIBSSH2_SESSION *session, void *buffer, \
+              const char *agent_path, void **abstract)
+
+#define LIBSSH2_AUTHAGENT_SIGN_FUNC(name) \
+    int name(LIBSSH2_SESSION* session, \
+             unsigned char *blob, unsigned int blen, \
+             const unsigned char *data, unsigned int dlen, \
+             unsigned char **signature, unsigned int *sigLen, \
+             const char *agentPath, \
+             void **abstract)
 
 #define LIBSSH2_CHANNEL_CLOSE_FUNC(name) \
-  void name(LIBSSH2_SESSION *session, void **session_abstract, \
-            LIBSSH2_CHANNEL *channel, void **channel_abstract)
+    void name(LIBSSH2_SESSION *session, void **session_abstract, \
+              LIBSSH2_CHANNEL *channel, void **channel_abstract)
 
 /* I/O callbacks */
 #define LIBSSH2_RECV_FUNC(name)                                         \
@@ -337,13 +392,16 @@ typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
                  int flags, void **abstract)
 
 /* libssh2_session_callback_set() constants */
-#define LIBSSH2_CALLBACK_IGNORE             0
-#define LIBSSH2_CALLBACK_DEBUG              1
-#define LIBSSH2_CALLBACK_DISCONNECT         2
-#define LIBSSH2_CALLBACK_MACERROR           3
-#define LIBSSH2_CALLBACK_X11                4
-#define LIBSSH2_CALLBACK_SEND               5
-#define LIBSSH2_CALLBACK_RECV               6
+#define LIBSSH2_CALLBACK_IGNORE               0
+#define LIBSSH2_CALLBACK_DEBUG                1
+#define LIBSSH2_CALLBACK_DISCONNECT           2
+#define LIBSSH2_CALLBACK_MACERROR             3
+#define LIBSSH2_CALLBACK_X11                  4
+#define LIBSSH2_CALLBACK_SEND                 5
+#define LIBSSH2_CALLBACK_RECV                 6
+#define LIBSSH2_CALLBACK_AUTHAGENT            7
+#define LIBSSH2_CALLBACK_AUTHAGENT_IDENTITIES 8
+#define LIBSSH2_CALLBACK_AUTHAGENT_SIGN       9
 
 /* libssh2_session_method_pref() constants */
 #define LIBSSH2_METHOD_KEX          0
@@ -356,10 +414,12 @@ typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
 #define LIBSSH2_METHOD_COMP_SC      7
 #define LIBSSH2_METHOD_LANG_CS      8
 #define LIBSSH2_METHOD_LANG_SC      9
+#define LIBSSH2_METHOD_SIGN_ALGO    10
 
 /* flags */
 #define LIBSSH2_FLAG_SIGPIPE        1
 #define LIBSSH2_FLAG_COMPRESS       2
+#define LIBSSH2_FLAG_QUOTE_PATHS    3
 
 typedef struct _LIBSSH2_SESSION                     LIBSSH2_SESSION;
 typedef struct _LIBSSH2_CHANNEL                     LIBSSH2_CHANNEL;
@@ -367,6 +427,25 @@ typedef struct _LIBSSH2_LISTENER                    LIBSSH2_LISTENER;
 typedef struct _LIBSSH2_KNOWNHOSTS                  LIBSSH2_KNOWNHOSTS;
 typedef struct _LIBSSH2_AGENT                       LIBSSH2_AGENT;
 
+/* SK signature callback */
+typedef struct _LIBSSH2_PRIVKEY_SK {
+    int algorithm;
+    uint8_t flags;
+    const char *application;
+    const unsigned char *key_handle;
+    size_t handle_len;
+    LIBSSH2_USERAUTH_SK_SIGN_FUNC((*sign_callback));
+    void **orig_abstract;
+} LIBSSH2_PRIVKEY_SK;
+
+int
+libssh2_sign_sk(LIBSSH2_SESSION *session,
+                unsigned char **sig,
+                size_t *sig_len,
+                const unsigned char *data,
+                size_t data_len,
+                void **abstract);
+
 typedef struct _LIBSSH2_POLLFD {
     unsigned char type; /* LIBSSH2_POLLFD_* below */
 
@@ -423,7 +502,7 @@ typedef struct _LIBSSH2_POLLFD {
 /* Hostkey Types */
 #define LIBSSH2_HOSTKEY_TYPE_UNKNOWN            0
 #define LIBSSH2_HOSTKEY_TYPE_RSA                1
-#define LIBSSH2_HOSTKEY_TYPE_DSS                2
+#define LIBSSH2_HOSTKEY_TYPE_DSS                2  /* deprecated */
 #define LIBSSH2_HOSTKEY_TYPE_ECDSA_256          3
 #define LIBSSH2_HOSTKEY_TYPE_ECDSA_384          4
 #define LIBSSH2_HOSTKEY_TYPE_ECDSA_521          5
@@ -506,6 +585,11 @@ typedef struct _LIBSSH2_POLLFD {
 #define LIBSSH2_ERROR_CHANNEL_WINDOW_FULL       -47
 #define LIBSSH2_ERROR_KEYFILE_AUTH_FAILED       -48
 #define LIBSSH2_ERROR_RANDGEN                   -49
+#define LIBSSH2_ERROR_MISSING_USERAUTH_BANNER   -50
+#define LIBSSH2_ERROR_ALGO_UNSUPPORTED          -51
+#define LIBSSH2_ERROR_MAC_FAILURE               -52
+#define LIBSSH2_ERROR_HASH_INIT                 -53
+#define LIBSSH2_ERROR_HASH_CALC                 -54
 
 /* this is a define to provide the old (<= 1.2.7) name */
 #define LIBSSH2_ERROR_BANNER_NONE LIBSSH2_ERROR_BANNER_RECV
@@ -566,14 +650,25 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
 
 LIBSSH2_API void **libssh2_session_abstract(LIBSSH2_SESSION *session);
 
+typedef void (libssh2_cb_generic)(void);
+
+LIBSSH2_API libssh2_cb_generic *
+libssh2_session_callback_set2(LIBSSH2_SESSION *session, int cbtype,
+                              libssh2_cb_generic *callback);
+
+LIBSSH2_DEPRECATED(1.11.1, "Use libssh2_session_callback_set2()")
 LIBSSH2_API void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
                                                int cbtype, void *callback);
 LIBSSH2_API int libssh2_session_banner_set(LIBSSH2_SESSION *session,
                                            const char *banner);
+#ifndef LIBSSH2_NO_DEPRECATED
+LIBSSH2_DEPRECATED(1.4.0, "Use libssh2_session_banner_set()")
 LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION *session,
                                    const char *banner);
 
+LIBSSH2_DEPRECATED(1.2.8, "Use libssh2_session_handshake()")
 LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int sock);
+#endif
 LIBSSH2_API int libssh2_session_handshake(LIBSSH2_SESSION *session,
                                           libssh2_socket_t sock);
 LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session,
@@ -581,8 +676,8 @@ LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session,
                                               const char *description,
                                               const char *lang);
 #define libssh2_session_disconnect(session, description) \
-  libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, \
-                                (description), "")
+    libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, \
+                                  (description), "")
 
 LIBSSH2_API int libssh2_session_free(LIBSSH2_SESSION *session);
 
@@ -614,6 +709,8 @@ LIBSSH2_API const char *libssh2_session_banner_get(LIBSSH2_SESSION *session);
 LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session,
                                         const char *username,
                                         unsigned int username_len);
+LIBSSH2_API int libssh2_userauth_banner(LIBSSH2_SESSION *session,
+                                        char **banner);
 LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
 
 LIBSSH2_API int
@@ -623,12 +720,13 @@ libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
                              const char *password,
                              unsigned int password_len,
                              LIBSSH2_PASSWD_CHANGEREQ_FUNC
-                             ((*passwd_change_cb)));
+                                 ((*passwd_change_cb)));
 
 #define libssh2_userauth_password(session, username, password) \
- libssh2_userauth_password_ex((session), (username),           \
-                              (unsigned int)strlen(username),  \
-                              (password), (unsigned int)strlen(password), NULL)
+    libssh2_userauth_password_ex((session), (username), \
+                                 (unsigned int)strlen(username), \
+                                 (password), (unsigned int)strlen(password), \
+                                 NULL)
 
 LIBSSH2_API int
 libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
@@ -638,11 +736,11 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
                                        const char *privatekey,
                                        const char *passphrase);
 
-#define libssh2_userauth_publickey_fromfile(session, username, publickey, \
-                                            privatekey, passphrase)     \
-    libssh2_userauth_publickey_fromfile_ex((session), (username),       \
+#define libssh2_userauth_publickey_fromfile(session, username, publickey,  \
+                                            privatekey, passphrase)        \
+    libssh2_userauth_publickey_fromfile_ex((session), (username),          \
                                            (unsigned int)strlen(username), \
-                                           (publickey),                 \
+                                           (publickey),                    \
                                            (privatekey), (passphrase))
 
 LIBSSH2_API int
@@ -651,7 +749,7 @@ libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                            const unsigned char *pubkeydata,
                            size_t pubkeydata_len,
                            LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                           ((*sign_callback)),
+                               ((*sign_callback)),
                            void **abstract);
 
 LIBSSH2_API int
@@ -666,16 +764,16 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
                                        const char *local_username,
                                        unsigned int local_username_len);
 
-#define libssh2_userauth_hostbased_fromfile(session, username, publickey, \
+#define libssh2_userauth_hostbased_fromfile(session, username, publickey,     \
                                             privatekey, passphrase, hostname) \
- libssh2_userauth_hostbased_fromfile_ex((session), (username), \
-                                        (unsigned int)strlen(username), \
-                                        (publickey),                    \
-                                        (privatekey), (passphrase),     \
-                                        (hostname),                     \
-                                        (unsigned int)strlen(hostname), \
-                                        (username),                     \
-                                        (unsigned int)strlen(username))
+    libssh2_userauth_hostbased_fromfile_ex((session), (username),             \
+                                           (unsigned int)strlen(username),    \
+                                           (publickey),                       \
+                                           (privatekey), (passphrase),        \
+                                           (hostname),                        \
+                                           (unsigned int)strlen(hostname),    \
+                                           (username),                        \
+                                           (unsigned int)strlen(username))
 
 LIBSSH2_API int
 libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
@@ -697,15 +795,28 @@ LIBSSH2_API int
 libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION* session,
                                          const char *username,
                                          unsigned int username_len,
-                                         LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(
-                                                       (*response_callback)));
+                                         LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC
+                                             ((*response_callback)));
 
-#define libssh2_userauth_keyboard_interactive(session, username,        \
-                                              response_callback)        \
-    libssh2_userauth_keyboard_interactive_ex((session), (username),     \
+#define libssh2_userauth_keyboard_interactive(session, username,             \
+                                              response_callback)             \
+    libssh2_userauth_keyboard_interactive_ex((session), (username),          \
                                              (unsigned int)strlen(username), \
                                              (response_callback))
 
+LIBSSH2_API int
+libssh2_userauth_publickey_sk(LIBSSH2_SESSION *session,
+                              const char *username,
+                              size_t username_len,
+                              const unsigned char *pubkeydata,
+                              size_t pubkeydata_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase,
+                              LIBSSH2_USERAUTH_SK_SIGN_FUNC
+                                  ((*sign_callback)),
+                              void **abstract);
+
 LIBSSH2_API int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds,
                              long timeout);
 
@@ -731,22 +842,27 @@ libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type,
                         const char *message, unsigned int message_len);
 
 #define libssh2_channel_open_session(session) \
-  libssh2_channel_open_ex((session), "session", sizeof("session") - 1, \
-                          LIBSSH2_CHANNEL_WINDOW_DEFAULT, \
-                          LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0)
+    libssh2_channel_open_ex((session), "session", sizeof("session") - 1, \
+                            LIBSSH2_CHANNEL_WINDOW_DEFAULT, \
+                            LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0)
 
 LIBSSH2_API LIBSSH2_CHANNEL *
 libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
                                 int port, const char *shost, int sport);
 #define libssh2_channel_direct_tcpip(session, host, port) \
-  libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22)
+    libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22)
+
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_channel_direct_streamlocal_ex(LIBSSH2_SESSION * session,
+                                      const char *socket_path,
+                                      const char *shost, int sport);
 
 LIBSSH2_API LIBSSH2_LISTENER *
 libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host,
                                   int port, int *bound_port,
                                   int queue_maxsize);
 #define libssh2_channel_forward_listen(session, port) \
- libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16)
+    libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16)
 
 LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
 
@@ -787,7 +903,7 @@ LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel,
                                                     int width_px,
                                                     int height_px);
 #define libssh2_channel_request_pty_size(channel, width, height) \
-  libssh2_channel_request_pty_size_ex((channel), (width), (height), 0, 0)
+    libssh2_channel_request_pty_size_ex((channel), (width), (height), 0, 0)
 
 LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel,
                                            int single_connection,
@@ -795,7 +911,13 @@ LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel,
                                            const char *auth_cookie,
                                            int screen_number);
 #define libssh2_channel_x11_req(channel, screen_number) \
- libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number))
+    libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number))
+
+LIBSSH2_API int libssh2_channel_signal_ex(LIBSSH2_CHANNEL *channel,
+                                          const char *signame,
+                                          size_t signame_len);
+#define libssh2_channel_signal(channel, signame) \
+    libssh2_channel_signal_ex((channel), signame, strlen(signame))
 
 LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
                                                 const char *request,
@@ -803,23 +925,25 @@ LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
                                                 const char *message,
                                                 unsigned int message_len);
 #define libssh2_channel_shell(channel) \
-  libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, \
-                                  NULL, 0)
+    libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, \
+                                    NULL, 0)
 #define libssh2_channel_exec(channel, command) \
-  libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, \
-                                  (command), (unsigned int)strlen(command))
+    libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, \
+                                    (command), (unsigned int)strlen(command))
 #define libssh2_channel_subsystem(channel, subsystem) \
-  libssh2_channel_process_startup((channel), "subsystem",              \
-                                  sizeof("subsystem") - 1, (subsystem), \
-                                  (unsigned int)strlen(subsystem))
+    libssh2_channel_process_startup((channel), "subsystem", \
+                                    sizeof("subsystem") - 1, (subsystem), \
+                                    (unsigned int)strlen(subsystem))
 
 LIBSSH2_API ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel,
                                             int stream_id, char *buf,
                                             size_t buflen);
 #define libssh2_channel_read(channel, buf, buflen) \
-  libssh2_channel_read_ex((channel), 0, (buf), (buflen))
+    libssh2_channel_read_ex((channel), 0, \
+                            (buf), (buflen))
 #define libssh2_channel_read_stderr(channel, buf, buflen) \
-  libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
+    libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, \
+                            (buf), (buflen))
 
 LIBSSH2_API int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel,
                                           int extended);
@@ -829,14 +953,15 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
                                unsigned long *read_avail,
                                unsigned long *window_size_initial);
 #define libssh2_channel_window_read(channel) \
-  libssh2_channel_window_read_ex((channel), NULL, NULL)
+    libssh2_channel_window_read_ex((channel), NULL, NULL)
 
-/* libssh2_channel_receive_window_adjust is DEPRECATED, do not use! */
+#ifndef LIBSSH2_NO_DEPRECATED
+LIBSSH2_DEPRECATED(1.1.0, "Use libssh2_channel_receive_window_adjust2()")
 LIBSSH2_API unsigned long
 libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
                                       unsigned long adjustment,
                                       unsigned char force);
-
+#endif
 LIBSSH2_API int
 libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
                                        unsigned long adjustment,
@@ -848,16 +973,17 @@ LIBSSH2_API ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
                                              size_t buflen);
 
 #define libssh2_channel_write(channel, buf, buflen) \
-  libssh2_channel_write_ex((channel), 0, (buf), (buflen))
-#define libssh2_channel_write_stderr(channel, buf, buflen)              \
-    libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR,       \
+    libssh2_channel_write_ex((channel), 0, \
+                             (buf), (buflen))
+#define libssh2_channel_write_stderr(channel, buf, buflen) \
+    libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR, \
                              (buf), (buflen))
 
 LIBSSH2_API unsigned long
 libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
                                 unsigned long *window_size_initial);
 #define libssh2_channel_window_write(channel) \
-  libssh2_channel_window_write_ex((channel), NULL)
+    libssh2_channel_window_write_ex((channel), NULL)
 
 LIBSSH2_API void libssh2_session_set_blocking(LIBSSH2_SESSION* session,
                                               int blocking);
@@ -870,12 +996,19 @@ LIBSSH2_API void libssh2_session_set_timeout(LIBSSH2_SESSION* session,
                                              long timeout);
 LIBSSH2_API long libssh2_session_get_timeout(LIBSSH2_SESSION* session);
 
-/* libssh2_channel_handle_extended_data is DEPRECATED, do not use! */
+LIBSSH2_API void libssh2_session_set_read_timeout(LIBSSH2_SESSION* session,
+                                                  long timeout);
+LIBSSH2_API long libssh2_session_get_read_timeout(LIBSSH2_SESSION* session);
+
+#ifndef LIBSSH2_NO_DEPRECATED
+LIBSSH2_DEPRECATED(1.1.0, "libssh2_channel_handle_extended_data2()")
 LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
                                                       int ignore_mode);
+#endif
 LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
                                                       int ignore_mode);
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /* libssh2_channel_ignore_extended_data() is defined below for BC with version
  * 0.1
  *
@@ -883,12 +1016,12 @@ LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
  * LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE is passed, extended data will be read
  * (FIFO) from the standard data channel
  */
-/* DEPRECATED */
-#define libssh2_channel_ignore_extended_data(channel, ignore) \
-  libssh2_channel_handle_extended_data((channel),                       \
-                                       (ignore) ?                       \
+/* DEPRECATED since 0.3.0. Use libssh2_channel_handle_extended_data2(). */
+#define libssh2_channel_ignore_extended_data(channel, ignore)                 \
+    libssh2_channel_handle_extended_data((channel), (ignore) ?                \
                                        LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE : \
                                        LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL)
+#endif
 
 #define LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA     -1
 #define LIBSSH2_CHANNEL_FLUSH_ALL               -2
@@ -896,7 +1029,7 @@ LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel,
                                          int streamid);
 #define libssh2_channel_flush(channel) libssh2_channel_flush_ex((channel), 0)
 #define libssh2_channel_flush_stderr(channel) \
- libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR)
+    libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR)
 
 LIBSSH2_API int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel);
 LIBSSH2_API int libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL* channel,
@@ -913,11 +1046,13 @@ LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API int libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *channel);
 
-/* libssh2_scp_recv is DEPRECATED, do not use! */
+#ifndef LIBSSH2_NO_DEPRECATED
+LIBSSH2_DEPRECATED(1.7.0, "Use libssh2_scp_recv2()")
 LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session,
                                               const char *path,
                                               struct stat *sb);
-/* Use libssh2_scp_recv2 for large (> 2GB) file support on windows */
+#endif
+/* Use libssh2_scp_recv2() for large (> 2GB) file support on windows */
 LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv2(LIBSSH2_SESSION *session,
                                                const char *path,
                                                libssh2_struct_stat *sb);
@@ -930,8 +1065,9 @@ libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
                    libssh2_int64_t size, time_t mtime, time_t atime);
 
 #define libssh2_scp_send(session, path, mode, size) \
-  libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0)
+    libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0)
 
+/* DEPRECATED */
 LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
                                       unsigned int *dest_len,
                                       const char *src, unsigned int src_len);
@@ -939,8 +1075,22 @@ LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
 LIBSSH2_API
 const char *libssh2_version(int req_version_num);
 
+typedef enum {
+    libssh2_no_crypto = 0,
+    libssh2_openssl,
+    libssh2_gcrypt,
+    libssh2_mbedtls,
+    libssh2_wincng,
+    libssh2_os400qc3
+} libssh2_crypto_engine_t;
+
+LIBSSH2_API
+libssh2_crypto_engine_t libssh2_crypto_engine(void);
+
 #define HAVE_LIBSSH2_KNOWNHOST_API 0x010101 /* since 1.1.1 */
 #define HAVE_LIBSSH2_VERSION_API   0x010100 /* libssh2_version since 1.1 */
+#define HAVE_LIBSSH2_CRYPTOENGINE_API 0x011100 /* libssh2_crypto_engine
+                                                  since 1.11 */
 
 struct libssh2_knownhost {
     unsigned int magic;  /* magic stored by the library */
@@ -951,7 +1101,7 @@ struct libssh2_knownhost {
 };
 
 /*
- * libssh2_knownhost_init
+ * libssh2_knownhost_init()
  *
  * Init a collection of known hosts. Returns the pointer to a collection.
  *
@@ -960,7 +1110,7 @@ LIBSSH2_API LIBSSH2_KNOWNHOSTS *
 libssh2_knownhost_init(LIBSSH2_SESSION *session);
 
 /*
- * libssh2_knownhost_add
+ * libssh2_knownhost_add()
  *
  * Add a host and its associated key to the collection of known hosts.
  *
@@ -997,7 +1147,7 @@ libssh2_knownhost_init(LIBSSH2_SESSION *session);
 #define LIBSSH2_KNOWNHOST_KEY_SHIFT        18
 #define LIBSSH2_KNOWNHOST_KEY_RSA1         (1<<18)
 #define LIBSSH2_KNOWNHOST_KEY_SSHRSA       (2<<18)
-#define LIBSSH2_KNOWNHOST_KEY_SSHDSS       (3<<18)
+#define LIBSSH2_KNOWNHOST_KEY_SSHDSS       (3<<18)  /* deprecated */
 #define LIBSSH2_KNOWNHOST_KEY_ECDSA_256    (4<<18)
 #define LIBSSH2_KNOWNHOST_KEY_ECDSA_384    (5<<18)
 #define LIBSSH2_KNOWNHOST_KEY_ECDSA_521    (6<<18)
@@ -1012,7 +1162,7 @@ libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
                       struct libssh2_knownhost **store);
 
 /*
- * libssh2_knownhost_addc
+ * libssh2_knownhost_addc()
  *
  * Add a host and its associated key to the collection of known hosts.
  *
@@ -1030,8 +1180,8 @@ libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
  * If 'sha1' is selected as type, the salt must be provided to the salt
  * argument. This too base64 encoded.
  *
- * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.  If
- * a custom type is used, salt is ignored and you must provide the host
+ * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.
+ * If a custom type is used, salt is ignored and you must provide the host
  * pre-hashed when checking for it in the libssh2_knownhost_check() function.
  *
  * The keylen parameter may be omitted (zero) if the key is provided as a
@@ -1047,7 +1197,7 @@ libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
                        struct libssh2_knownhost **store);
 
 /*
- * libssh2_knownhost_check
+ * libssh2_knownhost_check()
  *
  * Check a host and its associated key against the collection of known hosts.
  *
@@ -1086,7 +1236,7 @@ libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
                          struct libssh2_knownhost **knownhost);
 
 /*
- * libssh2_knownhost_del
+ * libssh2_knownhost_del()
  *
  * Remove a host from the collection of known hosts. The 'entry' struct is
  * retrieved by a call to libssh2_knownhost_check().
@@ -1097,7 +1247,7 @@ libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
                       struct libssh2_knownhost *entry);
 
 /*
- * libssh2_knownhost_free
+ * libssh2_knownhost_free()
  *
  * Free an entire collection of known hosts.
  *
@@ -1118,7 +1268,7 @@ libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
                            const char *line, size_t len, int type);
 
 /*
- * libssh2_knownhost_readfile
+ * libssh2_knownhost_readfile()
  *
  * Add hosts+key pairs from a given file.
  *
@@ -1154,7 +1304,7 @@ libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
                             int type);
 
 /*
- * libssh2_knownhost_writefile
+ * libssh2_knownhost_writefile()
  *
  * Write hosts+key pairs to a given file.
  *
@@ -1194,7 +1344,7 @@ struct libssh2_agent_publickey {
 };
 
 /*
- * libssh2_agent_init
+ * libssh2_agent_init()
  *
  * Init an ssh-agent handle. Returns the pointer to the handle.
  *
@@ -1236,8 +1386,8 @@ libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
  */
 LIBSSH2_API int
 libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
-               struct libssh2_agent_publickey **store,
-               struct libssh2_agent_publickey *prev);
+                           struct libssh2_agent_publickey **store,
+                           struct libssh2_agent_publickey *prev);
 
 /*
  * libssh2_agent_userauth()
@@ -1248,8 +1398,25 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
  */
 LIBSSH2_API int
 libssh2_agent_userauth(LIBSSH2_AGENT *agent,
-               const char *username,
-               struct libssh2_agent_publickey *identity);
+                       const char *username,
+                       struct libssh2_agent_publickey *identity);
+
+/*
+ * libssh2_agent_sign()
+ *
+ * Sign a payload using a system-installed ssh-agent.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_sign(LIBSSH2_AGENT *agent,
+                   struct libssh2_agent_publickey *identity,
+                   unsigned char **sig,
+                   size_t *s_len,
+                   const unsigned char *data,
+                   size_t d_len,
+                   const char *method,
+                   unsigned int method_len);
 
 /*
  * libssh2_agent_disconnect()
@@ -1304,7 +1471,7 @@ libssh2_agent_get_identity_path(LIBSSH2_AGENT *agent);
  */
 LIBSSH2_API void libssh2_keepalive_config(LIBSSH2_SESSION *session,
                                           int want_reply,
-                                          unsigned interval);
+                                          unsigned int interval);
 
 /*
  * libssh2_keepalive_send()
@@ -1322,15 +1489,15 @@ LIBSSH2_API int libssh2_keepalive_send(LIBSSH2_SESSION *session,
    enabled
  */
 LIBSSH2_API int libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
-#define LIBSSH2_TRACE_TRANS (1<<1)
-#define LIBSSH2_TRACE_KEX   (1<<2)
-#define LIBSSH2_TRACE_AUTH  (1<<3)
-#define LIBSSH2_TRACE_CONN  (1<<4)
-#define LIBSSH2_TRACE_SCP   (1<<5)
-#define LIBSSH2_TRACE_SFTP  (1<<6)
-#define LIBSSH2_TRACE_ERROR (1<<7)
-#define LIBSSH2_TRACE_PUBLICKEY (1<<8)
-#define LIBSSH2_TRACE_SOCKET (1<<9)
+#define LIBSSH2_TRACE_TRANS      (1<<1)
+#define LIBSSH2_TRACE_KEX        (1<<2)
+#define LIBSSH2_TRACE_AUTH       (1<<3)
+#define LIBSSH2_TRACE_CONN       (1<<4)
+#define LIBSSH2_TRACE_SCP        (1<<5)
+#define LIBSSH2_TRACE_SFTP       (1<<6)
+#define LIBSSH2_TRACE_ERROR      (1<<7)
+#define LIBSSH2_TRACE_PUBLICKEY  (1<<8)
+#define LIBSSH2_TRACE_SOCKET     (1<<9)
 
 typedef void (*libssh2_trace_handler_func)(LIBSSH2_SESSION*,
                                            void *,
diff --git a/libssh2/include/libssh2_publickey.h b/libssh2/include/libssh2_publickey.h
index 5dbdcf92..566acd65 100644
--- a/libssh2/include/libssh2_publickey.h
+++ b/libssh2/include/libssh2_publickey.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -41,6 +41,8 @@
  *
  * For more information on the publickey subsystem,
  * refer to IETF draft: secsh-publickey
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_PUBLICKEY_H
@@ -72,9 +74,9 @@ typedef struct _libssh2_publickey_list {
 /* Generally use the first macro here, but if both name and value are string
    literals, you can use _fast() to take advantage of preprocessing */
 #define libssh2_publickey_attribute(name, value, mandatory) \
-  { (name), strlen(name), (value), strlen(value), (mandatory) },
+    { (name), strlen(name), (value), strlen(value), (mandatory) },
 #define libssh2_publickey_attribute_fast(name, value, mandatory) \
-  { (name), sizeof(name) - 1, (value), sizeof(value) - 1, (mandatory) },
+    { (name), sizeof(name) - 1, (value), sizeof(value) - 1, (mandatory) },
 
 #ifdef __cplusplus
 extern "C" {
@@ -92,10 +94,12 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey,
                          unsigned long blob_len, char overwrite,
                          unsigned long num_attrs,
                          const libssh2_publickey_attribute attrs[]);
-#define libssh2_publickey_add(pkey, name, blob, blob_len, overwrite,    \
-                              num_attrs, attrs)                         \
-  libssh2_publickey_add_ex((pkey), (name), strlen(name), (blob), (blob_len), \
-                           (overwrite), (num_attrs), (attrs))
+#define libssh2_publickey_add(pkey, name, blob, blob_len, overwrite, \
+                              num_attrs, attrs) \
+    libssh2_publickey_add_ex((pkey), \
+                             (name), strlen(name), \
+                             (blob), (blob_len), \
+                             (overwrite), (num_attrs), (attrs))
 
 LIBSSH2_API int libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY *pkey,
                                             const unsigned char *name,
@@ -103,7 +107,9 @@ LIBSSH2_API int libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY *pkey,
                                             const unsigned char *blob,
                                             unsigned long blob_len);
 #define libssh2_publickey_remove(pkey, name, blob, blob_len) \
-  libssh2_publickey_remove_ex((pkey), (name), strlen(name), (blob), (blob_len))
+    libssh2_publickey_remove_ex((pkey), \
+                                (name), strlen(name), \
+                                (blob), (blob_len))
 
 LIBSSH2_API int
 libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY *pkey,
@@ -119,4 +125,4 @@ LIBSSH2_API int libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey);
 } /* extern "C" */
 #endif
 
-#endif /* ifndef: LIBSSH2_PUBLICKEY_H */
+#endif /* LIBSSH2_PUBLICKEY_H */
diff --git a/libssh2/include/libssh2_sftp.h b/libssh2/include/libssh2_sftp.h
index 476ea870..ab7b0af4 100644
--- a/libssh2/include/libssh2_sftp.h
+++ b/libssh2/include/libssh2_sftp.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,6 +33,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_SFTP_H
@@ -40,7 +42,7 @@
 
 #include "libssh2.h"
 
-#ifndef WIN32
+#ifndef _WIN32
 #include <unistd.h>
 #endif
 
@@ -165,19 +167,19 @@ struct _LIBSSH2_SFTP_STATVFS {
 
 /* macros to check for specific file types, added in 1.2.5 */
 #define LIBSSH2_SFTP_S_ISLNK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)
 #define LIBSSH2_SFTP_S_ISREG(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)
 #define LIBSSH2_SFTP_S_ISDIR(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)
 #define LIBSSH2_SFTP_S_ISCHR(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)
 #define LIBSSH2_SFTP_S_ISBLK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)
 #define LIBSSH2_SFTP_S_ISFIFO(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)
 #define LIBSSH2_SFTP_S_ISSOCK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)
+    (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)
 
 /* SFTP File Transfer Flags -- (e.g. flags parameter to sftp_open())
  * Danger will robinson... APPEND doesn't have any effect on OpenSSH servers */
@@ -230,12 +232,25 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp,
                      unsigned int filename_len,
                      unsigned long flags,
                      long mode, int open_type);
-#define libssh2_sftp_open(sftp, filename, flags, mode)                  \
-    libssh2_sftp_open_ex((sftp), (filename), strlen(filename), (flags), \
-                         (mode), LIBSSH2_SFTP_OPENFILE)
+#define libssh2_sftp_open(sftp, filename, flags, mode) \
+    libssh2_sftp_open_ex((sftp), \
+                         (filename), (unsigned int)strlen(filename), \
+                         (flags), (mode), LIBSSH2_SFTP_OPENFILE)
 #define libssh2_sftp_opendir(sftp, path) \
-    libssh2_sftp_open_ex((sftp), (path), strlen(path), 0, 0, \
-                         LIBSSH2_SFTP_OPENDIR)
+    libssh2_sftp_open_ex((sftp), \
+                         (path), (unsigned int)strlen(path), \
+                         0, 0, LIBSSH2_SFTP_OPENDIR)
+LIBSSH2_API LIBSSH2_SFTP_HANDLE *
+libssh2_sftp_open_ex_r(LIBSSH2_SFTP *sftp,
+                       const char *filename,
+                       size_t filename_len,
+                       unsigned long flags,
+                       long mode, int open_type,
+                       LIBSSH2_SFTP_ATTRIBUTES *attrs);
+#define libssh2_sftp_open_r(sftp, filename, flags, mode, attrs) \
+    libssh2_sftp_open_ex_r((sftp), (filename), strlen(filename), \
+                           (flags), (mode), LIBSSH2_SFTP_OPENFILE, \
+                           (attrs))
 
 LIBSSH2_API ssize_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle,
                                       char *buffer, size_t buffer_maxlen);
@@ -245,7 +260,7 @@ LIBSSH2_API int libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *handle, \
                                         char *longentry,
                                         size_t longentry_maxlen,
                                         LIBSSH2_SFTP_ATTRIBUTES *attrs);
-#define libssh2_sftp_readdir(handle, buffer, buffer_maxlen, attrs)      \
+#define libssh2_sftp_readdir(handle, buffer, buffer_maxlen, attrs) \
     libssh2_sftp_readdir_ex((handle), (buffer), (buffer_maxlen), NULL, 0, \
                             (attrs))
 
@@ -281,17 +296,27 @@ LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp,
                                        unsigned int dest_filename_len,
                                        long flags);
 #define libssh2_sftp_rename(sftp, sourcefile, destfile) \
-    libssh2_sftp_rename_ex((sftp), (sourcefile), strlen(sourcefile), \
-                           (destfile), strlen(destfile),                \
+    libssh2_sftp_rename_ex((sftp), \
+                           (sourcefile), (unsigned int)strlen(sourcefile), \
+                           (destfile), (unsigned int)strlen(destfile), \
                            LIBSSH2_SFTP_RENAME_OVERWRITE | \
                            LIBSSH2_SFTP_RENAME_ATOMIC | \
                            LIBSSH2_SFTP_RENAME_NATIVE)
 
+LIBSSH2_API int libssh2_sftp_posix_rename_ex(LIBSSH2_SFTP *sftp,
+                                             const char *source_filename,
+                                             size_t srouce_filename_len,
+                                             const char *dest_filename,
+                                             size_t dest_filename_len);
+#define libssh2_sftp_posix_rename(sftp, sourcefile, destfile) \
+    libssh2_sftp_posix_rename_ex((sftp), (sourcefile), strlen(sourcefile), \
+                                 (destfile), strlen(destfile))
+
 LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp,
                                        const char *filename,
                                        unsigned int filename_len);
 #define libssh2_sftp_unlink(sftp, filename) \
-    libssh2_sftp_unlink_ex((sftp), (filename), strlen(filename))
+    libssh2_sftp_unlink_ex((sftp), (filename), (unsigned int)strlen(filename))
 
 LIBSSH2_API int libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle,
                                       LIBSSH2_SFTP_STATVFS *st);
@@ -305,13 +330,13 @@ LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp,
                                       const char *path,
                                       unsigned int path_len, long mode);
 #define libssh2_sftp_mkdir(sftp, path, mode) \
-    libssh2_sftp_mkdir_ex((sftp), (path), strlen(path), (mode))
+    libssh2_sftp_mkdir_ex((sftp), (path), (unsigned int)strlen(path), (mode))
 
 LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp,
                                       const char *path,
                                       unsigned int path_len);
 #define libssh2_sftp_rmdir(sftp, path) \
-    libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
+    libssh2_sftp_rmdir_ex((sftp), (path), (unsigned int)strlen(path))
 
 LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp,
                                      const char *path,
@@ -319,14 +344,14 @@ LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp,
                                      int stat_type,
                                      LIBSSH2_SFTP_ATTRIBUTES *attrs);
 #define libssh2_sftp_stat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_STAT, \
-                         (attrs))
+    libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \
+                         LIBSSH2_SFTP_STAT, (attrs))
 #define libssh2_sftp_lstat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_LSTAT, \
-                         (attrs))
+    libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \
+                         LIBSSH2_SFTP_LSTAT, (attrs))
 #define libssh2_sftp_setstat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_SETSTAT, \
-                         (attrs))
+    libssh2_sftp_stat_ex((sftp), (path), (unsigned int)strlen(path), \
+                         LIBSSH2_SFTP_SETSTAT, (attrs))
 
 LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp,
                                         const char *path,
@@ -335,13 +360,19 @@ LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp,
                                         unsigned int target_len,
                                         int link_type);
 #define libssh2_sftp_symlink(sftp, orig, linkpath) \
-    libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), \
-                            strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
+    libssh2_sftp_symlink_ex((sftp), \
+                            (orig), (unsigned int)strlen(orig), \
+                            (linkpath), (unsigned int)strlen(linkpath), \
+                            LIBSSH2_SFTP_SYMLINK)
 #define libssh2_sftp_readlink(sftp, path, target, maxlen) \
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \
-    LIBSSH2_SFTP_READLINK)
+    libssh2_sftp_symlink_ex((sftp), \
+                            (path), (unsigned int)strlen(path), \
+                            (target), (maxlen), \
+                            LIBSSH2_SFTP_READLINK)
 #define libssh2_sftp_realpath(sftp, path, target, maxlen) \
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \
+    libssh2_sftp_symlink_ex((sftp), \
+                            (path), (unsigned int)strlen(path), \
+                            (target), (maxlen), \
                             LIBSSH2_SFTP_REALPATH)
 
 #ifdef __cplusplus
diff --git a/libssh2/libssh2-style.el b/libssh2/libssh2-style.el
new file mode 100644
index 00000000..3001010f
--- /dev/null
+++ b/libssh2/libssh2-style.el
@@ -0,0 +1,52 @@
+;;;; Emacs Lisp help for writing libssh2 code. ;;;;
+;;; Copyright (C) The libssh2 project and its contributors.
+;;; SPDX-License-Identifier: BSD-3-Clause
+
+;;; The libssh2 hacker's C conventions.
+;;; See the sample.emacs file on how this file can be made to take
+;;; effect automatically when editing libssh2 source files.
+
+(defconst libssh2-c-style
+  '((c-basic-offset . 4)
+    (c-comment-only-line-offset . 0)
+    (c-hanging-braces-alist     . ((substatement-open before after)))
+    (c-offsets-alist . ((topmost-intro        . 0)
+                        (topmost-intro-cont   . 0)
+                        (substatement         . +)
+                        (substatement-open    . 0)
+                        (statement-case-intro . +)
+                        (statement-case-open  . 0)
+                        (case-label           . 0)
+                        ))
+    )
+  "Libssh2 C Programming Style")
+
+(defun libssh2-code-cleanup ()
+  "tabify and delete trailing whitespace"
+  (interactive)
+  (untabify (point-min) (point-max))
+  (delete-trailing-whitespace)
+)
+
+;; Customizations for all of c-mode, c++-mode, and objc-mode
+(defun libssh2-c-mode-common-hook ()
+  "Libssh2 C mode hook"
+  ;; add libssh2 style and set it for the current buffer
+  (c-add-style "libssh2" libssh2-c-style t)
+  (setq tab-width 8
+        indent-tabs-mode nil            ; Use spaces, not tabs.
+        comment-column 40
+        c-font-lock-extra-types (append '("libssh2_int64_t" "LIBSSH2_USERAUTH_KBDINT_PROMPT" "LIBSSH2_SESSION" "LIBSSH2_CHANNEL" "ssize_t" "size_t" "uint32_t" "LIBSSH2_LISTENER" "LIBSSH2_POLLFD"))
+        )
+  ;; keybindings for C, C++, and Objective-C.  We can put these in
+  ;; c-mode-base-map because of inheritance ...
+  (define-key c-mode-base-map "\M-q" 'c-fill-paragraph)
+  (define-key c-mode-base-map "\M-m" 'libssh2-code-cleanup)
+  (setq c-recognize-knr-p nil)
+  ;;; (add-hook 'write-file-hooks 'delete-trailing-whitespace t)
+  (setq show-trailing-whitespace t)
+  )
+
+;; Set this is in your .emacs if you want to use the c-mode-hook as
+;; defined here right out of the box.
+; (add-hook 'c-mode-common-hook 'libssh2-c-mode-common-hook)
diff --git a/libssh2/libssh2.pc.in b/libssh2/libssh2.pc.in
index 96638167..9dde3e85 100644
--- a/libssh2/libssh2.pc.in
+++ b/libssh2/libssh2.pc.in
@@ -1,5 +1,8 @@
 ###########################################################################
 # libssh2 installation details
+#
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 ###########################################################################
 
 prefix=@prefix@
@@ -8,10 +11,11 @@ libdir=@libdir@
 includedir=@includedir@
 
 Name: libssh2
-URL: https://www.libssh2.org/
+URL: https://libssh2.org/
 Description: Library for SSH-based communication
-Version: @LIBSSH2VER@
-Requires.private: @LIBSREQUIRED@
-Libs: -L${libdir} -lssh2 @LIBS@
-Libs.private: @LIBS@
+Version: @LIBSSH2_VERSION@
+Requires: @LIBSSH2_PC_REQUIRES@
+Requires.private: @LIBSSH2_PC_REQUIRES_PRIVATE@
+Libs: -L${libdir} -lssh2 @LIBSSH2_PC_LIBS@
+Libs.private: @LIBSSH2_PC_LIBS_PRIVATE@
 Cflags: -I${includedir}
diff --git a/libssh2/libssh2/CMakeLists.txt b/libssh2/libssh2/CMakeLists.txt
deleted file mode 100644
index e6c95c88..00000000
--- a/libssh2/libssh2/CMakeLists.txt
+++ /dev/null
@@ -1,117 +0,0 @@
-# Copyright (c) 2014, 2015  Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-cmake_minimum_required(VERSION 2.8.11)
-
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
-
-project(libssh2 C)
-set(PROJECT_URL "https://www.libssh2.org/")
-set(PROJECT_DESCRIPTION "The SSH library")
-
-if (CMAKE_VERSION VERSION_LESS "3.1")
-  if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
-    set (CMAKE_C_FLAGS "--std=gnu90 ${CMAKE_C_FLAGS}")
-  endif()
-else()
-  set (CMAKE_C_STANDARD 90)
-endif()
-
-option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
-
-# Parse version
-
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/include/libssh2.h _HEADER_CONTENTS)
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION[ \t]+\"([^\"]+)\".*" "\\1"
-  LIBSSH2_VERSION "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_MAJOR "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_MINOR "${_HEADER_CONTENTS}")
-string(
-  REGEX REPLACE ".*#define LIBSSH2_VERSION_PATCH[ \t]+([0-9]+).*" "\\1"
-  LIBSSH2_VERSION_PATCH "${_HEADER_CONTENTS}")
-
-if(NOT LIBSSH2_VERSION OR
-   NOT LIBSSH2_VERSION_MAJOR MATCHES "^[0-9]+$" OR
-   NOT LIBSSH2_VERSION_MINOR MATCHES "^[0-9]+$" OR
-   NOT LIBSSH2_VERSION_PATCH MATCHES "^[0-9]+$")
-  message(
-    FATAL_ERROR
-    "Unable to parse version from"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/libssh2.h")
-endif()
-
-include(GNUInstallDirs)
-install(
-  FILES docs/AUTHORS COPYING docs/HACKING README RELEASE-NOTES NEWS
-  DESTINATION ${CMAKE_INSTALL_DOCDIR})
-
-include(max_warnings)
-include(FeatureSummary)
-
-add_subdirectory(src)
-
-option(BUILD_EXAMPLES "Build libssh2 examples" ON)
-if(BUILD_EXAMPLES)
-  add_subdirectory(example)
-endif()
-
-option(BUILD_TESTING "Build libssh2 test suite" ON)
-if(BUILD_TESTING)
-  enable_testing()
-  add_subdirectory(tests)
-endif()
-
-option(LINT "Check style while building" OFF)
-if(LINT)
-  add_custom_target(lint ALL
-    ./ci/checksrc.sh
-    WORKING_DIRECTORY ${libssh2_SOURCE_DIR})
-  add_dependencies(libssh2 lint)
-endif()
-
-add_subdirectory(docs)
-
-feature_summary(WHAT ALL)
-
-set(CPACK_PACKAGE_VERSION_MAJOR ${LIBSSH2_VERSION_MAJOR})
-set(CPACK_PACKAGE_VERSION_MINOR ${LIBSSH2_VERSION_MINOR})
-set(CPACK_PACKAGE_VERSION_PATCH ${LIBSSH2_VERSION_PATCH})
-set(CPACK_PACKAGE_VERSION ${LIBSSH2_VERSION})
-include(CPack)
diff --git a/libssh2/libssh2/COPYING b/libssh2/libssh2/COPYING
deleted file mode 100644
index 937ed32e..00000000
--- a/libssh2/libssh2/COPYING
+++ /dev/null
@@ -1,44 +0,0 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005,2006 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2006-2007 The Written Word, Inc.
- * Copyright (c) 2007 Eli Fant <elifantu@mail.ru>
- * Copyright (c) 2009-2021 Daniel Stenberg
- * Copyright (C) 2008, 2009 Simon Josefsson
- * Copyright (c) 2000 Markus Friedl
- * Copyright (c) 2015 Microsoft Corp.
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
diff --git a/libssh2/libssh2/ChangeLog b/libssh2/libssh2/ChangeLog
deleted file mode 100644
index 404c887c..00000000
--- a/libssh2/libssh2/ChangeLog
+++ /dev/null
@@ -1 +0,0 @@
-see NEWS
diff --git a/libssh2/libssh2/Makefile.OpenSSL.inc b/libssh2/libssh2/Makefile.OpenSSL.inc
deleted file mode 100644
index 1e4e8f0b..00000000
--- a/libssh2/libssh2/Makefile.OpenSSL.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = openssl.c
-CRYPTO_HHEADERS = openssl.h
-CRYPTO_LTLIBS = $(LTLIBSSL)
diff --git a/libssh2/libssh2/Makefile.WinCNG.inc b/libssh2/libssh2/Makefile.WinCNG.inc
deleted file mode 100644
index bbcb82bf..00000000
--- a/libssh2/libssh2/Makefile.WinCNG.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = wincng.c
-CRYPTO_HHEADERS = wincng.h
-CRYPTO_LTLIBS = $(LTLIBBCRYPT) $(LTLIBCRYPT32)
diff --git a/libssh2/libssh2/Makefile.am b/libssh2/libssh2/Makefile.am
deleted file mode 100644
index 986441bd..00000000
--- a/libssh2/libssh2/Makefile.am
+++ /dev/null
@@ -1,154 +0,0 @@
-AUTOMAKE_OPTIONS = foreign nostdinc
-
-SUBDIRS = src tests docs
-if BUILD_EXAMPLES
-SUBDIRS += example
-endif
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libssh2.pc
-
-include_HEADERS =			\
-	include/libssh2.h		\
-	include/libssh2_publickey.h	\
-	include/libssh2_sftp.h
-
-NETWAREFILES =  nw/keepscreen.c \
-	nw/nwlib.c \
-	nw/GNUmakefile \
-	nw/test/GNUmakefile
-
-DSP = win32/libssh2.dsp
-VCPROJ = win32/libssh2.vcproj
-
-DISTCLEANFILES = $(DSP)
-
-VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl	\
-vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c	\
-vms/readme.vms vms/libssh2_config.h
-
-WIN32FILES = win32/GNUmakefile win32/test/GNUmakefile		\
-win32/libssh2_config.h win32/config.mk win32/rules.mk		\
-win32/Makefile.Watcom win32/libssh2.dsw win32/tests.dsp $(DSP)	\
-win32/msvcproj.head win32/msvcproj.foot win32/libssh2.rc
-
-OS400FILES = os400/README400 os400/initscript.sh os400/make.sh		\
-os400/make-src.sh os400/make-rpg.sh os400/make-include.sh		\
-os400/os400sys.c os400/ccsid.c						\
-os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h		\
-os400/include/alloca.h os400/include/sys/socket.h os400/include/stdio.h	\
-os400/libssh2rpg/libssh2.rpgle.in					\
-os400/libssh2rpg/libssh2_ccsid.rpgle.in					\
-os400/libssh2rpg/libssh2_publickey.rpgle				\
-os400/libssh2rpg/libssh2_sftp.rpgle					\
-Makefile.os400qc3.inc
-
-EXTRA_DIST = $(WIN32FILES) $(NETWAREFILES) get_ver.awk \
- maketgz NMakefile RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
- CMakeLists.txt cmake $(OS400FILES)
-
-ACLOCAL_AMFLAGS = -I m4
-
-.PHONY: ChangeLog
-ChangeLog:
-	echo "see NEWS" > ./ChangeLog
-DISTCLEANFILES += ChangeLog
-
-dist-hook:
-	rm -rf $(top_builddir)/tests/log
-	find $(distdir) -name "*.dist" -exec rm {} \;
-	(distit=`find $(srcdir) -name "*.dist"`; \
-	for file in $$distit; do \
-	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
-	  cp $$file $(distdir)$$strip; \
-	done)
-
-# Code Coverage
-
-init-coverage:
-	make clean
-	lcov --directory . --zerocounters
-
-COVERAGE_CCOPTS ?= "-g --coverage"
-COVERAGE_OUT ?= docs/coverage
-
-build-coverage:
-	make CFLAGS=$(COVERAGE_CCOPTS) check
-	mkdir -p $(COVERAGE_OUT)
-	lcov --directory . --output-file $(COVERAGE_OUT)/$(PACKAGE).info \
-		--capture
-
-gen-coverage:
-	genhtml --output-directory $(COVERAGE_OUT) \
-		$(COVERAGE_OUT)/$(PACKAGE).info \
-		--highlight --frames --legend \
-		--title "$(PACKAGE_NAME)"
-
-coverage: init-coverage build-coverage gen-coverage
-
-# DSP/VCPROJ generation adapted from libcurl
-# only OpenSSL and WinCNG are supported with this build system
-CRYPTO_CSOURCES = openssl.c wincng.c mbedtls.c
-CRYPTO_HHEADERS = openssl.h wincng.h mbedtls.h
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-include Makefile.inc
-
-WIN32SOURCES = $(CSOURCES)
-WIN32HEADERS = $(HHEADERS) libssh2_config.h
-
-$(DSP): win32/msvcproj.head win32/msvcproj.foot Makefile.am
-	echo "creating $(DSP)"
-	@( (cat $(srcdir)/win32/msvcproj.head; \
-	echo "# Begin Group \"Source Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"cpp;c;cxx\""; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		echo "SOURCE=..\\src\\"$$file; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	echo "# Begin Group \"Header Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"h;hpp;hxx\""; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		if [ "$$file" = "libssh2_config.h" ]; \
-		then \
-			echo "SOURCE=.\\"$$file; \
-		else \
-			echo "SOURCE=..\\src\\"$$file; \
-		fi; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	cat $(srcdir)/win32/msvcproj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-$(VCPROJ): win32/vc8proj.head win32/vc8proj.foot Makefile.am
-	echo "creating $(VCPROJ)"
-	@( (cat $(srcdir)/vc8proj.head; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	echo "</Filter><Filter	Name=\"Header Files\">"; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	cat $(srcdir)/vc8proj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-checksrc:
-	perl src/checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF -ACOPYRIGHT \
-		-AFOPENMODE -Wsrc/libssh2_config.h src/*.[ch] include/*.h example/*.c \
-		tests/*.[ch]
diff --git a/libssh2/libssh2/Makefile.in b/libssh2/libssh2/Makefile.in
deleted file mode 100644
index c60873ab..00000000
--- a/libssh2/libssh2/Makefile.in
+++ /dev/null
@@ -1,1079 +0,0 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-
-VPATH = @srcdir@
-am__is_gnu_make = { \
-  if test -z '$(MAKELEVEL)'; then \
-    false; \
-  elif test -n '$(MAKE_HOST)'; then \
-    true; \
-  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
-    true; \
-  else \
-    false; \
-  fi; \
-}
-am__make_running_with_option = \
-  case $${target_option-} in \
-      ?) ;; \
-      *) echo "am__make_running_with_option: internal error: invalid" \
-              "target option '$${target_option-}' specified" >&2; \
-         exit 1;; \
-  esac; \
-  has_opt=no; \
-  sane_makeflags=$$MAKEFLAGS; \
-  if $(am__is_gnu_make); then \
-    sane_makeflags=$$MFLAGS; \
-  else \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        bs=\\; \
-        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
-          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
-    esac; \
-  fi; \
-  skip_next=no; \
-  strip_trailopt () \
-  { \
-    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
-  }; \
-  for flg in $$sane_makeflags; do \
-    test $$skip_next = yes && { skip_next=no; continue; }; \
-    case $$flg in \
-      *=*|--*) continue;; \
-        -*I) strip_trailopt 'I'; skip_next=yes;; \
-      -*I?*) strip_trailopt 'I';; \
-        -*O) strip_trailopt 'O'; skip_next=yes;; \
-      -*O?*) strip_trailopt 'O';; \
-        -*l) strip_trailopt 'l'; skip_next=yes;; \
-      -*l?*) strip_trailopt 'l';; \
-      -[dEDm]) skip_next=yes;; \
-      -[JT]) skip_next=yes;; \
-    esac; \
-    case $$flg in \
-      *$$target_option*) has_opt=yes; break;; \
-    esac; \
-  done; \
-  test $$has_opt = yes
-am__make_dryrun = (target_option=n; $(am__make_running_with_option))
-am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-build_triplet = @build@
-host_triplet = @host@
-@BUILD_EXAMPLES_TRUE@am__append_1 = example
-subdir = .
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
-	$(am__configure_deps) $(include_HEADERS) $(am__DIST_COMMON)
-am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
- configure.lineno config.status.lineno
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
-CONFIG_CLEAN_FILES = libssh2.pc
-CONFIG_CLEAN_VPATH_FILES =
-AM_V_P = $(am__v_P_@AM_V@)
-am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
-am__v_P_0 = false
-am__v_P_1 = :
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN     " $@;
-am__v_GEN_1 = 
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-am__v_at_1 = 
-SOURCES =
-DIST_SOURCES =
-RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
-	ctags-recursive dvi-recursive html-recursive info-recursive \
-	install-data-recursive install-dvi-recursive \
-	install-exec-recursive install-html-recursive \
-	install-info-recursive install-pdf-recursive \
-	install-ps-recursive install-recursive installcheck-recursive \
-	installdirs-recursive pdf-recursive ps-recursive \
-	tags-recursive uninstall-recursive
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
-am__vpath_adj = case $$p in \
-    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
-    *) f=$$p;; \
-  esac;
-am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
-am__install_max = 40
-am__nobase_strip_setup = \
-  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
-am__nobase_strip = \
-  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
-am__nobase_list = $(am__nobase_strip_setup); \
-  for p in $$list; do echo "$$p $$p"; done | \
-  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
-  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
-    if (++n[$$2] == $(am__install_max)) \
-      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
-    END { for (dir in files) print dir, files[dir] }'
-am__base_list = \
-  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
-  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
-am__uninstall_files_from_dir = { \
-  test -z "$$files" \
-    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
-    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
-         $(am__cd) "$$dir" && rm -f $$files; }; \
-  }
-am__installdirs = "$(DESTDIR)$(pkgconfigdir)" \
-	"$(DESTDIR)$(includedir)"
-DATA = $(pkgconfig_DATA)
-HEADERS = $(include_HEADERS)
-RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
-  distclean-recursive maintainer-clean-recursive
-am__recursive_targets = \
-  $(RECURSIVE_TARGETS) \
-  $(RECURSIVE_CLEAN_TARGETS) \
-  $(am__extra_recursive_targets)
-AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
-	cscope distdir distdir-am dist dist-all distcheck
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-# Read a list of newline-separated strings from the standard input,
-# and print each of them once, without duplicates.  Input order is
-# *not* preserved.
-am__uniquify_input = $(AWK) '\
-  BEGIN { nonempty = 0; } \
-  { items[$$0] = 1; nonempty = 1; } \
-  END { if (nonempty) { for (i in items) print i; }; } \
-'
-# Make sure the list of sources is unique.  This is necessary because,
-# e.g., the same source file might be shared among _SOURCES variables
-# for different programs/libraries.
-am__define_uniq_tagged_files = \
-  list='$(am__tagged_files)'; \
-  unique=`for i in $$list; do \
-    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-  done | $(am__uniquify_input)`
-DIST_SUBDIRS = src tests docs example
-am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
-	$(srcdir)/libssh2.pc.in COPYING ChangeLog NEWS README compile \
-	config.guess config.rpath config.sub depcomp install-sh \
-	ltmain.sh missing
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-distdir = $(PACKAGE)-$(VERSION)
-top_distdir = $(distdir)
-am__remove_distdir = \
-  if test -d "$(distdir)"; then \
-    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
-      && rm -rf "$(distdir)" \
-      || { sleep 5 && rm -rf "$(distdir)"; }; \
-  else :; fi
-am__post_remove_distdir = $(am__remove_distdir)
-am__relativize = \
-  dir0=`pwd`; \
-  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
-  sed_rest='s,^[^/]*/*,,'; \
-  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
-  sed_butlast='s,/*[^/]*$$,,'; \
-  while test -n "$$dir1"; do \
-    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
-    if test "$$first" != "."; then \
-      if test "$$first" = ".."; then \
-        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
-        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
-      else \
-        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
-        if test "$$first2" = "$$first"; then \
-          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
-        else \
-          dir2="../$$dir2"; \
-        fi; \
-        dir0="$$dir0"/"$$first"; \
-      fi; \
-    fi; \
-    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
-  done; \
-  reldir="$$dir2"
-DIST_ARCHIVES = $(distdir).tar.gz
-GZIP_ENV = --best
-DIST_TARGETS = dist-gzip
-# Exists only to be overridden by the user if desired.
-AM_DISTCHECK_DVI_TARGET = dvi
-distuninstallcheck_listfiles = find . -type f -print
-am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
-  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
-distcleancheck_listfiles = find . -type f -print
-ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AR = @AR@
-AS = @AS@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CSCOPE = @CSCOPE@
-CTAGS = @CTAGS@
-CXX = @CXX@
-CXXCPP = @CXXCPP@
-CXXDEPMODE = @CXXDEPMODE@
-CXXFLAGS = @CXXFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-DLLTOOL = @DLLTOOL@
-DSYMUTIL = @DSYMUTIL@
-DUMPBIN = @DUMPBIN@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EGREP = @EGREP@
-ETAGS = @ETAGS@
-EXEEXT = @EXEEXT@
-FGREP = @FGREP@
-GREP = @GREP@
-HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
-HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
-HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
-HAVE_LIBSSL = @HAVE_LIBSSL@
-HAVE_LIBZ = @HAVE_LIBZ@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBBCRYPT = @LIBBCRYPT@
-LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
-LIBGCRYPT = @LIBGCRYPT@
-LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
-LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
-LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
-LIBSSL = @LIBSSL@
-LIBSSL_PREFIX = @LIBSSL_PREFIX@
-LIBTOOL = @LIBTOOL@
-LIBZ = @LIBZ@
-LIBZ_PREFIX = @LIBZ_PREFIX@
-LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
-LIPO = @LIPO@
-LN_S = @LN_S@
-LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
-LTLIBGCRYPT = @LTLIBGCRYPT@
-LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
-LTLIBOBJS = @LTLIBOBJS@
-LTLIBSSL = @LTLIBSSL@
-LTLIBZ = @LTLIBZ@
-LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MANIFEST_TOOL = @MANIFEST_TOOL@
-MKDIR_P = @MKDIR_P@
-NM = @NM@
-NMEDIT = @NMEDIT@
-OBJDUMP = @OBJDUMP@
-OBJEXT = @OBJEXT@
-OTOOL = @OTOOL@
-OTOOL64 = @OTOOL64@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-RANLIB = @RANLIB@
-SED = @SED@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-SSHD = @SSHD@
-STRIP = @STRIP@
-VERSION = @VERSION@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_AR = @ac_ct_AR@
-ac_ct_CC = @ac_ct_CC@
-ac_ct_CXX = @ac_ct_CXX@
-ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build = @build@
-build_alias = @build_alias@
-build_cpu = @build_cpu@
-build_os = @build_os@
-build_vendor = @build_vendor@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-docdir = @docdir@
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-host = @host@
-host_alias = @host_alias@
-host_cpu = @host_cpu@
-host_os = @host_os@
-host_vendor = @host_vendor@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-runstatedir = @runstatedir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-AUTOMAKE_OPTIONS = foreign nostdinc
-SUBDIRS = src tests docs $(am__append_1)
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libssh2.pc
-include_HEADERS = \
-	include/libssh2.h		\
-	include/libssh2_publickey.h	\
-	include/libssh2_sftp.h
-
-NETWAREFILES = nw/keepscreen.c \
-	nw/nwlib.c \
-	nw/GNUmakefile \
-	nw/test/GNUmakefile
-
-DSP = win32/libssh2.dsp
-VCPROJ = win32/libssh2.vcproj
-DISTCLEANFILES = $(DSP) ChangeLog
-VMSFILES = vms/libssh2_make_example.dcl vms/libssh2_make_help.dcl	\
-vms/libssh2_make_kit.dcl vms/libssh2_make_lib.dcl vms/man2help.c	\
-vms/readme.vms vms/libssh2_config.h
-
-WIN32FILES = win32/GNUmakefile win32/test/GNUmakefile		\
-win32/libssh2_config.h win32/config.mk win32/rules.mk		\
-win32/Makefile.Watcom win32/libssh2.dsw win32/tests.dsp $(DSP)	\
-win32/msvcproj.head win32/msvcproj.foot win32/libssh2.rc
-
-OS400FILES = os400/README400 os400/initscript.sh os400/make.sh		\
-os400/make-src.sh os400/make-rpg.sh os400/make-include.sh		\
-os400/os400sys.c os400/ccsid.c						\
-os400/libssh2_config.h os400/macros.h os400/libssh2_ccsid.h		\
-os400/include/alloca.h os400/include/sys/socket.h os400/include/stdio.h	\
-os400/libssh2rpg/libssh2.rpgle.in					\
-os400/libssh2rpg/libssh2_ccsid.rpgle.in					\
-os400/libssh2rpg/libssh2_publickey.rpgle				\
-os400/libssh2rpg/libssh2_sftp.rpgle					\
-Makefile.os400qc3.inc
-
-EXTRA_DIST = $(WIN32FILES) $(NETWAREFILES) get_ver.awk \
- maketgz NMakefile RELEASE-NOTES libssh2.pc.in $(VMSFILES) config.rpath \
- CMakeLists.txt cmake $(OS400FILES)
-
-ACLOCAL_AMFLAGS = -I m4
-
-# DSP/VCPROJ generation adapted from libcurl
-# only OpenSSL and WinCNG are supported with this build system
-CRYPTO_CSOURCES = openssl.c wincng.c mbedtls.c
-CRYPTO_HHEADERS = openssl.h wincng.h mbedtls.h
-CSOURCES = channel.c comp.c crypt.c hostkey.c kex.c mac.c misc.c \
- packet.c publickey.c scp.c session.c sftp.c userauth.c transport.c \
- version.c knownhost.c agent.c $(CRYPTO_CSOURCES) pem.c keepalive.c global.c \
- blowfish.c bcrypt_pbkdf.c agent_win.c
-
-HHEADERS = libssh2_priv.h $(CRYPTO_HHEADERS) transport.h channel.h comp.h \
- mac.h misc.h packet.h userauth.h session.h sftp.h crypto.h blf.h agent.h
-
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-WIN32SOURCES = $(CSOURCES)
-WIN32HEADERS = $(HHEADERS) libssh2_config.h
-all: all-recursive
-
-.SUFFIXES:
-am--refresh: Makefile
-	@:
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
-	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
-		&& exit 0; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    echo ' $(SHELL) ./config.status'; \
-	    $(SHELL) ./config.status;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
-	esac;
-$(srcdir)/Makefile.inc $(am__empty):
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	$(SHELL) ./config.status --recheck
-
-$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
-	$(am__cd) $(srcdir) && $(AUTOCONF)
-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
-	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
-$(am__aclocal_m4_deps):
-libssh2.pc: $(top_builddir)/config.status $(srcdir)/libssh2.pc.in
-	cd $(top_builddir) && $(SHELL) ./config.status $@
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-
-distclean-libtool:
-	-rm -f libtool config.lt
-install-pkgconfigDATA: $(pkgconfig_DATA)
-	@$(NORMAL_INSTALL)
-	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
-	if test -n "$$list"; then \
-	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
-	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
-	fi; \
-	for p in $$list; do \
-	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; \
-	done | $(am__base_list) | \
-	while read files; do \
-	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
-	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
-	done
-
-uninstall-pkgconfigDATA:
-	@$(NORMAL_UNINSTALL)
-	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
-	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
-	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
-install-includeHEADERS: $(include_HEADERS)
-	@$(NORMAL_INSTALL)
-	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
-	if test -n "$$list"; then \
-	  echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
-	  $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
-	fi; \
-	for p in $$list; do \
-	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; \
-	done | $(am__base_list) | \
-	while read files; do \
-	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
-	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
-	done
-
-uninstall-includeHEADERS:
-	@$(NORMAL_UNINSTALL)
-	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
-	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
-	dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)
-
-# This directory's subdirectories are mostly independent; you can cd
-# into them and run 'make' without going through this Makefile.
-# To change the values of 'make' variables: instead of editing Makefiles,
-# (1) if the variable is set in 'config.status', edit 'config.status'
-#     (which will cause the Makefiles to be regenerated when you run 'make');
-# (2) otherwise, pass the desired values on the 'make' command line.
-$(am__recursive_targets):
-	@fail=; \
-	if $(am__make_keepgoing); then \
-	  failcom='fail=yes'; \
-	else \
-	  failcom='exit 1'; \
-	fi; \
-	dot_seen=no; \
-	target=`echo $@ | sed s/-recursive//`; \
-	case "$@" in \
-	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
-	  *) list='$(SUBDIRS)' ;; \
-	esac; \
-	for subdir in $$list; do \
-	  echo "Making $$target in $$subdir"; \
-	  if test "$$subdir" = "."; then \
-	    dot_seen=yes; \
-	    local_target="$$target-am"; \
-	  else \
-	    local_target="$$target"; \
-	  fi; \
-	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
-	  || eval $$failcom; \
-	done; \
-	if test "$$dot_seen" = "no"; then \
-	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
-	fi; test -z "$$fail"
-
-ID: $(am__tagged_files)
-	$(am__define_uniq_tagged_files); mkid -fID $$unique
-tags: tags-recursive
-TAGS: tags
-
-tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	set x; \
-	here=`pwd`; \
-	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
-	  include_option=--etags-include; \
-	  empty_fix=.; \
-	else \
-	  include_option=--include; \
-	  empty_fix=; \
-	fi; \
-	list='$(SUBDIRS)'; for subdir in $$list; do \
-	  if test "$$subdir" = .; then :; else \
-	    test ! -f $$subdir/TAGS || \
-	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
-	  fi; \
-	done; \
-	$(am__define_uniq_tagged_files); \
-	shift; \
-	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
-	  test -n "$$unique" || unique=$$empty_fix; \
-	  if test $$# -gt 0; then \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      "$$@" $$unique; \
-	  else \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      $$unique; \
-	  fi; \
-	fi
-ctags: ctags-recursive
-
-CTAGS: ctags
-ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	$(am__define_uniq_tagged_files); \
-	test -z "$(CTAGS_ARGS)$$unique" \
-	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
-	     $$unique
-
-GTAGS:
-	here=`$(am__cd) $(top_builddir) && pwd` \
-	  && $(am__cd) $(top_srcdir) \
-	  && gtags -i $(GTAGS_ARGS) "$$here"
-cscope: cscope.files
-	test ! -s cscope.files \
-	  || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
-clean-cscope:
-	-rm -f cscope.files
-cscope.files: clean-cscope cscopelist
-cscopelist: cscopelist-recursive
-
-cscopelist-am: $(am__tagged_files)
-	list='$(am__tagged_files)'; \
-	case "$(srcdir)" in \
-	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
-	  *) sdir=$(subdir)/$(srcdir) ;; \
-	esac; \
-	for i in $$list; do \
-	  if test -f "$$i"; then \
-	    echo "$(subdir)/$$i"; \
-	  else \
-	    echo "$$sdir/$$i"; \
-	  fi; \
-	done >> $(top_builddir)/cscope.files
-
-distclean-tags:
-	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
-distdir: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
-	$(am__remove_distdir)
-	test -d "$(distdir)" || mkdir "$(distdir)"
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
-	  if test "$$subdir" = .; then :; else \
-	    $(am__make_dryrun) \
-	      || test -d "$(distdir)/$$subdir" \
-	      || $(MKDIR_P) "$(distdir)/$$subdir" \
-	      || exit 1; \
-	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
-	    $(am__relativize); \
-	    new_distdir=$$reldir; \
-	    dir1=$$subdir; dir2="$(top_distdir)"; \
-	    $(am__relativize); \
-	    new_top_distdir=$$reldir; \
-	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
-	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
-	    ($(am__cd) $$subdir && \
-	      $(MAKE) $(AM_MAKEFLAGS) \
-	        top_distdir="$$new_top_distdir" \
-	        distdir="$$new_distdir" \
-		am__remove_distdir=: \
-		am__skip_length_check=: \
-		am__skip_mode_fix=: \
-	        distdir) \
-	      || exit 1; \
-	  fi; \
-	done
-	$(MAKE) $(AM_MAKEFLAGS) \
-	  top_distdir="$(top_distdir)" distdir="$(distdir)" \
-	  dist-hook
-	-test -n "$(am__skip_mode_fix)" \
-	|| find "$(distdir)" -type d ! -perm -755 \
-		-exec chmod u+rwx,go+rx {} \; -o \
-	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
-	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
-	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
-	|| chmod -R a+r "$(distdir)"
-dist-gzip: distdir
-	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
-	$(am__post_remove_distdir)
-
-dist-bzip2: distdir
-	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
-	$(am__post_remove_distdir)
-
-dist-lzip: distdir
-	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
-	$(am__post_remove_distdir)
-
-dist-xz: distdir
-	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
-	$(am__post_remove_distdir)
-
-dist-zstd: distdir
-	tardir=$(distdir) && $(am__tar) | zstd -c $${ZSTD_CLEVEL-$${ZSTD_OPT--19}} >$(distdir).tar.zst
-	$(am__post_remove_distdir)
-
-dist-tarZ: distdir
-	@echo WARNING: "Support for distribution archives compressed with" \
-		       "legacy program 'compress' is deprecated." >&2
-	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
-	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
-	$(am__post_remove_distdir)
-
-dist-shar: distdir
-	@echo WARNING: "Support for shar distribution archives is" \
-	               "deprecated." >&2
-	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
-	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
-	$(am__post_remove_distdir)
-
-dist-zip: distdir
-	-rm -f $(distdir).zip
-	zip -rq $(distdir).zip $(distdir)
-	$(am__post_remove_distdir)
-
-dist dist-all:
-	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
-	$(am__post_remove_distdir)
-
-# This target untars the dist file and tries a VPATH configuration.  Then
-# it guarantees that the distribution is self-contained by making another
-# tarfile.
-distcheck: dist
-	case '$(DIST_ARCHIVES)' in \
-	*.tar.gz*) \
-	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
-	*.tar.bz2*) \
-	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
-	*.tar.lz*) \
-	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
-	*.tar.xz*) \
-	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
-	*.tar.Z*) \
-	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
-	*.shar.gz*) \
-	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
-	*.zip*) \
-	  unzip $(distdir).zip ;;\
-	*.tar.zst*) \
-	  zstd -dc $(distdir).tar.zst | $(am__untar) ;;\
-	esac
-	chmod -R a-w $(distdir)
-	chmod u+w $(distdir)
-	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
-	chmod a-w $(distdir)
-	test -d $(distdir)/_build || exit 0; \
-	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
-	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
-	  && am__cwd=`pwd` \
-	  && $(am__cd) $(distdir)/_build/sub \
-	  && ../../configure \
-	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
-	    $(DISTCHECK_CONFIGURE_FLAGS) \
-	    --srcdir=../.. --prefix="$$dc_install_base" \
-	  && $(MAKE) $(AM_MAKEFLAGS) \
-	  && $(MAKE) $(AM_MAKEFLAGS) $(AM_DISTCHECK_DVI_TARGET) \
-	  && $(MAKE) $(AM_MAKEFLAGS) check \
-	  && $(MAKE) $(AM_MAKEFLAGS) install \
-	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
-	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
-	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
-	        distuninstallcheck \
-	  && chmod -R a-w "$$dc_install_base" \
-	  && ({ \
-	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
-	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
-	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
-	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
-	  && rm -rf "$$dc_destdir" \
-	  && $(MAKE) $(AM_MAKEFLAGS) dist \
-	  && rm -rf $(DIST_ARCHIVES) \
-	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
-	  && cd "$$am__cwd" \
-	  || exit 1
-	$(am__post_remove_distdir)
-	@(echo "$(distdir) archives ready for distribution: "; \
-	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
-	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
-distuninstallcheck:
-	@test -n '$(distuninstallcheck_dir)' || { \
-	  echo 'ERROR: trying to run $@ with an empty' \
-	       '$$(distuninstallcheck_dir)' >&2; \
-	  exit 1; \
-	}; \
-	$(am__cd) '$(distuninstallcheck_dir)' || { \
-	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
-	  exit 1; \
-	}; \
-	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
-	   || { echo "ERROR: files left after uninstall:" ; \
-	        if test -n "$(DESTDIR)"; then \
-	          echo "  (check DESTDIR support)"; \
-	        fi ; \
-	        $(distuninstallcheck_listfiles) ; \
-	        exit 1; } >&2
-distcleancheck: distclean
-	@if test '$(srcdir)' = . ; then \
-	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
-	  exit 1 ; \
-	fi
-	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
-	  || { echo "ERROR: files left in build directory after distclean:" ; \
-	       $(distcleancheck_listfiles) ; \
-	       exit 1; } >&2
-check-am: all-am
-check: check-recursive
-all-am: Makefile $(DATA) $(HEADERS)
-installdirs: installdirs-recursive
-installdirs-am:
-	for dir in "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(includedir)"; do \
-	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
-	done
-install: install-recursive
-install-exec: install-exec-recursive
-install-data: install-data-recursive
-uninstall: uninstall-recursive
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-recursive
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-clean: clean-recursive
-
-clean-am: clean-generic clean-libtool mostlyclean-am
-
-distclean: distclean-recursive
-	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
-	-rm -f Makefile
-distclean-am: clean-am distclean-generic distclean-libtool \
-	distclean-tags
-
-dvi: dvi-recursive
-
-dvi-am:
-
-html: html-recursive
-
-html-am:
-
-info: info-recursive
-
-info-am:
-
-install-data-am: install-includeHEADERS install-pkgconfigDATA
-
-install-dvi: install-dvi-recursive
-
-install-dvi-am:
-
-install-exec-am:
-
-install-html: install-html-recursive
-
-install-html-am:
-
-install-info: install-info-recursive
-
-install-info-am:
-
-install-man:
-
-install-pdf: install-pdf-recursive
-
-install-pdf-am:
-
-install-ps: install-ps-recursive
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-recursive
-	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
-	-rm -rf $(top_srcdir)/autom4te.cache
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-recursive
-
-mostlyclean-am: mostlyclean-generic mostlyclean-libtool
-
-pdf: pdf-recursive
-
-pdf-am:
-
-ps: ps-recursive
-
-ps-am:
-
-uninstall-am: uninstall-includeHEADERS uninstall-pkgconfigDATA
-
-.MAKE: $(am__recursive_targets) install-am install-strip
-
-.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
-	am--refresh check check-am clean clean-cscope clean-generic \
-	clean-libtool cscope cscopelist-am ctags ctags-am dist \
-	dist-all dist-bzip2 dist-gzip dist-hook dist-lzip dist-shar \
-	dist-tarZ dist-xz dist-zip dist-zstd distcheck distclean \
-	distclean-generic distclean-libtool distclean-tags \
-	distcleancheck distdir distuninstallcheck dvi dvi-am html \
-	html-am info info-am install install-am install-data \
-	install-data-am install-dvi install-dvi-am install-exec \
-	install-exec-am install-html install-html-am \
-	install-includeHEADERS install-info install-info-am \
-	install-man install-pdf install-pdf-am install-pkgconfigDATA \
-	install-ps install-ps-am install-strip installcheck \
-	installcheck-am installdirs installdirs-am maintainer-clean \
-	maintainer-clean-generic mostlyclean mostlyclean-generic \
-	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
-	uninstall-am uninstall-includeHEADERS uninstall-pkgconfigDATA
-
-.PRECIOUS: Makefile
-
-
-.PHONY: ChangeLog
-ChangeLog:
-	echo "see NEWS" > ./ChangeLog
-
-dist-hook:
-	rm -rf $(top_builddir)/tests/log
-	find $(distdir) -name "*.dist" -exec rm {} \;
-	(distit=`find $(srcdir) -name "*.dist"`; \
-	for file in $$distit; do \
-	  strip=`echo $$file | sed -e s/^$(srcdir)// -e s/\.dist//`; \
-	  cp $$file $(distdir)$$strip; \
-	done)
-
-# Code Coverage
-
-init-coverage:
-	make clean
-	lcov --directory . --zerocounters
-
-COVERAGE_CCOPTS ?= "-g --coverage"
-COVERAGE_OUT ?= docs/coverage
-
-build-coverage:
-	make CFLAGS=$(COVERAGE_CCOPTS) check
-	mkdir -p $(COVERAGE_OUT)
-	lcov --directory . --output-file $(COVERAGE_OUT)/$(PACKAGE).info \
-		--capture
-
-gen-coverage:
-	genhtml --output-directory $(COVERAGE_OUT) \
-		$(COVERAGE_OUT)/$(PACKAGE).info \
-		--highlight --frames --legend \
-		--title "$(PACKAGE_NAME)"
-
-coverage: init-coverage build-coverage gen-coverage
-
-$(DSP): win32/msvcproj.head win32/msvcproj.foot Makefile.am
-	echo "creating $(DSP)"
-	@( (cat $(srcdir)/win32/msvcproj.head; \
-	echo "# Begin Group \"Source Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"cpp;c;cxx\""; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		echo "SOURCE=..\\src\\"$$file; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	echo "# Begin Group \"Header Files\""; \
-	echo ""; \
-	echo "# PROP Default_Filter \"h;hpp;hxx\""; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "# Begin Source File"; \
-		echo ""; \
-		if [ "$$file" = "libssh2_config.h" ]; \
-		then \
-			echo "SOURCE=.\\"$$file; \
-		else \
-			echo "SOURCE=..\\src\\"$$file; \
-		fi; \
-		echo "# End Source File"; \
-	done; \
-	echo "# End Group"; \
-	cat $(srcdir)/win32/msvcproj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-$(VCPROJ): win32/vc8proj.head win32/vc8proj.foot Makefile.am
-	echo "creating $(VCPROJ)"
-	@( (cat $(srcdir)/vc8proj.head; \
-	win32_srcs='$(WIN32SOURCES)'; \
-	sorted_srcs=`for file in $$win32_srcs; do echo $$file; done | sort`; \
-	for file in $$sorted_srcs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	echo "</Filter><Filter	Name=\"Header Files\">"; \
-	win32_hdrs='$(WIN32HEADERS)'; \
-	sorted_hdrs=`for file in $$win32_hdrs; do echo $$file; done | sort`; \
-	for file in $$sorted_hdrs; do \
-		echo "<File RelativePath=\""..\src\$$file"\"></File>"; \
-	done; \
-	cat $(srcdir)/vc8proj.foot) | \
-	awk '{printf("%s\r\n", gensub("\r", "", "g"))}' > $@ )
-
-checksrc:
-	perl src/checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF -ACOPYRIGHT \
-		-AFOPENMODE -Wsrc/libssh2_config.h src/*.[ch] include/*.h example/*.c \
-		tests/*.[ch]
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/libssh2/libssh2/Makefile.inc b/libssh2/libssh2/Makefile.inc
deleted file mode 100644
index 20d2ebee..00000000
--- a/libssh2/libssh2/Makefile.inc
+++ /dev/null
@@ -1,7 +0,0 @@
-CSOURCES = channel.c comp.c crypt.c hostkey.c kex.c mac.c misc.c \
- packet.c publickey.c scp.c session.c sftp.c userauth.c transport.c \
- version.c knownhost.c agent.c $(CRYPTO_CSOURCES) pem.c keepalive.c global.c \
- blowfish.c bcrypt_pbkdf.c agent_win.c
-
-HHEADERS = libssh2_priv.h $(CRYPTO_HHEADERS) transport.h channel.h comp.h \
- mac.h misc.h packet.h userauth.h session.h sftp.h crypto.h blf.h agent.h
diff --git a/libssh2/libssh2/Makefile.libgcrypt.inc b/libssh2/libssh2/Makefile.libgcrypt.inc
deleted file mode 100644
index 0a3aae9a..00000000
--- a/libssh2/libssh2/Makefile.libgcrypt.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = libgcrypt.c
-CRYPTO_HHEADERS = libgcrypt.h
-CRYPTO_LTLIBS = $(LTLIBGCRYPT)
diff --git a/libssh2/libssh2/Makefile.mbedTLS.inc b/libssh2/libssh2/Makefile.mbedTLS.inc
deleted file mode 100644
index b9f19fce..00000000
--- a/libssh2/libssh2/Makefile.mbedTLS.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-CRYPTO_CSOURCES = mbedtls.c
-CRYPTO_HHEADERS = mbedtls.h
-CRYPTO_LTLIBS = $(LTLIBMBEDCRYPTO)
diff --git a/libssh2/libssh2/Makefile.os400qc3.inc b/libssh2/libssh2/Makefile.os400qc3.inc
deleted file mode 100644
index e55094d9..00000000
--- a/libssh2/libssh2/Makefile.os400qc3.inc
+++ /dev/null
@@ -1,2 +0,0 @@
-CRYPTO_CSOURCES = os400qc3.c
-CRYPTO_HHEADERS = os400qc3.h
diff --git a/libssh2/libssh2/NEWS b/libssh2/libssh2/NEWS
deleted file mode 100644
index 7e22b3dd..00000000
--- a/libssh2/libssh2/NEWS
+++ /dev/null
@@ -1,6831 +0,0 @@
-   Changelog for the libssh2 project. Generated with git2news.pl
-
-Daniel Stenberg (29 Aug 2021)
-- [Will Cosgrove brought this change]
-
-  updated docs for 1.10.0 release
-
-Marc Hörsken (30 May 2021)
-- [Laurent Stacul brought this change]
-
-  [tests] Try several times to connect the ssh server
-  
-  Sometimes, as the OCI container is run in detached mode, it is possible
-  the actual server is not ready yet to handle SSH traffic. The goal of
-  this PR is to try several times (max 3). The mechanism is the same as
-  for the connection to the docker machine.
-
-- [Laurent Stacul brought this change]
-
-  Remove openssh_server container on test exit
-
-- [Laurent Stacul brought this change]
-
-  Allow the tests to run inside a container
-  
-  The current tests suite starts SSH server as OCI container. This commit
-  add the possibility to run the tests in a container provided that:
-  
-  * the docker client is installed builder container
-  * the host docker daemon unix socket has been mounted in the builder
-    container (with, if needed, the DOCKER_HOST environment variable
-    accordingly set, and the permission to write on this socket)
-  * the builder container is run on the default bridge network, or the
-    host network. This PR does not handle the case where the builder
-    container is on another network.
-
-Marc Hoersken (28 May 2021)
-- CI/appveyor: run SSH server for tests on GitHub Actions (#607)
-  
-  No longer rely on DigitalOcean to host the Docker container.
-  
-  Unfortunately we require a small dispatcher script that has
-  access to a GitHub access token with scope repo in order to
-  trigger the daemon workflow on GitHub Actions also for PRs.
-  
-  This script is hosted by myself for the time being until GitHub
-  provides a tighter scope to trigger the workflow_dispatch event.
-
-GitHub (26 May 2021)
-- [Will Cosgrove brought this change]
-
-  openssl.c: guards around calling FIPS_mode() #596 (#603)
-  
-  Notes:
-  FIPS_mode() is not implemented in LibreSSL and this API is removed in OpenSSL 3.0 and was introduced in 0.9.7. Added guards around making this call.
-  
-  Credit:
-  Will Cosgrove
-
-- [Will Cosgrove brought this change]
-
-  configure.ac: don't undefine scoped variable (#594)
-  
-  * configure.ac: don't undefine scoped variable
-  
-  To get this script to run with Autoconf 2.71 on macOS I had to remove the undefine of the backend for loop variable. It seems scoped to the for loop and also isn't referenced later in the script so it seems OK to remove it.
-  
-  * configure.ac: remove cygwin specific CFLAGS #598
-  
-  Notes:
-  Remove cygwin specific Win32 CFLAGS and treat the build like a posix build
-  
-  Credit:
-  Will Cosgrove, Brian Inglis
-
-- [Laurent Stacul brought this change]
-
-  tests: Makefile.am: Add missing tests client keys in distribution tarball (#604)
-  
-  Notes:
-  Added missing test keys.
-  
-  Credit:
-  Laurent Stacul
-
-- [Laurent Stacul brought this change]
-
-  Makefile.am: Add missing test keys in the distribution tarball (#601)
-  
-  Notes:
-  Fix tests missing key to build the OCI image
-  
-  Credit:
-  Laurent Stacul
-
-Daniel Stenberg (16 May 2021)
-- dist: add src/agent.h
-  
-  Fixes #597
-  Closes #599
-
-GitHub (12 May 2021)
-- [Will Cosgrove brought this change]
-
-  packet.c: Reset read timeout after received a packet (#576) (#586)
-  
-  File:
-  packet.c
-  
-  Notes:
-  Attempt keyboard interactive login (Azure AD 2FA login) and use more than 60 seconds to complete the login, the connection fails.
-  
-  The _libssh2_packet_require function does almost the same as _libssh2_packet_requirev but this function sets state->start = 0 before returning.
-  
-  Credit:
-  teottin, Co-authored-by: Tor Erik Ottinsen <tor.ottinsen@kdi.kongsberg.com>
-
-- [kkoenig brought this change]
-
-  Support ECDSA certificate authentication (#570)
-  
-  Files: hostkey.c, userauth.c, test_public_key_auth_succeeds_with_correct_ecdsa_key.c
-  
-  Notes:
-  Support ECDSA certificate authentication
-  
-  Add a test for:
-    - Existing ecdsa basic public key authentication
-    - ecdsa public key authentication with a signed public key
-  
-  Credit:
-  kkoenig
-
-- [Gabriel Smith brought this change]
-
-  agent.c: Add support for Windows OpenSSH agent (#517)
-  
-  Files: agent.c, agent.h, agent_win.c
-  
-  Notes:
-  * agent: Add support for Windows OpenSSH agent
-  
-  The implementation was partially taken and modified from that found in
-  the Portable OpenSSH port to Win32 by the PowerShell team, but mostly
-  based on the existing Unix OpenSSH agent support.
-  
-  https://github.com/PowerShell/openssh-portable
-  
-  Regarding the partial transfer support implementation: partial transfers
-  are easy to deal with, but you need to track additional state when
-  non-blocking IO enters the picture. A tracker of how many bytes have
-  been transfered has been placed in the transfer context struct as that's
-  where it makes most sense. This tracker isn't placed behind a WIN32
-   #ifdef as it will probably be useful for other agent implementations.
-  
-  * agent: win32 openssh: Disable overlapped IO
-  
-  Non-blocking IO is not currently supported by the surrounding agent
-  code, despite a lot of the code having everything set up to handle it.
-  
-  Credit:
-  Co-authored-by: Gabriel Smith <gabriel.smith@precisionot.com>
-
-- [Zenju brought this change]
-
-  Fix detailed _libssh2_error being overwritten (#473)
-  
-  Files: openssl.c, pem.c, userauth.c
-  
-  Notes:
-  * Fix detailed _libssh2_error being overwritten by generic errors
-  * Unified error handling
-  
-  Credit:
-  Zenju
-
-- [Paul Capron brought this change]
-
-  Fix _libssh2_random() silently discarding errors (#520)
-  
-  Notes:
-  * Make _libssh2_random return code consistent
-  
-  Previously, _libssh2_random was advertized in HACKING.CRYPTO as
-  returning `void` (and was implemented that way in os400qc3.c), but that
-  was in other crypto backends a lie; _libssh2_random is (a macro
-  expanding) to an int-value expression or function.
-  
-  Moreover, that returned code was:
-    — 0 or success, -1 on error for the MbedTLS & WinCNG crypto backends
-  But also:
-    — 1 on success, -1 or 0 on error for the OpenSSL backend!
-    – 1 on success, error cannot happen for libgcrypt!
-  
-  This commit makes explicit that _libssh2_random can fail (because most of
-  the underlying crypto functions can indeed fail!), and it makes its result
-  code consistent: 0 on success, -1 on error.
-  
-  This is related to issue #519 https://github.com/libssh2/libssh2/issues/519
-  It fixes the first half of it.
-  
-  * Don't silent errors of _libssh2_random
-  
-  Make sure to check the returned code of _libssh2_random(), and
-  propagates any failure.
-  
-  A new LIBSSH_ERROR_RANDGEN constant is added to libssh2.h
-  None of the existing error constants seemed fit.
-  
-  This commit is related to d74285b68450c0e9ea6d5f8070450837fb1e74a7
-  and to https://github.com/libssh2/libssh2/issues/519 (see the issue
-  for more info.)  It closes #519.
-  
-  Credit:
-  Paul Capron
-
-- [Gabriel Smith brought this change]
-
-  ci: Remove caching of docker image layers (#589)
-  
-  Notes:
-  continued ci reliability work.
-  
-  Credit:
-  Gabriel Smith
-
-- [Gabriel Smith brought this change]
-
-  ci: Speed up docker builds for tests (#587)
-  
-  Notes:
-  The OpenSSH server docker image used for tests is pre-built to prevent
-  wasting time building it during a test, and unneeded rebuilds are
-  prevented by caching the image layers.
-  
-  Credit:
-  Gabriel Smith
-
-- [Will Cosgrove brought this change]
-
-  userauth.c: don't error if using keys without RSA (#555)
-  
-  file: userauth.c
-  
-  notes: libssh2 now supports many other key types besides RSA, if the library is built without RSA support and a user attempts RSA auth it shouldn't be an automatic error
-  
-  credit:
-  Will Cosgrove
-
-- [Marc brought this change]
-
-  openssl.c: Avoid OpenSSL latent error in FIPS mode (#528)
-  
-  File:
-  openssl.c
-  
-  Notes:
-  Avoid initing MD5 digest, which is not permitted in OpenSSL FIPS certified cryptography mode.
-  
-  Credit:
-  Marc
-
-- [Laurent Stacul brought this change]
-
-  openssl.c: Fix EVP_Cipher interface change in openssl 3 #463
-  
-  File:
-  openssl.c
-  
-  Notes:
-  Fixes building with OpenSSL 3, #463.
-  
-  The change is described there:
-  https://github.com/openssl/openssl/commit/f7397f0d58ce7ddf4c5366cd1846f16b341fbe43
-  
-  Credit:
-  Laurent Stacul, reported by Sergei
-
-- [Gabriel Smith brought this change]
-
-  openssh_fixture.c: Fix potential overwrite of buffer when reading stdout of command (#580)
-  
-  File:
-  openssh_fixture.c
-  Notes:
-  If reading the full output from the executed command took multiple
-  passes (such as when reading multiple lines) the old code would read
-  into the buffer starting at the some position (the start) every time.
-  The old code only works if fgets updated p or had an offset parameter,
-  both of which are not true.
-  
-  Credit:
-  Gabriel Smith
-
-- [Gabriel Smith brought this change]
-
-  ci: explicitly state the default branch (#585)
-  
-  Notes:
-  It looks like the $default-branch macro only works in templates, not
-  workflows. This is not explicitly stated anywhere except the linked PR
-  comment.
-  
-  https://github.com/actions/starter-workflows/pull/590#issuecomment-672360634
-  
-  credit:
-  Gabriel Smith
-
-- [Gabriel Smith brought this change]
-
-  ci: Swap from Travis to Github Actions (#581)
-  
-  Files: ci files
-  
-  Notes:
-  Move Linux CI using Github Actions
-  
-  Credit:
-  Gabriel Smith, Marc Hörsken
-
-- [Mary brought this change]
-
-  libssh2_priv.h: add iovec on 3ds (#575)
-  
-  file: libssh2_priv.h
-  note: include iovec for 3DS
-  credit: Mary Mstrodl
-
-- [Laurent Stacul brought this change]
-
-  Tests: Fix unused variables warning (#561)
-  
-  file: test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
-  
-  notes: fixed unused vars
-  
-  credit:
-  Laurent Stacul
-
-- [Viktor Szakats brought this change]
-
-  bcrypt_pbkdf.c: fix clang10 false positive warning (#563)
-  
-  File: bcrypt_pbkdf.c
-  
-  Notes:
-  blf_enc() takes a number of 64-bit blocks to encrypt, but using
-  sizeof(uint64_t) in the calculation triggers a warning with
-  clang 10 because the actual data type is uint32_t. Pass
-  BCRYPT_BLOCKS / 2 for the number of blocks like libc bcrypt(3)
-  does.
-  
-  Ref: https://github.com/openbsd/src/commit/04a2240bd8f465bcae6b595d912af3e2965856de
-  
-  Fixes #562
-  
-  Credit:
-  Viktor Szakats
-
-- [Will Cosgrove brought this change]
-
-  transport.c: release payload on error (#554)
-  
-  file: transport.c
-  notes: If the payload is invalid and there is an early return, we could leak the payload
-  credit:
-  Will Cosgrove
-
-- [Will Cosgrove brought this change]
-
-  ssh2_client_fuzzer.cc: fixed building
-  
-  The GitHub web editor did some funky things
-
-- [Will Cosgrove brought this change]
-
-  ssh_client_fuzzer.cc: set blocking mode on (#553)
-  
-  file: ssh_client_fuzzer.cc
-  
-  notes: the session needs blocking mode turned on to avoid EAGAIN being returned from libssh2_session_handshake()
-  
-  credit:
-  Will Cosgrove, reviewed by Michael Buckley
-
-- [Etienne Samson brought this change]
-
-  Add a LINT option to CMake (#372)
-  
-  * ci: make style-checking available locally
-  
-  * cmake: add a linting target
-  
-  * tests: check test suite syntax with checksrc.pl
-
-- [Will Cosgrove brought this change]
-
-  kex.c: kex_agree_instr() improve string reading (#552)
-  
-  * kex.c: kex_agree_instr() improve string reading
-  
-  file: kex.c
-  notes: if haystack isn't null terminated we should use memchr() not strchar(). We should also make sure we don't walk off the end of the buffer.
-  credit:
-  Will Cosgrove, reviewed by Michael Buckley
-
-- [Will Cosgrove brought this change]
-
-  kex.c: use string_buf in ecdh_sha2_nistp (#551)
-  
-  * kex.c: use string_buf in ecdh_sha2_nistp
-  
-  file: kex.c
-  
-  notes:
-  use string_buf in ecdh_sha2_nistp() to avoid attempting to parse malformed data
-
-- [Will Cosgrove brought this change]
-
-  kex.c: move EC macro outside of if check #549 (#550)
-  
-  File: kex.c
-  
-  Notes:
-  Moved the macro LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY outside of the LIBSSH2_ECDSA since it's also now used by the ED25519 code.
-  
-  Sha 256, 384 and 512 need to be defined for all backends now even if they aren't used directly. I believe this is already the case, but just a heads up.
-  
-  Credit:
-  Stefan-Ghinea
-
-- [Tim Gates brought this change]
-
-  kex.c: fix simple typo, niumber -> number (#545)
-  
-  File: kex.c
-  
-  Notes:
-  There is a small typo in src/kex.c.
-  
-  Should read `number` rather than `niumber`.
-  
-  Credit:
-  Tim Gates
-
-- [Tseng Jun brought this change]
-
-  session.c: Correct a typo which may lead to stack overflow (#533)
-  
-  File: session.c
-  
-  Notes:
-  Seems the author intend to terminate banner_dup buffer, later, print it to the debug console.
-  
-  Author:
-  Tseng Jun
-
-Marc Hoersken (10 Oct 2020)
-- wincng: fix random big number generation to match openssl
-  
-  The old function would set the least significant bits in
-  the most significant byte instead of the most significant bits.
-  
-  The old function would also zero pad too much bits in the
-  most significant byte. This lead to a reduction of key space
-  in the most significant byte according to the following listing:
-  - 8 bits reduced to 0 bits => eg. 2048 bits to 2040 bits DH key
-  - 7 bits reduced to 1 bits => eg. 2047 bits to 2041 bits DH key
-  - 6 bits reduced to 2 bits => eg. 2046 bits to 2042 bits DH key
-  - 5 bits reduced to 3 bits => eg. 2045 bits to 2043 bits DH key
-  
-  No change would occur for the case of 4 significant bits.
-  For 1 to 3 significant bits in the most significant byte
-  the DH key would actually be expanded instead of reduced:
-  - 3 bits expanded to 5 bits => eg. 2043 bits to 2045 bits DH key
-  - 2 bits expanded to 6 bits => eg. 2042 bits to 2046 bits DH key
-  - 1 bits expanded to 7 bits => eg. 2041 bits to 2047 bits DH key
-  
-  There is no case of 0 significant bits in the most significant byte
-  since this would be a case of 8 significant bits in the next byte.
-  
-  At the moment only the following case applies due to a fixed
-  DH key size value currently being used in libssh2:
-  
-  The DH group_order is fixed to 256 (bytes) which leads to a
-  2047 bits DH key size by calculating (256 * 8) - 1.
-  
-  This means the DH keyspace was previously reduced from 2047 bits
-  to 2041 bits (while the top and bottom bits are always set), so the
-  keyspace is actually always reduced from 2045 bits to 2039 bits.
-  
-  All of this is only relevant for Windows versions supporting the
-  WinCNG backend (Vista or newer) before Windows 10 version 1903.
-  
-  Closes #521
-
-Daniel Stenberg (28 Sep 2020)
-- libssh2_session_callback_set.3: explain the recv/send callbacks
-  
-  Describe how to actually use these callbacks.
-  
-  Closes #518
-
-GitHub (23 Sep 2020)
-- [Will Cosgrove brought this change]
-
-  agent.c: formatting
-  
-  Improved formatting of RECV_SEND_ALL macro.
-
-- [Will Cosgrove brought this change]
-
-  CMakeLists.txt: respect install lib dir #405 (#515)
-  
-  Files:
-  CMakeLists.txt
-  
-  Notes:
-  Use CMAKE_INSTALL_LIBDIR directory
-  
-  Credit: Arfrever
-
-- [Will Cosgrove brought this change]
-
-  kex.c: group16-sha512 and group18-sha512 support #457 (#468)
-  
-  Files: kex.c
-  
-  Notes:
-  Added key exchange group16-sha512 and group18-sha512. As a result did the following:
-  
-  Abstracted diffie_hellman_sha256() to diffie_hellman_sha_algo() which is now algorithm agnostic and takes the algorithm as a parameter since we needed sha512 support. Unfortunately it required some helper functions but they are simple.
-  Deleted diffie_hellman_sha1()
-  Deleted diffie_hellman_sha1 specific macro
-  Cleaned up some formatting
-  Defined sha384 in os400 and wincng backends
-  Defined LIBSSH2_DH_MAX_MODULUS_BITS to abort the connection if we receive too large of p from the server doing sha1 key exchange.
-  Reorder the default key exchange list to match OpenSSH and improve security
-  
-  Credit:
-  Will Cosgrove
-
-- [Igor Klevanets brought this change]
-
-  agent.c: Recv and send all bytes via network in agent_transact_unix() (#510)
-  
-  Files: agent.c
-  
-  Notes:
-  Handle sending/receiving partial packet replies in agent.c API.
-  
-  Credit: Klevanets Igor <cerevra@yandex-team.ru>
-
-- [Daniel Stenberg brought this change]
-
-  Makefile.am: include all test files in the dist #379
-  
-  File:
-  Makefile.am
-  
-  Notes:
-  No longer conditionally include OpenSSL specific test files, they aren't run if we're not building against OpenSSL 1.1.x anyway.
-  
-  Credit:
-  Daniel Stenberg
-
-- [Max Dymond brought this change]
-
-  Add support for an OSS Fuzzer fuzzing target (#392)
-  
-  Files:
-  .travis.yml, configure.ac, ossfuzz
-  
-  Notes:
-  This adds support for an OSS-Fuzz fuzzing target in ssh2_client_fuzzer,
-  which is a cut down example of ssh2.c. Future enhancements can improve
-  coverage.
-  
-  Credit:
-  Max Dymond
-
-- [Sebastián Katzer brought this change]
-
-  mbedtls.c: ECDSA support for mbed TLS (#385)
-  
-  Files:
-  mbedtls.c, mbedtls.h, .travis.yml
-  
-  Notes:
-  This PR adds support for ECDSA for both key exchange and host key algorithms.
-  
-  The following elliptic curves are supported:
-  
-  256-bit curve defined by FIPS 186-4 and SEC1
-  384-bit curve defined by FIPS 186-4 and SEC1
-  521-bit curve defined by FIPS 186-4 and SEC1
-  
-  Credit:
-  Sebastián Katzer
-
-Marc Hoersken (1 Sep 2020)
-- buildconf: exec autoreconf to avoid additional process (#512)
-  
-  Also make buildconf exit with the return code of autoreconf.
-  
-  Follow up to #224
-
-- scp.c: fix indentation in shell_quotearg documentation
-
-- wincng: make more use of new helper functions (#496)
-
-- wincng: make sure algorithm providers are closed once (#496)
-
-GitHub (10 Jul 2020)
-- [David Benjamin brought this change]
-
-  openssl.c: clean up curve25519 code (#499)
-  
-  File: openssl.c, openssl.h, crypto.h, kex.c
-  
-  Notes:
-  This cleans up a few things in the curve25519 implementation:
-  
-  - There is no need to create X509_PUBKEYs or PKCS8_PRIV_KEY_INFOs to
-    extract key material. EVP_PKEY_get_raw_private_key and
-    EVP_PKEY_get_raw_public_key work fine.
-  
-  - libssh2_x25519_ctx was never used (and occasionally mis-typedefed to
-    libssh2_ed25519_ctx). Remove it. The _libssh2_curve25519_new and
-    _libssh2_curve25519_gen_k interfaces use the bytes. Note, if it needs
-    to be added back, there is no need to roundtrip through
-    EVP_PKEY_new_raw_private_key. EVP_PKEY_keygen already generated an
-    EVP_PKEY.
-  
-  - Add some missing error checks.
-  
-  Credit:
-  David Benjamin
-
-- [Will Cosgrove brought this change]
-
-  transport.c: socket is disconnected, return error (#500)
-  
-  File: transport.c
-  
-  Notes:
-  This is to fix #102, instead of continuing to attempt to read a disconnected socket, it will now error out.
-  
-  Credit:
-  TDi-jonesds
-
-- [Will Cosgrove brought this change]
-
-  stale.yml
-  
-  Increasing stale values.
-
-Marc Hoersken (6 Jul 2020)
-- wincng: try newer DH API first, fallback to legacy RSA API
-  
-  Avoid the use of RtlGetVersion or similar Win32 functions,
-  since these depend on version information from manifests.
-  
-  This commit makes the WinCNG backend first try to use the
-  new DH algorithm API with the raw secret derivation feature.
-  In case this feature is not available the WinCNG backend
-  will fallback to the classic approach of using RSA-encrypt
-  to perform the required modular exponentiation of BigNums.
-  
-  The feature availability test is done during the first handshake
-  and the result is stored in the crypto backends global state.
-  
-  Follow up to #397
-  Closes #484
-
-- wincng: fix indentation of function arguments and comments
-  
-  Follow up to #397
-
-- [Wez Furlong brought this change]
-
-  wincng: use newer DH API for Windows 8.1+
-  
-  Since Windows 1903 the approach used to perform DH kex with the CNG
-  API has been failing.
-  
-  This commit switches to using the `DH` algorithm provider to perform
-  generation of the key pair and derivation of the shared secret.
-  
-  It uses a feature of CNG that is not yet documented.  The sources of
-  information that I've found on this are:
-  
-  * https://stackoverflow.com/a/56378698/149111
-  * https://github.com/wbenny/mini-tor/blob/5d39011e632be8e2b6b1819ee7295e8bd9b7a769/mini/crypto/cng/dh.inl#L355
-  
-  With this change I am able to successfully connect from Windows 10 to my
-  ubuntu system.
-  
-  Refs: https://github.com/alexcrichton/ssh2-rs/issues/122
-  Fixes: https://github.com/libssh2/libssh2/issues/388
-  Closes: https://github.com/libssh2/libssh2/pull/397
-
-GitHub (1 Jul 2020)
-- [Zenju brought this change]
-
-  comp.c: Fix name clash with ZLIB macro "compress" (#418)
-  
-  File: comp.c
-  
-  Notes:
-  * Fix name clash with ZLIB macro "compress".
-  
-  Credit:
-  Zenju
-
-- [yann-morin-1998 brought this change]
-
-  buildsystem: drop custom buildconf script, rely on autoreconf (#224)
-  
-  Notes:
-  The buildconf script is currently required, because we need to copy a
-  header around, because it is used both from the library and the examples
-  sources.
-  
-  However, having a custom 'buildconf'-like script is not needed if we can
-  ensure that the header exists by the time it is needed. For that, we can
-  just append the src/ directory to the headers search path for the
-  examples.
-  
-  And then it means we no longer need to generate the same header twice,
-  so we remove the second one from configure.ac.
-  
-  Now, we can just call "autoreconf -fi" to generate the autotools files,
-  instead of relying on the canned sequence in "buildconf", since
-  autoreconf has now long known what to do at the correct moment (future
-  versions of autotools, automake, autopoint, autoheader etc... may
-  require an other ordering, or other intermediate steps, etc...).
-  
-  Eventually, get rid of buildconf now it is no longer needed. In fact, we
-  really keep it for legacy, but have it just call autoreconf (and print a
-  nice user-friendly warning). Don't include it in the release tarballs,
-  though.
-  
-  Update doc, gitignore, and travis-CI jobs accordingly.
-  
-  Credit:
-  Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
-  Cc: Sam Voss <sam.voss@rockwellcollins.com>
-
-- [Will Cosgrove brought this change]
-
-  libssh2.h: Update Diffie Hellman group values (#493)
-  
-  File: libssh2.h
-  
-  Notes:
-  Update the min, preferred and max DH group values based on RFC 8270.
-  
-  Credit:
-  Will Cosgrove, noted from email list by Mitchell Holland
-
-Marc Hoersken (22 Jun 2020)
-- travis: use existing Makefile target to run checksrc
-
-- Makefile: also run checksrc on test source files
-
-- tests: avoid use of deprecated function _sleep (#490)
-
-- tests: avoid use of banned function strncat (#489)
-
-- tests: satisfy checksrc regarding max line length of 79 chars
-  
-  Follow up to 2764bc8e06d51876b6796d6080c6ac51e20f3332
-
-- tests: satisfy checksrc with whitespace only fixes
-  
-  checksrc.pl -i4 -m79 -ASIZEOFNOPAREN -ASNPRINTF
-              -ACOPYRIGHT -AFOPENMODE tests/*.[ch]
-
-- tests: add support for ports published via Docker for Windows
-
-- tests: restore retry behaviour for docker-machine ip command
-
-- tests: fix mix of declarations and code failing C89 compliance
-
-- wincng: add and improve checks in bit counting function
-
-- wincng: align bits to bytes calculation in all functions
-
-- wincng: do not disable key validation that can be enabled
-  
-  The modular exponentiation also works with key validation enabled.
-
-- wincng: fix return value in _libssh2_dh_secret
-  
-  Do not ignore return value of modular exponentiation.
-
-- appveyor: build and run tests for WinCNG crypto backend
-
-GitHub (1 Jun 2020)
-- [suryakalpo brought this change]
-
-  INSTALL_CMAKE.md: Update formatting (#481)
-  
-  File: INSTALL_CMAKE.md
-  
-  Notes:
-  Although the original text would be immediately clear to seasoned users of CMAKE and/or Unix shell, the lack of newlines may cause some confusion for newcomers. Hence, wrapping the texts in a md code-block such that the newlines appear as intended.
-  
-  credit:
-  suryakalpo
-
-Marc Hoersken (31 May 2020)
-- src: add new and align include guards in header files (#480)
-  
-  Make sure all include guards exist and follow the same format.
-
-- wincng: fix multiple definition of `_libssh2_wincng' (#479)
-  
-  Add missing include guard and move global state
-  from header to source file by using extern.
-
-GitHub (28 May 2020)
-- [Will Cosgrove brought this change]
-
-  transport.c: moving total_num check from #476 (#478)
-  
-  file: transport.c
-  
-  notes:
-  moving total_num zero length check from #476 up to the prior bounds check which already includes a total_num check. Makes it slightly more readable.
-  
-  credit:
-  Will Cosgrove
-
-- [lutianxiong brought this change]
-
-  transport.c: fix use-of-uninitialized-value (#476)
-  
-  file:transport.c
-  
-  notes:
-  return error if malloc(0)
-  
-  credit:
-  lutianxiong
-
-- [Dr. Koutheir Attouchi brought this change]
-
-  libssh2_sftp.h: Changed type of LIBSSH2_FX_* constants to unsigned long, fixes #474
-  
-  File:
-  libssh2_sftp.h
-  
-  Notes:
-  Error constants `LIBSSH2_FX_*` are only returned by `libssh2_sftp_last_error()` which returns `unsigned long`.
-  Therefore these constants should be defined as unsigned long literals, instead of int literals.
-  
-  Credit:
-  Dr. Koutheir Attouchi
-
-- [monnerat brought this change]
-
-  os400qc3.c: constify libssh2_os400qc3_hash_update() data parameter. (#469)
-  
-  Files: os400qc3.c, os400qc3.h
-  
-  Notes:
-  Fixes building on OS400. #426
-  
-  Credit:
-  Reported-by: hjindra on github, dev by Monnerat
-
-- [monnerat brought this change]
-
-  HACKING.CRYPTO: keep up to date with new crypto definitions from code. (#466)
-  
-  File: HACKING.CRYPTO
-  
-  Notes:
-  This commit updates the HACKING.CRYPTO documentation file in an attempt to make it in sync with current code.
-  New documented features are:
-  
-  SHA384
-  SHA512
-  ECDSA
-  ED25519
-  
-  Credit:
-  monnerat
-
-- [Harry Sintonen brought this change]
-
-  kex.c: Add diffie-hellman-group14-sha256 Key Exchange Method (#464)
-  
-  File: kex.c
-  
-  Notes: Added diffie-hellman-group14-sha256 kex
-  
-  Credit: Harry Sintonen <sintonen@iki.fi>
-
-- [Will Cosgrove brought this change]
-
-  os400qc3.h: define sha512 macros (#465)
-  
-  file: os400qc3.h
-  notes: fixes for building libssh2 1.9.x
-
-- [Will Cosgrove brought this change]
-
-  os400qc3.h: define EC types to fix building #426 (#462)
-  
-  File: os400qc3.h
-  Notes: define missing EC types which prevents building
-  Credit: hjindra
-
-- [Brendan Shanks brought this change]
-
-  hostkey.c: Fix 'unsigned int'/'uint32_t' mismatch (#461)
-  
-  File: hostkey.c
-  
-  Notes:
-  These types are the same size so most compilers are fine with it, but CodeWarrior (on classic MacOS) throws an ‘illegal implicit conversion’ error
-  
-  Credit: Brendan Shanks
-
-- [Thomas Klausner brought this change]
-
-  Makefile.am: Fix unportable test(1) operator. (#459)
-  
-  file: Makefile.am
-  
-  Notes:
-  The POSIX comparison operator for test(1) is =; bash supports == but not even test from GNU coreutils does.
-  
-  Credit:
-  Thomas Klausner
-
-- [Tseng Jun brought this change]
-
-  openssl.c: minor changes of coding style (#454)
-  
-  File: openssl.c
-  
-  Notes:
-  minor changes of coding style and align preprocessor conditional for #439
-  
-  Credit:
-  Tseng Jun
-
-- [Hans Meier brought this change]
-
-  openssl.c: Fix for use of uninitialized aes_ctr_cipher.key_len (#453)
-  
-  File:
-  Openssl.c
-  
-  Notes:
-  * Fix for use of uninitialized aes_ctr_cipher.key_len when using HAVE_OPAQUE_STRUCTS, regression from #439
-  
-  Credit:
-  Hans Meirer, Tseng Jun
-
-- [Zenju brought this change]
-
-  agent.c: Fix Unicode builds on Windows (#417)
-  
-  File: agent.c
-  
-  Notes:
-  Fixes unicode builds for Windows in Visual Studio 16.3.2.
-  
-  Credit:
-  Zenju
-
-- [Hans Meier brought this change]
-
-  openssl.c: Fix use-after-free crash in openssl backend without memory leak (#439)
-  
-  Files: openssl.c
-  
-  Notes:
-  Fixes memory leaks and use after free AES EVP_CIPHER contexts when using OpenSSL 1.0.x.
-  
-  Credit:
-  Hans Meier
-
-- [Romain Geissler @ Amadeus brought this change]
-
-  Session.c: Fix undefined warning when mixing with LTO-enabled libcurl. (#449)
-  
-  File: Session.c
-  
-  Notes:
-  With gcc 9, libssh2, libcurl and LTO enabled for all binaries I see this
-  warning (error with -Werror):
-  
-  vssh/libssh2.c: In function ‘ssh_statemach_act’:
-  /data/mwrep/rgeissler/ospack/ssh2/BUILD/libssh2-libssh2-03c7c4a/src/session.c:579:9: error: ‘seconds_to_next’ is used uninitialized in this function [-Werror=uninitialized]
-    579 |     int seconds_to_next;
-        |         ^
-  lto1: all warnings being treated as errors
-  
-  Gcc normally issues -Wuninitialized when it is sure there is a problem,
-  and -Wmaybe-uninitialized when it's not sure, but it's possible. Here
-  the compiler seems to have find a real case where this could happen. I
-  looked in your code and overall it seems you always check if the return
-  code is non null, not often that it's below zero. I think we should do
-  the same here. With this patch, gcc is fine.
-  
-  Credit:
-  Romain-Geissler-1A
-
-- [Zenju brought this change]
-
-  transport.c: Fix crash with delayed compression (#443)
-  
-  Files: transport.c
-  
-  Notes:
-  Fixes crash with delayed compression option using Bitvise server.
-  
-  Contributor:
-  Zenju
-
-- [Will Cosgrove brought this change]
-
-  Update INSTALL_MAKE path to INSTALL_MAKE.md (#446)
-  
-  Included for #429
-
-- [Will Cosgrove brought this change]
-
-  Update INSTALL_CMAKE filename to INSTALL_CMAKE.md (#445)
-  
-  Fixing for #429
-
-- [Wallace Souza brought this change]
-
-  Rename INSTALL_CMAKE to INTALL_CMAKE.md (#429)
-  
-  Adding Markdown file extension in order to Github render the instructions properly
-
-Will Cosgrove (17 Dec 2019)
-- [Daniel Stenberg brought this change]
-
-  include/libssh2.h: fix comment: the known host key uses 4 bits (#438)
-
-- [Zenju brought this change]
-
-  ssh-ed25519: Support PKIX + calc pubkey from private (#416)
-  
-  Files: openssl.c/h
-  Author: Zenju
-  Notes:
-  Adds support for PKIX key reading by fixing:
-  
-  _libssh2_pub_priv_keyfile() is missing the code to extract the ed25519 public key from a given private key
-  
-  _libssh2_ed25519_new_private_frommemory is only parsing the openssh key format but does not understand PKIX (as retrieved via PEM_read_bio_PrivateKey)
-
-GitHub (15 Oct 2019)
-- [Will Cosgrove brought this change]
-
-  .travis.yml: Fix Chrome and 32 bit builds (#423)
-  
-  File: .travis.yml
-  
-  Notes:
-  * Fix Chrome installing by using Travis build in directive
-  * Update to use libgcrypt20-dev package to fix 32 bit builds based on comments found here:
-  https://launchpad.net/ubuntu/xenial/i386/libgcrypt11-dev
-
-- [Will Cosgrove brought this change]
-
-  packet.c: improved parsing in packet_x11_open (#410)
-  
-  Use new API to parse data in packet_x11_open() for better bounds checking.
-
-Will Cosgrove (12 Sep 2019)
-- [Michael Buckley brought this change]
-
-  knownhost.c: Double the static buffer size when reading and writing known hosts (#409)
-  
-  Notes:
-  We had a user who was being repeatedly prompted to accept a server key repeatedly. It turns out the base64-encoded key was larger than the static buffers allocated to read and write known hosts. I doubled the size of these buffers.
-  
-  Credit:
-  Michael Buckley
-
-GitHub (4 Sep 2019)
-- [Will Cosgrove brought this change]
-
-  packet.c: improved packet parsing in packet_queue_listener (#404)
-  
-  * improved bounds checking in packet_queue_listener
-  
-  file: packet.c
-  
-  notes:
-  improved parsing packet in packet_queue_listener
-
-- [Will Cosgrove brought this change]
-
-  packet.c: improve message parsing (#402)
-  
-  * packet.c: improve parsing of packets
-  
-  file: packet.c
-  
-  notes:
-  Use _libssh2_get_string API in SSH_MSG_DEBUG/SSH_MSG_DISCONNECT. Additional uint32 bounds check in SSH_MSG_GLOBAL_REQUEST.
-
-- [Will Cosgrove brought this change]
-
-  misc.c: _libssh2_ntohu32 cast bit shifting (#401)
-  
-  To quite overly aggressive analyzers.
-  
-  Note, the builds pass, Travis is having some issues with Docker images.
-
-- [Will Cosgrove brought this change]
-
-  kex.c: improve bounds checking in kex_agree_methods() (#399)
-  
-  file: kex.c
-  
-  notes:
-  use _libssh2_get_string instead of kex_string_pair which does additional checks
-
-Will Cosgrove (23 Aug 2019)
-- [Fabrice Fontaine brought this change]
-
-  acinclude.m4: add mbedtls to LIBS (#371)
-  
-  Notes:
-  This is useful for static builds so that the Libs.private field in
-  libssh2.pc contains correct info for the benefit of pkg-config users.
-  Static link with libssh2 requires this information.
-  
-  Signed-off-by: Baruch Siach <baruch@tkos.co.il>
-  [Retrieved from:
-  https://git.buildroot.net/buildroot/tree/package/libssh2/0002-acinclude.m4-add-mbedtls-to-LIBS.patch]
-  Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
-  
-  Credit:
-  Fabrice Fontaine
-
-- [jethrogb brought this change]
-
-  Generate debug info when building with MSVC (#178)
-  
-  files: CMakeLists.txt
-  
-  notes: Generate debug info when building with MSVC
-  
-  credit:
-  jethrogb
-
-- [Panos brought this change]
-
-  Add agent forwarding implementation (#219)
-  
-  files: channel.c, test_agent_forward_succeeds.c, libssh2_priv.h, libssh2.h, ssh2_agent_forwarding.c
-  
-  notes:
-  * Adding SSH agent forwarding.
-  * Fix agent forwarding message, updated example.
-  Added integration test code and cmake target. Added example to cmake list.
-  
-  credit:
-  pkittenis
-
-GitHub (2 Aug 2019)
-- [Will Cosgrove brought this change]
-
-  Update EditorConfig
-  
-  Added max_line_length = 80
-
-- [Will Cosgrove brought this change]
-
-  global.c : fixed call to libssh2_crypto_exit #394 (#396)
-  
-  * global.c : fixed call to libssh2_crypto_exit #394
-  
-  File: global.c
-  
-  Notes: Don't call `libssh2_crypto_exit()` until `_libssh2_initialized` count is down to zero.
-  
-  Credit: seba30
-
-Will Cosgrove (30 Jul 2019)
-- [hlefebvre brought this change]
-
-  misc.c : Add an EWOULDBLOCK check for better portability (#172)
-  
-  File: misc.c
-  
-  Notes: Added support for all OS' that implement EWOULDBLOCK, not only VMS
-  
-  Credit: hlefebvre
-
-- [Etienne Samson brought this change]
-
-  userauth.c: fix off by one error when loading public keys with no id (#386)
-  
-  File: userauth.c
-  
-  Credit:
-  Etienne Samson
-  
-  Notes:
-  Caught by ASAN:
-  
-  =================================================================
-  ==73797==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60700001bcf0 at pc 0x00010026198d bp 0x7ffeefbfed30 sp 0x7ffeefbfe4d8
-  READ of size 69 at 0x60700001bcf0 thread T0
-  2019-07-04 08:35:30.292502+0200 atos[73890:2639175] examining /Users/USER/*/libssh2_clar [73797]
-      #0 0x10026198c in wrap_memchr (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c)
-      #1 0x1000f8e66 in file_read_publickey userauth.c:633
-      #2 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
-      #3 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
-      #4 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
-      #5 0x1000090c3 in clar_run_test clar.c:260
-      #6 0x1000038f3 in clar_run_suite clar.c:343
-      #7 0x100003272 in clar_test_run clar.c:522
-      #8 0x10000c3cc in main runner.c:60
-      #9 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
-  
-  0x60700001bcf0 is located 0 bytes to the right of 80-byte region [0x60700001bca0,0x60700001bcf0)
-  allocated by thread T0 here:
-      #0 0x10029e053 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5c053)
-      #1 0x1000b4978 in libssh2_default_alloc session.c:67
-      #2 0x1000f8aba in file_read_publickey userauth.c:597
-      #3 0x1000f2dc9 in userauth_publickey_fromfile userauth.c:1513
-      #4 0x1000f2948 in libssh2_userauth_publickey_fromfile_ex userauth.c:1590
-      #5 0x10000e254 in test_userauth_publickey__ed25519_auth_ok publickey.c:69
-      #6 0x1000090c3 in clar_run_test clar.c:260
-      #7 0x1000038f3 in clar_run_suite clar.c:343
-      #8 0x100003272 in clar_test_run clar.c:522
-      #9 0x10000c3cc in main runner.c:60
-      #10 0x7fff5b43b3d4 in start (libdyld.dylib:x86_64+0x163d4)
-  
-  SUMMARY: AddressSanitizer: heap-buffer-overflow (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x1f98c) in wrap_memchr
-  Shadow bytes around the buggy address:
-    0x1c0e00003740: fd fd fd fd fd fd fd fd fd fd fa fa fa fa fd fd
-    0x1c0e00003750: fd fd fd fd fd fd fd fa fa fa fa fa 00 00 00 00
-    0x1c0e00003760: 00 00 00 00 00 00 fa fa fa fa 00 00 00 00 00 00
-    0x1c0e00003770: 00 00 00 fa fa fa fa fa fd fd fd fd fd fd fd fd
-    0x1c0e00003780: fd fd fa fa fa fa fd fd fd fd fd fd fd fd fd fa
-  =>0x1c0e00003790: fa fa fa fa 00 00 00 00 00 00 00 00 00 00[fa]fa
-    0x1c0e000037a0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-    0x1c0e000037e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
-  Shadow byte legend (one shadow byte represents 8 application bytes):
-    Addressable:           00
-    Partially addressable: 01 02 03 04 05 06 07
-    Heap left redzone:       fa
-    Freed heap region:       fd
-    Stack left redzone:      f1
-    Stack mid redzone:       f2
-    Stack right redzone:     f3
-    Stack after return:      f5
-    Stack use after scope:   f8
-    Global redzone:          f9
-    Global init order:       f6
-    Poisoned by user:        f7
-    Container overflow:      fc
-    Array cookie:            ac
-    Intra object redzone:    bb
-    ASan internal:           fe
-    Left alloca redzone:     ca
-    Right alloca redzone:    cb
-    Shadow gap:              cc
-
-- [Thilo Schulz brought this change]
-
-  openssl.c : Fix use-after-free crash on reinitialization of openssl backend
-  
-  file : openssl.c
-  
-  notes :
-  libssh2's openssl backend has a use-after-free condition if HAVE_OPAQUE_STRUCTS is defined and you call libssh2_init() again after prior initialisation/deinitialisation of libssh2
-  
-  credit : Thilo Schulz
-
-- [axjowa brought this change]
-
-  openssl.h : Use of ifdef where if should be used (#389)
-  
-  File : openssl.h
-  
-  Notes :
-  LIBSSH2_ECDSA and LIBSSH2_ED25519 are always defined so the #ifdef
-  checks would never be false.
-  
-  This change makes it possible to build libssh2 against OpenSSL built
-  without EC support.
-  
-  Change-Id: I0a2f07c2d80178314dcb7d505d1295d19cf15afd
-  
-  Credit : axjowa
-
-- [Zenju brought this change]
-
-  Agent.c : Preserve error info from agent_list_identities() (#374)
-  
-  Files : agent.c
-  
-  Notes :
-  Currently the error details as returned by agent_transact_pageant() are overwritten by a generic "agent list id failed" message by int agent_list_identities(LIBSSH2_AGENT* agent).
-  
-  Credit :
-  Zenju
-
-- [Who? Me?! brought this change]
-
-  Channel.c: Make sure the error code is set in _libssh2_channel_open() (#381)
-  
-  File : Channel.c
-  
-  Notes :
-  if _libssh2_channel_open() fails, set the error code.
-  
-  Credit :
-  mark-i-m
-
-- [Orgad Shaneh brought this change]
-
-  Kex.c, Remove unneeded call to strlen (#373)
-  
-  File : Kex.c
-  
-  Notes :
-  Removed call to strlen
-  
-  Credit :
-  Orgad Shaneh
-
-- [Pedro Monreal brought this change]
-
-  Spelling corrections (#380)
-  
-  Files :
-  libssh2.h, libssh2_sftp.h, bcrypt_pbkdf.c, mbedtls.c, sftp.c, ssh2.c
-  
-  Notes :
-  * Fixed misspellings
-  
-  Credit :
-  Pedro Monreal
-
-- [Sebastián Katzer brought this change]
-
-  Fix Potential typecast error for `_libssh2_ecdsa_key_get_curve_type` (#383)
-  
-  Issue : #383
-  
-  Files : hostkey.c, crypto.h, openssl.c
-  
-  Notes :
-  * Fix potential typecast error for `_libssh2_ecdsa_key_get_curve_type`
-  * Rename _libssh2_ecdsa_key_get_curve_type to _libssh2_ecdsa_get_curve_type
-  
-  Credit :
-  Sebastián Katzer
-
-GitHub (20 Jun 2019)
-- [Will Cosgrove brought this change]
-
-  bump copyright date
-
-Version 1.9.0 (19 Jun 2019)
-
-GitHub (19 Jun 2019)
-- [Will Cosgrove brought this change]
-
-  1.9 Formatting
-
-- [Will Cosgrove brought this change]
-
-  1.9 Release notes
-
-Will Cosgrove (17 May 2019)
-- [Alexander Curtiss brought this change]
-
-  libgcrypt.c : Fixed _libssh2_rsa_sha1_sign memory leak. (#370)
-  
-  File: libgcrypt.c
-  
-  Notes : Added calls to gcry_sexp_release to free memory allocated by gcry_sexp_find_token
-  
-  Credit :
-  Reporter : beckmi
-  PR by: Alexander Curtiss
-
-- [Orivej Desh brought this change]
-
-  libssh2_priv.h : Fix musl build warning on sys/poll.h (#346)
-  
-  File : libssh2_priv.h
-  
-  Notes :
-  musl prints `redirecting incorrect #include <sys/poll.h> to <poll.h>`
-  http://git.musl-libc.org/cgit/musl/commit/include/sys/poll.h?id=54446d730cfb17c5f7bcf57f139458678f5066cc
-  
-  poll is defined by POSIX to be in poll.h:
-  http://pubs.opengroup.org/onlinepubs/7908799/xsh/poll.html
-  
-  Credit : Orivej Desh
-
-GitHub (1 May 2019)
-- [Will Cosgrove brought this change]
-
-  kex.c : additional bounds checks in diffie_hellman_sha1/256 (#361)
-  
-  Files : kex.c, misc.c, misc.h
-  
-  Notes :
-  Fixed possible out of bounds memory access when reading malformed data in diffie_hellman_sha1() and diffie_hellman_sha256().
-  
-  Added _libssh2_copy_string() to misc.c to return an allocated and filled char buffer from a string_buf offset. Removed no longer needed s var in kmdhgGPshakex_state_t.
-
-Will Cosgrove (26 Apr 2019)
-- [Tseng Jun brought this change]
-
-  sftp.c : sftp_bin2attr() Correct attrs->gid assignment (#366)
-  
-  Regression with fix for #339
-  
-  Credit : Tseng Jun
-
-- [Tseng Jun brought this change]
-
-  kex.c : Correct type cast in curve25519_sha256() (#365)
-
-GitHub (24 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  transport.c : scope local total_num var (#364)
-  
-  file : transport.c
-  notes : move local `total_num` variable inside of if block to prevent scope access issues which caused #360.
-
-Will Cosgrove (24 Apr 2019)
-- [doublex brought this change]
-
-  transport.c : fixes bounds check if partial packet is read
-  
-  Files : transport.c
-  
-  Issue : #360
-  
-  Notes :
-   'p->total_num' instead of local value total_num when doing bounds check.
-  
-  Credit : Doublex
-
-GitHub (23 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Editor config file for source files (#322)
-  
-  Simple start to an editor config file when editing source files to make sure they are configured correctly.
-
-- [Will Cosgrove brought this change]
-
-  misc.c : String buffer API improvements (#332)
-  
-  Files : misc.c, hostkey.c, kex.c, misc.h, openssl.c, sftp.c
-  
-  Notes :
-  * updated _libssh2_get_bignum_bytes and _libssh2_get_string. Now pass in length as an argument instead of returning it to keep signedness correct. Now returns -1 for failure, 0 for success.
-  
-  _libssh2_check_length now returns 0 on success and -1 on failure to match the other string_buf functions. Added comment to _libssh2_check_length.
-  
-  Credit : Will Cosgrove
-
-Will Cosgrove (19 Apr 2019)
-- [doublex brought this change]
-
-  mbedtls.c : _libssh2_mbedtls_rsa_new_private_frommemory() allow private-key from memory (#359)
-  
-  File : mbedtls.c
-  
-  Notes: _libssh2_mbedtls_rsa_new_private_frommemory() fixes private-key from memory reading to by adding NULL terminator before parsing; adds passphrase support.
-  
-  Credit: doublex
-
-- [Ryan Kelley brought this change]
-
-  Session.c : banner_receive() from leaking when accessing non ssh ports (#356)
-  
-  File : session.c
-  
-  Release previous banner in banner_receive() if the session is reused after a failed connection.
-  
-  Credit : Ryan Kelley
-
-GitHub (11 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Formatting in agent.c
-  
-  Removed whitespace.
-
-- [Will Cosgrove brought this change]
-
-  Fixed formatting in agent.c
-  
-  Quiet linter around a couple if blocks and pointer.
-
-Will Cosgrove (11 Apr 2019)
-- [Zhen-Huan HWANG brought this change]
-
-  sftp.c : discard and reset oversized packet in sftp_packet_read() (#269)
-  
-  file : sftp.c
-  
-  notes : when sftp_packet_read() encounters an sftp packet which exceeds SFTP max packet size it now resets the reading state so it can continue reading.
-  
-  credit : Zhen-Huan HWANG
-
-GitHub (11 Apr 2019)
-- [Will Cosgrove brought this change]
-
-  Add agent functions libssh2_agent_get_identity_path() and libssh2_agent_set_identity_path() (#308)
-  
-  File : agent.c
-  
-  Notes :
-  Libssh2 uses the SSH_AUTH_SOCK env variable to read the system agent location. However, when using a custom agent path you have to set this value using setenv which is not thread-safe. The new functions allow for a way to set a custom agent socket path in a thread safe manor.
-
-- [Will Cosgrove brought this change]
-
-  Simplified _libssh2_check_length (#350)
-  
-  * Simplified _libssh2_check_length
-  
-  misc.c : _libssh2_check_length()
-  
-  Removed cast and improved bounds checking and format.
-  
-  Credit : Yuriy M. Kaminskiy
-
-- [Will Cosgrove brought this change]
-
-  _libssh2_check_length() : additional bounds check (#348)
-  
-  Misc.c : _libssh2_check_length()
-  
-  Ensure the requested length is less than the total length before doing the additional bounds check
-
-Daniel Stenberg (25 Mar 2019)
-- misc: remove 'offset' from string_buf
-  
-  It isn't necessary.
-  
-  Closes #343
-
-- sftp: repair mtime from e1ead35e475
-  
-  A regression from e1ead35e4759 broke the SFTP mtime logic in
-  sftp_bin2attr
-  
-  Also simplified the _libssh2_get_u32/u64 functions slightly.
-  
-  Closes #342
-
-- session_disconnect: don't zero state, just clear the right bit
-  
-  If we clear the entire field, the freeing of data in session_free() is
-  skipped. Instead just clear the bit that risk making the code get stuck
-  in the transport functions.
-  
-  Regression from 4d66f6762ca3fc45d9.
-  
-  Reported-by: dimmaq on github
-  Fixes #338
-  Closes #340
-
-- libssh2_sftp.h: restore broken ABI
-  
-  Commit 41fbd44 changed variable sizes/types in a public struct which
-  broke the ABI, which breaks applications!
-  
-  This reverts that change.
-  
-  Closes #339
-
-- style: make includes and examples code style strict
-  
-  make travis and the makefile rule verify them too
-  
-  Closes #334
-
-GitHub (21 Mar 2019)
-- [Daniel Stenberg brought this change]
-
-  create a github issue template
-
-Daniel Stenberg (21 Mar 2019)
-- stale-bot: activated
-  
-  The stale bot will automatically mark stale issues (inactive for 90
-  days) and if still untouched after 21 more days, close them.
-  
-  See https://probot.github.io/apps/stale/
-
-- libssh2_session_supported_algs.3: fix formatting mistakes
-  
-  Reported-by: Max Horn
-  Fixes #57
-
-- [Zenju brought this change]
-
-  libssh2.h: Fix Error C2371 'ssize_t': redefinition
-  
-  Closes #331
-
-- travis: add code style check
-  
-  Closes #324
-
-- code style: unify code style
-  
-  Indent-level: 4
-  Max columns: 79
-  No spaces after if/for/while
-  Unified brace positions
-  Unified white spaces
-
-- src/checksrc.pl: code style checker
-  
-  imported as-is from curl
-
-Will Cosgrove (19 Mar 2019)
-- Merge branch 'MichaelBuckley-michaelbuckley-security-fixes'
-
-- Silence unused var warnings (#329)
-  
-  Silence warnings about unused variables in this test
-
-- Removed unneeded > 0 check
-  
-  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
-
-- [Matthew D. Fuller brought this change]
-
-  Spell OpenSS_H_ right when talking about their specific private key (#321)
-  
-  Good catch, thanks.
-
-GitHub (19 Mar 2019)
-- [Will Cosgrove brought this change]
-
-  Silence unused var warnings (#329)
-  
-  Silence warnings about unused variables in this test
-
-Michael Buckley (19 Mar 2019)
-- Fix more scope and printf warning errors
-
-- Silence unused variable warning
-
-GitHub (19 Mar 2019)
-- [Will Cosgrove brought this change]
-
-  Removed unneeded > 0 check
-  
-  When checking `userauth_kybd_num_prompts > 100` we don't care if it's also above zero.
-
-Will Cosgrove (19 Mar 2019)
-- [Matthew D. Fuller brought this change]
-
-  Spell OpenSS_H_ right when talking about their specific private key (#321)
-  
-  Good catch, thanks.
-
-Michael Buckley (18 Mar 2019)
-- Fix errors identified by the build process
-
-- Fix casting errors after merge
-
-GitHub (18 Mar 2019)
-- [Michael Buckley brought this change]
-
-  Merge branch 'master' into michaelbuckley-security-fixes
-
-Michael Buckley (18 Mar 2019)
-- Move fallback SIZE_MAX and UINT_MAX to libssh2_priv.h
-
-- Fix type and logic issues with _libssh2_get_u64
-
-Daniel Stenberg (17 Mar 2019)
-- examples: fix various compiler warnings
-
-- lib: fix various compiler warnings
-
-- session: ignore pedantic warnings for funcpointer <=> void *
-
-- travis: add a build using configure
-  
-  Closes #320
-
-- configure: provide --enable-werror
-
-- appveyor: remove old builds that mostly cause failures
-  
-  ... and only run on master branch.
-  
-  Closes #323
-
-- cmake: add two missing man pages to get installed too
-  
-  Both libssh2_session_handshake.3 and
-  libssh2_userauth_publickey_frommemory.3 were installed by the configure
-  build already.
-  
-  Reported-by: Arfrever on github
-  Fixes #278
-
-- include/libssh2.h: warning: "_WIN64" is not defined, evaluates to 0
-  
-  We don't use #if for defines that might not be defined.
-
-- pem: //-comments are not allowed
-
-Will Cosgrove (14 Mar 2019)
-- [Daniel Stenberg brought this change]
-
-  userauth: fix "Function call argument is an uninitialized value" (#318)
-  
-  Detected by scan-build.
-
-- fixed unsigned/signed issue
-
-Daniel Stenberg (15 Mar 2019)
-- session_disconnect: clear state
-  
-  If authentication is started but not completed before the application
-  gives up and instead wants to shut down the session, the '->state' field
-  might still be set and thus effectively dead-lock session_disconnect.
-  
-  This happens because both _libssh2_transport_send() and
-  _libssh2_transport_read() refuse to do anything as long as state is set
-  without the LIBSSH2_STATE_KEX_ACTIVE bit.
-  
-  Reported in curl bug https://github.com/curl/curl/issues/3650
-  
-  Closes #310
-
-Will Cosgrove (14 Mar 2019)
-- Release notes from 1.8.1
-
-Michael Buckley (14 Mar 2019)
-- Use string_buf in sftp_init().
-
-- Guard against out-of-bounds reads in publickey.c
-
-- Guard against out-of-bounds reads in session.c
-
-- Guard against out-of-bounds reads in userauth.c
-
-- Use LIBSSH2_ERROR_BUFFER_TOO_SMALL instead of LIBSSH2_ERROR_OUT_OF_BOUNDARY in sftp.c
-
-- Additional bounds checking in sftp.c
-
-- Additional length checks to prevent out-of-bounds reads and writes in _libssh2_packet_add(). https://libssh2.org/CVE-2019-3862.html
-
-- Add a required_size parameter to sftp_packet_require et. al. to require callers of these functions to handle packets that are too short. https://libssh2.org/CVE-2019-3860.html
-
-- Check the length of data passed to sftp_packet_add() to prevent out-of-bounds reads.
-
-- Prevent zero-byte allocation in sftp_packet_read() which could lead to an out-of-bounds read. https://libssh2.org/CVE-2019-3858.html
-
-- Sanitize padding_length - _libssh2_transport_read(). https://libssh2.org/CVE-2019-3861.html
-  
-  This prevents an underflow resulting in a potential out-of-bounds read if a server sends a too-large padding_length, possibly with malicious intent.
-
-- Defend against writing beyond the end of the payload in _libssh2_transport_read().
-
-- Defend against possible integer overflows in comp_method_zlib_decomp.
-
-GitHub (14 Mar 2019)
-- [Will Cosgrove brought this change]
-
-  Security fixes (#315)
-  
-  * Bounds checks
-  
-  Fixes for CVEs
-  https://www.libssh2.org/CVE-2019-3863.html
-  https://www.libssh2.org/CVE-2019-3856.html
-  
-  * Packet length bounds check
-  
-  CVE
-  https://www.libssh2.org/CVE-2019-3855.html
-  
-  * Response length check
-  
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
-  
-  * Bounds check
-  
-  CVE
-  https://www.libssh2.org/CVE-2019-3857.html
-  
-  * Bounds checking
-  
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
-  
-  and additional data validation
-  
-  * Check bounds before reading into buffers
-  
-  * Bounds checking
-  
-  CVE
-  https://www.libssh2.org/CVE-2019-3859.html
-  
-  * declare SIZE_MAX and UINT_MAX if needed
-
-- [Will Cosgrove brought this change]
-
-  fixed type warnings (#309)
-
-- [Will Cosgrove brought this change]
-
-  Bumping version number for pending 1.8.1 release
-
-Will Cosgrove (4 Mar 2019)
-- [Daniel Stenberg brought this change]
-
-  _libssh2_string_buf_free: use correct free (#304)
-  
-  Use LIBSSH2_FREE() here, not free(). We allow memory function
-  replacements so free() is rarely the right choice...
-
-GitHub (26 Feb 2019)
-- [Will Cosgrove brought this change]
-
-  Fix for building against libreSSL #302
-  
-  Changed to use the check we use elsewhere.
-
-- [Will Cosgrove brought this change]
-
-  Fix for when building against LibreSSL #302
-
-Will Cosgrove (25 Feb 2019)
-- [gartens brought this change]
-
-  docs: update libssh2_hostkey_hash.3 [ci skip] (#301)
-
-GitHub (21 Feb 2019)
-- [Will Cosgrove brought this change]
-
-  fix malloc/free mismatches #296 (#297)
-
-- [Will Cosgrove brought this change]
-
-  Replaced malloc with calloc #295
-
-- [Will Cosgrove brought this change]
-
-  Abstracted OpenSSL calls out of hostkey.c (#294)
-
-- [Will Cosgrove brought this change]
-
-  Fix memory dealloc impedance mis-match #292 (#293)
-  
-  When using ed25519 host keys and a custom memory allocator.
-
-- [Will Cosgrove brought this change]
-
-  Added call to OpenSSL_add_all_digests() #288
-  
-  For OpenSSL 1.0.x we need to call OpenSSL_add_all_digests().
-
-Will Cosgrove (12 Feb 2019)
-- [Zhen-Huan HWANG brought this change]
-
-  SFTP: increase maximum packet size to 256K (#268)
-  
-  to match implementations like OpenSSH.
-
-- [Zenju brought this change]
-
-  Fix https://github.com/libssh2/libssh2/pull/271 (#284)
-
-GitHub (16 Jan 2019)
-- [Will Cosgrove brought this change]
-
-  Agent NULL check in shutdown #281
-
-Will Cosgrove (15 Jan 2019)
-- [Adrian Moran brought this change]
-
-  mbedtls: Fix leak of 12 bytes by each key exchange. (#280)
-  
-  Correctly free ducts by calling _libssh2_mbedtls_bignum_free() in dtor.
-
-- [alex-weaver brought this change]
-
-  Fix error compiling on Win32 with STDCALL=ON (#275)
-
-GitHub (8 Nov 2018)
-- [Will Cosgrove brought this change]
-
-  Allow default permissions to be used in sftp_mkdir (#271)
-  
-  Added constant LIBSSH2_SFTP_DEFAULT_MODE to use the server default permissions when making a new directory
-
-Will Cosgrove (13 Sep 2018)
-- [Giulio Benetti brought this change]
-
-  openssl: fix dereferencing ambiguity potentially causing build failure (#267)
-  
-  When dereferencing from *aes_ctr_cipher, being a pointer itself,
-  ambiguity can occur; fixed possible build errors.
-
-Viktor Szakats (12 Sep 2018)
-- win32/GNUmakefile: define HAVE_WINDOWS_H
-  
-  This macro was only used in test/example code before, now it is
-  also used in library code, but only defined automatically by
-  automake/cmake, so let's do the same for the standalone win32
-  make file.
-  
-  It'd be probably better to just rely on the built-in _WIN32 macro
-  to detect the presence of windows.h though. It's already used
-  in most of libssh2 library code. There is a 3rd, similar macro
-  named LIBSSH2_WIN32, which might also be replaced with _WIN32.
-  
-  Ref: https://github.com/libssh2/libssh2/commit/8b870ad771cbd9cd29edbb3dbb0878e950f868ab
-  Closes https://github.com/libssh2/libssh2/pull/266
-
-Marc Hoersken (2 Sep 2018)
-- Fix conditional check for HAVE_DECL_SECUREZEROMEMORY
-  
-  "Unlike the other `AC_CHECK_*S' macros, when a symbol is not declared,
-  HAVE_DECL_symbol is defined to `0' instead of leaving HAVE_DECL_symbol
-  undeclared. When you are sure that the check was performed,
-  use HAVE_DECL_symbol in #if."
-  
-  Source: autoconf documentation for AC_CHECK_DECLS.
-
-- Fix implicit declaration of function 'SecureZeroMemory'
-  
-  Include window.h in order to use SecureZeroMemory on Windows.
-
-- Fix implicit declaration of function 'free' by including stdlib.h
-
-GitHub (27 Aug 2018)
-- [Will Cosgrove brought this change]
-
-  Use malloc abstraction function in pem parse
-  
-  Fix warning on WinCNG build.
-
-- [Will Cosgrove brought this change]
-
-  Fixed possible junk memory read in sftp_stat #258
-
-- [Will Cosgrove brought this change]
-
-  removed INT64_C define (#260)
-  
-  No longer used.
-
-- [Will Cosgrove brought this change]
-
-  Added conditional around engine.h include
-
-Will Cosgrove (6 Aug 2018)
-- [Alex Crichton brought this change]
-
-  Fix OpenSSL link error with `no-engine` support (#259)
-  
-  This commit fixes linking against an OpenSSL library that was compiled with
-  `no-engine` support by bypassing the initialization routines as they won't be
-  available anyway.
-
-GitHub (2 Aug 2018)
-- [Will Cosgrove brought this change]
-
-  ED25519 Key Support #39 (#248)
-  
-  OpenSSH Key and ED25519 support #39
-  Added _libssh2_explicit_zero() to explicitly zero sensitive data in memory #120
-  
-  * ED25519 Key file support - Requires OpenSSL 1.1.1 or later
-  * OpenSSH Key format reading support - Supports RSA/DSA/ECDSA/ED25519 types
-  * New string buffer reading functions - These add build-in bounds checking and convenance methods. Used for OpenSSL PEM file reading.
-  * Added new tests for OpenSSH formatted Keys
-
-- [Will Cosgrove brought this change]
-
-  ECDSA key types are now explicit (#251)
-  
-  * ECDSA key types are now explicit
-  
-  Issue was brough up in pull request #248
-
-Will Cosgrove (2 May 2018)
-- [Jakob Egger brought this change]
-
-  Add Instructions for building from Master (#249)
-
-GitHub (27 Apr 2018)
-- [Will Cosgrove brought this change]
-
-  Initialize sb_intl #226
-
-Will Cosgrove (19 Apr 2018)
-- [doublex brought this change]
-
-  buffer overflow (valgrind) (#159)
-
-- [Brendan Shanks brought this change]
-
-  mbedTLS: Remove some C99-style intermingled variable declarations (#196)
-
-GitHub (18 Apr 2018)
-- [Will Cosgrove brought this change]
-
-  fix for #160
-
-Will Cosgrove (18 Apr 2018)
-- [doublex brought this change]
-
-  fix memory leak when using mbedtls backend (#158)
-  
-   _libssh2_bn_init_from_bin/_libssh2_bn_free would leak bignum from mbedtls_calloc().
-
-- [Brendan Shanks brought this change]
-
-  mbedTLS: Avoid multiple definition errors for context handles (#197)
-
-- [Tseng Jun brought this change]
-
-  Fix the EVP cipher meth memory leakage problem (#244)
-  
-  * Fix the EVP cipher meth memory leakage problem
-  
-  Looks good, thanks for the fixes.
-
-Marc Hörsken (31 Mar 2018)
-- [Will Cosgrove brought this change]
-
-  Added ECDSA defines for WinCNG (#245)
-  
-  Fixed missing defines preventing building using WinCNG
-
-GitHub (30 Mar 2018)
-- [Will Cosgrove brought this change]
-
-  Fix for _libssh2_rsa_new with OpenSSL 1.0.x
-  
-  missing d value assignment.
-
-Will Cosgrove (20 Mar 2018)
-- [Etienne Samson brought this change]
-
-  A collection of small fixes (#198)
-  
-  * tests: Remove if-pyramids
-  
-  * tests: Switch run_command arguments
-  
-  * tests: Make run_command a vararg function
-  
-  * tests: Xcode doesn't obey CMake's test working directory
-  
-  * openssl: move manual AES-CTR cipher into crypto init
-  
-  * cmake: Move our include dir before all other include paths
-
-GitHub (15 Mar 2018)
-- [Will Cosgrove brought this change]
-
-  Fixes incorrect indexing of KEX prefs string
-  
-  After stripping out an invalid KEX pref entry, it would incorrectly advance again leaving invalid values in the list.
-
-Viktor Szakats (13 Mar 2018)
-- tests: fix checksrc warnings
-  
-  Also:
-  * add 'static' qualifier to file-wide const buffers
-  * fix a non-ANSI C89 comment
-  * silence a mismatched fprintf() mask warning by adding a cast
-
-- cmake: recognize OpenSSL 1.1 .dll names
-  
-  Also fix some comment typos and a stray tab.
-
-- docs: update an URL [ci skip]
-
-Daniel Stenberg (12 Mar 2018)
-- docs/SECURITY: the max embargo is 14 days now
-
-Viktor Szakats (12 Mar 2018)
-- docs: spelling fixes [ci skip]
-  
-  Closes https://github.com/libssh2/libssh2/pull/222
-
-GitHub (12 Mar 2018)
-- [Will Cosgrove brought this change]
-
-  Fixed minor tabs/spacing issues
-
-- [Will Cosgrove brought this change]
-
-  Update kex.c
-
-- [Will Cosgrove brought this change]
-
-  Added basic bounds checking #206
-  
-  Basic bounds checking in ecdh_sha2_nistp()
-
-- [Will Cosgrove brought this change]
-
-  Fixed Clang warning #206
-  
-  Fixed possible garbage value for secret in an error case
-
-- [Will Cosgrove brought this change]
-
-  Fixed incorrect #if to #ifdef #206
-  
-  When checking HAVE_OPAQUE_STRUCTS.
-
-Viktor Szakats (12 Mar 2018)
-- src: suppress two checksrc warnings
-  
-  Ref: https://github.com/libssh2/libssh2/pull/235
-
-- src: address fopen() warnings, add missing copyright headers
-  
-  Ref: https://github.com/libssh2/libssh2/pull/235
-
-- src: replace sprintf() with snprintf()
-  
-  Ref: https://github.com/libssh2/libssh2/pull/235
-
-- src: fix checksrc warnings
-  
-  Use checksrc.pl from the curl project, with (for now)
-  suppressed long line warnings and indentation set to
-  4 spaces. Fixes are whitespace for the most part.
-  
-  Warning count went down from 2704 to 12.
-  
-  Also fix codespell typos, two non-ANSI C89 comments
-  and a stray tab in include/libssh2.h.
-  
-  Ref: https://github.com/libssh2/libssh2/pull/235
-
-- checksrc: add source style checker
-  
-  This is a slightly extended version of this original source
-  from the curl project:
-  https://github.com/curl/curl/blob/8b754c430b9a4c51aa606c687ee5014faf7c7b06/lib/checksrc.pl
-  
-  This version adds the following options to customize it for
-  libssh2 (plus some whitespace formatting):
-  
-  `-i<n>`  to override indentation spaces (2)
-  `-m<n>`  to override maximum line length (79)
-  
-  Command-line used to check libssh2 sources:
-  
-  $ ./checksrc.pl -i4 -m500 *.c *.h
-  
-  Closes https://github.com/libssh2/libssh2/pull/236
-
-- src: add static qualifier
-  
-  To private, const strings.
-  
-  Closes https://github.com/libssh2/libssh2/pull/237
-
-- [Will Cosgrove brought this change]
-
-  Add support for ECDSA keys and host keys (#41)
-  
-  This commit lands full ECDSA key support when using the OpenSSL
-  backend. Which includes:
-  
-  New KEX methods:
-  ecdsa-sha2-nistp256, ecdsa-sha2-nistp384, ecdsa-sha2-nistp521
-  
-  Can now read OpenSSL formatted ECDSA key files.
-  
-  Now supports known host keys of type ecdsa-sha2-nistp256.
-  
-  New curve types:
-  NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1
-  
-  Default host key preferred ordering is now nistp256, nistp384,
-  nistp521, rsa, dss.
-  
-  Ref: https://github.com/libssh2/libssh2/issues/41
-  
-  Closes https://github.com/libssh2/libssh2/pull/206
-
-GitHub (15 Dec 2017)
-- [Will Cosgrove brought this change]
-
-  Fixed possible crash when decoding invalid data
-  
-  When trying to decode invalid data, it frees the buffer but doesn't nil it so the caller gets a junk memory pointer which they could potentially double free.
-
-- [Will Cosgrove brought this change]
-
-  Remove call to OpenSSL_add_all_ciphers()
-  
-  Now lives in libssh2 init() from PR #189
-
-- [Will Cosgrove brought this change]
-
-  Fixed incorrect reference to decrypted block
-  
-  Fixed incorrectly copied memory from p->buf into init instead of from the decrypted buffer block. The only reason this worked was because the crypt() function decrypts the value in-place and overwrites p->buf.  I'm working on a fork that no longer does this and exposed this bug.
-
-Will Cosgrove (20 Oct 2017)
-- [Pan brought this change]
-
-  Fix typo in crypt.c (#218)
-
-Kamil Dudka (17 Oct 2017)
-- session: avoid printing misleading debug messages
-  
-  ... while throwing LIBSSH2_ERROR_EAGAIN out of session_startup()
-  
-  If the session runs in blocking mode, LIBSSH2_ERROR_EAGAIN never reaches
-  the libssh2 API boundary and, in non-blocking mode, these messages are
-  suppressed by the condition in _libssh2_error_flags() anyway.
-  
-  Closes #211
-
-Viktor Szakats (15 Oct 2017)
-- win32/GNUmakefile: allow customizing dll suffixes
-  
-  - New `LIBSSH2_DLL_SUFFIX` envvar will add a suffix to the generated
-    libssh2 dll name. Useful to add `-x64` to 64-bit builds so that
-    it can live in the same directory as the 32-bit one. By default
-    this is empty.
-  
-  - New `LIBSSH2_DLL_A_SUFFIX` envvar to customize the suffix of the
-    generated import library (implib) for libssh2 .dll. It defaults
-    to `dll`, and it's useful to modify that to `.dll` to have the
-    standard naming scheme for mingw-built .dlls, i.e. `libssh2.dll.a`.
-  
-  Ref: https://github.com/curl/curl/commit/aaa16f80256abc1463fd9374815130a165222257
-  
-  Closes https://github.com/libssh2/libssh2/pull/215
-
-- makefile.m32: allow to override gcc, ar and ranlib
-  
-  Allow to ovverride certain build tools, making it possible to
-  use LLVM/Clang to build libssh2. The default behavior is unchanged.
-  To build with clang (as offered by MSYS2), these settings can
-  be used:
-  
-  LIBSSH2_CC=clang
-  LIBSSH2_AR=llvm-ar
-  LIBSSH2_RANLIB=llvm-ranlib
-  
-  Also adjust ranlib parameters to be compatible with LLVM/Clang's
-  ranlib tool.
-  
-  Closes https://github.com/libssh2/libssh2/pull/214
-
-GitHub (27 Sep 2017)
-- [Will Cosgrove brought this change]
-
-  Fixes out of bounds memory access (#210)
-  
-  If an invalid PEM file is read and the lines are longer than 128 characters it will go out of bounds and crash on line 91.
-
-Will Cosgrove (11 Sep 2017)
-- [Kamil Dudka brought this change]
-
-  scp: do not NUL-terminate the command for remote exec (#208)
-  
-  It breaks SCP download/upload from/to certain server implementations.
-  
-  The bug does not manifest with OpenSSH, which silently drops the NUL
-  byte (eventually with any garbage that follows the NUL byte) before
-  executing it.
-  
-  Bug: https://bugzilla.redhat.com/1489736
-
-GitHub (21 Aug 2017)
-- [Viktor Szakats brought this change]
-
-  openssl.c: remove no longer used variable (#204)
-  
-  after e378d2e30a40bd9bcee06dc3a4250f269098e200
-
-- [Will Cosgrove brought this change]
-
-  Fix for #188 (#189)
-  
-  * Update openssl.c
-  
-  * Create openssl.h
-
-Will Cosgrove (24 May 2017)
-- [Marcel Raad brought this change]
-
-  openssl: fix build with OpenSSL 1.1 API (#176)
-  
-  When building with OPENSSL_API_COMPAT=0x10100000L, OpenSSL_add_all_algorithms
-  and OpenSSL_add_all_ciphers don't exist. The corresponding functionality is
-  handled automatically with OpenSSL 1.1.
-
-- [Sune Bredahl brought this change]
-
-  Add support for SHA256 hostkey fingerprints (#180)
-  
-  Looks good, thanks!
-
-GitHub (12 May 2017)
-- [Will Cosgrove brought this change]
-
-  Fix memory leak of crypt_ctx->h using openSSL 1.1+ (#177)
-  
-  Need to use EVP_CIPHER_CTX_free instead of EVP_CIPHER_CTX_reset.
-
-Marc Hoersken (2 Mar 2017)
-- tests/openssh_server/authorized_keys: add key_rsa_encrypted.pub
-
-- tests: add simple test for passphrase-protected PEM file support
-
-- os400qc3: enable passphrase-protected PEM file support using pem.c
-
-- pem: fix indentation and replace assert after 386e012292
-
-- [Keno Fischer brought this change]
-
-  pem: add passphrase-protected PEM file support for libgcrypt and wincng
-  
-  Since they use our own PEM parser which did not support encrypted
-  PEM files, trying to use such files on these backends failed.
-  Fix that by augmenting the PEM parser to support encrypted PEM files.
-
-- [Thomas brought this change]
-
-  misc: use time constant implementation for AES CTR increment
-
-- [Thomas brought this change]
-
-  wincng: add AES CTR mode support (aes128-ctr, aes192-ctr, aes256-ctr)
-
-- [Thomas brought this change]
-
-  openssl: move shared AES-CTR code into misc
-
-Daniel Stenberg (20 Dec 2016)
-- [Alex Crichton brought this change]
-
-  kex: acknowledge error code from libssh2_dh_key_pair()
-  
-  Fixes a segfault using ssh-agent on Windows
-  
-  This commit fixes a segfault seen dereferencing a null pointer on
-  Windows when using ssh-agent. The problem ended up being that errors
-  weren't being communicated all the way through, causing null pointers to
-  be used when functions should have bailed out sooner.
-  
-  The `_libssh2_dh_key_pair` function for WinCNG was modified to propagate
-  errors, and then the two callsites in kex.c of
-  `diffie_hellman_sha{1,256}` were updated to recognize this error and
-  bail out.
-  
-  Fixes #162
-  Closes #163
-
-Alexander Lamaison (27 Nov 2016)
-- [monnerat brought this change]
-
-  Implement Diffie-Hellman computations in crypto backends. (#149)
-  
-  Not all backends feature the low level API needed to compute a Diffie-Hellman
-  secret, but some of them directly implement Diffie-Hellman support with opaque
-  private data. The later approach is now generalized and backends are
-  responsible for all Diffie Hellman computations.
-  As a side effect, procedures/macros _libssh2_bn_rand and _libssh2_bn_mod_exp
-  are no longer needed outside the backends.
-
-Peter Stuge (16 Nov 2016)
-- acinclude.m4: The mbedtls crypto backend actually requires libmbedcrypto
-  
-  Examples can't be linked with libmbedtls but need libmbedcrypto, and
-  any users of libssh2 which use libtool and libssh2.la would encounter
-  the same problem.
-  
-  This changes the mbedtls detection to search for libmbedcrypto, which
-  is the actual dependency for the backend.
-
-- acinclude.m4: Add CPPFLAGS=-I$prefix-dir/include in LIBSSH2_LIB_HAVE_LINKFLAGS
-  
-  This is absolutely neccessary for header files to be found when
-  AC_LIB_HAVE_LINKFLAGS searches for libraries.
-
-- acinclude.m4: Make saved variables in LIBSSH2_LIB_HAVE_LINKFLAGS uniform
-
-- docs/HACKING.CRYPTO: Improve documentation for autoconf build system
-
-Alexander Lamaison (16 Nov 2016)
-- [Alex Arslan brought this change]
-
-  Check for netinet/in.h in the tests cmake file (#148)
-
-- [Patrick Monnerat brought this change]
-
-  Define new Diffie-Hellman context for mbedTLS
-
-- [monnerat brought this change]
-
-  Make libssh2 work again on os400. (#118)
-  
-  * os400: minimum supported OS version is now V6R1.
-  Do not log compiler informational messages.
-  
-  * Implement crypto backend specific Diffie-Hellman computation.
-  
-  This feature is now needed on os400 because the QC3 library does not
-  implement bn_mod_exp() natively. Up to now, this function was emulated using
-  an RSA encryption, but commits ca5222ea819cc5ed797860070b4c6c1aeeb28420 and
-  7934c9ce2a029c43e3642a492d3b9e494d1542be (CVE-2016-0787) broke the emulation
-  because QC3 only supports RSA exponents up to 512 bits.
-  
-  Happily, QC3 supports a native API for Diffie-Hellman computation, with
-  opaque random value: this commit implements the use of this API and, as a
-  side effect, enables support of this feature for any other crypto backend that
-  would use it.
-  
-  A "generic" Diffie-Hellman computation internal API supports crypto backends
-  not implementing their own: this generic API uses the same functions as before.
-  
-  * Fix typos in docs/HACKING.CRYPTO.
-
-- [Peter Stuge brought this change]
-
-  acinclude.m4: Fixup OpenSSL EVP_aes_128_ctr() detection
-
-- [Peter Stuge brought this change]
-
-  configure.ac: Add --with-crypto= instead of many different --with-$backend
-  
-  The new --with-crypto option replaces the previous backend-specific
-  --with-{openssl,libgcrypt,mbedtls,wincng} options and fixes some issues.
-  
-  * libgcrypt or mbedtls would previously be used whenever found, even
-    if configure was passed --without-libgcrypt or --without-mbedtls.
-  
-  * If --with-$backend was specified then configure would not fail even
-    if that library could not be found, and would instead use whichever
-    crypto library was found first.
-  
-  The new option defaults to `auto`, which makes configure check for all
-  supported crypto libraries in turn, choosing the first one found, or
-  exiting with an error if none can be found.
-
-- [Tony Kelman brought this change]
-
-  Build mbedtls from source on Travis (#133)
-  
-  * Revert "Revert "travis: Test mbedtls too""
-  
-  This reverts commit c4c60eac5ca756333034b07dd9e0b97741493ed3.
-  
-  * travis: Build mbedtls from source on Travis
-  
-  Use TOOLCHAIN_OPTION when calling cmake on mbedtls
-  
-  * tests: only run DSA tests for non-mbedtls
-  
-  crypto backends
-
-- [Peter Stuge brought this change]
-
-  configure.ac src/Makefile.am: Remove dead AM_CONDITIONAL(OS400QC3)
-  
-  According to os400/README400 this backend can not be built
-  with configure+make, and the conditional is hard coded to false.
-
-- [Peter Stuge brought this change]
-
-  configure.ac: Add -DNDEBUG to CPPFLAGS in non-debug builds
-  
-  There are a few uses of assert() in channel.c, sftp.c and transport.c.
-
-- [Peter Stuge brought this change]
-
-  src/global.c: Fix conditional AES-CTR support
-  
-  Most of libssh2 already has conditional support for AES-CTR according to
-  the LIBSSH2_AES_CTR crypto backend #define, but global.c needed fixing.
-
-- [Peter Stuge brought this change]
-
-  src/crypto.h src/userauth.c: Fix conditional RSA support
-  
-  Most of libssh2 already has conditional support for RSA according to
-  the LIBSSH2_RSA crypto backend #define, but crypto.h and userauth.c
-  needed a few small fixes.
-
-- [Peter Stuge brought this change]
-
-  src/kex.c: Cast libssh2_sha{1,256}_update data arguments properly
-  
-  The update functions take a const unsigned char * but were called
-  with (const) char * in some places, causing unneccessary warnings.
-
-- [Peter Stuge brought this change]
-
-  docs/HACKING.CRYPTO: Fix two type typos
-
-- [Sergei Trofimovich brought this change]
-
-  acinclude.m4: fix ./configure --with-libgcrypt
-  
-  The change fixes passing of bogus gcrypt prefix.
-  Reproducible as:
-  
-      $ ./configure --with-libgcrypt
-      $ make V=1
-      ...
-      /bin/sh ../libtool  --tag=CC   --mode=link gcc  -g -O2 -Iyes/include -version-info 1:1:0 -no-undefined -export-symbols-regex '^libssh2_.*' -lgcrypt  -lz -Lyes/lib -o libssh2.la -rpath /usr/local/lib channel.lo comp.lo crypt.lo hostkey.lo kex.lo mac.lo misc.lo packet.lo publickey.lo scp.lo session.lo sftp.lo userauth.lo transport.lo version.lo knownhost.lo agent.lo libgcrypt.lo pem.lo keepalive.lo global.lo   -lgcrypt
-      ../libtool: line 7475: cd: yes/lib: No such file or directory
-      libtool:   error: cannot determine absolute directory name of 'yes/lib'
-  
-  These
-      -Iyes/include
-      -Lyes/lib
-  come from libgcrypt code autodetection:
-    if test -n "$use_libgcrypt" && test "$use_libgcrypt" != "no"; then
-       LDFLAGS="$LDFLAGS -L$use_libgcrypt/lib"
-       CFLAGS="$CFLAGS -I$use_libgcrypt/include"
-  
-  I assume it's a typo to use yes/no flag as a prefix and changed
-  it to '$with_libgcrypt_prefix'.
-  
-  Reported-by: Mikhail Pukhlikov <cynede@gentoo.org>
-  Signed-off-by: Sergei Trofimovich <siarheit@google.com>
-
-- [Zenju brought this change]
-
-  libssh2_sftp_init hang: last error not set
-  
-  The problem is that the original if statement simply returns NULL, but does not set the session last error code. The consequence is that libssh2_sftp_init() also returns NULL and libssh2_session_last_errno(sshSession) == LIBSSH2_ERROR_NONE.
-  
-  In my test the LIBSSH2_ERROR_EAGAIN is coming from sftp.c row 337:
-              if(4 != sftp->partial_size_len)
-                  /* we got a short read for the length part */
-                  return LIBSSH2_ERROR_EAGAIN;
-  
-  with "partial_size_len == 0". Not sure if this is expected.
-
-- [Aidan Hobson Sayers brought this change]
-
-  docs: correctly describe channel_wait_eof
-  
-  channel_wait_eof waits for channel->remote.eof, which is set on
-  receiving a `SSH_MSG_CHANNEL_EOF` message. This message is sent
-  when a party has no more data to send on a channel.
-
-- [Zenju brought this change]
-
-  Fix MSVC 14 compilation warning (#92)
-  
-  1>  sftp.c
-  1>libssh2-files\src\sftp.c(3393): warning C4456: declaration of 'retcode' hides previous local declaration
-  1>  libssh2-files\src\sftp.c(3315): note: see declaration of 'retcode'
-
-- [Salvador Fandino brought this change]
-
-  LIBSSH2_ERROR_CHANNEL_WINDOW_FULL: add new error code
-  
-  In order to signal that the requested operation can not succeed
-  because the receiving window had been exhausted, the error code
-  LIBSSH2_ERROR_BUFFER_TOO_SMALL has been reused but I have found
-  that in certain context it may be ambigous.
-  
-  This patch introduces a new error code,
-  LIBSSH2_ERROR_CHANNEL_WINDOW_FULL, exclusive to signal that condition.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_eof: handle receive window exhaustion
-  
-  Until now, in blocking mode, if the remote receiving window is
-  exhausted this function hangs forever as data is not read and the
-  remote side just keeps waiting for the window to grow before sending
-  more data.
-  
-  This patch, makes this function check for that condition and abort
-  with an error when it happens.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_closed: don't fail when unread data is queued
-  
-  This function was calling channel_wait_eof to ensure that the EOF
-  packet has already been received, but that function also checks that
-  the read data queue is empty before reporting the EOF. That caused
-  channel_wait_closed to fail with a LIBSSH2_ERROR_INVAL when some data
-  was queued even after a successful call to libssh2_channel_wait_eof.
-  
-  This patch changes libssh2_channel_wait_closed to look directly into
-  channel->remote.eof so that both libssh2_channel_wait_eof and
-  libssh2_channel_wait_closed bahave consistently.
-
-- [Salvador Fandino brought this change]
-
-  channel_wait_eof: fix debug message
-
-Daniel Stenberg (25 Oct 2016)
-- libssh2.h: start working on 1.8.1
-
-Version 1.8.0 (25 Oct 2016)
-
-Daniel Stenberg (25 Oct 2016)
-- RELEASE-NOTES: adjusted for 1.8.0
-
-Kamil Dudka (20 Oct 2016)
-- Revert "aes: the init function fails when OpenSSL has AES support"
-  
-  This partially reverts commit f4f2298ef3635acd031cc2ee0e71026cdcda5864
-  because it caused the compatibility code to call initialization routines
-  redundantly, leading to memory leakage with OpenSSL 1.1 and broken curl
-  test-suite in Fedora:
-  
-  88 bytes in 1 blocks are definitely lost in loss record 5 of 8
-     at 0x4C2DB8D: malloc (vg_replace_malloc.c:299)
-     by 0x72C607D: CRYPTO_zalloc (mem.c:100)
-     by 0x72A2480: EVP_CIPHER_meth_new (cmeth_lib.c:18)
-     by 0x4E5A550: make_ctr_evp.isra.0 (openssl.c:407)
-     by 0x4E5A8E8: _libssh2_init_aes_ctr (openssl.c:471)
-     by 0x4E5BB5A: libssh2_init (global.c:49)
-
-Daniel Stenberg (19 Oct 2016)
-- [Charles Collicutt brought this change]
-
-  libssh2_wait_socket: Fix comparison with api_timeout to use milliseconds (#134)
-  
-  Fixes #74
-
-- [Charles Collicutt brought this change]
-
-  Set err_msg on _libssh2_wait_socket errors (#135)
-
-- Revert "travis: Test mbedtls too"
-  
-  This reverts commit 3e6de50a24815e72ec5597947f1831f6083b7da8.
-  
-  Travis doesn't seem to support the mbedtls-dev package
-
-- maketgz: support "only" to only update version number locally
-  
-  and fix the date output locale
-
-- configure: make the --with-* options override the OpenSSL default
-  
-  ... previously it would default to OpenSSL even with the --with-[crypto]
-  options used unless you specificly disabled OpenSSL. Now, enabling another
-  backend will automatically disable OpenSSL if the other one is found.
-
-- [Keno Fischer brought this change]
-
-  docs: Add documentation on new cmake/configure options
-
-- [Keno Fischer brought this change]
-
-  configure: Add support for building with mbedtls
-
-- [wildart brought this change]
-
-  travis: Test mbedtls too
-
-- [wildart brought this change]
-
-  crypto: add support for the mbedTLS backend
-  
-  Closes #132
-
-- [wildart brought this change]
-
-  cmake: Add CLEAR_MEMORY option, analogously to that for autoconf
-
-- README.md: fix link typo
-
-- README: markdown version to look nicer on github
-
-Viktor Szakats (5 Sep 2016)
-- [Taylor Holberton brought this change]
-
-  openssl: add OpenSSL 1.1.0 compatibility
-
-Daniel Stenberg (4 Sep 2016)
-- [Antenore Gatta brought this change]
-
-  tests: HAVE_NETINET_IN_H was not defined correctly (#127)
-  
-  Fixes #125
-
-- SECURITY: fix web site typo
-
-- SECURITY: security process
-
-GitHub (14 Aug 2016)
-- [Alexander Lamaison brought this change]
-
-  Basic dockerised test suite.
-  
-  This introduces a test suite for libssh2. It runs OpenSSH in a Docker
-  container because that works well on Windows (via docker-machine) as
-  well as Linux. Presumably it works on Mac too with docker-machine, but
-  I've not tested that.
-  
-  Because the test suite is docker-machine aware, you can also run it
-  against a cloud provider, for more realistic network testing, by setting
-  your cloud provider as your active docker machine. The Appveyor CI setup
-  in this commit does that because Appveyor doesn't support docker
-  locally.
-
-Kamil Dudka (3 Aug 2016)
-- [Viktor Szakats brought this change]
-
-  misc.c: Delete unused static variables
-  
-  Closes #114
-
-Daniel Stenberg (9 Apr 2016)
-- [Will Cosgrove brought this change]
-
-  Merge pull request #103 from willco007/patch-2
-  
-  Fix for security issue CVE-2016-0787
-
-Alexander Lamaison (2 Apr 2016)
-- [Zenju brought this change]
-
-  Fix MSVC 14 compilation errors
-  
-  For _MSC_VER == 1900 these macros are not needed and create problems:
-  
-  
-  
-  1>C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt\stdio.h(1925): warning C4005: 'snprintf': macro redefinition (compiling source file libssh2-files\src\mac.c)
-  
-  1> \win32\libssh2_config.h(27): note: see previous definition of 'snprintf' (compiling source file libssh2-files\src\mac.c)
-  
-  1>C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt\stdio.h(1927): fatal error C1189: #error: Macro definition of snprintf conflicts with Standard Library function declaration (compiling source file libssh2-files\src\mac.c)
-
-Daniel Stenberg (26 Mar 2016)
-- [Brad Harder brought this change]
-
-  _libssh2_channel_open: speeling error fixed in channel error message
-
-Alexander Lamaison (15 Mar 2016)
-- Link with crypt32.lib on Windows.
-  
-  Makes linking with static OpenSSL work again.  Although it's not
-  required for dynamic OpenSSL, it does no harm.
-  
-  Fixes #98.
-
-- [Craig A. Berry brought this change]
-
-  Tweak VMS help file building.
-  
-  Primarily this is handling cases where top-level files moved into
-  the docs/ directory.  I also corrected a typo and removed the
-  claim that libssh2 is public domain.
-
-- [Craig A. Berry brought this change]
-
-  Build with standard stat structure on VMS.
-  
-  This gets us large file support, is available on any VMS release
-  in the last decade and more, and gives stat other modern features
-  such as 64-bit ino_t.
-
-- [Craig A. Berry brought this change]
-
-  Update vms/libssh2_config.h.
-  
-  VMS does have stdlib.h, gettimeofday(), and OpenSSL.  The latter
-  is appropriate to hard-wire in the configuration because it's
-  installed by default as part of the base operating system and
-  there is currently no libgcrypt port.
-
-- [Craig A. Berry brought this change]
-
-  VMS can't use %zd for off_t format.
-  
-  %z is a C99-ism that VMS doesn't currently have; even though the
-  compiler is C99-compliant, the library isn't quite.  The off_t used
-  for the st_size element of the stat can be 32-bit or 64-bit, so
-  detect what we've got and pick a format accordingly.
-
-- [Craig A. Berry brought this change]
-
-  Normalize line endings in libssh2_sftp_get_channel.3.
-  
-  Somehow it got Windows-style CRLF endings so convert to just LF,
-  for consistency as well as not to confuse tools that will regard
-  the \r as content (e.g. the OpenVMS help librarian).
-
-Dan Fandrich (29 Feb 2016)
-- libgcrypt: Fixed a NULL pointer dereference on OOM
-
-Daniel Stenberg (24 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  url updates, HTTP => HTTPS
-  
-  Closes #87
-
-Dan Fandrich (23 Feb 2016)
-- RELEASE-NOTES: removed some duplicated names
-
-Version 1.7.0 (23 Feb 2016)
-
-Daniel Stenberg (23 Feb 2016)
-- web: the site is now HTTPS
-
-- RELEASE-NOTES: 1.7.0 release
-
-- diffie_hellman_sha256: convert bytes to bits
-  
-  As otherwise we get far too small numbers.
-  
-  Reported-by: Andreas Schneider
-  
-  CVE-2016-0787
-
-Alexander Lamaison (18 Feb 2016)
-- Allow CI failures with VS 2008 x64.
-  
-  Appveyor doesn't support this combination.
-
-Daniel Stenberg (16 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  GNUmakefile: list system libs after user libs
-  
-  Otherwise some referenced WinSock functions will fail to
-  resolve when linking against LibreSSL 2.3.x static libraries
-  with mingw.
-  
-  Closes #80
-
-- [Viktor Szakats brought this change]
-
-  openssl: apply new HAVE_OPAQUE_STRUCTS macro
-  
-  Closes #81
-
-- [Viktor Szakats brought this change]
-
-  openssl: fix LibreSSL support after OpenSSL 1.1.0-pre1/2 support
-
-Alexander Lamaison (14 Feb 2016)
-- sftp.h: Fix non-C90 type.
-  
-  uint64_t does not exist in C90.  Use libssh2_uint64_t instead.
-
-- Exclude sshd tests from AppVeyor.
-  
-  They fail complaining that sshd wasn't invoked with an absolute path.
-
-- Test on more versions of Visual Studio.
-
-- Fix Appveyor builds.
-
-Daniel Stenberg (14 Feb 2016)
-- [Viktor Szakats brought this change]
-
-  openssl: add OpenSSL 1.1.0-pre3-dev compatibility
-  
-  by using API instead of accessing an internal structure.
-  
-  Closes #83
-
-- RELEASE-NOTES: synced with 996b04ececdf
-
-- include/libssh2.h: next version is 1.7.0
-
-- configure: build "silent" if possible
-
-- sftp: re-indented some minor stuff
-
-- [Jakob Egger brought this change]
-
-  sftp.c: ensure minimum read packet size
-  
-  For optimum performance we need to ensure we don't request tiny packets.
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Explicit return values & sanity checks
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Check Read Packet File Offset
-  
-  This commit adds a simple check to see if the offset of the read
-  request matches the expected file offset.
-  
-  We could try to recover, from this condition at some point in the future.
-  Right now it is better to return an error instead of corrupted data.
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Don't return EAGAIN if data was written to buffer
-
-- [Jakob Egger brought this change]
-
-  sftp.c: Send at least one read request before reading
-  
-  This commit ensures that we have sent at least one read request before
-  we try to read data in sftp_read().
-  
-  Otherwise sftp_read() would return 0 bytes (indicating EOF) if the
-  socket is not ready for writing.
-
-- [Jakob Egger brought this change]
-
-  sftp.c: stop reading when buffer is full
-  
-  Since we can only store data from a single chunk in filep,
-  we have to stop receiving data as soon as the buffer is full.
-  
-  This adresses the following bug report:
-  https://github.com/libssh2/libssh2/issues/50
-
-Salvador Fandiño (21 Jan 2016)
-- agent_disconnect_unix: unset the agent fd after closing it
-  
-  "agent_disconnect_unix", called by "libssh2_agent_disconnect", was
-  leaving the file descriptor in the agent structure unchanged. Later,
-  "libssh2_agent_free" would call again "libssh2_agent_disconnect" under
-  the hood and it would try to close again the same file descriptor. In
-  most cases that resulted in just a harmless error, but it is also
-  possible that the file descriptor had been reused between the two
-  calls resulting in the closing of an unrelated file descriptor.
-  
-  This patch sets agent->fd to LIBSSH2_INVALID_SOCKET avoiding that
-  issue.
-  
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
-
-Daniel Stenberg (18 Jan 2016)
-- [Patrick Monnerat brought this change]
-
-  os400qc3: support encrypted private keys
-  
-  PKCS#8 EncryptedPrivateKeyinfo structures are recognized and decoded to get
-  values accepted by the Qc3 crypto library.
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3: New PKCS#5 decoder
-  
-  The Qc3 library is not able to handle PKCS#8 EncryptedPrivateKeyInfo structures
-  by itself. It is only capable of decrypting the (encrypted) PrivateKeyInfo
-  part, providing a key encryption key and an encryption algorithm are given.
-  Since the encryption key and algorithm description part in a PKCS#8
-  EncryptedPrivateKeyInfo is a PKCS#5 structure, such a decoder is needed to
-  get the derived key method and hash, as well as encryption algorith and
-  initialisation vector.
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3: force continuous update on non-final hash/hmac computation
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3: Be sure hmac keys have a minimum length
-  
-  The Qc3 library requires a minimum key length depending on the target
-  hash algorithm. Append binary zeroes to the given key if not long enough.
-  This matches RFC 2104 specifications.
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3: Slave descriptor for key encryption key
-  
-  The Qc3 library requires the key encryption key to exist as long as
-  the encrypted key is used. Its descriptor token is then kept as an
-  "encrypted key slave" for recursive release.
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3.c: comment PEM/DER decoding
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3.c: improve ASN.1 header byte checks
-
-- [Patrick Monnerat brought this change]
-
-  os400qc3.c: improve OID matching
-
-- [Patrick Monnerat brought this change]
-
-  os400: os400qc3.c: replace malloc by LIBSSH2_ALLOC or alloca where possible
-
-- [Patrick Monnerat brought this change]
-
-  os400: asn1_new_from_bytes(): use data from a single element only
-
-- [Patrick Monnerat brought this change]
-
-  os400: fix an ILE/RPG prototype
-
-- [Patrick Monnerat brought this change]
-
-  os400: implement character encoding conversion support
-
-- [Patrick Monnerat brought this change]
-
-  os400: do not miss some external prototypes
-  
-  Build procedure extproto() did not strip braces from header files, thus
-  possibly prepended them to true prototypes. This prevented the prototype to
-  be recognized as such.
-  The solution implemented here is to map braces to semicolons, effectively
-  considering them as potential prototype delimiters.
-
-- [Patrick Monnerat brought this change]
-
-  os400: Really add specific README
-
-- [Patrick Monnerat brought this change]
-
-  os400: Add specific README and include new files in dist tarball
-
-- [Patrick Monnerat brought this change]
-
-  os400: add compilation scripts
-
-- [Patrick Monnerat brought this change]
-
-  os400: include files for ILE/RPG
-  
-  In addition, file os400/macros.h declares all procedures originally
-  defined as macros. It must not be used for real inclusion and is only
-  intended to be used as a `database' for macro wrapping procedures generation.
-
-- [Patrick Monnerat brought this change]
-
-  os400: add supplementary header files/wrappers. Define configuration.
-
-- [Patrick Monnerat brought this change]
-
-  Protect callback function calls from macro substitution
-  
-  Some structure fields holding callback addresses have the same name as the
-  underlying system function (connect, send, recv). Set parentheses around
-  their reference to suppress a possible macro substitution.
-  
-  Use a macro for connect() on OS/400 to resolve a const/nonconst parameter
-  problem.
-
-- [Patrick Monnerat brought this change]
-
-  Add interface for OS/400 crypto library QC3
-
-- [Patrick Monnerat brought this change]
-
-  misc: include stdarg.h for debug code
-
-- [Patrick Monnerat brought this change]
-
-  Document crypto library interface
-
-- [Patrick Monnerat brought this change]
-
-  Feature an optional crypto-specific macro to rsa sign a data fragment vector
-  
-  OS/400 crypto library is unable to sign a precomputed SHA1 hash: however
-  it does support a procedure that hashes data fragments and rsa signs.
-  If defined, the new macro _libssh2_rsa_sha1_signv() implements this function
-  and disables use of _libssh2_rsa_sha1_sign().
-  
-  The function described above requires that the struct iovec unused slacks are
-  cleared: for this reason, macro libssh2_prepare_iovec() has been introduced.
-  It should be defined as empty for crypto backends that are not sensitive
-  to struct iovec unused slack values.
-
-- [Patrick Monnerat brought this change]
-
-  Fold long lines in include files
-
-- [Viktor Szakats brought this change]
-
-  kex.c: fix indentation
-  
-  Closes #71
-
-- [Viktor Szakats brought this change]
-
-  add OpenSSL-1.1.0-pre2 compatibility
-  
-  Closes #70
-
-- [Viktor Szakats brought this change]
-
-  add OpenSSL 1.1.0-pre1 compatibility
-  
-  * close https://github.com/libssh2/libssh2/issues/69
-  * sync a declaration with the rest of similar ones
-  * handle EVP_MD_CTX_new() returning NULL with OpenSSL 1.1.0
-  * fix potential memory leak with OpenSSL 1.1.0 in
-    _libssh2_*_init() functions, when EVP_MD_CTX_new() succeeds,
-    but EVP_DigestInit() fails.
-
-Marc Hoersken (22 Dec 2015)
-- wincng.c: fixed _libssh2_wincng_hash_final return value
-  
-  _libssh2_wincng_hash_final was returning the internal BCRYPT
-  status code instead of a valid libssh2 return value (0 or -1).
-  
-  This also means that _libssh2_wincng_hash never returned 0.
-
-- wincng.c: fixed possible memory leak in _libssh2_wincng_hash
-  
-  If _libssh2_wincng_hash_update failed _libssh2_wincng_hash_final
-  would never have been called before.
-  
-  Reported by Zenju.
-
-Kamil Dudka (15 Dec 2015)
-- [Paul Howarth brought this change]
-
-  libssh2.pc.in: fix the output of pkg-config --libs
-  
-  ... such that it does not include LDFLAGS used to build libssh2 itself.
-  There was a similar fix in the curl project long time ago:
-  
-  https://github.com/bagder/curl/commit/curl-7_19_7-56-g4c8adc8
-  
-  Bug: https://bugzilla.redhat.com/1279966
-  Signed-off-by: Kamil Dudka <kdudka@redhat.com>
-
-Marc Hoersken (6 Dec 2015)
-- hostkey.c: align code path of ssh_rsa_init to ssh_dss_init
-
-- hostkey.c: fix invalid memory access if libssh2_dsa_new fails
-  
-  Reported by dimmaq, fixes #66
-
-Daniel Stenberg (3 Nov 2015)
-- [Will Cosgrove brought this change]
-
-  gcrypt: define libssh2_sha256_ctx
-  
-  Looks like it didn't make it into the latest commit for whatever reason.
-  
-  Closes #58
-
-- [Salvador Fandino brought this change]
-
-  libssh2_session_set_last_error: Add function
-  
-  Net::SSH2, the Perl wrapping module for libssh2 implements several features*
-  on top of libssh2 that can fail and so need some mechanism to report the error
-  condition to the user.
-  
-  Until now, besides the error state maintained internally by libssh2, another
-  error state was maintained at the Perl level for every session object and then
-  additional logic was used to merge both error states. That is a maintenance
-  nighmare, and actually there is no way to do it correctly and consistently.
-  
-  In order to allow the high level language to add new features to the library
-  but still rely in its error reporting features the new function
-  libssh2_session_set_last_error (that just exposses _libssh2_error_flags) is
-  introduced.
-  
-  *) For instance, connecting to a remote SSH service giving the hostname and
-  port.
-  
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
-
-- [Salvador Fandino brought this change]
-
-  _libssh2_error: Support allocating the error message
-  
-  Before this patch "_libssh2_error" required the error message to be a
-  static string.
-  
-  This patch adds a new function "_libssh2_error_flags" accepting an
-  additional "flags" argument and specifically the flag
-  "LIBSSH2_ERR_FLAG_DUP" indicating that the passed string must be
-  duplicated into the heap.
-  
-  Then, the method "_libssh2_error" has been rewritten to use that new
-  function under the hood.
-  
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-  Signed-off-by: Salvador Fandiño <sfandino@yahoo.com>
-
-- [Will Cosgrove brought this change]
-
-  added engine.h include to fix warning
-
-- [sune brought this change]
-
-  kex.c: removed dupe entry from libssh2_kex_methods[]
-  
-  Closes #51
-
-- [Salvador Fandiño brought this change]
-
-  userauth: Fix off by one error when reading public key file
-  
-  After reading the public key from file the size was incorrectly
-  decremented by one.
-  
-  This was usually a harmless error as the last character on the public
-  key file is an unimportant EOL. But if due to some error the public key
-  file is empty, the public key size becomes (uint)(0 - 1), resulting in
-  an unrecoverable out of memory error later.
-  
-  Signed-off-by: Salvador Fandi??o <sfandino-/E1597aS9LQAvxtiuMwx3w@public.gmane.org>
-
-- [Salvador Fandino brought this change]
-
-  channel: Detect bad usage of libssh2_channel_process_startup
-  
-  A common novice programmer error (at least among those using the
-  wrapping Perl module Net::SSH2), is to try to reuse channels.
-  
-  This patchs detects that incorrect usage and fails with a
-  LIBSSH2_ERROR_BAD_USE error instead of hanging.
-  
-  Signed-off-by: Salvador Fandino <sfandino-/E1597aS9LQAvxtiuMwx3w@public.gmane.org>
-
-- [Will Cosgrove brought this change]
-
-  kex: Added diffie-hellman-group-exchange-sha256 support
-  
-  ... and fixed HMAC_Init depricated usage
-  
-  Closes #48
-
-Alexander Lamaison (21 Sep 2015)
-- Prefixed new #defines to prevent collisions.
-  
-  Other libraries might have their own USE_WIN32_*FILES.
-
-- [keith-daigle brought this change]
-
-  Update examples/scp.c to fix bug where large files on win32 would cause got to wrap and go negative
-
-- [David Byron brought this change]
-
-  add libssh2_scp_recv2 to support large (> 2GB) files on windows
-
-Daniel Stenberg (17 Sep 2015)
-- [sune brought this change]
-
-  WinCNG: support for SHA256/512 HMAC
-  
-  Closes #47
-
-- [brian m. carlson brought this change]
-
-  Add support for HMAC-SHA-256 and HMAC-SHA-512.
-  
-  Implement support for these algorithms and wire them up to the libgcrypt
-  and OpenSSL backends.  Increase the maximum MAC buffer size to 64 bytes
-  to prevent buffer overflows.  Prefer HMAC-SHA-256 over HMAC-SHA-512, and
-  that over HMAC-SHA-1, as OpenSSH does.
-  
-  Closes #40
-
-- [Zenju brought this change]
-
-  kex: free server host key before allocating it (again)
-  
-  Fixes a memory leak when Synology server requests key exchange
-  
-  Closes #43
-
-- [Viktor Szakats brought this change]
-
-  GNUmakefile: up OpenSSL version
-  
-  closes #23
-
-- [Viktor Szakats brought this change]
-
-  GNUmakefile: add -m64 CFLAGS when targeting mingw64, add -m32/-m64 to LDFLAGS
-  
-  libssh2 equivalent of curl patch https://github.com/bagder/curl/commit/d21b66835f2af781a3c2a685abc92ef9f0cd86be
-  
-  This allows to build for the non-default target when using a multi-target mingw distro.
-  Also bump default OpenSSL dependency path to 1.0.2c.
-
-- [Viktor Szakats brought this change]
-
-  GNUmakefile: add support for LIBSSH2_LDFLAG_EXTRAS
-  
-  It is similar to existing LIBSSH2_CFLAG_EXTRAS, but for
-  extra linker options.
-  
-  Also delete some line/file ending whitespace.
-  
-  closes #27
-
-- [nasacj brought this change]
-
-  hostkey.c: Fix compiling error when OPENSSL_NO_MD5 is defined
-  
-  Closes #32
-
-- [Mizunashi Mana brought this change]
-
-  openssl.h: adjust the rsa/dsa includes
-  
-  ... to work when built without DSA support.
-  
-  Closes #36
-
-Alexander Lamaison (26 Jul 2015)
-- Let CMake build work as a subproject.
-  
-  Patch contributed by JasonHaslam.
-
-- Fix builds with Visual Studio 2015.
-  
-  VS2015 moved stdio functions to the header files as inline function.  That means check_function_exists can't detect them because it doesn't use header files - just does a link check.  Instead we need to use check_symbol_exists with the correct headers.
-
-Kamil Dudka (2 Jul 2015)
-- cmake: include CMake files in the release tarballs
-  
-  Despite we announced the CMake support in libssh2-1.6.0 release notes,
-  the files required by the CMake build system were not included in the
-  release tarballs.  Hence, the only way to use CMake for build was the
-  upstream git repository.
-  
-  This commit makes CMake actually supported in the release tarballs.
-
-- tests/mansyntax.sh: fix 'make distcheck' with recent autotools
-  
-  Do not create symbolic links off the build directory.  Recent autotools
-  verify that out-of-source build works even if the source directory tree
-  is not writable.
-
-- openssl: fix memleak in _libssh2_dsa_sha1_verify()
-
-Daniel Stenberg (12 Jun 2015)
-- openssl: make libssh2_sha1 return error code
-  
-  - use the internal prefix _libssh2_ for non-exported functions
-  
-  - removed libssh2_md5() since it wasn't used
-  
-  Reported-by: Kamil Dudka
-
-- [LarsNordin-LNdata brought this change]
-
-  SFTP: Increase speed and datasize in SFTP read
-  
-  The function sftp_read never return more then 2000 bytes (as it should
-  when I asked Daniel). I increased the MAX_SFTP_READ_SIZE to 30000 but
-  didn't get the same speed as a sftp read in SecureSSH. I analyzed the
-  code and found that a return always was dona when a chunk has been read.
-  I changed it to a sliding buffer and worked on all available chunks. I
-  got an increase in speed and non of the test I have done has failed
-  (both local net and over Internet). Please review and test. I think
-  30000 is still not the optimal MAX_SFTP_READ_SIZE, my next goal is to
-  make an API to enable changing this value (The SecureSSH sftp_read has
-  more complete filled packages when comparing the network traffic)
-
-- bump: start working on 1.6.1
-
-Version 1.6.0 (5 Jun 2015)
-
-Daniel Stenberg (5 Jun 2015)
-- RELEASE-NOTES: synced with 858930cae5c6a
-
-Marc Hoersken (19 May 2015)
-- wincng.c: fixed indentation
-
-- [sbredahl brought this change]
-
-  wincng.c: fixed memleak in (block) cipher destructor
-
-Alexander Lamaison (6 May 2015)
-- [Jakob Egger brought this change]
-
-  libssh2_channel_open: more detailed error message
-  
-  The error message returned by libssh2_channel_open in case of a server side channel open failure is now more detailed and includes the four standard error conditions in RFC 4254.
-
-- [Hannes Domani brought this change]
-
-  kex: fix libgcrypt memory leaks of bignum
-  
-  Fixes #168.
-
-Marc Hoersken (3 Apr 2015)
-- configure.ac: check for SecureZeroMemory for clear memory feature
-
-- Revert "wincng.c: fix clear memory feature compilation with mingw"
-  
-  This reverts commit 2d2744efdd0497b72b3e1ff6e732aa4c0037fc43.
-  
-  Autobuilds show that this did not solve the issue.
-  And it seems like RtlFillMemory is defined to memset,
-  which would be optimized out by some compilers.
-
-- wincng.c: fix clear memory feature compilation with mingw
-
-Alexander Lamaison (1 Apr 2015)
-- [LarsNordin-LNdata brought this change]
-
-  Enable use of OpenSSL that doesn't have DSA.
-  
-  Added #if LIBSSH2_DSA for all DSA functions.
-
-- [LarsNordin-LNdata brought this change]
-
-  Use correct no-blowfish #define with OpenSSL.
-  
-  The OpenSSL define is OPENSSL_NO_BF, not OPENSSL_NO_BLOWFISH.
-
-Marc Hoersken (25 Mar 2015)
-- configure: error if explicitly enabled clear-memory is not supported
-  
-  This takes 22bd8d81d8fab956085e2079bf8c29872455ce59 and
-  b8289b625e291bbb785ed4add31f4759241067f3 into account,
-  but still makes it enabled by default if it is supported
-  and error out in case it is unsupported and was requested.
-
-Daniel Stenberg (25 Mar 2015)
-- configure: make clear-memory default but only WARN if backend unsupported
-  
-  ... instead of previous ERROR.
-
-Marc Hoersken (24 Mar 2015)
-- wincng.h: fix warning about computed return value not being used
-
-- nonblocking examples: fix warning about unused tvdiff on Mac OS X
-
-Daniel Stenberg (24 Mar 2015)
-- openssl: fix compiler warnings
-
-- cofigure: fix --disable-clear-memory check
-
-Marc Hoersken (23 Mar 2015)
-- scp.c: improved command length calculation
-  
-  Reduced number of calls to strlen, because shell_quotearg already
-  returns the length of the resulting string (e.q. quoted path)
-  which we can add to the existing and known cmd_len.
-  Removed obsolete call to memset again, because we can put a final
-  NULL-byte at the end of the string using the calculated length.
-
-- scp.c: improved and streamlined formatting
-
-- scp.c: fix that scp_recv may transmit not initialised memory
-
-- scp.c: fix that scp_send may transmit not initialised memory
-  
-  Fixes ticket 244. Thanks Torsten.
-
-- kex: do not ignore failure of libssh2_sha1_init()
-  
-  Based upon 43b730ce56f010e9d33573fcb020df49798c1ed8.
-  Fixes ticket 290. Thanks for the suggestion, mstrsn.
-
-- wincng.h: fix return code of libssh2_md5_init()
-
-- openssl.c: fix possible segfault in case EVP_DigestInit fails
-
-- wincng.c: fix possible use of uninitialized variables
-
-- wincng.c: fix unused argument warning if clear memory is not enabled
-
-- wincng: Added explicit clear memory feature to WinCNG backend
-  
-  This re-introduces the original feature proposed during
-  the development of the WinCNG crypto backend. It still needs
-  to be added to libssh2 itself and probably other backends.
-  
-  Memory is cleared using the function SecureZeroMemory which is
-  available on Windows systems, just like the WinCNG backend.
-
-- wincng.c: fixed mixed line-endings
-
-- wincng.c: fixed use of invalid parameter types in a8d14c5dcf
-
-- wincng.c: only try to load keys corresponding to the algorithm
-
-- wincng.c: moved PEM headers into definitions
-
-- wincng.h: fixed invalid parameter name
-
-- wincng: fixed mismatch with declarations in crypto.h
-
-- userauth.c: fixed warning C6001: using uninitialized sig and sig_len
-
-- pem.c: fixed warning C6269: possible incorrect order of operations
-
-- wincng: add support for authentication keys to be passed in memory
-  
-  Based upon 18cfec8336e and daa2dfa2db.
-
-- pem.c: add _libssh2_pem_parse_memory to parse PEM from memory
-  
-  Requirement to implement 18cfec8336e for Libgcrypt and WinCNG.
-
-- pem.c: fix copy and paste mistake from 55d030089b8
-
-- userauth.c: fix another possible dereference of a null pointer
-
-- userauth.c: fix possible dereference of a null pointer
-
-- pem.c: reduce number of calls to strlen in readline
-
-Alexander Lamaison (17 Mar 2015)
-- [Will Cosgrove brought this change]
-
-  Initialise HMAC_CTX in more places.
-  
-  Missed a couple more places we init ctx to avoid openssl threading crash.
-
-- Build build breakage in WinCNG backend caused when adding libssh2_userauth_publickey_frommemory.
-  
-  The new feature isn't implemented for the WinCNG backend currently, but the WinCNG backend didn't contain any implementation of the required backend functions - even ones that returns an error.  That caused link errors.
-  
-  This change fixes the problem by providing an implementation of the backend functions that returns an error.
-
-- Fix breakage in WinCNG backend caused by introducing libssh2_hmac_ctx_init.
-  
-  The macro was defined to nothing for the libgcrypt backend, but not for WinCNG.  This brings the latter into line with the former.
-
-Daniel Stenberg (15 Mar 2015)
-- userauth_publickey_frommemory.3: add AVAILABILITY
-  
-  ... it will be added in 1.6.0
-
-- libssh2: next version will be called 1.6.0
-  
-  ... since we just added a new function.
-
-- docs: add libssh2_userauth_publickey_frommemory.3 to dist
-  
-  The function and man page were added in commit 18cfec8336e
-
-- [Jakob Egger brought this change]
-
-  direct_tcpip: Fixed channel write
-  
-  There were 3 bugs in this loop:
-  1) Started from beginning after partial writes
-  2) Aborted when 0 bytes were sent
-  3) Ignored LIBSSH2_ERROR_EAGAIN
-  
-  See also:
-  https://trac.libssh2.org/ticket/281
-  https://trac.libssh2.org/ticket/293
-
-Alexander Lamaison (15 Mar 2015)
-- [Will Cosgrove brought this change]
-
-  Must init HMAC_CTX before using it.
-  
-  Must init ctx before using it or openssl will reuse the hmac which is not thread safe and causes a crash.
-  Added libssh2_hmac_ctx_init macro.
-
-- Add continuous integration configurations.
-  
-  Linux-based CI is done by Travis CI.  Windows-based CI is done by Appveyor.
-
-- [David Calavera brought this change]
-
-  Allow authentication keys to be passed in memory.
-  
-  All credits go to Joe Turpin, I'm just reaplying and cleaning his patch:
-  http://www.libssh2.org/mail/libssh2-devel-archive-2012-01/0015.shtml
-  
-  * Use an unimplemented error for extracting keys from memory with libgcrypt.
-
-Daniel Stenberg (14 Mar 2015)
-- docs: include the renamed INSTALL* files in dist
-
-Alexander Lamaison (13 Mar 2015)
-- Prevent collisions between CMake and Autotools in examples/ and tests/.
-
-- Avoid clash between CMake build and Autotools.
-  
-  Autotools expects a configuration template file at src/libssh2_config.h.in, which buildconf generates.  But the CMake build system has its CMake-specific version of the file at this path.  This means that, if you don't run buildconf, the Autotools build will fail because it configured the wrong header template.
-  
-  See https://github.com/libssh2/libssh2/pull/8.
-
-- Merge pull request #8 from alamaison/cmake
-  
-  CMake build system.
-
-- CMake build system.
-  
-  Tested:
-   - Windows:
-      - Visual C++ 2005/2008/2010/2012/2013/MinGW-w64
-      - static/shared
-      - 32/64-bit
-      - OpenSSL/WinCNG
-      - Without zlib
-   - Linux:
-      - GCC 4.6.3/Clang 3.4
-      - static/shared
-      - 32/64-bit
-      - OpenSSL/Libgcrypt
-      - With/Without zlib
-   - MacOS X
-      - AppleClang 6.0.0
-      - static
-      - 64-bit
-      - OpenSSL
-      - Without zlib
-  
-  Conflicts:
-          README
-
-- Man man syntax tests fail gracefully if man version is not suitable.
-
-- Return valid code from test fixture on failure.
-  
-  The sshd test fixture was returning -1 if an error occurred, but negative error codes aren't technically valid (google it).  Bash on Windows converted them to 0 which made setup failure look as though all tests were passing.
-
-- Let mansyntax.sh work regardless of where it is called from.
-
-Daniel Stenberg (12 Mar 2015)
-- [Viktor Szakáts brought this change]
-
-  mingw build: allow to pass custom CFLAGS
-  
-  Allow to pass custom `CFLAGS` options via environment variable
-  `LIBSSH2_CFLAG_EXTRAS`. Default and automatically added options of
-  `GNUmakefile` have preference over custom ones. This addition is useful
-  for passing f.e. custom CPU tuning or LTO optimization (`-flto
-  -ffat-lto-objects`) options. The only current way to do this is to edit
-  `GNUmakefile`. This patch makes it unnecessary.
-  
-  This is a mirror of similar libcurl patch:
-  https://github.com/bagder/curl/pull/136
-
-- [Will Cosgrove brought this change]
-
-  userauth: Fixed prompt text no longer being copied to the prompts struct
-  
-  Regression from 031566f9c
-
-- README: update the git repo locations
-
-- wait_socket: wrong use of difftime()
-  
-  With reversed arguments it would always return a negative value...
-  
-  Bug: https://github.com/bagder/libssh2/issues/1
-
-- bump: start working toward 1.5.1 now
-
-Version 1.5.0 (11 Mar 2015)
-
-Daniel Stenberg (11 Mar 2015)
-- RELEASE-NOTES: 1.5.0 release
-
-- [Mariusz Ziulek brought this change]
-
-  kex: bail out on rubbish in the incoming packet
-  
-  CVE-2015-1782
-  
-  Bug: http://www.libssh2.org/adv_20150311.html
-
-- docs: move INSTALL, AUTHORS, HACKING and TODO to docs/
-  
-  And with this, cleanup README to be shorter and mention the new source
-  code home.
-
-- .gitignore: don't ignore INSTALL
-
-Dan Fandrich (4 Mar 2015)
-- examples/x11.c: include sys/select.h for improved portability
-
-Daniel Stenberg (4 Mar 2015)
-- RELEASE-NOTES: synced with a8473c819bc068
-  
-  In preparation for the upcoming 1.5.0 release.
-
-Guenter Knauf (8 Jan 2015)
-- NetWare build: added some missing exports.
-
-Marc Hoersken (29 Dec 2014)
-- knownhost.c: fix use of uninitialized argument variable wrote
-  
-  Detected by clang scan in       line 1195, column 18.
-
-- examples/x11.c: fix result of operation is garbage or undefined
-  
-  Fix use of uninitialized structure w_size_bck.
-  Detected by clang scan in       line 386, column 28.
-
-- examples/x11.c: remove dead assigments of some return values
-  
-  Detected by clang scan in line 212, column 9.
-  Detected by clang scan in line 222, column 13.
-  Detected by clang scan in       line 410, column 13.
-
-- examples/x11.c: fix possible memory leak if read fails
-  
-  Detected by clang scan in line 224, column 21.
-
-- examples/x11.c: fix invalid removal of first list element
-  
-  Fix use of memory after it was being freed.
-  Detected by clang scan in line 56, column 12.
-
-- userauth.c: make sure that sp_len is positive and avoid overflows
-  
-  ... if the pointer subtraction of sp1 - pubkey - 1 resulted in a
-  negative or larger value than pubkey_len, memchr would fail.
-  
-  Reported by Coverity CID 89846.
-
-- channel.c: remove logically dead code, host cannot be NULL here
-  
-  ... host cannot be NULL in line 525, because it is always
-  valid (e.g. at least set to "0.0.0.0") after lines 430 and 431.
-  
-  Reported by Coverity CID 89807.
-
-- session.c: check return value of session_nonblock during startup
-  
-  Reported by Coverity CID 89803.
-
-- session.c: check return value of session_nonblock in debug mode
-  
-  Reported by Coverity CID 89805.
-
-- pem.c: fix mixed line-endings introduced with 8670f5da24
-
-- pem.c: make sure there's a trailing zero and b64data is not NULL
-  
-  ... if there is no base64 data between PEM header and footer.
-  Reported by Coverity CID 89823.
-
-- kex.c: make sure mlist is not set to NULL
-  
-  ... if the currently unsupported LANG methods are called.
-  Reported by Coverity CID 89834.
-
-- packet.c: i < 256 was always true and i would overflow to 0
-  
-  Visualize that the 0-termination is intentional, because the array
-  is later passed to strlen within _libssh2_packet_askv.
-
-- silence multiple data conversion warnings
-
-Daniel Stenberg (23 Dec 2014)
-- agent_connect_unix: make sure there's a trailing zero
-  
-  ... if the path name was too long. Reported by Coverity CID 89801.
-
-Marc Hoersken (22 Dec 2014)
-- examples on Windows: use native SOCKET-type instead of int
-  
-  And check return values accordingly.
-
-- userauth.c: improve readability and clarity of for-loops
-
-Daniel Stenberg (22 Dec 2014)
-- calloc: introduce LIBSSH2_CALLOC()
-  
-  A simple function using LIBSSH2_ALLOC + memset, since this pattern was
-  used in multiple places and this simplies code in general.
-
-Marc Hoersken (15 Dec 2014)
-- libssh2_priv.h: Ignore session, context and format parameters
-
-- x11 example: check return value of socket function
-
-- examples: fixed mixed line-endings introduced with aedfba25b8
-
-- wincng.c: explicitly ignore BCrypt*AlgorithmProvider return codes
-  
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
-
-- wincng.c: fix possible invalid memory write access
-  
-  Fixes VS2012 code analysis warning C6386:
-  buffer overrun: accessing 'pbOutput', the writable size is
-  'cbOutput' bytes, but '3' bytes may be written: libssh2 wincng.c 610
-
-- tests on Windows: check for WSAStartup return code
-  
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
-
-- wincng.c: fix possible NULL pointer de-reference of bignum
-  
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'bignum'. libssh2 wincng.c 1567
-
-- wincng.c: fix possible use of uninitialized memory
-  
-  Fixes VS2012 code analysis warning C6001:
-  using uninitialized memory 'cbDecoded'. libssh2 wincng.c 553
-
-- packet.c: fix possible NULL pointer de-reference within listen_state
-  
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'listen_state->channel'. libssh2 packet.c 221
-
-- kex.c: fix possible NULL pointer de-reference with session->kex
-  
-  Fixes VS2012 code analysis warning C6011:
-  dereferencing NULL pointer 'session->kex'. libssh2 kex.c 1761
-
-- agent.c: check return code of MapViewOfFile
-  
-  Fixes VS2012 code analysis warning C6387: 'p+4' may be '0':
-  this does not adhere to the specification for the function
-  'memcpy': libssh2 agent.c 330
-  
-  Fixes VS2012 code analysis warning C6387: 'p' may be '0':
-  this does not adhere to the specification for the function
-  'UnmapViewOfFile': libssh2 agent.c 333
-
-- examples on Windows: check for socket return code
-  
-  Fixes VS2012 code analysis warning C28193:
-  The variable holds a value that must be examined
-
-- examples on Windows: check for WSAStartup return code
-  
-  Fixes VS2012 code analysis warning C6031:
-  return value ignored: <function> could return unexpected value
-
-Guenter Knauf (11 Dec 2014)
-- wincng.c: silent some more gcc compiler warnings.
-
-- wincng.c: silent gcc compiler warnings.
-
-- Watcom build: added support for WinCNG build.
-
-- build: updated dependencies in makefiles.
-
-Daniel Stenberg (4 Dec 2014)
-- configure: change LIBS not LDFLAGS when checking for libs
-  
-  Closes #289
-  
-  Patch-by: maurerpe
-
-Guenter Knauf (3 Dec 2014)
-- MinGW build: some more GNUMakefile tweaks.
-  
-  test/GNUmakefile: added architecture autodetection; added switches to
-  CFLAGS and RCFLAGS to make sure that the right architecture is used.
-  Added support to build with WinCNG.
-
-- sftpdir.c: added authentication method detection.
-  
-  Stuff copied over from ssh2.c to make testing a bit easier.
-
-- NMake build: fixed LIBS settings.
-
-- NMake build: added support for WinCNG build.
-
-- MinGW build: some GNUMakefile tweaks.
-  
-  Added architecture autodetection; added switches to CFLAGS and
-  RCFLAGS to make sure that the right architecture is used.
-  Added support to build with WinCNG.
-
-- MinGW build: Fixed redefine warnings.
-
-- Updated copyright year.
-
-Daniel Stenberg (31 Aug 2014)
-- COPYING: bump the copyright year
-
-Dan Fandrich (28 Jul 2014)
-- docs: fixed a bunch of typos
-
-- docs: added missing libssh2_session_handshake.3 file
-
-Marc Hoersken (19 May 2014)
-- wincng.c: specify the required libraries for dependencies using MSVC
-  
-  Initially reported by Bob Kast as "for MS VS builds, specify the
-  libraries that are required so they don't need to go into all
-  project files that may use this library". Thanks a lot.
-
-- [Bob Kast brought this change]
-
-  windows build: do not export externals from static library
-  
-  If you are building a DLL, then you need to explicitly export each
-  entry point. When building a static library, you should not.
-  
-  libssh2 was exporting the entry points whether it was building a DLL or a
-  static library. To elaborate further, if libssh2 was used as a static
-  library, which was being linked into a DLL, the libssh2 API would be
-  exported from that separate DLL.
-
-Daniel Stenberg (19 May 2014)
-- [Mikhail Gusarov brought this change]
-
-  Fix typos in manpages
-
-Marc Hoersken (18 May 2014)
-- wincng.c: Fixed memory leak in case of an error during ASN.1 decoding
-
-- configure: Display individual crypto backends on separate lines
-  
-  This avoids line-wrapping in between parameters and makes the
-  error message look like the following:
-  
-  configure: error: No crypto library found!
-  Try --with-libssl-prefix=PATH
-   or --with-libgcrypt-prefix=PATH
-   or --with-wincng on Windows
-
-- [Bob Kast brought this change]
-
-  libssh2_priv.h: a 1 bit bit-field should be unsigned
-  
-  some compilers may not like this
-
-- knownhost.c: Fixed warning that pointer targets differ in signedness
-
-- wincng.c: Fixed warning about pointer targets differing in signedness
-
-- tcpip-forward.c: Fixed warning that pointer targets differ in signedness
-  
-  libssh2_channel_forward_listen_ex uses ints instead of unsigned ints.
-
-- misc.c: Fixed warning about mixed declarations and code
-
-- libgcrypt.h: Fixed warning about pointer targets differing in signedness
-
-- wincng.h: Fixed warning about pointer targets differing in signedness
-
-- misc.c: Fixed warning about unused parameter abstract
-
-- tcpip-forward.c: Removed unused variables shost, sport and sockopt
-
-- wincng.h: Added forward declarations for all WinCNG functions
-  
-  Initially reported by Bob Kast as "Wincng - define function
-  prototypes for wincng routines". Thanks a lot.
-  
-  Also replaced structure definitions with type definitions.
-
-- [Bob Kast brought this change]
-
-  libssh2.h: on Windows, a socket is of type SOCKET, not int
-
-- win32: Added WinCNG targets to generated Visual Studio project
-  
-  Inspired by Bob Kast's reports, this commit enables the compilation
-  of libssh2 with WinCNG using the generated Visual Studio project files.
-  This commit adds WinCNG support to parts of the existing Win32 build
-  infrastructure, until new build systems, like pre-defined VS project
-  files or CMake files may be added.
-  
-  This commit and b20bfeb3e519119a48509a1099c06d65aa7da1d7 raise one
-  question: How to handle build systems, like VS project files, that
-  need to include all source files regardless of the desired target,
-  including all supported crypto backends? For now the mentioned commit
-  added a check for LIBSSH2_OPENSSL to openssl.c and with this commit
-  the supported crypto backends are hardcoded within Makefile.am.
-
-- libssh2_priv msvc: Removed redundant definition of inline keyword
-  
-  Initially reported by Bob Kast as "Remove redundant 'inline' define".
-  Thanks a lot.
-
-- wincng: Made data parameter to hash update function constant
-  
-  Initially reported by Bob Kast as "formal parameter must be const
-  since it is used in contexts where the actual parameter may be const".
-  Thanks a lot.
-
-- wincng: fix cross-compilation against the w64 mingw-runtime package
-
-- openssl: Check for LIBSSH2_OPENSSL in order to compile with openssl
-
-- wincng: Fixed use of possible uninitialized variable pPaddingInfo
-  
-  Reported by Bob Kast, thanks a lot.
-
-- wincng: Added cast for double to unsigned long conversion
-
-- wincng: Cleaned up includes and check NTSTATUS using macro
-  
-  Removed header file combination that is not supported on a real
-  Windows platform and can only be compiled using MinGW. Replaced
-  custom NTSTATUS return code checks with BCRYPT_SUCCESS macro.
-
-Daniel Stenberg (16 Mar 2014)
-- userauth_hostbased_fromfile: zero assign to avoid uninitialized use
-  
-  Detected by clang-analyze
-
-- channel_receive_window_adjust: store windows size always
-  
-  Avoid it sometimes returning without storing it, leaving calling
-  functions with unknown content!
-  
-  Detected by clang-analyzer
-
-- publickey_packet_receive: avoid junk in returned pointers
-  
-  clang-analyzer found this risk it would return a non-initialized pointer
-  in a success case
-
-Peter Stuge (16 Mar 2014)
-- [Marc Hoersken brought this change]
-
-  Added Windows Cryptography API: Next Generation based backend
-
-- [Marc Hoersken brought this change]
-
-  knownhost.c: fixed that 'key_type_len' may be used uninitialized
-  
-  ../src/knownhost.c: In function 'libssh2_knownhost_readline':
-  ../src/knownhost.c:651:16: warning: 'key_type_len' may be used
-  uninitialized in this function [-Wmaybe-uninitialized]
-               rc = knownhost_add(hosts, hostbuf, NULL,
-                  ^
-  ../src/knownhost.c:745:12: note: 'key_type_len' was declared here
-       size_t key_type_len;
-              ^
-
-- [Marc Hoersken brought this change]
-
-  pem.c: always compile pem.c independently of crypto backend
-
-- Fix non-autotools builds: Always define the LIBSSH2_OPENSSL CPP macro
-  
-  Commit d512b25f69a1b6778881f6b4b5ff9cfc6023be42 introduced a crypto
-  library abstraction in the autotools build system, to allow us to more
-  easily support new crypto libraries. In that process it was found that
-  all other build system which we support are hard-coded to build with
-  OpenSSL. Commit f5c1a0d98bd51aeb24aca3d49c7c81dcf8bd858d fixes automake
-  introduced into non-autotools build systems but still overlooked the
-  CPP macro saying that we are using OpenSSL.
-  
-  Thanks to Marc Hörsken for identifying this issue and proposing a fix
-  for win32/{GNUmakefile,config.mk}. This commit uses a slightly different
-  approach but the end result is the same.
-
-Dan Fandrich (15 Mar 2014)
-- channel_close: Close the channel even in the case of errors
-
-- sftp_close_handle: ensure the handle is always closed
-  
-  Errors are reported on return, but otherwise the close path is
-  completed as much as possible and the handle is freed on exit.
-
-Alexander Lamaison (6 Mar 2014)
-- knownhost: Restore behaviour of `libssh2_knownhost_writeline` with short buffer.
-  
-  Commit 85c6627c changed the behaviour of `libssh2_knownhost_writeline` so that it stopped returning the number of bytes needed when the given buffer was too small.  Also, the function changed such that is might write to part of the buffer before realising it is too small.
-  
-  This commit restores the original behaviour, whilst keeping the unknown-key-type functionality that 85c6627c.  Instead of writing to the buffer piecemeal, the length of the various parts is calculated up front and the buffer written only if there is enough space.  The calculated necessary size is output in `outlen` regardless of whether the buffer was written to.
-  
-  The main use-case for the original behaviour that this commit restores is to allow passing in a NULL buffer to get the actual buffer size needed, before calling the function again with the buffer allocated to the exact size required.
-
-- knownhost: Fix DSS keys being detected as unknown.
-  
-  I missing `else` meant ssh-dss format keys were being re-detected as unknown format.
-
-Dan Fandrich (6 Mar 2014)
-- knownhosts: Abort if the hosts buffer is too small
-  
-  This could otherwise cause a match on the wrong host
-
-- agent_list_identities: Fixed memory leak on OOM
-
-- Fixed a few typos
-
-- userauth: Fixed an attempt to free from stack on error
-
-- Fixed a few memory leaks in error paths
-
-- Fixed two potential use-after-frees of the payload buffer
-  
-  The first might occur if _libssh2_packet_add returns an error, as
-  fullpacket_state wasn't reset to idle so if it were possible for
-  fullpacket to be called again, it would return to the same state
-  handler and re-use the freed p->packet buffer.
-  
-  The second could occur if decrypt returned an error, as it freed the
-  packet buffer but did not clear total_num, meaning that freed buffer
-  could be written into again later.
-
-Alexander Lamaison (28 Nov 2013)
-- Fix missing `_libssh2_error` in `_libssh2_channel_write`.
-  
-  In one case, the error code from `_libssh2_transport_read` was being returned from `_libssh2_channel_write` without setting it as the last error by calling `_libssh2_error`.  This commit fixes that.
-  
-  Found when using a session whose socket had been inadvertently destroyed.  The calling code got confused because via `libssh2_session_last_error` it appeared no error had occurred, despite one being returned from the previous function.
-
-Kamil Dudka (21 Nov 2013)
-- [Mark McPherson brought this change]
-
-  openssl: initialise the digest context before calling EVP_DigestInit()
-  
-  When using the OpenSSL libraries in FIPS mode, the function call
-  EVP_DigestInit() is actually #defined to FIPS_digestinit().
-  Unfortunately wheres EVP_DigestInit() initialises the context and then
-  calls EVP_DigestInit_ex(), this function assumes that the context has
-  been pre-initialised and crashes when it isn't.
-  
-  Bug: https://trac.libssh2.org/ticket/279
-  
-  Fixes #279
-
-- [Marc Hörsken brought this change]
-
-  .gitignore: Ignore files like src/libssh2_config.h.in~
-
-Peter Stuge (13 Nov 2013)
-- Move automake conditionals added by commit d512b25f out of Makefile.inc
-  
-  Commit d512b25f69a1b6778881f6b4b5ff9cfc6023be42 added automake
-  conditionals to Makefile.inc but since Makefile.inc is included
-  from Makefile for all other build systems that does not work.
-  
-  This commit instead adds Makefile.OpenSSL.inc and Makefile.libgcrypt.inc
-  and moves the automake conditional to its proper place, src/Makefile.am.
-  
-  The automake conditional includes the correct Makefile.$name.inc per
-  the crypto library selection/detection done by configure.
-  
-  All non-autotools build system files in libssh2 are hardcoded to use
-  OpenSSL and do not get a conditional but at least there is some reuse
-  because they can all include the new Makefile.OpenSSL.inc.
-
-Daniel Stenberg (27 Oct 2013)
-- [Salvador Fandino brought this change]
-
-  Set default window size to 2MB
-  
-  The default channel window size used until now was 256KB. This value is
-  too small and results on a bottleneck on real-life networks where
-  round-trip delays can easily reach 300ms.
-  
-  The issue was not visible because the configured channel window size
-  was being ignored and a hard-coded value of ~22MB being used instead,
-  but that was fixed on a previous commit.
-  
-  This patch just changes the default window size
-  (LIBSSH2_CHANNEL_WINDOW_DEFAULT) to 2MB. It is the same value used by
-  OpenSSH and in our opinion represents a good compromise between memory
-  used and transfer speed.
-  
-  Performance tests were run to determine the optimum value. The details
-  and related discussion are available from the following thread on the
-  libssh2 mailing-list:
-  
-  http://www.libssh2.org/mail/libssh2-devel-archive-2013-10/0018.shtml
-  http://article.gmane.org/gmane.network.ssh.libssh2.devel/6543
-  
-  An excerpt follows:
-  
-  "I have been running some transfer test and measuring their speed.
-  
-  My setup was composed of a quad-core Linux machine running Ubuntu 13.10
-  x86_64 with a LXC container inside. The data transfers were performed
-  from the container to the host (never crossing through a physical
-  network device).
-  
-  Network delays were simulated using the tc tool. And ping was used to
-  verify that they worked as intended during the tests.
-  
-  The operation performed was the equivalent to the following ssh command:
-  
-    $ ssh container "dd bs=16K count=8K if=/dev/zero" >/dev/null
-  
-  Though, establishment and closing of the SSH connection was excluded
-  from the timings.
-  
-  I run the tests several times transferring files of sizes up to 128MB
-  and the results were consistent between runs.
-  
-  The results corresponding to the 128MB transfer are available here:
-  
-  https://docs.google.com/spreadsheet/ccc?key=0Ao1yRmX6PQQzdG5wSFlrZl9HRWNET3ZyN0hnaGo5ZFE&usp=sharing
-  
-  It clearly shows that 256KB is too small as the default window size.
-  Moving to a 512MB generates a great improvement and after the 1MB mark
-  the returns rapidly diminish. Other factors (TCP window size, probably)
-  become more limiting than the channel window size
-  
-  For comparison I also performed the same transfers using OpenSSH. Its
-  speed is usually on par with that of libssh2 using a window size of 1MB
-  (even if it uses a 2MB window, maybe it is less aggressive sending the
-  window adjust msgs)."
-  
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-
-- [Salvador brought this change]
-
-  _libssh2_channel_read: Honour window_size_initial
-  
-  _libssh2_channel_read was using an arbitrary hard-coded limit to trigger
-  the window adjusting code. The adjustment used was also hard-coded and
-  arbitrary, 15MB actually, which would limit the usability of libssh2 on
-  systems with little RAM.
-  
-  This patch, uses the window_size parameter passed to
-  libssh2_channel_open_ex (stored as remote.window_size_initial) plus the
-  buflen as the base for the trigger and the adjustment calculation.
-  
-  The memory usage when using the default window size is reduced from 22MB
-  to 256KB per channel (actually, if compression is used, these numbers
-  should be incremented by ~50% to account for the errors between the
-  decompressed packet sizes and the predicted sizes).
-  
-  My tests indicate that this change does not impact the performance of
-  transfers across localhost or a LAN, being it on par with that of
-  OpenSSH. On the other hand, it will probably slow down transfers on
-  networks with high bandwidth*delay when the default window size
-  (LIBSSH2_CHANNEL_WINDOW_DEFAULT=256KB) is used.
-  
-  Signed-off-by: Salvador Fandino <sfandino@yahoo.com>
-
-- [Salvador Fandino brought this change]
-
-  knownhosts: handle unknown key types
-  
-  Store but don't use keys of unsupported types on the known_hosts file.
-  
-  Currently, when libssh2 parses a known_host file containing keys of some
-  type it doesn't natively support, it stops reading the file and returns
-  an error.
-  
-  That means, that the known_host file can not be safely shared with other
-  software supporting other key types (i.e. OpenSSH).
-  
-  This patch adds support for handling keys of unknown type. It can read
-  and write them, even if they are never going to be matched.
-  
-  At the source level the patch does the following things:
-  
-  - add a new unknown key type LIBSSH2_KNOWNHOST_KEY_UNKNOWN
-  
-  - add a new slot (key_type_name) on the known_host struct that is
-  used to store the key type in ascii form when it is not supported
-  
-  - parse correctly known_hosts entries with unknown key types and
-  populate the key_type_name slot
-  
-  - print correctly known_hosts entries of unknown type
-  
-  - when checking a host key ignore keys that do not match the key
-  
-  Fixes #276
-
-- windows build: fix build errors
-  
-  Fixes various link errors with VS2010
-  
-  Reported-by: "kdekker"
-  Fixes #272
-
-- man page: add missing function argument
-  
-  for libssh2_userauth_publickey_fromfile_ex()
-  
-  Reported-by: "pastey"
-  
-  Fixes #262
-
-- [Salvador brought this change]
-
-  Fix zlib deflate usage
-  
-  Deflate may return Z_OK even when not all data has been compressed
-  if the output buffer becomes full.
-  
-  In practice this is very unlikely to happen because the output buffer
-  size is always some KBs larger than the size of the data passed for
-  compression from the upper layers and I think that zlib never expands
-  the data so much, even on the worst cases.
-  
-  Anyway, this patch plays on the safe side checking that the output
-  buffer is not exhausted.
-  
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-- [Salvador brought this change]
-
-  comp_method_zlib_decomp: Improve buffer growing algorithm
-  
-  The old algorithm was O(N^2), causing lots and lots of reallocations
-  when highly compressed data was transferred.
-  
-  This patch implements a simpler one that just doubles the buffer size
-  everytime it is exhausted. It results in O(N) complexity.
-  
-  Also a smaller inflate ratio is used to calculate the initial size (x4).
-  
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-- [Salvador brought this change]
-
-  Fix zlib usage
-  
-  Data may remain in zlib internal buffers when inflate() returns Z_OK
-  and avail_out == 0. In that case, inflate has to be called again.
-  
-  Also, once all the data has been inflated, it returns Z_BUF_ERROR to
-  signal that the input buffer has been exhausted.
-  
-  Until now, the way to detect that a packet payload had been completely
-  decompressed was to check that no data remained on the input buffer
-  but that didn't account for the case where data remained on the internal
-  zlib buffers.
-  
-  That resulted in packets not being completely decompressed and the
-  missing data reappearing on the next packet, though the bug was masked
-  by the buffer allocation algorithm most of the time and only manifested
-  when transferring highly compressible data.
-  
-  This patch fixes the zlib usage.
-  
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-- [Salvador brought this change]
-
-  _libssh2_channel_read: fix data drop when out of window
-  
-  After filling the read buffer with data from the read queue, when the
-  window size was too small, "libssh2_channel_receive_window_adjust" was
-  called to increase it. In non-blocking mode that function could return
-  EAGAIN and, in that case, the EAGAIN was propagated upwards and the data
-  already read on the buffer lost.
-  
-  The function was also moving between the two read states
-  "libssh2_NB_state_idle" and "libssh2_NB_state_created" both of which
-  behave in the same way (excepting a debug statment).
-  
-  This commit modifies "_libssh2_channel_read" so that the
-  "libssh2_channel_receive_window_adjust" call is performed first (when
-  required) and if everything goes well, then it reads the data from the
-  queued packets into the read buffer.
-  
-  It also removes the useless "libssh2_NB_state_created" read state.
-  
-  Some rotted comments have also been updated.
-  
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-- [Salvador Fandino brought this change]
-
-  window_size: redid window handling for flow control reasons
-  
-  Until now, the window size (channel->remote.window_size) was being
-  updated just after receiving the packet from the transport layer.
-  
-  That behaviour is wrong because the channel queue may grow uncontrolled
-  when data arrives from the network faster that the upper layer consumes
-  it.
-  
-  This patch adds a new counter, read_avail, which keeps a count of the
-  bytes available from the packet queue for reading. Also, now the window
-  size is adjusted when the data is actually read by an upper layer.
-  
-  That way, if the upper layer stops reading data, the window will
-  eventually fill and the remote host will stop sending data. When the
-  upper layers reads enough data, a window adjust packet is delivered and
-  the transfer resumes.
-  
-  The read_avail counter is used to detect the situation when the remote
-  server tries to send data surpassing the window size. In that case, the
-  extra data is discarded.
-  
-  Signed-off-by: Salvador <sfandino@yahoo.com>
-
-Peter Stuge (15 Sep 2013)
-- configure.ac: Call zlib zlib and not libz in text but keep option names
-
-- configure.ac: Reorder --with-* options in --help output
-
-- configure.ac: Rework crypto library detection
-  
-  This further simplifies adding new crypto libraries.
-
-- Clean up crypto library abstraction in build system and source code
-  
-  libssh2 used to explicitly check for libgcrypt and default to OpenSSL.
-  
-  Now all possible crypto libraries are checked for explicitly, making
-  the addition of further crypto libraries both simpler and cleaner.
-
-- configure.ac: Add zlib to Requires.private in libssh2.pc if using zlib
-
-- Revert "Added Windows Cryptography API: Next Generation based backend"
-  
-  This reverts commit d385230e15715e67796f16f3e65fd899f21a638b.
-
-Daniel Stenberg (7 Sep 2013)
-- [Leif Salomonsson brought this change]
-
-  sftp_statvfs: fix for servers not supporting statfvs extension
-  
-  Fixes issue arising when server does not support statfvs and or fstatvfs
-  extensions. sftp_statvfs() and sftp_fstatvfs() after this patch will
-  handle the case when SSH_FXP_STATUS is returned from server.
-
-- [Marc Hoersken brought this change]
-
-  Added Windows Cryptography API: Next Generation based backend
-
-- [Kamil Dudka brought this change]
-
-  partially revert "window_size: explicit adjustments only"
-  
-  This partially reverts commit 03ca9020756a4e16f0294e5b35e9826ee6af2364
-  in order to fix extreme slowdown when uploading to localhost via SFTP.
-  
-  I was able to repeat the issue on RHEL-7 on localhost only.  It did not
-  occur when uploading via network and it did not occur on a RHEL-6 box
-  with the same version of libssh2.
-  
-  The problem was that sftp_read() used a read-ahead logic to figure out
-  the window_size, but sftp_packet_read() called indirectly from
-  sftp_write() did not use any read-ahead logic.
-
-- _libssh2_channel_write: client spins on write when window full
-  
-  When there's no window to "write to", there's no point in waiting for
-  the socket to become writable since it most likely just will continue to
-  be.
-  
-  Patch-by: ncm
-  Fixes #258
-
-- _libssh2_channel_forward_cancel: avoid memory leaks on error
-  
-  Fixes #257
-
-- _libssh2_packet_add: avoid using uninitialized memory
-  
-  In _libssh2_packet_add, called by _libssh2_packet_read, a call to
-  _libssh2_packet_send that is supposed to send a one-byte message
-  SSH_MSG_REQUEST_FAILURE would send an uninitialized byte upon re-entry
-  if its call to _send returns _EAGAIN.
-  
-  Fixes #259
-
-- _libssh2_channel_forward_cancel: accessed struct after free
-  
-  ... and the assignment was pointless anyway since the struct was about
-  to be freed. Bug introduced in dde2b094.
-  
-  Fixes #268
-
-Peter Stuge (2 Jun 2013)
-- [Marc Hoersken brought this change]
-
-  Fixed compilation using mingw-w64
-
-- [Marc Hoersken brought this change]
-
-  knownhost.c: use LIBSSH2_FREE macro instead of free
-  
-  Use LIBSSH2_FREE instead of free since
-  _libssh2_base64_encode uses LIBSSH2_ALLOC
-
-Daniel Stenberg (18 May 2013)
-- [Matthias Kerestesch brought this change]
-
-  libssh2_agent_init: init ->fd to LIBSSH2_INVALID_SOCKET
-  
-  ... previously it was left at 0 which is a valid file descriptor!
-  
-  Bug: https://trac.libssh2.org/ticket/265
-  
-  Fixes #265
-
-- userauth_password: pass on the underlying error code
-  
-  _libssh2_packet_requirev() may return different errors and we pass that
-  to the parent instead of rewriting it.
-  
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2013-04/0029.shtml
-  Reported by: Cosmin
-
-Peter Stuge (9 May 2013)
-- [Marc Hoersken brought this change]
-
-  libcrypt.c: Fix typo in _libssh2_rsa_sha1_sign() parameter type
-
-Kamil Dudka (4 May 2013)
-- configure.ac: replace AM_CONFIG_HEADER with AC_CONFIG_HEADERS
-  
-  Reported by: Quintus
-  Bug: https://trac.libssh2.org/ticket/261
-
-Guenter Knauf (12 Apr 2013)
-- Fixed copyright string for NetWare build.
-
-Daniel Stenberg (9 Apr 2013)
-- [Richard W.M. Jones brought this change]
-
-  sftp: Add support for fsync (OpenSSH extension).
-  
-  The new libssh2_sftp_fsync API causes data and metadata in the
-  currently open file to be committed to disk at the server.
-  
-  This is an OpenSSH extension to the SFTP protocol.  See:
-  
-  https://bugzilla.mindrot.org/show_bug.cgi?id=1798
-
-- [Richard W.M. Jones brought this change]
-
-  sftp: statvfs: Along error path, reset the correct 'state' variable.
-
-- [Richard W.M. Jones brought this change]
-
-  sftp: seek: Don't flush buffers on same offset
-  
-  Signed-off-by: Richard W.M. Jones <rjones@redhat.com>
-
-Guenter Knauf (9 Feb 2013)
-- Updated dependency libs.
-
-- Fixed tool macro names.
-
-Daniel Stenberg (29 Nov 2012)
-- [Seth Willits brought this change]
-
-  compiler warnings: typecast strlen in macros
-  
-  ... in macro parameters to avoid compiler warnings about lost precision.
-  
-  Several macros in libssh2.h call strlen and pass the result directly to
-  unsigned int parameters of other functions, which warns about precision
-  loss because strlen returns size_t which is unsigned long on at least
-  some platforms (such as OS X). The fix is to simply typecast the
-  strlen() result to unsigned int.
-
-- libssh2.h: bump version to 1.4.4-DEV
-
-Version 1.4.3 (27 Nov 2012)
-
-Daniel Stenberg (27 Nov 2012)
-- RELEASE-NOTES: fixed for 1.4.3
-
-- sftp_read: return error if a too large package arrives
-
-Peter Stuge (13 Nov 2012)
-- Only define _libssh2_dsa_*() functions when building with DSA support
-
-Guenter Knauf (8 Nov 2012)
-- Added .def file to output.
-
-Kamil Dudka (1 Nov 2012)
-- libssh2_hostkey_hash.3: update the description of return value
-  
-  The function returns NULL also if the hash algorithm is not available.
-
-Guenter Knauf (24 Oct 2012)
-- Fixed mode acciedently committed.
-
-- Ignore generated file.
-
-- Added hack to make use of Makefile.inc.
-  
-  This should avoid further maintainance of the objects list.
-
-- Fixed MSVC NMakefile.
-  
-  Added missing source files; added resource for DLL.
-
-Kamil Dudka (22 Oct 2012)
-- examples: use stderr for messages, stdout for data
-  
-  Reported by: Karel Srot
-  Bug: https://bugzilla.redhat.com/867462
-
-- openssl: do not leak memory when handling errors
-  
-  ,.. in aes_ctr_init().  Detected by Coverity.
-
-- channel: fix possible NULL dereference
-  
-  ... in libssh2_channel_get_exit_signal().  Detected by Coverity.
-
-- Revert "aes: the init function fails when OpenSSL has AES support"
-  
-  This partially reverts commit f4f2298ef3635acd031cc2ee0e71026cdcda5864.
-  
-  We need to use the EVP_aes_???_ctr() functions in FIPS mode.
-
-- crypt: use hard-wired cipher block sizes consistently
-
-- openssl: do not ignore failure of EVP_CipherInit()
-
-- kex: do not ignore failure of libssh2_md5_init()
-  
-  The MD5 algorithm is disabled when running in FIPS mode.
-
-Daniel Stenberg (21 Aug 2012)
-- [Peter Krempa brought this change]
-
-  known_hosts: Fail when parsing unknown keys in known_hosts file.
-  
-  libssh2_knownhost_readfile() silently ignored problems when reading keys
-  in unsupported formats from the known hosts file. When the file is
-  written again from the internal structures of libssh2 it gets truntcated
-  to the point where the first unknown key was located.
-  
-   * src/knownhost.c:libssh2_knownhost_readfile() - return error if key
-                                                    parsing fails
-
-- AUTHORS: synced with 42fec44c8a4
-  
-  31 recent authors added
-
-- [Dave Hayden brought this change]
-
-  compression: add support for zlib@openssh.com
-  
-  Add a "use_in_auth" flag to the LIBSSH2_COMP_METHOD struct and a
-  separate "zlib@openssh.com" method, along with checking session->state
-  for LIBSSH2_STATE_AUTHENTICATED. Appears to work on the OpenSSH servers
-  I've tried against, and it should work as before with normal zlib
-  compression.
-
-- [Dmitry Smirnov brought this change]
-
-  configure: gcrypt doesn't come with pkg-config support
-  
-  ... so use plain old -lgcrypt to the linker to link with it.
-  
-  Fixes #225
-
-- sftp_read: Value stored to 'next' is never read
-  
-  Detected by clang-analyzer
-
-- publickey_init: errors are negative, fix check
-  
-  Detected by clang-analyzer.
-
-- [Maxime Larocque brought this change]
-
-  session_free: wrong variable used for keeping state
-  
-  If libssh2_session_free is called without the channel being freed
-  previously by libssh2_channel_free a memory leak could occur.
-  
-  A mismatch of states variables in session_free() prevent the call to
-  libssh2_channel_free function. session->state member is used instead of
-  session->free_state.
-  
-  It causes a leak of around 600 bytes on every connection on my systems
-  (Linux, x64 and PPC).
-  
-  (Debugging done under contract for Accedian Networks)
-  
-  Fixes #246
-
-Guenter Knauf (29 Jun 2012)
-- Small NetWare makefile tweak.
-
-- Some small Win32 makefile fixes.
-
-Daniel Stenberg (19 Jun 2012)
-- libssh2_userauth_publickey_fromfile_ex.3: mention publickey == NULL
-
-- comp_method_zlib_decomp: handle Z_BUF_ERROR when inflating
-  
-  When using libssh2 to perform an SFTP file transfer from the "JSCAPE MFT
-  Server" (http://www.jscape.com) the transfer failed. The default JSCAPE
-  configuration is to enforce zlib compression on SSH2 sessions so the
-  session was compressed. The relevant part of the debug trace contained:
-  
-   [libssh2] 1.052750 Transport: unhandled zlib error -5
-   [libssh2] 1.052750 Failure Event: -29 - decompression failure
-  
-  The trace comes from comp_method_zlib_decomp() in comp.c. The "unhandled
-  zlib error -5" is the status returned from the zlib function
-  inflate(). The -5 status corresponds to "Z_BUF_ERROR".
-  
-  The inflate() function takes a pointer to a z_stream structure and
-  "inflates" (decompresses) as much as it can. The relevant fields of the
-  z_stream structure are:
-  
-    next_in - pointer to the input buffer containing compressed data
-    avail_in - the number of bytes available at next_in
-    next_out - pointer to the output buffer to be filled with uncompressed
-               data
-    avail_out - how much space available at next_out
-  
-  To decompress data you set up a z_stream struct with the relevant fields
-  filled in and pass it to inflate(). On return the fields will have been
-  updated so next_in and avail_in show how much compressed data is yet to
-  be processed and next_out and avail_out show how much space is left in
-  the output buffer.
-  
-  If the supplied output buffer is too small then on return there will be
-  compressed data yet to be processed (avail_in != 0) and inflate() will
-  return Z_OK. In this case the output buffer must be grown, avail_out
-  updated and inflate() called again.
-  
-  If the supplied output buffer was big enough then on return the
-  compressed data will have been exhausted (avail_in == 0) and inflate()
-  will return Z_OK, so the data has all been uncompressed.
-  
-  There is a corner case where inflate() makes no progress. That is, there
-  may be unprocessed compressed data and space available in the output
-  buffer and yet the function does nothing. In this case inflate() will
-  return Z_BUF_ERROR. From the zlib documentation and the source code it
-  is not clear under what circumstances this happens. It could be that it
-  needs to write multiple bytes (all in one go) from its internal state to
-  the output buffer before processing the next chunk of input but but
-  can't because there is not enough space (though my guesses as to the
-  cause are not really relevant). Recovery from Z_BUF_ERROR is pretty
-  simple - just grow the output buffer, update avail_out and call
-  inflate() again.
-  
-  The comp_method_zlib_decomp() function does not handle the case when
-  inflate() returns Z_BUF_ERROR. It treats it as a non-recoverable error
-  and basically aborts the session.
-  
-  Fixes #240
-
-Guenter Knauf (12 Jun 2012)
-- MinGW makefile tweaks.
-  
-  Use GNU tools when compiling on Linux.
-  Fixed dist and dev targets.
-
-- NetWare makefile tweaks.
-  
-  Changed to use Windows commandline tools instead of
-  GNU tools when compiling on Windows. Fixed dist and
-  dev targets. Enabled nlmconv error for unresolved
-  symbols.
-
-Daniel Stenberg (11 Jun 2012)
-- Revert "config.rpath: generated file, no need to keep in git"
-  
-  This reverts commit 1ac7bd09cc685755577fb2c8829adcd081e7ab3c.
-  
-  This file still used by lib/*m4 functions so we need to keep the file
-  around.
-
-- BINDINGS: added PySsh2, a Python-ctypes binding
-
-Guenter Knauf (8 Jun 2012)
-- Fixed MinGW debug build.
-
-Daniel Stenberg (5 Jun 2012)
-- BINDINGS: Added the Cocoa/Objective-C one
-  
-  ... and sorted the bindings after the languages, alphabetically
-  
-  Reported by: Mike Abdullah
-
-- BINDINGS: document the bindings we know of
-
-Guenter Knauf (4 Jun 2012)
-- Fixed LIBSSH2_INT64_T_FORMAT macro.
-  
-  Usually a format macro should hold the whole format, otherwise
-  it should be named a prefix. Also fixed usage of this macro in
-  scp.c for a signed var where it was used as prefix for unsigned.
-
-- Removed obsolete define from makefiles.
-
-- Renamed NetWare makefiles.
-
-- Renamed NetWare makefiles.
-
-- Synced MinGW makefiles with 56c64a6..39e438f.
-  
-  Also synced MinGW test makefile with b092696..f8cb874.
-
-Peter Stuge (30 May 2012)
-- Revert "sftp: Don't send attrs.permissions on read-only SSH_FXP_OPEN"
-  
-  This reverts commit 04e79e0c798674a0796be8a55f63dd92e6877790.
-
-- sftp: Don't send attrs.permissions on read-only SSH_FXP_OPEN
-  
-  This works around a protocol violation in the ProFTPD 1.3.4 mod_sftp
-  server, as reported by Will Cosgrove in:
-  
-  http://libssh2.org/mail/libssh2-devel-archive-2012-05/0079.shtml
-  
-  Based on a suggested fix by TJ Saunders in:
-  
-  http://libssh2.org/mail/libssh2-devel-archive-2012-05/0104.shtml
-
-Guenter Knauf (28 May 2012)
-- Try to detect OpenSSL build type automatically.
-  
-  Also fixed recently added libgdi32 linkage which is only
-  required when OpenSSL libs are linked statically.
-
-Daniel Stenberg (25 May 2012)
-- config.rpath: generated file, no need to keep in git
-
-Guenter Knauf (22 May 2012)
-- Updated dependency libary versions.
-
-Daniel Stenberg (18 May 2012)
-- 1.4.3: towards the future
-
-Version 1.4.2 (18 May 2012)
-
-Daniel Stenberg (18 May 2012)
-- RELEASE-NOTES: synced with 92a9f952794
-
-Alexander Lamaison (15 May 2012)
-- win32/libssh2_config.h: Remove hardcoded #define LIBSSH2_HAVE_ZLIB.
-  
-  Rationale: Everything else in this file states a fact about the win32
-  platform that is unconditional for that platform.  There is nothing
-  unconditional about the presence of zlib.  It is neither included with
-  Windows nor with the platform SDK.  Therefore, this is not an appropriate
-  place to assert its presence.  Especially as, once asserted, it cannot be
-  overridden using a compiler flag.
-  
-  In contrast, if it is omitted, then it can easily be reasserted by adding
-  a compiler flag defining LIBSSH2_HAVE_ZLIB.
-
-Daniel Stenberg (14 May 2012)
-- RELEASE-NOTES: synced with 69a3354467c
-
-- _libssh2_packet_add: SSH_MSG_CHANNEL_REQUEST default to want_reply
-  
-  RFC4254 says the default 'want_reply' is TRUE but the code defaulted to
-  FALSE. Now changed.
-  
-  Fixes #233
-
-- gettimeofday: no need for a replacement under cygwin
-  
-  Fixes #224
-
-Alexander Lamaison (13 May 2012)
-- Prevent sftp_packet_read accessing freed memory.
-  
-  sftp_packet_add takes ownership of the packet passed to it and (now that we
-  handle zombies) might free the packet.  sftp_packet_read uses the packet type
-  byte as its return code but by this point sftp_packet_add might have freed
-  it.  This change fixes the problem by caching the packet type before calling
-  sftp_packet_add.
-  
-  I don't understand why sftp_packet_read uses the packet type as its return
-  code.  A future change might get rid of this entirely.
-
-Daniel Stenberg (12 May 2012)
-- sftp_packet_flush: flush zombies too
-  
-  As this function is called when the SFTP session is closed, it needs to
-  also kill all zombies left in the SFTP session to avoid leaking memory
-  just in case some zombie would still be in there.
-
-- sftp_packetlist_flush: zombies must not have responses already
-  
-  When flushing the packetlist, we must only add the request as a zombie
-  if no response has already been received. Otherwise we could wrongly
-  make it a zombie even though the response was already received and then
-  we'd get a zombie stuck there "forever"...
-
-- sftp_read: on EOF remove packet before flush
-  
-  Since the sftp_packetlist_flush() function will move all the existing
-  FXP_READ requests in this handle to the zombie list we must first remove
-  this just received packet as it is clearly not a zombie.
-
-- sftp_packet_require: sftp_packet_read() returning 0 is not an error
-  
-  Exactly as the comment in the code said, checking the return code from
-  sftp_packet_read() with <= was wrong and it should be < 0. With the new
-  filtering on incoming packets that are "zombies" we can now see this
-  getting zero returned.
-
-- sftp_packetlist_flush: only make it zombie if it was sent
-  
-  The list of outgoing packets may also contain packets that never were
-  sent off and we better not make them zombies too.
-
-- [Alexander Lamaison brought this change]
-
-  Mark outstanding read requests after EOF as zombies.
-  
-  In order to be fast, sftp_read sends many read requests at once.  With a small
-  file, this can mean that when EOF is received back, many of these requests are
-  still outstanding.  Responses arriving after we close the file and abandon the
-  file handle are queued in the SFTP packet queue and never collected.  This
-  causes transfer speed to drop as a progressively longer queue must be searched
-  for every packet.
-  
-  This change introduces a zombie request-ID list in the SFTP session that is
-  used to recognise these outstanding requests and prevent them being added to
-  the queue.
-
-Peter Stuge (23 Apr 2012)
-- [Rafael Kitover brought this change]
-
-  Update win32/GNUmakefile to use OpenSSL 1.0.1a
-  
-  libcrypto on win32 now depends on gdi32.dll, so move the OpenSSL LDLIBS
-  block to before the compiler definitions, so that libcrypto gets added
-  first, and then add -lgdi32 into the following common LDLIBS for gcc.
-
-Guenter Knauf (23 Apr 2012)
-- Changed 'Requires' to 'Requires.private'.
-  
-  Only static builds need to link against the crypto libs.
-
-- Fixed 'Requires:' names.
-  
-  The 'Requires:' line lists the names of the .pc files.
-
-- Added 'Requires:' line to libssh2.pc.
-  
-  This is necessary so that other libs which lookup libssh2 info
-  via pkg-config can add the right crypto lib dependencies.
-
-- Updated dependency lib versions.
-
-Peter Stuge (18 Apr 2012)
-- configure.ac: Add option to disable build of the example applications
-  
-  Examples are built by default. Any of the following options on the
-  configure command line will skip building them:
-  
-    --disable-examples-build
-    --enable-examples-build=no
-    --enable-examples-build=false
-
-- userauth.c: fread() from public key file to correctly detect any errors
-  
-  If the filename parameter for file_read_publickey() was the name of a
-  directory instead of a file then libssh2 would spin trying to fgetc()
-  from the FILE * for the opened directory when trying to determine the
-  length of the encoded public key, since fgetc() can't report errors.
-  
-  Use fread() instead to correctly detect this error condition along
-  with many others.
-  
-  This fixes the problem reported in
-  http://www.libssh2.org/mail/libssh2-devel-archive-2012-04/0021.shtml
-  
-  Reported-by: Oleksiy Zagorskyi <zalex_ua@i.ua>
-
-- Return LIBSSH2_ERROR_SOCKET_DISCONNECT on EOF when reading banner
-
-Guenter Knauf (17 Apr 2012)
-- Fixed copyright year.
-
-- Updated dependency lib versions in static makefiles.
-
-Daniel Stenberg (6 Apr 2012)
-- version: bump to 1.4.2
-  
-  We're on the 1.4.2 track now (at least)
-
-Version 1.4.1 (4 Apr 2012)
-
-Daniel Stenberg (4 Apr 2012)
-- RELEASE-NOTES: updated for 1.4.1 release
-
-- always do "forced" window updates
-  
-  When calling _libssh2_channel_receive_window_adjust() internally, we now
-  always use the 'force' option to prevent libssh2 to avoid sending the
-  update if the update isn't big enough.
-  
-  It isn't fully analyzed but we have seen corner cases which made a
-  necessary window update not get send due to this and then the other side
-  doesn't send data our side then sits waiting for forever.
-
-- channel_read: force window adjusts!
-  
-  if there's not enough room to receive the data that's being requested,
-  the window adjustment needs to be sent to the remote and thus the force
-  option has to be used. _libssh2_channel_receive_window_adjust() would
-  otherwise "queue" small window adjustments for a later packet but that
-  is really terribly for the small buffer read that for example is the
-  final little piece of a very large file as then there is no logical next
-  packet!
-  
-  Reported by: Armen Babakhanian
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0130.shtml
-
-- [Paul Howarth brought this change]
-
-  aes: the init function fails when OpenSSL has AES support
-  
-  The internal init function only worked fine when the configure script
-  didn't detect the OpenSSL AES_CTR function!
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0111.shtml
-  Reported by: Paul Howarth
-
-- [Matthew Booth brought this change]
-
-  transport_send: Finish in-progress key exchange before sending data
-  
-  _libssh2_channel_write() first reads outstanding packets before writing
-  new data. If it reads a key exchange request, it will immediately start
-  key re-exchange, which will require sending a response. If the output
-  socket is full, this will result in a return from
-  _libssh2_transport_read() of LIBSSH2_ERROR_EAGAIN. In order not to block
-  a write because there is no data to read, this error is explicitly
-  ignored and the code continues marshalling a packet for sending. When it
-  is sent, the remote end immediately drops the connection because it was
-  expecting a continuation of the key exchange, but got a data packet.
-  
-  This change adds the same check for key exchange to
-  _libssh2_transport_send() that is in _libssh2_transport_read(). This
-  ensures that key exchange is completed before any data packet is sent.
-
-- channel_write: acknowledge transport errors
-  
-  When draining data off the socket with _libssh2_transport_read() (which
-  in turn has to be done so that we can be sure to have read any possible
-  window-increasing packets), this code previously ignored errors which
-  could lead to nasty loops. Now all error codes except EAGAIN will cause
-  the error to be returned at once.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0068.shtml
-  Reported by: Matthew Booth
-
-- [Steven Dake brought this change]
-
-  In examples/x11.c, Make sure sizeof passed to read operation is correct
-  
-  sizeof(buf) expands to 8 or 4 (since its a pointer).  This variable may
-  have been static in the past, leading to this error.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  Fix suspicious sizeof usage in examples/x11.c
-  
-  In the x11 example, sizeof(buf) = 8UL (on x86_64), when this should
-  probably represent the buffer size available.  I am not sure how to
-  test that this change is actually correct, however.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- sftp_packet_read: follow-up fix for EAGAIN/window adjust
-  
-  The commit in 7194a9bd7ba45 wasn't complete. This change makes sure
-  variables are initialized properly before used in the EAGAIN and window
-  adjust cases.
-
-- sftp_packet_add: use named error code instead of number
-
-- sftp_packet_add: verify the packet before accepting it
-  
-  In order to bail out as quickly as possible when things are wrong and
-  out of sync, make sure the SFTP message is one we understand.
-
-- SFTP: preserve the original error code more
-  
-  Lots of places in the code translated the original error into the more
-  generic LIBSSH2_ERROR_SOCKET_TIMEOUT but this turns out to distort the
-  original error reason a lot and makes tracking down the real origin of a
-  problem really hard. This change makes the original error code be
-  preserved to a larger extent when return up to the parent function.
-
-- sftp_packet_read: adjust window size as necessary
-  
-  Commit 03ca9020756 tried to simplify the window sizing logic but broke
-  SFTP readdir as there was no window sizing code left there so large
-  directory listings no longer worked.
-  
-  This change introduces window sizing logic to the sftp_packet_read()
-  function so that it now tells the remote about the local size having a
-  window size that suffice when it is about to ask for directory data.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2012-03/0069.shtml
-  Reported by: Eric
-
-- [Steven Dake brought this change]
-
-  Tell C compiler we don't care about return code of libssh2_init
-  
-  The call of libssh2_init returns a return code, but nothing could be done
-  within the _libssh2_init_if_needed execution path.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  Add comment indicating a resource leak is not really a resource leak
-  
-  While possibly obvious to those investigating the code, coverity complains
-  about this out of scope leak.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  Use safer snprintf rather then sprintf in scp_send()
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  Use safer snprintf rather then sprintf in scp_recv()
-  
-  While the buffer is indeed allocated to a safe length, better safe then sorry.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  use snprintf in knownhost_writeline() rather then sprintf
-  
-  Although the function checks the length, if the code was in error, there
-  could potentially be a buffer overrun with the use of sprintf.  Instead replace
-  with snprintf.
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-- [Steven Dake brought this change]
-
-  Add tracing to print packets left on session at libssh2_session_free
-  
-  Signed-off-by: Steven Dake <sdake@redhat.com>
-
-Peter Stuge (2 Mar 2012)
-- Define and use LIBSSH2_INVALID_SOCKET instead of INVALID_SOCKET
-  
-  INVALID_SOCKET is a special value in Windows representing a
-  non-valid socket identifier. We were #defining this to -1 on
-  non-Windows platforms, causing unneccessary namespace pollution.
-  Let's have our own identifier instead.
-  
-  Thanks to Matt Lawson for pointing this out.
-
-- nw/Makefile.netware: Fix project name typo to avoid needless confusion
-
-- example/x11: Set raw terminal mode manually instead of with cfmakeraw()
-  
-  OpenSolaris has no cfmakeraw() so to make the example more portable
-  we simply do the equivalent operations on struct termios ourselves.
-  
-  Thanks to Tom Weber for reporting this problem, and finding a solution.
-
-Daniel Stenberg (17 Feb 2012)
-- sftp_write: cannot return acked data *and* EAGAIN
-  
-  Whenever we have acked data and is about to call a function that *MAY*
-  return EAGAIN we must return the number now and wait to get called
-  again. Our API only allows data *or* EAGAIN and we must never try to get
-  both.
-
-Peter Stuge (13 Feb 2012)
-- example/x11: Build only when sys/un.h is found by configure
-  
-  The example can't be built on systems without AF_UNIX sockets.
-
-Daniel Stenberg (10 Feb 2012)
-- [Alexander Lamaison brought this change]
-
-  Simplified sftp_read.
-  
-  Removed the total_read variable that originally must have tracked how
-  much data had been written to the buffer.  With non-blocking reads, we
-  must return straight away once we have read data into the buffer so this
-  variable served not purpose.
-  
-  I think it was still hanging around in case the initial processing of
-  'leftover' data meant we wrote to the buffer but this case, like the
-  others, must return immediately.  Now that it does, the last remaining
-  need for the variable is gone.
-
-- [Alexander Lamaison brought this change]
-
-  Cleaned up sftp_read and added more explanation.
-  
-  Replaced the gotos which were implementing the state machine with
-  a switch statement which makes the states more explicit.
-
-- sftp_read: avoid data *and* EAGAIN
-  
-  Whenever we have data and is about to call a function that *MAY* return
-  EAGAIN we must return the data now and wait to get called again. Our API
-  only allows data *or* EAGAIN and we must never try to get both.
-
-Peter Stuge (2 Feb 2012)
-- Add a tcpip-forward example which demonstrates remote port forwarding
-
-- libssh2.h: Add missing prototype for libssh2_session_banner_set()
-
-- example/subsystem_netconf.c: Return error when read buffer is too small
-  
-  Also remove a little redundancy in the read loop condition.
-
-- example/subsystem_netconf.c: Add a missing newline in an error message
-
-- Fix undefined reference to _libssh_error in libgcrypt backend
-  
-  Commit 209de22299b4b58e582891dfba70f57e1e0492db introduced a function
-  call to a non-existing function, and since then the libgcrypt backend
-  has not been buildable.
-
-Version 1.4.0 (31 Jan 2012)
-
-Daniel Stenberg (31 Jan 2012)
-- RELEASE-NOTES: synced with 6bd584d29 for 1.4.0
-
-- s/1.3.1/1.4.0
-  
-  We're bumping the minor number
-
-- [Jernej Kovacic brought this change]
-
-  libssh2_session_supported_algs: fix compiler warning
-
-- [Jernej Kovacic brought this change]
-
-  session_supported_algs docs: added an example
-
-- [Gellule Xg brought this change]
-
-  sftp-seek: clear EOF flag
-  
-  Set the EOF flag to False when calling seek64 to be able to get some
-  data back on a following read
-
-- [Peter Krempa brought this change]
-
-  userauth: Provide more informations if ssh pub key extraction fails
-  
-  If the function that extracts/computes the public key from a private key
-  fails the errors it reports were masked by the function calling it. This
-  patch modifies the key extraction function to return errors using
-  _libssh_error() function.  The error messages are tweaked to contain
-  reference to the failed operaton in addition to the reason.
-  
-   * AUTHORS: - add my name
-   * libgcrypt.c: _libssh2_pub_priv_keyfile(): - return a more verbose
-                                                 error using
-                                                 _libssh2_error() func.
-   * openssl.c: - modify call graph of _libssh2_pub_priv_keyfile() to use
-                  _libssh2_error for error reporting();
-   * userauth.c: - tweak functions calling _libssh2_pub_priv_keyfile() not
-                   to shadow error messages
-
-- TODO: remove issues we (sort of) did already
-
-- ssh2_exec: skip error outputs for EAGAIN
-  
-  Since the example uses non-blocking mode, it will just flood the output
-  with this "nonsense" error.
-
-Guenter Knauf (30 Nov 2011)
-- Some NetWare makefile tweaks.
-
-Daniel Stenberg (18 Nov 2011)
-- LIBSSH2_SFTP_PACKET_MAXLEN: increase to 80000
-  
-  Some SFTP servers send SFTP packets larger than 40000. Since the limit
-  is only present to avoid insane sizes anyway, we can easily bump it.
-  
-  The define was formerly in the public header libssh2_sftp.h but served
-  no external purpose and was moved into the source dir.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-11/0004.shtml
-  Reported by: Michael Harris
-
-Alexander Lamaison (18 Nov 2011)
-- [Peter Krempa brought this change]
-
-  knownhost_check(): Don't dereference ext if NULL is passed
-  
-  Documentation for libssh2_knownhost_checkp() and related functions
-  states that the last argument is filled with data if non-NULL.
-  
-  "knownhost if set to non-NULL, it must be a pointer to a 'struct
-  libssh2_knownhost' pointer that gets filled in to point to info about a
-  known host that matches or partially matches."
-  
-  In this function ext is dereferenced even if set to NULL, causing
-  segfault in applications not needing the extra data.
-
-Daniel Stenberg (11 Nov 2011)
-- [Peter Krempa brought this change]
-
-  knownhost_add: Avoid dereferencing uninitialized memory on error path.
-  
-  In function knownhost_add, memory is alocated for a new entry. If normal
-  alocation is used, memory is not initialized to 0 right after, but a
-  check is done to verify if correct key type is passed. This test is done
-  BEFORE setting the memory to null, and on the error path function
-  free_host() is called, that tries to dereference unititialized memory,
-  resulting into a glibc abort().
-  
-   * knownhost.c - knownhost_add(): - move typemask check before alloc
-
-- windows build: add define to avoid compiler warning
-  
-  A recent mingw compiler has started to complain on "#warning Please
-  include winsock2.h before windows.h" unless the magic define is set
-  first.
-  
-  Reported by: Vincent Torri
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-10/0064.shtml
-
-Henrik Nordstrom (31 Oct 2011)
-- [Vincent Torri brought this change]
-
-  Correct Windows include file name case, simplifying cross-compilation
-  
-  When cross compiling to Windows, libssh2.h include Windows header files
-  with upper case filenames : BaseTsd.h and WinSock2.h.
-  
-  These files have lowercase names with mingw-w64 (iirc, it's the same with
-  mingw). And as on Windows, being lowercase or uppercase does not matter.
-
-Daniel Stenberg (25 Oct 2011)
-- [Jernej Kovacic brought this change]
-
-  libssh2_session_supported_algs: added
-
-- [Kamil Dudka brought this change]
-
-  example/sftp_RW_nonblock: do not ignore LIBSSH2_ERROR_EAGAIN
-  
-  Bug: https://bugzilla.redhat.com/745420
-
-Peter Stuge (5 Oct 2011)
-- example/ssh2_agent: Print host key fingerprint before authentication
-  
-  Also moves the comment about not being authenticated to before the
-  agent authentication takes place, so that it better matches the code.
-
-Daniel Stenberg (29 Sep 2011)
-- OpenSSL EVP: fix threaded use of structs
-  
-  Make sure we don't clear or reset static structs after first init so
-  that they work fine even when used from multiple threads. Init the
-  structs in the global init.
-  
-  Help and assistance by: John Engstrom
-  
-  Fixes #229 (again)
-
-- openssl: don't init static structs differently
-  
-  make_ctr_evp() is changed to take a struct pointer, and then each
-  _libssh2_EVP_aes_[keylen]_ctr function is made to pass in their own
-  static struct
-  
-  Reported by: John Engstrom
-  Fixes #229
-
-Guenter Knauf (27 Sep 2011)
-- Removed obsolete include path.
-
-Daniel Stenberg (21 Sep 2011)
-- read_state: clear the state variable better
-  
-  Set read_state back to idle before trying to send anything so that if
-  the state somehow is wrongly set.
-  
-  Also, avoid such a case of confusion by resetting the read_state when an
-  sftp handle is closed.
-
-- sftp_read: remove leftover fprintf
-  
-  Reported by: Alexander Lamaison
-
-- sftp.h: fix the #ifdef to prevent multiple inclusions
-
-- sftp_read: use a state variable to avoid bad writes
-  
-  When a channel_write call has gotten an EAGAIN back, we try harder to
-  continue the same write in the subsequent invoke.
-
-- window_size: explicit adjustments only
-  
-  Removed the automatic window_size adjustments from
-  _libssh2_channel_read() and instead all channel readers must now make
-  sure to enlarge the window sizes properly themselves.
-  
-  libssh2_channel_read_ex() - the public function, now grows the window
-  size according to the requested buffer size. Applications can still opt
-  to grow the window more on demand. Larger windows tend to give higher
-  performance.
-  
-  sftp_read() now uses the read-ahead logic to figure out a window_size.
-
-- libssh2.h: bump the default window size to 256K
-
-- libssh2_userauth_keyboard_interactive.3: fix man warning
-  
-  It seemed to occur due to the excessive line length
-
-- [Mikhail Gusarov brought this change]
-
-  Add missing .gitignore entries
-
-- [Mikhail Gusarov brought this change]
-
-  Add manpage syntax checker to 'check' target
-  
-  In virtually every libssh2 release Debian's lintian catches syntax errors in
-  manpages. Prevent it by checking manpages as a part of testsuite.
-
-- libssh2_banner_set.3: fix nroff syntax mistake
-
-Guenter Knauf (10 Sep 2011)
-- Use predefined resource compiler macro.
-
-- Added casts to silent compiler warnings.
-
-- Fixed uint64_t printf.
-
-- Fixed macro function signatures.
-
-- NetWare makefile tweaks.
-
-- Removed unused var.
-
-- Added 2 samples not mentioned.
-
-- Dont build x11 sample with MinGW.
-
-- Fixed executable file description.
-
-- Removed unused var.
-
-- Kill stupid gcc 3.x uninitialized warning.
-
-- Build all examples.
-
-- More MinGW makefile tweaks.
-  
-  Renamed *.mingw makefiles to GNUmakefile since GNU make picks these
-  up automatically, and therefore win32/Makefile removed.
-
-- Removed forgotten WINSOCK_VERSION defines.
-
-Daniel Stenberg (9 Sep 2011)
-- libssh2_session_startup(3) => libssh2_session_handshake(3)
-  
-  Propagate for the current function in docs and examples.
-  libssh2_session_startup() is deprecated.
-
-- libssh2_banner_set => libssh2_session_banner_get
-  
-  Marked the old function as deprecated. Added the new name in the correct
-  name space with the same arguments and functionality.
-
-- new function: libssh2_session_banner_get
-  
-  Returns the banner from the server handshake
-  
-  Fixes #226
-
-- libssh2.h: bump version to 1.4.0 for new function(s)
-
-- remove embedded CVS/svn tags
-
-- [liuzl brought this change]
-
-  API add:libssh2_sftp_get_channel
-  
-  Return the channel of sftp, then caller can
-  control the channel's behavior.
-  
-  Signed-off-by: liuzl <xieepp@gmail.com>
-
-- _libssh2_channel_read: react on errors from receive_window_adjust
-  
-  Previously the function would ignore all errors except for EAGAIN.
-
-- sftp_read: extend and clarify the documentation
-
-- sftp_read: cap the read ahead maximum amount
-  
-  Now we only go up to LIBSSH2_CHANNEL_WINDOW_DEFAULT*30 bytes SFTP read
-  ahead, which currently equals 64K*30 == 1966080 bytes.
-
-- _libssh2_channel_read: fix non-blocking window adjusting
-  
-  If EAGAIN is returned when adjusting the receive window, we must not
-  read from the transport directly until we've finished the adjusting.
-
-Guenter Knauf (8 Sep 2011)
-- Fix for systems which need sys/select.h.
-
-- The files were not gone but renamed ...
-
-Daniel Stenberg (6 Sep 2011)
-- sftp_read: added documenting comment
-  
-  Taken from some recent email conversations I added some descriptions of
-  the logic in sftp_read() to aid readers.
-
-- 1.3.1: start the work
-
-Version 1.3.0 (6 Sep 2011)
-
-Daniel Stenberg (6 Sep 2011)
-- Makefile.am: the Makefile.win32 files are gone
-
-- RELEASE-NOTES: updated for 1.3.0
-
-- sftp_read: a short read is not end of file
-  
-  A returned READ packet that is short will now only reduce the
-  offset.
-  
-  This is a temporary fix as it is slightly better than the previous
-  approach but still not very good.
-
-- [liuzl brought this change]
-
-  _libssh2_packet_add: adjust window size when truncating
-  
-  When receiving more data than what the window size allows on a
-  particular channel, make sure that the window size is adjusted in that
-  case too. Previously it would only adjust the window in the non-error
-  case.
-
-Guenter Knauf (29 Aug 2011)
-- Silent compiler warning with MinGW64.
-
-- Fixed link to native Win32 awk tool.
-
-- Renamed MinGW makefiles.
-
-- Some MinGW makefile tweaks.
-  
-  Enable build without GNU tools and with MinGW64 compiler.
-
-- Fixed aes_ctr_do_cipher() signature.
-
-Daniel Stenberg (26 Aug 2011)
-- [liuzl brought this change]
-
-  libssh2_sftp_seek64: flush packetlist and buffered data
-  
-  When seeking to a new position, flush the packetlist and buffered data
-  to prevent already received or pending data to wrongly get used when
-  sftp-reading from the new offset within the file.
-
-- sftp_read: advance offset correctly for buffered copies
-  
-  In the case where a read packet has been received from the server, but
-  the entire contents couldn't be copied to the user-buffer, the data is
-  instead buffered and copied to the user's buffer in the next invocation
-  of sftp_read(). When that "extra" copy is made, the 'offset' pointer was
-  not advanced accordingly.
-  
-  The biggest impact of this flaw was that the 'already' variable at the
-  top of the function that figures out how much data "ahead" that has
-  already been asked for would slowly go more and more out of sync, which
-  could lead to the file not being read all the way to the end.
-  
-  This problem was most noticable in cases where the application would
-  only try to read the exact file size amount, like curl does. In the
-  examples libssh2 provides the sftp read function is most often called
-  with a fixed size large buffer and then the bug would not appear as
-  easily.
-  
-  This bug was introduced in the SFTP rewrite in 1.2.8.
-  
-  Bug: http://curl.haxx.se/mail/lib-2011-08/0305.html
-       http://www.libssh2.org/mail/libssh2-devel-archive-2011-08/0085.shtml
-
-- wrap some long lines < 80 columns
-
-- LIBSSH2_RECV: fix typo, use the RECV_FD macro
-
-- subsystem_netconf.c: fix compiler warnings
-
-- [Henrik Nordstrom brought this change]
-
-  Custom callbacks for performing low level socket I/O
-
-- version bump: start working towards 1.3.0
-
-Version 1.2.9 (16 Aug 2011)
-
-Daniel Stenberg (16 Aug 2011)
-- RELEASE-NOTES: synced with 95d69d3a81261
-
-- [Henrik Nordstrom brought this change]
-
-  Document prototypes for macro defined functions
-
-- [Henrik Nordstrom brought this change]
-
-  Avoid reuse after free when closing X11 channels
-
-- _libssh2_channel_write: handle window_size == 0 better
-  
-  When about to send data on the channel and the window size is 0, we must
-  not just return 0 if the transport_read() function returned EAGAIN as it
-  then causes a busy-loop.
-  
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2011-08/0011.shtml
-
-- gettimeofday: fix name space pollution
-  
-  For systems without its own gettimeofday() implementation, we still must
-  not provide one outside our namespace.
-  
-  Reported by: Bill Segall
-
-Dan Fandrich (5 Aug 2011)
-- libssh2.pc.in: Fixed spelling in pkgconfig file
-
-Peter Stuge (17 Jul 2011)
-- example/subsystem_netconf.c: Add missing #include <string.h>
-
-- example/subsystem_netconf.c: Discard ]]>]]> and return only XML response
-
-- example/subsystem_netconf.c: Fix uninitialized variable bug
-
-- example: Add subsystem_netconf.c
-  
-  This example demonstrates how to use libssh2 to send a request to
-  the NETCONF subsystem available e.g. in JunOS.
-  
-  See also http://tools.ietf.org/html/draft-ietf-netconf-ssh-06
-
-Daniel Stenberg (16 Jul 2011)
-- man page cleanups: non-existing functions need no man pages
-
-- libssh2_new_host_entry.3: removed
-  
-  This is just junk leftovers.
-
-- userauth_keyboard_interactive: fix buffer overflow
-  
-  Partly reverse 566894494b4972ae12 which was simplifying the code far too
-  much and ended up overflowing a buffer within the LIBSSH2_SESSION
-  struct. Back to allocating the buffer properly like it used to do.
-  
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-06/0032.shtml
-  Reported by: Alfred Gebert
-
-- keyboard-interactive man page: cleaned up
-
-- [Alfred Gebert brought this change]
-
-  _libssh2_recv(): handle ENOENT error as EAGAIN
-  
-  A sftp session failed with error "failure establishing ssh session" on
-  Solaris and HP-UX. Sometimes the first recv() function call sets errno
-  to ENOENT. In the man pages for recv of Solaris and HP-UX the error
-  ENOENT is not documented.
-  
-  I tested Solaris SPARC and x86, HP-UX i64, AIX, Windows and Linux.
-
-- agent_list_identities: fix out of scope access
-  
-  An auto variable out of scope was being referenced and used.
-  
-  fixes #220
-
-- _libssh2_wait_socket: fix timeouts for poll() uses
-
-- windows: inclusion fix
-  
-  include winsock2.h for all windows compilers
-
-- keyb-interactive: add the fixed buffer
-  
-  Belongs to commit 5668944
-
-- code cleanup: don't use C99/c++ comments
-  
-  We aim for C89 compliance
-
-- keyb-interactive: allow zero length fields
-  
-  Allow zero length fields so they don't cause malloc(0) calls
-  
-  Avoid free()ing NULL pointers
-  
-  Avoid a malloc of a fixed 5 byte buffer.
-
-- libssh2_channel_process_startup.3: clean up
-  
-  Remove the references to the macro-fied shortcuts as they have their own
-  individual man pages.
-  
-  Made the prototype different and more readable.
-
-- man page: fix .BR lines
-  
-  We don't use \fI etc on .BR lines
-
-- userauth_keyboard_interactive: skip code on zero length auth
-
-- libssh2_channel_forward_accept.3: mention how to get error
-  
-  Since this returns a pointer, libssh2_session_last_errno() must be used
-  to get the actual error code and it wasn't that clear before.
-
-- timeout docs: mention they're added in 1.2.9
-
-- sftp_write_sliding.c: indent fix
-  
-  Use the standard indenting and removed CVS leftover comment
-
-- [zl liu brought this change]
-
-  sftp_write_sliding: send the complete file
-  
-  When reaching the end of file there can still be data left not sent.
-
-- [Douglas Masterson brought this change]
-
-  session_startup: init state properly
-  
-  libssh2_session_startup() didn't set the state correctly so it could get
-  confused.
-  
-  Fixes #218
-
-- timeout: added man pages
-
-- BLOCK_ADJUST_ERRNO: move rc to right level
-  
-  We can't declare the variable within the block and use it in the final
-  do-while() expression to be properly portable C89.
-
-- [Matt Lilley brought this change]
-
-  adds a timeout to blocking calls
-  
-  Fixes bug #160 as per Daniel's suggestion
-  
-  Adds libssh2_session_set_timeout() and libssh2_session_get_timeout()
-
-- SCP: fix incorrect error code
-  
-  After an error occurs in libssh2_scp_recv() or libssh2_scp_send(), the
-  function libssh2_session_last_error() would return
-  LIBSSH2_ERROR_SOCKET_NONE on error.
-  
-  Bug: http://trac.libssh2.org/ticket/216
-  Patch by: "littlesavage"
-  
-  Fixes #216
-
-Guenter Knauf (19 Apr 2011)
-- Updated default (recommended) dependency versions.
-
-Daniel Stenberg (17 Apr 2011)
-- libssh2_session_block_directions: fix mistake
-  
-  The last LIBSSH2_SESSION_BLOCK_INBOUND should be
-  LIBSSH2_SESSION_BLOCK_OUTBOUND
-  
-  And I shortened the short description
-  
-  Reported by: "drswinghead"
-
-- msvcproj: added libs and debug stuff
-  
-  Added libraries needed to link whether using openssl dynamically or
-  statically
-  
-  Added LIBSSH2DEBUG define to debug versions to enable tracing
-  
-  URL: http://trac.libssh2.org/ticket/215
-  Patch by: Mark Smith
-
-- sftp_write: clean offsets on error
-  
-  When an error has occurred on FXP_WRITE, we must make sure that the
-  offset, sent offset and acked counter are reset properly.
-
-- example/.gitignore: ignore built binaries
-
-- sftp_write: flush the packetlist on error
-  
-  When an error occurs during write, flush the entire list of pending
-  outgoing SFTP packets.
-
-- keepalive: add first basic man pages
-  
-  Someone on IRC pointed out that we don't have these documented so I
-  wrote up a first set based on the information in the wiki:
-  http://trac.libssh2.org/wiki/KeepAlive
-
-- scp_write_nonblock.c: remove pointless check
-  
-  libssh2_channel_write() cannot return a value that is larger than the
-  input length value
-
-Mikhail Gusarov (9 Apr 2011)
-- s/\.NF/.nf/ to fix wrong macro name caught by man --warnings
-
-Daniel Stenberg (6 Apr 2011)
-- version: bump to 1.2.9_dev
-  
-  Also update the copyright year range to include 2011
-
-- configure: fix $VERSION
-  
-  Stop using the $VERSION variable as it seems to be magically used by
-  autoconfig itself and thus gets set to the value set in AC_INIT()
-  without us wanting that. $LIBSSH2VER is now the libssh2 version as
-  detected.
-  
-  Reported by: Paul Howarth
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2011-04/0008.shtml
-
-- maketgz: use git2news.pl by the correct name
-
-Version 1.2.8 (4 Apr 2011)
-
-Daniel Stenberg (4 Apr 2011)
-- RELEASE-NOTES: synced with fabf1a45ee
-
-- NEWS: auto-generated from git
-  
-  Starting now, the NEWS file is generated from git using the git2news.pl
-  script. This makes it always accurate and up-to-date, even for daily
-  snapshots etc.
-
-- sftp_write: handle FXP_WRITE errors
-  
-  When an sftp server returns an error back on write, make sure the
-  function bails out and returns the proper error.
-
-- configure: stop using the deprecated AM_INIT_AUTOMAKE syntax
-
-Alexander Lamaison (13 Mar 2011)
-- Support unlimited number of host names in a single line of the known_hosts file.
-  
-  Previously the code assumed either a single host name or a hostname,ip-address pair.  However, according to the spec [1], there can be any number of comma separated host names or IP addresses.
-  
-  [1] http://www.openbsd.org/cgi-bin/man.cgi?query=sshd&sektion=8
-
-Daniel Stenberg (26 Feb 2011)
-- libssh2_knownhost_readfile.3: clarify return value
-  
-  This function returns the number of parsed hosts on success, not just
-  zero as previously documented.
-
-Peter Stuge (26 Feb 2011)
-- Don't save allocated packet size until it has actually been allocated
-  
-  The allocated packet size is internal state which needs to match reality
-  in order to avoid problems. This commit fixes #211.
-
-Daniel Stenberg (21 Feb 2011)
-- [Alfred Gebert brought this change]
-
-  session_startup: manage server data before server identification
-  
-  Fix the bug that libssh2 could not connect if the sftp server
-  sends data before sending the version string.
-  
-  http://tools.ietf.org/html/rfc4253#section-4.2
-  
-  "The server MAY send other lines of data before sending the version
-  string.  Each line SHOULD be terminated by a Carriage Return and Line
-  Feed.  Such lines MUST NOT begin with "SSH-", and SHOULD be encoded
-  in ISO-10646 UTF-8 [RFC3629] (language is not specified).  Clients
-  MUST be able to process such lines."
-
-- [Alfred Gebert brought this change]
-
-  fullpacket: decompression only after init
-  
-  The buffer for the decompression (remote.comp_abstract) is initialised
-  in time when it is needed.  With this fix decompression is disabled when
-  the buffer (remote.comp_abstract) is not initialised.
-  
-  Bug: http://trac.libssh2.org/ticket/200
-
-- _libssh2_channel_read: store last error
-  
-  When the transport layer returns EAGAIN this function didn't call
-  _libssh2_error() which made the last_error not get set.
-
-- sftp_write: clarified the comment header
-
-- sftp_read: avoid wrapping counter to insanity
-  
-  As pointed out in bug #206, if a second invoke of libssh2_sftp_read()
-  would shrink the buffer size, libssh2 would go nuts and send out read
-  requests like crazy. This was due to an unsigned variable turning
-  "negative" by some wrong math, and that value would be the amount of
-  data attempt to pre-buffer!
-  
-  Bug: http://trac.libssh2.org/ticket/206
-
-- sftp_packet_read: use 32bit variables for 32bit data
-
-- libssh2_sftp_stat_ex.3: cleaned up, extended
-  
-  Removed the macros from it as they have their own man pages.
-  
-  Added the LIBSSH2_SFTP_ATTRIBUTES struct in here for easier reference.
-
-- sftp_readdir: return error if buffer is too small
-  
-  If asked to read data into a buffer and the buffer is too small to hold
-  the data, this function now returns an error instead of as previously
-  just copy as much as fits.
-
-- sftp_symlink: return error if receive buffer too small
-  
-  and clean up some variable type mismatches
-  
-  Discussion: http://www.libssh2.org/mail/libssh2-devel-archive-2011-01/0001.shtml
-
-- docs: clarify what happens with a too small buffer
-  
-  This flaw is subject to change, but I figured it might be valuable to
-  users of existing code to know how it works.
-
-- channel_request_pty_size: fix reqPTY_state
-  
-  The state variable isn't properly set so every other call to the
-  function fails!
-  
-  Bug: http://libssh2.org/mail/libssh2-devel-archive-2010-12/0096.shtml
-  Reported by: Steve Legg
-
-- data size: cleanup
-  
-  Fix 64bit warnings by using (s)size_t and dedicated uint32_t types more.
-
-- [Pierre Joye brought this change]
-
-  ssize_t: proper typedef with MSVC compilers
-  
-  As discussed on the mailing list, it was wrong for win64 and using the
-  VC-provided type is the safest approach instead of second- guessing
-  which one it should be.
-
-Guenter Knauf (22 Dec 2010)
-- Updated OpenSSL version.
-
-- Expanded tabs to spaces.
-
-Peter Stuge (21 Dec 2010)
-- [Joey Degges brought this change]
-
-  _libssh2_ntohu64: fix conversion from network bytes to uint64
-  
-  Cast individual bytes to uint64 to avoid overflow in arithmetic.
-
-Daniel Stenberg (20 Dec 2010)
-- libssh2_userauth_list: language fix
-  
-  "faily" is not a good English word, and I also cleaned up some other minor
-  mistakes
-
-- crypto: unify the generic functions
-  
-  Added crypto.h that is the unified header to include when using crypto
-  functionality. It should be the only header that needs to adapt to the
-  underlying crypto library in use. It provides the set of prototypes that
-  are library agnostic.
-
-- [Mark Smith brought this change]
-
-  userauth: derive publickey from private
-  
-  Pass a NULL pointer for the publickey parameter of
-  libssh2_userauth_publickey_fromfile and
-  libssh2_userauth_hostbased_fromfile functions.  In this case, the
-  functions recompute the public key from the private key file data.
-  
-  This is work done by Jean-Louis CHARTON
-  <Jean-Louis.CHARTON@oikialog.com>, then adapted by Mark Smith and
-  slightly edited further by me Daniel.
-  
-  WARNING: this does leave the feature NOT WORKING when libssh2 is built
-  to use libgcrypt instead of OpenSSL simply due to lack of
-  implementation.
-
-- ssh2_echo: Value stored to 'exitcode' is never read
-
-- _libssh2_packet_add: fix SSH_MSG_DEBUG weirdness
-  
-  I believe I may have caused this weird typo style error when I cleaned
-  up this function a while ago. Corrected now.
-
-- uint32: more longs converted to proper types
-  
-  I also moved the MAC struct over to the mac.h header file and made sure
-  that the users of that struct include that file.
-
-- SFTP: more types to uint32_t
-  
-  The 'num_names' field in the SSH_FXP_NAME response is an unsigned 32bit
-  value so we make sure to treat it like that.
-
-- SFTP: request_ids are uint32_t
-  
-  I went over the code and made sure we use uint32_t all over for the
-  request_id data. It is an unsigned 32bit value on the wire.
-
-- SFTP: store request_id separately in packets
-  
-  By using a new separate struct for incoming SFTP packets and not sharing
-  the generic packet struct, we can get rid of an unused field and add a
-  new one dedicated for holding the request_id for the incoming
-  package. As sftp_packet_ask() is called fairly often, a "mere" integer
-  comparison is MUCH faster than the previous memcmp() of (typically) 5
-  bytes.
-
-- libssh2_sftp_open_ex: man page extended and cleaned up
-  
-  I added the missing documentation for the 'flags' argument.
-
-- SFTP: unify the READ/WRITE chunk structs
-
-- SFTP: fix memory leaks
-  
-  Make sure that we cleanup remainders when the handle is closed and when
-  the subsystem is shutdown.
-  
-  Existing flaw: if a single handle sends packets that haven't been
-  replied to yet at the time when the handle is closed, those packets will
-  arrive later and end up in the generic packet brigade queue and they
-  will remain in there until flushed. They will use unnecessary memory,
-  make things slower and they will ruin the SFTP handling if the
-  request_id counter ever wraps (highly unlikely to every happen).
-
-- sftp_close_handle: packet list is generic
-  
-  Fix comment, simplify the loop logic
-
-- sftp_read: pipeline reads
-  
-  The SFTP read function now does transfers the same way the SFTP write
-  function was made to recently: it creates a list of many outgoing
-  FXP_READ packets that each asks for a small data chunk. The code then
-  tries to keep sending read request while collecting the acks for the
-  previous requests and returns the received data.
-
-- sftp_write: removed unused variable
-
-- _libssh2_channel_close: don't call transport read if disconnected
-  
-  The loop that waits for remote.close to get set may end up looping
-  forever since session->socket_state gets set to
-  LIBSSH2_SOCKET_DISCONNECTED by the packet_add() function called from the
-  transport_read() function and after having been set to
-  LIBSSH2_SOCKET_DISCONNECTED, the transport_read() function will only
-  return 0.
-  
-  Bug: http://trac.libssh2.org/ticket/198
-
-- libssh2_sftp_seek64: new man page
-  
-  Split off libssh2_sftp_seek64 from the libssh2_sftp_seek man page, and
-  mentioned that we consider the latter deprecated. Also added a mention
-  about the dangers of doing seek during writing or reading.
-
-- sftp_seek: fix
-  
-  The new SFTP write code caused a regression as the seek function no
-  longer worked as it didn't set the write position properly.
-  
-  It should be noted that seeking is STRONGLY PROHIBITED during upload, as
-  the upload magic uses two different offset positions and the multiple
-  outstanding packets etc make them sensitive to change in the midst of
-  operations.
-  
-  This functionality was just verified with the new example code
-  sftp_append. This bug was filed as bug #202:
-  
-  Bug: http://trac.libssh2.org/ticket/202
-
-- sftp_append: new example doing SFTP append
-
-- MAX_SFTP_OUTGOING_SIZE: 30000
-  
-  I ran SFTP upload tests against localhost. It showed that to make the
-  app reach really good speeds, I needed to do a little code tweak and
-  change MAX_SFTP_OUTGOING_SIZE from 4000 to 30000. The tests I did before
-  with the high latency tests didn't show any real difference whatever I
-  had that size set to.
-  
-  This number is the size in bytes that libssh2 cuts off the large input
-  buffer and sends off as an individual sftp packet.
-
-- sftp_write_sliding.c: new example
-  
-  This is an example that is very similar to sftp_write_nonblock.c, with
-  the exception that this uses
-  
-  1 - a larger upload buffer
-  
-  2 - a sliding buffer mechnism to allow the app to keep sending lots of
-  data to libssh2 without having to first drain the buffer.
-  
-  These are two key issues to make libssh2 SFTP uploads really perform
-  well at this point in time.
-
-- cpp: s/#elsif/#elif
-  
-  This looks like a typo as #elsif is not really C...
-
-- _libssh2_channel_write: revert channel_write() use
-  
-  The attempts made to have _libssh2_channel_write() accept larger pieces
-  of data and split up the data by itself into 32700 byte chunks and pass
-  them on to channel_write() in a loop as a way to do faster operations on
-  larger data blocks was a failed attempt.
-  
-  The reason why it is difficult:
-  
-  The API only allows EAGAIN or a length to be returned. When looping over
-  multiple blocks to get sent, one block can get sent and the next might
-  not. And yet: when transport_send() has returned EAGAIN we must not call
-  it again with new data until it has returned OK on the existing data it
-  is still working on. This makes it a mess and we do get a much easier
-  job by simply returning the bytes or EAGAIN at once, as in the EAGAIN
-  case we can assume that we will be called with the same arguments again
-  and transport_send() will be happy.
-  
-  Unfortunately, I think we take a small performance hit by not being able
-  to do this.
-
-- ssh2_echo: new example
-  
-  This is a new example snippet. The code is largely based on ssh2_exec,
-  and is written by Tommy Lindgren. I edited it into C90 compliance and to
-  conform to libssh2 indent style and some more.
-
-- send_existing: return after send_existing
-  
-  When a piece of data is sent from the send_existing() function we must
-  make the parent function return afterwards. Otherwise we risk that the
-  parent function tries to send more data and ends up getting an EGAIN for
-  that more data and since it can only return one return code it doesn't
-  return info for the successfully sent data.
-  
-  As this change is a regression I now added a larger comment explaining
-  why it has to work like this.
-
-- _libssh2_channel_write: count resent data as written
-  
-  In the logic that resends data that was kept for that purpose due to a
-  previous EAGAIN, the data was not counted as sent causing badness.
-
-Peter Stuge (13 Nov 2010)
-- Use fprintf(stderr, ) instead of write(2, ) for debugging
-
-- session/transport: Correctly handle when _libssh2_send() returns -EAGAIN
-
-- src/agent.c: Simplify _libssh2_send() error checking ever so slightly
-
-Daniel Stenberg (12 Nov 2010)
-- send/recv: use _libssh2_recv and _libssh2_send now
-  
-  Starting now, we unconditionally use the internal replacement functions
-  for send() and recv() - creatively named _libssh2_recv() and
-  _libssh2_send().
-  
-  On errors, these functions return the negative 'errno' value instead of
-  the traditional -1. This design allows systems that have no "natural"
-  errno support to not have to invent it. It also means that no code
-  outside of these two transfer functions should use the errno variable.
-
-- channel_write: move some logic to _libssh2_channel_write
-  
-  Some checks are better done in _libssh2_channel_write just once per
-  write instead of in channel_write() since the looping will call the
-  latter function multiple times per _libssh2_channel_write() invoke.
-
-- sftp_write: handle "left over" acked data
-  
-  The SFTP handle struct now buffers number of acked bytes that haven't
-  yet been returned. The way this is used is as following:
-  
-  1. sftp_write() gets called with a buffer of let say size 32000. We
-  split 32000 into 8 smaller packets and send them off one by one. One of
-  them gets acked before the function returns so 4000 is returned.
-  
-  2. sftp_write() gets called again a short while after the previous one,
-  now with a much smaller size passed in to the function. Lets say 8000.
-  In the mean-time, all of the remaining packets from the previous call
-  have been acked (7*4000 = 28000). This function then returns 8000 as all
-  data passed in are already sent and it can't return any more than what
-  it got passed in. But we have 28000 bytes acked. We now store the
-  remaining 20000 in the handle->u.file.acked struct field to add up in
-  the next call.
-  
-  3. sftp_write() gets called again, and now there's a backlogged 20000
-  bytes to return as fine and that will get skipped from the beginning
-  of the buffer that is passed in.
-
-- sftp_write: polished and simplified
-  
-  Removed unnecessary struct fields and state changes within the function.
-  
-  Made the loop that checks for ACKs only check chunks that were fully
-  sent.
-
-- SCP: on failure, show the numerical error reason
-  
-  By calling libssh2_session_last_errno()
-
-- SFTP: provide the numerical error reason on failure
-
-- SCP: clean up failure treatment
-  
-  When SCP send or recv fails, it gets a special message from the server
-  with a warning or error message included. We have no current API to
-  expose that message but the foundation is there. Removed unnecessary use
-  of session struct fields.
-
-- sftp_write: enlarge buffer to perform better
-
-- packets: code cleanup
-  
-  I added size checks in several places. I fixed the code flow to be easier
-  to read in some places.
-  
-  I removed unnecessary zeroing of structs. I removed unused struct fields.
-
-- LIBSSH2_CALLBACK_MACERROR: clarify return code use
-
-- _libssh2_userauth_publickey: avoid shadowing
-
-- packet: avoid shadowing global symbols
-
-- sftp_readdir: avoid shadowing
-
-- shadowing: don't shadow the global compress
-
-- _libssh2_packet_add: turn ifs into a single switch
-
-- _libssh2_packet_add: check SSH_MSG_GLOBAL_REQUEST packet
-
-- _libssh2_packet_add: SSH_MSG_DEBUG length checks
-  
-  Verify lengths before using them. Read always_display from the correct
-  index. Don't copy stuff around just to provide zero-termination of the
-  strings.
-
-- _libssh2_packet_add: SSH_MSG_IGNORE skip memmove
-  
-  There's no promise of a zero termination of the data in the callback so
-  no longer perform ugly operation in order to provide it.
-
-- _libssh2_packet_add: SSH_MSG_DISCONNECT length checks
-  
-  Verify lengths before trying to read data.
-
-- indent: break lines at 80 columns
-
-- SSH_MSG_CHANNEL_OPEN_FAILURE: used defined values
-  
-  We don't like magic numbers in the code. Now the acceptable failure
-  codes sent in the SSH_MSG_CHANNEL_OPEN_FAILURE message are added as
-  defined values in the private header file.
-
-- sftp_write: don't return EAGAIN if no EAGAIN was received
-  
-  This function now only returns EAGAIN if a lower layer actually returned
-  EAGAIN to it. If nothing was acked and no EAGAIN was received, it will
-  now instead return 0.
-
-- _libssh2_wait_socket: detect nothing-to-wait-for
-  
-  If _libssh2_wait_socket() gets called but there's no direction set to
-  wait for, this causes a "hang". This code now detects this situation,
-  set a 1 second timeout instead and outputs a debug output about it.
-
-- decomp: remove the free_dest argument
-  
-  Since the decompress function ALWAYS returns allocated memory we get a
-  lot simpler code by removing the ability to return data unallocated.
-
-- decomp: cleaned off old compression stuff
-  
-  I cleared off legacy code from when the compression and decompression
-  functions were a single unified function. Makes the code easier to read
-  too.
-
-- [TJ Saunders brought this change]
-
-  decomp: increase decompression buffer sizes
-
-- [TJ Saunders brought this change]
-
-  zlib: Add debug tracing of zlib errors
-
-- sftp_packet_read: handle partial reads of the length field
-  
-  SFTP packets come as [32 bit length][payload] and the code didn't
-  previously handle that the initial 32 bit field was read only partially
-  when it was read.
-
-- [Jasmeet Bagga brought this change]
-
-  kex_agree_hostkey: fix NULL pointer derefence
-  
-  While setting up the session, ssh tries to determine the type of
-  encryption method it can use for the session. This requires looking at
-  the keys offered by the remote host and comparing these with the methods
-  supported by libssh2 (rsa & dss). To do this there is an iteration over
-  the array containing the methods supported by libssh2.
-  
-  If there is no agreement on the type of encryption we come to the 3rd
-  entry of the hostkeyp array. Here hostkeyp is valid but *hostkep is
-  NULL. Thus when we dereference that in (*hostkeyp)->name there is a
-  crash
-
-- _libssh2_transport_send: remove dead assignment
-  
-  'data' isn't accessed beyond this point so there's no need to assign it.
-
-- scp_recv: remove dead assignment
-  
-  Instead of assigning a variable we won't read, we now use the more
-  explicit (void) prefix.
-
-- sftp_write: removed superfluous assignment
-
-- bugfix: avoid use of uninitialized value
-
-- sftp_packet_require: propagate error codes better
-  
-  There were some chances that they would cause -1 to get returned by
-  public functions and as we're hunting down all such occurances and since
-  the underlying functions do return valuable information the code now
-  passes back proper return codes better.
-
-- [Alfred Gebert brought this change]
-
-  fix memory leaks (two times cipher_data) for each sftp session
-
-- libssh2_userauth_authenticated: make it work as documented
-  
-  The man page clearly says it returns 1 for "already authenticated" but
-  the code said non-zero. I changed the code to use 1 now, as that is also
-  non-zero but it gets the benefit that it now matches the documentation.
-  
-  Using 1 instead of non-zero is better for two reasons:
-  
-  1. We have the opportunity to introduce other return codes in the future for
-     things like error and what not.
-  2. We don't expose the internal bitmask variable value.
-
-- userauth_keyboard_interactive: fix indent
-
-- [Alfred Gebert brought this change]
-
-  fix memory leak in userauth_keyboard_interactive()
-  
-  First I wanted to free the memory in session_free() but then
-  I had still memory leaks because in my test case the function
-  userauth_keyboard_interactive() is called twice. It is called
-  twice perhaps because the server has this authentication
-  methods available: publickey,gssapi-with-mic,keyboard-interactive
-  The keyboard-interactive method is successful.
-
-- dist: include sftp.h in dist archives
-
-Simon Josefsson (27 Oct 2010)
-- Update header to match new function prototype, see c48840ba88.
-
-Daniel Stenberg (26 Oct 2010)
-- bugfixes: the transport rearrange left some subtle flaws now gone
-
-- libssh2_userauth_publickey_fromfile_ex.3: cleaned up looks
-
-- libssh2_userauth_publickey: add man page
-  
-  I found an undocumented public function and we can't have it like
-  that. The description here is incomplete, but should serve as a template
-  to allow filling in...
-
-- libssh2_sftp_write.3: added blurb about the "write ahead"
-  
-  Documented the new SFTP write concept
-
-- sftp_close_handle: free any trailing write chunks
-
-- _libssh2_channel_write: fix warnings
-
-- SFTP: bufgix, move more sftp stuff to sftp.h
-  
-  The sftp_write function shouldn't assume that the buffer pointer will be
-  the same in subsequent calls, even if it assumes that the data already
-  passed in before haven't changed.
-  
-  The sftp structs are now moved to sftp.h (which I forgot to add before)
-
-- SFTP: use multiple outgoing packets when writing
-  
-  sftp_write was rewritten to split up outgoing data into multiple packets
-  and deal with the acks in a more asynchronous manner. This is meant to
-  help overcome latency and round-trip problems with the SFTP protocol.
-
-- TODO: implemented a lot of the ideas now
-
-- _libssh2_channel_write: removed 32500 size limit
-  
-  Neither _libssh2_channel_write nor sftp_write now have the 32500 size
-  limit anymore and instead the channel writing function now has its own
-  logic to send data in multiple calls until everything is sent.
-
-- send_existing: don't tell parent to return when drained
-  
-  That will just cause unnecessary code execution.
-
-- _libssh2_channel_write: general code cleanup
-  
-  simplified the function and removed some unused struct fields
-
-- _libssh2_transport_send: replaces _libssh2_transport_write
-  
-  The new function takes two data areas, combines them and sends them as a
-  single SSH packet. This allows several functions to allocate and copy
-  less data.
-  
-  I also found and fixed a mixed up use of the compression function
-  arguments that I introduced in my rewrite in a recent commit.
-
-- scp_write_nonblock: use select() instead of busyloop
-  
-  Make this example nicer by not busylooping.
-
-- send_existing: clear olen when the data is sent off
-
-- _libssh2_transport_write: allow 256 extra bytes around the packet
-
-- _libssh2_transport_write: remade to send without malloc
-
-- compress: compression disabled by default
-  
-  We now allow libssh2_session_flag() to enable compression with a new
-  flag and I added documentation for the previous LIBSSH2_FLAG_SIGPIPE
-  flag which I wasn't really aware of!
-
-- comp: split the compress function
-  
-  It is now made into two separate compress and decompress functions. In
-  preparation for upcoming further modficications.
-
-Dan Fandrich (20 Oct 2010)
-- Added header file to allow compiling in older environments
-
-Daniel Stenberg (20 Oct 2010)
-- TODO: add a possible new API for SFTP transfers
-
-- TODO: "New Transport API" added
-
-- TODO: add buffering plans
-
-Simon Josefsson (13 Oct 2010)
-- Mention libssh2_channel_get_exit_signal and give kudos.
-
-- [Tommy Lindgren brought this change]
-
-  Add libssh2_channel_get_exit_signal man page.
-  
-  Signed-off-by: Simon Josefsson <simon@josefsson.org>
-
-- [Tommy Lindgren brought this change]
-
-  Add libssh2_channel_get_exit_signal.
-  
-  Signed-off-by: Simon Josefsson <simon@josefsson.org>
-
-- Add libssh2_free man page and fix typo.
-
-- Add libssh2_free.
-
-Daniel Stenberg (11 Oct 2010)
-- scp_recv: improved treatment of channel_read() returning zero
-  
-  As a zero return code from channel_read() is not an error we must make
-  sure that the SCP functions deal with that properly. channel_read()
-  always returns 0 if the channel is EOFed already so we check for EOF
-  after 0-reads to be able to return error properly.
-
-- libssh2_session_methods.3: detail what can be asked for
-
-- compression: send zlib before none
-  
-  As the list of algorithms in a preferred order we should send zlib
-  before none to increase the chances that the server will let us do
-  compression.
-
-- compress: faster check, better return codes
-  
-  In the transport functions we avoid a strcmp() now and just check a
-  boolean instead.
-  
-  The compress/decompress function's return code is now acknowledged and
-  used as actual return code in case of failures.
-
-- libssh2_session_handshake: replaces libssh2_session_startup()
-  
-  The function libssh2_session_startup() is now considered deprecated due
-  to the portability issue with the socket argument.
-  libssh2_session_handshake() is the name of the replacement.
-
-- libssh2_socket_t: now externally visible
-  
-  In preparation for upcominig changes, the libssh2_socket_t type is now
-  typedef'ed in the public header.
-
-- _libssh2_transport_drain: removed
-  
-  This function proved not to be used nor useful.
-
-- _libssh2_channel_write: don't iterate over transport writes
-  
-  When a call to _libssh2_transport_write() succeeds, we must return from
-  _libssh2_channel_write() to allow the caller to provide the next chunk
-  of data.
-  
-  We cannot move on to send the next piece of data that may already have
-  been provided in this same function call, as we risk getting EAGAIN for
-  that and we can't return information both about sent data as well as
-  EAGAIN. So, by returning short now, the caller will call this function
-  again with new data to send.
-
-- _libssh2_transport_write: updated documentation blurb
-
-- _libssh2_transport_write: remove fprintf remainder
-  
-  Mistake from previous debugging
-
-- session: improved errors
-  
-  Replaced -1/SOCKET_NONE errors with appropriate error defines instead.
-  
-  Made the verbose trace output during banner receiving less annoying for
-  non-blocking sessions.
-
-- crypt_init: use correct error define
-
-- _libssh2_error: hide EAGAIN for non-blocking sessions
-  
-  In an attempt to make the trace output less cluttered for non-blocking
-  sessions the error function now avoids calling the debug function if the
-  error is the EAGAIN and the session is non-blocking.
-
-- agent: use better error defines
-
-- comp_method_zlib_init: use correct error defines
-
-- transport: better error codes
-  
-  LIBSSH2_SOCKET_NONE (-1) should no longer be used as error code as it is
-  (too) generic and we should instead use specific and dedicated error
-  codes to better describe the error.
-
-- channel: return code and _libssh2_error cleanup
-  
-  Made sure that all transport_write() call failures get _libssh2_error
-  called.
-
-- _libssh2_channel_write: limit to 32700 bytes
-  
-  The well known and used ssh server Dropbear has a maximum SSH packet
-  length at 32768 by default. Since the libssh2 design current have a
-  fixed one-to-one mapping from channel_write() to the packet size created
-  by transport_write() the previous limit of 32768 in the channel layer
-  caused the transport layer to create larger packets than 32768 at times
-  which Dropbear rejected forcibly (by closing the connection).
-  
-  The long term fix is of course to remove the hard relation between the
-  outgoing SSH packet size and what the input length argument is in the
-  transport_write() function call.
-
-- libssh.h: add more dedicated error codes
-
-- SCP: allow file names with bytes > 126
-  
-  When parsing the SCP protocol and verifying that the data looks like a
-  valid file name, byte values over 126 must not be consider illegal since
-  UTF-8 file names will use such codes.
-  
-  Reported by: Uli Zappe
-  Bug: http://www.libssh2.org/mail/libssh2-devel-archive-2010-08/0112.shtml
-
-Dan Fandrich (25 Aug 2010)
-- Document the three sftp stat constants
-
-Guenter Knauf (18 Aug 2010)
-- Fixed Win32 makefile which was now broken at resource build.
-
-- It is sufficient to pipe stderr to NUL to get rid of the nasty messages.
-
-- [Author: Guenter Knauf brought this change]
-
-  Removed Win32 ifdef completely for sys/uio.h.
-  
-  No idea why we had this ifdef at all but MSVC, MingW32, Watcom
-  and Borland all have no sys/uio.h header; so if there's another
-  Win32 compiler which needs it then it should be added explicitely
-  instead of this negative list.
-
-- New files should also be added to Makefile.am.
-  
-  Otherwise they will never be included with release and snapshot tarballs ...
-
-Daniel Stenberg (18 Aug 2010)
-- version: bump to 1.2.8_DEV
-
-Version 1.2.7 (17 Aug 2010)
-
-Daniel Stenberg (17 Aug 2010)
-- release: updated to hold 1.2.7 info
-
-Guenter Knauf (17 Aug 2010)
-- Use the new libssh2.rc file.
-
-- Added resource file for libssh2.dll (shamelessly stolen from libcurl).
-
-- Updated Win32 MSVC dependencies versions.
-
-- Added include for sys/select.h to get fd.set on some platforms.
-
-- Added Watcom makefile borrowed from libcurl.
-  
-  This makefile compiles already all files fine for static lib, but needs
-  final touch when I have OpenSSL fully working with shared libs and Watcom.
-
-- Added copyright define to libssh2.h and use it for binary builds.
-
-- Moved version defines up in order to include from .rc file.
-  
-  Blocked rest of header with ifndef so its possible to let
-  the rc compiler only use the version defines.
-
-- Some minor makefile tweaks.
-
-Daniel Stenberg (2 Aug 2010)
-- example: treat the libssh2_channel_read() return code properly
-  
-  A short read is not an error. Only negative values are errors!
-
-- libssh2_wait_socket: reset error code to "leak" EAGAIN less
-  
-  Since libssh2 often sets LIBSSH2_ERROR_EAGAIN internally before
-  _libssh2_wait_socket is called, we can decrease some amount of
-  confusion in user programs by resetting the error code in this function
-  to reduce the risk of EAGAIN being stored as error when a blocking
-  function returns.
-
-- _libssh2_wait_socket: poll needs milliseconds
-  
-  As reported on the mailing list, the code path using poll() should
-  multiple seconds with 1000 to get milliseconds, not divide!
-  
-  Reported by: Jan Van Boghout
-
-- typedef: make ssize_t get typedef without LIBSSH2_WIN32
-  
-  The condition around the ssize_t typedef depended on both LIBSSH2_WIN32
-  *and* _MSC_VER being defined when it should be enough to depend on
-  _MSC_VER only. It also makes it nicer so libssh2-using code builds fine
-  without having custom defines.
-
-- [John Little brought this change]
-
-  session_free: free more data to avoid memory leaks
-
-- channel_free: ignore problems with channel_close()
-  
-  As was pointed out in bug #182, we must not return failure from
-  _libssh2_channel_free() when _libssh2_channel_close() returns an error
-  that isn't EAGAIN. It can effectively cause the function to never go
-  through, like it did now in the case where the socket was actually
-  closed but socket_state still said LIBSSH2_SOCKET_CONNECTED.
-  
-  I consider this fix the right thing as it now also survives other
-  errors, even if making sure socket_state isn't lying is also a good
-  idea.
-
-- publickey_list_free: no return value from a void function
-  
-  Fixed a compiler warning I introduced previously when checking input
-  arguments more. I also added a check for the other pointer to avoid NULL
-  pointer dereferences.
-
-- [Lars Nordin brought this change]
-
-  openssl: make use of the EVP interface
-  
-  Make use of the EVP interface for the AES-funktion. Using this method
-  supports the use of different ENGINES in OpenSSL for the AES function
-  (and the direct call to the AES_encrypt should not be used according to
-  openssl.org)
-
-Peter Stuge (23 Jun 2010)
-- [Tor Arntsen brought this change]
-
-  Don't overflow MD5 server hostkey
-  
-  Use SHA_DIGEST_LENGTH and MD5_DIGEST_LENGTH in memcpy instead of hardcoded
-  values. An incorrect value was used for MD5.
-
-- Fix message length bugs in libssh2_debug()
-  
-  There was a buffer overflow waiting to happen when a debug message was
-  longer than 1536 bytes.
-  
-  Thanks to Daniel who spotted that there was a problem with the message
-  length passed to a trace handler also after commit
-  0f0652a3093111fc7dac0205fdcf8d02bf16e89f.
-
-- Make libssh2_debug() create a correctly terminated string
-  
-  Also use FILE *stderr rather than fd 2, which can very well be something
-  completely different.
-
-Daniel Stenberg (23 Jun 2010)
-- [TJ Saunders brought this change]
-
-  handshake: Compression enabled at the wrong time
-  
-  In KEXINIT messages, the client and server agree on, among other
-  things, whether to use compression. This method agreement occurs
-  in src/kex.c's kex_agree_methods() function. However, if
-  compression is enabled (either client->server, server->client, or
-  both), then the compression layer is initialized in
-  kex_agree_methods() -- before NEWKEYS has been received.
-  
-  Instead, the initialization of the compression layer should
-  happen after NEWKEYS has been received. This looks to occur
-  insrc/kex.c's diffie_hellman_sha1(), which even has the comment:
-  
-      /* The first key exchange has been performed,
-  
-          switch to active crypt/comp/mac mode */
-  
-  There, after NEWKEYS is received, the cipher and mac algorithms
-  are initialized, and that is where the compression should be
-  initialized as well.
-  
-  The current implementation fails if server->client compression is
-  enabled because most server implementations follow OpenSSH's
-  lead, where compression is initialized after NEWKEYS. Since the
-  server initializes compression after NEWKEYS, but libssh2
-  initializes compression after KEXINIT (i.e. before NEWKEYS), they
-  are out of sync.
-  
-  Reported in bug report #180
-
-- [TJ Saunders brought this change]
-
-  userauth_hostbased_fromfile: packet length too short
-  
-  The packet length calculated in src/userauth.c's
-  userauth_hostbased_fromfile() function is too short by 4 bytes;
-  it forgets to add four bytes for the length of the hostname.
-  This causes hostbased authentication to fail, since the server
-  will read junk data.
-  
-  verified against proftpd's mod_sftp module
-
-- _libssh2_userauth_publickey: reject method names longer than the data
-  
-  This functions get the method length by looking at the first 32
-  bit of data, and I now made it not accept method lengths that are
-  longer than the whole data set is, as given in the dedicated
-  function argument.
-  
-  This was detected when the function was given bogus public key
-  data as an ascii string, which caused the first 32bits to create
-  a HUGE number.
-
-- NULL resistance: make more public functions survive NULL pointer input
-  
-  Sending in NULL as the primary pointer is now dealt with by more
-  public functions. I also narrowed the userauth.c code somewhat to
-  stay within 80 columns better.
-
-- agent: make libssh2_agent_userauth() work blocking properly
-  
-  previously it would always work in a non-blocking manner
-
-Peter Stuge (17 Jun 2010)
-- Fix underscore typo for 64-bit printf format specifiers on Windows
-  
-  Commit 49ddf447ff4bd80285f926eac0115f4e595f9425 was missing underscores.
-
-Daniel Stenberg (16 Jun 2010)
-- libssh2_session_callback_set: extended the man page
diff --git a/libssh2/libssh2/NMakefile b/libssh2/libssh2/NMakefile
deleted file mode 100644
index 07bc2dda..00000000
--- a/libssh2/libssh2/NMakefile
+++ /dev/null
@@ -1,33 +0,0 @@
-!include "win32/config.mk"
-
-!if "$(WITH_WINCNG)" == "1"
-!include "Makefile.WinCNG.inc"
-!else
-!include "Makefile.OpenSSL.inc"
-!endif
-!include "Makefile.inc"
-
-OBJECTS=$(CSOURCES:.c=.obj)
-
-# SUBDIRS=src example
-SUBDIRS=src
-
-all-sub: win32\objects.mk
-	-for %D in ($(SUBDIRS)) do $(MAKE) /nologo /f %D/NMakefile BUILD=$(BUILD) SUBDIR=%D all-sub
-
-clean: 
-	-rmdir 2>NUL /s/q $(TARGET)
-	-del 2>NUL win32\objects.mk
-
-real-clean vclean: clean
-	-del 2>NUL libssh2.dll
-	-del 2>NUL libssh2.exp
-	-del 2>NUL libssh2.ilk
-	-del 2>NUL libssh2.lib
-	-del 2>NUL *.pdb
-
-win32\objects.mk: Makefile.inc
-	@echo OBJECTS = \>$@
-	@for %O in ($(OBJECTS)) do @echo $$(INTDIR)\%O \>>$@
-	@echo $$(EOL)>>$@
-
diff --git a/libssh2/libssh2/README b/libssh2/libssh2/README
deleted file mode 100644
index 8a148568..00000000
--- a/libssh2/libssh2/README
+++ /dev/null
@@ -1,19 +0,0 @@
-libssh2 - SSH2 library
-======================
-
-libssh2 is a library implementing the SSH2 protocol, available under
-the revised BSD license.
-
-Web site: https://www.libssh2.org/
-
-Mailing list: https://cool.haxx.se/mailman/listinfo/libssh2-devel
-
-License: see COPYING
-
-Source code: https://github.com/libssh2/libssh2
-
-Web site source code: https://github.com/libssh2/www
-
-Installation instructions are in:
- - docs/INSTALL_CMAKE for CMake
- - docs/INSTALL_AUTOTOOLS for Autotools
diff --git a/libssh2/libssh2/RELEASE-NOTES b/libssh2/libssh2/RELEASE-NOTES
deleted file mode 100644
index 62064a9f..00000000
--- a/libssh2/libssh2/RELEASE-NOTES
+++ /dev/null
@@ -1,62 +0,0 @@
-libssh2 1.10
-
-This release includes the following enhancements and bugfixes:
-
- o adds agent forwarding support
- o adds OpenSSH Agent support on Windows
- o adds ECDSA key support using the Mbed TLS backend
- o adds ECDSA cert authentication
- o adds diffie-hellman-group14-sha256, diffie-hellman-group16-sha512,
-   diffie-hellman-group18-sha512 key exchanges
- o adds support for PKIX key reading when using ed25519 with OpenSSL
- o adds support for EWOULDBLOCK on VMS systems
- o adds support for building with OpenSSL 3
- o adds support for using FIPS mode in OpenSSL
- o adds debug symbols when building with MSVC
- o adds support for building on the 3DS
- o adds unicode build support on Windows
- o restores os400 building
- o increases min, max and opt Diffie Hellman group values
- o improves portiablity of the make file
- o improves timeout behavior with 2FA keyboard auth
- o various improvements to the Wincng backend
- o fixes reading parital packet replies when using an agent
- o fixes Diffie Hellman key exchange on Windows 1903+ builds
- o fixes building tests with older versions of OpenSSL
- o fixes possible multiple definition warnings
- o fixes potential cast issues _libssh2_ecdsa_key_get_curve_type()
- o fixes potential use after free if libssh2_init() is called twice
- o improved linking when using Mbed TLS
- o fixes call to libssh2_crypto_exit() if crypto hasn't been initialized
- o fixes crash when loading public keys with no id
- o fixes possible out of bounds read when exchanging keys
- o fixes possible out of bounds read when reading packets
- o fixes possible out of bounds read when opening an X11 connection
- o fixes possible out of bounds read when ecdh host keys
- o fixes possible hang when trying to read a disconnected socket
- o fixes a crash when using the delayed compression option
- o fixes read error with large known host entries
- o fixes various warnings
- o fixes various small memory leaks
- o improved error handling, various detailed errors will now be reported
- o builds are now using OSS-Fuzz
- o builds now use autoreconf instead of a custom build script
- o cmake now respects install directory
- o improved CI backend
- o updated HACKING-CRYPTO documentation
- o use markdown file extensions
- o improved unit tests
-
-This release would not have looked like this without help, code, reports and
-advice from friends like these:
-
-  katzer, Orgad Shaneh, mark-i-m, Zenju, axjowa, Thilo Schulz,
-  Etienne Samson, hlefebvre, seba30, Panos, jethrogb, Fabrice Fontaine,
-  Will Cosgrove, Daniel Stenberg, Michael Buckley, Wallace Souza Silva,
-  Romain-Geissler-1A, meierha, Tseng Jun, Thomas Klausner, Brendan Shanks,
-  Harry Sintonen, monnerat, Koutheir Attouchi, Marc Hörsken, yann-morin-1998,
-  Wez Furlong, TDi-jonesds, David Benjamin, Max Dymond, Igor Klevanets,
-  Viktor Szakats, Laurent Stacul, Mstrodl, Gabriel Smith, MarcT512,
-  Paul Capron, teottin, Tor Erik Ottinsen, Brian Inglis
-
-  (40 contributors)
diff --git a/libssh2/libssh2/acinclude.m4 b/libssh2/libssh2/acinclude.m4
deleted file mode 100644
index 2066f0ec..00000000
--- a/libssh2/libssh2/acinclude.m4
+++ /dev/null
@@ -1,512 +0,0 @@
-
-dnl **********************************************************************
-dnl CURL_DETECT_ICC ([ACTION-IF-YES])
-dnl
-dnl check if this is the Intel ICC compiler, and if so run the ACTION-IF-YES
-dnl sets the $ICC variable to "yes" or "no"
-dnl **********************************************************************
-AC_DEFUN([CURL_DETECT_ICC],
-[
-    ICC="no"
-    AC_MSG_CHECKING([for icc in use])
-    if test "$GCC" = "yes"; then
-       dnl check if this is icc acting as gcc in disguise
-       AC_EGREP_CPP([^__INTEL_COMPILER], [__INTEL_COMPILER],
-         dnl action if the text is found, this it has not been replaced by the
-         dnl cpp
-         ICC="no",
-         dnl the text was not found, it was replaced by the cpp
-         ICC="yes"
-         AC_MSG_RESULT([yes])
-         [$1]
-       )
-    fi
-    if test "$ICC" = "no"; then
-        # this is not ICC
-        AC_MSG_RESULT([no])
-    fi
-])
-
-dnl We create a function for detecting which compiler we use and then set as
-dnl pendantic compiler options as possible for that particular compiler. The
-dnl options are only used for debug-builds.
-
-AC_DEFUN([CURL_CC_DEBUG_OPTS],
-[
-    if test "z$ICC" = "z"; then
-      CURL_DETECT_ICC
-    fi
-
-    if test "$GCC" = "yes"; then
-
-       dnl figure out gcc version!
-       AC_MSG_CHECKING([gcc version])
-       gccver=`$CC -dumpversion`
-       num1=`echo $gccver | cut -d . -f1`
-       num2=`echo $gccver | cut -d . -f2`
-       gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`
-       AC_MSG_RESULT($gccver)
-
-       if test "$ICC" = "yes"; then
-         dnl this is icc, not gcc.
-
-         dnl ICC warnings we ignore:
-         dnl * 269 warns on our "%Od" printf formatters for curl_off_t output:
-         dnl   "invalid format string conversion"
-         dnl * 279 warns on static conditions in while expressions
-         dnl * 981 warns on "operands are evaluated in unspecified order"
-         dnl * 1418 "external definition with no prior declaration"
-         dnl * 1419 warns on "external declaration in primary source file"
-         dnl   which we know and do on purpose.
-
-         WARN="-wd279,269,981,1418,1419"
-
-         if test "$gccnum" -gt "600"; then
-            dnl icc 6.0 and older doesn't have the -Wall flag
-            WARN="-Wall $WARN"
-         fi
-       else dnl $ICC = yes
-         dnl this is a set of options we believe *ALL* gcc versions support:
-         WARN="-W -Wall -Wwrite-strings -pedantic -Wpointer-arith -Wnested-externs -Winline -Wmissing-prototypes"
-
-         dnl -Wcast-align is a bit too annoying on all gcc versions ;-)
-
-         if test "$gccnum" -ge "207"; then
-           dnl gcc 2.7 or later
-           WARN="$WARN -Wmissing-declarations"
-         fi
-
-         if test "$gccnum" -gt "295"; then
-           dnl only if the compiler is newer than 2.95 since we got lots of
-           dnl "`_POSIX_C_SOURCE' is not defined" in system headers with
-           dnl gcc 2.95.4 on FreeBSD 4.9!
-           WARN="$WARN -Wundef -Wno-long-long -Wsign-compare"
-         fi
-
-         if test "$gccnum" -ge "296"; then
-           dnl gcc 2.96 or later
-           WARN="$WARN -Wfloat-equal"
-         fi
-
-         if test "$gccnum" -gt "296"; then
-           dnl this option does not exist in 2.96
-           WARN="$WARN -Wno-format-nonliteral"
-         fi
-
-         dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
-         dnl on i686-Linux as it gives us heaps with false positives.
-         dnl Also, on gcc 4.0.X it is totally unbearable and complains all
-         dnl over making it unusable for generic purposes. Let's not use it.
-
-         if test "$gccnum" -ge "303"; then
-           dnl gcc 3.3 and later
-           WARN="$WARN -Wendif-labels -Wstrict-prototypes"
-         fi
-
-         if test "$gccnum" -ge "304"; then
-           # try these on gcc 3.4
-           WARN="$WARN -Wdeclaration-after-statement"
-         fi
-
-         for flag in $CPPFLAGS; do
-           case "$flag" in
-            -I*)
-              dnl Include path, provide a -isystem option for the same dir
-              dnl to prevent warnings in those dirs. The -isystem was not very
-              dnl reliable on earlier gcc versions.
-              add=`echo $flag | sed 's/^-I/-isystem /g'`
-              WARN="$WARN $add"
-              ;;
-           esac
-         done
-
-       fi dnl $ICC = no
-
-       CFLAGS="$CFLAGS $WARN"
-
-      AC_MSG_NOTICE([Added this set of compiler options: $WARN])
-
-    else dnl $GCC = yes
-
-      AC_MSG_NOTICE([Added no extra compiler options])
-
-    fi dnl $GCC = yes
-
-    dnl strip off optimizer flags
-    NEWFLAGS=""
-    for flag in $CFLAGS; do
-      case "$flag" in
-      -O*)
-        dnl echo "cut off $flag"
-        ;;
-      *)
-        NEWFLAGS="$NEWFLAGS $flag"
-        ;;
-      esac
-    done
-    CFLAGS=$NEWFLAGS
-
-]) dnl end of AC_DEFUN()
-
-dnl CURL_CHECK_NONBLOCKING_SOCKET
-dnl -------------------------------------------------
-dnl Check for how to set a socket to non-blocking state. There seems to exist
-dnl four known different ways, with the one used almost everywhere being POSIX
-dnl and XPG3, while the other different ways for different systems (old BSD,
-dnl Windows and Amiga).
-dnl
-dnl There are two known platforms (AIX 3.x and SunOS 4.1.x) where the
-dnl O_NONBLOCK define is found but does not work. This condition is attempted
-dnl to get caught in this script by using an excessive number of #ifdefs...
-dnl
-AC_DEFUN([CURL_CHECK_NONBLOCKING_SOCKET],
-[
-  AC_MSG_CHECKING([non-blocking sockets style])
-
-  AC_TRY_COMPILE([
-/* headers for O_NONBLOCK test */
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-],[
-/* try to compile O_NONBLOCK */
-
-#if defined(sun) || defined(__sun__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# if defined(__SVR4) || defined(__srv4__)
-#  define PLATFORM_SOLARIS
-# else
-#  define PLATFORM_SUNOS4
-# endif
-#endif
-#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
-# define PLATFORM_AIX_V3
-#endif
-
-#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
-#error "O_NONBLOCK does not work on this platform"
-#endif
-  int socket;
-  int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
-],[
-dnl the O_NONBLOCK test was fine
-nonblock="O_NONBLOCK"
-AC_DEFINE(HAVE_O_NONBLOCK, 1, [use O_NONBLOCK for non-blocking sockets])
-],[
-dnl the code was bad, try a different program now, test 2
-
-  AC_TRY_COMPILE([
-/* headers for FIONBIO test */
-#include <unistd.h>
-#include <stropts.h>
-],[
-/* FIONBIO source test (old-style unix) */
- int socket;
- int flags = ioctl(socket, FIONBIO, &flags);
-],[
-dnl FIONBIO test was good
-nonblock="FIONBIO"
-AC_DEFINE(HAVE_FIONBIO, 1, [use FIONBIO for non-blocking sockets])
-],[
-dnl FIONBIO test was also bad
-dnl the code was bad, try a different program now, test 3
-
-  AC_TRY_COMPILE([
-/* headers for ioctlsocket test (Windows) */
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#endif
-],[
-/* ioctlsocket source code */
- SOCKET sd;
- unsigned long flags = 0;
- sd = socket(0, 0, 0);
- ioctlsocket(sd, FIONBIO, &flags);
-],[
-dnl ioctlsocket test was good
-nonblock="ioctlsocket"
-AC_DEFINE(HAVE_IOCTLSOCKET, 1, [use ioctlsocket() for non-blocking sockets])
-],[
-dnl ioctlsocket didnt compile!, go to test 4
-
-  AC_TRY_LINK([
-/* headers for IoctlSocket test (Amiga?) */
-#include <sys/ioctl.h>
-],[
-/* IoctlSocket source code */
- int socket;
- int flags = IoctlSocket(socket, FIONBIO, (long)1);
-],[
-dnl ioctlsocket test was good
-nonblock="IoctlSocket"
-AC_DEFINE(HAVE_IOCTLSOCKET_CASE, 1, [use Ioctlsocket() for non-blocking sockets])
-],[
-dnl Ioctlsocket didnt compile, do test 5!
-  AC_TRY_COMPILE([
-/* headers for SO_NONBLOCK test (BeOS) */
-#include <socket.h>
-],[
-/* SO_NONBLOCK source code */
- long b = 1;
- int socket;
- int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-],[
-dnl the SO_NONBLOCK test was good
-nonblock="SO_NONBLOCK"
-AC_DEFINE(HAVE_SO_NONBLOCK, 1, [use SO_NONBLOCK for non-blocking sockets])
-],[
-dnl test 5 didnt compile!
-nonblock="nada"
-AC_DEFINE(HAVE_DISABLED_NONBLOCKING, 1, [disabled non-blocking sockets])
-])
-dnl end of fifth test
-
-])
-dnl end of forth test
-
-])
-dnl end of third test
-
-])
-dnl end of second test
-
-])
-dnl end of non-blocking try-compile test
-  AC_MSG_RESULT($nonblock)
-
-  if test "$nonblock" = "nada"; then
-    AC_MSG_WARN([non-block sockets disabled])
-  fi
-])
-
-dnl CURL_CHECK_NEED_REENTRANT_SYSTEM
-dnl -------------------------------------------------
-dnl Checks if the preprocessor _REENTRANT definition
-dnl must be unconditionally done for this platform.
-dnl Internal macro for CURL_CONFIGURE_REENTRANT.
-
-AC_DEFUN([CURL_CHECK_NEED_REENTRANT_SYSTEM], [
-  case $host in
-    *-*-solaris* | *-*-hpux*)
-      tmp_need_reentrant="yes"
-      ;;
-    *)
-      tmp_need_reentrant="no"
-      ;;
-  esac
-])
-
-
-dnl CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
-dnl -------------------------------------------------
-dnl This macro ensures that configuration tests done
-dnl after this will execute with preprocessor symbol
-dnl _REENTRANT defined. This macro also ensures that
-dnl the generated config file defines NEED_REENTRANT
-dnl and that in turn setup.h will define _REENTRANT.
-dnl Internal macro for CURL_CONFIGURE_REENTRANT.
-
-AC_DEFUN([CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT], [
-AC_DEFINE(NEED_REENTRANT, 1,
-  [Define to 1 if _REENTRANT preprocessor symbol must be defined.])
-cat >>confdefs.h <<_EOF
-#ifndef _REENTRANT
-#  define _REENTRANT
-#endif
-_EOF
-])
-
-
-dnl CURL_CONFIGURE_REENTRANT
-dnl -------------------------------------------------
-dnl This first checks if the preprocessor _REENTRANT
-dnl symbol is already defined. If it isn't currently
-dnl defined a set of checks are performed to verify
-dnl if its definition is required to make visible to
-dnl the compiler a set of *_r functions. Finally, if
-dnl _REENTRANT is already defined or needed it takes
-dnl care of making adjustments necessary to ensure
-dnl that it is defined equally for further configure
-dnl tests and generated config file.
-
-AC_DEFUN([CURL_CONFIGURE_REENTRANT], [
-  AC_PREREQ([2.50])dnl
-  #
-  AC_MSG_CHECKING([if _REENTRANT is already defined])
-  AC_COMPILE_IFELSE([
-    AC_LANG_PROGRAM([[
-    ]],[[
-#ifdef _REENTRANT
-      int dummy=1;
-#else
-      force compilation error
-#endif
-    ]])
-  ],[
-    AC_MSG_RESULT([yes])
-    tmp_reentrant_initially_defined="yes"
-  ],[
-    AC_MSG_RESULT([no])
-    tmp_reentrant_initially_defined="no"
-  ])
-  #
-  if test "$tmp_reentrant_initially_defined" = "no"; then
-    AC_MSG_CHECKING([if _REENTRANT is actually needed])
-    CURL_CHECK_NEED_REENTRANT_SYSTEM
-
-    if test "$tmp_need_reentrant" = "yes"; then
-      AC_MSG_RESULT([yes])
-    else
-      AC_MSG_RESULT([no])
-    fi
-  fi
-  #
-  AC_MSG_CHECKING([if _REENTRANT is onwards defined])
-  if test "$tmp_reentrant_initially_defined" = "yes" ||
-    test "$tmp_need_reentrant" = "yes"; then
-    CURL_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
-    AC_MSG_RESULT([yes])
-  else
-    AC_MSG_RESULT([no])
-  fi
-  #
-])
-
-dnl LIBSSH2_LIB_HAVE_LINKFLAGS
-dnl --------------------------
-dnl Wrapper around AC_LIB_HAVE_LINKFLAGS to also check $prefix/lib, if set.
-dnl
-dnl autoconf only checks $prefix/lib64 if gcc -print-search-dirs output
-dnl includes a directory named lib64. So, to find libraries in $prefix/lib
-dnl we append -L$prefix/lib to LDFLAGS before checking.
-dnl
-dnl For conveniece, $4 is expanded if [lib]$1 is found.
-
-AC_DEFUN([LIBSSH2_LIB_HAVE_LINKFLAGS], [
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_lib$1_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_lib$1_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_lib$1_prefix}/lib"
-  fi
-
-  AC_LIB_HAVE_LINKFLAGS([$1], [$2], [$3])
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_lib$1" = "yes"; then :
-    $4
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-])
-
-AC_DEFUN([LIBSSH2_CHECK_CRYPTO], [
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "$1"; then
-m4_case([$1],
-[openssl], [
-  LIBSSH2_LIB_HAVE_LINKFLAGS([ssl], [crypto], [#include <openssl/ssl.h>], [
-    AC_DEFINE(LIBSSH2_OPENSSL, 1, [Use $1])
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }libssl libcrypto"
-
-    # Not all OpenSSL have AES-CTR functions.
-    libssh2_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBSSL"
-    AC_CHECK_FUNCS(EVP_aes_128_ctr)
-    LIBS="$libssh2_save_LIBS"
-
-    found_crypto="$1"
-    found_crypto_str="OpenSSL (AES-CTR: ${ac_cv_func_EVP_aes_128_ctr:-N/A})"
-  ])
-],
-
-[libgcrypt], [
-  LIBSSH2_LIB_HAVE_LINKFLAGS([gcrypt], [], [#include <gcrypt.h>], [
-    AC_DEFINE(LIBSSH2_LIBGCRYPT, 1, [Use $1])
-    found_crypto="$1"
-  ])
-],
-
-[mbedtls], [
-  LIBSSH2_LIB_HAVE_LINKFLAGS([mbedcrypto], [], [#include <mbedtls/version.h>], [
-    AC_DEFINE(LIBSSH2_MBEDTLS, 1, [Use $1])
-    LIBS="$LIBS -lmbedcrypto"
-    found_crypto="$1"
-    support_clear_memory=yes
-  ])
-],
-
-[wincng], [
-  # Look for Windows Cryptography API: Next Generation
-
-  AC_CHECK_HEADERS([ntdef.h ntstatus.h], [], [], [#include <windows.h>])
-  AC_CHECK_DECLS([SecureZeroMemory], [], [], [#include <windows.h>])
-
-  LIBSSH2_LIB_HAVE_LINKFLAGS([crypt32], [], [
-    #include <windows.h>
-    #include <wincrypt.h>
-  ])
-  LIBSSH2_LIB_HAVE_LINKFLAGS([bcrypt], [], [
-    #include <windows.h>
-    #include <bcrypt.h>
-  ], [
-    AC_DEFINE(LIBSSH2_WINCNG, 1, [Use $1])
-    found_crypto="$1"
-    found_crypto_str="Windows Cryptography API: Next Generation"
-    support_clear_memory="$ac_cv_have_decl_SecureZeroMemory"
-  ])
-],
-)
-  test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No $1 crypto library found!
-"
-fi
-])
-
-
-dnl LIBSSH2_CHECK_OPTION_WERROR
-dnl -------------------------------------------------
-dnl Verify if configure has been invoked with option
-dnl --enable-werror or --disable-werror, and set
-dnl shell variable want_werror as appropriate.
-
-AC_DEFUN([LIBSSH2_CHECK_OPTION_WERROR], [
-  AC_BEFORE([$0],[LIBSSH2_CHECK_COMPILER])dnl
-  AC_MSG_CHECKING([whether to enable compiler warnings as errors])
-  OPT_COMPILER_WERROR="default"
-  AC_ARG_ENABLE(werror,
-AC_HELP_STRING([--enable-werror],[Enable compiler warnings as errors])
-AC_HELP_STRING([--disable-werror],[Disable compiler warnings as errors]),
-  OPT_COMPILER_WERROR=$enableval)
-  case "$OPT_COMPILER_WERROR" in
-    no)
-      dnl --disable-werror option used
-      want_werror="no"
-      ;;
-    default)
-      dnl configure option not specified
-      want_werror="no"
-      ;;
-    *)
-      dnl --enable-werror option used
-      want_werror="yes"
-      ;;
-  esac
-  AC_MSG_RESULT([$want_werror])
-
-  if test X"$want_werror" = Xyes; then
-    CFLAGS="$CFLAGS -Werror"
-  fi
-])
-
diff --git a/libssh2/libssh2/aclocal.m4 b/libssh2/libssh2/aclocal.m4
deleted file mode 100644
index fc56a693..00000000
--- a/libssh2/libssh2/aclocal.m4
+++ /dev/null
@@ -1,1192 +0,0 @@
-# generated automatically by aclocal 1.16.4 -*- Autoconf -*-
-
-# Copyright (C) 1996-2021 Free Software Foundation, Inc.
-
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
-m4_ifndef([AC_AUTOCONF_VERSION],
-  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],,
-[m4_warning([this file was generated for autoconf 2.71.
-You have another version of autoconf.  It may work, but is not guaranteed to.
-If you have problems, you may need to regenerate the build system entirely.
-To do so, use the procedure documented by the package, typically 'autoreconf'.])])
-
-# Copyright (C) 2002-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_AUTOMAKE_VERSION(VERSION)
-# ----------------------------
-# Automake X.Y traces this macro to ensure aclocal.m4 has been
-# generated from the m4 files accompanying Automake X.Y.
-# (This private macro should not be called outside this file.)
-AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.16'
-dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
-dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.16.4], [],
-      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
-])
-
-# _AM_AUTOCONF_VERSION(VERSION)
-# -----------------------------
-# aclocal traces this macro to find the Autoconf version.
-# This is a private macro too.  Using m4_define simplifies
-# the logic in aclocal, which can simply ignore this definition.
-m4_define([_AM_AUTOCONF_VERSION], [])
-
-# AM_SET_CURRENT_AUTOMAKE_VERSION
-# -------------------------------
-# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
-# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
-AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.16.4])dnl
-m4_ifndef([AC_AUTOCONF_VERSION],
-  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
-
-# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
-# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
-# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
-#
-# Of course, Automake must honor this variable whenever it calls a
-# tool from the auxiliary directory.  The problem is that $srcdir (and
-# therefore $ac_aux_dir as well) can be either absolute or relative,
-# depending on how configure is run.  This is pretty annoying, since
-# it makes $ac_aux_dir quite unusable in subdirectories: in the top
-# source directory, any form will work fine, but in subdirectories a
-# relative path needs to be adjusted first.
-#
-# $ac_aux_dir/missing
-#    fails when called from a subdirectory if $ac_aux_dir is relative
-# $top_srcdir/$ac_aux_dir/missing
-#    fails if $ac_aux_dir is absolute,
-#    fails when called from a subdirectory in a VPATH build with
-#          a relative $ac_aux_dir
-#
-# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
-# are both prefixed by $srcdir.  In an in-source build this is usually
-# harmless because $srcdir is '.', but things will broke when you
-# start a VPATH build or use an absolute $srcdir.
-#
-# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
-# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
-#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
-# and then we would define $MISSING as
-#   MISSING="\${SHELL} $am_aux_dir/missing"
-# This will work as long as MISSING is not called from configure, because
-# unfortunately $(top_srcdir) has no meaning in configure.
-# However there are other variables, like CC, which are often used in
-# configure, and could therefore not use this "fixed" $ac_aux_dir.
-#
-# Another solution, used here, is to always expand $ac_aux_dir to an
-# absolute PATH.  The drawback is that using absolute paths prevent a
-# configured tree to be moved without reconfiguration.
-
-AC_DEFUN([AM_AUX_DIR_EXPAND],
-[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
-# Expand $ac_aux_dir to an absolute path.
-am_aux_dir=`cd "$ac_aux_dir" && pwd`
-])
-
-# AM_CONDITIONAL                                            -*- Autoconf -*-
-
-# Copyright (C) 1997-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_CONDITIONAL(NAME, SHELL-CONDITION)
-# -------------------------------------
-# Define a conditional.
-AC_DEFUN([AM_CONDITIONAL],
-[AC_PREREQ([2.52])dnl
- m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
-       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
-AC_SUBST([$1_TRUE])dnl
-AC_SUBST([$1_FALSE])dnl
-_AM_SUBST_NOTMAKE([$1_TRUE])dnl
-_AM_SUBST_NOTMAKE([$1_FALSE])dnl
-m4_define([_AM_COND_VALUE_$1], [$2])dnl
-if $2; then
-  $1_TRUE=
-  $1_FALSE='#'
-else
-  $1_TRUE='#'
-  $1_FALSE=
-fi
-AC_CONFIG_COMMANDS_PRE(
-[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
-  AC_MSG_ERROR([[conditional "$1" was never defined.
-Usually this means the macro was only invoked conditionally.]])
-fi])])
-
-# Copyright (C) 1999-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-
-# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
-# written in clear, in which case automake, when reading aclocal.m4,
-# will think it sees a *use*, and therefore will trigger all it's
-# C support machinery.  Also note that it means that autoscan, seeing
-# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
-
-
-# _AM_DEPENDENCIES(NAME)
-# ----------------------
-# See how the compiler implements dependency checking.
-# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
-# We try a few techniques and use that to set a single cache variable.
-#
-# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
-# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
-# dependency, and given that the user is not expected to run this macro,
-# just rely on AC_PROG_CC.
-AC_DEFUN([_AM_DEPENDENCIES],
-[AC_REQUIRE([AM_SET_DEPDIR])dnl
-AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
-AC_REQUIRE([AM_MAKE_INCLUDE])dnl
-AC_REQUIRE([AM_DEP_TRACK])dnl
-
-m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
-      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
-      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
-      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
-      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
-      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
-                    [depcc="$$1"   am_compiler_list=])
-
-AC_CACHE_CHECK([dependency style of $depcc],
-               [am_cv_$1_dependencies_compiler_type],
-[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named 'D' -- because '-MD' means "put the output
-  # in D".
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_$1_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
-  fi
-  am__universal=false
-  m4_case([$1], [CC],
-    [case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac],
-    [CXX],
-    [case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac])
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
-      # Solaris 10 /bin/sh.
-      echo '/* dummy */' > sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with '-c' and '-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle '-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs.
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # After this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested.
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok '-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_$1_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_$1_dependencies_compiler_type=none
-fi
-])
-AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
-AM_CONDITIONAL([am__fastdep$1], [
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
-])
-
-
-# AM_SET_DEPDIR
-# -------------
-# Choose a directory name for dependency files.
-# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
-AC_DEFUN([AM_SET_DEPDIR],
-[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
-AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
-])
-
-
-# AM_DEP_TRACK
-# ------------
-AC_DEFUN([AM_DEP_TRACK],
-[AC_ARG_ENABLE([dependency-tracking], [dnl
-AS_HELP_STRING(
-  [--enable-dependency-tracking],
-  [do not reject slow dependency extractors])
-AS_HELP_STRING(
-  [--disable-dependency-tracking],
-  [speeds up one-time build])])
-if test "x$enable_dependency_tracking" != xno; then
-  am_depcomp="$ac_aux_dir/depcomp"
-  AMDEPBACKSLASH='\'
-  am__nodep='_no'
-fi
-AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
-AC_SUBST([AMDEPBACKSLASH])dnl
-_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
-AC_SUBST([am__nodep])dnl
-_AM_SUBST_NOTMAKE([am__nodep])dnl
-])
-
-# Generate code to set up dependency tracking.              -*- Autoconf -*-
-
-# Copyright (C) 1999-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# _AM_OUTPUT_DEPENDENCY_COMMANDS
-# ------------------------------
-AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
-[{
-  # Older Autoconf quotes --file arguments for eval, but not when files
-  # are listed without --file.  Let's play safe and only enable the eval
-  # if we detect the quoting.
-  # TODO: see whether this extra hack can be removed once we start
-  # requiring Autoconf 2.70 or later.
-  AS_CASE([$CONFIG_FILES],
-          [*\'*], [eval set x "$CONFIG_FILES"],
-          [*], [set x $CONFIG_FILES])
-  shift
-  # Used to flag and report bootstrapping failures.
-  am_rc=0
-  for am_mf
-  do
-    # Strip MF so we end up with the name of the file.
-    am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile which includes
-    # dependency-tracking related rules and includes.
-    # Grep'ing the whole file directly is not great: AIX grep has a line
-    # limit of 2048, but all sed's we know have understand at least 4000.
-    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
-      || continue
-    am_dirpart=`AS_DIRNAME(["$am_mf"])`
-    am_filepart=`AS_BASENAME(["$am_mf"])`
-    AM_RUN_LOG([cd "$am_dirpart" \
-      && sed -e '/# am--include-marker/d' "$am_filepart" \
-        | $MAKE -f - am--depfiles]) || am_rc=$?
-  done
-  if test $am_rc -ne 0; then
-    AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments
-    for automatic dependency tracking.  If GNU make was not used, consider
-    re-running the configure script with MAKE="gmake" (or whatever is
-    necessary).  You can also try re-running configure with the
-    '--disable-dependency-tracking' option to at least be able to build
-    the package (albeit without support for automatic dependency tracking).])
-  fi
-  AS_UNSET([am_dirpart])
-  AS_UNSET([am_filepart])
-  AS_UNSET([am_mf])
-  AS_UNSET([am_rc])
-  rm -f conftest-deps.mk
-}
-])# _AM_OUTPUT_DEPENDENCY_COMMANDS
-
-
-# AM_OUTPUT_DEPENDENCY_COMMANDS
-# -----------------------------
-# This macro should only be invoked once -- use via AC_REQUIRE.
-#
-# This code is only required when automatic dependency tracking is enabled.
-# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
-# order to bootstrap the dependency handling code.
-AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
-[AC_CONFIG_COMMANDS([depfiles],
-     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
-     [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])])
-
-# Do all the work for Automake.                             -*- Autoconf -*-
-
-# Copyright (C) 1996-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This macro actually does too much.  Some checks are only needed if
-# your package does certain things.  But this isn't really a big deal.
-
-dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
-m4_define([AC_PROG_CC],
-m4_defn([AC_PROG_CC])
-[_AM_PROG_CC_C_O
-])
-
-# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
-# AM_INIT_AUTOMAKE([OPTIONS])
-# -----------------------------------------------
-# The call with PACKAGE and VERSION arguments is the old style
-# call (pre autoconf-2.50), which is being phased out.  PACKAGE
-# and VERSION should now be passed to AC_INIT and removed from
-# the call to AM_INIT_AUTOMAKE.
-# We support both call styles for the transition.  After
-# the next Automake release, Autoconf can make the AC_INIT
-# arguments mandatory, and then we can depend on a new Autoconf
-# release and drop the old call support.
-AC_DEFUN([AM_INIT_AUTOMAKE],
-[AC_PREREQ([2.65])dnl
-dnl Autoconf wants to disallow AM_ names.  We explicitly allow
-dnl the ones we care about.
-m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
-AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
-AC_REQUIRE([AC_PROG_INSTALL])dnl
-if test "`cd $srcdir && pwd`" != "`pwd`"; then
-  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
-  # is not polluted with repeated "-I."
-  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
-  # test to see if srcdir already configured
-  if test -f $srcdir/config.status; then
-    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
-  fi
-fi
-
-# test whether we have cygpath
-if test -z "$CYGPATH_W"; then
-  if (cygpath --version) >/dev/null 2>/dev/null; then
-    CYGPATH_W='cygpath -w'
-  else
-    CYGPATH_W=echo
-  fi
-fi
-AC_SUBST([CYGPATH_W])
-
-# Define the identity of the package.
-dnl Distinguish between old-style and new-style calls.
-m4_ifval([$2],
-[AC_DIAGNOSE([obsolete],
-             [$0: two- and three-arguments forms are deprecated.])
-m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
- AC_SUBST([PACKAGE], [$1])dnl
- AC_SUBST([VERSION], [$2])],
-[_AM_SET_OPTIONS([$1])dnl
-dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
-m4_if(
-  m4_ifset([AC_PACKAGE_NAME], [ok]):m4_ifset([AC_PACKAGE_VERSION], [ok]),
-  [ok:ok],,
-  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
- AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
- AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
-
-_AM_IF_OPTION([no-define],,
-[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
- AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
-
-# Some tools Automake needs.
-AC_REQUIRE([AM_SANITY_CHECK])dnl
-AC_REQUIRE([AC_ARG_PROGRAM])dnl
-AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
-AM_MISSING_PROG([AUTOCONF], [autoconf])
-AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
-AM_MISSING_PROG([AUTOHEADER], [autoheader])
-AM_MISSING_PROG([MAKEINFO], [makeinfo])
-AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
-AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
-AC_REQUIRE([AC_PROG_MKDIR_P])dnl
-# For better backward compatibility.  To be removed once Automake 1.9.x
-# dies out for good.  For more background, see:
-# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
-AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
-# We need awk for the "check" target (and possibly the TAP driver).  The
-# system "awk" is bad on some platforms.
-AC_REQUIRE([AC_PROG_AWK])dnl
-AC_REQUIRE([AC_PROG_MAKE_SET])dnl
-AC_REQUIRE([AM_SET_LEADING_DOT])dnl
-_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
-	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
-			     [_AM_PROG_TAR([v7])])])
-_AM_IF_OPTION([no-dependencies],,
-[AC_PROVIDE_IFELSE([AC_PROG_CC],
-		  [_AM_DEPENDENCIES([CC])],
-		  [m4_define([AC_PROG_CC],
-			     m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
-AC_PROVIDE_IFELSE([AC_PROG_CXX],
-		  [_AM_DEPENDENCIES([CXX])],
-		  [m4_define([AC_PROG_CXX],
-			     m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
-AC_PROVIDE_IFELSE([AC_PROG_OBJC],
-		  [_AM_DEPENDENCIES([OBJC])],
-		  [m4_define([AC_PROG_OBJC],
-			     m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
-AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
-		  [_AM_DEPENDENCIES([OBJCXX])],
-		  [m4_define([AC_PROG_OBJCXX],
-			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
-])
-# Variables for tags utilities; see am/tags.am
-if test -z "$CTAGS"; then
-  CTAGS=ctags
-fi
-AC_SUBST([CTAGS])
-if test -z "$ETAGS"; then
-  ETAGS=etags
-fi
-AC_SUBST([ETAGS])
-if test -z "$CSCOPE"; then
-  CSCOPE=cscope
-fi
-AC_SUBST([CSCOPE])
-
-AC_REQUIRE([AM_SILENT_RULES])dnl
-dnl The testsuite driver may need to know about EXEEXT, so add the
-dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
-dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
-AC_CONFIG_COMMANDS_PRE(dnl
-[m4_provide_if([_AM_COMPILER_EXEEXT],
-  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
-
-# POSIX will say in a future version that running "rm -f" with no argument
-# is OK; and we want to be able to make that assumption in our Makefile
-# recipes.  So use an aggressive probe to check that the usage we want is
-# actually supported "in the wild" to an acceptable degree.
-# See automake bug#10828.
-# To make any issue more visible, cause the running configure to be aborted
-# by default if the 'rm' program in use doesn't match our expectations; the
-# user can still override this though.
-if rm -f && rm -fr && rm -rf; then : OK; else
-  cat >&2 <<'END'
-Oops!
-
-Your 'rm' program seems unable to run without file operands specified
-on the command line, even when the '-f' option is present.  This is contrary
-to the behaviour of most rm programs out there, and not conforming with
-the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
-
-Please tell bug-automake@gnu.org about your system, including the value
-of your $PATH and any error possibly output before this message.  This
-can help us improve future automake versions.
-
-END
-  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
-    echo 'Configuration will proceed anyway, since you have set the' >&2
-    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
-    echo >&2
-  else
-    cat >&2 <<'END'
-Aborting the configuration process, to ensure you take notice of the issue.
-
-You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <https://www.gnu.org/software/coreutils/>.
-
-If you want to complete the configuration process using your problematic
-'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
-to "yes", and re-run configure.
-
-END
-    AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
-  fi
-fi
-dnl The trailing newline in this macro's definition is deliberate, for
-dnl backward compatibility and to allow trailing 'dnl'-style comments
-dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
-])
-
-dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
-dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
-dnl mangled by Autoconf and run in a shell conditional statement.
-m4_define([_AC_COMPILER_EXEEXT],
-m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
-
-# When config.status generates a header, we must update the stamp-h file.
-# This file resides in the same directory as the config header
-# that is generated.  The stamp files are numbered to have different names.
-
-# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
-# loop where config.status creates the headers, so we can generate
-# our stamp files there.
-AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
-[# Compute $1's index in $config_headers.
-_am_arg=$1
-_am_stamp_count=1
-for _am_header in $config_headers :; do
-  case $_am_header in
-    $_am_arg | $_am_arg:* )
-      break ;;
-    * )
-      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
-  esac
-done
-echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_PROG_INSTALL_SH
-# ------------------
-# Define $install_sh.
-AC_DEFUN([AM_PROG_INSTALL_SH],
-[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-if test x"${install_sh+set}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
-  *)
-    install_sh="\${SHELL} $am_aux_dir/install-sh"
-  esac
-fi
-AC_SUBST([install_sh])])
-
-# Copyright (C) 2003-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# Check whether the underlying file-system supports filenames
-# with a leading dot.  For instance MS-DOS doesn't.
-AC_DEFUN([AM_SET_LEADING_DOT],
-[rm -rf .tst 2>/dev/null
-mkdir .tst 2>/dev/null
-if test -d .tst; then
-  am__leading_dot=.
-else
-  am__leading_dot=_
-fi
-rmdir .tst 2>/dev/null
-AC_SUBST([am__leading_dot])])
-
-# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
-# From Jim Meyering
-
-# Copyright (C) 1996-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_MAINTAINER_MODE([DEFAULT-MODE])
-# ----------------------------------
-# Control maintainer-specific portions of Makefiles.
-# Default is to disable them, unless 'enable' is passed literally.
-# For symmetry, 'disable' may be passed as well.  Anyway, the user
-# can override the default with the --enable/--disable switch.
-AC_DEFUN([AM_MAINTAINER_MODE],
-[m4_case(m4_default([$1], [disable]),
-       [enable], [m4_define([am_maintainer_other], [disable])],
-       [disable], [m4_define([am_maintainer_other], [enable])],
-       [m4_define([am_maintainer_other], [enable])
-        m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
-AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
-  dnl maintainer-mode's default is 'disable' unless 'enable' is passed
-  AC_ARG_ENABLE([maintainer-mode],
-    [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
-      am_maintainer_other[ make rules and dependencies not useful
-      (and sometimes confusing) to the casual installer])],
-    [USE_MAINTAINER_MODE=$enableval],
-    [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
-  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
-  AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
-  MAINT=$MAINTAINER_MODE_TRUE
-  AC_SUBST([MAINT])dnl
-]
-)
-
-# Check to see how 'make' treats includes.	            -*- Autoconf -*-
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_MAKE_INCLUDE()
-# -----------------
-# Check whether make has an 'include' directive that can support all
-# the idioms we need for our automatic dependency tracking code.
-AC_DEFUN([AM_MAKE_INCLUDE],
-[AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive])
-cat > confinc.mk << 'END'
-am__doit:
-	@echo this is the am__doit target >confinc.out
-.PHONY: am__doit
-END
-am__include="#"
-am__quote=
-# BSD make does it like this.
-echo '.include "confinc.mk" # ignored' > confmf.BSD
-# Other make implementations (GNU, Solaris 10, AIX) do it like this.
-echo 'include confinc.mk # ignored' > confmf.GNU
-_am_result=no
-for s in GNU BSD; do
-  AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out])
-  AS_CASE([$?:`cat confinc.out 2>/dev/null`],
-      ['0:this is the am__doit target'],
-      [AS_CASE([$s],
-          [BSD], [am__include='.include' am__quote='"'],
-          [am__include='include' am__quote=''])])
-  if test "$am__include" != "#"; then
-    _am_result="yes ($s style)"
-    break
-  fi
-done
-rm -f confinc.* confmf.*
-AC_MSG_RESULT([${_am_result}])
-AC_SUBST([am__include])])
-AC_SUBST([am__quote])])
-
-# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
-
-# Copyright (C) 1997-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_MISSING_PROG(NAME, PROGRAM)
-# ------------------------------
-AC_DEFUN([AM_MISSING_PROG],
-[AC_REQUIRE([AM_MISSING_HAS_RUN])
-$1=${$1-"${am_missing_run}$2"}
-AC_SUBST($1)])
-
-# AM_MISSING_HAS_RUN
-# ------------------
-# Define MISSING if not defined so far and test if it is modern enough.
-# If it is, set am_missing_run to use it, otherwise, to nothing.
-AC_DEFUN([AM_MISSING_HAS_RUN],
-[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([missing])dnl
-if test x"${MISSING+set}" != xset; then
-  MISSING="\${SHELL} '$am_aux_dir/missing'"
-fi
-# Use eval to expand $SHELL
-if eval "$MISSING --is-lightweight"; then
-  am_missing_run="$MISSING "
-else
-  am_missing_run=
-  AC_MSG_WARN(['missing' script is too old or missing])
-fi
-])
-
-# Helper functions for option handling.                     -*- Autoconf -*-
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# _AM_MANGLE_OPTION(NAME)
-# -----------------------
-AC_DEFUN([_AM_MANGLE_OPTION],
-[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
-
-# _AM_SET_OPTION(NAME)
-# --------------------
-# Set option NAME.  Presently that only means defining a flag for this option.
-AC_DEFUN([_AM_SET_OPTION],
-[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
-
-# _AM_SET_OPTIONS(OPTIONS)
-# ------------------------
-# OPTIONS is a space-separated list of Automake options.
-AC_DEFUN([_AM_SET_OPTIONS],
-[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
-
-# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
-# -------------------------------------------
-# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
-AC_DEFUN([_AM_IF_OPTION],
-[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
-
-# Copyright (C) 1999-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# _AM_PROG_CC_C_O
-# ---------------
-# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
-# to automatically call this.
-AC_DEFUN([_AM_PROG_CC_C_O],
-[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-AC_REQUIRE_AUX_FILE([compile])dnl
-AC_LANG_PUSH([C])dnl
-AC_CACHE_CHECK(
-  [whether $CC understands -c and -o together],
-  [am_cv_prog_cc_c_o],
-  [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
-  # Make sure it works both with $CC and with simple cc.
-  # Following AC_PROG_CC_C_O, we do the test twice because some
-  # compilers refuse to overwrite an existing .o file with -o,
-  # though they will create one.
-  am_cv_prog_cc_c_o=yes
-  for am_i in 1 2; do
-    if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
-         && test -f conftest2.$ac_objext; then
-      : OK
-    else
-      am_cv_prog_cc_c_o=no
-      break
-    fi
-  done
-  rm -f core conftest*
-  unset am_i])
-if test "$am_cv_prog_cc_c_o" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-AC_LANG_POP([C])])
-
-# For backward compatibility.
-AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_RUN_LOG(COMMAND)
-# -------------------
-# Run COMMAND, save the exit status in ac_status, and log it.
-# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
-AC_DEFUN([AM_RUN_LOG],
-[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
-   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
-   ac_status=$?
-   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
-   (exit $ac_status); }])
-
-# Check to make sure that the build environment is sane.    -*- Autoconf -*-
-
-# Copyright (C) 1996-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_SANITY_CHECK
-# ---------------
-AC_DEFUN([AM_SANITY_CHECK],
-[AC_MSG_CHECKING([whether build environment is sane])
-# Reject unsafe characters in $srcdir or the absolute working directory
-# name.  Accept space and tab only in the latter.
-am_lf='
-'
-case `pwd` in
-  *[[\\\"\#\$\&\'\`$am_lf]]*)
-    AC_MSG_ERROR([unsafe absolute working directory name]);;
-esac
-case $srcdir in
-  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
-    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
-esac
-
-# Do 'set' in a subshell so we don't clobber the current shell's
-# arguments.  Must try -L first in case configure is actually a
-# symlink; some systems play weird games with the mod time of symlinks
-# (eg FreeBSD returns the mod time of the symlink's containing
-# directory).
-if (
-   am_has_slept=no
-   for am_try in 1 2; do
-     echo "timestamp, slept: $am_has_slept" > conftest.file
-     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
-     if test "$[*]" = "X"; then
-	# -L didn't work.
-	set X `ls -t "$srcdir/configure" conftest.file`
-     fi
-     if test "$[*]" != "X $srcdir/configure conftest.file" \
-	&& test "$[*]" != "X conftest.file $srcdir/configure"; then
-
-	# If neither matched, then we have a broken ls.  This can happen
-	# if, for instance, CONFIG_SHELL is bash and it inherits a
-	# broken ls alias from the environment.  This has actually
-	# happened.  Such a system could not be considered "sane".
-	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
-  alias in your environment])
-     fi
-     if test "$[2]" = conftest.file || test $am_try -eq 2; then
-       break
-     fi
-     # Just in case.
-     sleep 1
-     am_has_slept=yes
-   done
-   test "$[2]" = conftest.file
-   )
-then
-   # Ok.
-   :
-else
-   AC_MSG_ERROR([newly created file is older than distributed files!
-Check your system clock])
-fi
-AC_MSG_RESULT([yes])
-# If we didn't sleep, we still need to ensure time stamps of config.status and
-# generated files are strictly newer.
-am_sleep_pid=
-if grep 'slept: no' conftest.file >/dev/null 2>&1; then
-  ( sleep 1 ) &
-  am_sleep_pid=$!
-fi
-AC_CONFIG_COMMANDS_PRE(
-  [AC_MSG_CHECKING([that generated files are newer than configure])
-   if test -n "$am_sleep_pid"; then
-     # Hide warnings about reused PIDs.
-     wait $am_sleep_pid 2>/dev/null
-   fi
-   AC_MSG_RESULT([done])])
-rm -f conftest.file
-])
-
-# Copyright (C) 2009-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_SILENT_RULES([DEFAULT])
-# --------------------------
-# Enable less verbose build rules; with the default set to DEFAULT
-# ("yes" being less verbose, "no" or empty being verbose).
-AC_DEFUN([AM_SILENT_RULES],
-[AC_ARG_ENABLE([silent-rules], [dnl
-AS_HELP_STRING(
-  [--enable-silent-rules],
-  [less verbose build output (undo: "make V=1")])
-AS_HELP_STRING(
-  [--disable-silent-rules],
-  [verbose build output (undo: "make V=0")])dnl
-])
-case $enable_silent_rules in @%:@ (((
-  yes) AM_DEFAULT_VERBOSITY=0;;
-   no) AM_DEFAULT_VERBOSITY=1;;
-    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
-esac
-dnl
-dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
-dnl do not support nested variable expansions.
-dnl See automake bug#9928 and bug#10237.
-am_make=${MAKE-make}
-AC_CACHE_CHECK([whether $am_make supports nested variables],
-   [am_cv_make_support_nested_variables],
-   [if AS_ECHO([['TRUE=$(BAR$(V))
-BAR0=false
-BAR1=true
-V=1
-am__doit:
-	@$(TRUE)
-.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
-  am_cv_make_support_nested_variables=yes
-else
-  am_cv_make_support_nested_variables=no
-fi])
-if test $am_cv_make_support_nested_variables = yes; then
-  dnl Using '$V' instead of '$(V)' breaks IRIX make.
-  AM_V='$(V)'
-  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
-else
-  AM_V=$AM_DEFAULT_VERBOSITY
-  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
-fi
-AC_SUBST([AM_V])dnl
-AM_SUBST_NOTMAKE([AM_V])dnl
-AC_SUBST([AM_DEFAULT_V])dnl
-AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
-AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
-AM_BACKSLASH='\'
-AC_SUBST([AM_BACKSLASH])dnl
-_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
-])
-
-# Copyright (C) 2001-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# AM_PROG_INSTALL_STRIP
-# ---------------------
-# One issue with vendor 'install' (even GNU) is that you can't
-# specify the program used to strip binaries.  This is especially
-# annoying in cross-compiling environments, where the build's strip
-# is unlikely to handle the host's binaries.
-# Fortunately install-sh will honor a STRIPPROG variable, so we
-# always use install-sh in "make install-strip", and initialize
-# STRIPPROG with the value of the STRIP variable (set by the user).
-AC_DEFUN([AM_PROG_INSTALL_STRIP],
-[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
-# Installed binaries are usually stripped using 'strip' when the user
-# run "make install-strip".  However 'strip' might not be the right
-# tool to use in cross-compilation environments, therefore Automake
-# will honor the 'STRIP' environment variable to overrule this program.
-dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
-if test "$cross_compiling" != no; then
-  AC_CHECK_TOOL([STRIP], [strip], :)
-fi
-INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
-AC_SUBST([INSTALL_STRIP_PROGRAM])])
-
-# Copyright (C) 2006-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# _AM_SUBST_NOTMAKE(VARIABLE)
-# ---------------------------
-# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
-# This macro is traced by Automake.
-AC_DEFUN([_AM_SUBST_NOTMAKE])
-
-# AM_SUBST_NOTMAKE(VARIABLE)
-# --------------------------
-# Public sister of _AM_SUBST_NOTMAKE.
-AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
-
-# Check how to create a tarball.                            -*- Autoconf -*-
-
-# Copyright (C) 2004-2021 Free Software Foundation, Inc.
-#
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# _AM_PROG_TAR(FORMAT)
-# --------------------
-# Check how to create a tarball in format FORMAT.
-# FORMAT should be one of 'v7', 'ustar', or 'pax'.
-#
-# Substitute a variable $(am__tar) that is a command
-# writing to stdout a FORMAT-tarball containing the directory
-# $tardir.
-#     tardir=directory && $(am__tar) > result.tar
-#
-# Substitute a variable $(am__untar) that extract such
-# a tarball read from stdin.
-#     $(am__untar) < result.tar
-#
-AC_DEFUN([_AM_PROG_TAR],
-[# Always define AMTAR for backward compatibility.  Yes, it's still used
-# in the wild :-(  We should find a proper way to deprecate it ...
-AC_SUBST([AMTAR], ['$${TAR-tar}'])
-
-# We'll loop over all known methods to create a tar archive until one works.
-_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
-
-m4_if([$1], [v7],
-  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
-
-  [m4_case([$1],
-    [ustar],
-     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
-      # There is notably a 21 bits limit for the UID and the GID.  In fact,
-      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
-      # and bug#13588).
-      am_max_uid=2097151 # 2^21 - 1
-      am_max_gid=$am_max_uid
-      # The $UID and $GID variables are not portable, so we need to resort
-      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
-      # below are definitely unexpected, so allow the users to see them
-      # (that is, avoid stderr redirection).
-      am_uid=`id -u || echo unknown`
-      am_gid=`id -g || echo unknown`
-      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
-      if test $am_uid -le $am_max_uid; then
-         AC_MSG_RESULT([yes])
-      else
-         AC_MSG_RESULT([no])
-         _am_tools=none
-      fi
-      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
-      if test $am_gid -le $am_max_gid; then
-         AC_MSG_RESULT([yes])
-      else
-        AC_MSG_RESULT([no])
-        _am_tools=none
-      fi],
-
-  [pax],
-    [],
-
-  [m4_fatal([Unknown tar format])])
-
-  AC_MSG_CHECKING([how to create a $1 tar archive])
-
-  # Go ahead even if we have the value already cached.  We do so because we
-  # need to set the values for the 'am__tar' and 'am__untar' variables.
-  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
-
-  for _am_tool in $_am_tools; do
-    case $_am_tool in
-    gnutar)
-      for _am_tar in tar gnutar gtar; do
-        AM_RUN_LOG([$_am_tar --version]) && break
-      done
-      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
-      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
-      am__untar="$_am_tar -xf -"
-      ;;
-    plaintar)
-      # Must skip GNU tar: if it does not support --format= it doesn't create
-      # ustar tarball either.
-      (tar --version) >/dev/null 2>&1 && continue
-      am__tar='tar chf - "$$tardir"'
-      am__tar_='tar chf - "$tardir"'
-      am__untar='tar xf -'
-      ;;
-    pax)
-      am__tar='pax -L -x $1 -w "$$tardir"'
-      am__tar_='pax -L -x $1 -w "$tardir"'
-      am__untar='pax -r'
-      ;;
-    cpio)
-      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
-      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
-      am__untar='cpio -i -H $1 -d'
-      ;;
-    none)
-      am__tar=false
-      am__tar_=false
-      am__untar=false
-      ;;
-    esac
-
-    # If the value was cached, stop now.  We just wanted to have am__tar
-    # and am__untar set.
-    test -n "${am_cv_prog_tar_$1}" && break
-
-    # tar/untar a dummy directory, and stop if the command works.
-    rm -rf conftest.dir
-    mkdir conftest.dir
-    echo GrepMe > conftest.dir/file
-    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
-    rm -rf conftest.dir
-    if test -s conftest.tar; then
-      AM_RUN_LOG([$am__untar <conftest.tar])
-      AM_RUN_LOG([cat conftest.dir/file])
-      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
-    fi
-  done
-  rm -rf conftest.dir
-
-  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
-  AC_MSG_RESULT([$am_cv_prog_tar_$1])])
-
-AC_SUBST([am__tar])
-AC_SUBST([am__untar])
-]) # _AM_PROG_TAR
-
-m4_include([m4/autobuild.m4])
-m4_include([m4/lib-ld.m4])
-m4_include([m4/lib-link.m4])
-m4_include([m4/lib-prefix.m4])
-m4_include([m4/libtool.m4])
-m4_include([m4/ltoptions.m4])
-m4_include([m4/ltsugar.m4])
-m4_include([m4/ltversion.m4])
-m4_include([m4/lt~obsolete.m4])
-m4_include([acinclude.m4])
diff --git a/libssh2/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake b/libssh2/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake
deleted file mode 100644
index 8ac61abe..00000000
--- a/libssh2/libssh2/cmake/CheckFunctionExistsMayNeedLibrary.cmake
+++ /dev/null
@@ -1,81 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-
-# - check_function_exists_maybe_need_library(<function> <var> [lib1 ... libn])
-#
-# Check if function is available for linking, first without extra libraries, and
-# then, if not found that way, linking in each optional library as well.  This
-# function is similar to autotools AC_SEARCH_LIBS.
-#
-# If the function if found, this will define <var>.
-#
-# If the function was only found by linking in an additional library, this
-# will define NEED_LIB_LIBX, where LIBX is the one of lib1 to libn that
-# makes the function available, in uppercase.
-#
-# The following variables may be set before calling this macro to
-# modify the way the check is run:
-#
-#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
-#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
-#  CMAKE_REQUIRED_INCLUDES = list of include directories
-#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
-#
-
-include(CheckFunctionExists)
-include(CheckLibraryExists)
-
-function(check_function_exists_may_need_library function variable)
-
-  check_function_exists(${function} ${variable})
-
-  if(NOT ${variable})
-    foreach(lib ${ARGN})
-      string(TOUPPER ${lib} UP_LIB)
-      # Use new variable to prevent cache from previous step shortcircuiting
-      # new test
-      check_library_exists(${lib} ${function} "" HAVE_${function}_IN_${lib})
-      if(HAVE_${function}_IN_${lib})
-	set(${variable} 1 CACHE INTERNAL
-	  "Function ${function} found in library ${lib}")
-	set(NEED_LIB_${UP_LIB} 1 CACHE INTERNAL
-	  "Need to link ${lib}")
-	break()
-      endif()
-    endforeach()
-  endif()
-
-endfunction()
\ No newline at end of file
diff --git a/libssh2/libssh2/cmake/CheckNonblockingSocketSupport.cmake b/libssh2/libssh2/cmake/CheckNonblockingSocketSupport.cmake
deleted file mode 100644
index 74f4776a..00000000
--- a/libssh2/libssh2/cmake/CheckNonblockingSocketSupport.cmake
+++ /dev/null
@@ -1,119 +0,0 @@
-include(CheckCSourceCompiles)
-
-# - check_nonblocking_socket_support()
-#
-# Check for how to set a socket to non-blocking state. There seems to exist
-# four known different ways, with the one used almost everywhere being POSIX
-# and XPG3, while the other different ways for different systems (old BSD,
-# Windows and Amiga).
-#
-# One of the following variables will be set indicating the supported
-# method (if any):
-#   HAVE_O_NONBLOCK
-#   HAVE_FIONBIO
-#   HAVE_IOCTLSOCKET
-#   HAVE_IOCTLSOCKET_CASE
-#   HAVE_SO_NONBLOCK
-#   HAVE_DISABLED_NONBLOCKING
-#
-# The following variables may be set before calling this macro to
-# modify the way the check is run:
-#
-#  CMAKE_REQUIRED_FLAGS = string of compile command line flags
-#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
-#  CMAKE_REQUIRED_INCLUDES = list of include directories
-#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link
-#
-macro(check_nonblocking_socket_support)
-  # There are two known platforms (AIX 3.x and SunOS 4.1.x) where the
-  # O_NONBLOCK define is found but does not work.
-  check_c_source_compiles("
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-#if defined(sun) || defined(__sun__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# if defined(__SVR4) || defined(__srv4__)
-#  define PLATFORM_SOLARIS
-# else
-#  define PLATFORM_SUNOS4
-# endif
-#endif
-#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
-# define PLATFORM_AIX_V3
-#endif
-
-#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
-#error \"O_NONBLOCK does not work on this platform\"
-#endif
-
-int main()
-{
-    int socket;
-    int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
-}"
-  HAVE_O_NONBLOCK)
-
-  if(NOT HAVE_O_NONBLOCK)
-    check_c_source_compiles("/* FIONBIO test (old-style unix) */
-#include <unistd.h>
-#include <stropts.h>
-
-int main()
-{
-    int socket;
-    int flags = ioctl(socket, FIONBIO, &flags);
-}"
-    HAVE_FIONBIO)
-
-    if(NOT HAVE_FIONBIO)
-      check_c_source_compiles("/* ioctlsocket test (Windows) */
-#undef inline
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <windows.h>
-#include <winsock2.h>
-
-int main()
-{
-    SOCKET sd;
-    unsigned long flags = 0;
-    sd = socket(0, 0, 0);
-    ioctlsocket(sd, FIONBIO, &flags);
-}"
-      HAVE_IOCTLSOCKET)
-
-      if(NOT HAVE_IOCTLSOCKET)
-	check_c_source_compiles("/* IoctlSocket test (Amiga?) */
-#include <sys/ioctl.h>
-
-int main()
-{
-    int socket;
-    int flags = IoctlSocket(socket, FIONBIO, (long)1);
-}"
-        HAVE_IOCTLSOCKET_CASE)
-
-        if(NOT HAVE_IOCTLSOCKET_CASE)
-	  check_c_source_compiles("/* SO_NONBLOCK test (BeOS) */
-#include <socket.h>
-
-int main()
-{
-    long b = 1;
-    int socket;
-    int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-}"
-          HAVE_SO_NONBLOCK)
-
-	  if(NOT HAVE_SO_NONBLOCK)
-	    # No non-blocking socket method found
-	    set(HAVE_DISABLED_NONBLOCKING 1)
-	  endif()
-	endif()
-      endif()
-    endif()
-  endif()
-endmacro()
\ No newline at end of file
diff --git a/libssh2/libssh2/cmake/CopyRuntimeDependencies.cmake b/libssh2/libssh2/cmake/CopyRuntimeDependencies.cmake
deleted file mode 100644
index 083f7626..00000000
--- a/libssh2/libssh2/cmake/CopyRuntimeDependencies.cmake
+++ /dev/null
@@ -1,72 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-include(CMakeParseArguments)
-
-function(ADD_TARGET_TO_COPY_DEPENDENCIES)
-  set(options)
-  set(oneValueArgs TARGET)
-  set(multiValueArgs DEPENDENCIES BEFORE_TARGETS)
-  cmake_parse_arguments(COPY
-    "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  if(NOT COPY_DEPENDENCIES)
-    return()
-  endif()
-
-  # Using a custom target to drive custom commands stops multiple
-  # parallel builds trying to kick off the commands at the same time
-  add_custom_target(${COPY_TARGET})
-
-  foreach(target ${COPY_BEFORE_TARGETS})
-    add_dependencies(${target} ${COPY_TARGET})
-  endforeach()
-
-  foreach(dependency ${COPY_DEPENDENCIES})
-
-    add_custom_command(
-      TARGET ${COPY_TARGET}
-      DEPENDS ${dependency}
-      # Make directory first otherwise file is copied in place of
-      # directory instead of into it
-      COMMAND ${CMAKE_COMMAND}
-      ARGS -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
-      COMMAND ${CMAKE_COMMAND}
-      ARGS -E copy ${dependency} ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}
-      VERBATIM)
-
-  endforeach()
-
-endfunction()
diff --git a/libssh2/libssh2/cmake/FindLibgcrypt.cmake b/libssh2/libssh2/cmake/FindLibgcrypt.cmake
deleted file mode 100644
index 44a79873..00000000
--- a/libssh2/libssh2/cmake/FindLibgcrypt.cmake
+++ /dev/null
@@ -1,53 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# - Try to find Libgcrypt
-# This will define all or none of:
-#  LIBGCRYPT_FOUND - if Libgcrypt headers and library was found
-#  LIBGCRYPT_INCLUDE_DIRS - The Libgcrypt include directories
-#  LIBGCRYPT_LIBRARIES - The libraries needed to use Libgcrypt
-
-find_path(LIBGCRYPT_INCLUDE_DIR gcrypt.h)
-
-find_library(LIBGCRYPT_LIBRARY NAMES gcrypt libgcrypt)
-
-set(LIBGCRYPT_LIBRARIES ${LIBGCRYPT_LIBRARY})
-set(LIBGCRYPT_INCLUDE_DIRS ${LIBGCRYPT_INCLUDE_DIR})
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libgcrypt DEFAULT_MSG
-                                  LIBGCRYPT_LIBRARY LIBGCRYPT_INCLUDE_DIR)
-
-mark_as_advanced(LIBGCRYPT_INCLUDE_DIR LIBGCRYPT_LIBRARY)
\ No newline at end of file
diff --git a/libssh2/libssh2/cmake/FindmbedTLS.cmake b/libssh2/libssh2/cmake/FindmbedTLS.cmake
deleted file mode 100644
index 2f4adbc5..00000000
--- a/libssh2/libssh2/cmake/FindmbedTLS.cmake
+++ /dev/null
@@ -1,64 +0,0 @@
-# - Try to find mbedTLS
-# Once done this will define
-#
-# Read-Only variables
-#  MBEDTLS_FOUND - system has mbedTLS
-#  MBEDTLS_INCLUDE_DIR - the mbedTLS include directory
-#  MBEDTLS_LIBRARY_DIR - the mbedTLS library directory
-#  MBEDTLS_LIBRARIES - Link these to use mbedTLS
-#  MBEDTLS_LIBRARY - path to mbedTLS library
-#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
-#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
-
-FIND_PATH(MBEDTLS_INCLUDE_DIR mbedtls/version.h)
-
-IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
-    # Already in cache, be silent
-    SET(MBEDTLS_FIND_QUIETLY TRUE)
-ENDIF()
-
-FIND_LIBRARY(MBEDTLS_LIBRARY NAMES mbedtls libmbedtls libmbedx509)
-FIND_LIBRARY(MBEDX509_LIBRARY NAMES mbedx509 libmbedx509)
-FIND_LIBRARY(MBEDCRYPTO_LIBRARY NAMES mbedcrypto libmbedcrypto)
-
-IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
-     SET(MBEDTLS_FOUND TRUE)
-ENDIF()
-
-IF(MBEDTLS_FOUND)
-    # split mbedTLS into -L and -l linker options, so we can set them for pkg-config
-    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_DIR ${MBEDTLS_LIBRARY} PATH)
-    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY} NAME_WE)
-    GET_FILENAME_COMPONENT(MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY} NAME_WE)
-    GET_FILENAME_COMPONENT(MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY} NAME_WE)
-    STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
-    STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
-    STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
-    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
-
-    IF(NOT MBEDTLS_FIND_QUIETLY)
-        MESSAGE(STATUS "Found mbedTLS:")
-        FILE(READ ${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h MBEDTLSCONTENT)
-        STRING(REGEX MATCH "MBEDTLS_VERSION_STRING +\"[0-9|.]+\"" MBEDTLSMATCH ${MBEDTLSCONTENT})
-        IF (MBEDTLSMATCH)
-            STRING(REGEX REPLACE "MBEDTLS_VERSION_STRING +\"([0-9|.]+)\"" "\\1" MBEDTLS_VERSION ${MBEDTLSMATCH})
-            MESSAGE(STATUS "  version ${MBEDTLS_VERSION}")
-        ENDIF(MBEDTLSMATCH)
-        MESSAGE(STATUS "  TLS: ${MBEDTLS_LIBRARY}")
-        MESSAGE(STATUS "  X509: ${MBEDX509_LIBRARY}")
-        MESSAGE(STATUS "  Crypto: ${MBEDCRYPTO_LIBRARY}")
-    ENDIF(NOT MBEDTLS_FIND_QUIETLY)
-ELSE(MBEDTLS_FOUND)
-    IF(MBEDTLS_FIND_REQUIRED)
-        MESSAGE(FATAL_ERROR "Could not find mbedTLS")
-    ENDIF(MBEDTLS_FIND_REQUIRED)
-ENDIF(MBEDTLS_FOUND)
-
-MARK_AS_ADVANCED(
-    MBEDTLS_INCLUDE_DIR
-    MBEDTLS_LIBRARY_DIR
-    MBEDTLS_LIBRARIES
-    MBEDTLS_LIBRARY
-    MBEDX509_LIBRARY
-    MBEDCRYPTO_LIBRARY
-)
diff --git a/libssh2/libssh2/cmake/SocketLibraries.cmake b/libssh2/libssh2/cmake/SocketLibraries.cmake
deleted file mode 100644
index bfbbd711..00000000
--- a/libssh2/libssh2/cmake/SocketLibraries.cmake
+++ /dev/null
@@ -1,64 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Some systems have their socket functions in a library.
-# (Solaris -lsocket/-lnsl, Windows -lws2_32).  This macro appends those
-# libraries to the given list
-macro(append_needed_socket_libraries LIBRARIES_LIST)
-  if(CMAKE_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-    # x86 Windows uses STDCALL for these functions, so their names are mangled,
-    # meaning the platform checks don't work. Hardcoding these until we get
-    # a better solution.
-    set(HAVE_SOCKET 1)
-    set(HAVE_SELECT 1)
-    set(HAVE_INET_ADDR 1)
-    set(NEED_LIB_WS2_32 1)
-  else()
-    check_function_exists_may_need_library(socket HAVE_SOCKET socket ws2_32)
-    check_function_exists_may_need_library(select HAVE_SELECT ws2_32)
-    check_function_exists_may_need_library(inet_addr HAVE_INET_ADDR nsl ws2_32)
-  endif()
-
-  if(NEED_LIB_SOCKET)
-    list(APPEND ${LIBRARIES_LIST} socket)
-  endif()
-  if(NEED_LIB_NSL)
-    list(APPEND ${LIBRARIES_LIST} nsl)
-  endif()
-  if(NEED_LIB_WS2_32)
-    list(APPEND ${LIBRARIES_LIST} ws2_32)
-  endif()
-
-endmacro()
\ No newline at end of file
diff --git a/libssh2/libssh2/cmake/Toolchain-Linux-32.cmake b/libssh2/libssh2/cmake/Toolchain-Linux-32.cmake
deleted file mode 100644
index 6aad9b1e..00000000
--- a/libssh2/libssh2/cmake/Toolchain-Linux-32.cmake
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-# Cross-compile 32-bit binary on 64-bit linux host
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_VERSION 1)
-set(CMAKE_SYSTEM_PROCESSOR "i386")
-
-set(CMAKE_CXX_COMPILER_ARG1 "-m32")
-set(CMAKE_C_COMPILER_ARG1 "-m32")
\ No newline at end of file
diff --git a/libssh2/libssh2/cmake/max_warnings.cmake b/libssh2/libssh2/cmake/max_warnings.cmake
deleted file mode 100644
index b176d302..00000000
--- a/libssh2/libssh2/cmake/max_warnings.cmake
+++ /dev/null
@@ -1,23 +0,0 @@
-if(MSVC)
-  # Use the highest warning level for visual studio.
-  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
-  endif()
-  if(CMAKE_C_FLAGS MATCHES "/W[0-4]")
-    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-  else()
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
-  endif()
-
-  # Disable broken warnings
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
-elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-  if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-  endif()
-  if(NOT CMAKE_C_FLAGS MATCHES "-Wall")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-  endif()
-endif()
diff --git a/libssh2/libssh2/compile b/libssh2/libssh2/compile
deleted file mode 100755
index 23fcba01..00000000
--- a/libssh2/libssh2/compile
+++ /dev/null
@@ -1,348 +0,0 @@
-#! /bin/sh
-# Wrapper for compilers which do not understand '-c -o'.
-
-scriptversion=2018-03-07.03; # UTC
-
-# Copyright (C) 1999-2020 Free Software Foundation, Inc.
-# Written by Tom Tromey <tromey@cygnus.com>.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# This file is maintained in Automake, please report
-# bugs to <bug-automake@gnu.org> or send patches to
-# <automake-patches@gnu.org>.
-
-nl='
-'
-
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent tools from complaining about whitespace usage.
-IFS=" ""	$nl"
-
-file_conv=
-
-# func_file_conv build_file lazy
-# Convert a $build file to $host form and store it in $file
-# Currently only supports Windows hosts. If the determined conversion
-# type is listed in (the comma separated) LAZY, no conversion will
-# take place.
-func_file_conv ()
-{
-  file=$1
-  case $file in
-    / | /[!/]*) # absolute file, and not a UNC file
-      if test -z "$file_conv"; then
-	# lazily determine how to convert abs files
-	case `uname -s` in
-	  MINGW*)
-	    file_conv=mingw
-	    ;;
-	  CYGWIN* | MSYS*)
-	    file_conv=cygwin
-	    ;;
-	  *)
-	    file_conv=wine
-	    ;;
-	esac
-      fi
-      case $file_conv/,$2, in
-	*,$file_conv,*)
-	  ;;
-	mingw/*)
-	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
-	  ;;
-	cygwin/* | msys/*)
-	  file=`cygpath -m "$file" || echo "$file"`
-	  ;;
-	wine/*)
-	  file=`winepath -w "$file" || echo "$file"`
-	  ;;
-      esac
-      ;;
-  esac
-}
-
-# func_cl_dashL linkdir
-# Make cl look for libraries in LINKDIR
-func_cl_dashL ()
-{
-  func_file_conv "$1"
-  if test -z "$lib_path"; then
-    lib_path=$file
-  else
-    lib_path="$lib_path;$file"
-  fi
-  linker_opts="$linker_opts -LIBPATH:$file"
-}
-
-# func_cl_dashl library
-# Do a library search-path lookup for cl
-func_cl_dashl ()
-{
-  lib=$1
-  found=no
-  save_IFS=$IFS
-  IFS=';'
-  for dir in $lib_path $LIB
-  do
-    IFS=$save_IFS
-    if $shared && test -f "$dir/$lib.dll.lib"; then
-      found=yes
-      lib=$dir/$lib.dll.lib
-      break
-    fi
-    if test -f "$dir/$lib.lib"; then
-      found=yes
-      lib=$dir/$lib.lib
-      break
-    fi
-    if test -f "$dir/lib$lib.a"; then
-      found=yes
-      lib=$dir/lib$lib.a
-      break
-    fi
-  done
-  IFS=$save_IFS
-
-  if test "$found" != yes; then
-    lib=$lib.lib
-  fi
-}
-
-# func_cl_wrapper cl arg...
-# Adjust compile command to suit cl
-func_cl_wrapper ()
-{
-  # Assume a capable shell
-  lib_path=
-  shared=:
-  linker_opts=
-  for arg
-  do
-    if test -n "$eat"; then
-      eat=
-    else
-      case $1 in
-	-o)
-	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
-	  eat=1
-	  case $2 in
-	    *.o | *.[oO][bB][jJ])
-	      func_file_conv "$2"
-	      set x "$@" -Fo"$file"
-	      shift
-	      ;;
-	    *)
-	      func_file_conv "$2"
-	      set x "$@" -Fe"$file"
-	      shift
-	      ;;
-	  esac
-	  ;;
-	-I)
-	  eat=1
-	  func_file_conv "$2" mingw
-	  set x "$@" -I"$file"
-	  shift
-	  ;;
-	-I*)
-	  func_file_conv "${1#-I}" mingw
-	  set x "$@" -I"$file"
-	  shift
-	  ;;
-	-l)
-	  eat=1
-	  func_cl_dashl "$2"
-	  set x "$@" "$lib"
-	  shift
-	  ;;
-	-l*)
-	  func_cl_dashl "${1#-l}"
-	  set x "$@" "$lib"
-	  shift
-	  ;;
-	-L)
-	  eat=1
-	  func_cl_dashL "$2"
-	  ;;
-	-L*)
-	  func_cl_dashL "${1#-L}"
-	  ;;
-	-static)
-	  shared=false
-	  ;;
-	-Wl,*)
-	  arg=${1#-Wl,}
-	  save_ifs="$IFS"; IFS=','
-	  for flag in $arg; do
-	    IFS="$save_ifs"
-	    linker_opts="$linker_opts $flag"
-	  done
-	  IFS="$save_ifs"
-	  ;;
-	-Xlinker)
-	  eat=1
-	  linker_opts="$linker_opts $2"
-	  ;;
-	-*)
-	  set x "$@" "$1"
-	  shift
-	  ;;
-	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
-	  func_file_conv "$1"
-	  set x "$@" -Tp"$file"
-	  shift
-	  ;;
-	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
-	  func_file_conv "$1" mingw
-	  set x "$@" "$file"
-	  shift
-	  ;;
-	*)
-	  set x "$@" "$1"
-	  shift
-	  ;;
-      esac
-    fi
-    shift
-  done
-  if test -n "$linker_opts"; then
-    linker_opts="-link$linker_opts"
-  fi
-  exec "$@" $linker_opts
-  exit 1
-}
-
-eat=
-
-case $1 in
-  '')
-     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
-     exit 1;
-     ;;
-  -h | --h*)
-    cat <<\EOF
-Usage: compile [--help] [--version] PROGRAM [ARGS]
-
-Wrapper for compilers which do not understand '-c -o'.
-Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
-arguments, and rename the output as expected.
-
-If you are trying to build a whole package this is not the
-right script to run: please start by reading the file 'INSTALL'.
-
-Report bugs to <bug-automake@gnu.org>.
-EOF
-    exit $?
-    ;;
-  -v | --v*)
-    echo "compile $scriptversion"
-    exit $?
-    ;;
-  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
-  icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
-    func_cl_wrapper "$@"      # Doesn't return...
-    ;;
-esac
-
-ofile=
-cfile=
-
-for arg
-do
-  if test -n "$eat"; then
-    eat=
-  else
-    case $1 in
-      -o)
-	# configure might choose to run compile as 'compile cc -o foo foo.c'.
-	# So we strip '-o arg' only if arg is an object.
-	eat=1
-	case $2 in
-	  *.o | *.obj)
-	    ofile=$2
-	    ;;
-	  *)
-	    set x "$@" -o "$2"
-	    shift
-	    ;;
-	esac
-	;;
-      *.c)
-	cfile=$1
-	set x "$@" "$1"
-	shift
-	;;
-      *)
-	set x "$@" "$1"
-	shift
-	;;
-    esac
-  fi
-  shift
-done
-
-if test -z "$ofile" || test -z "$cfile"; then
-  # If no '-o' option was seen then we might have been invoked from a
-  # pattern rule where we don't need one.  That is ok -- this is a
-  # normal compilation that the losing compiler can handle.  If no
-  # '.c' file was seen then we are probably linking.  That is also
-  # ok.
-  exec "$@"
-fi
-
-# Name of file we expect compiler to create.
-cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
-
-# Create the lock directory.
-# Note: use '[/\\:.-]' here to ensure that we don't use the same name
-# that we are using for the .o file.  Also, base the name on the expected
-# object file name, since that is what matters with a parallel build.
-lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
-while true; do
-  if mkdir "$lockdir" >/dev/null 2>&1; then
-    break
-  fi
-  sleep 1
-done
-# FIXME: race condition here if user kills between mkdir and trap.
-trap "rmdir '$lockdir'; exit 1" 1 2 15
-
-# Run the compile.
-"$@"
-ret=$?
-
-if test -f "$cofile"; then
-  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
-elif test -f "${cofile}bj"; then
-  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
-fi
-
-rmdir "$lockdir"
-exit $ret
-
-# Local Variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/libssh2/libssh2/config.guess b/libssh2/libssh2/config.guess
deleted file mode 100755
index f50dcdb6..00000000
--- a/libssh2/libssh2/config.guess
+++ /dev/null
@@ -1,1480 +0,0 @@
-#! /bin/sh
-# Attempt to guess a canonical system name.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-24'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-#
-# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
-#
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-#
-# Please send patches to <config-patches@gnu.org>.
-
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION]
-
-Output the configuration name of the system \`$me' is run on.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.guess ($timestamp)
-
-Originally written by Per Bothner.
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help" >&2
-       exit 1 ;;
-    * )
-       break ;;
-  esac
-done
-
-if test $# != 0; then
-  echo "$me: too many arguments$help" >&2
-  exit 1
-fi
-
-trap 'exit 1' 1 2 15
-
-# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
-# compiler to aid in system detection is discouraged as it requires
-# temporary files to be created and, as you can see below, it is a
-# headache to deal with in a portable fashion.
-
-# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
-# use `HOST_CC' if defined, but it is deprecated.
-
-# Portable tmp directory creation inspired by the Autoconf team.
-
-set_cc_for_build='
-trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
-trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
-: ${TMPDIR=/tmp} ;
- { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
- { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
- { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
- { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
-dummy=$tmp/dummy ;
-tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > "$dummy.c" ;
-	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
-	     CC_FOR_BUILD="$c"; break ;
-	  fi ;
-	done ;
-	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found ;
-	fi
-	;;
- ,,*)   CC_FOR_BUILD=$CC ;;
- ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac ; set_cc_for_build= ;'
-
-# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 1994-08-24)
-if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
-	PATH=$PATH:/.attbin ; export PATH
-fi
-
-UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
-UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
-UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
-UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
-
-case "$UNAME_SYSTEM" in
-Linux|GNU|GNU/*)
-	# If the system lacks a compiler, then just pick glibc.
-	# We could probably try harder.
-	LIBC=gnu
-
-	eval "$set_cc_for_build"
-	cat <<-EOF > "$dummy.c"
-	#include <features.h>
-	#if defined(__UCLIBC__)
-	LIBC=uclibc
-	#elif defined(__dietlibc__)
-	LIBC=dietlibc
-	#else
-	LIBC=gnu
-	#endif
-	EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
-
-	# If ldd exists, use it to detect musl libc.
-	if command -v ldd >/dev/null && \
-		ldd --version 2>&1 | grep -q ^musl
-	then
-	    LIBC=musl
-	fi
-	;;
-esac
-
-# Note: order is significant - the case branches are not exclusive.
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
-    *:NetBSD:*:*)
-	# NetBSD (nbsd) targets should (where applicable) match one or
-	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
-	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
-	# switched to ELF, *-*-netbsd* would select the old
-	# object file format.  This provides both forward
-	# compatibility and a consistent mechanism for selecting the
-	# object file format.
-	#
-	# Note: NetBSD doesn't particularly care about the vendor
-	# portion of the name.  We always set it to "unknown".
-	sysctl="sysctl -n hw.machine_arch"
-	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
-	    "/sbin/$sysctl" 2>/dev/null || \
-	    "/usr/sbin/$sysctl" 2>/dev/null || \
-	    echo unknown)`
-	case "$UNAME_MACHINE_ARCH" in
-	    armeb) machine=armeb-unknown ;;
-	    arm*) machine=arm-unknown ;;
-	    sh3el) machine=shl-unknown ;;
-	    sh3eb) machine=sh-unknown ;;
-	    sh5el) machine=sh5le-unknown ;;
-	    earmv*)
-		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
-		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
-		machine="${arch}${endian}"-unknown
-		;;
-	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
-	esac
-	# The Operating System including object format, if it has switched
-	# to ELF recently (or will in the future) and ABI.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		os=netbsdelf
-		;;
-	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval "$set_cc_for_build"
-		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
-			| grep -q __ELF__
-		then
-		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
-		    # Return netbsd for either.  FIX?
-		    os=netbsd
-		else
-		    os=netbsdelf
-		fi
-		;;
-	    *)
-		os=netbsd
-		;;
-	esac
-	# Determine ABI tags.
-	case "$UNAME_MACHINE_ARCH" in
-	    earm*)
-		expr='s/^earmv[0-9]/-eabi/;s/eb$//'
-		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
-		;;
-	esac
-	# The OS release
-	# Debian GNU/NetBSD machines have a different userland, and
-	# thus, need a distinct triplet. However, they do not need
-	# kernel version information, so it can be replaced with a
-	# suitable tag, in the style of linux-gnu.
-	case "$UNAME_VERSION" in
-	    Debian*)
-		release='-gnu'
-		;;
-	    *)
-		release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
-		;;
-	esac
-	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
-	# contains redundant information, the shorter form:
-	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "$machine-${os}${release}${abi}"
-	exit ;;
-    *:Bitrig:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
-	exit ;;
-    *:OpenBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
-	exit ;;
-    *:LibertyBSD:*:*)
-	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
-	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
-	exit ;;
-    *:MidnightBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
-	exit ;;
-    *:ekkoBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
-	exit ;;
-    *:SolidBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
-	exit ;;
-    macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:MirBSD:*:*)
-	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
-	exit ;;
-    *:Sortix:*:*)
-	echo "$UNAME_MACHINE"-unknown-sortix
-	exit ;;
-    *:Redox:*:*)
-	echo "$UNAME_MACHINE"-unknown-redox
-	exit ;;
-    mips:OSF1:*.*)
-        echo mips-dec-osf1
-        exit ;;
-    alpha:OSF1:*:*)
-	case $UNAME_RELEASE in
-	*4.0)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
-		;;
-	*5.*)
-		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
-		;;
-	esac
-	# According to Compaq, /usr/sbin/psrinfo has been available on
-	# OSF/1 and Tru64 systems produced since 1995.  I hope that
-	# covers most systems running today.  This code pipes the CPU
-	# types through head -n 1, so we only detect the type of CPU 0.
-	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
-	case "$ALPHA_CPU_TYPE" in
-	    "EV4 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "EV4.5 (21064)")
-		UNAME_MACHINE=alpha ;;
-	    "LCA4 (21066/21068)")
-		UNAME_MACHINE=alpha ;;
-	    "EV5 (21164)")
-		UNAME_MACHINE=alphaev5 ;;
-	    "EV5.6 (21164A)")
-		UNAME_MACHINE=alphaev56 ;;
-	    "EV5.6 (21164PC)")
-		UNAME_MACHINE=alphapca56 ;;
-	    "EV5.7 (21164PC)")
-		UNAME_MACHINE=alphapca57 ;;
-	    "EV6 (21264)")
-		UNAME_MACHINE=alphaev6 ;;
-	    "EV6.7 (21264A)")
-		UNAME_MACHINE=alphaev67 ;;
-	    "EV6.8CB (21264C)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8AL (21264B)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.8CX (21264D)")
-		UNAME_MACHINE=alphaev68 ;;
-	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE=alphaev69 ;;
-	    "EV7 (21364)")
-		UNAME_MACHINE=alphaev7 ;;
-	    "EV7.9 (21364A)")
-		UNAME_MACHINE=alphaev79 ;;
-	esac
-	# A Pn.n version is a patched version.
-	# A Vn.n version is a released version.
-	# A Tn.n version is a released field test version.
-	# A Xn.n version is an unreleased experimental baselevel.
-	# 1.2 uses "1.2" for uname -r.
-	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
-	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
-	exitcode=$?
-	trap '' 0
-	exit $exitcode ;;
-    Amiga*:UNIX_System_V:4.0:*)
-	echo m68k-unknown-sysv4
-	exit ;;
-    *:[Aa]miga[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-amigaos
-	exit ;;
-    *:[Mm]orph[Oo][Ss]:*:*)
-	echo "$UNAME_MACHINE"-unknown-morphos
-	exit ;;
-    *:OS/390:*:*)
-	echo i370-ibm-openedition
-	exit ;;
-    *:z/VM:*:*)
-	echo s390-ibm-zvmoe
-	exit ;;
-    *:OS400:*:*)
-	echo powerpc-ibm-os400
-	exit ;;
-    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
-	echo arm-acorn-riscix"$UNAME_RELEASE"
-	exit ;;
-    arm*:riscos:*:*|arm*:RISCOS:*:*)
-	echo arm-unknown-riscos
-	exit ;;
-    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
-	echo hppa1.1-hitachi-hiuxmpp
-	exit ;;
-    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
-	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
-	if test "`(/bin/universe) 2>/dev/null`" = att ; then
-		echo pyramid-pyramid-sysv3
-	else
-		echo pyramid-pyramid-bsd
-	fi
-	exit ;;
-    NILE*:*:*:dcosx)
-	echo pyramid-pyramid-svr4
-	exit ;;
-    DRS?6000:unix:4.0:6*)
-	echo sparc-icl-nx6
-	exit ;;
-    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
-	case `/usr/bin/uname -p` in
-	    sparc) echo sparc-icl-nx7; exit ;;
-	esac ;;
-    s390x:SunOS:*:*)
-	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`"
-	exit ;;
-    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux"$UNAME_RELEASE"
-	exit ;;
-    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval "$set_cc_for_build"
-	SUN_ARCH=i386
-	# If there is a compiler, see if it is configured for 64-bit objects.
-	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
-	# This test works for both compilers.
-	if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		SUN_ARCH=x86_64
-	    fi
-	fi
-	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:6*:*)
-	# According to config.sub, this is the proper way to canonicalize
-	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
-	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    sun4*:SunOS:*:*)
-	case "`/usr/bin/arch -k`" in
-	    Series*|S4*)
-		UNAME_RELEASE=`uname -v`
-		;;
-	esac
-	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
-	exit ;;
-    sun3*:SunOS:*:*)
-	echo m68k-sun-sunos"$UNAME_RELEASE"
-	exit ;;
-    sun*:*:4.2BSD:*)
-	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
-	case "`/bin/arch`" in
-	    sun3)
-		echo m68k-sun-sunos"$UNAME_RELEASE"
-		;;
-	    sun4)
-		echo sparc-sun-sunos"$UNAME_RELEASE"
-		;;
-	esac
-	exit ;;
-    aushp:SunOS:*:*)
-	echo sparc-auspex-sunos"$UNAME_RELEASE"
-	exit ;;
-    # The situation for MiNT is a little confusing.  The machine name
-    # can be virtually everything (everything which is not
-    # "atarist" or "atariste" at least should have a processor
-    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
-    # to the lowercase version "mint" (or "freemint").  Finally
-    # the system name "TOS" denotes a system which is actually not
-    # MiNT.  But MiNT is downward compatible to TOS, so this should
-    # be no problem.
-    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint"$UNAME_RELEASE"
-	exit ;;
-    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint"$UNAME_RELEASE"
-	exit ;;
-    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint"$UNAME_RELEASE"
-	exit ;;
-    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint"$UNAME_RELEASE"
-	exit ;;
-    m68k:machten:*:*)
-	echo m68k-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    powerpc:machten:*:*)
-	echo powerpc-apple-machten"$UNAME_RELEASE"
-	exit ;;
-    RISC*:Mach:*:*)
-	echo mips-dec-mach_bsd4.3
-	exit ;;
-    RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix"$UNAME_RELEASE"
-	exit ;;
-    2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix"$UNAME_RELEASE"
-	exit ;;
-    mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-	#if defined (host_mips) && defined (MIPSEB)
-	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
-	#endif
-	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
-	#endif
-	#endif
-	  exit (-1);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
-	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
-	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
-	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos"$UNAME_RELEASE"
-	exit ;;
-    Motorola:PowerMAX_OS:*:*)
-	echo powerpc-motorola-powermax
-	exit ;;
-    Motorola:*:4.3:PL8-*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
-	echo powerpc-harris-powermax
-	exit ;;
-    Night_Hawk:Power_UNIX:*:*)
-	echo powerpc-harris-powerunix
-	exit ;;
-    m88k:CX/UX:7*:*)
-	echo m88k-harris-cxux7
-	exit ;;
-    m88k:*:4*:R4*)
-	echo m88k-motorola-sysv4
-	exit ;;
-    m88k:*:3*:R3*)
-	echo m88k-motorola-sysv3
-	exit ;;
-    AViiON:dgux:*:*)
-	# DG/UX returns AViiON for all architectures
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ]
-	then
-	    if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \
-	       [ "$TARGET_BINARY_INTERFACE"x = x ]
-	    then
-		echo m88k-dg-dgux"$UNAME_RELEASE"
-	    else
-		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
-	    fi
-	else
-	    echo i586-dg-dgux"$UNAME_RELEASE"
-	fi
-	exit ;;
-    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
-	echo m88k-dolphin-sysv3
-	exit ;;
-    M88*:*:R3*:*)
-	# Delta 88k system running SVR3
-	echo m88k-motorola-sysv3
-	exit ;;
-    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
-	echo m88k-tektronix-sysv3
-	exit ;;
-    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
-	echo m68k-tektronix-bsd
-	exit ;;
-    *:IRIX*:*:*)
-	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
-	exit ;;
-    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
-	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
-	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
-    i*86:AIX:*:*)
-	echo i386-ibm-aix
-	exit ;;
-    ia64:AIX:*:*)
-	if [ -x /usr/bin/oslevel ] ; then
-		IBM_REV=`/usr/bin/oslevel`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:2:3)
-	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval "$set_cc_for_build"
-		sed 's/^		//' << EOF > "$dummy.c"
-		#include <sys/systemcfg.h>
-
-		main()
-			{
-			if (!__power_pc())
-				exit(1);
-			puts("powerpc-ibm-aix3.2.5");
-			exit(0);
-			}
-EOF
-		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
-		then
-			echo "$SYSTEM_NAME"
-		else
-			echo rs6000-ibm-aix3.2.5
-		fi
-	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
-		echo rs6000-ibm-aix3.2.4
-	else
-		echo rs6000-ibm-aix3.2
-	fi
-	exit ;;
-    *:AIX:*:[4567])
-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
-		IBM_ARCH=rs6000
-	else
-		IBM_ARCH=powerpc
-	fi
-	if [ -x /usr/bin/lslpp ] ; then
-		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
-			   awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
-	else
-		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
-	fi
-	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
-	exit ;;
-    *:AIX:*:*)
-	echo rs6000-ibm-aix
-	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
-	echo romp-ibm-bsd4.4
-	exit ;;
-    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
-	exit ;;                             # report: romp-ibm BSD 4.3
-    *:BOSX:*:*)
-	echo rs6000-bull-bosx
-	exit ;;
-    DPX/2?00:B.O.S.:*:*)
-	echo m68k-bull-sysv3
-	exit ;;
-    9000/[34]??:4.3bsd:1.*:*)
-	echo m68k-hp-bsd
-	exit ;;
-    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
-	echo m68k-hp-bsd4.4
-	exit ;;
-    9000/[34678]??:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	case "$UNAME_MACHINE" in
-	    9000/31?)            HP_ARCH=m68000 ;;
-	    9000/[34]??)         HP_ARCH=m68k ;;
-	    9000/[678][0-9][0-9])
-		if [ -x /usr/bin/getconf ]; then
-		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
-		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "$sc_cpu_version" in
-		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
-		      532)                      # CPU_PA_RISC2_0
-			case "$sc_kernel_bits" in
-			  32) HP_ARCH=hppa2.0n ;;
-			  64) HP_ARCH=hppa2.0w ;;
-			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
-			esac ;;
-		    esac
-		fi
-		if [ "$HP_ARCH" = "" ]; then
-		    eval "$set_cc_for_build"
-		    sed 's/^		//' << EOF > "$dummy.c"
-
-		#define _HPUX_SOURCE
-		#include <stdlib.h>
-		#include <unistd.h>
-
-		int main ()
-		{
-		#if defined(_SC_KERNEL_BITS)
-		    long bits = sysconf(_SC_KERNEL_BITS);
-		#endif
-		    long cpu  = sysconf (_SC_CPU_VERSION);
-
-		    switch (cpu)
-			{
-			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
-			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
-			case CPU_PA_RISC2_0:
-		#if defined(_SC_KERNEL_BITS)
-			    switch (bits)
-				{
-				case 64: puts ("hppa2.0w"); break;
-				case 32: puts ("hppa2.0n"); break;
-				default: puts ("hppa2.0"); break;
-				} break;
-		#else  /* !defined(_SC_KERNEL_BITS) */
-			    puts ("hppa2.0"); break;
-		#endif
-			default: puts ("hppa1.0"); break;
-			}
-		    exit (0);
-		}
-EOF
-		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
-		    test -z "$HP_ARCH" && HP_ARCH=hppa
-		fi ;;
-	esac
-	if [ "$HP_ARCH" = hppa2.0w ]
-	then
-	    eval "$set_cc_for_build"
-
-	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
-	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
-	    # generating 64-bit code.  GNU and HP use different nomenclature:
-	    #
-	    # $ CC_FOR_BUILD=cc ./config.guess
-	    # => hppa2.0w-hp-hpux11.23
-	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
-	    # => hppa64-hp-hpux11.23
-
-	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
-		grep -q __LP64__
-	    then
-		HP_ARCH=hppa2.0w
-	    else
-		HP_ARCH=hppa64
-	    fi
-	fi
-	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
-	exit ;;
-    ia64:HP-UX:*:*)
-	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'`
-	echo ia64-hp-hpux"$HPUX_REV"
-	exit ;;
-    3050*:HI-UX:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#include <unistd.h>
-	int
-	main ()
-	{
-	  long cpu = sysconf (_SC_CPU_VERSION);
-	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
-	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
-	     results, however.  */
-	  if (CPU_IS_PA_RISC (cpu))
-	    {
-	      switch (cpu)
-		{
-		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
-		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
-		  default: puts ("hppa-hitachi-hiuxwe2"); break;
-		}
-	    }
-	  else if (CPU_IS_HP_MC68K (cpu))
-	    puts ("m68k-hitachi-hiuxwe2");
-	  else puts ("unknown-hitachi-hiuxwe2");
-	  exit (0);
-	}
-EOF
-	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
-		{ echo "$SYSTEM_NAME"; exit; }
-	echo unknown-hitachi-hiuxwe2
-	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
-	echo hppa1.1-hp-bsd
-	exit ;;
-    9000/8??:4.3bsd:*:*)
-	echo hppa1.0-hp-bsd
-	exit ;;
-    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
-	echo hppa1.0-hp-mpeix
-	exit ;;
-    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
-	echo hppa1.1-hp-osf
-	exit ;;
-    hp8??:OSF1:*:*)
-	echo hppa1.0-hp-osf
-	exit ;;
-    i*86:OSF1:*:*)
-	if [ -x /usr/sbin/sysversion ] ; then
-	    echo "$UNAME_MACHINE"-unknown-osf1mk
-	else
-	    echo "$UNAME_MACHINE"-unknown-osf1
-	fi
-	exit ;;
-    parisc*:Lites*:*:*)
-	echo hppa1.1-hp-lites
-	exit ;;
-    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
-	echo c1-convex-bsd
-	exit ;;
-    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
-	echo c34-convex-bsd
-	exit ;;
-    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
-	echo c38-convex-bsd
-	exit ;;
-    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
-	echo c4-convex-bsd
-	exit ;;
-    CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*[A-Z]90:*:*:*)
-	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
-	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-	      -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*TS:*:*:*)
-	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'
-	exit ;;
-    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
-	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
-	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
-	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
-	exit ;;
-    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
-	exit ;;
-    sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:BSD/OS:*:*)
-	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
-	exit ;;
-    *:FreeBSD:*:*)
-	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case "$UNAME_PROCESSOR" in
-	    amd64)
-		UNAME_PROCESSOR=x86_64 ;;
-	    i386)
-		UNAME_PROCESSOR=i586 ;;
-	esac
-	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    i*:CYGWIN*:*)
-	echo "$UNAME_MACHINE"-pc-cygwin
-	exit ;;
-    *:MINGW64*:*)
-	echo "$UNAME_MACHINE"-pc-mingw64
-	exit ;;
-    *:MINGW*:*)
-	echo "$UNAME_MACHINE"-pc-mingw32
-	exit ;;
-    *:MSYS*:*)
-	echo "$UNAME_MACHINE"-pc-msys
-	exit ;;
-    i*:PW*:*)
-	echo "$UNAME_MACHINE"-pc-pw32
-	exit ;;
-    *:Interix*:*)
-	case "$UNAME_MACHINE" in
-	    x86)
-		echo i586-pc-interix"$UNAME_RELEASE"
-		exit ;;
-	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	    IA64)
-		echo ia64-unknown-interix"$UNAME_RELEASE"
-		exit ;;
-	esac ;;
-    i*:UWIN*:*)
-	echo "$UNAME_MACHINE"-pc-uwin
-	exit ;;
-    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
-	echo x86_64-unknown-cygwin
-	exit ;;
-    prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`"
-	exit ;;
-    *:GNU:*:*)
-	# the GNU system
-	echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
-	exit ;;
-    *:GNU/*:*:*)
-	# other systems with GNU libc and userland
-	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC"
-	exit ;;
-    i*86:Minix:*:*)
-	echo "$UNAME_MACHINE"-pc-minix
-	exit ;;
-    aarch64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    aarch64_be:Linux:*:*)
-	UNAME_MACHINE=aarch64_be
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    alpha:Linux:*:*)
-	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
-	  EV5)   UNAME_MACHINE=alphaev5 ;;
-	  EV56)  UNAME_MACHINE=alphaev56 ;;
-	  PCA56) UNAME_MACHINE=alphapca56 ;;
-	  PCA57) UNAME_MACHINE=alphapca56 ;;
-	  EV6)   UNAME_MACHINE=alphaev6 ;;
-	  EV67)  UNAME_MACHINE=alphaev67 ;;
-	  EV68*) UNAME_MACHINE=alphaev68 ;;
-	esac
-	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arc:Linux:*:* | arceb:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    arm*:Linux:*:*)
-	eval "$set_cc_for_build"
-	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
-	    | grep -q __ARM_EABI__
-	then
-	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	else
-	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
-		| grep -q __ARM_PCS_VFP
-	    then
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
-	    else
-		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
-	    fi
-	fi
-	exit ;;
-    avr32*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    cris:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    crisv32:Linux:*:*)
-	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
-	exit ;;
-    e2k:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    frv:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    hexagon:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:Linux:*:*)
-	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	exit ;;
-    ia64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    k1om:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m32r*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    m68*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    mips:Linux:*:* | mips64:Linux:*:*)
-	eval "$set_cc_for_build"
-	sed 's/^	//' << EOF > "$dummy.c"
-	#undef CPU
-	#undef ${UNAME_MACHINE}
-	#undef ${UNAME_MACHINE}el
-	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
-	CPU=${UNAME_MACHINE}el
-	#else
-	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
-	CPU=${UNAME_MACHINE}
-	#else
-	CPU=
-	#endif
-	#endif
-EOF
-	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
-	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
-	;;
-    mips64el:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    openrisc*:Linux:*:*)
-	echo or1k-unknown-linux-"$LIBC"
-	exit ;;
-    or32:Linux:*:* | or1k*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    padre:Linux:*:*)
-	echo sparc-unknown-linux-"$LIBC"
-	exit ;;
-    parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-"$LIBC"
-	exit ;;
-    parisc:Linux:*:* | hppa:Linux:*:*)
-	# Look for CPU level
-	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
-	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
-	  *)    echo hppa-unknown-linux-"$LIBC" ;;
-	esac
-	exit ;;
-    ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-"$LIBC"
-	exit ;;
-    ppc:Linux:*:*)
-	echo powerpc-unknown-linux-"$LIBC"
-	exit ;;
-    ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-"$LIBC"
-	exit ;;
-    ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-"$LIBC"
-	exit ;;
-    riscv32:Linux:*:* | riscv64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    s390:Linux:*:* | s390x:Linux:*:*)
-	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
-	exit ;;
-    sh64*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sh*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    tile*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    vax:Linux:*:*)
-	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
-	exit ;;
-    x86_64:Linux:*:*)
-	if objdump -f /bin/sh | grep -q elf32-x86-64; then
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
-	else
-	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
-	fi
-	exit ;;
-    xtensa*:Linux:*:*)
-	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
-	exit ;;
-    i*86:DYNIX/ptx:4*:*)
-	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
-	# earlier versions are messed up and put the nodename in both
-	# sysname and nodename.
-	echo i386-sequent-sysv4
-	exit ;;
-    i*86:UNIX_SV:4.2MP:2.*)
-	# Unixware is an offshoot of SVR4, but it has its own version
-	# number series starting with 2...
-	# I am not positive that other SVR4 systems won't match this,
-	# I just have to hope.  -- rms.
-	# Use sysv4.2uw... so that sysv4* matches it.
-	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
-	exit ;;
-    i*86:OS/2:*:*)
-	# If we were able to find `uname', then EMX Unix compatibility
-	# is probably installed.
-	echo "$UNAME_MACHINE"-pc-os2-emx
-	exit ;;
-    i*86:XTS-300:*:STOP)
-	echo "$UNAME_MACHINE"-unknown-stop
-	exit ;;
-    i*86:atheos:*:*)
-	echo "$UNAME_MACHINE"-unknown-atheos
-	exit ;;
-    i*86:syllable:*:*)
-	echo "$UNAME_MACHINE"-pc-syllable
-	exit ;;
-    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
-	echo i386-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    i*86:*DOS:*:*)
-	echo "$UNAME_MACHINE"-pc-msdosdjgpp
-	exit ;;
-    i*86:*:4.*:*)
-	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
-	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
-	fi
-	exit ;;
-    i*86:*:5:[678]*)
-	# UnixWare 7.x, OpenUNIX and OpenServer 6.
-	case `/bin/uname -X | grep "^Machine"` in
-	    *486*)	     UNAME_MACHINE=i486 ;;
-	    *Pentium)	     UNAME_MACHINE=i586 ;;
-	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
-	esac
-	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
-	exit ;;
-    i*86:*:3.2:*)
-	if test -f /usr/options/cb.name; then
-		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
-	elif /bin/uname -X 2>/dev/null >/dev/null ; then
-		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
-		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
-		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
-			&& UNAME_MACHINE=i586
-		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
-			&& UNAME_MACHINE=i686
-		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
-	else
-		echo "$UNAME_MACHINE"-pc-sysv32
-	fi
-	exit ;;
-    pc:*:*:*)
-	# Left here for compatibility:
-	# uname -m prints for DJGPP always 'pc', but it prints nothing about
-	# the processor, so we play safe by assuming i586.
-	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configure will decide that
-	# this is a cross-build.
-	echo i586-pc-msdosdjgpp
-	exit ;;
-    Intel:Mach:3*:*)
-	echo i386-pc-mach3
-	exit ;;
-    paragon:*:*:*)
-	echo i860-intel-osf1
-	exit ;;
-    i860:*:4.*:*) # i860-SVR4
-	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
-	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
-	fi
-	exit ;;
-    mini*:CTIX:SYS*5:*)
-	# "miniframe"
-	echo m68010-convergent-sysv
-	exit ;;
-    mc68k:UNIX:SYSTEM5:3.51m)
-	echo m68k-convergent-sysv
-	exit ;;
-    M680?0:D-NIX:5.3:*)
-	echo m68k-diab-dnix
-	exit ;;
-    M68*:*:R3V[5678]*:*)
-	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
-    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
-	OS_REL=''
-	test -r /etc/.relid \
-	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4; exit; } ;;
-    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
-	OS_REL='.3'
-	test -r /etc/.relid \
-	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
-	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
-	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
-    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    mc68030:UNIX_System_V:4.*:*)
-	echo m68k-atari-sysv4
-	exit ;;
-    TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
-	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
-	exit ;;
-    SM[BE]S:UNIX_SV:*:*)
-	echo mips-dde-sysv"$UNAME_RELEASE"
-	exit ;;
-    RM*:ReliantUNIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    RM*:SINIX-*:*:*)
-	echo mips-sni-sysv4
-	exit ;;
-    *:SINIX-*:*:*)
-	if uname -p 2>/dev/null >/dev/null ; then
-		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo "$UNAME_MACHINE"-sni-sysv4
-	else
-		echo ns32k-sni-sysv
-	fi
-	exit ;;
-    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-			# says <Richard.M.Bartel@ccMail.Census.GOV>
-	echo i586-unisys-sysv4
-	exit ;;
-    *:UNIX_System_V:4*:FTX*)
-	# From Gerald Hewes <hewes@openmarket.com>.
-	# How about differentiating between stratus architectures? -djm
-	echo hppa1.1-stratus-sysv4
-	exit ;;
-    *:*:*:FTX*)
-	# From seanf@swdc.stratus.com.
-	echo i860-stratus-sysv4
-	exit ;;
-    i*86:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo "$UNAME_MACHINE"-stratus-vos
-	exit ;;
-    *:VOS:*:*)
-	# From Paul.Green@stratus.com.
-	echo hppa1.1-stratus-vos
-	exit ;;
-    mc68*:A/UX:*:*)
-	echo m68k-apple-aux"$UNAME_RELEASE"
-	exit ;;
-    news*:NEWS-OS:6*:*)
-	echo mips-sony-newsos6
-	exit ;;
-    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
-	if [ -d /usr/nec ]; then
-		echo mips-nec-sysv"$UNAME_RELEASE"
-	else
-		echo mips-unknown-sysv"$UNAME_RELEASE"
-	fi
-	exit ;;
-    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
-	echo powerpc-be-beos
-	exit ;;
-    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
-	echo powerpc-apple-beos
-	exit ;;
-    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
-	echo i586-pc-beos
-	exit ;;
-    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
-	echo i586-pc-haiku
-	exit ;;
-    x86_64:Haiku:*:*)
-	echo x86_64-unknown-haiku
-	exit ;;
-    SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    SX-ACE:SUPER-UX:*:*)
-	echo sxace-nec-superux"$UNAME_RELEASE"
-	exit ;;
-    Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Rhapsody:*:*)
-	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
-	exit ;;
-    *:Darwin:*:*)
-	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval "$set_cc_for_build"
-	if test "$UNAME_PROCESSOR" = unknown ; then
-	    UNAME_PROCESSOR=powerpc
-	fi
-	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
-	    if [ "$CC_FOR_BUILD" != no_compiler_found ]; then
-		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_64BIT_ARCH >/dev/null
-		then
-		    case $UNAME_PROCESSOR in
-			i386) UNAME_PROCESSOR=x86_64 ;;
-			powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		    esac
-		fi
-		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
-		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
-		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
-		       grep IS_PPC >/dev/null
-		then
-		    UNAME_PROCESSOR=powerpc
-		fi
-	    fi
-	elif test "$UNAME_PROCESSOR" = i386 ; then
-	    # Avoid executing cc on OS X 10.9, as it ships with a stub
-	    # that puts up a graphical alert prompting to install
-	    # developer tools.  Any system running Mac OS X 10.7 or
-	    # later (Darwin 11 and later) is required to have a 64-bit
-	    # processor. This is not true of the ARM version of Darwin
-	    # that Apple uses in portable devices.
-	    UNAME_PROCESSOR=x86_64
-	fi
-	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
-	exit ;;
-    *:procnto*:*:* | *:QNX:[0123456789]*:*)
-	UNAME_PROCESSOR=`uname -p`
-	if test "$UNAME_PROCESSOR" = x86; then
-		UNAME_PROCESSOR=i386
-		UNAME_MACHINE=pc
-	fi
-	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
-	exit ;;
-    *:QNX:*:4*)
-	echo i386-pc-qnx
-	exit ;;
-    NEO-*:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSR-*:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSV-*:NONSTOP_KERNEL:*:*)
-	echo nsv-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    NSX-*:NONSTOP_KERNEL:*:*)
-	echo nsx-tandem-nsk"$UNAME_RELEASE"
-	exit ;;
-    *:NonStop-UX:*:*)
-	echo mips-compaq-nonstopux
-	exit ;;
-    BS2000:POSIX*:*:*)
-	echo bs2000-siemens-sysv
-	exit ;;
-    DS/*:UNIX_System_V:*:*)
-	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
-	exit ;;
-    *:Plan9:*:*)
-	# "uname -m" is not consistent, so use $cputype instead. 386
-	# is converted to i386 for consistency with other x86
-	# operating systems.
-	if test "$cputype" = 386; then
-	    UNAME_MACHINE=i386
-	else
-	    UNAME_MACHINE="$cputype"
-	fi
-	echo "$UNAME_MACHINE"-unknown-plan9
-	exit ;;
-    *:TOPS-10:*:*)
-	echo pdp10-unknown-tops10
-	exit ;;
-    *:TENEX:*:*)
-	echo pdp10-unknown-tenex
-	exit ;;
-    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
-	echo pdp10-dec-tops20
-	exit ;;
-    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
-	echo pdp10-xkl-tops20
-	exit ;;
-    *:TOPS-20:*:*)
-	echo pdp10-unknown-tops20
-	exit ;;
-    *:ITS:*:*)
-	echo pdp10-unknown-its
-	exit ;;
-    SEI:*:*:SEIUX)
-	echo mips-sei-seiux"$UNAME_RELEASE"
-	exit ;;
-    *:DragonFly:*:*)
-	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`"
-	exit ;;
-    *:*VMS:*:*)
-	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "$UNAME_MACHINE" in
-	    A*) echo alpha-dec-vms ; exit ;;
-	    I*) echo ia64-dec-vms ; exit ;;
-	    V*) echo vax-dec-vms ; exit ;;
-	esac ;;
-    *:XENIX:*:SysV)
-	echo i386-pc-xenix
-	exit ;;
-    i*86:skyos:*:*)
-	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
-	exit ;;
-    i*86:rdos:*:*)
-	echo "$UNAME_MACHINE"-pc-rdos
-	exit ;;
-    i*86:AROS:*:*)
-	echo "$UNAME_MACHINE"-pc-aros
-	exit ;;
-    x86_64:VMkernel:*:*)
-	echo "$UNAME_MACHINE"-unknown-esx
-	exit ;;
-    amd64:Isilon\ OneFS:*:*)
-	echo x86_64-unknown-onefs
-	exit ;;
-esac
-
-echo "$0: unable to guess system type" >&2
-
-case "$UNAME_MACHINE:$UNAME_SYSTEM" in
-    mips:Linux | mips64:Linux)
-	# If we got here on MIPS GNU/Linux, output extra information.
-	cat >&2 <<EOF
-
-NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
-the system type. Please install a C compiler and try again.
-EOF
-	;;
-esac
-
-cat >&2 <<EOF
-
-This script (version $timestamp), has failed to recognize the
-operating system you are using. If your script is old, overwrite *all*
-copies of config.guess and config.sub with the latest versions from:
-
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
-and
-  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-If $0 has already been updated, send the following data and any
-information you think might be pertinent to config-patches@gnu.org to
-provide the necessary information to handle your system.
-
-config.guess timestamp = $timestamp
-
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
-
-hostinfo               = `(hostinfo) 2>/dev/null`
-/bin/universe          = `(/bin/universe) 2>/dev/null`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
-/bin/arch              = `(/bin/arch) 2>/dev/null`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
-
-UNAME_MACHINE = "$UNAME_MACHINE"
-UNAME_RELEASE = "$UNAME_RELEASE"
-UNAME_SYSTEM  = "$UNAME_SYSTEM"
-UNAME_VERSION = "$UNAME_VERSION"
-EOF
-
-exit 1
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/libssh2/libssh2/config.rpath b/libssh2/libssh2/config.rpath
deleted file mode 100755
index e082db6b..00000000
--- a/libssh2/libssh2/config.rpath
+++ /dev/null
@@ -1,660 +0,0 @@
-#! /bin/sh
-# Output a system dependent set of variables, describing how to set the
-# run time search path of shared libraries in an executable.
-#
-#   Copyright 1996-2006 Free Software Foundation, Inc.
-#   Taken from GNU libtool, 2001
-#   Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
-#
-#   This file is free software; the Free Software Foundation gives
-#   unlimited permission to copy and/or distribute it, with or without
-#   modifications, as long as this notice is preserved.
-#
-# The first argument passed to this file is the canonical host specification,
-#    CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or
-#    CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld
-# should be set by the caller.
-#
-# The set of defined variables is at the end of this script.
-
-# Known limitations:
-# - On IRIX 6.5 with CC="cc", the run time search patch must not be longer
-#   than 256 bytes, otherwise the compiler driver will dump core. The only
-#   known workaround is to choose shorter directory names for the build
-#   directory and/or the installation directory.
-
-# All known linkers require a `.a' archive for static linking (except MSVC,
-# which needs '.lib').
-libext=a
-shrext=.so
-
-host="$1"
-host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
-host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
-host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
-
-# Code taken from libtool.m4's _LT_CC_BASENAME.
-
-for cc_temp in $CC""; do
-  case $cc_temp in
-    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'`
-
-# Code taken from libtool.m4's AC_LIBTOOL_PROG_COMPILER_PIC.
-
-wl=
-if test "$GCC" = yes; then
-  wl='-Wl,'
-else
-  case "$host_os" in
-    aix*)
-      wl='-Wl,'
-      ;;
-    darwin*)
-      case $cc_basename in
-        xlc*)
-          wl='-Wl,'
-          ;;
-      esac
-      ;;
-    mingw* | pw32* | os2*)
-      ;;
-    hpux9* | hpux10* | hpux11*)
-      wl='-Wl,'
-      ;;
-    irix5* | irix6* | nonstopux*)
-      wl='-Wl,'
-      ;;
-    newsos6)
-      ;;
-    linux*)
-      case $cc_basename in
-        icc* | ecc*)
-          wl='-Wl,'
-          ;;
-        pgcc | pgf77 | pgf90)
-          wl='-Wl,'
-          ;;
-        ccc*)
-          wl='-Wl,'
-          ;;
-        como)
-          wl='-lopt='
-          ;;
-        *)
-          case `$CC -V 2>&1 | sed 5q` in
-            *Sun\ C*)
-              wl='-Wl,'
-              ;;
-          esac
-          ;;
-      esac
-      ;;
-    osf3* | osf4* | osf5*)
-      wl='-Wl,'
-      ;;
-    sco3.2v5*)
-      ;;
-    solaris*)
-      wl='-Wl,'
-      ;;
-    sunos4*)
-      wl='-Qoption ld '
-      ;;
-    sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
-      wl='-Wl,'
-      ;;
-    sysv4*MP*)
-      ;;
-    unicos*)
-      wl='-Wl,'
-      ;;
-    uts4*)
-      ;;
-  esac
-fi
-
-# Code taken from libtool.m4's AC_LIBTOOL_PROG_LD_SHLIBS.
-
-hardcode_libdir_flag_spec=
-hardcode_libdir_separator=
-hardcode_direct=no
-hardcode_minus_L=no
-
-case "$host_os" in
-  cygwin* | mingw* | pw32*)
-    # FIXME: the MSVC++ port hasn't been tested in a loooong time
-    # When not using gcc, we currently assume that we are using
-    # Microsoft Visual C++.
-    if test "$GCC" != yes; then
-      with_gnu_ld=no
-    fi
-    ;;
-  interix*)
-    # we just hope/assume this is gcc and not c89 (= MSVC++)
-    with_gnu_ld=yes
-    ;;
-  openbsd*)
-    with_gnu_ld=no
-    ;;
-esac
-
-ld_shlibs=yes
-if test "$with_gnu_ld" = yes; then
-  # Set some defaults for GNU ld with shared library support. These
-  # are reset later if shared libraries are not supported. Putting them
-  # here allows them to be overridden if necessary.
-  # Unlike libtool, we use -rpath here, not --rpath, since the documented
-  # option of GNU ld is called -rpath, not --rpath.
-  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-  case "$host_os" in
-    aix3* | aix4* | aix5*)
-      # On AIX/PPC, the GNU linker is very broken
-      if test "$host_cpu" != ia64; then
-        ld_shlibs=no
-      fi
-      ;;
-    amigaos*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_minus_L=yes
-      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
-      # that the semantics of dynamic libraries on AmigaOS, at least up
-      # to version 4, is to share data among multiple programs linked
-      # with the same dynamic library.  Since this doesn't match the
-      # behavior of shared libraries on other platforms, we cannot use
-      # them.
-      ld_shlibs=no
-      ;;
-    beos*)
-      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
-        :
-      else
-        ld_shlibs=no
-      fi
-      ;;
-    cygwin* | mingw* | pw32*)
-      # hardcode_libdir_flag_spec is actually meaningless, as there is
-      # no search path for DLLs.
-      hardcode_libdir_flag_spec='-L$libdir'
-      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
-        :
-      else
-        ld_shlibs=no
-      fi
-      ;;
-    interix3*)
-      hardcode_direct=no
-      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-      ;;
-    linux*)
-      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
-        :
-      else
-        ld_shlibs=no
-      fi
-      ;;
-    netbsd*)
-      ;;
-    solaris*)
-      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
-        ld_shlibs=no
-      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
-        :
-      else
-        ld_shlibs=no
-      fi
-      ;;
-    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
-      case `$LD -v 2>&1` in
-        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
-          ld_shlibs=no
-          ;;
-        *)
-          if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
-            hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
-          else
-            ld_shlibs=no
-          fi
-          ;;
-      esac
-      ;;
-    sunos4*)
-      hardcode_direct=yes
-      ;;
-    *)
-      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
-        :
-      else
-        ld_shlibs=no
-      fi
-      ;;
-  esac
-  if test "$ld_shlibs" = no; then
-    hardcode_libdir_flag_spec=
-  fi
-else
-  case "$host_os" in
-    aix3*)
-      # Note: this linker hardcodes the directories in LIBPATH if there
-      # are no directories specified by -L.
-      hardcode_minus_L=yes
-      if test "$GCC" = yes; then
-        # Neither direct hardcoding nor static linking is supported with a
-        # broken collect2.
-        hardcode_direct=unsupported
-      fi
-      ;;
-    aix4* | aix5*)
-      if test "$host_cpu" = ia64; then
-        # On IA64, the linker does run time linking by default, so we don't
-        # have to do anything special.
-        aix_use_runtimelinking=no
-      else
-        aix_use_runtimelinking=no
-        # Test if we are trying to use run time linking or normal
-        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-        # need to do runtime linking.
-        case $host_os in aix4.[23]|aix4.[23].*|aix5*)
-          for ld_flag in $LDFLAGS; do
-            if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
-              aix_use_runtimelinking=yes
-              break
-            fi
-          done
-          ;;
-        esac
-      fi
-      hardcode_direct=yes
-      hardcode_libdir_separator=':'
-      if test "$GCC" = yes; then
-        case $host_os in aix4.[012]|aix4.[012].*)
-          collect2name=`${CC} -print-prog-name=collect2`
-          if test -f "$collect2name" && \
-            strings "$collect2name" | grep resolve_lib_name >/dev/null
-          then
-            # We have reworked collect2
-            hardcode_direct=yes
-          else
-            # We have old collect2
-            hardcode_direct=unsupported
-            hardcode_minus_L=yes
-            hardcode_libdir_flag_spec='-L$libdir'
-            hardcode_libdir_separator=
-          fi
-          ;;
-        esac
-      fi
-      # Begin _LT_AC_SYS_LIBPATH_AIX.
-      echo 'int main () { return 0; }' > conftest.c
-      ${CC} ${LDFLAGS} conftest.c -o conftest
-      aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
-}'`
-      if test -z "$aix_libpath"; then
-        aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
-}'`
-      fi
-      if test -z "$aix_libpath"; then
-        aix_libpath="/usr/lib:/lib"
-      fi
-      rm -f conftest.c conftest
-      # End _LT_AC_SYS_LIBPATH_AIX.
-      if test "$aix_use_runtimelinking" = yes; then
-        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
-      else
-        if test "$host_cpu" = ia64; then
-          hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
-        else
-          hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
-        fi
-      fi
-      ;;
-    amigaos*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_minus_L=yes
-      # see comment about different semantics on the GNU ld section
-      ld_shlibs=no
-      ;;
-    bsdi[45]*)
-      ;;
-    cygwin* | mingw* | pw32*)
-      # When not using gcc, we currently assume that we are using
-      # Microsoft Visual C++.
-      # hardcode_libdir_flag_spec is actually meaningless, as there is
-      # no search path for DLLs.
-      hardcode_libdir_flag_spec=' '
-      libext=lib
-      ;;
-    darwin* | rhapsody*)
-      hardcode_direct=no
-      if test "$GCC" = yes ; then
-        :
-      else
-        case $cc_basename in
-          xlc*)
-            ;;
-          *)
-            ld_shlibs=no
-            ;;
-        esac
-      fi
-      ;;
-    dgux*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      ;;
-    freebsd1*)
-      ld_shlibs=no
-      ;;
-    freebsd2.2*)
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      ;;
-    freebsd2*)
-      hardcode_direct=yes
-      hardcode_minus_L=yes
-      ;;
-    freebsd* | kfreebsd*-gnu | dragonfly*)
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      ;;
-    hpux9*)
-      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
-      hardcode_libdir_separator=:
-      hardcode_direct=yes
-      # hardcode_minus_L: Not really in the search PATH,
-      # but as the default location of the library.
-      hardcode_minus_L=yes
-      ;;
-    hpux10*)
-      if test "$with_gnu_ld" = no; then
-        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
-        hardcode_libdir_separator=:
-        hardcode_direct=yes
-        # hardcode_minus_L: Not really in the search PATH,
-        # but as the default location of the library.
-        hardcode_minus_L=yes
-      fi
-      ;;
-    hpux11*)
-      if test "$with_gnu_ld" = no; then
-        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
-        hardcode_libdir_separator=:
-        case $host_cpu in
-          hppa*64*|ia64*)
-            hardcode_direct=no
-            ;;
-          *)
-            hardcode_direct=yes
-            # hardcode_minus_L: Not really in the search PATH,
-            # but as the default location of the library.
-            hardcode_minus_L=yes
-            ;;
-        esac
-      fi
-      ;;
-    irix5* | irix6* | nonstopux*)
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-      hardcode_libdir_separator=:
-      ;;
-    netbsd*)
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      ;;
-    newsos6)
-      hardcode_direct=yes
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-      hardcode_libdir_separator=:
-      ;;
-    openbsd*)
-      hardcode_direct=yes
-      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
-        hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-      else
-        case "$host_os" in
-          openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
-            hardcode_libdir_flag_spec='-R$libdir'
-            ;;
-          *)
-            hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
-            ;;
-        esac
-      fi
-      ;;
-    os2*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_minus_L=yes
-      ;;
-    osf3*)
-      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-      hardcode_libdir_separator=:
-      ;;
-    osf4* | osf5*)
-      if test "$GCC" = yes; then
-        hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-      else
-        # Both cc and cxx compiler support -rpath directly
-        hardcode_libdir_flag_spec='-rpath $libdir'
-      fi
-      hardcode_libdir_separator=:
-      ;;
-    solaris*)
-      hardcode_libdir_flag_spec='-R$libdir'
-      ;;
-    sunos4*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_direct=yes
-      hardcode_minus_L=yes
-      ;;
-    sysv4)
-      case $host_vendor in
-        sni)
-          hardcode_direct=yes # is this really true???
-          ;;
-        siemens)
-          hardcode_direct=no
-          ;;
-        motorola)
-          hardcode_direct=no #Motorola manual says yes, but my tests say they lie
-          ;;
-      esac
-      ;;
-    sysv4.3*)
-      ;;
-    sysv4*MP*)
-      if test -d /usr/nec; then
-        ld_shlibs=yes
-      fi
-      ;;
-    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7*)
-      ;;
-    sysv5* | sco3.2v5* | sco5v6*)
-      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
-      hardcode_libdir_separator=':'
-      ;;
-    uts4*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      ;;
-    *)
-      ld_shlibs=no
-      ;;
-  esac
-fi
-
-# Check dynamic linker characteristics
-# Code taken from libtool.m4's AC_LIBTOOL_SYS_DYNAMIC_LINKER.
-# Unlike libtool.m4, here we don't care about _all_ names of the library, but
-# only about the one the linker finds when passed -lNAME. This is the last
-# element of library_names_spec in libtool.m4, or possibly two of them if the
-# linker has special search rules.
-library_names_spec=      # the last element of library_names_spec in libtool.m4
-libname_spec='lib$name'
-case "$host_os" in
-  aix3*)
-    library_names_spec='$libname.a'
-    ;;
-  aix4* | aix5*)
-    library_names_spec='$libname$shrext'
-    ;;
-  amigaos*)
-    library_names_spec='$libname.a'
-    ;;
-  beos*)
-    library_names_spec='$libname$shrext'
-    ;;
-  bsdi[45]*)
-    library_names_spec='$libname$shrext'
-    ;;
-  cygwin* | mingw* | pw32*)
-    shrext=.dll
-    library_names_spec='$libname.dll.a $libname.lib'
-    ;;
-  darwin* | rhapsody*)
-    shrext=.dylib
-    library_names_spec='$libname$shrext'
-    ;;
-  dgux*)
-    library_names_spec='$libname$shrext'
-    ;;
-  freebsd1*)
-    ;;
-  kfreebsd*-gnu)
-    library_names_spec='$libname$shrext'
-    ;;
-  freebsd* | dragonfly*)
-    case "$host_os" in
-      freebsd[123]*)
-        library_names_spec='$libname$shrext$versuffix' ;;
-      *)
-        library_names_spec='$libname$shrext' ;;
-    esac
-    ;;
-  gnu*)
-    library_names_spec='$libname$shrext'
-    ;;
-  hpux9* | hpux10* | hpux11*)
-    case $host_cpu in
-      ia64*)
-        shrext=.so
-        ;;
-      hppa*64*)
-        shrext=.sl
-        ;;
-      *)
-        shrext=.sl
-        ;;
-    esac
-    library_names_spec='$libname$shrext'
-    ;;
-  interix3*)
-    library_names_spec='$libname$shrext'
-    ;;
-  irix5* | irix6* | nonstopux*)
-    library_names_spec='$libname$shrext'
-    case "$host_os" in
-      irix5* | nonstopux*)
-        libsuff= shlibsuff=
-        ;;
-      *)
-        case $LD in
-          *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;;
-          *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;;
-          *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;;
-          *) libsuff= shlibsuff= ;;
-        esac
-        ;;
-    esac
-    ;;
-  linux*oldld* | linux*aout* | linux*coff*)
-    ;;
-  linux*)
-    library_names_spec='$libname$shrext'
-    ;;
-  knetbsd*-gnu)
-    library_names_spec='$libname$shrext'
-    ;;
-  netbsd*)
-    library_names_spec='$libname$shrext'
-    ;;
-  newsos6)
-    library_names_spec='$libname$shrext'
-    ;;
-  nto-qnx*)
-    library_names_spec='$libname$shrext'
-    ;;
-  openbsd*)
-    library_names_spec='$libname$shrext$versuffix'
-    ;;
-  os2*)
-    libname_spec='$name'
-    shrext=.dll
-    library_names_spec='$libname.a'
-    ;;
-  osf3* | osf4* | osf5*)
-    library_names_spec='$libname$shrext'
-    ;;
-  solaris*)
-    library_names_spec='$libname$shrext'
-    ;;
-  sunos4*)
-    library_names_spec='$libname$shrext$versuffix'
-    ;;
-  sysv4 | sysv4.3*)
-    library_names_spec='$libname$shrext'
-    ;;
-  sysv4*MP*)
-    library_names_spec='$libname$shrext'
-    ;;
-  sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-    library_names_spec='$libname$shrext'
-    ;;
-  uts4*)
-    library_names_spec='$libname$shrext'
-    ;;
-esac
-
-sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
-escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"`
-shlibext=`echo "$shrext" | sed -e 's,^\.,,'`
-escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
-escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
-escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
-
-LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' <<EOF
-
-# How to pass a linker flag through the compiler.
-wl="$escaped_wl"
-
-# Static library suffix (normally "a").
-libext="$libext"
-
-# Shared library suffix (normally "so").
-shlibext="$shlibext"
-
-# Format of library name prefix.
-libname_spec="$escaped_libname_spec"
-
-# Library names that the linker finds when passed -lNAME.
-library_names_spec="$escaped_library_names_spec"
-
-# Flag to hardcode \$libdir into a binary during linking.
-# This must work even if \$libdir does not exist.
-hardcode_libdir_flag_spec="$escaped_hardcode_libdir_flag_spec"
-
-# Whether we need a single -rpath flag with a separated argument.
-hardcode_libdir_separator="$hardcode_libdir_separator"
-
-# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
-# resulting binary.
-hardcode_direct="$hardcode_direct"
-
-# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
-# resulting binary.
-hardcode_minus_L="$hardcode_minus_L"
-
-EOF
diff --git a/libssh2/libssh2/config.sub b/libssh2/libssh2/config.sub
deleted file mode 100755
index 1d8e98bc..00000000
--- a/libssh2/libssh2/config.sub
+++ /dev/null
@@ -1,1801 +0,0 @@
-#! /bin/sh
-# Configuration validation subroutine script.
-#   Copyright 1992-2018 Free Software Foundation, Inc.
-
-timestamp='2018-02-22'
-
-# This file is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <https://www.gnu.org/licenses/>.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
-
-
-# Please send patches to <config-patches@gnu.org>.
-#
-# Configuration subroutine to validate and canonicalize a configuration type.
-# Supply the specified configuration type as an argument.
-# If it is invalid, we print an error message on stderr and exit with code 1.
-# Otherwise, we print the canonical config type on stdout and succeed.
-
-# You can get the latest version of this script from:
-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
-
-# This file is supposed to be the same for all GNU packages
-# and recognize all the CPU types, system types and aliases
-# that are meaningful with *any* GNU software.
-# Each package is responsible for reporting which valid configurations
-# it does not support.  The user should be able to distinguish
-# a failure to support a valid configuration from a meaningless
-# configuration.
-
-# The goal of this file is to map all the various variations of a given
-# machine specification into a single specification in the form:
-#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
-# or in some cases, the newer four-part form:
-#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
-# It is wrong to echo any other type of specification.
-
-me=`echo "$0" | sed -e 's,.*/,,'`
-
-usage="\
-Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS
-
-Canonicalize a configuration name.
-
-Options:
-  -h, --help         print this help, then exit
-  -t, --time-stamp   print date of last modification, then exit
-  -v, --version      print version number, then exit
-
-Report bugs and patches to <config-patches@gnu.org>."
-
-version="\
-GNU config.sub ($timestamp)
-
-Copyright 1992-2018 Free Software Foundation, Inc.
-
-This is free software; see the source for copying conditions.  There is NO
-warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
-
-help="
-Try \`$me --help' for more information."
-
-# Parse command line
-while test $# -gt 0 ; do
-  case $1 in
-    --time-stamp | --time* | -t )
-       echo "$timestamp" ; exit ;;
-    --version | -v )
-       echo "$version" ; exit ;;
-    --help | --h* | -h )
-       echo "$usage"; exit ;;
-    -- )     # Stop option processing
-       shift; break ;;
-    - )	# Use stdin as input.
-       break ;;
-    -* )
-       echo "$me: invalid option $1$help"
-       exit 1 ;;
-
-    *local*)
-       # First pass through any local machine types.
-       echo "$1"
-       exit ;;
-
-    * )
-       break ;;
-  esac
-done
-
-case $# in
- 0) echo "$me: missing argument$help" >&2
-    exit 1;;
- 1) ;;
- *) echo "$me: too many arguments$help" >&2
-    exit 1;;
-esac
-
-# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
-# Here we must recognize all the valid KERNEL-OS combinations.
-maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
-case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \
-  kopensolaris*-gnu* | cloudabi*-eabi* | \
-  storm-chaos* | os2-emx* | rtmk-nova*)
-    os=-$maybe_os
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
-    ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
-  *)
-    basic_machine=`echo "$1" | sed 's/-[^-]*$//'`
-    if [ "$basic_machine" != "$1" ]
-    then os=`echo "$1" | sed 's/.*-/-/'`
-    else os=; fi
-    ;;
-esac
-
-### Let's recognize common machines as not being operating systems so
-### that things like config.sub decstation-3100 work.  We also
-### recognize some manufacturers as not being operating systems, so we
-### can provide default operating systems below.
-case $os in
-	-sun*os*)
-		# Prevent following clause from handling this invalid input.
-		;;
-	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
-	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
-	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
-		os=
-		basic_machine=$1
-		;;
-	-bluegene*)
-		os=-cnk
-		;;
-	-sim | -cisco | -oki | -wec | -winbond)
-		os=
-		basic_machine=$1
-		;;
-	-scout)
-		;;
-	-wrs)
-		os=-vxworks
-		basic_machine=$1
-		;;
-	-chorusos*)
-		os=-chorusos
-		basic_machine=$1
-		;;
-	-chorusrdb)
-		os=-chorusrdb
-		basic_machine=$1
-		;;
-	-hiux*)
-		os=-hiuxwe2
-		;;
-	-sco6)
-		os=-sco5v6
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5)
-		os=-sco3.2v5
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco4)
-		os=-sco3.2v4
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2.[4-9]*)
-		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco3.2v[4-9]*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco5v6*)
-		# Don't forget version if it is 3.2v4 or newer.
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-sco*)
-		os=-sco3.2v2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-udk*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-isc)
-		os=-isc2.2
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-clix*)
-		basic_machine=clipper-intergraph
-		;;
-	-isc*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'`
-		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
-		;;
-	-lynx*)
-		os=-lynxos
-		;;
-	-ptx*)
-		basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'`
-		;;
-	-psos*)
-		os=-psos
-		;;
-	-mint | -mint[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-esac
-
-# Decode aliases for certain CPU-COMPANY combinations.
-case $basic_machine in
-	# Recognize the basic CPU types without company name.
-	# Some are omitted here because they have special meanings below.
-	1750a | 580 \
-	| a29k \
-	| aarch64 | aarch64_be \
-	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
-	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
-	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| ba \
-	| be32 | be64 \
-	| bfin \
-	| c4x | c8051 | clipper \
-	| d10v | d30v | dlx | dsp16xx \
-	| e2k | epiphany \
-	| fido | fr30 | frv | ft32 \
-	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
-	| i370 | i860 | i960 | ia16 | ia64 \
-	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
-	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
-	| mips | mipsbe | mipseb | mipsel | mipsle \
-	| mips16 \
-	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
-	| mips64vr | mips64vrel \
-	| mips64vr4100 | mips64vr4100el \
-	| mips64vr4300 | mips64vr4300el \
-	| mips64vr5000 | mips64vr5000el \
-	| mips64vr5900 | mips64vr5900el \
-	| mipsisa32 | mipsisa32el \
-	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
-	| mipsisa64 | mipsisa64el \
-	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
-	| mipsisa64sb1 | mipsisa64sb1el \
-	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
-	| mipstx39 | mipstx39el \
-	| mn10200 | mn10300 \
-	| moxie \
-	| mt \
-	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
-	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
-	| pdp10 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
-	| pru \
-	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
-	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
-	| sh64 | sh64le \
-	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
-	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
-	| wasm32 \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
-		basic_machine=$basic_machine-unknown
-		;;
-	c54x)
-		basic_machine=tic54x-unknown
-		;;
-	c55x)
-		basic_machine=tic55x-unknown
-		;;
-	c6x)
-		basic_machine=tic6x-unknown
-		;;
-	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
-		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65)
-		;;
-	ms1)
-		basic_machine=mt-unknown
-		;;
-
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
-		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
-		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
-		;;
-
-	# We use `pc' rather than `unknown'
-	# because (1) that's what they normally are, and
-	# (2) the word "unknown" tends to confuse beginning users.
-	i*86 | x86_64)
-	  basic_machine=$basic_machine-pc
-	  ;;
-	# Object if more than one company name word.
-	*-*-*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-	# Recognize the basic CPU types with company name.
-	580-* \
-	| a29k-* \
-	| aarch64-* | aarch64_be-* \
-	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
-	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
-	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
-	| avr-* | avr32-* \
-	| ba-* \
-	| be32-* | be64-* \
-	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
-	| d10v-* | d30v-* | dlx-* \
-	| e2k-* | elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
-	| h8300-* | h8500-* \
-	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
-	| i*86-* | i860-* | i960-* | ia16-* | ia64-* \
-	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
-	| m32c-* | m32r-* | m32rle-* \
-	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
-	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
-	| mips16-* \
-	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
-	| mips64vr-* | mips64vrel-* \
-	| mips64vr4100-* | mips64vr4100el-* \
-	| mips64vr4300-* | mips64vr4300el-* \
-	| mips64vr5000-* | mips64vr5000el-* \
-	| mips64vr5900-* | mips64vr5900el-* \
-	| mipsisa32-* | mipsisa32el-* \
-	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
-	| mipsisa64-* | mipsisa64el-* \
-	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
-	| mipsisa64sb1-* | mipsisa64sb1el-* \
-	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
-	| mipstx39-* | mipstx39el-* \
-	| mmix-* \
-	| mt-* \
-	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
-	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
-	| orion-* \
-	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
-	| pru-* \
-	| pyramid-* \
-	| riscv32-* | riscv64-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
-	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
-	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
-	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \
-	| tahoe-* \
-	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
-	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
-	| wasm32-* \
-	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
-	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
-		;;
-	# Recognize the various machine names and aliases which stand
-	# for a CPU type and a company and sometimes even an OS.
-	386bsd)
-		basic_machine=i386-pc
-		os=-bsd
-		;;
-	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
-		basic_machine=m68000-att
-		;;
-	3b*)
-		basic_machine=we32k-att
-		;;
-	a29khif)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	abacus)
-		basic_machine=abacus-unknown
-		;;
-	adobe68k)
-		basic_machine=m68010-adobe
-		os=-scout
-		;;
-	alliant | fx80)
-		basic_machine=fx80-alliant
-		;;
-	altos | altos3068)
-		basic_machine=m68k-altos
-		;;
-	am29k)
-		basic_machine=a29k-none
-		os=-bsd
-		;;
-	amd64)
-		basic_machine=x86_64-pc
-		;;
-	amd64-*)
-		basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	amdahl)
-		basic_machine=580-amdahl
-		os=-sysv
-		;;
-	amiga | amiga-*)
-		basic_machine=m68k-unknown
-		;;
-	amigaos | amigados)
-		basic_machine=m68k-unknown
-		os=-amigaos
-		;;
-	amigaunix | amix)
-		basic_machine=m68k-unknown
-		os=-sysv4
-		;;
-	apollo68)
-		basic_machine=m68k-apollo
-		os=-sysv
-		;;
-	apollo68bsd)
-		basic_machine=m68k-apollo
-		os=-bsd
-		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
-	asmjs)
-		basic_machine=asmjs-unknown
-		;;
-	aux)
-		basic_machine=m68k-apple
-		os=-aux
-		;;
-	balance)
-		basic_machine=ns32k-sequent
-		os=-dynix
-		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	c90)
-		basic_machine=c90-cray
-		os=-unicos
-		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
-	convex-c1)
-		basic_machine=c1-convex
-		os=-bsd
-		;;
-	convex-c2)
-		basic_machine=c2-convex
-		os=-bsd
-		;;
-	convex-c32)
-		basic_machine=c32-convex
-		os=-bsd
-		;;
-	convex-c34)
-		basic_machine=c34-convex
-		os=-bsd
-		;;
-	convex-c38)
-		basic_machine=c38-convex
-		os=-bsd
-		;;
-	cray | j90)
-		basic_machine=j90-cray
-		os=-unicos
-		;;
-	craynv)
-		basic_machine=craynv-cray
-		os=-unicosmp
-		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
-		os=-elf
-		;;
-	crds | unos)
-		basic_machine=m68k-crds
-		;;
-	crisv32 | crisv32-* | etraxfs*)
-		basic_machine=crisv32-axis
-		;;
-	cris | cris-* | etrax*)
-		basic_machine=cris-axis
-		;;
-	crx)
-		basic_machine=crx-unknown
-		os=-elf
-		;;
-	da30 | da30-*)
-		basic_machine=m68k-da30
-		;;
-	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
-		basic_machine=mips-dec
-		;;
-	decsystem10* | dec10*)
-		basic_machine=pdp10-dec
-		os=-tops10
-		;;
-	decsystem20* | dec20*)
-		basic_machine=pdp10-dec
-		os=-tops20
-		;;
-	delta | 3300 | motorola-3300 | motorola-delta \
-	      | 3300-motorola | delta-motorola)
-		basic_machine=m68k-motorola
-		;;
-	delta88)
-		basic_machine=m88k-motorola
-		os=-sysv3
-		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
-	djgpp)
-		basic_machine=i586-pc
-		os=-msdosdjgpp
-		;;
-	dpx20 | dpx20-*)
-		basic_machine=rs6000-bull
-		os=-bosx
-		;;
-	dpx2*)
-		basic_machine=m68k-bull
-		os=-sysv3
-		;;
-	e500v[12])
-		basic_machine=powerpc-unknown
-		os=$os"spe"
-		;;
-	e500v[12]-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=$os"spe"
-		;;
-	ebmon29k)
-		basic_machine=a29k-amd
-		os=-ebmon
-		;;
-	elxsi)
-		basic_machine=elxsi-elxsi
-		os=-bsd
-		;;
-	encore | umax | mmax)
-		basic_machine=ns32k-encore
-		;;
-	es1800 | OSE68k | ose68k | ose | OSE)
-		basic_machine=m68k-ericsson
-		os=-ose
-		;;
-	fx2800)
-		basic_machine=i860-alliant
-		;;
-	genix)
-		basic_machine=ns32k-ns
-		;;
-	gmicro)
-		basic_machine=tron-gmicro
-		os=-sysv
-		;;
-	go32)
-		basic_machine=i386-pc
-		os=-go32
-		;;
-	h3050r* | hiux*)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	h8300hms)
-		basic_machine=h8300-hitachi
-		os=-hms
-		;;
-	h8300xray)
-		basic_machine=h8300-hitachi
-		os=-xray
-		;;
-	h8500hms)
-		basic_machine=h8500-hitachi
-		os=-hms
-		;;
-	harris)
-		basic_machine=m88k-harris
-		os=-sysv3
-		;;
-	hp300-*)
-		basic_machine=m68k-hp
-		;;
-	hp300bsd)
-		basic_machine=m68k-hp
-		os=-bsd
-		;;
-	hp300hpux)
-		basic_machine=m68k-hp
-		os=-hpux
-		;;
-	hp3k9[0-9][0-9] | hp9[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k2[0-9][0-9] | hp9k31[0-9])
-		basic_machine=m68000-hp
-		;;
-	hp9k3[2-9][0-9])
-		basic_machine=m68k-hp
-		;;
-	hp9k6[0-9][0-9] | hp6[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hp9k7[0-79][0-9] | hp7[0-79][0-9])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k78[0-9] | hp78[0-9])
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
-		# FIXME: really hppa2.0-hp
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][13679] | hp8[0-9][13679])
-		basic_machine=hppa1.1-hp
-		;;
-	hp9k8[0-9][0-9] | hp8[0-9][0-9])
-		basic_machine=hppa1.0-hp
-		;;
-	hppaosf)
-		basic_machine=hppa1.1-hp
-		os=-osf
-		;;
-	hppro)
-		basic_machine=hppa1.1-hp
-		os=-proelf
-		;;
-	i370-ibm* | ibm*)
-		basic_machine=i370-ibm
-		;;
-	i*86v32)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv32
-		;;
-	i*86v4*)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv4
-		;;
-	i*86v)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-sysv
-		;;
-	i*86sol2)
-		basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'`
-		os=-solaris2
-		;;
-	i386mach)
-		basic_machine=i386-mach
-		os=-mach
-		;;
-	vsta)
-		basic_machine=i386-unknown
-		os=-vsta
-		;;
-	iris | iris4d)
-		basic_machine=mips-sgi
-		case $os in
-		    -irix*)
-			;;
-		    *)
-			os=-irix4
-			;;
-		esac
-		;;
-	isi68 | isi)
-		basic_machine=m68k-isi
-		os=-sysv
-		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	magnum | m3230)
-		basic_machine=mips-mips
-		os=-sysv
-		;;
-	merlin)
-		basic_machine=ns32k-utek
-		os=-sysv
-		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
-	mingw32)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
-	miniframe)
-		basic_machine=m68000-convergent
-		;;
-	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
-		basic_machine=m68k-atari
-		os=-mint
-		;;
-	mips3*-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`
-		;;
-	mips3*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown
-		;;
-	monitor)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	morphos)
-		basic_machine=powerpc-unknown
-		os=-morphos
-		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
-		;;
-	msdos)
-		basic_machine=i386-pc
-		os=-msdos
-		;;
-	ms1-*)
-		basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'`
-		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
-	mvs)
-		basic_machine=i370-ibm
-		os=-mvs
-		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
-	ncr3000)
-		basic_machine=i486-ncr
-		os=-sysv4
-		;;
-	netbsd386)
-		basic_machine=i386-unknown
-		os=-netbsd
-		;;
-	netwinder)
-		basic_machine=armv4l-rebel
-		os=-linux
-		;;
-	news | news700 | news800 | news900)
-		basic_machine=m68k-sony
-		os=-newsos
-		;;
-	news1000)
-		basic_machine=m68030-sony
-		os=-newsos
-		;;
-	news-3600 | risc-news)
-		basic_machine=mips-sony
-		os=-newsos
-		;;
-	necv70)
-		basic_machine=v70-nec
-		os=-sysv
-		;;
-	next | m*-next)
-		basic_machine=m68k-next
-		case $os in
-		    -nextstep* )
-			;;
-		    -ns2*)
-		      os=-nextstep2
-			;;
-		    *)
-		      os=-nextstep3
-			;;
-		esac
-		;;
-	nh3000)
-		basic_machine=m68k-harris
-		os=-cxux
-		;;
-	nh[45]000)
-		basic_machine=m88k-harris
-		os=-cxux
-		;;
-	nindy960)
-		basic_machine=i960-intel
-		os=-nindy
-		;;
-	mon960)
-		basic_machine=i960-intel
-		os=-mon960
-		;;
-	nonstopux)
-		basic_machine=mips-compaq
-		os=-nonstopux
-		;;
-	np1)
-		basic_machine=np1-gould
-		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
-	nsr-tandem)
-		basic_machine=nsr-tandem
-		;;
-	nsv-tandem)
-		basic_machine=nsv-tandem
-		;;
-	nsx-tandem)
-		basic_machine=nsx-tandem
-		;;
-	op50n-* | op60c-*)
-		basic_machine=hppa1.1-oki
-		os=-proelf
-		;;
-	openrisc | openrisc-*)
-		basic_machine=or32-unknown
-		;;
-	os400)
-		basic_machine=powerpc-ibm
-		os=-os400
-		;;
-	OSE68000 | ose68000)
-		basic_machine=m68000-ericsson
-		os=-ose
-		;;
-	os68k)
-		basic_machine=m68k-none
-		os=-os68k
-		;;
-	pa-hitachi)
-		basic_machine=hppa1.1-hitachi
-		os=-hiuxwe2
-		;;
-	paragon)
-		basic_machine=i860-intel
-		os=-osf
-		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	pbd)
-		basic_machine=sparc-tti
-		;;
-	pbb)
-		basic_machine=m68k-tti
-		;;
-	pc532 | pc532-*)
-		basic_machine=ns32k-pc532
-		;;
-	pc98)
-		basic_machine=i386-pc
-		;;
-	pc98-*)
-		basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium | p5 | k5 | k6 | nexgen | viac3)
-		basic_machine=i586-pc
-		;;
-	pentiumpro | p6 | 6x86 | athlon | athlon_*)
-		basic_machine=i686-pc
-		;;
-	pentiumii | pentium2 | pentiumiii | pentium3)
-		basic_machine=i686-pc
-		;;
-	pentium4)
-		basic_machine=i786-pc
-		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
-		basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumpro-* | p6-* | 6x86-* | athlon-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
-		basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pentium4-*)
-		basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	pn)
-		basic_machine=pn-gould
-		;;
-	power)	basic_machine=power-ibm
-		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
-		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppcle | powerpclittle)
-		basic_machine=powerpcle-unknown
-		;;
-	ppcle-* | powerpclittle-*)
-		basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64)	basic_machine=powerpc64-unknown
-		;;
-	ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ppc64le | powerpc64little)
-		basic_machine=powerpc64le-unknown
-		;;
-	ppc64le-* | powerpc64little-*)
-		basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	ps2)
-		basic_machine=i386-ibm
-		;;
-	pw32)
-		basic_machine=i586-unknown
-		os=-pw32
-		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
-		;;
-	rdos32)
-		basic_machine=i386-pc
-		os=-rdos
-		;;
-	rom68k)
-		basic_machine=m68k-rom68k
-		os=-coff
-		;;
-	rm[46]00)
-		basic_machine=mips-siemens
-		;;
-	rtpc | rtpc-*)
-		basic_machine=romp-ibm
-		;;
-	s390 | s390-*)
-		basic_machine=s390-ibm
-		;;
-	s390x | s390x-*)
-		basic_machine=s390x-ibm
-		;;
-	sa29200)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	sb1)
-		basic_machine=mipsisa64sb1-unknown
-		;;
-	sb1el)
-		basic_machine=mipsisa64sb1el-unknown
-		;;
-	sde)
-		basic_machine=mipsisa32-sde
-		os=-elf
-		;;
-	sei)
-		basic_machine=mips-sei
-		os=-seiux
-		;;
-	sequent)
-		basic_machine=i386-sequent
-		;;
-	sh5el)
-		basic_machine=sh5le-unknown
-		;;
-	simso-wrs)
-		basic_machine=sparclite-wrs
-		os=-vxworks
-		;;
-	sps7)
-		basic_machine=m68k-bull
-		os=-sysv2
-		;;
-	spur)
-		basic_machine=spur-unknown
-		;;
-	st2000)
-		basic_machine=m68k-tandem
-		;;
-	stratus)
-		basic_machine=i860-stratus
-		os=-sysv4
-		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'`
-		;;
-	sun2)
-		basic_machine=m68000-sun
-		;;
-	sun2os3)
-		basic_machine=m68000-sun
-		os=-sunos3
-		;;
-	sun2os4)
-		basic_machine=m68000-sun
-		os=-sunos4
-		;;
-	sun3os3)
-		basic_machine=m68k-sun
-		os=-sunos3
-		;;
-	sun3os4)
-		basic_machine=m68k-sun
-		os=-sunos4
-		;;
-	sun4os3)
-		basic_machine=sparc-sun
-		os=-sunos3
-		;;
-	sun4os4)
-		basic_machine=sparc-sun
-		os=-sunos4
-		;;
-	sun4sol2)
-		basic_machine=sparc-sun
-		os=-solaris2
-		;;
-	sun3 | sun3-*)
-		basic_machine=m68k-sun
-		;;
-	sun4)
-		basic_machine=sparc-sun
-		;;
-	sun386 | sun386i | roadrunner)
-		basic_machine=i386-sun
-		;;
-	sv1)
-		basic_machine=sv1-cray
-		os=-unicos
-		;;
-	symmetry)
-		basic_machine=i386-sequent
-		os=-dynix
-		;;
-	t3e)
-		basic_machine=alphaev5-cray
-		os=-unicos
-		;;
-	t90)
-		basic_machine=t90-cray
-		os=-unicos
-		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
-		;;
-	tx39)
-		basic_machine=mipstx39-unknown
-		;;
-	tx39el)
-		basic_machine=mipstx39el-unknown
-		;;
-	toad1)
-		basic_machine=pdp10-xkl
-		os=-tops20
-		;;
-	tower | tower-32)
-		basic_machine=m68k-ncr
-		;;
-	tpf)
-		basic_machine=s390x-ibm
-		os=-tpf
-		;;
-	udi29k)
-		basic_machine=a29k-amd
-		os=-udi
-		;;
-	ultra3)
-		basic_machine=a29k-nyu
-		os=-sym1
-		;;
-	v810 | necv810)
-		basic_machine=v810-nec
-		os=-none
-		;;
-	vaxv)
-		basic_machine=vax-dec
-		os=-sysv
-		;;
-	vms)
-		basic_machine=vax-dec
-		os=-vms
-		;;
-	vpp*|vx|vx-*)
-		basic_machine=f301-fujitsu
-		;;
-	vxworks960)
-		basic_machine=i960-wrs
-		os=-vxworks
-		;;
-	vxworks68)
-		basic_machine=m68k-wrs
-		os=-vxworks
-		;;
-	vxworks29k)
-		basic_machine=a29k-wrs
-		os=-vxworks
-		;;
-	w65*)
-		basic_machine=w65-wdc
-		os=-none
-		;;
-	w89k-*)
-		basic_machine=hppa1.1-winbond
-		os=-proelf
-		;;
-	x64)
-		basic_machine=x86_64-pc
-		;;
-	xbox)
-		basic_machine=i686-pc
-		os=-mingw32
-		;;
-	xps | xps100)
-		basic_machine=xps100-honeywell
-		;;
-	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'`
-		;;
-	ymp)
-		basic_machine=ymp-cray
-		os=-unicos
-		;;
-	none)
-		basic_machine=none-none
-		os=-none
-		;;
-
-# Here we handle the default manufacturer of certain CPU types.  It is in
-# some cases the only manufacturer, in others, it is the most popular.
-	w89k)
-		basic_machine=hppa1.1-winbond
-		;;
-	op50n)
-		basic_machine=hppa1.1-oki
-		;;
-	op60c)
-		basic_machine=hppa1.1-oki
-		;;
-	romp)
-		basic_machine=romp-ibm
-		;;
-	mmix)
-		basic_machine=mmix-knuth
-		;;
-	rs6000)
-		basic_machine=rs6000-ibm
-		;;
-	vax)
-		basic_machine=vax-dec
-		;;
-	pdp11)
-		basic_machine=pdp11-dec
-		;;
-	we32k)
-		basic_machine=we32k-att
-		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
-		basic_machine=sh-unknown
-		;;
-	cydra)
-		basic_machine=cydra-cydrome
-		;;
-	orion)
-		basic_machine=orion-highlevel
-		;;
-	orion105)
-		basic_machine=clipper-highlevel
-		;;
-	mac | mpw | mac-mpw)
-		basic_machine=m68k-apple
-		;;
-	pmac | pmac-mpw)
-		basic_machine=powerpc-apple
-		;;
-	*-unknown)
-		# Make sure to match an already-canonicalized machine name.
-		;;
-	*)
-		echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-
-# Here we canonicalize certain aliases for manufacturers.
-case $basic_machine in
-	*-digital*)
-		basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'`
-		;;
-	*-commodore*)
-		basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'`
-		;;
-	*)
-		;;
-esac
-
-# Decode manufacturer-specific aliases for certain operating systems.
-
-if [ x"$os" != x"" ]
-then
-case $os in
-	# First match some system type aliases that might get confused
-	# with valid system types.
-	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
-		;;
-	-solaris1 | -solaris1.*)
-		os=`echo $os | sed -e 's|solaris1|sunos4|'`
-		;;
-	-solaris)
-		os=-solaris2
-		;;
-	-unixware*)
-		os=-sysv4.2uw
-		;;
-	-gnu/linux*)
-		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
-		;;
-	# es1800 is here to avoid being matched by es* (a different OS)
-	-es1800*)
-		os=-ose
-		;;
-	# Now accept the basic system types.
-	# The portable systems comes first.
-	# Each alternative MUST end in a * to match a version number.
-	# -sysv* is not here because it comes later, after sysvr4.
-	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
-	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* | -cloudabi* | -sortix* \
-	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
-	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
-	      | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \
-	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
-	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
-	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
-	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
-	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \
-	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
-	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
-	      | -morphos* | -superux* | -rtmk* | -windiss* \
-	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \
-	      | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \
-	      | -midnightbsd*)
-	# Remember, each alternative MUST END IN *, to match a version number.
-		;;
-	-qnx*)
-		case $basic_machine in
-		    x86-* | i*86-*)
-			;;
-		    *)
-			os=-nto$os
-			;;
-		esac
-		;;
-	-nto-qnx*)
-		;;
-	-nto*)
-		os=`echo $os | sed -e 's|nto|nto-qnx|'`
-		;;
-	-sim | -xray | -os68k* | -v88r* \
-	      | -windows* | -osx | -abug | -netware* | -os9* \
-	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
-		;;
-	-mac*)
-		os=`echo "$os" | sed -e 's|mac|macos|'`
-		;;
-	-linux-dietlibc)
-		os=-linux-dietlibc
-		;;
-	-linux*)
-		os=`echo $os | sed -e 's|linux|linux-gnu|'`
-		;;
-	-sunos5*)
-		os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
-		;;
-	-sunos6*)
-		os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
-		;;
-	-opened*)
-		os=-openedition
-		;;
-	-os400*)
-		os=-os400
-		;;
-	-wince*)
-		os=-wince
-		;;
-	-utek*)
-		os=-bsd
-		;;
-	-dynix*)
-		os=-bsd
-		;;
-	-acis*)
-		os=-aos
-		;;
-	-atheos*)
-		os=-atheos
-		;;
-	-syllable*)
-		os=-syllable
-		;;
-	-386bsd)
-		os=-bsd
-		;;
-	-ctix* | -uts*)
-		os=-sysv
-		;;
-	-nova*)
-		os=-rtmk-nova
-		;;
-	-ns2)
-		os=-nextstep2
-		;;
-	-nsk*)
-		os=-nsk
-		;;
-	# Preserve the version number of sinix5.
-	-sinix5.*)
-		os=`echo $os | sed -e 's|sinix|sysv|'`
-		;;
-	-sinix*)
-		os=-sysv4
-		;;
-	-tpf*)
-		os=-tpf
-		;;
-	-triton*)
-		os=-sysv3
-		;;
-	-oss*)
-		os=-sysv3
-		;;
-	-svr4*)
-		os=-sysv4
-		;;
-	-svr3)
-		os=-sysv3
-		;;
-	-sysvr4)
-		os=-sysv4
-		;;
-	# This must come after -sysvr4.
-	-sysv*)
-		;;
-	-ose*)
-		os=-ose
-		;;
-	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-		os=-mint
-		;;
-	-zvmoe)
-		os=-zvmoe
-		;;
-	-dicos*)
-		os=-dicos
-		;;
-	-pikeos*)
-		# Until real need of OS specific support for
-		# particular features comes up, bare metal
-		# configurations are quite functional.
-		case $basic_machine in
-		    arm*)
-			os=-eabi
-			;;
-		    *)
-			os=-elf
-			;;
-		esac
-		;;
-	-nacl*)
-		;;
-	-ios)
-		;;
-	-none)
-		;;
-	*)
-		# Get rid of the `-' at the beginning of $os.
-		os=`echo $os | sed 's/[^-]*-//'`
-		echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2
-		exit 1
-		;;
-esac
-else
-
-# Here we handle the default operating systems that come with various machines.
-# The value should be what the vendor currently ships out the door with their
-# machine or put another way, the most popular os provided with the machine.
-
-# Note that if you're going to try to match "-MANUFACTURER" here (say,
-# "-sun"), then you have to tell the case statement up towards the top
-# that MANUFACTURER isn't an operating system.  Otherwise, code above
-# will signal an error saying that MANUFACTURER isn't an operating
-# system, and we'll never get to this point.
-
-case $basic_machine in
-	score-*)
-		os=-elf
-		;;
-	spu-*)
-		os=-elf
-		;;
-	*-acorn)
-		os=-riscix1.2
-		;;
-	arm*-rebel)
-		os=-linux
-		;;
-	arm*-semi)
-		os=-aout
-		;;
-	c4x-* | tic4x-*)
-		os=-coff
-		;;
-	c8051-*)
-		os=-elf
-		;;
-	hexagon-*)
-		os=-elf
-		;;
-	tic54x-*)
-		os=-coff
-		;;
-	tic55x-*)
-		os=-coff
-		;;
-	tic6x-*)
-		os=-coff
-		;;
-	# This must come before the *-dec entry.
-	pdp10-*)
-		os=-tops20
-		;;
-	pdp11-*)
-		os=-none
-		;;
-	*-dec | vax-*)
-		os=-ultrix4.2
-		;;
-	m68*-apollo)
-		os=-domain
-		;;
-	i386-sun)
-		os=-sunos4.0.2
-		;;
-	m68000-sun)
-		os=-sunos3
-		;;
-	m68*-cisco)
-		os=-aout
-		;;
-	mep-*)
-		os=-elf
-		;;
-	mips*-cisco)
-		os=-elf
-		;;
-	mips*-*)
-		os=-elf
-		;;
-	or32-*)
-		os=-coff
-		;;
-	*-tti)	# must be before sparc entry or we get the wrong os.
-		os=-sysv3
-		;;
-	sparc-* | *-sun)
-		os=-sunos4.1.1
-		;;
-	pru-*)
-		os=-elf
-		;;
-	*-be)
-		os=-beos
-		;;
-	*-ibm)
-		os=-aix
-		;;
-	*-knuth)
-		os=-mmixware
-		;;
-	*-wec)
-		os=-proelf
-		;;
-	*-winbond)
-		os=-proelf
-		;;
-	*-oki)
-		os=-proelf
-		;;
-	*-hp)
-		os=-hpux
-		;;
-	*-hitachi)
-		os=-hiux
-		;;
-	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
-		os=-sysv
-		;;
-	*-cbm)
-		os=-amigaos
-		;;
-	*-dg)
-		os=-dgux
-		;;
-	*-dolphin)
-		os=-sysv3
-		;;
-	m68k-ccur)
-		os=-rtu
-		;;
-	m88k-omron*)
-		os=-luna
-		;;
-	*-next)
-		os=-nextstep
-		;;
-	*-sequent)
-		os=-ptx
-		;;
-	*-crds)
-		os=-unos
-		;;
-	*-ns)
-		os=-genix
-		;;
-	i370-*)
-		os=-mvs
-		;;
-	*-gould)
-		os=-sysv
-		;;
-	*-highlevel)
-		os=-bsd
-		;;
-	*-encore)
-		os=-bsd
-		;;
-	*-sgi)
-		os=-irix
-		;;
-	*-siemens)
-		os=-sysv4
-		;;
-	*-masscomp)
-		os=-rtu
-		;;
-	f30[01]-fujitsu | f700-fujitsu)
-		os=-uxpv
-		;;
-	*-rom68k)
-		os=-coff
-		;;
-	*-*bug)
-		os=-coff
-		;;
-	*-apple)
-		os=-macos
-		;;
-	*-atari*)
-		os=-mint
-		;;
-	*)
-		os=-none
-		;;
-esac
-fi
-
-# Here we handle the case where we know the os, and the CPU type, but not the
-# manufacturer.  We pick the logical manufacturer.
-vendor=unknown
-case $basic_machine in
-	*-unknown)
-		case $os in
-			-riscix*)
-				vendor=acorn
-				;;
-			-sunos*)
-				vendor=sun
-				;;
-			-cnk*|-aix*)
-				vendor=ibm
-				;;
-			-beos*)
-				vendor=be
-				;;
-			-hpux*)
-				vendor=hp
-				;;
-			-mpeix*)
-				vendor=hp
-				;;
-			-hiux*)
-				vendor=hitachi
-				;;
-			-unos*)
-				vendor=crds
-				;;
-			-dgux*)
-				vendor=dg
-				;;
-			-luna*)
-				vendor=omron
-				;;
-			-genix*)
-				vendor=ns
-				;;
-			-mvs* | -opened*)
-				vendor=ibm
-				;;
-			-os400*)
-				vendor=ibm
-				;;
-			-ptx*)
-				vendor=sequent
-				;;
-			-tpf*)
-				vendor=ibm
-				;;
-			-vxsim* | -vxworks* | -windiss*)
-				vendor=wrs
-				;;
-			-aux*)
-				vendor=apple
-				;;
-			-hms*)
-				vendor=hitachi
-				;;
-			-mpw* | -macos*)
-				vendor=apple
-				;;
-			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
-				vendor=atari
-				;;
-			-vos*)
-				vendor=stratus
-				;;
-		esac
-		basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"`
-		;;
-esac
-
-echo "$basic_machine$os"
-exit
-
-# Local variables:
-# eval: (add-hook 'write-file-functions 'time-stamp)
-# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
-# time-stamp-end: "'"
-# End:
diff --git a/libssh2/libssh2/configure b/libssh2/libssh2/configure
deleted file mode 100755
index 1cbf782b..00000000
--- a/libssh2/libssh2/configure
+++ /dev/null
@@ -1,26655 +0,0 @@
-#! /bin/sh
-# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.71 for libssh2 -.
-#
-# Report bugs to <libssh2-devel@cool.haxx.se>.
-#
-#
-# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,
-# Inc.
-#
-#
-# This configure script is free software; the Free Software Foundation
-# gives unlimited permission to copy, distribute and modify it.
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-as_nop=:
-if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else $as_nop
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-
-# Reset variables that may have inherited troublesome values from
-# the environment.
-
-# IFS needs to be set, to space, tab, and newline, in precisely that order.
-# (If _AS_PATH_WALK were called with IFS unset, it would have the
-# side effect of setting IFS to empty, thus disabling word splitting.)
-# Quoting is to prevent editors from complaining about space-tab.
-as_nl='
-'
-export as_nl
-IFS=" ""	$as_nl"
-
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# Ensure predictable behavior from utilities with locale-dependent output.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# We cannot yet rely on "unset" to work, but we need these variables
-# to be unset--not just set to an empty or harmless value--now, to
-# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
-# also avoids known problems related to "unset" and subshell syntax
-# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
-for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
-do eval test \${$as_var+y} \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-
-# Ensure that fds 0, 1, and 2 are open.
-if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
-if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
-if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
-
-# The user is always right.
-if ${PATH_SEPARATOR+false} :; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-
-# Use a proper internal environment variable to ensure we don't fall
-  # into an infinite loop, continuously re-executing ourselves.
-  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
-    _as_can_reexec=no; export _as_can_reexec;
-    # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-  fi
-  # We don't want this to propagate to other subprocesses.
-          { _as_can_reexec=; unset _as_can_reexec;}
-if test "x$CONFIG_SHELL" = x; then
-  as_bourne_compatible="as_nop=:
-if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else \$as_nop
-  case \`(set -o) 2>/dev/null\` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-"
-  as_required="as_fn_return () { (exit \$1); }
-as_fn_success () { as_fn_return 0; }
-as_fn_failure () { as_fn_return 1; }
-as_fn_ret_success () { return 0; }
-as_fn_ret_failure () { return 1; }
-
-exitcode=0
-as_fn_success || { exitcode=1; echo as_fn_success failed.; }
-as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
-as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
-as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
-if ( set x; as_fn_ret_success y && test x = \"\$1\" )
-then :
-
-else \$as_nop
-  exitcode=1; echo positional parameters were not saved.
-fi
-test x\$exitcode = x0 || exit 1
-blah=\$(echo \$(echo blah))
-test x\"\$blah\" = xblah || exit 1
-test -x / || exit 1"
-  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
-
-  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
-    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
-    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
-    PATH=/empty FPATH=/empty; export PATH FPATH
-    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
-      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1
-test \$(( 1 + 1 )) = 2 || exit 1"
-  if (eval "$as_required") 2>/dev/null
-then :
-  as_have_required=yes
-else $as_nop
-  as_have_required=no
-fi
-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
-then :
-
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-  as_found=:
-  case $as_dir in #(
-	 /*)
-	   for as_base in sh bash ksh sh5; do
-	     # Try only shells that exist, to save several forks.
-	     as_shell=$as_dir$as_base
-	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
-		    as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null
-then :
-  CONFIG_SHELL=$as_shell as_have_required=yes
-		   if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null
-then :
-  break 2
-fi
-fi
-	   done;;
-       esac
-  as_found=false
-done
-IFS=$as_save_IFS
-if $as_found
-then :
-
-else $as_nop
-  if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-	      as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
-then :
-  CONFIG_SHELL=$SHELL as_have_required=yes
-fi
-fi
-
-
-      if test "x$CONFIG_SHELL" != x
-then :
-  export CONFIG_SHELL
-             # We cannot yet assume a decent shell, so we have to provide a
-# neutralization value for shells without unset; and this also
-# works around shells that cannot unset nonexistent variables.
-# Preserve -v and -x to the replacement shell.
-BASH_ENV=/dev/null
-ENV=/dev/null
-(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
-case $- in # ((((
-  *v*x* | *x*v* ) as_opts=-vx ;;
-  *v* ) as_opts=-v ;;
-  *x* ) as_opts=-x ;;
-  * ) as_opts= ;;
-esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
-# Admittedly, this is quite paranoid, since all the known shells bail
-# out after a failed `exec'.
-printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
-exit 255
-fi
-
-    if test x$as_have_required = xno
-then :
-  printf "%s\n" "$0: This script requires a shell more modern than all"
-  printf "%s\n" "$0: the shells that I found on your system."
-  if test ${ZSH_VERSION+y} ; then
-    printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-    printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
-  else
-    printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and
-$0: libssh2-devel@cool.haxx.se about your system, including
-$0: any error possibly output before this message. Then
-$0: install a modern shell, or manually run the script
-$0: under such a shell if you do have one."
-  fi
-  exit 1
-fi
-fi
-fi
-SHELL=${CONFIG_SHELL-/bin/sh}
-export SHELL
-# Unset more variables known to interfere with behavior of common tools.
-CLICOLOR_FORCE= GREP_OPTIONS=
-unset CLICOLOR_FORCE GREP_OPTIONS
-
-## --------------------- ##
-## M4sh Shell Functions. ##
-## --------------------- ##
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-# as_fn_nop
-# ---------
-# Do nothing but, unlike ":", preserve the value of $?.
-as_fn_nop ()
-{
-  return $?
-}
-as_nop=as_fn_nop
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
-then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else $as_nop
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
-then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else $as_nop
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-# as_fn_nop
-# ---------
-# Do nothing but, unlike ":", preserve the value of $?.
-as_fn_nop ()
-{
-  return $?
-}
-as_nop=as_fn_nop
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  printf "%s\n" "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-  as_lineno_1=$LINENO as_lineno_1a=$LINENO
-  as_lineno_2=$LINENO as_lineno_2a=$LINENO
-  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
-  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
-  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
-  sed -n '
-    p
-    /[$]LINENO/=
-  ' <$as_myself |
-    sed '
-      s/[$]LINENO.*/&-/
-      t lineno
-      b
-      :lineno
-      N
-      :loop
-      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
-      t loop
-      s/-\n.*//
-    ' >$as_me.lineno &&
-  chmod +x "$as_me.lineno" ||
-    { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-
-  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-  # already done that, so ensure we don't try to do so again and fall
-  # in an infinite loop.  This has already happened in practice.
-  _as_can_reexec=no; export _as_can_reexec
-  # Don't try to exec as it changes $[0], causing all sort of problems
-  # (the dirname of $[0] is not the place where we might find the
-  # original and so on.  Autoconf is especially sensitive to this).
-  . "./$as_me.lineno"
-  # Exit status is that of the last command.
-  exit
-}
-
-
-# Determine whether it's possible to make 'echo' print without a newline.
-# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-# for compatibility with existing Makefiles.
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-# For backward compatibility with old third-party macros, we provide
-# the shell variables $as_echo and $as_echo_n.  New code should use
-# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-as_echo='printf %s\n'
-as_echo_n='printf %s'
-
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-SHELL=${CONFIG_SHELL-/bin/sh}
-
-
-test -n "$DJDIR" || exec 7<&0 </dev/null
-exec 6>&1
-
-# Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
-# so uname gets run too.
-ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
-
-#
-# Initializations.
-#
-ac_default_prefix=/usr/local
-ac_clean_files=
-ac_config_libobj_dir=.
-LIBOBJS=
-cross_compiling=no
-subdirs=
-MFLAGS=
-MAKEFLAGS=
-
-# Identity of this package.
-PACKAGE_NAME='libssh2'
-PACKAGE_TARNAME='libssh2'
-PACKAGE_VERSION='-'
-PACKAGE_STRING='libssh2 -'
-PACKAGE_BUGREPORT='libssh2-devel@cool.haxx.se'
-PACKAGE_URL=''
-
-ac_unique_file="src"
-# Factoring default headers for most tests.
-ac_includes_default="\
-#include <stddef.h>
-#ifdef HAVE_STDIO_H
-# include <stdio.h>
-#endif
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
-#endif
-#ifdef HAVE_STDINT_H
-# include <stdint.h>
-#endif
-#ifdef HAVE_STRINGS_H
-# include <strings.h>
-#endif
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-# include <sys/stat.h>
-#endif
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif"
-
-ac_header_c_list=
-ac_subst_vars='am__EXEEXT_FALSE
-am__EXEEXT_TRUE
-LTLIBOBJS
-LIBOBJS
-ALLOCA
-HAVE_SYS_UN_H_FALSE
-HAVE_SYS_UN_H_TRUE
-USE_OSSFUZZ_STATIC_FALSE
-USE_OSSFUZZ_STATIC_TRUE
-USE_OSSFUZZ_FLAG_FALSE
-USE_OSSFUZZ_FLAG_TRUE
-LIB_FUZZING_ENGINE
-USE_OSSFUZZERS_FALSE
-USE_OSSFUZZERS_TRUE
-BUILD_EXAMPLES_FALSE
-BUILD_EXAMPLES_TRUE
-CPP
-LIBSREQUIRED
-LIBZ_PREFIX
-LTLIBZ
-LIBZ
-HAVE_LIBZ
-WINCNG_FALSE
-WINCNG_TRUE
-MBEDTLS_FALSE
-MBEDTLS_TRUE
-LIBGCRYPT_FALSE
-LIBGCRYPT_TRUE
-OPENSSL_FALSE
-OPENSSL_TRUE
-LIBBCRYPT_PREFIX
-LTLIBBCRYPT
-LIBBCRYPT
-HAVE_LIBBCRYPT
-LIBCRYPT32_PREFIX
-LTLIBCRYPT32
-LIBCRYPT32
-HAVE_LIBCRYPT32
-LIBMBEDCRYPTO_PREFIX
-LTLIBMBEDCRYPTO
-LIBMBEDCRYPTO
-HAVE_LIBMBEDCRYPTO
-LIBGCRYPT_PREFIX
-LTLIBGCRYPT
-LIBGCRYPT
-HAVE_LIBGCRYPT
-LIBSSL_PREFIX
-LTLIBSSL
-LIBSSL
-HAVE_LIBSSL
-CXXCPP
-LT_SYS_LIBRARY_PATH
-OTOOL64
-OTOOL
-LIPO
-NMEDIT
-DSYMUTIL
-MANIFEST_TOOL
-RANLIB
-ac_ct_AR
-AR
-NM
-ac_ct_DUMPBIN
-DUMPBIN
-LD
-FGREP
-EGREP
-GREP
-LIBTOOL
-OBJDUMP
-DLLTOOL
-AS
-SSHD_FALSE
-SSHD_TRUE
-SSHD
-LN_S
-am__fastdepCXX_FALSE
-am__fastdepCXX_TRUE
-CXXDEPMODE
-ac_ct_CXX
-CXXFLAGS
-CXX
-am__fastdepCC_FALSE
-am__fastdepCC_TRUE
-CCDEPMODE
-am__nodep
-AMDEPBACKSLASH
-AMDEP_FALSE
-AMDEP_TRUE
-am__include
-DEPDIR
-OBJEXT
-EXEEXT
-ac_ct_CC
-CPPFLAGS
-LDFLAGS
-CFLAGS
-CC
-host_os
-host_vendor
-host_cpu
-host
-build_os
-build_vendor
-build_cpu
-build
-LIBSSH2VER
-CSCOPE
-ETAGS
-CTAGS
-am__untar
-am__tar
-AMTAR
-am__leading_dot
-SET_MAKE
-AWK
-mkdir_p
-MKDIR_P
-INSTALL_STRIP_PROGRAM
-STRIP
-install_sh
-MAKEINFO
-AUTOHEADER
-AUTOMAKE
-AUTOCONF
-ACLOCAL
-VERSION
-PACKAGE
-CYGPATH_W
-am__isrc
-INSTALL_DATA
-INSTALL_SCRIPT
-INSTALL_PROGRAM
-SED
-AM_BACKSLASH
-AM_DEFAULT_VERBOSITY
-AM_DEFAULT_V
-AM_V
-MAINT
-MAINTAINER_MODE_FALSE
-MAINTAINER_MODE_TRUE
-target_alias
-host_alias
-build_alias
-LIBS
-ECHO_T
-ECHO_N
-ECHO_C
-DEFS
-mandir
-localedir
-libdir
-psdir
-pdfdir
-dvidir
-htmldir
-infodir
-docdir
-oldincludedir
-includedir
-runstatedir
-localstatedir
-sharedstatedir
-sysconfdir
-datadir
-datarootdir
-libexecdir
-sbindir
-bindir
-program_transform_name
-prefix
-exec_prefix
-PACKAGE_URL
-PACKAGE_BUGREPORT
-PACKAGE_STRING
-PACKAGE_VERSION
-PACKAGE_TARNAME
-PACKAGE_NAME
-PATH_SEPARATOR
-SHELL
-am__quote'
-ac_subst_files=''
-ac_user_opts='
-enable_option_checking
-enable_maintainer_mode
-enable_silent_rules
-enable_dependency_tracking
-enable_shared
-enable_static
-with_pic
-enable_fast_install
-with_aix_soname
-with_gnu_ld
-with_sysroot
-enable_libtool_lock
-enable_largefile
-with_crypto
-enable_rpath
-with_libssl_prefix
-with_libgcrypt_prefix
-with_libmbedcrypto_prefix
-with_libcrypt32_prefix
-with_libbcrypt_prefix
-with_libz
-with_libz_prefix
-enable_crypt_none
-enable_mac_none
-enable_gex_new
-enable_clear_memory
-enable_debug
-enable_hidden_symbols
-enable_examples_build
-enable_ossfuzzers
-enable_werror
-'
-      ac_precious_vars='build_alias
-host_alias
-target_alias
-CC
-CFLAGS
-LDFLAGS
-LIBS
-CPPFLAGS
-CXX
-CXXFLAGS
-CCC
-LT_SYS_LIBRARY_PATH
-CXXCPP
-CPP'
-
-
-# Initialize some variables set by options.
-ac_init_help=
-ac_init_version=false
-ac_unrecognized_opts=
-ac_unrecognized_sep=
-# The variables have the same names as the options, with
-# dashes changed to underlines.
-cache_file=/dev/null
-exec_prefix=NONE
-no_create=
-no_recursion=
-prefix=NONE
-program_prefix=NONE
-program_suffix=NONE
-program_transform_name=s,x,x,
-silent=
-site=
-srcdir=
-verbose=
-x_includes=NONE
-x_libraries=NONE
-
-# Installation directory options.
-# These are left unexpanded so users can "make install exec_prefix=/foo"
-# and all the variables that are supposed to be based on exec_prefix
-# by default will actually change.
-# Use braces instead of parens because sh, perl, etc. also accept them.
-# (The list follows the same order as the GNU Coding Standards.)
-bindir='${exec_prefix}/bin'
-sbindir='${exec_prefix}/sbin'
-libexecdir='${exec_prefix}/libexec'
-datarootdir='${prefix}/share'
-datadir='${datarootdir}'
-sysconfdir='${prefix}/etc'
-sharedstatedir='${prefix}/com'
-localstatedir='${prefix}/var'
-runstatedir='${localstatedir}/run'
-includedir='${prefix}/include'
-oldincludedir='/usr/include'
-docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
-infodir='${datarootdir}/info'
-htmldir='${docdir}'
-dvidir='${docdir}'
-pdfdir='${docdir}'
-psdir='${docdir}'
-libdir='${exec_prefix}/lib'
-localedir='${datarootdir}/locale'
-mandir='${datarootdir}/man'
-
-ac_prev=
-ac_dashdash=
-for ac_option
-do
-  # If the previous option needs an argument, assign it.
-  if test -n "$ac_prev"; then
-    eval $ac_prev=\$ac_option
-    ac_prev=
-    continue
-  fi
-
-  case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
-  esac
-
-  case $ac_dashdash$ac_option in
-  --)
-    ac_dashdash=yes ;;
-
-  -bindir | --bindir | --bindi | --bind | --bin | --bi)
-    ac_prev=bindir ;;
-  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
-    bindir=$ac_optarg ;;
-
-  -build | --build | --buil | --bui | --bu)
-    ac_prev=build_alias ;;
-  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
-    build_alias=$ac_optarg ;;
-
-  -cache-file | --cache-file | --cache-fil | --cache-fi \
-  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
-    ac_prev=cache_file ;;
-  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
-  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
-    cache_file=$ac_optarg ;;
-
-  --config-cache | -C)
-    cache_file=config.cache ;;
-
-  -datadir | --datadir | --datadi | --datad)
-    ac_prev=datadir ;;
-  -datadir=* | --datadir=* | --datadi=* | --datad=*)
-    datadir=$ac_optarg ;;
-
-  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
-  | --dataroo | --dataro | --datar)
-    ac_prev=datarootdir ;;
-  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
-  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
-    datarootdir=$ac_optarg ;;
-
-  -disable-* | --disable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: \`$ac_useropt'"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=no ;;
-
-  -docdir | --docdir | --docdi | --doc | --do)
-    ac_prev=docdir ;;
-  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
-    docdir=$ac_optarg ;;
-
-  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
-    ac_prev=dvidir ;;
-  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
-    dvidir=$ac_optarg ;;
-
-  -enable-* | --enable-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: \`$ac_useropt'"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"enable_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval enable_$ac_useropt=\$ac_optarg ;;
-
-  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
-  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
-  | --exec | --exe | --ex)
-    ac_prev=exec_prefix ;;
-  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
-  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
-  | --exec=* | --exe=* | --ex=*)
-    exec_prefix=$ac_optarg ;;
-
-  -gas | --gas | --ga | --g)
-    # Obsolete; use --with-gas.
-    with_gas=yes ;;
-
-  -help | --help | --hel | --he | -h)
-    ac_init_help=long ;;
-  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
-    ac_init_help=recursive ;;
-  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
-    ac_init_help=short ;;
-
-  -host | --host | --hos | --ho)
-    ac_prev=host_alias ;;
-  -host=* | --host=* | --hos=* | --ho=*)
-    host_alias=$ac_optarg ;;
-
-  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
-    ac_prev=htmldir ;;
-  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
-  | --ht=*)
-    htmldir=$ac_optarg ;;
-
-  -includedir | --includedir | --includedi | --included | --include \
-  | --includ | --inclu | --incl | --inc)
-    ac_prev=includedir ;;
-  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
-  | --includ=* | --inclu=* | --incl=* | --inc=*)
-    includedir=$ac_optarg ;;
-
-  -infodir | --infodir | --infodi | --infod | --info | --inf)
-    ac_prev=infodir ;;
-  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
-    infodir=$ac_optarg ;;
-
-  -libdir | --libdir | --libdi | --libd)
-    ac_prev=libdir ;;
-  -libdir=* | --libdir=* | --libdi=* | --libd=*)
-    libdir=$ac_optarg ;;
-
-  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
-  | --libexe | --libex | --libe)
-    ac_prev=libexecdir ;;
-  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
-  | --libexe=* | --libex=* | --libe=*)
-    libexecdir=$ac_optarg ;;
-
-  -localedir | --localedir | --localedi | --localed | --locale)
-    ac_prev=localedir ;;
-  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
-    localedir=$ac_optarg ;;
-
-  -localstatedir | --localstatedir | --localstatedi | --localstated \
-  | --localstate | --localstat | --localsta | --localst | --locals)
-    ac_prev=localstatedir ;;
-  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
-  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
-    localstatedir=$ac_optarg ;;
-
-  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
-    ac_prev=mandir ;;
-  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
-    mandir=$ac_optarg ;;
-
-  -nfp | --nfp | --nf)
-    # Obsolete; use --without-fp.
-    with_fp=no ;;
-
-  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c | -n)
-    no_create=yes ;;
-
-  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
-    no_recursion=yes ;;
-
-  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
-  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
-  | --oldin | --oldi | --old | --ol | --o)
-    ac_prev=oldincludedir ;;
-  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
-  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
-  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
-    oldincludedir=$ac_optarg ;;
-
-  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
-    ac_prev=prefix ;;
-  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
-    prefix=$ac_optarg ;;
-
-  -program-prefix | --program-prefix | --program-prefi | --program-pref \
-  | --program-pre | --program-pr | --program-p)
-    ac_prev=program_prefix ;;
-  -program-prefix=* | --program-prefix=* | --program-prefi=* \
-  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
-    program_prefix=$ac_optarg ;;
-
-  -program-suffix | --program-suffix | --program-suffi | --program-suff \
-  | --program-suf | --program-su | --program-s)
-    ac_prev=program_suffix ;;
-  -program-suffix=* | --program-suffix=* | --program-suffi=* \
-  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
-    program_suffix=$ac_optarg ;;
-
-  -program-transform-name | --program-transform-name \
-  | --program-transform-nam | --program-transform-na \
-  | --program-transform-n | --program-transform- \
-  | --program-transform | --program-transfor \
-  | --program-transfo | --program-transf \
-  | --program-trans | --program-tran \
-  | --progr-tra | --program-tr | --program-t)
-    ac_prev=program_transform_name ;;
-  -program-transform-name=* | --program-transform-name=* \
-  | --program-transform-nam=* | --program-transform-na=* \
-  | --program-transform-n=* | --program-transform-=* \
-  | --program-transform=* | --program-transfor=* \
-  | --program-transfo=* | --program-transf=* \
-  | --program-trans=* | --program-tran=* \
-  | --progr-tra=* | --program-tr=* | --program-t=*)
-    program_transform_name=$ac_optarg ;;
-
-  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
-    ac_prev=pdfdir ;;
-  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
-    pdfdir=$ac_optarg ;;
-
-  -psdir | --psdir | --psdi | --psd | --ps)
-    ac_prev=psdir ;;
-  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
-    psdir=$ac_optarg ;;
-
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil)
-    silent=yes ;;
-
-  -runstatedir | --runstatedir | --runstatedi | --runstated \
-  | --runstate | --runstat | --runsta | --runst | --runs \
-  | --run | --ru | --r)
-    ac_prev=runstatedir ;;
-  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-  | --run=* | --ru=* | --r=*)
-    runstatedir=$ac_optarg ;;
-
-  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-    ac_prev=sbindir ;;
-  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-  | --sbi=* | --sb=*)
-    sbindir=$ac_optarg ;;
-
-  -sharedstatedir | --sharedstatedir | --sharedstatedi \
-  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
-  | --sharedst | --shareds | --shared | --share | --shar \
-  | --sha | --sh)
-    ac_prev=sharedstatedir ;;
-  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
-  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
-  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
-  | --sha=* | --sh=*)
-    sharedstatedir=$ac_optarg ;;
-
-  -site | --site | --sit)
-    ac_prev=site ;;
-  -site=* | --site=* | --sit=*)
-    site=$ac_optarg ;;
-
-  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
-    ac_prev=srcdir ;;
-  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
-    srcdir=$ac_optarg ;;
-
-  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
-  | --syscon | --sysco | --sysc | --sys | --sy)
-    ac_prev=sysconfdir ;;
-  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
-  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
-    sysconfdir=$ac_optarg ;;
-
-  -target | --target | --targe | --targ | --tar | --ta | --t)
-    ac_prev=target_alias ;;
-  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
-    target_alias=$ac_optarg ;;
-
-  -v | -verbose | --verbose | --verbos | --verbo | --verb)
-    verbose=yes ;;
-
-  -version | --version | --versio | --versi | --vers | -V)
-    ac_init_version=: ;;
-
-  -with-* | --with-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: \`$ac_useropt'"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=\$ac_optarg ;;
-
-  -without-* | --without-*)
-    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-    # Reject names that are not valid shell variable names.
-    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: \`$ac_useropt'"
-    ac_useropt_orig=$ac_useropt
-    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-    case $ac_user_opts in
-      *"
-"with_$ac_useropt"
-"*) ;;
-      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
-	 ac_unrecognized_sep=', ';;
-    esac
-    eval with_$ac_useropt=no ;;
-
-  --x)
-    # Obsolete; use --with-x.
-    with_x=yes ;;
-
-  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
-  | --x-incl | --x-inc | --x-in | --x-i)
-    ac_prev=x_includes ;;
-  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
-  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
-    x_includes=$ac_optarg ;;
-
-  -x-libraries | --x-libraries | --x-librarie | --x-librari \
-  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
-    ac_prev=x_libraries ;;
-  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
-  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-    x_libraries=$ac_optarg ;;
-
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
-    ;;
-
-  *=*)
-    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
-    # Reject names that are not valid shell variable names.
-    case $ac_envvar in #(
-      '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-    esac
-    eval $ac_envvar=\$ac_optarg
-    export $ac_envvar ;;
-
-  *)
-    # FIXME: should be removed in autoconf 3.0.
-    printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
-    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
-      printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
-    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-    ;;
-
-  esac
-done
-
-if test -n "$ac_prev"; then
-  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
-fi
-
-if test -n "$ac_unrecognized_opts"; then
-  case $enable_option_checking in
-    no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
-    *)     printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-  esac
-fi
-
-# Check all directory arguments for consistency.
-for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
-		datadir sysconfdir sharedstatedir localstatedir includedir \
-		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir runstatedir
-do
-  eval ac_val=\$$ac_var
-  # Remove trailing slashes.
-  case $ac_val in
-    */ )
-      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
-      eval $ac_var=\$ac_val;;
-  esac
-  # Be sure to have absolute directory names.
-  case $ac_val in
-    [\\/$]* | ?:[\\/]* )  continue;;
-    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
-  esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
-done
-
-# There might be people who depend on the old broken behavior: `$host'
-# used to hold the argument of --host etc.
-# FIXME: To remove some day.
-build=$build_alias
-host=$host_alias
-target=$target_alias
-
-# FIXME: To remove some day.
-if test "x$host_alias" != x; then
-  if test "x$build_alias" = x; then
-    cross_compiling=maybe
-  elif test "x$build_alias" != "x$host_alias"; then
-    cross_compiling=yes
-  fi
-fi
-
-ac_tool_prefix=
-test -n "$host_alias" && ac_tool_prefix=$host_alias-
-
-test "$silent" = yes && exec 6>/dev/null
-
-
-ac_pwd=`pwd` && test -n "$ac_pwd" &&
-ac_ls_di=`ls -di .` &&
-ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
-test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
-
-
-# Find the source files, if location was not specified.
-if test -z "$srcdir"; then
-  ac_srcdir_defaulted=yes
-  # Try the directory containing this script, then the parent directory.
-  ac_confdir=`$as_dirname -- "$as_myself" ||
-$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_myself" : 'X\(//\)[^/]' \| \
-	 X"$as_myself" : 'X\(//\)$' \| \
-	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_myself" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  srcdir=$ac_confdir
-  if test ! -r "$srcdir/$ac_unique_file"; then
-    srcdir=..
-  fi
-else
-  ac_srcdir_defaulted=no
-fi
-if test ! -r "$srcdir/$ac_unique_file"; then
-  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
-fi
-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-ac_abs_confdir=`(
-	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
-	pwd)`
-# When building in place, set srcdir=.
-if test "$ac_abs_confdir" = "$ac_pwd"; then
-  srcdir=.
-fi
-# Remove unnecessary trailing slashes from srcdir.
-# Double slashes in file names in object file debugging info
-# mess up M-x gdb in Emacs.
-case $srcdir in
-*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
-esac
-for ac_var in $ac_precious_vars; do
-  eval ac_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_env_${ac_var}_value=\$${ac_var}
-  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
-  eval ac_cv_env_${ac_var}_value=\$${ac_var}
-done
-
-#
-# Report the --help message.
-#
-if test "$ac_init_help" = "long"; then
-  # Omit some internal or obsolete options to make the list less imposing.
-  # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<_ACEOF
-\`configure' configures libssh2 - to adapt to many kinds of systems.
-
-Usage: $0 [OPTION]... [VAR=VALUE]...
-
-To assign environment variables (e.g., CC, CFLAGS...), specify them as
-VAR=VALUE.  See below for descriptions of some of the useful variables.
-
-Defaults for the options are specified in brackets.
-
-Configuration:
-  -h, --help              display this help and exit
-      --help=short        display options specific to this package
-      --help=recursive    display the short help of all the included packages
-  -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
-      --cache-file=FILE   cache test results in FILE [disabled]
-  -C, --config-cache      alias for \`--cache-file=config.cache'
-  -n, --no-create         do not create output files
-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-
-Installation directories:
-  --prefix=PREFIX         install architecture-independent files in PREFIX
-                          [$ac_default_prefix]
-  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                          [PREFIX]
-
-By default, \`make install' will install all the files in
-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
-for instance \`--prefix=\$HOME'.
-
-For better control, use the options below.
-
-Fine tuning of the installation directories:
-  --bindir=DIR            user executables [EPREFIX/bin]
-  --sbindir=DIR           system admin executables [EPREFIX/sbin]
-  --libexecdir=DIR        program executables [EPREFIX/libexec]
-  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-  --libdir=DIR            object code libraries [EPREFIX/lib]
-  --includedir=DIR        C header files [PREFIX/include]
-  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
-  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
-  --infodir=DIR           info documentation [DATAROOTDIR/info]
-  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
-  --mandir=DIR            man documentation [DATAROOTDIR/man]
-  --docdir=DIR            documentation root [DATAROOTDIR/doc/libssh2]
-  --htmldir=DIR           html documentation [DOCDIR]
-  --dvidir=DIR            dvi documentation [DOCDIR]
-  --pdfdir=DIR            pdf documentation [DOCDIR]
-  --psdir=DIR             ps documentation [DOCDIR]
-_ACEOF
-
-  cat <<\_ACEOF
-
-Program names:
-  --program-prefix=PREFIX            prepend PREFIX to installed program names
-  --program-suffix=SUFFIX            append SUFFIX to installed program names
-  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
-
-System types:
-  --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
-_ACEOF
-fi
-
-if test -n "$ac_init_help"; then
-  case $ac_init_help in
-     short | recursive ) echo "Configuration of libssh2 -:";;
-   esac
-  cat <<\_ACEOF
-
-Optional Features:
-  --disable-option-checking  ignore unrecognized --enable/--with options
-  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
-  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
-  --enable-maintainer-mode
-                          enable make rules and dependencies not useful (and
-                          sometimes confusing) to the casual installer
-  --enable-silent-rules   less verbose build output (undo: "make V=1")
-  --disable-silent-rules  verbose build output (undo: "make V=0")
-  --enable-dependency-tracking
-                          do not reject slow dependency extractors
-  --disable-dependency-tracking
-                          speeds up one-time build
-  --enable-shared[=PKGS]  build shared libraries [default=yes]
-  --enable-static[=PKGS]  build static libraries [default=yes]
-  --enable-fast-install[=PKGS]
-                          optimize for fast installation [default=yes]
-  --disable-libtool-lock  avoid locking (might break parallel builds)
-  --disable-largefile     omit support for large files
-  --disable-rpath         do not hardcode runtime library paths
-  --enable-crypt-none     Permit "none" cipher -- NOT RECOMMENDED
-  --enable-mac-none       Permit "none" MAC -- NOT RECOMMENDED
-  --disable-gex-new       Disable "new" diffie-hellman-group-exchange-sha1
-                          method
-  --disable-clear-memory  Disable clearing of memory before being freed
-  --enable-debug          Enable pedantic and debug options
-  --disable-debug         Disable debug options
-  --enable-hidden-symbols Hide internal symbols in library
-  --disable-hidden-symbols
-                          Leave all symbols with default visibility in library
-  --enable-examples-build Build example applications (this is the default)
-  --disable-examples-build
-                          Do not build example applications
-  --enable-ossfuzzers     Whether to generate the fuzzers for OSS-Fuzz
-  --enable-werror         Enable compiler warnings as errors
-  --disable-werror        Disable compiler warnings as errors
-
-Optional Packages:
-  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
-  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
-  --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
-                          both]
-  --with-aix-soname=aix|svr4|both
-                          shared library versioning (aka "SONAME") variant to
-                          provide on AIX, [default=aix].
-  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
-  --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
-                          compiler's sysroot if not specified).
-  --with-crypto=auto|openssl|libgcrypt|mbedtls|wincng
-                          Select crypto backend (default: auto)
-  --with-gnu-ld           assume the C compiler uses GNU ld default=no
-  --with-libssl-prefix[=DIR]  search for libssl in DIR/include and DIR/lib
-  --without-libssl-prefix     don't search for libssl in includedir and libdir
-  --with-libgcrypt-prefix[=DIR]  search for libgcrypt in DIR/include and DIR/lib
-  --without-libgcrypt-prefix     don't search for libgcrypt in includedir and libdir
-  --with-libmbedcrypto-prefix[=DIR]  search for libmbedcrypto in DIR/include and DIR/lib
-  --without-libmbedcrypto-prefix     don't search for libmbedcrypto in includedir and libdir
-  --with-libcrypt32-prefix[=DIR]  search for libcrypt32 in DIR/include and DIR/lib
-  --without-libcrypt32-prefix     don't search for libcrypt32 in includedir and libdir
-  --with-libbcrypt-prefix[=DIR]  search for libbcrypt in DIR/include and DIR/lib
-  --without-libbcrypt-prefix     don't search for libbcrypt in includedir and libdir
-  --with-libz             Use libz for compression
-  --with-libz-prefix[=DIR]  search for libz in DIR/include and DIR/lib
-  --without-libz-prefix     don't search for libz in includedir and libdir
-
-Some influential environment variables:
-  CC          C compiler command
-  CFLAGS      C compiler flags
-  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
-              nonstandard directory <lib dir>
-  LIBS        libraries to pass to the linker, e.g. -l<library>
-  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
-              you have headers in a nonstandard directory <include dir>
-  CXX         C++ compiler command
-  CXXFLAGS    C++ compiler flags
-  LT_SYS_LIBRARY_PATH
-              User-defined run-time library search path.
-  CXXCPP      C++ preprocessor
-  CPP         C preprocessor
-
-Use these variables to override the choices made by `configure' or to help
-it to find libraries and programs with nonstandard names/locations.
-
-Report bugs to <libssh2-devel@cool.haxx.se>.
-_ACEOF
-ac_status=$?
-fi
-
-if test "$ac_init_help" = "recursive"; then
-  # If there are subdirs, report their specific --help.
-  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
-    test -d "$ac_dir" ||
-      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
-      continue
-    ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-    cd "$ac_dir" || { ac_status=$?; continue; }
-    # Check for configure.gnu first; this name is used for a wrapper for
-    # Metaconfig's "Configure" on case-insensitive file systems.
-    if test -f "$ac_srcdir/configure.gnu"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-    elif test -f "$ac_srcdir/configure"; then
-      echo &&
-      $SHELL "$ac_srcdir/configure" --help=recursive
-    else
-      printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-    fi || ac_status=$?
-    cd "$ac_pwd" || { ac_status=$?; break; }
-  done
-fi
-
-test -n "$ac_init_help" && exit $ac_status
-if $ac_init_version; then
-  cat <<\_ACEOF
-libssh2 configure -
-generated by GNU Autoconf 2.71
-
-Copyright (C) 2021 Free Software Foundation, Inc.
-This configure script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it.
-_ACEOF
-  exit
-fi
-
-## ------------------------ ##
-## Autoconf initialization. ##
-## ------------------------ ##
-
-# ac_fn_c_try_compile LINENO
-# --------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest.beam
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_compile
-
-# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
-# -------------------------------------------
-# Tests whether TYPE exists after having included INCLUDES, setting cache
-# variable VAR accordingly.
-ac_fn_c_check_type ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-printf %s "checking for $2... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  eval "$3=no"
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-if (sizeof ($2))
-	 return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-if (sizeof (($2)))
-	    return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-else $as_nop
-  eval "$3=yes"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_c_check_type
-
-# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
-# -------------------------------------------------------
-# Tests whether HEADER exists and can be compiled using the include files in
-# INCLUDES, setting the cache variable VAR accordingly.
-ac_fn_c_check_header_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-printf %s "checking for $2... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-#include <$2>
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  eval "$3=yes"
-else $as_nop
-  eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_c_check_header_compile
-
-# ac_fn_c_try_link LINENO
-# -----------------------
-# Try to link conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_link ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest$ac_exeext && {
-	 test "$cross_compiling" = yes ||
-	 test -x conftest$ac_exeext
-       }
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
-  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
-  # interfere with the next link command; also delete a directory that is
-  # left behind by Apple's compiler.  We do this before executing the actions.
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_link
-
-# ac_fn_cxx_try_compile LINENO
-# ----------------------------
-# Try to compile conftest.$ac_ext, and return whether this succeeded.
-ac_fn_cxx_try_compile ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest.beam
-  if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_cxx_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest.$ac_objext
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_cxx_try_compile
-
-# ac_fn_c_check_func LINENO FUNC VAR
-# ----------------------------------
-# Tests whether FUNC exists, setting the cache variable VAR accordingly
-ac_fn_c_check_func ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-printf %s "checking for $2... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $2 innocuous_$2
-
-/* System header to define __stub macros and hopefully few prototypes,
-   which can conflict with char $2 (); below.  */
-
-#include <limits.h>
-#undef $2
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char $2 ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined __stub_$2 || defined __stub___$2
-choke me
-#endif
-
-int
-main (void)
-{
-return $2 ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  eval "$3=yes"
-else $as_nop
-  eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_c_check_func
-
-# ac_fn_cxx_try_cpp LINENO
-# ------------------------
-# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
-ac_fn_cxx_try_cpp ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_cpp conftest.$ac_ext"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } > conftest.i && {
-	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
-	 test ! -s conftest.err
-       }
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-    ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_cxx_try_cpp
-
-# ac_fn_cxx_try_link LINENO
-# -------------------------
-# Try to link conftest.$ac_ext, and return whether this succeeded.
-ac_fn_cxx_try_link ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && {
-	 test -z "$ac_cxx_werror_flag" ||
-	 test ! -s conftest.err
-       } && test -s conftest$ac_exeext && {
-	 test "$cross_compiling" = yes ||
-	 test -x conftest$ac_exeext
-       }
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-	ac_retval=1
-fi
-  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
-  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
-  # interfere with the next link command; also delete a directory that is
-  # left behind by Apple's compiler.  We do this before executing the actions.
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_cxx_try_link
-
-# ac_fn_c_try_run LINENO
-# ----------------------
-# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that
-# executables *can* be run.
-ac_fn_c_try_run ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: program exited with status $ac_status" >&5
-       printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-       ac_retval=$ac_status
-fi
-  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_run
-
-# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR
-# ------------------------------------------------------------------
-# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR
-# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR.
-ac_fn_check_decl ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  as_decl_name=`echo $2|sed 's/ *(.*//'`
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
-printf %s "checking whether $as_decl_name is declared... " >&6; }
-if eval test \${$3+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
-  eval ac_save_FLAGS=\$$6
-  as_fn_append $6 " $5"
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-int
-main (void)
-{
-#ifndef $as_decl_name
-#ifdef __cplusplus
-  (void) $as_decl_use;
-#else
-  (void) $as_decl_name;
-#endif
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  eval "$3=yes"
-else $as_nop
-  eval "$3=no"
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  eval $6=\$ac_save_FLAGS
-
-fi
-eval ac_res=\$$3
-	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_check_decl
-
-# ac_fn_c_try_cpp LINENO
-# ----------------------
-# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_cpp ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_cpp conftest.$ac_ext"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } > conftest.i && {
-	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       }
-then :
-  ac_retval=0
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-    ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_cpp
-ac_configure_args_raw=
-for ac_arg
-do
-  case $ac_arg in
-  *\'*)
-    ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-  esac
-  as_fn_append ac_configure_args_raw " '$ac_arg'"
-done
-
-case $ac_configure_args_raw in
-  *$as_nl*)
-    ac_safe_unquote= ;;
-  *)
-    ac_unsafe_z='|&;<>()$`\\"*?[ ''	' # This string ends in space, tab.
-    ac_unsafe_a="$ac_unsafe_z#~"
-    ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
-    ac_configure_args_raw=`      printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
-esac
-
-cat >config.log <<_ACEOF
-This file contains any messages produced by compilers while
-running configure, to aid debugging if configure makes a mistake.
-
-It was created by libssh2 $as_me -, which was
-generated by GNU Autoconf 2.71.  Invocation command line was
-
-  $ $0$ac_configure_args_raw
-
-_ACEOF
-exec 5>>config.log
-{
-cat <<_ASUNAME
-## --------- ##
-## Platform. ##
-## --------- ##
-
-hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
-uname -m = `(uname -m) 2>/dev/null || echo unknown`
-uname -r = `(uname -r) 2>/dev/null || echo unknown`
-uname -s = `(uname -s) 2>/dev/null || echo unknown`
-uname -v = `(uname -v) 2>/dev/null || echo unknown`
-
-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
-/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
-
-/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
-/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
-/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
-/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
-/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
-/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
-/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
-
-_ASUNAME
-
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    printf "%s\n" "PATH: $as_dir"
-  done
-IFS=$as_save_IFS
-
-} >&5
-
-cat >&5 <<_ACEOF
-
-
-## ----------- ##
-## Core tests. ##
-## ----------- ##
-
-_ACEOF
-
-
-# Keep a trace of the command line.
-# Strip out --no-create and --no-recursion so they do not pile up.
-# Strip out --silent because we don't want to record it for future runs.
-# Also quote any args containing shell meta-characters.
-# Make two passes to allow for proper duplicate-argument suppression.
-ac_configure_args=
-ac_configure_args0=
-ac_configure_args1=
-ac_must_keep_next=false
-for ac_pass in 1 2
-do
-  for ac_arg
-  do
-    case $ac_arg in
-    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-    | -silent | --silent | --silen | --sile | --sil)
-      continue ;;
-    *\'*)
-      ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    case $ac_pass in
-    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-    2)
-      as_fn_append ac_configure_args1 " '$ac_arg'"
-      if test $ac_must_keep_next = true; then
-	ac_must_keep_next=false # Got value, back to normal.
-      else
-	case $ac_arg in
-	  *=* | --config-cache | -C | -disable-* | --disable-* \
-	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
-	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
-	  | -with-* | --with-* | -without-* | --without-* | --x)
-	    case "$ac_configure_args0 " in
-	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
-	    esac
-	    ;;
-	  -* ) ac_must_keep_next=true ;;
-	esac
-      fi
-      as_fn_append ac_configure_args " '$ac_arg'"
-      ;;
-    esac
-  done
-done
-{ ac_configure_args0=; unset ac_configure_args0;}
-{ ac_configure_args1=; unset ac_configure_args1;}
-
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log.  We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
-  # Sanitize IFS.
-  IFS=" ""	$as_nl"
-  # Save into config.log some information that might help in debugging.
-  {
-    echo
-
-    printf "%s\n" "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
-    echo
-    # The following way of writing the cache mishandles newlines in values,
-(
-  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-  (set) 2>&1 |
-    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      sed -n \
-	"s/'\''/'\''\\\\'\'''\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
-      ;; #(
-    *)
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-)
-    echo
-
-    printf "%s\n" "## ----------------- ##
-## Output variables. ##
-## ----------------- ##"
-    echo
-    for ac_var in $ac_subst_vars
-    do
-      eval ac_val=\$$ac_var
-      case $ac_val in
-      *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-      esac
-      printf "%s\n" "$ac_var='\''$ac_val'\''"
-    done | sort
-    echo
-
-    if test -n "$ac_subst_files"; then
-      printf "%s\n" "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
-      echo
-      for ac_var in $ac_subst_files
-      do
-	eval ac_val=\$$ac_var
-	case $ac_val in
-	*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-	esac
-	printf "%s\n" "$ac_var='\''$ac_val'\''"
-      done | sort
-      echo
-    fi
-
-    if test -s confdefs.h; then
-      printf "%s\n" "## ----------- ##
-## confdefs.h. ##
-## ----------- ##"
-      echo
-      cat confdefs.h
-      echo
-    fi
-    test "$ac_signal" != 0 &&
-      printf "%s\n" "$as_me: caught signal $ac_signal"
-    printf "%s\n" "$as_me: exit $exit_status"
-  } >&5
-  rm -f core *.core core.conftest.* &&
-    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-    exit $exit_status
-' 0
-for ac_signal in 1 2 13 15; do
-  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
-done
-ac_signal=0
-
-# confdefs.h avoids OS command line length limits that DEFS can exceed.
-rm -f -r conftest* confdefs.h
-
-printf "%s\n" "/* confdefs.h */" > confdefs.h
-
-# Predefined preprocessor variables.
-
-printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
-
-printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
-
-printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
-
-printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
-
-printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
-
-printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
-
-
-# Let the site file select an alternate cache file if it wants to.
-# Prefer an explicitly selected file to automatically selected ones.
-if test -n "$CONFIG_SITE"; then
-  ac_site_files="$CONFIG_SITE"
-elif test "x$prefix" != xNONE; then
-  ac_site_files="$prefix/share/config.site $prefix/etc/config.site"
-else
-  ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
-fi
-
-for ac_site_file in $ac_site_files
-do
-  case $ac_site_file in #(
-  */*) :
-     ;; #(
-  *) :
-    ac_site_file=./$ac_site_file ;;
-esac
-  if test -f "$ac_site_file" && test -r "$ac_site_file"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
-    sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-done
-
-if test -r "$cache_file"; then
-  # Some versions of bash will fail to source /dev/null (special files
-  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
-    case $cache_file in
-      [\\/]* | ?:[\\/]* ) . "$cache_file";;
-      *)                      . "./$cache_file";;
-    esac
-  fi
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
-  >$cache_file
-fi
-
-# Test code for whether the C compiler supports C89 (global declarations)
-ac_c_conftest_c89_globals='
-/* Does the compiler advertise C89 conformance?
-   Do not test the value of __STDC__, because some compilers set it to 0
-   while being otherwise adequately conformant. */
-#if !defined __STDC__
-# error "Compiler does not advertise C89 conformance"
-#endif
-
-#include <stddef.h>
-#include <stdarg.h>
-struct stat;
-/* Most of the following tests are stolen from RCS 5.7 src/conf.sh.  */
-struct buf { int x; };
-struct buf * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not \xHH hex character constants.
-   These do not provoke an error unfortunately, instead are silently treated
-   as an "x".  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously \x00 != x always comes out true, for an
-   array size at least.  It is necessary to write \x00 == 0 to get something
-   that is true only with -std.  */
-int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) '\''x'\''
-int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),
-               int, int);'
-
-# Test code for whether the C compiler supports C89 (body of main).
-ac_c_conftest_c89_main='
-ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
-'
-
-# Test code for whether the C compiler supports C99 (global declarations)
-ac_c_conftest_c99_globals='
-// Does the compiler advertise C99 conformance?
-#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
-# error "Compiler does not advertise C99 conformance"
-#endif
-
-#include <stdbool.h>
-extern int puts (const char *);
-extern int printf (const char *, ...);
-extern int dprintf (int, const char *, ...);
-extern void *malloc (size_t);
-
-// Check varargs macros.  These examples are taken from C99 6.10.3.5.
-// dprintf is used instead of fprintf to avoid needing to declare
-// FILE and stderr.
-#define debug(...) dprintf (2, __VA_ARGS__)
-#define showlist(...) puts (#__VA_ARGS__)
-#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
-static void
-test_varargs_macros (void)
-{
-  int x = 1234;
-  int y = 5678;
-  debug ("Flag");
-  debug ("X = %d\n", x);
-  showlist (The first, second, and third items.);
-  report (x>y, "x is %d but y is %d", x, y);
-}
-
-// Check long long types.
-#define BIG64 18446744073709551615ull
-#define BIG32 4294967295ul
-#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
-#if !BIG_OK
-  #error "your preprocessor is broken"
-#endif
-#if BIG_OK
-#else
-  #error "your preprocessor is broken"
-#endif
-static long long int bignum = -9223372036854775807LL;
-static unsigned long long int ubignum = BIG64;
-
-struct incomplete_array
-{
-  int datasize;
-  double data[];
-};
-
-struct named_init {
-  int number;
-  const wchar_t *name;
-  double average;
-};
-
-typedef const char *ccp;
-
-static inline int
-test_restrict (ccp restrict text)
-{
-  // See if C++-style comments work.
-  // Iterate through items via the restricted pointer.
-  // Also check for declarations in for loops.
-  for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
-    continue;
-  return 0;
-}
-
-// Check varargs and va_copy.
-static bool
-test_varargs (const char *format, ...)
-{
-  va_list args;
-  va_start (args, format);
-  va_list args_copy;
-  va_copy (args_copy, args);
-
-  const char *str = "";
-  int number = 0;
-  float fnumber = 0;
-
-  while (*format)
-    {
-      switch (*format++)
-	{
-	case '\''s'\'': // string
-	  str = va_arg (args_copy, const char *);
-	  break;
-	case '\''d'\'': // int
-	  number = va_arg (args_copy, int);
-	  break;
-	case '\''f'\'': // float
-	  fnumber = va_arg (args_copy, double);
-	  break;
-	default:
-	  break;
-	}
-    }
-  va_end (args_copy);
-  va_end (args);
-
-  return *str && number && fnumber;
-}
-'
-
-# Test code for whether the C compiler supports C99 (body of main).
-ac_c_conftest_c99_main='
-  // Check bool.
-  _Bool success = false;
-  success |= (argc != 0);
-
-  // Check restrict.
-  if (test_restrict ("String literal") == 0)
-    success = true;
-  char *restrict newvar = "Another string";
-
-  // Check varargs.
-  success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
-  test_varargs_macros ();
-
-  // Check flexible array members.
-  struct incomplete_array *ia =
-    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
-  ia->datasize = 10;
-  for (int i = 0; i < ia->datasize; ++i)
-    ia->data[i] = i * 1.234;
-
-  // Check named initializers.
-  struct named_init ni = {
-    .number = 34,
-    .name = L"Test wide string",
-    .average = 543.34343,
-  };
-
-  ni.number = 58;
-
-  int dynamic_array[ni.number];
-  dynamic_array[0] = argv[0][0];
-  dynamic_array[ni.number - 1] = 543;
-
-  // work around unused variable warnings
-  ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
-	 || dynamic_array[ni.number - 1] != 543);
-'
-
-# Test code for whether the C compiler supports C11 (global declarations)
-ac_c_conftest_c11_globals='
-// Does the compiler advertise C11 conformance?
-#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
-# error "Compiler does not advertise C11 conformance"
-#endif
-
-// Check _Alignas.
-char _Alignas (double) aligned_as_double;
-char _Alignas (0) no_special_alignment;
-extern char aligned_as_int;
-char _Alignas (0) _Alignas (int) aligned_as_int;
-
-// Check _Alignof.
-enum
-{
-  int_alignment = _Alignof (int),
-  int_array_alignment = _Alignof (int[100]),
-  char_alignment = _Alignof (char)
-};
-_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
-
-// Check _Noreturn.
-int _Noreturn does_not_return (void) { for (;;) continue; }
-
-// Check _Static_assert.
-struct test_static_assert
-{
-  int x;
-  _Static_assert (sizeof (int) <= sizeof (long int),
-                  "_Static_assert does not work in struct");
-  long int y;
-};
-
-// Check UTF-8 literals.
-#define u8 syntax error!
-char const utf8_literal[] = u8"happens to be ASCII" "another string";
-
-// Check duplicate typedefs.
-typedef long *long_ptr;
-typedef long int *long_ptr;
-typedef long_ptr long_ptr;
-
-// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
-struct anonymous
-{
-  union {
-    struct { int i; int j; };
-    struct { int k; long int l; } w;
-  };
-  int m;
-} v1;
-'
-
-# Test code for whether the C compiler supports C11 (body of main).
-ac_c_conftest_c11_main='
-  _Static_assert ((offsetof (struct anonymous, i)
-		   == offsetof (struct anonymous, w.k)),
-		  "Anonymous union alignment botch");
-  v1.i = 2;
-  v1.w.k = 5;
-  ok |= v1.i != 5;
-'
-
-# Test code for whether the C compiler supports C11 (complete).
-ac_c_conftest_c11_program="${ac_c_conftest_c89_globals}
-${ac_c_conftest_c99_globals}
-${ac_c_conftest_c11_globals}
-
-int
-main (int argc, char **argv)
-{
-  int ok = 0;
-  ${ac_c_conftest_c89_main}
-  ${ac_c_conftest_c99_main}
-  ${ac_c_conftest_c11_main}
-  return ok;
-}
-"
-
-# Test code for whether the C compiler supports C99 (complete).
-ac_c_conftest_c99_program="${ac_c_conftest_c89_globals}
-${ac_c_conftest_c99_globals}
-
-int
-main (int argc, char **argv)
-{
-  int ok = 0;
-  ${ac_c_conftest_c89_main}
-  ${ac_c_conftest_c99_main}
-  return ok;
-}
-"
-
-# Test code for whether the C compiler supports C89 (complete).
-ac_c_conftest_c89_program="${ac_c_conftest_c89_globals}
-
-int
-main (int argc, char **argv)
-{
-  int ok = 0;
-  ${ac_c_conftest_c89_main}
-  return ok;
-}
-"
-
-as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H"
-as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H"
-as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H"
-as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
-as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H"
-as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H"
-as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
-as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
-as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H"
-# Test code for whether the C++ compiler supports C++98 (global declarations)
-ac_cxx_conftest_cxx98_globals='
-// Does the compiler advertise C++98 conformance?
-#if !defined __cplusplus || __cplusplus < 199711L
-# error "Compiler does not advertise C++98 conformance"
-#endif
-
-// These inclusions are to reject old compilers that
-// lack the unsuffixed header files.
-#include <cstdlib>
-#include <exception>
-
-// <cassert> and <cstring> are *not* freestanding headers in C++98.
-extern void assert (int);
-namespace std {
-  extern int strcmp (const char *, const char *);
-}
-
-// Namespaces, exceptions, and templates were all added after "C++ 2.0".
-using std::exception;
-using std::strcmp;
-
-namespace {
-
-void test_exception_syntax()
-{
-  try {
-    throw "test";
-  } catch (const char *s) {
-    // Extra parentheses suppress a warning when building autoconf itself,
-    // due to lint rules shared with more typical C programs.
-    assert (!(strcmp) (s, "test"));
-  }
-}
-
-template <typename T> struct test_template
-{
-  T const val;
-  explicit test_template(T t) : val(t) {}
-  template <typename U> T add(U u) { return static_cast<T>(u) + val; }
-};
-
-} // anonymous namespace
-'
-
-# Test code for whether the C++ compiler supports C++98 (body of main)
-ac_cxx_conftest_cxx98_main='
-  assert (argc);
-  assert (! argv[0]);
-{
-  test_exception_syntax ();
-  test_template<double> tt (2.0);
-  assert (tt.add (4) == 6.0);
-  assert (true && !false);
-}
-'
-
-# Test code for whether the C++ compiler supports C++11 (global declarations)
-ac_cxx_conftest_cxx11_globals='
-// Does the compiler advertise C++ 2011 conformance?
-#if !defined __cplusplus || __cplusplus < 201103L
-# error "Compiler does not advertise C++11 conformance"
-#endif
-
-namespace cxx11test
-{
-  constexpr int get_val() { return 20; }
-
-  struct testinit
-  {
-    int i;
-    double d;
-  };
-
-  class delegate
-  {
-  public:
-    delegate(int n) : n(n) {}
-    delegate(): delegate(2354) {}
-
-    virtual int getval() { return this->n; };
-  protected:
-    int n;
-  };
-
-  class overridden : public delegate
-  {
-  public:
-    overridden(int n): delegate(n) {}
-    virtual int getval() override final { return this->n * 2; }
-  };
-
-  class nocopy
-  {
-  public:
-    nocopy(int i): i(i) {}
-    nocopy() = default;
-    nocopy(const nocopy&) = delete;
-    nocopy & operator=(const nocopy&) = delete;
-  private:
-    int i;
-  };
-
-  // for testing lambda expressions
-  template <typename Ret, typename Fn> Ret eval(Fn f, Ret v)
-  {
-    return f(v);
-  }
-
-  // for testing variadic templates and trailing return types
-  template <typename V> auto sum(V first) -> V
-  {
-    return first;
-  }
-  template <typename V, typename... Args> auto sum(V first, Args... rest) -> V
-  {
-    return first + sum(rest...);
-  }
-}
-'
-
-# Test code for whether the C++ compiler supports C++11 (body of main)
-ac_cxx_conftest_cxx11_main='
-{
-  // Test auto and decltype
-  auto a1 = 6538;
-  auto a2 = 48573953.4;
-  auto a3 = "String literal";
-
-  int total = 0;
-  for (auto i = a3; *i; ++i) { total += *i; }
-
-  decltype(a2) a4 = 34895.034;
-}
-{
-  // Test constexpr
-  short sa[cxx11test::get_val()] = { 0 };
-}
-{
-  // Test initializer lists
-  cxx11test::testinit il = { 4323, 435234.23544 };
-}
-{
-  // Test range-based for
-  int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3,
-                 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
-  for (auto &x : array) { x += 23; }
-}
-{
-  // Test lambda expressions
-  using cxx11test::eval;
-  assert (eval ([](int x) { return x*2; }, 21) == 42);
-  double d = 2.0;
-  assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0);
-  assert (d == 5.0);
-  assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0);
-  assert (d == 5.0);
-}
-{
-  // Test use of variadic templates
-  using cxx11test::sum;
-  auto a = sum(1);
-  auto b = sum(1, 2);
-  auto c = sum(1.0, 2.0, 3.0);
-}
-{
-  // Test constructor delegation
-  cxx11test::delegate d1;
-  cxx11test::delegate d2();
-  cxx11test::delegate d3(45);
-}
-{
-  // Test override and final
-  cxx11test::overridden o1(55464);
-}
-{
-  // Test nullptr
-  char *c = nullptr;
-}
-{
-  // Test template brackets
-  test_template<::test_template<int>> v(test_template<int>(12));
-}
-{
-  // Unicode literals
-  char const *utf8 = u8"UTF-8 string \u2500";
-  char16_t const *utf16 = u"UTF-8 string \u2500";
-  char32_t const *utf32 = U"UTF-32 string \u2500";
-}
-'
-
-# Test code for whether the C compiler supports C++11 (complete).
-ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals}
-${ac_cxx_conftest_cxx11_globals}
-
-int
-main (int argc, char **argv)
-{
-  int ok = 0;
-  ${ac_cxx_conftest_cxx98_main}
-  ${ac_cxx_conftest_cxx11_main}
-  return ok;
-}
-"
-
-# Test code for whether the C compiler supports C++98 (complete).
-ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals}
-int
-main (int argc, char **argv)
-{
-  int ok = 0;
-  ${ac_cxx_conftest_cxx98_main}
-  return ok;
-}
-"
-
-
-# Auxiliary files required by this configure script.
-ac_aux_files="config.rpath ltmain.sh compile config.guess config.sub missing install-sh"
-
-# Locations in which to look for auxiliary files.
-ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.."
-
-# Search for a directory containing all of the required auxiliary files,
-# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.
-# If we don't find one directory that contains all the files we need,
-# we report the set of missing files from the *first* directory in
-# $ac_aux_dir_candidates and give up.
-ac_missing_aux_files=""
-ac_first_candidate=:
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_found=false
-for as_dir in $ac_aux_dir_candidates
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-  as_found=:
-
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}:  trying $as_dir" >&5
-  ac_aux_dir_found=yes
-  ac_install_sh=
-  for ac_aux in $ac_aux_files
-  do
-    # As a special case, if "install-sh" is required, that requirement
-    # can be satisfied by any of "install-sh", "install.sh", or "shtool",
-    # and $ac_install_sh is set appropriately for whichever one is found.
-    if test x"$ac_aux" = x"install-sh"
-    then
-      if test -f "${as_dir}install-sh"; then
-        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install-sh found" >&5
-        ac_install_sh="${as_dir}install-sh -c"
-      elif test -f "${as_dir}install.sh"; then
-        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install.sh found" >&5
-        ac_install_sh="${as_dir}install.sh -c"
-      elif test -f "${as_dir}shtool"; then
-        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}shtool found" >&5
-        ac_install_sh="${as_dir}shtool install -c"
-      else
-        ac_aux_dir_found=no
-        if $ac_first_candidate; then
-          ac_missing_aux_files="${ac_missing_aux_files} install-sh"
-        else
-          break
-        fi
-      fi
-    else
-      if test -f "${as_dir}${ac_aux}"; then
-        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}${ac_aux} found" >&5
-      else
-        ac_aux_dir_found=no
-        if $ac_first_candidate; then
-          ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}"
-        else
-          break
-        fi
-      fi
-    fi
-  done
-  if test "$ac_aux_dir_found" = yes; then
-    ac_aux_dir="$as_dir"
-    break
-  fi
-  ac_first_candidate=false
-
-  as_found=false
-done
-IFS=$as_save_IFS
-if $as_found
-then :
-
-else $as_nop
-  as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5
-fi
-
-
-# These three variables are undocumented and unsupported,
-# and are intended to be withdrawn in a future Autoconf release.
-# They can cause serious problems if a builder's source tree is in a directory
-# whose full name contains unusual characters.
-if test -f "${ac_aux_dir}config.guess"; then
-  ac_config_guess="$SHELL ${ac_aux_dir}config.guess"
-fi
-if test -f "${ac_aux_dir}config.sub"; then
-  ac_config_sub="$SHELL ${ac_aux_dir}config.sub"
-fi
-if test -f "$ac_aux_dir/configure"; then
-  ac_configure="$SHELL ${ac_aux_dir}configure"
-fi
-
-# Check that the precious variables saved in the cache have kept the same
-# value.
-ac_cache_corrupted=false
-for ac_var in $ac_precious_vars; do
-  eval ac_old_set=\$ac_cv_env_${ac_var}_set
-  eval ac_new_set=\$ac_env_${ac_var}_set
-  eval ac_old_val=\$ac_cv_env_${ac_var}_value
-  eval ac_new_val=\$ac_env_${ac_var}_value
-  case $ac_old_set,$ac_new_set in
-    set,)
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,set)
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-      ac_cache_corrupted=: ;;
-    ,);;
-    *)
-      if test "x$ac_old_val" != "x$ac_new_val"; then
-	# differences in whitespace do not lead to failure.
-	ac_old_val_w=`echo x $ac_old_val`
-	ac_new_val_w=`echo x $ac_new_val`
-	if test "$ac_old_val_w" != "$ac_new_val_w"; then
-	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
-printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-	  ac_cache_corrupted=:
-	else
-	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
-printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-	  eval $ac_var=\$ac_old_val
-	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
-printf "%s\n" "$as_me:   former value:  \`$ac_old_val'" >&2;}
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
-printf "%s\n" "$as_me:   current value: \`$ac_new_val'" >&2;}
-      fi;;
-  esac
-  # Pass precious variables to config.status.
-  if test "$ac_new_set" = set; then
-    case $ac_new_val in
-    *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-    *) ac_arg=$ac_var=$ac_new_val ;;
-    esac
-    case " $ac_configure_args " in
-      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
-      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
-    esac
-  fi
-done
-if $ac_cache_corrupted; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file'
-	    and start over" "$LINENO" 5
-fi
-## -------------------- ##
-## Main body of script. ##
-## -------------------- ##
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-ac_config_headers="$ac_config_headers src/libssh2_config.h"
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
-printf %s "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
-    # Check whether --enable-maintainer-mode was given.
-if test ${enable_maintainer_mode+y}
-then :
-  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
-else $as_nop
-  USE_MAINTAINER_MODE=no
-fi
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
-printf "%s\n" "$USE_MAINTAINER_MODE" >&6; }
-   if test $USE_MAINTAINER_MODE = yes; then
-  MAINTAINER_MODE_TRUE=
-  MAINTAINER_MODE_FALSE='#'
-else
-  MAINTAINER_MODE_TRUE='#'
-  MAINTAINER_MODE_FALSE=
-fi
-
-  MAINT=$MAINTAINER_MODE_TRUE
-
-
-# Check whether --enable-silent-rules was given.
-if test ${enable_silent_rules+y}
-then :
-  enableval=$enable_silent_rules;
-fi
-
-case $enable_silent_rules in # (((
-  yes) AM_DEFAULT_VERBOSITY=0;;
-   no) AM_DEFAULT_VERBOSITY=1;;
-    *) AM_DEFAULT_VERBOSITY=0;;
-esac
-am_make=${MAKE-make}
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
-printf %s "checking whether $am_make supports nested variables... " >&6; }
-if test ${am_cv_make_support_nested_variables+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if printf "%s\n" 'TRUE=$(BAR$(V))
-BAR0=false
-BAR1=true
-V=1
-am__doit:
-	@$(TRUE)
-.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
-  am_cv_make_support_nested_variables=yes
-else
-  am_cv_make_support_nested_variables=no
-fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
-printf "%s\n" "$am_cv_make_support_nested_variables" >&6; }
-if test $am_cv_make_support_nested_variables = yes; then
-    AM_V='$(V)'
-  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
-else
-  AM_V=$AM_DEFAULT_VERBOSITY
-  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
-fi
-AM_BACKSLASH='\'
-
-
-# Extract the first word of "sed", so it can be a program name with args.
-set dummy sed; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_path_SED+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  case $SED in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_SED="$SED" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-as_dummy="$PATH:/usr/bin:/usr/local/bin"
-for as_dir in $as_dummy
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_path_SED="$as_dir$ac_word$ac_exec_ext"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  test -z "$ac_cv_path_SED" && ac_cv_path_SED="sed-was-not-found-by-configure"
-  ;;
-esac
-fi
-SED=$ac_cv_path_SED
-if test -n "$SED"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
-printf "%s\n" "$SED" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-
-
-if test "x$SED" = "xsed-was-not-found-by-configure"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: sed was not found, this may ruin your chances to build fine" >&5
-printf "%s\n" "$as_me: WARNING: sed was not found, this may ruin your chances to build fine" >&2;}
-fi
-
-LIBSSH2VER=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
-am__api_version='1.16'
-
-
-
-  # Find a good install program.  We prefer a C program (faster),
-# so one script is as good as another.  But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-printf %s "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if test ${ac_cv_path_install+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    # Account for fact that we put trailing slashes in our PATH walk.
-case $as_dir in #((
-  ./ | /[cC]/* | \
-  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
-  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
-  /usr/ucb/* ) ;;
-  *)
-    # OSF1 and SCO ODT 3.0 have their own names for install.
-    # Don't use installbsd from OSF since it installs stuff as root
-    # by default.
-    for ac_prog in ginstall scoinst install; do
-      for ac_exec_ext in '' $ac_executable_extensions; do
-	if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then
-	  if test $ac_prog = install &&
-	    grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    rm -rf conftest.one conftest.two conftest.dir
-	    echo one > conftest.one
-	    echo two > conftest.two
-	    mkdir conftest.dir
-	    if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" &&
-	      test -s conftest.one && test -s conftest.two &&
-	      test -s conftest.dir/conftest.one &&
-	      test -s conftest.dir/conftest.two
-	    then
-	      ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c"
-	      break 3
-	    fi
-	  fi
-	fi
-      done
-    done
-    ;;
-esac
-
-  done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
-  if test ${ac_cv_path_install+y}; then
-    INSTALL=$ac_cv_path_install
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for INSTALL within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    INSTALL=$ac_install_sh
-  fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-printf "%s\n" "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
-printf %s "checking whether build environment is sane... " >&6; }
-# Reject unsafe characters in $srcdir or the absolute working directory
-# name.  Accept space and tab only in the latter.
-am_lf='
-'
-case `pwd` in
-  *[\\\"\#\$\&\'\`$am_lf]*)
-    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
-esac
-case $srcdir in
-  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
-    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
-esac
-
-# Do 'set' in a subshell so we don't clobber the current shell's
-# arguments.  Must try -L first in case configure is actually a
-# symlink; some systems play weird games with the mod time of symlinks
-# (eg FreeBSD returns the mod time of the symlink's containing
-# directory).
-if (
-   am_has_slept=no
-   for am_try in 1 2; do
-     echo "timestamp, slept: $am_has_slept" > conftest.file
-     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
-     if test "$*" = "X"; then
-	# -L didn't work.
-	set X `ls -t "$srcdir/configure" conftest.file`
-     fi
-     if test "$*" != "X $srcdir/configure conftest.file" \
-	&& test "$*" != "X conftest.file $srcdir/configure"; then
-
-	# If neither matched, then we have a broken ls.  This can happen
-	# if, for instance, CONFIG_SHELL is bash and it inherits a
-	# broken ls alias from the environment.  This has actually
-	# happened.  Such a system could not be considered "sane".
-	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
-  alias in your environment" "$LINENO" 5
-     fi
-     if test "$2" = conftest.file || test $am_try -eq 2; then
-       break
-     fi
-     # Just in case.
-     sleep 1
-     am_has_slept=yes
-   done
-   test "$2" = conftest.file
-   )
-then
-   # Ok.
-   :
-else
-   as_fn_error $? "newly created file is older than distributed files!
-Check your system clock" "$LINENO" 5
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-# If we didn't sleep, we still need to ensure time stamps of config.status and
-# generated files are strictly newer.
-am_sleep_pid=
-if grep 'slept: no' conftest.file >/dev/null 2>&1; then
-  ( sleep 1 ) &
-  am_sleep_pid=$!
-fi
-
-rm -f conftest.file
-
-test "$program_prefix" != NONE &&
-  program_transform_name="s&^&$program_prefix&;$program_transform_name"
-# Use a double $ so make ignores it.
-test "$program_suffix" != NONE &&
-  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
-# Double any \ or $.
-# By default was `s,x,x', remove it if useless.
-ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
-program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"`
-
-
-# Expand $ac_aux_dir to an absolute path.
-am_aux_dir=`cd "$ac_aux_dir" && pwd`
-
-
-  if test x"${MISSING+set}" != xset; then
-  MISSING="\${SHELL} '$am_aux_dir/missing'"
-fi
-# Use eval to expand $SHELL
-if eval "$MISSING --is-lightweight"; then
-  am_missing_run="$MISSING "
-else
-  am_missing_run=
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
-printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
-fi
-
-if test x"${install_sh+set}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
-  *)
-    install_sh="\${SHELL} $am_aux_dir/install-sh"
-  esac
-fi
-
-# Installed binaries are usually stripped using 'strip' when the user
-# run "make install-strip".  However 'strip' might not be the right
-# tool to use in cross-compilation environments, therefore Automake
-# will honor the 'STRIP' environment variable to overrule this program.
-if test "$cross_compiling" != no; then
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
-set dummy ${ac_tool_prefix}strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_STRIP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$STRIP"; then
-  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-STRIP=$ac_cv_prog_STRIP
-if test -n "$STRIP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-printf "%s\n" "$STRIP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_STRIP"; then
-  ac_ct_STRIP=$STRIP
-  # Extract the first word of "strip", so it can be a program name with args.
-set dummy strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_STRIP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_STRIP"; then
-  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_STRIP="strip"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
-if test -n "$ac_ct_STRIP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-printf "%s\n" "$ac_ct_STRIP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_STRIP" = x; then
-    STRIP=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    STRIP=$ac_ct_STRIP
-  fi
-else
-  STRIP="$ac_cv_prog_STRIP"
-fi
-
-fi
-INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5
-printf %s "checking for a race-free mkdir -p... " >&6; }
-if test -z "$MKDIR_P"; then
-  if test ${ac_cv_path_mkdir+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in mkdir gmkdir; do
-	 for ac_exec_ext in '' $ac_executable_extensions; do
-	   as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue
-	   case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #(
-	     'mkdir ('*'coreutils) '* | \
-	     'BusyBox '* | \
-	     'mkdir (fileutils) '4.1*)
-	       ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext
-	       break 3;;
-	   esac
-	 done
-       done
-  done
-IFS=$as_save_IFS
-
-fi
-
-  test -d ./--version && rmdir ./--version
-  if test ${ac_cv_path_mkdir+y}; then
-    MKDIR_P="$ac_cv_path_mkdir -p"
-  else
-    # As a last resort, use the slow shell script.  Don't cache a
-    # value for MKDIR_P within a source directory, because that will
-    # break other packages using the cache if that directory is
-    # removed, or if the value is a relative name.
-    MKDIR_P="$ac_install_sh -d"
-  fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
-printf "%s\n" "$MKDIR_P" >&6; }
-
-for ac_prog in gawk mawk nawk awk
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_AWK+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AWK"; then
-  ac_cv_prog_AWK="$AWK" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AWK="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-AWK=$ac_cv_prog_AWK
-if test -n "$AWK"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-printf "%s\n" "$AWK" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$AWK" && break
-done
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
-printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
-set x ${MAKE-make}
-ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
-if eval test \${ac_cv_prog_make_${ac_make}_set+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat >conftest.make <<\_ACEOF
-SHELL = /bin/sh
-all:
-	@echo '@@@%%%=$(MAKE)=@@@%%%'
-_ACEOF
-# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
-case `${MAKE-make} -f conftest.make 2>/dev/null` in
-  *@@@%%%=?*=@@@%%%*)
-    eval ac_cv_prog_make_${ac_make}_set=yes;;
-  *)
-    eval ac_cv_prog_make_${ac_make}_set=no;;
-esac
-rm -f conftest.make
-fi
-if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-  SET_MAKE=
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-  SET_MAKE="MAKE=${MAKE-make}"
-fi
-
-rm -rf .tst 2>/dev/null
-mkdir .tst 2>/dev/null
-if test -d .tst; then
-  am__leading_dot=.
-else
-  am__leading_dot=_
-fi
-rmdir .tst 2>/dev/null
-
-if test "`cd $srcdir && pwd`" != "`pwd`"; then
-  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
-  # is not polluted with repeated "-I."
-  am__isrc=' -I$(srcdir)'
-  # test to see if srcdir already configured
-  if test -f $srcdir/config.status; then
-    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
-  fi
-fi
-
-# test whether we have cygpath
-if test -z "$CYGPATH_W"; then
-  if (cygpath --version) >/dev/null 2>/dev/null; then
-    CYGPATH_W='cygpath -w'
-  else
-    CYGPATH_W=echo
-  fi
-fi
-
-
-# Define the identity of the package.
- PACKAGE='libssh2'
- VERSION='-'
-
-
-printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h
-
-
-printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h
-
-# Some tools Automake needs.
-
-ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
-
-
-AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
-
-
-AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
-
-
-AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
-
-
-MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
-
-# For better backward compatibility.  To be removed once Automake 1.9.x
-# dies out for good.  For more background, see:
-# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
-mkdir_p='$(MKDIR_P)'
-
-# We need awk for the "check" target (and possibly the TAP driver).  The
-# system "awk" is bad on some platforms.
-# Always define AMTAR for backward compatibility.  Yes, it's still used
-# in the wild :-(  We should find a proper way to deprecate it ...
-AMTAR='$${TAR-tar}'
-
-
-# We'll loop over all known methods to create a tar archive until one works.
-_am_tools='gnutar  pax cpio none'
-
-am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
-
-
-
-
-
-# Variables for tags utilities; see am/tags.am
-if test -z "$CTAGS"; then
-  CTAGS=ctags
-fi
-
-if test -z "$ETAGS"; then
-  ETAGS=etags
-fi
-
-if test -z "$CSCOPE"; then
-  CSCOPE=cscope
-fi
-
-
-
-# POSIX will say in a future version that running "rm -f" with no argument
-# is OK; and we want to be able to make that assumption in our Makefile
-# recipes.  So use an aggressive probe to check that the usage we want is
-# actually supported "in the wild" to an acceptable degree.
-# See automake bug#10828.
-# To make any issue more visible, cause the running configure to be aborted
-# by default if the 'rm' program in use doesn't match our expectations; the
-# user can still override this though.
-if rm -f && rm -fr && rm -rf; then : OK; else
-  cat >&2 <<'END'
-Oops!
-
-Your 'rm' program seems unable to run without file operands specified
-on the command line, even when the '-f' option is present.  This is contrary
-to the behaviour of most rm programs out there, and not conforming with
-the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
-
-Please tell bug-automake@gnu.org about your system, including the value
-of your $PATH and any error possibly output before this message.  This
-can help us improve future automake versions.
-
-END
-  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
-    echo 'Configuration will proceed anyway, since you have set the' >&2
-    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
-    echo >&2
-  else
-    cat >&2 <<'END'
-Aborting the configuration process, to ensure you take notice of the issue.
-
-You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <https://www.gnu.org/software/coreutils/>.
-
-If you want to complete the configuration process using your problematic
-'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
-to "yes", and re-run configure.
-
-END
-    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
-  fi
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking libssh2 version" >&5
-printf %s "checking libssh2 version... " >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBSSH2VER" >&5
-printf "%s\n" "$LIBSSH2VER" >&6; }
-
-
-
-AB_VERSION=$LIBSSH2VER
-
-
-
-  # Make sure we can run config.sub.
-$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
-  as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
-printf %s "checking build system type... " >&6; }
-if test ${ac_cv_build+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_build_alias=$build_alias
-test "x$ac_build_alias" = x &&
-  ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
-test "x$ac_build_alias" = x &&
-  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
-ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
-  as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-printf "%s\n" "$ac_cv_build" >&6; }
-case $ac_cv_build in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
-esac
-build=$ac_cv_build
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_build
-shift
-build_cpu=$1
-build_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-build_os=$*
-IFS=$ac_save_IFS
-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
-printf %s "checking host system type... " >&6; }
-if test ${ac_cv_host+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test "x$host_alias" = x; then
-  ac_cv_host=$ac_cv_build
-else
-  ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
-    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-printf "%s\n" "$ac_cv_host" >&6; }
-case $ac_cv_host in
-*-*-*) ;;
-*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
-esac
-host=$ac_cv_host
-ac_save_IFS=$IFS; IFS='-'
-set x $ac_cv_host
-shift
-host_cpu=$1
-host_vendor=$2
-shift; shift
-# Remember, the first character of IFS is used to create $*,
-# except with old shells:
-host_os=$*
-IFS=$ac_save_IFS
-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
-
-
-
-
-
-
-	if test -z "$AB_PACKAGE"; then
-	   AB_PACKAGE=${PACKAGE_NAME:-$PACKAGE}
-	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild project... $AB_PACKAGE" >&5
-printf "%s\n" "$as_me: autobuild project... $AB_PACKAGE" >&6;}
-
-	if test -z "$AB_VERSION"; then
-	   AB_VERSION=${PACKAGE_VERSION:-$VERSION}
-	fi
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild revision... $AB_VERSION" >&5
-printf "%s\n" "$as_me: autobuild revision... $AB_VERSION" >&6;}
-
-	hostname=`hostname`
-	if test "$hostname"; then
-	   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild hostname... $hostname" >&5
-printf "%s\n" "$as_me: autobuild hostname... $hostname" >&6;}
-	fi
-
-
-
-	date=`date +%Y%m%d-%H%M%S`
-	if test "$?" != 0; then
-	   date=`date`
-	fi
-	if test "$date"; then
-	   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: autobuild timestamp... $date" >&5
-printf "%s\n" "$as_me: autobuild timestamp... $date" >&6;}
-	fi
-
-
-# Check for the OS.
-# Daniel's note: this should not be necessary and we need to work to
-# get this removed.
-
-case "$host" in
-    *-mingw*)
-    CFLAGS="$CFLAGS -DLIBSSH2_WIN32"
-    LIBS="$LIBS -lws2_32"
-    ;;
-    *darwin*)
-    CFLAGS="$CFLAGS -DLIBSSH2_DARWIN"
-    ;;
-    *hpux*)
-    ;;
-    *osf*)
-    CFLAGS="$CFLAGS -D_POSIX_PII_SOCKET"
-    ;;
-    *)
-    ;;
-esac
-
-
-
-
-
-
-
-
-
-
-DEPDIR="${am__leading_dot}deps"
-
-ac_config_commands="$ac_config_commands depfiles"
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
-printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; }
-cat > confinc.mk << 'END'
-am__doit:
-	@echo this is the am__doit target >confinc.out
-.PHONY: am__doit
-END
-am__include="#"
-am__quote=
-# BSD make does it like this.
-echo '.include "confinc.mk" # ignored' > confmf.BSD
-# Other make implementations (GNU, Solaris 10, AIX) do it like this.
-echo 'include confinc.mk # ignored' > confmf.GNU
-_am_result=no
-for s in GNU BSD; do
-  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
-   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
-   ac_status=$?
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   (exit $ac_status); }
-  case $?:`cat confinc.out 2>/dev/null` in #(
-  '0:this is the am__doit target') :
-    case $s in #(
-  BSD) :
-    am__include='.include' am__quote='"' ;; #(
-  *) :
-    am__include='include' am__quote='' ;;
-esac ;; #(
-  *) :
-     ;;
-esac
-  if test "$am__include" != "#"; then
-    _am_result="yes ($s style)"
-    break
-  fi
-done
-rm -f confinc.* confmf.*
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
-printf "%s\n" "${_am_result}" >&6; }
-
-# Check whether --enable-dependency-tracking was given.
-if test ${enable_dependency_tracking+y}
-then :
-  enableval=$enable_dependency_tracking;
-fi
-
-if test "x$enable_dependency_tracking" != xno; then
-  am_depcomp="$ac_aux_dir/depcomp"
-  AMDEPBACKSLASH='\'
-  am__nodep='_no'
-fi
- if test "x$enable_dependency_tracking" != xno; then
-  AMDEP_TRUE=
-  AMDEP_FALSE='#'
-else
-  AMDEP_TRUE='#'
-  AMDEP_FALSE=
-fi
-
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
-set dummy ${ac_tool_prefix}clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}clang"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "clang", so it can be a program name with args.
-set dummy clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="clang"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-fi
-
-
-test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion -version; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
-# Try to create an executable without -o first, disregard a.out.
-# It will help us diagnose broken compilers, and finding out an intuition
-# of exeext.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-printf %s "checking whether the C compiler works... " >&6; }
-ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-
-# The possible output files:
-ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-
-ac_rmfiles=
-for ac_file in $ac_files
-do
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
-  esac
-done
-rm -f $ac_rmfiles
-
-if { { ac_try="$ac_link_default"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link_default") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-then :
-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-# in a Makefile.  We should not override ac_cv_exeext if it was cached,
-# so that the user can short-circuit this test for compilers unknown to
-# Autoconf.
-for ac_file in $ac_files ''
-do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
-	;;
-    [ab].out )
-	# We found the default executable, but exeext='' is most
-	# certainly right.
-	break;;
-    *.* )
-	if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no;
-	then :; else
-	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	fi
-	# We set ac_cv_exeext here because the later test for it is not
-	# safe: cross compilers may not add the suffix if given an `-o'
-	# argument, so we may need to know it at that point already.
-	# Even if this section looks crufty: it has the advantage of
-	# actually working.
-	break;;
-    * )
-	break;;
-  esac
-done
-test "$ac_cv_exeext" = no && ac_cv_exeext=
-
-else $as_nop
-  ac_file=''
-fi
-if test -z "$ac_file"
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "C compiler cannot create executables
-See \`config.log' for more details" "$LINENO" 5; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-printf %s "checking for C compiler default output file name... " >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-printf "%s\n" "$ac_file" >&6; }
-ac_exeext=$ac_cv_exeext
-
-rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
-ac_clean_files=$ac_clean_files_save
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-printf %s "checking for suffix of executables... " >&6; }
-if { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-then :
-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
-# work properly (i.e., refer to `conftest.exe'), while it won't with
-# `rm'.
-for ac_file in conftest.exe conftest conftest.*; do
-  test -f "$ac_file" || continue
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
-    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
-	  break;;
-    * ) break;;
-  esac
-done
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of executables: cannot compile and link
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest conftest$ac_cv_exeext
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-printf "%s\n" "$ac_cv_exeext" >&6; }
-
-rm -f conftest.$ac_ext
-EXEEXT=$ac_cv_exeext
-ac_exeext=$EXEEXT
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdio.h>
-int
-main (void)
-{
-FILE *f = fopen ("conftest.out", "w");
- return ferror (f) || fclose (f) != 0;
-
-  ;
-  return 0;
-}
-_ACEOF
-ac_clean_files="$ac_clean_files conftest.out"
-# Check that the compiler produces executables we can run.  If not, either
-# the compiler is broken, or we cross compile.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-printf %s "checking whether we are cross compiling... " >&6; }
-if test "$cross_compiling" != yes; then
-  { { ac_try="$ac_link"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_link") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-  if { ac_try='./conftest$ac_cv_exeext'
-  { { case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_try") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; }; then
-    cross_compiling=no
-  else
-    if test "$cross_compiling" = maybe; then
-	cross_compiling=yes
-    else
-	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error 77 "cannot run C compiled programs.
-If you meant to cross compile, use \`--host'.
-See \`config.log' for more details" "$LINENO" 5; }
-    fi
-  fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-printf "%s\n" "$cross_compiling" >&6; }
-
-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-ac_clean_files=$ac_clean_files_save
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-printf %s "checking for suffix of object files... " >&6; }
-if test ${ac_cv_objext+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-rm -f conftest.o conftest.obj
-if { { ac_try="$ac_compile"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compile") 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-then :
-  for ac_file in conftest.o conftest.obj conftest.*; do
-  test -f "$ac_file" || continue;
-  case $ac_file in
-    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
-    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
-       break;;
-  esac
-done
-else $as_nop
-  printf "%s\n" "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot compute suffix of object files: cannot compile
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-rm -f conftest.$ac_cv_objext conftest.$ac_ext
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-printf "%s\n" "$ac_cv_objext" >&6; }
-OBJEXT=$ac_cv_objext
-ac_objext=$OBJEXT
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
-printf %s "checking whether the compiler supports GNU C... " >&6; }
-if test ${ac_cv_c_compiler_gnu+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+y}
-ac_save_CFLAGS=$CFLAGS
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-printf %s "checking whether $CC accepts -g... " >&6; }
-if test ${ac_cv_prog_cc_g+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_g=yes
-else $as_nop
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-else $as_nop
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
-if test $ac_test_CFLAGS; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-ac_prog_cc_stdc=no
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
-printf %s "checking for $CC option to enable C11 features... " >&6; }
-if test ${ac_cv_prog_cc_c11+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c11=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c11_program
-_ACEOF
-for ac_arg in '' -std=gnu11
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c11=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c11" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c11" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c11" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
-printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
-     CC="$CC $ac_cv_prog_cc_c11"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
-  ac_prog_cc_stdc=c11
-fi
-fi
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
-printf %s "checking for $CC option to enable C99 features... " >&6; }
-if test ${ac_cv_prog_cc_c99+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c99=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c99_program
-_ACEOF
-for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c99=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c99" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c99" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c99" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
-printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
-     CC="$CC $ac_cv_prog_cc_c99"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-  ac_prog_cc_stdc=c99
-fi
-fi
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
-printf %s "checking for $CC option to enable C89 features... " >&6; }
-if test ${ac_cv_prog_cc_c89+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c89_program
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c89" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c89" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
-     CC="$CC $ac_cv_prog_cc_c89"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-  ac_prog_cc_stdc=c89
-fi
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-  ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
-printf %s "checking whether $CC understands -c and -o together... " >&6; }
-if test ${am_cv_prog_cc_c_o+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-  # Make sure it works both with $CC and with simple cc.
-  # Following AC_PROG_CC_C_O, we do the test twice because some
-  # compilers refuse to overwrite an existing .o file with -o,
-  # though they will create one.
-  am_cv_prog_cc_c_o=yes
-  for am_i in 1 2; do
-    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
-   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
-   ac_status=$?
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   (exit $ac_status); } \
-         && test -f conftest2.$ac_objext; then
-      : OK
-    else
-      am_cv_prog_cc_c_o=no
-      break
-    fi
-  done
-  rm -f core conftest*
-  unset am_i
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
-printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
-if test "$am_cv_prog_cc_c_o" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-depcc="$CC"   am_compiler_list=
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
-printf %s "checking dependency style of $depcc... " >&6; }
-if test ${am_cv_CC_dependencies_compiler_type+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named 'D' -- because '-MD' means "put the output
-  # in D".
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_CC_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
-  fi
-  am__universal=false
-  case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
-      # Solaris 10 /bin/sh.
-      echo '/* dummy */' > sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with '-c' and '-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle '-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs.
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # After this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested.
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok '-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_CC_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_CC_dependencies_compiler_type=none
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
-printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
-CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
-
- if
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
-  am__fastdepCC_TRUE=
-  am__fastdepCC_FALSE='#'
-else
-  am__fastdepCC_TRUE='#'
-  am__fastdepCC_FALSE=
-fi
-
-
-
-ac_header= ac_cache=
-for ac_item in $ac_header_c_list
-do
-  if test $ac_cache; then
-    ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
-    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
-      printf "%s\n" "#define $ac_item 1" >> confdefs.h
-    fi
-    ac_header= ac_cache=
-  elif test $ac_header; then
-    ac_cache=$ac_item
-  else
-    ac_header=$ac_item
-  fi
-done
-
-
-
-
-
-
-
-
-if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
-then :
-
-printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
-
-fi
-ac_fn_c_check_type "$LINENO" "long long" "ac_cv_type_long_long" "$ac_includes_default"
-if test "x$ac_cv_type_long_long" = xyes
-then :
-
-printf "%s\n" "#define HAVE_LONGLONG 1" >>confdefs.h
-
-   longlong="yes"
-
-fi
-
-
-
-    #
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is already defined" >&5
-printf %s "checking if _REENTRANT is already defined... " >&6; }
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-
-
-int
-main (void)
-{
-
-#ifdef _REENTRANT
-      int dummy=1;
-#else
-      force compilation error
-#endif
-
-  ;
-  return 0;
-}
-
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-    tmp_reentrant_initially_defined="yes"
-
-else $as_nop
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-    tmp_reentrant_initially_defined="no"
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  #
-  if test "$tmp_reentrant_initially_defined" = "no"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is actually needed" >&5
-printf %s "checking if _REENTRANT is actually needed... " >&6; }
-
-  case $host in
-    *-*-solaris* | *-*-hpux*)
-      tmp_need_reentrant="yes"
-      ;;
-    *)
-      tmp_need_reentrant="no"
-      ;;
-  esac
-
-
-    if test "$tmp_need_reentrant" = "yes"; then
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-    fi
-  fi
-  #
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _REENTRANT is onwards defined" >&5
-printf %s "checking if _REENTRANT is onwards defined... " >&6; }
-  if test "$tmp_reentrant_initially_defined" = "yes" ||
-    test "$tmp_need_reentrant" = "yes"; then
-
-
-printf "%s\n" "#define NEED_REENTRANT 1" >>confdefs.h
-
-cat >>confdefs.h <<_EOF
-#ifndef _REENTRANT
-#  define _REENTRANT
-#endif
-_EOF
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-  else
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-  fi
-  #
-
-
-# Some systems (Solaris?) have socket() in -lsocket.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
-printf %s "checking for library containing socket... " >&6; }
-if test ${ac_cv_search_socket+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_func_search_save_LIBS=$LIBS
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char socket ();
-int
-main (void)
-{
-return socket ();
-  ;
-  return 0;
-}
-_ACEOF
-for ac_lib in '' socket
-do
-  if test -z "$ac_lib"; then
-    ac_res="none required"
-  else
-    ac_res=-l$ac_lib
-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
-  fi
-  if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_search_socket=$ac_res
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext
-  if test ${ac_cv_search_socket+y}
-then :
-  break
-fi
-done
-if test ${ac_cv_search_socket+y}
-then :
-
-else $as_nop
-  ac_cv_search_socket=no
-fi
-rm conftest.$ac_ext
-LIBS=$ac_func_search_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
-printf "%s\n" "$ac_cv_search_socket" >&6; }
-ac_res=$ac_cv_search_socket
-if test "$ac_res" != no
-then :
-  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
-
-fi
-
-
-# Solaris has inet_addr() in -lnsl.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing inet_addr" >&5
-printf %s "checking for library containing inet_addr... " >&6; }
-if test ${ac_cv_search_inet_addr+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_func_search_save_LIBS=$LIBS
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char inet_addr ();
-int
-main (void)
-{
-return inet_addr ();
-  ;
-  return 0;
-}
-_ACEOF
-for ac_lib in '' nsl
-do
-  if test -z "$ac_lib"; then
-    ac_res="none required"
-  else
-    ac_res=-l$ac_lib
-    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
-  fi
-  if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_search_inet_addr=$ac_res
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext
-  if test ${ac_cv_search_inet_addr+y}
-then :
-  break
-fi
-done
-if test ${ac_cv_search_inet_addr+y}
-then :
-
-else $as_nop
-  ac_cv_search_inet_addr=no
-fi
-rm conftest.$ac_ext
-LIBS=$ac_func_search_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_inet_addr" >&5
-printf "%s\n" "$ac_cv_search_inet_addr" >&6; }
-ac_res=$ac_cv_search_inet_addr
-if test "$ac_res" != no
-then :
-  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
-
-fi
-
-
-
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}gcc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "gcc", so it can be a program name with args.
-set dummy gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="gcc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-if test -z "$CC"; then
-          if test -n "$ac_tool_prefix"; then
-    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
-set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}cc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  fi
-fi
-if test -z "$CC"; then
-  # Extract the first word of "cc", so it can be a program name with args.
-set dummy cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-  ac_prog_rejected=no
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
-       ac_prog_rejected=yes
-       continue
-     fi
-    ac_cv_prog_CC="cc"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-if test $ac_prog_rejected = yes; then
-  # We found a bogon in the path, so make sure we never use it.
-  set dummy $ac_cv_prog_CC
-  shift
-  if test $# != 0; then
-    # We chose a different compiler from the bogus one.
-    # However, it has the same basename, so the bogon will be chosen
-    # first if we set CC to just the basename; use the full file name.
-    shift
-    ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
-  fi
-fi
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  for ac_prog in cl.exe
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-    test -n "$CC" && break
-  done
-fi
-if test -z "$CC"; then
-  ac_ct_CC=$CC
-  for ac_prog in cl.exe
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CC" && break
-done
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-fi
-
-fi
-if test -z "$CC"; then
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
-set dummy ${ac_tool_prefix}clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CC"; then
-  ac_cv_prog_CC="$CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CC="${ac_tool_prefix}clang"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CC=$ac_cv_prog_CC
-if test -n "$CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_CC"; then
-  ac_ct_CC=$CC
-  # Extract the first word of "clang", so it can be a program name with args.
-set dummy clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CC"; then
-  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CC="clang"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CC=$ac_cv_prog_ac_ct_CC
-if test -n "$ac_ct_CC"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_CC" = x; then
-    CC=""
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CC=$ac_ct_CC
-  fi
-else
-  CC="$ac_cv_prog_CC"
-fi
-
-fi
-
-
-test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "no acceptable C compiler found in \$PATH
-See \`config.log' for more details" "$LINENO" 5; }
-
-# Provide some information about the compiler.
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion -version; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
-printf %s "checking whether the compiler supports GNU C... " >&6; }
-if test ${ac_cv_c_compiler_gnu+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-ac_cv_c_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-ac_test_CFLAGS=${CFLAGS+y}
-ac_save_CFLAGS=$CFLAGS
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-printf %s "checking whether $CC accepts -g... " >&6; }
-if test ${ac_cv_prog_cc_g+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_g=yes
-else $as_nop
-  CFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-else $as_nop
-  ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_c_werror_flag=$ac_save_c_werror_flag
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
-if test $ac_test_CFLAGS; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O2"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O2"
-  else
-    CFLAGS=
-  fi
-fi
-ac_prog_cc_stdc=no
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
-printf %s "checking for $CC option to enable C11 features... " >&6; }
-if test ${ac_cv_prog_cc_c11+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c11=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c11_program
-_ACEOF
-for ac_arg in '' -std=gnu11
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c11=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c11" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c11" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c11" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
-printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
-     CC="$CC $ac_cv_prog_cc_c11"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
-  ac_prog_cc_stdc=c11
-fi
-fi
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
-printf %s "checking for $CC option to enable C99 features... " >&6; }
-if test ${ac_cv_prog_cc_c99+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c99=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c99_program
-_ACEOF
-for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c99=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c99" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c99" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c99" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
-printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
-     CC="$CC $ac_cv_prog_cc_c99"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-  ac_prog_cc_stdc=c99
-fi
-fi
-if test x$ac_prog_cc_stdc = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
-printf %s "checking for $CC option to enable C89 features... " >&6; }
-if test ${ac_cv_prog_cc_c89+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cc_c89=no
-ac_save_CC=$CC
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_c_conftest_c89_program
-_ACEOF
-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-do
-  CC="$ac_save_CC $ac_arg"
-  if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_prog_cc_c89=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cc_c89" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-fi
-
-if test "x$ac_cv_prog_cc_c89" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cc_c89" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
-     CC="$CC $ac_cv_prog_cc_c89"
-fi
-  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-  ac_prog_cc_stdc=c89
-fi
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-  ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
-printf %s "checking whether $CC understands -c and -o together... " >&6; }
-if test ${am_cv_prog_cc_c_o+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-  # Make sure it works both with $CC and with simple cc.
-  # Following AC_PROG_CC_C_O, we do the test twice because some
-  # compilers refuse to overwrite an existing .o file with -o,
-  # though they will create one.
-  am_cv_prog_cc_c_o=yes
-  for am_i in 1 2; do
-    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
-   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
-   ac_status=$?
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   (exit $ac_status); } \
-         && test -f conftest2.$ac_objext; then
-      : OK
-    else
-      am_cv_prog_cc_c_o=no
-      break
-    fi
-  done
-  rm -f core conftest*
-  unset am_i
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
-printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
-if test "$am_cv_prog_cc_c_o" != yes; then
-   # Losing compiler, so override with the script.
-   # FIXME: It is wrong to rewrite CC.
-   # But if we don't then we get into trouble of one sort or another.
-   # A longer-term fix would be to have automake use am__CC in this case,
-   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
-   CC="$am_aux_dir/compile $CC"
-fi
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-depcc="$CC"   am_compiler_list=
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
-printf %s "checking dependency style of $depcc... " >&6; }
-if test ${am_cv_CC_dependencies_compiler_type+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named 'D' -- because '-MD' means "put the output
-  # in D".
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_CC_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
-  fi
-  am__universal=false
-  case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
-      # Solaris 10 /bin/sh.
-      echo '/* dummy */' > sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with '-c' and '-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle '-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs.
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # After this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested.
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok '-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_CC_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_CC_dependencies_compiler_type=none
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
-printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
-CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
-
- if
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
-  am__fastdepCC_TRUE=
-  am__fastdepCC_FALSE='#'
-else
-  am__fastdepCC_TRUE='#'
-  am__fastdepCC_FALSE=
-fi
-
-
-
-
-
-
-
-
-ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-if test -z "$CXX"; then
-  if test -n "$CCC"; then
-    CXX=$CCC
-  else
-    if test -n "$ac_tool_prefix"; then
-  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$CXX"; then
-  ac_cv_prog_CXX="$CXX" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-CXX=$ac_cv_prog_CXX
-if test -n "$CXX"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
-printf "%s\n" "$CXX" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-    test -n "$CXX" && break
-  done
-fi
-if test -z "$CXX"; then
-  ac_ct_CXX=$CXX
-  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC clang++
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_CXX"; then
-  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_CXX="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
-if test -n "$ac_ct_CXX"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
-printf "%s\n" "$ac_ct_CXX" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_CXX" && break
-done
-
-  if test "x$ac_ct_CXX" = x; then
-    CXX="g++"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    CXX=$ac_ct_CXX
-  fi
-fi
-
-  fi
-fi
-# Provide some information about the compiler.
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
-set X $ac_compile
-ac_compiler=$2
-for ac_option in --version -v -V -qversion; do
-  { { ac_try="$ac_compiler $ac_option >&5"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
-  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    sed '10a\
-... rest of stderr output deleted ...
-         10q' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-  fi
-  rm -f conftest.er1 conftest.err
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-done
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5
-printf %s "checking whether the compiler supports GNU C++... " >&6; }
-if test ${ac_cv_cxx_compiler_gnu+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-#ifndef __GNUC__
-       choke me
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"
-then :
-  ac_compiler_gnu=yes
-else $as_nop
-  ac_compiler_gnu=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
-printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; }
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-
-if test $ac_compiler_gnu = yes; then
-  GXX=yes
-else
-  GXX=
-fi
-ac_test_CXXFLAGS=${CXXFLAGS+y}
-ac_save_CXXFLAGS=$CXXFLAGS
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
-printf %s "checking whether $CXX accepts -g... " >&6; }
-if test ${ac_cv_prog_cxx_g+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
-   ac_cxx_werror_flag=yes
-   ac_cv_prog_cxx_g=no
-   CXXFLAGS="-g"
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"
-then :
-  ac_cv_prog_cxx_g=yes
-else $as_nop
-  CXXFLAGS=""
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"
-then :
-
-else $as_nop
-  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
-	 CXXFLAGS="-g"
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"
-then :
-  ac_cv_prog_cxx_g=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
-printf "%s\n" "$ac_cv_prog_cxx_g" >&6; }
-if test $ac_test_CXXFLAGS; then
-  CXXFLAGS=$ac_save_CXXFLAGS
-elif test $ac_cv_prog_cxx_g = yes; then
-  if test "$GXX" = yes; then
-    CXXFLAGS="-g -O2"
-  else
-    CXXFLAGS="-g"
-  fi
-else
-  if test "$GXX" = yes; then
-    CXXFLAGS="-O2"
-  else
-    CXXFLAGS=
-  fi
-fi
-ac_prog_cxx_stdcxx=no
-if test x$ac_prog_cxx_stdcxx = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5
-printf %s "checking for $CXX option to enable C++11 features... " >&6; }
-if test ${ac_cv_prog_cxx_11+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cxx_11=no
-ac_save_CXX=$CXX
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_cxx_conftest_cxx11_program
-_ACEOF
-for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA
-do
-  CXX="$ac_save_CXX $ac_arg"
-  if ac_fn_cxx_try_compile "$LINENO"
-then :
-  ac_cv_prog_cxx_cxx11=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cxx_cxx11" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CXX=$ac_save_CXX
-fi
-
-if test "x$ac_cv_prog_cxx_cxx11" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cxx_cxx11" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
-printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; }
-     CXX="$CXX $ac_cv_prog_cxx_cxx11"
-fi
-  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
-  ac_prog_cxx_stdcxx=cxx11
-fi
-fi
-if test x$ac_prog_cxx_stdcxx = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5
-printf %s "checking for $CXX option to enable C++98 features... " >&6; }
-if test ${ac_cv_prog_cxx_98+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_prog_cxx_98=no
-ac_save_CXX=$CXX
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_cxx_conftest_cxx98_program
-_ACEOF
-for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA
-do
-  CXX="$ac_save_CXX $ac_arg"
-  if ac_fn_cxx_try_compile "$LINENO"
-then :
-  ac_cv_prog_cxx_cxx98=$ac_arg
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-  test "x$ac_cv_prog_cxx_cxx98" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CXX=$ac_save_CXX
-fi
-
-if test "x$ac_cv_prog_cxx_cxx98" = xno
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
-else $as_nop
-  if test "x$ac_cv_prog_cxx_cxx98" = x
-then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
-printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; }
-     CXX="$CXX $ac_cv_prog_cxx_cxx98"
-fi
-  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98
-  ac_prog_cxx_stdcxx=cxx98
-fi
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-depcc="$CXX"  am_compiler_list=
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
-printf %s "checking dependency style of $depcc... " >&6; }
-if test ${am_cv_CXX_dependencies_compiler_type+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
-  # We make a subdir and do the tests there.  Otherwise we can end up
-  # making bogus files that we don't know about and never remove.  For
-  # instance it was reported that on HP-UX the gcc test will end up
-  # making a dummy file named 'D' -- because '-MD' means "put the output
-  # in D".
-  rm -rf conftest.dir
-  mkdir conftest.dir
-  # Copy depcomp to subdir because otherwise we won't find it if we're
-  # using a relative directory.
-  cp "$am_depcomp" conftest.dir
-  cd conftest.dir
-  # We will build objects and dependencies in a subdirectory because
-  # it helps to detect inapplicable dependency modes.  For instance
-  # both Tru64's cc and ICC support -MD to output dependencies as a
-  # side effect of compilation, but ICC will put the dependencies in
-  # the current directory while Tru64 will put them in the object
-  # directory.
-  mkdir sub
-
-  am_cv_CXX_dependencies_compiler_type=none
-  if test "$am_compiler_list" = ""; then
-     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
-  fi
-  am__universal=false
-  case " $depcc " in #(
-     *\ -arch\ *\ -arch\ *) am__universal=true ;;
-     esac
-
-  for depmode in $am_compiler_list; do
-    # Setup a source with many dependencies, because some compilers
-    # like to wrap large dependency lists on column 80 (with \), and
-    # we should not choose a depcomp mode which is confused by this.
-    #
-    # We need to recreate these files for each test, as the compiler may
-    # overwrite some of them when testing with obscure command lines.
-    # This happens at least with the AIX C compiler.
-    : > sub/conftest.c
-    for i in 1 2 3 4 5 6; do
-      echo '#include "conftst'$i'.h"' >> sub/conftest.c
-      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
-      # Solaris 10 /bin/sh.
-      echo '/* dummy */' > sub/conftst$i.h
-    done
-    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
-
-    # We check with '-c' and '-o' for the sake of the "dashmstdout"
-    # mode.  It turns out that the SunPro C++ compiler does not properly
-    # handle '-M -o', and we need to detect this.  Also, some Intel
-    # versions had trouble with output in subdirs.
-    am__obj=sub/conftest.${OBJEXT-o}
-    am__minus_obj="-o $am__obj"
-    case $depmode in
-    gcc)
-      # This depmode causes a compiler race in universal mode.
-      test "$am__universal" = false || continue
-      ;;
-    nosideeffect)
-      # After this tag, mechanisms are not by side-effect, so they'll
-      # only be used when explicitly requested.
-      if test "x$enable_dependency_tracking" = xyes; then
-	continue
-      else
-	break
-      fi
-      ;;
-    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
-      # This compiler won't grok '-c -o', but also, the minuso test has
-      # not run yet.  These depmodes are late enough in the game, and
-      # so weak that their functioning should not be impacted.
-      am__obj=conftest.${OBJEXT-o}
-      am__minus_obj=
-      ;;
-    none) break ;;
-    esac
-    if depmode=$depmode \
-       source=sub/conftest.c object=$am__obj \
-       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
-       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
-         >/dev/null 2>conftest.err &&
-       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
-       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
-       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
-      # icc doesn't choke on unknown options, it will just issue warnings
-      # or remarks (even with -Werror).  So we grep stderr for any message
-      # that says an option was ignored or not supported.
-      # When given -MP, icc 7.0 and 7.1 complain thusly:
-      #   icc: Command line warning: ignoring option '-M'; no argument required
-      # The diagnosis changed in icc 8.0:
-      #   icc: Command line remark: option '-MP' not supported
-      if (grep 'ignoring option' conftest.err ||
-          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
-        am_cv_CXX_dependencies_compiler_type=$depmode
-        break
-      fi
-    fi
-  done
-
-  cd ..
-  rm -rf conftest.dir
-else
-  am_cv_CXX_dependencies_compiler_type=none
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
-printf "%s\n" "$am_cv_CXX_dependencies_compiler_type" >&6; }
-CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
-
- if
-  test "x$enable_dependency_tracking" != xno \
-  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
-  am__fastdepCXX_TRUE=
-  am__fastdepCXX_FALSE='#'
-else
-  am__fastdepCXX_TRUE='#'
-  am__fastdepCXX_FALSE=
-fi
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
-printf %s "checking whether ln -s works... " >&6; }
-LN_S=$as_ln_s
-if test "$LN_S" = "ln -s"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
-printf "%s\n" "no, using $LN_S" >&6; }
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
-printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
-set x ${MAKE-make}
-ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
-if eval test \${ac_cv_prog_make_${ac_make}_set+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat >conftest.make <<\_ACEOF
-SHELL = /bin/sh
-all:
-	@echo '@@@%%%=$(MAKE)=@@@%%%'
-_ACEOF
-# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
-case `${MAKE-make} -f conftest.make 2>/dev/null` in
-  *@@@%%%=?*=@@@%%%*)
-    eval ac_cv_prog_make_${ac_make}_set=yes;;
-  *)
-    eval ac_cv_prog_make_${ac_make}_set=no;;
-esac
-rm -f conftest.make
-fi
-if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-  SET_MAKE=
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-  SET_MAKE="MAKE=${MAKE-make}"
-fi
-
-for ac_prog in sshd
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_path_SSHD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  case $SSHD in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_SSHD="$SSHD" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/libexec$PATH_SEPARATOR     /usr/sbin$PATH_SEPARATOR/usr/etc$PATH_SEPARATOR/etc
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_path_SSHD="$as_dir$ac_word$ac_exec_ext"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-  ;;
-esac
-fi
-SSHD=$ac_cv_path_SSHD
-if test -n "$SSHD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SSHD" >&5
-printf "%s\n" "$SSHD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$SSHD" && break
-done
-
- if test -n "$SSHD"; then
-  SSHD_TRUE=
-  SSHD_FALSE='#'
-else
-  SSHD_TRUE='#'
-  SSHD_FALSE=
-fi
-
-enable_win32_dll=yes
-
-case $host in
-*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
-set dummy ${ac_tool_prefix}as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_AS+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AS"; then
-  ac_cv_prog_AS="$AS" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AS="${ac_tool_prefix}as"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-AS=$ac_cv_prog_AS
-if test -n "$AS"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-printf "%s\n" "$AS" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_AS"; then
-  ac_ct_AS=$AS
-  # Extract the first word of "as", so it can be a program name with args.
-set dummy as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_AS+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_AS"; then
-  ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_AS="as"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_AS=$ac_cv_prog_ac_ct_AS
-if test -n "$ac_ct_AS"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
-printf "%s\n" "$ac_ct_AS" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_AS" = x; then
-    AS="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    AS=$ac_ct_AS
-  fi
-else
-  AS="$ac_cv_prog_AS"
-fi
-
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
-set dummy ${ac_tool_prefix}dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DLLTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DLLTOOL"; then
-  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-DLLTOOL=$ac_cv_prog_DLLTOOL
-if test -n "$DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
-printf "%s\n" "$DLLTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_DLLTOOL"; then
-  ac_ct_DLLTOOL=$DLLTOOL
-  # Extract the first word of "dlltool", so it can be a program name with args.
-set dummy dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DLLTOOL"; then
-  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
-if test -n "$ac_ct_DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
-printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_DLLTOOL" = x; then
-    DLLTOOL="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    DLLTOOL=$ac_ct_DLLTOOL
-  fi
-else
-  DLLTOOL="$ac_cv_prog_DLLTOOL"
-fi
-
-  if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
-set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OBJDUMP"; then
-  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-OBJDUMP=$ac_cv_prog_OBJDUMP
-if test -n "$OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_OBJDUMP"; then
-  ac_ct_OBJDUMP=$OBJDUMP
-  # Extract the first word of "objdump", so it can be a program name with args.
-set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OBJDUMP"; then
-  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OBJDUMP="objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
-if test -n "$ac_ct_OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OBJDUMP" = x; then
-    OBJDUMP="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    OBJDUMP=$ac_ct_OBJDUMP
-  fi
-else
-  OBJDUMP="$ac_cv_prog_OBJDUMP"
-fi
-
-  ;;
-esac
-
-test -z "$AS" && AS=as
-
-
-
-
-
-test -z "$DLLTOOL" && DLLTOOL=dlltool
-
-
-
-
-
-test -z "$OBJDUMP" && OBJDUMP=objdump
-
-
-
-
-
-
-
-case `pwd` in
-  *\ * | *\	*)
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
-printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
-esac
-
-
-
-macro_version='2.4.6'
-macro_revision='2.4.6'
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-ltmain=$ac_aux_dir/ltmain.sh
-
-# Backslashify metacharacters that are still active within
-# double-quoted strings.
-sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
-
-# Same as above, but do not quote variable references.
-double_quote_subst='s/\(["`\\]\)/\\\1/g'
-
-# Sed substitution to delay expansion of an escaped shell variable in a
-# double_quote_subst'ed string.
-delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
-
-# Sed substitution to delay expansion of an escaped single quote.
-delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
-
-# Sed substitution to avoid accidental globbing in evaled expressions
-no_glob_subst='s/\*/\\\*/g'
-
-ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
-printf %s "checking how to print strings... " >&6; }
-# Test print first, because it will be a builtin if present.
-if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
-   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='print -r --'
-elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='printf %s\n'
-else
-  # Use this function as a fallback that always works.
-  func_fallback_echo ()
-  {
-    eval 'cat <<_LTECHO_EOF
-$1
-_LTECHO_EOF'
-  }
-  ECHO='func_fallback_echo'
-fi
-
-# func_echo_all arg...
-# Invoke $ECHO with all args, space-separated.
-func_echo_all ()
-{
-    $ECHO ""
-}
-
-case $ECHO in
-  printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5
-printf "%s\n" "printf" >&6; } ;;
-  print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
-printf "%s\n" "print -r" >&6; } ;;
-  *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5
-printf "%s\n" "cat" >&6; } ;;
-esac
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
-printf %s "checking for a sed that does not truncate output... " >&6; }
-if test ${ac_cv_path_SED+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-     for ac_i in 1 2 3 4 5 6 7; do
-       ac_script="$ac_script$as_nl$ac_script"
-     done
-     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
-     { ac_script=; unset ac_script;}
-     if test -z "$SED"; then
-  ac_path_SED_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in sed gsed
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_SED" || continue
-# Check for GNU ac_path_SED and select it if it is found.
-  # Check for GNU $ac_path_SED
-case `"$ac_path_SED" --version 2>&1` in
-*GNU*)
-  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" '' >> "conftest.nl"
-    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_SED_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_SED="$ac_path_SED"
-      ac_path_SED_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_SED_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_SED"; then
-    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
-  fi
-else
-  ac_cv_path_SED=$SED
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-printf "%s\n" "$ac_cv_path_SED" >&6; }
- SED="$ac_cv_path_SED"
-  rm -f conftest.sed
-
-test -z "$SED" && SED=sed
-Xsed="$SED -e 1s/^X//"
-
-
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-printf %s "checking for grep that handles long lines and -e... " >&6; }
-if test ${ac_cv_path_GREP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$GREP"; then
-  ac_path_GREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in grep ggrep
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_GREP" || continue
-# Check for GNU ac_path_GREP and select it if it is found.
-  # Check for GNU $ac_path_GREP
-case `"$ac_path_GREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'GREP' >> "conftest.nl"
-    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_GREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_GREP="$ac_path_GREP"
-      ac_path_GREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_GREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_GREP"; then
-    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_GREP=$GREP
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-printf "%s\n" "$ac_cv_path_GREP" >&6; }
- GREP="$ac_cv_path_GREP"
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
-printf %s "checking for egrep... " >&6; }
-if test ${ac_cv_path_EGREP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-   then ac_cv_path_EGREP="$GREP -E"
-   else
-     if test -z "$EGREP"; then
-  ac_path_EGREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in egrep
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_EGREP" || continue
-# Check for GNU ac_path_EGREP and select it if it is found.
-  # Check for GNU $ac_path_EGREP
-case `"$ac_path_EGREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'EGREP' >> "conftest.nl"
-    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_EGREP="$ac_path_EGREP"
-      ac_path_EGREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_EGREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_EGREP"; then
-    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_EGREP=$EGREP
-fi
-
-   fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
-printf "%s\n" "$ac_cv_path_EGREP" >&6; }
- EGREP="$ac_cv_path_EGREP"
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
-printf %s "checking for fgrep... " >&6; }
-if test ${ac_cv_path_FGREP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-   then ac_cv_path_FGREP="$GREP -F"
-   else
-     if test -z "$FGREP"; then
-  ac_path_FGREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in fgrep
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_FGREP" || continue
-# Check for GNU ac_path_FGREP and select it if it is found.
-  # Check for GNU $ac_path_FGREP
-case `"$ac_path_FGREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
-*)
-  ac_count=0
-  printf %s 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    printf "%s\n" 'FGREP' >> "conftest.nl"
-    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_FGREP="$ac_path_FGREP"
-      ac_path_FGREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_FGREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_FGREP"; then
-    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_FGREP=$FGREP
-fi
-
-   fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
-printf "%s\n" "$ac_cv_path_FGREP" >&6; }
- FGREP="$ac_cv_path_FGREP"
-
-
-test -z "$GREP" && GREP=grep
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# Check whether --with-gnu-ld was given.
-if test ${with_gnu_ld+y}
-then :
-  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
-fi
-
-ac_prog=ld
-if test yes = "$GCC"; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
-printf %s "checking for ld used by $CC... " >&6; }
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return, which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [\\/]* | ?:[\\/]*)
-      re_direlt='/[^/][^/]*/\.\./'
-      # Canonicalize the pathname of ld
-      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
-      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD=$ac_prog
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test yes = "$with_gnu_ld"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
-printf %s "checking for GNU ld... " >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
-printf %s "checking for non-GNU ld... " >&6; }
-fi
-if test ${lt_cv_path_LD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  for ac_dir in $PATH; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD=$ac_dir/$ac_prog
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some variants of GNU ld only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
-      *GNU* | *'with BFD'*)
-	test no != "$with_gnu_ld" && break
-	;;
-      *)
-	test yes != "$with_gnu_ld" && break
-	;;
-      esac
-    fi
-  done
-  IFS=$lt_save_ifs
-else
-  lt_cv_path_LD=$LD # Let the user override the test with a path.
-fi
-fi
-
-LD=$lt_cv_path_LD
-if test -n "$LD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
-printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
-if test ${lt_cv_prog_gnu_ld+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU lds only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  lt_cv_prog_gnu_ld=yes
-  ;;
-*)
-  lt_cv_prog_gnu_ld=no
-  ;;
-esac
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
-printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
-with_gnu_ld=$lt_cv_prog_gnu_ld
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
-printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
-if test ${lt_cv_path_NM+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$NM"; then
-  # Let the user override the test.
-  lt_cv_path_NM=$NM
-else
-  lt_nm_to_check=${ac_tool_prefix}nm
-  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
-    lt_nm_to_check="$lt_nm_to_check nm"
-  fi
-  for lt_tmp_nm in $lt_nm_to_check; do
-    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
-      IFS=$lt_save_ifs
-      test -z "$ac_dir" && ac_dir=.
-      tmp_nm=$ac_dir/$lt_tmp_nm
-      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
-	# Check to see if the nm accepts a BSD-compat flag.
-	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
-	#   nm: unknown option "B" ignored
-	# Tru64's nm complains that /dev/null is an invalid object file
-	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
-	case $build_os in
-	mingw*) lt_bad_file=conftest.nm/nofile ;;
-	*) lt_bad_file=/dev/null ;;
-	esac
-	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
-	*$lt_bad_file* | *'Invalid file or object type'*)
-	  lt_cv_path_NM="$tmp_nm -B"
-	  break 2
-	  ;;
-	*)
-	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
-	  */dev/null*)
-	    lt_cv_path_NM="$tmp_nm -p"
-	    break 2
-	    ;;
-	  *)
-	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
-	    continue # so that we can try to find one that supports BSD flags
-	    ;;
-	  esac
-	  ;;
-	esac
-      fi
-    done
-    IFS=$lt_save_ifs
-  done
-  : ${lt_cv_path_NM=no}
-fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
-printf "%s\n" "$lt_cv_path_NM" >&6; }
-if test no != "$lt_cv_path_NM"; then
-  NM=$lt_cv_path_NM
-else
-  # Didn't find any BSD compatible name lister, look for dumpbin.
-  if test -n "$DUMPBIN"; then :
-    # Let the user override the test.
-  else
-    if test -n "$ac_tool_prefix"; then
-  for ac_prog in dumpbin "link -dump"
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DUMPBIN+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DUMPBIN"; then
-  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-DUMPBIN=$ac_cv_prog_DUMPBIN
-if test -n "$DUMPBIN"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
-printf "%s\n" "$DUMPBIN" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-    test -n "$DUMPBIN" && break
-  done
-fi
-if test -z "$DUMPBIN"; then
-  ac_ct_DUMPBIN=$DUMPBIN
-  for ac_prog in dumpbin "link -dump"
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DUMPBIN+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DUMPBIN"; then
-  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
-if test -n "$ac_ct_DUMPBIN"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
-printf "%s\n" "$ac_ct_DUMPBIN" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_DUMPBIN" && break
-done
-
-  if test "x$ac_ct_DUMPBIN" = x; then
-    DUMPBIN=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    DUMPBIN=$ac_ct_DUMPBIN
-  fi
-fi
-
-    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
-    *COFF*)
-      DUMPBIN="$DUMPBIN -symbols -headers"
-      ;;
-    *)
-      DUMPBIN=:
-      ;;
-    esac
-  fi
-
-  if test : != "$DUMPBIN"; then
-    NM=$DUMPBIN
-  fi
-fi
-test -z "$NM" && NM=nm
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
-printf %s "checking the name lister ($NM) interface... " >&6; }
-if test ${lt_cv_nm_interface+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_nm_interface="BSD nm"
-  echo "int some_variable = 0;" > conftest.$ac_ext
-  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
-  (eval "$ac_compile" 2>conftest.err)
-  cat conftest.err >&5
-  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
-  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
-  cat conftest.err >&5
-  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
-  cat conftest.out >&5
-  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
-    lt_cv_nm_interface="MS dumpbin"
-  fi
-  rm -f conftest*
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
-printf "%s\n" "$lt_cv_nm_interface" >&6; }
-
-# find the maximum length of command line arguments
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
-printf %s "checking the maximum length of command line arguments... " >&6; }
-if test ${lt_cv_sys_max_cmd_len+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-    i=0
-  teststring=ABCD
-
-  case $build_os in
-  msdosdjgpp*)
-    # On DJGPP, this test can blow up pretty badly due to problems in libc
-    # (any single argument exceeding 2000 bytes causes a buffer overrun
-    # during glob expansion).  Even if it were fixed, the result of this
-    # check would be larger than it should be.
-    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
-    ;;
-
-  gnu*)
-    # Under GNU Hurd, this test is not required because there is
-    # no limit to the length of command line arguments.
-    # Libtool will interpret -1 as no limit whatsoever
-    lt_cv_sys_max_cmd_len=-1;
-    ;;
-
-  cygwin* | mingw* | cegcc*)
-    # On Win9x/ME, this test blows up -- it succeeds, but takes
-    # about 5 minutes as the teststring grows exponentially.
-    # Worse, since 9x/ME are not pre-emptively multitasking,
-    # you end up with a "frozen" computer, even though with patience
-    # the test eventually succeeds (with a max line length of 256k).
-    # Instead, let's just punt: use the minimum linelength reported by
-    # all of the supported platforms: 8192 (on NT/2K/XP).
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  mint*)
-    # On MiNT this can take a long time and run out of memory.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  amigaos*)
-    # On AmigaOS with pdksh, this test takes hours, literally.
-    # So we just punt and use a minimum line length of 8192.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
-    # This has been around since 386BSD, at least.  Likely further.
-    if test -x /sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
-    elif test -x /usr/sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
-    else
-      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
-    fi
-    # And add a safety zone
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    ;;
-
-  interix*)
-    # We know the value 262144 and hardcode it with a safety zone (like BSD)
-    lt_cv_sys_max_cmd_len=196608
-    ;;
-
-  os2*)
-    # The test takes a long time on OS/2.
-    lt_cv_sys_max_cmd_len=8192
-    ;;
-
-  osf*)
-    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
-    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
-    # nice to cause kernel panics so lets avoid the loop below.
-    # First set a reasonable default.
-    lt_cv_sys_max_cmd_len=16384
-    #
-    if test -x /sbin/sysconfig; then
-      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
-        *1*) lt_cv_sys_max_cmd_len=-1 ;;
-      esac
-    fi
-    ;;
-  sco3.2v5*)
-    lt_cv_sys_max_cmd_len=102400
-    ;;
-  sysv5* | sco5v6* | sysv4.2uw2*)
-    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
-    if test -n "$kargmax"; then
-      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
-    else
-      lt_cv_sys_max_cmd_len=32768
-    fi
-    ;;
-  *)
-    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
-    if test -n "$lt_cv_sys_max_cmd_len" && \
-       test undefined != "$lt_cv_sys_max_cmd_len"; then
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    else
-      # Make teststring a little bigger before we do anything with it.
-      # a 1K string should be a reasonable start.
-      for i in 1 2 3 4 5 6 7 8; do
-        teststring=$teststring$teststring
-      done
-      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
-      # If test is not a shell built-in, we'll probably end up computing a
-      # maximum length that is only half of the actual maximum length, but
-      # we can't tell.
-      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
-	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
-	      test 17 != "$i" # 1/2 MB should be enough
-      do
-        i=`expr $i + 1`
-        teststring=$teststring$teststring
-      done
-      # Only check the string length outside the loop.
-      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
-      teststring=
-      # Add a significant safety factor because C++ compilers can tack on
-      # massive amounts of additional arguments before passing them to the
-      # linker.  It appears as though 1/2 is a usable value.
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
-    fi
-    ;;
-  esac
-
-fi
-
-if test -n "$lt_cv_sys_max_cmd_len"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
-printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5
-printf "%s\n" "none" >&6; }
-fi
-max_cmd_len=$lt_cv_sys_max_cmd_len
-
-
-
-
-
-
-: ${CP="cp -f"}
-: ${MV="mv -f"}
-: ${RM="rm -f"}
-
-if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
-  lt_unset=unset
-else
-  lt_unset=false
-fi
-
-
-
-
-
-# test EBCDIC or ASCII
-case `echo X|tr X '\101'` in
- A) # ASCII based system
-    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
-  lt_SP2NL='tr \040 \012'
-  lt_NL2SP='tr \015\012 \040\040'
-  ;;
- *) # EBCDIC based system
-  lt_SP2NL='tr \100 \n'
-  lt_NL2SP='tr \r\n \100\100'
-  ;;
-esac
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
-printf %s "checking how to convert $build file names to $host format... " >&6; }
-if test ${lt_cv_to_host_file_cmd+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
-        ;;
-    esac
-    ;;
-  *-*-cygwin* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_noop
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
-        ;;
-    esac
-    ;;
-  * ) # unhandled hosts (and "normal" native builds)
-    lt_cv_to_host_file_cmd=func_convert_file_noop
-    ;;
-esac
-
-fi
-
-to_host_file_cmd=$lt_cv_to_host_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; }
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
-printf %s "checking how to convert $build file names to toolchain format... " >&6; }
-if test ${lt_cv_to_tool_file_cmd+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  #assume ordinary cross tools, or native build.
-lt_cv_to_tool_file_cmd=func_convert_file_noop
-case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
-        ;;
-    esac
-    ;;
-esac
-
-fi
-
-to_tool_file_cmd=$lt_cv_to_tool_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; }
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
-printf %s "checking for $LD option to reload object files... " >&6; }
-if test ${lt_cv_ld_reload_flag+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_reload_flag='-r'
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
-printf "%s\n" "$lt_cv_ld_reload_flag" >&6; }
-reload_flag=$lt_cv_ld_reload_flag
-case $reload_flag in
-"" | " "*) ;;
-*) reload_flag=" $reload_flag" ;;
-esac
-reload_cmds='$LD$reload_flag -o $output$reload_objs'
-case $host_os in
-  cygwin* | mingw* | pw32* | cegcc*)
-    if test yes != "$GCC"; then
-      reload_cmds=false
-    fi
-    ;;
-  darwin*)
-    if test yes = "$GCC"; then
-      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
-    else
-      reload_cmds='$LD$reload_flag -o $output$reload_objs'
-    fi
-    ;;
-esac
-
-
-
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
-set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OBJDUMP"; then
-  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-OBJDUMP=$ac_cv_prog_OBJDUMP
-if test -n "$OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_OBJDUMP"; then
-  ac_ct_OBJDUMP=$OBJDUMP
-  # Extract the first word of "objdump", so it can be a program name with args.
-set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OBJDUMP"; then
-  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OBJDUMP="objdump"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
-if test -n "$ac_ct_OBJDUMP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OBJDUMP" = x; then
-    OBJDUMP="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    OBJDUMP=$ac_ct_OBJDUMP
-  fi
-else
-  OBJDUMP="$ac_cv_prog_OBJDUMP"
-fi
-
-test -z "$OBJDUMP" && OBJDUMP=objdump
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
-printf %s "checking how to recognize dependent libraries... " >&6; }
-if test ${lt_cv_deplibs_check_method+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_file_magic_cmd='$MAGIC_CMD'
-lt_cv_file_magic_test_file=
-lt_cv_deplibs_check_method='unknown'
-# Need to set the preceding variable on all platforms that support
-# interlibrary dependencies.
-# 'none' -- dependencies not supported.
-# 'unknown' -- same as none, but documents that we really don't know.
-# 'pass_all' -- all dependencies passed with no checks.
-# 'test_compile' -- check by making test program.
-# 'file_magic [[regex]]' -- check by looking for files in library path
-# that responds to the $file_magic_cmd with a given extended regex.
-# If you have 'file' or equivalent on your system and you're not sure
-# whether 'pass_all' will *always* work, you probably want this one.
-
-case $host_os in
-aix[4-9]*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-beos*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-bsdi[45]*)
-  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
-  lt_cv_file_magic_cmd='/usr/bin/file -L'
-  lt_cv_file_magic_test_file=/shlib/libc.so
-  ;;
-
-cygwin*)
-  # func_win32_libid is a shell function defined in ltmain.sh
-  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
-  lt_cv_file_magic_cmd='func_win32_libid'
-  ;;
-
-mingw* | pw32*)
-  # Base MSYS/MinGW do not provide the 'file' command needed by
-  # func_win32_libid shell function, so use a weaker test based on 'objdump',
-  # unless we find 'file', for example because we are cross-compiling.
-  if ( file / ) >/dev/null 2>&1; then
-    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
-    lt_cv_file_magic_cmd='func_win32_libid'
-  else
-    # Keep this pattern in sync with the one in func_win32_libid.
-    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
-    lt_cv_file_magic_cmd='$OBJDUMP -f'
-  fi
-  ;;
-
-cegcc*)
-  # use the weaker test based on 'objdump'. See mingw*.
-  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
-  lt_cv_file_magic_cmd='$OBJDUMP -f'
-  ;;
-
-darwin* | rhapsody*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-freebsd* | dragonfly*)
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
-    case $host_cpu in
-    i*86 )
-      # Not sure whether the presence of OpenBSD here was a mistake.
-      # Let's accept both of them until this is cleared up.
-      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
-      lt_cv_file_magic_cmd=/usr/bin/file
-      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
-      ;;
-    esac
-  else
-    lt_cv_deplibs_check_method=pass_all
-  fi
-  ;;
-
-haiku*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-hpux10.20* | hpux11*)
-  lt_cv_file_magic_cmd=/usr/bin/file
-  case $host_cpu in
-  ia64*)
-    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
-    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
-    ;;
-  hppa*64*)
-    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
-    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
-    ;;
-  *)
-    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
-    lt_cv_file_magic_test_file=/usr/lib/libc.sl
-    ;;
-  esac
-  ;;
-
-interix[3-9]*)
-  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
-  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
-  ;;
-
-irix5* | irix6* | nonstopux*)
-  case $LD in
-  *-32|*"-32 ") libmagic=32-bit;;
-  *-n32|*"-n32 ") libmagic=N32;;
-  *-64|*"-64 ") libmagic=64-bit;;
-  *) libmagic=never-match;;
-  esac
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-netbsd* | netbsdelf*-gnu)
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
-    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
-  else
-    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
-  fi
-  ;;
-
-newos6*)
-  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
-  lt_cv_file_magic_cmd=/usr/bin/file
-  lt_cv_file_magic_test_file=/usr/lib/libnls.so
-  ;;
-
-*nto* | *qnx*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-openbsd* | bitrig*)
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
-  else
-    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
-  fi
-  ;;
-
-osf3* | osf4* | osf5*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-rdos*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-solaris*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-sysv4 | sysv4.3*)
-  case $host_vendor in
-  motorola)
-    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
-    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
-    ;;
-  ncr)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  sequent)
-    lt_cv_file_magic_cmd='/bin/file'
-    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
-    ;;
-  sni)
-    lt_cv_file_magic_cmd='/bin/file'
-    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
-    lt_cv_file_magic_test_file=/lib/libc.so
-    ;;
-  siemens)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  pc)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  esac
-  ;;
-
-tpf*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-os2*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-esac
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
-printf "%s\n" "$lt_cv_deplibs_check_method" >&6; }
-
-file_magic_glob=
-want_nocaseglob=no
-if test "$build" = "$host"; then
-  case $host_os in
-  mingw* | pw32*)
-    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
-      want_nocaseglob=yes
-    else
-      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
-    fi
-    ;;
-  esac
-fi
-
-file_magic_cmd=$lt_cv_file_magic_cmd
-deplibs_check_method=$lt_cv_deplibs_check_method
-test -z "$deplibs_check_method" && deplibs_check_method=unknown
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
-set dummy ${ac_tool_prefix}dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DLLTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DLLTOOL"; then
-  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-DLLTOOL=$ac_cv_prog_DLLTOOL
-if test -n "$DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
-printf "%s\n" "$DLLTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_DLLTOOL"; then
-  ac_ct_DLLTOOL=$DLLTOOL
-  # Extract the first word of "dlltool", so it can be a program name with args.
-set dummy dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DLLTOOL"; then
-  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
-if test -n "$ac_ct_DLLTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
-printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_DLLTOOL" = x; then
-    DLLTOOL="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    DLLTOOL=$ac_ct_DLLTOOL
-  fi
-else
-  DLLTOOL="$ac_cv_prog_DLLTOOL"
-fi
-
-test -z "$DLLTOOL" && DLLTOOL=dlltool
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
-printf %s "checking how to associate runtime and link libraries... " >&6; }
-if test ${lt_cv_sharedlib_from_linklib_cmd+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_sharedlib_from_linklib_cmd='unknown'
-
-case $host_os in
-cygwin* | mingw* | pw32* | cegcc*)
-  # two different shell functions defined in ltmain.sh;
-  # decide which one to use based on capabilities of $DLLTOOL
-  case `$DLLTOOL --help 2>&1` in
-  *--identify-strict*)
-    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
-    ;;
-  *)
-    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
-    ;;
-  esac
-  ;;
-*)
-  # fallback: assume linklib IS sharedlib
-  lt_cv_sharedlib_from_linklib_cmd=$ECHO
-  ;;
-esac
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
-printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
-sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
-test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
-
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  for ac_prog in ar
-  do
-    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
-set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_AR+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$AR"; then
-  ac_cv_prog_AR="$AR" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-AR=$ac_cv_prog_AR
-if test -n "$AR"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-printf "%s\n" "$AR" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-    test -n "$AR" && break
-  done
-fi
-if test -z "$AR"; then
-  ac_ct_AR=$AR
-  for ac_prog in ar
-do
-  # Extract the first word of "$ac_prog", so it can be a program name with args.
-set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_AR+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_AR"; then
-  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_AR="$ac_prog"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_AR=$ac_cv_prog_ac_ct_AR
-if test -n "$ac_ct_AR"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
-printf "%s\n" "$ac_ct_AR" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  test -n "$ac_ct_AR" && break
-done
-
-  if test "x$ac_ct_AR" = x; then
-    AR="false"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    AR=$ac_ct_AR
-  fi
-fi
-
-: ${AR=ar}
-: ${AR_FLAGS=cr}
-
-
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
-printf %s "checking for archiver @FILE support... " >&6; }
-if test ${lt_cv_ar_at_file+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ar_at_file=no
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  echo conftest.$ac_objext > conftest.lst
-      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
-      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
-  (eval $lt_ar_try) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-      if test 0 -eq "$ac_status"; then
-	# Ensure the archiver fails upon bogus file names.
-	rm -f conftest.$ac_objext libconftest.a
-	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
-  (eval $lt_ar_try) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-	if test 0 -ne "$ac_status"; then
-          lt_cv_ar_at_file=@
-        fi
-      fi
-      rm -f conftest.* libconftest.a
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
-printf "%s\n" "$lt_cv_ar_at_file" >&6; }
-
-if test no = "$lt_cv_ar_at_file"; then
-  archiver_list_spec=
-else
-  archiver_list_spec=$lt_cv_ar_at_file
-fi
-
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
-set dummy ${ac_tool_prefix}strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_STRIP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$STRIP"; then
-  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-STRIP=$ac_cv_prog_STRIP
-if test -n "$STRIP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-printf "%s\n" "$STRIP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_STRIP"; then
-  ac_ct_STRIP=$STRIP
-  # Extract the first word of "strip", so it can be a program name with args.
-set dummy strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_STRIP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_STRIP"; then
-  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_STRIP="strip"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
-if test -n "$ac_ct_STRIP"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-printf "%s\n" "$ac_ct_STRIP" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_STRIP" = x; then
-    STRIP=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    STRIP=$ac_ct_STRIP
-  fi
-else
-  STRIP="$ac_cv_prog_STRIP"
-fi
-
-test -z "$STRIP" && STRIP=:
-
-
-
-
-
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
-set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_RANLIB+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$RANLIB"; then
-  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-RANLIB=$ac_cv_prog_RANLIB
-if test -n "$RANLIB"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
-printf "%s\n" "$RANLIB" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_RANLIB"; then
-  ac_ct_RANLIB=$RANLIB
-  # Extract the first word of "ranlib", so it can be a program name with args.
-set dummy ranlib; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_RANLIB+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_RANLIB"; then
-  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_RANLIB="ranlib"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
-if test -n "$ac_ct_RANLIB"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
-printf "%s\n" "$ac_ct_RANLIB" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_RANLIB" = x; then
-    RANLIB=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    RANLIB=$ac_ct_RANLIB
-  fi
-else
-  RANLIB="$ac_cv_prog_RANLIB"
-fi
-
-test -z "$RANLIB" && RANLIB=:
-
-
-
-
-
-
-# Determine commands to create old-style static archives.
-old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
-old_postinstall_cmds='chmod 644 $oldlib'
-old_postuninstall_cmds=
-
-if test -n "$RANLIB"; then
-  case $host_os in
-  bitrig* | openbsd*)
-    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
-    ;;
-  *)
-    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
-    ;;
-  esac
-  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
-fi
-
-case $host_os in
-  darwin*)
-    lock_old_archive_extraction=yes ;;
-  *)
-    lock_old_archive_extraction=no ;;
-esac
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# If no C compiler was specified, use CC.
-LTCC=${LTCC-"$CC"}
-
-# If no C compiler flags were specified, use CFLAGS.
-LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
-
-# Allow CC to be a program name with arguments.
-compiler=$CC
-
-
-# Check for command to grab the raw symbol name followed by C symbol from nm.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
-printf %s "checking command to parse $NM output from $compiler object... " >&6; }
-if test ${lt_cv_sys_global_symbol_pipe+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-# These are sane defaults that work on at least a few old systems.
-# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
-
-# Character class describing NM global symbol codes.
-symcode='[BCDEGRST]'
-
-# Regexp to match symbols that can be accessed directly from C.
-sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
-
-# Define system-specific variables.
-case $host_os in
-aix*)
-  symcode='[BCDT]'
-  ;;
-cygwin* | mingw* | pw32* | cegcc*)
-  symcode='[ABCDGISTW]'
-  ;;
-hpux*)
-  if test ia64 = "$host_cpu"; then
-    symcode='[ABCDEGRST]'
-  fi
-  ;;
-irix* | nonstopux*)
-  symcode='[BCDEGRST]'
-  ;;
-osf*)
-  symcode='[BCDEGQRST]'
-  ;;
-solaris*)
-  symcode='[BDRT]'
-  ;;
-sco3.2v5*)
-  symcode='[DT]'
-  ;;
-sysv4.2uw2*)
-  symcode='[DT]'
-  ;;
-sysv5* | sco5v6* | unixware* | OpenUNIX*)
-  symcode='[ABDT]'
-  ;;
-sysv4)
-  symcode='[DFNSTU]'
-  ;;
-esac
-
-# If we're using GNU nm, then use its standard symbol codes.
-case `$NM -V 2>&1` in
-*GNU* | *'with BFD'*)
-  symcode='[ABCDGIRSTW]' ;;
-esac
-
-if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-  # Gets list of data symbols to import.
-  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
-  # Adjust the below global symbol transforms to fixup imported variables.
-  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
-  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
-  lt_c_name_lib_hook="\
-  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
-  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
-else
-  # Disable hooks by default.
-  lt_cv_sys_global_symbol_to_import=
-  lt_cdecl_hook=
-  lt_c_name_hook=
-  lt_c_name_lib_hook=
-fi
-
-# Transform an extracted symbol line into a proper C declaration.
-# Some systems (esp. on ia64) link data and code symbols differently,
-# so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n"\
-$lt_cdecl_hook\
-" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
-
-# Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
-$lt_c_name_hook\
-" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
-
-# Transform an extracted symbol line into symbol name with lib prefix and
-# symbol address.
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
-$lt_c_name_lib_hook\
-" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
-
-# Handle CRLF in mingw tool chain
-opt_cr=
-case $build_os in
-mingw*)
-  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
-  ;;
-esac
-
-# Try without a prefix underscore, then with it.
-for ac_symprfx in "" "_"; do
-
-  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
-  symxfrm="\\1 $ac_symprfx\\2 \\2"
-
-  # Write the raw and C identifiers.
-  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-    # Fake it for dumpbin and say T for any non-static function,
-    # D for any global variable and I for any imported variable.
-    # Also find C++ and __fastcall symbols from MSVC++,
-    # which start with @ or ?.
-    lt_cv_sys_global_symbol_pipe="$AWK '"\
-"     {last_section=section; section=\$ 3};"\
-"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
-"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
-"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
-"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
-"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
-"     \$ 0!~/External *\|/{next};"\
-"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
-"     {if(hide[section]) next};"\
-"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
-"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
-"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
-"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
-"     ' prfx=^$ac_symprfx"
-  else
-    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
-  fi
-  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
-
-  # Check to see that the pipe works correctly.
-  pipe_works=no
-
-  rm -f conftest*
-  cat > conftest.$ac_ext <<_LT_EOF
-#ifdef __cplusplus
-extern "C" {
-#endif
-char nm_test_var;
-void nm_test_func(void);
-void nm_test_func(void){}
-#ifdef __cplusplus
-}
-#endif
-int main(){nm_test_var='a';nm_test_func();return(0);}
-_LT_EOF
-
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    # Now try to grab the symbols.
-    nlist=conftest.nm
-    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&5
-    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&5 && test -s "$nlist"; then
-      # Try sorting and uniquifying the output.
-      if sort "$nlist" | uniq > "$nlist"T; then
-	mv -f "$nlist"T "$nlist"
-      else
-	rm -f "$nlist"T
-      fi
-
-      # Make sure that we snagged all the symbols we need.
-      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
-	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
-	  cat <<_LT_EOF > conftest.$ac_ext
-/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
-/* DATA imports from DLLs on WIN32 can't be const, because runtime
-   relocations are performed -- see ld's documentation on pseudo-relocs.  */
-# define LT_DLSYM_CONST
-#elif defined __osf__
-/* This system does not cope well with relocations in const data.  */
-# define LT_DLSYM_CONST
-#else
-# define LT_DLSYM_CONST const
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-_LT_EOF
-	  # Now generate the symbol file.
-	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
-
-	  cat <<_LT_EOF >> conftest.$ac_ext
-
-/* The mapping between symbol names and symbols.  */
-LT_DLSYM_CONST struct {
-  const char *name;
-  void       *address;
-}
-lt__PROGRAM__LTX_preloaded_symbols[] =
-{
-  { "@PROGRAM@", (void *) 0 },
-_LT_EOF
-	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
-	  cat <<\_LT_EOF >> conftest.$ac_ext
-  {0, (void *) 0}
-};
-
-/* This works around a problem in FreeBSD linker */
-#ifdef FREEBSD_WORKAROUND
-static const void *lt_preloaded_setup() {
-  return lt__PROGRAM__LTX_preloaded_symbols;
-}
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-_LT_EOF
-	  # Now try linking the two files.
-	  mv conftest.$ac_objext conftstm.$ac_objext
-	  lt_globsym_save_LIBS=$LIBS
-	  lt_globsym_save_CFLAGS=$CFLAGS
-	  LIBS=conftstm.$ac_objext
-	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
-	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s conftest$ac_exeext; then
-	    pipe_works=yes
-	  fi
-	  LIBS=$lt_globsym_save_LIBS
-	  CFLAGS=$lt_globsym_save_CFLAGS
-	else
-	  echo "cannot find nm_test_func in $nlist" >&5
-	fi
-      else
-	echo "cannot find nm_test_var in $nlist" >&5
-      fi
-    else
-      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
-    fi
-  else
-    echo "$progname: failed program was:" >&5
-    cat conftest.$ac_ext >&5
-  fi
-  rm -rf conftest* conftst*
-
-  # Do not use the global_symbol_pipe unless it works.
-  if test yes = "$pipe_works"; then
-    break
-  else
-    lt_cv_sys_global_symbol_pipe=
-  fi
-done
-
-fi
-
-if test -z "$lt_cv_sys_global_symbol_pipe"; then
-  lt_cv_sys_global_symbol_to_cdecl=
-fi
-if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-printf "%s\n" "failed" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-printf "%s\n" "ok" >&6; }
-fi
-
-# Response file support.
-if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-  nm_file_list_spec='@'
-elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
-  nm_file_list_spec='@'
-fi
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
-printf %s "checking for sysroot... " >&6; }
-
-# Check whether --with-sysroot was given.
-if test ${with_sysroot+y}
-then :
-  withval=$with_sysroot;
-else $as_nop
-  with_sysroot=no
-fi
-
-
-lt_sysroot=
-case $with_sysroot in #(
- yes)
-   if test yes = "$GCC"; then
-     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
-   fi
-   ;; #(
- /*)
-   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
-   ;; #(
- no|'')
-   ;; #(
- *)
-   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
-printf "%s\n" "$with_sysroot" >&6; }
-   as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
-   ;;
-esac
-
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
-printf "%s\n" "${lt_sysroot:-no}" >&6; }
-
-
-
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
-printf %s "checking for a working dd... " >&6; }
-if test ${ac_cv_path_lt_DD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  printf 0123456789abcdef0123456789abcdef >conftest.i
-cat conftest.i conftest.i >conftest2.i
-: ${lt_DD:=$DD}
-if test -z "$lt_DD"; then
-  ac_path_lt_DD_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_prog in dd
-   do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_lt_DD="$as_dir$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_lt_DD" || continue
-if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
-  cmp -s conftest.i conftest.out \
-  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
-fi
-      $ac_path_lt_DD_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_lt_DD"; then
-    :
-  fi
-else
-  ac_cv_path_lt_DD=$lt_DD
-fi
-
-rm -f conftest.i conftest2.i conftest.out
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
-printf "%s\n" "$ac_cv_path_lt_DD" >&6; }
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
-printf %s "checking how to truncate binary pipes... " >&6; }
-if test ${lt_cv_truncate_bin+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  printf 0123456789abcdef0123456789abcdef >conftest.i
-cat conftest.i conftest.i >conftest2.i
-lt_cv_truncate_bin=
-if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
-  cmp -s conftest.i conftest.out \
-  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
-fi
-rm -f conftest.i conftest2.i conftest.out
-test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
-printf "%s\n" "$lt_cv_truncate_bin" >&6; }
-
-
-
-
-
-
-
-# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
-func_cc_basename ()
-{
-    for cc_temp in $*""; do
-      case $cc_temp in
-        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-        \-*) ;;
-        *) break;;
-      esac
-    done
-    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
-}
-
-# Check whether --enable-libtool-lock was given.
-if test ${enable_libtool_lock+y}
-then :
-  enableval=$enable_libtool_lock;
-fi
-
-test no = "$enable_libtool_lock" || enable_libtool_lock=yes
-
-# Some flags need to be propagated to the compiler or linker for good
-# libtool support.
-case $host in
-ia64-*-hpux*)
-  # Find out what ABI is being produced by ac_compile, and set mode
-  # options accordingly.
-  echo 'int i;' > conftest.$ac_ext
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.$ac_objext` in
-      *ELF-32*)
-	HPUX_IA64_MODE=32
-	;;
-      *ELF-64*)
-	HPUX_IA64_MODE=64
-	;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-*-*-irix6*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    if test yes = "$lt_cv_prog_gnu_ld"; then
-      case `/usr/bin/file conftest.$ac_objext` in
-	*32-bit*)
-	  LD="${LD-ld} -melf32bsmip"
-	  ;;
-	*N32*)
-	  LD="${LD-ld} -melf32bmipn32"
-	  ;;
-	*64-bit*)
-	  LD="${LD-ld} -melf64bmip"
-	;;
-      esac
-    else
-      case `/usr/bin/file conftest.$ac_objext` in
-	*32-bit*)
-	  LD="${LD-ld} -32"
-	  ;;
-	*N32*)
-	  LD="${LD-ld} -n32"
-	  ;;
-	*64-bit*)
-	  LD="${LD-ld} -64"
-	  ;;
-      esac
-    fi
-  fi
-  rm -rf conftest*
-  ;;
-
-mips64*-*linux*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    emul=elf
-    case `/usr/bin/file conftest.$ac_objext` in
-      *32-bit*)
-	emul="${emul}32"
-	;;
-      *64-bit*)
-	emul="${emul}64"
-	;;
-    esac
-    case `/usr/bin/file conftest.$ac_objext` in
-      *MSB*)
-	emul="${emul}btsmip"
-	;;
-      *LSB*)
-	emul="${emul}ltsmip"
-	;;
-    esac
-    case `/usr/bin/file conftest.$ac_objext` in
-      *N32*)
-	emul="${emul}n32"
-	;;
-    esac
-    LD="${LD-ld} -m $emul"
-  fi
-  rm -rf conftest*
-  ;;
-
-x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
-s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.  Note that the listed cases only cover the
-  # situations where additional linker options are needed (such as when
-  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
-  # vice versa); the common cases where no linker options are needed do
-  # not appear in the list.
-  echo 'int i;' > conftest.$ac_ext
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.o` in
-      *32-bit*)
-	case $host in
-	  x86_64-*kfreebsd*-gnu)
-	    LD="${LD-ld} -m elf_i386_fbsd"
-	    ;;
-	  x86_64-*linux*)
-	    case `/usr/bin/file conftest.o` in
-	      *x86-64*)
-		LD="${LD-ld} -m elf32_x86_64"
-		;;
-	      *)
-		LD="${LD-ld} -m elf_i386"
-		;;
-	    esac
-	    ;;
-	  powerpc64le-*linux*)
-	    LD="${LD-ld} -m elf32lppclinux"
-	    ;;
-	  powerpc64-*linux*)
-	    LD="${LD-ld} -m elf32ppclinux"
-	    ;;
-	  s390x-*linux*)
-	    LD="${LD-ld} -m elf_s390"
-	    ;;
-	  sparc64-*linux*)
-	    LD="${LD-ld} -m elf32_sparc"
-	    ;;
-	esac
-	;;
-      *64-bit*)
-	case $host in
-	  x86_64-*kfreebsd*-gnu)
-	    LD="${LD-ld} -m elf_x86_64_fbsd"
-	    ;;
-	  x86_64-*linux*)
-	    LD="${LD-ld} -m elf_x86_64"
-	    ;;
-	  powerpcle-*linux*)
-	    LD="${LD-ld} -m elf64lppc"
-	    ;;
-	  powerpc-*linux*)
-	    LD="${LD-ld} -m elf64ppc"
-	    ;;
-	  s390*-*linux*|s390*-*tpf*)
-	    LD="${LD-ld} -m elf64_s390"
-	    ;;
-	  sparc*-*linux*)
-	    LD="${LD-ld} -m elf64_sparc"
-	    ;;
-	esac
-	;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-
-*-*-sco3.2v5*)
-  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
-  SAVE_CFLAGS=$CFLAGS
-  CFLAGS="$CFLAGS -belf"
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
-printf %s "checking whether the C compiler needs -belf... " >&6; }
-if test ${lt_cv_cc_needs_belf+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  lt_cv_cc_needs_belf=yes
-else $as_nop
-  lt_cv_cc_needs_belf=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-     ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
-printf "%s\n" "$lt_cv_cc_needs_belf" >&6; }
-  if test yes != "$lt_cv_cc_needs_belf"; then
-    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
-    CFLAGS=$SAVE_CFLAGS
-  fi
-  ;;
-*-*solaris*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo 'int i;' > conftest.$ac_ext
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-    case `/usr/bin/file conftest.o` in
-    *64-bit*)
-      case $lt_cv_prog_gnu_ld in
-      yes*)
-        case $host in
-        i?86-*-solaris*|x86_64-*-solaris*)
-          LD="${LD-ld} -m elf_x86_64"
-          ;;
-        sparc*-*-solaris*)
-          LD="${LD-ld} -m elf64_sparc"
-          ;;
-        esac
-        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
-        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
-          LD=${LD-ld}_sol2
-        fi
-        ;;
-      *)
-	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
-	  LD="${LD-ld} -64"
-	fi
-	;;
-      esac
-      ;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-esac
-
-need_locks=$enable_libtool_lock
-
-if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
-set dummy ${ac_tool_prefix}mt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_MANIFEST_TOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$MANIFEST_TOOL"; then
-  ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
-if test -n "$MANIFEST_TOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
-printf "%s\n" "$MANIFEST_TOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
-  ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
-  # Extract the first word of "mt", so it can be a program name with args.
-set dummy mt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_MANIFEST_TOOL"; then
-  ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
-if test -n "$ac_ct_MANIFEST_TOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
-printf "%s\n" "$ac_ct_MANIFEST_TOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_MANIFEST_TOOL" = x; then
-    MANIFEST_TOOL=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
-  fi
-else
-  MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
-fi
-
-test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
-printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
-if test ${lt_cv_path_mainfest_tool+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_path_mainfest_tool=no
-  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
-  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
-  cat conftest.err >&5
-  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
-    lt_cv_path_mainfest_tool=yes
-  fi
-  rm -f conftest*
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
-printf "%s\n" "$lt_cv_path_mainfest_tool" >&6; }
-if test yes != "$lt_cv_path_mainfest_tool"; then
-  MANIFEST_TOOL=:
-fi
-
-
-
-
-
-
-  case $host_os in
-    rhapsody* | darwin*)
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
-set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_DSYMUTIL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$DSYMUTIL"; then
-  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-DSYMUTIL=$ac_cv_prog_DSYMUTIL
-if test -n "$DSYMUTIL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
-printf "%s\n" "$DSYMUTIL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_DSYMUTIL"; then
-  ac_ct_DSYMUTIL=$DSYMUTIL
-  # Extract the first word of "dsymutil", so it can be a program name with args.
-set dummy dsymutil; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_DSYMUTIL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_DSYMUTIL"; then
-  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
-if test -n "$ac_ct_DSYMUTIL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
-printf "%s\n" "$ac_ct_DSYMUTIL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_DSYMUTIL" = x; then
-    DSYMUTIL=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    DSYMUTIL=$ac_ct_DSYMUTIL
-  fi
-else
-  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
-fi
-
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
-set dummy ${ac_tool_prefix}nmedit; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_NMEDIT+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$NMEDIT"; then
-  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-NMEDIT=$ac_cv_prog_NMEDIT
-if test -n "$NMEDIT"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
-printf "%s\n" "$NMEDIT" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_NMEDIT"; then
-  ac_ct_NMEDIT=$NMEDIT
-  # Extract the first word of "nmedit", so it can be a program name with args.
-set dummy nmedit; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_NMEDIT+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_NMEDIT"; then
-  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_NMEDIT="nmedit"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
-if test -n "$ac_ct_NMEDIT"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
-printf "%s\n" "$ac_ct_NMEDIT" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_NMEDIT" = x; then
-    NMEDIT=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    NMEDIT=$ac_ct_NMEDIT
-  fi
-else
-  NMEDIT="$ac_cv_prog_NMEDIT"
-fi
-
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
-set dummy ${ac_tool_prefix}lipo; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_LIPO+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$LIPO"; then
-  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-LIPO=$ac_cv_prog_LIPO
-if test -n "$LIPO"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
-printf "%s\n" "$LIPO" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_LIPO"; then
-  ac_ct_LIPO=$LIPO
-  # Extract the first word of "lipo", so it can be a program name with args.
-set dummy lipo; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_LIPO+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_LIPO"; then
-  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_LIPO="lipo"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
-if test -n "$ac_ct_LIPO"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
-printf "%s\n" "$ac_ct_LIPO" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_LIPO" = x; then
-    LIPO=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    LIPO=$ac_ct_LIPO
-  fi
-else
-  LIPO="$ac_cv_prog_LIPO"
-fi
-
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
-set dummy ${ac_tool_prefix}otool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OTOOL"; then
-  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-OTOOL=$ac_cv_prog_OTOOL
-if test -n "$OTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
-printf "%s\n" "$OTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_OTOOL"; then
-  ac_ct_OTOOL=$OTOOL
-  # Extract the first word of "otool", so it can be a program name with args.
-set dummy otool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OTOOL+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OTOOL"; then
-  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OTOOL="otool"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
-if test -n "$ac_ct_OTOOL"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
-printf "%s\n" "$ac_ct_OTOOL" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OTOOL" = x; then
-    OTOOL=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    OTOOL=$ac_ct_OTOOL
-  fi
-else
-  OTOOL="$ac_cv_prog_OTOOL"
-fi
-
-    if test -n "$ac_tool_prefix"; then
-  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
-set dummy ${ac_tool_prefix}otool64; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_OTOOL64+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$OTOOL64"; then
-  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-OTOOL64=$ac_cv_prog_OTOOL64
-if test -n "$OTOOL64"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
-printf "%s\n" "$OTOOL64" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-fi
-if test -z "$ac_cv_prog_OTOOL64"; then
-  ac_ct_OTOOL64=$OTOOL64
-  # Extract the first word of "otool64", so it can be a program name with args.
-set dummy otool64; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-printf %s "checking for $ac_word... " >&6; }
-if test ${ac_cv_prog_ac_ct_OTOOL64+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -n "$ac_ct_OTOOL64"; then
-  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-    ac_cv_prog_ac_ct_OTOOL64="otool64"
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
-if test -n "$ac_ct_OTOOL64"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
-printf "%s\n" "$ac_ct_OTOOL64" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-  if test "x$ac_ct_OTOOL64" = x; then
-    OTOOL64=":"
-  else
-    case $cross_compiling:$ac_tool_warned in
-yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-ac_tool_warned=yes ;;
-esac
-    OTOOL64=$ac_ct_OTOOL64
-  fi
-else
-  OTOOL64="$ac_cv_prog_OTOOL64"
-fi
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
-printf %s "checking for -single_module linker flag... " >&6; }
-if test ${lt_cv_apple_cc_single_mod+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_apple_cc_single_mod=no
-      if test -z "$LT_MULTI_MODULE"; then
-	# By default we will add the -single_module flag. You can override
-	# by either setting the environment variable LT_MULTI_MODULE
-	# non-empty at configure time, or by adding -multi_module to the
-	# link flags.
-	rm -rf libconftest.dylib*
-	echo "int foo(void){return 1;}" > conftest.c
-	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
--dynamiclib -Wl,-single_module conftest.c" >&5
-	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
-	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
-        _lt_result=$?
-	# If there is a non-empty error log, and "single_module"
-	# appears in it, assume the flag caused a linker warning
-        if test -s conftest.err && $GREP single_module conftest.err; then
-	  cat conftest.err >&5
-	# Otherwise, if the output was created with a 0 exit code from
-	# the compiler, it worked.
-	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
-	  lt_cv_apple_cc_single_mod=yes
-	else
-	  cat conftest.err >&5
-	fi
-	rm -rf libconftest.dylib*
-	rm -f conftest.*
-      fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
-printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; }
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
-printf %s "checking for -exported_symbols_list linker flag... " >&6; }
-if test ${lt_cv_ld_exported_symbols_list+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_exported_symbols_list=no
-      save_LDFLAGS=$LDFLAGS
-      echo "_main" > conftest.sym
-      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  lt_cv_ld_exported_symbols_list=yes
-else $as_nop
-  lt_cv_ld_exported_symbols_list=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-	LDFLAGS=$save_LDFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
-printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; }
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
-printf %s "checking for -force_load linker flag... " >&6; }
-if test ${lt_cv_ld_force_load+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_ld_force_load=no
-      cat > conftest.c << _LT_EOF
-int forced_loaded() { return 2;}
-_LT_EOF
-      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
-      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
-      echo "$AR cr libconftest.a conftest.o" >&5
-      $AR cr libconftest.a conftest.o 2>&5
-      echo "$RANLIB libconftest.a" >&5
-      $RANLIB libconftest.a 2>&5
-      cat > conftest.c << _LT_EOF
-int main() { return 0;}
-_LT_EOF
-      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
-      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
-      _lt_result=$?
-      if test -s conftest.err && $GREP force_load conftest.err; then
-	cat conftest.err >&5
-      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
-	lt_cv_ld_force_load=yes
-      else
-	cat conftest.err >&5
-      fi
-        rm -f conftest.err libconftest.a conftest conftest.c
-        rm -rf conftest.dSYM
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
-printf "%s\n" "$lt_cv_ld_force_load" >&6; }
-    case $host_os in
-    rhapsody* | darwin1.[012])
-      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
-    darwin1.*)
-      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[912]*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.[012][,.]*)
-	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-	10.*|11.*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-      esac
-    ;;
-  esac
-    if test yes = "$lt_cv_apple_cc_single_mod"; then
-      _lt_dar_single_mod='$single_module'
-    fi
-    if test yes = "$lt_cv_ld_exported_symbols_list"; then
-      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
-    else
-      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
-    fi
-    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
-      _lt_dsymutil='~$DSYMUTIL $lib || :'
-    else
-      _lt_dsymutil=
-    fi
-    ;;
-  esac
-
-# func_munge_path_list VARIABLE PATH
-# -----------------------------------
-# VARIABLE is name of variable containing _space_ separated list of
-# directories to be munged by the contents of PATH, which is string
-# having a format:
-# "DIR[:DIR]:"
-#       string "DIR[ DIR]" will be prepended to VARIABLE
-# ":DIR[:DIR]"
-#       string "DIR[ DIR]" will be appended to VARIABLE
-# "DIRP[:DIRP]::[DIRA:]DIRA"
-#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
-#       "DIRA[ DIRA]" will be appended to VARIABLE
-# "DIR[:DIR]"
-#       VARIABLE will be replaced by "DIR[ DIR]"
-func_munge_path_list ()
-{
-    case x$2 in
-    x)
-        ;;
-    *:)
-        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
-        ;;
-    x:*)
-        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
-        ;;
-    *::*)
-        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
-        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
-        ;;
-    *)
-        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
-        ;;
-    esac
-}
-
-ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
-"
-if test "x$ac_cv_header_dlfcn_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_DLFCN_H 1" >>confdefs.h
-
-fi
-
-
-
-
-func_stripname_cnf ()
-{
-  case $2 in
-  .*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%\\\\$2\$%%"`;;
-  *)  func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%$2\$%%"`;;
-  esac
-} # func_stripname_cnf
-
-
-
-
-
-# Set options
-
-
-
-        enable_dlopen=no
-
-
-
-            # Check whether --enable-shared was given.
-if test ${enable_shared+y}
-then :
-  enableval=$enable_shared; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_shared=yes ;;
-    no) enable_shared=no ;;
-    *)
-      enable_shared=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_shared=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  enable_shared=yes
-fi
-
-
-
-
-
-
-
-
-
-  # Check whether --enable-static was given.
-if test ${enable_static+y}
-then :
-  enableval=$enable_static; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_static=yes ;;
-    no) enable_static=no ;;
-    *)
-     enable_static=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_static=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  enable_static=yes
-fi
-
-
-
-
-
-
-
-
-
-
-# Check whether --with-pic was given.
-if test ${with_pic+y}
-then :
-  withval=$with_pic; lt_p=${PACKAGE-default}
-    case $withval in
-    yes|no) pic_mode=$withval ;;
-    *)
-      pic_mode=default
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for lt_pkg in $withval; do
-	IFS=$lt_save_ifs
-	if test "X$lt_pkg" = "X$lt_p"; then
-	  pic_mode=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  pic_mode=default
-fi
-
-
-
-
-
-
-
-
-  # Check whether --enable-fast-install was given.
-if test ${enable_fast_install+y}
-then :
-  enableval=$enable_fast_install; p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_fast_install=yes ;;
-    no) enable_fast_install=no ;;
-    *)
-      enable_fast_install=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_fast_install=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac
-else $as_nop
-  enable_fast_install=yes
-fi
-
-
-
-
-
-
-
-
-  shared_archive_member_spec=
-case $host,$enable_shared in
-power*-*-aix[5-9]*,yes)
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
-printf %s "checking which variant of shared library versioning to provide... " >&6; }
-
-# Check whether --with-aix-soname was given.
-if test ${with_aix_soname+y}
-then :
-  withval=$with_aix_soname; case $withval in
-    aix|svr4|both)
-      ;;
-    *)
-      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
-      ;;
-    esac
-    lt_cv_with_aix_soname=$with_aix_soname
-else $as_nop
-  if test ${lt_cv_with_aix_soname+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_with_aix_soname=aix
-fi
-
-    with_aix_soname=$lt_cv_with_aix_soname
-fi
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
-printf "%s\n" "$with_aix_soname" >&6; }
-  if test aix != "$with_aix_soname"; then
-    # For the AIX way of multilib, we name the shared archive member
-    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
-    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
-    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
-    # the AIX toolchain works better with OBJECT_MODE set (default 32).
-    if test 64 = "${OBJECT_MODE-32}"; then
-      shared_archive_member_spec=shr_64
-    else
-      shared_archive_member_spec=shr
-    fi
-  fi
-  ;;
-*)
-  with_aix_soname=aix
-  ;;
-esac
-
-
-
-
-
-
-
-
-
-
-# This can be used to rebuild libtool when needed
-LIBTOOL_DEPS=$ltmain
-
-# Always use our own libtool.
-LIBTOOL='$(SHELL) $(top_builddir)/libtool'
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-test -z "$LN_S" && LN_S="ln -s"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-if test -n "${ZSH_VERSION+set}"; then
-   setopt NO_GLOB_SUBST
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
-printf %s "checking for objdir... " >&6; }
-if test ${lt_cv_objdir+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  rm -f .libs 2>/dev/null
-mkdir .libs 2>/dev/null
-if test -d .libs; then
-  lt_cv_objdir=.libs
-else
-  # MS-DOS does not allow filenames that begin with a dot.
-  lt_cv_objdir=_libs
-fi
-rmdir .libs 2>/dev/null
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
-printf "%s\n" "$lt_cv_objdir" >&6; }
-objdir=$lt_cv_objdir
-
-
-
-
-
-printf "%s\n" "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h
-
-
-
-
-case $host_os in
-aix3*)
-  # AIX sometimes has problems with the GCC collect2 program.  For some
-  # reason, if we set the COLLECT_NAMES environment variable, the problems
-  # vanish in a puff of smoke.
-  if test set != "${COLLECT_NAMES+set}"; then
-    COLLECT_NAMES=
-    export COLLECT_NAMES
-  fi
-  ;;
-esac
-
-# Global variables:
-ofile=libtool
-can_build_shared=yes
-
-# All known linkers require a '.a' archive for static linking (except MSVC,
-# which needs '.lib').
-libext=a
-
-with_gnu_ld=$lt_cv_prog_gnu_ld
-
-old_CC=$CC
-old_CFLAGS=$CFLAGS
-
-# Set sane defaults for various variables
-test -z "$CC" && CC=cc
-test -z "$LTCC" && LTCC=$CC
-test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
-test -z "$LD" && LD=ld
-test -z "$ac_objext" && ac_objext=o
-
-func_cc_basename $compiler
-cc_basename=$func_cc_basename_result
-
-
-# Only perform the check for file, if the check method requires it
-test -z "$MAGIC_CMD" && MAGIC_CMD=file
-case $deplibs_check_method in
-file_magic*)
-  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
-printf %s "checking for ${ac_tool_prefix}file... " >&6; }
-if test ${lt_cv_path_MAGIC_CMD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  case $MAGIC_CMD in
-[\\/*] |  ?:[\\/]*)
-  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
-  ;;
-*)
-  lt_save_MAGIC_CMD=$MAGIC_CMD
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
-  for ac_dir in $ac_dummy; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/${ac_tool_prefix}file"; then
-      lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
-      if test -n "$file_magic_test_file"; then
-	case $deplibs_check_method in
-	"file_magic "*)
-	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
-	    $EGREP "$file_magic_regex" > /dev/null; then
-	    :
-	  else
-	    cat <<_LT_EOF 1>&2
-
-*** Warning: the command libtool uses to detect shared libraries,
-*** $file_magic_cmd, produces output that libtool cannot recognize.
-*** The result is that libtool may fail to recognize shared libraries
-*** as such.  This will affect the creation of libtool libraries that
-*** depend on shared libraries, but programs linked with such libtool
-*** libraries will work regardless of this problem.  Nevertheless, you
-*** may want to report the problem to your system manager and/or to
-*** bug-libtool@gnu.org
-
-_LT_EOF
-	  fi ;;
-	esac
-      fi
-      break
-    fi
-  done
-  IFS=$lt_save_ifs
-  MAGIC_CMD=$lt_save_MAGIC_CMD
-  ;;
-esac
-fi
-
-MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-if test -n "$MAGIC_CMD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
-printf "%s\n" "$MAGIC_CMD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-
-
-
-if test -z "$lt_cv_path_MAGIC_CMD"; then
-  if test -n "$ac_tool_prefix"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for file" >&5
-printf %s "checking for file... " >&6; }
-if test ${lt_cv_path_MAGIC_CMD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  case $MAGIC_CMD in
-[\\/*] |  ?:[\\/]*)
-  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
-  ;;
-*)
-  lt_save_MAGIC_CMD=$MAGIC_CMD
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
-  for ac_dir in $ac_dummy; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/file"; then
-      lt_cv_path_MAGIC_CMD=$ac_dir/"file"
-      if test -n "$file_magic_test_file"; then
-	case $deplibs_check_method in
-	"file_magic "*)
-	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
-	    $EGREP "$file_magic_regex" > /dev/null; then
-	    :
-	  else
-	    cat <<_LT_EOF 1>&2
-
-*** Warning: the command libtool uses to detect shared libraries,
-*** $file_magic_cmd, produces output that libtool cannot recognize.
-*** The result is that libtool may fail to recognize shared libraries
-*** as such.  This will affect the creation of libtool libraries that
-*** depend on shared libraries, but programs linked with such libtool
-*** libraries will work regardless of this problem.  Nevertheless, you
-*** may want to report the problem to your system manager and/or to
-*** bug-libtool@gnu.org
-
-_LT_EOF
-	  fi ;;
-	esac
-      fi
-      break
-    fi
-  done
-  IFS=$lt_save_ifs
-  MAGIC_CMD=$lt_save_MAGIC_CMD
-  ;;
-esac
-fi
-
-MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-if test -n "$MAGIC_CMD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
-printf "%s\n" "$MAGIC_CMD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-
-
-  else
-    MAGIC_CMD=:
-  fi
-fi
-
-  fi
-  ;;
-esac
-
-# Use C for the default configuration in the libtool script
-
-lt_save_CC=$CC
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-# Source file extension for C test sources.
-ac_ext=c
-
-# Object file extension for compiled C test sources.
-objext=o
-objext=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="int some_variable = 0;"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='int main(){return(0);}'
-
-
-
-
-
-
-
-# If no C compiler was specified, use CC.
-LTCC=${LTCC-"$CC"}
-
-# If no C compiler flags were specified, use CFLAGS.
-LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
-
-# Allow CC to be a program name with arguments.
-compiler=$CC
-
-# Save the default compiler, since it gets overwritten when the other
-# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
-compiler_DEFAULT=$CC
-
-# save warnings/boilerplate of simple test code
-ac_outfile=conftest.$ac_objext
-echo "$lt_simple_compile_test_code" >conftest.$ac_ext
-eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_compiler_boilerplate=`cat conftest.err`
-$RM conftest*
-
-ac_outfile=conftest.$ac_objext
-echo "$lt_simple_link_test_code" >conftest.$ac_ext
-eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_linker_boilerplate=`cat conftest.err`
-$RM -r conftest*
-
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
-
-lt_prog_compiler_no_builtin_flag=
-
-if test yes = "$GCC"; then
-  case $cc_basename in
-  nvcc*)
-    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
-  *)
-    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
-  esac
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
-printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
-if test ${lt_cv_prog_compiler_rtti_exceptions+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_rtti_exceptions=no
-   ac_outfile=conftest.$ac_objext
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   # The option is referenced via a variable to avoid confusing sed.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>conftest.err)
-   ac_status=$?
-   cat conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s "$ac_outfile"; then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings other than the usual output.
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
-     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_rtti_exceptions=yes
-     fi
-   fi
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
-printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
-
-if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
-    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
-else
-    :
-fi
-
-fi
-
-
-
-
-
-
-  lt_prog_compiler_wl=
-lt_prog_compiler_pic=
-lt_prog_compiler_static=
-
-
-  if test yes = "$GCC"; then
-    lt_prog_compiler_wl='-Wl,'
-    lt_prog_compiler_static='-static'
-
-    case $host_os in
-      aix*)
-      # All AIX code is PIC.
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	lt_prog_compiler_static='-Bstatic'
-      fi
-      lt_prog_compiler_pic='-fPIC'
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            lt_prog_compiler_pic='-fPIC'
-        ;;
-      m68k)
-            # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the '-m68020' flag to GCC prevents building anything better,
-            # like '-m68040'.
-            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
-        ;;
-      esac
-      ;;
-
-    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
-      # PIC is the default for these OSes.
-      ;;
-
-    mingw* | cygwin* | pw32* | os2* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      # Although the cygwin gcc ignores -fPIC, still need this for old-style
-      # (--disable-auto-import) libraries
-      lt_prog_compiler_pic='-DDLL_EXPORT'
-      case $host_os in
-      os2*)
-	lt_prog_compiler_static='$wl-static'
-	;;
-      esac
-      ;;
-
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      lt_prog_compiler_pic='-fno-common'
-      ;;
-
-    haiku*)
-      # PIC is the default for Haiku.
-      # The "-static" flag exists, but is broken.
-      lt_prog_compiler_static=
-      ;;
-
-    hpux*)
-      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
-      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
-      # sets the default TLS model and affects inlining.
-      case $host_cpu in
-      hppa*64*)
-	# +Z the default
-	;;
-      *)
-	lt_prog_compiler_pic='-fPIC'
-	;;
-      esac
-      ;;
-
-    interix[3-9]*)
-      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
-      # Instead, we relocate shared libraries at runtime.
-      ;;
-
-    msdosdjgpp*)
-      # Just because we use GCC doesn't mean we suddenly get shared libraries
-      # on systems that don't support them.
-      lt_prog_compiler_can_build_shared=no
-      enable_shared=no
-      ;;
-
-    *nto* | *qnx*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      lt_prog_compiler_pic='-fPIC -shared'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	lt_prog_compiler_pic=-Kconform_pic
-      fi
-      ;;
-
-    *)
-      lt_prog_compiler_pic='-fPIC'
-      ;;
-    esac
-
-    case $cc_basename in
-    nvcc*) # Cuda Compiler Driver 2.2
-      lt_prog_compiler_wl='-Xlinker '
-      if test -n "$lt_prog_compiler_pic"; then
-        lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
-      fi
-      ;;
-    esac
-  else
-    # PORTME Check for flag to pass linker flags through the system compiler.
-    case $host_os in
-    aix*)
-      lt_prog_compiler_wl='-Wl,'
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	lt_prog_compiler_static='-Bstatic'
-      else
-	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
-      fi
-      ;;
-
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      lt_prog_compiler_pic='-fno-common'
-      case $cc_basename in
-      nagfor*)
-        # NAG Fortran compiler
-        lt_prog_compiler_wl='-Wl,-Wl,,'
-        lt_prog_compiler_pic='-PIC'
-        lt_prog_compiler_static='-Bstatic'
-        ;;
-      esac
-      ;;
-
-    mingw* | cygwin* | pw32* | os2* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      lt_prog_compiler_pic='-DDLL_EXPORT'
-      case $host_os in
-      os2*)
-	lt_prog_compiler_static='$wl-static'
-	;;
-      esac
-      ;;
-
-    hpux9* | hpux10* | hpux11*)
-      lt_prog_compiler_wl='-Wl,'
-      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
-      # not for PA HP-UX.
-      case $host_cpu in
-      hppa*64*|ia64*)
-	# +Z the default
-	;;
-      *)
-	lt_prog_compiler_pic='+Z'
-	;;
-      esac
-      # Is there a better lt_prog_compiler_static that works with the bundled CC?
-      lt_prog_compiler_static='$wl-a ${wl}archive'
-      ;;
-
-    irix5* | irix6* | nonstopux*)
-      lt_prog_compiler_wl='-Wl,'
-      # PIC (with -KPIC) is the default.
-      lt_prog_compiler_static='-non_shared'
-      ;;
-
-    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-      case $cc_basename in
-      # old Intel for x86_64, which still supported -KPIC.
-      ecc*)
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-KPIC'
-	lt_prog_compiler_static='-static'
-        ;;
-      # flang / f18. f95 an alias for gfortran or flang on Debian
-      flang* | f18* | f95*)
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-fPIC'
-	lt_prog_compiler_static='-static'
-        ;;
-      # icc used to be incompatible with GCC.
-      # ICC 10 doesn't accept -KPIC any more.
-      icc* | ifort*)
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-fPIC'
-	lt_prog_compiler_static='-static'
-        ;;
-      # Lahey Fortran 8.1.
-      lf95*)
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='--shared'
-	lt_prog_compiler_static='--static'
-	;;
-      nagfor*)
-	# NAG Fortran compiler
-	lt_prog_compiler_wl='-Wl,-Wl,,'
-	lt_prog_compiler_pic='-PIC'
-	lt_prog_compiler_static='-Bstatic'
-	;;
-      tcc*)
-	# Fabrice Bellard et al's Tiny C Compiler
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-fPIC'
-	lt_prog_compiler_static='-static'
-	;;
-      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
-        # Portland Group compilers (*not* the Pentium gcc compiler,
-	# which looks to be a dead project)
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-fpic'
-	lt_prog_compiler_static='-Bstatic'
-        ;;
-      ccc*)
-        lt_prog_compiler_wl='-Wl,'
-        # All Alpha code is PIC.
-        lt_prog_compiler_static='-non_shared'
-        ;;
-      xl* | bgxl* | bgf* | mpixl*)
-	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
-	lt_prog_compiler_wl='-Wl,'
-	lt_prog_compiler_pic='-qpic'
-	lt_prog_compiler_static='-qstaticlink'
-	;;
-      *)
-	case `$CC -V 2>&1 | sed 5q` in
-	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
-	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
-	  lt_prog_compiler_pic='-KPIC'
-	  lt_prog_compiler_static='-Bstatic'
-	  lt_prog_compiler_wl=''
-	  ;;
-	*Sun\ F* | *Sun*Fortran*)
-	  lt_prog_compiler_pic='-KPIC'
-	  lt_prog_compiler_static='-Bstatic'
-	  lt_prog_compiler_wl='-Qoption ld '
-	  ;;
-	*Sun\ C*)
-	  # Sun C 5.9
-	  lt_prog_compiler_pic='-KPIC'
-	  lt_prog_compiler_static='-Bstatic'
-	  lt_prog_compiler_wl='-Wl,'
-	  ;;
-        *Intel*\ [CF]*Compiler*)
-	  lt_prog_compiler_wl='-Wl,'
-	  lt_prog_compiler_pic='-fPIC'
-	  lt_prog_compiler_static='-static'
-	  ;;
-	*Portland\ Group*)
-	  lt_prog_compiler_wl='-Wl,'
-	  lt_prog_compiler_pic='-fpic'
-	  lt_prog_compiler_static='-Bstatic'
-	  ;;
-	esac
-	;;
-      esac
-      ;;
-
-    newsos6)
-      lt_prog_compiler_pic='-KPIC'
-      lt_prog_compiler_static='-Bstatic'
-      ;;
-
-    *nto* | *qnx*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      lt_prog_compiler_pic='-fPIC -shared'
-      ;;
-
-    osf3* | osf4* | osf5*)
-      lt_prog_compiler_wl='-Wl,'
-      # All OSF/1 code is PIC.
-      lt_prog_compiler_static='-non_shared'
-      ;;
-
-    rdos*)
-      lt_prog_compiler_static='-non_shared'
-      ;;
-
-    solaris*)
-      lt_prog_compiler_pic='-KPIC'
-      lt_prog_compiler_static='-Bstatic'
-      case $cc_basename in
-      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
-	lt_prog_compiler_wl='-Qoption ld ';;
-      *)
-	lt_prog_compiler_wl='-Wl,';;
-      esac
-      ;;
-
-    sunos4*)
-      lt_prog_compiler_wl='-Qoption ld '
-      lt_prog_compiler_pic='-PIC'
-      lt_prog_compiler_static='-Bstatic'
-      ;;
-
-    sysv4 | sysv4.2uw2* | sysv4.3*)
-      lt_prog_compiler_wl='-Wl,'
-      lt_prog_compiler_pic='-KPIC'
-      lt_prog_compiler_static='-Bstatic'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	lt_prog_compiler_pic='-Kconform_pic'
-	lt_prog_compiler_static='-Bstatic'
-      fi
-      ;;
-
-    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
-      lt_prog_compiler_wl='-Wl,'
-      lt_prog_compiler_pic='-KPIC'
-      lt_prog_compiler_static='-Bstatic'
-      ;;
-
-    unicos*)
-      lt_prog_compiler_wl='-Wl,'
-      lt_prog_compiler_can_build_shared=no
-      ;;
-
-    uts4*)
-      lt_prog_compiler_pic='-pic'
-      lt_prog_compiler_static='-Bstatic'
-      ;;
-
-    *)
-      lt_prog_compiler_can_build_shared=no
-      ;;
-    esac
-  fi
-
-case $host_os in
-  # For platforms that do not support PIC, -DPIC is meaningless:
-  *djgpp*)
-    lt_prog_compiler_pic=
-    ;;
-  *)
-    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
-    ;;
-esac
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
-printf %s "checking for $compiler option to produce PIC... " >&6; }
-if test ${lt_cv_prog_compiler_pic+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; }
-lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
-
-#
-# Check to make sure the PIC flag actually works.
-#
-if test -n "$lt_prog_compiler_pic"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
-printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
-if test ${lt_cv_prog_compiler_pic_works+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_works=no
-   ac_outfile=conftest.$ac_objext
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   # The option is referenced via a variable to avoid confusing sed.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>conftest.err)
-   ac_status=$?
-   cat conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s "$ac_outfile"; then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings other than the usual output.
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
-     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_pic_works=yes
-     fi
-   fi
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; }
-
-if test yes = "$lt_cv_prog_compiler_pic_works"; then
-    case $lt_prog_compiler_pic in
-     "" | " "*) ;;
-     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
-     esac
-else
-    lt_prog_compiler_pic=
-     lt_prog_compiler_can_build_shared=no
-fi
-
-fi
-
-
-
-
-
-
-
-
-
-
-
-#
-# Check to make sure the static flag actually works.
-#
-wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
-printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
-if test ${lt_cv_prog_compiler_static_works+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_static_works=no
-   save_LDFLAGS=$LDFLAGS
-   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
-   echo "$lt_simple_link_test_code" > conftest.$ac_ext
-   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
-     # The linker can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     if test -s conftest.err; then
-       # Append any errors to the config.log.
-       cat conftest.err 1>&5
-       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
-       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-       if diff conftest.exp conftest.er2 >/dev/null; then
-         lt_cv_prog_compiler_static_works=yes
-       fi
-     else
-       lt_cv_prog_compiler_static_works=yes
-     fi
-   fi
-   $RM -r conftest*
-   LDFLAGS=$save_LDFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; }
-
-if test yes = "$lt_cv_prog_compiler_static_works"; then
-    :
-else
-    lt_prog_compiler_static=
-fi
-
-
-
-
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
-printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
-if test ${lt_cv_prog_compiler_c_o+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o=no
-   $RM -r conftest 2>/dev/null
-   mkdir conftest
-   cd conftest
-   mkdir out
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-   lt_compiler_flag="-o out/conftest2.$ac_objext"
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>out/conftest.err)
-   ac_status=$?
-   cat out/conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s out/conftest2.$ac_objext
-   then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
-     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
-     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_c_o=yes
-     fi
-   fi
-   chmod u+w . 2>&5
-   $RM conftest*
-   # SGI C++ compiler will create directory out/ii_files/ for
-   # template instantiation
-   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
-   $RM out/* && rmdir out
-   cd ..
-   $RM -r conftest
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
-
-
-
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
-printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
-if test ${lt_cv_prog_compiler_c_o+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o=no
-   $RM -r conftest 2>/dev/null
-   mkdir conftest
-   cd conftest
-   mkdir out
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-   lt_compiler_flag="-o out/conftest2.$ac_objext"
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>out/conftest.err)
-   ac_status=$?
-   cat out/conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s out/conftest2.$ac_objext
-   then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
-     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
-     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_c_o=yes
-     fi
-   fi
-   chmod u+w . 2>&5
-   $RM conftest*
-   # SGI C++ compiler will create directory out/ii_files/ for
-   # template instantiation
-   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
-   $RM out/* && rmdir out
-   cd ..
-   $RM -r conftest
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
-
-
-
-
-hard_links=nottested
-if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
-  # do not overwrite the value of need_locks provided by the user
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
-printf %s "checking if we can lock with hard links... " >&6; }
-  hard_links=yes
-  $RM conftest*
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  touch conftest.a
-  ln conftest.a conftest.b 2>&5 || hard_links=no
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
-printf "%s\n" "$hard_links" >&6; }
-  if test no = "$hard_links"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
-printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
-    need_locks=warn
-  fi
-else
-  need_locks=no
-fi
-
-
-
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
-printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
-
-  runpath_var=
-  allow_undefined_flag=
-  always_export_symbols=no
-  archive_cmds=
-  archive_expsym_cmds=
-  compiler_needs_object=no
-  enable_shared_with_static_runtimes=no
-  export_dynamic_flag_spec=
-  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-  hardcode_automatic=no
-  hardcode_direct=no
-  hardcode_direct_absolute=no
-  hardcode_libdir_flag_spec=
-  hardcode_libdir_separator=
-  hardcode_minus_L=no
-  hardcode_shlibpath_var=unsupported
-  inherit_rpath=no
-  link_all_deplibs=unknown
-  module_cmds=
-  module_expsym_cmds=
-  old_archive_from_new_cmds=
-  old_archive_from_expsyms_cmds=
-  thread_safe_flag_spec=
-  whole_archive_flag_spec=
-  # include_expsyms should be a list of space-separated symbols to be *always*
-  # included in the symbol list
-  include_expsyms=
-  # exclude_expsyms can be an extended regexp of symbols to exclude
-  # it will be wrapped by ' (' and ')$', so one must not match beginning or
-  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
-  # as well as any symbol that contains 'd'.
-  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
-  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
-  # platforms (ab)use it in PIC code, but their linkers get confused if
-  # the symbol is explicitly referenced.  Since portable code cannot
-  # rely on this symbol name, it's probably fine to never include it in
-  # preloaded symbol tables.
-  # Exclude shared library initialization/finalization symbols.
-  extract_expsyms_cmds=
-
-  case $host_os in
-  cygwin* | mingw* | pw32* | cegcc*)
-    # FIXME: the MSVC++ port hasn't been tested in a loooong time
-    # When not using gcc, we currently assume that we are using
-    # Microsoft Visual C++.
-    if test yes != "$GCC"; then
-      with_gnu_ld=no
-    fi
-    ;;
-  interix*)
-    # we just hope/assume this is gcc and not c89 (= MSVC++)
-    with_gnu_ld=yes
-    ;;
-  openbsd* | bitrig*)
-    with_gnu_ld=no
-    ;;
-  linux* | k*bsd*-gnu | gnu*)
-    link_all_deplibs=no
-    ;;
-  esac
-
-  ld_shlibs=yes
-
-  # On some targets, GNU ld is compatible enough with the native linker
-  # that we're better off using the native interface for both.
-  lt_use_gnu_ld_interface=no
-  if test yes = "$with_gnu_ld"; then
-    case $host_os in
-      aix*)
-	# The AIX port of GNU ld has always aspired to compatibility
-	# with the native linker.  However, as the warning in the GNU ld
-	# block says, versions before 2.19.5* couldn't really create working
-	# shared libraries, regardless of the interface used.
-	case `$LD -v 2>&1` in
-	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
-	  *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
-	  *\ \(GNU\ Binutils\)\ [3-9]*) ;;
-	  *)
-	    lt_use_gnu_ld_interface=yes
-	    ;;
-	esac
-	;;
-      *)
-	lt_use_gnu_ld_interface=yes
-	;;
-    esac
-  fi
-
-  if test yes = "$lt_use_gnu_ld_interface"; then
-    # If archive_cmds runs LD, not CC, wlarc should be empty
-    wlarc='$wl'
-
-    # Set some defaults for GNU ld with shared library support. These
-    # are reset later if shared libraries are not supported. Putting them
-    # here allows them to be overridden if necessary.
-    runpath_var=LD_RUN_PATH
-    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-    export_dynamic_flag_spec='$wl--export-dynamic'
-    # ancient GNU ld didn't support --whole-archive et. al.
-    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
-      whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-    else
-      whole_archive_flag_spec=
-    fi
-    supports_anon_versioning=no
-    case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
-      *GNU\ gold*) supports_anon_versioning=yes ;;
-      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
-      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
-      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
-      *\ 2.11.*) ;; # other 2.11 versions
-      *) supports_anon_versioning=yes ;;
-    esac
-
-    # See if GNU ld supports shared libraries.
-    case $host_os in
-    aix[3-9]*)
-      # On AIX/PPC, the GNU linker is very broken
-      if test ia64 != "$host_cpu"; then
-	ld_shlibs=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: the GNU linker, at least up to release 2.19, is reported
-*** to be unable to reliably create shared libraries on AIX.
-*** Therefore, libtool is disabling shared libraries support.  If you
-*** really care for shared libraries, you may want to install binutils
-*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
-*** You will then need to restart the configuration process.
-
-_LT_EOF
-      fi
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-            archive_expsym_cmds=''
-        ;;
-      m68k)
-            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
-            hardcode_libdir_flag_spec='-L$libdir'
-            hardcode_minus_L=yes
-        ;;
-      esac
-      ;;
-
-    beos*)
-      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	allow_undefined_flag=unsupported
-	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
-	# support --undefined.  This deserves some investigation.  FIXME
-	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-      else
-	ld_shlibs=no
-      fi
-      ;;
-
-    cygwin* | mingw* | pw32* | cegcc*)
-      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
-      # as there is no search path for DLLs.
-      hardcode_libdir_flag_spec='-L$libdir'
-      export_dynamic_flag_spec='$wl--export-all-symbols'
-      allow_undefined_flag=unsupported
-      always_export_symbols=no
-      enable_shared_with_static_runtimes=yes
-      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
-      exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
-
-      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	# If the export-symbols file already is a .def file, use it as
-	# is; otherwise, prepend EXPORTS...
-	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
-          cp $export_symbols $output_objdir/$soname.def;
-        else
-          echo EXPORTS > $output_objdir/$soname.def;
-          cat $export_symbols >> $output_objdir/$soname.def;
-        fi~
-        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-      else
-	ld_shlibs=no
-      fi
-      ;;
-
-    haiku*)
-      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-      link_all_deplibs=yes
-      ;;
-
-    os2*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_minus_L=yes
-      allow_undefined_flag=unsupported
-      shrext_cmds=.dll
-      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	prefix_cmds="$SED"~
-	if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	  prefix_cmds="$prefix_cmds -e 1d";
-	fi~
-	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-      enable_shared_with_static_runtimes=yes
-      ;;
-
-    interix[3-9]*)
-      hardcode_direct=no
-      hardcode_shlibpath_var=no
-      hardcode_libdir_flag_spec='$wl-rpath,$libdir'
-      export_dynamic_flag_spec='$wl-E'
-      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
-      # Instead, shared libraries are loaded at an image base (0x10000000 by
-      # default) and relocated if they conflict, which is a slow very memory
-      # consuming and fragmenting process.  To avoid this, we pick a random,
-      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
-      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      ;;
-
-    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
-      tmp_diet=no
-      if test linux-dietlibc = "$host_os"; then
-	case $cc_basename in
-	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
-	esac
-      fi
-      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
-	 && test no = "$tmp_diet"
-      then
-	tmp_addflag=' $pic_flag'
-	tmp_sharedflag='-shared'
-	case $cc_basename,$host_cpu in
-        pgcc*)				# Portland Group C compiler
-	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  tmp_addflag=' $pic_flag'
-	  ;;
-	pgf77* | pgf90* | pgf95* | pgfortran*)
-					# Portland Group f77 and f90 compilers
-	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  tmp_addflag=' $pic_flag -Mnomain' ;;
-	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
-	  tmp_addflag=' -i_dynamic' ;;
-	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
-	  tmp_addflag=' -i_dynamic -nofor_main' ;;
-	ifc* | ifort*)			# Intel Fortran compiler
-	  tmp_addflag=' -nofor_main' ;;
-	lf95*)				# Lahey Fortran 8.1
-	  whole_archive_flag_spec=
-	  tmp_sharedflag='--shared' ;;
-        nagfor*)                        # NAGFOR 5.3
-          tmp_sharedflag='-Wl,-shared' ;;
-	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
-	  tmp_sharedflag='-qmkshrobj'
-	  tmp_addflag= ;;
-	nvcc*)	# Cuda Compiler Driver 2.2
-	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  compiler_needs_object=yes
-	  ;;
-	esac
-	case `$CC -V 2>&1 | sed 5q` in
-	*Sun\ C*)			# Sun C 5.9
-	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  compiler_needs_object=yes
-	  tmp_sharedflag='-G' ;;
-	*Sun\ F*)			# Sun Fortran 8.3
-	  tmp_sharedflag='-G' ;;
-	esac
-	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-
-        if test yes = "$supports_anon_versioning"; then
-          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-            echo "local: *; };" >> $output_objdir/$libname.ver~
-            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
-        fi
-
-	case $cc_basename in
-	tcc*)
-	  export_dynamic_flag_spec='-rdynamic'
-	  ;;
-	xlf* | bgf* | bgxlf* | mpixlf*)
-	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
-	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
-	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
-	  if test yes = "$supports_anon_versioning"; then
-	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
-              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-              echo "local: *; };" >> $output_objdir/$libname.ver~
-              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
-	  fi
-	  ;;
-	esac
-      else
-        ld_shlibs=no
-      fi
-      ;;
-
-    netbsd* | netbsdelf*-gnu)
-      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
-	wlarc=
-      else
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      fi
-      ;;
-
-    solaris*)
-      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
-	ld_shlibs=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: The releases 2.8.* of the GNU linker cannot reliably
-*** create shared libraries on Solaris systems.  Therefore, libtool
-*** is disabling shared libraries support.  We urge you to upgrade GNU
-*** binutils to release 2.9.1 or newer.  Another option is to modify
-*** your PATH or compiler configuration so that the native linker is
-*** used, and then restart.
-
-_LT_EOF
-      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      else
-	ld_shlibs=no
-      fi
-      ;;
-
-    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
-      case `$LD -v 2>&1` in
-        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
-	ld_shlibs=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
-*** reliably create shared libraries on SCO systems.  Therefore, libtool
-*** is disabling shared libraries support.  We urge you to upgrade GNU
-*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
-*** your PATH or compiler configuration so that the native linker is
-*** used, and then restart.
-
-_LT_EOF
-	;;
-	*)
-	  # For security reasons, it is highly recommended that you always
-	  # use absolute paths for naming shared libraries, and exclude the
-	  # DT_RUNPATH tag from executables and libraries.  But doing so
-	  # requires that you compile everything twice, which is a pain.
-	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	  else
-	    ld_shlibs=no
-	  fi
-	;;
-      esac
-      ;;
-
-    sunos4*)
-      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-      wlarc=
-      hardcode_direct=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    *)
-      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      else
-	ld_shlibs=no
-      fi
-      ;;
-    esac
-
-    if test no = "$ld_shlibs"; then
-      runpath_var=
-      hardcode_libdir_flag_spec=
-      export_dynamic_flag_spec=
-      whole_archive_flag_spec=
-    fi
-  else
-    # PORTME fill in a description of your system's linker (not GNU ld)
-    case $host_os in
-    aix3*)
-      allow_undefined_flag=unsupported
-      always_export_symbols=yes
-      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
-      # Note: this linker hardcodes the directories in LIBPATH if there
-      # are no directories specified by -L.
-      hardcode_minus_L=yes
-      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
-	# Neither direct hardcoding nor static linking is supported with a
-	# broken collect2.
-	hardcode_direct=unsupported
-      fi
-      ;;
-
-    aix[4-9]*)
-      if test ia64 = "$host_cpu"; then
-	# On IA64, the linker does run time linking by default, so we don't
-	# have to do anything special.
-	aix_use_runtimelinking=no
-	exp_sym_flag='-Bexport'
-	no_entry_flag=
-      else
-	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
-	# Without the "-l" option, or with the "-B" option, AIX nm treats
-	# weak defined symbols like other global defined symbols, whereas
-	# GNU nm marks them as "W".
-	# While the 'weak' keyword is ignored in the Export File, we need
-	# it in the Import File for the 'aix-soname' feature, so we have
-	# to replace the "-B" option with "-P" for AIX nm.
-	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
-	else
-	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
-	fi
-	aix_use_runtimelinking=no
-
-	# Test if we are trying to use run time linking or normal
-	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# have runtime linking enabled, and use it for executables.
-	# For shared libraries, we enable/disable runtime linking
-	# depending on the kind of the shared library created -
-	# when "with_aix_soname,aix_use_runtimelinking" is:
-	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
-	# "aix,yes"  lib.so          shared, rtl:yes, for executables
-	#            lib.a           static archive
-	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
-	#            lib.a(lib.so.V) shared, rtl:no,  for executables
-	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
-	#            lib.a(lib.so.V) shared, rtl:no
-	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
-	#            lib.a           static archive
-	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
-	  for ld_flag in $LDFLAGS; do
-	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
-	    aix_use_runtimelinking=yes
-	    break
-	  fi
-	  done
-	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
-	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
-	    # so we don't have lib.a shared libs to link our executables.
-	    # We have to force runtime linking in this case.
-	    aix_use_runtimelinking=yes
-	    LDFLAGS="$LDFLAGS -Wl,-brtl"
-	  fi
-	  ;;
-	esac
-
-	exp_sym_flag='-bexport'
-	no_entry_flag='-bnoentry'
-      fi
-
-      # When large executables or shared objects are built, AIX ld can
-      # have problems creating the table of contents.  If linking a library
-      # or program results in "error TOC overflow" add -mminimal-toc to
-      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
-      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
-      archive_cmds=''
-      hardcode_direct=yes
-      hardcode_direct_absolute=yes
-      hardcode_libdir_separator=':'
-      link_all_deplibs=yes
-      file_list_spec='$wl-f,'
-      case $with_aix_soname,$aix_use_runtimelinking in
-      aix,*) ;; # traditional, no import file
-      svr4,* | *,yes) # use import file
-	# The Import File defines what to hardcode.
-	hardcode_direct=no
-	hardcode_direct_absolute=no
-	;;
-      esac
-
-      if test yes = "$GCC"; then
-	case $host_os in aix4.[012]|aix4.[012].*)
-	# We only want to do this on AIX 4.2 and lower, the check
-	# below for broken collect2 doesn't work under 4.3+
-	  collect2name=`$CC -print-prog-name=collect2`
-	  if test -f "$collect2name" &&
-	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
-	  then
-	  # We have reworked collect2
-	  :
-	  else
-	  # We have old collect2
-	  hardcode_direct=unsupported
-	  # It fails to find uninstalled libraries when the uninstalled
-	  # path is not listed in the libpath.  Setting hardcode_minus_L
-	  # to unsupported forces relinking
-	  hardcode_minus_L=yes
-	  hardcode_libdir_flag_spec='-L$libdir'
-	  hardcode_libdir_separator=
-	  fi
-	  ;;
-	esac
-	shared_flag='-shared'
-	if test yes = "$aix_use_runtimelinking"; then
-	  shared_flag="$shared_flag "'$wl-G'
-	fi
-	# Need to ensure runtime linking is disabled for the traditional
-	# shared library, or the linker may eventually find shared libraries
-	# /with/ Import File - we do not want to mix them.
-	shared_flag_aix='-shared'
-	shared_flag_svr4='-shared $wl-G'
-      else
-	# not using gcc
-	if test ia64 = "$host_cpu"; then
-	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
-	# chokes on -Wl,-G. The following line is correct:
-	  shared_flag='-G'
-	else
-	  if test yes = "$aix_use_runtimelinking"; then
-	    shared_flag='$wl-G'
-	  else
-	    shared_flag='$wl-bM:SRE'
-	  fi
-	  shared_flag_aix='$wl-bM:SRE'
-	  shared_flag_svr4='$wl-G'
-	fi
-      fi
-
-      export_dynamic_flag_spec='$wl-bexpall'
-      # It seems that -bexpall does not export symbols beginning with
-      # underscore (_), so it is better to generate a list of symbols to export.
-      always_export_symbols=yes
-      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
-	# Warning - without using the other runtime loading flags (-brtl),
-	# -berok will link without error, but may produce a broken library.
-	allow_undefined_flag='-berok'
-        # Determine the default libpath from the value encoded in an
-        # empty executable.
-        if test set = "${lt_cv_aix_libpath+set}"; then
-  aix_libpath=$lt_cv_aix_libpath
-else
-  if test ${lt_cv_aix_libpath_+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-
-  lt_aix_libpath_sed='
-      /Import File Strings/,/^$/ {
-	  /^0/ {
-	      s/^0  *\([^ ]*\) *$/\1/
-	      p
-	  }
-      }'
-  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  # Check for a 64-bit object if we didn't find anything.
-  if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-  if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_=/usr/lib:/lib
-  fi
-
-fi
-
-  aix_libpath=$lt_cv_aix_libpath_
-fi
-
-        hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
-        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
-      else
-	if test ia64 = "$host_cpu"; then
-	  hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib'
-	  allow_undefined_flag="-z nodefs"
-	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
-	else
-	 # Determine the default libpath from the value encoded in an
-	 # empty executable.
-	 if test set = "${lt_cv_aix_libpath+set}"; then
-  aix_libpath=$lt_cv_aix_libpath
-else
-  if test ${lt_cv_aix_libpath_+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-
-  lt_aix_libpath_sed='
-      /Import File Strings/,/^$/ {
-	  /^0/ {
-	      s/^0  *\([^ ]*\) *$/\1/
-	      p
-	  }
-      }'
-  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  # Check for a 64-bit object if we didn't find anything.
-  if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-  if test -z "$lt_cv_aix_libpath_"; then
-    lt_cv_aix_libpath_=/usr/lib:/lib
-  fi
-
-fi
-
-  aix_libpath=$lt_cv_aix_libpath_
-fi
-
-	 hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
-	  # Warning - without using the other run time loading flags,
-	  # -berok will link without error, but may produce a broken library.
-	  no_undefined_flag=' $wl-bernotok'
-	  allow_undefined_flag=' $wl-berok'
-	  if test yes = "$with_gnu_ld"; then
-	    # We only use this code for GNU lds that support --whole-archive.
-	    whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive'
-	  else
-	    # Exported symbols can be pulled into shared objects from archives
-	    whole_archive_flag_spec='$convenience'
-	  fi
-	  archive_cmds_need_lc=yes
-	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
-	  # -brtl affects multiple linker settings, -berok does not and is overridden later
-	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
-	  if test svr4 != "$with_aix_soname"; then
-	    # This is similar to how AIX traditionally builds its shared libraries.
-	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
-	  fi
-	  if test aix != "$with_aix_soname"; then
-	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
-	  else
-	    # used by -dlpreopen to get the symbols
-	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
-	  fi
-	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
-	fi
-      fi
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-            archive_expsym_cmds=''
-        ;;
-      m68k)
-            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
-            hardcode_libdir_flag_spec='-L$libdir'
-            hardcode_minus_L=yes
-        ;;
-      esac
-      ;;
-
-    bsdi[45]*)
-      export_dynamic_flag_spec=-rdynamic
-      ;;
-
-    cygwin* | mingw* | pw32* | cegcc*)
-      # When not using gcc, we currently assume that we are using
-      # Microsoft Visual C++.
-      # hardcode_libdir_flag_spec is actually meaningless, as there is
-      # no search path for DLLs.
-      case $cc_basename in
-      cl*)
-	# Native MSVC
-	hardcode_libdir_flag_spec=' '
-	allow_undefined_flag=unsupported
-	always_export_symbols=yes
-	file_list_spec='@'
-	# Tell ltmain to make .lib files, not .a files.
-	libext=lib
-	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=.dll
-	# FIXME: Setting linknames here is a bad hack.
-	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
-	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
-            cp "$export_symbols" "$output_objdir/$soname.def";
-            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
-          else
-            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
-          fi~
-          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-          linknames='
-	# The linker will not automatically build a static lib if we build a DLL.
-	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
-	enable_shared_with_static_runtimes=yes
-	exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
-	export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
-	# Don't use ranlib
-	old_postinstall_cmds='chmod 644 $oldlib'
-	postlink_cmds='lt_outputfile="@OUTPUT@"~
-          lt_tool_outputfile="@TOOL_OUTPUT@"~
-          case $lt_outputfile in
-            *.exe|*.EXE) ;;
-            *)
-              lt_outputfile=$lt_outputfile.exe
-              lt_tool_outputfile=$lt_tool_outputfile.exe
-              ;;
-          esac~
-          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
-            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-            $RM "$lt_outputfile.manifest";
-          fi'
-	;;
-      *)
-	# Assume MSVC wrapper
-	hardcode_libdir_flag_spec=' '
-	allow_undefined_flag=unsupported
-	# Tell ltmain to make .lib files, not .a files.
-	libext=lib
-	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=.dll
-	# FIXME: Setting linknames here is a bad hack.
-	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
-	# The linker will automatically build a .lib file if we build a DLL.
-	old_archive_from_new_cmds='true'
-	# FIXME: Should let the user specify the lib program.
-	old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
-	enable_shared_with_static_runtimes=yes
-	;;
-      esac
-      ;;
-
-    darwin* | rhapsody*)
-
-
-  archive_cmds_need_lc=no
-  hardcode_direct=no
-  hardcode_automatic=yes
-  hardcode_shlibpath_var=unsupported
-  if test yes = "$lt_cv_ld_force_load"; then
-    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
-
-  else
-    whole_archive_flag_spec=''
-  fi
-  link_all_deplibs=yes
-  allow_undefined_flag=$_lt_dar_allow_undefined
-  case $cc_basename in
-     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
-     *) _lt_dar_can_shared=$GCC ;;
-  esac
-  if test yes = "$_lt_dar_can_shared"; then
-    output_verbose_link_cmd=func_echo_all
-    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
-    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
-
-  else
-  ld_shlibs=no
-  fi
-
-      ;;
-
-    dgux*)
-      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_shlibpath_var=no
-      ;;
-
-    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
-    # support.  Future versions do this automatically, but an explicit c++rt0.o
-    # does not break anything, and helps significantly (at the cost of a little
-    # extra space).
-    freebsd2.2*)
-      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
-    freebsd2.*)
-      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-      hardcode_direct=yes
-      hardcode_minus_L=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
-      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    hpux9*)
-      if test yes = "$GCC"; then
-	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-      else
-	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-      fi
-      hardcode_libdir_flag_spec='$wl+b $wl$libdir'
-      hardcode_libdir_separator=:
-      hardcode_direct=yes
-
-      # hardcode_minus_L: Not really in the search PATH,
-      # but as the default location of the library.
-      hardcode_minus_L=yes
-      export_dynamic_flag_spec='$wl-E'
-      ;;
-
-    hpux10*)
-      if test yes,no = "$GCC,$with_gnu_ld"; then
-	archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
-      fi
-      if test no = "$with_gnu_ld"; then
-	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
-	hardcode_libdir_separator=:
-	hardcode_direct=yes
-	hardcode_direct_absolute=yes
-	export_dynamic_flag_spec='$wl-E'
-	# hardcode_minus_L: Not really in the search PATH,
-	# but as the default location of the library.
-	hardcode_minus_L=yes
-      fi
-      ;;
-
-    hpux11*)
-      if test yes,no = "$GCC,$with_gnu_ld"; then
-	case $host_cpu in
-	hppa*64*)
-	  archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	ia64*)
-	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	esac
-      else
-	case $host_cpu in
-	hppa*64*)
-	  archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	ia64*)
-	  archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-
-	  # Older versions of the 11.00 compiler do not understand -b yet
-	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
-	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
-printf %s "checking if $CC understands -b... " >&6; }
-if test ${lt_cv_prog_compiler__b+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler__b=no
-   save_LDFLAGS=$LDFLAGS
-   LDFLAGS="$LDFLAGS -b"
-   echo "$lt_simple_link_test_code" > conftest.$ac_ext
-   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
-     # The linker can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     if test -s conftest.err; then
-       # Append any errors to the config.log.
-       cat conftest.err 1>&5
-       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
-       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-       if diff conftest.exp conftest.er2 >/dev/null; then
-         lt_cv_prog_compiler__b=yes
-       fi
-     else
-       lt_cv_prog_compiler__b=yes
-     fi
-   fi
-   $RM -r conftest*
-   LDFLAGS=$save_LDFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
-printf "%s\n" "$lt_cv_prog_compiler__b" >&6; }
-
-if test yes = "$lt_cv_prog_compiler__b"; then
-    archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
-else
-    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
-fi
-
-	  ;;
-	esac
-      fi
-      if test no = "$with_gnu_ld"; then
-	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
-	hardcode_libdir_separator=:
-
-	case $host_cpu in
-	hppa*64*|ia64*)
-	  hardcode_direct=no
-	  hardcode_shlibpath_var=no
-	  ;;
-	*)
-	  hardcode_direct=yes
-	  hardcode_direct_absolute=yes
-	  export_dynamic_flag_spec='$wl-E'
-
-	  # hardcode_minus_L: Not really in the search PATH,
-	  # but as the default location of the library.
-	  hardcode_minus_L=yes
-	  ;;
-	esac
-      fi
-      ;;
-
-    irix5* | irix6* | nonstopux*)
-      if test yes = "$GCC"; then
-	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	# Try to use the -exported_symbol ld option, if it does not
-	# work, assume that -exports_file does not work either and
-	# implicitly export all symbols.
-	# This should be the same for all languages, so no per-tag cache variable.
-	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
-printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
-if test ${lt_cv_irix_exported_symbol+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  save_LDFLAGS=$LDFLAGS
-	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
-	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-int foo (void) { return 0; }
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  lt_cv_irix_exported_symbol=yes
-else $as_nop
-  lt_cv_irix_exported_symbol=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-           LDFLAGS=$save_LDFLAGS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
-printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
-	if test yes = "$lt_cv_irix_exported_symbol"; then
-          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
-	fi
-	link_all_deplibs=no
-      else
-	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
-      fi
-      archive_cmds_need_lc='no'
-      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-      hardcode_libdir_separator=:
-      inherit_rpath=yes
-      link_all_deplibs=yes
-      ;;
-
-    linux*)
-      case $cc_basename in
-      tcc*)
-	# Fabrice Bellard et al's Tiny C Compiler
-	ld_shlibs=yes
-	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	;;
-      esac
-      ;;
-
-    netbsd* | netbsdelf*-gnu)
-      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
-      else
-	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
-      fi
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_direct=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    newsos6)
-      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      hardcode_direct=yes
-      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-      hardcode_libdir_separator=:
-      hardcode_shlibpath_var=no
-      ;;
-
-    *nto* | *qnx*)
-      ;;
-
-    openbsd* | bitrig*)
-      if test -f /usr/libexec/ld.so; then
-	hardcode_direct=yes
-	hardcode_shlibpath_var=no
-	hardcode_direct_absolute=yes
-	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
-	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
-	  export_dynamic_flag_spec='$wl-E'
-	else
-	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
-	fi
-      else
-	ld_shlibs=no
-      fi
-      ;;
-
-    os2*)
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_minus_L=yes
-      allow_undefined_flag=unsupported
-      shrext_cmds=.dll
-      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	prefix_cmds="$SED"~
-	if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	  prefix_cmds="$prefix_cmds -e 1d";
-	fi~
-	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-      enable_shared_with_static_runtimes=yes
-      ;;
-
-    osf3*)
-      if test yes = "$GCC"; then
-	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
-	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-      else
-	allow_undefined_flag=' -expect_unresolved \*'
-	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-      fi
-      archive_cmds_need_lc='no'
-      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-      hardcode_libdir_separator=:
-      ;;
-
-    osf4* | osf5*)	# as osf3* with the addition of -msym flag
-      if test yes = "$GCC"; then
-	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
-	archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
-      else
-	allow_undefined_flag=' -expect_unresolved \*'
-	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
-          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
-
-	# Both c and cxx compiler support -rpath directly
-	hardcode_libdir_flag_spec='-rpath $libdir'
-      fi
-      archive_cmds_need_lc='no'
-      hardcode_libdir_separator=:
-      ;;
-
-    solaris*)
-      no_undefined_flag=' -z defs'
-      if test yes = "$GCC"; then
-	wlarc='$wl'
-	archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
-      else
-	case `$CC -V 2>&1` in
-	*"Compilers 5.0"*)
-	  wlarc=''
-	  archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
-	  ;;
-	*)
-	  wlarc='$wl'
-	  archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
-	  ;;
-	esac
-      fi
-      hardcode_libdir_flag_spec='-R$libdir'
-      hardcode_shlibpath_var=no
-      case $host_os in
-      solaris2.[0-5] | solaris2.[0-5].*) ;;
-      *)
-	# The compiler driver will combine and reorder linker options,
-	# but understands '-z linker_flag'.  GCC discards it without '$wl',
-	# but is careful enough not to reorder.
-	# Supported since Solaris 2.6 (maybe 2.5.1?)
-	if test yes = "$GCC"; then
-	  whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
-	else
-	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
-	fi
-	;;
-      esac
-      link_all_deplibs=yes
-      ;;
-
-    sunos4*)
-      if test sequent = "$host_vendor"; then
-	# Use $CC to link under sequent, because it throws in some extra .o
-	# files that make .init and .fini sections work.
-	archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
-      fi
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_direct=yes
-      hardcode_minus_L=yes
-      hardcode_shlibpath_var=no
-      ;;
-
-    sysv4)
-      case $host_vendor in
-	sni)
-	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  hardcode_direct=yes # is this really true???
-	;;
-	siemens)
-	  ## LD is ld it makes a PLAMLIB
-	  ## CC just makes a GrossModule.
-	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
-	  reload_cmds='$CC -r -o $output$reload_objs'
-	  hardcode_direct=no
-        ;;
-	motorola)
-	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
-	;;
-      esac
-      runpath_var='LD_RUN_PATH'
-      hardcode_shlibpath_var=no
-      ;;
-
-    sysv4.3*)
-      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      hardcode_shlibpath_var=no
-      export_dynamic_flag_spec='-Bexport'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	hardcode_shlibpath_var=no
-	runpath_var=LD_RUN_PATH
-	hardcode_runpath_var=yes
-	ld_shlibs=yes
-      fi
-      ;;
-
-    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
-      no_undefined_flag='$wl-z,text'
-      archive_cmds_need_lc=no
-      hardcode_shlibpath_var=no
-      runpath_var='LD_RUN_PATH'
-
-      if test yes = "$GCC"; then
-	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      fi
-      ;;
-
-    sysv5* | sco3.2v5* | sco5v6*)
-      # Note: We CANNOT use -z defs as we might desire, because we do not
-      # link with -lc, and that would cause any symbols used from libc to
-      # always be unresolved, which means just about no library would
-      # ever link correctly.  If we're not using GNU ld we use -z text
-      # though, which does catch some bad symbols but isn't as heavy-handed
-      # as -z defs.
-      no_undefined_flag='$wl-z,text'
-      allow_undefined_flag='$wl-z,nodefs'
-      archive_cmds_need_lc=no
-      hardcode_shlibpath_var=no
-      hardcode_libdir_flag_spec='$wl-R,$libdir'
-      hardcode_libdir_separator=':'
-      link_all_deplibs=yes
-      export_dynamic_flag_spec='$wl-Bexport'
-      runpath_var='LD_RUN_PATH'
-
-      if test yes = "$GCC"; then
-	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      fi
-      ;;
-
-    uts4*)
-      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      hardcode_libdir_flag_spec='-L$libdir'
-      hardcode_shlibpath_var=no
-      ;;
-
-    *)
-      ld_shlibs=no
-      ;;
-    esac
-
-    if test sni = "$host_vendor"; then
-      case $host in
-      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
-	export_dynamic_flag_spec='$wl-Blargedynsym'
-	;;
-      esac
-    fi
-  fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
-printf "%s\n" "$ld_shlibs" >&6; }
-test no = "$ld_shlibs" && can_build_shared=no
-
-with_gnu_ld=$with_gnu_ld
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#
-# Do we need to explicitly link libc?
-#
-case "x$archive_cmds_need_lc" in
-x|xyes)
-  # Assume -lc should be added
-  archive_cmds_need_lc=yes
-
-  if test yes,yes = "$GCC,$enable_shared"; then
-    case $archive_cmds in
-    *'~'*)
-      # FIXME: we may have to deal with multi-command sequences.
-      ;;
-    '$CC '*)
-      # Test whether the compiler implicitly links with -lc since on some
-      # systems, -lgcc has to come before -lc. If gcc already passes -lc
-      # to ld, don't add -lc before -lgcc.
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
-printf %s "checking whether -lc should be explicitly linked in... " >&6; }
-if test ${lt_cv_archive_cmds_need_lc+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  $RM conftest*
-	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } 2>conftest.err; then
-	  soname=conftest
-	  lib=conftest
-	  libobjs=conftest.$ac_objext
-	  deplibs=
-	  wl=$lt_prog_compiler_wl
-	  pic_flag=$lt_prog_compiler_pic
-	  compiler_flags=-v
-	  linker_flags=-v
-	  verstring=
-	  output_objdir=.
-	  libname=conftest
-	  lt_save_allow_undefined_flag=$allow_undefined_flag
-	  allow_undefined_flag=
-	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
-  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-	  then
-	    lt_cv_archive_cmds_need_lc=no
-	  else
-	    lt_cv_archive_cmds_need_lc=yes
-	  fi
-	  allow_undefined_flag=$lt_save_allow_undefined_flag
-	else
-	  cat conftest.err 1>&5
-	fi
-	$RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
-printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; }
-      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
-      ;;
-    esac
-  fi
-  ;;
-esac
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
-printf %s "checking dynamic linker characteristics... " >&6; }
-
-if test yes = "$GCC"; then
-  case $host_os in
-    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
-    *) lt_awk_arg='/^libraries:/' ;;
-  esac
-  case $host_os in
-    mingw* | cegcc*) lt_sed_strip_eq='s|=\([A-Za-z]:\)|\1|g' ;;
-    *) lt_sed_strip_eq='s|=/|/|g' ;;
-  esac
-  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
-  case $lt_search_path_spec in
-  *\;*)
-    # if the path contains ";" then we assume it to be the separator
-    # otherwise default to the standard path separator (i.e. ":") - it is
-    # assumed that no part of a normal pathname contains ";" but that should
-    # okay in the real world where ";" in dirpaths is itself problematic.
-    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
-    ;;
-  *)
-    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
-    ;;
-  esac
-  # Ok, now we have the path, separated by spaces, we can step through it
-  # and add multilib dir if necessary...
-  lt_tmp_lt_search_path_spec=
-  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
-  # ...but if some path component already ends with the multilib dir we assume
-  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
-  case "$lt_multi_os_dir; $lt_search_path_spec " in
-  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
-    lt_multi_os_dir=
-    ;;
-  esac
-  for lt_sys_path in $lt_search_path_spec; do
-    if test -d "$lt_sys_path$lt_multi_os_dir"; then
-      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
-    elif test -n "$lt_multi_os_dir"; then
-      test -d "$lt_sys_path" && \
-	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
-    fi
-  done
-  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
-BEGIN {RS = " "; FS = "/|\n";} {
-  lt_foo = "";
-  lt_count = 0;
-  for (lt_i = NF; lt_i > 0; lt_i--) {
-    if ($lt_i != "" && $lt_i != ".") {
-      if ($lt_i == "..") {
-        lt_count++;
-      } else {
-        if (lt_count == 0) {
-          lt_foo = "/" $lt_i lt_foo;
-        } else {
-          lt_count--;
-        }
-      }
-    }
-  }
-  if (lt_foo != "") { lt_freq[lt_foo]++; }
-  if (lt_freq[lt_foo] == 1) { print lt_foo; }
-}'`
-  # AWK program above erroneously prepends '/' to C:/dos/paths
-  # for these hosts.
-  case $host_os in
-    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
-      $SED 's|/\([A-Za-z]:\)|\1|g'` ;;
-  esac
-  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
-else
-  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-fi
-library_names_spec=
-libname_spec='lib$name'
-soname_spec=
-shrext_cmds=.so
-postinstall_cmds=
-postuninstall_cmds=
-finish_cmds=
-finish_eval=
-shlibpath_var=
-shlibpath_overrides_runpath=unknown
-version_type=none
-dynamic_linker="$host_os ld.so"
-sys_lib_dlsearch_path_spec="/lib /usr/lib"
-need_lib_prefix=unknown
-hardcode_into_libs=no
-
-# when you set need_version to no, make sure it does not cause -set_version
-# flags to be left without arguments
-need_version=unknown
-
-
-
-case $host_os in
-aix3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
-  shlibpath_var=LIBPATH
-
-  # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='$libname$release$shared_ext$major'
-  ;;
-
-aix[4-9]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  hardcode_into_libs=yes
-  if test ia64 = "$host_cpu"; then
-    # AIX 5 supports IA64
-    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
-    shlibpath_var=LD_LIBRARY_PATH
-  else
-    # With GCC up to 2.95.x, collect2 would create an import file
-    # for dependence libraries.  The import file would start with
-    # the line '#! .'.  This would cause the generated library to
-    # depend on '.', always an invalid library.  This was fixed in
-    # development snapshots of GCC prior to 3.0.
-    case $host_os in
-      aix4 | aix4.[01] | aix4.[01].*)
-      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
-	   echo ' yes '
-	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
-	:
-      else
-	can_build_shared=no
-      fi
-      ;;
-    esac
-    # Using Import Files as archive members, it is possible to support
-    # filename-based versioning of shared library archives on AIX. While
-    # this would work for both with and without runtime linking, it will
-    # prevent static linking of such archives. So we do filename-based
-    # shared library versioning with .so extension only, which is used
-    # when both runtime linking and shared linking is enabled.
-    # Unfortunately, runtime linking may impact performance, so we do
-    # not want this to be the default eventually. Also, we use the
-    # versioned .so libs for executables only if there is the -brtl
-    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
-    # To allow for filename-based versioning support, we need to create
-    # libNAME.so.V as an archive file, containing:
-    # *) an Import File, referring to the versioned filename of the
-    #    archive as well as the shared archive member, telling the
-    #    bitwidth (32 or 64) of that shared object, and providing the
-    #    list of exported symbols of that shared object, eventually
-    #    decorated with the 'weak' keyword
-    # *) the shared object with the F_LOADONLY flag set, to really avoid
-    #    it being seen by the linker.
-    # At run time we better use the real file rather than another symlink,
-    # but for link time we create the symlink libNAME.so -> libNAME.so.V
-
-    case $with_aix_soname,$aix_use_runtimelinking in
-    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
-    # soname into executable. Probably we can add versioning support to
-    # collect2, so additional links can be useful in future.
-    aix,yes) # traditional libtool
-      dynamic_linker='AIX unversionable lib.so'
-      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
-      # instead of lib<name>.a to let people know that these are not
-      # typical AIX shared libraries.
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      ;;
-    aix,no) # traditional AIX only
-      dynamic_linker='AIX lib.a(lib.so.V)'
-      # We preserve .a as extension for shared libraries through AIX4.2
-      # and later when we are not doing run time linking.
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      ;;
-    svr4,*) # full svr4 only
-      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,yes) # both, prefer svr4
-      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # unpreferred sharedlib libNAME.a needs extra handling
-      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
-      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,no) # both, prefer aix
-      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
-      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
-      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
-      ;;
-    esac
-    shlibpath_var=LIBPATH
-  fi
-  ;;
-
-amigaos*)
-  case $host_cpu in
-  powerpc)
-    # Since July 2007 AmigaOS4 officially supports .so libraries.
-    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    ;;
-  m68k)
-    library_names_spec='$libname.ixlibrary $libname.a'
-    # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
-    ;;
-  esac
-  ;;
-
-beos*)
-  library_names_spec='$libname$shared_ext'
-  dynamic_linker="$host_os ld.so"
-  shlibpath_var=LIBRARY_PATH
-  ;;
-
-bsdi[45]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
-  # the default ld.so.conf also contains /usr/contrib/lib and
-  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
-  # libtool to hard-code these into programs
-  ;;
-
-cygwin* | mingw* | pw32* | cegcc*)
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-
-  case $GCC,$cc_basename in
-  yes,*)
-    # gcc
-    library_names_spec='$libname.dll.a'
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname~
-      chmod a+x \$dldir/$dlname~
-      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-      fi'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-
-    case $host_os in
-    cygwin*)
-      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-
-      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
-      ;;
-    mingw* | cegcc*)
-      # MinGW DLLs use traditional 'lib' prefix
-      soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-      ;;
-    pw32*)
-      # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-      ;;
-    esac
-    dynamic_linker='Win32 ld.exe'
-    ;;
-
-  *,cl*)
-    # Native MSVC
-    libname_spec='$name'
-    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-    library_names_spec='$libname.dll.lib'
-
-    case $build_os in
-    mingw*)
-      sys_lib_search_path_spec=
-      lt_save_ifs=$IFS
-      IFS=';'
-      for lt_path in $LIB
-      do
-        IFS=$lt_save_ifs
-        # Let DOS variable expansion print the short 8.3 style file name.
-        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
-        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
-      done
-      IFS=$lt_save_ifs
-      # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
-      ;;
-    cygwin*)
-      # Convert to unix form, then to dos form, then back to unix form
-      # but this time dos style (no spaces!) so that the unix form looks
-      # like /cygdrive/c/PROGRA~1:/cygdr...
-      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
-      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
-      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      ;;
-    *)
-      sys_lib_search_path_spec=$LIB
-      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
-        # It is most probably a Windows format PATH.
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
-      else
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      fi
-      # FIXME: find the short name or the path components, as spaces are
-      # common. (e.g. "Program Files" -> "PROGRA~1")
-      ;;
-    esac
-
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-    dynamic_linker='Win32 link.exe'
-    ;;
-
-  *)
-    # Assume MSVC wrapper
-    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
-    dynamic_linker='Win32 ld.exe'
-    ;;
-  esac
-  # FIXME: first we should search . and the directory the executable is in
-  shlibpath_var=PATH
-  ;;
-
-darwin* | rhapsody*)
-  dynamic_linker="$host_os dyld"
-  version_type=darwin
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$major$shared_ext'
-  shlibpath_overrides_runpath=yes
-  shlibpath_var=DYLD_LIBRARY_PATH
-  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
-
-  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
-  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
-  ;;
-
-dgux*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-freebsd* | dragonfly*)
-  # DragonFly does not have aout.  When/if they implement a new
-  # versioning mechanism, adjust this.
-  if test -x /usr/bin/objformat; then
-    objformat=`/usr/bin/objformat`
-  else
-    case $host_os in
-    freebsd[23].*) objformat=aout ;;
-    *) objformat=elf ;;
-    esac
-  fi
-  version_type=freebsd-$objformat
-  case $version_type in
-    freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      soname_spec='$libname$release$shared_ext$major'
-      need_version=no
-      need_lib_prefix=no
-      ;;
-    freebsd-*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-      need_version=yes
-      ;;
-  esac
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_os in
-  freebsd2.*)
-    shlibpath_overrides_runpath=yes
-    ;;
-  freebsd3.[01]* | freebsdelf3.[01]*)
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
-  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
-    shlibpath_overrides_runpath=no
-    hardcode_into_libs=yes
-    ;;
-  *) # from 4.6 on, and DragonFly
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  esac
-  ;;
-
-haiku*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  dynamic_linker="$host_os runtime_loader"
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
-  hardcode_into_libs=yes
-  ;;
-
-hpux9* | hpux10* | hpux11*)
-  # Give a soname corresponding to the major version so that dld.sl refuses to
-  # link against other versions.
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  case $host_cpu in
-  ia64*)
-    shrext_cmds='.so'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.so"
-    shlibpath_var=LD_LIBRARY_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    if test 32 = "$HPUX_IA64_MODE"; then
-      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
-    else
-      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
-    fi
-    ;;
-  hppa*64*)
-    shrext_cmds='.sl'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-    ;;
-  *)
-    shrext_cmds='.sl'
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=SHLIB_PATH
-    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    ;;
-  esac
-  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
-  postinstall_cmds='chmod 555 $lib'
-  # or fails outright, so override atomically:
-  install_override_mode=555
-  ;;
-
-interix[3-9]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-irix5* | irix6* | nonstopux*)
-  case $host_os in
-    nonstopux*) version_type=nonstopux ;;
-    *)
-	if test yes = "$lt_cv_prog_gnu_ld"; then
-		version_type=linux # correct to gnu/linux during the next big refactor
-	else
-		version_type=irix
-	fi ;;
-  esac
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
-  case $host_os in
-  irix5* | nonstopux*)
-    libsuff= shlibsuff=
-    ;;
-  *)
-    case $LD in # libtool.m4 will add one of these switches to LD
-    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
-      libsuff= shlibsuff= libmagic=32-bit;;
-    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
-      libsuff=32 shlibsuff=N32 libmagic=N32;;
-    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
-      libsuff=64 shlibsuff=64 libmagic=64-bit;;
-    *) libsuff= shlibsuff= libmagic=never-match;;
-    esac
-    ;;
-  esac
-  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
-  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
-  hardcode_into_libs=yes
-  ;;
-
-# No shared lib support for Linux oldld, aout, or coff.
-linux*oldld* | linux*aout* | linux*coff*)
-  dynamic_linker=no
-  ;;
-
-linux*android*)
-  version_type=none # Android doesn't support versioned libraries.
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext'
-  soname_spec='$libname$release$shared_ext'
-  finish_cmds=
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  dynamic_linker='Android linker'
-  # Don't embed -rpath directories since the linker doesn't support them.
-  hardcode_libdir_flag_spec='-L$libdir'
-  ;;
-
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-
-  # Some binutils ld are patched to set DT_RUNPATH
-  if test ${lt_cv_shlibpath_overrides_runpath+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_shlibpath_overrides_runpath=no
-    save_LDFLAGS=$LDFLAGS
-    save_libdir=$libdir
-    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
-	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null
-then :
-  lt_cv_shlibpath_overrides_runpath=yes
-fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LDFLAGS=$save_LDFLAGS
-    libdir=$save_libdir
-
-fi
-
-  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  # Ideally, we could use ldconfig to report *all* directores which are
-  # searched for libraries, however this is still not possible.  Aside from not
-  # being certain /sbin/ldconfig is available, command
-  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
-  # even though it is searched at run-time.  Try to do the best guess by
-  # appending ld.so.conf contents (and includes) to the search path.
-  if test -f /etc/ld.so.conf; then
-    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
-  fi
-
-  # We used to test for /lib/ld.so.1 and disable shared libraries on
-  # powerpc, because MkLinux only supported shared libraries with the
-  # GNU dynamic linker.  Since this was broken with cross compilers,
-  # most powerpc-linux boxes support dynamic linking these days and
-  # people can always --disable-shared, the test was removed, and we
-  # assume the GNU/Linux dynamic linker is in use.
-  dynamic_linker='GNU/Linux ld.so'
-  ;;
-
-netbsdelf*-gnu)
-  version_type=linux
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='NetBSD ld.elf_so'
-  ;;
-
-netbsd*)
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-    dynamic_linker='NetBSD (a.out) ld.so'
-  else
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    dynamic_linker='NetBSD ld.elf_so'
-  fi
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  ;;
-
-newsos6)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-*nto* | *qnx*)
-  version_type=qnx
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='ldqnx.so'
-  ;;
-
-openbsd* | bitrig*)
-  version_type=sunos
-  sys_lib_dlsearch_path_spec=/usr/lib
-  need_lib_prefix=no
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-    need_version=no
-  else
-    need_version=yes
-  fi
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-os2*)
-  libname_spec='$name'
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-  # OS/2 can only load a DLL with a base name of 8 characters or less.
-  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
-    v=$($ECHO $release$versuffix | tr -d .-);
-    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
-    $ECHO $n$v`$shared_ext'
-  library_names_spec='${libname}_dll.$libext'
-  dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=BEGINLIBPATH
-  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  postinstall_cmds='base_file=`basename \$file`~
-    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
-    dldir=$destdir/`dirname \$dlpath`~
-    test -d \$dldir || mkdir -p \$dldir~
-    $install_prog $dir/$dlname \$dldir/$dlname~
-    chmod a+x \$dldir/$dlname~
-    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-    fi'
-  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
-    dlpath=$dir/\$dldll~
-    $RM \$dlpath'
-  ;;
-
-osf3* | osf4* | osf5*)
-  version_type=osf
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  ;;
-
-rdos*)
-  dynamic_linker=no
-  ;;
-
-solaris*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  # ldd complains unless libraries are executable
-  postinstall_cmds='chmod +x $lib'
-  ;;
-
-sunos4*)
-  version_type=sunos
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  if test yes = "$with_gnu_ld"; then
-    need_lib_prefix=no
-  fi
-  need_version=yes
-  ;;
-
-sysv4 | sysv4.3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_vendor in
-    sni)
-      shlibpath_overrides_runpath=no
-      need_lib_prefix=no
-      runpath_var=LD_RUN_PATH
-      ;;
-    siemens)
-      need_lib_prefix=no
-      ;;
-    motorola)
-      need_lib_prefix=no
-      need_version=no
-      shlibpath_overrides_runpath=no
-      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
-      ;;
-  esac
-  ;;
-
-sysv4*MP*)
-  if test -d /usr/nec; then
-    version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
-    soname_spec='$libname$shared_ext.$major'
-    shlibpath_var=LD_LIBRARY_PATH
-  fi
-  ;;
-
-sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=sco
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  if test yes = "$with_gnu_ld"; then
-    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
-  else
-    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
-    case $host_os in
-      sco3.2v5*)
-        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
-	;;
-    esac
-  fi
-  sys_lib_dlsearch_path_spec='/usr/lib'
-  ;;
-
-tpf*)
-  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-uts4*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-*)
-  dynamic_linker=no
-  ;;
-esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
-printf "%s\n" "$dynamic_linker" >&6; }
-test no = "$dynamic_linker" && can_build_shared=no
-
-variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test yes = "$GCC"; then
-  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
-fi
-
-if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
-  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
-fi
-
-if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
-  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
-fi
-
-# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
-configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
-
-# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
-func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
-
-# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
-configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
-printf %s "checking how to hardcode library paths into programs... " >&6; }
-hardcode_action=
-if test -n "$hardcode_libdir_flag_spec" ||
-   test -n "$runpath_var" ||
-   test yes = "$hardcode_automatic"; then
-
-  # We can hardcode non-existent directories.
-  if test no != "$hardcode_direct" &&
-     # If the only mechanism to avoid hardcoding is shlibpath_var, we
-     # have to relink, otherwise we might link with an installed library
-     # when we should be linking with a yet-to-be-installed one
-     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" &&
-     test no != "$hardcode_minus_L"; then
-    # Linking always hardcodes the temporary library directory.
-    hardcode_action=relink
-  else
-    # We can link without hardcoding, and we can hardcode nonexisting dirs.
-    hardcode_action=immediate
-  fi
-else
-  # We cannot hardcode anything, or else we can only hardcode existing
-  # directories.
-  hardcode_action=unsupported
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
-printf "%s\n" "$hardcode_action" >&6; }
-
-if test relink = "$hardcode_action" ||
-   test yes = "$inherit_rpath"; then
-  # Fast installation is not supported
-  enable_fast_install=no
-elif test yes = "$shlibpath_overrides_runpath" ||
-     test no = "$enable_shared"; then
-  # Fast installation is not necessary
-  enable_fast_install=needless
-fi
-
-
-
-
-
-
-  if test yes != "$enable_dlopen"; then
-  enable_dlopen=unknown
-  enable_dlopen_self=unknown
-  enable_dlopen_self_static=unknown
-else
-  lt_cv_dlopen=no
-  lt_cv_dlopen_libs=
-
-  case $host_os in
-  beos*)
-    lt_cv_dlopen=load_add_on
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=yes
-    ;;
-
-  mingw* | pw32* | cegcc*)
-    lt_cv_dlopen=LoadLibrary
-    lt_cv_dlopen_libs=
-    ;;
-
-  cygwin*)
-    lt_cv_dlopen=dlopen
-    lt_cv_dlopen_libs=
-    ;;
-
-  darwin*)
-    # if libdl is installed we need to link against it
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
-printf %s "checking for dlopen in -ldl... " >&6; }
-if test ${ac_cv_lib_dl_dlopen+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldl  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
-int
-main (void)
-{
-return dlopen ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_lib_dl_dlopen=yes
-else $as_nop
-  ac_cv_lib_dl_dlopen=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
-if test "x$ac_cv_lib_dl_dlopen" = xyes
-then :
-  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
-else $as_nop
-
-    lt_cv_dlopen=dyld
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=yes
-
-fi
-
-    ;;
-
-  tpf*)
-    # Don't try to run any link tests for TPF.  We know it's impossible
-    # because TPF is a cross-compiler, and we know how we open DSOs.
-    lt_cv_dlopen=dlopen
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=no
-    ;;
-
-  *)
-    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
-if test "x$ac_cv_func_shl_load" = xyes
-then :
-  lt_cv_dlopen=shl_load
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
-printf %s "checking for shl_load in -ldld... " >&6; }
-if test ${ac_cv_lib_dld_shl_load+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldld  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char shl_load ();
-int
-main (void)
-{
-return shl_load ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_lib_dld_shl_load=yes
-else $as_nop
-  ac_cv_lib_dld_shl_load=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
-printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; }
-if test "x$ac_cv_lib_dld_shl_load" = xyes
-then :
-  lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
-else $as_nop
-  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
-if test "x$ac_cv_func_dlopen" = xyes
-then :
-  lt_cv_dlopen=dlopen
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
-printf %s "checking for dlopen in -ldl... " >&6; }
-if test ${ac_cv_lib_dl_dlopen+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldl  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
-int
-main (void)
-{
-return dlopen ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_lib_dl_dlopen=yes
-else $as_nop
-  ac_cv_lib_dl_dlopen=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
-if test "x$ac_cv_lib_dl_dlopen" = xyes
-then :
-  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
-printf %s "checking for dlopen in -lsvld... " >&6; }
-if test ${ac_cv_lib_svld_dlopen+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lsvld  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dlopen ();
-int
-main (void)
-{
-return dlopen ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_lib_svld_dlopen=yes
-else $as_nop
-  ac_cv_lib_svld_dlopen=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; }
-if test "x$ac_cv_lib_svld_dlopen" = xyes
-then :
-  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
-printf %s "checking for dld_link in -ldld... " >&6; }
-if test ${ac_cv_lib_dld_dld_link+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldld  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-char dld_link ();
-int
-main (void)
-{
-return dld_link ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_lib_dld_dld_link=yes
-else $as_nop
-  ac_cv_lib_dld_dld_link=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
-printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; }
-if test "x$ac_cv_lib_dld_dld_link" = xyes
-then :
-  lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
-fi
-
-
-fi
-
-
-fi
-
-
-fi
-
-
-fi
-
-
-fi
-
-    ;;
-  esac
-
-  if test no = "$lt_cv_dlopen"; then
-    enable_dlopen=no
-  else
-    enable_dlopen=yes
-  fi
-
-  case $lt_cv_dlopen in
-  dlopen)
-    save_CPPFLAGS=$CPPFLAGS
-    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
-
-    save_LDFLAGS=$LDFLAGS
-    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
-
-    save_LIBS=$LIBS
-    LIBS="$lt_cv_dlopen_libs $LIBS"
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
-printf %s "checking whether a program can dlopen itself... " >&6; }
-if test ${lt_cv_dlopen_self+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  	  if test yes = "$cross_compiling"; then :
-  lt_cv_dlopen_self=cross
-else
-  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
-  lt_status=$lt_dlunknown
-  cat > conftest.$ac_ext <<_LT_EOF
-#line $LINENO "configure"
-#include "confdefs.h"
-
-#if HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-
-#include <stdio.h>
-
-#ifdef RTLD_GLOBAL
-#  define LT_DLGLOBAL		RTLD_GLOBAL
-#else
-#  ifdef DL_GLOBAL
-#    define LT_DLGLOBAL		DL_GLOBAL
-#  else
-#    define LT_DLGLOBAL		0
-#  endif
-#endif
-
-/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
-   find out it does not work in some platform. */
-#ifndef LT_DLLAZY_OR_NOW
-#  ifdef RTLD_LAZY
-#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
-#  else
-#    ifdef DL_LAZY
-#      define LT_DLLAZY_OR_NOW		DL_LAZY
-#    else
-#      ifdef RTLD_NOW
-#        define LT_DLLAZY_OR_NOW	RTLD_NOW
-#      else
-#        ifdef DL_NOW
-#          define LT_DLLAZY_OR_NOW	DL_NOW
-#        else
-#          define LT_DLLAZY_OR_NOW	0
-#        endif
-#      endif
-#    endif
-#  endif
-#endif
-
-/* When -fvisibility=hidden is used, assume the code has been annotated
-   correspondingly for the symbols needed.  */
-#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
-int fnord () __attribute__((visibility("default")));
-#endif
-
-int fnord () { return 42; }
-int main ()
-{
-  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
-  int status = $lt_dlunknown;
-
-  if (self)
-    {
-      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
-      else
-        {
-	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
-          else puts (dlerror ());
-	}
-      /* dlclose (self); */
-    }
-  else
-    puts (dlerror ());
-
-  return status;
-}
-_LT_EOF
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
-    (./conftest; exit; ) >&5 2>/dev/null
-    lt_status=$?
-    case x$lt_status in
-      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
-      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
-      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
-    esac
-  else :
-    # compilation failed
-    lt_cv_dlopen_self=no
-  fi
-fi
-rm -fr conftest*
-
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
-printf "%s\n" "$lt_cv_dlopen_self" >&6; }
-
-    if test yes = "$lt_cv_dlopen_self"; then
-      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
-printf %s "checking whether a statically linked program can dlopen itself... " >&6; }
-if test ${lt_cv_dlopen_self_static+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  	  if test yes = "$cross_compiling"; then :
-  lt_cv_dlopen_self_static=cross
-else
-  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
-  lt_status=$lt_dlunknown
-  cat > conftest.$ac_ext <<_LT_EOF
-#line $LINENO "configure"
-#include "confdefs.h"
-
-#if HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-
-#include <stdio.h>
-
-#ifdef RTLD_GLOBAL
-#  define LT_DLGLOBAL		RTLD_GLOBAL
-#else
-#  ifdef DL_GLOBAL
-#    define LT_DLGLOBAL		DL_GLOBAL
-#  else
-#    define LT_DLGLOBAL		0
-#  endif
-#endif
-
-/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
-   find out it does not work in some platform. */
-#ifndef LT_DLLAZY_OR_NOW
-#  ifdef RTLD_LAZY
-#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
-#  else
-#    ifdef DL_LAZY
-#      define LT_DLLAZY_OR_NOW		DL_LAZY
-#    else
-#      ifdef RTLD_NOW
-#        define LT_DLLAZY_OR_NOW	RTLD_NOW
-#      else
-#        ifdef DL_NOW
-#          define LT_DLLAZY_OR_NOW	DL_NOW
-#        else
-#          define LT_DLLAZY_OR_NOW	0
-#        endif
-#      endif
-#    endif
-#  endif
-#endif
-
-/* When -fvisibility=hidden is used, assume the code has been annotated
-   correspondingly for the symbols needed.  */
-#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
-int fnord () __attribute__((visibility("default")));
-#endif
-
-int fnord () { return 42; }
-int main ()
-{
-  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
-  int status = $lt_dlunknown;
-
-  if (self)
-    {
-      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
-      else
-        {
-	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
-          else puts (dlerror ());
-	}
-      /* dlclose (self); */
-    }
-  else
-    puts (dlerror ());
-
-  return status;
-}
-_LT_EOF
-  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
-  (eval $ac_link) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
-    (./conftest; exit; ) >&5 2>/dev/null
-    lt_status=$?
-    case x$lt_status in
-      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
-      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
-      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
-    esac
-  else :
-    # compilation failed
-    lt_cv_dlopen_self_static=no
-  fi
-fi
-rm -fr conftest*
-
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
-printf "%s\n" "$lt_cv_dlopen_self_static" >&6; }
-    fi
-
-    CPPFLAGS=$save_CPPFLAGS
-    LDFLAGS=$save_LDFLAGS
-    LIBS=$save_LIBS
-    ;;
-  esac
-
-  case $lt_cv_dlopen_self in
-  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
-  *) enable_dlopen_self=unknown ;;
-  esac
-
-  case $lt_cv_dlopen_self_static in
-  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
-  *) enable_dlopen_self_static=unknown ;;
-  esac
-fi
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-striplib=
-old_striplib=
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
-printf %s "checking whether stripping libraries is possible... " >&6; }
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP"; then
-      striplib="$STRIP -x"
-      old_striplib="$STRIP -S"
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-    fi
-    ;;
-  *)
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-    ;;
-  esac
-fi
-
-
-
-
-
-
-
-
-
-
-
-
-  # Report what library types will actually be built
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
-printf %s "checking if libtool supports shared libraries... " >&6; }
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
-printf "%s\n" "$can_build_shared" >&6; }
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
-printf %s "checking whether to build shared libraries... " >&6; }
-  test no = "$can_build_shared" && enable_shared=no
-
-  # On AIX, shared libraries and static libraries use the same namespace, and
-  # are all built from PIC.
-  case $host_os in
-  aix3*)
-    test yes = "$enable_shared" && enable_static=no
-    if test -n "$RANLIB"; then
-      archive_cmds="$archive_cmds~\$RANLIB \$lib"
-      postinstall_cmds='$RANLIB $lib'
-    fi
-    ;;
-
-  aix[4-9]*)
-    if test ia64 != "$host_cpu"; then
-      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
-      yes,aix,yes) ;;			# shared object as lib.so file only
-      yes,svr4,*) ;;			# shared object as lib.so archive member only
-      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
-      esac
-    fi
-    ;;
-  esac
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
-printf "%s\n" "$enable_shared" >&6; }
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
-printf %s "checking whether to build static libraries... " >&6; }
-  # Make sure either enable_shared or enable_static is yes.
-  test yes = "$enable_shared" || enable_static=yes
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
-printf "%s\n" "$enable_static" >&6; }
-
-
-
-
-fi
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-CC=$lt_save_CC
-
-      if test -n "$CXX" && ( test no != "$CXX" &&
-    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
-    (test g++ != "$CXX"))); then
-  ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
-printf %s "checking how to run the C++ preprocessor... " >&6; }
-if test -z "$CXXCPP"; then
-  if test ${ac_cv_prog_CXXCPP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-      # Double quotes because $CXX needs to be expanded
-    for CXXCPP in "$CXX -E" cpp /lib/cpp
-    do
-      ac_preproc_ok=false
-for ac_cxx_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_cxx_try_cpp "$LINENO"
-then :
-
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_cxx_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
-  break
-fi
-
-    done
-    ac_cv_prog_CXXCPP=$CXXCPP
-
-fi
-  CXXCPP=$ac_cv_prog_CXXCPP
-else
-  ac_cv_prog_CXXCPP=$CXXCPP
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
-printf "%s\n" "$CXXCPP" >&6; }
-ac_preproc_ok=false
-for ac_cxx_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_cxx_try_cpp "$LINENO"
-then :
-
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_cxx_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
-
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-else
-  _lt_caught_CXX_error=yes
-fi
-
-ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-
-archive_cmds_need_lc_CXX=no
-allow_undefined_flag_CXX=
-always_export_symbols_CXX=no
-archive_expsym_cmds_CXX=
-compiler_needs_object_CXX=no
-export_dynamic_flag_spec_CXX=
-hardcode_direct_CXX=no
-hardcode_direct_absolute_CXX=no
-hardcode_libdir_flag_spec_CXX=
-hardcode_libdir_separator_CXX=
-hardcode_minus_L_CXX=no
-hardcode_shlibpath_var_CXX=unsupported
-hardcode_automatic_CXX=no
-inherit_rpath_CXX=no
-module_cmds_CXX=
-module_expsym_cmds_CXX=
-link_all_deplibs_CXX=unknown
-old_archive_cmds_CXX=$old_archive_cmds
-reload_flag_CXX=$reload_flag
-reload_cmds_CXX=$reload_cmds
-no_undefined_flag_CXX=
-whole_archive_flag_spec_CXX=
-enable_shared_with_static_runtimes_CXX=no
-
-# Source file extension for C++ test sources.
-ac_ext=cpp
-
-# Object file extension for compiled C++ test sources.
-objext=o
-objext_CXX=$objext
-
-# No sense in running all these tests if we already determined that
-# the CXX compiler isn't working.  Some variables (like enable_shared)
-# are currently assumed to apply to all compilers on this platform,
-# and will be corrupted by setting them based on a non-working compiler.
-if test yes != "$_lt_caught_CXX_error"; then
-  # Code to be used in simple compile tests
-  lt_simple_compile_test_code="int some_variable = 0;"
-
-  # Code to be used in simple link tests
-  lt_simple_link_test_code='int main(int, char *[]) { return(0); }'
-
-  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
-
-
-
-
-
-
-# If no C compiler was specified, use CC.
-LTCC=${LTCC-"$CC"}
-
-# If no C compiler flags were specified, use CFLAGS.
-LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
-
-# Allow CC to be a program name with arguments.
-compiler=$CC
-
-
-  # save warnings/boilerplate of simple test code
-  ac_outfile=conftest.$ac_objext
-echo "$lt_simple_compile_test_code" >conftest.$ac_ext
-eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_compiler_boilerplate=`cat conftest.err`
-$RM conftest*
-
-  ac_outfile=conftest.$ac_objext
-echo "$lt_simple_link_test_code" >conftest.$ac_ext
-eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_linker_boilerplate=`cat conftest.err`
-$RM -r conftest*
-
-
-  # Allow CC to be a program name with arguments.
-  lt_save_CC=$CC
-  lt_save_CFLAGS=$CFLAGS
-  lt_save_LD=$LD
-  lt_save_GCC=$GCC
-  GCC=$GXX
-  lt_save_with_gnu_ld=$with_gnu_ld
-  lt_save_path_LD=$lt_cv_path_LD
-  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
-    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
-  else
-    $as_unset lt_cv_prog_gnu_ld
-  fi
-  if test -n "${lt_cv_path_LDCXX+set}"; then
-    lt_cv_path_LD=$lt_cv_path_LDCXX
-  else
-    $as_unset lt_cv_path_LD
-  fi
-  test -z "${LDCXX+set}" || LD=$LDCXX
-  CC=${CXX-"c++"}
-  CFLAGS=$CXXFLAGS
-  compiler=$CC
-  compiler_CXX=$CC
-  func_cc_basename $compiler
-cc_basename=$func_cc_basename_result
-
-
-  if test -n "$compiler"; then
-    # We don't want -fno-exception when compiling C++ code, so set the
-    # no_builtin_flag separately
-    if test yes = "$GXX"; then
-      lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
-    else
-      lt_prog_compiler_no_builtin_flag_CXX=
-    fi
-
-    if test yes = "$GXX"; then
-      # Set up default GNU C++ configuration
-
-
-
-# Check whether --with-gnu-ld was given.
-if test ${with_gnu_ld+y}
-then :
-  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
-fi
-
-ac_prog=ld
-if test yes = "$GCC"; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
-printf %s "checking for ld used by $CC... " >&6; }
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return, which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [\\/]* | ?:[\\/]*)
-      re_direlt='/[^/][^/]*/\.\./'
-      # Canonicalize the pathname of ld
-      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
-      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD=$ac_prog
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test yes = "$with_gnu_ld"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
-printf %s "checking for GNU ld... " >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
-printf %s "checking for non-GNU ld... " >&6; }
-fi
-if test ${lt_cv_path_LD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  for ac_dir in $PATH; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD=$ac_dir/$ac_prog
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some variants of GNU ld only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
-      *GNU* | *'with BFD'*)
-	test no != "$with_gnu_ld" && break
-	;;
-      *)
-	test yes != "$with_gnu_ld" && break
-	;;
-      esac
-    fi
-  done
-  IFS=$lt_save_ifs
-else
-  lt_cv_path_LD=$LD # Let the user override the test with a path.
-fi
-fi
-
-LD=$lt_cv_path_LD
-if test -n "$LD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
-printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
-if test ${lt_cv_prog_gnu_ld+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU lds only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  lt_cv_prog_gnu_ld=yes
-  ;;
-*)
-  lt_cv_prog_gnu_ld=no
-  ;;
-esac
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
-printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
-with_gnu_ld=$lt_cv_prog_gnu_ld
-
-
-
-
-
-
-
-      # Check if GNU C++ uses GNU ld as the underlying linker, since the
-      # archiving commands below assume that GNU ld is being used.
-      if test yes = "$with_gnu_ld"; then
-        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-
-        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
-        export_dynamic_flag_spec_CXX='$wl--export-dynamic'
-
-        # If archive_cmds runs LD, not CC, wlarc should be empty
-        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
-        #     investigate it a little bit more. (MM)
-        wlarc='$wl'
-
-        # ancient GNU ld didn't support --whole-archive et. al.
-        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
-	  $GREP 'no-whole-archive' > /dev/null; then
-          whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-        else
-          whole_archive_flag_spec_CXX=
-        fi
-      else
-        with_gnu_ld=no
-        wlarc=
-
-        # A generic and very simple default shared library creation
-        # command for GNU C++ for the case where it uses the native
-        # linker, instead of GNU ld.  If possible, this setting should
-        # overridden to take advantage of the native linker features on
-        # the platform it is being used on.
-        archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-      fi
-
-      # Commands to make compiler produce verbose output that lists
-      # what "hidden" libraries, object files and flags are used when
-      # linking a shared library.
-      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-
-    else
-      GXX=no
-      with_gnu_ld=no
-      wlarc=
-    fi
-
-    # PORTME: fill in a description of your system's C++ link characteristics
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
-printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
-    ld_shlibs_CXX=yes
-    case $host_os in
-      aix3*)
-        # FIXME: insert proper C++ library support
-        ld_shlibs_CXX=no
-        ;;
-      aix[4-9]*)
-        if test ia64 = "$host_cpu"; then
-          # On IA64, the linker does run time linking by default, so we don't
-          # have to do anything special.
-          aix_use_runtimelinking=no
-          exp_sym_flag='-Bexport'
-          no_entry_flag=
-        else
-          aix_use_runtimelinking=no
-
-          # Test if we are trying to use run time linking or normal
-          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # have runtime linking enabled, and use it for executables.
-          # For shared libraries, we enable/disable runtime linking
-          # depending on the kind of the shared library created -
-          # when "with_aix_soname,aix_use_runtimelinking" is:
-          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
-          # "aix,yes"  lib.so          shared, rtl:yes, for executables
-          #            lib.a           static archive
-          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
-          #            lib.a(lib.so.V) shared, rtl:no,  for executables
-          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
-          #            lib.a(lib.so.V) shared, rtl:no
-          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
-          #            lib.a           static archive
-          case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
-	    for ld_flag in $LDFLAGS; do
-	      case $ld_flag in
-	      *-brtl*)
-	        aix_use_runtimelinking=yes
-	        break
-	        ;;
-	      esac
-	    done
-	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
-	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
-	      # so we don't have lib.a shared libs to link our executables.
-	      # We have to force runtime linking in this case.
-	      aix_use_runtimelinking=yes
-	      LDFLAGS="$LDFLAGS -Wl,-brtl"
-	    fi
-	    ;;
-          esac
-
-          exp_sym_flag='-bexport'
-          no_entry_flag='-bnoentry'
-        fi
-
-        # When large executables or shared objects are built, AIX ld can
-        # have problems creating the table of contents.  If linking a library
-        # or program results in "error TOC overflow" add -mminimal-toc to
-        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
-        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
-        archive_cmds_CXX=''
-        hardcode_direct_CXX=yes
-        hardcode_direct_absolute_CXX=yes
-        hardcode_libdir_separator_CXX=':'
-        link_all_deplibs_CXX=yes
-        file_list_spec_CXX='$wl-f,'
-        case $with_aix_soname,$aix_use_runtimelinking in
-        aix,*) ;;	# no import file
-        svr4,* | *,yes) # use import file
-          # The Import File defines what to hardcode.
-          hardcode_direct_CXX=no
-          hardcode_direct_absolute_CXX=no
-          ;;
-        esac
-
-        if test yes = "$GXX"; then
-          case $host_os in aix4.[012]|aix4.[012].*)
-          # We only want to do this on AIX 4.2 and lower, the check
-          # below for broken collect2 doesn't work under 4.3+
-	  collect2name=`$CC -print-prog-name=collect2`
-	  if test -f "$collect2name" &&
-	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
-	  then
-	    # We have reworked collect2
-	    :
-	  else
-	    # We have old collect2
-	    hardcode_direct_CXX=unsupported
-	    # It fails to find uninstalled libraries when the uninstalled
-	    # path is not listed in the libpath.  Setting hardcode_minus_L
-	    # to unsupported forces relinking
-	    hardcode_minus_L_CXX=yes
-	    hardcode_libdir_flag_spec_CXX='-L$libdir'
-	    hardcode_libdir_separator_CXX=
-	  fi
-          esac
-          shared_flag='-shared'
-	  if test yes = "$aix_use_runtimelinking"; then
-	    shared_flag=$shared_flag' $wl-G'
-	  fi
-	  # Need to ensure runtime linking is disabled for the traditional
-	  # shared library, or the linker may eventually find shared libraries
-	  # /with/ Import File - we do not want to mix them.
-	  shared_flag_aix='-shared'
-	  shared_flag_svr4='-shared $wl-G'
-        else
-          # not using gcc
-          if test ia64 = "$host_cpu"; then
-	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
-	  # chokes on -Wl,-G. The following line is correct:
-	  shared_flag='-G'
-          else
-	    if test yes = "$aix_use_runtimelinking"; then
-	      shared_flag='$wl-G'
-	    else
-	      shared_flag='$wl-bM:SRE'
-	    fi
-	    shared_flag_aix='$wl-bM:SRE'
-	    shared_flag_svr4='$wl-G'
-          fi
-        fi
-
-        export_dynamic_flag_spec_CXX='$wl-bexpall'
-        # It seems that -bexpall does not export symbols beginning with
-        # underscore (_), so it is better to generate a list of symbols to
-	# export.
-        always_export_symbols_CXX=yes
-	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
-          # Warning - without using the other runtime loading flags (-brtl),
-          # -berok will link without error, but may produce a broken library.
-          # The "-G" linker flag allows undefined symbols.
-          no_undefined_flag_CXX='-bernotok'
-          # Determine the default libpath from the value encoded in an empty
-          # executable.
-          if test set = "${lt_cv_aix_libpath+set}"; then
-  aix_libpath=$lt_cv_aix_libpath
-else
-  if test ${lt_cv_aix_libpath__CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_link "$LINENO"
-then :
-
-  lt_aix_libpath_sed='
-      /Import File Strings/,/^$/ {
-	  /^0/ {
-	      s/^0  *\([^ ]*\) *$/\1/
-	      p
-	  }
-      }'
-  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  # Check for a 64-bit object if we didn't find anything.
-  if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-  if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX=/usr/lib:/lib
-  fi
-
-fi
-
-  aix_libpath=$lt_cv_aix_libpath__CXX
-fi
-
-          hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
-
-          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
-        else
-          if test ia64 = "$host_cpu"; then
-	    hardcode_libdir_flag_spec_CXX='$wl-R $libdir:/usr/lib:/lib'
-	    allow_undefined_flag_CXX="-z nodefs"
-	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
-          else
-	    # Determine the default libpath from the value encoded in an
-	    # empty executable.
-	    if test set = "${lt_cv_aix_libpath+set}"; then
-  aix_libpath=$lt_cv_aix_libpath
-else
-  if test ${lt_cv_aix_libpath__CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_link "$LINENO"
-then :
-
-  lt_aix_libpath_sed='
-      /Import File Strings/,/^$/ {
-	  /^0/ {
-	      s/^0  *\([^ ]*\) *$/\1/
-	      p
-	  }
-      }'
-  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  # Check for a 64-bit object if we didn't find anything.
-  if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-  if test -z "$lt_cv_aix_libpath__CXX"; then
-    lt_cv_aix_libpath__CXX=/usr/lib:/lib
-  fi
-
-fi
-
-  aix_libpath=$lt_cv_aix_libpath__CXX
-fi
-
-	    hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
-	    # Warning - without using the other run time loading flags,
-	    # -berok will link without error, but may produce a broken library.
-	    no_undefined_flag_CXX=' $wl-bernotok'
-	    allow_undefined_flag_CXX=' $wl-berok'
-	    if test yes = "$with_gnu_ld"; then
-	      # We only use this code for GNU lds that support --whole-archive.
-	      whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
-	    else
-	      # Exported symbols can be pulled into shared objects from archives
-	      whole_archive_flag_spec_CXX='$convenience'
-	    fi
-	    archive_cmds_need_lc_CXX=yes
-	    archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
-	    # -brtl affects multiple linker settings, -berok does not and is overridden later
-	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`'
-	    if test svr4 != "$with_aix_soname"; then
-	      # This is similar to how AIX traditionally builds its shared
-	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
-	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
-	    fi
-	    if test aix != "$with_aix_soname"; then
-	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
-	    else
-	      # used by -dlpreopen to get the symbols
-	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
-	    fi
-	    archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d'
-          fi
-        fi
-        ;;
-
-      beos*)
-	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	  allow_undefined_flag_CXX=unsupported
-	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
-	  # support --undefined.  This deserves some investigation.  FIXME
-	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	else
-	  ld_shlibs_CXX=no
-	fi
-	;;
-
-      chorus*)
-        case $cc_basename in
-          *)
-	  # FIXME: insert proper C++ library support
-	  ld_shlibs_CXX=no
-	  ;;
-        esac
-        ;;
-
-      cygwin* | mingw* | pw32* | cegcc*)
-	case $GXX,$cc_basename in
-	,cl* | no,cl*)
-	  # Native MSVC
-	  # hardcode_libdir_flag_spec is actually meaningless, as there is
-	  # no search path for DLLs.
-	  hardcode_libdir_flag_spec_CXX=' '
-	  allow_undefined_flag_CXX=unsupported
-	  always_export_symbols_CXX=yes
-	  file_list_spec_CXX='@'
-	  # Tell ltmain to make .lib files, not .a files.
-	  libext=lib
-	  # Tell ltmain to make .dll files, not .so files.
-	  shrext_cmds=.dll
-	  # FIXME: Setting linknames here is a bad hack.
-	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
-	  archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
-              cp "$export_symbols" "$output_objdir/$soname.def";
-              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
-            else
-              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
-            fi~
-            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-            linknames='
-	  # The linker will not automatically build a static lib if we build a DLL.
-	  # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
-	  enable_shared_with_static_runtimes_CXX=yes
-	  # Don't use ranlib
-	  old_postinstall_cmds_CXX='chmod 644 $oldlib'
-	  postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
-            lt_tool_outputfile="@TOOL_OUTPUT@"~
-            case $lt_outputfile in
-              *.exe|*.EXE) ;;
-              *)
-                lt_outputfile=$lt_outputfile.exe
-                lt_tool_outputfile=$lt_tool_outputfile.exe
-                ;;
-            esac~
-            func_to_tool_file "$lt_outputfile"~
-            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
-              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-              $RM "$lt_outputfile.manifest";
-            fi'
-	  ;;
-	*)
-	  # g++
-	  # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
-	  # as there is no search path for DLLs.
-	  hardcode_libdir_flag_spec_CXX='-L$libdir'
-	  export_dynamic_flag_spec_CXX='$wl--export-all-symbols'
-	  allow_undefined_flag_CXX=unsupported
-	  always_export_symbols_CXX=no
-	  enable_shared_with_static_runtimes_CXX=yes
-
-	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	    # If the export-symbols file already is a .def file, use it as
-	    # is; otherwise, prepend EXPORTS...
-	    archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^[	 ]*//'\''     -e '\''/^\(;.*\)*$/d'\''     -e '\''s/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p'\''     -e q     $export_symbols`" ; then
-              cp $export_symbols $output_objdir/$soname.def;
-            else
-              echo EXPORTS > $output_objdir/$soname.def;
-              cat $export_symbols >> $output_objdir/$soname.def;
-            fi~
-            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	  else
-	    ld_shlibs_CXX=no
-	  fi
-	  ;;
-	esac
-	;;
-      darwin* | rhapsody*)
-
-
-  archive_cmds_need_lc_CXX=no
-  hardcode_direct_CXX=no
-  hardcode_automatic_CXX=yes
-  hardcode_shlibpath_var_CXX=unsupported
-  if test yes = "$lt_cv_ld_force_load"; then
-    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
-
-  else
-    whole_archive_flag_spec_CXX=''
-  fi
-  link_all_deplibs_CXX=yes
-  allow_undefined_flag_CXX=$_lt_dar_allow_undefined
-  case $cc_basename in
-     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
-     *) _lt_dar_can_shared=$GCC ;;
-  esac
-  if test yes = "$_lt_dar_can_shared"; then
-    output_verbose_link_cmd=func_echo_all
-    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
-    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    module_expsym_cmds_CXX="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
-       if test yes != "$lt_cv_apple_cc_single_mod"; then
-      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
-      archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
-    fi
-
-  else
-  ld_shlibs_CXX=no
-  fi
-
-	;;
-
-      os2*)
-	hardcode_libdir_flag_spec_CXX='-L$libdir'
-	hardcode_minus_L_CXX=yes
-	allow_undefined_flag_CXX=unsupported
-	shrext_cmds=.dll
-	archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	  $ECHO EXPORTS >> $output_objdir/$libname.def~
-	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	  emximp -o $lib $output_objdir/$libname.def'
-	archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	  $ECHO EXPORTS >> $output_objdir/$libname.def~
-	  prefix_cmds="$SED"~
-	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	    prefix_cmds="$prefix_cmds -e 1d";
-	  fi~
-	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	  emximp -o $lib $output_objdir/$libname.def'
-	old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-	enable_shared_with_static_runtimes_CXX=yes
-	;;
-
-      dgux*)
-        case $cc_basename in
-          ec++*)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          ghcx*)
-	    # Green Hills C++ Compiler
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-        esac
-        ;;
-
-      freebsd2.*)
-        # C++ shared libraries reported to be fairly broken before
-	# switch to ELF
-        ld_shlibs_CXX=no
-        ;;
-
-      freebsd-elf*)
-        archive_cmds_need_lc_CXX=no
-        ;;
-
-      freebsd* | dragonfly*)
-        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
-        # conventions
-        ld_shlibs_CXX=yes
-        ;;
-
-      haiku*)
-        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-        link_all_deplibs_CXX=yes
-        ;;
-
-      hpux9*)
-        hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
-        hardcode_libdir_separator_CXX=:
-        export_dynamic_flag_spec_CXX='$wl-E'
-        hardcode_direct_CXX=yes
-        hardcode_minus_L_CXX=yes # Not in the search PATH,
-				             # but as the default
-				             # location of the library.
-
-        case $cc_basename in
-          CC*)
-            # FIXME: insert proper C++ library support
-            ld_shlibs_CXX=no
-            ;;
-          aCC*)
-            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-            # Commands to make compiler produce verbose output that lists
-            # what "hidden" libraries, object files and flags are used when
-            # linking a shared library.
-            #
-            # There doesn't appear to be a way to prevent this compiler from
-            # explicitly linking system object files so we need to strip them
-            # from the output so that they don't get included in the library
-            # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-            ;;
-          *)
-            if test yes = "$GXX"; then
-              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-            else
-              # FIXME: insert proper C++ library support
-              ld_shlibs_CXX=no
-            fi
-            ;;
-        esac
-        ;;
-
-      hpux10*|hpux11*)
-        if test no = "$with_gnu_ld"; then
-	  hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
-	  hardcode_libdir_separator_CXX=:
-
-          case $host_cpu in
-            hppa*64*|ia64*)
-              ;;
-            *)
-	      export_dynamic_flag_spec_CXX='$wl-E'
-              ;;
-          esac
-        fi
-        case $host_cpu in
-          hppa*64*|ia64*)
-            hardcode_direct_CXX=no
-            hardcode_shlibpath_var_CXX=no
-            ;;
-          *)
-            hardcode_direct_CXX=yes
-            hardcode_direct_absolute_CXX=yes
-            hardcode_minus_L_CXX=yes # Not in the search PATH,
-					         # but as the default
-					         # location of the library.
-            ;;
-        esac
-
-        case $cc_basename in
-          CC*)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          aCC*)
-	    case $host_cpu in
-	      hppa*64*)
-	        archive_cmds_CXX='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	      ia64*)
-	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	      *)
-	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	    esac
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-	    ;;
-          *)
-	    if test yes = "$GXX"; then
-	      if test no = "$with_gnu_ld"; then
-	        case $host_cpu in
-	          hppa*64*)
-	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	          ia64*)
-	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	          *)
-	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	        esac
-	      fi
-	    else
-	      # FIXME: insert proper C++ library support
-	      ld_shlibs_CXX=no
-	    fi
-	    ;;
-        esac
-        ;;
-
-      interix[3-9]*)
-	hardcode_direct_CXX=no
-	hardcode_shlibpath_var_CXX=no
-	hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
-	export_dynamic_flag_spec_CXX='$wl-E'
-	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
-	# Instead, shared libraries are loaded at an image base (0x10000000 by
-	# default) and relocated if they conflict, which is a slow very memory
-	# consuming and fragmenting process.  To avoid this, we pick a random,
-	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
-	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	archive_expsym_cmds_CXX='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	;;
-      irix5* | irix6*)
-        case $cc_basename in
-          CC*)
-	    # SGI C++
-	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
-	    # necessary to make sure instantiated templates are included
-	    # in the archive.
-	    old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
-	    ;;
-          *)
-	    if test yes = "$GXX"; then
-	      if test no = "$with_gnu_ld"; then
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	      else
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
-	      fi
-	    fi
-	    link_all_deplibs_CXX=yes
-	    ;;
-        esac
-        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
-        hardcode_libdir_separator_CXX=:
-        inherit_rpath_CXX=yes
-        ;;
-
-      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-        case $cc_basename in
-          KCC*)
-	    # Kuck and Associates, Inc. (KAI) C++ Compiler
-
-	    # KCC will only create a shared library if the output file
-	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
-	    # to its proper name (with version) after linking.
-	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-
-	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
-	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
-	    old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
-	    ;;
-	  icpc* | ecpc* )
-	    # Intel C++
-	    with_gnu_ld=yes
-	    # version 8.0 and above of icpc choke on multiply defined symbols
-	    # if we add $predep_objects and $postdep_objects, however 7.1 and
-	    # earlier do not add the objects themselves.
-	    case `$CC -V 2>&1` in
-	      *"Version 7."*)
-	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-		;;
-	      *)  # Version 8.0 or newer
-	        tmp_idyn=
-	        case $host_cpu in
-		  ia64*) tmp_idyn=' -i_dynamic';;
-		esac
-	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-		;;
-	    esac
-	    archive_cmds_need_lc_CXX=no
-	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
-	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
-	    whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
-	    ;;
-          pgCC* | pgcpp*)
-            # Portland Group C++ compiler
-	    case `$CC -V` in
-	    *pgCC\ [1-5].* | *pgcpp\ [1-5].*)
-	      prelink_cmds_CXX='tpldir=Template.dir~
-               rm -rf $tpldir~
-               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
-               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
-	      old_archive_cmds_CXX='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
-                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
-                $RANLIB $oldlib'
-	      archive_cmds_CXX='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	      archive_expsym_cmds_CXX='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	      ;;
-	    *) # Version 6 and above use weak symbols
-	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	      ;;
-	    esac
-
-	    hardcode_libdir_flag_spec_CXX='$wl--rpath $wl$libdir'
-	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
-	    whole_archive_flag_spec_CXX='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-            ;;
-	  cxx*)
-	    # Compaq C++
-	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
-
-	    runpath_var=LD_RUN_PATH
-	    hardcode_libdir_flag_spec_CXX='-rpath $libdir'
-	    hardcode_libdir_separator_CXX=:
-
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
-	    ;;
-	  xl* | mpixl* | bgxl*)
-	    # IBM XL 8.0 on PPC, with GNU ld
-	    hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
-	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
-	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	    if test yes = "$supports_anon_versioning"; then
-	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
-                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-                echo "local: *; };" >> $output_objdir/$libname.ver~
-                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
-	    fi
-	    ;;
-	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
-	    *Sun\ C*)
-	      # Sun C++ 5.9
-	      no_undefined_flag_CXX=' -zdefs'
-	      archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	      archive_expsym_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
-	      hardcode_libdir_flag_spec_CXX='-R$libdir'
-	      whole_archive_flag_spec_CXX='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	      compiler_needs_object_CXX=yes
-
-	      # Not sure whether something based on
-	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
-	      # would be better.
-	      output_verbose_link_cmd='func_echo_all'
-
-	      # Archives containing C++ object files must be created using
-	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
-	      # necessary to make sure instantiated templates are included
-	      # in the archive.
-	      old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
-	      ;;
-	    esac
-	    ;;
-	esac
-	;;
-
-      lynxos*)
-        # FIXME: insert proper C++ library support
-	ld_shlibs_CXX=no
-	;;
-
-      m88k*)
-        # FIXME: insert proper C++ library support
-        ld_shlibs_CXX=no
-	;;
-
-      mvs*)
-        case $cc_basename in
-          cxx*)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-	  *)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-	esac
-	;;
-
-      netbsd*)
-        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	  archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
-	  wlarc=
-	  hardcode_libdir_flag_spec_CXX='-R$libdir'
-	  hardcode_direct_CXX=yes
-	  hardcode_shlibpath_var_CXX=no
-	fi
-	# Workaround some broken pre-1.5 toolchains
-	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
-	;;
-
-      *nto* | *qnx*)
-        ld_shlibs_CXX=yes
-	;;
-
-      openbsd* | bitrig*)
-	if test -f /usr/libexec/ld.so; then
-	  hardcode_direct_CXX=yes
-	  hardcode_shlibpath_var_CXX=no
-	  hardcode_direct_absolute_CXX=yes
-	  archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-	  hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
-	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
-	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
-	    export_dynamic_flag_spec_CXX='$wl-E'
-	    whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-	  fi
-	  output_verbose_link_cmd=func_echo_all
-	else
-	  ld_shlibs_CXX=no
-	fi
-	;;
-
-      osf3* | osf4* | osf5*)
-        case $cc_basename in
-          KCC*)
-	    # Kuck and Associates, Inc. (KAI) C++ Compiler
-
-	    # KCC will only create a shared library if the output file
-	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
-	    # to its proper name (with version) after linking.
-	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-
-	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
-	    hardcode_libdir_separator_CXX=:
-
-	    # Archives containing C++ object files must be created using
-	    # the KAI C++ compiler.
-	    case $host in
-	      osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;;
-	      *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;;
-	    esac
-	    ;;
-          RCC*)
-	    # Rational C++ 2.4.1
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          cxx*)
-	    case $host in
-	      osf3*)
-	        allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
-	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
-		;;
-	      *)
-	        allow_undefined_flag_CXX=' -expect_unresolved \*'
-	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	        archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
-                  echo "-hidden">> $lib.exp~
-                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
-                  $RM $lib.exp'
-	        hardcode_libdir_flag_spec_CXX='-rpath $libdir'
-		;;
-	    esac
-
-	    hardcode_libdir_separator_CXX=:
-
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-	    ;;
-	  *)
-	    if test yes,no = "$GXX,$with_gnu_ld"; then
-	      allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
-	      case $host in
-	        osf3*)
-	          archive_cmds_CXX='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-		  ;;
-	        *)
-	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-		  ;;
-	      esac
-
-	      hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
-	      hardcode_libdir_separator_CXX=:
-
-	      # Commands to make compiler produce verbose output that lists
-	      # what "hidden" libraries, object files and flags are used when
-	      # linking a shared library.
-	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-
-	    else
-	      # FIXME: insert proper C++ library support
-	      ld_shlibs_CXX=no
-	    fi
-	    ;;
-        esac
-        ;;
-
-      psos*)
-        # FIXME: insert proper C++ library support
-        ld_shlibs_CXX=no
-        ;;
-
-      sunos4*)
-        case $cc_basename in
-          CC*)
-	    # Sun C++ 4.x
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          lcc*)
-	    # Lucid
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-        esac
-        ;;
-
-      solaris*)
-        case $cc_basename in
-          CC* | sunCC*)
-	    # Sun C++ 4.2, 5.x and Centerline C++
-            archive_cmds_need_lc_CXX=yes
-	    no_undefined_flag_CXX=' -zdefs'
-	    archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	    archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	    hardcode_libdir_flag_spec_CXX='-R$libdir'
-	    hardcode_shlibpath_var_CXX=no
-	    case $host_os in
-	      solaris2.[0-5] | solaris2.[0-5].*) ;;
-	      *)
-		# The compiler driver will combine and reorder linker options,
-		# but understands '-z linker_flag'.
-	        # Supported since Solaris 2.6 (maybe 2.5.1?)
-		whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
-	        ;;
-	    esac
-	    link_all_deplibs_CXX=yes
-
-	    output_verbose_link_cmd='func_echo_all'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
-	    # necessary to make sure instantiated templates are included
-	    # in the archive.
-	    old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
-	    ;;
-          gcx*)
-	    # Green Hills C++ Compiler
-	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-
-	    # The C++ compiler must be used to create the archive.
-	    old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
-	    ;;
-          *)
-	    # GNU C++ compiler with Solaris linker
-	    if test yes,no = "$GXX,$with_gnu_ld"; then
-	      no_undefined_flag_CXX=' $wl-z ${wl}defs'
-	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
-	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	        # Commands to make compiler produce verbose output that lists
-	        # what "hidden" libraries, object files and flags are used when
-	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-	      else
-	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
-	        # platform.
-	        archive_cmds_CXX='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	        # Commands to make compiler produce verbose output that lists
-	        # what "hidden" libraries, object files and flags are used when
-	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-	      fi
-
-	      hardcode_libdir_flag_spec_CXX='$wl-R $wl$libdir'
-	      case $host_os in
-		solaris2.[0-5] | solaris2.[0-5].*) ;;
-		*)
-		  whole_archive_flag_spec_CXX='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
-		  ;;
-	      esac
-	    fi
-	    ;;
-        esac
-        ;;
-
-    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
-      no_undefined_flag_CXX='$wl-z,text'
-      archive_cmds_need_lc_CXX=no
-      hardcode_shlibpath_var_CXX=no
-      runpath_var='LD_RUN_PATH'
-
-      case $cc_basename in
-        CC*)
-	  archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-	  archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-      esac
-      ;;
-
-      sysv5* | sco3.2v5* | sco5v6*)
-	# Note: We CANNOT use -z defs as we might desire, because we do not
-	# link with -lc, and that would cause any symbols used from libc to
-	# always be unresolved, which means just about no library would
-	# ever link correctly.  If we're not using GNU ld we use -z text
-	# though, which does catch some bad symbols but isn't as heavy-handed
-	# as -z defs.
-	no_undefined_flag_CXX='$wl-z,text'
-	allow_undefined_flag_CXX='$wl-z,nodefs'
-	archive_cmds_need_lc_CXX=no
-	hardcode_shlibpath_var_CXX=no
-	hardcode_libdir_flag_spec_CXX='$wl-R,$libdir'
-	hardcode_libdir_separator_CXX=':'
-	link_all_deplibs_CXX=yes
-	export_dynamic_flag_spec_CXX='$wl-Bexport'
-	runpath_var='LD_RUN_PATH'
-
-	case $cc_basename in
-          CC*)
-	    archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
-              '"$old_archive_cmds_CXX"
-	    reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
-              '"$reload_cmds_CXX"
-	    ;;
-	  *)
-	    archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    ;;
-	esac
-      ;;
-
-      tandem*)
-        case $cc_basename in
-          NCC*)
-	    # NonStop-UX NCC 3.20
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    ld_shlibs_CXX=no
-	    ;;
-        esac
-        ;;
-
-      vxworks*)
-        # FIXME: insert proper C++ library support
-        ld_shlibs_CXX=no
-        ;;
-
-      *)
-        # FIXME: insert proper C++ library support
-        ld_shlibs_CXX=no
-        ;;
-    esac
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
-printf "%s\n" "$ld_shlibs_CXX" >&6; }
-    test no = "$ld_shlibs_CXX" && can_build_shared=no
-
-    GCC_CXX=$GXX
-    LD_CXX=$LD
-
-    ## CAVEAT EMPTOR:
-    ## There is no encapsulation within the following macros, do not change
-    ## the running order or otherwise move them around unless you know exactly
-    ## what you are doing...
-    # Dependencies to place before and after the object being linked:
-predep_objects_CXX=
-postdep_objects_CXX=
-predeps_CXX=
-postdeps_CXX=
-compiler_lib_search_path_CXX=
-
-cat > conftest.$ac_ext <<_LT_EOF
-class Foo
-{
-public:
-  Foo (void) { a = 0; }
-private:
-  int a;
-};
-_LT_EOF
-
-
-_lt_libdeps_save_CFLAGS=$CFLAGS
-case "$CC $CFLAGS " in #(
-*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
-*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
-*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
-esac
-
-if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }; then
-  # Parse the compiler output and extract the necessary
-  # objects, libraries and library flags.
-
-  # Sentinel used to keep track of whether or not we are before
-  # the conftest object file.
-  pre_test_object_deps_done=no
-
-  for p in `eval "$output_verbose_link_cmd"`; do
-    case $prev$p in
-
-    -L* | -R* | -l*)
-       # Some compilers place space between "-{L,R}" and the path.
-       # Remove the space.
-       if test x-L = "$p" ||
-          test x-R = "$p"; then
-	 prev=$p
-	 continue
-       fi
-
-       # Expand the sysroot to ease extracting the directories later.
-       if test -z "$prev"; then
-         case $p in
-         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
-         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
-         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
-         esac
-       fi
-       case $p in
-       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
-       esac
-       if test no = "$pre_test_object_deps_done"; then
-	 case $prev in
-	 -L | -R)
-	   # Internal compiler library paths should come after those
-	   # provided the user.  The postdeps already come after the
-	   # user supplied libs so there is no need to process them.
-	   if test -z "$compiler_lib_search_path_CXX"; then
-	     compiler_lib_search_path_CXX=$prev$p
-	   else
-	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} $prev$p"
-	   fi
-	   ;;
-	 # The "-l" case would never come before the object being
-	 # linked, so don't bother handling this case.
-	 esac
-       else
-	 if test -z "$postdeps_CXX"; then
-	   postdeps_CXX=$prev$p
-	 else
-	   postdeps_CXX="${postdeps_CXX} $prev$p"
-	 fi
-       fi
-       prev=
-       ;;
-
-    *.lto.$objext) ;; # Ignore GCC LTO objects
-    *.$objext)
-       # This assumes that the test object file only shows up
-       # once in the compiler output.
-       if test "$p" = "conftest.$objext"; then
-	 pre_test_object_deps_done=yes
-	 continue
-       fi
-
-       if test no = "$pre_test_object_deps_done"; then
-	 if test -z "$predep_objects_CXX"; then
-	   predep_objects_CXX=$p
-	 else
-	   predep_objects_CXX="$predep_objects_CXX $p"
-	 fi
-       else
-	 if test -z "$postdep_objects_CXX"; then
-	   postdep_objects_CXX=$p
-	 else
-	   postdep_objects_CXX="$postdep_objects_CXX $p"
-	 fi
-       fi
-       ;;
-
-    *) ;; # Ignore the rest.
-
-    esac
-  done
-
-  # Clean up.
-  rm -f a.out a.exe
-else
-  echo "libtool.m4: error: problem compiling CXX test program"
-fi
-
-$RM -f confest.$objext
-CFLAGS=$_lt_libdeps_save_CFLAGS
-
-# PORTME: override above test on systems where it is broken
-case $host_os in
-interix[3-9]*)
-  # Interix 3.5 installs completely hosed .la files for C++, so rather than
-  # hack all around it, let's just trust "g++" to DTRT.
-  predep_objects_CXX=
-  postdep_objects_CXX=
-  postdeps_CXX=
-  ;;
-esac
-
-
-case " $postdeps_CXX " in
-*" -lc "*) archive_cmds_need_lc_CXX=no ;;
-esac
- compiler_lib_search_dirs_CXX=
-if test -n "${compiler_lib_search_path_CXX}"; then
- compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | $SED -e 's! -L! !g' -e 's!^ !!'`
-fi
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    lt_prog_compiler_wl_CXX=
-lt_prog_compiler_pic_CXX=
-lt_prog_compiler_static_CXX=
-
-
-  # C++ specific cases for pic, static, wl, etc.
-  if test yes = "$GXX"; then
-    lt_prog_compiler_wl_CXX='-Wl,'
-    lt_prog_compiler_static_CXX='-static'
-
-    case $host_os in
-    aix*)
-      # All AIX code is PIC.
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	lt_prog_compiler_static_CXX='-Bstatic'
-      fi
-      lt_prog_compiler_pic_CXX='-fPIC'
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            lt_prog_compiler_pic_CXX='-fPIC'
-        ;;
-      m68k)
-            # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the '-m68020' flag to GCC prevents building anything better,
-            # like '-m68040'.
-            lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
-        ;;
-      esac
-      ;;
-
-    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
-      # PIC is the default for these OSes.
-      ;;
-    mingw* | cygwin* | os2* | pw32* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      # Although the cygwin gcc ignores -fPIC, still need this for old-style
-      # (--disable-auto-import) libraries
-      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
-      case $host_os in
-      os2*)
-	lt_prog_compiler_static_CXX='$wl-static'
-	;;
-      esac
-      ;;
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      lt_prog_compiler_pic_CXX='-fno-common'
-      ;;
-    *djgpp*)
-      # DJGPP does not support shared libraries at all
-      lt_prog_compiler_pic_CXX=
-      ;;
-    haiku*)
-      # PIC is the default for Haiku.
-      # The "-static" flag exists, but is broken.
-      lt_prog_compiler_static_CXX=
-      ;;
-    interix[3-9]*)
-      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
-      # Instead, we relocate shared libraries at runtime.
-      ;;
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	lt_prog_compiler_pic_CXX=-Kconform_pic
-      fi
-      ;;
-    hpux*)
-      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
-      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
-      # sets the default TLS model and affects inlining.
-      case $host_cpu in
-      hppa*64*)
-	;;
-      *)
-	lt_prog_compiler_pic_CXX='-fPIC'
-	;;
-      esac
-      ;;
-    *qnx* | *nto*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      lt_prog_compiler_pic_CXX='-fPIC -shared'
-      ;;
-    *)
-      lt_prog_compiler_pic_CXX='-fPIC'
-      ;;
-    esac
-  else
-    case $host_os in
-      aix[4-9]*)
-	# All AIX code is PIC.
-	if test ia64 = "$host_cpu"; then
-	  # AIX 5 now supports IA64 processor
-	  lt_prog_compiler_static_CXX='-Bstatic'
-	else
-	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
-	fi
-	;;
-      chorus*)
-	case $cc_basename in
-	cxch68*)
-	  # Green Hills C++ Compiler
-	  # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
-	  ;;
-	esac
-	;;
-      mingw* | cygwin* | os2* | pw32* | cegcc*)
-	# This hack is so that the source file can tell whether it is being
-	# built for inclusion in a dll (and should export symbols for example).
-	lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
-	;;
-      dgux*)
-	case $cc_basename in
-	  ec++*)
-	    lt_prog_compiler_pic_CXX='-KPIC'
-	    ;;
-	  ghcx*)
-	    # Green Hills C++ Compiler
-	    lt_prog_compiler_pic_CXX='-pic'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      freebsd* | dragonfly*)
-	# FreeBSD uses GNU C++
-	;;
-      hpux9* | hpux10* | hpux11*)
-	case $cc_basename in
-	  CC*)
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
-	    if test ia64 != "$host_cpu"; then
-	      lt_prog_compiler_pic_CXX='+Z'
-	    fi
-	    ;;
-	  aCC*)
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
-	    case $host_cpu in
-	    hppa*64*|ia64*)
-	      # +Z the default
-	      ;;
-	    *)
-	      lt_prog_compiler_pic_CXX='+Z'
-	      ;;
-	    esac
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      interix*)
-	# This is c89, which is MS Visual C++ (no shared libs)
-	# Anyone wants to do a port?
-	;;
-      irix5* | irix6* | nonstopux*)
-	case $cc_basename in
-	  CC*)
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_static_CXX='-non_shared'
-	    # CC pic flag -KPIC is the default.
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-	case $cc_basename in
-	  KCC*)
-	    # KAI C++ Compiler
-	    lt_prog_compiler_wl_CXX='--backend -Wl,'
-	    lt_prog_compiler_pic_CXX='-fPIC'
-	    ;;
-	  ecpc* )
-	    # old Intel C++ for x86_64, which still supported -KPIC.
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_pic_CXX='-KPIC'
-	    lt_prog_compiler_static_CXX='-static'
-	    ;;
-	  icpc* )
-	    # Intel C++, used to be incompatible with GCC.
-	    # ICC 10 doesn't accept -KPIC any more.
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_pic_CXX='-fPIC'
-	    lt_prog_compiler_static_CXX='-static'
-	    ;;
-	  pgCC* | pgcpp*)
-	    # Portland Group C++ compiler
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_pic_CXX='-fpic'
-	    lt_prog_compiler_static_CXX='-Bstatic'
-	    ;;
-	  cxx*)
-	    # Compaq C++
-	    # Make sure the PIC flag is empty.  It appears that all Alpha
-	    # Linux and Compaq Tru64 Unix objects are PIC.
-	    lt_prog_compiler_pic_CXX=
-	    lt_prog_compiler_static_CXX='-non_shared'
-	    ;;
-	  xlc* | xlC* | bgxl[cC]* | mpixl[cC]*)
-	    # IBM XL 8.0, 9.0 on PPC and BlueGene
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_pic_CXX='-qpic'
-	    lt_prog_compiler_static_CXX='-qstaticlink'
-	    ;;
-	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
-	    *Sun\ C*)
-	      # Sun C++ 5.9
-	      lt_prog_compiler_pic_CXX='-KPIC'
-	      lt_prog_compiler_static_CXX='-Bstatic'
-	      lt_prog_compiler_wl_CXX='-Qoption ld '
-	      ;;
-	    esac
-	    ;;
-	esac
-	;;
-      lynxos*)
-	;;
-      m88k*)
-	;;
-      mvs*)
-	case $cc_basename in
-	  cxx*)
-	    lt_prog_compiler_pic_CXX='-W c,exportall'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      netbsd* | netbsdelf*-gnu)
-	;;
-      *qnx* | *nto*)
-        # QNX uses GNU C++, but need to define -shared option too, otherwise
-        # it will coredump.
-        lt_prog_compiler_pic_CXX='-fPIC -shared'
-        ;;
-      osf3* | osf4* | osf5*)
-	case $cc_basename in
-	  KCC*)
-	    lt_prog_compiler_wl_CXX='--backend -Wl,'
-	    ;;
-	  RCC*)
-	    # Rational C++ 2.4.1
-	    lt_prog_compiler_pic_CXX='-pic'
-	    ;;
-	  cxx*)
-	    # Digital/Compaq C++
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    # Make sure the PIC flag is empty.  It appears that all Alpha
-	    # Linux and Compaq Tru64 Unix objects are PIC.
-	    lt_prog_compiler_pic_CXX=
-	    lt_prog_compiler_static_CXX='-non_shared'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      psos*)
-	;;
-      solaris*)
-	case $cc_basename in
-	  CC* | sunCC*)
-	    # Sun C++ 4.2, 5.x and Centerline C++
-	    lt_prog_compiler_pic_CXX='-KPIC'
-	    lt_prog_compiler_static_CXX='-Bstatic'
-	    lt_prog_compiler_wl_CXX='-Qoption ld '
-	    ;;
-	  gcx*)
-	    # Green Hills C++ Compiler
-	    lt_prog_compiler_pic_CXX='-PIC'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      sunos4*)
-	case $cc_basename in
-	  CC*)
-	    # Sun C++ 4.x
-	    lt_prog_compiler_pic_CXX='-pic'
-	    lt_prog_compiler_static_CXX='-Bstatic'
-	    ;;
-	  lcc*)
-	    # Lucid
-	    lt_prog_compiler_pic_CXX='-pic'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
-	case $cc_basename in
-	  CC*)
-	    lt_prog_compiler_wl_CXX='-Wl,'
-	    lt_prog_compiler_pic_CXX='-KPIC'
-	    lt_prog_compiler_static_CXX='-Bstatic'
-	    ;;
-	esac
-	;;
-      tandem*)
-	case $cc_basename in
-	  NCC*)
-	    # NonStop-UX NCC 3.20
-	    lt_prog_compiler_pic_CXX='-KPIC'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      vxworks*)
-	;;
-      *)
-	lt_prog_compiler_can_build_shared_CXX=no
-	;;
-    esac
-  fi
-
-case $host_os in
-  # For platforms that do not support PIC, -DPIC is meaningless:
-  *djgpp*)
-    lt_prog_compiler_pic_CXX=
-    ;;
-  *)
-    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
-    ;;
-esac
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
-printf %s "checking for $compiler option to produce PIC... " >&6; }
-if test ${lt_cv_prog_compiler_pic_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; }
-lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX
-
-#
-# Check to make sure the PIC flag actually works.
-#
-if test -n "$lt_prog_compiler_pic_CXX"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
-printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; }
-if test ${lt_cv_prog_compiler_pic_works_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_pic_works_CXX=no
-   ac_outfile=conftest.$ac_objext
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"  ## exclude from sc_useless_quotes_in_assignment
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   # The option is referenced via a variable to avoid confusing sed.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>conftest.err)
-   ac_status=$?
-   cat conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s "$ac_outfile"; then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings other than the usual output.
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
-     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_pic_works_CXX=yes
-     fi
-   fi
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
-
-if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then
-    case $lt_prog_compiler_pic_CXX in
-     "" | " "*) ;;
-     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
-     esac
-else
-    lt_prog_compiler_pic_CXX=
-     lt_prog_compiler_can_build_shared_CXX=no
-fi
-
-fi
-
-
-
-
-
-#
-# Check to make sure the static flag actually works.
-#
-wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
-printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
-if test ${lt_cv_prog_compiler_static_works_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_static_works_CXX=no
-   save_LDFLAGS=$LDFLAGS
-   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
-   echo "$lt_simple_link_test_code" > conftest.$ac_ext
-   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
-     # The linker can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     if test -s conftest.err; then
-       # Append any errors to the config.log.
-       cat conftest.err 1>&5
-       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
-       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-       if diff conftest.exp conftest.er2 >/dev/null; then
-         lt_cv_prog_compiler_static_works_CXX=yes
-       fi
-     else
-       lt_cv_prog_compiler_static_works_CXX=yes
-     fi
-   fi
-   $RM -r conftest*
-   LDFLAGS=$save_LDFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
-printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; }
-
-if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then
-    :
-else
-    lt_prog_compiler_static_CXX=
-fi
-
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
-printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
-if test ${lt_cv_prog_compiler_c_o_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o_CXX=no
-   $RM -r conftest 2>/dev/null
-   mkdir conftest
-   cd conftest
-   mkdir out
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-   lt_compiler_flag="-o out/conftest2.$ac_objext"
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>out/conftest.err)
-   ac_status=$?
-   cat out/conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s out/conftest2.$ac_objext
-   then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
-     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
-     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_c_o_CXX=yes
-     fi
-   fi
-   chmod u+w . 2>&5
-   $RM conftest*
-   # SGI C++ compiler will create directory out/ii_files/ for
-   # template instantiation
-   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
-   $RM out/* && rmdir out
-   cd ..
-   $RM -r conftest
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
-printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
-if test ${lt_cv_prog_compiler_c_o_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_prog_compiler_c_o_CXX=no
-   $RM -r conftest 2>/dev/null
-   mkdir conftest
-   cd conftest
-   mkdir out
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-   lt_compiler_flag="-o out/conftest2.$ac_objext"
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
-   (eval "$lt_compile" 2>out/conftest.err)
-   ac_status=$?
-   cat out/conftest.err >&5
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   if (exit $ac_status) && test -s out/conftest2.$ac_objext
-   then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
-     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
-     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
-       lt_cv_prog_compiler_c_o_CXX=yes
-     fi
-   fi
-   chmod u+w . 2>&5
-   $RM conftest*
-   # SGI C++ compiler will create directory out/ii_files/ for
-   # template instantiation
-   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
-   $RM out/* && rmdir out
-   cd ..
-   $RM -r conftest
-   $RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; }
-
-
-
-
-hard_links=nottested
-if test no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; then
-  # do not overwrite the value of need_locks provided by the user
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
-printf %s "checking if we can lock with hard links... " >&6; }
-  hard_links=yes
-  $RM conftest*
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  touch conftest.a
-  ln conftest.a conftest.b 2>&5 || hard_links=no
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
-printf "%s\n" "$hard_links" >&6; }
-  if test no = "$hard_links"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
-printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
-    need_locks=warn
-  fi
-else
-  need_locks=no
-fi
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
-printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
-
-  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-  exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
-  case $host_os in
-  aix[4-9]*)
-    # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
-    # Without the "-l" option, or with the "-B" option, AIX nm treats
-    # weak defined symbols like other global defined symbols, whereas
-    # GNU nm marks them as "W".
-    # While the 'weak' keyword is ignored in the Export File, we need
-    # it in the Import File for the 'aix-soname' feature, so we have
-    # to replace the "-B" option with "-P" for AIX nm.
-    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
-    else
-      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
-    fi
-    ;;
-  pw32*)
-    export_symbols_cmds_CXX=$ltdll_cmds
-    ;;
-  cygwin* | mingw* | cegcc*)
-    case $cc_basename in
-    cl*)
-      exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
-      ;;
-    *)
-      export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
-      exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
-      ;;
-    esac
-    ;;
-  linux* | k*bsd*-gnu | gnu*)
-    link_all_deplibs_CXX=no
-    ;;
-  *)
-    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-    ;;
-  esac
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
-printf "%s\n" "$ld_shlibs_CXX" >&6; }
-test no = "$ld_shlibs_CXX" && can_build_shared=no
-
-with_gnu_ld_CXX=$with_gnu_ld
-
-
-
-
-
-
-#
-# Do we need to explicitly link libc?
-#
-case "x$archive_cmds_need_lc_CXX" in
-x|xyes)
-  # Assume -lc should be added
-  archive_cmds_need_lc_CXX=yes
-
-  if test yes,yes = "$GCC,$enable_shared"; then
-    case $archive_cmds_CXX in
-    *'~'*)
-      # FIXME: we may have to deal with multi-command sequences.
-      ;;
-    '$CC '*)
-      # Test whether the compiler implicitly links with -lc since on some
-      # systems, -lgcc has to come before -lc. If gcc already passes -lc
-      # to ld, don't add -lc before -lgcc.
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
-printf %s "checking whether -lc should be explicitly linked in... " >&6; }
-if test ${lt_cv_archive_cmds_need_lc_CXX+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  $RM conftest*
-	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } 2>conftest.err; then
-	  soname=conftest
-	  lib=conftest
-	  libobjs=conftest.$ac_objext
-	  deplibs=
-	  wl=$lt_prog_compiler_wl_CXX
-	  pic_flag=$lt_prog_compiler_pic_CXX
-	  compiler_flags=-v
-	  linker_flags=-v
-	  verstring=
-	  output_objdir=.
-	  libname=conftest
-	  lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
-	  allow_undefined_flag_CXX=
-	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
-  (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
-  ac_status=$?
-  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; }
-	  then
-	    lt_cv_archive_cmds_need_lc_CXX=no
-	  else
-	    lt_cv_archive_cmds_need_lc_CXX=yes
-	  fi
-	  allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
-	else
-	  cat conftest.err 1>&5
-	fi
-	$RM conftest*
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
-printf "%s\n" "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
-      archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX
-      ;;
-    esac
-  fi
-  ;;
-esac
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
-printf %s "checking dynamic linker characteristics... " >&6; }
-
-library_names_spec=
-libname_spec='lib$name'
-soname_spec=
-shrext_cmds=.so
-postinstall_cmds=
-postuninstall_cmds=
-finish_cmds=
-finish_eval=
-shlibpath_var=
-shlibpath_overrides_runpath=unknown
-version_type=none
-dynamic_linker="$host_os ld.so"
-sys_lib_dlsearch_path_spec="/lib /usr/lib"
-need_lib_prefix=unknown
-hardcode_into_libs=no
-
-# when you set need_version to no, make sure it does not cause -set_version
-# flags to be left without arguments
-need_version=unknown
-
-
-
-case $host_os in
-aix3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
-  shlibpath_var=LIBPATH
-
-  # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='$libname$release$shared_ext$major'
-  ;;
-
-aix[4-9]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  hardcode_into_libs=yes
-  if test ia64 = "$host_cpu"; then
-    # AIX 5 supports IA64
-    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
-    shlibpath_var=LD_LIBRARY_PATH
-  else
-    # With GCC up to 2.95.x, collect2 would create an import file
-    # for dependence libraries.  The import file would start with
-    # the line '#! .'.  This would cause the generated library to
-    # depend on '.', always an invalid library.  This was fixed in
-    # development snapshots of GCC prior to 3.0.
-    case $host_os in
-      aix4 | aix4.[01] | aix4.[01].*)
-      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
-	   echo ' yes '
-	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
-	:
-      else
-	can_build_shared=no
-      fi
-      ;;
-    esac
-    # Using Import Files as archive members, it is possible to support
-    # filename-based versioning of shared library archives on AIX. While
-    # this would work for both with and without runtime linking, it will
-    # prevent static linking of such archives. So we do filename-based
-    # shared library versioning with .so extension only, which is used
-    # when both runtime linking and shared linking is enabled.
-    # Unfortunately, runtime linking may impact performance, so we do
-    # not want this to be the default eventually. Also, we use the
-    # versioned .so libs for executables only if there is the -brtl
-    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
-    # To allow for filename-based versioning support, we need to create
-    # libNAME.so.V as an archive file, containing:
-    # *) an Import File, referring to the versioned filename of the
-    #    archive as well as the shared archive member, telling the
-    #    bitwidth (32 or 64) of that shared object, and providing the
-    #    list of exported symbols of that shared object, eventually
-    #    decorated with the 'weak' keyword
-    # *) the shared object with the F_LOADONLY flag set, to really avoid
-    #    it being seen by the linker.
-    # At run time we better use the real file rather than another symlink,
-    # but for link time we create the symlink libNAME.so -> libNAME.so.V
-
-    case $with_aix_soname,$aix_use_runtimelinking in
-    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
-    # soname into executable. Probably we can add versioning support to
-    # collect2, so additional links can be useful in future.
-    aix,yes) # traditional libtool
-      dynamic_linker='AIX unversionable lib.so'
-      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
-      # instead of lib<name>.a to let people know that these are not
-      # typical AIX shared libraries.
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      ;;
-    aix,no) # traditional AIX only
-      dynamic_linker='AIX lib.a(lib.so.V)'
-      # We preserve .a as extension for shared libraries through AIX4.2
-      # and later when we are not doing run time linking.
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      ;;
-    svr4,*) # full svr4 only
-      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,yes) # both, prefer svr4
-      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # unpreferred sharedlib libNAME.a needs extra handling
-      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
-      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,no) # both, prefer aix
-      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
-      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
-      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
-      ;;
-    esac
-    shlibpath_var=LIBPATH
-  fi
-  ;;
-
-amigaos*)
-  case $host_cpu in
-  powerpc)
-    # Since July 2007 AmigaOS4 officially supports .so libraries.
-    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    ;;
-  m68k)
-    library_names_spec='$libname.ixlibrary $libname.a'
-    # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
-    ;;
-  esac
-  ;;
-
-beos*)
-  library_names_spec='$libname$shared_ext'
-  dynamic_linker="$host_os ld.so"
-  shlibpath_var=LIBRARY_PATH
-  ;;
-
-bsdi[45]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
-  # the default ld.so.conf also contains /usr/contrib/lib and
-  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
-  # libtool to hard-code these into programs
-  ;;
-
-cygwin* | mingw* | pw32* | cegcc*)
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-
-  case $GCC,$cc_basename in
-  yes,*)
-    # gcc
-    library_names_spec='$libname.dll.a'
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname~
-      chmod a+x \$dldir/$dlname~
-      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-      fi'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-
-    case $host_os in
-    cygwin*)
-      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-
-      ;;
-    mingw* | cegcc*)
-      # MinGW DLLs use traditional 'lib' prefix
-      soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-      ;;
-    pw32*)
-      # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-      ;;
-    esac
-    dynamic_linker='Win32 ld.exe'
-    ;;
-
-  *,cl*)
-    # Native MSVC
-    libname_spec='$name'
-    soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
-    library_names_spec='$libname.dll.lib'
-
-    case $build_os in
-    mingw*)
-      sys_lib_search_path_spec=
-      lt_save_ifs=$IFS
-      IFS=';'
-      for lt_path in $LIB
-      do
-        IFS=$lt_save_ifs
-        # Let DOS variable expansion print the short 8.3 style file name.
-        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
-        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
-      done
-      IFS=$lt_save_ifs
-      # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
-      ;;
-    cygwin*)
-      # Convert to unix form, then to dos form, then back to unix form
-      # but this time dos style (no spaces!) so that the unix form looks
-      # like /cygdrive/c/PROGRA~1:/cygdr...
-      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
-      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
-      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      ;;
-    *)
-      sys_lib_search_path_spec=$LIB
-      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
-        # It is most probably a Windows format PATH.
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
-      else
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      fi
-      # FIXME: find the short name or the path components, as spaces are
-      # common. (e.g. "Program Files" -> "PROGRA~1")
-      ;;
-    esac
-
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-    dynamic_linker='Win32 link.exe'
-    ;;
-
-  *)
-    # Assume MSVC wrapper
-    library_names_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext $libname.lib'
-    dynamic_linker='Win32 ld.exe'
-    ;;
-  esac
-  # FIXME: first we should search . and the directory the executable is in
-  shlibpath_var=PATH
-  ;;
-
-darwin* | rhapsody*)
-  dynamic_linker="$host_os dyld"
-  version_type=darwin
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$major$shared_ext'
-  shlibpath_overrides_runpath=yes
-  shlibpath_var=DYLD_LIBRARY_PATH
-  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
-
-  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
-  ;;
-
-dgux*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-freebsd* | dragonfly*)
-  # DragonFly does not have aout.  When/if they implement a new
-  # versioning mechanism, adjust this.
-  if test -x /usr/bin/objformat; then
-    objformat=`/usr/bin/objformat`
-  else
-    case $host_os in
-    freebsd[23].*) objformat=aout ;;
-    *) objformat=elf ;;
-    esac
-  fi
-  version_type=freebsd-$objformat
-  case $version_type in
-    freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      soname_spec='$libname$release$shared_ext$major'
-      need_version=no
-      need_lib_prefix=no
-      ;;
-    freebsd-*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-      need_version=yes
-      ;;
-  esac
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_os in
-  freebsd2.*)
-    shlibpath_overrides_runpath=yes
-    ;;
-  freebsd3.[01]* | freebsdelf3.[01]*)
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
-  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
-    shlibpath_overrides_runpath=no
-    hardcode_into_libs=yes
-    ;;
-  *) # from 4.6 on, and DragonFly
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  esac
-  ;;
-
-haiku*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  dynamic_linker="$host_os runtime_loader"
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
-  hardcode_into_libs=yes
-  ;;
-
-hpux9* | hpux10* | hpux11*)
-  # Give a soname corresponding to the major version so that dld.sl refuses to
-  # link against other versions.
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  case $host_cpu in
-  ia64*)
-    shrext_cmds='.so'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.so"
-    shlibpath_var=LD_LIBRARY_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    if test 32 = "$HPUX_IA64_MODE"; then
-      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
-    else
-      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
-    fi
-    ;;
-  hppa*64*)
-    shrext_cmds='.sl'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-    ;;
-  *)
-    shrext_cmds='.sl'
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=SHLIB_PATH
-    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    ;;
-  esac
-  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
-  postinstall_cmds='chmod 555 $lib'
-  # or fails outright, so override atomically:
-  install_override_mode=555
-  ;;
-
-interix[3-9]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-irix5* | irix6* | nonstopux*)
-  case $host_os in
-    nonstopux*) version_type=nonstopux ;;
-    *)
-	if test yes = "$lt_cv_prog_gnu_ld"; then
-		version_type=linux # correct to gnu/linux during the next big refactor
-	else
-		version_type=irix
-	fi ;;
-  esac
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
-  case $host_os in
-  irix5* | nonstopux*)
-    libsuff= shlibsuff=
-    ;;
-  *)
-    case $LD in # libtool.m4 will add one of these switches to LD
-    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
-      libsuff= shlibsuff= libmagic=32-bit;;
-    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
-      libsuff=32 shlibsuff=N32 libmagic=N32;;
-    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
-      libsuff=64 shlibsuff=64 libmagic=64-bit;;
-    *) libsuff= shlibsuff= libmagic=never-match;;
-    esac
-    ;;
-  esac
-  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
-  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
-  hardcode_into_libs=yes
-  ;;
-
-# No shared lib support for Linux oldld, aout, or coff.
-linux*oldld* | linux*aout* | linux*coff*)
-  dynamic_linker=no
-  ;;
-
-linux*android*)
-  version_type=none # Android doesn't support versioned libraries.
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext'
-  soname_spec='$libname$release$shared_ext'
-  finish_cmds=
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  dynamic_linker='Android linker'
-  # Don't embed -rpath directories since the linker doesn't support them.
-  hardcode_libdir_flag_spec_CXX='-L$libdir'
-  ;;
-
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-
-  # Some binutils ld are patched to set DT_RUNPATH
-  if test ${lt_cv_shlibpath_overrides_runpath+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  lt_cv_shlibpath_overrides_runpath=no
-    save_LDFLAGS=$LDFLAGS
-    save_libdir=$libdir
-    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
-	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\""
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_link "$LINENO"
-then :
-  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null
-then :
-  lt_cv_shlibpath_overrides_runpath=yes
-fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LDFLAGS=$save_LDFLAGS
-    libdir=$save_libdir
-
-fi
-
-  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  # Ideally, we could use ldconfig to report *all* directores which are
-  # searched for libraries, however this is still not possible.  Aside from not
-  # being certain /sbin/ldconfig is available, command
-  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
-  # even though it is searched at run-time.  Try to do the best guess by
-  # appending ld.so.conf contents (and includes) to the search path.
-  if test -f /etc/ld.so.conf; then
-    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
-  fi
-
-  # We used to test for /lib/ld.so.1 and disable shared libraries on
-  # powerpc, because MkLinux only supported shared libraries with the
-  # GNU dynamic linker.  Since this was broken with cross compilers,
-  # most powerpc-linux boxes support dynamic linking these days and
-  # people can always --disable-shared, the test was removed, and we
-  # assume the GNU/Linux dynamic linker is in use.
-  dynamic_linker='GNU/Linux ld.so'
-  ;;
-
-netbsdelf*-gnu)
-  version_type=linux
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='NetBSD ld.elf_so'
-  ;;
-
-netbsd*)
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-    dynamic_linker='NetBSD (a.out) ld.so'
-  else
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    dynamic_linker='NetBSD ld.elf_so'
-  fi
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  ;;
-
-newsos6)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-*nto* | *qnx*)
-  version_type=qnx
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='ldqnx.so'
-  ;;
-
-openbsd* | bitrig*)
-  version_type=sunos
-  sys_lib_dlsearch_path_spec=/usr/lib
-  need_lib_prefix=no
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-    need_version=no
-  else
-    need_version=yes
-  fi
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-os2*)
-  libname_spec='$name'
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-  # OS/2 can only load a DLL with a base name of 8 characters or less.
-  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
-    v=$($ECHO $release$versuffix | tr -d .-);
-    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
-    $ECHO $n$v`$shared_ext'
-  library_names_spec='${libname}_dll.$libext'
-  dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=BEGINLIBPATH
-  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  postinstall_cmds='base_file=`basename \$file`~
-    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
-    dldir=$destdir/`dirname \$dlpath`~
-    test -d \$dldir || mkdir -p \$dldir~
-    $install_prog $dir/$dlname \$dldir/$dlname~
-    chmod a+x \$dldir/$dlname~
-    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-    fi'
-  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
-    dlpath=$dir/\$dldll~
-    $RM \$dlpath'
-  ;;
-
-osf3* | osf4* | osf5*)
-  version_type=osf
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  ;;
-
-rdos*)
-  dynamic_linker=no
-  ;;
-
-solaris*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  # ldd complains unless libraries are executable
-  postinstall_cmds='chmod +x $lib'
-  ;;
-
-sunos4*)
-  version_type=sunos
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  if test yes = "$with_gnu_ld"; then
-    need_lib_prefix=no
-  fi
-  need_version=yes
-  ;;
-
-sysv4 | sysv4.3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_vendor in
-    sni)
-      shlibpath_overrides_runpath=no
-      need_lib_prefix=no
-      runpath_var=LD_RUN_PATH
-      ;;
-    siemens)
-      need_lib_prefix=no
-      ;;
-    motorola)
-      need_lib_prefix=no
-      need_version=no
-      shlibpath_overrides_runpath=no
-      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
-      ;;
-  esac
-  ;;
-
-sysv4*MP*)
-  if test -d /usr/nec; then
-    version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
-    soname_spec='$libname$shared_ext.$major'
-    shlibpath_var=LD_LIBRARY_PATH
-  fi
-  ;;
-
-sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=sco
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  if test yes = "$with_gnu_ld"; then
-    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
-  else
-    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
-    case $host_os in
-      sco3.2v5*)
-        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
-	;;
-    esac
-  fi
-  sys_lib_dlsearch_path_spec='/usr/lib'
-  ;;
-
-tpf*)
-  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-uts4*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-*)
-  dynamic_linker=no
-  ;;
-esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
-printf "%s\n" "$dynamic_linker" >&6; }
-test no = "$dynamic_linker" && can_build_shared=no
-
-variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test yes = "$GCC"; then
-  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
-fi
-
-if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
-  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
-fi
-
-if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
-  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
-fi
-
-# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
-configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
-
-# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
-func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
-
-# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
-configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
-printf %s "checking how to hardcode library paths into programs... " >&6; }
-hardcode_action_CXX=
-if test -n "$hardcode_libdir_flag_spec_CXX" ||
-   test -n "$runpath_var_CXX" ||
-   test yes = "$hardcode_automatic_CXX"; then
-
-  # We can hardcode non-existent directories.
-  if test no != "$hardcode_direct_CXX" &&
-     # If the only mechanism to avoid hardcoding is shlibpath_var, we
-     # have to relink, otherwise we might link with an installed library
-     # when we should be linking with a yet-to-be-installed one
-     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" &&
-     test no != "$hardcode_minus_L_CXX"; then
-    # Linking always hardcodes the temporary library directory.
-    hardcode_action_CXX=relink
-  else
-    # We can link without hardcoding, and we can hardcode nonexisting dirs.
-    hardcode_action_CXX=immediate
-  fi
-else
-  # We cannot hardcode anything, or else we can only hardcode existing
-  # directories.
-  hardcode_action_CXX=unsupported
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
-printf "%s\n" "$hardcode_action_CXX" >&6; }
-
-if test relink = "$hardcode_action_CXX" ||
-   test yes = "$inherit_rpath_CXX"; then
-  # Fast installation is not supported
-  enable_fast_install=no
-elif test yes = "$shlibpath_overrides_runpath" ||
-     test no = "$enable_shared"; then
-  # Fast installation is not necessary
-  enable_fast_install=needless
-fi
-
-
-
-
-
-
-
-  fi # test -n "$compiler"
-
-  CC=$lt_save_CC
-  CFLAGS=$lt_save_CFLAGS
-  LDCXX=$LD
-  LD=$lt_save_LD
-  GCC=$lt_save_GCC
-  with_gnu_ld=$lt_save_with_gnu_ld
-  lt_cv_path_LDCXX=$lt_cv_path_LD
-  lt_cv_path_LD=$lt_save_path_LD
-  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
-  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
-fi # test yes != "$_lt_caught_CXX_error"
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-        ac_config_commands="$ac_config_commands libtool"
-
-
-
-
-# Only expand once:
-
-
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
-printf %s "checking whether byte ordering is bigendian... " >&6; }
-if test ${ac_cv_c_bigendian+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_c_bigendian=unknown
-    # See if we're dealing with a universal compiler.
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifndef __APPLE_CC__
-	       not a universal capable compiler
-	     #endif
-	     typedef int dummy;
-
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-	# Check for potential -arch flags.  It is not universal unless
-	# there are at least two -arch flags with different values.
-	ac_arch=
-	ac_prev=
-	for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
-	 if test -n "$ac_prev"; then
-	   case $ac_word in
-	     i?86 | x86_64 | ppc | ppc64)
-	       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
-		 ac_arch=$ac_word
-	       else
-		 ac_cv_c_bigendian=universal
-		 break
-	       fi
-	       ;;
-	   esac
-	   ac_prev=
-	 elif test "x$ac_word" = "x-arch"; then
-	   ac_prev=arch
-	 fi
-       done
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    if test $ac_cv_c_bigendian = unknown; then
-      # See if sys/param.h defines the BYTE_ORDER macro.
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
-	     #include <sys/param.h>
-
-int
-main (void)
-{
-#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
-		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
-		     && LITTLE_ENDIAN)
-	      bogus endian macros
-	     #endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  # It does; now see whether it defined to BIG_ENDIAN or not.
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
-		#include <sys/param.h>
-
-int
-main (void)
-{
-#if BYTE_ORDER != BIG_ENDIAN
-		 not big endian
-		#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_c_bigendian=yes
-else $as_nop
-  ac_cv_c_bigendian=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    fi
-    if test $ac_cv_c_bigendian = unknown; then
-      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
-      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-
-int
-main (void)
-{
-#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
-	      bogus endian macros
-	     #endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  # It does; now see whether it defined to _BIG_ENDIAN or not.
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-
-int
-main (void)
-{
-#ifndef _BIG_ENDIAN
-		 not big endian
-		#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_c_bigendian=yes
-else $as_nop
-  ac_cv_c_bigendian=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    fi
-    if test $ac_cv_c_bigendian = unknown; then
-      # Compile a test program.
-      if test "$cross_compiling" = yes
-then :
-  # Try to guess by grepping values from an object file.
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-unsigned short int ascii_mm[] =
-		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
-		unsigned short int ascii_ii[] =
-		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
-		int use_ascii (int i) {
-		  return ascii_mm[i] + ascii_ii[i];
-		}
-		unsigned short int ebcdic_ii[] =
-		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
-		unsigned short int ebcdic_mm[] =
-		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
-		int use_ebcdic (int i) {
-		  return ebcdic_mm[i] + ebcdic_ii[i];
-		}
-		extern int foo;
-
-int
-main (void)
-{
-return use_ascii (foo) == use_ebcdic (foo);
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
-	      ac_cv_c_bigendian=yes
-	    fi
-	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
-	      if test "$ac_cv_c_bigendian" = unknown; then
-		ac_cv_c_bigendian=no
-	      else
-		# finding both strings is unlikely to happen, but who knows?
-		ac_cv_c_bigendian=unknown
-	      fi
-	    fi
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_includes_default
-int
-main (void)
-{
-
-	     /* Are we little or big endian?  From Harbison&Steele.  */
-	     union
-	     {
-	       long int l;
-	       char c[sizeof (long int)];
-	     } u;
-	     u.l = 1;
-	     return u.c[sizeof (long int) - 1] == 1;
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_run "$LINENO"
-then :
-  ac_cv_c_bigendian=no
-else $as_nop
-  ac_cv_c_bigendian=yes
-fi
-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
-  conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-
-    fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
-printf "%s\n" "$ac_cv_c_bigendian" >&6; }
- case $ac_cv_c_bigendian in #(
-   yes)
-     printf "%s\n" "#define WORDS_BIGENDIAN 1" >>confdefs.h
-;; #(
-   no)
-      ;; #(
-   universal)
-
-printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
-
-     ;; #(
-   *)
-     as_fn_error $? "unknown endianness
- presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
- esac
-
-
-# Check whether --enable-largefile was given.
-if test ${enable_largefile+y}
-then :
-  enableval=$enable_largefile;
-fi
-
-if test "$enable_largefile" != no; then
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
-printf %s "checking for special C compiler options needed for large files... " >&6; }
-if test ${ac_cv_sys_largefile_CC+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_sys_largefile_CC=no
-     if test "$GCC" != yes; then
-       ac_save_CC=$CC
-       while :; do
-	 # IRIX 6.2 and later do not support large files by default,
-	 # so use the C compiler's -n32 option if that helps.
-	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-	 if ac_fn_c_try_compile "$LINENO"
-then :
-  break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-	 CC="$CC -n32"
-	 if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_largefile_CC=' -n32'; break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam
-	 break
-       done
-       CC=$ac_save_CC
-       rm -f conftest.$ac_ext
-    fi
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
-printf "%s\n" "$ac_cv_sys_largefile_CC" >&6; }
-  if test "$ac_cv_sys_largefile_CC" != no; then
-    CC=$CC$ac_cv_sys_largefile_CC
-  fi
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
-printf %s "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
-if test ${ac_cv_sys_file_offset_bits+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  while :; do
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_file_offset_bits=no; break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#define _FILE_OFFSET_BITS 64
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_file_offset_bits=64; break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  ac_cv_sys_file_offset_bits=unknown
-  break
-done
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
-printf "%s\n" "$ac_cv_sys_file_offset_bits" >&6; }
-case $ac_cv_sys_file_offset_bits in #(
-  no | unknown) ;;
-  *)
-printf "%s\n" "#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits" >>confdefs.h
-;;
-esac
-rm -rf conftest*
-  if test $ac_cv_sys_file_offset_bits = unknown; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
-printf %s "checking for _LARGE_FILES value needed for large files... " >&6; }
-if test ${ac_cv_sys_large_files+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  while :; do
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_large_files=no; break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#define _LARGE_FILES 1
-#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
-		       && LARGE_OFF_T % 2147483647 == 1)
-		      ? 1 : -1];
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_sys_large_files=1; break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  ac_cv_sys_large_files=unknown
-  break
-done
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
-printf "%s\n" "$ac_cv_sys_large_files" >&6; }
-case $ac_cv_sys_large_files in #(
-  no | unknown) ;;
-  *)
-printf "%s\n" "#define _LARGE_FILES $ac_cv_sys_large_files" >>confdefs.h
-;;
-esac
-rm -rf conftest*
-  fi
-fi
-
-
-# Crypto backends
-
-found_crypto=none
-found_crypto_str=""
-support_clear_memory=no
-crypto_errors=""
-
-
-
-
-
-
-
-# Check whether --with-crypto was given.
-if test ${with_crypto+y}
-then :
-  withval=$with_crypto; use_crypto=$withval
-else $as_nop
-  use_crypto=auto
-
-fi
-
-
-case "${use_crypto}" in
-  auto|openssl|libgcrypt|mbedtls|wincng)
-
-      if test "X$prefix" = "XNONE"; then
-    acl_final_prefix="$ac_default_prefix"
-  else
-    acl_final_prefix="$prefix"
-  fi
-  if test "X$exec_prefix" = "XNONE"; then
-    acl_final_exec_prefix='${prefix}'
-  else
-    acl_final_exec_prefix="$exec_prefix"
-  fi
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-gnu-ld was given.
-if test ${with_gnu_ld+y}
-then :
-  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
-else $as_nop
-  with_gnu_ld=no
-fi
-
-# Prepare PATH_SEPARATOR.
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  echo "#! /bin/sh" >conf$$.sh
-  echo  "exit 0"   >>conf$$.sh
-  chmod +x conf$$.sh
-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
-    PATH_SEPARATOR=';'
-  else
-    PATH_SEPARATOR=:
-  fi
-  rm -f conf$$.sh
-fi
-ac_prog=ld
-if test "$GCC" = yes; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by GCC" >&5
-printf %s "checking for ld used by GCC... " >&6; }
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [\\/]* | [A-Za-z]:[\\/]*)
-      re_direlt='/[^/][^/]*/\.\./'
-      # Canonicalize the path of ld
-      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
-      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD="$ac_prog"
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test "$with_gnu_ld" = yes; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
-printf %s "checking for GNU ld... " >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
-printf %s "checking for non-GNU ld... " >&6; }
-fi
-if test ${acl_cv_path_LD+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test -z "$LD"; then
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
-  for ac_dir in $PATH; do
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      acl_cv_path_LD="$ac_dir/$ac_prog"
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some GNU ld's only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
-      *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break ;;
-      *)
-	test "$with_gnu_ld" != yes && break ;;
-      esac
-    fi
-  done
-  IFS="$ac_save_ifs"
-else
-  acl_cv_path_LD="$LD" # Let the user override the test with a path.
-fi
-fi
-
-LD="$acl_cv_path_LD"
-if test -n "$LD"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
-else
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-fi
-test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
-printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
-if test ${acl_cv_prog_gnu_ld+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  acl_cv_prog_gnu_ld=yes ;;
-*)
-  acl_cv_prog_gnu_ld=no ;;
-esac
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_prog_gnu_ld" >&5
-printf "%s\n" "$acl_cv_prog_gnu_ld" >&6; }
-with_gnu_ld=$acl_cv_prog_gnu_ld
-
-
-
-
-
-                                                { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shared library run path origin" >&5
-printf %s "checking for shared library run path origin... " >&6; }
-if test ${acl_cv_rpath+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
-    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
-    . ./conftest.sh
-    rm -f ./conftest.sh
-    acl_cv_rpath=done
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5
-printf "%s\n" "$acl_cv_rpath" >&6; }
-  wl="$acl_cv_wl"
-  acl_libext="$acl_cv_libext"
-  acl_shlibext="$acl_cv_shlibext"
-  acl_libname_spec="$acl_cv_libname_spec"
-  acl_library_names_spec="$acl_cv_library_names_spec"
-  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
-  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
-  acl_hardcode_direct="$acl_cv_hardcode_direct"
-  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
-    # Check whether --enable-rpath was given.
-if test ${enable_rpath+y}
-then :
-  enableval=$enable_rpath; :
-else $as_nop
-  enable_rpath=yes
-fi
-
-
-
-                  acl_libdirstem=lib
-  searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
-  if test -n "$searchpath"; then
-    acl_save_IFS="${IFS= 	}"; IFS=":"
-    for searchdir in $searchpath; do
-      if test -d "$searchdir"; then
-        case "$searchdir" in
-          */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
-          *) searchdir=`cd "$searchdir" && pwd`
-             case "$searchdir" in
-               */lib64 ) acl_libdirstem=lib64 ;;
-             esac ;;
-        esac
-      fi
-    done
-    IFS="$acl_save_IFS"
-  fi
-
-
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "openssl"; then
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libssl_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libssl_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libssl_prefix}/lib"
-  fi
-
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libssl-prefix was given.
-if test ${with_libssl_prefix+y}
-then :
-  withval=$with_libssl_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBSSL=
-  LTLIBSSL=
-  INCSSL=
-  LIBSSL_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='ssl crypto'
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBSSL="${LIBSSL}${LIBSSL:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBSSL; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBSSL="${LIBSSL}${LIBSSL:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBSSL="${LIBSSL}${LIBSSL:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBSSL="${LIBSSL}${LIBSSL:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBSSL; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBSSL="${LIBSSL}${LIBSSL:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBSSL="${LIBSSL}${LIBSSL:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBSSL="${LIBSSL}${LIBSSL:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBSSL="${LIBSSL}${LIBSSL:+ }$found_a"
-              else
-                                                LIBSSL="${LIBSSL}${LIBSSL:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBSSL_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCSSL; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCSSL="${INCSSL}${INCSSL:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBSSL; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBSSL="${LIBSSL}${LIBSSL:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBSSL; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBSSL="${LIBSSL}${LIBSSL:+ }$dep"
-                    LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBSSL="${LIBSSL}${LIBSSL:+ }-l$name"
-            LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBSSL="${LIBSSL}${LIBSSL:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBSSL="${LIBSSL}${LIBSSL:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBSSL="${LTLIBSSL}${LTLIBSSL:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCSSL; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libssl" >&5
-printf %s "checking for libssl... " >&6; }
-if test ${ac_cv_libssl+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBSSL"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <openssl/ssl.h>
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libssl=yes
-else $as_nop
-  ac_cv_libssl=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libssl" >&5
-printf "%s\n" "$ac_cv_libssl" >&6; }
-  if test "$ac_cv_libssl" = yes; then
-    HAVE_LIBSSL=yes
-
-printf "%s\n" "#define HAVE_LIBSSL 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libssl" >&5
-printf %s "checking how to link with libssl... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBSSL" >&5
-printf "%s\n" "$LIBSSL" >&6; }
-  else
-    HAVE_LIBSSL=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBSSL=
-    LTLIBSSL=
-    LIBSSL_PREFIX=
-  fi
-
-
-
-
-
-
-
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libssl" = "yes"; then :
-
-
-printf "%s\n" "#define LIBSSH2_OPENSSL 1" >>confdefs.h
-
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }libssl libcrypto"
-
-    # Not all OpenSSL have AES-CTR functions.
-    libssh2_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBSSL"
-    ac_fn_c_check_func "$LINENO" "EVP_aes_128_ctr" "ac_cv_func_EVP_aes_128_ctr"
-if test "x$ac_cv_func_EVP_aes_128_ctr" = xyes
-then :
-  printf "%s\n" "#define HAVE_EVP_AES_128_CTR 1" >>confdefs.h
-
-fi
-
-    LIBS="$libssh2_save_LIBS"
-
-    found_crypto="openssl"
-    found_crypto_str="OpenSSL (AES-CTR: ${ac_cv_func_EVP_aes_128_ctr:-N/A})"
-
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-
-
-  test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No openssl crypto library found!
-"
-fi
-
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "libgcrypt"; then
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libgcrypt_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libgcrypt_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libgcrypt_prefix}/lib"
-  fi
-
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libgcrypt-prefix was given.
-if test ${with_libgcrypt_prefix+y}
-then :
-  withval=$with_libgcrypt_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBGCRYPT=
-  LTLIBGCRYPT=
-  INCGCRYPT=
-  LIBGCRYPT_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='gcrypt '
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBGCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBGCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$found_a"
-              else
-                                                LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBGCRYPT_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCGCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCGCRYPT="${INCGCRYPT}${INCGCRYPT:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBGCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBGCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$dep"
-                    LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }-l$name"
-            LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBGCRYPT="${LIBGCRYPT}${LIBGCRYPT:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBGCRYPT="${LTLIBGCRYPT}${LTLIBGCRYPT:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCGCRYPT; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libgcrypt" >&5
-printf %s "checking for libgcrypt... " >&6; }
-if test ${ac_cv_libgcrypt+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBGCRYPT"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <gcrypt.h>
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libgcrypt=yes
-else $as_nop
-  ac_cv_libgcrypt=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libgcrypt" >&5
-printf "%s\n" "$ac_cv_libgcrypt" >&6; }
-  if test "$ac_cv_libgcrypt" = yes; then
-    HAVE_LIBGCRYPT=yes
-
-printf "%s\n" "#define HAVE_LIBGCRYPT 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libgcrypt" >&5
-printf %s "checking how to link with libgcrypt... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBGCRYPT" >&5
-printf "%s\n" "$LIBGCRYPT" >&6; }
-  else
-    HAVE_LIBGCRYPT=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBGCRYPT=
-    LTLIBGCRYPT=
-    LIBGCRYPT_PREFIX=
-  fi
-
-
-
-
-
-
-
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libgcrypt" = "yes"; then :
-
-
-printf "%s\n" "#define LIBSSH2_LIBGCRYPT 1" >>confdefs.h
-
-    found_crypto="libgcrypt"
-
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-
-
-  test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No libgcrypt crypto library found!
-"
-fi
-
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "mbedtls"; then
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libmbedcrypto_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libmbedcrypto_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libmbedcrypto_prefix}/lib"
-  fi
-
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libmbedcrypto-prefix was given.
-if test ${with_libmbedcrypto_prefix+y}
-then :
-  withval=$with_libmbedcrypto_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBMBEDCRYPTO=
-  LTLIBMBEDCRYPTO=
-  INCMBEDCRYPTO=
-  LIBMBEDCRYPTO_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='mbedcrypto '
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBMBEDCRYPTO; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBMBEDCRYPTO; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$found_a"
-              else
-                                                LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBMBEDCRYPTO_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCMBEDCRYPTO; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCMBEDCRYPTO="${INCMBEDCRYPTO}${INCMBEDCRYPTO:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBMBEDCRYPTO; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBMBEDCRYPTO; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$dep"
-                    LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }-l$name"
-            LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBMBEDCRYPTO="${LIBMBEDCRYPTO}${LIBMBEDCRYPTO:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBMBEDCRYPTO="${LTLIBMBEDCRYPTO}${LTLIBMBEDCRYPTO:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCMBEDCRYPTO; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libmbedcrypto" >&5
-printf %s "checking for libmbedcrypto... " >&6; }
-if test ${ac_cv_libmbedcrypto+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBMBEDCRYPTO"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <mbedtls/version.h>
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libmbedcrypto=yes
-else $as_nop
-  ac_cv_libmbedcrypto=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libmbedcrypto" >&5
-printf "%s\n" "$ac_cv_libmbedcrypto" >&6; }
-  if test "$ac_cv_libmbedcrypto" = yes; then
-    HAVE_LIBMBEDCRYPTO=yes
-
-printf "%s\n" "#define HAVE_LIBMBEDCRYPTO 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libmbedcrypto" >&5
-printf %s "checking how to link with libmbedcrypto... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBMBEDCRYPTO" >&5
-printf "%s\n" "$LIBMBEDCRYPTO" >&6; }
-  else
-    HAVE_LIBMBEDCRYPTO=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBMBEDCRYPTO=
-    LTLIBMBEDCRYPTO=
-    LIBMBEDCRYPTO_PREFIX=
-  fi
-
-
-
-
-
-
-
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libmbedcrypto" = "yes"; then :
-
-
-printf "%s\n" "#define LIBSSH2_MBEDTLS 1" >>confdefs.h
-
-    LIBS="$LIBS -lmbedcrypto"
-    found_crypto="mbedtls"
-    support_clear_memory=yes
-
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-
-
-  test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No mbedtls crypto library found!
-"
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5
-printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; }
-if test ${ac_cv_c_undeclared_builtin_options+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_save_CFLAGS=$CFLAGS
-   ac_cv_c_undeclared_builtin_options='cannot detect'
-   for ac_arg in '' -fno-builtin; do
-     CFLAGS="$ac_save_CFLAGS $ac_arg"
-     # This test program should *not* compile successfully.
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-(void) strchr;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-else $as_nop
-  # This test program should compile successfully.
-        # No library function is consistently available on
-        # freestanding implementations, so test against a dummy
-        # declaration.  Include always-available headers on the
-        # off chance that they somehow elicit warnings.
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <float.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-extern void ac_decl (int, char *);
-
-int
-main (void)
-{
-(void) ac_decl (0, (char *) 0);
-  (void) ac_decl;
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  if test x"$ac_arg" = x
-then :
-  ac_cv_c_undeclared_builtin_options='none needed'
-else $as_nop
-  ac_cv_c_undeclared_builtin_options=$ac_arg
-fi
-          break
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    done
-    CFLAGS=$ac_save_CFLAGS
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
-printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; }
-  case $ac_cv_c_undeclared_builtin_options in #(
-  'cannot detect') :
-    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "cannot make $CC report undeclared builtins
-See \`config.log' for more details" "$LINENO" 5; } ;; #(
-  'none needed') :
-    ac_c_undeclared_builtin_options='' ;; #(
-  *) :
-    ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;;
-esac
-
-
-if test "$use_crypto" = "auto" && test "$found_crypto" = "none" || test "$use_crypto" = "wincng"; then
-
-  # Look for Windows Cryptography API: Next Generation
-
-  ac_fn_c_check_header_compile "$LINENO" "ntdef.h" "ac_cv_header_ntdef_h" "#include <windows.h>
-"
-if test "x$ac_cv_header_ntdef_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_NTDEF_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "ntstatus.h" "ac_cv_header_ntstatus_h" "#include <windows.h>
-"
-if test "x$ac_cv_header_ntstatus_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_NTSTATUS_H 1" >>confdefs.h
-
-fi
-
-  ac_fn_check_decl "$LINENO" "SecureZeroMemory" "ac_cv_have_decl_SecureZeroMemory" "#include <windows.h>
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
-if test "x$ac_cv_have_decl_SecureZeroMemory" = xyes
-then :
-  ac_have_decl=1
-else $as_nop
-  ac_have_decl=0
-fi
-printf "%s\n" "#define HAVE_DECL_SECUREZEROMEMORY $ac_have_decl" >>confdefs.h
-
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libcrypt32_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libcrypt32_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libcrypt32_prefix}/lib"
-  fi
-
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libcrypt32-prefix was given.
-if test ${with_libcrypt32_prefix+y}
-then :
-  withval=$with_libcrypt32_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBCRYPT32=
-  LTLIBCRYPT32=
-  INCCRYPT32=
-  LIBCRYPT32_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='crypt32 '
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBCRYPT32; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBCRYPT32; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$found_a"
-              else
-                                                LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBCRYPT32_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCCRYPT32; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCCRYPT32="${INCCRYPT32}${INCCRYPT32:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBCRYPT32; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBCRYPT32; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$dep"
-                    LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }-l$name"
-            LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBCRYPT32="${LIBCRYPT32}${LIBCRYPT32:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBCRYPT32="${LTLIBCRYPT32}${LTLIBCRYPT32:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCCRYPT32; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libcrypt32" >&5
-printf %s "checking for libcrypt32... " >&6; }
-if test ${ac_cv_libcrypt32+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBCRYPT32"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-    #include <windows.h>
-    #include <wincrypt.h>
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libcrypt32=yes
-else $as_nop
-  ac_cv_libcrypt32=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libcrypt32" >&5
-printf "%s\n" "$ac_cv_libcrypt32" >&6; }
-  if test "$ac_cv_libcrypt32" = yes; then
-    HAVE_LIBCRYPT32=yes
-
-printf "%s\n" "#define HAVE_LIBCRYPT32 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libcrypt32" >&5
-printf %s "checking how to link with libcrypt32... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBCRYPT32" >&5
-printf "%s\n" "$LIBCRYPT32" >&6; }
-  else
-    HAVE_LIBCRYPT32=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBCRYPT32=
-    LTLIBCRYPT32=
-    LIBCRYPT32_PREFIX=
-  fi
-
-
-
-
-
-
-
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libcrypt32" = "yes"; then :
-
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-
-
-  libssh2_save_CPPFLAGS="$CPPFLAGS"
-  libssh2_save_LDFLAGS="$LDFLAGS"
-
-  if test "${with_libbcrypt_prefix+set}" = set; then
-    CPPFLAGS="$CPPFLAGS${CPPFLAGS:+ }-I${with_libbcrypt_prefix}/include"
-    LDFLAGS="$LDFLAGS${LDFLAGS:+ }-L${with_libbcrypt_prefix}/lib"
-  fi
-
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libbcrypt-prefix was given.
-if test ${with_libbcrypt_prefix+y}
-then :
-  withval=$with_libbcrypt_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBBCRYPT=
-  LTLIBBCRYPT=
-  INCBCRYPT=
-  LIBBCRYPT_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='bcrypt '
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBBCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBBCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$found_a"
-              else
-                                                LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBBCRYPT_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCBCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCBCRYPT="${INCBCRYPT}${INCBCRYPT:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBBCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBBCRYPT; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$dep"
-                    LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }-l$name"
-            LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBBCRYPT="${LIBBCRYPT}${LIBBCRYPT:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBBCRYPT="${LTLIBBCRYPT}${LTLIBBCRYPT:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCBCRYPT; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libbcrypt" >&5
-printf %s "checking for libbcrypt... " >&6; }
-if test ${ac_cv_libbcrypt+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBBCRYPT"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-    #include <windows.h>
-    #include <bcrypt.h>
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libbcrypt=yes
-else $as_nop
-  ac_cv_libbcrypt=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libbcrypt" >&5
-printf "%s\n" "$ac_cv_libbcrypt" >&6; }
-  if test "$ac_cv_libbcrypt" = yes; then
-    HAVE_LIBBCRYPT=yes
-
-printf "%s\n" "#define HAVE_LIBBCRYPT 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libbcrypt" >&5
-printf %s "checking how to link with libbcrypt... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBBCRYPT" >&5
-printf "%s\n" "$LIBBCRYPT" >&6; }
-  else
-    HAVE_LIBBCRYPT=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBBCRYPT=
-    LTLIBBCRYPT=
-    LIBBCRYPT_PREFIX=
-  fi
-
-
-
-
-
-
-
-
-  LDFLAGS="$libssh2_save_LDFLAGS"
-
-  if test "$ac_cv_libbcrypt" = "yes"; then :
-
-
-printf "%s\n" "#define LIBSSH2_WINCNG 1" >>confdefs.h
-
-    found_crypto="wincng"
-    found_crypto_str="Windows Cryptography API: Next Generation"
-    support_clear_memory="$ac_cv_have_decl_SecureZeroMemory"
-
-  else
-    CPPFLAGS="$libssh2_save_CPPFLAGS"
-  fi
-
-
-  test "$found_crypto" = "none" &&
-    crypto_errors="${crypto_errors}No wincng crypto library found!
-"
-fi
-
-    ;;
-  yes|"")
-    crypto_errors="No crypto backend specified!"
-    ;;
-  *)
-    crypto_errors="Unknown crypto backend '${use_crypto}' specified!"
-    ;;
-esac
-
-if test "$found_crypto" = "none"; then
-  crypto_errors="${crypto_errors}
-Specify --with-crypto=\$backend and/or the neccessary library search prefix.
-
-Known crypto backends: auto, openssl, libgcrypt, mbedtls, wincng"
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: ${crypto_errors}" >&5
-printf "%s\n" "$as_me: ERROR: ${crypto_errors}" >&6;}
-else
-  test "$found_crypto_str" = "" && found_crypto_str="$found_crypto"
-fi
-
- if test "$found_crypto" = "openssl"; then
-  OPENSSL_TRUE=
-  OPENSSL_FALSE='#'
-else
-  OPENSSL_TRUE='#'
-  OPENSSL_FALSE=
-fi
-
- if test "$found_crypto" = "libgcrypt"; then
-  LIBGCRYPT_TRUE=
-  LIBGCRYPT_FALSE='#'
-else
-  LIBGCRYPT_TRUE='#'
-  LIBGCRYPT_FALSE=
-fi
-
- if test "$found_crypto" = "mbedtls"; then
-  MBEDTLS_TRUE=
-  MBEDTLS_FALSE='#'
-else
-  MBEDTLS_TRUE='#'
-  MBEDTLS_FALSE=
-fi
-
- if test "$found_crypto" = "wincng"; then
-  WINCNG_TRUE=
-  WINCNG_FALSE='#'
-else
-  WINCNG_TRUE='#'
-  WINCNG_FALSE=
-fi
-
-
-
-# libz
-
-
-# Check whether --with-libz was given.
-if test ${with_libz+y}
-then :
-  withval=$with_libz; use_libz=$withval
-else $as_nop
-  use_libz=auto
-fi
-
-
-found_libz=no
-libz_errors=""
-
-if test "$use_libz" != no; then
-
-
-
-
-
-
-
-
-
-
-    use_additional=yes
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-
-# Check whether --with-libz-prefix was given.
-if test ${with_libz_prefix+y}
-then :
-  withval=$with_libz_prefix;
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-
-fi
-
-      LIBZ=
-  LTLIBZ=
-  INCZ=
-  LIBZ_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='z '
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-                        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIBZ="${LIBZ}${LIBZ:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIBZ="${LTLIBZ}${LTLIBZ:+ }$value"
-          else
-                                    :
-          fi
-        else
-                              found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-                                    if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-                        if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIBZ; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                                    if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                                    if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-                        LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-                                                        if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                                LIBZ="${LIBZ}${LIBZ:+ }$found_so"
-              else
-                                                                                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                                if test "$acl_hardcode_direct" = yes; then
-                                                      LIBZ="${LIBZ}${LIBZ:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                                                            LIBZ="${LIBZ}${LIBZ:+ }$found_so"
-                                                            haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                                                                                haveit=
-                    for x in $LDFLAGS $LIBZ; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIBZ="${LIBZ}${LIBZ:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                                                                                        LIBZ="${LIBZ}${LIBZ:+ }$found_so"
-                    else
-                                                                                                                                                                                LIBZ="${LIBZ}${LIBZ:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                                LIBZ="${LIBZ}${LIBZ:+ }$found_a"
-              else
-                                                LIBZ="${LIBZ}${LIBZ:+ }-L$found_dir -l$name"
-              fi
-            fi
-                        additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIBZ_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-                                                                                                                if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INCZ; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                                            INCZ="${INCZ}${INCZ:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-                        if test -n "$found_la"; then
-                                                        save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-                            for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                                                                                                                                                                if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIBZ; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LIBZ="${LIBZ}${LIBZ:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIBZ; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                                                        LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                                                                  haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                                                                  haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                                        names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                                                                                names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                                        LIBZ="${LIBZ}${LIBZ:+ }$dep"
-                    LTLIBZ="${LTLIBZ}${LTLIBZ:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-                                                            LIBZ="${LIBZ}${LIBZ:+ }-l$name"
-            LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-                        alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-            acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIBZ="${LIBZ}${LIBZ:+ }$flag"
-    else
-            for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIBZ="${LIBZ}${LIBZ:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-            for found_dir in $ltrpathdirs; do
-      LTLIBZ="${LTLIBZ}${LTLIBZ:+ }-R$found_dir"
-    done
-  fi
-
-
-        ac_save_CPPFLAGS="$CPPFLAGS"
-
-  for element in $INCZ; do
-    haveit=
-    for x in $CPPFLAGS; do
-
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  eval x=\"$x\"
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
-    fi
-  done
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libz" >&5
-printf %s "checking for libz... " >&6; }
-if test ${ac_cv_libz+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIBZ"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <zlib.h>
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_libz=yes
-else $as_nop
-  ac_cv_libz=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-    LIBS="$ac_save_LIBS"
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_libz" >&5
-printf "%s\n" "$ac_cv_libz" >&6; }
-  if test "$ac_cv_libz" = yes; then
-    HAVE_LIBZ=yes
-
-printf "%s\n" "#define HAVE_LIBZ 1" >>confdefs.h
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libz" >&5
-printf %s "checking how to link with libz... " >&6; }
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBZ" >&5
-printf "%s\n" "$LIBZ" >&6; }
-  else
-    HAVE_LIBZ=no
-            CPPFLAGS="$ac_save_CPPFLAGS"
-    LIBZ=
-    LTLIBZ=
-    LIBZ_PREFIX=
-  fi
-
-
-
-
-
-
-
-  if test "$ac_cv_libz" != yes; then
-    if test "$use_libz" = auto; then
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot find libz, disabling compression" >&5
-printf "%s\n" "$as_me: Cannot find libz, disabling compression" >&6;}
-      found_libz="disabled; no libz found"
-    else
-      libz_errors="No libz found!
-Try --with-libz-prefix=PATH if you know that you have it."
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: $libz_errors" >&5
-printf "%s\n" "$as_me: ERROR: $libz_errors" >&6;}
-    fi
-  else
-
-printf "%s\n" "#define LIBSSH2_HAVE_ZLIB 1" >>confdefs.h
-
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }zlib"
-    found_libz="yes"
-  fi
-fi
-
-
-
-#
-# Optional Settings
-#
-# Check whether --enable-crypt-none was given.
-if test ${enable_crypt_none+y}
-then :
-  enableval=$enable_crypt_none;
-printf "%s\n" "#define LIBSSH2_CRYPT_NONE 1" >>confdefs.h
-
-fi
-
-
-# Check whether --enable-mac-none was given.
-if test ${enable_mac_none+y}
-then :
-  enableval=$enable_mac_none;
-printf "%s\n" "#define LIBSSH2_MAC_NONE 1" >>confdefs.h
-
-fi
-
-
-# Check whether --enable-gex-new was given.
-if test ${enable_gex_new+y}
-then :
-  enableval=$enable_gex_new; GEX_NEW=$enableval
-fi
-
-if test "$GEX_NEW" != "no"; then
-
-printf "%s\n" "#define LIBSSH2_DH_GEX_NEW 1" >>confdefs.h
-
-fi
-
-# Check whether --enable-clear-memory was given.
-if test ${enable_clear_memory+y}
-then :
-  enableval=$enable_clear_memory; CLEAR_MEMORY=$enableval
-fi
-
-if test "$CLEAR_MEMORY" != "no"; then
-  if test "$support_clear_memory" = "yes"; then
-
-printf "%s\n" "#define LIBSSH2_CLEAR_MEMORY 1" >>confdefs.h
-
-    enable_clear_memory=yes
-  else
-    if test "$CLEAR_MEMORY" = "yes"; then
-      as_fn_error $? "secure clearing/zeroing of memory is not supported by the selected crypto backend" "$LINENO" 5
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&5
-printf "%s\n" "$as_me: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&2;}
-    fi
-    enable_clear_memory=unsupported
-  fi
-else
-  if test "$support_clear_memory" = "yes"; then
-    enable_clear_memory=no
-  else
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&5
-printf "%s\n" "$as_me: WARNING: secure clearing/zeroing of memory is not supported by the selected crypto backend" >&2;}
-    enable_clear_memory=unsupported
-  fi
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable pedantic and debug compiler options" >&5
-printf %s "checking whether to enable pedantic and debug compiler options... " >&6; }
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-printf %s "checking how to run the C preprocessor... " >&6; }
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  if test ${ac_cv_prog_CPP+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-      # Double quotes because $CC needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
-    do
-      ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
-  break
-fi
-
-    done
-    ac_cv_prog_CPP=$CPP
-
-fi
-  CPP=$ac_cv_prog_CPP
-else
-  ac_cv_prog_CPP=$CPP
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-printf "%s\n" "$CPP" >&6; }
-ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <limits.h>
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-
-else $as_nop
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"
-then :
-  # Broken: success on invalid input.
-continue
-else $as_nop
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok
-then :
-
-else $as_nop
-  { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-
-# Check whether --enable-debug was given.
-if test ${enable_debug+y}
-then :
-  enableval=$enable_debug;  case "$enable_debug" in
-  no)
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-       CPPFLAGS="$CPPFLAGS -DNDEBUG"
-       ;;
-  *)   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-    enable_debug=yes
-    CPPFLAGS="$CPPFLAGS -DLIBSSH2DEBUG"
-    CFLAGS="$CFLAGS -g"
-
-
-    if test "z$ICC" = "z"; then
-
-    ICC="no"
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for icc in use" >&5
-printf %s "checking for icc in use... " >&6; }
-    if test "$GCC" = "yes"; then
-              cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-__INTEL_COMPILER
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "^__INTEL_COMPILER" >/dev/null 2>&1
-then :
-                    ICC="no"
-else $as_nop
-           ICC="yes"
-         { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-
-
-fi
-rm -rf conftest*
-
-    fi
-    if test "$ICC" = "no"; then
-        # this is not ICC
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-    fi
-
-    fi
-
-    if test "$GCC" = "yes"; then
-
-              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5
-printf %s "checking gcc version... " >&6; }
-       gccver=`$CC -dumpversion`
-       num1=`echo $gccver | cut -d . -f1`
-       num2=`echo $gccver | cut -d . -f2`
-       gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gccver" >&5
-printf "%s\n" "$gccver" >&6; }
-
-       if test "$ICC" = "yes"; then
-
-
-         WARN="-wd279,269,981,1418,1419"
-
-         if test "$gccnum" -gt "600"; then
-                        WARN="-Wall $WARN"
-         fi
-       else                   WARN="-W -Wall -Wwrite-strings -pedantic -Wpointer-arith -Wnested-externs -Winline -Wmissing-prototypes"
-
-
-         if test "$gccnum" -ge "207"; then
-                      WARN="$WARN -Wmissing-declarations"
-         fi
-
-         if test "$gccnum" -gt "295"; then
-                                            WARN="$WARN -Wundef -Wno-long-long -Wsign-compare"
-         fi
-
-         if test "$gccnum" -ge "296"; then
-                      WARN="$WARN -Wfloat-equal"
-         fi
-
-         if test "$gccnum" -gt "296"; then
-                      WARN="$WARN -Wno-format-nonliteral"
-         fi
-
-
-         if test "$gccnum" -ge "303"; then
-                      WARN="$WARN -Wendif-labels -Wstrict-prototypes"
-         fi
-
-         if test "$gccnum" -ge "304"; then
-           # try these on gcc 3.4
-           WARN="$WARN -Wdeclaration-after-statement"
-         fi
-
-         for flag in $CPPFLAGS; do
-           case "$flag" in
-            -I*)
-                                                        add=`echo $flag | sed 's/^-I/-isystem /g'`
-              WARN="$WARN $add"
-              ;;
-           esac
-         done
-
-       fi
-       CFLAGS="$CFLAGS $WARN"
-
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added this set of compiler options: $WARN" >&5
-printf "%s\n" "$as_me: Added this set of compiler options: $WARN" >&6;}
-
-    else
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Added no extra compiler options" >&5
-printf "%s\n" "$as_me: Added no extra compiler options" >&6;}
-
-    fi
-        NEWFLAGS=""
-    for flag in $CFLAGS; do
-      case "$flag" in
-      -O*)
-                ;;
-      *)
-        NEWFLAGS="$NEWFLAGS $flag"
-        ;;
-      esac
-    done
-    CFLAGS=$NEWFLAGS
-
-
-       ;;
-  esac
-
-else $as_nop
-  enable_debug=no
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-
-fi
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable hidden symbols in the library" >&5
-printf %s "checking whether to enable hidden symbols in the library... " >&6; }
-# Check whether --enable-hidden-symbols was given.
-if test ${enable_hidden_symbols+y}
-then :
-  enableval=$enable_hidden_symbols;  case "$enableval" in
-  no)
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-       ;;
-  *)
-       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC supports it" >&5
-printf %s "checking whether $CC supports it... " >&6; }
-       if test "$GCC" = yes ; then
-         if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
-           { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-
-printf "%s\n" "#define LIBSSH2_API __attribute__ ((visibility (\"default\")))" >>confdefs.h
-
-           CFLAGS="$CFLAGS -fvisibility=hidden"
-         else
-            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-          fi
-
-       else
-                  if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
-           { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-
-printf "%s\n" "#define LIBSSH2_API __global" >>confdefs.h
-
-           CFLAGS="$CFLAGS -xldscope=hidden"
-         else
-           { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-         fi
-       fi
-       ;;
-  esac
-else $as_nop
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-
-fi
-
-
-# Build example applications?
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build example applications" >&5
-printf %s "checking whether to build example applications... " >&6; }
-# Check whether --enable-examples-build was given.
-if test ${enable_examples_build+y}
-then :
-  enableval=$enable_examples_build; case "$enableval" in
-  no | false)
-    build_examples='no'
-    ;;
-  *)
-    build_examples='yes'
-    ;;
-esac
-else $as_nop
-  build_examples='yes'
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $build_examples" >&5
-printf "%s\n" "$build_examples" >&6; }
- if test "x$build_examples" != "xno"; then
-  BUILD_EXAMPLES_TRUE=
-  BUILD_EXAMPLES_FALSE='#'
-else
-  BUILD_EXAMPLES_TRUE='#'
-  BUILD_EXAMPLES_FALSE=
-fi
-
-
-
-# Build OSS fuzzing targets?
-# Check whether --enable-ossfuzzers was given.
-if test ${enable_ossfuzzers+y}
-then :
-  enableval=$enable_ossfuzzers; have_ossfuzzers=yes
-else $as_nop
-  have_ossfuzzers=no
-fi
-
- if test "x$have_ossfuzzers" = "xyes"; then
-  USE_OSSFUZZERS_TRUE=
-  USE_OSSFUZZERS_FALSE='#'
-else
-  USE_OSSFUZZERS_TRUE='#'
-  USE_OSSFUZZERS_FALSE=
-fi
-
-
-
-# Set the correct flags for the given fuzzing engine.
-
- if test "x$LIB_FUZZING_ENGINE" = "x-fsanitize=fuzzer"; then
-  USE_OSSFUZZ_FLAG_TRUE=
-  USE_OSSFUZZ_FLAG_FALSE='#'
-else
-  USE_OSSFUZZ_FLAG_TRUE='#'
-  USE_OSSFUZZ_FLAG_FALSE=
-fi
-
- if test -f "$LIB_FUZZING_ENGINE"; then
-  USE_OSSFUZZ_STATIC_TRUE=
-  USE_OSSFUZZ_STATIC_FALSE='#'
-else
-  USE_OSSFUZZ_STATIC_TRUE='#'
-  USE_OSSFUZZ_STATIC_FALSE=
-fi
-
-
-
-# Checks for header files.
-# AC_HEADER_STDC
-ac_fn_c_check_header_compile "$LINENO" "errno.h" "ac_cv_header_errno_h" "$ac_includes_default"
-if test "x$ac_cv_header_errno_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_ERRNO_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "fcntl.h" "ac_cv_header_fcntl_h" "$ac_includes_default"
-if test "x$ac_cv_header_fcntl_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_FCNTL_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
-if test "x$ac_cv_header_stdio_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_STDIO_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
-if test "x$ac_cv_header_stdlib_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_STDLIB_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$ac_includes_default"
-if test "x$ac_cv_header_unistd_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_UNISTD_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "sys/uio.h" "ac_cv_header_sys_uio_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_uio_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_UIO_H 1" >>confdefs.h
-
-fi
-
-ac_fn_c_check_header_compile "$LINENO" "sys/select.h" "ac_cv_header_sys_select_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_select_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_SELECT_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_socket_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "sys/ioctl.h" "ac_cv_header_sys_ioctl_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_ioctl_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_IOCTL_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_time_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h
-
-fi
-
-ac_fn_c_check_header_compile "$LINENO" "arpa/inet.h" "ac_cv_header_arpa_inet_h" "$ac_includes_default"
-if test "x$ac_cv_header_arpa_inet_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_ARPA_INET_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "netinet/in.h" "ac_cv_header_netinet_in_h" "$ac_includes_default"
-if test "x$ac_cv_header_netinet_in_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_NETINET_IN_H 1" >>confdefs.h
-
-fi
-
-       for ac_header in sys/un.h
-do :
-  ac_fn_c_check_header_compile "$LINENO" "sys/un.h" "ac_cv_header_sys_un_h" "$ac_includes_default"
-if test "x$ac_cv_header_sys_un_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_SYS_UN_H 1" >>confdefs.h
- have_sys_un_h=yes
-else $as_nop
-  have_sys_un_h=no
-fi
-
-done
- if test "x$have_sys_un_h" = xyes; then
-  HAVE_SYS_UN_H_TRUE=
-  HAVE_SYS_UN_H_FALSE='#'
-else
-  HAVE_SYS_UN_H_TRUE='#'
-  HAVE_SYS_UN_H_FALSE=
-fi
-
-
-case $host in
-  *-*-cygwin* | *-*-cegcc*)
-    # These are POSIX-like systems using BSD-like sockets API.
-    ;;
-  *)
-    ac_fn_c_check_header_compile "$LINENO" "windows.h" "ac_cv_header_windows_h" "$ac_includes_default"
-if test "x$ac_cv_header_windows_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WINDOWS_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default"
-if test "x$ac_cv_header_winsock2_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WINSOCK2_H 1" >>confdefs.h
-
-fi
-ac_fn_c_check_header_compile "$LINENO" "ws2tcpip.h" "ac_cv_header_ws2tcpip_h" "$ac_includes_default"
-if test "x$ac_cv_header_ws2tcpip_h" = xyes
-then :
-  printf "%s\n" "#define HAVE_WS2TCPIP_H 1" >>confdefs.h
-
-fi
-
-    ;;
-esac
-
-case $host in
-  *darwin*|*interix*)
-                                        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: poll use is disabled on this platform" >&5
-printf "%s\n" "$as_me: poll use is disabled on this platform" >&6;}
-    ;;
-  *)
-    ac_fn_c_check_func "$LINENO" "poll" "ac_cv_func_poll"
-if test "x$ac_cv_func_poll" = xyes
-then :
-  printf "%s\n" "#define HAVE_POLL 1" >>confdefs.h
-
-fi
-
-    ;;
-esac
-
-ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday"
-if test "x$ac_cv_func_gettimeofday" = xyes
-then :
-  printf "%s\n" "#define HAVE_GETTIMEOFDAY 1" >>confdefs.h
-
-fi
-ac_fn_c_check_func "$LINENO" "select" "ac_cv_func_select"
-if test "x$ac_cv_func_select" = xyes
-then :
-  printf "%s\n" "#define HAVE_SELECT 1" >>confdefs.h
-
-fi
-ac_fn_c_check_func "$LINENO" "strtoll" "ac_cv_func_strtoll"
-if test "x$ac_cv_func_strtoll" = xyes
-then :
-  printf "%s\n" "#define HAVE_STRTOLL 1" >>confdefs.h
-
-fi
-ac_fn_c_check_func "$LINENO" "memset_s" "ac_cv_func_memset_s"
-if test "x$ac_cv_func_memset_s" = xyes
-then :
-  printf "%s\n" "#define HAVE_MEMSET_S 1" >>confdefs.h
-
-fi
-
-
-if test "$ac_cv_func_select" != "yes"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for select in ws2_32" >&5
-printf %s "checking for select in ws2_32... " >&6; }
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-#ifdef HAVE_WINSOCK2_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <winsock2.h>
-#endif
-
-int
-main (void)
-{
-
-      select(0,(fd_set *)NULL,(fd_set *)NULL,(fd_set *)NULL,(struct timeval *)NULL);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
-      HAVE_SELECT="1"
-
-printf "%s\n" "#define HAVE_SELECT 1" >>confdefs.h
-
-
-else $as_nop
-
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-fi
-
-ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
-if test "x$ac_cv_type_size_t" = xyes
-then :
-
-else $as_nop
-
-printf "%s\n" "#define size_t unsigned int" >>confdefs.h
-
-fi
-
-# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
-# for constant arguments.  Useless!
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5
-printf %s "checking for working alloca.h... " >&6; }
-if test ${ac_cv_working_alloca_h+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <alloca.h>
-int
-main (void)
-{
-char *p = (char *) alloca (2 * sizeof (int));
-			  if (p) return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_working_alloca_h=yes
-else $as_nop
-  ac_cv_working_alloca_h=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5
-printf "%s\n" "$ac_cv_working_alloca_h" >&6; }
-if test $ac_cv_working_alloca_h = yes; then
-
-printf "%s\n" "#define HAVE_ALLOCA_H 1" >>confdefs.h
-
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for alloca" >&5
-printf %s "checking for alloca... " >&6; }
-if test ${ac_cv_func_alloca_works+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test $ac_cv_working_alloca_h = yes; then
-  ac_cv_func_alloca_works=yes
-else
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdlib.h>
-#include <stddef.h>
-#ifndef alloca
-# ifdef __GNUC__
-#  define alloca __builtin_alloca
-# elif defined _MSC_VER
-#  include <malloc.h>
-#  define alloca _alloca
-# else
-#  ifdef  __cplusplus
-extern "C"
-#  endif
-void *alloca (size_t);
-# endif
-#endif
-
-int
-main (void)
-{
-char *p = (char *) alloca (1);
-				    if (p) return 0;
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-  ac_cv_func_alloca_works=yes
-else $as_nop
-  ac_cv_func_alloca_works=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5
-printf "%s\n" "$ac_cv_func_alloca_works" >&6; }
-fi
-
-if test $ac_cv_func_alloca_works = yes; then
-
-printf "%s\n" "#define HAVE_ALLOCA 1" >>confdefs.h
-
-else
-  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
-# that cause trouble.  Some versions do not even contain alloca or
-# contain a buggy version.  If you still want to use their alloca,
-# use ar to extract alloca.o from them instead of compiling alloca.c.
-
-ALLOCA=\${LIBOBJDIR}alloca.$ac_objext
-
-printf "%s\n" "#define C_ALLOCA 1" >>confdefs.h
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking stack direction for C alloca" >&5
-printf %s "checking stack direction for C alloca... " >&6; }
-if test ${ac_cv_c_stack_direction+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  if test "$cross_compiling" = yes
-then :
-  ac_cv_c_stack_direction=0
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$ac_includes_default
-int
-find_stack_direction (int *addr, int depth)
-{
-  int dir, dummy = 0;
-  if (! addr)
-    addr = &dummy;
-  *addr = addr < &dummy ? 1 : addr == &dummy ? 0 : -1;
-  dir = depth ? find_stack_direction (addr, depth - 1) : 0;
-  return dir + dummy;
-}
-
-int
-main (int argc, char **argv)
-{
-  return find_stack_direction (0, argc + !argv + 20) < 0;
-}
-_ACEOF
-if ac_fn_c_try_run "$LINENO"
-then :
-  ac_cv_c_stack_direction=1
-else $as_nop
-  ac_cv_c_stack_direction=-1
-fi
-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
-  conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5
-printf "%s\n" "$ac_cv_c_stack_direction" >&6; }
-printf "%s\n" "#define STACK_DIRECTION $ac_cv_c_stack_direction" >>confdefs.h
-
-
-fi
-
-
-# Checks for typedefs, structures, and compiler characteristics.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
-printf %s "checking for an ANSI C-conforming const... " >&6; }
-if test ${ac_cv_c_const+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-int
-main (void)
-{
-
-#ifndef __cplusplus
-  /* Ultrix mips cc rejects this sort of thing.  */
-  typedef int charset[2];
-  const charset cs = { 0, 0 };
-  /* SunOS 4.1.1 cc rejects this.  */
-  char const *const *pcpcc;
-  char **ppc;
-  /* NEC SVR4.0.2 mips cc rejects this.  */
-  struct point {int x, y;};
-  static struct point const zero = {0,0};
-  /* IBM XL C 1.02.0.0 rejects this.
-     It does not let you subtract one const X* pointer from another in
-     an arm of an if-expression whose if-part is not a constant
-     expression */
-  const char *g = "string";
-  pcpcc = &g + (g ? g-g : 0);
-  /* HPUX 7.0 cc rejects these. */
-  ++pcpcc;
-  ppc = (char**) pcpcc;
-  pcpcc = (char const *const *) ppc;
-  { /* SCO 3.2v4 cc rejects this sort of thing.  */
-    char tx;
-    char *t = &tx;
-    char const *s = 0 ? (char *) 0 : (char const *) 0;
-
-    *t++ = 0;
-    if (s) return 0;
-  }
-  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
-    int x[] = {25, 17};
-    const int *foo = &x[0];
-    ++foo;
-  }
-  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
-    typedef const int *iptr;
-    iptr p = 0;
-    ++p;
-  }
-  { /* IBM XL C 1.02.0.0 rejects this sort of thing, saying
-       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
-    struct s { int j; const int *ap[3]; } bx;
-    struct s *b = &bx; b->j = 5;
-  }
-  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
-    const int foo = 10;
-    if (!foo) return 0;
-  }
-  return !cs[0] && !zero.x;
-#endif
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_c_const=yes
-else $as_nop
-  ac_cv_c_const=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
-printf "%s\n" "$ac_cv_c_const" >&6; }
-if test $ac_cv_c_const = no; then
-
-printf "%s\n" "#define const /**/" >>confdefs.h
-
-fi
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
-printf %s "checking for inline... " >&6; }
-if test ${ac_cv_c_inline+y}
-then :
-  printf %s "(cached) " >&6
-else $as_nop
-  ac_cv_c_inline=no
-for ac_kw in inline __inline__ __inline; do
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifndef __cplusplus
-typedef int foo_t;
-static $ac_kw foo_t static_foo (void) {return 0; }
-$ac_kw foo_t foo (void) {return 0; }
-#endif
-
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  ac_cv_c_inline=$ac_kw
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  test "$ac_cv_c_inline" != no && break
-done
-
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
-printf "%s\n" "$ac_cv_c_inline" >&6; }
-
-case $ac_cv_c_inline in
-  inline | yes) ;;
-  *)
-    case $ac_cv_c_inline in
-      no) ac_val=;;
-      *) ac_val=$ac_cv_c_inline;;
-    esac
-    cat >>confdefs.h <<_ACEOF
-#ifndef __cplusplus
-#define inline $ac_val
-#endif
-_ACEOF
-    ;;
-esac
-
-
-
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking non-blocking sockets style" >&5
-printf %s "checking non-blocking sockets style... " >&6; }
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for O_NONBLOCK test */
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-int
-main (void)
-{
-
-/* try to compile O_NONBLOCK */
-
-#if defined(sun) || defined(__sun__) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-# if defined(__SVR4) || defined(__srv4__)
-#  define PLATFORM_SOLARIS
-# else
-#  define PLATFORM_SUNOS4
-# endif
-#endif
-#if (defined(_AIX) || defined(__xlC__)) && !defined(_AIX41)
-# define PLATFORM_AIX_V3
-#endif
-
-#if defined(PLATFORM_SUNOS4) || defined(PLATFORM_AIX_V3) || defined(__BEOS__)
-#error "O_NONBLOCK does not work on this platform"
-#endif
-  int socket;
-  int flags = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-nonblock="O_NONBLOCK"
-
-printf "%s\n" "#define HAVE_O_NONBLOCK 1" >>confdefs.h
-
-
-else $as_nop
-
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for FIONBIO test */
-#include <unistd.h>
-#include <stropts.h>
-
-int
-main (void)
-{
-
-/* FIONBIO source test (old-style unix) */
- int socket;
- int flags = ioctl(socket, FIONBIO, &flags);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-nonblock="FIONBIO"
-
-printf "%s\n" "#define HAVE_FIONBIO 1" >>confdefs.h
-
-
-else $as_nop
-
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for ioctlsocket test (Windows) */
-#undef inline
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#else
-#ifdef HAVE_WINSOCK_H
-#include <winsock.h>
-#endif
-#endif
-#endif
-
-int
-main (void)
-{
-
-/* ioctlsocket source code */
- SOCKET sd;
- unsigned long flags = 0;
- sd = socket(0, 0, 0);
- ioctlsocket(sd, FIONBIO, &flags);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-nonblock="ioctlsocket"
-
-printf "%s\n" "#define HAVE_IOCTLSOCKET 1" >>confdefs.h
-
-
-else $as_nop
-
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for IoctlSocket test (Amiga?) */
-#include <sys/ioctl.h>
-
-int
-main (void)
-{
-
-/* IoctlSocket source code */
- int socket;
- int flags = IoctlSocket(socket, FIONBIO, (long)1);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"
-then :
-
-nonblock="IoctlSocket"
-
-printf "%s\n" "#define HAVE_IOCTLSOCKET_CASE 1" >>confdefs.h
-
-
-else $as_nop
-
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-/* headers for SO_NONBLOCK test (BeOS) */
-#include <socket.h>
-
-int
-main (void)
-{
-
-/* SO_NONBLOCK source code */
- long b = 1;
- int socket;
- int flags = setsockopt(socket, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-
-nonblock="SO_NONBLOCK"
-
-printf "%s\n" "#define HAVE_SO_NONBLOCK 1" >>confdefs.h
-
-
-else $as_nop
-
-nonblock="nada"
-
-printf "%s\n" "#define HAVE_DISABLED_NONBLOCKING 1" >>confdefs.h
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam \
-    conftest$ac_exeext conftest.$ac_ext
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $nonblock" >&5
-printf "%s\n" "$nonblock" >&6; }
-
-  if test "$nonblock" = "nada"; then
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: non-block sockets disabled" >&5
-printf "%s\n" "$as_me: WARNING: non-block sockets disabled" >&2;}
-  fi
-
-
-missing_required_deps=0
-
-if test "${libz_errors}" != ""; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: ${libz_errors}" >&5
-printf "%s\n" "$as_me: ERROR: ${libz_errors}" >&6;}
-  missing_required_deps=1
-fi
-
-if test "$found_crypto" = "none"; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: ERROR: ${crypto_errors}" >&5
-printf "%s\n" "$as_me: ERROR: ${crypto_errors}" >&6;}
-  missing_required_deps=1
-fi
-
-if test $missing_required_deps = 1; then
-  as_fn_error $? "Required dependencies are missing!" "$LINENO" 5
-fi
-
-# Configure parameters
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable compiler warnings as errors" >&5
-printf %s "checking whether to enable compiler warnings as errors... " >&6; }
-  OPT_COMPILER_WERROR="default"
-  # Check whether --enable-werror was given.
-if test ${enable_werror+y}
-then :
-  enableval=$enable_werror; OPT_COMPILER_WERROR=$enableval
-fi
-
-  case "$OPT_COMPILER_WERROR" in
-    no)
-            want_werror="no"
-      ;;
-    default)
-            want_werror="no"
-      ;;
-    *)
-            want_werror="yes"
-      ;;
-  esac
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $want_werror" >&5
-printf "%s\n" "$want_werror" >&6; }
-
-  if test X"$want_werror" = Xyes; then
-    CFLAGS="$CFLAGS -Werror"
-  fi
-
-
-ac_config_files="$ac_config_files Makefile src/Makefile tests/Makefile tests/ossfuzz/Makefile example/Makefile docs/Makefile libssh2.pc"
-
-cat >confcache <<\_ACEOF
-# This file is a shell script that caches the results of configure
-# tests run on this system so they can be shared between configure
-# scripts and configure runs, see configure's option --config-cache.
-# It is not useful on other systems.  If it contains results you don't
-# want to keep, you may remove or edit it.
-#
-# config.status only pays attention to the cache file if you give it
-# the --recheck option to rerun configure.
-#
-# `ac_cv_env_foo' variables (set or unset) will be overridden when
-# loading this file, other *unset* `ac_cv_foo' will be assigned the
-# following values.
-
-_ACEOF
-
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
-  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
-    eval ac_val=\$$ac_var
-    case $ac_val in #(
-    *${as_nl}*)
-      case $ac_var in #(
-      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      esac
-      case $ac_var in #(
-      _ | IFS | as_nl) ;; #(
-      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
-      *) { eval $ac_var=; unset $ac_var;} ;;
-      esac ;;
-    esac
-  done
-
-  (set) 2>&1 |
-    case $as_nl`(ac_space=' '; set) 2>&1` in #(
-    *${as_nl}ac_space=\ *)
-      # `set' does not quote correctly, so add quotes: double-quote
-      # substitution turns \\\\ into \\, and sed turns \\ into \.
-      sed -n \
-	"s/'/'\\\\''/g;
-	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-      ;; #(
-    *)
-      # `set' quotes correctly as required by POSIX, so do not add quotes.
-      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-      ;;
-    esac |
-    sort
-) |
-  sed '
-     /^ac_cv_env_/b end
-     t clear
-     :clear
-     s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/
-     t end
-     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-     :end' >>confcache
-if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-  if test -w "$cache_file"; then
-    if test "x$cache_file" != "x/dev/null"; then
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
-      if test ! -f "$cache_file" || test -h "$cache_file"; then
-	cat confcache >"$cache_file"
-      else
-        case $cache_file in #(
-        */* | ?:*)
-	  mv -f confcache "$cache_file"$$ &&
-	  mv -f "$cache_file"$$ "$cache_file" ;; #(
-        *)
-	  mv -f confcache "$cache_file" ;;
-	esac
-      fi
-    fi
-  else
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
-  fi
-fi
-rm -f confcache
-
-test "x$prefix" = xNONE && prefix=$ac_default_prefix
-# Let make expand exec_prefix.
-test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
-
-DEFS=-DHAVE_CONFIG_H
-
-ac_libobjs=
-ac_ltlibobjs=
-U=
-for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-  # 1. Remove the extension, and $U if already installed.
-  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
-  ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
-  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-  #    will be set to the directory where LIBOBJS objects are built.
-  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
-done
-LIBOBJS=$ac_libobjs
-
-LTLIBOBJS=$ac_ltlibobjs
-
-
-if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
-  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
-printf %s "checking that generated files are newer than configure... " >&6; }
-   if test -n "$am_sleep_pid"; then
-     # Hide warnings about reused PIDs.
-     wait $am_sleep_pid 2>/dev/null
-   fi
-   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5
-printf "%s\n" "done" >&6; }
- if test -n "$EXEEXT"; then
-  am__EXEEXT_TRUE=
-  am__EXEEXT_FALSE='#'
-else
-  am__EXEEXT_TRUE='#'
-  am__EXEEXT_FALSE=
-fi
-
-if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
-  as_fn_error $? "conditional \"AMDEP\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
-  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
-  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
-  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${SSHD_TRUE}" && test -z "${SSHD_FALSE}"; then
-  as_fn_error $? "conditional \"SSHD\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-
-if test -z "${OPENSSL_TRUE}" && test -z "${OPENSSL_FALSE}"; then
-  as_fn_error $? "conditional \"OPENSSL\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${LIBGCRYPT_TRUE}" && test -z "${LIBGCRYPT_FALSE}"; then
-  as_fn_error $? "conditional \"LIBGCRYPT\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${MBEDTLS_TRUE}" && test -z "${MBEDTLS_FALSE}"; then
-  as_fn_error $? "conditional \"MBEDTLS\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${WINCNG_TRUE}" && test -z "${WINCNG_FALSE}"; then
-  as_fn_error $? "conditional \"WINCNG\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${BUILD_EXAMPLES_TRUE}" && test -z "${BUILD_EXAMPLES_FALSE}"; then
-  as_fn_error $? "conditional \"BUILD_EXAMPLES\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${USE_OSSFUZZERS_TRUE}" && test -z "${USE_OSSFUZZERS_FALSE}"; then
-  as_fn_error $? "conditional \"USE_OSSFUZZERS\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${USE_OSSFUZZ_FLAG_TRUE}" && test -z "${USE_OSSFUZZ_FLAG_FALSE}"; then
-  as_fn_error $? "conditional \"USE_OSSFUZZ_FLAG\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${USE_OSSFUZZ_STATIC_TRUE}" && test -z "${USE_OSSFUZZ_STATIC_FALSE}"; then
-  as_fn_error $? "conditional \"USE_OSSFUZZ_STATIC\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-if test -z "${HAVE_SYS_UN_H_TRUE}" && test -z "${HAVE_SYS_UN_H_FALSE}"; then
-  as_fn_error $? "conditional \"HAVE_SYS_UN_H\" was never defined.
-Usually this means the macro was only invoked conditionally." "$LINENO" 5
-fi
-
-: "${CONFIG_STATUS=./config.status}"
-ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
-as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-# Run this file to recreate the current configuration.
-# Compiler output produced by configure, useful for debugging
-# configure, is in config.log if it exists.
-
-debug=false
-ac_cs_recheck=false
-ac_cs_silent=false
-
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
-## -------------------- ##
-## M4sh Initialization. ##
-## -------------------- ##
-
-# Be more Bourne compatible
-DUALCASE=1; export DUALCASE # for MKS sh
-as_nop=:
-if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else $as_nop
-  case `(set -o) 2>/dev/null` in #(
-  *posix*) :
-    set -o posix ;; #(
-  *) :
-     ;;
-esac
-fi
-
-
-
-# Reset variables that may have inherited troublesome values from
-# the environment.
-
-# IFS needs to be set, to space, tab, and newline, in precisely that order.
-# (If _AS_PATH_WALK were called with IFS unset, it would have the
-# side effect of setting IFS to empty, thus disabling word splitting.)
-# Quoting is to prevent editors from complaining about space-tab.
-as_nl='
-'
-export as_nl
-IFS=" ""	$as_nl"
-
-PS1='$ '
-PS2='> '
-PS4='+ '
-
-# Ensure predictable behavior from utilities with locale-dependent output.
-LC_ALL=C
-export LC_ALL
-LANGUAGE=C
-export LANGUAGE
-
-# We cannot yet rely on "unset" to work, but we need these variables
-# to be unset--not just set to an empty or harmless value--now, to
-# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
-# also avoids known problems related to "unset" and subshell syntax
-# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
-for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
-do eval test \${$as_var+y} \
-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-done
-
-# Ensure that fds 0, 1, and 2 are open.
-if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
-if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
-if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
-
-# The user is always right.
-if ${PATH_SEPARATOR+false} :; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-# Find who we are.  Look in the path if we contain no directory separator.
-as_myself=
-case $0 in #((
-  *[\\/]* ) as_myself=$0 ;;
-  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  case $as_dir in #(((
-    '') as_dir=./ ;;
-    */) ;;
-    *) as_dir=$as_dir/ ;;
-  esac
-    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
-  done
-IFS=$as_save_IFS
-
-     ;;
-esac
-# We did not find ourselves, most probably we were run as `sh COMMAND'
-# in which case we are not to be found in the path.
-if test "x$as_myself" = x; then
-  as_myself=$0
-fi
-if test ! -f "$as_myself"; then
-  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-  exit 1
-fi
-
-
-
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
-# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
-# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
-as_fn_error ()
-{
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-  fi
-  printf "%s\n" "$as_me: error: $2" >&2
-  as_fn_exit $as_status
-} # as_fn_error
-
-
-
-# as_fn_set_status STATUS
-# -----------------------
-# Set $? to STATUS, without forking.
-as_fn_set_status ()
-{
-  return $1
-} # as_fn_set_status
-
-# as_fn_exit STATUS
-# -----------------
-# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
-as_fn_exit ()
-{
-  set +e
-  as_fn_set_status $1
-  exit $1
-} # as_fn_exit
-
-# as_fn_unset VAR
-# ---------------
-# Portably unset VAR.
-as_fn_unset ()
-{
-  { eval $1=; unset $1;}
-}
-as_unset=as_fn_unset
-
-# as_fn_append VAR VALUE
-# ----------------------
-# Append the text in VALUE to the end of the definition contained in VAR. Take
-# advantage of any shell optimizations that allow amortized linear growth over
-# repeated appends, instead of the typical quadratic growth present in naive
-# implementations.
-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
-then :
-  eval 'as_fn_append ()
-  {
-    eval $1+=\$2
-  }'
-else $as_nop
-  as_fn_append ()
-  {
-    eval $1=\$$1\$2
-  }
-fi # as_fn_append
-
-# as_fn_arith ARG...
-# ------------------
-# Perform arithmetic evaluation on the ARGs, and store the result in the
-# global $as_val. Take advantage of shells that can avoid forks. The arguments
-# must be portable across $(()) and expr.
-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
-then :
-  eval 'as_fn_arith ()
-  {
-    as_val=$(( $* ))
-  }'
-else $as_nop
-  as_fn_arith ()
-  {
-    as_val=`expr "$@" || test $? -eq 1`
-  }
-fi # as_fn_arith
-
-
-if expr a : '\(a\)' >/dev/null 2>&1 &&
-   test "X`expr 00001 : '.*\(...\)'`" = X001; then
-  as_expr=expr
-else
-  as_expr=false
-fi
-
-if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
-  as_basename=basename
-else
-  as_basename=false
-fi
-
-if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
-  as_dirname=dirname
-else
-  as_dirname=false
-fi
-
-as_me=`$as_basename -- "$0" ||
-$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$0" : 'X\(//\)$' \| \
-	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$0" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-
-# Determine whether it's possible to make 'echo' print without a newline.
-# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-# for compatibility with existing Makefiles.
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
-  case `echo 'xy\c'` in
-  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
-  xy)  ECHO_C='\c';;
-  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
-       ECHO_T='	';;
-  esac;;
-*)
-  ECHO_N='-n';;
-esac
-
-# For backward compatibility with old third-party macros, we provide
-# the shell variables $as_echo and $as_echo_n.  New code should use
-# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-as_echo='printf %s\n'
-as_echo_n='printf %s'
-
-rm -f conf$$ conf$$.exe conf$$.file
-if test -d conf$$.dir; then
-  rm -f conf$$.dir/conf$$.file
-else
-  rm -f conf$$.dir
-  mkdir conf$$.dir 2>/dev/null
-fi
-if (echo >conf$$.file) 2>/dev/null; then
-  if ln -s conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s='ln -s'
-    # ... but there are two gotchas:
-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
-    # In both cases, we have to default to `cp -pR'.
-    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-      as_ln_s='cp -pR'
-  elif ln conf$$.file conf$$ 2>/dev/null; then
-    as_ln_s=ln
-  else
-    as_ln_s='cp -pR'
-  fi
-else
-  as_ln_s='cp -pR'
-fi
-rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
-rmdir conf$$.dir 2>/dev/null
-
-
-# as_fn_mkdir_p
-# -------------
-# Create "$as_dir" as a directory, including parents if necessary.
-as_fn_mkdir_p ()
-{
-
-  case $as_dir in #(
-  -*) as_dir=./$as_dir;;
-  esac
-  test -d "$as_dir" || eval $as_mkdir_p || {
-    as_dirs=
-    while :; do
-      case $as_dir in #(
-      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-      *) as_qdir=$as_dir;;
-      esac
-      as_dirs="'$as_qdir' $as_dirs"
-      as_dir=`$as_dirname -- "$as_dir" ||
-$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$as_dir" : 'X\(//\)[^/]' \| \
-	 X"$as_dir" : 'X\(//\)$' \| \
-	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_dir" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-      test -d "$as_dir" && break
-    done
-    test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
-
-
-} # as_fn_mkdir_p
-if mkdir -p . 2>/dev/null; then
-  as_mkdir_p='mkdir -p "$as_dir"'
-else
-  test -d ./-p && rmdir ./-p
-  as_mkdir_p=false
-fi
-
-
-# as_fn_executable_p FILE
-# -----------------------
-# Test if FILE is an executable regular file.
-as_fn_executable_p ()
-{
-  test -f "$1" && test -x "$1"
-} # as_fn_executable_p
-as_test_x='test -x'
-as_executable_p=as_fn_executable_p
-
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-
-
-exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
-_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# Save the log message, to keep $0 and so on meaningful, and to
-# report actual input values of CONFIG_FILES etc. instead of their
-# values after options handling.
-ac_log="
-This file was extended by libssh2 $as_me -, which was
-generated by GNU Autoconf 2.71.  Invocation command line was
-
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  $ $0 $@
-
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
-"
-
-_ACEOF
-
-case $ac_config_files in *"
-"*) set x $ac_config_files; shift; ac_config_files=$*;;
-esac
-
-case $ac_config_headers in *"
-"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
-esac
-
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-# Files that config.status was made for.
-config_files="$ac_config_files"
-config_headers="$ac_config_headers"
-config_commands="$ac_config_commands"
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-ac_cs_usage="\
-\`$as_me' instantiates files and other configuration actions
-from templates according to the current configuration.  Unless the files
-and actions are specified as TAGs, all are instantiated by default.
-
-Usage: $0 [OPTION]... [TAG]...
-
-  -h, --help       print this help, then exit
-  -V, --version    print version number and configuration settings, then exit
-      --config     print configuration, then exit
-  -q, --quiet, --silent
-                   do not print progress messages
-  -d, --debug      don't remove temporary files
-      --recheck    update $as_me by reconfiguring in the same conditions
-      --file=FILE[:TEMPLATE]
-                   instantiate the configuration file FILE
-      --header=FILE[:TEMPLATE]
-                   instantiate the configuration header FILE
-
-Configuration files:
-$config_files
-
-Configuration headers:
-$config_headers
-
-Configuration commands:
-$config_commands
-
-Report bugs to <libssh2-devel@cool.haxx.se>."
-
-_ACEOF
-ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
-ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_cs_config='$ac_cs_config_escaped'
-ac_cs_version="\\
-libssh2 config.status -
-configured by $0, generated by GNU Autoconf 2.71,
-  with options \\"\$ac_cs_config\\"
-
-Copyright (C) 2021 Free Software Foundation, Inc.
-This config.status script is free software; the Free Software Foundation
-gives unlimited permission to copy, distribute and modify it."
-
-ac_pwd='$ac_pwd'
-srcdir='$srcdir'
-INSTALL='$INSTALL'
-MKDIR_P='$MKDIR_P'
-AWK='$AWK'
-test -n "\$AWK" || AWK=awk
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# The default lists apply if the user does not specify any file.
-ac_need_defaults=:
-while test $# != 0
-do
-  case $1 in
-  --*=?*)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
-    ac_shift=:
-    ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
-  *)
-    ac_option=$1
-    ac_optarg=$2
-    ac_shift=shift
-    ;;
-  esac
-
-  case $ac_option in
-  # Handling of the options.
-  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-    ac_cs_recheck=: ;;
-  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
-    printf "%s\n" "$ac_cs_version"; exit ;;
-  --config | --confi | --conf | --con | --co | --c )
-    printf "%s\n" "$ac_cs_config"; exit ;;
-  --debug | --debu | --deb | --de | --d | -d )
-    debug=: ;;
-  --file | --fil | --fi | --f )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
-    esac
-    as_fn_append CONFIG_FILES " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --header | --heade | --head | --hea )
-    $ac_shift
-    case $ac_optarg in
-    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    esac
-    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
-    ac_need_defaults=false;;
-  --he | --h)
-    # Conflict between --help and --header
-    as_fn_error $? "ambiguous option: \`$1'
-Try \`$0 --help' for more information.";;
-  --help | --hel | -h )
-    printf "%s\n" "$ac_cs_usage"; exit ;;
-  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-  | -silent | --silent | --silen | --sile | --sil | --si | --s)
-    ac_cs_silent=: ;;
-
-  # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
-Try \`$0 --help' for more information." ;;
-
-  *) as_fn_append ac_config_targets " $1"
-     ac_need_defaults=false ;;
-
-  esac
-  shift
-done
-
-ac_configure_extra_args=
-
-if $ac_cs_silent; then
-  exec 6>/dev/null
-  ac_configure_extra_args="$ac_configure_extra_args --silent"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-if \$ac_cs_recheck; then
-  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-  shift
-  \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
-  CONFIG_SHELL='$SHELL'
-  export CONFIG_SHELL
-  exec "\$@"
-fi
-
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-exec 5>>config.log
-{
-  echo
-  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
-## Running $as_me. ##
-_ASBOX
-  printf "%s\n" "$ac_log"
-} >&5
-
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-#
-# INIT-COMMANDS
-#
-AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
-
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-sed_quote_subst='$sed_quote_subst'
-double_quote_subst='$double_quote_subst'
-delay_variable_subst='$delay_variable_subst'
-AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`'
-DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
-OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
-macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
-macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
-enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
-enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
-pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
-enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
-shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
-SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
-ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
-PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
-host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
-host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
-host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
-build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
-build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
-build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
-SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
-Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
-GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
-EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
-FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
-LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
-NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
-LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
-max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
-ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
-exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
-lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
-lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
-lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
-lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
-lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
-reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
-reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
-deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
-file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
-file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
-want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
-sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
-AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
-AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
-archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
-STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
-RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
-old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
-old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
-old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
-lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
-CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
-CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
-compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
-GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
-lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
-lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
-lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`'
-lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
-lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
-nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
-lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
-lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
-objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
-MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
-lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
-need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
-MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
-DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
-NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
-LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
-OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
-OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
-libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
-shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
-extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
-archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
-enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
-export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
-whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
-compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
-old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
-old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
-archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
-archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
-module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
-module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
-with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
-allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
-no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
-hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
-hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
-hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
-hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
-hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
-hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
-hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
-inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
-link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
-always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
-export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
-exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
-include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
-prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
-postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
-file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
-variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
-need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
-need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
-version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
-runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
-shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
-shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
-libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
-library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
-soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
-install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
-postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
-postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
-finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
-finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
-hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
-sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
-configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
-configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
-hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
-enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
-enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
-enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
-old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
-striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
-compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`'
-predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`'
-postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`'
-predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
-postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
-compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
-LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
-reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
-reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
-GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
-lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
-lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
-archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
-enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
-export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
-whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
-compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
-old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
-allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
-no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
-inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
-link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
-always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
-export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
-include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
-prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
-file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
-hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
-compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
-predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
-postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
-predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
-postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
-compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'
-
-LTCC='$LTCC'
-LTCFLAGS='$LTCFLAGS'
-compiler='$compiler_DEFAULT'
-
-# A function that is used when there is no print builtin or printf.
-func_fallback_echo ()
-{
-  eval 'cat <<_LTECHO_EOF
-\$1
-_LTECHO_EOF'
-}
-
-# Quote evaled strings.
-for var in AS \
-DLLTOOL \
-OBJDUMP \
-SHELL \
-ECHO \
-PATH_SEPARATOR \
-SED \
-GREP \
-EGREP \
-FGREP \
-LD \
-NM \
-LN_S \
-lt_SP2NL \
-lt_NL2SP \
-reload_flag \
-deplibs_check_method \
-file_magic_cmd \
-file_magic_glob \
-want_nocaseglob \
-sharedlib_from_linklib_cmd \
-AR \
-AR_FLAGS \
-archiver_list_spec \
-STRIP \
-RANLIB \
-CC \
-CFLAGS \
-compiler \
-lt_cv_sys_global_symbol_pipe \
-lt_cv_sys_global_symbol_to_cdecl \
-lt_cv_sys_global_symbol_to_import \
-lt_cv_sys_global_symbol_to_c_name_address \
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
-lt_cv_nm_interface \
-nm_file_list_spec \
-lt_cv_truncate_bin \
-lt_prog_compiler_no_builtin_flag \
-lt_prog_compiler_pic \
-lt_prog_compiler_wl \
-lt_prog_compiler_static \
-lt_cv_prog_compiler_c_o \
-need_locks \
-MANIFEST_TOOL \
-DSYMUTIL \
-NMEDIT \
-LIPO \
-OTOOL \
-OTOOL64 \
-shrext_cmds \
-export_dynamic_flag_spec \
-whole_archive_flag_spec \
-compiler_needs_object \
-with_gnu_ld \
-allow_undefined_flag \
-no_undefined_flag \
-hardcode_libdir_flag_spec \
-hardcode_libdir_separator \
-exclude_expsyms \
-include_expsyms \
-file_list_spec \
-variables_saved_for_relink \
-libname_spec \
-library_names_spec \
-soname_spec \
-install_override_mode \
-finish_eval \
-old_striplib \
-striplib \
-compiler_lib_search_dirs \
-predep_objects \
-postdep_objects \
-predeps \
-postdeps \
-compiler_lib_search_path \
-LD_CXX \
-reload_flag_CXX \
-compiler_CXX \
-lt_prog_compiler_no_builtin_flag_CXX \
-lt_prog_compiler_pic_CXX \
-lt_prog_compiler_wl_CXX \
-lt_prog_compiler_static_CXX \
-lt_cv_prog_compiler_c_o_CXX \
-export_dynamic_flag_spec_CXX \
-whole_archive_flag_spec_CXX \
-compiler_needs_object_CXX \
-with_gnu_ld_CXX \
-allow_undefined_flag_CXX \
-no_undefined_flag_CXX \
-hardcode_libdir_flag_spec_CXX \
-hardcode_libdir_separator_CXX \
-exclude_expsyms_CXX \
-include_expsyms_CXX \
-file_list_spec_CXX \
-compiler_lib_search_dirs_CXX \
-predep_objects_CXX \
-postdep_objects_CXX \
-predeps_CXX \
-postdeps_CXX \
-compiler_lib_search_path_CXX; do
-    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
-    *[\\\\\\\`\\"\\\$]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
-      ;;
-    *)
-      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
-      ;;
-    esac
-done
-
-# Double-quote double-evaled strings.
-for var in reload_cmds \
-old_postinstall_cmds \
-old_postuninstall_cmds \
-old_archive_cmds \
-extract_expsyms_cmds \
-old_archive_from_new_cmds \
-old_archive_from_expsyms_cmds \
-archive_cmds \
-archive_expsym_cmds \
-module_cmds \
-module_expsym_cmds \
-export_symbols_cmds \
-prelink_cmds \
-postlink_cmds \
-postinstall_cmds \
-postuninstall_cmds \
-finish_cmds \
-sys_lib_search_path_spec \
-configure_time_dlsearch_path \
-configure_time_lt_sys_library_path \
-reload_cmds_CXX \
-old_archive_cmds_CXX \
-old_archive_from_new_cmds_CXX \
-old_archive_from_expsyms_cmds_CXX \
-archive_cmds_CXX \
-archive_expsym_cmds_CXX \
-module_cmds_CXX \
-module_expsym_cmds_CXX \
-export_symbols_cmds_CXX \
-prelink_cmds_CXX \
-postlink_cmds_CXX; do
-    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
-    *[\\\\\\\`\\"\\\$]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
-      ;;
-    *)
-      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
-      ;;
-    esac
-done
-
-ac_aux_dir='$ac_aux_dir'
-
-# See if we are running on zsh, and set the options that allow our
-# commands through without removal of \ escapes INIT.
-if test -n "\${ZSH_VERSION+set}"; then
-   setopt NO_GLOB_SUBST
-fi
-
-
-    PACKAGE='$PACKAGE'
-    VERSION='$VERSION'
-    RM='$RM'
-    ofile='$ofile'
-
-
-
-
-
-
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-
-# Handling of arguments.
-for ac_config_target in $ac_config_targets
-do
-  case $ac_config_target in
-    "src/libssh2_config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/libssh2_config.h" ;;
-    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
-    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
-    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
-    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
-    "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;;
-    "tests/ossfuzz/Makefile") CONFIG_FILES="$CONFIG_FILES tests/ossfuzz/Makefile" ;;
-    "example/Makefile") CONFIG_FILES="$CONFIG_FILES example/Makefile" ;;
-    "docs/Makefile") CONFIG_FILES="$CONFIG_FILES docs/Makefile" ;;
-    "libssh2.pc") CONFIG_FILES="$CONFIG_FILES libssh2.pc" ;;
-
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-  esac
-done
-
-
-# If the user did not use the arguments to specify the items to instantiate,
-# then the envvar interface is used.  Set only those that are not.
-# We use the long form for the default assignment because of an extremely
-# bizarre bug on SunOS 4.1.3.
-if $ac_need_defaults; then
-  test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files
-  test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers
-  test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands
-fi
-
-# Have a temporary directory for convenience.  Make it in the build tree
-# simply because there is no reason against having it here, and in addition,
-# creating and moving files from /tmp can sometimes cause problems.
-# Hook for its removal unless debugging.
-# Note that there is a small window in which the directory will not be cleaned:
-# after its creation but before its name has been assigned to `$tmp'.
-$debug ||
-{
-  tmp= ac_tmp=
-  trap 'exit_status=$?
-  : "${ac_tmp:=$tmp}"
-  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
-' 0
-  trap 'as_fn_exit 1' 1 2 13 15
-}
-# Create a (secure) tmp directory for tmp files.
-
-{
-  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
-  test -d "$tmp"
-}  ||
-{
-  tmp=./conf$$-$RANDOM
-  (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
-ac_tmp=$tmp
-
-# Set up the scripts for CONFIG_FILES section.
-# No need to generate them if there are no CONFIG_FILES.
-# This happens for instance with `./config.status config.h'.
-if test -n "$CONFIG_FILES"; then
-
-
-ac_cr=`echo X | tr X '\015'`
-# On cygwin, bash can eat \r inside `` if the user requested igncr.
-# But we know of no other shell where ac_cr would be empty at this
-# point, so we can use a bashism as a fallback.
-if test "x$ac_cr" = x; then
-  eval ac_cr=\$\'\\r\'
-fi
-ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
-if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
-else
-  ac_cs_awk_cr=$ac_cr
-fi
-
-echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
-_ACEOF
-
-
-{
-  echo "cat >conf$$subs.awk <<_ACEOF" &&
-  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
-  echo "_ACEOF"
-} >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
-ac_delim='%!_!# '
-for ac_last_try in false false false false false :; do
-  . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-
-  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
-  if test $ac_delim_n = $ac_delim_num; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-rm -f conf$$subs.sh
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
-_ACEOF
-sed -n '
-h
-s/^/S["/; s/!.*/"]=/
-p
-g
-s/^[^!]*!//
-:repl
-t repl
-s/'"$ac_delim"'$//
-t delim
-:nl
-h
-s/\(.\{148\}\)..*/\1/
-t more1
-s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
-p
-n
-b repl
-:more1
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t nl
-:delim
-h
-s/\(.\{148\}\)..*/\1/
-t more2
-s/["\\]/\\&/g; s/^/"/; s/$/"/
-p
-b
-:more2
-s/["\\]/\\&/g; s/^/"/; s/$/"\\/
-p
-g
-s/.\{148\}//
-t delim
-' <conf$$subs.awk | sed '
-/^[^""]/{
-  N
-  s/\n//
-}
-' >>$CONFIG_STATUS || ac_write_fail=1
-rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-_ACAWK
-cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
-  for (key in S) S_is_set[key] = 1
-  FS = ""
-
-}
-{
-  line = $ 0
-  nfields = split(line, field, "@")
-  substed = 0
-  len = length(field[1])
-  for (i = 2; i < nfields; i++) {
-    key = field[i]
-    keylen = length(key)
-    if (S_is_set[key]) {
-      value = S[key]
-      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
-      len += length(value) + length(field[++i])
-      substed = 1
-    } else
-      len += 1 + keylen
-  }
-
-  print line
-}
-
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
-  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
-else
-  cat
-fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
-_ACEOF
-
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
-# trailing colons and then remove the whole line if VPATH becomes empty
-# (actually we leave an empty line to preserve line numbers).
-if test "x$srcdir" = x.; then
-  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
-h
-s///
-s/^/:/
-s/[	 ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
-s/:*$//
-x
-s/\(=[	 ]*\).*/\1/
-G
-s/\n//
-s/^[^=]*=[	 ]*$//
-}'
-fi
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-fi # test -n "$CONFIG_FILES"
-
-# Set up the scripts for CONFIG_HEADERS section.
-# No need to generate them if there are no CONFIG_HEADERS.
-# This happens for instance with `./config.status Makefile'.
-if test -n "$CONFIG_HEADERS"; then
-cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
-BEGIN {
-_ACEOF
-
-# Transform confdefs.h into an awk script `defines.awk', embedded as
-# here-document in config.status, that substitutes the proper values into
-# config.h.in to produce config.h.
-
-# Create a delimiter string that does not exist in confdefs.h, to ease
-# handling of long lines.
-ac_delim='%!_!# '
-for ac_last_try in false false :; do
-  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
-  if test -z "$ac_tt"; then
-    break
-  elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
-  else
-    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
-  fi
-done
-
-# For the awk script, D is an array of macro values keyed by name,
-# likewise P contains macro parameters if any.  Preserve backslash
-# newline sequences.
-
-ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
-sed -n '
-s/.\{148\}/&'"$ac_delim"'/g
-t rset
-:rset
-s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
-t def
-d
-:def
-s/\\$//
-t bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3"/p
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
-d
-:bsnl
-s/["\\]/\\&/g
-s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
-D["\1"]=" \3\\\\\\n"\\/p
-t cont
-s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
-t cont
-d
-:cont
-n
-s/.\{148\}/&'"$ac_delim"'/g
-t clear
-:clear
-s/\\$//
-t bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/"/p
-d
-:bsnlc
-s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
-b cont
-' <confdefs.h | sed '
-s/'"$ac_delim"'/"\\\
-"/g' >>$CONFIG_STATUS || ac_write_fail=1
-
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  for (key in D) D_is_set[key] = 1
-  FS = ""
-}
-/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
-  line = \$ 0
-  split(line, arg, " ")
-  if (arg[1] == "#") {
-    defundef = arg[2]
-    mac1 = arg[3]
-  } else {
-    defundef = substr(arg[1], 2)
-    mac1 = arg[2]
-  }
-  split(mac1, mac2, "(") #)
-  macro = mac2[1]
-  prefix = substr(line, 1, index(line, defundef) - 1)
-  if (D_is_set[macro]) {
-    # Preserve the white space surrounding the "#".
-    print prefix "define", macro P[macro] D[macro]
-    next
-  } else {
-    # Replace #undef with comments.  This is necessary, for example,
-    # in the case of _POSIX_SOURCE, which is predefined and required
-    # on some systems where configure will not decide to define it.
-    if (defundef == "undef") {
-      print "/*", prefix defundef, macro, "*/"
-      next
-    }
-  }
-}
-{ print }
-_ACAWK
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
-fi # test -n "$CONFIG_HEADERS"
-
-
-eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
-shift
-for ac_tag
-do
-  case $ac_tag in
-  :[FHLC]) ac_mode=$ac_tag; continue;;
-  esac
-  case $ac_mode$ac_tag in
-  :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-  :[FH]-) ac_tag=-:-;;
-  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-  esac
-  ac_save_IFS=$IFS
-  IFS=:
-  set x $ac_tag
-  IFS=$ac_save_IFS
-  shift
-  ac_file=$1
-  shift
-
-  case $ac_mode in
-  :L) ac_source=$1;;
-  :[FH])
-    ac_file_inputs=
-    for ac_f
-    do
-      case $ac_f in
-      -) ac_f="$ac_tmp/stdin";;
-      *) # Look for the file first in the build tree, then in the source tree
-	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
-	 # because $ac_f cannot contain `:'.
-	 test -f "$ac_f" ||
-	   case $ac_f in
-	   [\\/$]*) false;;
-	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
-	   esac ||
-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-      esac
-      case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-      as_fn_append ac_file_inputs " '$ac_f'"
-    done
-
-    # Let's still pretend it is `configure' which instantiates (i.e., don't
-    # use $as_me), people would be surprised to read:
-    #    /* config.h.  Generated by config.status.  */
-    configure_input='Generated from '`
-	  printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-	`' by configure.'
-    if test x"$ac_file" != x-; then
-      configure_input="$ac_file.  $configure_input"
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-printf "%s\n" "$as_me: creating $ac_file" >&6;}
-    fi
-    # Neutralize special characters interpreted by sed in replacement strings.
-    case $configure_input in #(
-    *\&* | *\|* | *\\* )
-       ac_sed_conf_input=`printf "%s\n" "$configure_input" |
-       sed 's/[\\\\&|]/\\\\&/g'`;; #(
-    *) ac_sed_conf_input=$configure_input;;
-    esac
-
-    case $ac_tag in
-    *:-:* | *:-) cat >"$ac_tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
-    esac
-    ;;
-  esac
-
-  ac_dir=`$as_dirname -- "$ac_file" ||
-$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$ac_file" : 'X\(//\)[^/]' \| \
-	 X"$ac_file" : 'X\(//\)$' \| \
-	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$ac_file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-  as_dir="$ac_dir"; as_fn_mkdir_p
-  ac_builddir=.
-
-case "$ac_dir" in
-.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
-*)
-  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
-  # A ".." for each directory in $ac_dir_suffix.
-  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-  case $ac_top_builddir_sub in
-  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-  esac ;;
-esac
-ac_abs_top_builddir=$ac_pwd
-ac_abs_builddir=$ac_pwd$ac_dir_suffix
-# for backward compatibility:
-ac_top_builddir=$ac_top_build_prefix
-
-case $srcdir in
-  .)  # We are building in place.
-    ac_srcdir=.
-    ac_top_srcdir=$ac_top_builddir_sub
-    ac_abs_top_srcdir=$ac_pwd ;;
-  [\\/]* | ?:[\\/]* )  # Absolute name.
-    ac_srcdir=$srcdir$ac_dir_suffix;
-    ac_top_srcdir=$srcdir
-    ac_abs_top_srcdir=$srcdir ;;
-  *) # Relative name.
-    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_top_build_prefix$srcdir
-    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
-esac
-ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-
-
-  case $ac_mode in
-  :F)
-  #
-  # CONFIG_FILE
-  #
-
-  case $INSTALL in
-  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
-  esac
-  ac_MKDIR_P=$MKDIR_P
-  case $MKDIR_P in
-  [\\/$]* | ?:[\\/]* ) ;;
-  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
-  esac
-_ACEOF
-
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-# If the template does not know about datarootdir, expand it.
-# FIXME: This hack should be removed a few years after 2.60.
-ac_datarootdir_hack=; ac_datarootdir_seen=
-ac_sed_dataroot='
-/datarootdir/ {
-  p
-  q
-}
-/@datadir@/p
-/@docdir@/p
-/@infodir@/p
-/@localedir@/p
-/@mandir@/p'
-case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
-*datarootdir*) ac_datarootdir_seen=yes;;
-*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-  ac_datarootdir_hack='
-  s&@datadir@&$datadir&g
-  s&@docdir@&$docdir&g
-  s&@infodir@&$infodir&g
-  s&@localedir@&$localedir&g
-  s&@mandir@&$mandir&g
-  s&\\\${datarootdir}&$datarootdir&g' ;;
-esac
-_ACEOF
-
-# Neutralize VPATH when `$srcdir' = `.'.
-# Shell code in configure.ac might set extrasub.
-# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-ac_sed_extra="$ac_vpsub
-$extrasub
-_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-:t
-/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
-s|@configure_input@|$ac_sed_conf_input|;t t
-s&@top_builddir@&$ac_top_builddir_sub&;t t
-s&@top_build_prefix@&$ac_top_build_prefix&;t t
-s&@srcdir@&$ac_srcdir&;t t
-s&@abs_srcdir@&$ac_abs_srcdir&;t t
-s&@top_srcdir@&$ac_top_srcdir&;t t
-s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
-s&@builddir@&$ac_builddir&;t t
-s&@abs_builddir@&$ac_abs_builddir&;t t
-s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
-s&@INSTALL@&$ac_INSTALL&;t t
-s&@MKDIR_P@&$ac_MKDIR_P&;t t
-$ac_datarootdir_hack
-"
-eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
-  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-
-test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-      "$ac_tmp/out"`; test -z "$ac_out"; } &&
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
-printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
-
-  rm -f "$ac_tmp/stdin"
-  case $ac_file in
-  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
-  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
-  esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
- ;;
-  :H)
-  #
-  # CONFIG_HEADER
-  #
-  if test x"$ac_file" != x-; then
-    {
-      printf "%s\n" "/* $configure_input  */" >&1 \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
-    } >"$ac_tmp/config.h" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
-      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
-printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
-    else
-      rm -f "$ac_file"
-      mv "$ac_tmp/config.h" "$ac_file" \
-	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
-    fi
-  else
-    printf "%s\n" "/* $configure_input  */" >&1 \
-      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
-      || as_fn_error $? "could not create -" "$LINENO" 5
-  fi
-# Compute "$ac_file"'s index in $config_headers.
-_am_arg="$ac_file"
-_am_stamp_count=1
-for _am_header in $config_headers :; do
-  case $_am_header in
-    $_am_arg | $_am_arg:* )
-      break ;;
-    * )
-      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
-  esac
-done
-echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
-$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$_am_arg" : 'X\(//\)[^/]' \| \
-	 X"$_am_arg" : 'X\(//\)$' \| \
-	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$_am_arg" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`/stamp-h$_am_stamp_count
- ;;
-
-  :C)  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
-printf "%s\n" "$as_me: executing $ac_file commands" >&6;}
- ;;
-  esac
-
-
-  case $ac_file$ac_mode in
-    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
-  # Older Autoconf quotes --file arguments for eval, but not when files
-  # are listed without --file.  Let's play safe and only enable the eval
-  # if we detect the quoting.
-  # TODO: see whether this extra hack can be removed once we start
-  # requiring Autoconf 2.70 or later.
-  case $CONFIG_FILES in #(
-  *\'*) :
-    eval set x "$CONFIG_FILES" ;; #(
-  *) :
-    set x $CONFIG_FILES ;; #(
-  *) :
-     ;;
-esac
-  shift
-  # Used to flag and report bootstrapping failures.
-  am_rc=0
-  for am_mf
-  do
-    # Strip MF so we end up with the name of the file.
-    am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile which includes
-    # dependency-tracking related rules and includes.
-    # Grep'ing the whole file directly is not great: AIX grep has a line
-    # limit of 2048, but all sed's we know have understand at least 4000.
-    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
-      || continue
-    am_dirpart=`$as_dirname -- "$am_mf" ||
-$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$am_mf" : 'X\(//\)[^/]' \| \
-	 X"$am_mf" : 'X\(//\)$' \| \
-	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$am_mf" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)[^/].*/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-    am_filepart=`$as_basename -- "$am_mf" ||
-$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
-	 X"$am_mf" : 'X\(//\)$' \| \
-	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$am_mf" |
-    sed '/^.*\/\([^/][^/]*\)\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\/\(\/\).*/{
-	    s//\1/
-	    q
-	  }
-	  s/.*/./; q'`
-    { echo "$as_me:$LINENO: cd "$am_dirpart" \
-      && sed -e '/# am--include-marker/d' "$am_filepart" \
-        | $MAKE -f - am--depfiles" >&5
-   (cd "$am_dirpart" \
-      && sed -e '/# am--include-marker/d' "$am_filepart" \
-        | $MAKE -f - am--depfiles) >&5 2>&5
-   ac_status=$?
-   echo "$as_me:$LINENO: \$? = $ac_status" >&5
-   (exit $ac_status); } || am_rc=$?
-  done
-  if test $am_rc -ne 0; then
-    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "Something went wrong bootstrapping makefile fragments
-    for automatic dependency tracking.  If GNU make was not used, consider
-    re-running the configure script with MAKE=\"gmake\" (or whatever is
-    necessary).  You can also try re-running configure with the
-    '--disable-dependency-tracking' option to at least be able to build
-    the package (albeit without support for automatic dependency tracking).
-See \`config.log' for more details" "$LINENO" 5; }
-  fi
-  { am_dirpart=; unset am_dirpart;}
-  { am_filepart=; unset am_filepart;}
-  { am_mf=; unset am_mf;}
-  { am_rc=; unset am_rc;}
-  rm -f conftest-deps.mk
-}
- ;;
-    "libtool":C)
-
-    # See if we are running on zsh, and set the options that allow our
-    # commands through without removal of \ escapes.
-    if test -n "${ZSH_VERSION+set}"; then
-      setopt NO_GLOB_SUBST
-    fi
-
-    cfgfile=${ofile}T
-    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
-    $RM "$cfgfile"
-
-    cat <<_LT_EOF >> "$cfgfile"
-#! $SHELL
-# Generated automatically by $as_me ($PACKAGE) $VERSION
-# NOTE: Changes made to this file will be lost: look at ltmain.sh.
-
-# Provide generalized library-building support services.
-# Written by Gordon Matzigkeit, 1996
-
-# Copyright (C) 2014 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# GNU Libtool is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of of the License, or
-# (at your option) any later version.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program or library that is built
-# using GNU Libtool, you may include this file under the  same
-# distribution terms that you use for the rest of that program.
-#
-# GNU Libtool is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-# The names of the tagged configurations supported by this script.
-available_tags='CXX '
-
-# Configured defaults for sys_lib_dlsearch_path munging.
-: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
-
-# ### BEGIN LIBTOOL CONFIG
-
-# Assembler program.
-AS=$lt_AS
-
-# DLL creation program.
-DLLTOOL=$lt_DLLTOOL
-
-# Object dumper program.
-OBJDUMP=$lt_OBJDUMP
-
-# Which release of libtool.m4 was used?
-macro_version=$macro_version
-macro_revision=$macro_revision
-
-# Whether or not to build shared libraries.
-build_libtool_libs=$enable_shared
-
-# Whether or not to build static libraries.
-build_old_libs=$enable_static
-
-# What type of objects to build.
-pic_mode=$pic_mode
-
-# Whether or not to optimize for fast installation.
-fast_install=$enable_fast_install
-
-# Shared archive member basename,for filename based shared library versioning on AIX.
-shared_archive_member_spec=$shared_archive_member_spec
-
-# Shell to use when invoking shell scripts.
-SHELL=$lt_SHELL
-
-# An echo program that protects backslashes.
-ECHO=$lt_ECHO
-
-# The PATH separator for the build system.
-PATH_SEPARATOR=$lt_PATH_SEPARATOR
-
-# The host system.
-host_alias=$host_alias
-host=$host
-host_os=$host_os
-
-# The build system.
-build_alias=$build_alias
-build=$build
-build_os=$build_os
-
-# A sed program that does not truncate output.
-SED=$lt_SED
-
-# Sed that helps us avoid accidentally triggering echo(1) options like -n.
-Xsed="\$SED -e 1s/^X//"
-
-# A grep program that handles long lines.
-GREP=$lt_GREP
-
-# An ERE matcher.
-EGREP=$lt_EGREP
-
-# A literal string matcher.
-FGREP=$lt_FGREP
-
-# A BSD- or MS-compatible name lister.
-NM=$lt_NM
-
-# Whether we need soft or hard links.
-LN_S=$lt_LN_S
-
-# What is the maximum length of a command?
-max_cmd_len=$max_cmd_len
-
-# Object file suffix (normally "o").
-objext=$ac_objext
-
-# Executable file suffix (normally "").
-exeext=$exeext
-
-# whether the shell understands "unset".
-lt_unset=$lt_unset
-
-# turn spaces into newlines.
-SP2NL=$lt_lt_SP2NL
-
-# turn newlines into spaces.
-NL2SP=$lt_lt_NL2SP
-
-# convert \$build file names to \$host format.
-to_host_file_cmd=$lt_cv_to_host_file_cmd
-
-# convert \$build files to toolchain format.
-to_tool_file_cmd=$lt_cv_to_tool_file_cmd
-
-# Method to check whether dependent libraries are shared objects.
-deplibs_check_method=$lt_deplibs_check_method
-
-# Command to use when deplibs_check_method = "file_magic".
-file_magic_cmd=$lt_file_magic_cmd
-
-# How to find potential files when deplibs_check_method = "file_magic".
-file_magic_glob=$lt_file_magic_glob
-
-# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
-want_nocaseglob=$lt_want_nocaseglob
-
-# Command to associate shared and link libraries.
-sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
-
-# The archiver.
-AR=$lt_AR
-
-# Flags to create an archive.
-AR_FLAGS=$lt_AR_FLAGS
-
-# How to feed a file listing to the archiver.
-archiver_list_spec=$lt_archiver_list_spec
-
-# A symbol stripping program.
-STRIP=$lt_STRIP
-
-# Commands used to install an old-style archive.
-RANLIB=$lt_RANLIB
-old_postinstall_cmds=$lt_old_postinstall_cmds
-old_postuninstall_cmds=$lt_old_postuninstall_cmds
-
-# Whether to use a lock for old archive extraction.
-lock_old_archive_extraction=$lock_old_archive_extraction
-
-# A C compiler.
-LTCC=$lt_CC
-
-# LTCC compiler flags.
-LTCFLAGS=$lt_CFLAGS
-
-# Take the output of nm and produce a listing of raw symbols and C names.
-global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
-
-# Transform the output of nm in a proper C declaration.
-global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
-
-# Transform the output of nm into a list of symbols to manually relocate.
-global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import
-
-# Transform the output of nm in a C name address pair.
-global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
-
-# Transform the output of nm in a C name address pair when lib prefix is needed.
-global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
-
-# The name lister interface.
-nm_interface=$lt_lt_cv_nm_interface
-
-# Specify filename containing input files for \$NM.
-nm_file_list_spec=$lt_nm_file_list_spec
-
-# The root where to search for dependent libraries,and where our libraries should be installed.
-lt_sysroot=$lt_sysroot
-
-# Command to truncate a binary pipe.
-lt_truncate_bin=$lt_lt_cv_truncate_bin
-
-# The name of the directory that contains temporary libtool files.
-objdir=$objdir
-
-# Used to examine libraries when file_magic_cmd begins with "file".
-MAGIC_CMD=$MAGIC_CMD
-
-# Must we lock files when doing compilation?
-need_locks=$lt_need_locks
-
-# Manifest tool.
-MANIFEST_TOOL=$lt_MANIFEST_TOOL
-
-# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
-DSYMUTIL=$lt_DSYMUTIL
-
-# Tool to change global to local symbols on Mac OS X.
-NMEDIT=$lt_NMEDIT
-
-# Tool to manipulate fat objects and archives on Mac OS X.
-LIPO=$lt_LIPO
-
-# ldd/readelf like tool for Mach-O binaries on Mac OS X.
-OTOOL=$lt_OTOOL
-
-# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
-OTOOL64=$lt_OTOOL64
-
-# Old archive suffix (normally "a").
-libext=$libext
-
-# Shared library suffix (normally ".so").
-shrext_cmds=$lt_shrext_cmds
-
-# The commands to extract the exported symbol list from a shared archive.
-extract_expsyms_cmds=$lt_extract_expsyms_cmds
-
-# Variables whose values should be saved in libtool wrapper scripts and
-# restored at link time.
-variables_saved_for_relink=$lt_variables_saved_for_relink
-
-# Do we need the "lib" prefix for modules?
-need_lib_prefix=$need_lib_prefix
-
-# Do we need a version for libraries?
-need_version=$need_version
-
-# Library versioning type.
-version_type=$version_type
-
-# Shared library runtime path variable.
-runpath_var=$runpath_var
-
-# Shared library path variable.
-shlibpath_var=$shlibpath_var
-
-# Is shlibpath searched before the hard-coded library search path?
-shlibpath_overrides_runpath=$shlibpath_overrides_runpath
-
-# Format of library name prefix.
-libname_spec=$lt_libname_spec
-
-# List of archive names.  First name is the real one, the rest are links.
-# The last name is the one that the linker finds with -lNAME
-library_names_spec=$lt_library_names_spec
-
-# The coded name of the library, if different from the real name.
-soname_spec=$lt_soname_spec
-
-# Permission mode override for installation of shared libraries.
-install_override_mode=$lt_install_override_mode
-
-# Command to use after installation of a shared archive.
-postinstall_cmds=$lt_postinstall_cmds
-
-# Command to use after uninstallation of a shared archive.
-postuninstall_cmds=$lt_postuninstall_cmds
-
-# Commands used to finish a libtool library installation in a directory.
-finish_cmds=$lt_finish_cmds
-
-# As "finish_cmds", except a single script fragment to be evaled but
-# not shown.
-finish_eval=$lt_finish_eval
-
-# Whether we should hardcode library paths into libraries.
-hardcode_into_libs=$hardcode_into_libs
-
-# Compile-time system search path for libraries.
-sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
-
-# Detected run-time system search path for libraries.
-sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
-
-# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
-configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
-
-# Whether dlopen is supported.
-dlopen_support=$enable_dlopen
-
-# Whether dlopen of programs is supported.
-dlopen_self=$enable_dlopen_self
-
-# Whether dlopen of statically linked programs is supported.
-dlopen_self_static=$enable_dlopen_self_static
-
-# Commands to strip libraries.
-old_striplib=$lt_old_striplib
-striplib=$lt_striplib
-
-
-# The linker used to build libraries.
-LD=$lt_LD
-
-# How to create reloadable object files.
-reload_flag=$lt_reload_flag
-reload_cmds=$lt_reload_cmds
-
-# Commands used to build an old-style archive.
-old_archive_cmds=$lt_old_archive_cmds
-
-# A language specific compiler.
-CC=$lt_compiler
-
-# Is the compiler the GNU compiler?
-with_gcc=$GCC
-
-# Compiler flag to turn off builtin functions.
-no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
-
-# Additional compiler flags for building library objects.
-pic_flag=$lt_lt_prog_compiler_pic
-
-# How to pass a linker flag through the compiler.
-wl=$lt_lt_prog_compiler_wl
-
-# Compiler flag to prevent dynamic linking.
-link_static_flag=$lt_lt_prog_compiler_static
-
-# Does compiler simultaneously support -c and -o options?
-compiler_c_o=$lt_lt_cv_prog_compiler_c_o
-
-# Whether or not to add -lc for building shared libraries.
-build_libtool_need_lc=$archive_cmds_need_lc
-
-# Whether or not to disallow shared libs when runtime libs are static.
-allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
-
-# Compiler flag to allow reflexive dlopens.
-export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
-
-# Compiler flag to generate shared objects directly from archives.
-whole_archive_flag_spec=$lt_whole_archive_flag_spec
-
-# Whether the compiler copes with passing no objects directly.
-compiler_needs_object=$lt_compiler_needs_object
-
-# Create an old-style archive from a shared archive.
-old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
-
-# Create a temporary old-style archive to link instead of a shared archive.
-old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
-
-# Commands used to build a shared archive.
-archive_cmds=$lt_archive_cmds
-archive_expsym_cmds=$lt_archive_expsym_cmds
-
-# Commands used to build a loadable module if different from building
-# a shared archive.
-module_cmds=$lt_module_cmds
-module_expsym_cmds=$lt_module_expsym_cmds
-
-# Whether we are building with GNU ld or not.
-with_gnu_ld=$lt_with_gnu_ld
-
-# Flag that allows shared libraries with undefined symbols to be built.
-allow_undefined_flag=$lt_allow_undefined_flag
-
-# Flag that enforces no undefined symbols.
-no_undefined_flag=$lt_no_undefined_flag
-
-# Flag to hardcode \$libdir into a binary during linking.
-# This must work even if \$libdir does not exist
-hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
-
-# Whether we need a single "-rpath" flag with a separated argument.
-hardcode_libdir_separator=$lt_hardcode_libdir_separator
-
-# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
-# DIR into the resulting binary.
-hardcode_direct=$hardcode_direct
-
-# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
-# DIR into the resulting binary and the resulting library dependency is
-# "absolute",i.e impossible to change by setting \$shlibpath_var if the
-# library is relocated.
-hardcode_direct_absolute=$hardcode_direct_absolute
-
-# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
-# into the resulting binary.
-hardcode_minus_L=$hardcode_minus_L
-
-# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
-# into the resulting binary.
-hardcode_shlibpath_var=$hardcode_shlibpath_var
-
-# Set to "yes" if building a shared library automatically hardcodes DIR
-# into the library and all subsequent libraries and executables linked
-# against it.
-hardcode_automatic=$hardcode_automatic
-
-# Set to yes if linker adds runtime paths of dependent libraries
-# to runtime path list.
-inherit_rpath=$inherit_rpath
-
-# Whether libtool must link a program against all its dependency libraries.
-link_all_deplibs=$link_all_deplibs
-
-# Set to "yes" if exported symbols are required.
-always_export_symbols=$always_export_symbols
-
-# The commands to list exported symbols.
-export_symbols_cmds=$lt_export_symbols_cmds
-
-# Symbols that should not be listed in the preloaded symbols.
-exclude_expsyms=$lt_exclude_expsyms
-
-# Symbols that must always be exported.
-include_expsyms=$lt_include_expsyms
-
-# Commands necessary for linking programs (against libraries) with templates.
-prelink_cmds=$lt_prelink_cmds
-
-# Commands necessary for finishing linking programs.
-postlink_cmds=$lt_postlink_cmds
-
-# Specify filename containing input files.
-file_list_spec=$lt_file_list_spec
-
-# How to hardcode a shared library path into an executable.
-hardcode_action=$hardcode_action
-
-# The directories searched by this compiler when creating a shared library.
-compiler_lib_search_dirs=$lt_compiler_lib_search_dirs
-
-# Dependencies to place before and after the objects being linked to
-# create a shared library.
-predep_objects=$lt_predep_objects
-postdep_objects=$lt_postdep_objects
-predeps=$lt_predeps
-postdeps=$lt_postdeps
-
-# The library search path used internally by the compiler when linking
-# a shared library.
-compiler_lib_search_path=$lt_compiler_lib_search_path
-
-# ### END LIBTOOL CONFIG
-
-_LT_EOF
-
-    cat <<'_LT_EOF' >> "$cfgfile"
-
-# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
-
-# func_munge_path_list VARIABLE PATH
-# -----------------------------------
-# VARIABLE is name of variable containing _space_ separated list of
-# directories to be munged by the contents of PATH, which is string
-# having a format:
-# "DIR[:DIR]:"
-#       string "DIR[ DIR]" will be prepended to VARIABLE
-# ":DIR[:DIR]"
-#       string "DIR[ DIR]" will be appended to VARIABLE
-# "DIRP[:DIRP]::[DIRA:]DIRA"
-#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
-#       "DIRA[ DIRA]" will be appended to VARIABLE
-# "DIR[:DIR]"
-#       VARIABLE will be replaced by "DIR[ DIR]"
-func_munge_path_list ()
-{
-    case x$2 in
-    x)
-        ;;
-    *:)
-        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
-        ;;
-    x:*)
-        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
-        ;;
-    *::*)
-        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
-        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
-        ;;
-    *)
-        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
-        ;;
-    esac
-}
-
-
-# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
-func_cc_basename ()
-{
-    for cc_temp in $*""; do
-      case $cc_temp in
-        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
-        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
-        \-*) ;;
-        *) break;;
-      esac
-    done
-    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
-}
-
-
-# ### END FUNCTIONS SHARED WITH CONFIGURE
-
-_LT_EOF
-
-  case $host_os in
-  aix3*)
-    cat <<\_LT_EOF >> "$cfgfile"
-# AIX sometimes has problems with the GCC collect2 program.  For some
-# reason, if we set the COLLECT_NAMES environment variable, the problems
-# vanish in a puff of smoke.
-if test set != "${COLLECT_NAMES+set}"; then
-  COLLECT_NAMES=
-  export COLLECT_NAMES
-fi
-_LT_EOF
-    ;;
-  esac
-
-
-
-ltmain=$ac_aux_dir/ltmain.sh
-
-
-  # We use sed instead of cat because bash on DJGPP gets confused if
-  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
-  # text mode, it properly converts lines to CR/LF.  This bash problem
-  # is reportedly fixed, but why not run on old versions too?
-  sed '$q' "$ltmain" >> "$cfgfile" \
-     || (rm -f "$cfgfile"; exit 1)
-
-   mv -f "$cfgfile" "$ofile" ||
-    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
-  chmod +x "$ofile"
-
-
-    cat <<_LT_EOF >> "$ofile"
-
-# ### BEGIN LIBTOOL TAG CONFIG: CXX
-
-# The linker used to build libraries.
-LD=$lt_LD_CXX
-
-# How to create reloadable object files.
-reload_flag=$lt_reload_flag_CXX
-reload_cmds=$lt_reload_cmds_CXX
-
-# Commands used to build an old-style archive.
-old_archive_cmds=$lt_old_archive_cmds_CXX
-
-# A language specific compiler.
-CC=$lt_compiler_CXX
-
-# Is the compiler the GNU compiler?
-with_gcc=$GCC_CXX
-
-# Compiler flag to turn off builtin functions.
-no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX
-
-# Additional compiler flags for building library objects.
-pic_flag=$lt_lt_prog_compiler_pic_CXX
-
-# How to pass a linker flag through the compiler.
-wl=$lt_lt_prog_compiler_wl_CXX
-
-# Compiler flag to prevent dynamic linking.
-link_static_flag=$lt_lt_prog_compiler_static_CXX
-
-# Does compiler simultaneously support -c and -o options?
-compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX
-
-# Whether or not to add -lc for building shared libraries.
-build_libtool_need_lc=$archive_cmds_need_lc_CXX
-
-# Whether or not to disallow shared libs when runtime libs are static.
-allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX
-
-# Compiler flag to allow reflexive dlopens.
-export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX
-
-# Compiler flag to generate shared objects directly from archives.
-whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX
-
-# Whether the compiler copes with passing no objects directly.
-compiler_needs_object=$lt_compiler_needs_object_CXX
-
-# Create an old-style archive from a shared archive.
-old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX
-
-# Create a temporary old-style archive to link instead of a shared archive.
-old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX
-
-# Commands used to build a shared archive.
-archive_cmds=$lt_archive_cmds_CXX
-archive_expsym_cmds=$lt_archive_expsym_cmds_CXX
-
-# Commands used to build a loadable module if different from building
-# a shared archive.
-module_cmds=$lt_module_cmds_CXX
-module_expsym_cmds=$lt_module_expsym_cmds_CXX
-
-# Whether we are building with GNU ld or not.
-with_gnu_ld=$lt_with_gnu_ld_CXX
-
-# Flag that allows shared libraries with undefined symbols to be built.
-allow_undefined_flag=$lt_allow_undefined_flag_CXX
-
-# Flag that enforces no undefined symbols.
-no_undefined_flag=$lt_no_undefined_flag_CXX
-
-# Flag to hardcode \$libdir into a binary during linking.
-# This must work even if \$libdir does not exist
-hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
-
-# Whether we need a single "-rpath" flag with a separated argument.
-hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
-
-# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
-# DIR into the resulting binary.
-hardcode_direct=$hardcode_direct_CXX
-
-# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
-# DIR into the resulting binary and the resulting library dependency is
-# "absolute",i.e impossible to change by setting \$shlibpath_var if the
-# library is relocated.
-hardcode_direct_absolute=$hardcode_direct_absolute_CXX
-
-# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
-# into the resulting binary.
-hardcode_minus_L=$hardcode_minus_L_CXX
-
-# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
-# into the resulting binary.
-hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX
-
-# Set to "yes" if building a shared library automatically hardcodes DIR
-# into the library and all subsequent libraries and executables linked
-# against it.
-hardcode_automatic=$hardcode_automatic_CXX
-
-# Set to yes if linker adds runtime paths of dependent libraries
-# to runtime path list.
-inherit_rpath=$inherit_rpath_CXX
-
-# Whether libtool must link a program against all its dependency libraries.
-link_all_deplibs=$link_all_deplibs_CXX
-
-# Set to "yes" if exported symbols are required.
-always_export_symbols=$always_export_symbols_CXX
-
-# The commands to list exported symbols.
-export_symbols_cmds=$lt_export_symbols_cmds_CXX
-
-# Symbols that should not be listed in the preloaded symbols.
-exclude_expsyms=$lt_exclude_expsyms_CXX
-
-# Symbols that must always be exported.
-include_expsyms=$lt_include_expsyms_CXX
-
-# Commands necessary for linking programs (against libraries) with templates.
-prelink_cmds=$lt_prelink_cmds_CXX
-
-# Commands necessary for finishing linking programs.
-postlink_cmds=$lt_postlink_cmds_CXX
-
-# Specify filename containing input files.
-file_list_spec=$lt_file_list_spec_CXX
-
-# How to hardcode a shared library path into an executable.
-hardcode_action=$hardcode_action_CXX
-
-# The directories searched by this compiler when creating a shared library.
-compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX
-
-# Dependencies to place before and after the objects being linked to
-# create a shared library.
-predep_objects=$lt_predep_objects_CXX
-postdep_objects=$lt_postdep_objects_CXX
-predeps=$lt_predeps_CXX
-postdeps=$lt_postdeps_CXX
-
-# The library search path used internally by the compiler when linking
-# a shared library.
-compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
-
-# ### END LIBTOOL TAG CONFIG: CXX
-_LT_EOF
-
- ;;
-
-  esac
-done # for ac_tag
-
-
-as_fn_exit 0
-_ACEOF
-ac_clean_files=$ac_clean_files_save
-
-test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
-
-
-# configure is writing to config.log, and then calls config.status.
-# config.status does its own redirection, appending to config.log.
-# Unfortunately, on DOS this fails, as config.log is still kept open
-# by configure, so config.status won't be able to write to it; its
-# output is simply discarded.  So we exec the FD to /dev/null,
-# effectively closing config.log, so it can be properly (re)opened and
-# appended to by config.status.  When coming back to configure, we
-# need to make the FD available again.
-if test "$no_create" != yes; then
-  ac_cs_success=:
-  ac_config_status_args=
-  test "$silent" = yes &&
-    ac_config_status_args="$ac_config_status_args --quiet"
-  exec 5>/dev/null
-  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
-  exec 5>>config.log
-  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
-  # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
-fi
-if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-fi
-
-
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: summary of build options:
-
-  version:          ${LIBSSH2VER}
-  Host type:        ${host}
-  Install prefix:   ${prefix}
-  Compiler:         ${CC}
-  Compiler flags:   ${CFLAGS}
-  Library types:    Shared=${enable_shared}, Static=${enable_static}
-  Crypto library:   ${found_crypto_str}
-  Clear memory:     $enable_clear_memory
-  Debug build:      $enable_debug
-  Build examples:   $build_examples
-  Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
-" >&5
-printf "%s\n" "$as_me: summary of build options:
-
-  version:          ${LIBSSH2VER}
-  Host type:        ${host}
-  Install prefix:   ${prefix}
-  Compiler:         ${CC}
-  Compiler flags:   ${CFLAGS}
-  Library types:    Shared=${enable_shared}, Static=${enable_static}
-  Crypto library:   ${found_crypto_str}
-  Clear memory:     $enable_clear_memory
-  Debug build:      $enable_debug
-  Build examples:   $build_examples
-  Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
-" >&6;}
-
diff --git a/libssh2/libssh2/configure.ac b/libssh2/libssh2/configure.ac
deleted file mode 100644
index c4fc3e4e..00000000
--- a/libssh2/libssh2/configure.ac
+++ /dev/null
@@ -1,407 +0,0 @@
-# AC_PREREQ(2.57)
-AC_INIT(libssh2, [-], libssh2-devel@cool.haxx.se)
-AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_SRCDIR([src])
-AC_CONFIG_HEADERS([src/libssh2_config.h])
-AM_MAINTAINER_MODE
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-
-dnl SED is needed by some of the tools
-AC_PATH_PROG( SED, sed, sed-was-not-found-by-configure,
-              $PATH:/usr/bin:/usr/local/bin)
-AC_SUBST(SED)
-
-if test "x$SED" = "xsed-was-not-found-by-configure"; then
-  AC_MSG_WARN([sed was not found, this may ruin your chances to build fine])
-fi
-
-dnl figure out the libssh2 version
-LIBSSH2VER=`$SED -ne 's/^#define LIBSSH2_VERSION *"\(.*\)"/\1/p' ${srcdir}/include/libssh2.h`
-AM_INIT_AUTOMAKE
-AC_MSG_CHECKING([libssh2 version])
-AC_MSG_RESULT($LIBSSH2VER)
-
-AC_SUBST(LIBSSH2VER)
-
-AB_VERSION=$LIBSSH2VER
-
-AB_INIT
-
-# Check for the OS.
-# Daniel's note: this should not be necessary and we need to work to
-# get this removed.
-AC_CANONICAL_HOST
-case "$host" in
-    *-mingw*)
-    CFLAGS="$CFLAGS -DLIBSSH2_WIN32"
-    LIBS="$LIBS -lws2_32"
-    ;;
-    *darwin*)
-    CFLAGS="$CFLAGS -DLIBSSH2_DARWIN"
-    ;;
-    *hpux*)
-    ;;
-    *osf*)
-    CFLAGS="$CFLAGS -D_POSIX_PII_SOCKET"
-    ;;
-    *)
-    ;;
-esac
-
-AC_CHECK_TYPE(long long,
-   [AC_DEFINE(HAVE_LONGLONG, 1,
-      [Define to 1 if the compiler supports the 'long long' data type.])]
-   longlong="yes"
-)
-
-dnl Our configure and build reentrant settings
-CURL_CONFIGURE_REENTRANT
-
-# Some systems (Solaris?) have socket() in -lsocket.
-AC_SEARCH_LIBS(socket, socket)
-
-# Solaris has inet_addr() in -lnsl.
-AC_SEARCH_LIBS(inet_addr, nsl)
-
-AC_SUBST(LIBS)
-
-AC_PROG_CC
-AC_PROG_CXX
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AC_PROG_MAKE_SET
-AC_PATH_PROGS(SSHD, [sshd], [],
-     [$PATH$PATH_SEPARATOR/usr/libexec$PATH_SEPARATOR]dnl
-     [/usr/sbin$PATH_SEPARATOR/usr/etc$PATH_SEPARATOR/etc])
-AM_CONDITIONAL(SSHD, test -n "$SSHD")
-AC_LIBTOOL_WIN32_DLL
-AC_PROG_LIBTOOL
-AC_C_BIGENDIAN
-
-dnl check for how to do large files
-AC_SYS_LARGEFILE
-
-# Crypto backends
-
-found_crypto=none
-found_crypto_str=""
-support_clear_memory=no
-crypto_errors=""
-
-m4_set_add([crypto_backends], [openssl])
-m4_set_add([crypto_backends], [libgcrypt])
-m4_set_add([crypto_backends], [mbedtls])
-m4_set_add([crypto_backends], [wincng])
-
-AC_ARG_WITH([crypto],
-  AC_HELP_STRING([--with-crypto=auto|]m4_set_contents([crypto_backends], [|]),
-    [Select crypto backend (default: auto)]),
-  use_crypto=$withval,
-  use_crypto=auto
-)
-
-case "${use_crypto}" in
-  auto|m4_set_contents([crypto_backends], [|]))
-    m4_set_map([crypto_backends], [LIBSSH2_CHECK_CRYPTO])
-    ;;
-  yes|"")
-    crypto_errors="No crypto backend specified!"
-    ;;
-  *)
-    crypto_errors="Unknown crypto backend '${use_crypto}' specified!"
-    ;;
-esac
-
-if test "$found_crypto" = "none"; then
-  crypto_errors="${crypto_errors}
-Specify --with-crypto=\$backend and/or the neccessary library search prefix.
-
-Known crypto backends: auto, m4_set_contents([crypto_backends], [, ])"
-  AS_MESSAGE([ERROR: ${crypto_errors}])
-else
-  test "$found_crypto_str" = "" && found_crypto_str="$found_crypto"
-fi
-
-m4_set_foreach([crypto_backends], [backend],
-  [AM_CONDITIONAL(m4_toupper(backend), test "$found_crypto" = "backend")]
-)
-
-# libz
-
-AC_ARG_WITH([libz],
-  AC_HELP_STRING([--with-libz],[Use libz for compression]),
-  use_libz=$withval,
-  use_libz=auto)
-
-found_libz=no
-libz_errors=""
-
-if test "$use_libz" != no; then
-  AC_LIB_HAVE_LINKFLAGS([z], [], [#include <zlib.h>])
-  if test "$ac_cv_libz" != yes; then
-    if test "$use_libz" = auto; then
-      AC_MSG_NOTICE([Cannot find libz, disabling compression])
-      found_libz="disabled; no libz found"
-    else
-      libz_errors="No libz found!
-Try --with-libz-prefix=PATH if you know that you have it."
-      AS_MESSAGE([ERROR: $libz_errors])
-    fi
-  else
-    AC_DEFINE(LIBSSH2_HAVE_ZLIB, 1, [Compile in zlib support])
-    LIBSREQUIRED="$LIBSREQUIRED${LIBSREQUIRED:+ }zlib"
-    found_libz="yes"
-  fi
-fi
-
-AC_SUBST(LIBSREQUIRED)
-
-#
-# Optional Settings
-#
-AC_ARG_ENABLE(crypt-none,
-  AC_HELP_STRING([--enable-crypt-none],[Permit "none" cipher -- NOT RECOMMENDED]),
-  [AC_DEFINE(LIBSSH2_CRYPT_NONE, 1, [Enable "none" cipher -- NOT RECOMMENDED])])
-
-AC_ARG_ENABLE(mac-none,
-  AC_HELP_STRING([--enable-mac-none],[Permit "none" MAC -- NOT RECOMMENDED]),
-  [AC_DEFINE(LIBSSH2_MAC_NONE, 1, [Enable "none" MAC -- NOT RECOMMENDED])])
-
-AC_ARG_ENABLE(gex-new,
-  AC_HELP_STRING([--disable-gex-new],[Disable "new" diffie-hellman-group-exchange-sha1 method]),
-  [GEX_NEW=$enableval])
-if test "$GEX_NEW" != "no"; then
-  AC_DEFINE(LIBSSH2_DH_GEX_NEW, 1, [Enable newer diffie-hellman-group-exchange-sha1 syntax])
-fi
-
-AC_ARG_ENABLE(clear-memory,
-  AC_HELP_STRING([--disable-clear-memory],[Disable clearing of memory before being freed]),
-  [CLEAR_MEMORY=$enableval])
-if test "$CLEAR_MEMORY" != "no"; then
-  if test "$support_clear_memory" = "yes"; then
-    AC_DEFINE(LIBSSH2_CLEAR_MEMORY, 1, [Enable clearing of memory before being freed])
-    enable_clear_memory=yes
-  else
-    if test "$CLEAR_MEMORY" = "yes"; then
-      AC_MSG_ERROR([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    else
-      AC_MSG_WARN([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    fi
-    enable_clear_memory=unsupported
-  fi
-else
-  if test "$support_clear_memory" = "yes"; then
-    enable_clear_memory=no
-  else
-    AC_MSG_WARN([secure clearing/zeroing of memory is not supported by the selected crypto backend])
-    enable_clear_memory=unsupported
-  fi
-fi
-
-dnl ************************************************************
-dnl option to switch on compiler debug options
-dnl
-AC_MSG_CHECKING([whether to enable pedantic and debug compiler options])
-AC_ARG_ENABLE(debug,
-AC_HELP_STRING([--enable-debug],[Enable pedantic and debug options])
-AC_HELP_STRING([--disable-debug],[Disable debug options]),
-[ case "$enable_debug" in
-  no)
-       AC_MSG_RESULT(no)
-       CPPFLAGS="$CPPFLAGS -DNDEBUG"
-       ;;
-  *)   AC_MSG_RESULT(yes)
-    enable_debug=yes
-    CPPFLAGS="$CPPFLAGS -DLIBSSH2DEBUG"
-    CFLAGS="$CFLAGS -g"
-
-    dnl set compiler "debug" options to become more picky, and remove
-    dnl optimize options from CFLAGS
-    CURL_CC_DEBUG_OPTS
-       ;;
-  esac
- ],
-       enable_debug=no
-       AC_MSG_RESULT(no)
-)
-
-dnl ************************************************************
-dnl Enable hiding of internal symbols in library to reduce its size and
-dnl speed dynamic linking of applications.  This currently is only supported
-dnl on gcc >= 4.0 and SunPro C.
-dnl
-AC_MSG_CHECKING([whether to enable hidden symbols in the library])
-AC_ARG_ENABLE(hidden-symbols,
-AC_HELP_STRING([--enable-hidden-symbols],[Hide internal symbols in library])
-AC_HELP_STRING([--disable-hidden-symbols],[Leave all symbols with default visibility in library]),
-[ case "$enableval" in
-  no)
-       AC_MSG_RESULT(no)
-       ;;
-  *)
-       AC_MSG_CHECKING([whether $CC supports it])
-       if test "$GCC" = yes ; then
-         if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
-           AC_MSG_RESULT(yes)
-           AC_DEFINE(LIBSSH2_API, [__attribute__ ((visibility ("default")))], [to make a symbol visible])
-           CFLAGS="$CFLAGS -fvisibility=hidden"
-         else
-            AC_MSG_RESULT(no)
-          fi
-
-       else
-         dnl Test for SunPro cc
-         if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
-           AC_MSG_RESULT(yes)
-           AC_DEFINE(LIBSSH2_API, [__global], [to make a symbol visible])
-           CFLAGS="$CFLAGS -xldscope=hidden"
-         else
-           AC_MSG_RESULT(no)
-         fi
-       fi
-       ;;
-  esac ],
-       AC_MSG_RESULT(no)
-)
-
-# Build example applications?
-AC_MSG_CHECKING([whether to build example applications])
-AC_ARG_ENABLE([examples-build],
-AC_HELP_STRING([--enable-examples-build], [Build example applications (this is the default)])
-AC_HELP_STRING([--disable-examples-build], [Do not build example applications]),
-[case "$enableval" in
-  no | false)
-    build_examples='no'
-    ;;
-  *)
-    build_examples='yes'
-    ;;
-esac], [build_examples='yes'])
-AC_MSG_RESULT($build_examples)
-AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$build_examples" != "xno"])
-
-
-# Build OSS fuzzing targets?
-AC_ARG_ENABLE([ossfuzzers],
-  [AS_HELP_STRING([--enable-ossfuzzers],
-    [Whether to generate the fuzzers for OSS-Fuzz])],
-  [have_ossfuzzers=yes], [have_ossfuzzers=no])
-AM_CONDITIONAL([USE_OSSFUZZERS], [test "x$have_ossfuzzers" = "xyes"])
-
-
-# Set the correct flags for the given fuzzing engine.
-AC_SUBST([LIB_FUZZING_ENGINE])
-AM_CONDITIONAL([USE_OSSFUZZ_FLAG], [test "x$LIB_FUZZING_ENGINE" = "x-fsanitize=fuzzer"])
-AM_CONDITIONAL([USE_OSSFUZZ_STATIC], [test -f "$LIB_FUZZING_ENGINE"])
-
-
-# Checks for header files.
-# AC_HEADER_STDC
-AC_CHECK_HEADERS([errno.h fcntl.h stdio.h stdlib.h unistd.h sys/uio.h])
-AC_CHECK_HEADERS([sys/select.h sys/socket.h sys/ioctl.h sys/time.h])
-AC_CHECK_HEADERS([arpa/inet.h netinet/in.h])
-AC_CHECK_HEADERS([sys/un.h], [have_sys_un_h=yes], [have_sys_un_h=no])
-AM_CONDITIONAL([HAVE_SYS_UN_H], test "x$have_sys_un_h" = xyes)
-
-case $host in
-  *-*-cygwin* | *-*-cegcc*)
-    # These are POSIX-like systems using BSD-like sockets API.
-    ;;
-  *)
-    AC_CHECK_HEADERS([windows.h winsock2.h ws2tcpip.h])
-    ;;
-esac
-
-case $host in
-  *darwin*|*interix*)
-    dnl poll() does not work on these platforms
-    dnl Interix: "does provide poll(), but the implementing developer must
-    dnl have been in a bad mood, because poll() only works on the /proc
-    dnl filesystem here"
-    dnl Mac OS X's poll has funny behaviors, like:
-    dnl not being able to do poll on no fildescriptors (10.3?)
-    dnl not being able to poll on some files (like anything in /dev)
-    dnl not having reliable timeout support
-    dnl inconsistent return of POLLHUP where other implementations give POLLIN
-    AC_MSG_NOTICE([poll use is disabled on this platform])
-    ;;
-  *)
-    AC_CHECK_FUNCS(poll)
-    ;;
-esac
-
-AC_CHECK_FUNCS(gettimeofday select strtoll memset_s)
-
-dnl Check for select() into ws2_32 for Msys/Mingw
-if test "$ac_cv_func_select" != "yes"; then
-  AC_MSG_CHECKING([for select in ws2_32])
-  AC_TRY_LINK([
-#ifdef HAVE_WINSOCK2_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <winsock2.h>
-#endif
-    ],[
-      select(0,(fd_set *)NULL,(fd_set *)NULL,(fd_set *)NULL,(struct timeval *)NULL);
-    ],[
-      AC_MSG_RESULT([yes])
-      HAVE_SELECT="1"
-      AC_DEFINE_UNQUOTED(HAVE_SELECT, 1,
-        [Define to 1 if you have the select function.])
-    ],[
-      AC_MSG_RESULT([no])
-  ])
-fi
-
-AC_FUNC_ALLOCA
-
-# Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_C_INLINE
-
-CURL_CHECK_NONBLOCKING_SOCKET
-
-missing_required_deps=0
-
-if test "${libz_errors}" != ""; then
-  AS_MESSAGE([ERROR: ${libz_errors}])
-  missing_required_deps=1
-fi
-
-if test "$found_crypto" = "none"; then
-  AS_MESSAGE([ERROR: ${crypto_errors}])
-  missing_required_deps=1
-fi
-
-if test $missing_required_deps = 1; then
-  AC_MSG_ERROR([Required dependencies are missing!])
-fi
-
-# Configure parameters
-LIBSSH2_CHECK_OPTION_WERROR
-
-AC_CONFIG_FILES([Makefile
-                 src/Makefile
-                 tests/Makefile
-                 tests/ossfuzz/Makefile
-                 example/Makefile
-                 docs/Makefile
-                 libssh2.pc])
-AC_OUTPUT
-
-AC_MSG_NOTICE([summary of build options:
-
-  version:          ${LIBSSH2VER}
-  Host type:        ${host}
-  Install prefix:   ${prefix}
-  Compiler:         ${CC}
-  Compiler flags:   ${CFLAGS}
-  Library types:    Shared=${enable_shared}, Static=${enable_static}
-  Crypto library:   ${found_crypto_str}
-  Clear memory:     $enable_clear_memory
-  Debug build:      $enable_debug
-  Build examples:   $build_examples
-  Path to sshd:     $ac_cv_path_SSHD (only for self-tests)
-  zlib compression: ${found_libz}
-])
diff --git a/libssh2/libssh2/depcomp b/libssh2/libssh2/depcomp
deleted file mode 100755
index 6b391623..00000000
--- a/libssh2/libssh2/depcomp
+++ /dev/null
@@ -1,791 +0,0 @@
-#! /bin/sh
-# depcomp - compile a program generating dependencies as side-effects
-
-scriptversion=2018-03-07.03; # UTC
-
-# Copyright (C) 1999-2020 Free Software Foundation, Inc.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
-
-case $1 in
-  '')
-    echo "$0: No command.  Try '$0 --help' for more information." 1>&2
-    exit 1;
-    ;;
-  -h | --h*)
-    cat <<\EOF
-Usage: depcomp [--help] [--version] PROGRAM [ARGS]
-
-Run PROGRAMS ARGS to compile a file, generating dependencies
-as side-effects.
-
-Environment variables:
-  depmode     Dependency tracking mode.
-  source      Source file read by 'PROGRAMS ARGS'.
-  object      Object file output by 'PROGRAMS ARGS'.
-  DEPDIR      directory where to store dependencies.
-  depfile     Dependency file to output.
-  tmpdepfile  Temporary file to use when outputting dependencies.
-  libtool     Whether libtool is used (yes/no).
-
-Report bugs to <bug-automake@gnu.org>.
-EOF
-    exit $?
-    ;;
-  -v | --v*)
-    echo "depcomp $scriptversion"
-    exit $?
-    ;;
-esac
-
-# Get the directory component of the given path, and save it in the
-# global variables '$dir'.  Note that this directory component will
-# be either empty or ending with a '/' character.  This is deliberate.
-set_dir_from ()
-{
-  case $1 in
-    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
-      *) dir=;;
-  esac
-}
-
-# Get the suffix-stripped basename of the given path, and save it the
-# global variable '$base'.
-set_base_from ()
-{
-  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
-}
-
-# If no dependency file was actually created by the compiler invocation,
-# we still have to create a dummy depfile, to avoid errors with the
-# Makefile "include basename.Plo" scheme.
-make_dummy_depfile ()
-{
-  echo "#dummy" > "$depfile"
-}
-
-# Factor out some common post-processing of the generated depfile.
-# Requires the auxiliary global variable '$tmpdepfile' to be set.
-aix_post_process_depfile ()
-{
-  # If the compiler actually managed to produce a dependency file,
-  # post-process it.
-  if test -f "$tmpdepfile"; then
-    # Each line is of the form 'foo.o: dependency.h'.
-    # Do two passes, one to just change these to
-    #   $object: dependency.h
-    # and one to simply output
-    #   dependency.h:
-    # which is needed to avoid the deleted-header problem.
-    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
-      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
-    } > "$depfile"
-    rm -f "$tmpdepfile"
-  else
-    make_dummy_depfile
-  fi
-}
-
-# A tabulation character.
-tab='	'
-# A newline character.
-nl='
-'
-# Character ranges might be problematic outside the C locale.
-# These definitions help.
-upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
-lower=abcdefghijklmnopqrstuvwxyz
-digits=0123456789
-alpha=${upper}${lower}
-
-if test -z "$depmode" || test -z "$source" || test -z "$object"; then
-  echo "depcomp: Variables source, object and depmode must be set" 1>&2
-  exit 1
-fi
-
-# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
-depfile=${depfile-`echo "$object" |
-  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
-tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
-
-rm -f "$tmpdepfile"
-
-# Avoid interferences from the environment.
-gccflag= dashmflag=
-
-# Some modes work just like other modes, but use different flags.  We
-# parameterize here, but still list the modes in the big case below,
-# to make depend.m4 easier to write.  Note that we *cannot* use a case
-# here, because this file can only contain one case statement.
-if test "$depmode" = hp; then
-  # HP compiler uses -M and no extra arg.
-  gccflag=-M
-  depmode=gcc
-fi
-
-if test "$depmode" = dashXmstdout; then
-  # This is just like dashmstdout with a different argument.
-  dashmflag=-xM
-  depmode=dashmstdout
-fi
-
-cygpath_u="cygpath -u -f -"
-if test "$depmode" = msvcmsys; then
-  # This is just like msvisualcpp but w/o cygpath translation.
-  # Just convert the backslash-escaped backslashes to single forward
-  # slashes to satisfy depend.m4
-  cygpath_u='sed s,\\\\,/,g'
-  depmode=msvisualcpp
-fi
-
-if test "$depmode" = msvc7msys; then
-  # This is just like msvc7 but w/o cygpath translation.
-  # Just convert the backslash-escaped backslashes to single forward
-  # slashes to satisfy depend.m4
-  cygpath_u='sed s,\\\\,/,g'
-  depmode=msvc7
-fi
-
-if test "$depmode" = xlc; then
-  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
-  gccflag=-qmakedep=gcc,-MF
-  depmode=gcc
-fi
-
-case "$depmode" in
-gcc3)
-## gcc 3 implements dependency tracking that does exactly what
-## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
-## it if -MD -MP comes after the -MF stuff.  Hmm.
-## Unfortunately, FreeBSD c89 acceptance of flags depends upon
-## the command line argument order; so add the flags where they
-## appear in depend2.am.  Note that the slowdown incurred here
-## affects only configure: in makefiles, %FASTDEP% shortcuts this.
-  for arg
-  do
-    case $arg in
-    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
-    *)  set fnord "$@" "$arg" ;;
-    esac
-    shift # fnord
-    shift # $arg
-  done
-  "$@"
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  mv "$tmpdepfile" "$depfile"
-  ;;
-
-gcc)
-## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
-## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
-## (see the conditional assignment to $gccflag above).
-## There are various ways to get dependency output from gcc.  Here's
-## why we pick this rather obscure method:
-## - Don't want to use -MD because we'd like the dependencies to end
-##   up in a subdir.  Having to rename by hand is ugly.
-##   (We might end up doing this anyway to support other compilers.)
-## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
-##   -MM, not -M (despite what the docs say).  Also, it might not be
-##   supported by the other compilers which use the 'gcc' depmode.
-## - Using -M directly means running the compiler twice (even worse
-##   than renaming).
-  if test -z "$gccflag"; then
-    gccflag=-MD,
-  fi
-  "$@" -Wp,"$gccflag$tmpdepfile"
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  # The second -e expression handles DOS-style file names with drive
-  # letters.
-  sed -e 's/^[^:]*: / /' \
-      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
-## This next piece of magic avoids the "deleted header file" problem.
-## The problem is that when a header file which appears in a .P file
-## is deleted, the dependency causes make to die (because there is
-## typically no way to rebuild the header).  We avoid this by adding
-## dummy dependencies for each header file.  Too bad gcc doesn't do
-## this for us directly.
-## Some versions of gcc put a space before the ':'.  On the theory
-## that the space means something, we add a space to the output as
-## well.  hp depmode also adds that space, but also prefixes the VPATH
-## to the object.  Take care to not repeat it in the output.
-## Some versions of the HPUX 10.20 sed can't process this invocation
-## correctly.  Breaking it into two sed invocations is a workaround.
-  tr ' ' "$nl" < "$tmpdepfile" \
-    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
-    | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-hp)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-sgi)
-  if test "$libtool" = yes; then
-    "$@" "-Wp,-MDupdate,$tmpdepfile"
-  else
-    "$@" -MDupdate "$tmpdepfile"
-  fi
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-
-  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
-    echo "$object : \\" > "$depfile"
-    # Clip off the initial element (the dependent).  Don't try to be
-    # clever and replace this with sed code, as IRIX sed won't handle
-    # lines with more than a fixed number of characters (4096 in
-    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
-    # the IRIX cc adds comments like '#:fec' to the end of the
-    # dependency line.
-    tr ' ' "$nl" < "$tmpdepfile" \
-      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
-      | tr "$nl" ' ' >> "$depfile"
-    echo >> "$depfile"
-    # The second pass generates a dummy entry for each header file.
-    tr ' ' "$nl" < "$tmpdepfile" \
-      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
-      >> "$depfile"
-  else
-    make_dummy_depfile
-  fi
-  rm -f "$tmpdepfile"
-  ;;
-
-xlc)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-aix)
-  # The C for AIX Compiler uses -M and outputs the dependencies
-  # in a .u file.  In older versions, this file always lives in the
-  # current directory.  Also, the AIX compiler puts '$object:' at the
-  # start of each line; $object doesn't have directory information.
-  # Version 6 uses the directory in both cases.
-  set_dir_from "$object"
-  set_base_from "$object"
-  if test "$libtool" = yes; then
-    tmpdepfile1=$dir$base.u
-    tmpdepfile2=$base.u
-    tmpdepfile3=$dir.libs/$base.u
-    "$@" -Wc,-M
-  else
-    tmpdepfile1=$dir$base.u
-    tmpdepfile2=$dir$base.u
-    tmpdepfile3=$dir$base.u
-    "$@" -M
-  fi
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-    exit $stat
-  fi
-
-  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-  do
-    test -f "$tmpdepfile" && break
-  done
-  aix_post_process_depfile
-  ;;
-
-tcc)
-  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
-  # FIXME: That version still under development at the moment of writing.
-  #        Make that this statement remains true also for stable, released
-  #        versions.
-  # It will wrap lines (doesn't matter whether long or short) with a
-  # trailing '\', as in:
-  #
-  #   foo.o : \
-  #    foo.c \
-  #    foo.h \
-  #
-  # It will put a trailing '\' even on the last line, and will use leading
-  # spaces rather than leading tabs (at least since its commit 0394caf7
-  # "Emit spaces for -MD").
-  "$@" -MD -MF "$tmpdepfile"
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
-  # We have to change lines of the first kind to '$object: \'.
-  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
-  # And for each line of the second kind, we have to emit a 'dep.h:'
-  # dummy dependency, to avoid the deleted-header problem.
-  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-## The order of this option in the case statement is important, since the
-## shell code in configure will try each of these formats in the order
-## listed in this file.  A plain '-MD' option would be understood by many
-## compilers, so we must ensure this comes after the gcc and icc options.
-pgcc)
-  # Portland's C compiler understands '-MD'.
-  # Will always output deps to 'file.d' where file is the root name of the
-  # source file under compilation, even if file resides in a subdirectory.
-  # The object file name does not affect the name of the '.d' file.
-  # pgcc 10.2 will output
-  #    foo.o: sub/foo.c sub/foo.h
-  # and will wrap long lines using '\' :
-  #    foo.o: sub/foo.c ... \
-  #     sub/foo.h ... \
-  #     ...
-  set_dir_from "$object"
-  # Use the source, not the object, to determine the base name, since
-  # that's sadly what pgcc will do too.
-  set_base_from "$source"
-  tmpdepfile=$base.d
-
-  # For projects that build the same source file twice into different object
-  # files, the pgcc approach of using the *source* file root name can cause
-  # problems in parallel builds.  Use a locking strategy to avoid stomping on
-  # the same $tmpdepfile.
-  lockdir=$base.d-lock
-  trap "
-    echo '$0: caught signal, cleaning up...' >&2
-    rmdir '$lockdir'
-    exit 1
-  " 1 2 13 15
-  numtries=100
-  i=$numtries
-  while test $i -gt 0; do
-    # mkdir is a portable test-and-set.
-    if mkdir "$lockdir" 2>/dev/null; then
-      # This process acquired the lock.
-      "$@" -MD
-      stat=$?
-      # Release the lock.
-      rmdir "$lockdir"
-      break
-    else
-      # If the lock is being held by a different process, wait
-      # until the winning process is done or we timeout.
-      while test -d "$lockdir" && test $i -gt 0; do
-        sleep 1
-        i=`expr $i - 1`
-      done
-    fi
-    i=`expr $i - 1`
-  done
-  trap - 1 2 13 15
-  if test $i -le 0; then
-    echo "$0: failed to acquire lock after $numtries attempts" >&2
-    echo "$0: check lockdir '$lockdir'" >&2
-    exit 1
-  fi
-
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  # Each line is of the form `foo.o: dependent.h',
-  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
-  # Do two passes, one to just change these to
-  # `$object: dependent.h' and one to simply `dependent.h:'.
-  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
-  # Some versions of the HPUX 10.20 sed can't process this invocation
-  # correctly.  Breaking it into two sed invocations is a workaround.
-  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
-    | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-hp2)
-  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
-  # compilers, which have integrated preprocessors.  The correct option
-  # to use with these is +Maked; it writes dependencies to a file named
-  # 'foo.d', which lands next to the object file, wherever that
-  # happens to be.
-  # Much of this is similar to the tru64 case; see comments there.
-  set_dir_from  "$object"
-  set_base_from "$object"
-  if test "$libtool" = yes; then
-    tmpdepfile1=$dir$base.d
-    tmpdepfile2=$dir.libs/$base.d
-    "$@" -Wc,+Maked
-  else
-    tmpdepfile1=$dir$base.d
-    tmpdepfile2=$dir$base.d
-    "$@" +Maked
-  fi
-  stat=$?
-  if test $stat -ne 0; then
-     rm -f "$tmpdepfile1" "$tmpdepfile2"
-     exit $stat
-  fi
-
-  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
-  do
-    test -f "$tmpdepfile" && break
-  done
-  if test -f "$tmpdepfile"; then
-    sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
-    # Add 'dependent.h:' lines.
-    sed -ne '2,${
-               s/^ *//
-               s/ \\*$//
-               s/$/:/
-               p
-             }' "$tmpdepfile" >> "$depfile"
-  else
-    make_dummy_depfile
-  fi
-  rm -f "$tmpdepfile" "$tmpdepfile2"
-  ;;
-
-tru64)
-  # The Tru64 compiler uses -MD to generate dependencies as a side
-  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
-  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
-  # dependencies in 'foo.d' instead, so we check for that too.
-  # Subdirectories are respected.
-  set_dir_from  "$object"
-  set_base_from "$object"
-
-  if test "$libtool" = yes; then
-    # Libtool generates 2 separate objects for the 2 libraries.  These
-    # two compilations output dependencies in $dir.libs/$base.o.d and
-    # in $dir$base.o.d.  We have to check for both files, because
-    # one of the two compilations can be disabled.  We should prefer
-    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
-    # automatically cleaned when .libs/ is deleted, while ignoring
-    # the former would cause a distcleancheck panic.
-    tmpdepfile1=$dir$base.o.d          # libtool 1.5
-    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
-    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
-    "$@" -Wc,-MD
-  else
-    tmpdepfile1=$dir$base.d
-    tmpdepfile2=$dir$base.d
-    tmpdepfile3=$dir$base.d
-    "$@" -MD
-  fi
-
-  stat=$?
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-    exit $stat
-  fi
-
-  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
-  do
-    test -f "$tmpdepfile" && break
-  done
-  # Same post-processing that is required for AIX mode.
-  aix_post_process_depfile
-  ;;
-
-msvc7)
-  if test "$libtool" = yes; then
-    showIncludes=-Wc,-showIncludes
-  else
-    showIncludes=-showIncludes
-  fi
-  "$@" $showIncludes > "$tmpdepfile"
-  stat=$?
-  grep -v '^Note: including file: ' "$tmpdepfile"
-  if test $stat -ne 0; then
-    rm -f "$tmpdepfile"
-    exit $stat
-  fi
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  # The first sed program below extracts the file names and escapes
-  # backslashes for cygpath.  The second sed program outputs the file
-  # name when reading, but also accumulates all include files in the
-  # hold buffer in order to output them again at the end.  This only
-  # works with sed implementations that can handle large buffers.
-  sed < "$tmpdepfile" -n '
-/^Note: including file:  *\(.*\)/ {
-  s//\1/
-  s/\\/\\\\/g
-  p
-}' | $cygpath_u | sort -u | sed -n '
-s/ /\\ /g
-s/\(.*\)/'"$tab"'\1 \\/p
-s/.\(.*\) \\/\1:/
-H
-$ {
-  s/.*/'"$tab"'/
-  G
-  p
-}' >> "$depfile"
-  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
-  rm -f "$tmpdepfile"
-  ;;
-
-msvc7msys)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-#nosideeffect)
-  # This comment above is used by automake to tell side-effect
-  # dependency tracking mechanisms from slower ones.
-
-dashmstdout)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout, regardless of -o.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  # Remove '-o $object'.
-  IFS=" "
-  for arg
-  do
-    case $arg in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    *)
-      set fnord "$@" "$arg"
-      shift # fnord
-      shift # $arg
-      ;;
-    esac
-  done
-
-  test -z "$dashmflag" && dashmflag=-M
-  # Require at least two characters before searching for ':'
-  # in the target name.  This is to cope with DOS-style filenames:
-  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
-  "$@" $dashmflag |
-    sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
-  rm -f "$depfile"
-  cat < "$tmpdepfile" > "$depfile"
-  # Some versions of the HPUX 10.20 sed can't process this sed invocation
-  # correctly.  Breaking it into two sed invocations is a workaround.
-  tr ' ' "$nl" < "$tmpdepfile" \
-    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
-    | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-dashXmstdout)
-  # This case only exists to satisfy depend.m4.  It is never actually
-  # run, as this mode is specially recognized in the preamble.
-  exit 1
-  ;;
-
-makedepend)
-  "$@" || exit $?
-  # Remove any Libtool call
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-  # X makedepend
-  shift
-  cleared=no eat=no
-  for arg
-  do
-    case $cleared in
-    no)
-      set ""; shift
-      cleared=yes ;;
-    esac
-    if test $eat = yes; then
-      eat=no
-      continue
-    fi
-    case "$arg" in
-    -D*|-I*)
-      set fnord "$@" "$arg"; shift ;;
-    # Strip any option that makedepend may not understand.  Remove
-    # the object too, otherwise makedepend will parse it as a source file.
-    -arch)
-      eat=yes ;;
-    -*|$object)
-      ;;
-    *)
-      set fnord "$@" "$arg"; shift ;;
-    esac
-  done
-  obj_suffix=`echo "$object" | sed 's/^.*\././'`
-  touch "$tmpdepfile"
-  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
-  rm -f "$depfile"
-  # makedepend may prepend the VPATH from the source file name to the object.
-  # No need to regex-escape $object, excess matching of '.' is harmless.
-  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
-  # Some versions of the HPUX 10.20 sed can't process the last invocation
-  # correctly.  Breaking it into two sed invocations is a workaround.
-  sed '1,2d' "$tmpdepfile" \
-    | tr ' ' "$nl" \
-    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
-    | sed -e 's/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile" "$tmpdepfile".bak
-  ;;
-
-cpp)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  # Remove '-o $object'.
-  IFS=" "
-  for arg
-  do
-    case $arg in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    *)
-      set fnord "$@" "$arg"
-      shift # fnord
-      shift # $arg
-      ;;
-    esac
-  done
-
-  "$@" -E \
-    | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-             -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-    | sed '$ s: \\$::' > "$tmpdepfile"
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  cat < "$tmpdepfile" >> "$depfile"
-  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-msvisualcpp)
-  # Important note: in order to support this mode, a compiler *must*
-  # always write the preprocessed file to stdout.
-  "$@" || exit $?
-
-  # Remove the call to Libtool.
-  if test "$libtool" = yes; then
-    while test "X$1" != 'X--mode=compile'; do
-      shift
-    done
-    shift
-  fi
-
-  IFS=" "
-  for arg
-  do
-    case "$arg" in
-    -o)
-      shift
-      ;;
-    $object)
-      shift
-      ;;
-    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
-        set fnord "$@"
-        shift
-        shift
-        ;;
-    *)
-        set fnord "$@" "$arg"
-        shift
-        shift
-        ;;
-    esac
-  done
-  "$@" -E 2>/dev/null |
-  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
-  rm -f "$depfile"
-  echo "$object : \\" > "$depfile"
-  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
-  echo "$tab" >> "$depfile"
-  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
-  rm -f "$tmpdepfile"
-  ;;
-
-msvcmsys)
-  # This case exists only to let depend.m4 do its work.  It works by
-  # looking at the text of this script.  This case will never be run,
-  # since it is checked for above.
-  exit 1
-  ;;
-
-none)
-  exec "$@"
-  ;;
-
-*)
-  echo "Unknown depmode $depmode" 1>&2
-  exit 1
-  ;;
-esac
-
-exit 0
-
-# Local Variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/libssh2/libssh2/docs/AUTHORS b/libssh2/libssh2/docs/AUTHORS
deleted file mode 100644
index 5c7445bf..00000000
--- a/libssh2/libssh2/docs/AUTHORS
+++ /dev/null
@@ -1,79 +0,0 @@
- libssh2 is the result of many friendly people. This list is an attempt to
- mention all contributors. If we've missed anyone, tell us!
-
- This list of names is a-z sorted.
-
-Adam Gobiowski
-Alexander Holyapin
-Alexander Lamaison
-Alfred Gebert
-Ben Kibbey
-Bjorn Stenborg
-Carlo Bramini
-Cristian Rodríguez
-Daiki Ueno
-Dan Casey
-Dan Fandrich
-Daniel Stenberg
-Dave Hayden
-Dave McCaldon
-David J Sullivan
-David Robins
-Dmitry Smirnov
-Douglas Masterson
-Edink Kadribasic
-Erik Brossler
-Francois Dupoux
-Gellule Xg
-Grubsky Grigory
-Guenter Knauf
-Heiner Steven
-Henrik Nordstrom
-James Housleys
-Jasmeet Bagga
-Jean-Louis Charton
-Jernej Kovacic
-Joey Degges
-John Little
-Jose Baars
-Jussi Mononen
-Kamil Dudka
-Lars Nordin
-Mark McPherson
-Mark Smith
-Markus Moeller
-Matt Lilley
-Matthew Booth
-Maxime Larocque
-Mike Protts
-Mikhail Gusarov
-Neil Gierman
-Olivier Hervieu
-Paul Howarth
-Paul Querna
-Paul Veldkamp
-Peter Krempa
-Peter O'Gorman
-Peter Stuge
-Pierre Joye
-Rafael Kitover
-Romain Bondue
-Sara Golemon
-Satish Mittal
-Sean Peterson
-Selcuk Gueney
-Simon Hart
-Simon Josefsson
-Sofian Brabez
-Steven Ayre
-Steven Dake
-Steven Van Ingelgem
-TJ Saunders
-Tommy Lindgren
-Tor Arntsen
-Vincent Jaulin
-Vincent Torri
-Vlad Grachov
-Wez Furlong
-Yang Tse
-Zl Liu
diff --git a/libssh2/libssh2/docs/BINDINGS b/libssh2/libssh2/docs/BINDINGS
deleted file mode 100644
index 471f9be8..00000000
--- a/libssh2/libssh2/docs/BINDINGS
+++ /dev/null
@@ -1,29 +0,0 @@
-
-Creative people have written bindings or interfaces for various environments
-and programming languages. Using one of these bindings allows you to take
-advantage of libssh2 directly from within your favourite language.
-
-The bindings listed below are not part of the libssh2 distribution archives,
-but must be downloaded and installed separately.
-
-Cocoa/Objective-C
-  https://github.com/karelia/libssh2_sftp-Cocoa-wrapper
-
-Haskell
-  FFI bindings - https://hackage.haskell.org/package/libssh2
-
-Perl
-  Net::SSH2 - https://metacpan.org/pod/Net::SSH2
-
-PHP
-  ssh2 - https://pecl.php.net/package/ssh2
-
-Python
-  pylibssh2 - https://pypi.python.org/pypi/pylibssh2
-
-Python-ctypes
-
-  PySsh2 - https://github.com/gellule/PySsh2
-
-Ruby
-  libssh2-ruby - https://github.com/mitchellh/libssh2-ruby
diff --git a/libssh2/libssh2/docs/CMakeLists.txt b/libssh2/libssh2/docs/CMakeLists.txt
deleted file mode 100644
index 6abf0e49..00000000
--- a/libssh2/libssh2/docs/CMakeLists.txt
+++ /dev/null
@@ -1,210 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-set(MAN_PAGES
-  libssh2_agent_connect.3
-  libssh2_agent_disconnect.3
-  libssh2_agent_free.3
-  libssh2_agent_get_identity.3
-  libssh2_agent_get_identity_path.3
-  libssh2_agent_init.3
-  libssh2_agent_list_identities.3
-  libssh2_agent_set_identity_path.3
-  libssh2_agent_userauth.3
-  libssh2_banner_set.3
-  libssh2_base64_decode.3
-  libssh2_channel_close.3
-  libssh2_channel_direct_tcpip.3
-  libssh2_channel_direct_tcpip_ex.3
-  libssh2_channel_eof.3
-  libssh2_channel_exec.3
-  libssh2_channel_flush.3
-  libssh2_channel_flush_ex.3
-  libssh2_channel_flush_stderr.3
-  libssh2_channel_forward_accept.3
-  libssh2_channel_forward_cancel.3
-  libssh2_channel_forward_listen.3
-  libssh2_channel_forward_listen_ex.3
-  libssh2_channel_free.3
-  libssh2_channel_get_exit_signal.3
-  libssh2_channel_get_exit_status.3
-  libssh2_channel_handle_extended_data.3
-  libssh2_channel_handle_extended_data2.3
-  libssh2_channel_ignore_extended_data.3
-  libssh2_channel_open_ex.3
-  libssh2_channel_open_session.3
-  libssh2_channel_process_startup.3
-  libssh2_channel_read.3
-  libssh2_channel_read_ex.3
-  libssh2_channel_read_stderr.3
-  libssh2_channel_receive_window_adjust.3
-  libssh2_channel_receive_window_adjust2.3
-  libssh2_channel_request_pty.3
-  libssh2_channel_request_pty_ex.3
-  libssh2_channel_request_pty_size.3
-  libssh2_channel_request_pty_size_ex.3
-  libssh2_channel_send_eof.3
-  libssh2_channel_set_blocking.3
-  libssh2_channel_setenv.3
-  libssh2_channel_setenv_ex.3
-  libssh2_channel_shell.3
-  libssh2_channel_subsystem.3
-  libssh2_channel_wait_closed.3
-  libssh2_channel_wait_eof.3
-  libssh2_channel_window_read.3
-  libssh2_channel_window_read_ex.3
-  libssh2_channel_window_write.3
-  libssh2_channel_window_write_ex.3
-  libssh2_channel_write.3
-  libssh2_channel_write_ex.3
-  libssh2_channel_write_stderr.3
-  libssh2_channel_x11_req.3
-  libssh2_channel_x11_req_ex.3
-  libssh2_exit.3
-  libssh2_free.3
-  libssh2_hostkey_hash.3
-  libssh2_init.3
-  libssh2_keepalive_config.3
-  libssh2_keepalive_send.3
-  libssh2_knownhost_add.3
-  libssh2_knownhost_addc.3
-  libssh2_knownhost_check.3
-  libssh2_knownhost_checkp.3
-  libssh2_knownhost_del.3
-  libssh2_knownhost_free.3
-  libssh2_knownhost_get.3
-  libssh2_knownhost_init.3
-  libssh2_knownhost_readfile.3
-  libssh2_knownhost_readline.3
-  libssh2_knownhost_writefile.3
-  libssh2_knownhost_writeline.3
-  libssh2_poll.3
-  libssh2_poll_channel_read.3
-  libssh2_publickey_add.3
-  libssh2_publickey_add_ex.3
-  libssh2_publickey_init.3
-  libssh2_publickey_list_fetch.3
-  libssh2_publickey_list_free.3
-  libssh2_publickey_remove.3
-  libssh2_publickey_remove_ex.3
-  libssh2_publickey_shutdown.3
-  libssh2_scp_recv.3
-  libssh2_scp_recv2.3
-  libssh2_scp_send.3
-  libssh2_scp_send64.3
-  libssh2_scp_send_ex.3
-  libssh2_session_abstract.3
-  libssh2_session_banner_get.3
-  libssh2_session_banner_set.3
-  libssh2_session_block_directions.3
-  libssh2_session_callback_set.3
-  libssh2_session_disconnect.3
-  libssh2_session_disconnect_ex.3
-  libssh2_session_flag.3
-  libssh2_session_free.3
-  libssh2_session_get_blocking.3
-  libssh2_session_get_timeout.3
-  libssh2_session_handshake.3
-  libssh2_session_hostkey.3
-  libssh2_session_init.3
-  libssh2_session_init_ex.3
-  libssh2_session_last_errno.3
-  libssh2_session_last_error.3
-  libssh2_session_set_last_error.3
-  libssh2_session_method_pref.3
-  libssh2_session_methods.3
-  libssh2_session_set_blocking.3
-  libssh2_session_set_timeout.3
-  libssh2_session_startup.3
-  libssh2_session_supported_algs.3
-  libssh2_sftp_close.3
-  libssh2_sftp_close_handle.3
-  libssh2_sftp_closedir.3
-  libssh2_sftp_fsetstat.3
-  libssh2_sftp_fstat.3
-  libssh2_sftp_fstat_ex.3
-  libssh2_sftp_fstatvfs.3
-  libssh2_sftp_fsync.3
-  libssh2_sftp_get_channel.3
-  libssh2_sftp_init.3
-  libssh2_sftp_last_error.3
-  libssh2_sftp_lstat.3
-  libssh2_sftp_mkdir.3
-  libssh2_sftp_mkdir_ex.3
-  libssh2_sftp_open.3
-  libssh2_sftp_open_ex.3
-  libssh2_sftp_opendir.3
-  libssh2_sftp_read.3
-  libssh2_sftp_readdir.3
-  libssh2_sftp_readdir_ex.3
-  libssh2_sftp_readlink.3
-  libssh2_sftp_realpath.3
-  libssh2_sftp_rename.3
-  libssh2_sftp_rename_ex.3
-  libssh2_sftp_rewind.3
-  libssh2_sftp_rmdir.3
-  libssh2_sftp_rmdir_ex.3
-  libssh2_sftp_seek.3
-  libssh2_sftp_seek64.3
-  libssh2_sftp_setstat.3
-  libssh2_sftp_shutdown.3
-  libssh2_sftp_stat.3
-  libssh2_sftp_stat_ex.3
-  libssh2_sftp_statvfs.3
-  libssh2_sftp_symlink.3
-  libssh2_sftp_symlink_ex.3
-  libssh2_sftp_tell.3
-  libssh2_sftp_tell64.3
-  libssh2_sftp_unlink.3
-  libssh2_sftp_unlink_ex.3
-  libssh2_sftp_write.3
-  libssh2_trace.3
-  libssh2_trace_sethandler.3
-  libssh2_userauth_authenticated.3
-  libssh2_userauth_hostbased_fromfile.3
-  libssh2_userauth_hostbased_fromfile_ex.3
-  libssh2_userauth_keyboard_interactive.3
-  libssh2_userauth_keyboard_interactive_ex.3
-  libssh2_userauth_list.3
-  libssh2_userauth_password.3
-  libssh2_userauth_password_ex.3
-  libssh2_userauth_publickey.3
-  libssh2_userauth_publickey_fromfile.3
-  libssh2_userauth_publickey_fromfile_ex.3
-  libssh2_userauth_publickey_frommemory.3
-  libssh2_version.3)
-
-include(GNUInstallDirs)
-install(FILES ${MAN_PAGES} DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
diff --git a/libssh2/libssh2/docs/HACKING b/libssh2/libssh2/docs/HACKING
deleted file mode 100644
index 5da8e66c..00000000
--- a/libssh2/libssh2/docs/HACKING
+++ /dev/null
@@ -1,13 +0,0 @@
-
-libssh2 source code style guide:
-
- - 4 level indent
- - spaces-only (no tabs)
- - open braces on the if/for line:
-
-     if (banana) {
-         go_nuts();
-     }
-
- - keep source lines shorter than 80 columns
- - See libssh2-style.el for how to achieve this within Emacs
diff --git a/libssh2/libssh2/docs/HACKING-CRYPTO b/libssh2/libssh2/docs/HACKING-CRYPTO
deleted file mode 100644
index ca947728..00000000
--- a/libssh2/libssh2/docs/HACKING-CRYPTO
+++ /dev/null
@@ -1,902 +0,0 @@
-    Definitions needed to implement a specific crypto library
-
-This document offers some hints about implementing a new crypto library
-interface.
-
-A crypto library interface consists of at least a header file, defining
-entities referenced from the libssh2 core modules.
-Real code implementation (if needed), is left at the implementor's choice.
-
-This document lists the entities that must/may be defined in the header file.
-
-Procedures listed as "void" may indeed have a result type: the void indication
-indicates the libssh2 core modules never use the function result.
-
-
-0) Build system.
-
-Adding a crypto backend to the autotools build system (./configure) is easy:
-
-0.1) Add one new line in configure.ac
-
-m4_set_add([crypto_backends], [newname])
-
-This automatically creates a --with-crypto=newname option.
-
-0.2) Add an m4_case stanza to LIBSSH2_CRYPTO_CHECK in acinclude.m4
-
-This must check for all required libraries, and if found set and AC_SUBST a
-variable with the library linking flags. The recommended method is to use
-LIBSSH2_LIB_HAVE_LINKFLAGS from LIBSSH2_CRYPTO_CHECK, which automatically
-creates and handles a --with-$newname-prefix option and sets an
-LTLIBNEWNAME variable on success.
-
-0.3) Create Makefile.newname.inc in the top-level directory
-
-This must set CRYPTO_CSOURCES, CRYPTO_HHEADERS and CRYPTO_LTLIBS.
-Set CRYPTO_CSOURCES and CRYPTO_HHEADERS to the new backend source files
-and set CRYPTO_LTLIBS to the required library linking parameters, e.g.
-$(LTLIBNEWNAME) as generated by by LIBSSH2_LIB_HAVE_LINKFLAGS.
-
-0.4) Add a new block in src/Makefile.am
-
-if NEWNAME
-include ../Makefile.newname.inc
-endif
-
-
-1) Crypto library initialization/termination.
-
-void libssh2_crypto_init(void);
-Initializes the crypto library. May be an empty macro if not needed.
-
-void libssh2_crypto_exit(void);
-Terminates the crypto library use. May be an empty macro if not needed.
-
-
-2) HMAC
-
-libssh2_hmac_ctx
-Type of an HMAC computation context. Generally a struct.
-Used for all hash algorithms.
-
-void libssh2_hmac_ctx_init(libssh2_hmac_ctx ctx);
-Initializes the HMAC computation context ctx.
-Called before setting-up the hash algorithm.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_hmac_update(libssh2_hmac_ctx ctx,
-                         const unsigned char *data,
-                         int datalen);
-Continue computation of an HMAC on datalen bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_hmac_final(libssh2_hmac_ctx ctx,
-                        unsigned char output[]);
-Get the computed HMAC from context ctx into the output buffer. The
-minimum data buffer size depends on the HMAC hash algorithm.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx);
-Releases the HMAC computation context at ctx.
-
-
-3) Hash algorithms.
-
-3.1) SHA-1
-Must always be implemented.
-
-SHA_DIGEST_LENGTH
-#define to 20, the SHA-1 digest length.
-
-libssh2_sha1_ctx
-Type of an SHA-1 computation context. Generally a struct.
-
-int libssh2_sha1_init(libssh2_sha1_ctx *x);
-Initializes the SHA-1 computation context at x.
-Returns 1 for success and 0 for failure
-
-void libssh2_sha1_update(libssh2_sha1_ctx ctx,
-                         const unsigned char *data,
-                         size_t len);
-Continue computation of SHA-1 on len bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_sha1_final(libssh2_sha1_ctx ctx,
-                        unsigned char output[SHA_DIGEST_LEN]);
-Get the computed SHA-1 signature from context ctx and store it into the
-output buffer.
-Release the context.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
-                            const void *key,
-                            int keylen);
-Setup the HMAC computation context ctx for an HMAC-SHA-1 computation using the
-keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
-
-3.2) SHA-256
-Must always be implemented.
-
-SHA256_DIGEST_LENGTH
-#define to 32, the SHA-256 digest length.
-
-libssh2_sha256_ctx
-Type of an SHA-256 computation context. Generally a struct.
-
-int libssh2_sha256_init(libssh2_sha256_ctx *x);
-Initializes the SHA-256 computation context at x.
-Returns 1 for success and 0 for failure
-
-void libssh2_sha256_update(libssh2_sha256_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
-Continue computation of SHA-256 on len bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_sha256_final(libssh2_sha256_ctx ctx,
-                          unsigned char output[SHA256_DIGEST_LENGTH]);
-Gets the computed SHA-256 signature from context ctx into the output buffer.
-Release the context.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-int libssh2_sha256(const unsigned char *message,
-                   unsigned long len,
-                   unsigned char output[SHA256_DIGEST_LENGTH]);
-Computes the SHA-256 signature over the given message of length len and
-store the result into the output buffer.
-Return 1 if error, else 0.
-Note: Seems unused in current code, but defined in each crypto library backend.
-
-LIBSSH2_HMAC_SHA256
-#define as 1 if the crypto library supports HMAC-SHA-256, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-void libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
-                              const void *key,
-                              int keylen);
-Setup the HMAC computation context ctx for an HMAC-256 computation using the
-keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
-
-3.3) SHA-384
-Mandatory if ECDSA is implemented. Can be omitted otherwise.
-
-SHA384_DIGEST_LENGTH
-#define to 48, the SHA-384 digest length.
-
-libssh2_sha384_ctx
-Type of an SHA-384 computation context. Generally a struct.
-
-int libssh2_sha384_init(libssh2_sha384_ctx *x);
-Initializes the SHA-384 computation context at x.
-Returns 1 for success and 0 for failure
-
-void libssh2_sha384_update(libssh2_sha384_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
-Continue computation of SHA-384 on len bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_sha384_final(libssh2_sha384_ctx ctx,
-                          unsigned char output[SHA384_DIGEST_LENGTH]);
-Gets the computed SHA-384 signature from context ctx into the output buffer.
-Release the context.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-int libssh2_sha384(const unsigned char *message,
-                   unsigned long len,
-                   unsigned char output[SHA384_DIGEST_LENGTH]);
-Computes the SHA-384 signature over the given message of length len and
-store the result into the output buffer.
-Return 1 if error, else 0.
-
-3.4) SHA-512
-Must always be implemented.
-
-SHA512_DIGEST_LENGTH
-#define to 64, the SHA-512 digest length.
-
-libssh2_sha512_ctx
-Type of an SHA-512 computation context. Generally a struct.
-
-int libssh2_sha512_init(libssh2_sha512_ctx *x);
-Initializes the SHA-512 computation context at x.
-Returns 1 for success and 0 for failure
-
-void libssh2_sha512_update(libssh2_sha512_ctx ctx,
-                           const unsigned char *data,
-                           size_t len);
-Continue computation of SHA-512 on len bytes at data using context ctx.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_sha512_final(libssh2_sha512_ctx ctx,
-                          unsigned char output[SHA512_DIGEST_LENGTH]);
-Gets the computed SHA-512 signature from context ctx into the output buffer.
-Release the context.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-int libssh2_sha512(const unsigned char *message,
-                   unsigned long len,
-                   unsigned char output[SHA512_DIGEST_LENGTH]);
-Computes the SHA-512 signature over the given message of length len and
-store the result into the output buffer.
-Return 1 if error, else 0.
-Note: Seems unused in current code, but defined in each crypto library backend.
-
-LIBSSH2_HMAC_SHA512
-#define as 1 if the crypto library supports HMAC-SHA-512, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-void libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
-                              const void *key,
-                              int keylen);
-Setup the HMAC computation context ctx for an HMAC-512 computation using the
-keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
-
-3.5) MD5
-LIBSSH2_MD5
-#define to 1 if the crypto library supports MD5, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-MD5_DIGEST_LENGTH
-#define to 16, the MD5 digest length.
-
-libssh2_md5_ctx
-Type of an MD5 computation context. Generally a struct.
-
-int libssh2_md5_init(libssh2_md5_ctx *x);
-Initializes the MD5 computation context at x.
-Returns 1 for success and 0 for failure
-
-void libssh2_md5_update(libssh2_md5_ctx ctx,
-                        const unsigned char *data,
-                        size_t len);
-Continues computation of MD5 on len bytes at data using context ctx.
-Returns 1 for success and 0 for failure.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_md5_final(libssh2_md5_ctx ctx,
-                       unsigned char output[MD5_DIGEST_LENGTH]);
-Gets the computed MD5 signature from context ctx into the output buffer.
-Release the context.
-Note: if the ctx parameter is modified by the underlying code,
-this procedure must be implemented as a macro to map ctx --> &ctx.
-
-void libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
-                           const void *key,
-                           int keylen);
-Setup the HMAC computation context ctx for an HMAC-MD5 computation using the
-keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
-
-3.6) RIPEMD-160
-LIBSSH2_HMAC_RIPEMD
-#define as 1 if the crypto library supports HMAC-RIPEMD-160, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-void libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
-                                 const void *key,
-                                 int keylen);
-Setup the HMAC computation context ctx for an HMAC-RIPEMD-160 computation using
-the keylen-byte key. Is invoked just after libssh2_hmac_ctx_init().
-Returns 1 for success and 0 for failure.
-
-
-4) Bidirectional key ciphers.
-
-_libssh2_cipher_ctx
-Type of a cipher computation context.
-
-_libssh2_cipher_type(name);
-Macro defining name as storage identifying a cipher algorithm for
-the crypto library interface. No trailing semicolon.
-
-int _libssh2_cipher_init(_libssh2_cipher_ctx *h,
-                         _libssh2_cipher_type(algo),
-                         unsigned char *iv,
-                         unsigned char *secret,
-                         int encrypt);
-Creates a cipher context for the given algorithm with the initialization vector
-iv and the secret key secret. Prepare for encryption or decryption depending on
-encrypt.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                          _libssh2_cipher_type(algo),
-                          int encrypt,
-                          unsigned char *block,
-                          size_t blocksize);
-Encrypt or decrypt in-place data at (block, blocksize) using the given
-context and/or algorithm.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-void _libssh2_cipher_dtor(_libssh2_cipher_ctx *ctx);
-Release cipher context at ctx.
-
-4.1) AES
-4.1.1) AES in CBC block mode.
-LIBSSH2_AES
-#define as 1 if the crypto library supports AES in CBC mode, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_aes128
-AES-128-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-_libssh2_cipher_aes192
-AES-192-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-_libssh2_cipher_aes256
-AES-256-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-4.1.2) AES in CTR block mode.
-LIBSSH2_AES_CTR
-#define as 1 if the crypto library supports AES in CTR mode, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_aes128ctr
-AES-128-CTR algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-_libssh2_cipher_aes192ctr
-AES-192-CTR algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-_libssh2_cipher_aes256ctr
-AES-256-CTR algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-4.2) Blowfish in CBC block mode.
-LIBSSH2_BLOWFISH
-#define as 1 if the crypto library supports blowfish in CBC mode, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_blowfish
-Blowfish-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-4.3) RC4.
-LIBSSH2_RC4
-#define as 1 if the crypto library supports RC4 (arcfour), else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_arcfour
-RC4 algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-4.4) CAST5 in CBC block mode.
-LIBSSH2_CAST
-#define 1 if the crypto library supports cast, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_cast5
-CAST5-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-4.5) Tripple DES in CBC block mode.
-LIBSSH2_3DES
-#define as 1 if the crypto library supports TripleDES in CBC mode, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-_libssh2_cipher_3des
-TripleDES-CBC algorithm identifier initializer.
-#define with constant value of type _libssh2_cipher_type().
-
-
-5) Diffie-Hellman support.
-
-5.1) Diffie-Hellman context.
-_libssh2_dh_ctx
-Type of a Diffie-Hellman computation context.
-Must always be defined.
-
-5.2) Diffie-Hellman computation procedures.
-void libssh2_dh_init(_libssh2_dh_ctx *dhctx);
-Initializes the Diffie-Hellman context at `dhctx'. No effective context
-creation needed here.
-
-int libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                        _libssh2_bn *g, _libssh2_bn *p, int group_order,
-                        _libssh2_bn_ctx *bnctx);
-Generates a Diffie-Hellman key pair using base `g', prime `p' and the given
-`group_order'. Can use the given big number context `bnctx' if needed.
-The private key is stored as opaque in the Diffie-Hellman context `*dhctx' and
-the public key is returned in `public'.
-0 is returned upon success, else -1.
-
-int libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                      _libssh2_bn *f, _libssh2_bn *p, _libssh2_bn_ctx * bnctx)
-Computes the Diffie-Hellman secret from the previously created context `*dhctx',
-the public key `f' from the other party and the same prime `p' used at
-context creation. The result is stored in `secret'.
-0 is returned upon success, else -1.
-
-void libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
-Destroys Diffie-Hellman context at `dhctx' and resets its storage.
-
-
-6) Big numbers.
-Positive multi-byte integers support is sufficient.
-
-6.1) Computation contexts.
-This has a real meaning if the big numbers computations need some context
-storage. If not, use a dummy type and functions (macros).
-
-_libssh2_bn_ctx
-Type of multiple precision computation context. May not be empty. if not used,
-#define as char, for example.
-
-_libssh2_bn_ctx _libssh2_bn_ctx_new(void);
-Returns a new multiple precision computation context.
-
-void _libssh2_bn_ctx_free(_libssh2_bn_ctx ctx);
-Releases a multiple precision computation context.
-
-6.2) Computation support.
-_libssh2_bn
-Type of multiple precision numbers (aka bignumbers or huge integers) for the
-crypto library.
-
-_libssh2_bn * _libssh2_bn_init(void);
-Creates a multiple precision number (preset to zero).
-
-_libssh2_bn * _libssh2_bn_init_from_bin(void);
-Create a multiple precision number intended to be set by the
-_libssh2_bn_from_bin() function (see below). Unlike _libssh2_bn_init(), this
-code may be a dummy initializer if the _libssh2_bn_from_bin() actually
-allocates the number. Returns a value of type _libssh2_bn *.
-
-void _libssh2_bn_free(_libssh2_bn *bn);
-Destroys the multiple precision number at bn.
-
-unsigned long _libssh2_bn_bytes(_libssh2_bn *bn);
-Get the number of bytes needed to store the bits of the multiple precision
-number at bn.
-
-unsigned long _libssh2_bn_bits(_libssh2_bn *bn);
-Returns the number of bits of multiple precision number at bn.
-
-int _libssh2_bn_set_word(_libssh2_bn *bn, unsigned long val);
-Sets the value of bn to val.
-Returns 1 on success, 0 otherwise.
-
-_libssh2_bn * _libssh2_bn_from_bin(_libssh2_bn *bn, int len,
-                                   const unsigned char *val);
-Converts the positive integer in big-endian form of length len at val
-into a _libssh2_bn and place it in bn. If bn is NULL, a new _libssh2_bn is
-created.
-Returns a pointer to target _libssh2_bn or NULL if error.
-
-int _libssh2_bn_to_bin(_libssh2_bn *bn, unsigned char *val);
-Converts the absolute value of bn into big-endian form and store it at
-val. val must point to _libssh2_bn_bytes(bn) bytes of memory.
-Returns the length of the big-endian number.
-
-
-7) Private key algorithms.
-Format of an RSA public key:
-a) "ssh-rsa".
-b) RSA exponent, MSB first, with high order bit = 0.
-c) RSA modulus, MSB first, with high order bit = 0.
-Each item is preceded by its 32-bit byte length, MSB first.
-
-Format of a DSA public key:
-a) "ssh-dss".
-b) p, MSB first, with high order bit = 0.
-c) q, MSB first, with high order bit = 0.
-d) g, MSB first, with high order bit = 0.
-e) pub_key, MSB first, with high order bit = 0.
-Each item is preceded by its 32-bit byte length, MSB first.
-
-Format of an ECDSA public key:
-a) "ecdsa-sha2-nistp256" or "ecdsa-sha2-nistp384" or "ecdsa-sha2-nistp521".
-b) domain: "nistp256", "nistp384" or "nistp521" matching a).
-c) raw public key ("octal").
-Each item is preceded by its 32-bit byte length, MSB first.
-
-Format of an ED25519 public key:
-a) "ssh-ed25519".
-b) raw key (32 bytes).
-Each item is preceded by its 32-bit byte length, MSB first.
-
-int _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                              unsigned char **method,
-                              size_t *method_len,
-                              unsigned char **pubkeydata,
-                              size_t *pubkeydata_len,
-                              const char *privatekey,
-                              const char *passphrase);
-Reads a private key from file privatekey and extract the public key -->
-(pubkeydata, pubkeydata_len). Store the associated method (ssh-rsa or ssh-dss)
-into (method, method_len).
-Both buffers have to be allocated using LIBSSH2_ALLOC().
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                    unsigned char **method,
-                                    size_t *method_len,
-                                    unsigned char **pubkeydata,
-                                    size_t *pubkeydata_len,
-                                    const char *privatekeydata,
-                                    size_t privatekeydata_len,
-                                    const char *passphrase);
-Gets a private key from bytes at (privatekeydata, privatekeydata_len) and
-extract the public key --> (pubkeydata, pubkeydata_len). Store the associated
-method (ssh-rsa or ssh-dss) into (method, method_len).
-Both buffers have to be allocated using LIBSSH2_ALLOC().
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-
-7.1) RSA
-LIBSSH2_RSA
-#define as 1 if the crypto library supports RSA, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-libssh2_rsa_ctx
-Type of an RSA computation context. Generally a struct.
-
-int _libssh2_rsa_new(libssh2_rsa_ctx **rsa,
-                     const unsigned char *edata,
-                     unsigned long elen,
-                     const unsigned char *ndata,
-                     unsigned long nlen,
-                     const unsigned char *ddata,
-                     unsigned long dlen,
-                     const unsigned char *pdata,
-                     unsigned long plen,
-                     const unsigned char *qdata,
-                     unsigned long qlen,
-                     const unsigned char *e1data,
-                     unsigned long e1len,
-                     const unsigned char *e2data,
-                     unsigned long e2len,
-                     const unsigned char *coeffdata, unsigned long coefflen);
-Creates a new context for RSA computations from key source values:
-    pdata, plen    Prime number p. Only used if private key known (ddata).
-    qdata, qlen    Prime number q. Only used if private key known (ddata).
-    ndata, nlen    Modulus n.
-    edata, elen    Exponent e.
-    ddata, dlen    e^-1 % phi(n) = private key. May be NULL if unknown.
-    e1data, e1len    dp = d % (p-1). Only used if private key known (dtata).
-    e2data, e2len    dq = d % (q-1). Only used if private key known (dtata).
-    coeffdata, coefflen    q^-1 % p. Only used if private key known.
-Returns 0 if OK.
-This procedure is already prototyped in crypto.h.
-Note: the current generic code only calls this function with e and n (public
-key parameters): unless used internally by the backend, it is not needed to
-support the private key and the other parameters here.
-
-int _libssh2_rsa_new_private(libssh2_rsa_ctx **rsa,
-                             LIBSSH2_SESSION *session,
-                             const char *filename,
-                             unsigned const char *passphrase);
-Reads an RSA private key from file filename into a new RSA context.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                        LIBSSH2_SESSION *session,
-                                        const char *data,
-          size_t data_len,
-                                        unsigned const char *passphrase);
-Gets an RSA private key from data into a new RSA context.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                             const unsigned char *sig,
-                             unsigned long sig_len,
-                             const unsigned char *m, unsigned long m_len);
-Verify (sig, sig_len) signature of (m, m_len) using an SHA-1 hash and the
-RSA context.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_rsa_sha1_signv(LIBSSH2_SESSION *session,
-                            unsigned char **sig, size_t *siglen,
-                            int count, const struct iovec vector[],
-                            libssh2_rsa_ctx *ctx);
-RSA signs the SHA-1 hash computed over the count data chunks in vector.
-Signature is stored at (sig, siglen).
-Signature buffer must be allocated from the given session.
-Returns 0 if OK, else -1.
-Note: this procedure is optional: if provided, it MUST be defined as a macro.
-
-int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                           libssh2_rsa_ctx *rsactx,
-                           const unsigned char *hash,
-                           size_t hash_len,
-                           unsigned char **signature,
-                           size_t *signature_len);
-RSA signs the (hash, hashlen) SHA-1 hash bytes and stores the allocated
-signature at (signature, signature_len).
-Signature buffer must be allocated from the given session.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-Note: this procedure is not used if macro _libssh2_rsa_sha1_signv() is defined.
-
-void _libssh2_rsa_free(libssh2_rsa_ctx *rsactx);
-Releases the RSA computation context at rsactx.
-
-
-7.2) DSA
-LIBSSH2_DSA
-#define as 1 if the crypto library supports DSA, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-
-libssh2_dsa_ctx
-Type of a DSA computation context. Generally a struct.
-
-int _libssh2_dsa_new(libssh2_dsa_ctx **dsa,
-                     const unsigned char *pdata,
-                     unsigned long plen,
-                     const unsigned char *qdata,
-                     unsigned long qlen,
-                     const unsigned char *gdata,
-                     unsigned long glen,
-                     const unsigned char *ydata,
-                     unsigned long ylen,
-                     const unsigned char *x, unsigned long x_len);
-Creates a new context for DSA computations from source key values:
-    pdata, plen    Prime number p. Only used if private key known (ddata).
-    qdata, qlen    Prime number q. Only used if private key known (ddata).
-    gdata, glen    G number.
-    ydata, ylen    Public key.
-    xdata, xlen    Private key. Only taken if xlen non-zero.
-Returns 0 if OK.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_dsa_new_private(libssh2_dsa_ctx **dsa,
-                             LIBSSH2_SESSION *session,
-                             const char *filename,
-                             unsigned const char *passphrase);
-Gets a DSA private key from file filename into a new DSA context.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
-                                        LIBSSH2_SESSION *session,
-                                        const char *data,
-                                        size_t data_len,
-                                        unsigned const char *passphrase);
-Gets a DSA private key from the data_len-bytes data into a new DSA context.
-Must call _libssh2_init_if_needed().
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx *dsactx,
-                             const unsigned char *sig,
-                             const unsigned char *m, unsigned long m_len);
-Verify (sig, siglen) signature of (m, m_len) using an SHA-1 hash and the
-DSA context.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx *dsactx,
-                           const unsigned char *hash,
-                           unsigned long hash_len, unsigned char *sig);
-DSA signs the (hash, hash_len) data using SHA-1 and store the signature at sig.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-void _libssh2_dsa_free(libssh2_dsa_ctx *dsactx);
-Releases the DSA computation context at dsactx.
-
-
-7.3) ECDSA
-LIBSSH2_ECDSA
-#define as 1 if the crypto library supports ECDSA, else 0.
-If defined as 0, _libssh2_ec_key should be defined as void and the rest of
-this section can be omitted.
-
-EC_MAX_POINT_LEN
-Maximum point length. Usually defined as ((528 * 2 / 8) + 1) (= 133).
-
-libssh2_ecdsa_ctx
-Type of an ECDSA computation context. Generally a struct.
-
-_libssh2_ec_key
-Type of an elliptic curve key.
-
-libssh2_curve_type
-An enum type defining curve types. Current supported identifiers are:
-    LIBSSH2_EC_CURVE_NISTP256
-    LIBSSH2_EC_CURVE_NISTP384
-    LIBSSH2_EC_CURVE_NISTP521
-
-int _libssh2_ecdsa_create_key(_libssh2_ec_key **out_private_key,
-                              unsigned char **out_public_key_octal,
-                              size_t *out_public_key_octal_len,
-                              libssh2_curve_type curve_type);
-Create a new ECDSA private key of type curve_type and return it at
-out_private_key. If out_public_key_octal is not NULL, store an allocated
-pointer to the associated public key in "octal" form in it and its length
-at out_public_key_octal_len.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx **ec_ctx,
-                               LIBSSH2_SESSION * session,
-                               const char *filename,
-                               unsigned const char *passphrase);
-Reads an ECDSA private key from PEM file filename into a new ECDSA context.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
-                                          LIBSSH2_SESSION * session,
-                                          const char *filedata,
-                                          size_t filedata_len,
-                                          unsigned const char *passphrase);
-Builds an ECDSA private key from PEM data at filedata of length filedata_len
-into a new ECDSA context stored at ec_ctx.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx **ecdsactx,
-                                             const unsigned char *k,
-                                             size_t k_len,
-                                             libssh2_curve_type type);
-Stores at ecdsactx a new ECDSA context associated with the given curve type
-and with "octal" form public key (k, k_len).
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx **ec_ctx,
-                                       LIBSSH2_SESSION * session,
-                                       const char *filename,
-                                       unsigned const char *passphrase);
-Reads a PEM-encoded ECDSA private key from file filename encrypted with
-passphrase and stores at ec_ctx a new ECDSA context for it.
-Return 0 if OK, else -1.
-Currently used only from openssl backend (ought to be private).
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_sign(LIBSSH2_SESSION *session, libssh2_ecdsa_ctx *ec_ctx,
-                        const unsigned char *hash, unsigned long hash_len,
-                        unsigned char **signature, size_t *signature_len);
-ECDSA signs the (hash, hashlen) hash bytes and stores the allocated
-signature at (signature, signature_len). Hash algorithm used should be
-SHA-256, SHA-384 or SHA-512 depending on type stored in ECDSA context at ec_ctx.
-Signature buffer must be allocated from the given session.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_verify(libssh2_ecdsa_ctx *ctx,
-                          const unsigned char *r, size_t r_len,
-                          const unsigned char *s, size_t s_len,
-                          const unsigned char *m, size_t m_len);
-Verify the ECDSA signature made of (r, r_len) and (s, s_len) of (m, m_len)
-using the hash algorithm configured in the ECDSA context ctx.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-libssh2_curve_type _libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ecdsactx);
-Returns the curve type associated with given context.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ecdsa_curve_type_from_name(const char *name,
-                                        libssh2_curve_type *out_type);
-Stores in out_type the curve type matching string name of the form
-"ecdsa-sha2-nistpxxx".
-Return 0 if OK, else -1.
-Currently used only from openssl backend (ought to be private).
-This procedure is already prototyped in crypto.h.
-
-void _libssh2_ecdsa_free(libssh2_ecdsa_ctx *ecdsactx);
-Releases the ECDSA computation context at ecdsactx.
-
-
-7.4) ED25519
-LIBSSH2_ED25519
-#define as 1 if the crypto library supports ED25519, else 0.
-If defined as 0, the rest of this section can be omitted.
-
-
-libssh2_ed25519_ctx
-Type of an ED25519 computation context. Generally a struct.
-
-int _libssh2_curve25519_new(LIBSSH2_SESSION *session, libssh2_ed25519_ctx **ctx,
-                            uint8_t **out_public_key,
-                            uint8_t **out_private_key);
-Generates an ED25519 key pair, stores a pointer to them at out_private_key
-and out_public_key respectively and stores at ctx a new ED25519 context for
-this key.
-Argument ctx, out_private_key and out_public key may be NULL to disable storing
-the corresponding value.
-Length of each key is LIBSSH2_ED25519_KEY_LEN (32 bytes).
-Key buffers are allocated and should be released by caller after use.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ed25519_new_private(libssh2_ed25519_ctx **ed_ctx,
-                                 LIBSSH2_SESSION *session,
-                                 const char *filename,
-                                 const uint8_t *passphrase);
-Reads an ED25519 private key from PEM file filename into a new ED25519 context.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ed25519_new_public(libssh2_ed25519_ctx **ed_ctx,
-                                LIBSSH2_SESSION *session,
-                                const unsigned char *raw_pub_key,
-                                const uint8_t key_len);
-Stores at ed_ctx a new ED25519 key context for raw public key (raw_pub_key,
-key_len).
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx **ed_ctx,
-                                            LIBSSH2_SESSION *session,
-                                            const char *filedata,
-                                            size_t filedata_len,
-                                            unsigned const char *passphrase);
-Builds an ED25519 private key from PEM data at filedata of length filedata_len
-into a new ED25519 context stored at ed_ctx.
-Must call _libssh2_init_if_needed().
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
-                          uint8_t **out_sig, size_t *out_sig_len,
-                          const uint8_t *message, size_t message_len);
-ED25519 signs the (message, message_len) bytes and stores the allocated
-signature at (sig, sig_len).
-Signature buffer is allocated from the given session.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_ed25519_verify(libssh2_ed25519_ctx *ctx, const uint8_t *s,
-                            size_t s_len, const uint8_t *m, size_t m_len);
-Verify (s, s_len) signature of (m, m_len) using the given ED25519 context.
-Return 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-int _libssh2_curve25519_gen_k(_libssh2_bn **k,
-                              uint8_t private_key[LIBSSH2_ED25519_KEY_LEN],
-                              uint8_t srvr_public_key[LIBSSH2_ED25519_KEY_LEN]);
-Computes a shared ED25519 secret key from the given raw server public key and
-raw client public key and stores it as a big number in *k. Big number should
-have been initialized before calling this function.
-Returns 0 if OK, else -1.
-This procedure is already prototyped in crypto.h.
-
-void _libssh2_ed25519_free(libssh2_ed25519_ctx *ed25519ctx);
-Releases the ED25519 computation context at ed25519ctx.
-
-
-8) Miscellaneous
-
-void libssh2_prepare_iovec(struct iovec *vector, unsigned int len);
-Prepare len consecutive iovec slots before using them.
-In example, this is needed to preset unused structure slacks on platforms
-requiring it.
-If this is not needed, it should be defined as an empty macro.
-
-int _libssh2_random(unsigned char *buf, int len);
-Store len random bytes at buf.
-Returns 0 if OK, else -1.
diff --git a/libssh2/libssh2/docs/INSTALL_AUTOTOOLS b/libssh2/libssh2/docs/INSTALL_AUTOTOOLS
deleted file mode 100644
index a75b5181..00000000
--- a/libssh2/libssh2/docs/INSTALL_AUTOTOOLS
+++ /dev/null
@@ -1,355 +0,0 @@
-Installation Instructions
-*************************
-
-Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free
-Software Foundation, Inc.
-
-This file is free documentation; the Free Software Foundation gives
-unlimited permission to copy, distribute and modify it.
-
-When Building directly from Master
-==================================
-
-If you want to build directly from the git repository, you must first
-generate the configure script and Makefile using autotools. There is
-a convenience script that calls all tools in the correct order. Make
-sure that autoconf, automake and libtool are installed on your system,
-then execute:
-
-  autoreconf -fi
-
-After executing this script, you can build the project as usual:
-
-  ./configure
-  make
-
-Basic Installation
-==================
-
-These are generic installation instructions.
-
-   The `configure' shell script attempts to guess correct values for
-various system-dependent variables used during compilation.  It uses
-those values to create a `Makefile' in each directory of the package.
-It may also create one or more `.h' files containing system-dependent
-definitions.  Finally, it creates a shell script `config.status' that
-you can run in the future to recreate the current configuration, and a
-file `config.log' containing compiler output (useful mainly for
-debugging `configure').
-
-   It can also use an optional file (typically called `config.cache'
-and enabled with `--cache-file=config.cache' or simply `-C') that saves
-the results of its tests to speed up reconfiguring.  (Caching is
-disabled by default to prevent problems with accidental use of stale
-cache files.)
-
-   If you need to do unusual things to compile the package, please try
-to figure out how `configure' could check whether to do them, and mail
-diffs or instructions to the address given in the `README' so they can
-be considered for the next release.  If you are using the cache, and at
-some point `config.cache' contains results you don't want to keep, you
-may remove or edit it.
-
-   The file `configure.ac' (or `configure.in') is used to create
-`configure' by a program called `autoconf'.  You only need
-`configure.ac' if you want to change it or regenerate `configure' using
-a newer version of `autoconf'.
-
-The simplest way to compile this package is:
-
-  1. `cd' to the directory containing the package's source code and type
-     `./configure' to configure the package for your system.  If you're
-     using `csh' on an old version of System V, you might need to type
-     `sh ./configure' instead to prevent `csh' from trying to execute
-     `configure' itself.
-
-     Running `configure' takes awhile.  While running, it prints some
-     messages telling which features it is checking for.
-
-  2. Type `make' to compile the package.
-
-  3. Optionally, type `make check' to run any self-tests that come with
-     the package.
-
-  4. Type `make install' to install the programs and any data files and
-     documentation.
-
-  5. You can remove the program binaries and object files from the
-     source code directory by typing `make clean'.  To also remove the
-     files that `configure' created (so you can compile the package for
-     a different kind of computer), type `make distclean'.  There is
-     also a `make maintainer-clean' target, but that is intended mainly
-     for the package's developers.  If you use it, you may have to get
-     all sorts of other programs in order to regenerate files that came
-     with the distribution.
-
-Compilers and Options
-=====================
-
-Some systems require unusual options for compilation or linking that the
-`configure' script does not know about.  Run `./configure --help' for
-details on some of the pertinent environment variables.
-
-   You can give `configure' initial values for configuration parameters
-by setting variables in the command line or in the environment.  Here
-is an example:
-
-     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
-
-   *Note Defining Variables::, for more details.
-
-Compiling For Multiple Architectures
-====================================
-
-You can compile the package for more than one kind of computer at the
-same time, by placing the object files for each architecture in their
-own directory.  To do this, you must use a version of `make' that
-supports the `VPATH' variable, such as GNU `make'.  `cd' to the
-directory where you want the object files and executables to go and run
-the `configure' script.  `configure' automatically checks for the
-source code in the directory that `configure' is in and in `..'.
-
-   If you have to use a `make' that does not support the `VPATH'
-variable, you have to compile the package for one architecture at a
-time in the source code directory.  After you have installed the
-package for one architecture, use `make distclean' before reconfiguring
-for another architecture.
-
-Installation Names
-==================
-
-By default, `make install' installs the package's commands under
-`/usr/local/bin', include files under `/usr/local/include', etc.  You
-can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX'.
-
-   You can specify separate installation prefixes for
-architecture-specific files and architecture-independent files.  If you
-pass the option `--exec-prefix=PREFIX' to `configure', the package uses
-PREFIX as the prefix for installing programs and libraries.
-Documentation and other data files still use the regular prefix.
-
-   In addition, if you use an unusual directory layout you can give
-options like `--bindir=DIR' to specify different values for particular
-kinds of files.  Run `configure --help' for a list of the directories
-you can set and what kinds of files go in them.
-
-   If the package supports it, you can cause programs to be installed
-with an extra prefix or suffix on their names by giving `configure' the
-option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
-
-Optional Features
-=================
-
-Some packages pay attention to `--enable-FEATURE' options to
-`configure', where FEATURE indicates an optional part of the package.
-They may also pay attention to `--with-PACKAGE' options, where PACKAGE
-is something like `gnu-as' or `x' (for the X Window System).  The
-`README' should mention any `--enable-' and `--with-' options that the
-package recognizes.
-
-   For packages that use the X Window System, `configure' can usually
-find the X include and library files automatically, but if it doesn't,
-you can use the `configure' options `--x-includes=DIR' and
-`--x-libraries=DIR' to specify their locations.
-
-Specifying the System Type
-==========================
-
-There may be some features `configure' cannot figure out automatically,
-but needs to determine by the type of machine the package will run on.
-Usually, assuming the package is built to be run on the _same_
-architectures, `configure' can figure that out, but if it prints a
-message saying it cannot guess the machine type, give it the
-`--build=TYPE' option.  TYPE can either be a short name for the system
-type, such as `sun4', or a canonical name which has the form:
-
-     CPU-COMPANY-SYSTEM
-
-where SYSTEM can have one of these forms:
-
-     OS KERNEL-OS
-
-   See the file `config.sub' for the possible values of each field.  If
-`config.sub' isn't included in this package, then this package doesn't
-need to know the machine type.
-
-   If you are _building_ compiler tools for cross-compiling, you should
-use the option `--target=TYPE' to select the type of system they will
-produce code for.
-
-   If you want to _use_ a cross compiler, that generates code for a
-platform different from the build platform, you should specify the
-"host" platform (i.e., that on which the generated programs will
-eventually be run) with `--host=TYPE'.
-
-Sharing Defaults
-================
-
-If you want to set default values for `configure' scripts to share, you
-can create a site shell script called `config.site' that gives default
-values for variables like `CC', `cache_file', and `prefix'.
-`configure' looks for `PREFIX/share/config.site' if it exists, then
-`PREFIX/etc/config.site' if it exists.  Or, you can set the
-`CONFIG_SITE' environment variable to the location of the site script.
-A warning: not all `configure' scripts look for a site script.
-
-Defining Variables
-==================
-
-Variables not defined in a site shell script can be set in the
-environment passed to `configure'.  However, some packages may run
-configure again during the build, and the customized values of these
-variables may be lost.  In order to avoid this problem, you should set
-them in the `configure' command line, using `VAR=value'.  For example:
-
-     ./configure CC=/usr/local2/bin/gcc
-
-causes the specified `gcc' to be used as the C compiler (unless it is
-overridden in the site shell script).  Here is a another example:
-
-     /bin/bash ./configure CONFIG_SHELL=/bin/bash
-
-Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent
-configuration-related scripts to be executed by `/bin/bash'.
-
-`configure' Invocation
-======================
-
-`configure' recognizes the following options to control how it operates.
-
-`--help'
-`-h'
-     Print a summary of the options to `configure', and exit.
-
-`--version'
-`-V'
-     Print the version of Autoconf used to generate the `configure'
-     script, and exit.
-
-`--cache-file=FILE'
-     Enable the cache: use and save the results of the tests in FILE,
-     traditionally `config.cache'.  FILE defaults to `/dev/null' to
-     disable caching.
-
-`--config-cache'
-`-C'
-     Alias for `--cache-file=config.cache'.
-
-`--quiet'
-`--silent'
-`-q'
-     Do not print messages saying which checks are being made.  To
-     suppress all normal output, redirect it to `/dev/null' (any error
-     messages will still be shown).
-
-`--srcdir=DIR'
-     Look for the package's source code in directory DIR.  Usually
-     `configure' can determine that directory automatically.
-
-`configure' also accepts some other, not widely useful, options.  Run
-`configure --help' for more details.
-
-More configure options
-======================
-
-Some ./configure options deserve additional comments:
-
- * --enable-crypt-none
-
-	The SSH2 Transport allows for unencrypted data
-	transmission using the "none" cipher.  Because this is
-	such a huge security hole, it is typically disabled on
-	SSH2 implementations and is disabled in libssh2 by
-	default as well.
-
-	Enabling this option will allow for "none" as a
-	negotiable method, however it still requires that the
-	method be advertized by the remote end and that no
-	more-preferable methods are available.
-
- * --enable-mac-none
-
-	The SSH2 Transport also allows implementations to
-	forego a message authentication code.  While this is
-	less of a security risk than using a "none" cipher, it
-	is still not recommended as disabling MAC hashes
-	removes a layer of security.
-
-	Enabling this option will allow for "none" as a
-	negotiable method, however it still requires that the
-	method be advertized by the remote end and that no
-	more-preferable methods are available.
-
- * --disable-gex-new
-
-	The diffie-hellman-group-exchange-sha1 (dh-gex) key
-	exchange method originally defined an exchange
-	negotiation using packet type 30 to request a
-	generation pair based on a single target value.  Later
-	refinement of dh-gex provided for range and target
-	values.  By default libssh2 will use the newer range
-	method.
-
-	If you experience trouble connecting to an old SSH
-	server using dh-gex, try this option to fallback on
-	the older more reliable method.
-
- * --with-libgcrypt
- * --without-libgcrypt
- * --with-libgcrypt-prefix=DIR
-
-	libssh2 can use the Libgcrypt library
-	(https://www.gnupg.org/) for cryptographic operations.
-        One of the cryptographic libraries is required.
-
-	Configure will attempt to locate Libgcrypt
-	automatically.
-
-	If your installation of Libgcrypt is in another
-	location, specify it using --with-libgcrypt-prefix.
-
- * --with-openssl
- * --without-openssl
- * --with-libssl-prefix=[DIR]
-
-	libssh2 can use the OpenSSL library
-	(https://www.openssl.org) for cryptographic operations.
-        One of the cryptographic libraries is required.
-
-	Configure will attempt to locate OpenSSL in the
-	default location.
-
-	If your installation of OpenSSL is in another
-	location, specify it using --with-libssl-prefix.
-
- * --with-mbedtls
- * --without-mbedtls
- * --with-libmbedtls-prefix=[DIR]
-
-        libssh2 can use the mbedTLS library
-        (https://tls.mbed.org) for cryptographic operations.
-        One of the cryptographic libraries is required.
-
-        Configure will attempt to locate mbedTLS in the
-        default location.
-
-        If your installation of mbedTLS is in another
-        location, specify it using --with-libmbedtls-prefix.
-
- * --with-libz
- * --without-libz
- * --with-libz-prefix=[DIR]
-
-	If present, libssh2 will attempt to use the zlib
-	(http://www.zlib.org) for payload compression, however
-	zlib is not required.
-
-	If your installation of Libz is in another location,
-	specify it using --with-libz-prefix.
-
- * --enable-debug
-
-	Will make the build use more pedantic and strict compiler
-	options as well as enable the libssh2_trace() function (for
-	showing debug traces).
diff --git a/libssh2/libssh2/docs/INSTALL_CMAKE.md b/libssh2/libssh2/docs/INSTALL_CMAKE.md
deleted file mode 100644
index c136fdce..00000000
--- a/libssh2/libssh2/docs/INSTALL_CMAKE.md
+++ /dev/null
@@ -1,193 +0,0 @@
-License: see COPYING
-
-Source code: https://github.com/libssh2/libssh2
-
-Web site source code: https://github.com/libssh2/www
-
-Installation instructions are in docs/INSTALL
-=======
-To build libssh2 you will need CMake v2.8 or later [1] and one of the
-following cryptography libraries:
-
-* OpenSSL
-* Libgcrypt
-* WinCNG
-* mbedTLS
-
-Getting started
----------------
-
-If you are happy with the default options, make a new build directory,
-change to it, configure the build environment and build the project:
-
-```
-  mkdir bin
-  cd bin
-  cmake ..
-  cmake --build .
-```
-
-libssh2 will be built as a static library and will use any
-cryptography library available.  The library binary will be put in
-`bin/src`, with the examples in `bin/example` and the tests in
-`bin/tests`.
-
-Customising the build
----------------------
-
-Of course, you might want to customise the build options.  You can
-pass the options to CMake on the command line:
-
-  cmake -D<option>=<value> ..
-
-The following options are available:
-
- * `LINT=ON`
-
-    Enables running the source code linter when building. Can be `ON` or `OFF`.
-
-
- * `BUILD_SHARED_LIBS=OFF`
-
-    Determines whether libssh2 is built as a static library or as a
-    shared library (.dll/.so).  Can be `ON` or `OFF`.
-
- * `CRYPTO_BACKEND=`
-
-    Chooses a specific cryptography library to use for cryptographic
-    operations.  Can be `OpenSSL` (https://www.openssl.org),
-    `Libgcrypt` (https://www.gnupg.org/), `WinCNG` (Windows Vista+),
-    `mbedTLS` (https://tls.mbed.org/) or blank to use any library available.
-
-    CMake will attempt to locate the libraries automatically.  See [2]
-    for more information.
-
- * `ENABLE_ZLIB_COMPRESSION=OFF`
-
-    Will use zlib (http://www.zlib.org) for payload compression.  Can
-    be `ON` or `OFF`.
-
- * `ENABLE_CRYPT_NONE=OFF`
-
-    The SSH2 Transport allows for unencrypted data transmission using
-    the "none" cipher.  Because this is such a huge security hole, it
-    is typically disabled on SSH2 implementations and is disabled in
-    libssh2 by default as well.
-
-    Enabling this option will allow for "none" as a negotiable method,
-    however it still requires that the method be advertized by the
-    remote end and that no more-preferable methods are available.
-
- * `ENABLE_MAC_NONE=OFF`
-
-    The SSH2 Transport also allows implementations to forego a message
-    authentication code.  While this is less of a security risk than
-    using a "none" cipher, it is still not recommended as disabling
-    MAC hashes removes a layer of security.
-
-    Enabling this option will allow for "none" as a negotiable method,
-    however it still requires that the method be advertized by the
-    remote end and that no more-preferable methods are available.
-
- * `ENABLE_GEX_NEW=ON`
-
-    The diffie-hellman-group-exchange-sha1 (dh-gex) key exchange
-    method originally defined an exchange negotiation using packet
-    type 30 to request a generation pair based on a single target
-    value.  Later refinement of dh-gex provided for range and target
-    values.  By default libssh2 will use the newer range method.
-
-    If you experience trouble connecting to an old SSH server using
-    dh-gex, try this option to fallback on the older more reliable
-    method.
-
- * `ENABLE_DEBUG_LOGGING=ON` in Debug, `=OFF` in Release
-
-    Will enable the libssh2_trace() function for showing debug traces.
-
- * `CLEAR_MEMORY=ON`
-
-    Securely zero memory before freeing it (if the backend supports this).
-
-Build tools
------------
-
-The previous examples used CMake to start the build using:
-
-  cmake --build .
-
-Alternatively, once CMake has configured your project, you can just
-use your own build tool, e.g GNU make, Visual Studio, etc., from that
-point onwards.
-
-Tests
------
-
-To test the build, run the appropriate test target for your build
-system.  For example:
-
-```
-  cmake --build . --target test
-```
-or
-```
-  cmake --build . --target RUN_TESTS
-```
-
-How do I use libssh2 in my project if my project doesn't use CMake?
--------------------------------------------------------------------
-
-If you are not using CMake for your own project, install libssh2
-```
-  cmake <libssh2 source location>
-  cmake --build .
-  cmake --build . --target install
-```
-or
-```
-  cmake --build . --target INSTALL
-```
-
-and then specify the install location to your project in the normal
-way for your build environment.  If you don't like the default install
-location, add `-DCMAKE_INSTALL_PREFIX=<chosen prefix>` when initially
-configuring the project.
-
-How can I use libssh2 in my project if it also uses CMake?
-----------------------------------------------------------
-
-If your own project also uses CMake, you don't need to worry about
-setting it up with libssh2's location.  Just add just the following
-lines and CMake will find libssh2 on your system, set up the necessary
-paths and link the library with your binary.
-
-    find_package(Libssh2 REQUIRED CONFIG)
-    target_link_libraries(my_project_target Libssh2::libssh2)
-
-Of course, you still have to make libssh2 available on your system
-first.  You can install it in the traditional way shown above, but you
-don't have to.  Instead you can just build it, which will export its
-location to the user package registry [3] where `find_package` will
-find it.
-
-You can even combine the two steps using a so-called 'superbuild'
-project [4] that downloads, builds and exports libssh2, and then
-builds your project:
-
-    include(ExternalProject)
-
-    ExternalProject_Add(
-        Libssh2
-        URL <libssh2 download location>
-        URL_HASH SHA1=<libssh2 archive SHA1>
-        INSTALL_COMMAND "")
-
-    ExternalProject_Add(
-        MyProject DEPENDS Libssh2
-        SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src
-        INSTALL_COMMAND "")
-
-[1] https://www.cmake.org/cmake/resources/software.html
-[2] https://www.cmake.org/cmake/help/v3.0/manual/cmake-packages.7.html
-[3] https://www.cmake.org/cmake/help/v3.0/manual/cmake-packages.7.html#package-registry
-[4] https://blog.kitware.com/wp-content/uploads/2016/01/kitware_quarterly1009.pdf
diff --git a/libssh2/libssh2/docs/Makefile.am b/libssh2/libssh2/docs/Makefile.am
deleted file mode 100644
index a8094312..00000000
--- a/libssh2/libssh2/docs/Makefile.am
+++ /dev/null
@@ -1,177 +0,0 @@
-# $Id: Makefile.am,v 1.37 2009/03/26 15:41:15 bagder Exp $
-
-EXTRA_DIST = template.3 BINDINGS INSTALL_AUTOTOOLS INSTALL_CMAKE.md HACKING TODO \
- AUTHORS CMakeLists.txt HACKING-CRYPTO SECURITY.md
-
-dist_man_MANS = \
-	libssh2_agent_connect.3 \
-	libssh2_agent_disconnect.3 \
-	libssh2_agent_free.3 \
-	libssh2_agent_get_identity.3 \
-	libssh2_agent_get_identity_path.3 \
-	libssh2_agent_init.3 \
-	libssh2_agent_list_identities.3 \
-	libssh2_agent_set_identity_path.3 \
-	libssh2_agent_userauth.3 \
-	libssh2_banner_set.3 \
-	libssh2_base64_decode.3 \
-	libssh2_channel_close.3 \
-	libssh2_channel_direct_tcpip.3 \
-	libssh2_channel_direct_tcpip_ex.3 \
-	libssh2_channel_eof.3 \
-	libssh2_channel_exec.3 \
-	libssh2_channel_flush.3 \
-	libssh2_channel_flush_ex.3 \
-	libssh2_channel_flush_stderr.3 \
-	libssh2_channel_forward_accept.3 \
-	libssh2_channel_forward_cancel.3 \
-	libssh2_channel_forward_listen.3 \
-	libssh2_channel_forward_listen_ex.3 \
-	libssh2_channel_free.3 \
-	libssh2_channel_get_exit_signal.3 \
-	libssh2_channel_get_exit_status.3 \
-	libssh2_channel_handle_extended_data.3 \
-	libssh2_channel_handle_extended_data2.3 \
-	libssh2_channel_ignore_extended_data.3 \
-	libssh2_channel_open_ex.3 \
-	libssh2_channel_open_session.3 \
-	libssh2_channel_process_startup.3 \
-	libssh2_channel_read.3 \
-	libssh2_channel_read_ex.3 \
-	libssh2_channel_read_stderr.3 \
-	libssh2_channel_receive_window_adjust.3 \
-	libssh2_channel_receive_window_adjust2.3 \
-	libssh2_channel_request_pty.3 \
-	libssh2_channel_request_pty_ex.3 \
-	libssh2_channel_request_pty_size.3 \
-	libssh2_channel_request_pty_size_ex.3 \
-	libssh2_channel_send_eof.3 \
-	libssh2_channel_set_blocking.3 \
-	libssh2_channel_setenv.3 \
-	libssh2_channel_setenv_ex.3 \
-	libssh2_channel_shell.3 \
-	libssh2_channel_subsystem.3 \
-	libssh2_channel_wait_closed.3 \
-	libssh2_channel_wait_eof.3 \
-	libssh2_channel_window_read.3 \
-	libssh2_channel_window_read_ex.3 \
-	libssh2_channel_window_write.3 \
-	libssh2_channel_window_write_ex.3 \
-	libssh2_channel_write.3 \
-	libssh2_channel_write_ex.3 \
-	libssh2_channel_write_stderr.3 \
-	libssh2_channel_x11_req.3 \
-	libssh2_channel_x11_req_ex.3 \
-	libssh2_exit.3 \
-	libssh2_free.3 \
-	libssh2_hostkey_hash.3 \
-	libssh2_init.3 \
-	libssh2_keepalive_config.3 \
-	libssh2_keepalive_send.3 \
-	libssh2_knownhost_add.3 \
-	libssh2_knownhost_addc.3 \
-	libssh2_knownhost_check.3 \
-	libssh2_knownhost_checkp.3 \
-	libssh2_knownhost_del.3 \
-	libssh2_knownhost_free.3 \
-	libssh2_knownhost_get.3 \
-	libssh2_knownhost_init.3 \
-	libssh2_knownhost_readfile.3 \
-	libssh2_knownhost_readline.3 \
-	libssh2_knownhost_writefile.3 \
-	libssh2_knownhost_writeline.3 \
-	libssh2_poll.3 \
-	libssh2_poll_channel_read.3 \
-	libssh2_publickey_add.3 \
-	libssh2_publickey_add_ex.3 \
-	libssh2_publickey_init.3 \
-	libssh2_publickey_list_fetch.3 \
-	libssh2_publickey_list_free.3 \
-	libssh2_publickey_remove.3 \
-	libssh2_publickey_remove_ex.3 \
-	libssh2_publickey_shutdown.3 \
-	libssh2_scp_recv.3 \
-	libssh2_scp_recv2.3 \
-	libssh2_scp_send.3 \
-	libssh2_scp_send64.3 \
-	libssh2_scp_send_ex.3 \
-	libssh2_session_abstract.3 \
-	libssh2_session_banner_get.3 \
-	libssh2_session_banner_set.3 \
-	libssh2_session_block_directions.3 \
-	libssh2_session_callback_set.3 \
-	libssh2_session_disconnect.3 \
-	libssh2_session_disconnect_ex.3 \
-	libssh2_session_flag.3 \
-	libssh2_session_free.3 \
-	libssh2_session_get_blocking.3 \
-	libssh2_session_get_timeout.3 \
-	libssh2_session_handshake.3 \
-	libssh2_session_hostkey.3 \
-	libssh2_session_init.3 \
-	libssh2_session_init_ex.3 \
-	libssh2_session_last_errno.3 \
-	libssh2_session_last_error.3 \
-	libssh2_session_set_last_error.3 \
-	libssh2_session_method_pref.3 \
-	libssh2_session_methods.3 \
-	libssh2_session_set_blocking.3 \
-	libssh2_session_set_timeout.3 \
-	libssh2_session_startup.3 \
-	libssh2_session_supported_algs.3 \
-	libssh2_sftp_close.3 \
-	libssh2_sftp_close_handle.3 \
-	libssh2_sftp_closedir.3 \
-	libssh2_sftp_fsetstat.3 \
-	libssh2_sftp_fstat.3 \
-	libssh2_sftp_fstat_ex.3 \
-	libssh2_sftp_fstatvfs.3 \
-	libssh2_sftp_fsync.3 \
-	libssh2_sftp_get_channel.3 \
-	libssh2_sftp_init.3 \
-	libssh2_sftp_last_error.3 \
-	libssh2_sftp_lstat.3 \
-	libssh2_sftp_mkdir.3 \
-	libssh2_sftp_mkdir_ex.3 \
-	libssh2_sftp_open.3 \
-	libssh2_sftp_open_ex.3 \
-	libssh2_sftp_opendir.3 \
-	libssh2_sftp_read.3 \
-	libssh2_sftp_readdir.3 \
-	libssh2_sftp_readdir_ex.3 \
-	libssh2_sftp_readlink.3 \
-	libssh2_sftp_realpath.3 \
-	libssh2_sftp_rename.3 \
-	libssh2_sftp_rename_ex.3 \
-	libssh2_sftp_rewind.3 \
-	libssh2_sftp_rmdir.3 \
-	libssh2_sftp_rmdir_ex.3 \
-	libssh2_sftp_seek.3 \
-	libssh2_sftp_seek64.3 \
-	libssh2_sftp_setstat.3 \
-	libssh2_sftp_shutdown.3 \
-	libssh2_sftp_stat.3 \
-	libssh2_sftp_stat_ex.3 \
-	libssh2_sftp_statvfs.3 \
-	libssh2_sftp_symlink.3 \
-	libssh2_sftp_symlink_ex.3 \
-	libssh2_sftp_tell.3 \
-	libssh2_sftp_tell64.3 \
-	libssh2_sftp_unlink.3 \
-	libssh2_sftp_unlink_ex.3 \
-	libssh2_sftp_write.3 \
-	libssh2_trace.3 \
-	libssh2_trace_sethandler.3 \
-	libssh2_userauth_authenticated.3 \
-	libssh2_userauth_hostbased_fromfile.3 \
-	libssh2_userauth_hostbased_fromfile_ex.3 \
-	libssh2_userauth_keyboard_interactive.3 \
-	libssh2_userauth_keyboard_interactive_ex.3 \
-	libssh2_userauth_list.3 \
-	libssh2_userauth_password.3 \
-	libssh2_userauth_password_ex.3 \
-	libssh2_userauth_publickey.3 \
-	libssh2_userauth_publickey_fromfile.3 \
-	libssh2_userauth_publickey_fromfile_ex.3 \
-	libssh2_userauth_publickey_frommemory.3 \
-	libssh2_version.3
diff --git a/libssh2/libssh2/docs/Makefile.in b/libssh2/libssh2/docs/Makefile.in
deleted file mode 100644
index 40143ed1..00000000
--- a/libssh2/libssh2/docs/Makefile.in
+++ /dev/null
@@ -1,736 +0,0 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-# $Id: Makefile.am,v 1.37 2009/03/26 15:41:15 bagder Exp $
-VPATH = @srcdir@
-am__is_gnu_make = { \
-  if test -z '$(MAKELEVEL)'; then \
-    false; \
-  elif test -n '$(MAKE_HOST)'; then \
-    true; \
-  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
-    true; \
-  else \
-    false; \
-  fi; \
-}
-am__make_running_with_option = \
-  case $${target_option-} in \
-      ?) ;; \
-      *) echo "am__make_running_with_option: internal error: invalid" \
-              "target option '$${target_option-}' specified" >&2; \
-         exit 1;; \
-  esac; \
-  has_opt=no; \
-  sane_makeflags=$$MAKEFLAGS; \
-  if $(am__is_gnu_make); then \
-    sane_makeflags=$$MFLAGS; \
-  else \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        bs=\\; \
-        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
-          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
-    esac; \
-  fi; \
-  skip_next=no; \
-  strip_trailopt () \
-  { \
-    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
-  }; \
-  for flg in $$sane_makeflags; do \
-    test $$skip_next = yes && { skip_next=no; continue; }; \
-    case $$flg in \
-      *=*|--*) continue;; \
-        -*I) strip_trailopt 'I'; skip_next=yes;; \
-      -*I?*) strip_trailopt 'I';; \
-        -*O) strip_trailopt 'O'; skip_next=yes;; \
-      -*O?*) strip_trailopt 'O';; \
-        -*l) strip_trailopt 'l'; skip_next=yes;; \
-      -*l?*) strip_trailopt 'l';; \
-      -[dEDm]) skip_next=yes;; \
-      -[JT]) skip_next=yes;; \
-    esac; \
-    case $$flg in \
-      *$$target_option*) has_opt=yes; break;; \
-    esac; \
-  done; \
-  test $$has_opt = yes
-am__make_dryrun = (target_option=n; $(am__make_running_with_option))
-am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-build_triplet = @build@
-host_triplet = @host@
-subdir = docs
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
-CONFIG_CLEAN_FILES =
-CONFIG_CLEAN_VPATH_FILES =
-AM_V_P = $(am__v_P_@AM_V@)
-am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
-am__v_P_0 = false
-am__v_P_1 = :
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN     " $@;
-am__v_GEN_1 = 
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-am__v_at_1 = 
-SOURCES =
-DIST_SOURCES =
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
-am__vpath_adj = case $$p in \
-    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
-    *) f=$$p;; \
-  esac;
-am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
-am__install_max = 40
-am__nobase_strip_setup = \
-  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
-am__nobase_strip = \
-  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
-am__nobase_list = $(am__nobase_strip_setup); \
-  for p in $$list; do echo "$$p $$p"; done | \
-  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
-  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
-    if (++n[$$2] == $(am__install_max)) \
-      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
-    END { for (dir in files) print dir, files[dir] }'
-am__base_list = \
-  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
-  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
-am__uninstall_files_from_dir = { \
-  test -z "$$files" \
-    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
-    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
-         $(am__cd) "$$dir" && rm -f $$files; }; \
-  }
-man3dir = $(mandir)/man3
-am__installdirs = "$(DESTDIR)$(man3dir)"
-NROFF = nroff
-MANS = $(dist_man_MANS)
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-am__DIST_COMMON = $(dist_man_MANS) $(srcdir)/Makefile.in AUTHORS TODO
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AR = @AR@
-AS = @AS@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CSCOPE = @CSCOPE@
-CTAGS = @CTAGS@
-CXX = @CXX@
-CXXCPP = @CXXCPP@
-CXXDEPMODE = @CXXDEPMODE@
-CXXFLAGS = @CXXFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-DLLTOOL = @DLLTOOL@
-DSYMUTIL = @DSYMUTIL@
-DUMPBIN = @DUMPBIN@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EGREP = @EGREP@
-ETAGS = @ETAGS@
-EXEEXT = @EXEEXT@
-FGREP = @FGREP@
-GREP = @GREP@
-HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
-HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
-HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
-HAVE_LIBSSL = @HAVE_LIBSSL@
-HAVE_LIBZ = @HAVE_LIBZ@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBBCRYPT = @LIBBCRYPT@
-LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
-LIBGCRYPT = @LIBGCRYPT@
-LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
-LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
-LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
-LIBSSL = @LIBSSL@
-LIBSSL_PREFIX = @LIBSSL_PREFIX@
-LIBTOOL = @LIBTOOL@
-LIBZ = @LIBZ@
-LIBZ_PREFIX = @LIBZ_PREFIX@
-LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
-LIPO = @LIPO@
-LN_S = @LN_S@
-LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
-LTLIBGCRYPT = @LTLIBGCRYPT@
-LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
-LTLIBOBJS = @LTLIBOBJS@
-LTLIBSSL = @LTLIBSSL@
-LTLIBZ = @LTLIBZ@
-LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MANIFEST_TOOL = @MANIFEST_TOOL@
-MKDIR_P = @MKDIR_P@
-NM = @NM@
-NMEDIT = @NMEDIT@
-OBJDUMP = @OBJDUMP@
-OBJEXT = @OBJEXT@
-OTOOL = @OTOOL@
-OTOOL64 = @OTOOL64@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-RANLIB = @RANLIB@
-SED = @SED@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-SSHD = @SSHD@
-STRIP = @STRIP@
-VERSION = @VERSION@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_AR = @ac_ct_AR@
-ac_ct_CC = @ac_ct_CC@
-ac_ct_CXX = @ac_ct_CXX@
-ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build = @build@
-build_alias = @build_alias@
-build_cpu = @build_cpu@
-build_os = @build_os@
-build_vendor = @build_vendor@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-docdir = @docdir@
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-host = @host@
-host_alias = @host_alias@
-host_cpu = @host_cpu@
-host_os = @host_os@
-host_vendor = @host_vendor@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-runstatedir = @runstatedir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-EXTRA_DIST = template.3 BINDINGS INSTALL_AUTOTOOLS INSTALL_CMAKE.md HACKING TODO \
- AUTHORS CMakeLists.txt HACKING-CRYPTO SECURITY.md
-
-dist_man_MANS = \
-	libssh2_agent_connect.3 \
-	libssh2_agent_disconnect.3 \
-	libssh2_agent_free.3 \
-	libssh2_agent_get_identity.3 \
-	libssh2_agent_get_identity_path.3 \
-	libssh2_agent_init.3 \
-	libssh2_agent_list_identities.3 \
-	libssh2_agent_set_identity_path.3 \
-	libssh2_agent_userauth.3 \
-	libssh2_banner_set.3 \
-	libssh2_base64_decode.3 \
-	libssh2_channel_close.3 \
-	libssh2_channel_direct_tcpip.3 \
-	libssh2_channel_direct_tcpip_ex.3 \
-	libssh2_channel_eof.3 \
-	libssh2_channel_exec.3 \
-	libssh2_channel_flush.3 \
-	libssh2_channel_flush_ex.3 \
-	libssh2_channel_flush_stderr.3 \
-	libssh2_channel_forward_accept.3 \
-	libssh2_channel_forward_cancel.3 \
-	libssh2_channel_forward_listen.3 \
-	libssh2_channel_forward_listen_ex.3 \
-	libssh2_channel_free.3 \
-	libssh2_channel_get_exit_signal.3 \
-	libssh2_channel_get_exit_status.3 \
-	libssh2_channel_handle_extended_data.3 \
-	libssh2_channel_handle_extended_data2.3 \
-	libssh2_channel_ignore_extended_data.3 \
-	libssh2_channel_open_ex.3 \
-	libssh2_channel_open_session.3 \
-	libssh2_channel_process_startup.3 \
-	libssh2_channel_read.3 \
-	libssh2_channel_read_ex.3 \
-	libssh2_channel_read_stderr.3 \
-	libssh2_channel_receive_window_adjust.3 \
-	libssh2_channel_receive_window_adjust2.3 \
-	libssh2_channel_request_pty.3 \
-	libssh2_channel_request_pty_ex.3 \
-	libssh2_channel_request_pty_size.3 \
-	libssh2_channel_request_pty_size_ex.3 \
-	libssh2_channel_send_eof.3 \
-	libssh2_channel_set_blocking.3 \
-	libssh2_channel_setenv.3 \
-	libssh2_channel_setenv_ex.3 \
-	libssh2_channel_shell.3 \
-	libssh2_channel_subsystem.3 \
-	libssh2_channel_wait_closed.3 \
-	libssh2_channel_wait_eof.3 \
-	libssh2_channel_window_read.3 \
-	libssh2_channel_window_read_ex.3 \
-	libssh2_channel_window_write.3 \
-	libssh2_channel_window_write_ex.3 \
-	libssh2_channel_write.3 \
-	libssh2_channel_write_ex.3 \
-	libssh2_channel_write_stderr.3 \
-	libssh2_channel_x11_req.3 \
-	libssh2_channel_x11_req_ex.3 \
-	libssh2_exit.3 \
-	libssh2_free.3 \
-	libssh2_hostkey_hash.3 \
-	libssh2_init.3 \
-	libssh2_keepalive_config.3 \
-	libssh2_keepalive_send.3 \
-	libssh2_knownhost_add.3 \
-	libssh2_knownhost_addc.3 \
-	libssh2_knownhost_check.3 \
-	libssh2_knownhost_checkp.3 \
-	libssh2_knownhost_del.3 \
-	libssh2_knownhost_free.3 \
-	libssh2_knownhost_get.3 \
-	libssh2_knownhost_init.3 \
-	libssh2_knownhost_readfile.3 \
-	libssh2_knownhost_readline.3 \
-	libssh2_knownhost_writefile.3 \
-	libssh2_knownhost_writeline.3 \
-	libssh2_poll.3 \
-	libssh2_poll_channel_read.3 \
-	libssh2_publickey_add.3 \
-	libssh2_publickey_add_ex.3 \
-	libssh2_publickey_init.3 \
-	libssh2_publickey_list_fetch.3 \
-	libssh2_publickey_list_free.3 \
-	libssh2_publickey_remove.3 \
-	libssh2_publickey_remove_ex.3 \
-	libssh2_publickey_shutdown.3 \
-	libssh2_scp_recv.3 \
-	libssh2_scp_recv2.3 \
-	libssh2_scp_send.3 \
-	libssh2_scp_send64.3 \
-	libssh2_scp_send_ex.3 \
-	libssh2_session_abstract.3 \
-	libssh2_session_banner_get.3 \
-	libssh2_session_banner_set.3 \
-	libssh2_session_block_directions.3 \
-	libssh2_session_callback_set.3 \
-	libssh2_session_disconnect.3 \
-	libssh2_session_disconnect_ex.3 \
-	libssh2_session_flag.3 \
-	libssh2_session_free.3 \
-	libssh2_session_get_blocking.3 \
-	libssh2_session_get_timeout.3 \
-	libssh2_session_handshake.3 \
-	libssh2_session_hostkey.3 \
-	libssh2_session_init.3 \
-	libssh2_session_init_ex.3 \
-	libssh2_session_last_errno.3 \
-	libssh2_session_last_error.3 \
-	libssh2_session_set_last_error.3 \
-	libssh2_session_method_pref.3 \
-	libssh2_session_methods.3 \
-	libssh2_session_set_blocking.3 \
-	libssh2_session_set_timeout.3 \
-	libssh2_session_startup.3 \
-	libssh2_session_supported_algs.3 \
-	libssh2_sftp_close.3 \
-	libssh2_sftp_close_handle.3 \
-	libssh2_sftp_closedir.3 \
-	libssh2_sftp_fsetstat.3 \
-	libssh2_sftp_fstat.3 \
-	libssh2_sftp_fstat_ex.3 \
-	libssh2_sftp_fstatvfs.3 \
-	libssh2_sftp_fsync.3 \
-	libssh2_sftp_get_channel.3 \
-	libssh2_sftp_init.3 \
-	libssh2_sftp_last_error.3 \
-	libssh2_sftp_lstat.3 \
-	libssh2_sftp_mkdir.3 \
-	libssh2_sftp_mkdir_ex.3 \
-	libssh2_sftp_open.3 \
-	libssh2_sftp_open_ex.3 \
-	libssh2_sftp_opendir.3 \
-	libssh2_sftp_read.3 \
-	libssh2_sftp_readdir.3 \
-	libssh2_sftp_readdir_ex.3 \
-	libssh2_sftp_readlink.3 \
-	libssh2_sftp_realpath.3 \
-	libssh2_sftp_rename.3 \
-	libssh2_sftp_rename_ex.3 \
-	libssh2_sftp_rewind.3 \
-	libssh2_sftp_rmdir.3 \
-	libssh2_sftp_rmdir_ex.3 \
-	libssh2_sftp_seek.3 \
-	libssh2_sftp_seek64.3 \
-	libssh2_sftp_setstat.3 \
-	libssh2_sftp_shutdown.3 \
-	libssh2_sftp_stat.3 \
-	libssh2_sftp_stat_ex.3 \
-	libssh2_sftp_statvfs.3 \
-	libssh2_sftp_symlink.3 \
-	libssh2_sftp_symlink_ex.3 \
-	libssh2_sftp_tell.3 \
-	libssh2_sftp_tell64.3 \
-	libssh2_sftp_unlink.3 \
-	libssh2_sftp_unlink_ex.3 \
-	libssh2_sftp_write.3 \
-	libssh2_trace.3 \
-	libssh2_trace_sethandler.3 \
-	libssh2_userauth_authenticated.3 \
-	libssh2_userauth_hostbased_fromfile.3 \
-	libssh2_userauth_hostbased_fromfile_ex.3 \
-	libssh2_userauth_keyboard_interactive.3 \
-	libssh2_userauth_keyboard_interactive_ex.3 \
-	libssh2_userauth_list.3 \
-	libssh2_userauth_password.3 \
-	libssh2_userauth_password_ex.3 \
-	libssh2_userauth_publickey.3 \
-	libssh2_userauth_publickey_fromfile.3 \
-	libssh2_userauth_publickey_fromfile_ex.3 \
-	libssh2_userauth_publickey_frommemory.3 \
-	libssh2_version.3
-
-all: all-am
-
-.SUFFIXES:
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
-	        && { if test -f $@; then exit 0; else break; fi; }; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign docs/Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign docs/Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
-	esac;
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-
-$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(am__aclocal_m4_deps):
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-install-man3: $(dist_man_MANS)
-	@$(NORMAL_INSTALL)
-	@list1=''; \
-	list2='$(dist_man_MANS)'; \
-	test -n "$(man3dir)" \
-	  && test -n "`echo $$list1$$list2`" \
-	  || exit 0; \
-	echo " $(MKDIR_P) '$(DESTDIR)$(man3dir)'"; \
-	$(MKDIR_P) "$(DESTDIR)$(man3dir)" || exit 1; \
-	{ for i in $$list1; do echo "$$i"; done;  \
-	if test -n "$$list2"; then \
-	  for i in $$list2; do echo "$$i"; done \
-	    | sed -n '/\.3[a-z]*$$/p'; \
-	fi; \
-	} | while read p; do \
-	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; echo "$$p"; \
-	done | \
-	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
-	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
-	sed 'N;N;s,\n, ,g' | { \
-	list=; while read file base inst; do \
-	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
-	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man3dir)/$$inst'"; \
-	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man3dir)/$$inst" || exit $$?; \
-	  fi; \
-	done; \
-	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
-	while read files; do \
-	  test -z "$$files" || { \
-	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man3dir)'"; \
-	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man3dir)" || exit $$?; }; \
-	done; }
-
-uninstall-man3:
-	@$(NORMAL_UNINSTALL)
-	@list=''; test -n "$(man3dir)" || exit 0; \
-	files=`{ for i in $$list; do echo "$$i"; done; \
-	l2='$(dist_man_MANS)'; for i in $$l2; do echo "$$i"; done | \
-	  sed -n '/\.3[a-z]*$$/p'; \
-	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^3][0-9a-z]*$$,3,;x' \
-	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
-	dir='$(DESTDIR)$(man3dir)'; $(am__uninstall_files_from_dir)
-tags TAGS:
-
-ctags CTAGS:
-
-cscope cscopelist:
-
-distdir: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-check-am: all-am
-check: check-am
-all-am: Makefile $(MANS)
-installdirs:
-	for dir in "$(DESTDIR)$(man3dir)"; do \
-	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
-	done
-install: install-am
-install-exec: install-exec-am
-install-data: install-data-am
-uninstall: uninstall-am
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-am
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-clean: clean-am
-
-clean-am: clean-generic clean-libtool mostlyclean-am
-
-distclean: distclean-am
-	-rm -f Makefile
-distclean-am: clean-am distclean-generic
-
-dvi: dvi-am
-
-dvi-am:
-
-html: html-am
-
-html-am:
-
-info: info-am
-
-info-am:
-
-install-data-am: install-man
-
-install-dvi: install-dvi-am
-
-install-dvi-am:
-
-install-exec-am:
-
-install-html: install-html-am
-
-install-html-am:
-
-install-info: install-info-am
-
-install-info-am:
-
-install-man: install-man3
-
-install-pdf: install-pdf-am
-
-install-pdf-am:
-
-install-ps: install-ps-am
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-am
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-am
-
-mostlyclean-am: mostlyclean-generic mostlyclean-libtool
-
-pdf: pdf-am
-
-pdf-am:
-
-ps: ps-am
-
-ps-am:
-
-uninstall-am: uninstall-man
-
-uninstall-man: uninstall-man3
-
-.MAKE: install-am install-strip
-
-.PHONY: all all-am check check-am clean clean-generic clean-libtool \
-	cscopelist-am ctags-am distclean distclean-generic \
-	distclean-libtool distdir dvi dvi-am html html-am info info-am \
-	install install-am install-data install-data-am install-dvi \
-	install-dvi-am install-exec install-exec-am install-html \
-	install-html-am install-info install-info-am install-man \
-	install-man3 install-pdf install-pdf-am install-ps \
-	install-ps-am install-strip installcheck installcheck-am \
-	installdirs maintainer-clean maintainer-clean-generic \
-	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
-	ps ps-am tags-am uninstall uninstall-am uninstall-man \
-	uninstall-man3
-
-.PRECIOUS: Makefile
-
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/libssh2/libssh2/docs/SECURITY.md b/libssh2/libssh2/docs/SECURITY.md
deleted file mode 100644
index 6f442eb6..00000000
--- a/libssh2/libssh2/docs/SECURITY.md
+++ /dev/null
@@ -1,100 +0,0 @@
-libssh2 security
-================
-
-This document is intended to provide guidance on how security vulnerabilities
-should be handled in the libssh2 project.
-
-Publishing Information
-----------------------
-
-All known and public libssh2 vulnerabilities will be listed on [the libssh2
-web site](https://www.libssh2.org/).
-
-Security vulnerabilities should not be entered in the project's public bug
-tracker unless the necessary configuration is in place to limit access to the
-issue to only the reporter and the project's security team.
-
-Vulnerability Handling
-----------------------
-
-The typical process for handling a new security vulnerability is as follows.
-
-No information should be made public about a vulnerability until it is
-formally announced at the end of this process. That means, for example that a
-bug tracker entry must NOT be created to track the issue since that will make
-the issue public and it should not be discussed on the project's public
-mailing list. Also messages associated with any commits should not make any
-reference to the security nature of the commit if done prior to the public
-announcement.
-
-- The person discovering the issue, the reporter, reports the vulnerability
-  privately to `libssh2-security@haxx.se`. That's an email alias that reaches a
-  handful of selected and trusted people.
-
-- Messages that do not relate to the reporting or managing of an undisclosed
-  security vulnerability in libssh2 are ignored and no further action is
-  required.
-
-- A person in the security team sends an e-mail to the original reporter to
-  acknowledge the report.
-
-- The security team investigates the report and either rejects it or accepts
-  it.
-
-- If the report is rejected, the team writes to the reporter to explain why.
-
-- If the report is accepted, the team writes to the reporter to let him/her
-  know it is accepted and that they are working on a fix.
-
-- The security team discusses the problem, works out a fix, considers the
-  impact of the problem and suggests a release schedule. This discussion
-  should involve the reporter as much as possible.
-
-- The release of the information should be "as soon as possible" and is most
-  often synced with an upcoming release that contains the fix. If the
-  reporter, or anyone else, thinks the next planned release is too far away
-  then a separate earlier release for security reasons should be considered.
-
-- Write a security advisory draft about the problem that explains what the
-  problem is, its impact, which versions it affects, solutions or
-  workarounds, when the release is out and make sure to credit all
-  contributors properly.
-
-- Request a CVE number from
-  [distros@openwall](http://oss-security.openwall.org/wiki/mailing-lists/distros)
-  when also informing and preparing them for the upcoming public security
-  vulnerability announcement - attach the advisory draft for information. Note
-  that 'distros' won't accept an embargo longer than 14 days.
-
-- Update the "security advisory" with the CVE number.
-
-- The security team commits the fix in a private branch. The commit message
-  should ideally contain the CVE number. This fix is usually also distributed
-  to the 'distros' mailing list to allow them to use the fix prior to the
-  public announcement.
-
-- At the day of the next release, the private branch is merged into the master
-  branch and pushed. Once pushed, the information is accessible to the public
-  and the actual release should follow suit immediately afterwards.
-
-- The project team creates a release that includes the fix.
-
-- The project team announces the release and the vulnerability to the world in
-  the same manner we always announce releases. It gets sent to the libssh2
-  mailing list and the oss-security mailing list.
-
-- The security web page on the web site should get the new vulnerability
-  mentioned.
-
-LIBSSH2-SECURITY (at haxx dot se)
---------------------------------
-
-Who is on this list? There are a couple of criteria you must meet, and then we
-might ask you to join the list or you can ask to join it. It really isn't very
-formal. We basically only require that you have a long-term presence in the
-libssh2 project and you have shown an understanding for the project and its way
-of working. You must've been around for a good while and you should have no
-plans in vanishing in the near future.
-
-We do not make the list of participants public mostly because it tends to vary
-somewhat over time and a list somewhere will only risk getting outdated.
diff --git a/libssh2/libssh2/docs/TODO b/libssh2/libssh2/docs/TODO
deleted file mode 100644
index cae1afa7..00000000
--- a/libssh2/libssh2/docs/TODO
+++ /dev/null
@@ -1,174 +0,0 @@
-Things TODO
-===========
-
-* Fix the numerous malloc+copy operations for sending data, see "Buffering
-  Improvements" below for details
-
-* make sure the windowing code adapts better to slow situations so that it
-  doesn't then use as much memory as today. Possibly by an app-controllable
-  "Window mode"?
-
-* Decrease the number of mallocs. Everywhere. Will get easier once the
-  buffering improvements have been done.
-
-* Use SO_NOSIGPIPE for Mac OS/BSD systems where MSG_NOSIGNAL doesn't
-  exist/work
-
-* Extend the test suite to actually test lots of aspects of libssh2
-
-* Fix all compiler warnings (some can't be done without API changes)
-
-* Expose error messages sent by the server
-
-* select() is troublesome with libssh2 when using multiple channels over
-  the same session. See "New Transport API" below for more details.
-
-At next SONAME bump
-===================
-
-* stop using #defined macros as part of the official API. The macros should
-  either be turned into real functions or discarded from the API.
-
-* fix the parts of the API where object pointers and function pointers are
-  mixed like libssh2_session_callback_set()
-
-* remove the following functions from the API/ABI
-
-  libssh2_base64_decode()
-  libssh2_session_flag()
-  libssh2_channel_handle_extended_data()
-  libssh2_channel_receive_window_adjust()
-  libssh2_poll()
-  libssh2_poll_channel_read()
-  libssh2_session_startup() (libssh2_session_handshake() is the replacement)
-  libssh2_banner_set() (libssh2_session_banner_set() is the repacement)
-
-* Rename a few function:
-
-  libssh2_hostkey_hash => libssh2_session_hostkey_hash
-  libssh2_banner_set => libssh2_session_banner_set
-
-* change 'int' to 'libssh2_socket_t' in the public API for sockets.
-
-* Use 'size_t' for string lengths in all functions.
-
-* Add a comment field to struct libssh2_knownhost.
-
-* remove the existing libssh2_knownhost_add() function and rename
-  libssh2_knownhost_addc to become the new libssh2_knownhost_add instead
-
-* remove the existing libssh2_scp_send_ex() function and rename
-  libssh2_scp_send64 to become the new libssh2_scp_send instead.
-
-* remove the existing libssh2_knownhost_check() functin and rename
-  libssh2_knownhost_checkp() to become the new libssh2_knownhost_check instead
-
-Buffering Improvements
-======================
-
-transport_write
-
-  - If this function gets called with a total packet size that is larger than
-  32K, it should create more than one SSH packet so that it keeps the largest
-  one below 32K
-
-sftp_write
-
-  - should not copy/allocate anything for the data, only create a header chunk
-  and pass on the payload data to channel_write "pointed to"
-
-New Transport API
-=================
-
-THE PROBLEM
-
-The problem in a nutshell is that when an application opens up multiple
-channels over a single session, those are all using the same socket. If the
-application is then using select() to wait for traffic (like any sensible app
-does) and wants to act on the data when select() tells there is something to
-for example read, what does an application do?
-
-With our current API, you have to loop over all the channels and read from
-them to see if they have data. This effectively makes blocking reads
-impossible. If the app has many channels in a setup like this, it even becomes
-slow. (The original API had the libssh2_poll_channel_read() and libssh2_poll()
-to somewhat overcome this hurdle, but they too have pretty much the same
-problems plus a few others.)
-
-Traffic in the other direction is similarly limited: the app has to try
-sending to all channels, even though some of them may very well not accept any
-data at that point.
-
-A SOLUTION
-
-I suggest we introduce two new helper functions:
-
- libssh2_transport_read()
-
- - Read "a bunch" of data from the given socket and returns information to the
-   app about what channels that are now readable (ie they will not block when
-   read from). The function can be called over and over and it will repeatedly
-   return info about what channels that are readable at that moment.
-
- libssh2_transport_write()
-
- - Returns information about what channels that are writable, in the sense
-   that they have windows set from the remote side that allows data to get
-   sent. Writing to one of those channels will not block. Of course, the
-   underlying socket may only accept a certain amount of data, so at the first
-   short return, nothing more should be attempted to get sent until select()
-   (or equivalent) has been used on the master socket again.
-
-I haven't yet figured out a sensible API for how these functions should return
-that info, but if we agree on the general principles I guess we can work that
-out.
-
-VOLUNTARY
-
-  I wanted to mention that these two helper functions would not be mandatory
-  in any way. They would just be there for those who want them, and existing
-  programs can remain using the old functions only if they prefer to.
-
-New SFTP API
-============
-
-PURPOSE
-
- Provide API functions that explicitly tells at once that a (full) SFTP file
- transfer is wanted, to allow libssh2 to leverage on that knowledge to speed
- up things internally. It can for example do read ahead, buffer writes (merge
- small writes into larger chunks), better tune the SSH window and more. This
- sort of API is already provided for SCP transfers.
-
-API
-
- New functions:
-
-    LIBSSH2_SFTP_HANDLE *libssh2_sftp_send(SFTP_SESSION *sftp,
-                                           uint64_t filesize,
-                                           char *remote_path,
-                                           size_t remote_path_len,
-                                           long mode);
-
- Tell libssh2 that a local file with a given size is about to get sent to
- the SFTP server.
-
-    LIBSSH2_SFTP_HANDLE *libssh2_sftp_recv();
-
- Tell libssh2 that a remote file is requested to get downloaded from the SFTP
- server.
-
- Only the setup of the file transfer is different from an application's point
- of view. Depending on direction of the transfer(s), the following already
- existing functions should then be used until the transfer is complete:
-
- libssh2_sftp_read()
- libssh2_sftp_write()
-
-HOW TO USE
-
- 1. Setup the transfer using one of the two new functions.
-
- 2. Loop through the reading or writing of data.
-
- 3. Cleanup the transfer
diff --git a/libssh2/libssh2/docs/libssh2_agent_connect.3 b/libssh2/libssh2/docs/libssh2_agent_connect.3
deleted file mode 100644
index 1c6ff6d9..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_connect.3
+++ /dev/null
@@ -1,23 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_connect 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_connect - connect to an ssh-agent
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_agent_connect(LIBSSH2_AGENT *agent);
-.SH DESCRIPTION
-Connect to an ssh-agent running on the system.
-
-Call \fBlibssh2_agent_disconnect(3)\fP to close the connection after
-you're doing using it.
-.SH RETURN VALUE
-Returns 0 if succeeded, or a negative value for error.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_init(3)
-.BR libssh2_agent_disconnect(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_agent_disconnect.3 b/libssh2/libssh2/docs/libssh2_agent_disconnect.3
deleted file mode 100644
index f9f9ef07..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_disconnect.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_disconnect 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_disconnect - close a connection to an ssh-agent
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_agent_disconnect(LIBSSH2_AGENT *agent);
-.SH DESCRIPTION
-Close a connection to an ssh-agent.
-
-.SH RETURN VALUE
-Returns 0 if succeeded, or a negative value for error.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_connect(3)
-.BR libssh2_agent_free(3)
diff --git a/libssh2/libssh2/docs/libssh2_agent_free.3 b/libssh2/libssh2/docs/libssh2_agent_free.3
deleted file mode 100644
index 197f87eb..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_free.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_free 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_free - free an ssh-agent handle
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void libssh2_agent_free(LIBSSH2_AGENT *agent);
-.SH DESCRIPTION
-Free an ssh-agent handle.  This function also frees the internal
-collection of public keys.
-.SH RETURN VALUE
-None.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_init(3)
-.BR libssh2_agent_disconnect(3)
diff --git a/libssh2/libssh2/docs/libssh2_agent_get_identity.3 b/libssh2/libssh2/docs/libssh2_agent_get_identity.3
deleted file mode 100644
index a9441656..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_get_identity.3
+++ /dev/null
@@ -1,34 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_get_identity 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_get_identity - get a public key off the collection of public keys managed by ssh-agent
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
-                               struct libssh2_agent_publickey **store,
-                               struct libssh2_agent_publickey *prev);
-.SH DESCRIPTION
-\fIlibssh2_agent_get_identity(3)\fP allows an application to iterate
-over all public keys in the collection managed by ssh-agent.
-
-\fIstore\fP should point to a pointer that gets filled in to point to the
-public key data.
-
-\fIprev\fP is a pointer to a previous 'struct libssh2_agent_publickey'
-as returned by a previous invoke of this function, or NULL to get the
-first entry in the internal collection.
-.SH RETURN VALUE
-Returns 0 if everything is fine and information about a host was stored in
-the \fIstore\fP struct.
-
-Returns 1 if it reached the end of public keys.
-
-Returns negative values for error
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_list_identities(3)
-.BR libssh2_agent_userauth(3)
diff --git a/libssh2/libssh2/docs/libssh2_agent_get_identity_path.3 b/libssh2/libssh2/docs/libssh2_agent_get_identity_path.3
deleted file mode 100644
index 58d6dd56..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_get_identity_path.3
+++ /dev/null
@@ -1,22 +0,0 @@
-.\"
-.\" Copyright (c) 2019 by Will Cosgrove
-.\"
-.TH libssh2_agent_get_identity_path 3 "6 Mar 2019" "libssh2 1.9" "libssh2 manual"
-.SH NAME
-libssh2_agent_get_identity_path - gets the custom ssh-agent socket path
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *
-libssh2_agent_get_identity_path(LIBSSH2_AGENT *agent);
-.SH DESCRIPTION
-Returns the custom agent identity socket path if set using libssh2_agent_set_identity_path()
-
-.SH RETURN VALUE
-Returns the socket path on disk.
-.SH AVAILABILITY
-Added in libssh2 1.9
-.SH SEE ALSO
-.BR libssh2_agent_init(3)
-.BR libssh2_agent_set_identity_path(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_agent_init.3 b/libssh2/libssh2/docs/libssh2_agent_init.3
deleted file mode 100644
index 26e891e4..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_init.3
+++ /dev/null
@@ -1,26 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_init 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_init - init an ssh-agent handle
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_AGENT *libssh2_agent_init(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Init an ssh-agent handle. Returns the handle to an internal
-representation of an ssh-agent connection.  After the successful
-initialization, an application can call \fBlibssh2_agent_connect(3)\fP
-to connect to a running ssh-agent.
-
-Call \fBlibssh2_agent_free(3)\fP to free the handle again after you're
-doing using it.
-.SH RETURN VALUE
-Returns a handle pointer or NULL if something went wrong. The returned handle
-is used as input to all other ssh-agent related functions libssh2 provides.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_connect(3)
-.BR libssh2_agent_free(3)
diff --git a/libssh2/libssh2/docs/libssh2_agent_list_identities.3 b/libssh2/libssh2/docs/libssh2_agent_list_identities.3
deleted file mode 100644
index e1e4b545..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_list_identities.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_list_identities 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_list_identities - request an ssh-agent to list of public keys.
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
-.SH DESCRIPTION
-Request an ssh-agent to list of public keys, and stores them in the
-internal collection of the handle.  Call
-\fIlibssh2_agent_get_identity(3)\fP to get a public key off the
-collection.
-
-.SH RETURN VALUE
-Returns 0 if succeeded, or a negative value for error.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_connect(3)
-.BR libssh2_agent_get_identity(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_agent_set_identity_path.3 b/libssh2/libssh2/docs/libssh2_agent_set_identity_path.3
deleted file mode 100644
index 73e1266d..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_set_identity_path.3
+++ /dev/null
@@ -1,22 +0,0 @@
-.\"
-.\" Copyright (c) 2019 by Will Cosgrove
-.\"
-.TH libssh2_agent_set_identity_path 3 "6 Mar 2019" "libssh2 1.9" "libssh2 manual"
-.SH NAME
-libssh2_agent_set_identity_path - set an ssh-agent socket path on disk
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void
-libssh2_agent_set_identity_path(LIBSSH2_AGENT *agent, const char *path);
-.SH DESCRIPTION
-Allows a custom agent identity socket path instead of the default SSH_AUTH_SOCK env value
-
-.SH RETURN VALUE
-Returns void
-.SH AVAILABILITY
-Added in libssh2 1.9
-.SH SEE ALSO
-.BR libssh2_agent_init(3)
-.BR libssh2_agent_get_identity_path(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_agent_userauth.3 b/libssh2/libssh2/docs/libssh2_agent_userauth.3
deleted file mode 100644
index 3c956fec..00000000
--- a/libssh2/libssh2/docs/libssh2_agent_userauth.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daiki Ueno
-.\"
-.TH libssh2_agent_userauth 3 "23 Dec 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_agent_userauth - authenticate a session with a public key, with the help of ssh-agent
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_agent_userauth(LIBSSH2_AGENT *agent,
-                           const char *username,
-                           struct libssh2_agent_publickey *identity);
-.SH DESCRIPTION
-\fIagent\fP - ssh-agent handle as returned by 
-.BR libssh2_agent_init(3)
-
-\fIusername\fP - Remote user name to authenticate as.
-
-\fIidentity\fP - Public key to authenticate with, as returned by 
-.BR libssh2_agent_get_identity(3)
-
-Attempt public key authentication with the help of ssh-agent.
-.SH RETURN VALUE
-Returns 0 if succeeded, or a negative value for error.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_agent_init(3)
-.BR libssh2_agent_get_identity(3)
diff --git a/libssh2/libssh2/docs/libssh2_banner_set.3 b/libssh2/libssh2/docs/libssh2_banner_set.3
deleted file mode 100644
index 2baa121e..00000000
--- a/libssh2/libssh2/docs/libssh2_banner_set.3
+++ /dev/null
@@ -1,32 +0,0 @@
-.TH libssh2_banner_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_banner_set - set the SSH protocol banner for the local client
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_banner_set(LIBSSH2_SESSION *session, const char *banner);
-
-.SH DESCRIPTION
-This function is \fBDEPRECATED\fP. Use \fIlibssh2_session_banner_set(3)\fP
-instead!
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIbanner\fP - A pointer to a user defined banner
-
-Set the banner that will be sent to the remote host when the SSH session is 
-started with 
-.BR libssh2_session_handshake(3)
-  This is optional; a banner corresponding to the protocol and libssh2 version will be sent by default.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH AVAILABILITY
-Marked as deprecated since 1.4.0
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-.SH SEE ALSO
-.BR libssh2_session_handshake(3)
diff --git a/libssh2/libssh2/docs/libssh2_base64_decode.3 b/libssh2/libssh2/docs/libssh2_base64_decode.3
deleted file mode 100644
index 932f03a8..00000000
--- a/libssh2/libssh2/docs/libssh2_base64_decode.3
+++ /dev/null
@@ -1,25 +0,0 @@
-.TH libssh2_base64_decode 3 "23 Dec 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_base64_decode - decode a base64 encoded string
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
-                          unsigned int *dest_len, const char *src,
-                          unsigned int src_len);
-.SH DESCRIPTION
-This function is deemed DEPRECATED and will be removed from libssh2 in a
-future version. Don't use it!
-
-Decode a base64 chunk and store it into a newly allocated buffer. 'dest_len'
-will be set to hold the length of the returned buffer that '*dest' will point
-to.
-
-The returned buffer is allocated by this function, but it is not clear how to
-free that memory!
-.SH BUGS
-The memory that *dest points to is allocated by the malloc function libssh2
-uses, but there's no way for an application to free this data in a safe and
-reliable way!
-.SH RETURN VALUE
-0 if successful, \-1 if any error occurred.
diff --git a/libssh2/libssh2/docs/libssh2_channel_close.3 b/libssh2/libssh2/docs/libssh2_channel_close.3
deleted file mode 100644
index 2fe0a0d4..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_close.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.TH libssh2_channel_close 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_close - close a channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_close(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-\fIchannel\fP - active channel stream to set closed status on.
-
-Close an active data channel. In practice this means sending an SSH_MSG_CLOSE 
-packet to the remote host which serves as instruction that no further data 
-will be sent to it. The remote host may still send data back until it sends 
-its own close message in response. To wait for the remote end to close its 
-connection as well, follow this command with 
-.BR libssh2_channel_wait_closed(3)
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_direct_tcpip.3 b/libssh2/libssh2/docs/libssh2_channel_direct_tcpip.3
deleted file mode 100644
index 742769df..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_direct_tcpip.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_channel_direct_tcpip 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_direct_tcpip - convenience macro for \fIlibssh2_channel_direct_tcpip_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int port);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_direct_tcpip_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_direct_tcpip_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_direct_tcpip_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_direct_tcpip_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_direct_tcpip_ex.3 b/libssh2/libssh2/docs/libssh2_channel_direct_tcpip_ex.3
deleted file mode 100644
index 481c55ce..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_direct_tcpip_ex.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.TH libssh2_channel_direct_tcpip_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_direct_tcpip_ex - Tunnel a TCP connection through an SSH session
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL * 
-libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host, int port, const char *shost, int sport);
-
-LIBSSH2_CHANNEL * 
-libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int port);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIhost\fP - Third party host to connect to using the SSH host as a proxy.
-
-\fIport\fP - Port on third party host to connect to.
-
-\fIshost\fP - Host to tell the SSH server the connection originated on.
-
-\fIsport\fP - Port to tell the SSH server the connection originated from.
-
-Tunnel a TCP/IP connection through the SSH transport via the remote host to 
-a third party. Communication from the client to the SSH server remains 
-encrypted, communication from the server to the 3rd party host travels 
-in cleartext.
-
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_eof.3 b/libssh2/libssh2/docs/libssh2_channel_eof.3
deleted file mode 100644
index ed4a074b..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_eof.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_eof - check a channel's EOF status
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
-.SH DESCRIPTION
-\fIchannel\fP - active channel stream to set closed status on.
-
-Check if the remote host has sent an EOF status for the selected stream.
-.SH RETURN VALUE
-Returns 1 if the remote host has sent EOF, otherwise 0. Negative on
-failure.
-.SH SEE ALSO
-.BR libssh2_channel_close(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_exec.3 b/libssh2/libssh2/docs/libssh2_channel_exec.3
deleted file mode 100644
index 3ab069d7..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_exec.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_exec 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_exec - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_process_startup(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_process_startup(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_flush.3 b/libssh2/libssh2/docs/libssh2_channel_flush.3
deleted file mode 100644
index b449945b..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_flush.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_flush 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_flush - convenience macro for \fIlibssh2_channel_flush_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_flush_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_flush_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_flush_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_flush_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_flush_ex.3 b/libssh2/libssh2/docs/libssh2_channel_flush_ex.3
deleted file mode 100644
index 1885176b..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_flush_ex.3
+++ /dev/null
@@ -1,32 +0,0 @@
-.TH libssh2_channel_flush_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_flush_ex - flush a channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid);
-
-int 
-libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
-
-int 
-libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-\fIchannel\fP - Active channel stream to flush.
-
-\fIstreamid\fP - Specific substream number to flush. Groups of substreams may 
-be flushed by passing on of the following Constants.
-.br
-\fBLIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA\fP: Flush all extended data substreams
-.br
-\fBLIBSSH2_CHANNEL_FLUSH_ALL\fP: Flush all substreams
-
-Flush the read buffer for a given channel instance. Individual substreams may 
-be flushed by number or using one of the provided macros.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
diff --git a/libssh2/libssh2/docs/libssh2_channel_flush_stderr.3 b/libssh2/libssh2/docs/libssh2_channel_flush_stderr.3
deleted file mode 100644
index 156bb06f..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_flush_stderr.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_flush_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_flush_stderr - convenience macro for \fIlibssh2_channel_flush_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_flush_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_flush_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_flush_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_flush_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_forward_accept.3 b/libssh2/libssh2/docs/libssh2_channel_forward_accept.3
deleted file mode 100644
index 176ac1cd..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_forward_accept.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_channel_forward_accept 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_forward_accept - accept a queued connection
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);
-
-.SH DESCRIPTION
-\fIlistener\fP is a forwarding listener instance as returned by
-\fBlibssh2_channel_forward_listen_ex(3)\fP.
-.SH RETURN VALUE
-A newly allocated channel instance or NULL on failure.
-.SH ERRORS
-When this function returns NULL use \fIlibssh2_session_last_errno(3)\fP to
-extract the error code. If that code is \fILIBSSH2_ERROR_EAGAIN\fP, the
-session is set to do non-blocking I/O but the call would block.
-.SH SEE ALSO
-.BR libssh2_channel_forward_listen_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_forward_cancel.3 b/libssh2/libssh2/docs/libssh2_channel_forward_cancel.3
deleted file mode 100644
index 16f826fb..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_forward_cancel.3
+++ /dev/null
@@ -1,27 +0,0 @@
-.TH libssh2_channel_forward_cancel 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_forward_cancel - cancel a forwarded TCP port
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
-
-.SH DESCRIPTION
-\fIlistener\fP - Forwarding listener instance as returned by 
-.BR libssh2_channel_forward_listen_ex(3)
-
-Instruct the remote host to stop listening for new connections on a previously requested host/port.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-.SH SEE ALSO
-.BR libssh2_channel_forward_listen_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_forward_listen.3 b/libssh2/libssh2/docs/libssh2_channel_forward_listen.3
deleted file mode 100644
index 6cb54e73..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_forward_listen.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_forward_listen 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_forward_listen - convenience macro for \fIlibssh2_channel_forward_listen_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_forward_listen_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_forward_listen_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_forward_listen_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_forward_listen_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_forward_listen_ex.3 b/libssh2/libssh2/docs/libssh2_channel_forward_listen_ex.3
deleted file mode 100644
index a358f6ce..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_forward_listen_ex.3
+++ /dev/null
@@ -1,46 +0,0 @@
-.TH libssh2_channel_forward_listen_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_forward_listen_ex - listen to inbound connections
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_LISTENER * 
-libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, char *host, int port, int *bound_port, int queue_maxsize);
-
-LIBSSH2_LISTENER * 
-libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
-
-.SH DESCRIPTION
-Instruct the remote SSH server to begin listening for inbound TCP/IP
-connections. New connections will be queued by the library until accepted by
-\fIlibssh2_channel_forward_accept(3)\fP.
-
-\fIsession\fP - instance as returned by libssh2_session_init(). 
-
-\fIhost\fP - specific address to bind to on the remote host. Binding to
-0.0.0.0 (default when NULL is passed) will bind to all available addresses.
-
-\fIport\fP - port to bind to on the remote host. When 0 is passed, the remote
-host will select the first available dynamic port.
-
-\fIbound_port\fP - Populated with the actual port bound on the remote
-host. Useful when requesting dynamic port numbers.
-
-\fIqueue_maxsize\fP - Maximum number of pending connections to queue before
-rejecting further attempts.
-
-\fIlibssh2_channel_forward_listen(3)\fP is a macro.
-.SH RETURN VALUE
-A newly allocated LIBSSH2_LISTENER instance or NULL on failure.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_PROTO\fP - An invalid SSH protocol response was received on the socket.
-
-\fILIBSSH2_ERROR_REQUEST_DENIED\fP - The remote server refused the request.
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-.SH SEE ALSO
-.BR libssh2_channel_forward_accept(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_free.3 b/libssh2/libssh2/docs/libssh2_channel_free.3
deleted file mode 100644
index fc76f5a8..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_free.3
+++ /dev/null
@@ -1,25 +0,0 @@
-.TH libssh2_channel_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_free - free all resources associated with a channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_free(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-\fIchannel\fP - Channel stream to free.
-
-Release all resources associated with a channel stream. If the channel has 
-not yet been closed with 
-.BR libssh2_channel_close(3)
-, it will be called automatically so that the remote end may know that it 
-can safely free its own resources.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH SEE ALSO
-.BR libssh2_channel_close(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_get_exit_signal.3 b/libssh2/libssh2/docs/libssh2_channel_get_exit_signal.3
deleted file mode 100644
index 138e7c72..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_get_exit_signal.3
+++ /dev/null
@@ -1,34 +0,0 @@
-.TH libssh2_channel_get_exit_signal 3 "4 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
-.SH NAME
-libssh2_channel_get_exit_signal - get the remote exit signal
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel, char **exitsignal, size_t *exitsignal_len, char **errmsg, size_t *errmsg_len, char **langtag, size_t *langtag_len);
-
-.SH DESCRIPTION
-\fIchannel\fP - Closed channel stream to retrieve exit signal from.
-
-\fIexitsignal\fP - If not NULL, is populated by reference with the exit signal
-(without leading "SIG"). Note that the string is stored in a newly allocated
-buffer. If the remote program exited cleanly, the referenced string pointer
-will be set to NULL. 
-
-\fIexitsignal_len\fP - If not NULL, is populated by reference with the length
-of exitsignal. 
-
-\fIerrmsg\fP - If not NULL, is populated by reference with the error message
-(if provided by remote server, if not it will be set to NULL). Note that the
-string is stored in a newly allocated buffer.
-
-\fIerrmsg_len\fP - If not NULL, is populated by reference with the length of errmsg.
-
-\fIlangtag\fP - If not NULL, is populated by reference with the language tag 
-(if provided by remote server, if not it will be set to NULL). Note that the
-string is stored in a newly allocated buffer.
-
-\fIlangtag_len\fP - If not NULL, is populated by reference with the length of langtag.
-
-.SH RETURN VALUE
-Numeric error code corresponding to the the Error Code constants.
diff --git a/libssh2/libssh2/docs/libssh2_channel_get_exit_status.3 b/libssh2/libssh2/docs/libssh2_channel_get_exit_status.3
deleted file mode 100644
index 4a8c9e2f..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_get_exit_status.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_channel_get_exit_status 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_get_exit_status - get the remote exit code
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel)
-
-.SH DESCRIPTION
-\fIchannel\fP - Closed channel stream to retrieve exit status from.
-
-Returns the exit code raised by the process running on the remote host at 
-the other end of the named channel. Note that the exit status may not be 
-available if the remote end has not yet set its status to closed.
-
-.SH RETURN VALUE
-Returns 0 on failure, otherwise the \fIExit Status\fP reported by remote host
diff --git a/libssh2/libssh2/docs/libssh2_channel_handle_extended_data.3 b/libssh2/libssh2/docs/libssh2_channel_handle_extended_data.3
deleted file mode 100644
index 8ab24883..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_handle_extended_data.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.TH libssh2_channel_handle_extended_data 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_handle_extended_data - set extended data handling mode
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void 
-libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);
-
-.SH DESCRIPTION
-This function is deprecated. Use the
-\fIlibssh2_channel_handle_extended_data2(3)\fP function instead!
-
-\fIchannel\fP - Active channel stream to change extended data handling on.
-
-\fIignore_mode\fP - One of the three LIBSSH2_CHANNEL_EXTENDED_DATA_* Constants.
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual 
-reading
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_MERGE\fP: Treat extended data and ordinary
-data the same. Merge all substreams such that calls to
-\fIlibssh2_channel_read(3)\fP will pull from all substreams on a
-first-in/first-out basis.
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it 
-arrives.
-
-Change how a channel deals with extended data packets. By default all extended
-data is queued until read by \fIlibssh2_channel_read_ex(3)\fP
-.SH RETURN VALUE
-None.
-.SH SEE ALSO
-.BR libssh2_channel_handle_extended_data2(3)
-.BR libssh2_channel_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_handle_extended_data2.3 b/libssh2/libssh2/docs/libssh2_channel_handle_extended_data2.3
deleted file mode 100644
index 8910d8ce..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_handle_extended_data2.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.TH libssh2_channel_handle_extended_data2 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_handle_extended_data2 - set extended data handling mode
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel, int ignore_mode);
-
-.SH DESCRIPTION
-\fIchannel\fP - Active channel stream to change extended data handling on.
-
-\fIignore_mode\fP - One of the three LIBSSH2_CHANNEL_EXTENDED_DATA_* Constants.
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL\fP: Queue extended data for eventual 
-reading
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_MERGE\fP: Treat extended data and ordinary 
-data the same. Merge all substreams such that calls to 
-.BR libssh2_channel_read(3)
-will pull from all substreams on a first-in/first-out basis.
-.br
-\fBLIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE\fP: Discard all extended data as it 
-arrives.
-
-Change how a channel deals with extended data packets. By default all 
-extended data is queued until read by 
-.BR libssh2_channel_read_ex(3)
-
-.SH RETURN VALUE
-Return 0 on success or LIBSSH2_ERROR_EAGAIN when it would otherwise block.
-
-.SH SEE ALSO
-.BR libssh2_channel_handle_extended_data(3)
-.BR libssh2_channel_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_ignore_extended_data.3 b/libssh2/libssh2/docs/libssh2_channel_ignore_extended_data.3
deleted file mode 100644
index 342c6208..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_ignore_extended_data.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_channel_ignore_extended_data 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_ignore_extended_data - convenience macro for \fIlibssh2_channel_handle_extended_data(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-libssh2_channel_ignore_extended_data(arguments)
-
-.SH DESCRIPTION
-This function is deprecated. Use the
-\fIlibssh2_channel_handle_extended_data2(3)\fP function instead!
-
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_handle_extended_data(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_handle_extended_data(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_handle_extended_data(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_handle_extended_data(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_open_ex.3 b/libssh2/libssh2/docs/libssh2_channel_open_ex.3
deleted file mode 100644
index 7dec2945..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_open_ex.3
+++ /dev/null
@@ -1,54 +0,0 @@
-.TH libssh2_channel_open_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_open_ex - establish a generic session channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type, unsigned int channel_type_len, unsigned int window_size, unsigned int packet_size, const char *message, unsigned int message_len);
-
-LIBSSH2_CHANNEL *
-libssh2_channel_open_session(session);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIchannel_type\fP - Channel type to open. Typically one of session, 
-direct-tcpip, or tcpip-forward. The SSH2 protocol allowed for additional 
-types including local, custom channel types.
-
-\fIchannel_type_len\fP - Length of channel_type
-
-\fIwindow_size\fP - Maximum amount of unacknowledged data remote host is 
-allowed to send before receiving an SSH_MSG_CHANNEL_WINDOW_ADJUST packet.
-
-\fIpacket_size\fP - Maximum number of bytes remote host is allowed to send 
-in a single SSH_MSG_CHANNEL_DATA or SSG_MSG_CHANNEL_EXTENDED_DATA packet.
-
-\fImessage\fP - Additional data as required by the selected channel_type.
-
-\fImessage_len\fP - Length of message parameter.
-
-Allocate a new channel for exchanging data with the server. This method is 
-typically called through its macroized form: 
-.BR libssh2_channel_open_session(3)
-or via 
-.BR libssh2_channel_direct_tcpip(3)
-or
-.BR libssh2_channel_forward_listen(3)
-
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_FAILURE\fP - 
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-
-.SH SEE ALSO
-Add related functions
diff --git a/libssh2/libssh2/docs/libssh2_channel_open_session.3 b/libssh2/libssh2/docs/libssh2_channel_open_session.3
deleted file mode 100644
index 4306f4cc..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_open_session.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_channel_open_session 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_open_session - convenience macro for \fIlibssh2_channel_open_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_channel_open_session(LIBSSH2_SESSION *session);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_open_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_open_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_open_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_process_startup.3 b/libssh2/libssh2/docs/libssh2_channel_process_startup.3
deleted file mode 100644
index 7c279820..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_process_startup.3
+++ /dev/null
@@ -1,38 +0,0 @@
-.TH libssh2_channel_process_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_process_startup - request a shell on a channel
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                    const char *request,
-                                    unsigned int request_len,
-                                    const char *message,
-                                    unsigned int message_len);
-.SH DESCRIPTION
-\fIchannel\fP - Active session channel instance.
-
-\fIrequest\fP - Type of process to startup. The SSH2 protocol currently 
-defines shell, exec, and subsystem as standard process services.
-
-\fIrequest_len\fP - Length of request parameter.
-
-\fImessage\fP - Request specific message data to include.
-
-\fImessage_len\fP - Length of message parameter.
-
-Initiate a request on a session type channel such as returned by 
-.BR libssh2_channel_open_ex(3)
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_read.3 b/libssh2/libssh2/docs/libssh2_channel_read.3
deleted file mode 100644
index f1857167..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_read.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_read - convenience macro for \fIlibssh2_channel_read_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-ssize_t libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_read_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_read_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_read_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_read_ex.3 b/libssh2/libssh2/docs/libssh2_channel_read_ex.3
deleted file mode 100644
index 83d7c3e0..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_read_ex.3
+++ /dev/null
@@ -1,45 +0,0 @@
-.TH libssh2_channel_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_read_ex - read data from a channel stream
-.SH SYNOPSIS
-#include <libssh2.h>
-
-ssize_t
-libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);
-
-ssize_t
-libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
-ssize_t
-libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
-.SH DESCRIPTION
-Attempt to read data from an active channel stream. All channel streams have
-one standard I/O substream (stream_id == 0), and may have up to 2^32 extended
-data streams as identified by the selected \fIstream_id\fP. The SSH2 protocol
-currently defines a stream ID of 1 to be the stderr substream.
-
-\fIchannel\fP - active channel stream to read from. 
-
-\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR) 
-
-\fIbuf\fP - pointer to storage buffer to read data into
-
-\fIbuflen\fP - size of the buf storage
-
-\fIlibssh2_channel_read(3)\fP and \fIlibssh2_channel_read_stderr(3)\fP are
-macros.
-.SH RETURN VALUE
-Actual number of bytes read or negative on failure. It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-Note that a return value of zero (0) can in fact be a legitimate value and
-only signals that no payload data was read. It is not an error.
-.SH ERRORS
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_CLOSED\fP - The channel has been closed.
-
-.SH SEE ALSO
-.BR libssh2_poll_channel_read(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_read_stderr.3 b/libssh2/libssh2/docs/libssh2_channel_read_stderr.3
deleted file mode 100644
index 9324410b..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_read_stderr.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_read_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_read_stderr - convenience macro for \fIlibssh2_channel_read_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-ssize_t libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_read_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_read_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_read_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust.3 b/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust.3
deleted file mode 100644
index a7288118..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.TH libssh2_channel_receive_window_adjust 3 "15 Mar 2009" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_receive_window_adjust - adjust the channel window
-.SH SYNOPSIS
-#include <libssh2.h>
-
-unsigned long
-libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
-                                      unsigned long adjustment,
-                                      unsigned char force);
-
-.SH DESCRIPTION
-This function is deprecated in 1.1. Use
-\fIlibssh2_channel_receive_window_adjust2(3)\fP!
-
-Adjust the receive window for a channel by adjustment bytes. If the amount to
-be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
-adjustment amount will be queued for a later packet.
-.SH RETURN VALUE
-Returns the new size of the receive window (as understood by remote end). Note
-that the window value sent over the wire is strictly 32bit, but this API is
-made to return a 'long' which may not be 32 bit on all platforms.
-.SH ERRORS
-In 1.0 and earlier, this function returns LIBSSH2_ERROR_EAGAIN for
-non-blocking channels where it would otherwise block. However, that is a
-negative number and this function only returns an unsigned value and this then
-leads to a very strange value being returned.
-.SH SEE ALSO
-.BR libssh2_channel_window_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust2.3 b/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust2.3
deleted file mode 100644
index dd2fcc1e..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_receive_window_adjust2.3
+++ /dev/null
@@ -1,27 +0,0 @@
-.TH libssh2_channel_receive_window_adjust2 3 "26 Mar 2009" "libssh2 1.1" "libssh2 manual"
-.SH NAME
-libssh2_channel_receive_window_adjust2 - adjust the channel window
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL * channel,
-                                       unsigned long adjustment,
-                                       unsigned char force,
-                                       unsigned int *window);
-
-.SH DESCRIPTION
-Adjust the receive window for a channel by adjustment bytes. If the amount to
-be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
-adjustment amount will be queued for a later packet.
-
-This function stores the new size of the receive window (as understood by
-remote end) in the variable 'window' points to.
-.SH RETURN VALUE
-Return 0 on success and a negative value on error. If used in non-blocking
-mode it will return LIBSSH2_ERROR_EAGAIN when it would otherwise block.
-.SH ERRORS
-.SH AVAILABILITY
-Added in libssh2 1.1 since the previous API has deficiencies.
-.SH SEE ALSO
-.BR libssh2_channel_window_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_request_pty.3 b/libssh2/libssh2/docs/libssh2_channel_request_pty.3
deleted file mode 100644
index f57352b2..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_request_pty.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_request_pty 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_request_pty - convenience macro for \fIlibssh2_channel_request_pty_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_request_pty(LIBSSH2_SESSION *session, const char *term);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_request_pty_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_request_pty_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_request_pty_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_request_pty_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_request_pty_ex.3 b/libssh2/libssh2/docs/libssh2_channel_request_pty_ex.3
deleted file mode 100644
index 35b5840a..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_request_pty_ex.3
+++ /dev/null
@@ -1,47 +0,0 @@
-.TH libssh2_channel_request_pty_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_request_pty_ex - short function description
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term, unsigned int term_len, const char *modes, unsigned int modes_len, int width, int height, int width_px, int height_px);
-
-int 
-libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, char *term);
-
-.SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
-.BR libssh2_channel_open_ex(3)
-
-\fIterm\fP - Terminal emulation (e.g. vt102, ansi, etc...)
-
-\fIterm_len\fP - Length of term parameter
-
-\fImodes\fP - Terminal mode modifier values
-
-\fImodes_len\fP - Length of modes parameter.
-
-\fIwidth\fP - Width of pty in characters
-
-\fIheight\fP - Height of pty in characters
-
-\fIwidth_px\fP - Width of pty in pixels
-
-\fIheight_px\fP - Height of pty in pixels
-
-Request a PTY on an established channel. Note that this does not make sense 
-for all channel types and may be ignored by the server despite returning 
-success.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_request_pty_size.3 b/libssh2/libssh2/docs/libssh2_channel_request_pty_size.3
deleted file mode 100644
index 4b0c12df..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_request_pty_size.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_request_pty_size 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_request_pty_size - convenience macro for \fIlibssh2_channel_request_pty_size_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel, int width, int height);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_request_pty_size_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_request_pty_size_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_request_pty_size_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_request_pty_size_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_request_pty_size_ex.3 b/libssh2/libssh2/docs/libssh2_channel_request_pty_size_ex.3
deleted file mode 100644
index b3cd6197..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_request_pty_size_ex.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_channel_request_pty_size_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_request_pty_size_ex - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_channel_send_eof.3 b/libssh2/libssh2/docs/libssh2_channel_send_eof.3
deleted file mode 100644
index 0e5975ac..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_send_eof.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.TH libssh2_channel_send_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_send_eof - send EOF to remote server
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-Tell the remote host that no further data will be sent on the specified 
-channel. Processes typically interpret this as a closed stdin descriptor.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-.SH SEE ALSO
-.BR libssh2_channel_wait_eof(3)
-.BR libssh2_channel_eof(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_set_blocking.3 b/libssh2/libssh2/docs/libssh2_channel_set_blocking.3
deleted file mode 100644
index 55ee4ff0..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_set_blocking.3
+++ /dev/null
@@ -1,23 +0,0 @@
-.TH libssh2_channel_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_set_blocking - set or clear blocking mode on channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void 
-libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);
-.SH DESCRIPTION
-\fIchannel\fP - channel stream to set or clean blocking status on.
-
-\fIblocking\fP - Set to a non-zero value to make the channel block, or zero to
-make it non-blocking.
-
-Currently this is just a short cut call to 
-.BR libssh2_session_set_blocking(3)
-and therefore will affect the session and all channels.
-.SH RETURN VALUE
-None
-.SH SEE ALSO
-.BR libssh2_session_set_blocking(3)
-.BR libssh2_channel_read_ex(3)
-.BR libssh2_channel_write_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_setenv.3 b/libssh2/libssh2/docs/libssh2_channel_setenv.3
deleted file mode 100644
index b30d4710..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_setenv.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_setenv 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_setenv - convenience macro for \fIlibssh2_channel_setenv_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_setenv(LIBSSH2_CHANNEL *channel, const char *varname, const char *value);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_setenv_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_setenv_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_setenv_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_setenv_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_setenv_ex.3 b/libssh2/libssh2/docs/libssh2_channel_setenv_ex.3
deleted file mode 100644
index 4a5fd3e9..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_setenv_ex.3
+++ /dev/null
@@ -1,41 +0,0 @@
-.TH libssh2_channel_setenv_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_setenv_ex - set an environment variable on the channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varname, unsigned int varname_len, const char *value, unsigned int value_len);
-
-int
-libssh2_channel_setenv(LIBSSH2_CHANNEL *channel, char *varname, const char *value);
-
-.SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
-.BR libssh2_channel_open_ex(3)
-
-\fIvarname\fP - Name of environment variable to set on the remote 
-channel instance.
-
-\fIvarname_len\fP - Length of passed varname parameter.
-
-\fIvalue\fP - Value to set varname to.
-
-\fIvalue_len\fP - Length of value parameter.
-
-Set an environment variable in the remote channel's process space. Note that
-this does not make sense for all channel types and may be ignored by the
-server despite returning success.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_shell.3 b/libssh2/libssh2/docs/libssh2_channel_shell.3
deleted file mode 100644
index 4ba6e69d..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_shell.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_shell 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_shell - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_shell(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_process_startup(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_process_startup(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_subsystem.3 b/libssh2/libssh2/docs/libssh2_channel_subsystem.3
deleted file mode 100644
index dd29f2c9..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_subsystem.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_subsystem 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_subsystem - convenience macro for \fIlibssh2_channel_process_startup(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_process_startup(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_process_startup(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_process_startup(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_wait_closed.3 b/libssh2/libssh2/docs/libssh2_channel_wait_closed.3
deleted file mode 100644
index 44717368..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_wait_closed.3
+++ /dev/null
@@ -1,22 +0,0 @@
-.TH libssh2_channel_wait_closed 3 "29 Nov 2007" "libssh2 0.19" "libssh2 manual"
-.SH NAME
-libssh2_channel_wait_closed - wait for the remote to close the channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-Enter a temporary blocking state until the remote host closes the named
-channel. Typically sent after \fIlibssh2_channel_close(3)\fP in order to
-examine the exit status.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure. It returns LIBSSH2_ERROR_EAGAIN
-when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
-.SH SEE ALSO
-.BR libssh2_channel_send_eof(3)
-.BR libssh2_channel_eof(3)
-.BR libssh2_channel_wait_eof(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_wait_eof.3 b/libssh2/libssh2/docs/libssh2_channel_wait_eof.3
deleted file mode 100644
index 8a3dc475..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_wait_eof.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_channel_wait_eof 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_wait_eof - wait for the remote to reply to an EOF request
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-Wait for the remote end to send EOF.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure. It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH SEE ALSO
-.BR libssh2_channel_send_eof(3)
-.BR libssh2_channel_eof(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_window_read.3 b/libssh2/libssh2/docs/libssh2_channel_window_read.3
deleted file mode 100644
index 70938d30..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_window_read.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_window_read 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_window_read - convenience macro for \fIlibssh2_channel_window_read_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-unsigned long libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_window_read_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_window_read_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_window_read_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_window_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_window_read_ex.3 b/libssh2/libssh2/docs/libssh2_channel_window_read_ex.3
deleted file mode 100644
index b5280960..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_window_read_ex.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.TH libssh2_channel_window_read_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_window_read_ex - Check the status of the read window
-.SH SYNOPSIS
-#include <libssh2.h>
-
-unsigned long
-libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
-                               unsigned long *read_avail,
-                               unsigned long *window_size_initial)
-.SH DESCRIPTION
-Check the status of the read window. Returns the number of bytes which the
-remote end may send without overflowing the window limit read_avail (if
-passed) will be populated with the number of bytes actually available to be
-read window_size_initial (if passed) will be populated with the
-window_size_initial as defined by the channel_open request
-.SH RETURN VALUE
-The number of bytes which the remote end may send without overflowing the
-window limit
-.SH ERRORS
-
-.SH SEE ALSO
-.BR libssh2_channel_receive_window_adjust(3),
-.BR libssh2_channel_window_write_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_window_write.3 b/libssh2/libssh2/docs/libssh2_channel_window_write.3
deleted file mode 100644
index d8c39930..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_window_write.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_window_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_window_write - convenience macro for \fIlibssh2_channel_window_write_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-unsigned long libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_window_write_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_window_write_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_window_write_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_window_write_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_window_write_ex.3 b/libssh2/libssh2/docs/libssh2_channel_window_write_ex.3
deleted file mode 100644
index d34cd408..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_window_write_ex.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_channel_window_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_window_write_ex - Check the status of the write window
-.SH SYNOPSIS
-#include <libssh2.h>
-
-unsigned long
-libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
-                                unsigned long *window_size_initial)
-.SH DESCRIPTION
-Check the status of the write window Returns the number of bytes which may be
-safely written on the channel without blocking. 'window_size_initial' (if
-passed) will be populated with the size of the initial window as defined by
-the channel_open request
-.SH RETURN VALUE
-Number of bytes which may be safely written on the channel without blocking.
-.SH ERRORS
-
-.SH SEE ALSO
-.BR libssh2_channel_window_read_ex(3),
-.BR libssh2_channel_receive_window_adjust(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_write.3 b/libssh2/libssh2/docs/libssh2_channel_write.3
deleted file mode 100644
index b9de747f..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_write.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_channel_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_write - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-ssize_t libssh2_channel_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_write_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_write_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_write_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_write_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_write_ex.3 b/libssh2/libssh2/docs/libssh2_channel_write_ex.3
deleted file mode 100644
index 4ef7df17..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_write_ex.3
+++ /dev/null
@@ -1,47 +0,0 @@
-.TH libssh2_channel_write_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_write_ex - write data to a channel stream blocking
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
-                                 int stream_id, char *buf,
-                                 size_t buflen);
-.SH DESCRIPTION
-Write data to a channel stream. All channel streams have one standard I/O
-substream (stream_id == 0), and may have up to 2^32 extended data streams as
-identified by the selected \fIstream_id\fP. The SSH2 protocol currently
-defines a stream ID of 1 to be the stderr substream.
-
-\fIchannel\fP - active channel stream to write to. 
-
-\fIstream_id\fP - substream ID number (e.g. 0 or SSH_EXTENDED_DATA_STDERR) 
-
-\fIbuf\fP - pointer to buffer to write
-
-\fIbuflen\fP - size of the data to write
-
-\fIlibssh2_channel_write(3)\fP and \fIlibssh2_channel_write_stderr(3)\fP are
-convenience macros for this function.
-
-\fIlibssh2_channel_write_ex(3)\fP will use as much as possible of the buffer
-and put it into a single SSH protocol packet. This means that to get maximum
-performance when sending larger files, you should try to always pass in at
-least 32K of data to this function.
-.SH RETURN VALUE
-Actual number of bytes written or negative on failure.
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP - An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_CLOSED\fP - The channel has been closed.
-
-\fILIBSSH2_ERROR_CHANNEL_EOF_SENT\fP - The channel has been requested to be
-closed.
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
-.BR libssh2_channel_read_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_write_stderr.3 b/libssh2/libssh2/docs/libssh2_channel_write_stderr.3
deleted file mode 100644
index ac4d3874..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_write_stderr.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_channel_write_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_write_stderr - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-ssize_t libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_write_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_write_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_write_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_write_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_x11_req.3 b/libssh2/libssh2/docs/libssh2_channel_x11_req.3
deleted file mode 100644
index c558e408..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_x11_req.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_channel_x11_req 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_channel_x11_req - convenience macro for \fIlibssh2_channel_x11_req_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_channel_x11_req_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_channel_x11_req_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_channel_x11_req_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_channel_x11_req_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_channel_x11_req_ex.3 b/libssh2/libssh2/docs/libssh2_channel_x11_req_ex.3
deleted file mode 100644
index e0121bd1..00000000
--- a/libssh2/libssh2/docs/libssh2_channel_x11_req_ex.3
+++ /dev/null
@@ -1,44 +0,0 @@
-.TH libssh2_channel_x11_req_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_channel_x11_req_ex - request an X11 forwarding channel
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number);
-
-int
-libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
-
-.SH DESCRIPTION
-\fIchannel\fP - Previously opened channel instance such as returned by 
-.BR libssh2_channel_open_ex(3)
-
-\fIsingle_connection\fP - non-zero to only forward a single connection.
-
-\fIauth_proto\fP - X11 authentication protocol to use
-
-\fIauth_cookie\fP - the cookie (hexadecimal encoded).
-
-\fIscreen_number\fP - the XLL screen to forward
-
-Request an X11 forwarding on \fIchannel\fP. To use X11 forwarding, 
-.BR libssh2_session_callback_set(3)
-must first be called to set \fBLIBSSH2_CALLBACK_X11\fP. This callback will be
-invoked when the remote host accepts the X11 forwarding.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_CHANNEL_REQUEST_DENIED\fP - 
-
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
-.BR libssh2_session_callback_set(3)
diff --git a/libssh2/libssh2/docs/libssh2_exit.3 b/libssh2/libssh2/docs/libssh2_exit.3
deleted file mode 100644
index 2e7afd73..00000000
--- a/libssh2/libssh2/docs/libssh2_exit.3
+++ /dev/null
@@ -1,14 +0,0 @@
-.TH libssh2_exit 3 "19 Mar 2010" "libssh2 1.2.5" "libssh2 manual"
-.SH NAME
-libssh2_exit - global library deinitialization
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void
-libssh2_exit(void);
-.SH DESCRIPTION
-Exit the libssh2 functions and free's all memory used internal.
-.SH AVAILABILITY
-Added in libssh2 1.2.5
-.SH SEE ALSO
-.BR libssh2_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_free.3 b/libssh2/libssh2/docs/libssh2_free.3
deleted file mode 100644
index 30176d58..00000000
--- a/libssh2/libssh2/docs/libssh2_free.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_exit 3 "13 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
-.SH NAME
-libssh2_free - deallocate libssh2 memory
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void
-libssh2_free(LIBSSH2_SESSION *session, void *ptr);
-.SH DESCRIPTION
-Deallocate memory allocated by earlier call to libssh2 functions.  It
-uses the memory allocation callbacks provided by the application, if
-any.  Otherwise, this will just call free().
-
-This function is mostly useful under Windows when libssh2 is linked to
-one run-time library and the application to another.
-.SH AVAILABILITY
-Added in libssh2 1.2.8
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_hostkey_hash.3 b/libssh2/libssh2/docs/libssh2_hostkey_hash.3
deleted file mode 100644
index d57fc0dd..00000000
--- a/libssh2/libssh2/docs/libssh2_hostkey_hash.3
+++ /dev/null
@@ -1,26 +0,0 @@
-.TH libssh2_hostkey_hash 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_hostkey_hash - return a hash of the remote host's key
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *
-libssh2_hostkey_hash(LIBSSH2_SESSION *session, int hash_type);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIhash_type\fP - One of: \fBLIBSSH2_HOSTKEY_HASH_MD5\fP, 
-\fBLIBSSH2_HOSTKEY_HASH_SHA1\fP or \fBLIBSSH2_HOSTKEY_HASH_SHA256\fP.
-
-Returns the computed digest of the remote system's hostkey. The length of 
-the returned string is hash_type specific (e.g. 16 bytes for MD5, 
-20 bytes for SHA1, 32 bytes for SHA256).
-.SH RETURN VALUE
-Computed hostkey hash value, or NULL if the information is not available
-(either the session has not yet been started up, or the requested hash
-algorithm was not available). The hash consists of raw binary bytes, not hex
-digits, so it is not directly printable.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_init.3 b/libssh2/libssh2/docs/libssh2_init.3
deleted file mode 100644
index 416a7893..00000000
--- a/libssh2/libssh2/docs/libssh2_init.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_init 3 "19 Mar 2010" "libssh2 1.2.5" "libssh2 manual"
-.SH NAME
-libssh2_init - global library initialization
-.SH SYNOPSIS
-#include <libssh2.h>
-
-#define LIBSSH2_INIT_NO_CRYPTO 0x0001
-
-int
-libssh2_init(int flags);
-.SH DESCRIPTION
-Initialize the libssh2 functions.  This typically initialize the
-crypto library.  It uses a global state, and is not thread safe -- you
-must make sure this function is not called concurrently.
-.SH RETURN VALUE
-Returns 0 if succeeded, or a negative value for error.
-.SH AVAILABILITY
-Added in libssh2 1.2.5
-.SH SEE ALSO
-.BR libssh2_exit(3)
diff --git a/libssh2/libssh2/docs/libssh2_keepalive_config.3 b/libssh2/libssh2/docs/libssh2_keepalive_config.3
deleted file mode 100644
index 15e3ab96..00000000
--- a/libssh2/libssh2/docs/libssh2_keepalive_config.3
+++ /dev/null
@@ -1,27 +0,0 @@
-.TH libssh2_keepalive_config 3 "12 Apr 2011" "libssh2 1.2.5" "libssh2 manual"
-.SH NAME
-libssh2_keepalive_config - short function description
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-
-void libssh2_keepalive_config(LIBSSH2_SESSION *session,
-                              int want_reply,
-                              unsigned interval);
-.fi
-.SH DESCRIPTION
-Set how often keepalive messages should be sent. \fBwant_reply\fP indicates
-whether the keepalive messages should request a response from the server.
-\fBinterval\fP is number of seconds that can pass without any I/O, use 0 (the
-default) to disable keepalives.  To avoid some busy-loop corner-cases, if you
-specify an interval of 1 it will be treated as 2.
-
-Note that non-blocking applications are responsible for sending the keepalive
-messages using \fBlibssh2_keepalive_send(3)\fP.
-.SH RETURN VALUE
-Nothing
-.SH AVAILABILITY
-Added in libssh2 1.2.5
-.SH SEE ALSO
-.BR libssh2_keepalive_send(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_keepalive_send.3 b/libssh2/libssh2/docs/libssh2_keepalive_send.3
deleted file mode 100644
index f4f19d1a..00000000
--- a/libssh2/libssh2/docs/libssh2_keepalive_send.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_keepalive_send 3 "13 Apr 2011" "libssh2 1.2.5" "libssh2 manual"
-.SH NAME
-libssh2_keepalive_send - short function description
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-
-int libssh2_keepalive_send(LIBSSH2_SESSION *session,
-                           int *seconds_to_next);
-.SH DESCRIPTION
-Send a keepalive message if needed.  \fBseconds_to_next\fP indicates how many
-seconds you can sleep after this call before you need to call it again.
-.SH RETURN VALUE
-Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on I/O errors.
-.SH AVAILABILITY
-Added in libssh2 1.2.5
-.SH SEE ALSO
-.BR libssh2_keepalive_config(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_add.3 b/libssh2/libssh2/docs/libssh2_knownhost_add.3
deleted file mode 100644
index 00a69e0d..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_add.3
+++ /dev/null
@@ -1,66 +0,0 @@
-
-.\" Copyright (c) 2009, 2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_add 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_add - add a known host
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-int libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
-                          char *host, char *salt,
-                          char *key, size_t keylen,
-                          int typemask,
-                          struct libssh2_knownhost **store);
-.SH DESCRIPTION
-We discourage use of this function as of libssh2 1.2.5. Instead we strongly
-urge users to use \fIlibssh2_knownhost_addc(3)\fP instead, which as a more
-complete API. \fIlibssh2_knownhost_add(3)\fP is subject for removal in a
-future release.
-
-Adds a known host to the collection of known hosts identified by the 'hosts'
-handle.
-
-\fIhost\fP is a pointer the host name in plain text or hashed. If hashed, it
-must be provided base64 encoded. The host name can be the IP numerical address
-of the host or the full name.
-
-\fIsalt\P is a pointer to the salt used for the host hashing, if the host is
-provided hashed. If the host is provided in plain text, salt has no meaning.
-The salt has to be provided base64 encoded with a trailing zero byte.
-
-\fIkey\fP is a pointer to the key for the given host.
-
-\fIkeylen\fP is the total size in bytes of the key pointed to by the \fIkey\fP
-argument
-
-\fItypemask\fP is a bitmask that specifies format and info about the data
-passed to this function. Specifically, it details what format the host name is,
-what format the key is and what key type it is.
-
-The host name is given as one of the following types:
-LIBSSH2_KNOWNHOST_TYPE_PLAIN, LIBSSH2_KNOWNHOST_TYPE_SHA1 or
-LIBSSH2_KNOWNHOST_TYPE_CUSTOM.
-
-The key is encoded using one of the following encodings:
-LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
-
-The key is using one of these algorithms:
-LIBSSH2_KNOWNHOST_KEY_RSA1, LIBSSH2_KNOWNHOST_KEY_SSHRSA or
-LIBSSH2_KNOWNHOST_KEY_SSHDSS.
-
-\fIstore\fP should point to a pointer that gets filled in to point to the
-known host data after the addition. NULL can be passed if you don't care about
-this pointer.
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-.SH AVAILABILITY
-Added in libssh2 1.2, deprecated since libssh2 1.2.5. Use
-\fIlibssh2_knownhost_addc(3)\fP instead!
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_check(3)
-.BR libssh2_knownhost_addc(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_addc.3 b/libssh2/libssh2/docs/libssh2_knownhost_addc.3
deleted file mode 100644
index 73e262a4..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_addc.3
+++ /dev/null
@@ -1,68 +0,0 @@
-
-.\" Copyright (c) 2009, 2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_add 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_add - add a known host
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
-                           char *host, char *salt,
-                           char *key, size_t keylen,
-                           const char *comment, size_t commentlen,
-                           int typemask,
-                           struct libssh2_knownhost **store);
-.SH DESCRIPTION
-Adds a known host to the collection of known hosts identified by the 'hosts'
-handle.
-
-\fIhost\fP is a pointer the host name in plain text or hashed. If hashed, it
-must be provided base64 encoded. The host name can be the IP numerical address
-of the host or the full name.
-
-If you want to add a key for a specific port number for the given host, you
-must provide the host name like '[host]:port' with the actual characters '['
-and ']' enclosing the host name and a colon separating the host part from the
-port number. For example: \&"[host.example.com]:222".
-
-\fIsalt\fP is a pointer to the salt used for the host hashing, if the host is
-provided hashed. If the host is provided in plain text, salt has no meaning.
-The salt has to be provided base64 encoded with a trailing zero byte.
-
-\fIkey\fP is a pointer to the key for the given host.
-
-\fIkeylen\fP is the total size in bytes of the key pointed to by the \fIkey\fP
-argument
-
-\fIcomment\fP is a pointer to a comment for the key.
-
-\fIcommentlen\fP is the total size in bytes of the comment pointed to by the \fIcomment\fP argument
-
-\fItypemask\fP is a bitmask that specifies format and info about the data
-passed to this function. Specifically, it details what format the host name is,
-what format the key is and what key type it is.
-
-The host name is given as one of the following types:
-LIBSSH2_KNOWNHOST_TYPE_PLAIN, LIBSSH2_KNOWNHOST_TYPE_SHA1 or
-LIBSSH2_KNOWNHOST_TYPE_CUSTOM.
-
-The key is encoded using one of the following encodings:
-LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
-
-The key is using one of these algorithms:
-LIBSSH2_KNOWNHOST_KEY_RSA1, LIBSSH2_KNOWNHOST_KEY_SSHRSA or
-LIBSSH2_KNOWNHOST_KEY_SSHDSS.
-
-\fIstore\fP should point to a pointer that gets filled in to point to the
-known host data after the addition. NULL can be passed if you don't care about
-this pointer.
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-.SH AVAILABILITY
-Added in libssh2 1.2.5
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_check(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_check.3 b/libssh2/libssh2/docs/libssh2_knownhost_check.3
deleted file mode 100644
index 889392cb..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_check.3
+++ /dev/null
@@ -1,58 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_check 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_check - check a host+key against the list of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
-                            const char *host,
-                            const char *key, size_t keylen,
-                            int typemask,
-                            struct libssh2_knownhost **knownhost);
-.SH DESCRIPTION
-Checks a host and its associated key against the collection of known hosts,
-and returns info back about the (partially) matched entry.
-
-\fIhost\fP is a pointer the host name in plain text. The host name can be the
-IP numerical address of the host or the full name.
-
-\fIkey\fP is a pointer to the key for the given host.
-
-\fIkeylen\fP is the total size in bytes of the key pointed to by the \fIkey\fP
-argument
-
-\fItypemask\fP is a bitmask that specifies format and info about the data
-passed to this function. Specifically, it details what format the host name is,
-what format the key is and what key type it is.
-
-The host name is given as one of the following types:
-LIBSSH2_KNOWNHOST_TYPE_PLAIN or LIBSSH2_KNOWNHOST_TYPE_CUSTOM.
-
-The key is encoded using one of the following encodings:
-LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
-
-\fIknownhost\fP if set to non-NULL, it must be a pointer to a 'struct
-libssh2_knownhost' pointer that gets filled in to point to info about a known
-host that matches or partially matches.
-.SH RETURN VALUE
-\fIlibssh2_knownhost_check(3)\fP returns info about how well the provided
-host + key pair matched one of the entries in the list of known hosts.
-
-LIBSSH2_KNOWNHOST_CHECK_FAILURE - something prevented the check to be made
-
-LIBSSH2_KNOWNHOST_CHECK_NOTFOUND - no host match was found
-
-LIBSSH2_KNOWNHOST_CHECK_MATCH - hosts and keys match.
-
-LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys didn't match!
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH EXAMPLE
-See the ssh2_exec.c example as provided in the tarball.
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_add(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_checkp.3 b/libssh2/libssh2/docs/libssh2_knownhost_checkp.3
deleted file mode 100644
index 434ed7b3..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_checkp.3
+++ /dev/null
@@ -1,63 +0,0 @@
-.\"
-.\" Copyright (c) 2009-2010 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_check 3 "1 May 2010" "libssh2 1.2.6" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_checkp - check a host+key against the list of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
-                             const char *host, int port,
-                             const char *key, size_t keylen,
-                             int typemask,
-                             struct libssh2_knownhost **knownhost);
-.SH DESCRIPTION
-Checks a host and its associated key against the collection of known hosts,
-and returns info back about the (partially) matched entry.
-
-\fIhost\fP is a pointer the host name in plain text. The host name can be the
-IP numerical address of the host or the full name.
-
-\fIport\fP is the port number used by the host (or a negative number
-to check the generic host). If the port number is given, libssh2 will
-check the key for the specific host + port number combination in
-addition to the plain host name only check.
-
-\fIkey\fP is a pointer to the key for the given host.
-
-\fIkeylen\fP is the total size in bytes of the key pointed to by the \fIkey\fP
-argument
-
-\fItypemask\fP is a bitmask that specifies format and info about the data
-passed to this function. Specifically, it details what format the host name is,
-what format the key is and what key type it is.
-
-The host name is given as one of the following types:
-LIBSSH2_KNOWNHOST_TYPE_PLAIN or LIBSSH2_KNOWNHOST_TYPE_CUSTOM.
-
-The key is encoded using one of the following encodings:
-LIBSSH2_KNOWNHOST_KEYENC_RAW or LIBSSH2_KNOWNHOST_KEYENC_BASE64.
-
-\fIknownhost\fP if set to non-NULL, it must be a pointer to a 'struct
-libssh2_knownhost' pointer that gets filled in to point to info about a known
-host that matches or partially matches.
-.SH RETURN VALUE
-\fIlibssh2_knownhost_check(3)\fP returns info about how well the provided
-host + key pair matched one of the entries in the list of known hosts.
-
-LIBSSH2_KNOWNHOST_CHECK_FAILURE - something prevented the check to be made
-
-LIBSSH2_KNOWNHOST_CHECK_NOTFOUND - no host match was found
-
-LIBSSH2_KNOWNHOST_CHECK_MATCH - hosts and keys match.
-
-LIBSSH2_KNOWNHOST_CHECK_MISMATCH - host was found, but the keys didn't match!
-.SH AVAILABILITY
-Added in libssh2 1.2.6
-.SH EXAMPLE
-See the ssh2_exec.c example as provided in the tarball.
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_add(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_del.3 b/libssh2/libssh2/docs/libssh2_knownhost_del.3
deleted file mode 100644
index 75a8eaf5..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_del.3
+++ /dev/null
@@ -1,26 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_del 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_del - delete a known host entry
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
-                          struct libssh2_knownhost *entry);
-.SH DESCRIPTION
-Delete a known host entry from the collection of known hosts.
-
-\fIentry\fP is a pointer to a struct that you can extract with
-\fIlibssh2_knownhost_check(3)\fP or \fIlibssh2_knownhost_get(3)\fP.
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_add(3)
-.BR libssh2_knownhost_check(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_free.3 b/libssh2/libssh2/docs/libssh2_knownhost_free.3
deleted file mode 100644
index 8d8bcc29..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_free.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_free 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_free - free a collection of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts);
-.SH DESCRIPTION
-Free a collection of known hosts.
-.SH RETURN VALUE
-None.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_add(3)
-.BR libssh2_knownhost_check(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_get.3 b/libssh2/libssh2/docs/libssh2_knownhost_get.3
deleted file mode 100644
index d725f8dc..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_get.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_get 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_get - get a known host off the collection of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
-                          struct libssh2_knownhost **store,
-                          struct libssh2_knownhost *prev):
-.SH DESCRIPTION
-\fIlibssh2_knownhost_get(3)\fP allows an application to iterate over all known
-hosts in the collection.
-
-\fIstore\fP should point to a pointer that gets filled in to point to the
-known host data.
-
-\fIprev\fP is a pointer to a previous 'struct libssh2_knownhost' as returned
-by a previous invoke of this function, or NULL to get the first entry in the
-internal collection.
-.SH RETURN VALUE
-Returns 0 if everything is fine and information about a host was stored in
-the \fIstore\fP struct.
-
-Returns 1 if it reached the end of hosts.
-
-Returns negative values for error
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_readfile(3)
-.BR libssh2_knownhost_writefile(3)
-.BR libssh2_knownhost_add(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_init.3 b/libssh2/libssh2/docs/libssh2_knownhost_init.3
deleted file mode 100644
index 145f10ca..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_init.3
+++ /dev/null
@@ -1,25 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_init 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_init - init a collection of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_KNOWNHOSTS *libssh2_knownhost_init(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Init a collection of known hosts for this session. Returns the handle to an
-internal representation of a known host collection.
-
-Call \fBlibssh2_knownhost_free(3)\fP to free the collection again after you're
-doing using it.
-.SH RETURN VALUE
-Returns a handle pointer or NULL if something went wrong. The returned handle
-is used as input to all other known host related functions libssh2 provides.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_add(3)
-.BR libssh2_knownhost_check(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_readfile.3 b/libssh2/libssh2/docs/libssh2_knownhost_readfile.3
deleted file mode 100644
index 68aa9402..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_readfile.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.\"
-.\" Copyright (c) 2009-2011 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_readfile 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_readfile - parse a file of known hosts
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
-                               const char *filename, int type);
-.SH DESCRIPTION
-Reads a collection of known hosts from a specified file and adds them to the
-collection of known hosts.
-
-\fIfilename\fP specifies which file to read
-
-\fItype\fP specifies what file type it is, and
-\fILIBSSH2_KNOWNHOST_FILE_OPENSSH\fP is the only currently supported
-format. This file is normally found named ~/.ssh/known_hosts
-.SH RETURN VALUE
-Returns a negative value, a regular libssh2 error code for errors, or a
-positive number as number of parsed known hosts in the file.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_init(3)
-.BR libssh2_knownhost_free(3)
-.BR libssh2_knownhost_check(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_readline.3 b/libssh2/libssh2/docs/libssh2_knownhost_readline.3
deleted file mode 100644
index a5881c44..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_readline.3
+++ /dev/null
@@ -1,30 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_readline 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_readline - read a known host line
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
-                               const char *line, size_t len, int type):
-.SH DESCRIPTION
-Tell libssh2 to read a buffer as it if is a line from a known hosts file.
-
-\fIline\fP points to the start of the line
-
-\fIlen\fP is the length of the line in bytes
-
-\fItype\fP specifies what file type it is, and
-\fILIBSSH2_KNOWNHOST_FILE_OPENSSH\fP is the only currently supported
-format. This file is normally found named ~/.ssh/known_hosts
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_get(3)
-.BR libssh2_knownhost_writeline(3)
-.BR libssh2_knownhost_readfile(3)
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_writefile.3 b/libssh2/libssh2/docs/libssh2_knownhost_writefile.3
deleted file mode 100644
index 48335a01..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_writefile.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_writefile 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_writefile - write a collection of known hosts to a file
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
-                                const char *filename, int type);
-.SH DESCRIPTION
-Writes all the known hosts to the specified file using the specified file
-format.
-
-\fIfilename\fP specifies what filename to create
-
-\fItype\fP specifies what file type it is, and
-\fILIBSSH2_KNOWNHOST_FILE_OPENSSH\fP is the only currently supported
-format.
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_readfile(3)
-.BR libssh2_knownhost_add(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_knownhost_writeline.3 b/libssh2/libssh2/docs/libssh2_knownhost_writeline.3
deleted file mode 100644
index c014a6a3..00000000
--- a/libssh2/libssh2/docs/libssh2_knownhost_writeline.3
+++ /dev/null
@@ -1,46 +0,0 @@
-.\"
-.\" Copyright (c) 2009 by Daniel Stenberg
-.\"
-.TH libssh2_knownhost_writeline 3 "28 May 2009" "libssh2 1.2" "libssh2 manual"
-.SH NAME
-libssh2_knownhost_writeline - convert a known host to a line for storage
-.SH SYNOPSIS
-#include <libssh2.h>
-
-libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
-                            struct libssh2_knownhost *known,
-                            char *buffer, size_t buflen,
-                            size_t *outlen,
-                            int type);
-.SH DESCRIPTION
-Converts a single known host to a single line of output for storage, using
-the 'type' output format.
-
-\fIknown\fP identifies which particular known host
-
-\fIbuffer\fP points to an allocated buffer
-
-\fIbuflen\fP is the size of the \fIbuffer\fP. See RETURN VALUE about the size.
-
-\fIoutlen\fP must be a pointer to a size_t variable that will get the output
-length of the stored data chunk. The number does not included the trailing
-zero!
-
-\fItype\fP specifies what file type it is, and
-\fILIBSSH2_KNOWNHOST_FILE_OPENSSH\fP is the only currently supported
-format.
-.SH RETURN VALUE
-Returns a regular libssh2 error code, where negative values are error codes
-and 0 indicates success.
-
-If the provided buffer is deemed too small to fit the data libssh2 wants to
-store in it, LIBSSH2_ERROR_BUFFER_TOO_SMALL will be returned. The application
-is then advised to call the function again with a larger buffer. The
-\fIoutlen\fP size will then hold the requested size.
-.SH AVAILABILITY
-Added in libssh2 1.2
-.SH SEE ALSO
-.BR libssh2_knownhost_get(3)
-.BR libssh2_knownhost_readline(3)
-.BR libssh2_knownhost_writefile(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_poll.3 b/libssh2/libssh2/docs/libssh2_poll.3
deleted file mode 100644
index 6656945c..00000000
--- a/libssh2/libssh2/docs/libssh2_poll.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_poll 3 "14 Dec 2006" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_poll - poll for activity on a socket, channel or listener
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds, long timeout);
-.SH DESCRIPTION
-This function is deprecated. Do note use. We encourage users to instead use
-the \fIpoll(3)\fP or \fIselect(3)\fP functions to check for socket activity or
-when specific sockets are ready to get received from or send to.
-
-Poll for activity on a socket, channel, listener, or any combination of these
-three types. The calling semantics for this function generally match
-\fIpoll(2)\fP however the structure of fds is somewhat more complex in order
-to accommodate the disparate datatypes, POLLFD constants have been namespaced
-to avoid platform discrepancies, and revents has additional values defined.
-.SH "RETURN VALUE"
-Number of fds with interesting events.
-.SH SEE ALSO
-.BR libssh2_poll_channel_read(3)
diff --git a/libssh2/libssh2/docs/libssh2_poll_channel_read.3 b/libssh2/libssh2/docs/libssh2_poll_channel_read.3
deleted file mode 100644
index 207275b5..00000000
--- a/libssh2/libssh2/docs/libssh2_poll_channel_read.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_poll_channel_read 3 "14 Dec 2006" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_poll_channel_read - check if data is available
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended);
-.SH DESCRIPTION
-This function is deprecated. Do note use.
-
-\fIlibssh2_poll_channel_read(3)\fP checks to see if data is available in the
-\fIchannel\fP's read buffer. No attempt is made with this method to see if
-packets are available to be processed. For full polling support, use
-\fIlibssh2_poll(3)\fP.
-.SH RETURN VALUE
-Returns 1 when data is available and 0 otherwise.
-.SH SEE ALSO
-.BR libssh2_poll(3)
diff --git a/libssh2/libssh2/docs/libssh2_publickey_add.3 b/libssh2/libssh2/docs/libssh2_publickey_add.3
deleted file mode 100644
index 666cd942..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_add.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_publickey_add 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_publickey_add - convenience macro for \fIlibssh2_publickey_add_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_publickey_add(LIBSSH2_PUBLICKEY *pkey,
-			  const unsigned char *name,
-                          const unsigned char *blob, unsigned long blob_len, char overwrite,
-                          unsigned long num_attrs, const libssh2_publickey_attribute attrs[]);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_publickey_add_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_publickey_add_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_publickey_add_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_publickey_add_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_publickey_add_ex.3 b/libssh2/libssh2/docs/libssh2_publickey_add_ex.3
deleted file mode 100644
index 5c01d234..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_add_ex.3
+++ /dev/null
@@ -1,25 +0,0 @@
-.TH libssh2_publickey_add_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_add_ex - Add a public key entry
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-                         unsigned long name_len, const unsigned char *blob,
-                         unsigned long blob_len, char overwrite,
-                         unsigned long num_attrs,
-                         const libssh2_publickey_attribute attrs[])
-
-.SH DESCRIPTION
-TBD
-.SH RETURN VALUE
-Returns 0 on success, negative on failure.
-.SH ERRORS
-LIBSSH2_ERROR_BAD_USE
-LIBSSH2_ERROR_ALLOC,
-LIBSSH2_ERROR_EAGAIN
-LIBSSH2_ERROR_SOCKET_SEND,
-LIBSSH2_ERROR_SOCKET_TIMEOUT,
-LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_publickey_init.3 b/libssh2/libssh2/docs/libssh2_publickey_init.3
deleted file mode 100644
index 448eb714..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_init.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_publickey_init 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_init - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_publickey_list_fetch.3 b/libssh2/libssh2/docs/libssh2_publickey_list_fetch.3
deleted file mode 100644
index 07a7024b..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_list_fetch.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_publickey_list_fetch 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_list_fetch - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_publickey_list_free.3 b/libssh2/libssh2/docs/libssh2_publickey_list_free.3
deleted file mode 100644
index d50e935d..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_list_free.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_publickey_list_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_list_free - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_publickey_remove.3 b/libssh2/libssh2/docs/libssh2_publickey_remove.3
deleted file mode 100644
index 874fdbed..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_remove.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_publickey_remove 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_publickey_remove - convenience macro for \fIlibssh2_publickey_remove_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_publickey_remove(LIBSSH2_PUBLICKEY *pkey,
-			     const unsigned char *name, unsigned long name_len,
-			     const unsigned char *blob, unsigned long blob_len);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_publickey_remove_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_publickey_remove_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_publickey_remove_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_publickey_remove_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_publickey_remove_ex.3 b/libssh2/libssh2/docs/libssh2_publickey_remove_ex.3
deleted file mode 100644
index a6cba50c..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_remove_ex.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_publickey_list_remove_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_list_remove_ex - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_publickey_shutdown.3 b/libssh2/libssh2/docs/libssh2_publickey_shutdown.3
deleted file mode 100644
index fe67a763..00000000
--- a/libssh2/libssh2/docs/libssh2_publickey_shutdown.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_publickey_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_publickey_shutdown - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_scp_recv.3 b/libssh2/libssh2/docs/libssh2_scp_recv.3
deleted file mode 100644
index 2edcdd48..00000000
--- a/libssh2/libssh2/docs/libssh2_scp_recv.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.TH libssh2_scp_recv 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_scp_recv - request a remote file via SCP
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat *sb);
-
-.SH DESCRIPTION
-This function is \fBDEPRECATED\fP. Use \fIlibssh2_scp_recv2(3)\fP
-instead!
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIpath\fP - Full path and filename of file to transfer. That is the remote
-file name.
-
-\fIsb\fP - Populated with remote file's size, mode, mtime, and atime
-
-Request a file from the remote host via SCP.
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
-block.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
-.BR libssh2_channel_open_ex(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_scp_recv2.3 b/libssh2/libssh2/docs/libssh2_scp_recv2.3
deleted file mode 100644
index 6b48fd14..00000000
--- a/libssh2/libssh2/docs/libssh2_scp_recv2.3
+++ /dev/null
@@ -1,32 +0,0 @@
-.TH libssh2_scp_recv2 3 "29 Jun 2015" "libssh2 1.6.1" "libssh2 manual"
-.SH NAME
-libssh2_scp_recv2 - request a remote file via SCP
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_scp_recv2(LIBSSH2_SESSION *session, const char *path, struct_stat *sb);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIpath\fP - Full path and filename of file to transfer. That is the remote
-file name.
-
-\fIsb\fP - Populated with remote file's size, mode, mtime, and atime
-
-Request a file from the remote host via SCP.
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
-block.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
-.BR libssh2_channel_open_ex(3)
-
diff --git a/libssh2/libssh2/docs/libssh2_scp_send.3 b/libssh2/libssh2/docs/libssh2_scp_send.3
deleted file mode 100644
index 5e29347b..00000000
--- a/libssh2/libssh2/docs/libssh2_scp_send.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_scp_send 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_scp_send - convenience macro for \fIlibssh2_scp_send_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_scp_send(LIBSSH2_SESSION *session, const char *path, int mode, size_t size);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_scp_send_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_scp_send_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_scp_send_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_scp_send_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_scp_send64.3 b/libssh2/libssh2/docs/libssh2_scp_send64.3
deleted file mode 100644
index 98d7e74f..00000000
--- a/libssh2/libssh2/docs/libssh2_scp_send64.3
+++ /dev/null
@@ -1,47 +0,0 @@
-.TH libssh2_scp_send64 3 "17 Apr 2010" "libssh2 1.2.6" "libssh2 manual"
-.SH NAME
-libssh2_scp_send64 - Send a file via SCP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
-                   libssh2_uint64_t size, time_t mtime, time_t atime);
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIpath\fP - Full path and filename of file to transfer to. That is the remote
-file name.
-
-\fImode\fP - File access mode to create file with
-
-\fIsize\fP - Size of file being transmitted (Must be known ahead of
-time). Note that this needs to be passed on as variable type
-libssh2_uint64_t. This type is 64 bit on modern operating systems and
-compilers.
-
-\fImtime\fP - mtime to assign to file being created
-
-\fIatime\fP - atime to assign to file being created (Set this and 
-mtime to zero to instruct remote host to use current time).
-
-Send a file to the remote host via SCP.
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
-block.
-.SH AVAILABILITY
-This function was added in libssh2 1.2.6 and is meant to replace the former
-\fIlibssh2_scp_send_ex(3)\fP function.
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_scp_send_ex.3 b/libssh2/libssh2/docs/libssh2_scp_send_ex.3
deleted file mode 100644
index 8de7083d..00000000
--- a/libssh2/libssh2/docs/libssh2_scp_send_ex.3
+++ /dev/null
@@ -1,48 +0,0 @@
-.TH libssh2_scp_send_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_scp_send_ex - Send a file via SCP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-LIBSSH2_CHANNEL *
-libssh2_scp_send_ex(LIBSSH2_SESSION *session, const char *path, int mode,
-                    size_t size, long mtime, long atime);
-.SH DESCRIPTION
-This function has been deemed deprecated since libssh2 1.2.6. See
-\fIlibssh2_scp_send64(3)\fP.
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIpath\fP - Full path and filename of file to transfer to. That is the remote
-file name.
-
-\fImode\fP - File access mode to create file with
-
-\fIsize\fP - Size of file being transmitted (Must be known 
-ahead of time precisely)
-
-\fImtime\fP - mtime to assign to file being created
-
-\fIatime\fP - atime to assign to file being created (Set this and 
-mtime to zero to instruct remote host to use current time).
-
-Send a file to the remote host via SCP.
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_CHANNEL instance, or NULL on errors.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SCP_PROTOCOL\fP - 
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
-block.
-.SH AVAILABILITY
-This function was marked deprecated in libssh2 1.2.6 as
- \fIlibssh2_scp_send64(3)\fP has been introduced to replace this function.
-.SH SEE ALSO
-.BR libssh2_channel_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_abstract.3 b/libssh2/libssh2/docs/libssh2_session_abstract.3
deleted file mode 100644
index d880b09b..00000000
--- a/libssh2/libssh2/docs/libssh2_session_abstract.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.TH libssh2_session_abstract 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_abstract - return a pointer to a session's abstract pointer
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void **
-libssh2_session_abstract(LIBSSH2_SESSION *session);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-Return a pointer to where the abstract pointer provided to
-\fBlibssh2_session_init_ex(3)\fP is stored. By providing a doubly
-de-referenced pointer, the internal storage of the session instance may be
-modified in place.
-
-.SH RETURN VALUE
-A pointer to session internal storage who's contents point to previously
-provided abstract data.
-
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_banner_get.3 b/libssh2/libssh2/docs/libssh2_session_banner_get.3
deleted file mode 100644
index e253aa13..00000000
--- a/libssh2/libssh2/docs/libssh2_session_banner_get.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_session_banner_get 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
-.SH NAME
-libssh2_session_banner_get - get the remote banner
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *libssh2_session_banner_get(oLIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Once the session has been setup and \fIlibssh2_session_handshake(3)\fP has
-completed successfully, this function can be used to get the server id from
-the banner each server presents.
-.SH RETURN VALUE
-A pointer to a string or NULL if something failed. The data pointed to will be
-allocated and associated to the session handle and will be freed by libssh2
-when \fIlibssh2_session_free(3)\fP is used.
-.SH AVAILABILITY
-Added in 1.4.0
-.SH SEE ALSO
-.BR libssh2_session_banner_set(3),
-.BR libssh2_session_handshake(3),
-.BR libssh2_session_free(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_banner_set.3 b/libssh2/libssh2/docs/libssh2_session_banner_set.3
deleted file mode 100644
index 5e4161ea..00000000
--- a/libssh2/libssh2/docs/libssh2_session_banner_set.3
+++ /dev/null
@@ -1,32 +0,0 @@
-.TH libssh2_session_banner_set 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
-.SH NAME
-libssh2_session_banner_set - set the SSH protocol banner for the local client
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_session_banner_set(LIBSSH2_SESSION *session, const char *banner);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIbanner\fP - A pointer to a zero-terminated string holding the user defined
-banner
-
-Set the banner that will be sent to the remote host when the SSH session is
-started with \fIlibssh2_session_handshake(3)\fP This is optional; a banner
-corresponding to the protocol and libssh2 version will be sent by default.
-.SH RETURN VALUE
-Returns 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
-when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-.SH AVAILABILITY
-Added in 1.4.0.
-
-Before 1.4.0 this function was known as libssh2_banner_set(3)
-.SH SEE ALSO
-.BR libssh2_session_handshake(3),
-.BR libssh2_session_banner_get(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_block_directions.3 b/libssh2/libssh2/docs/libssh2_session_block_directions.3
deleted file mode 100644
index 48ffca3d..00000000
--- a/libssh2/libssh2/docs/libssh2_session_block_directions.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.TH libssh2_session_block_directions 3 "1 Oct 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_session_block_directions - get directions to wait for
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_session_block_directions(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by \fBlibssh2_session_init_ex(3)\fP
-
-When any of libssh2 functions return \fBLIBSSH2_ERROR_EAGAIN\fP an application
-should wait for the socket to have data available for reading or
-writing. Depending on the return value of
-\fIlibssh2_session_block_directions(3)\fP an application should wait for read,
-write or both.
-.SH RETURN VALUE
-Returns the set of directions as a binary mask. Can be a combination of:
-
-LIBSSH2_SESSION_BLOCK_INBOUND: Inbound direction blocked.
-
-LIBSSH2_SESSION_BLOCK_OUTBOUND: Outbound direction blocked.
-
-Application should wait for data to be available for socket prior to calling a
-libssh2 function again. If \fBLIBSSH2_SESSION_BLOCK_INBOUND\fP is set select
-should contain the session socket in readfds set.  Correspondingly in case of
-\fBLIBSSH2_SESSION_BLOCK_OUTBOUND\fP writefds set should contain the socket.
-.SH AVAILABILITY
-Added in 1.0
diff --git a/libssh2/libssh2/docs/libssh2_session_callback_set.3 b/libssh2/libssh2/docs/libssh2_session_callback_set.3
deleted file mode 100644
index 6a075cbf..00000000
--- a/libssh2/libssh2/docs/libssh2_session_callback_set.3
+++ /dev/null
@@ -1,76 +0,0 @@
-.TH libssh2_session_callback_set 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_callback_set - set a callback function
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
-                                   int cbtype, void *callback);
-.SH DESCRIPTION
-Sets a custom callback handler for a previously initialized session
-object. Callbacks are triggered by the receipt of special packets at the
-Transport layer. To disable a callback, set it to NULL.
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIcbtype\fP - Callback type. One of the types listed in Callback Types.
-
-\fIcallback\fP - Pointer to custom callback function. The prototype for 
-this function must match the associated callback declaration macro.
-.SH CALLBACK TYPES
-.IP LIBSSH2_CALLBACK_IGNORE
-Called when a SSH_MSG_IGNORE message is received
-.IP LIBSSH2_CALLBACK_DEBUG
-Called when a SSH_MSG_DEBUG message is received
-.IP LIBSSH2_CALLBACK_DISCONNECT
-Called when a SSH_MSG_DISCONNECT message is received
-.IP LIBSSH2_CALLBACK_MACERROR
-Called when a mismatched MAC has been detected in the transport layer. If the
-function returns 0, the packet will be accepted nonetheless.
-.IP LIBSSH2_CALLBACK_X11
-Called when an X11 connection has been accepted
-.IP LIBSSH2_CALLBACK_SEND
-Called when libssh2 wants to send data on the connection.  Can be set to a
-custom function to handle I/O your own way.
-
-The prototype of the callback:
-
-.nf
-ssize_t sendcb(libssh2_socket_t sockfd, const void *buffer,
-               size_t length, int flags, void **abstract);
-.fi
-
-\fBsockfd\fP is the socket to write to, \fBbuffer\fP points to the data to
-send, \fBlength\fP is the size of the data, \fBflags\fP is the flags that
-would've been used to a \fIsend()\fP call and \fBabstract\fP is a pointer to
-the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
-
-The callback returns the number of bytes sent, or -1 for error. The special
-return code \fB-EAGAIN\fP can be returned to signal that the send was aborted
-to prevent getting blocked and it needs to be called again.
-.IP LIBSSH2_CALLBACK_RECV
-Called when libssh2 wants to read data from the connection. Can be set to a
-custom function to handle I/O your own way.
-
-The prototype of the callback:
-
-.nf
-ssize_t recvcb(libssh2_socket_t sockfd, void *buffer,
-               size_t length, int flags, void **abstract);
-.fi
-
-\fBsockfd\fP is the socket to read from, \fBbuffer\fP where to store received
-data into, \fBlength\fP is the size of the buffer, \fBflags\fP is the flags
-that would've been used to a \fIrecv()\fP call and \fBabstract\fP is a pointer
-to the abstract pointer set in the \fIlibssh2_session_init_ex(3)\fP call.
-
-The callback returns the number of bytes read, or -1 for error. The special
-return code \fB-EAGAIN\fP can be returned to signal that the read was aborted
-to prevent getting blocked and it needs to be called again.
-.SH RETURN VALUE
-Pointer to previous callback handler. Returns NULL if no prior callback
-handler was set or the callback type was unknown.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_disconnect.3 b/libssh2/libssh2/docs/libssh2_session_disconnect.3
deleted file mode 100644
index 32d5e878..00000000
--- a/libssh2/libssh2/docs/libssh2_session_disconnect.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_session_disconnect 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_session_disconnect - convenience macro for \fIlibssh2_session_disconnect_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_session_disconnect_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_session_disconnect_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_session_disconnect_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_session_disconnect_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_disconnect_ex.3 b/libssh2/libssh2/docs/libssh2_session_disconnect_ex.3
deleted file mode 100644
index 82174f9b..00000000
--- a/libssh2/libssh2/docs/libssh2_session_disconnect_ex.3
+++ /dev/null
@@ -1,38 +0,0 @@
-.TH libssh2_session_disconnect_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_disconnect_ex - terminate transport layer
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason, const char *description, const char *lang);
-
-int 
-libssh2_session_disconnect(LIBSSH2_SESSION *session, const char *description);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIreason\fP - One of the Disconnect Reason constants.
-
-\fIdescription\fP - Human readable reason for disconnection.
-
-\fIlang\fP - Localization string describing the language/encoding of the description provided.
-
-Send a disconnect message to the remote host associated with \fIsession\fP, 
-along with a \fIreason\fP symbol and a verbose \fIdescription\fP.
-
-As a convenience, the macro 
-.BR libssh2_session_disconnect(3)
-is provided. It calls
-.BR libssh2_session_disconnect_ex(3)
-with \fIreason\fP set to SSH_DISCONNECT_BY_APPLICATION 
-and \fIlang\fP set to an empty string.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_flag.3 b/libssh2/libssh2/docs/libssh2_session_flag.3
deleted file mode 100644
index 3a9e5e55..00000000
--- a/libssh2/libssh2/docs/libssh2_session_flag.3
+++ /dev/null
@@ -1,23 +0,0 @@
-.TH libssh2_session_flag 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_flag - TODO
-.SH SYNOPSIS
-int
-libssh2_session_flag(LIBSSH2_SESSION *session, int flag, int value);
-.SH DESCRIPTION
-Set options for the created session. \fIflag\fP is the option to set, while
-\fIvalue\fP is typically set to 1 or 0 to enable or disable the option.
-.SH FLAGS
-.IP LIBSSH2_FLAG_SIGPIPE
-If set, libssh2 will not attempt to block SIGPIPEs but will let them trigger
-from the underlying socket layer.
-.IP LIBSSH2_FLAG_COMPRESS
-If set - before the connection negotiation is performed - libssh2 will try to
-negotiate compression enabling for this connection. By default libssh2 will
-not attempt to use compression.
-.SH RETURN VALUE
-Returns regular libssh2 error code.
-.SH AVAILABILITY
-This function has existed since the age of dawn. LIBSSH2_FLAG_COMPRESS was
-added in version 1.2.8.
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_session_free.3 b/libssh2/libssh2/docs/libssh2_session_free.3
deleted file mode 100644
index 96eff0cb..00000000
--- a/libssh2/libssh2/docs/libssh2_session_free.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_session_free 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_free - frees resources associated with a session instance
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_session_free(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Frees all resources associated with a session instance. Typically called after
-.BR libssh2_session_disconnect_ex(3)
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
-.BR libssh2_session_disconnect_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_get_blocking.3 b/libssh2/libssh2/docs/libssh2_session_get_blocking.3
deleted file mode 100644
index 8d98fa33..00000000
--- a/libssh2/libssh2/docs/libssh2_session_get_blocking.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_session_get_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_get_blocking - TODO
-.SH SYNOPSIS
-int libssh2_session_get_blocking(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Returns 0 if the state of the session has previously be set to non-blocking
-and it returns 1 if the state was set to blocking.
-.SH RETURN VALUE
-See description.
-.SH SEE ALSO
-.BR libssh2_session_set_blocking(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_get_timeout.3 b/libssh2/libssh2/docs/libssh2_session_get_timeout.3
deleted file mode 100644
index 94aacd65..00000000
--- a/libssh2/libssh2/docs/libssh2_session_get_timeout.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_session_get_timeout 3 "4 May 2011" "libssh2 1.2.9" "libssh2 manual"
-.SH NAME
-libssh2_session_get_timeout - get the timeout for blocking functions
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-long libssh2_session_get_timeout(LIBSSH2_SESSION *session);
-.SH DESCRIPTION
-Returns the \fBtimeout\fP (in milliseconds) for how long a blocking the
-libssh2 function calls may wait until they consider the situation an error and
-return LIBSSH2_ERROR_TIMEOUT.
-
-By default libssh2 has no timeout (zero) for blocking functions.
-.SH RETURN VALUE
-The value of the timeout setting.
-.SH AVAILABILITY
-Added in 1.2.9
-.SH SEE ALSO
-.BR libssh2_session_set_timeout(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_handshake.3 b/libssh2/libssh2/docs/libssh2_session_handshake.3
deleted file mode 100644
index 33908c64..00000000
--- a/libssh2/libssh2/docs/libssh2_session_handshake.3
+++ /dev/null
@@ -1,40 +0,0 @@
-.TH libssh2_session_handshake 3 "7 Oct 2010" "libssh2 1.2.8" "libssh2 manual"
-.SH NAME
-libssh2_session_handshake - perform the SSH handshake
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_session_handshake(LIBSSH2_SESSION *session, libssh2_socket_t socket);
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by
-.BR libssh2_session_init_ex(3)
-
-\fIsocket\fP - Connected socket descriptor. Typically a TCP connection
-though the protocol allows for any reliable transport and the library will
-attempt to use any berkeley socket.
-
-Begin transport layer protocol negotiation with the connected host.
-.SH RETURN VALUE
-Returns 0 on success, negative on failure.
-.SH ERRORS
-\fILIBSSH2_ERROR_SOCKET_NONE\fP - The socket is invalid.
-
-\fILIBSSH2_ERROR_BANNER_SEND\fP - Unable to send banner to remote host.
-
-\fILIBSSH2_ERROR_KEX_FAILURE\fP - >Encryption key exchange with the remote
-host failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_DISCONNECT\fP - The socket was disconnected.
-
-\fILIBSSH2_ERROR_PROTO\fP - An invalid SSH protocol response was received on
-the socket.
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-.SH AVAILABILITY
-Added in 1.2.8
-.SH SEE ALSO
-.BR libssh2_session_free(3)
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_hostkey.3 b/libssh2/libssh2/docs/libssh2_session_hostkey.3
deleted file mode 100644
index 5d044407..00000000
--- a/libssh2/libssh2/docs/libssh2_session_hostkey.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_session_hostkey 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_hostkey - get the remote key
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *libssh2_session_hostkey(LIBSSH2_SESSION *session,
-                                    size_t *len, int *type);
-.SH DESCRIPTION
-Returns a pointer to the current host key, the value \fIlen\fP points to will
-get the length of the key.
-
-The value \fItype\fP points to the type of hostkey which is one of:
-LIBSSH2_HOSTKEY_TYPE_RSA, LIBSSH2_HOSTKEY_TYPE_DSS, or
-LIBSSH2_HOSTKEY_TYPE_UNKNOWN.
-
-.SH RETURN VALUE
-A pointer, or NULL if something went wrong.
-.SH SEE ALSO
-.BR libssh2_knownhost_check(3)
-.BR libssh2_knownhost_add(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_init.3 b/libssh2/libssh2/docs/libssh2_session_init.3
deleted file mode 100644
index 476a3b42..00000000
--- a/libssh2/libssh2/docs/libssh2_session_init.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_session_init 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_session_init - convenience macro for \fIlibssh2_session_init_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_SESSION *
-libssh2_session_init(void);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_session_init_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_session_init_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_session_init_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_init_ex.3 b/libssh2/libssh2/docs/libssh2_session_init_ex.3
deleted file mode 100644
index 5e4ef06c..00000000
--- a/libssh2/libssh2/docs/libssh2_session_init_ex.3
+++ /dev/null
@@ -1,42 +0,0 @@
-.TH libssh2_session_init_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_init_ex - initializes an SSH session object
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_SESSION * 
-libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*myalloc)), LIBSSH2_FREE_FUNC((*myfree)), LIBSSH2_REALLOC_FUNC((*myrealloc)), void *abstract);
-
-LIBSSH2_SESSION *
-libssh2_session_init(void);
-
-.SH DESCRIPTION
-\fImyalloc\fP - Custom allocator function. Refer to the section on Callbacks 
-for implementing an allocator callback. Pass a value of NULL to use the 
-default system allocator.
-
-\fImyfree\fP - Custom de-allocator function. Refer to the section on Callbacks 
-for implementing a deallocator callback. Pass a value of NULL to use the 
-default system deallocator.
-
-\fImyrealloc\fP - Custom re-allocator function. Refer to the section on 
-Callbacks for implementing a reallocator callback. Pass a value of NULL to 
-use the default system reallocator.
-
-\fIabstract\fP - Arbitrary pointer to application specific callback data. 
-This value will be passed to any callback function associated with the named 
-session instance.
-
-Initializes an SSH session object. By default system memory allocators
-(malloc(), free(), realloc()) will be used for any dynamically allocated memory
-blocks. Alternate memory allocation functions may be specified using the
-extended version of this API call, and/or optional application specific data
-may be attached to the session object.
-
-This method must be called first, prior to configuring session options or
-starting up an SSH session with a remote server.
-.SH RETURN VALUE
-Pointer to a newly allocated LIBSSH2_SESSION instance, or NULL on errors.
-.SH SEE ALSO
-.BR libssh2_session_free(3)
-.BR libssh2_session_handshake(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_last_errno.3 b/libssh2/libssh2/docs/libssh2_session_last_errno.3
deleted file mode 100644
index f9172cbc..00000000
--- a/libssh2/libssh2/docs/libssh2_session_last_errno.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_session_last_errno 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_last_errno - get the most recent error number
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_session_last_errno(LIBSSH2_SESSION *session);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-Determine the most recent error condition.
-
-.SH RETURN VALUE
-Numeric error code corresponding to the the Error Code constants.
-
-.SH SEE ALSO
-.BR libssh2_session_last_error(3)
-.BR libssh2_session_set_last_error(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_last_error.3 b/libssh2/libssh2/docs/libssh2_session_last_error.3
deleted file mode 100644
index 2a64dbb7..00000000
--- a/libssh2/libssh2/docs/libssh2_session_last_error.3
+++ /dev/null
@@ -1,32 +0,0 @@
-.TH libssh2_session_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_last_error - get the most recent error
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_session_last_error(LIBSSH2_SESSION *session, char **errmsg, int *errmsg_len, int want_buf);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIerrmsg\fP - If not NULL, is populated by reference with the human 
-readable form of the most recent error message.
-
-\fIerrmsg_len\fP - If not NULL, is populated by reference with the length 
-of errmsg. (The string is NUL-terminated, so the length is only useful as 
-an optimization, to avoid calling strlen.)
-
-\fIwant_buf\fP - If set to a non-zero value, "ownership" of the errmsg 
-buffer will be given to the calling scope. If necessary, the errmsg buffer 
-will be duplicated.
-
-Determine the most recent error condition and its cause.
-
-.SH RETURN VALUE
-Numeric error code corresponding to the the Error Code constants.
-
-.SH SEE ALSO
-.BR libssh2_session_last_errno(3)
-.BR libssh2_session_set_last_error(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_method_pref.3 b/libssh2/libssh2/docs/libssh2_session_method_pref.3
deleted file mode 100644
index dcf77f6d..00000000
--- a/libssh2/libssh2/docs/libssh2_session_method_pref.3
+++ /dev/null
@@ -1,40 +0,0 @@
-.TH libssh2_session_method_pref 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_method_pref - set preferred key exchange method
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_session_method_pref(LIBSSH2_SESSION *session, int method_type, const char *prefs);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fImethod_type\fP - One of the Method Type constants.
-
-\fIprefs\fP - Coma delimited list of preferred methods to use with 
-the most preferred listed first and the least preferred listed last. 
-If a method is listed which is not supported by libssh2 it will be 
-ignored and not sent to the remote host during protocol negotiation.
-
-Set preferred methods to be negotiated. These 
-preferences must be set prior to calling
-.BR libssh2_session_handshake(3)
-as they are used during the protocol initiation phase.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_INVAL\fP - The requested method type was invalid.
-
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_METHOD_NOT_SUPPORTED\fP - The requested method is not supported.
-
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
-.BR libssh2_session_handshake(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_methods.3 b/libssh2/libssh2/docs/libssh2_session_methods.3
deleted file mode 100644
index cc4f6d49..00000000
--- a/libssh2/libssh2/docs/libssh2_session_methods.3
+++ /dev/null
@@ -1,27 +0,0 @@
-.TH libssh2_session_methods 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_methods - return the currently active algorithms
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *
-libssh2_session_methods(LIBSSH2_SESSION *session, int method_type);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fImethod_type\fP - one of the method type constants: LIBSSH2_METHOD_KEX,
-LIBSSH2_METHOD_HOSTKEY, LIBSSH2_METHOD_CRYPT_CS, LIBSSH2_METHOD_CRYPT_SC,
-LIBSSH2_METHOD_MAC_CS, LIBSSH2_METHOD_MAC_SC, LIBSSH2_METHOD_COMP_CS,
-LIBSSH2_METHOD_COMP_SC, LIBSSH2_METHOD_LANG_CS, LIBSSH2_METHOD_LANG_SC.
-
-Returns the actual method negotiated for a particular transport parameter.
-.SH RETURN VALUE
-Negotiated method or NULL if the session has not yet been started.
-.SH ERRORS
-\fILIBSSH2_ERROR_INVAL\fP - The requested method type was invalid.
-
-\fILIBSSH2_ERROR_METHOD_NONE\fP - no method has been set
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_set_blocking.3 b/libssh2/libssh2/docs/libssh2_session_set_blocking.3
deleted file mode 100644
index b16e0091..00000000
--- a/libssh2/libssh2/docs/libssh2_session_set_blocking.3
+++ /dev/null
@@ -1,30 +0,0 @@
-.TH libssh2_session_set_blocking 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_set_blocking - set or clear blocking mode on session
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void 
-libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking);
-
-.SH DESCRIPTION
-\fIsession\fP - session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIblocking\fP - Set to a non-zero value to make the channel block, or zero to
-make it non-blocking.
-
-Set or clear blocking mode on the selected on the session.  This will
-instantly affect any channels associated with this session. If a read is
-performed on a session with no data currently available, a blocking session
-will wait for data to arrive and return what it receives.  A non-blocking
-session will return immediately with an empty buffer.  If a write is performed
-on a session with no room for more data, a blocking session will wait for
-room.  A non-blocking session will return immediately without writing
-anything.
-
-.SH RETURN VALUE
-None
-
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_set_last_error.3 b/libssh2/libssh2/docs/libssh2_session_set_last_error.3
deleted file mode 100644
index fca6d1df..00000000
--- a/libssh2/libssh2/docs/libssh2_session_set_last_error.3
+++ /dev/null
@@ -1,33 +0,0 @@
-.TH libssh2_session_set_last_error 3 "26 Oct 2015" "libssh2 1.6.1" "libssh2 manual"
-.SH NAME
-libssh2_session_set_last_error - sets the internal error state
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_session_set_last_error(LIBSSH2_SESSION *session, int errcode, const char *errmsg)
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by
-.BR libssh2_session_init_ex(3)
-
-\fIerrcode\fP - One of the error codes as defined in the public
-libssh2 header file.
-
-\fIerrmsg\fP - If not NULL, a copy of the given string is stored
-inside the session object as the error message.
-
-This function is provided for high level language wrappers
-(i.e. Python or Perl) and other libraries that may extend libssh2 with
-additional features while still relying on its error reporting
-mechanism.
-
-.SH RETURN VALUE
-Numeric error code corresponding to the the Error Code constants.
-
-.SH AVAILABILITY
-Added in 1.6.1
-
-.SH SEE ALSO
-.BR libssh2_session_last_error(3)
-.BR libssh2_session_last_errno(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_set_timeout.3 b/libssh2/libssh2/docs/libssh2_session_set_timeout.3
deleted file mode 100644
index 2d4f10f1..00000000
--- a/libssh2/libssh2/docs/libssh2_session_set_timeout.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_session_set_timeout 3 "4 May 2011" "libssh2 1.2.9" "libssh2 manual"
-.SH NAME
-libssh2_session_set_timeout - set timeout for blocking functions
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-void libssh2_session_set_timeout(LIBSSH2_SESSION *session, long timeout);
-.SH DESCRIPTION
-Set the \fBtimeout\fP in milliseconds for how long a blocking the libssh2
-function calls may wait until they consider the situation an error and return
-LIBSSH2_ERROR_TIMEOUT.
-
-By default or if you set the timeout to zero, libssh2 has no timeout for
-blocking functions.
-.SH RETURN VALUE
-Nothing
-.SH AVAILABILITY
-Added in 1.2.9
-.SH SEE ALSO
-.BR libssh2_session_get_timeout(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_startup.3 b/libssh2/libssh2/docs/libssh2_session_startup.3
deleted file mode 100644
index b59056f7..00000000
--- a/libssh2/libssh2/docs/libssh2_session_startup.3
+++ /dev/null
@@ -1,42 +0,0 @@
-.TH libssh2_session_startup 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_session_startup - begin transport layer
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_session_startup(LIBSSH2_SESSION *session, int socket);
-.SH DESCRIPTION
-Starting in libssh2 version 1.2.8 this function is considered deprecated. Use
-\fIlibssh2_session_handshake(3)\fP instead.
-
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIsocket\fP - Connected socket descriptor. Typically a TCP connection 
-though the protocol allows for any reliable transport and the library will 
-attempt to use any berkeley socket.
-
-Begin transport layer protocol negotiation with the connected host.
-.SH RETURN VALUE
-Returns 0 on success, negative on failure.
-.SH ERRORS
-\fILIBSSH2_ERROR_SOCKET_NONE\fP - The socket is invalid.
-
-\fILIBSSH2_ERROR_BANNER_SEND\fP - Unable to send banner to remote host.
-
-\fILIBSSH2_ERROR_KEX_FAILURE\fP - >Encryption key exchange with the remote 
-host failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_DISCONNECT\fP - The socket was disconnected.
-
-\fILIBSSH2_ERROR_PROTO\fP - An invalid SSH protocol response was received on 
-the socket.
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would block.
-
-.SH SEE ALSO
-.BR libssh2_session_free(3)
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_session_supported_algs.3 b/libssh2/libssh2/docs/libssh2_session_supported_algs.3
deleted file mode 100644
index 6e414a90..00000000
--- a/libssh2/libssh2/docs/libssh2_session_supported_algs.3
+++ /dev/null
@@ -1,74 +0,0 @@
-.TH libssh2_session_supported_algs 3 "23 Oct 2011" "libssh2 1.4.0" "libssh2 manual"
-.SH NAME
-libssh2_session_supported_algs - get list of supported algorithms
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
-                                   int method_type,
-                                   const char*** algs);
-.SH DESCRIPTION
-\fIsession\fP - An instance of initialized LIBSSH2_SESSION (the function will
-use its pointer to the memory allocation function).  \fImethod_type\fP -
-Method type. See \fIlibssh2_session_method_pref(3)\fP.  \fIalgs\fP - Address
-of a pointer that will point to an array of returned algorithms
-
-Get a list of supported algorithms for the given \fImethod_type\fP. The
-method_type parameter is equivalent to method_type in
-\fIlibssh2_session_method_pref(3)\fP. If successful, the function will
-allocate the appropriate amount of memory. When not needed anymore, it must be
-deallocated by calling \fIlibssh2_free(3)\fP. When this function is
-unsuccessful, this must not be done.
-
-In order to get a list of all supported compression algorithms,
-libssh2_session_flag(session, LIBSSH2_FLAG_COMPRESS, 1) must be called before
-calling this function, otherwise only "none" will be returned.
-
-If successful, the function will allocate and fill the array with supported
-algorithms (the same names as defined in RFC 4253).  The array is not NULL
-terminated.
-.SH EXAMPLE
-.nf
-#include "libssh2.h"
-
-const char **algorithms;
-int rc, i;
-LIBSSH2_SESSION *session;
-
-/* initialize session */
-session = libssh2_session_init();
-rc = libssh2_session_supported_algs(session,
-                                    LIBSSH2_METHOD_CRYPT_CS,
-                                    &algorithms);
-if (rc>0) {
-    /* the call succeeded, do sth. with the list of algorithms
-       (e.g. list them)... */
-    printf("Supported symmetric algorithms:\\n");
-    for ( i=0; i<rc; i++ )
-        printf("\\t%s\\n", algorithms[i]);
-
-    /* ... and free the allocated memory when not needed anymore */
-    libssh2_free(session, algorithms);
-}
-else {
-    /* call failed, error handling */
-}
-.SH RETURN VALUE
-On success, a number of returned algorithms (i.e a positive number will be
-returned).  In case of a failure, an error code (a negative number, see below)
-is returned.  0 should never be returned.
-.SH ERRORS
-\fILIBSSH2_ERROR_BAD_USE\fP - Invalid address of algs.
-
-\fILIBSSH2_ERROR_METHOD_NOT_SUPPORTED\fP -  Unknown method type.
-
-\fILIBSSH2_ERROR_INVAL\fP - Internal error (normally should not occur).
-
-\fILIBSSH2_ERROR_ALLOC\fP - Allocation of memory failed.
-.SH AVAILABILITY
-Added in 1.4.0
-.SH SEE ALSO
-.BR libssh2_session_methods(3),
-.BR libssh2_session_method_pref(3)
-.BR libssh2_free(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_close.3 b/libssh2/libssh2/docs/libssh2_sftp_close.3
deleted file mode 100644
index b169b1ba..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_close.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_close 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_close - convenience macro for \fIlibssh2_sftp_close_handle(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_close_handle(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_close_handle(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_close_handle(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_close_handle(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_close_handle.3 b/libssh2/libssh2/docs/libssh2_sftp_close_handle.3
deleted file mode 100644
index 30e299cf..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_close_handle.3
+++ /dev/null
@@ -1,43 +0,0 @@
-.TH libssh2_sftp_close_handle 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_close_handle - close filehandle
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle);
-
-int 
-libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
-
-int 
-libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle);
-
-.SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP
-or \fBlibssh2_sftp_opendir(3)\fP (which is a macro).
-
-Close an active LIBSSH2_SFTP_HANDLE. Because files and directories share the
-same underlying storage mechanism these methods may be used
-interchangeably. \fBlibssh2_sftp_close(3)\fP and \fBlibssh2_sftp_closedir(3)\fP
-are macros for \fBlibssh2_sftp_close_handle(3)\fP.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_closedir.3 b/libssh2/libssh2/docs/libssh2_sftp_closedir.3
deleted file mode 100644
index 3e032a77..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_closedir.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_closedir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_closedir - convenience macro for \fIlibssh2_sftp_close_handle(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle)
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_close_handle(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_close_handle(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_close_handle(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_close_handle(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_fsetstat.3 b/libssh2/libssh2/docs/libssh2_sftp_fsetstat.3
deleted file mode 100644
index e77dd214..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_fsetstat.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_fsetstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_fsetstat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_fsetstat(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_fstat_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_fstat.3 b/libssh2/libssh2/docs/libssh2_sftp_fstat.3
deleted file mode 100644
index 66116a39..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_fstat.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_fstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_fstat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_fstat(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_fstat_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_fstat_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_fstat_ex.3
deleted file mode 100644
index 107594cf..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_fstat_ex.3
+++ /dev/null
@@ -1,104 +0,0 @@
-.TH libssh2_sftp_fstat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_fstat_ex - get or set attributes on an SFTP file handle
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle,
-                      LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat)
-
-#define libssh2_sftp_fstat(handle, attrs) \\
-    libssh2_sftp_fstat_ex((handle), (attrs), 0)
-#define libssh2_sftp_fsetstat(handle, attrs) \\
-    libssh2_sftp_fstat_ex((handle), (attrs), 1)
-.fi
-.SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by 
-.BR libssh2_sftp_open_ex(3)
-
-\fIattrs\fP - Pointer to an LIBSSH2_SFTP_ATTRIBUTES structure to set file
-metadata from or into depending on the value of setstat.
-
-\fIsetstat\fP - When non-zero, the file's metadata will be updated 
-with the data found in attrs according to the values of attrs->flags 
-and other relevant member attributes.
-
-Get or Set statbuf type data for a given LIBSSH2_SFTP_HANDLE instance.
-.SH DATA TYPES
-LIBSSH2_SFTP_ATTRIBUTES is a typedefed struct that is defined as below
-
-.nf
-struct _LIBSSH2_SFTP_ATTRIBUTES {
-
-    /* If flags & ATTR_* bit is set, then the value in this
-     * struct will be meaningful Otherwise it should be ignored
-     */
-    unsigned long flags;
-
-    /* size of file, in bytes */
-    libssh2_uint64_t filesize;
-
-    /* numerical representation of the user and group owner of
-     * the file
-     */
-    unsigned long uid, gid;
-
-    /* bitmask of permissions */
-    unsigned long permissions;
-
-    /* access time and modified time of file */
-    unsigned long atime, mtime;
-};
-.fi
-
-You will find a full set of defines and macros to identify flags and
-permissions on the \fBlibssh2_sftp.h\fP header file, but some of the
-most common ones are:
-
-To check for specific user permissions, the set of defines are in the
-pattern LIBSSH2_SFTP_S_I<action><who> where <action> is R, W or X for
-read, write and executable and <who> is USR, GRP and OTH for user,
-group and other. So, you check for a user readable file, use the bit
-\fILIBSSH2_SFTP_S_IRUSR\fP while you want to see if it is executable
-for other, you use \fILIBSSH2_SFTP_S_IXOTH\fP and so on.
-
-To check for specific file types, you would previously (before libssh2
-1.2.5) use the standard posix S_IS***() macros, but since 1.2.5
-libssh2 offers its own set of macros for this functionality:
-.IP LIBSSH2_SFTP_S_ISLNK
-Test for a symbolic link
-.IP LIBSSH2_SFTP_S_ISREG
-Test for a regular file
-.IP LIBSSH2_SFTP_S_ISDIR
-Test for a directory
-.IP LIBSSH2_SFTP_S_ISCHR
-Test for a character special file
-.IP LIBSSH2_SFTP_S_ISBLK
-Test for a block special file
-.IP LIBSSH2_SFTP_S_ISFIFO
-Test for a pipe or FIFO special file
-.IP LIBSSH2_SFTP_S_ISSOCK
-Test for a socket
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-.SH AVAILABILITY
-This function has been around since forever, but most of the
-LIBSSH2_SFTP_S_* defines were introduced in libssh2 0.14 and the
-LIBSSH2_SFTP_S_IS***() macros were introduced in libssh2 1.2.5.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_fstatvfs.3 b/libssh2/libssh2/docs/libssh2_sftp_fstatvfs.3
deleted file mode 100644
index 934d2a10..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_fstatvfs.3
+++ /dev/null
@@ -1 +0,0 @@
-.so man3/libssh2_sftp_statvfs.3
diff --git a/libssh2/libssh2/docs/libssh2_sftp_fsync.3 b/libssh2/libssh2/docs/libssh2_sftp_fsync.3
deleted file mode 100644
index 646760a0..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_fsync.3
+++ /dev/null
@@ -1,39 +0,0 @@
-.TH libssh2_sftp_fsync 3 "8 Apr 2013" "libssh2 1.4.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_fsync - synchronize file to disk
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int
-libssh2_sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
-.fi
-.SH DESCRIPTION
-This function causes the remote server to synchronize the file
-data and metadata to disk (like fsync(2)).
-
-For this to work requires fsync@openssh.com support on the server.
-
-\fIhandle\fP - SFTP File Handle as returned by
-.BR libssh2_sftp_open_ex(3)
-
-.SH RETURN VALUE
-Returns 0 on success or negative on failure. If used in non-blocking mode, it
-returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response
-was received on the socket, or an SFTP operation caused an errorcode
-to be returned by the server.  In particular, this can be returned if
-the SSH server does not support the fsync operation: the SFTP subcode
-\fILIBSSH2_FX_OP_UNSUPPORTED\fP will be returned in this case.
-
-.SH AVAILABILITY
-Added in libssh2 1.4.4 and OpenSSH 6.3.
-.SH SEE ALSO
-.BR fsync(2)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_get_channel.3 b/libssh2/libssh2/docs/libssh2_sftp_get_channel.3
deleted file mode 100644
index d1d82bc7..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_get_channel.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_sftp_get_channel 3 "9 Sep 2011" "libssh2 1.4.0" "libssh2 manual"
-.SH NAME
-libssh2_sftp_get_channel - return the channel of sftp
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-.fi
-LIBSSH2_CHANNEL *libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp);
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by
-.BR libssh2_sftp_init(3)
-
-Return the channel of the given sftp handle.
-.SH RETURN VALUE
-The channel of the SFTP instance or NULL if something was wrong.
-.SH AVAILABILITY
-Added in 1.4.0
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_init.3 b/libssh2/libssh2/docs/libssh2_sftp_init.3
deleted file mode 100644
index a59d0300..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_init.3
+++ /dev/null
@@ -1,39 +0,0 @@
-.TH libssh2_sftp_init 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_init - open SFTP channel for the given SSH session.
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-LIBSSH2_SFTP *
-libssh2_sftp_init(LIBSSH2_SESSION *session);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-Open a channel and initialize the SFTP subsystem. Although the SFTP subsystem
-operates over the same type of channel as those exported by the Channel API,
-the protocol itself implements its own unique binary packet protocol which
-must be managed with the libssh2_sftp_*() family of functions. When an SFTP
-session is complete, it must be destroyed using the
-.BR libssh2_sftp_shutdown(3)
-function.
-.SH RETURN VALUE
-A pointer to the newly allocated SFTP instance or NULL on failure.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
-returned by the server.
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call would
-block.
-.SH SEE ALSO
-.BR libssh2_sftp_shutdown(3)
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_last_error.3 b/libssh2/libssh2/docs/libssh2_sftp_last_error.3
deleted file mode 100644
index aadbd5d1..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_last_error.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.TH libssh2_sftp_last_error 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_last_error - return the last SFTP-specific error code
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-unsigned long 
-libssh2_sftp_last_error(LIBSSH2_SFTP *sftp);
-
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-Returns the last error code produced by the SFTP layer. Note that this only
-returns a sensible error code if libssh2 returned LIBSSH2_ERROR_SFTP_PROTOCOL
-in a previous call. Using \fBlibssh2_sftp_last_error(3)\fP without a
-preceding SFTP protocol error, it will return an unspecified value.
-
-.SH RETURN VALUE
-Current error code state of the SFTP instance.
-
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_lstat.3 b/libssh2/libssh2/docs/libssh2_sftp_lstat.3
deleted file mode 100644
index 78c90577..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_lstat.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_lstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_lstat - convenience macro for \fIlibssh2_sftp_stat_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_lstat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_stat_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_stat_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_stat_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_stat_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_mkdir.3 b/libssh2/libssh2/docs/libssh2_sftp_mkdir.3
deleted file mode 100644
index 999bd016..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_mkdir.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_mkdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_mkdir - convenience macro for \fIlibssh2_sftp_mkdir_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path, long mode);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_mkdir_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_mkdir_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_mkdir_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_mkdir_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_mkdir_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_mkdir_ex.3
deleted file mode 100644
index 20df03c3..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_mkdir_ex.3
+++ /dev/null
@@ -1,40 +0,0 @@
-.TH libssh2_sftp_mkdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_mkdir_ex - create a directory on the remote file system
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len, long mode);
-
-int 
-libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path, long mode);
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIpath\fP - full path of the new directory to create. Note that the new 
-directory's parents must all exist prior to making this call.
-
-\fIpath_len\fP - length of the full path of the new directory to create.
-
-\fImode\fP - directory creation mode (e.g. 0755).
-
-Create a directory on the remote file system.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
-returned by the server.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_open.3 b/libssh2/libssh2/docs/libssh2_sftp_open.3
deleted file mode 100644
index 90969860..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_open.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_sftp_open 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_open - convenience macro for \fIlibssh2_sftp_open_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open(LIBSSH2_SFTP *sftp, const char *path, unsigned long flags, long mode);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_open_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_open_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_open_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_opendir.3 b/libssh2/libssh2/docs/libssh2_sftp_opendir.3
deleted file mode 100644
index d3451031..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_opendir.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_sftp_opendir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_opendir - convenience macro for \fIlibssh2_sftp_open_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_opendir(LIBSSH2_SFTP *sftp, const char *path);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_open_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_open_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_open_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_read.3 b/libssh2/libssh2/docs/libssh2_sftp_read.3
deleted file mode 100644
index 36bc9794..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_read.3
+++ /dev/null
@@ -1,43 +0,0 @@
-.TH libssh2_sftp_read 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_read - read data from an SFTP handle
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-ssize_t 
-libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxlen);
-
-.SH DESCRIPTION
-\fIhandle\fP is the SFTP File Handle as returned by 
-.BR libssh2_sftp_open_ex(3)
-
-\fIbuffer\fP is a pointer to a pre-allocated buffer of at least
-
-\fIbuffer_maxlen\fP bytes to read data into.
-
-Reads a block of data from an LIBSSH2_SFTP_HANDLE. This method is modelled
-after the POSIX 
-.BR read(2)
-function and uses the same calling semantics. 
-.BR libssh2_sftp_read(3)
-will attempt to read as much as possible however it may not fill all of buffer
-if the file pointer reaches the end or if further reads would cause the socket
-to block.
-.SH RETURN VALUE
-Number of bytes actually populated into buffer, or negative on failure.  
-It returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
-received on the socket, or an SFTP operation caused an errorcode to be
-returned by the server.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
-.BR libssh2_sftp_read(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_readdir.3 b/libssh2/libssh2/docs/libssh2_sftp_readdir.3
deleted file mode 100644
index adecbcbe..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_readdir.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_readdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_readdir - convenience macro for \fIlibssh2_sftp_readdir_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxlen, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_readdir_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_readdir_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_readdir_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_readdir_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_readdir_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_readdir_ex.3
deleted file mode 100644
index a40e4df8..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_readdir_ex.3
+++ /dev/null
@@ -1,65 +0,0 @@
-.TH libssh2_sftp_readdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_readdir_ex - read directory data from an SFTP handle
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *handle,
-                        char *buffer, size_t buffer_maxlen,
-                        char *longentry, size_t longentry_maxlen,
-                        LIBSSH2_SFTP_ATTRIBUTES *attrs);
-.SH DESCRIPTION
-Reads a block of data from a LIBSSH2_SFTP_HANDLE and returns file entry
-information for the next entry, if any.
-
-\fIhandle\fP - is the SFTP File Handle as returned by 
-.BR libssh2_sftp_open_ex(3)
-
-\fIbuffer\fP - is a pointer to a pre-allocated buffer of at least
-\fIbuffer_maxlen\fP bytes to read data into.
-
-\fIbuffer_maxlen\fP - is the length of buffer in bytes. If the length of the 
-filename is longer than the space provided by buffer_maxlen it will be 
-truncated to fit.
-
-\fIlongentry\fP - is a pointer to a pre-allocated buffer of at least
-\fIlongentry_maxlen\fP bytes to read data into. The format of the `longname'
-field is unspecified by SFTP protocol. It MUST be suitable for use in the
-output of a directory listing command (in fact, the recommended operation for
-a directory listing command is to simply display this data).
-
-\fIlongentry_maxlen\fP - is the length of longentry in bytes. If the length of
-the full directory entry is longer than the space provided by
-\fIlongentry_maxlen\fP it will be truncated to fit.
-
-\fIattrs\fP - is a pointer to LIBSSH2_SFTP_ATTRIBUTES storage to populate 
-statbuf style data into.
-.SH RETURN VALUE
-Number of bytes actually populated into buffer (not counting the terminating
-zero), or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN when it would
-otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it isn't
-really a failure per se.
-.SH BUG
-Passing in a too small buffer for 'buffer' or 'longentry' when receiving data
-only results in libssh2 1.2.7 or earlier to not copy the entire data amount,
-and it is not possible for the application to tell when it happens!
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to be 
-returned by the server.
-
-From 1.2.8, LIBSSH2_ERROR_BUFFER_TOO_SMALL is returned if any of the
-given 'buffer' or 'longentry' buffers are too small to fit the requested
-object name.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3),
-.BR libssh2_sftp_close_handle(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_readlink.3 b/libssh2/libssh2/docs/libssh2_sftp_readlink.3
deleted file mode 100644
index 7425074e..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_readlink.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_sftp_readlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_readlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-#define libssh2_sftp_readlink(sftp, path, target, maxlen) \\
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
-    LIBSSH2_SFTP_READLINK)
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_symlink_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_realpath.3 b/libssh2/libssh2/docs/libssh2_sftp_realpath.3
deleted file mode 100644
index 33f0fa82..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_realpath.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_sftp_realpath 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_realpath - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-#define libssh2_sftp_realpath(sftp, path, target, maxlen) \\
-  libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
-                          LIBSSH2_SFTP_REALPATH)
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_symlink_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_rename.3 b/libssh2/libssh2/docs/libssh2_sftp_rename.3
deleted file mode 100644
index 4939e3c1..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_rename.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_rename 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_rename - convenience macro for \fIlibssh2_sftp_rename_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename, const char *destination_filename);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_rename_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_rename_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_rename_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_rename_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_rename_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_rename_ex.3
deleted file mode 100644
index 20a3b9db..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_rename_ex.3
+++ /dev/null
@@ -1,56 +0,0 @@
-.TH libssh2_sftp_rename_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_rename_ex - rename an SFTP file
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename, unsigned int source_filename_len, const char *dest_filename, unsigned int dest_filename_len, long flags);
-
-int 
-libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename, const char *dest_filename);
-
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIsourcefile\fP - Path and name of the existing filesystem entry
-
-\fIsourcefile_len\fP - Length of the path and name of the existing 
-filesystem entry
-
-\fIdestfile\fP - Path and name of the target filesystem entry
-
-\fIdestfile_len\fP - Length of the path and name of the target 
-filesystem entry
-
-\fIflags\fP - 
-Bitmask flags made up of LIBSSH2_SFTP_RENAME_* constants.
-
-Rename a filesystem object on the remote filesystem. The semantics of 
-this command typically include the ability to move a filesystem object 
-between folders and/or filesystem mounts. If the LIBSSH2_SFTP_RENAME_OVERWRITE 
-flag is not set and the destfile entry already exists, the operation 
-will fail. Use of the other two flags indicate a preference (but not a 
-requirement) for the remote end to perform an atomic rename operation 
-and/or using native system calls when possible.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_rewind.3 b/libssh2/libssh2/docs/libssh2_sftp_rewind.3
deleted file mode 100644
index 92d99e2b..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_rewind.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_rewind 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_rewind - convenience macro for \fIlibssh2_sftp_seek64(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_rewind(LIBSSH2_SFTP_HANDLE *handle);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_seek64(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_seek64(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_seek64(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_seek64(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_rmdir.3 b/libssh2/libssh2/docs/libssh2_sftp_rmdir.3
deleted file mode 100644
index 0d4b67f2..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_rmdir.3
+++ /dev/null
@@ -1,18 +0,0 @@
-.TH libssh2_sftp_rmdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_rmdir - convenience macro for \fIlibssh2_sftp_rmdir_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-#define libssh2_sftp_rmdir(sftp, path) \\
-    libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_rmdir_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_rmdir_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_rmdir_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_rmdir_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_rmdir_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_rmdir_ex.3
deleted file mode 100644
index daa85cf0..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_rmdir_ex.3
+++ /dev/null
@@ -1,36 +0,0 @@
-.TH libssh2_sftp_rmdir_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_rmdir_ex - remove an SFTP directory
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
-                          unsigned int path_len);
-.SH DESCRIPTION
-Remove a directory from the remote file system.
-
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIsourcefile\fP - Full path of the existing directory to remove.
-
-\fIsourcefile_len\fP - Length of the full path of the existing directory to
-remove.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_seek.3 b/libssh2/libssh2/docs/libssh2_sftp_seek.3
deleted file mode 100644
index ccf5e106..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_seek.3
+++ /dev/null
@@ -1,25 +0,0 @@
-.TH libssh2_sftp_seek 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_sftp_seek - set the read/write position indicator within a file
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset);
-.SH DESCRIPTION
-Deprecated function. Use \fIlibssh2_sftp_seek64(3)\fP instead!
-
-\fIhandle\fP - SFTP File Handle as returned by 
-.BR libssh2_sftp_open_ex(3)
-
-\fIoffset\fP - Number of bytes from the beginning of file to seek to.
-
-Move the file handle's internal pointer to an arbitrary location. 
-Note that libssh2 implements file pointers as a localized concept to make 
-file access appear more POSIX like. No packets are exchanged with the server 
-during a seek operation. The localized file pointer is simply used as a 
-convenience offset during read/write operations.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3),
-.BR libssh2_sftp_seek64(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_seek64.3 b/libssh2/libssh2/docs/libssh2_sftp_seek64.3
deleted file mode 100644
index 57c9a485..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_seek64.3
+++ /dev/null
@@ -1,29 +0,0 @@
-.TH libssh2_sftp_seek64 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_sftp_seek64 - set the read/write position within a file
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle,
-                         libssh2_uint64_t offset);
-.SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by 
-.BR libssh2_sftp_open_ex(3)
-
-\fIoffset\fP - Number of bytes from the beginning of file to seek to.
-
-Move the file handle's internal pointer to an arbitrary location. libssh2
-implements file pointers as a localized concept to make file access appear
-more POSIX like. No packets are exchanged with the server during a seek
-operation. The localized file pointer is simply used as a convenience offset
-during read/write operations.
-
-You MUST NOT seek during writing or reading a file with SFTP, as the internals
-use outstanding packets and changing the "file position" during transit will
-results in badness.
-.SH AVAILABILITY
-Added in 1.0
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_setstat.3 b/libssh2/libssh2/docs/libssh2_sftp_setstat.3
deleted file mode 100644
index 198703e0..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_setstat.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_setstat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_setstat - convenience macro for \fIlibssh2_sftp_stat_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_setstat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attr);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_stat_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_stat_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_stat_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_stat_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_shutdown.3 b/libssh2/libssh2/docs/libssh2_sftp_shutdown.3
deleted file mode 100644
index 42cc1c49..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_shutdown.3
+++ /dev/null
@@ -1,24 +0,0 @@
-.TH libssh2_sftp_shutdown 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_shutdown - shut down an SFTP session
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp);
-
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-Destroys a previously initialized SFTP session and frees all resources 
-associated with it.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_stat.3 b/libssh2/libssh2/docs/libssh2_sftp_stat.3
deleted file mode 100644
index 96cb2a5a..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_stat.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_stat 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_stat - convenience macro for \fIlibssh2_sftp_fstat_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_stat(LIBSSH2_SFTP *sftp, const char *path, LIBSSH2_SFTP_ATTRIBUTES *attrs);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_fstat_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_fstat_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_fstat_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_stat_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_stat_ex.3
deleted file mode 100644
index 2fd9507f..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_stat_ex.3
+++ /dev/null
@@ -1,74 +0,0 @@
-.TH libssh2_sftp_stat_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_stat_ex - get status about an SFTP file
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path,
-                         unsigned int path_len, int stat_type,
-                         LIBSSH2_SFTP_ATTRIBUTES *attrs);
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIpath\fP - Remote filesystem object to stat/lstat/setstat.
-
-\fIpath_len\fP - Length of the name of the remote filesystem object 
-to stat/lstat/setstat.
-
-\fIstat_type\fP - One of the three constants specifying the type of 
-stat operation to perform:
-
-.br
-\fBLIBSSH2_SFTP_STAT\fP: performs stat(2) operation
-.br
-\fBLIBSSH2_SFTP_LSTAT\fP: performs lstat(2) operation
-.br
-\fBLIBSSH2_SFTP_SETSTAT\fP: performs operation to set stat info on file
-
-\fIattrs\fP - Pointer to a \fBLIBSSH2_SFTP_ATTRIBUTES\fP structure to set file
-metadata from or into depending on the value of stat_type.
-
-Get or Set statbuf type data on a remote filesystem object. When getting
-statbuf data,
-.BR libssh2_sftp_stat(3)
-will follow all symlinks, while 
-.BR libssh2_sftp_lstat(3)
-will return data about the object encountered, even if that object 
-happens to be a symlink.
-
-The LIBSSH2_SFTP_ATTRIBUTES struct looks like this:
-
-.nf
-struct LIBSSH2_SFTP_ATTRIBUTES {
-    /* If flags & ATTR_* bit is set, then the value in this struct will be
-     * meaningful Otherwise it should be ignored
-     */
-    unsigned long flags;
-
-    libssh2_uint64_t filesize;
-    unsigned long uid;
-    unsigned long gid;
-    unsigned long permissions;
-    unsigned long atime;
-    unsigned long mtime;
-};
-.fi
-.SH RETURN VALUE
-Returns 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
-when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_statvfs.3 b/libssh2/libssh2/docs/libssh2_sftp_statvfs.3
deleted file mode 100644
index 6327030a..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_statvfs.3
+++ /dev/null
@@ -1,79 +0,0 @@
-.TH libssh2_sftp_statvfs 3 "22 May 2010" "libssh2 1.2.6" "libssh2 manual"
-.SH NAME
-libssh2_sftp_statvfs, libssh2_sftp_fstatvfs - get file system statistics
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int
-libssh2_sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
-                     size_t path_len, LIBSSH2_SFTP_STATVFS *st);
-
-int
-libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle,
-                      LIBSSH2_SFTP_STATVFS *st)
-.fi
-.SH DESCRIPTION
-These functions provide statvfs(2)-like operations and require
-statvfs@openssh.com and fstatvfs@openssh.com extension support on the server.
-
-\fIsftp\fP - SFTP instance as returned by
-.BR libssh2_sftp_init(3)
-
-\fIhandle\fP - SFTP File Handle as returned by
-.BR libssh2_sftp_open_ex(3)
-
-\fIpath\fP - full path of any file within the mounted file system.
-
-\fIpath_len\fP - length of the full path.
-
-\fIst\fP - Pointer to a LIBSSH2_SFTP_STATVFS structure to place file system
-statistics into.
-
-.SH DATA TYPES
-LIBSSH2_SFTP_STATVFS is a typedefed struct that is defined as below
-
-.nf
-struct _LIBSSH2_SFTP_STATVFS {
-    libssh2_uint64_t  f_bsize;    /* file system block size */
-    libssh2_uint64_t  f_frsize;   /* fragment size */
-    libssh2_uint64_t  f_blocks;   /* size of fs in f_frsize units */
-    libssh2_uint64_t  f_bfree;    /* # free blocks */
-    libssh2_uint64_t  f_bavail;   /* # free blocks for non-root */
-    libssh2_uint64_t  f_files;    /* # inodes */
-    libssh2_uint64_t  f_ffree;    /* # free inodes */
-    libssh2_uint64_t  f_favail;   /* # free inodes for non-root */
-    libssh2_uint64_t  f_fsid;     /* file system ID */
-    libssh2_uint64_t  f_flag;     /* mount flags */
-    libssh2_uint64_t  f_namemax;  /* maximum filename length */
-};
-.fi
-
-It is unspecified whether all members of the returned struct have meaningful
-values on all file systems.
-
-The field \fIf_flag\fP is a bit mask. Bits are defined as follows:
-.IP LIBSSH2_SFTP_ST_RDONLY
-Read-only file system.
-.IP LIBSSH2_SFTP_ST_NOSUID
-Set-user-ID/set-group-ID bits are ignored by \fBexec\fP(3).
-
-.SH RETURN VALUE
-Returns 0 on success or negative on failure. If used in non-blocking mode, it
-returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was
-received on the socket, or an SFTP operation caused an errorcode to be returned
-by the server.
-.SH AVAILABILITY
-Added in libssh2 1.2.6
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_symlink.3 b/libssh2/libssh2/docs/libssh2_sftp_symlink.3
deleted file mode 100644
index 3de7b290..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_symlink.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_sftp_symlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_symlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-#define libssh2_sftp_symlink(sftp, orig, linkpath) \\
-    libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), \\
-                            strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_symlink_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_symlink_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_symlink_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_symlink_ex.3
deleted file mode 100644
index fc0bc936..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_symlink_ex.3
+++ /dev/null
@@ -1,79 +0,0 @@
-.TH libssh2_sftp_symlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_symlink_ex - read or set a symbolic link
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
-                        unsigned int path_len, char *target,
-                        unsigned int target_len, int link_type);
-.SH DESCRIPTION
-Create a symlink or read out symlink information from the remote side.
-
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIpath\fP - Remote filesystem object to create a symlink from or resolve.
-
-\fIpath_len\fP - Length of the name of the remote filesystem object to 
-create a symlink from or resolve.
-
-\fItarget\fP - a pointer to a buffer. The buffer has different uses depending
-what the \fIlink_type\fP argument is set to.
-.br
-\fBLIBSSH2_SFTP_SYMLINK\fP: Remote filesystem object to link to.
-.br
-\fBLIBSSH2_SFTP_READLINK\fP: Pre-allocated buffer to resolve symlink target
-into.
-.br
-\fBLIBSSH2_SFTP_REALPATH\fP: Pre-allocated buffer to resolve realpath target
-into.
-
-\fItarget_len\fP - Length of the name of the remote filesystem target object.
-
-\fIlink_type\fP - One of the three previously mentioned constants which 
-determines the resulting behavior of this function.
-
-These are convenience macros:
-
-.BR libssh2_sftp_symlink(3)
-: Create a symbolic link between two filesystem objects.
-.br
-.BR libssh2_sftp_readlink(3)
-: Resolve a symbolic link filesystem object to its next target.
-.br
-.BR libssh2_sftp_realpath(3)
-: Resolve a complex, relative, or symlinked filepath to its effective target.
-.SH RETURN VALUE
-When using LIBSSH2_SFTP_SYMLINK, this function returns 0 on success or negative
-on failure.
-
-When using LIBSSH2_SFTP_READLINK or LIBSSH2_SFTP_REALPATH, it returns the
-number of bytes it copied to the target buffer (not including the terminating
-zero) or negative on failure.
-
-It returns LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-From 1.2.8, LIBSSH2_ERROR_BUFFER_TOO_SMALL is returned if the given 'target'
-buffer is too small to fit the requested object name.
-.SH BUG
-Passing in a too small buffer when receiving data only results in libssh2
-1.2.7 or earlier to not copy the entire data amount, and it is not possible
-for the application to tell when it happens!
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_tell.3 b/libssh2/libssh2/docs/libssh2_sftp_tell.3
deleted file mode 100644
index 2ff1fbad..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_tell.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_sftp_tell 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_tell - get the current read/write position indicator for a file
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-size_t 
-libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle);
-
-.SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP.
-
-Returns the current offset of the file handle's internal pointer. Note that
-this is now deprecated. Use the newer \fBlibssh2_sftp_tell64(3)\fP instead!
-.SH RETURN VALUE
-Current offset from beginning of file in bytes.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3),
-.BR libssh2_sftp_tell64(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_tell64.3 b/libssh2/libssh2/docs/libssh2_sftp_tell64.3
deleted file mode 100644
index 827601f1..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_tell64.3
+++ /dev/null
@@ -1,21 +0,0 @@
-.TH libssh2_sftp_tell64 3 "22 Dec 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_sftp_tell64 - get the current read/write position indicator for a file
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-libssh2_uint64_t
-libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle);
-
-.SH DESCRIPTION
-\fIhandle\fP - SFTP File Handle as returned by \fBlibssh2_sftp_open_ex(3)\fP
-
-Identify the current offset of the file handle's internal pointer.
-.SH RETURN VALUE
-Current offset from beginning of file in bytes.
-.SH AVAILABILITY
-Added in libssh2 1.0
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3),
-.BR libssh2_sftp_tell(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_unlink.3 b/libssh2/libssh2/docs/libssh2_sftp_unlink.3
deleted file mode 100644
index 32bbbf96..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_unlink.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_sftp_unlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_sftp_unlink - convenience macro for \fIlibssh2_sftp_unlink_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_sftp_unlink_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_sftp_unlink_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_sftp_unlink_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_sftp_unlink_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_unlink_ex.3 b/libssh2/libssh2/docs/libssh2_sftp_unlink_ex.3
deleted file mode 100644
index 6672a8c3..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_unlink_ex.3
+++ /dev/null
@@ -1,42 +0,0 @@
-.TH libssh2_sftp_unlink_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_unlink_ex - unlink an SFTP file
-.SH SYNOPSIS
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-int 
-libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename, unsigned int filename_len);
-
-int 
-libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
-
-.SH DESCRIPTION
-\fIsftp\fP - SFTP instance as returned by 
-.BR libssh2_sftp_init(3)
-
-\fIfilename\fP - Path and name of the existing filesystem entry
-
-\fIfilename_len\fP - Length of the path and name of the existing 
-filesystem entry
-
-Unlink (delete) a file from the remote filesystem.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-
-.SH SEE ALSO
-.BR libssh2_sftp_init(3)
diff --git a/libssh2/libssh2/docs/libssh2_sftp_write.3 b/libssh2/libssh2/docs/libssh2_sftp_write.3
deleted file mode 100644
index 8d819129..00000000
--- a/libssh2/libssh2/docs/libssh2_sftp_write.3
+++ /dev/null
@@ -1,71 +0,0 @@
-.TH libssh2_sftp_write 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_sftp_write - write SFTP data
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle,
-                           const char *buffer,
-                           size_t count);
-.SH DESCRIPTION
-\fBlibssh2_sftp_write(3)\fP writes a block of data to the SFTP server. This
-method is modeled after the POSIX write() function and uses the same calling
-semantics.
-
-\fIhandle\fP - SFTP file handle as returned by \fIlibssh2_sftp_open_ex(3)\fP.
-
-\fIbuffer\fP - points to the data to send off.
-
-\fIcount\fP - Number of bytes from 'buffer' to write. Note that it may not be
-possible to write all bytes as requested.
-
-\fIlibssh2_sftp_handle(3)\fP will use as much as possible of the buffer and
-put it into a single SFTP protocol packet. This means that to get maximum
-performance when sending larger files, you should try to always pass in at
-least 32K of data to this function.
-
-.SH WRITE AHEAD
-Starting in libssh2 version 1.2.8, the default behavior of libssh2 is to
-create several smaller outgoing packets for all data you pass to this function
-and it will return a positive number as soon as the first packet is
-acknowledged from the server.
-
-This has the effect that sometimes more data has been sent off but isn't acked
-yet when this function returns, and when this function is subsequently called
-again to write more data, libssh2 will immediately figure out that the data is
-already received remotely.
-
-In most normal situation this should not cause any problems, but it should be
-noted that if you've once called libssh2_sftp_write() with data and it returns
-short, you MUST still assume that the rest of the data might've been cached so
-you need to make sure you don't alter that data and think that the version you
-have in your next function invoke will be detected or used.
-
-The reason for this funny behavior is that SFTP can only send 32K data in each
-packet and it gets all packets acked individually. This means we cannot use a
-simple serial approach if we want to reach high performance even on high
-latency connections. And we want that.
-.SH RETURN VALUE
-Actual number of bytes written or negative on failure.
-
-If used in non-blocking mode, it returns LIBSSH2_ERROR_EAGAIN when it would
-otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative number, it isn't
-really a failure per se.
-
-If this function returns 0 (zero) it should not be considered an error, but
-simply that there was no error but yet no payload data got sent to the other
-end.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
-received on the socket, or an SFTP operation caused an errorcode to 
-be returned by the server.
-.SH SEE ALSO
-.BR libssh2_sftp_open_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_trace.3 b/libssh2/libssh2/docs/libssh2_trace.3
deleted file mode 100644
index 4d01bf7e..00000000
--- a/libssh2/libssh2/docs/libssh2_trace.3
+++ /dev/null
@@ -1,35 +0,0 @@
-.TH libssh2_trace 3 "26 Dec 2008" "libssh2 1.0" "libssh2 manual"
-.SH NAME
-libssh2_trace - enable debug info from inside libssh2
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
-
-.SH DESCRIPTION
-This is a function present in the library that can be used to get debug info
-from within libssh2 when it is running. Helpful when trying to trace or debug
-behaviors. Note that this function has no effect unless libssh2 was built to
-support tracing! It is usually disabled in release builds.
-
-\fBbitmask\fP can be set to the logical OR of none, one or more of these:
-.RS
-.IP LIBSSH2_TRACE_SOCKET
-Socket low-level debugging
-.IP LIBSSH2_TRACE_TRANS
-Transport layer debugging
-.IP LIBSSH2_TRACE_KEX
-Key exchange debugging
-.IP LIBSSH2_TRACE_AUTH
-Authentication debugging
-.IP LIBSSH2_TRACE_CONN
-Connection layer debugging
-.IP LIBSSH2_TRACE_SCP
-SCP debugging
-.IP LIBSSH2_TRACE_SFTP
-SFTP debugging
-.IP LIBSSH2_TRACE_ERROR
-Error debugging
-.IP LIBSSH2_TRACE_PUBLICKEY
-Public Key debugging
-.RE
diff --git a/libssh2/libssh2/docs/libssh2_trace_sethandler.3 b/libssh2/libssh2/docs/libssh2_trace_sethandler.3
deleted file mode 100644
index 57d84ba9..00000000
--- a/libssh2/libssh2/docs/libssh2_trace_sethandler.3
+++ /dev/null
@@ -1,28 +0,0 @@
-.TH libssh2_trace_sethandler 3 "15 Jan 2010" "libssh2 1.2.3" "libssh2 manual"
-.SH NAME
-libssh2_trace_sethandler - set a trace output handler
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-typedef void (*libssh2_trace_handler_func)(LIBSSH2_SESSION *session,
-                                           void* context,
-                                           const char *data,
-                                           size_t length);
-
-int libssh2_trace_sethandler(LIBSSH2_SESSION *session,
-                             void* context,
-                             libssh2_trace_handler_func callback);
-.SH DESCRIPTION
-libssh2_trace_sethandler installs a trace output handler for your application.
-By default, when tracing has been switched on via a call to libssh2_trace(),
-all output is written to stderr.  By calling this method and passing a
-function pointer that matches the libssh2_trace_handler_func prototype,
-libssh2 will call back as it generates trace output.  This can be used to
-capture the trace output and put it into a log file or diagnostic window.
-This function has no effect unless libssh2 was built to support this option,
-and a typical "release build" might not.
-
-\fBcontext\fP can be used to pass arbitrary user defined data back into the callback when invoked.
-.SH AVAILABILITY
-Added in libssh2 version 1.2.3
diff --git a/libssh2/libssh2/docs/libssh2_userauth_authenticated.3 b/libssh2/libssh2/docs/libssh2_userauth_authenticated.3
deleted file mode 100644
index 786e0f0e..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_authenticated.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_userauth_authenticated 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_authenticated - return authentication status
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int 
-libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
-
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-Indicates whether or not the named session has been successfully authenticated.
-
-.SH RETURN VALUE
-Returns 1 if authenticated and 0 if not.
-
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile.3 b/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile.3
deleted file mode 100644
index 21153561..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile.3
+++ /dev/null
@@ -1,17 +0,0 @@
-.TH libssh2_userauth_hostbased_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_userauth_hostbased_fromfile - convenience macro for \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_userauth_hostbased_fromfile(LIBSSH2_SESSION *session, const char *username, const char *publickey, const char *privatekey, const char *passphrase, const char *hostname);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_userauth_hostbased_fromfile_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_userauth_hostbased_fromfile_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3 b/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3
deleted file mode 100644
index a65f8029..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_hostbased_fromfile_ex.3
+++ /dev/null
@@ -1,12 +0,0 @@
-.TH libssh2_userauth_hostbased_fromfile_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_hostbased_fromfile_ex - TODO
-.SH SYNOPSIS
-
-.SH DESCRIPTION
-
-.SH RETURN VALUE
-
-.SH ERRORS
-
-.SH SEE ALSO
diff --git a/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive.3 b/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive.3
deleted file mode 100644
index a85de321..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_userauth_keyboard_interactive 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_userauth_keyboard_interactive - convenience macro for \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-
-int
-libssh2_userauth_keyboard_interactive(LIBSSH2_SESSION* session,
-                                      const char *username,
-           LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*response_callback)));
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_userauth_keyboard_interactive_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_userauth_keyboard_interactive_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3 b/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3
deleted file mode 100644
index ada012a2..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_keyboard_interactive_ex.3
+++ /dev/null
@@ -1,58 +0,0 @@
-.TH libssh2_userauth_keyboard_interactive_ex 3 "8 Mar 2008" "libssh2 0.19" "libssh2 manual"
-.SH NAME
-libssh2_userauth_keyboard_interactive_ex - authenticate a session using
-keyboard-interactive authentication
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-int
-libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *session,
-                                         const char *username,
-                                         unsigned int username_len,
-            LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(*response_callback));
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by
-\fIlibssh2_session_init_ex(3)\fP.
-
-\fIusername\fP - Name of user to attempt keyboard-interactive authentication
-for.
-
-\fIusername_len\fP - Length of username parameter.
-
-\fIresponse_callback\fP - As authentication proceeds, the host issues several
-(1 or more) challenges and requires responses. This callback will be called at
-this moment. The callback is responsible to obtain responses for the
-challenges, fill the provided data structure and then return
-control. Responses will be sent to the host. String values will be free(3)ed
-by the library. The callback prototype must match this:
-
-.nf
- void response(const char *name,
-               int name_len, const char *instruction,
-               int instruction_len,
-               int num_prompts,
-               const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-               LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-               void **abstract);
-.fi
-
-Attempts keyboard-interactive (challenge/response) authentication.
-
-Note that many SSH servers will always issue a single "password" challenge,
-requesting actual password as response, but it is not required by the
-protocol, and various authentication schemes, such as smartcard authentication
-may use keyboard-interactive authentication type too.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns LIBSSH2_ERROR_EAGAIN
-when it would otherwise block. While LIBSSH2_ERROR_EAGAIN is a negative
-number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fLIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
-or public/private key.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_list.3 b/libssh2/libssh2/docs/libssh2_userauth_list.3
deleted file mode 100644
index de349f10..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_list.3
+++ /dev/null
@@ -1,39 +0,0 @@
-.TH libssh2_userauth_list 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_list - list supported authentication methods
-.SH SYNOPSIS
-.nf
-#include <libssh2.h>
-
-char *
-libssh2_userauth_list(LIBSSH2_SESSION *session, const char *username,
-                      unsigned int username_len);
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIusername\fP - Username which will be used while authenticating. Note that
-most server implementations do not permit attempting authentication with
-different usernames between requests. Therefore this must be the same username
-you will use on later userauth calls.
-
-\fIusername_len\fP - Length of username parameter.
-
-Send a \fBSSH_USERAUTH_NONE\fP request to the remote host. Unless the remote
-host is configured to accept none as a viable authentication scheme
-(unlikely), it will return \fBSSH_USERAUTH_FAILURE\fP along with a listing of
-what authentication schemes it does support. In the unlikely event that none
-authentication succeeds, this method with return NULL. This case may be
-distinguished from a failing case by examining
-\fIlibssh2_userauth_authenticated(3)\fP.
-.SH RETURN VALUE
-On success a comma delimited list of supported authentication schemes.  This
-list is internally managed by libssh2.  On failure returns NULL.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_EAGAIN\fP - Marked for non-blocking I/O but the call
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_password.3 b/libssh2/libssh2/docs/libssh2_userauth_password.3
deleted file mode 100644
index 15e55118..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_password.3
+++ /dev/null
@@ -1,19 +0,0 @@
-.TH libssh2_userauth_password 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_userauth_password - convenience macro for \fIlibssh2_userauth_password_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int libssh2_userauth_password(LIBSSH2_SESSION *session,
-                              const char *username,
-                              const char *password);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_userauth_password_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_userauth_password_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_userauth_password_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_userauth_password_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_password_ex.3 b/libssh2/libssh2/docs/libssh2_userauth_password_ex.3
deleted file mode 100644
index dc9e1083..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_password_ex.3
+++ /dev/null
@@ -1,57 +0,0 @@
-.TH libssh2_userauth_password_ex 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_password_ex - authenticate a session with username and password
-.SH SYNOPSIS
-#include <libssh2.h>
-.nf
-int libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
-                    const char *username,
-                    unsigned int username_len,
-                    const char *password,
-                    unsigned int password_len,
-                    LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)));
-
-#define libssh2_userauth_password(session, username, password) \\
- libssh2_userauth_password_ex((session), (username), \\
-                              strlen(username), \\
-                              (password), strlen(password), NULL)
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by 
-.BR libssh2_session_init_ex(3)
-
-\fIusername\fP - Name of user to attempt plain password authentication for.
-
-\fIusername_len\fP - Length of username parameter.
-
-\fIpassword\fP - Password to use for authenticating username.
-
-\fIpassword_len\fP - Length of password parameter.
-
-\fIpasswd_change_cb\fP - If the host accepts authentication but 
-requests that the password be changed, this callback will be issued. 
-If no callback is defined, but server required password change, 
-authentication will fail.
-
-Attempt basic password authentication. Note that many SSH servers 
-which appear to support ordinary password authentication actually have 
-it disabled and use Keyboard Interactive authentication (routed via 
-PAM or another authentication backed) instead.
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-Some of the errors this function may return include:
-
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_PASSWORD_EXPIRED\fP - 
-
-\fLIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - failed, invalid username/password
-or public/private key.
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_publickey.3 b/libssh2/libssh2/docs/libssh2_userauth_publickey.3
deleted file mode 100644
index 0081a248..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_publickey.3
+++ /dev/null
@@ -1,27 +0,0 @@
-.TH libssh2_userauth_publickey 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_publickey - authenticate using a callback function
-.SH SYNOPSIS
-#include <libssh2.h>
-
-.nf
-int libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                               const char *user,
-                               const unsigned char *pubkeydata,
-                               size_t pubkeydata_len,
-                               sign_callback,
-                               void **abstract);
-.SH DESCRIPTION
-Authenticate with the \fIsign_callback\fP callback that matches the prototype
-below
-.SH CALLBACK
-.nf
-int name(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
-         const unsigned char *data, size_t data_len, void **abstract);
-.fi
-
-This function gets called...
-.SH RETURN VALUE
-Return 0 on success or negative on failure.
-.SH SEE ALSO
-.BR libssh2_userauth_publickey_fromfile_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile.3 b/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile.3
deleted file mode 100644
index f4799a1c..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile.3
+++ /dev/null
@@ -1,22 +0,0 @@
-.TH libssh2_userauth_publickey_fromfile 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
-.SH NAME
-libssh2_userauth_publickey_fromfile - convenience macro for \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP calls
-.SH SYNOPSIS
-#include <libssh2.h>
-
-int
-libssh2_userauth_publickey_fromfile(LIBSSH2_SESSION *session,
-                                    const char *username,
-                                    const char *publickey,
-                                    const char *privatekey,
-                                    const char *passphrase);
-
-.SH DESCRIPTION
-This is a macro defined in a public libssh2 header file that is using the
-underlying function \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP.
-.SH RETURN VALUE
-See \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP
-.SH ERRORS
-See \fIlibssh2_userauth_publickey_fromfile_ex(3)\fP
-.SH SEE ALSO
-.BR libssh2_userauth_publickey_fromfile_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3 b/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3
deleted file mode 100644
index 0d77c9a3..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_publickey_fromfile_ex.3
+++ /dev/null
@@ -1,52 +0,0 @@
-.TH libssh2_userauth_publickey_fromfile 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_userauth_publickey_fromfile - authenticate a session with a public key, read from a file
-.SH SYNOPSIS
-#include <libssh2.h>
-
-.nf
-int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
-                                           const char *username,
-                                           unsigned int ousername_len,
-                                           const char *publickey,
-                                           const char *privatekey,
-                                           const char *passphrase);
-.SH DESCRIPTION
-\fIsession\fP - Session instance as returned by
-\fBlibssh2_session_init_ex(3)\fP
-
-\fIusername\fP - Pointer to user name to authenticate as.
-
-\fIusername_len\fP - Length of \fIusername\fP.
-
-\fIpublickey\fP - Path name of the public key file.
-(e.g. /etc/ssh/hostkey.pub). If libssh2 is built against OpenSSL, this option
-can be set to NULL.
-
-\fIprivatekey\fP - Path name of the private key file. (e.g. /etc/ssh/hostkey)
-
-\fIpassphrase\fP - Passphrase to use when decoding \fIprivatekey\fP.
-
-Attempt public key authentication using a PEM encoded private key file stored
-on disk
-
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_PUBLICKEY_UNVERIFIED\fP - The username/public key
-combination was invalid.
-
-\fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - Authentication using the supplied
-public key was not accepted.
-
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_userauth_publickey_frommemory.3 b/libssh2/libssh2/docs/libssh2_userauth_publickey_frommemory.3
deleted file mode 100644
index 685bd591..00000000
--- a/libssh2/libssh2/docs/libssh2_userauth_publickey_frommemory.3
+++ /dev/null
@@ -1,56 +0,0 @@
-.TH libssh2_userauth_publickey_frommemory 3 "1 Sep 2014" "libssh2 1.5" "libssh2 manual"
-.SH NAME
-libssh2_userauth_publickey_frommemory - authenticate a session with a public key, read from memory
-.SH SYNOPSIS
-#include <libssh2.h>
-
-.nf
-int libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
-                                           const char *username,
-                                           size_t username_len,
-                                           const char *publickeydata,
-                                           size_t publickeydata_len,
-                                           const char *privatekeydata,
-                                           size_t privatekeydata_len,
-                                           const char *passphrase);
-.SH DESCRIPTION
-This function allows to authenticate a session with a public key read from memory.
-It's only supported when libssh2 is backed by OpenSSL.
-\fIsession\fP - Session instance as returned by
-.BR libssh2_session_init_ex(3)
-
-\fIusername\fP - Remote user name to authenticate as.
-
-\fIusername_len\fP - Length of username.
-
-\fIpublickeydata\fP - Buffer containing the contents of a public key file.
-
-\fIpublickeydata_len\fP - Length of public key data.
-
-\fIprivatekeydata\fP - Buffer containing the contents of a private key file.
-
-\fIprivatekeydata_len\fP - Length of private key data.
-
-\fIpassphrase\fP - Passphrase to use when decoding private key file.
-
-Attempt public key authentication using a PEM encoded private key file stored in memory.
-.SH RETURN VALUE
-Return 0 on success or negative on failure.  It returns
-LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
-LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-.SH ERRORS
-\fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
-
-\fILIBSSH2_ERROR_SOCKET_SEND\fP - Unable to send data on socket.
-
-\fILIBSSH2_ERROR_SOCKET_TIMEOUT\fP - 
-
-\fILIBSSH2_ERROR_PUBLICKEY_UNVERIFIED\fP - The username/public key
-combination was invalid.
-
-\fILIBSSH2_ERROR_AUTHENTICATION_FAILED\fP - Authentication using the supplied
-public key was not accepted.
-.SH AVAILABILITY
-libssh2_userauth_publickey_frommemory was added in libssh2 1.6.0
-.SH SEE ALSO
-.BR libssh2_session_init_ex(3)
diff --git a/libssh2/libssh2/docs/libssh2_version.3 b/libssh2/libssh2/docs/libssh2_version.3
deleted file mode 100644
index f98ca967..00000000
--- a/libssh2/libssh2/docs/libssh2_version.3
+++ /dev/null
@@ -1,36 +0,0 @@
-.TH libssh2_version 3 "23 Feb 2009" "libssh2 1.1" "libssh2 manual"
-.SH NAME
-libssh2_version - return the libssh2 version number
-.SH SYNOPSIS
-#include <libssh2.h>
-
-const char *
-libssh2_version(int required_version);
-.SH DESCRIPTION
-If \fIrequired_version\fP is lower than or equal to the version number of the
-libssh2 in use, the version number of libssh2 is returned as a pointer to a
-zero terminated string.
-
-The \fIrequired_version\fP should be the version number as constructed by the
-LIBSSH2_VERSION_NUM define in the libssh2.h public header file, which is a 24
-bit number in the 0xMMmmpp format. MM for major, mm for minor and pp for patch
-number.
-.SH RETURN VALUE
-The version number of libssh2 is returned as a pointer to a zero terminated
-string or NULL if the \fIrequired_version\fP isn't fulfilled.
-.SH EXAMPLE
-To make sure you run with the correct libssh2 version:
-
-.nf
-if (!libssh2_version(LIBSSH2_VERSION_NUM)) {
-  fprintf (stderr, \&"Runtime libssh2 version too old!\&");
-  exit(1);
-}
-.fi
-
-Unconditionally get the version number:
-
-printf(\&"libssh2 version: %s\&", libssh2_version(0) );
-.SH AVAILABILITY
-This function was added in libssh2 1.1, in previous versions there way no way
-to extract this info in run-time.
diff --git a/libssh2/libssh2/docs/template.3 b/libssh2/libssh2/docs/template.3
deleted file mode 100644
index d5b4473c..00000000
--- a/libssh2/libssh2/docs/template.3
+++ /dev/null
@@ -1,20 +0,0 @@
-.TH libssh2_template 3 "1 Jun 2007" "libssh2 0.15" "libssh2 manual"
-.SH NAME
-libssh2_template - short function description
-.SH SYNOPSIS
-#include <libssh2.h>
-
-void 
-libssh2_template(void);
-
-.SH DESCRIPTION
-Long text describing the function and its input arguments.
-
-.SH RETURN VALUE
-Describe what the function returns.
-
-.SH ERRORS
-Add error codes
-
-.SH SEE ALSO
-Add related functions
diff --git a/libssh2/libssh2/example/CMakeLists.txt b/libssh2/libssh2/example/CMakeLists.txt
deleted file mode 100644
index 3dc115ef..00000000
--- a/libssh2/libssh2/example/CMakeLists.txt
+++ /dev/null
@@ -1,101 +0,0 @@
-# Copyright (c) 2014, 2015 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-include(CheckIncludeFiles)
-include(CheckSymbolExists)
-include(CopyRuntimeDependencies)
-include(SocketLibraries)
-
-set(EXAMPLES
-  direct_tcpip
-  ssh2
-  scp
-  scp_nonblock
-  scp_write
-  scp_write_nonblock
-  sftp
-  sftp_nonblock
-  sftp_write
-  sftp_write_nonblock
-  sftp_mkdir
-  sftp_mkdir_nonblock
-  sftp_RW_nonblock
-  sftp_write_sliding
-  sftpdir
-  sftpdir_nonblock
-  ssh2_exec
-  ssh2_agent
-  ssh2_agent_forwarding
-  ssh2_echo
-  sftp_append
-  subsystem_netconf
-  tcpip-forward)
-
-append_needed_socket_libraries(LIBRARIES)
-
-foreach(example ${EXAMPLES})
-  add_executable(example-${example} ${example}.c)
-  list(APPEND EXAMPLE_TARGETS example-${example})
-  # to find generated header
-  target_include_directories(example-${example} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-  target_link_libraries(example-${example} libssh2 ${LIBRARIES})
-endforeach()
-add_target_to_copy_dependencies(
-  TARGET copy_example_dependencies
-  DEPENDENCIES ${RUNTIME_DEPENDENCIES}
-  BEFORE_TARGETS ${EXAMPLE_TARGETS})
-
-## Platform checks
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(stdlib.h HAVE_STDLIB_H)
-check_include_files(sys/select.h HAVE_SYS_SELECT_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(sys/time.h HAVE_SYS_TIME_H)
-check_include_files(arpa/inet.h HAVE_ARPA_INET_H)
-check_include_files(netinet/in.h HAVE_NETINET_IN_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-
-check_symbol_exists(strcasecmp strings.h HAVE_STRCASECMP)
-check_symbol_exists(_stricmp string.h HAVE__STRICMP)
-check_symbol_exists(snprintf stdio.h HAVE_SNPRINTF)
-check_symbol_exists(_snprintf stdio.h HAVE__SNPRINTF)
-
-check_symbol_exists(__func__ "" HAVE___FUNC__)
-check_symbol_exists(__FUNCTION__ "" HAVE___FUNCTION__)
-
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h)
diff --git a/libssh2/libssh2/example/Makefile.am b/libssh2/libssh2/example/Makefile.am
deleted file mode 100644
index ec542cd1..00000000
--- a/libssh2/libssh2/example/Makefile.am
+++ /dev/null
@@ -1,17 +0,0 @@
-AUTOMAKE_OPTIONS = foreign nostdinc
-
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in CMakeLists.txt
-
-# samples
-noinst_PROGRAMS = direct_tcpip ssh2 scp scp_nonblock scp_write		\
- scp_write_nonblock sftp sftp_nonblock sftp_write sftp_write_nonblock	\
- sftp_mkdir sftp_mkdir_nonblock sftp_RW_nonblock sftp_write_sliding	\
- sftpdir sftpdir_nonblock ssh2_exec ssh2_agent ssh2_agent_forwarding \
- ssh2_echo sftp_append subsystem_netconf tcpip-forward
-
-if HAVE_SYS_UN_H
-noinst_PROGRAMS += x11
-endif
-
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/example -I../src
-LDADD = $(top_builddir)/src/libssh2.la
diff --git a/libssh2/libssh2/example/Makefile.in b/libssh2/libssh2/example/Makefile.in
deleted file mode 100644
index ff86a2e4..00000000
--- a/libssh2/libssh2/example/Makefile.in
+++ /dev/null
@@ -1,924 +0,0 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-VPATH = @srcdir@
-am__is_gnu_make = { \
-  if test -z '$(MAKELEVEL)'; then \
-    false; \
-  elif test -n '$(MAKE_HOST)'; then \
-    true; \
-  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
-    true; \
-  else \
-    false; \
-  fi; \
-}
-am__make_running_with_option = \
-  case $${target_option-} in \
-      ?) ;; \
-      *) echo "am__make_running_with_option: internal error: invalid" \
-              "target option '$${target_option-}' specified" >&2; \
-         exit 1;; \
-  esac; \
-  has_opt=no; \
-  sane_makeflags=$$MAKEFLAGS; \
-  if $(am__is_gnu_make); then \
-    sane_makeflags=$$MFLAGS; \
-  else \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        bs=\\; \
-        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
-          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
-    esac; \
-  fi; \
-  skip_next=no; \
-  strip_trailopt () \
-  { \
-    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
-  }; \
-  for flg in $$sane_makeflags; do \
-    test $$skip_next = yes && { skip_next=no; continue; }; \
-    case $$flg in \
-      *=*|--*) continue;; \
-        -*I) strip_trailopt 'I'; skip_next=yes;; \
-      -*I?*) strip_trailopt 'I';; \
-        -*O) strip_trailopt 'O'; skip_next=yes;; \
-      -*O?*) strip_trailopt 'O';; \
-        -*l) strip_trailopt 'l'; skip_next=yes;; \
-      -*l?*) strip_trailopt 'l';; \
-      -[dEDm]) skip_next=yes;; \
-      -[JT]) skip_next=yes;; \
-    esac; \
-    case $$flg in \
-      *$$target_option*) has_opt=yes; break;; \
-    esac; \
-  done; \
-  test $$has_opt = yes
-am__make_dryrun = (target_option=n; $(am__make_running_with_option))
-am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-build_triplet = @build@
-host_triplet = @host@
-noinst_PROGRAMS = direct_tcpip$(EXEEXT) ssh2$(EXEEXT) scp$(EXEEXT) \
-	scp_nonblock$(EXEEXT) scp_write$(EXEEXT) \
-	scp_write_nonblock$(EXEEXT) sftp$(EXEEXT) \
-	sftp_nonblock$(EXEEXT) sftp_write$(EXEEXT) \
-	sftp_write_nonblock$(EXEEXT) sftp_mkdir$(EXEEXT) \
-	sftp_mkdir_nonblock$(EXEEXT) sftp_RW_nonblock$(EXEEXT) \
-	sftp_write_sliding$(EXEEXT) sftpdir$(EXEEXT) \
-	sftpdir_nonblock$(EXEEXT) ssh2_exec$(EXEEXT) \
-	ssh2_agent$(EXEEXT) ssh2_agent_forwarding$(EXEEXT) \
-	ssh2_echo$(EXEEXT) sftp_append$(EXEEXT) \
-	subsystem_netconf$(EXEEXT) tcpip-forward$(EXEEXT) \
-	$(am__EXEEXT_1)
-@HAVE_SYS_UN_H_TRUE@am__append_1 = x11
-subdir = example
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
-CONFIG_CLEAN_FILES =
-CONFIG_CLEAN_VPATH_FILES =
-@HAVE_SYS_UN_H_TRUE@am__EXEEXT_1 = x11$(EXEEXT)
-PROGRAMS = $(noinst_PROGRAMS)
-direct_tcpip_SOURCES = direct_tcpip.c
-direct_tcpip_OBJECTS = direct_tcpip.$(OBJEXT)
-direct_tcpip_LDADD = $(LDADD)
-direct_tcpip_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-AM_V_lt = $(am__v_lt_@AM_V@)
-am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
-am__v_lt_0 = --silent
-am__v_lt_1 = 
-scp_SOURCES = scp.c
-scp_OBJECTS = scp.$(OBJEXT)
-scp_LDADD = $(LDADD)
-scp_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-scp_nonblock_SOURCES = scp_nonblock.c
-scp_nonblock_OBJECTS = scp_nonblock.$(OBJEXT)
-scp_nonblock_LDADD = $(LDADD)
-scp_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-scp_write_SOURCES = scp_write.c
-scp_write_OBJECTS = scp_write.$(OBJEXT)
-scp_write_LDADD = $(LDADD)
-scp_write_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-scp_write_nonblock_SOURCES = scp_write_nonblock.c
-scp_write_nonblock_OBJECTS = scp_write_nonblock.$(OBJEXT)
-scp_write_nonblock_LDADD = $(LDADD)
-scp_write_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_SOURCES = sftp.c
-sftp_OBJECTS = sftp.$(OBJEXT)
-sftp_LDADD = $(LDADD)
-sftp_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_RW_nonblock_SOURCES = sftp_RW_nonblock.c
-sftp_RW_nonblock_OBJECTS = sftp_RW_nonblock.$(OBJEXT)
-sftp_RW_nonblock_LDADD = $(LDADD)
-sftp_RW_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_append_SOURCES = sftp_append.c
-sftp_append_OBJECTS = sftp_append.$(OBJEXT)
-sftp_append_LDADD = $(LDADD)
-sftp_append_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_mkdir_SOURCES = sftp_mkdir.c
-sftp_mkdir_OBJECTS = sftp_mkdir.$(OBJEXT)
-sftp_mkdir_LDADD = $(LDADD)
-sftp_mkdir_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_mkdir_nonblock_SOURCES = sftp_mkdir_nonblock.c
-sftp_mkdir_nonblock_OBJECTS = sftp_mkdir_nonblock.$(OBJEXT)
-sftp_mkdir_nonblock_LDADD = $(LDADD)
-sftp_mkdir_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_nonblock_SOURCES = sftp_nonblock.c
-sftp_nonblock_OBJECTS = sftp_nonblock.$(OBJEXT)
-sftp_nonblock_LDADD = $(LDADD)
-sftp_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_write_SOURCES = sftp_write.c
-sftp_write_OBJECTS = sftp_write.$(OBJEXT)
-sftp_write_LDADD = $(LDADD)
-sftp_write_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_write_nonblock_SOURCES = sftp_write_nonblock.c
-sftp_write_nonblock_OBJECTS = sftp_write_nonblock.$(OBJEXT)
-sftp_write_nonblock_LDADD = $(LDADD)
-sftp_write_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftp_write_sliding_SOURCES = sftp_write_sliding.c
-sftp_write_sliding_OBJECTS = sftp_write_sliding.$(OBJEXT)
-sftp_write_sliding_LDADD = $(LDADD)
-sftp_write_sliding_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftpdir_SOURCES = sftpdir.c
-sftpdir_OBJECTS = sftpdir.$(OBJEXT)
-sftpdir_LDADD = $(LDADD)
-sftpdir_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-sftpdir_nonblock_SOURCES = sftpdir_nonblock.c
-sftpdir_nonblock_OBJECTS = sftpdir_nonblock.$(OBJEXT)
-sftpdir_nonblock_LDADD = $(LDADD)
-sftpdir_nonblock_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-ssh2_SOURCES = ssh2.c
-ssh2_OBJECTS = ssh2.$(OBJEXT)
-ssh2_LDADD = $(LDADD)
-ssh2_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-ssh2_agent_SOURCES = ssh2_agent.c
-ssh2_agent_OBJECTS = ssh2_agent.$(OBJEXT)
-ssh2_agent_LDADD = $(LDADD)
-ssh2_agent_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-ssh2_agent_forwarding_SOURCES = ssh2_agent_forwarding.c
-ssh2_agent_forwarding_OBJECTS = ssh2_agent_forwarding.$(OBJEXT)
-ssh2_agent_forwarding_LDADD = $(LDADD)
-ssh2_agent_forwarding_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-ssh2_echo_SOURCES = ssh2_echo.c
-ssh2_echo_OBJECTS = ssh2_echo.$(OBJEXT)
-ssh2_echo_LDADD = $(LDADD)
-ssh2_echo_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-ssh2_exec_SOURCES = ssh2_exec.c
-ssh2_exec_OBJECTS = ssh2_exec.$(OBJEXT)
-ssh2_exec_LDADD = $(LDADD)
-ssh2_exec_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-subsystem_netconf_SOURCES = subsystem_netconf.c
-subsystem_netconf_OBJECTS = subsystem_netconf.$(OBJEXT)
-subsystem_netconf_LDADD = $(LDADD)
-subsystem_netconf_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-tcpip_forward_SOURCES = tcpip-forward.c
-tcpip_forward_OBJECTS = tcpip-forward.$(OBJEXT)
-tcpip_forward_LDADD = $(LDADD)
-tcpip_forward_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-x11_SOURCES = x11.c
-x11_OBJECTS = x11.$(OBJEXT)
-x11_LDADD = $(LDADD)
-x11_DEPENDENCIES = $(top_builddir)/src/libssh2.la
-AM_V_P = $(am__v_P_@AM_V@)
-am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
-am__v_P_0 = false
-am__v_P_1 = :
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN     " $@;
-am__v_GEN_1 = 
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-am__v_at_1 = 
-DEFAULT_INCLUDES = 
-depcomp = $(SHELL) $(top_srcdir)/depcomp
-am__maybe_remake_depfiles = depfiles
-am__depfiles_remade = ./$(DEPDIR)/direct_tcpip.Po ./$(DEPDIR)/scp.Po \
-	./$(DEPDIR)/scp_nonblock.Po ./$(DEPDIR)/scp_write.Po \
-	./$(DEPDIR)/scp_write_nonblock.Po ./$(DEPDIR)/sftp.Po \
-	./$(DEPDIR)/sftp_RW_nonblock.Po ./$(DEPDIR)/sftp_append.Po \
-	./$(DEPDIR)/sftp_mkdir.Po ./$(DEPDIR)/sftp_mkdir_nonblock.Po \
-	./$(DEPDIR)/sftp_nonblock.Po ./$(DEPDIR)/sftp_write.Po \
-	./$(DEPDIR)/sftp_write_nonblock.Po \
-	./$(DEPDIR)/sftp_write_sliding.Po ./$(DEPDIR)/sftpdir.Po \
-	./$(DEPDIR)/sftpdir_nonblock.Po ./$(DEPDIR)/ssh2.Po \
-	./$(DEPDIR)/ssh2_agent.Po ./$(DEPDIR)/ssh2_agent_forwarding.Po \
-	./$(DEPDIR)/ssh2_echo.Po ./$(DEPDIR)/ssh2_exec.Po \
-	./$(DEPDIR)/subsystem_netconf.Po ./$(DEPDIR)/tcpip-forward.Po \
-	./$(DEPDIR)/x11.Po
-am__mv = mv -f
-COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
-LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
-	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
-	$(AM_CFLAGS) $(CFLAGS)
-AM_V_CC = $(am__v_CC_@AM_V@)
-am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
-am__v_CC_0 = @echo "  CC      " $@;
-am__v_CC_1 = 
-CCLD = $(CC)
-LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
-	$(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CCLD = $(am__v_CCLD_@AM_V@)
-am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
-am__v_CCLD_0 = @echo "  CCLD    " $@;
-am__v_CCLD_1 = 
-SOURCES = direct_tcpip.c scp.c scp_nonblock.c scp_write.c \
-	scp_write_nonblock.c sftp.c sftp_RW_nonblock.c sftp_append.c \
-	sftp_mkdir.c sftp_mkdir_nonblock.c sftp_nonblock.c \
-	sftp_write.c sftp_write_nonblock.c sftp_write_sliding.c \
-	sftpdir.c sftpdir_nonblock.c ssh2.c ssh2_agent.c \
-	ssh2_agent_forwarding.c ssh2_echo.c ssh2_exec.c \
-	subsystem_netconf.c tcpip-forward.c x11.c
-DIST_SOURCES = direct_tcpip.c scp.c scp_nonblock.c scp_write.c \
-	scp_write_nonblock.c sftp.c sftp_RW_nonblock.c sftp_append.c \
-	sftp_mkdir.c sftp_mkdir_nonblock.c sftp_nonblock.c \
-	sftp_write.c sftp_write_nonblock.c sftp_write_sliding.c \
-	sftpdir.c sftpdir_nonblock.c ssh2.c ssh2_agent.c \
-	ssh2_agent_forwarding.c ssh2_echo.c ssh2_exec.c \
-	subsystem_netconf.c tcpip-forward.c x11.c
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-# Read a list of newline-separated strings from the standard input,
-# and print each of them once, without duplicates.  Input order is
-# *not* preserved.
-am__uniquify_input = $(AWK) '\
-  BEGIN { nonempty = 0; } \
-  { items[$$0] = 1; nonempty = 1; } \
-  END { if (nonempty) { for (i in items) print i; }; } \
-'
-# Make sure the list of sources is unique.  This is necessary because,
-# e.g., the same source file might be shared among _SOURCES variables
-# for different programs/libraries.
-am__define_uniq_tagged_files = \
-  list='$(am__tagged_files)'; \
-  unique=`for i in $$list; do \
-    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-  done | $(am__uniquify_input)`
-am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AR = @AR@
-AS = @AS@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CSCOPE = @CSCOPE@
-CTAGS = @CTAGS@
-CXX = @CXX@
-CXXCPP = @CXXCPP@
-CXXDEPMODE = @CXXDEPMODE@
-CXXFLAGS = @CXXFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-DLLTOOL = @DLLTOOL@
-DSYMUTIL = @DSYMUTIL@
-DUMPBIN = @DUMPBIN@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EGREP = @EGREP@
-ETAGS = @ETAGS@
-EXEEXT = @EXEEXT@
-FGREP = @FGREP@
-GREP = @GREP@
-HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
-HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
-HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
-HAVE_LIBSSL = @HAVE_LIBSSL@
-HAVE_LIBZ = @HAVE_LIBZ@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBBCRYPT = @LIBBCRYPT@
-LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
-LIBGCRYPT = @LIBGCRYPT@
-LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
-LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
-LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
-LIBSSL = @LIBSSL@
-LIBSSL_PREFIX = @LIBSSL_PREFIX@
-LIBTOOL = @LIBTOOL@
-LIBZ = @LIBZ@
-LIBZ_PREFIX = @LIBZ_PREFIX@
-LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
-LIPO = @LIPO@
-LN_S = @LN_S@
-LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
-LTLIBGCRYPT = @LTLIBGCRYPT@
-LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
-LTLIBOBJS = @LTLIBOBJS@
-LTLIBSSL = @LTLIBSSL@
-LTLIBZ = @LTLIBZ@
-LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MANIFEST_TOOL = @MANIFEST_TOOL@
-MKDIR_P = @MKDIR_P@
-NM = @NM@
-NMEDIT = @NMEDIT@
-OBJDUMP = @OBJDUMP@
-OBJEXT = @OBJEXT@
-OTOOL = @OTOOL@
-OTOOL64 = @OTOOL64@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-RANLIB = @RANLIB@
-SED = @SED@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-SSHD = @SSHD@
-STRIP = @STRIP@
-VERSION = @VERSION@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_AR = @ac_ct_AR@
-ac_ct_CC = @ac_ct_CC@
-ac_ct_CXX = @ac_ct_CXX@
-ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build = @build@
-build_alias = @build_alias@
-build_cpu = @build_cpu@
-build_os = @build_os@
-build_vendor = @build_vendor@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-docdir = @docdir@
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-host = @host@
-host_alias = @host_alias@
-host_cpu = @host_cpu@
-host_os = @host_os@
-host_vendor = @host_vendor@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-runstatedir = @runstatedir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-AUTOMAKE_OPTIONS = foreign nostdinc
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in CMakeLists.txt
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/example -I../src
-LDADD = $(top_builddir)/src/libssh2.la
-all: all-am
-
-.SUFFIXES:
-.SUFFIXES: .c .lo .o .obj
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
-	        && { if test -f $@; then exit 0; else break; fi; }; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign example/Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign example/Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
-	esac;
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-
-$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(am__aclocal_m4_deps):
-
-clean-noinstPROGRAMS:
-	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
-
-direct_tcpip$(EXEEXT): $(direct_tcpip_OBJECTS) $(direct_tcpip_DEPENDENCIES) $(EXTRA_direct_tcpip_DEPENDENCIES) 
-	@rm -f direct_tcpip$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(direct_tcpip_OBJECTS) $(direct_tcpip_LDADD) $(LIBS)
-
-scp$(EXEEXT): $(scp_OBJECTS) $(scp_DEPENDENCIES) $(EXTRA_scp_DEPENDENCIES) 
-	@rm -f scp$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(scp_OBJECTS) $(scp_LDADD) $(LIBS)
-
-scp_nonblock$(EXEEXT): $(scp_nonblock_OBJECTS) $(scp_nonblock_DEPENDENCIES) $(EXTRA_scp_nonblock_DEPENDENCIES) 
-	@rm -f scp_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(scp_nonblock_OBJECTS) $(scp_nonblock_LDADD) $(LIBS)
-
-scp_write$(EXEEXT): $(scp_write_OBJECTS) $(scp_write_DEPENDENCIES) $(EXTRA_scp_write_DEPENDENCIES) 
-	@rm -f scp_write$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(scp_write_OBJECTS) $(scp_write_LDADD) $(LIBS)
-
-scp_write_nonblock$(EXEEXT): $(scp_write_nonblock_OBJECTS) $(scp_write_nonblock_DEPENDENCIES) $(EXTRA_scp_write_nonblock_DEPENDENCIES) 
-	@rm -f scp_write_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(scp_write_nonblock_OBJECTS) $(scp_write_nonblock_LDADD) $(LIBS)
-
-sftp$(EXEEXT): $(sftp_OBJECTS) $(sftp_DEPENDENCIES) $(EXTRA_sftp_DEPENDENCIES) 
-	@rm -f sftp$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_OBJECTS) $(sftp_LDADD) $(LIBS)
-
-sftp_RW_nonblock$(EXEEXT): $(sftp_RW_nonblock_OBJECTS) $(sftp_RW_nonblock_DEPENDENCIES) $(EXTRA_sftp_RW_nonblock_DEPENDENCIES) 
-	@rm -f sftp_RW_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_RW_nonblock_OBJECTS) $(sftp_RW_nonblock_LDADD) $(LIBS)
-
-sftp_append$(EXEEXT): $(sftp_append_OBJECTS) $(sftp_append_DEPENDENCIES) $(EXTRA_sftp_append_DEPENDENCIES) 
-	@rm -f sftp_append$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_append_OBJECTS) $(sftp_append_LDADD) $(LIBS)
-
-sftp_mkdir$(EXEEXT): $(sftp_mkdir_OBJECTS) $(sftp_mkdir_DEPENDENCIES) $(EXTRA_sftp_mkdir_DEPENDENCIES) 
-	@rm -f sftp_mkdir$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_mkdir_OBJECTS) $(sftp_mkdir_LDADD) $(LIBS)
-
-sftp_mkdir_nonblock$(EXEEXT): $(sftp_mkdir_nonblock_OBJECTS) $(sftp_mkdir_nonblock_DEPENDENCIES) $(EXTRA_sftp_mkdir_nonblock_DEPENDENCIES) 
-	@rm -f sftp_mkdir_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_mkdir_nonblock_OBJECTS) $(sftp_mkdir_nonblock_LDADD) $(LIBS)
-
-sftp_nonblock$(EXEEXT): $(sftp_nonblock_OBJECTS) $(sftp_nonblock_DEPENDENCIES) $(EXTRA_sftp_nonblock_DEPENDENCIES) 
-	@rm -f sftp_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_nonblock_OBJECTS) $(sftp_nonblock_LDADD) $(LIBS)
-
-sftp_write$(EXEEXT): $(sftp_write_OBJECTS) $(sftp_write_DEPENDENCIES) $(EXTRA_sftp_write_DEPENDENCIES) 
-	@rm -f sftp_write$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_write_OBJECTS) $(sftp_write_LDADD) $(LIBS)
-
-sftp_write_nonblock$(EXEEXT): $(sftp_write_nonblock_OBJECTS) $(sftp_write_nonblock_DEPENDENCIES) $(EXTRA_sftp_write_nonblock_DEPENDENCIES) 
-	@rm -f sftp_write_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_write_nonblock_OBJECTS) $(sftp_write_nonblock_LDADD) $(LIBS)
-
-sftp_write_sliding$(EXEEXT): $(sftp_write_sliding_OBJECTS) $(sftp_write_sliding_DEPENDENCIES) $(EXTRA_sftp_write_sliding_DEPENDENCIES) 
-	@rm -f sftp_write_sliding$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftp_write_sliding_OBJECTS) $(sftp_write_sliding_LDADD) $(LIBS)
-
-sftpdir$(EXEEXT): $(sftpdir_OBJECTS) $(sftpdir_DEPENDENCIES) $(EXTRA_sftpdir_DEPENDENCIES) 
-	@rm -f sftpdir$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftpdir_OBJECTS) $(sftpdir_LDADD) $(LIBS)
-
-sftpdir_nonblock$(EXEEXT): $(sftpdir_nonblock_OBJECTS) $(sftpdir_nonblock_DEPENDENCIES) $(EXTRA_sftpdir_nonblock_DEPENDENCIES) 
-	@rm -f sftpdir_nonblock$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(sftpdir_nonblock_OBJECTS) $(sftpdir_nonblock_LDADD) $(LIBS)
-
-ssh2$(EXEEXT): $(ssh2_OBJECTS) $(ssh2_DEPENDENCIES) $(EXTRA_ssh2_DEPENDENCIES) 
-	@rm -f ssh2$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_OBJECTS) $(ssh2_LDADD) $(LIBS)
-
-ssh2_agent$(EXEEXT): $(ssh2_agent_OBJECTS) $(ssh2_agent_DEPENDENCIES) $(EXTRA_ssh2_agent_DEPENDENCIES) 
-	@rm -f ssh2_agent$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_agent_OBJECTS) $(ssh2_agent_LDADD) $(LIBS)
-
-ssh2_agent_forwarding$(EXEEXT): $(ssh2_agent_forwarding_OBJECTS) $(ssh2_agent_forwarding_DEPENDENCIES) $(EXTRA_ssh2_agent_forwarding_DEPENDENCIES) 
-	@rm -f ssh2_agent_forwarding$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_agent_forwarding_OBJECTS) $(ssh2_agent_forwarding_LDADD) $(LIBS)
-
-ssh2_echo$(EXEEXT): $(ssh2_echo_OBJECTS) $(ssh2_echo_DEPENDENCIES) $(EXTRA_ssh2_echo_DEPENDENCIES) 
-	@rm -f ssh2_echo$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_echo_OBJECTS) $(ssh2_echo_LDADD) $(LIBS)
-
-ssh2_exec$(EXEEXT): $(ssh2_exec_OBJECTS) $(ssh2_exec_DEPENDENCIES) $(EXTRA_ssh2_exec_DEPENDENCIES) 
-	@rm -f ssh2_exec$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_exec_OBJECTS) $(ssh2_exec_LDADD) $(LIBS)
-
-subsystem_netconf$(EXEEXT): $(subsystem_netconf_OBJECTS) $(subsystem_netconf_DEPENDENCIES) $(EXTRA_subsystem_netconf_DEPENDENCIES) 
-	@rm -f subsystem_netconf$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(subsystem_netconf_OBJECTS) $(subsystem_netconf_LDADD) $(LIBS)
-
-tcpip-forward$(EXEEXT): $(tcpip_forward_OBJECTS) $(tcpip_forward_DEPENDENCIES) $(EXTRA_tcpip_forward_DEPENDENCIES) 
-	@rm -f tcpip-forward$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(tcpip_forward_OBJECTS) $(tcpip_forward_LDADD) $(LIBS)
-
-x11$(EXEEXT): $(x11_OBJECTS) $(x11_DEPENDENCIES) $(EXTRA_x11_DEPENDENCIES) 
-	@rm -f x11$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(x11_OBJECTS) $(x11_LDADD) $(LIBS)
-
-mostlyclean-compile:
-	-rm -f *.$(OBJEXT)
-
-distclean-compile:
-	-rm -f *.tab.c
-
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/direct_tcpip.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scp.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scp_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scp_write.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scp_write_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_RW_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_append.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_mkdir.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_mkdir_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_write.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_write_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp_write_sliding.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftpdir.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftpdir_nonblock.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2_agent.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2_agent_forwarding.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2_echo.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2_exec.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/subsystem_netconf.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tcpip-forward.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/x11.Po@am__quote@ # am--include-marker
-
-$(am__depfiles_remade):
-	@$(MKDIR_P) $(@D)
-	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
-
-am--depfiles: $(am__depfiles_remade)
-
-.c.o:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
-
-.c.obj:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
-
-.c.lo:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-
-ID: $(am__tagged_files)
-	$(am__define_uniq_tagged_files); mkid -fID $$unique
-tags: tags-am
-TAGS: tags
-
-tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	set x; \
-	here=`pwd`; \
-	$(am__define_uniq_tagged_files); \
-	shift; \
-	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
-	  test -n "$$unique" || unique=$$empty_fix; \
-	  if test $$# -gt 0; then \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      "$$@" $$unique; \
-	  else \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      $$unique; \
-	  fi; \
-	fi
-ctags: ctags-am
-
-CTAGS: ctags
-ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	$(am__define_uniq_tagged_files); \
-	test -z "$(CTAGS_ARGS)$$unique" \
-	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
-	     $$unique
-
-GTAGS:
-	here=`$(am__cd) $(top_builddir) && pwd` \
-	  && $(am__cd) $(top_srcdir) \
-	  && gtags -i $(GTAGS_ARGS) "$$here"
-cscopelist: cscopelist-am
-
-cscopelist-am: $(am__tagged_files)
-	list='$(am__tagged_files)'; \
-	case "$(srcdir)" in \
-	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
-	  *) sdir=$(subdir)/$(srcdir) ;; \
-	esac; \
-	for i in $$list; do \
-	  if test -f "$$i"; then \
-	    echo "$(subdir)/$$i"; \
-	  else \
-	    echo "$$sdir/$$i"; \
-	  fi; \
-	done >> $(top_builddir)/cscope.files
-
-distclean-tags:
-	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-distdir: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-check-am: all-am
-check: check-am
-all-am: Makefile $(PROGRAMS)
-installdirs:
-install: install-am
-install-exec: install-exec-am
-install-data: install-data-am
-uninstall: uninstall-am
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-am
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-clean: clean-am
-
-clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
-	mostlyclean-am
-
-distclean: distclean-am
-		-rm -f ./$(DEPDIR)/direct_tcpip.Po
-	-rm -f ./$(DEPDIR)/scp.Po
-	-rm -f ./$(DEPDIR)/scp_nonblock.Po
-	-rm -f ./$(DEPDIR)/scp_write.Po
-	-rm -f ./$(DEPDIR)/scp_write_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp.Po
-	-rm -f ./$(DEPDIR)/sftp_RW_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_append.Po
-	-rm -f ./$(DEPDIR)/sftp_mkdir.Po
-	-rm -f ./$(DEPDIR)/sftp_mkdir_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_write.Po
-	-rm -f ./$(DEPDIR)/sftp_write_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_write_sliding.Po
-	-rm -f ./$(DEPDIR)/sftpdir.Po
-	-rm -f ./$(DEPDIR)/sftpdir_nonblock.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
-	-rm -f ./$(DEPDIR)/ssh2_agent.Po
-	-rm -f ./$(DEPDIR)/ssh2_agent_forwarding.Po
-	-rm -f ./$(DEPDIR)/ssh2_echo.Po
-	-rm -f ./$(DEPDIR)/ssh2_exec.Po
-	-rm -f ./$(DEPDIR)/subsystem_netconf.Po
-	-rm -f ./$(DEPDIR)/tcpip-forward.Po
-	-rm -f ./$(DEPDIR)/x11.Po
-	-rm -f Makefile
-distclean-am: clean-am distclean-compile distclean-generic \
-	distclean-tags
-
-dvi: dvi-am
-
-dvi-am:
-
-html: html-am
-
-html-am:
-
-info: info-am
-
-info-am:
-
-install-data-am:
-
-install-dvi: install-dvi-am
-
-install-dvi-am:
-
-install-exec-am:
-
-install-html: install-html-am
-
-install-html-am:
-
-install-info: install-info-am
-
-install-info-am:
-
-install-man:
-
-install-pdf: install-pdf-am
-
-install-pdf-am:
-
-install-ps: install-ps-am
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-am
-		-rm -f ./$(DEPDIR)/direct_tcpip.Po
-	-rm -f ./$(DEPDIR)/scp.Po
-	-rm -f ./$(DEPDIR)/scp_nonblock.Po
-	-rm -f ./$(DEPDIR)/scp_write.Po
-	-rm -f ./$(DEPDIR)/scp_write_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp.Po
-	-rm -f ./$(DEPDIR)/sftp_RW_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_append.Po
-	-rm -f ./$(DEPDIR)/sftp_mkdir.Po
-	-rm -f ./$(DEPDIR)/sftp_mkdir_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_write.Po
-	-rm -f ./$(DEPDIR)/sftp_write_nonblock.Po
-	-rm -f ./$(DEPDIR)/sftp_write_sliding.Po
-	-rm -f ./$(DEPDIR)/sftpdir.Po
-	-rm -f ./$(DEPDIR)/sftpdir_nonblock.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
-	-rm -f ./$(DEPDIR)/ssh2_agent.Po
-	-rm -f ./$(DEPDIR)/ssh2_agent_forwarding.Po
-	-rm -f ./$(DEPDIR)/ssh2_echo.Po
-	-rm -f ./$(DEPDIR)/ssh2_exec.Po
-	-rm -f ./$(DEPDIR)/subsystem_netconf.Po
-	-rm -f ./$(DEPDIR)/tcpip-forward.Po
-	-rm -f ./$(DEPDIR)/x11.Po
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-am
-
-mostlyclean-am: mostlyclean-compile mostlyclean-generic \
-	mostlyclean-libtool
-
-pdf: pdf-am
-
-pdf-am:
-
-ps: ps-am
-
-ps-am:
-
-uninstall-am:
-
-.MAKE: install-am install-strip
-
-.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
-	clean-generic clean-libtool clean-noinstPROGRAMS cscopelist-am \
-	ctags ctags-am distclean distclean-compile distclean-generic \
-	distclean-libtool distclean-tags distdir dvi dvi-am html \
-	html-am info info-am install install-am install-data \
-	install-data-am install-dvi install-dvi-am install-exec \
-	install-exec-am install-html install-html-am install-info \
-	install-info-am install-man install-pdf install-pdf-am \
-	install-ps install-ps-am install-strip installcheck \
-	installcheck-am installdirs maintainer-clean \
-	maintainer-clean-generic mostlyclean mostlyclean-compile \
-	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
-	tags tags-am uninstall uninstall-am
-
-.PRECIOUS: Makefile
-
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/libssh2/libssh2/example/direct_tcpip.c b/libssh2/libssh2/example/direct_tcpip.c
deleted file mode 100644
index 4e1d90f4..00000000
--- a/libssh2/libssh2/example/direct_tcpip.c
+++ /dev/null
@@ -1,343 +0,0 @@
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#endif
-
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-
-#ifndef INADDR_NONE
-#define INADDR_NONE (in_addr_t)-1
-#endif
-
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
-
-const char *server_ip = "127.0.0.1";
-
-const char *local_listenip = "127.0.0.1";
-unsigned int local_listenport = 2222;
-
-const char *remote_desthost = "localhost"; /* resolved by the server */
-unsigned int remote_destport = 22;
-
-enum {
-    AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
-};
-
-int main(int argc, char *argv[])
-{
-    int rc, i, auth = AUTH_NONE;
-    struct sockaddr_in sin;
-    socklen_t sinlen;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel = NULL;
-    const char *shost;
-    unsigned int sport;
-    fd_set fds;
-    struct timeval tv;
-    ssize_t len, wr;
-    char buf[16384];
-
-#ifdef WIN32
-    char sockopt;
-    SOCKET sock = INVALID_SOCKET;
-    SOCKET listensock = INVALID_SOCKET, forwardsock = INVALID_SOCKET;
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#else
-    int sockopt, sock = -1;
-    int listensock = -1, forwardsock = -1;
-#endif
-
-    if(argc > 1)
-        server_ip = argv[1];
-    if(argc > 2)
-        username = argv[2];
-    if(argc > 3)
-        password = argv[3];
-    if(argc > 4)
-        local_listenip = argv[4];
-    if(argc > 5)
-        local_listenport = atoi(argv[5]);
-    if(argc > 6)
-        remote_desthost = argv[6];
-    if(argc > 7)
-        remote_destport = atoi(argv[7]);
-
-    rc = libssh2_init(0);
-    if(rc) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Connect to SSH server */
-    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
-    }
-#endif
-
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = inet_addr(server_ip);
-    if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        return -1;
-    }
-    sin.sin_port = htons(22);
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
-    }
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++)
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 8) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[8], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[8], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
-
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    listensock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(listensock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open listen socket!\n");
-        return -1;
-    }
-#else
-    if(listensock == -1) {
-        perror("socket");
-        return -1;
-    }
-#endif
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(local_listenport);
-    sin.sin_addr.s_addr = inet_addr(local_listenip);
-    if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        goto shutdown;
-    }
-    sockopt = 1;
-    setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &sockopt,
-               sizeof(sockopt));
-    sinlen = sizeof(sin);
-    if(-1 == bind(listensock, (struct sockaddr *)&sin, sinlen)) {
-        perror("bind");
-        goto shutdown;
-    }
-    if(-1 == listen(listensock, 2)) {
-        perror("listen");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "Waiting for TCP connection on %s:%d...\n",
-        inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
-
-    forwardsock = accept(listensock, (struct sockaddr *)&sin, &sinlen);
-#ifdef WIN32
-    if(forwardsock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to accept forward socket!\n");
-        goto shutdown;
-    }
-#else
-    if(forwardsock == -1) {
-        perror("accept");
-        goto shutdown;
-    }
-#endif
-
-    shost = inet_ntoa(sin.sin_addr);
-    sport = ntohs(sin.sin_port);
-
-    fprintf(stderr, "Forwarding connection from %s:%d here to remote %s:%d\n",
-        shost, sport, remote_desthost, remote_destport);
-
-    channel = libssh2_channel_direct_tcpip_ex(session, remote_desthost,
-        remote_destport, shost, sport);
-    if(!channel) {
-        fprintf(stderr, "Could not open the direct-tcpip channel!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
-        goto shutdown;
-    }
-
-    /* Must use non-blocking IO hereafter due to the current libssh2 API */
-    libssh2_session_set_blocking(session, 0);
-
-    while(1) {
-        FD_ZERO(&fds);
-        FD_SET(forwardsock, &fds);
-        tv.tv_sec = 0;
-        tv.tv_usec = 100000;
-        rc = select(forwardsock + 1, &fds, NULL, NULL, &tv);
-        if(-1 == rc) {
-            perror("select");
-            goto shutdown;
-        }
-        if(rc && FD_ISSET(forwardsock, &fds)) {
-            len = recv(forwardsock, buf, sizeof(buf), 0);
-            if(len < 0) {
-                perror("read");
-                goto shutdown;
-            }
-            else if(0 == len) {
-                fprintf(stderr, "The client at %s:%d disconnected!\n", shost,
-                    sport);
-                goto shutdown;
-            }
-            wr = 0;
-            while(wr < len) {
-                i = libssh2_channel_write(channel, buf + wr, len - wr);
-                if(LIBSSH2_ERROR_EAGAIN == i) {
-                    continue;
-                }
-                if(i < 0) {
-                    fprintf(stderr, "libssh2_channel_write: %d\n", i);
-                    goto shutdown;
-                }
-                wr += i;
-            }
-        }
-        while(1) {
-            len = libssh2_channel_read(channel, buf, sizeof(buf));
-            if(LIBSSH2_ERROR_EAGAIN == len)
-                break;
-            else if(len < 0) {
-                fprintf(stderr, "libssh2_channel_read: %d", (int)len);
-                goto shutdown;
-            }
-            wr = 0;
-            while(wr < len) {
-                i = send(forwardsock, buf + wr, len - wr, 0);
-                if(i <= 0) {
-                    perror("write");
-                    goto shutdown;
-                }
-                wr += i;
-            }
-            if(libssh2_channel_eof(channel)) {
-                fprintf(stderr, "The server at %s:%d disconnected!\n",
-                    remote_desthost, remote_destport);
-                goto shutdown;
-            }
-        }
-    }
-
-shutdown:
-#ifdef WIN32
-    closesocket(forwardsock);
-    closesocket(listensock);
-#else
-    close(forwardsock);
-    close(listensock);
-#endif
-    if(channel)
-        libssh2_channel_free(channel);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/libssh2_config.h.in b/libssh2/libssh2/example/libssh2_config.h.in
deleted file mode 100644
index 307c6255..00000000
--- a/libssh2/libssh2/example/libssh2_config.h.in
+++ /dev/null
@@ -1,264 +0,0 @@
-/* src/libssh2_config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define if building universal (internal helper macro) */
-#undef AC_APPLE_UNIVERSAL_BUILD
-
-/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
-   systems. This function is required for `alloca.c' support on those systems.
-   */
-#undef CRAY_STACKSEG_END
-
-/* Define to 1 if using `alloca.c'. */
-#undef C_ALLOCA
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#undef HAVE_ALLOCA
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
-   */
-#undef HAVE_ALLOCA_H
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#undef HAVE_ARPA_INET_H
-
-/* Define to 1 if you have the declaration of `SecureZeroMemory', and to 0 if
-   you don't. */
-#undef HAVE_DECL_SECUREZEROMEMORY
-
-/* disabled non-blocking sockets */
-#undef HAVE_DISABLED_NONBLOCKING
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#undef HAVE_ERRNO_H
-
-/* Define to 1 if you have the `EVP_aes_128_ctr' function. */
-#undef HAVE_EVP_AES_128_CTR
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#undef HAVE_FCNTL_H
-
-/* use FIONBIO for non-blocking sockets */
-#undef HAVE_FIONBIO
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#undef HAVE_GETTIMEOFDAY
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* use ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET
-
-/* use Ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET_CASE
-
-/* Define if you have the bcrypt library. */
-#undef HAVE_LIBBCRYPT
-
-/* Define if you have the crypt32 library. */
-#undef HAVE_LIBCRYPT32
-
-/* Define if you have the gcrypt library. */
-#undef HAVE_LIBGCRYPT
-
-/* Define if you have the mbedcrypto library. */
-#undef HAVE_LIBMBEDCRYPTO
-
-/* Define if you have the ssl library. */
-#undef HAVE_LIBSSL
-
-/* Define if you have the z library. */
-#undef HAVE_LIBZ
-
-/* Define to 1 if the compiler supports the 'long long' data type. */
-#undef HAVE_LONGLONG
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the `memset_s' function. */
-#undef HAVE_MEMSET_S
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#undef HAVE_NETINET_IN_H
-
-/* Define to 1 if you have the <ntdef.h> header file. */
-#undef HAVE_NTDEF_H
-
-/* Define to 1 if you have the <ntstatus.h> header file. */
-#undef HAVE_NTSTATUS_H
-
-/* use O_NONBLOCK for non-blocking sockets */
-#undef HAVE_O_NONBLOCK
-
-/* Define to 1 if you have the `poll' function. */
-#undef HAVE_POLL
-
-/* Define to 1 if you have the select function. */
-#undef HAVE_SELECT
-
-/* use SO_NONBLOCK for non-blocking sockets */
-#undef HAVE_SO_NONBLOCK
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the `strtoll' function. */
-#undef HAVE_STRTOLL
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#undef HAVE_SYS_IOCTL_H
-
-/* Define to 1 if you have the <sys/select.h> header file. */
-#undef HAVE_SYS_SELECT_H
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#undef HAVE_SYS_SOCKET_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#undef HAVE_SYS_TIME_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <sys/uio.h> header file. */
-#undef HAVE_SYS_UIO_H
-
-/* Define to 1 if you have the <sys/un.h> header file. */
-#undef HAVE_SYS_UN_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Define to 1 if you have the <windows.h> header file. */
-#undef HAVE_WINDOWS_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to 1 if you have the <ws2tcpip.h> header file. */
-#undef HAVE_WS2TCPIP_H
-
-/* to make a symbol visible */
-#undef LIBSSH2_API
-
-/* Enable clearing of memory before being freed */
-#undef LIBSSH2_CLEAR_MEMORY
-
-/* Enable "none" cipher -- NOT RECOMMENDED */
-#undef LIBSSH2_CRYPT_NONE
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#undef LIBSSH2_DH_GEX_NEW
-
-/* Compile in zlib support */
-#undef LIBSSH2_HAVE_ZLIB
-
-/* Use libgcrypt */
-#undef LIBSSH2_LIBGCRYPT
-
-/* Enable "none" MAC -- NOT RECOMMENDED */
-#undef LIBSSH2_MAC_NONE
-
-/* Use mbedtls */
-#undef LIBSSH2_MBEDTLS
-
-/* Use openssl */
-#undef LIBSSH2_OPENSSL
-
-/* Use wincng */
-#undef LIBSSH2_WINCNG
-
-/* Define to the sub-directory where libtool stores uninstalled libraries. */
-#undef LT_OBJDIR
-
-/* Define to 1 if _REENTRANT preprocessor symbol must be defined. */
-#undef NEED_REENTRANT
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at runtime.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown */
-#undef STACK_DIRECTION
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* Version number of package */
-#undef VERSION
-
-/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
-   significant byte first (like Motorola and SPARC, unlike Intel). */
-#if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
-#else
-# ifndef WORDS_BIGENDIAN
-#  undef WORDS_BIGENDIAN
-# endif
-#endif
-
-/* Enable large inode numbers on Mac OS X 10.5.  */
-#ifndef _DARWIN_USE_64_BIT_INODE
-# define _DARWIN_USE_64_BIT_INODE 1
-#endif
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
diff --git a/libssh2/libssh2/example/libssh2_config_cmake.h.in b/libssh2/libssh2/example/libssh2_config_cmake.h.in
deleted file mode 100644
index 12264f7f..00000000
--- a/libssh2/libssh2/example/libssh2_config_cmake.h.in
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#cmakedefine HAVE_UNISTD_H
-#cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_STDLIB_H
-#cmakedefine HAVE_SYS_SELECT_H
-#cmakedefine HAVE_SYS_SOCKET_H
-#cmakedefine HAVE_SYS_TIME_H
-#cmakedefine HAVE_ARPA_INET_H
-#cmakedefine HAVE_NETINET_IN_H
-#cmakedefine HAVE_WINSOCK2_H
-
-/* Functions */
-#cmakedefine HAVE_STRCASECMP
-#cmakedefine HAVE__STRICMP
-#cmakedefine HAVE_SNPRINTF
-#cmakedefine HAVE__SNPRINTF
-
-/* Workaround for platforms without POSIX strcasecmp (e.g. Windows) */
-#ifndef HAVE_STRCASECMP
-# ifdef HAVE__STRICMP
-# define strcasecmp _stricmp
-# define HAVE_STRCASECMP
-# endif
-#endif
-
-/* Symbols */
-#cmakedefine HAVE___FUNC__
-#cmakedefine HAVE___FUNCTION__
-
-/* Workaround for platforms without C90 __func__ */
-#ifndef HAVE___FUNC__
-# ifdef HAVE___FUNCTION__
-# define __func__ __FUNCTION__
-# define HAVE___FUNC__
-# endif
-#endif
diff --git a/libssh2/libssh2/example/scp.c b/libssh2/libssh2/example/scp.c
deleted file mode 100644
index 9ad1e7d4..00000000
--- a/libssh2/libssh2/example/scp.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Sample showing how to do a simple SCP transfer.
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *scppath = "/tmp/TEST";
-    libssh2_struct_stat fileinfo;
-    int rc;
-    libssh2_struct_stat_size got = 0;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        scppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-#define HOME_DIR "/home/username/"
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME_DIR ".ssh/id_rsa.pub",
-                                               HOME_DIR ".ssh/id_rsa",
-                                               password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    /* Request a file via SCP */
-    channel = libssh2_scp_recv2(session, scppath, &fileinfo);
-
-    if(!channel) {
-        fprintf(stderr, "Unable to open a session: %d\n",
-                libssh2_session_last_errno(session));
-        goto shutdown;
-    }
-
-
-    while(got < fileinfo.st_size) {
-        char mem[1024];
-        int amount = sizeof(mem);
-
-        if((fileinfo.st_size -got) < amount) {
-            amount = (int)(fileinfo.st_size -got);
-        }
-
-        rc = libssh2_channel_read(channel, mem, amount);
-        if(rc > 0) {
-            write(1, mem, rc);
-        }
-        else if(rc < 0) {
-            fprintf(stderr, "libssh2_channel_read() failed: %d\n", rc);
-            break;
-        }
-        got += rc;
-    }
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
- shutdown:
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/scp_nonblock.c b/libssh2/libssh2/example/scp_nonblock.c
deleted file mode 100644
index bc5bdb3d..00000000
--- a/libssh2/libssh2/example/scp_nonblock.c
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Sample showing how to do SCP transfers in a non-blocking manner.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "scp_nonblock 192.168.0.1 user password /tmp/secrets"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef HAVE_GETTIMEOFDAY
-/* diff in ms */
-static long tvdiff(struct timeval newer, struct timeval older)
-{
-  return (newer.tv_sec-older.tv_sec)*1000+
-      (newer.tv_usec-older.tv_usec)/1000;
-}
-#endif
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *scppath = "/tmp/TEST";
-    libssh2_struct_stat fileinfo;
-#ifdef HAVE_GETTIMEOFDAY
-    struct timeval start;
-    struct timeval end;
-    long time_ms;
-#endif
-    int rc;
-    int spin = 0;
-    libssh2_struct_stat_size got = 0;
-    libssh2_struct_stat_size total = 0;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        scppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin), sizeof(struct sockaddr_in))) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-#ifdef HAVE_GETTIMEOFDAY
-    gettimeofday(&start, NULL);
-#endif
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    while((rc = libssh2_session_handshake(session, sock)) ==
-          LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-        * is check the hostkey's fingerprint against our known hosts Your app
-        * may have it hard coded, may go to a file, may present it to the
-        * user, that's your call
-        */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        "/home/username/"
-                                                        ".ssh/id_rsa.pub",
-                                                        "/home/username/"
-                                                        ".ssh/id_rsa",
-                                                        password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-#if 0
-    libssh2_trace(session, LIBSSH2_TRACE_CONN);
-#endif
-
-    /* Request a file via SCP */
-    fprintf(stderr, "libssh2_scp_recv2()!\n");
-    do {
-        channel = libssh2_scp_recv2(session, scppath, &fileinfo);
-
-        if(!channel) {
-            if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                char *err_msg;
-
-                libssh2_session_last_error(session, &err_msg, NULL, 0);
-                fprintf(stderr, "%s\n", err_msg);
-                goto shutdown;
-            }
-            else {
-                fprintf(stderr, "libssh2_scp_recv() spin\n");
-                waitsocket(sock, session);
-            }
-        }
-    } while(!channel);
-    fprintf(stderr, "libssh2_scp_recv() is done, now receive data!\n");
-
-    while(got < fileinfo.st_size) {
-        char mem[1024*24];
-        int rc;
-
-        do {
-            int amount = sizeof(mem);
-
-            if((fileinfo.st_size -got) < amount) {
-                amount = (int)(fileinfo.st_size - got);
-            }
-
-            /* loop until we block */
-            rc = libssh2_channel_read(channel, mem, amount);
-            if(rc > 0) {
-                write(1, mem, rc);
-                got += rc;
-                total += rc;
-            }
-        } while(rc > 0);
-
-        if((rc == LIBSSH2_ERROR_EAGAIN) && (got < fileinfo.st_size)) {
-            /* this is due to blocking that would occur otherwise
-            so we loop on this condition */
-
-            spin++;
-            waitsocket(sock, session); /* now we wait */
-            continue;
-        }
-        break;
-    }
-
-#ifdef HAVE_GETTIMEOFDAY
-    gettimeofday(&end, NULL);
-
-    time_ms = tvdiff(end, start);
-    fprintf(stderr, "Got %ld bytes in %ld ms = %.1f bytes/sec spin: %d\n",
-            (long)total,
-            time_ms, total/(time_ms/1000.0), spin);
-#else
-    fprintf(stderr, "Got %ld bytes spin: %d\n", (long)total, spin);
-#endif
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
-shutdown:
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/scp_write.c b/libssh2/libssh2/example/scp_write.c
deleted file mode 100644
index 030232ec..00000000
--- a/libssh2/libssh2/example/scp_write.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Sample showing how to do an SCP upload.
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session = NULL;
-    LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "scp_write.c";
-    const char *scppath = "/tmp/TEST";
-    FILE *local;
-    int rc;
-    char mem[1024];
-    size_t nread;
-    char *ptr;
-    struct stat fileinfo;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        scppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
-    }
-
-    stat(loclfile, &fileinfo);
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(-1 == sock) {
-        fprintf(stderr, "failed to create socket!\n");
-        return -1;
-    }
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-#define HOME "/home/username/"
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME ".ssh/id_rsa.pub",
-                                               HOME ".ssh/id_rsa",
-                                               password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    /* Send a file via scp. The mode parameter must only have permissions! */
-    channel = libssh2_scp_send(session, scppath, fileinfo.st_mode & 0777,
-                               (unsigned long)fileinfo.st_size);
-
-    if(!channel) {
-        char *errmsg;
-        int errlen;
-        int err = libssh2_session_last_error(session, &errmsg, &errlen, 0);
-        fprintf(stderr, "Unable to open a session: (%d) %s\n", err, errmsg);
-        goto shutdown;
-    }
-
-    fprintf(stderr, "SCP session waiting to send file\n");
-    do {
-        nread = fread(mem, 1, sizeof(mem), local);
-        if(nread <= 0) {
-            /* end of file */
-            break;
-        }
-        ptr = mem;
-
-        do {
-            /* write the same data over and over, until error or completion */
-            rc = libssh2_channel_write(channel, ptr, nread);
-            if(rc < 0) {
-                fprintf(stderr, "ERROR %d\n", rc);
-                break;
-            }
-            else {
-                /* rc indicates how many bytes were written this time */
-                ptr += rc;
-                nread -= rc;
-            }
-        } while(nread);
-
-    } while(1);
-
-    fprintf(stderr, "Sending EOF\n");
-    libssh2_channel_send_eof(channel);
-
-    fprintf(stderr, "Waiting for EOF\n");
-    libssh2_channel_wait_eof(channel);
-
-    fprintf(stderr, "Waiting for channel to close\n");
-    libssh2_channel_wait_closed(channel);
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
- shutdown:
-
-    if(session) {
-        libssh2_session_disconnect(session, "Normal Shutdown");
-        libssh2_session_free(session);
-    }
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    if(local)
-        fclose(local);
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/scp_write_nonblock.c b/libssh2/libssh2/example/scp_write_nonblock.c
deleted file mode 100644
index 9226322e..00000000
--- a/libssh2/libssh2/example/scp_write_nonblock.c
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Sample showing how to do an SCP non-blocking upload transfer.
- */
-
-#include "libssh2_config.h"
-
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <time.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session = NULL;
-    LIBSSH2_CHANNEL *channel;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "scp_write.c";
-    const char *scppath = "/tmp/TEST";
-    FILE *local;
-    int rc;
-    char mem[1024*100];
-    size_t nread;
-    char *ptr;
-    struct stat fileinfo;
-    time_t start;
-    long total = 0;
-    int duration;
-    size_t prev;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        scppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't local file %s\n", loclfile);
-        return -1;
-    }
-
-    stat(loclfile, &fileinfo);
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    while((rc = libssh2_session_handshake(session, sock))
-          == LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-#define HOME "/home/username/"
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        HOME ".ssh/id_rsa.pub",
-                                                        HOME ".ssh/id_rsa",
-                                                        password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    /* Send a file via scp. The mode parameter must only have permissions! */
-    do {
-        channel = libssh2_scp_send(session, scppath, fileinfo.st_mode & 0777,
-                                   (unsigned long)fileinfo.st_size);
-
-        if((!channel) && (libssh2_session_last_errno(session) !=
-                          LIBSSH2_ERROR_EAGAIN)) {
-            char *err_msg;
-
-            libssh2_session_last_error(session, &err_msg, NULL, 0);
-            fprintf(stderr, "%s\n", err_msg);
-            goto shutdown;
-        }
-    } while(!channel);
-
-    fprintf(stderr, "SCP session waiting to send file\n");
-    start = time(NULL);
-    do {
-        nread = fread(mem, 1, sizeof(mem), local);
-        if(nread <= 0) {
-            /* end of file */
-            break;
-        }
-        ptr = mem;
-
-        total += nread;
-
-        prev = 0;
-        do {
-            while((rc = libssh2_channel_write(channel, ptr, nread)) ==
-                  LIBSSH2_ERROR_EAGAIN) {
-                waitsocket(sock, session);
-                prev = 0;
-            }
-            if(rc < 0) {
-                fprintf(stderr, "ERROR %d total %ld / %d prev %d\n", rc,
-                        total, (int)nread, (int)prev);
-                break;
-            }
-            else {
-                prev = nread;
-
-                /* rc indicates how many bytes were written this time */
-                nread -= rc;
-                ptr += rc;
-            }
-        } while(nread);
-    } while(!nread); /* only continue if nread was drained */
-
-    duration = (int)(time(NULL)-start);
-
-    fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
-
-    fprintf(stderr, "Sending EOF\n");
-    while(libssh2_channel_send_eof(channel) == LIBSSH2_ERROR_EAGAIN);
-
-    fprintf(stderr, "Waiting for EOF\n");
-    while(libssh2_channel_wait_eof(channel) == LIBSSH2_ERROR_EAGAIN);
-
-    fprintf(stderr, "Waiting for channel to close\n");
-    while(libssh2_channel_wait_closed(channel) == LIBSSH2_ERROR_EAGAIN);
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
- shutdown:
-
-    while(libssh2_session_disconnect(session,
-                                     "Normal Shutdown,") ==
-          LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp.c b/libssh2/libssh2/example/sftp.c
deleted file mode 100644
index 8f67244a..00000000
--- a/libssh2/libssh2/example/sftp.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Sample showing how to do SFTP transfers.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password /tmp/secrets -p|-i|-k"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
-const char *sftppath = "/tmp/TEST";
-
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruction, int instruction_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    int i;
-    size_t n;
-    char buf[1024];
-    (void)abstract;
-
-    fprintf(stderr, "Performing keyboard-interactive authentication.\n");
-
-    fprintf(stderr, "Authentication name: '");
-    fwrite(name, 1, name_len, stderr);
-    fprintf(stderr, "'\n");
-
-    fprintf(stderr, "Authentication instruction: '");
-    fwrite(instruction, 1, instruction_len, stderr);
-    fprintf(stderr, "'\n");
-
-    fprintf(stderr, "Number of prompts: %d\n\n", num_prompts);
-
-    for(i = 0; i < num_prompts; i++) {
-        fprintf(stderr, "Prompt %d from server: '", i);
-        fwrite(prompts[i].text, 1, prompts[i].length, stderr);
-        fprintf(stderr, "'\n");
-
-        fprintf(stderr, "Please type response: ");
-        fgets(buf, sizeof(buf), stdin);
-        n = strlen(buf);
-        while(n > 0 && strchr("\r\n", buf[n - 1]))
-          n--;
-        buf[n] = 0;
-
-        responses[i].text = strdup(buf);
-        responses[i].length = n;
-
-        fprintf(stderr, "Response %d from user is '", i);
-        fwrite(responses[i].text, 1, responses[i].length, stderr);
-        fprintf(stderr, "'\n\n");
-    }
-
-    fprintf(stderr,
-        "Done. Sending keyboard-interactive responses to server now.\n");
-}
-
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 0;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    int rc;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are blocking */
-    libssh2_session_set_blocking(session, 1);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 4. argument we set this option if supported */
-    if(argc > 5) {
-        if((auth_pw & 1) && !strcasecmp(argv[5], "-p")) {
-            auth_pw = 1;
-        }
-        if((auth_pw & 2) && !strcasecmp(argv[5], "-i")) {
-            auth_pw = 2;
-        }
-        if((auth_pw & 4) && !strcasecmp(argv[5], "-k")) {
-            auth_pw = 4;
-        }
-    }
-
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr,
-                "\tAuthentication by keyboard-interactive succeeded.\n");
-        }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-        }
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "libssh2_sftp_open()!\n");
-    /* Request a file via SFTP */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath, LIBSSH2_FXF_READ, 0);
-
-    if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP: %ld\n",
-                libssh2_sftp_last_error(sftp_session));
-        goto shutdown;
-    }
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
-    do {
-        char mem[1024];
-
-        /* loop until we fail */
-        fprintf(stderr, "libssh2_sftp_read()!\n");
-        rc = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
-        if(rc > 0) {
-            write(1, mem, rc);
-        }
-        else {
-            break;
-        }
-    } while(1);
-
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-  shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_RW_nonblock.c b/libssh2/libssh2/example/sftp_RW_nonblock.c
deleted file mode 100644
index 70d87db3..00000000
--- a/libssh2/libssh2/example/sftp_RW_nonblock.c
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
- * Sample showing how to do SFTP transfers in a non-blocking manner.
- *
- * It will first download a given source file, store it locally and then
- * upload the file again to a given destination file.
- *
- * Using the SFTP server running on 127.0.0.1
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#define STORAGE "/tmp/sftp-storage" /* this is the local file name this
-                                       example uses to store the downloaded
-                                       file in */
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/TEST"; /* source path */
-    const char *dest = "/tmp/TEST2";    /* destination path */
-    int rc;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-    FILE *tempstorage;
-    char mem[1000];
-    struct timeval timeout;
-    fd_set fd;
-    fd_set fd2;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * The application is responsible for creating the socket establishing
-     * the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = htonl(0x7F000001);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    libssh2_session_set_blocking(session, 0);
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(argc > 1) {
-        username = argv[1];
-    }
-    if(argc > 2) {
-        password = argv[2];
-    }
-    if(argc > 3) {
-        sftppath = argv[3];
-    }
-    if(argc > 4) {
-        dest = argv[4];
-    }
-
-    tempstorage = fopen(STORAGE, "wb");
-    if(!tempstorage) {
-        fprintf(stderr, "Can't open temp storage file %s\n", STORAGE);
-        goto shutdown;
-    }
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password))
-               == LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        while((rc =
-               libssh2_userauth_publickey_fromfile(session, username,
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa.pub",
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa",
-                                                   password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    do {
-        sftp_session = libssh2_sftp_init(session);
-
-        if(!sftp_session) {
-            if(libssh2_session_last_errno(session) ==
-               LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "non-blocking init\n");
-                waitsocket(sock, session); /* now we wait */
-            }
-            else {
-                fprintf(stderr, "Unable to init SFTP session\n");
-                goto shutdown;
-            }
-        }
-    } while(!sftp_session);
-
-    /* Request a file via SFTP */
-    do {
-        sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
-                                        LIBSSH2_FXF_READ, 0);
-
-        if(!sftp_handle) {
-            if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "Unable to open file with SFTP\n");
-                goto shutdown;
-            }
-            else {
-                fprintf(stderr, "non-blocking open\n");
-                waitsocket(sock, session); /* now we wait */
-            }
-        }
-    } while(!sftp_handle);
-
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
-    do {
-        do {
-            /* read in a loop until we block */
-            rc = libssh2_sftp_read(sftp_handle, mem, sizeof(mem));
-            fprintf(stderr, "libssh2_sftp_read returned %d\n",
-                    rc);
-
-            if(rc > 0) {
-                /* write to stderr */
-                write(2, mem, rc);
-                /* write to temporary storage area */
-                fwrite(mem, rc, 1, tempstorage);
-            }
-        } while(rc > 0);
-
-        if(rc != LIBSSH2_ERROR_EAGAIN) {
-            /* error or end of file */
-            break;
-        }
-
-        timeout.tv_sec = 10;
-        timeout.tv_usec = 0;
-
-        FD_ZERO(&fd);
-        FD_ZERO(&fd2);
-        FD_SET(sock, &fd);
-        FD_SET(sock, &fd2);
-
-        /* wait for readable or writeable */
-        rc = select(sock + 1, &fd, &fd2, NULL, &timeout);
-        if(rc <= 0) {
-            /* negative is error
-               0 is timeout */
-            fprintf(stderr, "SFTP download timed out: %d\n", rc);
-            break;
-        }
-
-    } while(1);
-
-    libssh2_sftp_close(sftp_handle);
-    fclose(tempstorage);
-
-    tempstorage = fopen(STORAGE, "rb");
-    if(!tempstorage) {
-        /* weird, we can't read the file we just wrote to... */
-        fprintf(stderr, "can't open %s for reading\n", STORAGE);
-        goto shutdown;
-    }
-
-    /* we're done downloading, now reverse the process and upload the
-       temporarily stored data to the destination path */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, dest,
-                          LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT,
-                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-    if(sftp_handle) {
-        size_t nread;
-        char *ptr;
-        do {
-            nread = fread(mem, 1, sizeof(mem), tempstorage);
-            if(nread <= 0) {
-                /* end of file */
-                break;
-            }
-            ptr = mem;
-
-            do {
-                /* write data in a loop until we block */
-                rc = libssh2_sftp_write(sftp_handle, ptr,
-                                        nread);
-                ptr += rc;
-                nread -= nread;
-            } while(rc >= 0);
-
-            if(rc != LIBSSH2_ERROR_EAGAIN) {
-                /* error or end of file */
-                break;
-            }
-
-            timeout.tv_sec = 10;
-            timeout.tv_usec = 0;
-
-            FD_ZERO(&fd);
-            FD_ZERO(&fd2);
-            FD_SET(sock, &fd);
-            FD_SET(sock, &fd2);
-
-            /* wait for readable or writeable */
-            rc = select(sock + 1, &fd, &fd2, NULL, &timeout);
-            if(rc <= 0) {
-                /* negative is error
-                   0 is timeout */
-                fprintf(stderr, "SFTP upload timed out: %d\n",
-                        rc);
-                break;
-            }
-        } while(1);
-        fprintf(stderr, "SFTP upload done!\n");
-    }
-    else {
-        fprintf(stderr, "SFTP failed to open destination path: %s\n",
-                dest);
-    }
-
-    libssh2_sftp_shutdown(sftp_session);
-
-  shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    if(tempstorage)
-        fclose(tempstorage);
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_append.c b/libssh2/libssh2/example/sftp_append.c
deleted file mode 100644
index bfea1f72..00000000
--- a/libssh2/libssh2/example/sftp_append.c
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Sample showing how to do SFTP append of a local file onto a remote one.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * sftp_append 192.168.0.1 user password localfile /tmp/remotefile
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write.c";
-    const char *sftppath = "/tmp/TEST";
-    int rc;
-    FILE *local;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-    LIBSSH2_SFTP_ATTRIBUTES attrs;
-    char mem[1024*100];
-    size_t nread;
-    char *ptr;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        sftppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are blocking */
-    libssh2_session_set_blocking(session, 1);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-#define HOME "/home/username/"
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                                               HOME ".ssh/id_rsa.pub",
-                                               HOME ".ssh/id_rsa",
-                                               password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "libssh2_sftp_open() for READ and WRITE!\n");
-    /* Request a file via SFTP */
-
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath,
-                          LIBSSH2_FXF_WRITE|LIBSSH2_FXF_READ,
-                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-    if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
-        goto shutdown;
-    }
-
-    if(libssh2_sftp_fstat_ex(sftp_handle, &attrs, 0) < 0) {
-        fprintf(stderr, "libssh2_sftp_fstat_ex failed\n");
-        goto shutdown;
-    }
-    else
-        libssh2_sftp_seek64(sftp_handle, attrs.filesize);
-    fprintf(stderr, "Did a seek to position %ld\n", (long) attrs.filesize);
-
-    fprintf(stderr, "libssh2_sftp_open() a handle for APPEND\n");
-
-    if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
-        goto shutdown;
-    }
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-    do {
-        nread = fread(mem, 1, sizeof(mem), local);
-        if(nread <= 0) {
-            /* end of file */
-            break;
-        }
-        ptr = mem;
-
-        do {
-            /* write data in a loop until we block */
-            rc = libssh2_sftp_write(sftp_handle, ptr, nread);
-            if(rc < 0)
-                break;
-            ptr += rc;
-            nread -= rc;
-        } while(nread);
-
-    } while(rc > 0);
-
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-shutdown:
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    if(local)
-        fclose(local);
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_mkdir.c b/libssh2/libssh2/example/sftp_mkdir.c
deleted file mode 100644
index 2347abe4..00000000
--- a/libssh2/libssh2/example/sftp_mkdir.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Sample showing how to do SFTP mkdir
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password /tmp/sftp_mkdir"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/sftp_mkdir";
-    int rc;
-    LIBSSH2_SFTP *sftp_session;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                            "/home/username/.ssh/id_rsa.pub",
-                            "/home/username/.ssh/id_rsa",
-                            password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    /* Since we have not set non-blocking, tell libssh2 we are blocking */
-    libssh2_session_set_blocking(session, 1);
-
-    /* Make a directory via SFTP */
-    rc = libssh2_sftp_mkdir(sftp_session, sftppath,
-                            LIBSSH2_SFTP_S_IRWXU|
-                            LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IXGRP|
-                            LIBSSH2_SFTP_S_IROTH|LIBSSH2_SFTP_S_IXOTH);
-
-    if(rc)
-        fprintf(stderr, "libssh2_sftp_mkdir failed: %d\n", rc);
-
-    libssh2_sftp_shutdown(sftp_session);
-
- shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_mkdir_nonblock.c b/libssh2/libssh2/example/sftp_mkdir_nonblock.c
deleted file mode 100644
index 217cc4b3..00000000
--- a/libssh2/libssh2/example/sftp_mkdir_nonblock.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Sample showing how to do SFTP non-blocking mkdir.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password /tmp/sftp_write_nonblock.c"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/sftp_mkdir_nonblock";
-    int rc;
-    LIBSSH2_SFTP *sftp_session;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                            "/home/username/.ssh/id_rsa.pub",
-                            "/home/username/.ssh/id_rsa",
-                            password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    fprintf(stderr, "libssh2_sftp_mkdirnb()!\n");
-    /* Make a directory via SFTP */
-    while(libssh2_sftp_mkdir(sftp_session, sftppath,
-                              LIBSSH2_SFTP_S_IRWXU|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IXGRP|
-                              LIBSSH2_SFTP_S_IROTH|LIBSSH2_SFTP_S_IXOTH)
-           == LIBSSH2_ERROR_EAGAIN);
-
-    libssh2_sftp_shutdown(sftp_session);
-
- shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_nonblock.c b/libssh2/libssh2/example/sftp_nonblock.c
deleted file mode 100644
index 8ef091e1..00000000
--- a/libssh2/libssh2/example/sftp_nonblock.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Sample showing how to do SFTP non-blocking transfers.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp_nonblock 192.168.0.1 user password /tmp/secrets"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef HAVE_GETTIMEOFDAY
-/* diff in ms */
-static long tvdiff(struct timeval newer, struct timeval older)
-{
-  return (newer.tv_sec-older.tv_sec)*1000+
-      (newer.tv_usec-older.tv_usec)/1000;
-}
-#endif
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/TEST";
-#ifdef HAVE_GETTIMEOFDAY
-    struct timeval start;
-    struct timeval end;
-    long time_ms;
-#endif
-    int rc;
-    int total = 0;
-    int spin = 0;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-#ifdef HAVE_GETTIMEOFDAY
-    gettimeofday(&start, NULL);
-#endif
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
-    while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-        * is check the hostkey's fingerprint against our known hosts Your app
-        * may have it hard coded, may go to a file, may present it to the
-        * user, that's your call
-        */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password))
-               == LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        while((rc =
-               libssh2_userauth_publickey_fromfile(session, username,
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa.pub",
-                                                   "/home/username/"
-                                                   ".ssh/id_rsa",
-                                                   password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-#if 0
-    libssh2_trace(session, LIBSSH2_TRACE_CONN);
-#endif
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    do {
-        sftp_session = libssh2_sftp_init(session);
-
-        if(!sftp_session) {
-            if(libssh2_session_last_errno(session) ==
-               LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "non-blocking init\n");
-                waitsocket(sock, session); /* now we wait */
-            }
-            else {
-                fprintf(stderr, "Unable to init SFTP session\n");
-                goto shutdown;
-            }
-        }
-    } while(!sftp_session);
-
-    fprintf(stderr, "libssh2_sftp_open()!\n");
-    /* Request a file via SFTP */
-    do {
-        sftp_handle = libssh2_sftp_open(sftp_session, sftppath,
-                                        LIBSSH2_FXF_READ, 0);
-
-        if(!sftp_handle) {
-            if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                fprintf(stderr, "Unable to open file with SFTP\n");
-                goto shutdown;
-            }
-            else {
-                fprintf(stderr, "non-blocking open\n");
-                waitsocket(sock, session); /* now we wait */
-            }
-        }
-    } while(!sftp_handle);
-
-    fprintf(stderr, "libssh2_sftp_open() is done, now receive data!\n");
-    do {
-        char mem[1024*24];
-
-        /* loop until we fail */
-        while((rc = libssh2_sftp_read(sftp_handle, mem,
-                                       sizeof(mem))) == LIBSSH2_ERROR_EAGAIN) {
-            spin++;
-            waitsocket(sock, session); /* now we wait */
-        }
-        if(rc > 0) {
-            total += rc;
-            write(1, mem, rc);
-        }
-        else {
-            break;
-        }
-    } while(1);
-
-#ifdef HAVE_GETTIMEOFDAY
-    gettimeofday(&end, NULL);
-    time_ms = tvdiff(end, start);
-    fprintf(stderr, "Got %d bytes in %ld ms = %.1f bytes/sec spin: %d\n",
-            total,
-            time_ms, total/(time_ms/1000.0), spin);
-#else
-    fprintf(stderr, "Got %d bytes spin: %d\n", total, spin);
-#endif
-
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-shutdown:
-
-    fprintf(stderr, "libssh2_session_disconnect\n");
-    while(libssh2_session_disconnect(session,
-                                      "Normal Shutdown, Thank you") ==
-           LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_write.c b/libssh2/libssh2/example/sftp_write.c
deleted file mode 100644
index c1350e9c..00000000
--- a/libssh2/libssh2/example/sftp_write.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Sample showing how to do SFTP write transfers.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password sftp_write.c /tmp/secrets"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write.c";
-    const char *sftppath = "/tmp/TEST";
-    int rc;
-    FILE *local;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-    char mem[1024*100];
-    size_t nread;
-    char *ptr;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        sftppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-            sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are blocking */
-    libssh2_session_set_blocking(session, 1);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-        const char *privkey = "/home/username/.ssh/id_rsa.pub";
-        if(libssh2_userauth_publickey_fromfile(session, username,
-                                               pubkey, privkey,
-                                               password)) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "libssh2_sftp_open()!\n");
-    /* Request a file via SFTP */
-    sftp_handle =
-        libssh2_sftp_open(sftp_session, sftppath,
-                      LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC,
-                      LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                      LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-
-    if(!sftp_handle) {
-        fprintf(stderr, "Unable to open file with SFTP\n");
-        goto shutdown;
-    }
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-    do {
-        nread = fread(mem, 1, sizeof(mem), local);
-        if(nread <= 0) {
-            /* end of file */
-            break;
-        }
-        ptr = mem;
-
-        do {
-            /* write data in a loop until we block */
-            rc = libssh2_sftp_write(sftp_handle, ptr, nread);
-            if(rc < 0)
-                break;
-            ptr += rc;
-            nread -= rc;
-        } while(nread);
-
-    } while(rc > 0);
-
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-shutdown:
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    if(local)
-        fclose(local);
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_write_nonblock.c b/libssh2/libssh2/example/sftp_write_nonblock.c
deleted file mode 100644
index 934749ea..00000000
--- a/libssh2/libssh2/example/sftp_write_nonblock.c
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Sample showing how to do SFTP non-blocking write transfers.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password thisfile /tmp/storehere"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <time.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write_nonblock.c";
-    const char *sftppath = "/tmp/sftp_write_nonblock.c";
-    int rc;
-    FILE *local;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-    char mem[1024 * 100];
-    size_t nread;
-    char *ptr;
-    time_t start;
-    long total = 0;
-    int duration;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        sftppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-        */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
-    while((rc = libssh2_session_handshake(session, sock))
-           == LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do is
-     * check the hostkey's fingerprint against our known hosts Your app may
-     * have it hard coded, may go to a file, may present it to the user,
-     * that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-        const char *privkey = "/home/username/.ssh/id_rsa";
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        pubkey, privkey,
-                                                        password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    do {
-        sftp_session = libssh2_sftp_init(session);
-
-        if(!sftp_session &&
-            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to init SFTP session\n");
-            goto shutdown;
-        }
-    } while(!sftp_session);
-
-    fprintf(stderr, "libssh2_sftp_open()!\n");
-    /* Request a file via SFTP */
-    do {
-        sftp_handle =
-            libssh2_sftp_open(sftp_session, sftppath,
-                              LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|
-                              LIBSSH2_FXF_TRUNC,
-                              LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-        if(!sftp_handle &&
-           (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to open file with SFTP\n");
-            goto shutdown;
-        }
-    } while(!sftp_handle);
-
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-
-    start = time(NULL);
-
-    do {
-        nread = fread(mem, 1, sizeof(mem), local);
-        if(nread <= 0) {
-            /* end of file */
-            break;
-        }
-        ptr = mem;
-
-        total += nread;
-
-        do {
-            /* write data in a loop until we block */
-            while((rc = libssh2_sftp_write(sftp_handle, ptr, nread)) ==
-                   LIBSSH2_ERROR_EAGAIN) {
-                waitsocket(sock, session);
-            }
-            if(rc < 0)
-                break;
-            ptr += rc;
-            nread -= rc;
-
-        } while(nread);
-    } while(rc > 0);
-
-    duration = (int)(time(NULL)-start);
-
-    fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
-
-
-    fclose(local);
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-shutdown:
-
-    while(libssh2_session_disconnect(session, "Normal Shutdown")
-           == LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftp_write_sliding.c b/libssh2/libssh2/example/sftp_write_sliding.c
deleted file mode 100644
index 9a72140f..00000000
--- a/libssh2/libssh2/example/sftp_write_sliding.c
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Sample showing how to do SFTP non-blocking write transfers.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "sftp 192.168.0.1 user password file /tmp/storehere"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <time.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *loclfile = "sftp_write_nonblock.c";
-    const char *sftppath = "/tmp/sftp_write_nonblock.c";
-    int rc;
-    FILE *local;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-    char mem[1024 * 1000];
-    size_t nread;
-    size_t memuse;
-    time_t start;
-    long total = 0;
-    int duration;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        loclfile = argv[4];
-    }
-    if(argc > 5) {
-        sftppath = argv[5];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    local = fopen(loclfile, "rb");
-    if(!local) {
-        fprintf(stderr, "Can't open local file %s\n", loclfile);
-        return -1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-        */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-        * and setup crypto, compression, and MAC layers
-        */
-    while((rc = libssh2_session_handshake(session, sock))
-           == LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do is
-     * check the hostkey's fingerprint against our known hosts Your app may
-     * have it hard coded, may go to a file, may present it to the user,
-     * that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-#define PUBKEY "/home/username/.ssh/id_rsa.pub"
-#define PRIVKEY "/home/username/.ssh/id_rsa"
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        PUBKEY, PRIVKEY,
-                                                        password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    do {
-        sftp_session = libssh2_sftp_init(session);
-
-        if(!sftp_session &&
-            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to init SFTP session\n");
-            goto shutdown;
-        }
-    } while(!sftp_session);
-
-    fprintf(stderr, "libssh2_sftp_open()!\n");
-    /* Request a file via SFTP */
-    do {
-        sftp_handle =
-            libssh2_sftp_open(sftp_session, sftppath,
-                              LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|
-                              LIBSSH2_FXF_TRUNC,
-                              LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
-                              LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
-
-        if(!sftp_handle &&
-           (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to open file with SFTP\n");
-            goto shutdown;
-        }
-    } while(!sftp_handle);
-
-    fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
-
-    start = time(NULL);
-
-    memuse = 0; /* it starts blank */
-    do {
-        nread = fread(&mem[memuse], 1, sizeof(mem)-memuse, local);
-        if(nread <= 0) {
-            /* end of file */
-            if(memuse > 0)
-                /* the previous sending is not finished */
-                nread = 0;
-            else
-                break;
-        }
-        memuse += nread;
-        total += nread;
-
-        /* write data in a loop until we block */
-        while((rc = libssh2_sftp_write(sftp_handle, mem, memuse)) ==
-               LIBSSH2_ERROR_EAGAIN) {
-            waitsocket(sock, session);
-        }
-        if(rc < 0)
-            break;
-
-        if(memuse - rc) {
-            /* make room for more data at the end of the buffer */
-            memmove(&mem[0], &mem[rc], memuse - rc);
-            memuse -= rc;
-        }
-        else
-            /* 'mem' was consumed fully */
-            memuse = 0;
-
-    } while(rc > 0);
-
-    duration = (int)(time(NULL)-start);
-
-    fprintf(stderr, "%ld bytes in %d seconds makes %.1f bytes/sec\n",
-           total, duration, total/(double)duration);
-
-
-    fclose(local);
-    libssh2_sftp_close(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-shutdown:
-
-    while(libssh2_session_disconnect(session, "Normal Shutdown")
-          == LIBSSH2_ERROR_EAGAIN);
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftpdir.c b/libssh2/libssh2/example/sftpdir.c
deleted file mode 100644
index 8fb16b1e..00000000
--- a/libssh2/libssh2/example/sftpdir.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * Sample doing an SFTP directory listing.
- *
- * The sample code has default values for host name, user name, password and
- * path, but you can specify them on the command line like:
- *
- * "sftpdir 192.168.0.1 user password /tmp/secretdir"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef WIN32
-#define __FILESIZE "I64"
-#else
-#define __FILESIZE "llu"
-#endif
-
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruction, int instruction_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    (void)name;
-    (void)name_len;
-    (void)instruction;
-    (void)instruction_len;
-    if(num_prompts == 1) {
-        responses[0].text = strdup(password);
-        responses[0].length = strlen(password);
-    }
-    (void)prompts;
-    (void)abstract;
-} /* kbd_callback */
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int rc, sock, i, auth_pw = 0;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    const char *sftppath = "/tmp/secretdir";
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 5. argument we set this option if supported */
-    if(argc > 5) {
-        if((auth_pw & 1) && !strcasecmp(argv[5], "-p")) {
-            auth_pw = 1;
-        }
-        if((auth_pw & 2) && !strcasecmp(argv[5], "-i")) {
-            auth_pw = 2;
-        }
-        if((auth_pw & 4) && !strcasecmp(argv[5], "-k")) {
-            auth_pw = 4;
-        }
-    }
-
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "\tAuthentication by password failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by password succeeded.\n");
-        }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive succeeded.\n");
-        }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-        }
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    sftp_session = libssh2_sftp_init(session);
-
-    if(!sftp_session) {
-        fprintf(stderr, "Unable to init SFTP session\n");
-        goto shutdown;
-    }
-
-    /* Since we have not set non-blocking, tell libssh2 we are blocking */
-    libssh2_session_set_blocking(session, 1);
-
-    fprintf(stderr, "libssh2_sftp_opendir()!\n");
-    /* Request a dir listing via SFTP */
-    sftp_handle = libssh2_sftp_opendir(sftp_session, sftppath);
-
-    if(!sftp_handle) {
-        fprintf(stderr, "Unable to open dir with SFTP\n");
-        goto shutdown;
-    }
-    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing!\n");
-    do {
-        char mem[512];
-        char longentry[512];
-        LIBSSH2_SFTP_ATTRIBUTES attrs;
-
-        /* loop until we fail */
-        rc = libssh2_sftp_readdir_ex(sftp_handle, mem, sizeof(mem),
-                                     longentry, sizeof(longentry), &attrs);
-        if(rc > 0) {
-            /* rc is the length of the file name in the mem
-               buffer */
-
-            if(longentry[0] != '\0') {
-                printf("%s\n", longentry);
-            }
-            else {
-                if(attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
-                    /* this should check what permissions it
-                       is and print the output accordingly */
-                    printf("--fix----- ");
-                }
-                else {
-                    printf("---------- ");
-                }
-
-                if(attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID) {
-                    printf("%4d %4d ", (int) attrs.uid, (int) attrs.gid);
-                }
-                else {
-                    printf("   -    - ");
-                }
-
-                if(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
-                    printf("%8" __FILESIZE " ", attrs.filesize);
-                }
-
-                printf("%s\n", mem);
-            }
-        }
-        else
-            break;
-
-    } while(1);
-
-    libssh2_sftp_closedir(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
- shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/sftpdir_nonblock.c b/libssh2/libssh2/example/sftpdir_nonblock.c
deleted file mode 100644
index e9498d97..00000000
--- a/libssh2/libssh2/example/sftpdir_nonblock.c
+++ /dev/null
@@ -1,249 +0,0 @@
-/*
- * Sample doing an SFTP directory listing.
- *
- * The sample code has default values for host name, user name, password and
- * path, but you can specify them on the command line like:
- *
- * "sftpdir 192.168.0.1 user password /tmp/secretdir"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-# include <inttypes.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#ifdef WIN32
-#define __FILESIZE "I64"
-#else
-#define __FILESIZE "llu"
-#endif
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 1;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    const char *username = "username";
-    const char *password = "password";
-    const char *sftppath = "/tmp/secretdir";
-    const char *pubkey = "/home/username/.ssh/id_rsa.pub";
-    const char *privkey = "/home/username/.ssh/id_rsa";
-    int rc;
-    LIBSSH2_SFTP *sftp_session;
-    LIBSSH2_SFTP_HANDLE *sftp_handle;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        sftppath = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /*
-     * The application code is responsible for creating the socket
-     * and establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-               sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance
-     */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* Since we have set non-blocking, tell libssh2 we are non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    while((rc = libssh2_session_handshake(session, sock)) ==
-          LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    if(auth_pw) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                        pubkey, privkey,
-                                                        password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-    fprintf(stderr, "libssh2_sftp_init()!\n");
-    do {
-        sftp_session = libssh2_sftp_init(session);
-
-        if((!sftp_session) && (libssh2_session_last_errno(session) !=
-                               LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to init SFTP session\n");
-            goto shutdown;
-        }
-    } while(!sftp_session);
-
-    fprintf(stderr, "libssh2_sftp_opendir()!\n");
-    /* Request a dir listing via SFTP */
-    do {
-        sftp_handle = libssh2_sftp_opendir(sftp_session, sftppath);
-
-        if((!sftp_handle) && (libssh2_session_last_errno(session) !=
-                              LIBSSH2_ERROR_EAGAIN)) {
-            fprintf(stderr, "Unable to open dir with SFTP\n");
-            goto shutdown;
-        }
-    } while(!sftp_handle);
-
-    fprintf(stderr, "libssh2_sftp_opendir() is done, now receive listing!\n");
-    do {
-        char mem[512];
-        LIBSSH2_SFTP_ATTRIBUTES attrs;
-
-        /* loop until we fail */
-        while((rc = libssh2_sftp_readdir(sftp_handle, mem, sizeof(mem),
-                                         &attrs)) == LIBSSH2_ERROR_EAGAIN) {
-            ;
-        }
-        if(rc > 0) {
-            /* rc is the length of the file name in the mem
-               buffer */
-
-            if(attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
-                /* this should check what permissions it
-                   is and print the output accordingly */
-                printf("--fix----- ");
-            }
-            else {
-                printf("---------- ");
-            }
-
-            if(attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID) {
-                printf("%4d %4d ", (int) attrs.uid, (int) attrs.gid);
-            }
-            else {
-                printf("   -    - ");
-            }
-
-            if(attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
-                printf("%8" __FILESIZE " ", attrs.filesize);
-            }
-
-            printf("%s\n", mem);
-        }
-        else if(rc == LIBSSH2_ERROR_EAGAIN) {
-            /* blocking */
-            fprintf(stderr, "Blocking\n");
-        }
-        else {
-            break;
-        }
-
-    } while(1);
-
-    libssh2_sftp_closedir(sftp_handle);
-    libssh2_sftp_shutdown(sftp_session);
-
-  shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/ssh2.c b/libssh2/libssh2/example/ssh2.c
deleted file mode 100644
index fa86f551..00000000
--- a/libssh2/libssh2/example/ssh2.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Sample showing how to do SSH2 connect.
- *
- * The sample code has default values for host name, user name, password
- * and path to copy, but you can specify them on the command line like:
- *
- * "ssh2 host user password [-p|-i|-k]"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-# ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-
-const char *keyfile1 = "~/.ssh/id_rsa.pub";
-const char *keyfile2 = "~/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "password";
-
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruction, int instruction_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    (void)name;
-    (void)name_len;
-    (void)instruction;
-    (void)instruction_len;
-    if(num_prompts == 1) {
-        responses[0].text = strdup(password);
-        responses[0].length = strlen(password);
-    }
-    (void)prompts;
-    (void)abstract;
-} /* kbd_callback */
-
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int rc, sock, i, auth_pw = 0;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Ultra basic "connect to port 22 on localhost".  Your code is
-     * responsible for creating the socket establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance and start it up. This will trade welcome
-     * banners, exchange keys, and setup crypto, compression, and MAC layers
-     */
-    session = libssh2_session_init();
-    if(libssh2_session_handshake(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return -1;
-    }
-
-    /* At this point we havn't authenticated. The first thing to do is check
-     * the hostkey's fingerprint against our known hosts Your app may have it
-     * hard coded, may go to a file, may present it to the user, that's your
-     * call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    /* if we got an 4. argument we set this option if supported */
-    if(argc > 4) {
-        if((auth_pw & 1) && !strcasecmp(argv[4], "-p")) {
-            auth_pw = 1;
-        }
-        if((auth_pw & 2) && !strcasecmp(argv[4], "-i")) {
-            auth_pw = 2;
-        }
-        if((auth_pw & 4) && !strcasecmp(argv[4], "-k")) {
-            auth_pw = 4;
-        }
-    }
-
-    if(auth_pw & 1) {
-        /* We could authenticate via password */
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "\tAuthentication by password failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by password succeeded.\n");
-        }
-    }
-    else if(auth_pw & 2) {
-        /* Or via keyboard-interactive */
-        if(libssh2_userauth_keyboard_interactive(session, username,
-                                                 &kbd_callback) ) {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr,
-                    "\tAuthentication by keyboard-interactive succeeded.\n");
-        }
-    }
-    else if(auth_pw & 4) {
-        /* Or by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        else {
-            fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-        }
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    /* Request a shell */
-    channel = libssh2_channel_open_session(session);
-    if(!channel) {
-        fprintf(stderr, "Unable to open a session\n");
-        goto shutdown;
-    }
-
-    /* Some environment variables may be set,
-     * It's up to the server which ones it'll allow though
-     */
-    libssh2_channel_setenv(channel, "FOO", "bar");
-
-    /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
-     */
-    if(libssh2_channel_request_pty(channel, "vanilla")) {
-        fprintf(stderr, "Failed requesting pty\n");
-        goto skip_shell;
-    }
-
-    /* Open a SHELL on that pty */
-    if(libssh2_channel_shell(channel)) {
-        fprintf(stderr, "Unable to request shell on allocated pty\n");
-        goto shutdown;
-    }
-
-    /* At this point the shell can be interacted with using
-     * libssh2_channel_read()
-     * libssh2_channel_read_stderr()
-     * libssh2_channel_write()
-     * libssh2_channel_write_stderr()
-     *
-     * Blocking mode may be (en|dis)abled with: libssh2_channel_set_blocking()
-     * If the server send EOF, libssh2_channel_eof() will return non-0
-     * To send EOF to the server use: libssh2_channel_send_eof()
-     * A channel can be closed with: libssh2_channel_close()
-     * A channel can be freed with: libssh2_channel_free()
-     */
-
-  skip_shell:
-    if(channel) {
-        libssh2_channel_free(channel);
-        channel = NULL;
-    }
-
-    /* Other channel types are supported via:
-     * libssh2_scp_send()
-     * libssh2_scp_recv2()
-     * libssh2_channel_direct_tcpip()
-     */
-
-  shutdown:
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done!\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/ssh2_agent.c b/libssh2/libssh2/example/ssh2_agent.c
deleted file mode 100644
index 1cc50844..00000000
--- a/libssh2/libssh2/example/ssh2_agent.c
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Sample showing how to do SSH2 connect using ssh-agent.
- *
- * The sample code has default values for host name, user name:
- *
- * "ssh2_agent host user"
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-# ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-
-const char *username = "username";
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock = -1, i, rc;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session = NULL;
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_AGENT *agent = NULL;
-    struct libssh2_agent_publickey *identity, *prev_identity = NULL;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1) {
-        hostaddr = inet_addr(argv[1]);
-    }
-    else {
-        hostaddr = htonl(0x7F000001);
-    }
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Ultra basic "connect to port 22 on localhost".  Your code is
-     * responsible for creating the socket establishing the connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock == -1) {
-        fprintf(stderr, "failed to create socket!\n");
-        rc = 1;
-        goto shutdown;
-    }
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        goto shutdown;
-    }
-
-    /* Create a session instance and start it up. This will trade welcome
-     * banners, exchange keys, and setup crypto, compression, and MAC layers
-     */
-    session = libssh2_session_init();
-    if(libssh2_session_handshake(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return 1;
-    }
-
-    /* At this point we havn't authenticated. The first thing to do is check
-     * the hostkey's fingerprint against our known hosts Your app may have it
-     * hard coded, may go to a file, may present it to the user, that's your
-     * call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    }
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "publickey") == NULL) {
-        fprintf(stderr, "\"publickey\" authentication is not supported\n");
-        goto shutdown;
-    }
-
-    /* Connect to the ssh-agent */
-    agent = libssh2_agent_init(session);
-    if(!agent) {
-        fprintf(stderr, "Failure initializing ssh-agent support\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_connect(agent)) {
-        fprintf(stderr, "Failure connecting to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_list_identities(agent)) {
-        fprintf(stderr, "Failure requesting identities to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    while(1) {
-        rc = libssh2_agent_get_identity(agent, &identity, prev_identity);
-        if(rc == 1)
-            break;
-        if(rc < 0) {
-            fprintf(stderr,
-                    "Failure obtaining identity from ssh-agent support\n");
-            rc = 1;
-            goto shutdown;
-        }
-        if(libssh2_agent_userauth(agent, username, identity)) {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s failed!\n",
-                   username, identity->comment);
-        }
-        else {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s succeeded!\n",
-                   username, identity->comment);
-            break;
-        }
-        prev_identity = identity;
-    }
-    if(rc) {
-        fprintf(stderr, "Couldn't continue authentication\n");
-        goto shutdown;
-    }
-
-    /* We're authenticated now. */
-
-    /* Request a shell */
-    channel = libssh2_channel_open_session(session);
-    if(!channel) {
-        fprintf(stderr, "Unable to open a session\n");
-        goto shutdown;
-    }
-
-    /* Some environment variables may be set,
-     * It's up to the server which ones it'll allow though
-     */
-    libssh2_channel_setenv(channel, "FOO", "bar");
-
-    /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
-     */
-    if(libssh2_channel_request_pty(channel, "vanilla")) {
-        fprintf(stderr, "Failed requesting pty\n");
-        goto skip_shell;
-    }
-
-    /* Open a SHELL on that pty */
-    if(libssh2_channel_shell(channel)) {
-        fprintf(stderr, "Unable to request shell on allocated pty\n");
-        goto shutdown;
-    }
-
-    /* At this point the shell can be interacted with using
-     * libssh2_channel_read()
-     * libssh2_channel_read_stderr()
-     * libssh2_channel_write()
-     * libssh2_channel_write_stderr()
-     *
-     * Blocking mode may be (en|dis)abled with: libssh2_channel_set_blocking()
-     * If the server send EOF, libssh2_channel_eof() will return non-0
-     * To send EOF to the server use: libssh2_channel_send_eof()
-     * A channel can be closed with: libssh2_channel_close()
-     * A channel can be freed with: libssh2_channel_free()
-     */
-
-  skip_shell:
-    if(channel) {
-        libssh2_channel_free(channel);
-        channel = NULL;
-    }
-
-    /* Other channel types are supported via:
-     * libssh2_scp_send()
-     * libssh2_scp_recv2()
-     * libssh2_channel_direct_tcpip()
-     */
-
-  shutdown:
-
-    if(agent) {
-        libssh2_agent_disconnect(agent);
-        libssh2_agent_free(agent);
-    }
-
-    if(session) {
-        libssh2_session_disconnect(session,
-                                   "Normal Shutdown, Thank you for playing");
-        libssh2_session_free(session);
-    }
-
-    if(sock != -1) {
-#ifdef WIN32
-        closesocket(sock);
-#else
-        close(sock);
-#endif
-    }
-
-    fprintf(stderr, "all done!\n");
-
-    libssh2_exit();
-
-    return rc;
-}
diff --git a/libssh2/libssh2/example/ssh2_agent_forwarding.c b/libssh2/libssh2/example/ssh2_agent_forwarding.c
deleted file mode 100644
index b99fc95f..00000000
--- a/libssh2/libssh2/example/ssh2_agent_forwarding.c
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Sample showing how to use libssh2 to request agent forwarding
- * on the remote host. The command executed will run with agent forwarded
- * so you should be able to do things like clone out protected git
- * repos and such.
- *
- * The example uses agent authentication to ensure an agent to forward
- * is running.
- *
- * Run it like this:
- *
- * $ ./ssh2_agent_forwarding 127.0.0.1 user "uptime"
- *
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-#endif
-#include <sys/types.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "uptime";
-    const char *username    = NULL;
-    unsigned long hostaddr;
-    int sock;
-    struct sockaddr_in sin;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_AGENT *agent = NULL;
-    struct libssh2_agent_publickey *identity, *prev_identity = NULL;
-    int rc;
-    int exitcode;
-    char *exitsignal = (char *)"none";
-    int bytecount = 0;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    WSAStartup(MAKEWORD(2, 0), &wsadata);
-#endif
-    if(argc < 2) {
-        fprintf(stderr, "At least IP and username arguments are required.\n");
-        return 1;
-    }
-    /* must be ip address only */
-    hostname = argv[1];
-    username = argv[2];
-
-    if(argc > 3) {
-        commandline = argv[3];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    hostaddr = inet_addr(hostname);
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    if(libssh2_session_handshake(session, sock) != 0) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* Connect to the ssh-agent */
-    agent = libssh2_agent_init(session);
-    if(!agent) {
-        fprintf(stderr, "Failure initializing ssh-agent support\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_connect(agent)) {
-        fprintf(stderr, "Failure connecting to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    if(libssh2_agent_list_identities(agent)) {
-        fprintf(stderr, "Failure requesting identities to ssh-agent\n");
-        rc = 1;
-        goto shutdown;
-    }
-    while(1) {
-        rc = libssh2_agent_get_identity(agent, &identity, prev_identity);
-        if(rc == 1)
-            break;
-        if(rc < 0) {
-            fprintf(stderr,
-                    "Failure obtaining identity from ssh-agent support\n");
-            rc = 1;
-            goto shutdown;
-        }
-        if(libssh2_agent_userauth(agent, username, identity)) {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s failed!\n",
-                   username, identity->comment);
-        }
-        else {
-            fprintf(stderr, "\tAuthentication with username %s and "
-                   "public key %s succeeded!\n",
-                   username, identity->comment);
-            break;
-        }
-        prev_identity = identity;
-    }
-    if(rc) {
-        fprintf(stderr, "Couldn't continue authentication\n");
-        goto shutdown;
-    }
-
-#if 0
-    libssh2_trace(session, ~0);
-#endif
-
-    /* Set session to non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(channel == NULL) {
-        fprintf(stderr, "Error\n");
-        exit(1);
-    }
-    while((rc = libssh2_channel_request_auth_agent(channel)) ==
-          LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(rc != 0) {
-        fprintf(stderr, "Error, couldn't request auth agent, error code %d.\n",
-                rc);
-        exit(1);
-    }
-    else {
-        fprintf(stdout, "\tAgent forwarding request succeeded!\n");
-    }
-    while((rc = libssh2_channel_exec(channel, commandline)) ==
-          LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(rc != 0) {
-        fprintf(stderr, "Error\n");
-        exit(1);
-    }
-    for(;;) {
-        /* loop until we block */
-        int rc;
-        do {
-            char buffer[0x4000];
-            rc = libssh2_channel_read(channel, buffer, sizeof(buffer) );
-            if(rc > 0) {
-                int i;
-                bytecount += rc;
-                fprintf(stderr, "We read:\n");
-                for(i = 0; i < rc; ++i)
-                    fputc(buffer[i], stderr);
-                fprintf(stderr, "\n");
-            }
-            else {
-                if(rc != LIBSSH2_ERROR_EAGAIN)
-                    /* no need to output this for the EAGAIN case */
-                    fprintf(stderr, "libssh2_channel_read returned %d\n", rc);
-            }
-        }
-        while(rc > 0);
-
-        /* this is due to blocking that would occur otherwise so we loop on
-           this condition */
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            waitsocket(sock, session);
-        }
-        else
-            break;
-    }
-    exitcode = 127;
-    while((rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(rc == 0) {
-        exitcode = libssh2_channel_get_exit_status(channel);
-        libssh2_channel_get_exit_signal(channel, &exitsignal,
-                                        NULL, NULL, NULL, NULL, NULL);
-    }
-
-    if(exitsignal) {
-        printf("\nGot signal: %s\n", exitsignal);
-    }
-    else {
-        printf("\nEXIT: %d bytecount: %d\n", exitcode, bytecount);
-    }
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
-shutdown:
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/ssh2_echo.c b/libssh2/libssh2/example/ssh2_echo.c
deleted file mode 100644
index eae41656..00000000
--- a/libssh2/libssh2/example/ssh2_echo.c
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * Run it like this:
- *
- * $ ./ssh2_echo 127.0.0.1 user password
- *
- * The code sends a 'cat' command, and then writes a lot of data to it only to
- * check that reading the returned data sums up to the same amount.
- *
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-#define BUFSIZE 32000
-
-int main(int argc, char *argv[])
-{
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "cat";
-    const char *username    = "user";
-    const char *password    = "password";
-    unsigned long hostaddr;
-    int sock;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    int rc;
-    int exitcode = 0;
-    char *exitsignal = (char *)"none";
-    size_t len;
-    LIBSSH2_KNOWNHOSTS *nh;
-    int type;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1)
-        /* must be ip address only */
-        hostname = argv[1];
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    hostaddr = inet_addr(hostname);
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* tell libssh2 we want it all done non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    nh = libssh2_knownhost_init(session);
-    if(!nh) {
-        /* eeek, do cleanup here */
-        return 2;
-    }
-
-    /* read all hosts from here */
-    libssh2_knownhost_readfile(nh, "known_hosts",
-                               LIBSSH2_KNOWNHOST_FILE_OPENSSH);
-
-    /* store all known hosts to here */
-    libssh2_knownhost_writefile(nh, "dumpfile",
-                                LIBSSH2_KNOWNHOST_FILE_OPENSSH);
-
-    fingerprint = libssh2_session_hostkey(session, &len, &type);
-    if(fingerprint) {
-        struct libssh2_knownhost *host;
-        int check = libssh2_knownhost_checkp(nh, hostname, 22,
-                                             fingerprint, len,
-                                             LIBSSH2_KNOWNHOST_TYPE_PLAIN|
-                                             LIBSSH2_KNOWNHOST_KEYENC_RAW,
-                                             &host);
-
-        fprintf(stderr, "Host check: %d, key: %s\n", check,
-                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
-                host->key:"<none>");
-
-        /*****
-         * At this point, we could verify that 'check' tells us the key is
-         * fine or bail out.
-         *****/
-    }
-    else {
-        /* eeek, do cleanup here */
-        return 3;
-    }
-    libssh2_knownhost_free(nh);
-
-    if(strlen(password) != 0) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-              LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            exit(1);
-        }
-    }
-
-    libssh2_trace(session, LIBSSH2_TRACE_SOCKET);
-
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(channel == NULL) {
-        fprintf(stderr, "Error\n");
-        exit(1);
-    }
-    while((rc = libssh2_channel_exec(channel, commandline)) ==
-          LIBSSH2_ERROR_EAGAIN)
-        waitsocket(sock, session);
-
-    if(rc != 0) {
-        fprintf(stderr, "exec error\n");
-        exit(1);
-    }
-    else {
-        LIBSSH2_POLLFD *fds = NULL;
-        int running = 1;
-        int bufsize = BUFSIZE;
-        char buffer[BUFSIZE];
-        int totsize = 1500000;
-        int totwritten = 0;
-        int totread = 0;
-        int partials = 0;
-        int rereads = 0;
-        int rewrites = 0;
-        int i;
-
-        for(i = 0; i < BUFSIZE; i++)
-            buffer[i] = 'A';
-
-        fds = malloc(sizeof (LIBSSH2_POLLFD));
-        if(!fds) {
-            fprintf(stderr, "malloc failed\n");
-            exit(1);
-        }
-
-        fds[0].type = LIBSSH2_POLLFD_CHANNEL;
-        fds[0].fd.channel = channel;
-        fds[0].events = LIBSSH2_POLLFD_POLLIN | LIBSSH2_POLLFD_POLLOUT;
-
-        do {
-            int rc = (libssh2_poll(fds, 1, 10));
-            int act = 0;
-
-            if(rc < 1)
-                continue;
-
-            if(fds[0].revents & LIBSSH2_POLLFD_POLLIN) {
-                int n = libssh2_channel_read(channel, buffer, sizeof(buffer));
-                act++;
-
-                if(n == LIBSSH2_ERROR_EAGAIN) {
-                    rereads++;
-                    fprintf(stderr, "will read again\n");
-                }
-                else if(n < 0) {
-                    fprintf(stderr, "read failed\n");
-                    exit(1);
-                }
-                else {
-                    totread += n;
-                    fprintf(stderr, "read %d bytes (%d in total)\n",
-                            n, totread);
-                }
-            }
-
-            if(fds[0].revents & LIBSSH2_POLLFD_POLLOUT) {
-                act++;
-
-                if(totwritten < totsize) {
-                    /* we have not written all data yet */
-                    int left = totsize - totwritten;
-                    int size = (left < bufsize) ? left : bufsize;
-                    int n = libssh2_channel_write_ex(channel, 0, buffer, size);
-
-                    if(n == LIBSSH2_ERROR_EAGAIN) {
-                        rewrites++;
-                        fprintf(stderr, "will write again\n");
-                    }
-                    else if(n < 0) {
-                        fprintf(stderr, "write failed\n");
-                        exit(1);
-                    }
-                    else {
-                        totwritten += n;
-                        fprintf(stderr, "wrote %d bytes (%d in total)",
-                                n, totwritten);
-                        if(left >= bufsize && n != bufsize) {
-                            partials++;
-                            fprintf(stderr, " PARTIAL");
-                        }
-                        fprintf(stderr, "\n");
-                    }
-                }
-                else {
-                    /* all data written, send EOF */
-                    rc = libssh2_channel_send_eof(channel);
-
-                    if(rc == LIBSSH2_ERROR_EAGAIN) {
-                        fprintf(stderr, "will send eof again\n");
-                    }
-                    else if(rc < 0) {
-                        fprintf(stderr, "send eof failed\n");
-                        exit(1);
-                    }
-                    else {
-                        fprintf(stderr, "sent eof\n");
-                        /* we're done writing, stop listening for OUT events */
-                        fds[0].events &= ~LIBSSH2_POLLFD_POLLOUT;
-                    }
-                }
-            }
-
-            if(fds[0].revents & LIBSSH2_POLLFD_CHANNEL_CLOSED) {
-                if(!act) /* don't leave loop until we have read all data */
-                    running = 0;
-            }
-        } while(running);
-
-        exitcode = 127;
-        while((rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN)
-            waitsocket(sock, session);
-
-        if(rc == 0) {
-            exitcode = libssh2_channel_get_exit_status(channel);
-            libssh2_channel_get_exit_signal(channel, &exitsignal,
-                                            NULL, NULL, NULL, NULL, NULL);
-        }
-
-        if(exitsignal)
-            fprintf(stderr, "\nGot signal: %s\n", exitsignal);
-
-        libssh2_channel_free(channel);
-        channel = NULL;
-
-        fprintf(stderr, "\nrereads: %d rewrites: %d totwritten %d\n",
-                rereads, rewrites, totwritten);
-
-        if(totwritten != totread) {
-            fprintf(stderr, "\n*** FAIL bytes written: %d bytes "
-                    "read: %d ***\n", totwritten, totread);
-            exit(1);
-        }
-    }
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return exitcode;
-}
diff --git a/libssh2/libssh2/example/ssh2_exec.c b/libssh2/libssh2/example/ssh2_exec.c
deleted file mode 100644
index d33c6d9a..00000000
--- a/libssh2/libssh2/example/ssh2_exec.c
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- * Sample showing how to use libssh2 to execute a command remotely.
- *
- * The sample code has fixed values for host name, user name, password
- * and command to run.
- *
- * Run it like this:
- *
- * $ ./ssh2_exec 127.0.0.1 user password "uptime"
- *
- */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-# include <arpa/inet.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-
-static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
-{
-    struct timeval timeout;
-    int rc;
-    fd_set fd;
-    fd_set *writefd = NULL;
-    fd_set *readfd = NULL;
-    int dir;
-
-    timeout.tv_sec = 10;
-    timeout.tv_usec = 0;
-
-    FD_ZERO(&fd);
-
-    FD_SET(socket_fd, &fd);
-
-    /* now make sure we wait in the correct direction */
-    dir = libssh2_session_block_directions(session);
-
-    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-        readfd = &fd;
-
-    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-        writefd = &fd;
-
-    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
-
-    return rc;
-}
-
-int main(int argc, char *argv[])
-{
-    const char *hostname = "127.0.0.1";
-    const char *commandline = "uptime";
-    const char *username    = "user";
-    const char *password    = "password";
-    unsigned long hostaddr;
-    int sock;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    int rc;
-    int exitcode;
-    char *exitsignal = (char *)"none";
-    int bytecount = 0;
-    size_t len;
-    LIBSSH2_KNOWNHOSTS *nh;
-    int type;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#endif
-
-    if(argc > 1)
-        /* must be ip address only */
-        hostname = argv[1];
-
-    if(argc > 2) {
-        username = argv[2];
-    }
-    if(argc > 3) {
-        password = argv[3];
-    }
-    if(argc > 4) {
-        commandline = argv[4];
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    hostaddr = inet_addr(hostname);
-
-    /* Ultra basic "connect to port 22 on localhost"
-     * Your code is responsible for creating the socket establishing the
-     * connection
-     */
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session)
-        return -1;
-
-    /* tell libssh2 we want it all done non-blocking */
-    libssh2_session_set_blocking(session, 0);
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    while((rc = libssh2_session_handshake(session, sock)) ==
-           LIBSSH2_ERROR_EAGAIN);
-    if(rc) {
-        fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
-        return -1;
-    }
-
-    nh = libssh2_knownhost_init(session);
-    if(!nh) {
-        /* eeek, do cleanup here */
-        return 2;
-    }
-
-    /* read all hosts from here */
-    libssh2_knownhost_readfile(nh, "known_hosts",
-                               LIBSSH2_KNOWNHOST_FILE_OPENSSH);
-
-    /* store all known hosts to here */
-    libssh2_knownhost_writefile(nh, "dumpfile",
-                                LIBSSH2_KNOWNHOST_FILE_OPENSSH);
-
-    fingerprint = libssh2_session_hostkey(session, &len, &type);
-    if(fingerprint) {
-        struct libssh2_knownhost *host;
-#if LIBSSH2_VERSION_NUM >= 0x010206
-        /* introduced in 1.2.6 */
-        int check = libssh2_knownhost_checkp(nh, hostname, 22,
-                                             fingerprint, len,
-                                             LIBSSH2_KNOWNHOST_TYPE_PLAIN|
-                                             LIBSSH2_KNOWNHOST_KEYENC_RAW,
-                                             &host);
-#else
-        /* 1.2.5 or older */
-        int check = libssh2_knownhost_check(nh, hostname,
-                                            fingerprint, len,
-                                            LIBSSH2_KNOWNHOST_TYPE_PLAIN|
-                                            LIBSSH2_KNOWNHOST_KEYENC_RAW,
-                                            &host);
-#endif
-        fprintf(stderr, "Host check: %d, key: %s\n", check,
-                (check <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
-                host->key:"<none>");
-
-        /*****
-         * At this point, we could verify that 'check' tells us the key is
-         * fine or bail out.
-         *****/
-    }
-    else {
-        /* eeek, do cleanup here */
-        return 3;
-    }
-    libssh2_knownhost_free(nh);
-
-    if(strlen(password) != 0) {
-        /* We could authenticate via password */
-        while((rc = libssh2_userauth_password(session, username, password)) ==
-               LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else {
-        /* Or by public key */
-        while((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                         "/home/user/"
-                                                         ".ssh/id_rsa.pub",
-                                                         "/home/user/"
-                                                         ".ssh/id_rsa",
-                                                         password)) ==
-               LIBSSH2_ERROR_EAGAIN);
-        if(rc) {
-            fprintf(stderr, "\tAuthentication by public key failed\n");
-            goto shutdown;
-        }
-    }
-
-#if 0
-    libssh2_trace(session, ~0);
-#endif
-
-    /* Exec non-blocking on the remove host */
-    while((channel = libssh2_channel_open_session(session)) == NULL &&
-          libssh2_session_last_error(session, NULL, NULL, 0) ==
-          LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(channel == NULL) {
-        fprintf(stderr, "Error\n");
-        exit(1);
-    }
-    while((rc = libssh2_channel_exec(channel, commandline)) ==
-           LIBSSH2_ERROR_EAGAIN) {
-        waitsocket(sock, session);
-    }
-    if(rc != 0) {
-        fprintf(stderr, "Error\n");
-        exit(1);
-    }
-    for(;;) {
-        /* loop until we block */
-        int rc;
-        do {
-            char buffer[0x4000];
-            rc = libssh2_channel_read(channel, buffer, sizeof(buffer) );
-            if(rc > 0) {
-                int i;
-                bytecount += rc;
-                fprintf(stderr, "We read:\n");
-                for(i = 0; i < rc; ++i)
-                    fputc(buffer[i], stderr);
-                fprintf(stderr, "\n");
-            }
-            else {
-                if(rc != LIBSSH2_ERROR_EAGAIN)
-                    /* no need to output this for the EAGAIN case */
-                    fprintf(stderr, "libssh2_channel_read returned %d\n", rc);
-            }
-        }
-        while(rc > 0);
-
-        /* this is due to blocking that would occur otherwise so we loop on
-           this condition */
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            waitsocket(sock, session);
-        }
-        else
-            break;
-    }
-    exitcode = 127;
-    while((rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN)
-        waitsocket(sock, session);
-
-    if(rc == 0) {
-        exitcode = libssh2_channel_get_exit_status(channel);
-        libssh2_channel_get_exit_signal(channel, &exitsignal,
-                                        NULL, NULL, NULL, NULL, NULL);
-    }
-
-    if(exitsignal)
-        fprintf(stderr, "\nGot signal: %s\n", exitsignal);
-    else
-        fprintf(stderr, "\nEXIT: %d bytecount: %d\n", exitcode, bytecount);
-
-    libssh2_channel_free(channel);
-    channel = NULL;
-
-shutdown:
-
-    libssh2_session_disconnect(session,
-                               "Normal Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-    fprintf(stderr, "all done\n");
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/subsystem_netconf.c b/libssh2/libssh2/example/subsystem_netconf.c
deleted file mode 100644
index cef25fee..00000000
--- a/libssh2/libssh2/example/subsystem_netconf.c
+++ /dev/null
@@ -1,312 +0,0 @@
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#endif
-
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-
-#ifndef INADDR_NONE
-#define INADDR_NONE (in_addr_t)~0
-#endif
-
-#ifndef HAVE_SNPRINTF
-# ifdef HAVE__SNPRINTF
-# define snprintf _snprintf
-# endif
-#endif
-
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
-
-const char *server_ip = "127.0.0.1";
-
-enum {
-    AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
-};
-
-static int netconf_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t len)
-{
-    int i;
-    ssize_t wr = 0;
-
-    do {
-        i = libssh2_channel_write(channel, buf, len);
-        if(i < 0) {
-            fprintf(stderr, "libssh2_channel_write: %d\n", i);
-            return -1;
-        }
-        wr += i;
-    } while(i > 0 && wr < (ssize_t)len);
-
-    return 0;
-}
-
-static int netconf_read_until(LIBSSH2_CHANNEL *channel, const char *endtag,
-                              char *buf, size_t buflen)
-{
-    ssize_t len;
-    size_t rd = 0;
-    char *endreply = NULL, *specialsequence = NULL;
-
-    memset(buf, 0, buflen);
-
-    do {
-        len = libssh2_channel_read(channel, buf + rd, buflen - rd);
-        if(LIBSSH2_ERROR_EAGAIN == len)
-            continue;
-        else if(len < 0) {
-            fprintf(stderr, "libssh2_channel_read: %d\n", (int)len);
-            return -1;
-        }
-        rd += len;
-
-        /* read more data until we see a rpc-reply closing tag followed by
-         * the special sequence ]]>]]> */
-
-        /* really, this MUST be replaced with proper XML parsing! */
-
-        endreply = strstr(buf, endtag);
-        if(endreply)
-            specialsequence = strstr(endreply, "]]>]]>");
-
-    } while(!specialsequence && rd < buflen);
-
-    if(!specialsequence) {
-        fprintf(stderr, "%s: ]]>]]> not found! read buffer too small?\n",
-                __func__);
-        return -1;
-    }
-
-    /* discard the special sequence so that only XML is returned */
-    rd = specialsequence - buf;
-    buf[rd] = 0;
-
-    return rd;
-}
-
-int main(int argc, char *argv[])
-{
-    int rc, i, auth = AUTH_NONE;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel = NULL;
-    char buf[1048576]; /* avoid any buffer reallocation for simplicity */
-    ssize_t len;
-
-#ifdef WIN32
-    SOCKET sock = INVALID_SOCKET;
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#else
-    int sock = -1;
-#endif
-
-    if(argc > 1)
-        server_ip = argv[1];
-    if(argc > 2)
-        username = argv[2];
-    if(argc > 3)
-        password = argv[3];
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Connect to SSH server */
-    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
-    }
-#endif
-
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = inet_addr(server_ip);
-    if(INADDR_NONE == sin.sin_addr.s_addr) {
-        fprintf(stderr, "inet_addr: Invalid IP address \"%s\"\n", server_ip);
-        return -1;
-    }
-    sin.sin_port = htons(830);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "Failed to connect to %s!\n", inet_ntoa(sin.sin_addr));
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
-    }
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++)
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 4) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[4], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[4], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
-
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                                keyfile2, password)) {
-            fprintf(stderr, "Authentication by public key failed!\n");
-            goto shutdown;
-        }
-        fprintf(stderr, "Authentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    /* open a channel */
-    channel = libssh2_channel_open_session(session);
-    if(!channel) {
-        fprintf(stderr, "Could not open the channel!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
-        goto shutdown;
-    }
-
-    /* execute the subsystem on our channel */
-    if(libssh2_channel_subsystem(channel, "netconf")) {
-        fprintf(stderr, "Could not execute the \"netconf\" subsystem!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
-        goto shutdown;
-    }
-
-    /* NETCONF: https://tools.ietf.org/html/draft-ietf-netconf-ssh-06 */
-
-    fprintf(stderr, "Sending NETCONF client <hello>\n");
-    snprintf(buf, sizeof(buf),
-      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-      "<hello>"
-      "<capabilities>"
-      "<capability>urn:ietf:params:xml:ns:netconf:base:1.0</capability>"
-      "</capabilities>"
-      "</hello>\n"
-      "]]>]]>\n%n", (int *)&len);
-    if(-1 == netconf_write(channel, buf, len))
-        goto shutdown;
-
-    fprintf(stderr, "Reading NETCONF server <hello>\n");
-    len = netconf_read_until(channel, "</hello>", buf, sizeof(buf));
-    if(-1 == len)
-        goto shutdown;
-
-    fprintf(stderr, "Got %d bytes:\n----------------------\n%s",
-            (int)len, buf);
-
-    fprintf(stderr, "Sending NETCONF <rpc>\n");
-    snprintf(buf, sizeof(buf),
-      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-      "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">"
-      "<get-interface-information><terse/></get-interface-information>"
-      "</rpc>\n"
-      "]]>]]>\n%n", (int *)&len);
-    if(-1 == netconf_write(channel, buf, len))
-        goto shutdown;
-
-    fprintf(stderr, "Reading NETCONF <rpc-reply>\n");
-    len = netconf_read_until(channel, "</rpc-reply>", buf, sizeof(buf));
-    if(-1 == len)
-        goto shutdown;
-
-    fprintf(stderr, "Got %d bytes:\n----------------------\n%s",
-            (int)len, buf);
-
-shutdown:
-    if(channel)
-        libssh2_channel_free(channel);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/tcpip-forward.c b/libssh2/libssh2/example/tcpip-forward.c
deleted file mode 100644
index 51ca17ab..00000000
--- a/libssh2/libssh2/example/tcpip-forward.c
+++ /dev/null
@@ -1,328 +0,0 @@
-#include "libssh2_config.h"
-#include <libssh2.h>
-
-#ifdef WIN32
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#endif
-
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <sys/types.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-
-#ifndef INADDR_NONE
-#define INADDR_NONE (in_addr_t)-1
-#endif
-
-const char *keyfile1 = "/home/username/.ssh/id_rsa.pub";
-const char *keyfile2 = "/home/username/.ssh/id_rsa";
-const char *username = "username";
-const char *password = "";
-
-const char *server_ip = "127.0.0.1";
-
-const char *remote_listenhost = "localhost"; /* resolved by the server */
-int remote_wantport = 2222;
-int remote_listenport;
-
-const char *local_destip = "127.0.0.1";
-int local_destport = 22;
-
-enum {
-    AUTH_NONE = 0,
-    AUTH_PASSWORD,
-    AUTH_PUBLICKEY
-};
-
-int main(int argc, char *argv[])
-{
-    int rc, i, auth = AUTH_NONE;
-    struct sockaddr_in sin;
-    socklen_t sinlen = sizeof(sin);
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_LISTENER *listener = NULL;
-    LIBSSH2_CHANNEL *channel = NULL;
-    fd_set fds;
-    struct timeval tv;
-    ssize_t len, wr;
-    char buf[16384];
-
-#ifdef WIN32
-    SOCKET sock = INVALID_SOCKET, forwardsock = INVALID_SOCKET;
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return 1;
-    }
-#else
-    int sock = -1, forwardsock = -1;
-#endif
-
-    if(argc > 1)
-        server_ip = argv[1];
-    if(argc > 2)
-        username = argv[2];
-    if(argc > 3)
-        password = argv[3];
-    if(argc > 4)
-        remote_listenhost = argv[4];
-    if(argc > 5)
-        remote_wantport = atoi(argv[5]);
-    if(argc > 6)
-        local_destip = argv[6];
-    if(argc > 7)
-        local_destport = atoi(argv[7]);
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    /* Connect to SSH server */
-    sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(sock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open socket!\n");
-        return -1;
-    }
-#else
-    if(sock == -1) {
-        perror("socket");
-        return -1;
-    }
-#endif
-
-    sin.sin_family = AF_INET;
-    sin.sin_addr.s_addr = inet_addr(server_ip);
-    if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        return -1;
-    }
-    sin.sin_port = htons(22);
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return -1;
-    }
-
-    /* Create a session instance */
-    session = libssh2_session_init();
-    if(!session) {
-        fprintf(stderr, "Could not initialize SSH session!\n");
-        return -1;
-    }
-
-    /* ... start it up. This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    rc = libssh2_session_handshake(session, sock);
-    if(rc) {
-        fprintf(stderr, "Error when starting up SSH session: %d\n", rc);
-        return -1;
-    }
-
-    /* At this point we havn't yet authenticated.  The first thing to do
-     * is check the hostkey's fingerprint against our known hosts Your app
-     * may have it hard coded, may go to a file, may present it to the
-     * user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    fprintf(stderr, "Fingerprint: ");
-    for(i = 0; i < 20; i++)
-        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
-    fprintf(stderr, "\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    fprintf(stderr, "Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password"))
-        auth |= AUTH_PASSWORD;
-    if(strstr(userauthlist, "publickey"))
-        auth |= AUTH_PUBLICKEY;
-
-    /* check for options */
-    if(argc > 8) {
-        if((auth & AUTH_PASSWORD) && !strcasecmp(argv[8], "-p"))
-            auth = AUTH_PASSWORD;
-        if((auth & AUTH_PUBLICKEY) && !strcasecmp(argv[8], "-k"))
-            auth = AUTH_PUBLICKEY;
-    }
-
-    if(auth & AUTH_PASSWORD) {
-        if(libssh2_userauth_password(session, username, password)) {
-            fprintf(stderr, "Authentication by password failed.\n");
-            goto shutdown;
-        }
-    }
-    else if(auth & AUTH_PUBLICKEY) {
-        if(libssh2_userauth_publickey_fromfile(session, username, keyfile1,
-                                               keyfile2, password)) {
-            fprintf(stderr, "\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        fprintf(stderr, "\tAuthentication by public key succeeded.\n");
-    }
-    else {
-        fprintf(stderr, "No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "Asking server to listen on remote %s:%d\n",
-        remote_listenhost, remote_wantport);
-
-    listener = libssh2_channel_forward_listen_ex(session, remote_listenhost,
-        remote_wantport, &remote_listenport, 1);
-    if(!listener) {
-        fprintf(stderr, "Could not start the tcpip-forward listener!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "Server is listening on %s:%d\n", remote_listenhost,
-        remote_listenport);
-
-    fprintf(stderr, "Waiting for remote connection\n");
-    channel = libssh2_channel_forward_accept(listener);
-    if(!channel) {
-        fprintf(stderr, "Could not accept connection!\n"
-                "(Note that this can be a problem at the server!"
-                " Please review the server logs.)\n");
-        goto shutdown;
-    }
-
-    fprintf(stderr,
-        "Accepted remote connection. Connecting to local server %s:%d\n",
-        local_destip, local_destport);
-    forwardsock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-#ifdef WIN32
-    if(forwardsock == INVALID_SOCKET) {
-        fprintf(stderr, "failed to open forward socket!\n");
-        goto shutdown;
-    }
-#else
-    if(forwardsock == -1) {
-        perror("socket");
-        goto shutdown;
-    }
-#endif
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(local_destport);
-    sin.sin_addr.s_addr = inet_addr(local_destip);
-    if(INADDR_NONE == sin.sin_addr.s_addr) {
-        perror("inet_addr");
-        goto shutdown;
-    }
-    if(-1 == connect(forwardsock, (struct sockaddr *)&sin, sinlen)) {
-        perror("connect");
-        goto shutdown;
-    }
-
-    fprintf(stderr, "Forwarding connection from remote %s:%d to local %s:%d\n",
-        remote_listenhost, remote_listenport, local_destip, local_destport);
-
-    /* Must use non-blocking IO hereafter due to the current libssh2 API */
-    libssh2_session_set_blocking(session, 0);
-
-    while(1) {
-        FD_ZERO(&fds);
-        FD_SET(forwardsock, &fds);
-        tv.tv_sec = 0;
-        tv.tv_usec = 100000;
-        rc = select(forwardsock + 1, &fds, NULL, NULL, &tv);
-        if(-1 == rc) {
-            perror("select");
-            goto shutdown;
-        }
-        if(rc && FD_ISSET(forwardsock, &fds)) {
-            len = recv(forwardsock, buf, sizeof(buf), 0);
-            if(len < 0) {
-                perror("read");
-                goto shutdown;
-            }
-            else if(0 == len) {
-                fprintf(stderr, "The local server at %s:%d disconnected!\n",
-                    local_destip, local_destport);
-                goto shutdown;
-            }
-            wr = 0;
-            do {
-                i = libssh2_channel_write(channel, buf, len);
-                if(i < 0) {
-                    fprintf(stderr, "libssh2_channel_write: %d\n", i);
-                    goto shutdown;
-                }
-                wr += i;
-            } while(i > 0 && wr < len);
-        }
-        while(1) {
-            len = libssh2_channel_read(channel, buf, sizeof(buf));
-            if(LIBSSH2_ERROR_EAGAIN == len)
-                break;
-            else if(len < 0) {
-                fprintf(stderr, "libssh2_channel_read: %d", (int)len);
-                goto shutdown;
-            }
-            wr = 0;
-            while(wr < len) {
-                i = send(forwardsock, buf + wr, len - wr, 0);
-                if(i <= 0) {
-                    perror("write");
-                    goto shutdown;
-                }
-                wr += i;
-            }
-            if(libssh2_channel_eof(channel)) {
-                fprintf(stderr, "The remote client at %s:%d disconnected!\n",
-                    remote_listenhost, remote_listenport);
-                goto shutdown;
-            }
-        }
-    }
-
-shutdown:
-#ifdef WIN32
-    closesocket(forwardsock);
-#else
-    close(forwardsock);
-#endif
-    if(channel)
-        libssh2_channel_free(channel);
-    if(listener)
-        libssh2_channel_forward_cancel(listener);
-    libssh2_session_disconnect(session, "Client disconnecting normally");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    closesocket(sock);
-#else
-    close(sock);
-#endif
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/example/x11.c b/libssh2/libssh2/example/x11.c
deleted file mode 100644
index c49b64ea..00000000
--- a/libssh2/libssh2/example/x11.c
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
- *
- * Sample showing how to makes SSH2 with X11 Forwarding works.
- *
- * Usage :
- * "ssh2 host user password [DEBUG]"
- */
-
-#include <string.h>
-#include <sys/ioctl.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <sys/select.h>
-#include <arpa/inet.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <termios.h>
-
-#include <libssh2.h>
-
-#define _PATH_UNIX_X "/tmp/.X11-unix/X%d"
-
-/*
- * Chained list that contains channels and associated X11 socket for each X11
- * connections
- */
-struct chan_X11_list {
-    LIBSSH2_CHANNEL  *chan;
-    int               sock;
-    struct chan_X11_list *next;
-};
-
-struct chan_X11_list * gp_x11_chan = NULL;
-struct termios         _saved_tio;
-
-/*
- * Utility function to remove a Node of the chained list
- */
-static void remove_node(struct chan_X11_list *elem)
-{
-    struct chan_X11_list *current_node = NULL;
-
-    current_node = gp_x11_chan;
-
-    if(gp_x11_chan == elem) {
-        gp_x11_chan = gp_x11_chan->next;
-        free(current_node);
-        return;
-    }
-
-    while(current_node->next != NULL) {
-        if(current_node->next == elem) {
-            current_node->next = current_node->next->next;
-            current_node = current_node->next;
-            free(current_node);
-            break;
-        }
-    }
-}
-
-
-static void session_shutdown(LIBSSH2_SESSION *session)
-{
-    libssh2_session_disconnect(session,
-                                "Session Shutdown, Thank you for playing");
-    libssh2_session_free(session);
-}
-
-static int _raw_mode(void)
-{
-    int rc;
-    struct termios tio;
-
-    rc = tcgetattr(fileno(stdin), &tio);
-    if(rc != -1) {
-        _saved_tio = tio;
-        /* do the equivalent of cfmakeraw() manually, to build on Solaris */
-        tio.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
-        tio.c_oflag &= ~OPOST;
-        tio.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
-        tio.c_cflag &= ~(CSIZE|PARENB);
-        tio.c_cflag |= CS8;
-        rc = tcsetattr(fileno(stdin), TCSADRAIN, &tio);
-    }
-    return rc;
-}
-
-static int _normal_mode(void)
-{
-    int rc;
-    rc = tcsetattr(fileno(stdin), TCSADRAIN, &_saved_tio);
-    return rc;
-}
-
-/*
- * CallBack to initialize the forwarding.
- * Save the channel to loop on it, save the X11 forwarded socket to send
- * and receive info from our X server.
- */
-static void x11_callback(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel,
-                         char *shost, int sport, void **abstract)
-{
-    const char *display = NULL;
-    char *ptr          = NULL;
-    char *temp_buff    = NULL;
-    int   display_port = 0;
-    int   sock         = 0;
-    int   rc           = 0;
-    struct sockaddr_un addr;
-    struct chan_X11_list *new;
-    struct chan_X11_list *chan_iter;
-    (void)session;
-    (void)shost;
-    (void)sport;
-    (void)abstract;
-    /*
-     * Connect to the display
-     * Inspired by x11_connect_display in openssh
-     */
-    display = getenv("DISPLAY");
-    if(display != NULL) {
-        if(strncmp(display, "unix:", 5) == 0 ||
-            display[0] == ':') {
-            /* Connect to the local unix domain */
-            ptr = strrchr(display, ':');
-            temp_buff = (char *) calloc(strlen(ptr + 1), sizeof(char));
-            if(!temp_buff) {
-                perror("calloc");
-                return;
-            }
-            memcpy(temp_buff, ptr + 1, strlen(ptr + 1));
-            display_port = atoi(temp_buff);
-            free(temp_buff);
-
-            sock = socket(AF_UNIX, SOCK_STREAM, 0);
-            if(sock < 0)
-                return;
-            memset(&addr, 0, sizeof(addr));
-            addr.sun_family = AF_UNIX;
-            snprintf(addr.sun_path, sizeof(addr.sun_path),
-                     _PATH_UNIX_X, display_port);
-            rc = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
-
-            if(rc != -1) {
-                /* Connection Successfull */
-                if(gp_x11_chan == NULL) {
-                    /* Calloc ensure that gp_X11_chan is full of 0 */
-                    gp_x11_chan = (struct chan_X11_list *)
-                        calloc(1, sizeof(struct chan_X11_list));
-                    gp_x11_chan->sock = sock;
-                    gp_x11_chan->chan = channel;
-                    gp_x11_chan->next = NULL;
-                }
-                else {
-                    chan_iter = gp_x11_chan;
-                    while(chan_iter->next != NULL)
-                        chan_iter = chan_iter->next;
-                    /* Create the new Node */
-                    new = (struct chan_X11_list *)
-                        malloc(sizeof(struct chan_X11_list));
-                    new->sock = sock;
-                    new->chan = channel;
-                    new->next = NULL;
-                    chan_iter->next = new;
-                }
-            }
-            else
-                close(sock);
-        }
-    }
-    return;
-}
-
-/*
- * Send and receive Data for the X11 channel.
- * If the connection is closed, returns -1, 0 either.
- */
-static int x11_send_receive(LIBSSH2_CHANNEL *channel, int sock)
-{
-    char *buf          = NULL;
-    int   bufsize      = 8192;
-    int   rc           = 0;
-    int   nfds         = 1;
-    LIBSSH2_POLLFD  *fds      = NULL;
-    fd_set set;
-    struct timeval timeval_out;
-    timeval_out.tv_sec = 0;
-    timeval_out.tv_usec = 0;
-
-
-    FD_ZERO(&set);
-    FD_SET(sock, &set);
-
-    buf = calloc(bufsize, sizeof(char));
-    if(!buf)
-        return 0;
-
-    fds = malloc(sizeof (LIBSSH2_POLLFD));
-    if(!fds) {
-        free(buf);
-        return 0;
-    }
-
-    fds[0].type = LIBSSH2_POLLFD_CHANNEL;
-    fds[0].fd.channel = channel;
-    fds[0].events = LIBSSH2_POLLFD_POLLIN;
-    fds[0].revents = LIBSSH2_POLLFD_POLLIN;
-
-    rc = libssh2_poll(fds, nfds, 0);
-    if(rc >0) {
-        rc = libssh2_channel_read(channel, buf, bufsize);
-        write(sock, buf, rc);
-    }
-
-    rc = select(sock + 1, &set, NULL, NULL, &timeval_out);
-    if(rc > 0) {
-        memset((void *)buf, 0, bufsize);
-
-        /* Data in sock*/
-        rc = read(sock, buf, bufsize);
-        if(rc > 0) {
-            libssh2_channel_write(channel, buf, rc);
-        }
-        else {
-            free(buf);
-            return -1;
-        }
-    }
-
-    free(fds);
-    free(buf);
-    if(libssh2_channel_eof(channel) == 1) {
-        return -1;
-    }
-    return 0;
-}
-
-/*
- * Main, more than inspired by ssh2.c by Bagder
- */
-int
-main (int argc, char *argv[])
-{
-    unsigned long hostaddr = 0;
-    int sock = 0;
-    int rc = 0;
-    struct sockaddr_in sin;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    char *username = NULL;
-    char *password = NULL;
-    size_t bufsiz = 8193;
-    char *buf = NULL;
-    int set_debug_on = 0;
-    int nfds = 1;
-    LIBSSH2_POLLFD *fds = NULL;
-
-    /* Chan List struct */
-    struct chan_X11_list *current_node = NULL;
-
-    /* Struct winsize for term size */
-    struct winsize w_size;
-    struct winsize w_size_bck;
-
-    /* For select on stdin */
-    fd_set set;
-    struct timeval timeval_out;
-    timeval_out.tv_sec = 0;
-    timeval_out.tv_usec = 10;
-
-
-    if(argc > 3) {
-        hostaddr = inet_addr(argv[1]);
-        username = argv[2];
-        password = argv[3];
-    }
-    else {
-        fprintf(stderr, "Usage: %s destination username password",
-                argv[0]);
-        return -1;
-    }
-
-    if(argc > 4) {
-        set_debug_on = 1;
-        fprintf(stderr, "DEBUG is ON: %d\n", set_debug_on);
-    }
-
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-        return 1;
-    }
-
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock == -1) {
-        perror("socket");
-        return -1;
-    }
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(22);
-    sin.sin_addr.s_addr = hostaddr;
-
-    rc = connect(sock, (struct sockaddr *) &sin,
-                 sizeof(struct sockaddr_in));
-    if(rc != 0) {
-        fprintf(stderr, "Failed to established connection!\n");
-        return -1;
-    }
-    /* Open a session */
-    session = libssh2_session_init();
-    rc      = libssh2_session_handshake(session, sock);
-    if(rc != 0) {
-        fprintf(stderr, "Failed Start the SSH session\n");
-        return -1;
-    }
-
-    if(set_debug_on == 1)
-        libssh2_trace(session, LIBSSH2_TRACE_CONN);
-
-    /* ignore pedantic warnings by gcc on the callback argument */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-    /* Set X11 Callback */
-    libssh2_session_callback_set(session, LIBSSH2_CALLBACK_X11,
-                                 (void *)x11_callback);
-#pragma GCC diagnostic pop
-
-    /* Authenticate via password */
-    rc = libssh2_userauth_password(session, username, password);
-    if(rc != 0) {
-        fprintf(stderr, "Failed to authenticate\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-    /* Open a channel */
-    channel  = libssh2_channel_open_session(session);
-    if(channel == NULL) {
-        fprintf(stderr, "Failed to open a new channel\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-
-    /* Request a PTY */
-    rc = libssh2_channel_request_pty(channel, "xterm");
-    if(rc != 0) {
-        fprintf(stderr, "Failed to request a pty\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-    /* Request X11 */
-    rc = libssh2_channel_x11_req(channel, 0);
-    if(rc != 0) {
-        fprintf(stderr, "Failed to request X11 forwarding\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-    /* Request a shell */
-    rc = libssh2_channel_shell(channel);
-    if(rc != 0) {
-        fprintf(stderr, "Failed to open a shell\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-    rc = _raw_mode();
-    if(rc != 0) {
-        fprintf(stderr, "Failed to entered in raw mode\n");
-        session_shutdown(session);
-        close(sock);
-        return -1;
-    }
-
-    memset(&w_size, 0, sizeof(struct winsize));
-    memset(&w_size_bck, 0, sizeof(struct winsize));
-
-    while(1) {
-
-        FD_ZERO(&set);
-        FD_SET(fileno(stdin), &set);
-
-        /* Search if a resize pty has to be send */
-        ioctl(fileno(stdin), TIOCGWINSZ, &w_size);
-        if((w_size.ws_row != w_size_bck.ws_row) ||
-           (w_size.ws_col != w_size_bck.ws_col)) {
-            w_size_bck = w_size;
-
-            libssh2_channel_request_pty_size(channel,
-                                             w_size.ws_col,
-                                             w_size.ws_row);
-        }
-
-        buf = calloc(bufsiz, sizeof(char));
-        if(buf == NULL)
-            break;
-
-        fds = malloc(sizeof (LIBSSH2_POLLFD));
-        if(fds == NULL) {
-            free(buf);
-            break;
-        }
-
-        fds[0].type = LIBSSH2_POLLFD_CHANNEL;
-        fds[0].fd.channel = channel;
-        fds[0].events = LIBSSH2_POLLFD_POLLIN;
-        fds[0].revents = LIBSSH2_POLLFD_POLLIN;
-
-        rc = libssh2_poll(fds, nfds, 0);
-        if(rc >0) {
-            libssh2_channel_read(channel, buf, sizeof(buf));
-            fprintf(stdout, "%s", buf);
-            fflush(stdout);
-        }
-
-        /* Looping on X clients */
-        if(gp_x11_chan != NULL) {
-            current_node = gp_x11_chan;
-        }
-        else
-            current_node = NULL;
-
-        while(current_node != NULL) {
-            struct chan_X11_list *next_node;
-            rc = x11_send_receive(current_node->chan, current_node->sock);
-            next_node = current_node->next;
-            if(rc == -1) {
-                shutdown(current_node->sock, SHUT_RDWR);
-                close(current_node->sock);
-                remove_node(current_node);
-            }
-
-            current_node = next_node;
-        }
-
-
-        rc = select(fileno(stdin) + 1, &set, NULL, NULL, &timeval_out);
-        if(rc > 0) {
-            /* Data in stdin*/
-            rc = read(fileno(stdin), buf, 1);
-            if(rc > 0)
-                libssh2_channel_write(channel, buf, sizeof(buf));
-        }
-
-        free(fds);
-        free(buf);
-
-        if(libssh2_channel_eof (channel) == 1) {
-            break;
-        }
-    }
-
-    if(channel) {
-        libssh2_channel_free(channel);
-        channel = NULL;
-    }
-    _normal_mode();
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/libssh2/get_ver.awk b/libssh2/libssh2/get_ver.awk
deleted file mode 100755
index 8253168e..00000000
--- a/libssh2/libssh2/get_ver.awk
+++ /dev/null
@@ -1,24 +0,0 @@
-# fetch libssh2 version number from input file and write them to STDOUT
-BEGIN {
-  while ((getline < ARGV[1]) > 0) {
-    if (match ($0, /^#define LIBSSH2_COPYRIGHT "[^"]+"$/)) {
-      my_copyright_str = substr($0, 28, length($0)-28);
-    }
-    else if (match ($0, /^#define LIBSSH2_VERSION[ |\t]+"[^"]+"/)) {
-      my_ver_str = substr($3, 2, length($3) - 2);
-      split(my_ver_str, v, ".");
-      if (v[3])
-        gsub("[^0-9].*$", "", v[3]);
-      else
-        v[3] = 0;
-      if (v[2])
-        gsub("[^0-9].*$", "", v[2]);
-      else
-        v[2] = 0;
-      my_ver = v[1] "," v[2] "," v[3];
-    }
-  }
-  print "LIBSSH2_VERSION = " my_ver "";
-  print "LIBSSH2_VERSION_STR = " my_ver_str "";
-  print "LIBSSH2_COPYRIGHT_STR = " my_copyright_str "";
-}
diff --git a/libssh2/libssh2/include/libssh2.h b/libssh2/libssh2/include/libssh2.h
deleted file mode 100644
index 995d83ed..00000000
--- a/libssh2/libssh2/include/libssh2.h
+++ /dev/null
@@ -1,1349 +0,0 @@
-/* Copyright (c) 2004-2009, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2015 Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_H
-#define LIBSSH2_H 1
-
-#define LIBSSH2_COPYRIGHT "2004-2019 The libssh2 project and its contributors."
-
-/* We use underscore instead of dash when appending DEV in dev versions just
-   to make the BANNER define (used by src/session.c) be a valid SSH
-   banner. Release versions have no appended strings and may of course not
-   have dashes either. */
-#define LIBSSH2_VERSION "1.10.0"
-
-/* The numeric version number is also available "in parts" by using these
-   defines: */
-#define LIBSSH2_VERSION_MAJOR 1
-#define LIBSSH2_VERSION_MINOR 10
-#define LIBSSH2_VERSION_PATCH 0
-
-/* This is the numeric version of the libssh2 version number, meant for easier
-   parsing and comparions by programs. The LIBSSH2_VERSION_NUM define will
-   always follow this syntax:
-
-         0xXXYYZZ
-
-   Where XX, YY and ZZ are the main version, release and patch numbers in
-   hexadecimal (using 8 bits each). All three numbers are always represented
-   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
-   appears as "0x090b07".
-
-   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
-   and it is always a greater number in a more recent release. It makes
-   comparisons with greater than and less than work.
-*/
-#define LIBSSH2_VERSION_NUM 0x010a00
-
-/*
- * This is the date and time when the full source package was created. The
- * timestamp is not stored in the source code repo, as the timestamp is
- * properly set in the tarballs by the maketgz script.
- *
- * The format of the date should follow this template:
- *
- * "Mon Feb 12 11:35:33 UTC 2007"
- */
-#define LIBSSH2_TIMESTAMP "Sun 29 Aug 2021 08:37:50 PM UTC"
-
-#ifndef RC_INVOKED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#ifdef _WIN32
-# include <basetsd.h>
-# include <winsock2.h>
-#endif
-
-#include <stddef.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-/* Allow alternate API prefix from CFLAGS or calling app */
-#ifndef LIBSSH2_API
-# ifdef LIBSSH2_WIN32
-#  ifdef _WINDLL
-#   ifdef LIBSSH2_LIBRARY
-#    define LIBSSH2_API __declspec(dllexport)
-#   else
-#    define LIBSSH2_API __declspec(dllimport)
-#   endif /* LIBSSH2_LIBRARY */
-#  else
-#   define LIBSSH2_API
-#  endif
-# else /* !LIBSSH2_WIN32 */
-#  define LIBSSH2_API
-# endif /* LIBSSH2_WIN32 */
-#endif /* LIBSSH2_API */
-
-#ifdef HAVE_SYS_UIO_H
-# include <sys/uio.h>
-#endif
-
-#if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
-# include <sys/bsdskt.h>
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-typedef unsigned int uint32_t;
-typedef int int32_t;
-typedef unsigned long long uint64_t;
-typedef long long int64_t;
-#endif
-
-#ifdef _MSC_VER
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-typedef unsigned int uint32_t;
-typedef __int32 int32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-typedef unsigned __int64 libssh2_uint64_t;
-typedef __int64 libssh2_int64_t;
-#if (!defined(HAVE_SSIZE_T) && !defined(ssize_t))
-typedef SSIZE_T ssize_t;
-#define HAVE_SSIZE_T
-#endif
-#else
-#include <stdint.h>
-typedef unsigned long long libssh2_uint64_t;
-typedef long long libssh2_int64_t;
-#endif
-
-#ifdef WIN32
-typedef SOCKET libssh2_socket_t;
-#define LIBSSH2_INVALID_SOCKET INVALID_SOCKET
-#else /* !WIN32 */
-typedef int libssh2_socket_t;
-#define LIBSSH2_INVALID_SOCKET -1
-#endif /* WIN32 */
-
-/*
- * Determine whether there is small or large file support on windows.
- */
-
-#if defined(_MSC_VER) && !defined(_WIN32_WCE)
-#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
-#    define LIBSSH2_USE_WIN32_LARGE_FILES
-#  else
-#    define LIBSSH2_USE_WIN32_SMALL_FILES
-#  endif
-#endif
-
-#if defined(__MINGW32__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES)
-#  define LIBSSH2_USE_WIN32_LARGE_FILES
-#endif
-
-#if defined(__WATCOMC__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES)
-#  define LIBSSH2_USE_WIN32_LARGE_FILES
-#endif
-
-#if defined(__POCC__)
-#  undef LIBSSH2_USE_WIN32_LARGE_FILES
-#endif
-
-#if defined(_WIN32) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES) && \
-    !defined(LIBSSH2_USE_WIN32_SMALL_FILES)
-#  define LIBSSH2_USE_WIN32_SMALL_FILES
-#endif
-
-/*
- * Large file (>2Gb) support using WIN32 functions.
- */
-
-#ifdef LIBSSH2_USE_WIN32_LARGE_FILES
-#  include <io.h>
-#  include <sys/types.h>
-#  include <sys/stat.h>
-#  define LIBSSH2_STRUCT_STAT_SIZE_FORMAT    "%I64d"
-typedef struct _stati64 libssh2_struct_stat;
-typedef __int64 libssh2_struct_stat_size;
-#endif
-
-/*
- * Small file (<2Gb) support using WIN32 functions.
- */
-
-#ifdef LIBSSH2_USE_WIN32_SMALL_FILES
-#  include <sys/types.h>
-#  include <sys/stat.h>
-#  ifndef _WIN32_WCE
-#    define LIBSSH2_STRUCT_STAT_SIZE_FORMAT    "%d"
-typedef struct _stat libssh2_struct_stat;
-typedef off_t libssh2_struct_stat_size;
-#  endif
-#endif
-
-#ifndef LIBSSH2_STRUCT_STAT_SIZE_FORMAT
-#  ifdef __VMS
-/* We have to roll our own format here because %z is a C99-ism we don't
-   have. */
-#    if __USE_OFF64_T || __USING_STD_STAT
-#      define LIBSSH2_STRUCT_STAT_SIZE_FORMAT      "%Ld"
-#    else
-#      define LIBSSH2_STRUCT_STAT_SIZE_FORMAT      "%d"
-#    endif
-#  else
-#    define LIBSSH2_STRUCT_STAT_SIZE_FORMAT      "%zd"
-#  endif
-typedef struct stat libssh2_struct_stat;
-typedef off_t libssh2_struct_stat_size;
-#endif
-
-/* Part of every banner, user specified or not */
-#define LIBSSH2_SSH_BANNER                  "SSH-2.0-libssh2_" LIBSSH2_VERSION
-
-#define LIBSSH2_SSH_DEFAULT_BANNER            LIBSSH2_SSH_BANNER
-#define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF  LIBSSH2_SSH_DEFAULT_BANNER "\r\n"
-
-/* Default generate and safe prime sizes for
-   diffie-hellman-group-exchange-sha1 */
-#define LIBSSH2_DH_GEX_MINGROUP     2048
-#define LIBSSH2_DH_GEX_OPTGROUP     4096
-#define LIBSSH2_DH_GEX_MAXGROUP     8192
-
-#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
-
-/* Defaults for pty requests */
-#define LIBSSH2_TERM_WIDTH      80
-#define LIBSSH2_TERM_HEIGHT     24
-#define LIBSSH2_TERM_WIDTH_PX   0
-#define LIBSSH2_TERM_HEIGHT_PX  0
-
-/* 1/4 second */
-#define LIBSSH2_SOCKET_POLL_UDELAY      250000
-/* 0.25 * 120 == 30 seconds */
-#define LIBSSH2_SOCKET_POLL_MAXLOOPS    120
-
-/* Maximum size to allow a payload to compress to, plays it safe by falling
-   short of spec limits */
-#define LIBSSH2_PACKET_MAXCOMP      32000
-
-/* Maximum size to allow a payload to deccompress to, plays it safe by
-   allowing more than spec requires */
-#define LIBSSH2_PACKET_MAXDECOMP    40000
-
-/* Maximum size for an inbound compressed payload, plays it safe by
-   overshooting spec limits */
-#define LIBSSH2_PACKET_MAXPAYLOAD   40000
-
-/* Malloc callbacks */
-#define LIBSSH2_ALLOC_FUNC(name)   void *name(size_t count, void **abstract)
-#define LIBSSH2_REALLOC_FUNC(name) void *name(void *ptr, size_t count, \
-                                              void **abstract)
-#define LIBSSH2_FREE_FUNC(name)    void name(void *ptr, void **abstract)
-
-typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT
-{
-    char *text;
-    unsigned int length;
-    unsigned char echo;
-} LIBSSH2_USERAUTH_KBDINT_PROMPT;
-
-typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
-{
-    char *text;
-    unsigned int length;
-} LIBSSH2_USERAUTH_KBDINT_RESPONSE;
-
-/* 'publickey' authentication callback */
-#define LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC(name) \
-  int name(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, \
-           const unsigned char *data, size_t data_len, void **abstract)
-
-/* 'keyboard-interactive' authentication callback */
-#define LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(name_) \
- void name_(const char *name, int name_len, const char *instruction, \
-            int instruction_len, int num_prompts, \
-            const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,              \
-            LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses, void **abstract)
-
-/* Callbacks for special SSH packets */
-#define LIBSSH2_IGNORE_FUNC(name) \
- void name(LIBSSH2_SESSION *session, const char *message, int message_len, \
-           void **abstract)
-
-#define LIBSSH2_DEBUG_FUNC(name) \
- void name(LIBSSH2_SESSION *session, int always_display, const char *message, \
-           int message_len, const char *language, int language_len, \
-           void **abstract)
-
-#define LIBSSH2_DISCONNECT_FUNC(name) \
- void name(LIBSSH2_SESSION *session, int reason, const char *message, \
-           int message_len, const char *language, int language_len, \
-           void **abstract)
-
-#define LIBSSH2_PASSWD_CHANGEREQ_FUNC(name) \
- void name(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, \
-           void **abstract)
-
-#define LIBSSH2_MACERROR_FUNC(name) \
- int name(LIBSSH2_SESSION *session, const char *packet, int packet_len, \
-          void **abstract)
-
-#define LIBSSH2_X11_OPEN_FUNC(name) \
- void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, \
-           const char *shost, int sport, void **abstract)
-
-#define LIBSSH2_CHANNEL_CLOSE_FUNC(name) \
-  void name(LIBSSH2_SESSION *session, void **session_abstract, \
-            LIBSSH2_CHANNEL *channel, void **channel_abstract)
-
-/* I/O callbacks */
-#define LIBSSH2_RECV_FUNC(name)                                         \
-    ssize_t name(libssh2_socket_t socket,                               \
-                 void *buffer, size_t length,                           \
-                 int flags, void **abstract)
-#define LIBSSH2_SEND_FUNC(name)                                         \
-    ssize_t name(libssh2_socket_t socket,                               \
-                 const void *buffer, size_t length,                     \
-                 int flags, void **abstract)
-
-/* libssh2_session_callback_set() constants */
-#define LIBSSH2_CALLBACK_IGNORE             0
-#define LIBSSH2_CALLBACK_DEBUG              1
-#define LIBSSH2_CALLBACK_DISCONNECT         2
-#define LIBSSH2_CALLBACK_MACERROR           3
-#define LIBSSH2_CALLBACK_X11                4
-#define LIBSSH2_CALLBACK_SEND               5
-#define LIBSSH2_CALLBACK_RECV               6
-
-/* libssh2_session_method_pref() constants */
-#define LIBSSH2_METHOD_KEX          0
-#define LIBSSH2_METHOD_HOSTKEY      1
-#define LIBSSH2_METHOD_CRYPT_CS     2
-#define LIBSSH2_METHOD_CRYPT_SC     3
-#define LIBSSH2_METHOD_MAC_CS       4
-#define LIBSSH2_METHOD_MAC_SC       5
-#define LIBSSH2_METHOD_COMP_CS      6
-#define LIBSSH2_METHOD_COMP_SC      7
-#define LIBSSH2_METHOD_LANG_CS      8
-#define LIBSSH2_METHOD_LANG_SC      9
-
-/* flags */
-#define LIBSSH2_FLAG_SIGPIPE        1
-#define LIBSSH2_FLAG_COMPRESS       2
-
-typedef struct _LIBSSH2_SESSION                     LIBSSH2_SESSION;
-typedef struct _LIBSSH2_CHANNEL                     LIBSSH2_CHANNEL;
-typedef struct _LIBSSH2_LISTENER                    LIBSSH2_LISTENER;
-typedef struct _LIBSSH2_KNOWNHOSTS                  LIBSSH2_KNOWNHOSTS;
-typedef struct _LIBSSH2_AGENT                       LIBSSH2_AGENT;
-
-typedef struct _LIBSSH2_POLLFD {
-    unsigned char type; /* LIBSSH2_POLLFD_* below */
-
-    union {
-        libssh2_socket_t socket; /* File descriptors -- examined with
-                                    system select() call */
-        LIBSSH2_CHANNEL *channel; /* Examined by checking internal state */
-        LIBSSH2_LISTENER *listener; /* Read polls only -- are inbound
-                                       connections waiting to be accepted? */
-    } fd;
-
-    unsigned long events; /* Requested Events */
-    unsigned long revents; /* Returned Events */
-} LIBSSH2_POLLFD;
-
-/* Poll FD Descriptor Types */
-#define LIBSSH2_POLLFD_SOCKET       1
-#define LIBSSH2_POLLFD_CHANNEL      2
-#define LIBSSH2_POLLFD_LISTENER     3
-
-/* Note: Win32 Doesn't actually have a poll() implementation, so some of these
-   values are faked with select() data */
-/* Poll FD events/revents -- Match sys/poll.h where possible */
-#define LIBSSH2_POLLFD_POLLIN           0x0001 /* Data available to be read or
-                                                  connection available --
-                                                  All */
-#define LIBSSH2_POLLFD_POLLPRI          0x0002 /* Priority data available to
-                                                  be read -- Socket only */
-#define LIBSSH2_POLLFD_POLLEXT          0x0002 /* Extended data available to
-                                                  be read -- Channel only */
-#define LIBSSH2_POLLFD_POLLOUT          0x0004 /* Can may be written --
-                                                  Socket/Channel */
-/* revents only */
-#define LIBSSH2_POLLFD_POLLERR          0x0008 /* Error Condition -- Socket */
-#define LIBSSH2_POLLFD_POLLHUP          0x0010 /* HangUp/EOF -- Socket */
-#define LIBSSH2_POLLFD_SESSION_CLOSED   0x0010 /* Session Disconnect */
-#define LIBSSH2_POLLFD_POLLNVAL         0x0020 /* Invalid request -- Socket
-                                                  Only */
-#define LIBSSH2_POLLFD_POLLEX           0x0040 /* Exception Condition --
-                                                  Socket/Win32 */
-#define LIBSSH2_POLLFD_CHANNEL_CLOSED   0x0080 /* Channel Disconnect */
-#define LIBSSH2_POLLFD_LISTENER_CLOSED  0x0080 /* Listener Disconnect */
-
-#define HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
-/* Block Direction Types */
-#define LIBSSH2_SESSION_BLOCK_INBOUND                  0x0001
-#define LIBSSH2_SESSION_BLOCK_OUTBOUND                 0x0002
-
-/* Hash Types */
-#define LIBSSH2_HOSTKEY_HASH_MD5                            1
-#define LIBSSH2_HOSTKEY_HASH_SHA1                           2
-#define LIBSSH2_HOSTKEY_HASH_SHA256                         3
-
-/* Hostkey Types */
-#define LIBSSH2_HOSTKEY_TYPE_UNKNOWN            0
-#define LIBSSH2_HOSTKEY_TYPE_RSA                1
-#define LIBSSH2_HOSTKEY_TYPE_DSS                2
-#define LIBSSH2_HOSTKEY_TYPE_ECDSA_256          3
-#define LIBSSH2_HOSTKEY_TYPE_ECDSA_384          4
-#define LIBSSH2_HOSTKEY_TYPE_ECDSA_521          5
-#define LIBSSH2_HOSTKEY_TYPE_ED25519            6
-
-/* Disconnect Codes (defined by SSH protocol) */
-#define SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT          1
-#define SSH_DISCONNECT_PROTOCOL_ERROR                       2
-#define SSH_DISCONNECT_KEY_EXCHANGE_FAILED                  3
-#define SSH_DISCONNECT_RESERVED                             4
-#define SSH_DISCONNECT_MAC_ERROR                            5
-#define SSH_DISCONNECT_COMPRESSION_ERROR                    6
-#define SSH_DISCONNECT_SERVICE_NOT_AVAILABLE                7
-#define SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED       8
-#define SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE              9
-#define SSH_DISCONNECT_CONNECTION_LOST                      10
-#define SSH_DISCONNECT_BY_APPLICATION                       11
-#define SSH_DISCONNECT_TOO_MANY_CONNECTIONS                 12
-#define SSH_DISCONNECT_AUTH_CANCELLED_BY_USER               13
-#define SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE       14
-#define SSH_DISCONNECT_ILLEGAL_USER_NAME                    15
-
-/* Error Codes (defined by libssh2) */
-#define LIBSSH2_ERROR_NONE                      0
-
-/* The library once used -1 as a generic error return value on numerous places
-   through the code, which subsequently was converted to
-   LIBSSH2_ERROR_SOCKET_NONE uses over time. As this is a generic error code,
-   the goal is to never ever return this code but instead make sure that a
-   more accurate and descriptive error code is used. */
-#define LIBSSH2_ERROR_SOCKET_NONE               -1
-
-#define LIBSSH2_ERROR_BANNER_RECV               -2
-#define LIBSSH2_ERROR_BANNER_SEND               -3
-#define LIBSSH2_ERROR_INVALID_MAC               -4
-#define LIBSSH2_ERROR_KEX_FAILURE               -5
-#define LIBSSH2_ERROR_ALLOC                     -6
-#define LIBSSH2_ERROR_SOCKET_SEND               -7
-#define LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE      -8
-#define LIBSSH2_ERROR_TIMEOUT                   -9
-#define LIBSSH2_ERROR_HOSTKEY_INIT              -10
-#define LIBSSH2_ERROR_HOSTKEY_SIGN              -11
-#define LIBSSH2_ERROR_DECRYPT                   -12
-#define LIBSSH2_ERROR_SOCKET_DISCONNECT         -13
-#define LIBSSH2_ERROR_PROTO                     -14
-#define LIBSSH2_ERROR_PASSWORD_EXPIRED          -15
-#define LIBSSH2_ERROR_FILE                      -16
-#define LIBSSH2_ERROR_METHOD_NONE               -17
-#define LIBSSH2_ERROR_AUTHENTICATION_FAILED     -18
-#define LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED    \
-    LIBSSH2_ERROR_AUTHENTICATION_FAILED
-#define LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED      -19
-#define LIBSSH2_ERROR_CHANNEL_OUTOFORDER        -20
-#define LIBSSH2_ERROR_CHANNEL_FAILURE           -21
-#define LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED    -22
-#define LIBSSH2_ERROR_CHANNEL_UNKNOWN           -23
-#define LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED   -24
-#define LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED   -25
-#define LIBSSH2_ERROR_CHANNEL_CLOSED            -26
-#define LIBSSH2_ERROR_CHANNEL_EOF_SENT          -27
-#define LIBSSH2_ERROR_SCP_PROTOCOL              -28
-#define LIBSSH2_ERROR_ZLIB                      -29
-#define LIBSSH2_ERROR_SOCKET_TIMEOUT            -30
-#define LIBSSH2_ERROR_SFTP_PROTOCOL             -31
-#define LIBSSH2_ERROR_REQUEST_DENIED            -32
-#define LIBSSH2_ERROR_METHOD_NOT_SUPPORTED      -33
-#define LIBSSH2_ERROR_INVAL                     -34
-#define LIBSSH2_ERROR_INVALID_POLL_TYPE         -35
-#define LIBSSH2_ERROR_PUBLICKEY_PROTOCOL        -36
-#define LIBSSH2_ERROR_EAGAIN                    -37
-#define LIBSSH2_ERROR_BUFFER_TOO_SMALL          -38
-#define LIBSSH2_ERROR_BAD_USE                   -39
-#define LIBSSH2_ERROR_COMPRESS                  -40
-#define LIBSSH2_ERROR_OUT_OF_BOUNDARY           -41
-#define LIBSSH2_ERROR_AGENT_PROTOCOL            -42
-#define LIBSSH2_ERROR_SOCKET_RECV               -43
-#define LIBSSH2_ERROR_ENCRYPT                   -44
-#define LIBSSH2_ERROR_BAD_SOCKET                -45
-#define LIBSSH2_ERROR_KNOWN_HOSTS               -46
-#define LIBSSH2_ERROR_CHANNEL_WINDOW_FULL       -47
-#define LIBSSH2_ERROR_KEYFILE_AUTH_FAILED       -48
-#define LIBSSH2_ERROR_RANDGEN                   -49
-
-/* this is a define to provide the old (<= 1.2.7) name */
-#define LIBSSH2_ERROR_BANNER_NONE LIBSSH2_ERROR_BANNER_RECV
-
-/* Global API */
-#define LIBSSH2_INIT_NO_CRYPTO        0x0001
-
-/*
- * libssh2_init()
- *
- * Initialize the libssh2 functions.  This typically initialize the
- * crypto library.  It uses a global state, and is not thread safe --
- * you must make sure this function is not called concurrently.
- *
- * Flags can be:
- * 0:                              Normal initialize
- * LIBSSH2_INIT_NO_CRYPTO:         Do not initialize the crypto library (ie.
- *                                 OPENSSL_add_cipher_algoritms() for OpenSSL
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int libssh2_init(int flags);
-
-/*
- * libssh2_exit()
- *
- * Exit the libssh2 functions and free's all memory used internal.
- */
-LIBSSH2_API void libssh2_exit(void);
-
-/*
- * libssh2_free()
- *
- * Deallocate memory allocated by earlier call to libssh2 functions.
- */
-LIBSSH2_API void libssh2_free(LIBSSH2_SESSION *session, void *ptr);
-
-/*
- * libssh2_session_supported_algs()
- *
- * Fills algs with a list of supported acryptographic algorithms. Returns a
- * non-negative number (number of supported algorithms) on success or a
- * negative number (an error code) on failure.
- *
- * NOTE: on success, algs must be deallocated (by calling libssh2_free) when
- * not needed anymore
- */
-LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
-                                               int method_type,
-                                               const char ***algs);
-
-/* Session API */
-LIBSSH2_API LIBSSH2_SESSION *
-libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
-                        LIBSSH2_FREE_FUNC((*my_free)),
-                        LIBSSH2_REALLOC_FUNC((*my_realloc)), void *abstract);
-#define libssh2_session_init() libssh2_session_init_ex(NULL, NULL, NULL, NULL)
-
-LIBSSH2_API void **libssh2_session_abstract(LIBSSH2_SESSION *session);
-
-LIBSSH2_API void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
-                                               int cbtype, void *callback);
-LIBSSH2_API int libssh2_session_banner_set(LIBSSH2_SESSION *session,
-                                           const char *banner);
-LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION *session,
-                                   const char *banner);
-
-LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int sock);
-LIBSSH2_API int libssh2_session_handshake(LIBSSH2_SESSION *session,
-                                          libssh2_socket_t sock);
-LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session,
-                                              int reason,
-                                              const char *description,
-                                              const char *lang);
-#define libssh2_session_disconnect(session, description) \
-  libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, \
-                                (description), "")
-
-LIBSSH2_API int libssh2_session_free(LIBSSH2_SESSION *session);
-
-LIBSSH2_API const char *libssh2_hostkey_hash(LIBSSH2_SESSION *session,
-                                             int hash_type);
-
-LIBSSH2_API const char *libssh2_session_hostkey(LIBSSH2_SESSION *session,
-                                                size_t *len, int *type);
-
-LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session,
-                                            int method_type,
-                                            const char *prefs);
-LIBSSH2_API const char *libssh2_session_methods(LIBSSH2_SESSION *session,
-                                                int method_type);
-LIBSSH2_API int libssh2_session_last_error(LIBSSH2_SESSION *session,
-                                           char **errmsg,
-                                           int *errmsg_len, int want_buf);
-LIBSSH2_API int libssh2_session_last_errno(LIBSSH2_SESSION *session);
-LIBSSH2_API int libssh2_session_set_last_error(LIBSSH2_SESSION* session,
-                                               int errcode,
-                                               const char *errmsg);
-LIBSSH2_API int libssh2_session_block_directions(LIBSSH2_SESSION *session);
-
-LIBSSH2_API int libssh2_session_flag(LIBSSH2_SESSION *session, int flag,
-                                     int value);
-LIBSSH2_API const char *libssh2_session_banner_get(LIBSSH2_SESSION *session);
-
-/* Userauth API */
-LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session,
-                                        const char *username,
-                                        unsigned int username_len);
-LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
-
-LIBSSH2_API int
-libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
-                             const char *username,
-                             unsigned int username_len,
-                             const char *password,
-                             unsigned int password_len,
-                             LIBSSH2_PASSWD_CHANGEREQ_FUNC
-                             ((*passwd_change_cb)));
-
-#define libssh2_userauth_password(session, username, password) \
- libssh2_userauth_password_ex((session), (username),           \
-                              (unsigned int)strlen(username),  \
-                              (password), (unsigned int)strlen(password), NULL)
-
-LIBSSH2_API int
-libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
-                                       const char *username,
-                                       unsigned int username_len,
-                                       const char *publickey,
-                                       const char *privatekey,
-                                       const char *passphrase);
-
-#define libssh2_userauth_publickey_fromfile(session, username, publickey, \
-                                            privatekey, passphrase)     \
-    libssh2_userauth_publickey_fromfile_ex((session), (username),       \
-                                           (unsigned int)strlen(username), \
-                                           (publickey),                 \
-                                           (privatekey), (passphrase))
-
-LIBSSH2_API int
-libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                           const char *username,
-                           const unsigned char *pubkeydata,
-                           size_t pubkeydata_len,
-                           LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                           ((*sign_callback)),
-                           void **abstract);
-
-LIBSSH2_API int
-libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
-                                       const char *username,
-                                       unsigned int username_len,
-                                       const char *publickey,
-                                       const char *privatekey,
-                                       const char *passphrase,
-                                       const char *hostname,
-                                       unsigned int hostname_len,
-                                       const char *local_username,
-                                       unsigned int local_username_len);
-
-#define libssh2_userauth_hostbased_fromfile(session, username, publickey, \
-                                            privatekey, passphrase, hostname) \
- libssh2_userauth_hostbased_fromfile_ex((session), (username), \
-                                        (unsigned int)strlen(username), \
-                                        (publickey),                    \
-                                        (privatekey), (passphrase),     \
-                                        (hostname),                     \
-                                        (unsigned int)strlen(hostname), \
-                                        (username),                     \
-                                        (unsigned int)strlen(username))
-
-LIBSSH2_API int
-libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
-                                      const char *username,
-                                      size_t username_len,
-                                      const char *publickeyfiledata,
-                                      size_t publickeyfiledata_len,
-                                      const char *privatekeyfiledata,
-                                      size_t privatekeyfiledata_len,
-                                      const char *passphrase);
-
-/*
- * response_callback is provided with filled by library prompts array,
- * but client must allocate and fill individual responses. Responses
- * array is already allocated. Responses data will be freed by libssh2
- * after callback return, but before subsequent callback invocation.
- */
-LIBSSH2_API int
-libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION* session,
-                                         const char *username,
-                                         unsigned int username_len,
-                                         LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(
-                                                       (*response_callback)));
-
-#define libssh2_userauth_keyboard_interactive(session, username,        \
-                                              response_callback)        \
-    libssh2_userauth_keyboard_interactive_ex((session), (username),     \
-                                             (unsigned int)strlen(username), \
-                                             (response_callback))
-
-LIBSSH2_API int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds,
-                             long timeout);
-
-/* Channel API */
-#define LIBSSH2_CHANNEL_WINDOW_DEFAULT  (2*1024*1024)
-#define LIBSSH2_CHANNEL_PACKET_DEFAULT  32768
-#define LIBSSH2_CHANNEL_MINADJUST       1024
-
-/* Extended Data Handling */
-#define LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL        0
-#define LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE        1
-#define LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE         2
-
-#define SSH_EXTENDED_DATA_STDERR 1
-
-/* Returned by any function that would block during a read/write operation */
-#define LIBSSH2CHANNEL_EAGAIN LIBSSH2_ERROR_EAGAIN
-
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type,
-                        unsigned int channel_type_len,
-                        unsigned int window_size, unsigned int packet_size,
-                        const char *message, unsigned int message_len);
-
-#define libssh2_channel_open_session(session) \
-  libssh2_channel_open_ex((session), "session", sizeof("session") - 1, \
-                          LIBSSH2_CHANNEL_WINDOW_DEFAULT, \
-                          LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0)
-
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
-                                int port, const char *shost, int sport);
-#define libssh2_channel_direct_tcpip(session, host, port) \
-  libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22)
-
-LIBSSH2_API LIBSSH2_LISTENER *
-libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host,
-                                  int port, int *bound_port,
-                                  int queue_maxsize);
-#define libssh2_channel_forward_listen(session, port) \
- libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16)
-
-LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
-
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);
-
-LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel,
-                                          const char *varname,
-                                          unsigned int varname_len,
-                                          const char *value,
-                                          unsigned int value_len);
-
-#define libssh2_channel_setenv(channel, varname, value)                 \
-    libssh2_channel_setenv_ex((channel), (varname),                     \
-                              (unsigned int)strlen(varname), (value),   \
-                              (unsigned int)strlen(value))
-
-LIBSSH2_API int libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel);
-
-LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel,
-                                               const char *term,
-                                               unsigned int term_len,
-                                               const char *modes,
-                                               unsigned int modes_len,
-                                               int width, int height,
-                                               int width_px, int height_px);
-#define libssh2_channel_request_pty(channel, term)                      \
-    libssh2_channel_request_pty_ex((channel), (term),                   \
-                                   (unsigned int)strlen(term),          \
-                                   NULL, 0,                             \
-                                   LIBSSH2_TERM_WIDTH,                  \
-                                   LIBSSH2_TERM_HEIGHT,                 \
-                                   LIBSSH2_TERM_WIDTH_PX,               \
-                                   LIBSSH2_TERM_HEIGHT_PX)
-
-LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel,
-                                                    int width, int height,
-                                                    int width_px,
-                                                    int height_px);
-#define libssh2_channel_request_pty_size(channel, width, height) \
-  libssh2_channel_request_pty_size_ex((channel), (width), (height), 0, 0)
-
-LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel,
-                                           int single_connection,
-                                           const char *auth_proto,
-                                           const char *auth_cookie,
-                                           int screen_number);
-#define libssh2_channel_x11_req(channel, screen_number) \
- libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number))
-
-LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                                const char *request,
-                                                unsigned int request_len,
-                                                const char *message,
-                                                unsigned int message_len);
-#define libssh2_channel_shell(channel) \
-  libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, \
-                                  NULL, 0)
-#define libssh2_channel_exec(channel, command) \
-  libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, \
-                                  (command), (unsigned int)strlen(command))
-#define libssh2_channel_subsystem(channel, subsystem) \
-  libssh2_channel_process_startup((channel), "subsystem",              \
-                                  sizeof("subsystem") - 1, (subsystem), \
-                                  (unsigned int)strlen(subsystem))
-
-LIBSSH2_API ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel,
-                                            int stream_id, char *buf,
-                                            size_t buflen);
-#define libssh2_channel_read(channel, buf, buflen) \
-  libssh2_channel_read_ex((channel), 0, (buf), (buflen))
-#define libssh2_channel_read_stderr(channel, buf, buflen) \
-  libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
-
-LIBSSH2_API int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel,
-                                          int extended);
-
-LIBSSH2_API unsigned long
-libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
-                               unsigned long *read_avail,
-                               unsigned long *window_size_initial);
-#define libssh2_channel_window_read(channel) \
-  libssh2_channel_window_read_ex((channel), NULL, NULL)
-
-/* libssh2_channel_receive_window_adjust is DEPRECATED, do not use! */
-LIBSSH2_API unsigned long
-libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
-                                      unsigned long adjustment,
-                                      unsigned char force);
-
-LIBSSH2_API int
-libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
-                                       unsigned long adjustment,
-                                       unsigned char force,
-                                       unsigned int *storewindow);
-
-LIBSSH2_API ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
-                                             int stream_id, const char *buf,
-                                             size_t buflen);
-
-#define libssh2_channel_write(channel, buf, buflen) \
-  libssh2_channel_write_ex((channel), 0, (buf), (buflen))
-#define libssh2_channel_write_stderr(channel, buf, buflen)              \
-    libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR,       \
-                             (buf), (buflen))
-
-LIBSSH2_API unsigned long
-libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
-                                unsigned long *window_size_initial);
-#define libssh2_channel_window_write(channel) \
-  libssh2_channel_window_write_ex((channel), NULL)
-
-LIBSSH2_API void libssh2_session_set_blocking(LIBSSH2_SESSION* session,
-                                              int blocking);
-LIBSSH2_API int libssh2_session_get_blocking(LIBSSH2_SESSION* session);
-
-LIBSSH2_API void libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel,
-                                              int blocking);
-
-LIBSSH2_API void libssh2_session_set_timeout(LIBSSH2_SESSION* session,
-                                             long timeout);
-LIBSSH2_API long libssh2_session_get_timeout(LIBSSH2_SESSION* session);
-
-/* libssh2_channel_handle_extended_data is DEPRECATED, do not use! */
-LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
-                                                      int ignore_mode);
-LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
-                                                      int ignore_mode);
-
-/* libssh2_channel_ignore_extended_data() is defined below for BC with version
- * 0.1
- *
- * Future uses should use libssh2_channel_handle_extended_data() directly if
- * LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE is passed, extended data will be read
- * (FIFO) from the standard data channel
- */
-/* DEPRECATED */
-#define libssh2_channel_ignore_extended_data(channel, ignore) \
-  libssh2_channel_handle_extended_data((channel),                       \
-                                       (ignore) ?                       \
-                                       LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE : \
-                                       LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL)
-
-#define LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA     -1
-#define LIBSSH2_CHANNEL_FLUSH_ALL               -2
-LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel,
-                                         int streamid);
-#define libssh2_channel_flush(channel) libssh2_channel_flush_ex((channel), 0)
-#define libssh2_channel_flush_stderr(channel) \
- libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR)
-
-LIBSSH2_API int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel);
-LIBSSH2_API int libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL* channel,
-                                                char **exitsignal,
-                                                size_t *exitsignal_len,
-                                                char **errmsg,
-                                                size_t *errmsg_len,
-                                                char **langtag,
-                                                size_t *langtag_len);
-LIBSSH2_API int libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *channel);
-
-/* libssh2_scp_recv is DEPRECATED, do not use! */
-LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session,
-                                              const char *path,
-                                              struct stat *sb);
-/* Use libssh2_scp_recv2 for large (> 2GB) file support on windows */
-LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv2(LIBSSH2_SESSION *session,
-                                               const char *path,
-                                               libssh2_struct_stat *sb);
-LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session,
-                                                 const char *path, int mode,
-                                                 size_t size, long mtime,
-                                                 long atime);
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
-                   libssh2_int64_t size, time_t mtime, time_t atime);
-
-#define libssh2_scp_send(session, path, mode, size) \
-  libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0)
-
-LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
-                                      unsigned int *dest_len,
-                                      const char *src, unsigned int src_len);
-
-LIBSSH2_API
-const char *libssh2_version(int req_version_num);
-
-#define HAVE_LIBSSH2_KNOWNHOST_API 0x010101 /* since 1.1.1 */
-#define HAVE_LIBSSH2_VERSION_API   0x010100 /* libssh2_version since 1.1 */
-
-struct libssh2_knownhost {
-    unsigned int magic;  /* magic stored by the library */
-    void *node; /* handle to the internal representation of this host */
-    char *name; /* this is NULL if no plain text host name exists */
-    char *key;  /* key in base64/printable format */
-    int typemask;
-};
-
-/*
- * libssh2_knownhost_init
- *
- * Init a collection of known hosts. Returns the pointer to a collection.
- *
- */
-LIBSSH2_API LIBSSH2_KNOWNHOSTS *
-libssh2_knownhost_init(LIBSSH2_SESSION *session);
-
-/*
- * libssh2_knownhost_add
- *
- * Add a host and its associated key to the collection of known hosts.
- *
- * The 'type' argument specifies on what format the given host and keys are:
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - SHA1(<salt> <host>) base64-encoded!
- * custom - another hash
- *
- * If 'sha1' is selected as type, the salt must be provided to the salt
- * argument. This too base64 encoded.
- *
- * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.  If
- * a custom type is used, salt is ignored and you must provide the host
- * pre-hashed when checking for it in the libssh2_knownhost_check() function.
- *
- * The keylen parameter may be omitted (zero) if the key is provided as a
- * NULL-terminated base64-encoded string.
- */
-
-/* host format (2 bits) */
-#define LIBSSH2_KNOWNHOST_TYPE_MASK    0xffff
-#define LIBSSH2_KNOWNHOST_TYPE_PLAIN   1
-#define LIBSSH2_KNOWNHOST_TYPE_SHA1    2 /* always base64 encoded */
-#define LIBSSH2_KNOWNHOST_TYPE_CUSTOM  3
-
-/* key format (2 bits) */
-#define LIBSSH2_KNOWNHOST_KEYENC_MASK     (3<<16)
-#define LIBSSH2_KNOWNHOST_KEYENC_RAW      (1<<16)
-#define LIBSSH2_KNOWNHOST_KEYENC_BASE64   (2<<16)
-
-/* type of key (4 bits) */
-#define LIBSSH2_KNOWNHOST_KEY_MASK         (15<<18)
-#define LIBSSH2_KNOWNHOST_KEY_SHIFT        18
-#define LIBSSH2_KNOWNHOST_KEY_RSA1         (1<<18)
-#define LIBSSH2_KNOWNHOST_KEY_SSHRSA       (2<<18)
-#define LIBSSH2_KNOWNHOST_KEY_SSHDSS       (3<<18)
-#define LIBSSH2_KNOWNHOST_KEY_ECDSA_256    (4<<18)
-#define LIBSSH2_KNOWNHOST_KEY_ECDSA_384    (5<<18)
-#define LIBSSH2_KNOWNHOST_KEY_ECDSA_521    (6<<18)
-#define LIBSSH2_KNOWNHOST_KEY_ED25519      (7<<18)
-#define LIBSSH2_KNOWNHOST_KEY_UNKNOWN      (15<<18)
-
-LIBSSH2_API int
-libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
-                      const char *host,
-                      const char *salt,
-                      const char *key, size_t keylen, int typemask,
-                      struct libssh2_knownhost **store);
-
-/*
- * libssh2_knownhost_addc
- *
- * Add a host and its associated key to the collection of known hosts.
- *
- * Takes a comment argument that may be NULL.  A NULL comment indicates
- * there is no comment and the entry will end directly after the key
- * when written out to a file.  An empty string "" comment will indicate an
- * empty comment which will cause a single space to be written after the key.
- *
- * The 'type' argument specifies on what format the given host and keys are:
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - SHA1(<salt> <host>) base64-encoded!
- * custom - another hash
- *
- * If 'sha1' is selected as type, the salt must be provided to the salt
- * argument. This too base64 encoded.
- *
- * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.  If
- * a custom type is used, salt is ignored and you must provide the host
- * pre-hashed when checking for it in the libssh2_knownhost_check() function.
- *
- * The keylen parameter may be omitted (zero) if the key is provided as a
- * NULL-terminated base64-encoded string.
- */
-
-LIBSSH2_API int
-libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
-                       const char *host,
-                       const char *salt,
-                       const char *key, size_t keylen,
-                       const char *comment, size_t commentlen, int typemask,
-                       struct libssh2_knownhost **store);
-
-/*
- * libssh2_knownhost_check
- *
- * Check a host and its associated key against the collection of known hosts.
- *
- * The type is the type/format of the given host name.
- *
- * plain  - ascii "hostname.domain.tld"
- * custom - prehashed base64 encoded. Note that this cannot use any salts.
- *
- *
- * 'knownhost' may be set to NULL if you don't care about that info.
- *
- * Returns:
- *
- * LIBSSH2_KNOWNHOST_CHECK_* values, see below
- *
- */
-
-#define LIBSSH2_KNOWNHOST_CHECK_MATCH    0
-#define LIBSSH2_KNOWNHOST_CHECK_MISMATCH 1
-#define LIBSSH2_KNOWNHOST_CHECK_NOTFOUND 2
-#define LIBSSH2_KNOWNHOST_CHECK_FAILURE  3
-
-LIBSSH2_API int
-libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
-                        const char *host, const char *key, size_t keylen,
-                        int typemask,
-                        struct libssh2_knownhost **knownhost);
-
-/* this function is identital to the above one, but also takes a port
-   argument that allows libssh2 to do a better check */
-LIBSSH2_API int
-libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
-                         const char *host, int port,
-                         const char *key, size_t keylen,
-                         int typemask,
-                         struct libssh2_knownhost **knownhost);
-
-/*
- * libssh2_knownhost_del
- *
- * Remove a host from the collection of known hosts. The 'entry' struct is
- * retrieved by a call to libssh2_knownhost_check().
- *
- */
-LIBSSH2_API int
-libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
-                      struct libssh2_knownhost *entry);
-
-/*
- * libssh2_knownhost_free
- *
- * Free an entire collection of known hosts.
- *
- */
-LIBSSH2_API void
-libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts);
-
-/*
- * libssh2_knownhost_readline()
- *
- * Pass in a line of a file of 'type'. It makes libssh2 read this line.
- *
- * LIBSSH2_KNOWNHOST_FILE_OPENSSH is the only supported type.
- *
- */
-LIBSSH2_API int
-libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
-                           const char *line, size_t len, int type);
-
-/*
- * libssh2_knownhost_readfile
- *
- * Add hosts+key pairs from a given file.
- *
- * Returns a negative value for error or number of successfully added hosts.
- *
- * This implementation currently only knows one 'type' (openssh), all others
- * are reserved for future use.
- */
-
-#define LIBSSH2_KNOWNHOST_FILE_OPENSSH 1
-
-LIBSSH2_API int
-libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
-                           const char *filename, int type);
-
-/*
- * libssh2_knownhost_writeline()
- *
- * Ask libssh2 to convert a known host to an output line for storage.
- *
- * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the given
- * output buffer is too small to hold the desired output.
- *
- * This implementation currently only knows one 'type' (openssh), all others
- * are reserved for future use.
- *
- */
-LIBSSH2_API int
-libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
-                            struct libssh2_knownhost *known,
-                            char *buffer, size_t buflen,
-                            size_t *outlen, /* the amount of written data */
-                            int type);
-
-/*
- * libssh2_knownhost_writefile
- *
- * Write hosts+key pairs to a given file.
- *
- * This implementation currently only knows one 'type' (openssh), all others
- * are reserved for future use.
- */
-
-LIBSSH2_API int
-libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
-                            const char *filename, int type);
-
-/*
- * libssh2_knownhost_get()
- *
- * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
- * the first one. Or pass a pointer to the previously returned one to get the
- * next.
- *
- * Returns:
- * 0 if a fine host was stored in 'store'
- * 1 if end of hosts
- * [negative] on errors
- */
-LIBSSH2_API int
-libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
-                      struct libssh2_knownhost **store,
-                      struct libssh2_knownhost *prev);
-
-#define HAVE_LIBSSH2_AGENT_API 0x010202 /* since 1.2.2 */
-
-struct libssh2_agent_publickey {
-    unsigned int magic;              /* magic stored by the library */
-    void *node;     /* handle to the internal representation of key */
-    unsigned char *blob;           /* public key blob */
-    size_t blob_len;               /* length of the public key blob */
-    char *comment;                 /* comment in printable format */
-};
-
-/*
- * libssh2_agent_init
- *
- * Init an ssh-agent handle. Returns the pointer to the handle.
- *
- */
-LIBSSH2_API LIBSSH2_AGENT *
-libssh2_agent_init(LIBSSH2_SESSION *session);
-
-/*
- * libssh2_agent_connect()
- *
- * Connect to an ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_connect(LIBSSH2_AGENT *agent);
-
-/*
- * libssh2_agent_list_identities()
- *
- * Request an ssh-agent to list identities.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
-
-/*
- * libssh2_agent_get_identity()
- *
- * Traverse the internal list of public keys. Pass NULL to 'prev' to get
- * the first one. Or pass a pointer to the previously returned one to get the
- * next.
- *
- * Returns:
- * 0 if a fine public key was stored in 'store'
- * 1 if end of public keys
- * [negative] on errors
- */
-LIBSSH2_API int
-libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
-               struct libssh2_agent_publickey **store,
-               struct libssh2_agent_publickey *prev);
-
-/*
- * libssh2_agent_userauth()
- *
- * Do publickey user authentication with the help of ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_userauth(LIBSSH2_AGENT *agent,
-               const char *username,
-               struct libssh2_agent_publickey *identity);
-
-/*
- * libssh2_agent_disconnect()
- *
- * Close a connection to an ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_disconnect(LIBSSH2_AGENT *agent);
-
-/*
- * libssh2_agent_free()
- *
- * Free an ssh-agent handle.  This function also frees the internal
- * collection of public keys.
- */
-LIBSSH2_API void
-libssh2_agent_free(LIBSSH2_AGENT *agent);
-
-/*
- * libssh2_agent_set_identity_path()
- *
- * Allows a custom agent identity socket path beyond SSH_AUTH_SOCK env
- *
- */
-LIBSSH2_API void
-libssh2_agent_set_identity_path(LIBSSH2_AGENT *agent,
-                                const char *path);
-
-/*
- * libssh2_agent_get_identity_path()
- *
- * Returns the custom agent identity socket path if set
- *
- */
-LIBSSH2_API const char *
-libssh2_agent_get_identity_path(LIBSSH2_AGENT *agent);
-
-/*
- * libssh2_keepalive_config()
- *
- * Set how often keepalive messages should be sent.  WANT_REPLY
- * indicates whether the keepalive messages should request a response
- * from the server.  INTERVAL is number of seconds that can pass
- * without any I/O, use 0 (the default) to disable keepalives.  To
- * avoid some busy-loop corner-cases, if you specify an interval of 1
- * it will be treated as 2.
- *
- * Note that non-blocking applications are responsible for sending the
- * keepalive messages using libssh2_keepalive_send().
- */
-LIBSSH2_API void libssh2_keepalive_config(LIBSSH2_SESSION *session,
-                                          int want_reply,
-                                          unsigned interval);
-
-/*
- * libssh2_keepalive_send()
- *
- * Send a keepalive message if needed.  SECONDS_TO_NEXT indicates how
- * many seconds you can sleep after this call before you need to call
- * it again.  Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on
- * I/O errors.
- */
-LIBSSH2_API int libssh2_keepalive_send(LIBSSH2_SESSION *session,
-                                       int *seconds_to_next);
-
-/* NOTE NOTE NOTE
-   libssh2_trace() has no function in builds that aren't built with debug
-   enabled
- */
-LIBSSH2_API int libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
-#define LIBSSH2_TRACE_TRANS (1<<1)
-#define LIBSSH2_TRACE_KEX   (1<<2)
-#define LIBSSH2_TRACE_AUTH  (1<<3)
-#define LIBSSH2_TRACE_CONN  (1<<4)
-#define LIBSSH2_TRACE_SCP   (1<<5)
-#define LIBSSH2_TRACE_SFTP  (1<<6)
-#define LIBSSH2_TRACE_ERROR (1<<7)
-#define LIBSSH2_TRACE_PUBLICKEY (1<<8)
-#define LIBSSH2_TRACE_SOCKET (1<<9)
-
-typedef void (*libssh2_trace_handler_func)(LIBSSH2_SESSION*,
-                                           void *,
-                                           const char *,
-                                           size_t);
-LIBSSH2_API int libssh2_trace_sethandler(LIBSSH2_SESSION *session,
-                                         void *context,
-                                         libssh2_trace_handler_func callback);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* !RC_INVOKED */
-
-#endif /* LIBSSH2_H */
diff --git a/libssh2/libssh2/include/libssh2_publickey.h b/libssh2/libssh2/include/libssh2_publickey.h
deleted file mode 100644
index 5dbdcf92..00000000
--- a/libssh2/libssh2/include/libssh2_publickey.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Note: This include file is only needed for using the
- * publickey SUBSYSTEM which is not the same as publickey
- * authentication.  For authentication you only need libssh2.h
- *
- * For more information on the publickey subsystem,
- * refer to IETF draft: secsh-publickey
- */
-
-#ifndef LIBSSH2_PUBLICKEY_H
-#define LIBSSH2_PUBLICKEY_H 1
-
-#include "libssh2.h"
-
-typedef struct _LIBSSH2_PUBLICKEY               LIBSSH2_PUBLICKEY;
-
-typedef struct _libssh2_publickey_attribute {
-    const char *name;
-    unsigned long name_len;
-    const char *value;
-    unsigned long value_len;
-    char mandatory;
-} libssh2_publickey_attribute;
-
-typedef struct _libssh2_publickey_list {
-    unsigned char *packet; /* For freeing */
-
-    const unsigned char *name;
-    unsigned long name_len;
-    const unsigned char *blob;
-    unsigned long blob_len;
-    unsigned long num_attrs;
-    libssh2_publickey_attribute *attrs; /* free me */
-} libssh2_publickey_list;
-
-/* Generally use the first macro here, but if both name and value are string
-   literals, you can use _fast() to take advantage of preprocessing */
-#define libssh2_publickey_attribute(name, value, mandatory) \
-  { (name), strlen(name), (value), strlen(value), (mandatory) },
-#define libssh2_publickey_attribute_fast(name, value, mandatory) \
-  { (name), sizeof(name) - 1, (value), sizeof(value) - 1, (mandatory) },
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Publickey Subsystem */
-LIBSSH2_API LIBSSH2_PUBLICKEY *
-libssh2_publickey_init(LIBSSH2_SESSION *session);
-
-LIBSSH2_API int
-libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey,
-                         const unsigned char *name,
-                         unsigned long name_len,
-                         const unsigned char *blob,
-                         unsigned long blob_len, char overwrite,
-                         unsigned long num_attrs,
-                         const libssh2_publickey_attribute attrs[]);
-#define libssh2_publickey_add(pkey, name, blob, blob_len, overwrite,    \
-                              num_attrs, attrs)                         \
-  libssh2_publickey_add_ex((pkey), (name), strlen(name), (blob), (blob_len), \
-                           (overwrite), (num_attrs), (attrs))
-
-LIBSSH2_API int libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY *pkey,
-                                            const unsigned char *name,
-                                            unsigned long name_len,
-                                            const unsigned char *blob,
-                                            unsigned long blob_len);
-#define libssh2_publickey_remove(pkey, name, blob, blob_len) \
-  libssh2_publickey_remove_ex((pkey), (name), strlen(name), (blob), (blob_len))
-
-LIBSSH2_API int
-libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY *pkey,
-                             unsigned long *num_keys,
-                             libssh2_publickey_list **pkey_list);
-LIBSSH2_API void
-libssh2_publickey_list_free(LIBSSH2_PUBLICKEY *pkey,
-                            libssh2_publickey_list *pkey_list);
-
-LIBSSH2_API int libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* ifndef: LIBSSH2_PUBLICKEY_H */
diff --git a/libssh2/libssh2/include/libssh2_sftp.h b/libssh2/libssh2/include/libssh2_sftp.h
deleted file mode 100644
index 476ea870..00000000
--- a/libssh2/libssh2/include/libssh2_sftp.h
+++ /dev/null
@@ -1,351 +0,0 @@
-/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_SFTP_H
-#define LIBSSH2_SFTP_H 1
-
-#include "libssh2.h"
-
-#ifndef WIN32
-#include <unistd.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Note: Version 6 was documented at the time of writing
- * However it was marked as "DO NOT IMPLEMENT" due to pending changes
- *
- * Let's start with Version 3 (The version found in OpenSSH) and go from there
- */
-#define LIBSSH2_SFTP_VERSION        3
-
-typedef struct _LIBSSH2_SFTP                LIBSSH2_SFTP;
-typedef struct _LIBSSH2_SFTP_HANDLE         LIBSSH2_SFTP_HANDLE;
-typedef struct _LIBSSH2_SFTP_ATTRIBUTES     LIBSSH2_SFTP_ATTRIBUTES;
-typedef struct _LIBSSH2_SFTP_STATVFS        LIBSSH2_SFTP_STATVFS;
-
-/* Flags for open_ex() */
-#define LIBSSH2_SFTP_OPENFILE           0
-#define LIBSSH2_SFTP_OPENDIR            1
-
-/* Flags for rename_ex() */
-#define LIBSSH2_SFTP_RENAME_OVERWRITE   0x00000001
-#define LIBSSH2_SFTP_RENAME_ATOMIC      0x00000002
-#define LIBSSH2_SFTP_RENAME_NATIVE      0x00000004
-
-/* Flags for stat_ex() */
-#define LIBSSH2_SFTP_STAT               0
-#define LIBSSH2_SFTP_LSTAT              1
-#define LIBSSH2_SFTP_SETSTAT            2
-
-/* Flags for symlink_ex() */
-#define LIBSSH2_SFTP_SYMLINK            0
-#define LIBSSH2_SFTP_READLINK           1
-#define LIBSSH2_SFTP_REALPATH           2
-
-/* Flags for sftp_mkdir() */
-#define LIBSSH2_SFTP_DEFAULT_MODE      -1
-
-/* SFTP attribute flag bits */
-#define LIBSSH2_SFTP_ATTR_SIZE              0x00000001
-#define LIBSSH2_SFTP_ATTR_UIDGID            0x00000002
-#define LIBSSH2_SFTP_ATTR_PERMISSIONS       0x00000004
-#define LIBSSH2_SFTP_ATTR_ACMODTIME         0x00000008
-#define LIBSSH2_SFTP_ATTR_EXTENDED          0x80000000
-
-/* SFTP statvfs flag bits */
-#define LIBSSH2_SFTP_ST_RDONLY              0x00000001
-#define LIBSSH2_SFTP_ST_NOSUID              0x00000002
-
-struct _LIBSSH2_SFTP_ATTRIBUTES {
-    /* If flags & ATTR_* bit is set, then the value in this struct will be
-     * meaningful Otherwise it should be ignored
-     */
-    unsigned long flags;
-
-    libssh2_uint64_t filesize;
-    unsigned long uid, gid;
-    unsigned long permissions;
-    unsigned long atime, mtime;
-};
-
-struct _LIBSSH2_SFTP_STATVFS {
-    libssh2_uint64_t  f_bsize;    /* file system block size */
-    libssh2_uint64_t  f_frsize;   /* fragment size */
-    libssh2_uint64_t  f_blocks;   /* size of fs in f_frsize units */
-    libssh2_uint64_t  f_bfree;    /* # free blocks */
-    libssh2_uint64_t  f_bavail;   /* # free blocks for non-root */
-    libssh2_uint64_t  f_files;    /* # inodes */
-    libssh2_uint64_t  f_ffree;    /* # free inodes */
-    libssh2_uint64_t  f_favail;   /* # free inodes for non-root */
-    libssh2_uint64_t  f_fsid;     /* file system ID */
-    libssh2_uint64_t  f_flag;     /* mount flags */
-    libssh2_uint64_t  f_namemax;  /* maximum filename length */
-};
-
-/* SFTP filetypes */
-#define LIBSSH2_SFTP_TYPE_REGULAR           1
-#define LIBSSH2_SFTP_TYPE_DIRECTORY         2
-#define LIBSSH2_SFTP_TYPE_SYMLINK           3
-#define LIBSSH2_SFTP_TYPE_SPECIAL           4
-#define LIBSSH2_SFTP_TYPE_UNKNOWN           5
-#define LIBSSH2_SFTP_TYPE_SOCKET            6
-#define LIBSSH2_SFTP_TYPE_CHAR_DEVICE       7
-#define LIBSSH2_SFTP_TYPE_BLOCK_DEVICE      8
-#define LIBSSH2_SFTP_TYPE_FIFO              9
-
-/*
- * Reproduce the POSIX file modes here for systems that are not POSIX
- * compliant.
- *
- * These is used in "permissions" of "struct _LIBSSH2_SFTP_ATTRIBUTES"
- */
-/* File type */
-#define LIBSSH2_SFTP_S_IFMT         0170000     /* type of file mask */
-#define LIBSSH2_SFTP_S_IFIFO        0010000     /* named pipe (fifo) */
-#define LIBSSH2_SFTP_S_IFCHR        0020000     /* character special */
-#define LIBSSH2_SFTP_S_IFDIR        0040000     /* directory */
-#define LIBSSH2_SFTP_S_IFBLK        0060000     /* block special */
-#define LIBSSH2_SFTP_S_IFREG        0100000     /* regular */
-#define LIBSSH2_SFTP_S_IFLNK        0120000     /* symbolic link */
-#define LIBSSH2_SFTP_S_IFSOCK       0140000     /* socket */
-
-/* File mode */
-/* Read, write, execute/search by owner */
-#define LIBSSH2_SFTP_S_IRWXU        0000700     /* RWX mask for owner */
-#define LIBSSH2_SFTP_S_IRUSR        0000400     /* R for owner */
-#define LIBSSH2_SFTP_S_IWUSR        0000200     /* W for owner */
-#define LIBSSH2_SFTP_S_IXUSR        0000100     /* X for owner */
-/* Read, write, execute/search by group */
-#define LIBSSH2_SFTP_S_IRWXG        0000070     /* RWX mask for group */
-#define LIBSSH2_SFTP_S_IRGRP        0000040     /* R for group */
-#define LIBSSH2_SFTP_S_IWGRP        0000020     /* W for group */
-#define LIBSSH2_SFTP_S_IXGRP        0000010     /* X for group */
-/* Read, write, execute/search by others */
-#define LIBSSH2_SFTP_S_IRWXO        0000007     /* RWX mask for other */
-#define LIBSSH2_SFTP_S_IROTH        0000004     /* R for other */
-#define LIBSSH2_SFTP_S_IWOTH        0000002     /* W for other */
-#define LIBSSH2_SFTP_S_IXOTH        0000001     /* X for other */
-
-/* macros to check for specific file types, added in 1.2.5 */
-#define LIBSSH2_SFTP_S_ISLNK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)
-#define LIBSSH2_SFTP_S_ISREG(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)
-#define LIBSSH2_SFTP_S_ISDIR(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)
-#define LIBSSH2_SFTP_S_ISCHR(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)
-#define LIBSSH2_SFTP_S_ISBLK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)
-#define LIBSSH2_SFTP_S_ISFIFO(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)
-#define LIBSSH2_SFTP_S_ISSOCK(m) \
-  (((m) & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)
-
-/* SFTP File Transfer Flags -- (e.g. flags parameter to sftp_open())
- * Danger will robinson... APPEND doesn't have any effect on OpenSSH servers */
-#define LIBSSH2_FXF_READ                        0x00000001
-#define LIBSSH2_FXF_WRITE                       0x00000002
-#define LIBSSH2_FXF_APPEND                      0x00000004
-#define LIBSSH2_FXF_CREAT                       0x00000008
-#define LIBSSH2_FXF_TRUNC                       0x00000010
-#define LIBSSH2_FXF_EXCL                        0x00000020
-
-/* SFTP Status Codes (returned by libssh2_sftp_last_error() ) */
-#define LIBSSH2_FX_OK                       0UL
-#define LIBSSH2_FX_EOF                      1UL
-#define LIBSSH2_FX_NO_SUCH_FILE             2UL
-#define LIBSSH2_FX_PERMISSION_DENIED        3UL
-#define LIBSSH2_FX_FAILURE                  4UL
-#define LIBSSH2_FX_BAD_MESSAGE              5UL
-#define LIBSSH2_FX_NO_CONNECTION            6UL
-#define LIBSSH2_FX_CONNECTION_LOST          7UL
-#define LIBSSH2_FX_OP_UNSUPPORTED           8UL
-#define LIBSSH2_FX_INVALID_HANDLE           9UL
-#define LIBSSH2_FX_NO_SUCH_PATH             10UL
-#define LIBSSH2_FX_FILE_ALREADY_EXISTS      11UL
-#define LIBSSH2_FX_WRITE_PROTECT            12UL
-#define LIBSSH2_FX_NO_MEDIA                 13UL
-#define LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM   14UL
-#define LIBSSH2_FX_QUOTA_EXCEEDED           15UL
-#define LIBSSH2_FX_UNKNOWN_PRINCIPLE        16UL /* Initial mis-spelling */
-#define LIBSSH2_FX_UNKNOWN_PRINCIPAL        16UL
-#define LIBSSH2_FX_LOCK_CONFlICT            17UL /* Initial mis-spelling */
-#define LIBSSH2_FX_LOCK_CONFLICT            17UL
-#define LIBSSH2_FX_DIR_NOT_EMPTY            18UL
-#define LIBSSH2_FX_NOT_A_DIRECTORY          19UL
-#define LIBSSH2_FX_INVALID_FILENAME         20UL
-#define LIBSSH2_FX_LINK_LOOP                21UL
-
-/* Returned by any function that would block during a read/write operation */
-#define LIBSSH2SFTP_EAGAIN LIBSSH2_ERROR_EAGAIN
-
-/* SFTP API */
-LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session);
-LIBSSH2_API int libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp);
-LIBSSH2_API unsigned long libssh2_sftp_last_error(LIBSSH2_SFTP *sftp);
-LIBSSH2_API LIBSSH2_CHANNEL *libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp);
-
-/* File / Directory Ops */
-LIBSSH2_API LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp,
-                     const char *filename,
-                     unsigned int filename_len,
-                     unsigned long flags,
-                     long mode, int open_type);
-#define libssh2_sftp_open(sftp, filename, flags, mode)                  \
-    libssh2_sftp_open_ex((sftp), (filename), strlen(filename), (flags), \
-                         (mode), LIBSSH2_SFTP_OPENFILE)
-#define libssh2_sftp_opendir(sftp, path) \
-    libssh2_sftp_open_ex((sftp), (path), strlen(path), 0, 0, \
-                         LIBSSH2_SFTP_OPENDIR)
-
-LIBSSH2_API ssize_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle,
-                                      char *buffer, size_t buffer_maxlen);
-
-LIBSSH2_API int libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *handle, \
-                                        char *buffer, size_t buffer_maxlen,
-                                        char *longentry,
-                                        size_t longentry_maxlen,
-                                        LIBSSH2_SFTP_ATTRIBUTES *attrs);
-#define libssh2_sftp_readdir(handle, buffer, buffer_maxlen, attrs)      \
-    libssh2_sftp_readdir_ex((handle), (buffer), (buffer_maxlen), NULL, 0, \
-                            (attrs))
-
-LIBSSH2_API ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle,
-                                       const char *buffer, size_t count);
-LIBSSH2_API int libssh2_sftp_fsync(LIBSSH2_SFTP_HANDLE *handle);
-
-LIBSSH2_API int libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle);
-#define libssh2_sftp_close(handle) libssh2_sftp_close_handle(handle)
-#define libssh2_sftp_closedir(handle) libssh2_sftp_close_handle(handle)
-
-LIBSSH2_API void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset);
-LIBSSH2_API void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle,
-                                     libssh2_uint64_t offset);
-#define libssh2_sftp_rewind(handle) libssh2_sftp_seek64((handle), 0)
-
-LIBSSH2_API size_t libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle);
-LIBSSH2_API libssh2_uint64_t libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle);
-
-LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle,
-                                      LIBSSH2_SFTP_ATTRIBUTES *attrs,
-                                      int setstat);
-#define libssh2_sftp_fstat(handle, attrs) \
-    libssh2_sftp_fstat_ex((handle), (attrs), 0)
-#define libssh2_sftp_fsetstat(handle, attrs) \
-    libssh2_sftp_fstat_ex((handle), (attrs), 1)
-
-/* Miscellaneous Ops */
-LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp,
-                                       const char *source_filename,
-                                       unsigned int srouce_filename_len,
-                                       const char *dest_filename,
-                                       unsigned int dest_filename_len,
-                                       long flags);
-#define libssh2_sftp_rename(sftp, sourcefile, destfile) \
-    libssh2_sftp_rename_ex((sftp), (sourcefile), strlen(sourcefile), \
-                           (destfile), strlen(destfile),                \
-                           LIBSSH2_SFTP_RENAME_OVERWRITE | \
-                           LIBSSH2_SFTP_RENAME_ATOMIC | \
-                           LIBSSH2_SFTP_RENAME_NATIVE)
-
-LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp,
-                                       const char *filename,
-                                       unsigned int filename_len);
-#define libssh2_sftp_unlink(sftp, filename) \
-    libssh2_sftp_unlink_ex((sftp), (filename), strlen(filename))
-
-LIBSSH2_API int libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle,
-                                      LIBSSH2_SFTP_STATVFS *st);
-
-LIBSSH2_API int libssh2_sftp_statvfs(LIBSSH2_SFTP *sftp,
-                                     const char *path,
-                                     size_t path_len,
-                                     LIBSSH2_SFTP_STATVFS *st);
-
-LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp,
-                                      const char *path,
-                                      unsigned int path_len, long mode);
-#define libssh2_sftp_mkdir(sftp, path, mode) \
-    libssh2_sftp_mkdir_ex((sftp), (path), strlen(path), (mode))
-
-LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp,
-                                      const char *path,
-                                      unsigned int path_len);
-#define libssh2_sftp_rmdir(sftp, path) \
-    libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
-
-LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp,
-                                     const char *path,
-                                     unsigned int path_len,
-                                     int stat_type,
-                                     LIBSSH2_SFTP_ATTRIBUTES *attrs);
-#define libssh2_sftp_stat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_STAT, \
-                         (attrs))
-#define libssh2_sftp_lstat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_LSTAT, \
-                         (attrs))
-#define libssh2_sftp_setstat(sftp, path, attrs) \
-    libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_SETSTAT, \
-                         (attrs))
-
-LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp,
-                                        const char *path,
-                                        unsigned int path_len,
-                                        char *target,
-                                        unsigned int target_len,
-                                        int link_type);
-#define libssh2_sftp_symlink(sftp, orig, linkpath) \
-    libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), \
-                            strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
-#define libssh2_sftp_readlink(sftp, path, target, maxlen) \
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \
-    LIBSSH2_SFTP_READLINK)
-#define libssh2_sftp_realpath(sftp, path, target, maxlen) \
-    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \
-                            LIBSSH2_SFTP_REALPATH)
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* LIBSSH2_SFTP_H */
diff --git a/libssh2/libssh2/install-sh b/libssh2/libssh2/install-sh
deleted file mode 100755
index ec298b53..00000000
--- a/libssh2/libssh2/install-sh
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/bin/sh
-# install - install a program, script, or datafile
-
-scriptversion=2020-11-14.01; # UTC
-
-# This originates from X11R5 (mit/util/scripts/install.sh), which was
-# later released in X11R6 (xc/config/util/install.sh) with the
-# following copyright and license.
-#
-# Copyright (C) 1994 X Consortium
-#
-# 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
-# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
-# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Except as contained in this notice, the name of the X Consortium shall not
-# be used in advertising or otherwise to promote the sale, use or other deal-
-# ings in this Software without prior written authorization from the X Consor-
-# tium.
-#
-#
-# FSF changes to this file are in the public domain.
-#
-# Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
-# when there is no Makefile.
-#
-# This script is compatible with the BSD install script, but was written
-# from scratch.
-
-tab='	'
-nl='
-'
-IFS=" $tab$nl"
-
-# Set DOITPROG to "echo" to test this script.
-
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
-
-# Put in absolute file names if you don't have them in your path;
-# or use environment vars.
-
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
-
-posix_mkdir=
-
-# Desired mode of installed file.
-mode=0755
-
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
-chmodcmd=$chmodprog
-chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
-stripcmd=
-
-src=
-dst=
-dir_arg=
-dst_arg=
-
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
-   or: $0 [OPTION]... SRCFILES... DIRECTORY
-   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
-   or: $0 [OPTION]... -d DIRECTORIES...
-
-In the 1st form, copy SRCFILE to DSTFILE.
-In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
-In the 4th, create DIRECTORIES.
-
-Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
-
-Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
-"
-
-while test $# -ne 0; do
-  case $1 in
-    -c) ;;
-
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
-
-    -g) chgrpcmd="$chgrpprog $2"
-        shift;;
-
-    --help) echo "$usage"; exit $?;;
-
-    -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
-
-    -o) chowncmd="$chownprog $2"
-        shift;;
-
-    -p) cpprog="$cpprog -p";;
-
-    -s) stripcmd=$stripprog;;
-
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
-
-    --version) echo "$0 $scriptversion"; exit $?;;
-
-    --) shift
-        break;;
-
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
-
-    *)  break;;
-  esac
-  shift
-done
-
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
-  # When -d is used, all remaining arguments are directories to create.
-  # When -t is used, the destination is already specified.
-  # Otherwise, the last argument is the destination.  Remove it from $@.
-  for arg
-  do
-    if test -n "$dst_arg"; then
-      # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
-      shift # fnord
-    fi
-    shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
-  done
-fi
-
-if test $# -eq 0; then
-  if test -z "$dir_arg"; then
-    echo "$0: no input file specified." >&2
-    exit 1
-  fi
-  # It's OK to call 'install-sh -d' without argument.
-  # This can happen when creating conditional directories.
-  exit 0
-fi
-
-if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
-
-  # Set umask so as not to create temps with too-generous modes.
-  # However, 'strip' requires both read and write access to temps.
-  case $mode in
-    # Optimize common cases.
-    *644) cp_umask=133;;
-    *755) cp_umask=22;;
-
-    *[0-7])
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw='% 200'
-      fi
-      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
-    *)
-      if test -z "$stripcmd"; then
-        u_plus_rw=
-      else
-        u_plus_rw=,u+rw
-      fi
-      cp_umask=$mode$u_plus_rw;;
-  esac
-fi
-
-for src
-do
-  # Protect names problematic for 'test' and other utilities.
-  case $src in
-    -* | [=\(\)!]) src=./$src;;
-  esac
-
-  if test -n "$dir_arg"; then
-    dst=$src
-    dstdir=$dst
-    test -d "$dstdir"
-    dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
-  else
-
-    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
-    # might cause directories to be created, which would be especially bad
-    # if $src (and thus $dsttmp) contains '*'.
-    if test ! -f "$src" && test ! -d "$src"; then
-      echo "$0: $src does not exist." >&2
-      exit 1
-    fi
-
-    if test -z "$dst_arg"; then
-      echo "$0: no destination specified." >&2
-      exit 1
-    fi
-    dst=$dst_arg
-
-    # If destination is a directory, append the input filename.
-    if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
-      fi
-      dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
-      dstdir_status=0
-    else
-      dstdir=`dirname "$dst"`
-      test -d "$dstdir"
-      dstdir_status=$?
-    fi
-  fi
-
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
-  obsolete_mkdir_used=false
-
-  if test $dstdir_status != 0; then
-    case $posix_mkdir in
-      '')
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
-
-        posix_mkdir=false
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
-	then
-	  if test -z "$dir_arg" || {
-	       # Check for POSIX incompatibilities with -m.
-	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-	       # other-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
-	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
-	fi
-	trap '' 0;;
-    esac
-
-    if
-      $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
-      )
-    then :
-    else
-
-      # mkdir does not conform to POSIX,
-      # or it failed possibly due to a race condition.  Create the
-      # directory the slow way, step by step, checking for races as we go.
-
-      case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
-      esac
-
-      oIFS=$IFS
-      IFS=/
-      set -f
-      set fnord $dstdir
-      shift
-      set +f
-      IFS=$oIFS
-
-      prefixes=
-
-      for d
-      do
-        test X"$d" = X && continue
-
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask $mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
-      done
-
-      if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
-      fi
-    fi
-  fi
-
-  if test -n "$dir_arg"; then
-    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
-    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
-      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
-  else
-
-    # Make a couple of temp file names in the proper directory.
-    dsttmp=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_rm.$$_
-
-    # Trap to clean up those temp files at exit.
-    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
-
-    # Copy the file name to the temp name.
-    (umask $cp_umask &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $doit_exec $cpprog "$src" "$dsttmp") &&
-
-    # and set any options; do chmod last to preserve setuid bits.
-    #
-    # If any of these fail, we abort the whole thing.  If we want to
-    # ignore errors from any of these, just make sure not to ignore
-    # errors from the above "$doit $cpprog $src $dsttmp" command.
-    #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
-
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
-
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
-
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
-
-    trap '' 0
-  fi
-done
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/libssh2/libssh2/libssh2.pc.in b/libssh2/libssh2/libssh2.pc.in
deleted file mode 100644
index 96638167..00000000
--- a/libssh2/libssh2/libssh2.pc.in
+++ /dev/null
@@ -1,17 +0,0 @@
-###########################################################################
-# libssh2 installation details
-###########################################################################
-
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: libssh2
-URL: https://www.libssh2.org/
-Description: Library for SSH-based communication
-Version: @LIBSSH2VER@
-Requires.private: @LIBSREQUIRED@
-Libs: -L${libdir} -lssh2 @LIBS@
-Libs.private: @LIBS@
-Cflags: -I${includedir}
diff --git a/libssh2/libssh2/ltmain.sh b/libssh2/libssh2/ltmain.sh
deleted file mode 100755
index 21e5e078..00000000
--- a/libssh2/libssh2/ltmain.sh
+++ /dev/null
@@ -1,11251 +0,0 @@
-#! /bin/sh
-## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
-##               by inline-source v2014-01-03.01
-
-# libtool (GNU libtool) 2.4.6
-# Provide generalized library-building support services.
-# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
-
-# Copyright (C) 1996-2015 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# GNU Libtool is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# As a special exception to the GNU General Public License,
-# if you distribute this file as part of a program or library that
-# is built using GNU Libtool, you may include this file under the
-# same distribution terms that you use for the rest of that program.
-#
-# GNU Libtool is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-PROGRAM=libtool
-PACKAGE=libtool
-VERSION="2.4.6 Debian-2.4.6-15"
-package_revision=2.4.6
-
-
-## ------ ##
-## Usage. ##
-## ------ ##
-
-# Run './libtool --help' for help with using this script from the
-# command line.
-
-
-## ------------------------------- ##
-## User overridable command paths. ##
-## ------------------------------- ##
-
-# After configure completes, it has a better idea of some of the
-# shell tools we need than the defaults used by the functions shared
-# with bootstrap, so set those here where they can still be over-
-# ridden by the user, but otherwise take precedence.
-
-: ${AUTOCONF="autoconf"}
-: ${AUTOMAKE="automake"}
-
-
-## -------------------------- ##
-## Source external libraries. ##
-## -------------------------- ##
-
-# Much of our low-level functionality needs to be sourced from external
-# libraries, which are installed to $pkgauxdir.
-
-# Set a version string for this script.
-scriptversion=2015-01-20.17; # UTC
-
-# General shell script boiler plate, and helper functions.
-# Written by Gary V. Vaughan, 2004
-
-# Copyright (C) 2004-2015 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-
-# As a special exception to the GNU General Public License, if you distribute
-# this file as part of a program or library that is built using GNU Libtool,
-# you may include this file under the same distribution terms that you use
-# for the rest of that program.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
-# General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-# Please report bugs or propose patches to gary@gnu.org.
-
-
-## ------ ##
-## Usage. ##
-## ------ ##
-
-# Evaluate this file near the top of your script to gain access to
-# the functions and variables defined here:
-#
-#   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
-#
-# If you need to override any of the default environment variable
-# settings, do that before evaluating this file.
-
-
-## -------------------- ##
-## Shell normalisation. ##
-## -------------------- ##
-
-# Some shells need a little help to be as Bourne compatible as possible.
-# Before doing anything else, make sure all that help has been provided!
-
-DUALCASE=1; export DUALCASE # for MKS sh
-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-  emulate sh
-  NULLCMD=:
-  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '${1+"$@"}'='"$@"'
-  setopt NO_GLOB_SUBST
-else
-  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
-fi
-
-# NLS nuisances: We save the old values in case they are required later.
-_G_user_locale=
-_G_safe_locale=
-for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
-do
-  eval "if test set = \"\${$_G_var+set}\"; then
-          save_$_G_var=\$$_G_var
-          $_G_var=C
-	  export $_G_var
-	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
-	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
-	fi"
-done
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-# Make sure IFS has a sensible default
-sp=' '
-nl='
-'
-IFS="$sp	$nl"
-
-# There are apparently some retarded systems that use ';' as a PATH separator!
-if test "${PATH_SEPARATOR+set}" != set; then
-  PATH_SEPARATOR=:
-  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-      PATH_SEPARATOR=';'
-  }
-fi
-
-
-
-## ------------------------- ##
-## Locate command utilities. ##
-## ------------------------- ##
-
-
-# func_executable_p FILE
-# ----------------------
-# Check that FILE is an executable regular file.
-func_executable_p ()
-{
-    test -f "$1" && test -x "$1"
-}
-
-
-# func_path_progs PROGS_LIST CHECK_FUNC [PATH]
-# --------------------------------------------
-# Search for either a program that responds to --version with output
-# containing "GNU", or else returned by CHECK_FUNC otherwise, by
-# trying all the directories in PATH with each of the elements of
-# PROGS_LIST.
-#
-# CHECK_FUNC should accept the path to a candidate program, and
-# set $func_check_prog_result if it truncates its output less than
-# $_G_path_prog_max characters.
-func_path_progs ()
-{
-    _G_progs_list=$1
-    _G_check_func=$2
-    _G_PATH=${3-"$PATH"}
-
-    _G_path_prog_max=0
-    _G_path_prog_found=false
-    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
-    for _G_dir in $_G_PATH; do
-      IFS=$_G_save_IFS
-      test -z "$_G_dir" && _G_dir=.
-      for _G_prog_name in $_G_progs_list; do
-        for _exeext in '' .EXE; do
-          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
-          func_executable_p "$_G_path_prog" || continue
-          case `"$_G_path_prog" --version 2>&1` in
-            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
-            *)     $_G_check_func $_G_path_prog
-		   func_path_progs_result=$func_check_prog_result
-		   ;;
-          esac
-          $_G_path_prog_found && break 3
-        done
-      done
-    done
-    IFS=$_G_save_IFS
-    test -z "$func_path_progs_result" && {
-      echo "no acceptable sed could be found in \$PATH" >&2
-      exit 1
-    }
-}
-
-
-# We want to be able to use the functions in this file before configure
-# has figured out where the best binaries are kept, which means we have
-# to search for them ourselves - except when the results are already set
-# where we skip the searches.
-
-# Unless the user overrides by setting SED, search the path for either GNU
-# sed, or the sed that truncates its output the least.
-test -z "$SED" && {
-  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-  for _G_i in 1 2 3 4 5 6 7; do
-    _G_sed_script=$_G_sed_script$nl$_G_sed_script
-  done
-  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
-  _G_sed_script=
-
-  func_check_prog_sed ()
-  {
-    _G_path_prog=$1
-
-    _G_count=0
-    printf 0123456789 >conftest.in
-    while :
-    do
-      cat conftest.in conftest.in >conftest.tmp
-      mv conftest.tmp conftest.in
-      cp conftest.in conftest.nl
-      echo '' >> conftest.nl
-      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
-      diff conftest.out conftest.nl >/dev/null 2>&1 || break
-      _G_count=`expr $_G_count + 1`
-      if test "$_G_count" -gt "$_G_path_prog_max"; then
-        # Best one so far, save it but keep looking for a better one
-        func_check_prog_result=$_G_path_prog
-        _G_path_prog_max=$_G_count
-      fi
-      # 10*(2^10) chars as input seems more than enough
-      test 10 -lt "$_G_count" && break
-    done
-    rm -f conftest.in conftest.tmp conftest.nl conftest.out
-  }
-
-  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
-  rm -f conftest.sed
-  SED=$func_path_progs_result
-}
-
-
-# Unless the user overrides by setting GREP, search the path for either GNU
-# grep, or the grep that truncates its output the least.
-test -z "$GREP" && {
-  func_check_prog_grep ()
-  {
-    _G_path_prog=$1
-
-    _G_count=0
-    _G_path_prog_max=0
-    printf 0123456789 >conftest.in
-    while :
-    do
-      cat conftest.in conftest.in >conftest.tmp
-      mv conftest.tmp conftest.in
-      cp conftest.in conftest.nl
-      echo 'GREP' >> conftest.nl
-      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
-      diff conftest.out conftest.nl >/dev/null 2>&1 || break
-      _G_count=`expr $_G_count + 1`
-      if test "$_G_count" -gt "$_G_path_prog_max"; then
-        # Best one so far, save it but keep looking for a better one
-        func_check_prog_result=$_G_path_prog
-        _G_path_prog_max=$_G_count
-      fi
-      # 10*(2^10) chars as input seems more than enough
-      test 10 -lt "$_G_count" && break
-    done
-    rm -f conftest.in conftest.tmp conftest.nl conftest.out
-  }
-
-  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
-  GREP=$func_path_progs_result
-}
-
-
-## ------------------------------- ##
-## User overridable command paths. ##
-## ------------------------------- ##
-
-# All uppercase variable names are used for environment variables.  These
-# variables can be overridden by the user before calling a script that
-# uses them if a suitable command of that name is not already available
-# in the command search PATH.
-
-: ${CP="cp -f"}
-: ${ECHO="printf %s\n"}
-: ${EGREP="$GREP -E"}
-: ${FGREP="$GREP -F"}
-: ${LN_S="ln -s"}
-: ${MAKE="make"}
-: ${MKDIR="mkdir"}
-: ${MV="mv -f"}
-: ${RM="rm -f"}
-: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
-
-
-## -------------------- ##
-## Useful sed snippets. ##
-## -------------------- ##
-
-sed_dirname='s|/[^/]*$||'
-sed_basename='s|^.*/||'
-
-# Sed substitution that helps us do robust quoting.  It backslashifies
-# metacharacters that are still active within double-quoted strings.
-sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
-
-# Same as above, but do not quote variable references.
-sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
-
-# Sed substitution that turns a string into a regex matching for the
-# string literally.
-sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
-
-# Sed substitution that converts a w32 file name or path
-# that contains forward slashes, into one that contains
-# (escaped) backslashes.  A very naive implementation.
-sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
-
-# Re-'\' parameter expansions in output of sed_double_quote_subst that
-# were '\'-ed in input to the same.  If an odd number of '\' preceded a
-# '$' in input to sed_double_quote_subst, that '$' was protected from
-# expansion.  Since each input '\' is now two '\'s, look for any number
-# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
-_G_bs='\\'
-_G_bs2='\\\\'
-_G_bs4='\\\\\\\\'
-_G_dollar='\$'
-sed_double_backslash="\
-  s/$_G_bs4/&\\
-/g
-  s/^$_G_bs2$_G_dollar/$_G_bs&/
-  s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
-  s/\n//g"
-
-
-## ----------------- ##
-## Global variables. ##
-## ----------------- ##
-
-# Except for the global variables explicitly listed below, the following
-# functions in the '^func_' namespace, and the '^require_' namespace
-# variables initialised in the 'Resource management' section, sourcing
-# this file will not pollute your global namespace with anything
-# else. There's no portable way to scope variables in Bourne shell
-# though, so actually running these functions will sometimes place
-# results into a variable named after the function, and often use
-# temporary variables in the '^_G_' namespace. If you are careful to
-# avoid using those namespaces casually in your sourcing script, things
-# should continue to work as you expect. And, of course, you can freely
-# overwrite any of the functions or variables defined here before
-# calling anything to customize them.
-
-EXIT_SUCCESS=0
-EXIT_FAILURE=1
-EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
-EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
-
-# Allow overriding, eg assuming that you follow the convention of
-# putting '$debug_cmd' at the start of all your functions, you can get
-# bash to show function call trace with:
-#
-#    debug_cmd='echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
-debug_cmd=${debug_cmd-":"}
-exit_cmd=:
-
-# By convention, finish your script with:
-#
-#    exit $exit_status
-#
-# so that you can set exit_status to non-zero if you want to indicate
-# something went wrong during execution without actually bailing out at
-# the point of failure.
-exit_status=$EXIT_SUCCESS
-
-# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
-# is ksh but when the shell is invoked as "sh" and the current value of
-# the _XPG environment variable is not equal to 1 (one), the special
-# positional parameter $0, within a function call, is the name of the
-# function.
-progpath=$0
-
-# The name of this program.
-progname=`$ECHO "$progpath" |$SED "$sed_basename"`
-
-# Make sure we have an absolute progpath for reexecution:
-case $progpath in
-  [\\/]*|[A-Za-z]:\\*) ;;
-  *[\\/]*)
-     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
-     progdir=`cd "$progdir" && pwd`
-     progpath=$progdir/$progname
-     ;;
-  *)
-     _G_IFS=$IFS
-     IFS=${PATH_SEPARATOR-:}
-     for progdir in $PATH; do
-       IFS=$_G_IFS
-       test -x "$progdir/$progname" && break
-     done
-     IFS=$_G_IFS
-     test -n "$progdir" || progdir=`pwd`
-     progpath=$progdir/$progname
-     ;;
-esac
-
-
-## ----------------- ##
-## Standard options. ##
-## ----------------- ##
-
-# The following options affect the operation of the functions defined
-# below, and should be set appropriately depending on run-time para-
-# meters passed on the command line.
-
-opt_dry_run=false
-opt_quiet=false
-opt_verbose=false
-
-# Categories 'all' and 'none' are always available.  Append any others
-# you will pass as the first argument to func_warning from your own
-# code.
-warning_categories=
-
-# By default, display warnings according to 'opt_warning_types'.  Set
-# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
-# treat the next displayed warning as a fatal error.
-warning_func=func_warn_and_continue
-
-# Set to 'all' to display all warnings, 'none' to suppress all
-# warnings, or a space delimited list of some subset of
-# 'warning_categories' to display only the listed warnings.
-opt_warning_types=all
-
-
-## -------------------- ##
-## Resource management. ##
-## -------------------- ##
-
-# This section contains definitions for functions that each ensure a
-# particular resource (a file, or a non-empty configuration variable for
-# example) is available, and if appropriate to extract default values
-# from pertinent package files. Call them using their associated
-# 'require_*' variable to ensure that they are executed, at most, once.
-#
-# It's entirely deliberate that calling these functions can set
-# variables that don't obey the namespace limitations obeyed by the rest
-# of this file, in order that that they be as useful as possible to
-# callers.
-
-
-# require_term_colors
-# -------------------
-# Allow display of bold text on terminals that support it.
-require_term_colors=func_require_term_colors
-func_require_term_colors ()
-{
-    $debug_cmd
-
-    test -t 1 && {
-      # COLORTERM and USE_ANSI_COLORS environment variables take
-      # precedence, because most terminfo databases neglect to describe
-      # whether color sequences are supported.
-      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
-
-      if test 1 = "$USE_ANSI_COLORS"; then
-        # Standard ANSI escape sequences
-        tc_reset=''
-        tc_bold='';   tc_standout=''
-        tc_red='';   tc_green=''
-        tc_blue='';  tc_cyan=''
-      else
-        # Otherwise trust the terminfo database after all.
-        test -n "`tput sgr0 2>/dev/null`" && {
-          tc_reset=`tput sgr0`
-          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
-          tc_standout=$tc_bold
-          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
-          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
-          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
-          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
-          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
-        }
-      fi
-    }
-
-    require_term_colors=:
-}
-
-
-## ----------------- ##
-## Function library. ##
-## ----------------- ##
-
-# This section contains a variety of useful functions to call in your
-# scripts. Take note of the portable wrappers for features provided by
-# some modern shells, which will fall back to slower equivalents on
-# less featureful shells.
-
-
-# func_append VAR VALUE
-# ---------------------
-# Append VALUE onto the existing contents of VAR.
-
-  # We should try to minimise forks, especially on Windows where they are
-  # unreasonably slow, so skip the feature probes when bash or zsh are
-  # being used:
-  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
-    : ${_G_HAVE_ARITH_OP="yes"}
-    : ${_G_HAVE_XSI_OPS="yes"}
-    # The += operator was introduced in bash 3.1
-    case $BASH_VERSION in
-      [12].* | 3.0 | 3.0*) ;;
-      *)
-        : ${_G_HAVE_PLUSEQ_OP="yes"}
-        ;;
-    esac
-  fi
-
-  # _G_HAVE_PLUSEQ_OP
-  # Can be empty, in which case the shell is probed, "yes" if += is
-  # useable or anything else if it does not work.
-  test -z "$_G_HAVE_PLUSEQ_OP" \
-    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
-    && _G_HAVE_PLUSEQ_OP=yes
-
-if test yes = "$_G_HAVE_PLUSEQ_OP"
-then
-  # This is an XSI compatible shell, allowing a faster implementation...
-  eval 'func_append ()
-  {
-    $debug_cmd
-
-    eval "$1+=\$2"
-  }'
-else
-  # ...otherwise fall back to using expr, which is often a shell builtin.
-  func_append ()
-  {
-    $debug_cmd
-
-    eval "$1=\$$1\$2"
-  }
-fi
-
-
-# func_append_quoted VAR VALUE
-# ----------------------------
-# Quote VALUE and append to the end of shell variable VAR, separated
-# by a space.
-if test yes = "$_G_HAVE_PLUSEQ_OP"; then
-  eval 'func_append_quoted ()
-  {
-    $debug_cmd
-
-    func_quote_for_eval "$2"
-    eval "$1+=\\ \$func_quote_for_eval_result"
-  }'
-else
-  func_append_quoted ()
-  {
-    $debug_cmd
-
-    func_quote_for_eval "$2"
-    eval "$1=\$$1\\ \$func_quote_for_eval_result"
-  }
-fi
-
-
-# func_append_uniq VAR VALUE
-# --------------------------
-# Append unique VALUE onto the existing contents of VAR, assuming
-# entries are delimited by the first character of VALUE.  For example:
-#
-#   func_append_uniq options " --another-option option-argument"
-#
-# will only append to $options if " --another-option option-argument "
-# is not already present somewhere in $options already (note spaces at
-# each end implied by leading space in second argument).
-func_append_uniq ()
-{
-    $debug_cmd
-
-    eval _G_current_value='`$ECHO $'$1'`'
-    _G_delim=`expr "$2" : '\(.\)'`
-
-    case $_G_delim$_G_current_value$_G_delim in
-      *"$2$_G_delim"*) ;;
-      *) func_append "$@" ;;
-    esac
-}
-
-
-# func_arith TERM...
-# ------------------
-# Set func_arith_result to the result of evaluating TERMs.
-  test -z "$_G_HAVE_ARITH_OP" \
-    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
-    && _G_HAVE_ARITH_OP=yes
-
-if test yes = "$_G_HAVE_ARITH_OP"; then
-  eval 'func_arith ()
-  {
-    $debug_cmd
-
-    func_arith_result=$(( $* ))
-  }'
-else
-  func_arith ()
-  {
-    $debug_cmd
-
-    func_arith_result=`expr "$@"`
-  }
-fi
-
-
-# func_basename FILE
-# ------------------
-# Set func_basename_result to FILE with everything up to and including
-# the last / stripped.
-if test yes = "$_G_HAVE_XSI_OPS"; then
-  # If this shell supports suffix pattern removal, then use it to avoid
-  # forking. Hide the definitions single quotes in case the shell chokes
-  # on unsupported syntax...
-  _b='func_basename_result=${1##*/}'
-  _d='case $1 in
-        */*) func_dirname_result=${1%/*}$2 ;;
-        *  ) func_dirname_result=$3        ;;
-      esac'
-
-else
-  # ...otherwise fall back to using sed.
-  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
-  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
-      if test "X$func_dirname_result" = "X$1"; then
-        func_dirname_result=$3
-      else
-        func_append func_dirname_result "$2"
-      fi'
-fi
-
-eval 'func_basename ()
-{
-    $debug_cmd
-
-    '"$_b"'
-}'
-
-
-# func_dirname FILE APPEND NONDIR_REPLACEMENT
-# -------------------------------------------
-# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
-# otherwise set result to NONDIR_REPLACEMENT.
-eval 'func_dirname ()
-{
-    $debug_cmd
-
-    '"$_d"'
-}'
-
-
-# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
-# --------------------------------------------------------
-# Perform func_basename and func_dirname in a single function
-# call:
-#   dirname:  Compute the dirname of FILE.  If nonempty,
-#             add APPEND to the result, otherwise set result
-#             to NONDIR_REPLACEMENT.
-#             value returned in "$func_dirname_result"
-#   basename: Compute filename of FILE.
-#             value retuned in "$func_basename_result"
-# For efficiency, we do not delegate to the functions above but instead
-# duplicate the functionality here.
-eval 'func_dirname_and_basename ()
-{
-    $debug_cmd
-
-    '"$_b"'
-    '"$_d"'
-}'
-
-
-# func_echo ARG...
-# ----------------
-# Echo program name prefixed message.
-func_echo ()
-{
-    $debug_cmd
-
-    _G_message=$*
-
-    func_echo_IFS=$IFS
-    IFS=$nl
-    for _G_line in $_G_message; do
-      IFS=$func_echo_IFS
-      $ECHO "$progname: $_G_line"
-    done
-    IFS=$func_echo_IFS
-}
-
-
-# func_echo_all ARG...
-# --------------------
-# Invoke $ECHO with all args, space-separated.
-func_echo_all ()
-{
-    $ECHO "$*"
-}
-
-
-# func_echo_infix_1 INFIX ARG...
-# ------------------------------
-# Echo program name, followed by INFIX on the first line, with any
-# additional lines not showing INFIX.
-func_echo_infix_1 ()
-{
-    $debug_cmd
-
-    $require_term_colors
-
-    _G_infix=$1; shift
-    _G_indent=$_G_infix
-    _G_prefix="$progname: $_G_infix: "
-    _G_message=$*
-
-    # Strip color escape sequences before counting printable length
-    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
-    do
-      test -n "$_G_tc" && {
-        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
-        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
-      }
-    done
-    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
-
-    func_echo_infix_1_IFS=$IFS
-    IFS=$nl
-    for _G_line in $_G_message; do
-      IFS=$func_echo_infix_1_IFS
-      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
-      _G_prefix=$_G_indent
-    done
-    IFS=$func_echo_infix_1_IFS
-}
-
-
-# func_error ARG...
-# -----------------
-# Echo program name prefixed message to standard error.
-func_error ()
-{
-    $debug_cmd
-
-    $require_term_colors
-
-    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
-}
-
-
-# func_fatal_error ARG...
-# -----------------------
-# Echo program name prefixed message to standard error, and exit.
-func_fatal_error ()
-{
-    $debug_cmd
-
-    func_error "$*"
-    exit $EXIT_FAILURE
-}
-
-
-# func_grep EXPRESSION FILENAME
-# -----------------------------
-# Check whether EXPRESSION matches any line of FILENAME, without output.
-func_grep ()
-{
-    $debug_cmd
-
-    $GREP "$1" "$2" >/dev/null 2>&1
-}
-
-
-# func_len STRING
-# ---------------
-# Set func_len_result to the length of STRING. STRING may not
-# start with a hyphen.
-  test -z "$_G_HAVE_XSI_OPS" \
-    && (eval 'x=a/b/c;
-      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
-    && _G_HAVE_XSI_OPS=yes
-
-if test yes = "$_G_HAVE_XSI_OPS"; then
-  eval 'func_len ()
-  {
-    $debug_cmd
-
-    func_len_result=${#1}
-  }'
-else
-  func_len ()
-  {
-    $debug_cmd
-
-    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
-  }
-fi
-
-
-# func_mkdir_p DIRECTORY-PATH
-# ---------------------------
-# Make sure the entire path to DIRECTORY-PATH is available.
-func_mkdir_p ()
-{
-    $debug_cmd
-
-    _G_directory_path=$1
-    _G_dir_list=
-
-    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
-
-      # Protect directory names starting with '-'
-      case $_G_directory_path in
-        -*) _G_directory_path=./$_G_directory_path ;;
-      esac
-
-      # While some portion of DIR does not yet exist...
-      while test ! -d "$_G_directory_path"; do
-        # ...make a list in topmost first order.  Use a colon delimited
-	# list incase some portion of path contains whitespace.
-        _G_dir_list=$_G_directory_path:$_G_dir_list
-
-        # If the last portion added has no slash in it, the list is done
-        case $_G_directory_path in */*) ;; *) break ;; esac
-
-        # ...otherwise throw away the child directory and loop
-        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
-      done
-      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
-
-      func_mkdir_p_IFS=$IFS; IFS=:
-      for _G_dir in $_G_dir_list; do
-	IFS=$func_mkdir_p_IFS
-        # mkdir can fail with a 'File exist' error if two processes
-        # try to create one of the directories concurrently.  Don't
-        # stop in that case!
-        $MKDIR "$_G_dir" 2>/dev/null || :
-      done
-      IFS=$func_mkdir_p_IFS
-
-      # Bail out if we (or some other process) failed to create a directory.
-      test -d "$_G_directory_path" || \
-        func_fatal_error "Failed to create '$1'"
-    fi
-}
-
-
-# func_mktempdir [BASENAME]
-# -------------------------
-# Make a temporary directory that won't clash with other running
-# libtool processes, and avoids race conditions if possible.  If
-# given, BASENAME is the basename for that directory.
-func_mktempdir ()
-{
-    $debug_cmd
-
-    _G_template=${TMPDIR-/tmp}/${1-$progname}
-
-    if test : = "$opt_dry_run"; then
-      # Return a directory name, but don't create it in dry-run mode
-      _G_tmpdir=$_G_template-$$
-    else
-
-      # If mktemp works, use that first and foremost
-      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
-
-      if test ! -d "$_G_tmpdir"; then
-        # Failing that, at least try and use $RANDOM to avoid a race
-        _G_tmpdir=$_G_template-${RANDOM-0}$$
-
-        func_mktempdir_umask=`umask`
-        umask 0077
-        $MKDIR "$_G_tmpdir"
-        umask $func_mktempdir_umask
-      fi
-
-      # If we're not in dry-run mode, bomb out on failure
-      test -d "$_G_tmpdir" || \
-        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
-    fi
-
-    $ECHO "$_G_tmpdir"
-}
-
-
-# func_normal_abspath PATH
-# ------------------------
-# Remove doubled-up and trailing slashes, "." path components,
-# and cancel out any ".." path components in PATH after making
-# it an absolute path.
-func_normal_abspath ()
-{
-    $debug_cmd
-
-    # These SED scripts presuppose an absolute path with a trailing slash.
-    _G_pathcar='s|^/\([^/]*\).*$|\1|'
-    _G_pathcdr='s|^/[^/]*||'
-    _G_removedotparts=':dotsl
-		s|/\./|/|g
-		t dotsl
-		s|/\.$|/|'
-    _G_collapseslashes='s|/\{1,\}|/|g'
-    _G_finalslash='s|/*$|/|'
-
-    # Start from root dir and reassemble the path.
-    func_normal_abspath_result=
-    func_normal_abspath_tpath=$1
-    func_normal_abspath_altnamespace=
-    case $func_normal_abspath_tpath in
-      "")
-        # Empty path, that just means $cwd.
-        func_stripname '' '/' "`pwd`"
-        func_normal_abspath_result=$func_stripname_result
-        return
-        ;;
-      # The next three entries are used to spot a run of precisely
-      # two leading slashes without using negated character classes;
-      # we take advantage of case's first-match behaviour.
-      ///*)
-        # Unusual form of absolute path, do nothing.
-        ;;
-      //*)
-        # Not necessarily an ordinary path; POSIX reserves leading '//'
-        # and for example Cygwin uses it to access remote file shares
-        # over CIFS/SMB, so we conserve a leading double slash if found.
-        func_normal_abspath_altnamespace=/
-        ;;
-      /*)
-        # Absolute path, do nothing.
-        ;;
-      *)
-        # Relative path, prepend $cwd.
-        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
-        ;;
-    esac
-
-    # Cancel out all the simple stuff to save iterations.  We also want
-    # the path to end with a slash for ease of parsing, so make sure
-    # there is one (and only one) here.
-    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
-    while :; do
-      # Processed it all yet?
-      if test / = "$func_normal_abspath_tpath"; then
-        # If we ascended to the root using ".." the result may be empty now.
-        if test -z "$func_normal_abspath_result"; then
-          func_normal_abspath_result=/
-        fi
-        break
-      fi
-      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
-          -e "$_G_pathcar"`
-      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-          -e "$_G_pathcdr"`
-      # Figure out what to do with it
-      case $func_normal_abspath_tcomponent in
-        "")
-          # Trailing empty path component, ignore it.
-          ;;
-        ..)
-          # Parent dir; strip last assembled component from result.
-          func_dirname "$func_normal_abspath_result"
-          func_normal_abspath_result=$func_dirname_result
-          ;;
-        *)
-          # Actual path component, append it.
-          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
-          ;;
-      esac
-    done
-    # Restore leading double-slash if one was found on entry.
-    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
-}
-
-
-# func_notquiet ARG...
-# --------------------
-# Echo program name prefixed message only when not in quiet mode.
-func_notquiet ()
-{
-    $debug_cmd
-
-    $opt_quiet || func_echo ${1+"$@"}
-
-    # A bug in bash halts the script if the last line of a function
-    # fails when set -e is in force, so we need another command to
-    # work around that:
-    :
-}
-
-
-# func_relative_path SRCDIR DSTDIR
-# --------------------------------
-# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
-func_relative_path ()
-{
-    $debug_cmd
-
-    func_relative_path_result=
-    func_normal_abspath "$1"
-    func_relative_path_tlibdir=$func_normal_abspath_result
-    func_normal_abspath "$2"
-    func_relative_path_tbindir=$func_normal_abspath_result
-
-    # Ascend the tree starting from libdir
-    while :; do
-      # check if we have found a prefix of bindir
-      case $func_relative_path_tbindir in
-        $func_relative_path_tlibdir)
-          # found an exact match
-          func_relative_path_tcancelled=
-          break
-          ;;
-        $func_relative_path_tlibdir*)
-          # found a matching prefix
-          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
-          func_relative_path_tcancelled=$func_stripname_result
-          if test -z "$func_relative_path_result"; then
-            func_relative_path_result=.
-          fi
-          break
-          ;;
-        *)
-          func_dirname $func_relative_path_tlibdir
-          func_relative_path_tlibdir=$func_dirname_result
-          if test -z "$func_relative_path_tlibdir"; then
-            # Have to descend all the way to the root!
-            func_relative_path_result=../$func_relative_path_result
-            func_relative_path_tcancelled=$func_relative_path_tbindir
-            break
-          fi
-          func_relative_path_result=../$func_relative_path_result
-          ;;
-      esac
-    done
-
-    # Now calculate path; take care to avoid doubling-up slashes.
-    func_stripname '' '/' "$func_relative_path_result"
-    func_relative_path_result=$func_stripname_result
-    func_stripname '/' '/' "$func_relative_path_tcancelled"
-    if test -n "$func_stripname_result"; then
-      func_append func_relative_path_result "/$func_stripname_result"
-    fi
-
-    # Normalisation. If bindir is libdir, return '.' else relative path.
-    if test -n "$func_relative_path_result"; then
-      func_stripname './' '' "$func_relative_path_result"
-      func_relative_path_result=$func_stripname_result
-    fi
-
-    test -n "$func_relative_path_result" || func_relative_path_result=.
-
-    :
-}
-
-
-# func_quote_for_eval ARG...
-# --------------------------
-# Aesthetically quote ARGs to be evaled later.
-# This function returns two values:
-#   i) func_quote_for_eval_result
-#      double-quoted, suitable for a subsequent eval
-#  ii) func_quote_for_eval_unquoted_result
-#      has all characters that are still active within double
-#      quotes backslashified.
-func_quote_for_eval ()
-{
-    $debug_cmd
-
-    func_quote_for_eval_unquoted_result=
-    func_quote_for_eval_result=
-    while test 0 -lt $#; do
-      case $1 in
-        *[\\\`\"\$]*)
-	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
-        *)
-          _G_unquoted_arg=$1 ;;
-      esac
-      if test -n "$func_quote_for_eval_unquoted_result"; then
-	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
-      else
-        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
-      fi
-
-      case $_G_unquoted_arg in
-        # Double-quote args containing shell metacharacters to delay
-        # word splitting, command substitution and variable expansion
-        # for a subsequent eval.
-        # Many Bourne shells cannot handle close brackets correctly
-        # in scan sets, so we specify it separately.
-        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-          _G_quoted_arg=\"$_G_unquoted_arg\"
-          ;;
-        *)
-          _G_quoted_arg=$_G_unquoted_arg
-	  ;;
-      esac
-
-      if test -n "$func_quote_for_eval_result"; then
-	func_append func_quote_for_eval_result " $_G_quoted_arg"
-      else
-        func_append func_quote_for_eval_result "$_G_quoted_arg"
-      fi
-      shift
-    done
-}
-
-
-# func_quote_for_expand ARG
-# -------------------------
-# Aesthetically quote ARG to be evaled later; same as above,
-# but do not quote variable references.
-func_quote_for_expand ()
-{
-    $debug_cmd
-
-    case $1 in
-      *[\\\`\"]*)
-	_G_arg=`$ECHO "$1" | $SED \
-	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
-      *)
-        _G_arg=$1 ;;
-    esac
-
-    case $_G_arg in
-      # Double-quote args containing shell metacharacters to delay
-      # word splitting and command substitution for a subsequent eval.
-      # Many Bourne shells cannot handle close brackets correctly
-      # in scan sets, so we specify it separately.
-      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-        _G_arg=\"$_G_arg\"
-        ;;
-    esac
-
-    func_quote_for_expand_result=$_G_arg
-}
-
-
-# func_stripname PREFIX SUFFIX NAME
-# ---------------------------------
-# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
-# PREFIX and SUFFIX must not contain globbing or regex special
-# characters, hashes, percent signs, but SUFFIX may contain a leading
-# dot (in which case that matches only a dot).
-if test yes = "$_G_HAVE_XSI_OPS"; then
-  eval 'func_stripname ()
-  {
-    $debug_cmd
-
-    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
-    # positional parameters, so assign one to ordinary variable first.
-    func_stripname_result=$3
-    func_stripname_result=${func_stripname_result#"$1"}
-    func_stripname_result=${func_stripname_result%"$2"}
-  }'
-else
-  func_stripname ()
-  {
-    $debug_cmd
-
-    case $2 in
-      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
-      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
-    esac
-  }
-fi
-
-
-# func_show_eval CMD [FAIL_EXP]
-# -----------------------------
-# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
-# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
-# is given, then evaluate it.
-func_show_eval ()
-{
-    $debug_cmd
-
-    _G_cmd=$1
-    _G_fail_exp=${2-':'}
-
-    func_quote_for_expand "$_G_cmd"
-    eval "func_notquiet $func_quote_for_expand_result"
-
-    $opt_dry_run || {
-      eval "$_G_cmd"
-      _G_status=$?
-      if test 0 -ne "$_G_status"; then
-	eval "(exit $_G_status); $_G_fail_exp"
-      fi
-    }
-}
-
-
-# func_show_eval_locale CMD [FAIL_EXP]
-# ------------------------------------
-# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
-# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
-# is given, then evaluate it.  Use the saved locale for evaluation.
-func_show_eval_locale ()
-{
-    $debug_cmd
-
-    _G_cmd=$1
-    _G_fail_exp=${2-':'}
-
-    $opt_quiet || {
-      func_quote_for_expand "$_G_cmd"
-      eval "func_echo $func_quote_for_expand_result"
-    }
-
-    $opt_dry_run || {
-      eval "$_G_user_locale
-	    $_G_cmd"
-      _G_status=$?
-      eval "$_G_safe_locale"
-      if test 0 -ne "$_G_status"; then
-	eval "(exit $_G_status); $_G_fail_exp"
-      fi
-    }
-}
-
-
-# func_tr_sh
-# ----------
-# Turn $1 into a string suitable for a shell variable name.
-# Result is stored in $func_tr_sh_result.  All characters
-# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
-# if $1 begins with a digit, a '_' is prepended as well.
-func_tr_sh ()
-{
-    $debug_cmd
-
-    case $1 in
-    [0-9]* | *[!a-zA-Z0-9_]*)
-      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
-      ;;
-    * )
-      func_tr_sh_result=$1
-      ;;
-    esac
-}
-
-
-# func_verbose ARG...
-# -------------------
-# Echo program name prefixed message in verbose mode only.
-func_verbose ()
-{
-    $debug_cmd
-
-    $opt_verbose && func_echo "$*"
-
-    :
-}
-
-
-# func_warn_and_continue ARG...
-# -----------------------------
-# Echo program name prefixed warning message to standard error.
-func_warn_and_continue ()
-{
-    $debug_cmd
-
-    $require_term_colors
-
-    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
-}
-
-
-# func_warning CATEGORY ARG...
-# ----------------------------
-# Echo program name prefixed warning message to standard error. Warning
-# messages can be filtered according to CATEGORY, where this function
-# elides messages where CATEGORY is not listed in the global variable
-# 'opt_warning_types'.
-func_warning ()
-{
-    $debug_cmd
-
-    # CATEGORY must be in the warning_categories list!
-    case " $warning_categories " in
-      *" $1 "*) ;;
-      *) func_internal_error "invalid warning category '$1'" ;;
-    esac
-
-    _G_category=$1
-    shift
-
-    case " $opt_warning_types " in
-      *" $_G_category "*) $warning_func ${1+"$@"} ;;
-    esac
-}
-
-
-# func_sort_ver VER1 VER2
-# -----------------------
-# 'sort -V' is not generally available.
-# Note this deviates from the version comparison in automake
-# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
-# but this should suffice as we won't be specifying old
-# version formats or redundant trailing .0 in bootstrap.conf.
-# If we did want full compatibility then we should probably
-# use m4_version_compare from autoconf.
-func_sort_ver ()
-{
-    $debug_cmd
-
-    printf '%s\n%s\n' "$1" "$2" \
-      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
-}
-
-# func_lt_ver PREV CURR
-# ---------------------
-# Return true if PREV and CURR are in the correct order according to
-# func_sort_ver, otherwise false.  Use it like this:
-#
-#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
-func_lt_ver ()
-{
-    $debug_cmd
-
-    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
-}
-
-
-# Local variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
-# time-stamp-time-zone: "UTC"
-# End:
-#! /bin/sh
-
-# Set a version string for this script.
-scriptversion=2015-10-07.11; # UTC
-
-# A portable, pluggable option parser for Bourne shell.
-# Written by Gary V. Vaughan, 2010
-
-# Copyright (C) 2010-2015 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-# Please report bugs or propose patches to gary@gnu.org.
-
-
-## ------ ##
-## Usage. ##
-## ------ ##
-
-# This file is a library for parsing options in your shell scripts along
-# with assorted other useful supporting features that you can make use
-# of too.
-#
-# For the simplest scripts you might need only:
-#
-#   #!/bin/sh
-#   . relative/path/to/funclib.sh
-#   . relative/path/to/options-parser
-#   scriptversion=1.0
-#   func_options ${1+"$@"}
-#   eval set dummy "$func_options_result"; shift
-#   ...rest of your script...
-#
-# In order for the '--version' option to work, you will need to have a
-# suitably formatted comment like the one at the top of this file
-# starting with '# Written by ' and ending with '# warranty; '.
-#
-# For '-h' and '--help' to work, you will also need a one line
-# description of your script's purpose in a comment directly above the
-# '# Written by ' line, like the one at the top of this file.
-#
-# The default options also support '--debug', which will turn on shell
-# execution tracing (see the comment above debug_cmd below for another
-# use), and '--verbose' and the func_verbose function to allow your script
-# to display verbose messages only when your user has specified
-# '--verbose'.
-#
-# After sourcing this file, you can plug processing for additional
-# options by amending the variables from the 'Configuration' section
-# below, and following the instructions in the 'Option parsing'
-# section further down.
-
-## -------------- ##
-## Configuration. ##
-## -------------- ##
-
-# You should override these variables in your script after sourcing this
-# file so that they reflect the customisations you have added to the
-# option parser.
-
-# The usage line for option parsing errors and the start of '-h' and
-# '--help' output messages. You can embed shell variables for delayed
-# expansion at the time the message is displayed, but you will need to
-# quote other shell meta-characters carefully to prevent them being
-# expanded when the contents are evaled.
-usage='$progpath [OPTION]...'
-
-# Short help message in response to '-h' and '--help'.  Add to this or
-# override it after sourcing this library to reflect the full set of
-# options your script accepts.
-usage_message="\
-       --debug        enable verbose shell tracing
-   -W, --warnings=CATEGORY
-                      report the warnings falling in CATEGORY [all]
-   -v, --verbose      verbosely report processing
-       --version      print version information and exit
-   -h, --help         print short or long help message and exit
-"
-
-# Additional text appended to 'usage_message' in response to '--help'.
-long_help_message="
-Warning categories include:
-       'all'          show all warnings
-       'none'         turn off all the warnings
-       'error'        warnings are treated as fatal errors"
-
-# Help message printed before fatal option parsing errors.
-fatal_help="Try '\$progname --help' for more information."
-
-
-
-## ------------------------- ##
-## Hook function management. ##
-## ------------------------- ##
-
-# This section contains functions for adding, removing, and running hooks
-# to the main code.  A hook is just a named list of of function, that can
-# be run in order later on.
-
-# func_hookable FUNC_NAME
-# -----------------------
-# Declare that FUNC_NAME will run hooks added with
-# 'func_add_hook FUNC_NAME ...'.
-func_hookable ()
-{
-    $debug_cmd
-
-    func_append hookable_fns " $1"
-}
-
-
-# func_add_hook FUNC_NAME HOOK_FUNC
-# ---------------------------------
-# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
-# first have been declared "hookable" by a call to 'func_hookable'.
-func_add_hook ()
-{
-    $debug_cmd
-
-    case " $hookable_fns " in
-      *" $1 "*) ;;
-      *) func_fatal_error "'$1' does not accept hook functions." ;;
-    esac
-
-    eval func_append ${1}_hooks '" $2"'
-}
-
-
-# func_remove_hook FUNC_NAME HOOK_FUNC
-# ------------------------------------
-# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
-func_remove_hook ()
-{
-    $debug_cmd
-
-    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
-}
-
-
-# func_run_hooks FUNC_NAME [ARG]...
-# ---------------------------------
-# Run all hook functions registered to FUNC_NAME.
-# It is assumed that the list of hook functions contains nothing more
-# than a whitespace-delimited list of legal shell function names, and
-# no effort is wasted trying to catch shell meta-characters or preserve
-# whitespace.
-func_run_hooks ()
-{
-    $debug_cmd
-
-    _G_rc_run_hooks=false
-
-    case " $hookable_fns " in
-      *" $1 "*) ;;
-      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
-    esac
-
-    eval _G_hook_fns=\$$1_hooks; shift
-
-    for _G_hook in $_G_hook_fns; do
-      if eval $_G_hook '"$@"'; then
-        # store returned options list back into positional
-        # parameters for next 'cmd' execution.
-        eval _G_hook_result=\$${_G_hook}_result
-        eval set dummy "$_G_hook_result"; shift
-        _G_rc_run_hooks=:
-      fi
-    done
-
-    $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
-}
-
-
-
-## --------------- ##
-## Option parsing. ##
-## --------------- ##
-
-# In order to add your own option parsing hooks, you must accept the
-# full positional parameter list in your hook function, you may remove/edit
-# any options that you action, and then pass back the remaining unprocessed
-# options in '<hooked_function_name>_result', escaped suitably for
-# 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
-# hook's caller know that it should pay attention to
-# '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
-# arguments are left untouched by the hook and therefore caller will ignore the
-# result variable.
-#
-# Like this:
-#
-#    my_options_prep ()
-#    {
-#        $debug_cmd
-#
-#        # Extend the existing usage message.
-#        usage_message=$usage_message'
-#      -s, --silent       don'\''t print informational messages
-#    '
-#        # No change in '$@' (ignored completely by this hook).  There is
-#        # no need to do the equivalent (but slower) action:
-#        # func_quote_for_eval ${1+"$@"}
-#        # my_options_prep_result=$func_quote_for_eval_result
-#        false
-#    }
-#    func_add_hook func_options_prep my_options_prep
-#
-#
-#    my_silent_option ()
-#    {
-#        $debug_cmd
-#
-#        args_changed=false
-#
-#        # Note that for efficiency, we parse as many options as we can
-#        # recognise in a loop before passing the remainder back to the
-#        # caller on the first unrecognised argument we encounter.
-#        while test $# -gt 0; do
-#          opt=$1; shift
-#          case $opt in
-#            --silent|-s) opt_silent=:
-#                         args_changed=:
-#                         ;;
-#            # Separate non-argument short options:
-#            -s*)         func_split_short_opt "$_G_opt"
-#                         set dummy "$func_split_short_opt_name" \
-#                             "-$func_split_short_opt_arg" ${1+"$@"}
-#                         shift
-#                         args_changed=:
-#                         ;;
-#            *)           # Make sure the first unrecognised option "$_G_opt"
-#                         # is added back to "$@", we could need that later
-#                         # if $args_changed is true.
-#                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
-#          esac
-#        done
-#
-#        if $args_changed; then
-#          func_quote_for_eval ${1+"$@"}
-#          my_silent_option_result=$func_quote_for_eval_result
-#        fi
-#
-#        $args_changed
-#    }
-#    func_add_hook func_parse_options my_silent_option
-#
-#
-#    my_option_validation ()
-#    {
-#        $debug_cmd
-#
-#        $opt_silent && $opt_verbose && func_fatal_help "\
-#    '--silent' and '--verbose' options are mutually exclusive."
-#
-#        false
-#    }
-#    func_add_hook func_validate_options my_option_validation
-#
-# You'll also need to manually amend $usage_message to reflect the extra
-# options you parse.  It's preferable to append if you can, so that
-# multiple option parsing hooks can be added safely.
-
-
-# func_options_finish [ARG]...
-# ----------------------------
-# Finishing the option parse loop (call 'func_options' hooks ATM).
-func_options_finish ()
-{
-    $debug_cmd
-
-    _G_func_options_finish_exit=false
-    if func_run_hooks func_options ${1+"$@"}; then
-      func_options_finish_result=$func_run_hooks_result
-      _G_func_options_finish_exit=:
-    fi
-
-    $_G_func_options_finish_exit
-}
-
-
-# func_options [ARG]...
-# ---------------------
-# All the functions called inside func_options are hookable. See the
-# individual implementations for details.
-func_hookable func_options
-func_options ()
-{
-    $debug_cmd
-
-    _G_rc_options=false
-
-    for my_func in options_prep parse_options validate_options options_finish
-    do
-      if eval func_$my_func '${1+"$@"}'; then
-        eval _G_res_var='$'"func_${my_func}_result"
-        eval set dummy "$_G_res_var" ; shift
-        _G_rc_options=:
-      fi
-    done
-
-    # Save modified positional parameters for caller.  As a top-level
-    # options-parser function we always need to set the 'func_options_result'
-    # variable (regardless the $_G_rc_options value).
-    if $_G_rc_options; then
-      func_options_result=$_G_res_var
-    else
-      func_quote_for_eval ${1+"$@"}
-      func_options_result=$func_quote_for_eval_result
-    fi
-
-    $_G_rc_options
-}
-
-
-# func_options_prep [ARG]...
-# --------------------------
-# All initialisations required before starting the option parse loop.
-# Note that when calling hook functions, we pass through the list of
-# positional parameters.  If a hook function modifies that list, and
-# needs to propagate that back to rest of this script, then the complete
-# modified list must be put in 'func_run_hooks_result' before
-# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
-func_hookable func_options_prep
-func_options_prep ()
-{
-    $debug_cmd
-
-    # Option defaults:
-    opt_verbose=false
-    opt_warning_types=
-
-    _G_rc_options_prep=false
-    if func_run_hooks func_options_prep ${1+"$@"}; then
-      _G_rc_options_prep=:
-      # save modified positional parameters for caller
-      func_options_prep_result=$func_run_hooks_result
-    fi
-
-    $_G_rc_options_prep
-}
-
-
-# func_parse_options [ARG]...
-# ---------------------------
-# The main option parsing loop.
-func_hookable func_parse_options
-func_parse_options ()
-{
-    $debug_cmd
-
-    func_parse_options_result=
-
-    _G_rc_parse_options=false
-    # this just eases exit handling
-    while test $# -gt 0; do
-      # Defer to hook functions for initial option parsing, so they
-      # get priority in the event of reusing an option name.
-      if func_run_hooks func_parse_options ${1+"$@"}; then
-        eval set dummy "$func_run_hooks_result"; shift
-        _G_rc_parse_options=:
-      fi
-
-      # Break out of the loop if we already parsed every option.
-      test $# -gt 0 || break
-
-      _G_match_parse_options=:
-      _G_opt=$1
-      shift
-      case $_G_opt in
-        --debug|-x)   debug_cmd='set -x'
-                      func_echo "enabling shell trace mode"
-                      $debug_cmd
-                      ;;
-
-        --no-warnings|--no-warning|--no-warn)
-                      set dummy --warnings none ${1+"$@"}
-                      shift
-		      ;;
-
-        --warnings|--warning|-W)
-                      if test $# = 0 && func_missing_arg $_G_opt; then
-                        _G_rc_parse_options=:
-                        break
-                      fi
-                      case " $warning_categories $1" in
-                        *" $1 "*)
-                          # trailing space prevents matching last $1 above
-                          func_append_uniq opt_warning_types " $1"
-                          ;;
-                        *all)
-                          opt_warning_types=$warning_categories
-                          ;;
-                        *none)
-                          opt_warning_types=none
-                          warning_func=:
-                          ;;
-                        *error)
-                          opt_warning_types=$warning_categories
-                          warning_func=func_fatal_error
-                          ;;
-                        *)
-                          func_fatal_error \
-                             "unsupported warning category: '$1'"
-                          ;;
-                      esac
-                      shift
-                      ;;
-
-        --verbose|-v) opt_verbose=: ;;
-        --version)    func_version ;;
-        -\?|-h)       func_usage ;;
-        --help)       func_help ;;
-
-	# Separate optargs to long options (plugins may need this):
-	--*=*)        func_split_equals "$_G_opt"
-	              set dummy "$func_split_equals_lhs" \
-                          "$func_split_equals_rhs" ${1+"$@"}
-                      shift
-                      ;;
-
-       # Separate optargs to short options:
-        -W*)
-                      func_split_short_opt "$_G_opt"
-                      set dummy "$func_split_short_opt_name" \
-                          "$func_split_short_opt_arg" ${1+"$@"}
-                      shift
-                      ;;
-
-        # Separate non-argument short options:
-        -\?*|-h*|-v*|-x*)
-                      func_split_short_opt "$_G_opt"
-                      set dummy "$func_split_short_opt_name" \
-                          "-$func_split_short_opt_arg" ${1+"$@"}
-                      shift
-                      ;;
-
-        --)           _G_rc_parse_options=: ; break ;;
-        -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
-        *)            set dummy "$_G_opt" ${1+"$@"}; shift
-                      _G_match_parse_options=false
-                      break
-                      ;;
-      esac
-
-      $_G_match_parse_options && _G_rc_parse_options=:
-    done
-
-
-    if $_G_rc_parse_options; then
-      # save modified positional parameters for caller
-      func_quote_for_eval ${1+"$@"}
-      func_parse_options_result=$func_quote_for_eval_result
-    fi
-
-    $_G_rc_parse_options
-}
-
-
-# func_validate_options [ARG]...
-# ------------------------------
-# Perform any sanity checks on option settings and/or unconsumed
-# arguments.
-func_hookable func_validate_options
-func_validate_options ()
-{
-    $debug_cmd
-
-    _G_rc_validate_options=false
-
-    # Display all warnings if -W was not given.
-    test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
-
-    if func_run_hooks func_validate_options ${1+"$@"}; then
-      # save modified positional parameters for caller
-      func_validate_options_result=$func_run_hooks_result
-      _G_rc_validate_options=:
-    fi
-
-    # Bail if the options were screwed!
-    $exit_cmd $EXIT_FAILURE
-
-    $_G_rc_validate_options
-}
-
-
-
-## ----------------- ##
-## Helper functions. ##
-## ----------------- ##
-
-# This section contains the helper functions used by the rest of the
-# hookable option parser framework in ascii-betical order.
-
-
-# func_fatal_help ARG...
-# ----------------------
-# Echo program name prefixed message to standard error, followed by
-# a help hint, and exit.
-func_fatal_help ()
-{
-    $debug_cmd
-
-    eval \$ECHO \""Usage: $usage"\"
-    eval \$ECHO \""$fatal_help"\"
-    func_error ${1+"$@"}
-    exit $EXIT_FAILURE
-}
-
-
-# func_help
-# ---------
-# Echo long help message to standard output and exit.
-func_help ()
-{
-    $debug_cmd
-
-    func_usage_message
-    $ECHO "$long_help_message"
-    exit 0
-}
-
-
-# func_missing_arg ARGNAME
-# ------------------------
-# Echo program name prefixed message to standard error and set global
-# exit_cmd.
-func_missing_arg ()
-{
-    $debug_cmd
-
-    func_error "Missing argument for '$1'."
-    exit_cmd=exit
-}
-
-
-# func_split_equals STRING
-# ------------------------
-# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
-# splitting STRING at the '=' sign.
-test -z "$_G_HAVE_XSI_OPS" \
-    && (eval 'x=a/b/c;
-      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
-    && _G_HAVE_XSI_OPS=yes
-
-if test yes = "$_G_HAVE_XSI_OPS"
-then
-  # This is an XSI compatible shell, allowing a faster implementation...
-  eval 'func_split_equals ()
-  {
-      $debug_cmd
-
-      func_split_equals_lhs=${1%%=*}
-      func_split_equals_rhs=${1#*=}
-      test "x$func_split_equals_lhs" = "x$1" \
-        && func_split_equals_rhs=
-  }'
-else
-  # ...otherwise fall back to using expr, which is often a shell builtin.
-  func_split_equals ()
-  {
-      $debug_cmd
-
-      func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
-      func_split_equals_rhs=
-      test "x$func_split_equals_lhs" = "x$1" \
-        || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
-  }
-fi #func_split_equals
-
-
-# func_split_short_opt SHORTOPT
-# -----------------------------
-# Set func_split_short_opt_name and func_split_short_opt_arg shell
-# variables after splitting SHORTOPT after the 2nd character.
-if test yes = "$_G_HAVE_XSI_OPS"
-then
-  # This is an XSI compatible shell, allowing a faster implementation...
-  eval 'func_split_short_opt ()
-  {
-      $debug_cmd
-
-      func_split_short_opt_arg=${1#??}
-      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
-  }'
-else
-  # ...otherwise fall back to using expr, which is often a shell builtin.
-  func_split_short_opt ()
-  {
-      $debug_cmd
-
-      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
-      func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
-  }
-fi #func_split_short_opt
-
-
-# func_usage
-# ----------
-# Echo short help message to standard output and exit.
-func_usage ()
-{
-    $debug_cmd
-
-    func_usage_message
-    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
-    exit 0
-}
-
-
-# func_usage_message
-# ------------------
-# Echo short help message to standard output.
-func_usage_message ()
-{
-    $debug_cmd
-
-    eval \$ECHO \""Usage: $usage"\"
-    echo
-    $SED -n 's|^# ||
-        /^Written by/{
-          x;p;x
-        }
-	h
-	/^Written by/q' < "$progpath"
-    echo
-    eval \$ECHO \""$usage_message"\"
-}
-
-
-# func_version
-# ------------
-# Echo version message to standard output and exit.
-func_version ()
-{
-    $debug_cmd
-
-    printf '%s\n' "$progname $scriptversion"
-    $SED -n '
-        /(C)/!b go
-        :more
-        /\./!{
-          N
-          s|\n# | |
-          b more
-        }
-        :go
-        /^# Written by /,/# warranty; / {
-          s|^# ||
-          s|^# *$||
-          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
-          p
-        }
-        /^# Written by / {
-          s|^# ||
-          p
-        }
-        /^warranty; /q' < "$progpath"
-
-    exit $?
-}
-
-
-# Local variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
-# time-stamp-time-zone: "UTC"
-# End:
-
-# Set a version string.
-scriptversion='(GNU libtool) 2.4.6'
-
-
-# func_echo ARG...
-# ----------------
-# Libtool also displays the current mode in messages, so override
-# funclib.sh func_echo with this custom definition.
-func_echo ()
-{
-    $debug_cmd
-
-    _G_message=$*
-
-    func_echo_IFS=$IFS
-    IFS=$nl
-    for _G_line in $_G_message; do
-      IFS=$func_echo_IFS
-      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
-    done
-    IFS=$func_echo_IFS
-}
-
-
-# func_warning ARG...
-# -------------------
-# Libtool warnings are not categorized, so override funclib.sh
-# func_warning with this simpler definition.
-func_warning ()
-{
-    $debug_cmd
-
-    $warning_func ${1+"$@"}
-}
-
-
-## ---------------- ##
-## Options parsing. ##
-## ---------------- ##
-
-# Hook in the functions to make sure our own options are parsed during
-# the option parsing loop.
-
-usage='$progpath [OPTION]... [MODE-ARG]...'
-
-# Short help message in response to '-h'.
-usage_message="Options:
-       --config             show all configuration variables
-       --debug              enable verbose shell tracing
-   -n, --dry-run            display commands without modifying any files
-       --features           display basic configuration information and exit
-       --mode=MODE          use operation mode MODE
-       --no-warnings        equivalent to '-Wnone'
-       --preserve-dup-deps  don't remove duplicate dependency libraries
-       --quiet, --silent    don't print informational messages
-       --tag=TAG            use configuration variables from tag TAG
-   -v, --verbose            print more informational messages than default
-       --version            print version information
-   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
-   -h, --help, --help-all   print short, long, or detailed help message
-"
-
-# Additional text appended to 'usage_message' in response to '--help'.
-func_help ()
-{
-    $debug_cmd
-
-    func_usage_message
-    $ECHO "$long_help_message
-
-MODE must be one of the following:
-
-       clean           remove files from the build directory
-       compile         compile a source file into a libtool object
-       execute         automatically set library path, then run a program
-       finish          complete the installation of libtool libraries
-       install         install libraries or executables
-       link            create a library or an executable
-       uninstall       remove libraries from an installed directory
-
-MODE-ARGS vary depending on the MODE.  When passed as first option,
-'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
-Try '$progname --help --mode=MODE' for a more detailed description of MODE.
-
-When reporting a bug, please describe a test case to reproduce it and
-include the following information:
-
-       host-triplet:   $host
-       shell:          $SHELL
-       compiler:       $LTCC
-       compiler flags: $LTCFLAGS
-       linker:         $LD (gnu? $with_gnu_ld)
-       version:        $progname $scriptversion Debian-2.4.6-15
-       automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
-       autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
-
-Report bugs to <bug-libtool@gnu.org>.
-GNU libtool home page: <http://www.gnu.org/s/libtool/>.
-General help using GNU software: <http://www.gnu.org/gethelp/>."
-    exit 0
-}
-
-
-# func_lo2o OBJECT-NAME
-# ---------------------
-# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
-# object suffix.
-
-lo2o=s/\\.lo\$/.$objext/
-o2lo=s/\\.$objext\$/.lo/
-
-if test yes = "$_G_HAVE_XSI_OPS"; then
-  eval 'func_lo2o ()
-  {
-    case $1 in
-      *.lo) func_lo2o_result=${1%.lo}.$objext ;;
-      *   ) func_lo2o_result=$1               ;;
-    esac
-  }'
-
-  # func_xform LIBOBJ-OR-SOURCE
-  # ---------------------------
-  # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
-  # suffix to a '.lo' libtool-object suffix.
-  eval 'func_xform ()
-  {
-    func_xform_result=${1%.*}.lo
-  }'
-else
-  # ...otherwise fall back to using sed.
-  func_lo2o ()
-  {
-    func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
-  }
-
-  func_xform ()
-  {
-    func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
-  }
-fi
-
-
-# func_fatal_configuration ARG...
-# -------------------------------
-# Echo program name prefixed message to standard error, followed by
-# a configuration failure hint, and exit.
-func_fatal_configuration ()
-{
-    func__fatal_error ${1+"$@"} \
-      "See the $PACKAGE documentation for more information." \
-      "Fatal configuration error."
-}
-
-
-# func_config
-# -----------
-# Display the configuration for all the tags in this script.
-func_config ()
-{
-    re_begincf='^# ### BEGIN LIBTOOL'
-    re_endcf='^# ### END LIBTOOL'
-
-    # Default configuration.
-    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
-
-    # Now print the configurations for the tags.
-    for tagname in $taglist; do
-      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
-    done
-
-    exit $?
-}
-
-
-# func_features
-# -------------
-# Display the features supported by this script.
-func_features ()
-{
-    echo "host: $host"
-    if test yes = "$build_libtool_libs"; then
-      echo "enable shared libraries"
-    else
-      echo "disable shared libraries"
-    fi
-    if test yes = "$build_old_libs"; then
-      echo "enable static libraries"
-    else
-      echo "disable static libraries"
-    fi
-
-    exit $?
-}
-
-
-# func_enable_tag TAGNAME
-# -----------------------
-# Verify that TAGNAME is valid, and either flag an error and exit, or
-# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
-# variable here.
-func_enable_tag ()
-{
-    # Global variable:
-    tagname=$1
-
-    re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
-    re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
-    sed_extractcf=/$re_begincf/,/$re_endcf/p
-
-    # Validate tagname.
-    case $tagname in
-      *[!-_A-Za-z0-9,/]*)
-        func_fatal_error "invalid tag name: $tagname"
-        ;;
-    esac
-
-    # Don't test for the "default" C tag, as we know it's
-    # there but not specially marked.
-    case $tagname in
-        CC) ;;
-    *)
-        if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
-	  taglist="$taglist $tagname"
-
-	  # Evaluate the configuration.  Be careful to quote the path
-	  # and the sed script, to avoid splitting on whitespace, but
-	  # also don't use non-portable quotes within backquotes within
-	  # quotes we have to do it in 2 steps:
-	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
-	  eval "$extractedcf"
-        else
-	  func_error "ignoring unknown tag $tagname"
-        fi
-        ;;
-    esac
-}
-
-
-# func_check_version_match
-# ------------------------
-# Ensure that we are using m4 macros, and libtool script from the same
-# release of libtool.
-func_check_version_match ()
-{
-    if test "$package_revision" != "$macro_revision"; then
-      if test "$VERSION" != "$macro_version"; then
-        if test -z "$macro_version"; then
-          cat >&2 <<_LT_EOF
-$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
-$progname: definition of this LT_INIT comes from an older release.
-$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
-$progname: and run autoconf again.
-_LT_EOF
-        else
-          cat >&2 <<_LT_EOF
-$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
-$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
-$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
-$progname: and run autoconf again.
-_LT_EOF
-        fi
-      else
-        cat >&2 <<_LT_EOF
-$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
-$progname: but the definition of this LT_INIT comes from revision $macro_revision.
-$progname: You should recreate aclocal.m4 with macros from revision $package_revision
-$progname: of $PACKAGE $VERSION and run autoconf again.
-_LT_EOF
-      fi
-
-      exit $EXIT_MISMATCH
-    fi
-}
-
-
-# libtool_options_prep [ARG]...
-# -----------------------------
-# Preparation for options parsed by libtool.
-libtool_options_prep ()
-{
-    $debug_mode
-
-    # Option defaults:
-    opt_config=false
-    opt_dlopen=
-    opt_dry_run=false
-    opt_help=false
-    opt_mode=
-    opt_preserve_dup_deps=false
-    opt_quiet=false
-
-    nonopt=
-    preserve_args=
-
-    _G_rc_lt_options_prep=:
-
-    # Shorthand for --mode=foo, only valid as the first argument
-    case $1 in
-    clean|clea|cle|cl)
-      shift; set dummy --mode clean ${1+"$@"}; shift
-      ;;
-    compile|compil|compi|comp|com|co|c)
-      shift; set dummy --mode compile ${1+"$@"}; shift
-      ;;
-    execute|execut|execu|exec|exe|ex|e)
-      shift; set dummy --mode execute ${1+"$@"}; shift
-      ;;
-    finish|finis|fini|fin|fi|f)
-      shift; set dummy --mode finish ${1+"$@"}; shift
-      ;;
-    install|instal|insta|inst|ins|in|i)
-      shift; set dummy --mode install ${1+"$@"}; shift
-      ;;
-    link|lin|li|l)
-      shift; set dummy --mode link ${1+"$@"}; shift
-      ;;
-    uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
-      shift; set dummy --mode uninstall ${1+"$@"}; shift
-      ;;
-    *)
-      _G_rc_lt_options_prep=false
-      ;;
-    esac
-
-    if $_G_rc_lt_options_prep; then
-      # Pass back the list of options.
-      func_quote_for_eval ${1+"$@"}
-      libtool_options_prep_result=$func_quote_for_eval_result
-    fi
-
-    $_G_rc_lt_options_prep
-}
-func_add_hook func_options_prep libtool_options_prep
-
-
-# libtool_parse_options [ARG]...
-# ---------------------------------
-# Provide handling for libtool specific options.
-libtool_parse_options ()
-{
-    $debug_cmd
-
-    _G_rc_lt_parse_options=false
-
-    # Perform our own loop to consume as many options as possible in
-    # each iteration.
-    while test $# -gt 0; do
-      _G_match_lt_parse_options=:
-      _G_opt=$1
-      shift
-      case $_G_opt in
-        --dry-run|--dryrun|-n)
-                        opt_dry_run=:
-                        ;;
-
-        --config)       func_config ;;
-
-        --dlopen|-dlopen)
-                        opt_dlopen="${opt_dlopen+$opt_dlopen
-}$1"
-                        shift
-                        ;;
-
-        --preserve-dup-deps)
-                        opt_preserve_dup_deps=: ;;
-
-        --features)     func_features ;;
-
-        --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
-
-        --help)         opt_help=: ;;
-
-        --help-all)     opt_help=': help-all' ;;
-
-        --mode)         test $# = 0 && func_missing_arg $_G_opt && break
-                        opt_mode=$1
-                        case $1 in
-                          # Valid mode arguments:
-                          clean|compile|execute|finish|install|link|relink|uninstall) ;;
-
-                          # Catch anything else as an error
-                          *) func_error "invalid argument for $_G_opt"
-                             exit_cmd=exit
-                             break
-                             ;;
-                        esac
-                        shift
-                        ;;
-
-        --no-silent|--no-quiet)
-                        opt_quiet=false
-                        func_append preserve_args " $_G_opt"
-                        ;;
-
-        --no-warnings|--no-warning|--no-warn)
-                        opt_warning=false
-                        func_append preserve_args " $_G_opt"
-                        ;;
-
-        --no-verbose)
-                        opt_verbose=false
-                        func_append preserve_args " $_G_opt"
-                        ;;
-
-        --silent|--quiet)
-                        opt_quiet=:
-                        opt_verbose=false
-                        func_append preserve_args " $_G_opt"
-                        ;;
-
-        --tag)          test $# = 0 && func_missing_arg $_G_opt && break
-                        opt_tag=$1
-                        func_append preserve_args " $_G_opt $1"
-                        func_enable_tag "$1"
-                        shift
-                        ;;
-
-        --verbose|-v)   opt_quiet=false
-                        opt_verbose=:
-                        func_append preserve_args " $_G_opt"
-                        ;;
-
-        # An option not handled by this hook function:
-        *)              set dummy "$_G_opt" ${1+"$@"} ; shift
-                        _G_match_lt_parse_options=false
-                        break
-                        ;;
-      esac
-      $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
-    done
-
-    if $_G_rc_lt_parse_options; then
-      # save modified positional parameters for caller
-      func_quote_for_eval ${1+"$@"}
-      libtool_parse_options_result=$func_quote_for_eval_result
-    fi
-
-    $_G_rc_lt_parse_options
-}
-func_add_hook func_parse_options libtool_parse_options
-
-
-
-# libtool_validate_options [ARG]...
-# ---------------------------------
-# Perform any sanity checks on option settings and/or unconsumed
-# arguments.
-libtool_validate_options ()
-{
-    # save first non-option argument
-    if test 0 -lt $#; then
-      nonopt=$1
-      shift
-    fi
-
-    # preserve --debug
-    test : = "$debug_cmd" || func_append preserve_args " --debug"
-
-    case $host in
-      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
-      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
-      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
-        # don't eliminate duplications in $postdeps and $predeps
-        opt_duplicate_compiler_generated_deps=:
-        ;;
-      *)
-        opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
-        ;;
-    esac
-
-    $opt_help || {
-      # Sanity checks first:
-      func_check_version_match
-
-      test yes != "$build_libtool_libs" \
-        && test yes != "$build_old_libs" \
-        && func_fatal_configuration "not configured to build any kind of library"
-
-      # Darwin sucks
-      eval std_shrext=\"$shrext_cmds\"
-
-      # Only execute mode is allowed to have -dlopen flags.
-      if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
-        func_error "unrecognized option '-dlopen'"
-        $ECHO "$help" 1>&2
-        exit $EXIT_FAILURE
-      fi
-
-      # Change the help message to a mode-specific one.
-      generic_help=$help
-      help="Try '$progname --help --mode=$opt_mode' for more information."
-    }
-
-    # Pass back the unparsed argument list
-    func_quote_for_eval ${1+"$@"}
-    libtool_validate_options_result=$func_quote_for_eval_result
-}
-func_add_hook func_validate_options libtool_validate_options
-
-
-# Process options as early as possible so that --help and --version
-# can return quickly.
-func_options ${1+"$@"}
-eval set dummy "$func_options_result"; shift
-
-
-
-## ----------- ##
-##    Main.    ##
-## ----------- ##
-
-magic='%%%MAGIC variable%%%'
-magic_exe='%%%MAGIC EXE variable%%%'
-
-# Global variables.
-extracted_archives=
-extracted_serial=0
-
-# If this variable is set in any of the actions, the command in it
-# will be execed at the end.  This prevents here-documents from being
-# left over by shells.
-exec_cmd=
-
-
-# A function that is used when there is no print builtin or printf.
-func_fallback_echo ()
-{
-  eval 'cat <<_LTECHO_EOF
-$1
-_LTECHO_EOF'
-}
-
-# func_generated_by_libtool
-# True iff stdin has been generated by Libtool. This function is only
-# a basic sanity check; it will hardly flush out determined imposters.
-func_generated_by_libtool_p ()
-{
-  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
-}
-
-# func_lalib_p file
-# True iff FILE is a libtool '.la' library or '.lo' object file.
-# This function is only a basic sanity check; it will hardly flush out
-# determined imposters.
-func_lalib_p ()
-{
-    test -f "$1" &&
-      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
-}
-
-# func_lalib_unsafe_p file
-# True iff FILE is a libtool '.la' library or '.lo' object file.
-# This function implements the same check as func_lalib_p without
-# resorting to external programs.  To this end, it redirects stdin and
-# closes it afterwards, without saving the original file descriptor.
-# As a safety measure, use it only where a negative result would be
-# fatal anyway.  Works if 'file' does not exist.
-func_lalib_unsafe_p ()
-{
-    lalib_p=no
-    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
-	for lalib_p_l in 1 2 3 4
-	do
-	    read lalib_p_line
-	    case $lalib_p_line in
-		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
-	    esac
-	done
-	exec 0<&5 5<&-
-    fi
-    test yes = "$lalib_p"
-}
-
-# func_ltwrapper_script_p file
-# True iff FILE is a libtool wrapper script
-# This function is only a basic sanity check; it will hardly flush out
-# determined imposters.
-func_ltwrapper_script_p ()
-{
-    test -f "$1" &&
-      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
-}
-
-# func_ltwrapper_executable_p file
-# True iff FILE is a libtool wrapper executable
-# This function is only a basic sanity check; it will hardly flush out
-# determined imposters.
-func_ltwrapper_executable_p ()
-{
-    func_ltwrapper_exec_suffix=
-    case $1 in
-    *.exe) ;;
-    *) func_ltwrapper_exec_suffix=.exe ;;
-    esac
-    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
-}
-
-# func_ltwrapper_scriptname file
-# Assumes file is an ltwrapper_executable
-# uses $file to determine the appropriate filename for a
-# temporary ltwrapper_script.
-func_ltwrapper_scriptname ()
-{
-    func_dirname_and_basename "$1" "" "."
-    func_stripname '' '.exe' "$func_basename_result"
-    func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
-}
-
-# func_ltwrapper_p file
-# True iff FILE is a libtool wrapper script or wrapper executable
-# This function is only a basic sanity check; it will hardly flush out
-# determined imposters.
-func_ltwrapper_p ()
-{
-    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
-}
-
-
-# func_execute_cmds commands fail_cmd
-# Execute tilde-delimited COMMANDS.
-# If FAIL_CMD is given, eval that upon failure.
-# FAIL_CMD may read-access the current command in variable CMD!
-func_execute_cmds ()
-{
-    $debug_cmd
-
-    save_ifs=$IFS; IFS='~'
-    for cmd in $1; do
-      IFS=$sp$nl
-      eval cmd=\"$cmd\"
-      IFS=$save_ifs
-      func_show_eval "$cmd" "${2-:}"
-    done
-    IFS=$save_ifs
-}
-
-
-# func_source file
-# Source FILE, adding directory component if necessary.
-# Note that it is not necessary on cygwin/mingw to append a dot to
-# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
-# behavior happens only for exec(3), not for open(2)!  Also, sourcing
-# 'FILE.' does not work on cygwin managed mounts.
-func_source ()
-{
-    $debug_cmd
-
-    case $1 in
-    */* | *\\*)	. "$1" ;;
-    *)		. "./$1" ;;
-    esac
-}
-
-
-# func_resolve_sysroot PATH
-# Replace a leading = in PATH with a sysroot.  Store the result into
-# func_resolve_sysroot_result
-func_resolve_sysroot ()
-{
-  func_resolve_sysroot_result=$1
-  case $func_resolve_sysroot_result in
-  =*)
-    func_stripname '=' '' "$func_resolve_sysroot_result"
-    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
-    ;;
-  esac
-}
-
-# func_replace_sysroot PATH
-# If PATH begins with the sysroot, replace it with = and
-# store the result into func_replace_sysroot_result.
-func_replace_sysroot ()
-{
-  case $lt_sysroot:$1 in
-  ?*:"$lt_sysroot"*)
-    func_stripname "$lt_sysroot" '' "$1"
-    func_replace_sysroot_result='='$func_stripname_result
-    ;;
-  *)
-    # Including no sysroot.
-    func_replace_sysroot_result=$1
-    ;;
-  esac
-}
-
-# func_infer_tag arg
-# Infer tagged configuration to use if any are available and
-# if one wasn't chosen via the "--tag" command line option.
-# Only attempt this if the compiler in the base compile
-# command doesn't match the default compiler.
-# arg is usually of the form 'gcc ...'
-func_infer_tag ()
-{
-    $debug_cmd
-
-    if test -n "$available_tags" && test -z "$tagname"; then
-      CC_quoted=
-      for arg in $CC; do
-	func_append_quoted CC_quoted "$arg"
-      done
-      CC_expanded=`func_echo_all $CC`
-      CC_quoted_expanded=`func_echo_all $CC_quoted`
-      case $@ in
-      # Blanks in the command may have been stripped by the calling shell,
-      # but not from the CC environment variable when configure was run.
-      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
-      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
-      # Blanks at the start of $base_compile will cause this to fail
-      # if we don't check for them as well.
-      *)
-	for z in $available_tags; do
-	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
-	    # Evaluate the configuration.
-	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
-	    CC_quoted=
-	    for arg in $CC; do
-	      # Double-quote args containing other shell metacharacters.
-	      func_append_quoted CC_quoted "$arg"
-	    done
-	    CC_expanded=`func_echo_all $CC`
-	    CC_quoted_expanded=`func_echo_all $CC_quoted`
-	    case "$@ " in
-	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
-	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
-	      # The compiler in the base compile command matches
-	      # the one in the tagged configuration.
-	      # Assume this is the tagged configuration we want.
-	      tagname=$z
-	      break
-	      ;;
-	    esac
-	  fi
-	done
-	# If $tagname still isn't set, then no tagged configuration
-	# was found and let the user know that the "--tag" command
-	# line option must be used.
-	if test -z "$tagname"; then
-	  func_echo "unable to infer tagged configuration"
-	  func_fatal_error "specify a tag with '--tag'"
-#	else
-#	  func_verbose "using $tagname tagged configuration"
-	fi
-	;;
-      esac
-    fi
-}
-
-
-
-# func_write_libtool_object output_name pic_name nonpic_name
-# Create a libtool object file (analogous to a ".la" file),
-# but don't create it if we're doing a dry run.
-func_write_libtool_object ()
-{
-    write_libobj=$1
-    if test yes = "$build_libtool_libs"; then
-      write_lobj=\'$2\'
-    else
-      write_lobj=none
-    fi
-
-    if test yes = "$build_old_libs"; then
-      write_oldobj=\'$3\'
-    else
-      write_oldobj=none
-    fi
-
-    $opt_dry_run || {
-      cat >${write_libobj}T <<EOF
-# $write_libobj - a libtool object file
-# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
-#
-# Please DO NOT delete this file!
-# It is necessary for linking the library.
-
-# Name of the PIC object.
-pic_object=$write_lobj
-
-# Name of the non-PIC object
-non_pic_object=$write_oldobj
-
-EOF
-      $MV "${write_libobj}T" "$write_libobj"
-    }
-}
-
-
-##################################################
-# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
-##################################################
-
-# func_convert_core_file_wine_to_w32 ARG
-# Helper function used by file name conversion functions when $build is *nix,
-# and $host is mingw, cygwin, or some other w32 environment. Relies on a
-# correctly configured wine environment available, with the winepath program
-# in $build's $PATH.
-#
-# ARG is the $build file name to be converted to w32 format.
-# Result is available in $func_convert_core_file_wine_to_w32_result, and will
-# be empty on error (or when ARG is empty)
-func_convert_core_file_wine_to_w32 ()
-{
-  $debug_cmd
-
-  func_convert_core_file_wine_to_w32_result=$1
-  if test -n "$1"; then
-    # Unfortunately, winepath does not exit with a non-zero error code, so we
-    # are forced to check the contents of stdout. On the other hand, if the
-    # command is not found, the shell will set an exit code of 127 and print
-    # *an error message* to stdout. So we must check for both error code of
-    # zero AND non-empty stdout, which explains the odd construction:
-    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
-    if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
-      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
-        $SED -e "$sed_naive_backslashify"`
-    else
-      func_convert_core_file_wine_to_w32_result=
-    fi
-  fi
-}
-# end: func_convert_core_file_wine_to_w32
-
-
-# func_convert_core_path_wine_to_w32 ARG
-# Helper function used by path conversion functions when $build is *nix, and
-# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
-# configured wine environment available, with the winepath program in $build's
-# $PATH. Assumes ARG has no leading or trailing path separator characters.
-#
-# ARG is path to be converted from $build format to win32.
-# Result is available in $func_convert_core_path_wine_to_w32_result.
-# Unconvertible file (directory) names in ARG are skipped; if no directory names
-# are convertible, then the result may be empty.
-func_convert_core_path_wine_to_w32 ()
-{
-  $debug_cmd
-
-  # unfortunately, winepath doesn't convert paths, only file names
-  func_convert_core_path_wine_to_w32_result=
-  if test -n "$1"; then
-    oldIFS=$IFS
-    IFS=:
-    for func_convert_core_path_wine_to_w32_f in $1; do
-      IFS=$oldIFS
-      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
-      if test -n "$func_convert_core_file_wine_to_w32_result"; then
-        if test -z "$func_convert_core_path_wine_to_w32_result"; then
-          func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
-        else
-          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
-        fi
-      fi
-    done
-    IFS=$oldIFS
-  fi
-}
-# end: func_convert_core_path_wine_to_w32
-
-
-# func_cygpath ARGS...
-# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
-# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
-# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
-# (2), returns the Cygwin file name or path in func_cygpath_result (input
-# file name or path is assumed to be in w32 format, as previously converted
-# from $build's *nix or MSYS format). In case (3), returns the w32 file name
-# or path in func_cygpath_result (input file name or path is assumed to be in
-# Cygwin format). Returns an empty string on error.
-#
-# ARGS are passed to cygpath, with the last one being the file name or path to
-# be converted.
-#
-# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
-# environment variable; do not put it in $PATH.
-func_cygpath ()
-{
-  $debug_cmd
-
-  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
-    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
-    if test "$?" -ne 0; then
-      # on failure, ensure result is empty
-      func_cygpath_result=
-    fi
-  else
-    func_cygpath_result=
-    func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
-  fi
-}
-#end: func_cygpath
-
-
-# func_convert_core_msys_to_w32 ARG
-# Convert file name or path ARG from MSYS format to w32 format.  Return
-# result in func_convert_core_msys_to_w32_result.
-func_convert_core_msys_to_w32 ()
-{
-  $debug_cmd
-
-  # awkward: cmd appends spaces to result
-  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
-    $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
-}
-#end: func_convert_core_msys_to_w32
-
-
-# func_convert_file_check ARG1 ARG2
-# Verify that ARG1 (a file name in $build format) was converted to $host
-# format in ARG2. Otherwise, emit an error message, but continue (resetting
-# func_to_host_file_result to ARG1).
-func_convert_file_check ()
-{
-  $debug_cmd
-
-  if test -z "$2" && test -n "$1"; then
-    func_error "Could not determine host file name corresponding to"
-    func_error "  '$1'"
-    func_error "Continuing, but uninstalled executables may not work."
-    # Fallback:
-    func_to_host_file_result=$1
-  fi
-}
-# end func_convert_file_check
-
-
-# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
-# Verify that FROM_PATH (a path in $build format) was converted to $host
-# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
-# func_to_host_file_result to a simplistic fallback value (see below).
-func_convert_path_check ()
-{
-  $debug_cmd
-
-  if test -z "$4" && test -n "$3"; then
-    func_error "Could not determine the host path corresponding to"
-    func_error "  '$3'"
-    func_error "Continuing, but uninstalled executables may not work."
-    # Fallback.  This is a deliberately simplistic "conversion" and
-    # should not be "improved".  See libtool.info.
-    if test "x$1" != "x$2"; then
-      lt_replace_pathsep_chars="s|$1|$2|g"
-      func_to_host_path_result=`echo "$3" |
-        $SED -e "$lt_replace_pathsep_chars"`
-    else
-      func_to_host_path_result=$3
-    fi
-  fi
-}
-# end func_convert_path_check
-
-
-# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
-# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
-# and appending REPL if ORIG matches BACKPAT.
-func_convert_path_front_back_pathsep ()
-{
-  $debug_cmd
-
-  case $4 in
-  $1 ) func_to_host_path_result=$3$func_to_host_path_result
-    ;;
-  esac
-  case $4 in
-  $2 ) func_append func_to_host_path_result "$3"
-    ;;
-  esac
-}
-# end func_convert_path_front_back_pathsep
-
-
-##################################################
-# $build to $host FILE NAME CONVERSION FUNCTIONS #
-##################################################
-# invoked via '$to_host_file_cmd ARG'
-#
-# In each case, ARG is the path to be converted from $build to $host format.
-# Result will be available in $func_to_host_file_result.
-
-
-# func_to_host_file ARG
-# Converts the file name ARG from $build format to $host format. Return result
-# in func_to_host_file_result.
-func_to_host_file ()
-{
-  $debug_cmd
-
-  $to_host_file_cmd "$1"
-}
-# end func_to_host_file
-
-
-# func_to_tool_file ARG LAZY
-# converts the file name ARG from $build format to toolchain format. Return
-# result in func_to_tool_file_result.  If the conversion in use is listed
-# in (the comma separated) LAZY, no conversion takes place.
-func_to_tool_file ()
-{
-  $debug_cmd
-
-  case ,$2, in
-    *,"$to_tool_file_cmd",*)
-      func_to_tool_file_result=$1
-      ;;
-    *)
-      $to_tool_file_cmd "$1"
-      func_to_tool_file_result=$func_to_host_file_result
-      ;;
-  esac
-}
-# end func_to_tool_file
-
-
-# func_convert_file_noop ARG
-# Copy ARG to func_to_host_file_result.
-func_convert_file_noop ()
-{
-  func_to_host_file_result=$1
-}
-# end func_convert_file_noop
-
-
-# func_convert_file_msys_to_w32 ARG
-# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
-# conversion to w32 is not available inside the cwrapper.  Returns result in
-# func_to_host_file_result.
-func_convert_file_msys_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_file_result=$1
-  if test -n "$1"; then
-    func_convert_core_msys_to_w32 "$1"
-    func_to_host_file_result=$func_convert_core_msys_to_w32_result
-  fi
-  func_convert_file_check "$1" "$func_to_host_file_result"
-}
-# end func_convert_file_msys_to_w32
-
-
-# func_convert_file_cygwin_to_w32 ARG
-# Convert file name ARG from Cygwin to w32 format.  Returns result in
-# func_to_host_file_result.
-func_convert_file_cygwin_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_file_result=$1
-  if test -n "$1"; then
-    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
-    # LT_CYGPATH in this case.
-    func_to_host_file_result=`cygpath -m "$1"`
-  fi
-  func_convert_file_check "$1" "$func_to_host_file_result"
-}
-# end func_convert_file_cygwin_to_w32
-
-
-# func_convert_file_nix_to_w32 ARG
-# Convert file name ARG from *nix to w32 format.  Requires a wine environment
-# and a working winepath. Returns result in func_to_host_file_result.
-func_convert_file_nix_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_file_result=$1
-  if test -n "$1"; then
-    func_convert_core_file_wine_to_w32 "$1"
-    func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
-  fi
-  func_convert_file_check "$1" "$func_to_host_file_result"
-}
-# end func_convert_file_nix_to_w32
-
-
-# func_convert_file_msys_to_cygwin ARG
-# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
-# Returns result in func_to_host_file_result.
-func_convert_file_msys_to_cygwin ()
-{
-  $debug_cmd
-
-  func_to_host_file_result=$1
-  if test -n "$1"; then
-    func_convert_core_msys_to_w32 "$1"
-    func_cygpath -u "$func_convert_core_msys_to_w32_result"
-    func_to_host_file_result=$func_cygpath_result
-  fi
-  func_convert_file_check "$1" "$func_to_host_file_result"
-}
-# end func_convert_file_msys_to_cygwin
-
-
-# func_convert_file_nix_to_cygwin ARG
-# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
-# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
-# in func_to_host_file_result.
-func_convert_file_nix_to_cygwin ()
-{
-  $debug_cmd
-
-  func_to_host_file_result=$1
-  if test -n "$1"; then
-    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
-    func_convert_core_file_wine_to_w32 "$1"
-    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
-    func_to_host_file_result=$func_cygpath_result
-  fi
-  func_convert_file_check "$1" "$func_to_host_file_result"
-}
-# end func_convert_file_nix_to_cygwin
-
-
-#############################################
-# $build to $host PATH CONVERSION FUNCTIONS #
-#############################################
-# invoked via '$to_host_path_cmd ARG'
-#
-# In each case, ARG is the path to be converted from $build to $host format.
-# The result will be available in $func_to_host_path_result.
-#
-# Path separators are also converted from $build format to $host format.  If
-# ARG begins or ends with a path separator character, it is preserved (but
-# converted to $host format) on output.
-#
-# All path conversion functions are named using the following convention:
-#   file name conversion function    : func_convert_file_X_to_Y ()
-#   path conversion function         : func_convert_path_X_to_Y ()
-# where, for any given $build/$host combination the 'X_to_Y' value is the
-# same.  If conversion functions are added for new $build/$host combinations,
-# the two new functions must follow this pattern, or func_init_to_host_path_cmd
-# will break.
-
-
-# func_init_to_host_path_cmd
-# Ensures that function "pointer" variable $to_host_path_cmd is set to the
-# appropriate value, based on the value of $to_host_file_cmd.
-to_host_path_cmd=
-func_init_to_host_path_cmd ()
-{
-  $debug_cmd
-
-  if test -z "$to_host_path_cmd"; then
-    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
-    to_host_path_cmd=func_convert_path_$func_stripname_result
-  fi
-}
-
-
-# func_to_host_path ARG
-# Converts the path ARG from $build format to $host format. Return result
-# in func_to_host_path_result.
-func_to_host_path ()
-{
-  $debug_cmd
-
-  func_init_to_host_path_cmd
-  $to_host_path_cmd "$1"
-}
-# end func_to_host_path
-
-
-# func_convert_path_noop ARG
-# Copy ARG to func_to_host_path_result.
-func_convert_path_noop ()
-{
-  func_to_host_path_result=$1
-}
-# end func_convert_path_noop
-
-
-# func_convert_path_msys_to_w32 ARG
-# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
-# conversion to w32 is not available inside the cwrapper.  Returns result in
-# func_to_host_path_result.
-func_convert_path_msys_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_path_result=$1
-  if test -n "$1"; then
-    # Remove leading and trailing path separator characters from ARG.  MSYS
-    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
-    # and winepath ignores them completely.
-    func_stripname : : "$1"
-    func_to_host_path_tmp1=$func_stripname_result
-    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
-    func_to_host_path_result=$func_convert_core_msys_to_w32_result
-    func_convert_path_check : ";" \
-      "$func_to_host_path_tmp1" "$func_to_host_path_result"
-    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
-  fi
-}
-# end func_convert_path_msys_to_w32
-
-
-# func_convert_path_cygwin_to_w32 ARG
-# Convert path ARG from Cygwin to w32 format.  Returns result in
-# func_to_host_file_result.
-func_convert_path_cygwin_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_path_result=$1
-  if test -n "$1"; then
-    # See func_convert_path_msys_to_w32:
-    func_stripname : : "$1"
-    func_to_host_path_tmp1=$func_stripname_result
-    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
-    func_convert_path_check : ";" \
-      "$func_to_host_path_tmp1" "$func_to_host_path_result"
-    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
-  fi
-}
-# end func_convert_path_cygwin_to_w32
-
-
-# func_convert_path_nix_to_w32 ARG
-# Convert path ARG from *nix to w32 format.  Requires a wine environment and
-# a working winepath.  Returns result in func_to_host_file_result.
-func_convert_path_nix_to_w32 ()
-{
-  $debug_cmd
-
-  func_to_host_path_result=$1
-  if test -n "$1"; then
-    # See func_convert_path_msys_to_w32:
-    func_stripname : : "$1"
-    func_to_host_path_tmp1=$func_stripname_result
-    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
-    func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
-    func_convert_path_check : ";" \
-      "$func_to_host_path_tmp1" "$func_to_host_path_result"
-    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
-  fi
-}
-# end func_convert_path_nix_to_w32
-
-
-# func_convert_path_msys_to_cygwin ARG
-# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
-# Returns result in func_to_host_file_result.
-func_convert_path_msys_to_cygwin ()
-{
-  $debug_cmd
-
-  func_to_host_path_result=$1
-  if test -n "$1"; then
-    # See func_convert_path_msys_to_w32:
-    func_stripname : : "$1"
-    func_to_host_path_tmp1=$func_stripname_result
-    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
-    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
-    func_to_host_path_result=$func_cygpath_result
-    func_convert_path_check : : \
-      "$func_to_host_path_tmp1" "$func_to_host_path_result"
-    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
-  fi
-}
-# end func_convert_path_msys_to_cygwin
-
-
-# func_convert_path_nix_to_cygwin ARG
-# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
-# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
-# func_to_host_file_result.
-func_convert_path_nix_to_cygwin ()
-{
-  $debug_cmd
-
-  func_to_host_path_result=$1
-  if test -n "$1"; then
-    # Remove leading and trailing path separator characters from
-    # ARG. msys behavior is inconsistent here, cygpath turns them
-    # into '.;' and ';.', and winepath ignores them completely.
-    func_stripname : : "$1"
-    func_to_host_path_tmp1=$func_stripname_result
-    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
-    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
-    func_to_host_path_result=$func_cygpath_result
-    func_convert_path_check : : \
-      "$func_to_host_path_tmp1" "$func_to_host_path_result"
-    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
-  fi
-}
-# end func_convert_path_nix_to_cygwin
-
-
-# func_dll_def_p FILE
-# True iff FILE is a Windows DLL '.def' file.
-# Keep in sync with _LT_DLL_DEF_P in libtool.m4
-func_dll_def_p ()
-{
-  $debug_cmd
-
-  func_dll_def_p_tmp=`$SED -n \
-    -e 's/^[	 ]*//' \
-    -e '/^\(;.*\)*$/d' \
-    -e 's/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p' \
-    -e q \
-    "$1"`
-  test DEF = "$func_dll_def_p_tmp"
-}
-
-
-# func_mode_compile arg...
-func_mode_compile ()
-{
-    $debug_cmd
-
-    # Get the compilation command and the source file.
-    base_compile=
-    srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
-    suppress_opt=yes
-    suppress_output=
-    arg_mode=normal
-    libobj=
-    later=
-    pie_flag=
-
-    for arg
-    do
-      case $arg_mode in
-      arg  )
-	# do not "continue".  Instead, add this to base_compile
-	lastarg=$arg
-	arg_mode=normal
-	;;
-
-      target )
-	libobj=$arg
-	arg_mode=normal
-	continue
-	;;
-
-      normal )
-	# Accept any command-line options.
-	case $arg in
-	-o)
-	  test -n "$libobj" && \
-	    func_fatal_error "you cannot specify '-o' more than once"
-	  arg_mode=target
-	  continue
-	  ;;
-
-	-pie | -fpie | -fPIE)
-          func_append pie_flag " $arg"
-	  continue
-	  ;;
-
-	-shared | -static | -prefer-pic | -prefer-non-pic)
-	  func_append later " $arg"
-	  continue
-	  ;;
-
-	-no-suppress)
-	  suppress_opt=no
-	  continue
-	  ;;
-
-	-Xcompiler)
-	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
-	  continue      #  The current "srcfile" will either be retained or
-	  ;;            #  replaced later.  I would guess that would be a bug.
-
-	-Wc,*)
-	  func_stripname '-Wc,' '' "$arg"
-	  args=$func_stripname_result
-	  lastarg=
-	  save_ifs=$IFS; IFS=,
-	  for arg in $args; do
-	    IFS=$save_ifs
-	    func_append_quoted lastarg "$arg"
-	  done
-	  IFS=$save_ifs
-	  func_stripname ' ' '' "$lastarg"
-	  lastarg=$func_stripname_result
-
-	  # Add the arguments to base_compile.
-	  func_append base_compile " $lastarg"
-	  continue
-	  ;;
-
-	*)
-	  # Accept the current argument as the source file.
-	  # The previous "srcfile" becomes the current argument.
-	  #
-	  lastarg=$srcfile
-	  srcfile=$arg
-	  ;;
-	esac  #  case $arg
-	;;
-      esac    #  case $arg_mode
-
-      # Aesthetically quote the previous argument.
-      func_append_quoted base_compile "$lastarg"
-    done # for arg
-
-    case $arg_mode in
-    arg)
-      func_fatal_error "you must specify an argument for -Xcompile"
-      ;;
-    target)
-      func_fatal_error "you must specify a target with '-o'"
-      ;;
-    *)
-      # Get the name of the library object.
-      test -z "$libobj" && {
-	func_basename "$srcfile"
-	libobj=$func_basename_result
-      }
-      ;;
-    esac
-
-    # Recognize several different file suffixes.
-    # If the user specifies -o file.o, it is replaced with file.lo
-    case $libobj in
-    *.[cCFSifmso] | \
-    *.ada | *.adb | *.ads | *.asm | \
-    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
-    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
-      func_xform "$libobj"
-      libobj=$func_xform_result
-      ;;
-    esac
-
-    case $libobj in
-    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
-    *)
-      func_fatal_error "cannot determine name of library object from '$libobj'"
-      ;;
-    esac
-
-    func_infer_tag $base_compile
-
-    for arg in $later; do
-      case $arg in
-      -shared)
-	test yes = "$build_libtool_libs" \
-	  || func_fatal_configuration "cannot build a shared library"
-	build_old_libs=no
-	continue
-	;;
-
-      -static)
-	build_libtool_libs=no
-	build_old_libs=yes
-	continue
-	;;
-
-      -prefer-pic)
-	pic_mode=yes
-	continue
-	;;
-
-      -prefer-non-pic)
-	pic_mode=no
-	continue
-	;;
-      esac
-    done
-
-    func_quote_for_eval "$libobj"
-    test "X$libobj" != "X$func_quote_for_eval_result" \
-      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
-      && func_warning "libobj name '$libobj' may not contain shell special characters."
-    func_dirname_and_basename "$obj" "/" ""
-    objname=$func_basename_result
-    xdir=$func_dirname_result
-    lobj=$xdir$objdir/$objname
-
-    test -z "$base_compile" && \
-      func_fatal_help "you must specify a compilation command"
-
-    # Delete any leftover library objects.
-    if test yes = "$build_old_libs"; then
-      removelist="$obj $lobj $libobj ${libobj}T"
-    else
-      removelist="$lobj $libobj ${libobj}T"
-    fi
-
-    # On Cygwin there's no "real" PIC flag so we must build both object types
-    case $host_os in
-    cygwin* | mingw* | pw32* | os2* | cegcc*)
-      pic_mode=default
-      ;;
-    esac
-    if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
-      # non-PIC code in shared libraries is not supported
-      pic_mode=default
-    fi
-
-    # Calculate the filename of the output object if compiler does
-    # not support -o with -c
-    if test no = "$compiler_c_o"; then
-      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
-      lockfile=$output_obj.lock
-    else
-      output_obj=
-      need_locks=no
-      lockfile=
-    fi
-
-    # Lock this critical section if it is needed
-    # We use this script file to make the link, it avoids creating a new file
-    if test yes = "$need_locks"; then
-      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
-	func_echo "Waiting for $lockfile to be removed"
-	sleep 2
-      done
-    elif test warn = "$need_locks"; then
-      if test -f "$lockfile"; then
-	$ECHO "\
-*** ERROR, $lockfile exists and contains:
-`cat $lockfile 2>/dev/null`
-
-This indicates that another process is trying to use the same
-temporary object file, and libtool could not work around it because
-your compiler does not support '-c' and '-o' together.  If you
-repeat this compilation, it may succeed, by chance, but you had better
-avoid parallel builds (make -j) in this platform, or get a better
-compiler."
-
-	$opt_dry_run || $RM $removelist
-	exit $EXIT_FAILURE
-      fi
-      func_append removelist " $output_obj"
-      $ECHO "$srcfile" > "$lockfile"
-    fi
-
-    $opt_dry_run || $RM $removelist
-    func_append removelist " $lockfile"
-    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
-
-    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
-    srcfile=$func_to_tool_file_result
-    func_quote_for_eval "$srcfile"
-    qsrcfile=$func_quote_for_eval_result
-
-    # Only build a PIC object if we are building libtool libraries.
-    if test yes = "$build_libtool_libs"; then
-      # Without this assignment, base_compile gets emptied.
-      fbsd_hideous_sh_bug=$base_compile
-
-      if test no != "$pic_mode"; then
-	command="$base_compile $qsrcfile $pic_flag"
-      else
-	# Don't build PIC code
-	command="$base_compile $qsrcfile"
-      fi
-
-      func_mkdir_p "$xdir$objdir"
-
-      if test -z "$output_obj"; then
-	# Place PIC objects in $objdir
-	func_append command " -o $lobj"
-      fi
-
-      func_show_eval_locale "$command"	\
-          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
-
-      if test warn = "$need_locks" &&
-	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
-	$ECHO "\
-*** ERROR, $lockfile contains:
-`cat $lockfile 2>/dev/null`
-
-but it should contain:
-$srcfile
-
-This indicates that another process is trying to use the same
-temporary object file, and libtool could not work around it because
-your compiler does not support '-c' and '-o' together.  If you
-repeat this compilation, it may succeed, by chance, but you had better
-avoid parallel builds (make -j) in this platform, or get a better
-compiler."
-
-	$opt_dry_run || $RM $removelist
-	exit $EXIT_FAILURE
-      fi
-
-      # Just move the object if needed, then go on to compile the next one
-      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
-	func_show_eval '$MV "$output_obj" "$lobj"' \
-	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
-      fi
-
-      # Allow error messages only from the first compilation.
-      if test yes = "$suppress_opt"; then
-	suppress_output=' >/dev/null 2>&1'
-      fi
-    fi
-
-    # Only build a position-dependent object if we build old libraries.
-    if test yes = "$build_old_libs"; then
-      if test yes != "$pic_mode"; then
-	# Don't build PIC code
-	command="$base_compile $qsrcfile$pie_flag"
-      else
-	command="$base_compile $qsrcfile $pic_flag"
-      fi
-      if test yes = "$compiler_c_o"; then
-	func_append command " -o $obj"
-      fi
-
-      # Suppress compiler output if we already did a PIC compilation.
-      func_append command "$suppress_output"
-      func_show_eval_locale "$command" \
-        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
-
-      if test warn = "$need_locks" &&
-	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
-	$ECHO "\
-*** ERROR, $lockfile contains:
-`cat $lockfile 2>/dev/null`
-
-but it should contain:
-$srcfile
-
-This indicates that another process is trying to use the same
-temporary object file, and libtool could not work around it because
-your compiler does not support '-c' and '-o' together.  If you
-repeat this compilation, it may succeed, by chance, but you had better
-avoid parallel builds (make -j) in this platform, or get a better
-compiler."
-
-	$opt_dry_run || $RM $removelist
-	exit $EXIT_FAILURE
-      fi
-
-      # Just move the object if needed
-      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
-	func_show_eval '$MV "$output_obj" "$obj"' \
-	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
-      fi
-    fi
-
-    $opt_dry_run || {
-      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
-
-      # Unlock the critical section if it was locked
-      if test no != "$need_locks"; then
-	removelist=$lockfile
-        $RM "$lockfile"
-      fi
-    }
-
-    exit $EXIT_SUCCESS
-}
-
-$opt_help || {
-  test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
-}
-
-func_mode_help ()
-{
-    # We need to display help for each of the modes.
-    case $opt_mode in
-      "")
-        # Generic help is extracted from the usage comments
-        # at the start of this file.
-        func_help
-        ;;
-
-      clean)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
-
-Remove files from the build directory.
-
-RM is the name of the program to use to delete files associated with each FILE
-(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
-to RM.
-
-If FILE is a libtool library, object or program, all the files associated
-with it are deleted. Otherwise, only FILE itself is deleted using RM."
-        ;;
-
-      compile)
-      $ECHO \
-"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
-
-Compile a source file into a libtool library object.
-
-This mode accepts the following additional options:
-
-  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
-  -no-suppress      do not suppress compiler output for multiple passes
-  -prefer-pic       try to build PIC objects only
-  -prefer-non-pic   try to build non-PIC objects only
-  -shared           do not build a '.o' file suitable for static linking
-  -static           only build a '.o' file suitable for static linking
-  -Wc,FLAG          pass FLAG directly to the compiler
-
-COMPILE-COMMAND is a command to be used in creating a 'standard' object file
-from the given SOURCEFILE.
-
-The output file name is determined by removing the directory component from
-SOURCEFILE, then substituting the C source code suffix '.c' with the
-library object suffix, '.lo'."
-        ;;
-
-      execute)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
-
-Automatically set library path, then run a program.
-
-This mode accepts the following additional options:
-
-  -dlopen FILE      add the directory containing FILE to the library path
-
-This mode sets the library path environment variable according to '-dlopen'
-flags.
-
-If any of the ARGS are libtool executable wrappers, then they are translated
-into their corresponding uninstalled binary, and any of their required library
-directories are added to the library path.
-
-Then, COMMAND is executed, with ARGS as arguments."
-        ;;
-
-      finish)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
-
-Complete the installation of libtool libraries.
-
-Each LIBDIR is a directory that contains libtool libraries.
-
-The commands that this mode executes may require superuser privileges.  Use
-the '--dry-run' option if you just want to see what would be executed."
-        ;;
-
-      install)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
-
-Install executables or libraries.
-
-INSTALL-COMMAND is the installation command.  The first component should be
-either the 'install' or 'cp' program.
-
-The following components of INSTALL-COMMAND are treated specially:
-
-  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
-
-The rest of the components are interpreted as arguments to that command (only
-BSD-compatible install options are recognized)."
-        ;;
-
-      link)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
-
-Link object files or libraries together to form another library, or to
-create an executable program.
-
-LINK-COMMAND is a command using the C compiler that you would use to create
-a program from several object files.
-
-The following components of LINK-COMMAND are treated specially:
-
-  -all-static       do not do any dynamic linking at all
-  -avoid-version    do not add a version suffix if possible
-  -bindir BINDIR    specify path to binaries directory (for systems where
-                    libraries must be found in the PATH setting at runtime)
-  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
-  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
-  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
-  -export-symbols SYMFILE
-                    try to export only the symbols listed in SYMFILE
-  -export-symbols-regex REGEX
-                    try to export only the symbols matching REGEX
-  -LLIBDIR          search LIBDIR for required installed libraries
-  -lNAME            OUTPUT-FILE requires the installed library libNAME
-  -module           build a library that can dlopened
-  -no-fast-install  disable the fast-install mode
-  -no-install       link a not-installable executable
-  -no-undefined     declare that a library does not refer to external symbols
-  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
-  -objectlist FILE  use a list of object files found in FILE to specify objects
-  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
-  -precious-files-regex REGEX
-                    don't remove output files matching REGEX
-  -release RELEASE  specify package release information
-  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
-  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
-  -shared           only do dynamic linking of libtool libraries
-  -shrext SUFFIX    override the standard shared library file extension
-  -static           do not do any dynamic linking of uninstalled libtool libraries
-  -static-libtool-libs
-                    do not do any dynamic linking of libtool libraries
-  -version-info CURRENT[:REVISION[:AGE]]
-                    specify library version info [each variable defaults to 0]
-  -weak LIBNAME     declare that the target provides the LIBNAME interface
-  -Wc,FLAG
-  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
-  -Wl,FLAG
-  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
-  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
-
-All other options (arguments beginning with '-') are ignored.
-
-Every other argument is treated as a filename.  Files ending in '.la' are
-treated as uninstalled libtool libraries, other files are standard or library
-object files.
-
-If the OUTPUT-FILE ends in '.la', then a libtool library is created,
-only library objects ('.lo' files) may be specified, and '-rpath' is
-required, except when creating a convenience library.
-
-If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
-using 'ar' and 'ranlib', or on Windows using 'lib'.
-
-If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
-is created, otherwise an executable program is created."
-        ;;
-
-      uninstall)
-        $ECHO \
-"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
-
-Remove libraries from an installation directory.
-
-RM is the name of the program to use to delete files associated with each FILE
-(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
-to RM.
-
-If FILE is a libtool library, all the files associated with it are deleted.
-Otherwise, only FILE itself is deleted using RM."
-        ;;
-
-      *)
-        func_fatal_help "invalid operation mode '$opt_mode'"
-        ;;
-    esac
-
-    echo
-    $ECHO "Try '$progname --help' for more information about other modes."
-}
-
-# Now that we've collected a possible --mode arg, show help if necessary
-if $opt_help; then
-  if test : = "$opt_help"; then
-    func_mode_help
-  else
-    {
-      func_help noexit
-      for opt_mode in compile link execute install finish uninstall clean; do
-	func_mode_help
-      done
-    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
-    {
-      func_help noexit
-      for opt_mode in compile link execute install finish uninstall clean; do
-	echo
-	func_mode_help
-      done
-    } |
-    $SED '1d
-      /^When reporting/,/^Report/{
-	H
-	d
-      }
-      $x
-      /information about other modes/d
-      /more detailed .*MODE/d
-      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
-  fi
-  exit $?
-fi
-
-
-# func_mode_execute arg...
-func_mode_execute ()
-{
-    $debug_cmd
-
-    # The first argument is the command name.
-    cmd=$nonopt
-    test -z "$cmd" && \
-      func_fatal_help "you must specify a COMMAND"
-
-    # Handle -dlopen flags immediately.
-    for file in $opt_dlopen; do
-      test -f "$file" \
-	|| func_fatal_help "'$file' is not a file"
-
-      dir=
-      case $file in
-      *.la)
-	func_resolve_sysroot "$file"
-	file=$func_resolve_sysroot_result
-
-	# Check to see that this really is a libtool archive.
-	func_lalib_unsafe_p "$file" \
-	  || func_fatal_help "'$lib' is not a valid libtool archive"
-
-	# Read the libtool library.
-	dlname=
-	library_names=
-	func_source "$file"
-
-	# Skip this library if it cannot be dlopened.
-	if test -z "$dlname"; then
-	  # Warn if it was a shared library.
-	  test -n "$library_names" && \
-	    func_warning "'$file' was not linked with '-export-dynamic'"
-	  continue
-	fi
-
-	func_dirname "$file" "" "."
-	dir=$func_dirname_result
-
-	if test -f "$dir/$objdir/$dlname"; then
-	  func_append dir "/$objdir"
-	else
-	  if test ! -f "$dir/$dlname"; then
-	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
-	  fi
-	fi
-	;;
-
-      *.lo)
-	# Just add the directory containing the .lo file.
-	func_dirname "$file" "" "."
-	dir=$func_dirname_result
-	;;
-
-      *)
-	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
-	continue
-	;;
-      esac
-
-      # Get the absolute pathname.
-      absdir=`cd "$dir" && pwd`
-      test -n "$absdir" && dir=$absdir
-
-      # Now add the directory to shlibpath_var.
-      if eval "test -z \"\$$shlibpath_var\""; then
-	eval "$shlibpath_var=\"\$dir\""
-      else
-	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
-      fi
-    done
-
-    # This variable tells wrapper scripts just to set shlibpath_var
-    # rather than running their programs.
-    libtool_execute_magic=$magic
-
-    # Check if any of the arguments is a wrapper script.
-    args=
-    for file
-    do
-      case $file in
-      -* | *.la | *.lo ) ;;
-      *)
-	# Do a test to see if this is really a libtool program.
-	if func_ltwrapper_script_p "$file"; then
-	  func_source "$file"
-	  # Transform arg to wrapped name.
-	  file=$progdir/$program
-	elif func_ltwrapper_executable_p "$file"; then
-	  func_ltwrapper_scriptname "$file"
-	  func_source "$func_ltwrapper_scriptname_result"
-	  # Transform arg to wrapped name.
-	  file=$progdir/$program
-	fi
-	;;
-      esac
-      # Quote arguments (to preserve shell metacharacters).
-      func_append_quoted args "$file"
-    done
-
-    if $opt_dry_run; then
-      # Display what would be done.
-      if test -n "$shlibpath_var"; then
-	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
-	echo "export $shlibpath_var"
-      fi
-      $ECHO "$cmd$args"
-      exit $EXIT_SUCCESS
-    else
-      if test -n "$shlibpath_var"; then
-	# Export the shlibpath_var.
-	eval "export $shlibpath_var"
-      fi
-
-      # Restore saved environment variables
-      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
-      do
-	eval "if test \"\${save_$lt_var+set}\" = set; then
-                $lt_var=\$save_$lt_var; export $lt_var
-	      else
-		$lt_unset $lt_var
-	      fi"
-      done
-
-      # Now prepare to actually exec the command.
-      exec_cmd=\$cmd$args
-    fi
-}
-
-test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
-
-
-# func_mode_finish arg...
-func_mode_finish ()
-{
-    $debug_cmd
-
-    libs=
-    libdirs=
-    admincmds=
-
-    for opt in "$nonopt" ${1+"$@"}
-    do
-      if test -d "$opt"; then
-	func_append libdirs " $opt"
-
-      elif test -f "$opt"; then
-	if func_lalib_unsafe_p "$opt"; then
-	  func_append libs " $opt"
-	else
-	  func_warning "'$opt' is not a valid libtool archive"
-	fi
-
-      else
-	func_fatal_error "invalid argument '$opt'"
-      fi
-    done
-
-    if test -n "$libs"; then
-      if test -n "$lt_sysroot"; then
-        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
-        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
-      else
-        sysroot_cmd=
-      fi
-
-      # Remove sysroot references
-      if $opt_dry_run; then
-        for lib in $libs; do
-          echo "removing references to $lt_sysroot and '=' prefixes from $lib"
-        done
-      else
-        tmpdir=`func_mktempdir`
-        for lib in $libs; do
-	  $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
-	    > $tmpdir/tmp-la
-	  mv -f $tmpdir/tmp-la $lib
-	done
-        ${RM}r "$tmpdir"
-      fi
-    fi
-
-    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
-      for libdir in $libdirs; do
-	if test -n "$finish_cmds"; then
-	  # Do each command in the finish commands.
-	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
-'"$cmd"'"'
-	fi
-	if test -n "$finish_eval"; then
-	  # Do the single finish_eval.
-	  eval cmds=\"$finish_eval\"
-	  $opt_dry_run || eval "$cmds" || func_append admincmds "
-       $cmds"
-	fi
-      done
-    fi
-
-    # Exit here if they wanted silent mode.
-    $opt_quiet && exit $EXIT_SUCCESS
-
-    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
-      echo "----------------------------------------------------------------------"
-      echo "Libraries have been installed in:"
-      for libdir in $libdirs; do
-	$ECHO "   $libdir"
-      done
-      echo
-      echo "If you ever happen to want to link against installed libraries"
-      echo "in a given directory, LIBDIR, you must either use libtool, and"
-      echo "specify the full pathname of the library, or use the '-LLIBDIR'"
-      echo "flag during linking and do at least one of the following:"
-      if test -n "$shlibpath_var"; then
-	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
-	echo "     during execution"
-      fi
-      if test -n "$runpath_var"; then
-	echo "   - add LIBDIR to the '$runpath_var' environment variable"
-	echo "     during linking"
-      fi
-      if test -n "$hardcode_libdir_flag_spec"; then
-	libdir=LIBDIR
-	eval flag=\"$hardcode_libdir_flag_spec\"
-
-	$ECHO "   - use the '$flag' linker flag"
-      fi
-      if test -n "$admincmds"; then
-	$ECHO "   - have your system administrator run these commands:$admincmds"
-      fi
-      if test -f /etc/ld.so.conf; then
-	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
-      fi
-      echo
-
-      echo "See any operating system documentation about shared libraries for"
-      case $host in
-	solaris2.[6789]|solaris2.1[0-9])
-	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
-	  echo "pages."
-	  ;;
-	*)
-	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
-	  ;;
-      esac
-      echo "----------------------------------------------------------------------"
-    fi
-    exit $EXIT_SUCCESS
-}
-
-test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
-
-
-# func_mode_install arg...
-func_mode_install ()
-{
-    $debug_cmd
-
-    # There may be an optional sh(1) argument at the beginning of
-    # install_prog (especially on Windows NT).
-    if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
-       # Allow the use of GNU shtool's install command.
-       case $nonopt in *shtool*) :;; *) false;; esac
-    then
-      # Aesthetically quote it.
-      func_quote_for_eval "$nonopt"
-      install_prog="$func_quote_for_eval_result "
-      arg=$1
-      shift
-    else
-      install_prog=
-      arg=$nonopt
-    fi
-
-    # The real first argument should be the name of the installation program.
-    # Aesthetically quote it.
-    func_quote_for_eval "$arg"
-    func_append install_prog "$func_quote_for_eval_result"
-    install_shared_prog=$install_prog
-    case " $install_prog " in
-      *[\\\ /]cp\ *) install_cp=: ;;
-      *) install_cp=false ;;
-    esac
-
-    # We need to accept at least all the BSD install flags.
-    dest=
-    files=
-    opts=
-    prev=
-    install_type=
-    isdir=false
-    stripme=
-    no_mode=:
-    for arg
-    do
-      arg2=
-      if test -n "$dest"; then
-	func_append files " $dest"
-	dest=$arg
-	continue
-      fi
-
-      case $arg in
-      -d) isdir=: ;;
-      -f)
-	if $install_cp; then :; else
-	  prev=$arg
-	fi
-	;;
-      -g | -m | -o)
-	prev=$arg
-	;;
-      -s)
-	stripme=" -s"
-	continue
-	;;
-      -*)
-	;;
-      *)
-	# If the previous option needed an argument, then skip it.
-	if test -n "$prev"; then
-	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
-	    arg2=$install_override_mode
-	    no_mode=false
-	  fi
-	  prev=
-	else
-	  dest=$arg
-	  continue
-	fi
-	;;
-      esac
-
-      # Aesthetically quote the argument.
-      func_quote_for_eval "$arg"
-      func_append install_prog " $func_quote_for_eval_result"
-      if test -n "$arg2"; then
-	func_quote_for_eval "$arg2"
-      fi
-      func_append install_shared_prog " $func_quote_for_eval_result"
-    done
-
-    test -z "$install_prog" && \
-      func_fatal_help "you must specify an install program"
-
-    test -n "$prev" && \
-      func_fatal_help "the '$prev' option requires an argument"
-
-    if test -n "$install_override_mode" && $no_mode; then
-      if $install_cp; then :; else
-	func_quote_for_eval "$install_override_mode"
-	func_append install_shared_prog " -m $func_quote_for_eval_result"
-      fi
-    fi
-
-    if test -z "$files"; then
-      if test -z "$dest"; then
-	func_fatal_help "no file or destination specified"
-      else
-	func_fatal_help "you must specify a destination"
-      fi
-    fi
-
-    # Strip any trailing slash from the destination.
-    func_stripname '' '/' "$dest"
-    dest=$func_stripname_result
-
-    # Check to see that the destination is a directory.
-    test -d "$dest" && isdir=:
-    if $isdir; then
-      destdir=$dest
-      destname=
-    else
-      func_dirname_and_basename "$dest" "" "."
-      destdir=$func_dirname_result
-      destname=$func_basename_result
-
-      # Not a directory, so check to see that there is only one file specified.
-      set dummy $files; shift
-      test "$#" -gt 1 && \
-	func_fatal_help "'$dest' is not a directory"
-    fi
-    case $destdir in
-    [\\/]* | [A-Za-z]:[\\/]*) ;;
-    *)
-      for file in $files; do
-	case $file in
-	*.lo) ;;
-	*)
-	  func_fatal_help "'$destdir' must be an absolute directory name"
-	  ;;
-	esac
-      done
-      ;;
-    esac
-
-    # This variable tells wrapper scripts just to set variables rather
-    # than running their programs.
-    libtool_install_magic=$magic
-
-    staticlibs=
-    future_libdirs=
-    current_libdirs=
-    for file in $files; do
-
-      # Do each installation.
-      case $file in
-      *.$libext)
-	# Do the static libraries later.
-	func_append staticlibs " $file"
-	;;
-
-      *.la)
-	func_resolve_sysroot "$file"
-	file=$func_resolve_sysroot_result
-
-	# Check to see that this really is a libtool archive.
-	func_lalib_unsafe_p "$file" \
-	  || func_fatal_help "'$file' is not a valid libtool archive"
-
-	library_names=
-	old_library=
-	relink_command=
-	func_source "$file"
-
-	# Add the libdir to current_libdirs if it is the destination.
-	if test "X$destdir" = "X$libdir"; then
-	  case "$current_libdirs " in
-	  *" $libdir "*) ;;
-	  *) func_append current_libdirs " $libdir" ;;
-	  esac
-	else
-	  # Note the libdir as a future libdir.
-	  case "$future_libdirs " in
-	  *" $libdir "*) ;;
-	  *) func_append future_libdirs " $libdir" ;;
-	  esac
-	fi
-
-	func_dirname "$file" "/" ""
-	dir=$func_dirname_result
-	func_append dir "$objdir"
-
-	if test -n "$relink_command"; then
-	  # Determine the prefix the user has applied to our future dir.
-	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
-
-	  # Don't allow the user to place us outside of our expected
-	  # location b/c this prevents finding dependent libraries that
-	  # are installed to the same prefix.
-	  # At present, this check doesn't affect windows .dll's that
-	  # are installed into $libdir/../bin (currently, that works fine)
-	  # but it's something to keep an eye on.
-	  test "$inst_prefix_dir" = "$destdir" && \
-	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
-
-	  if test -n "$inst_prefix_dir"; then
-	    # Stick the inst_prefix_dir data into the link command.
-	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
-	  else
-	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
-	  fi
-
-	  func_warning "relinking '$file'"
-	  func_show_eval "$relink_command" \
-	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
-	fi
-
-	# See the names of the shared library.
-	set dummy $library_names; shift
-	if test -n "$1"; then
-	  realname=$1
-	  shift
-
-	  srcname=$realname
-	  test -n "$relink_command" && srcname=${realname}T
-
-	  # Install the shared library and build the symlinks.
-	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
-	      'exit $?'
-	  tstripme=$stripme
-	  case $host_os in
-	  cygwin* | mingw* | pw32* | cegcc*)
-	    case $realname in
-	    *.dll.a)
-	      tstripme=
-	      ;;
-	    esac
-	    ;;
-	  os2*)
-	    case $realname in
-	    *_dll.a)
-	      tstripme=
-	      ;;
-	    esac
-	    ;;
-	  esac
-	  if test -n "$tstripme" && test -n "$striplib"; then
-	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
-	  fi
-
-	  if test "$#" -gt 0; then
-	    # Delete the old symlinks, and create new ones.
-	    # Try 'ln -sf' first, because the 'ln' binary might depend on
-	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
-	    # so we also need to try rm && ln -s.
-	    for linkname
-	    do
-	      test "$linkname" != "$realname" \
-		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
-	    done
-	  fi
-
-	  # Do each command in the postinstall commands.
-	  lib=$destdir/$realname
-	  func_execute_cmds "$postinstall_cmds" 'exit $?'
-	fi
-
-	# Install the pseudo-library for information purposes.
-	func_basename "$file"
-	name=$func_basename_result
-	instname=$dir/${name}i
-	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
-
-	# Maybe install the static library, too.
-	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
-	;;
-
-      *.lo)
-	# Install (i.e. copy) a libtool object.
-
-	# Figure out destination file name, if it wasn't already specified.
-	if test -n "$destname"; then
-	  destfile=$destdir/$destname
-	else
-	  func_basename "$file"
-	  destfile=$func_basename_result
-	  destfile=$destdir/$destfile
-	fi
-
-	# Deduce the name of the destination old-style object file.
-	case $destfile in
-	*.lo)
-	  func_lo2o "$destfile"
-	  staticdest=$func_lo2o_result
-	  ;;
-	*.$objext)
-	  staticdest=$destfile
-	  destfile=
-	  ;;
-	*)
-	  func_fatal_help "cannot copy a libtool object to '$destfile'"
-	  ;;
-	esac
-
-	# Install the libtool object if requested.
-	test -n "$destfile" && \
-	  func_show_eval "$install_prog $file $destfile" 'exit $?'
-
-	# Install the old object if enabled.
-	if test yes = "$build_old_libs"; then
-	  # Deduce the name of the old-style object file.
-	  func_lo2o "$file"
-	  staticobj=$func_lo2o_result
-	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
-	fi
-	exit $EXIT_SUCCESS
-	;;
-
-      *)
-	# Figure out destination file name, if it wasn't already specified.
-	if test -n "$destname"; then
-	  destfile=$destdir/$destname
-	else
-	  func_basename "$file"
-	  destfile=$func_basename_result
-	  destfile=$destdir/$destfile
-	fi
-
-	# If the file is missing, and there is a .exe on the end, strip it
-	# because it is most likely a libtool script we actually want to
-	# install
-	stripped_ext=
-	case $file in
-	  *.exe)
-	    if test ! -f "$file"; then
-	      func_stripname '' '.exe' "$file"
-	      file=$func_stripname_result
-	      stripped_ext=.exe
-	    fi
-	    ;;
-	esac
-
-	# Do a test to see if this is really a libtool program.
-	case $host in
-	*cygwin* | *mingw*)
-	    if func_ltwrapper_executable_p "$file"; then
-	      func_ltwrapper_scriptname "$file"
-	      wrapper=$func_ltwrapper_scriptname_result
-	    else
-	      func_stripname '' '.exe' "$file"
-	      wrapper=$func_stripname_result
-	    fi
-	    ;;
-	*)
-	    wrapper=$file
-	    ;;
-	esac
-	if func_ltwrapper_script_p "$wrapper"; then
-	  notinst_deplibs=
-	  relink_command=
-
-	  func_source "$wrapper"
-
-	  # Check the variables that should have been set.
-	  test -z "$generated_by_libtool_version" && \
-	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
-
-	  finalize=:
-	  for lib in $notinst_deplibs; do
-	    # Check to see that each library is installed.
-	    libdir=
-	    if test -f "$lib"; then
-	      func_source "$lib"
-	    fi
-	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
-	    if test -n "$libdir" && test ! -f "$libfile"; then
-	      func_warning "'$lib' has not been installed in '$libdir'"
-	      finalize=false
-	    fi
-	  done
-
-	  relink_command=
-	  func_source "$wrapper"
-
-	  outputname=
-	  if test no = "$fast_install" && test -n "$relink_command"; then
-	    $opt_dry_run || {
-	      if $finalize; then
-	        tmpdir=`func_mktempdir`
-		func_basename "$file$stripped_ext"
-		file=$func_basename_result
-	        outputname=$tmpdir/$file
-	        # Replace the output file specification.
-	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
-
-	        $opt_quiet || {
-	          func_quote_for_expand "$relink_command"
-		  eval "func_echo $func_quote_for_expand_result"
-	        }
-	        if eval "$relink_command"; then :
-	          else
-		  func_error "error: relink '$file' with the above command before installing it"
-		  $opt_dry_run || ${RM}r "$tmpdir"
-		  continue
-	        fi
-	        file=$outputname
-	      else
-	        func_warning "cannot relink '$file'"
-	      fi
-	    }
-	  else
-	    # Install the binary that we compiled earlier.
-	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
-	  fi
-	fi
-
-	# remove .exe since cygwin /usr/bin/install will append another
-	# one anyway
-	case $install_prog,$host in
-	*/usr/bin/install*,*cygwin*)
-	  case $file:$destfile in
-	  *.exe:*.exe)
-	    # this is ok
-	    ;;
-	  *.exe:*)
-	    destfile=$destfile.exe
-	    ;;
-	  *:*.exe)
-	    func_stripname '' '.exe' "$destfile"
-	    destfile=$func_stripname_result
-	    ;;
-	  esac
-	  ;;
-	esac
-	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
-	$opt_dry_run || if test -n "$outputname"; then
-	  ${RM}r "$tmpdir"
-	fi
-	;;
-      esac
-    done
-
-    for file in $staticlibs; do
-      func_basename "$file"
-      name=$func_basename_result
-
-      # Set up the ranlib parameters.
-      oldlib=$destdir/$name
-      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
-      tool_oldlib=$func_to_tool_file_result
-
-      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
-
-      if test -n "$stripme" && test -n "$old_striplib"; then
-	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
-      fi
-
-      # Do each command in the postinstall commands.
-      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
-    done
-
-    test -n "$future_libdirs" && \
-      func_warning "remember to run '$progname --finish$future_libdirs'"
-
-    if test -n "$current_libdirs"; then
-      # Maybe just do a dry run.
-      $opt_dry_run && current_libdirs=" -n$current_libdirs"
-      exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
-    else
-      exit $EXIT_SUCCESS
-    fi
-}
-
-test install = "$opt_mode" && func_mode_install ${1+"$@"}
-
-
-# func_generate_dlsyms outputname originator pic_p
-# Extract symbols from dlprefiles and create ${outputname}S.o with
-# a dlpreopen symbol table.
-func_generate_dlsyms ()
-{
-    $debug_cmd
-
-    my_outputname=$1
-    my_originator=$2
-    my_pic_p=${3-false}
-    my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
-    my_dlsyms=
-
-    if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
-      if test -n "$NM" && test -n "$global_symbol_pipe"; then
-	my_dlsyms=${my_outputname}S.c
-      else
-	func_error "not configured to extract global symbols from dlpreopened files"
-      fi
-    fi
-
-    if test -n "$my_dlsyms"; then
-      case $my_dlsyms in
-      "") ;;
-      *.c)
-	# Discover the nlist of each of the dlfiles.
-	nlist=$output_objdir/$my_outputname.nm
-
-	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
-
-	# Parse the name list into a source file.
-	func_verbose "creating $output_objdir/$my_dlsyms"
-
-	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
-/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
-/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
-
-#ifdef __cplusplus
-extern \"C\" {
-#endif
-
-#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
-#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
-#endif
-
-/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
-/* DATA imports from DLLs on WIN32 can't be const, because runtime
-   relocations are performed -- see ld's documentation on pseudo-relocs.  */
-# define LT_DLSYM_CONST
-#elif defined __osf__
-/* This system does not cope well with relocations in const data.  */
-# define LT_DLSYM_CONST
-#else
-# define LT_DLSYM_CONST const
-#endif
-
-#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
-
-/* External symbol declarations for the compiler. */\
-"
-
-	if test yes = "$dlself"; then
-	  func_verbose "generating symbol list for '$output'"
-
-	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
-
-	  # Add our own program objects to the symbol list.
-	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
-	  for progfile in $progfiles; do
-	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
-	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
-	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
-	  done
-
-	  if test -n "$exclude_expsyms"; then
-	    $opt_dry_run || {
-	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
-	      eval '$MV "$nlist"T "$nlist"'
-	    }
-	  fi
-
-	  if test -n "$export_symbols_regex"; then
-	    $opt_dry_run || {
-	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
-	      eval '$MV "$nlist"T "$nlist"'
-	    }
-	  fi
-
-	  # Prepare the list of exported symbols
-	  if test -z "$export_symbols"; then
-	    export_symbols=$output_objdir/$outputname.exp
-	    $opt_dry_run || {
-	      $RM $export_symbols
-	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
-	      case $host in
-	      *cygwin* | *mingw* | *cegcc* )
-                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
-                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
-	        ;;
-	      esac
-	    }
-	  else
-	    $opt_dry_run || {
-	      eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
-	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
-	      eval '$MV "$nlist"T "$nlist"'
-	      case $host in
-	        *cygwin* | *mingw* | *cegcc* )
-	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
-	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
-	          ;;
-	      esac
-	    }
-	  fi
-	fi
-
-	for dlprefile in $dlprefiles; do
-	  func_verbose "extracting global C symbols from '$dlprefile'"
-	  func_basename "$dlprefile"
-	  name=$func_basename_result
-          case $host in
-	    *cygwin* | *mingw* | *cegcc* )
-	      # if an import library, we need to obtain dlname
-	      if func_win32_import_lib_p "$dlprefile"; then
-	        func_tr_sh "$dlprefile"
-	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
-	        dlprefile_dlbasename=
-	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
-	          # Use subshell, to avoid clobbering current variable values
-	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
-	          if test -n "$dlprefile_dlname"; then
-	            func_basename "$dlprefile_dlname"
-	            dlprefile_dlbasename=$func_basename_result
-	          else
-	            # no lafile. user explicitly requested -dlpreopen <import library>.
-	            $sharedlib_from_linklib_cmd "$dlprefile"
-	            dlprefile_dlbasename=$sharedlib_from_linklib_result
-	          fi
-	        fi
-	        $opt_dry_run || {
-	          if test -n "$dlprefile_dlbasename"; then
-	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
-	          else
-	            func_warning "Could not compute DLL name from $name"
-	            eval '$ECHO ": $name " >> "$nlist"'
-	          fi
-	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
-	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
-	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
-	        }
-	      else # not an import lib
-	        $opt_dry_run || {
-	          eval '$ECHO ": $name " >> "$nlist"'
-	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
-	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
-	        }
-	      fi
-	    ;;
-	    *)
-	      $opt_dry_run || {
-	        eval '$ECHO ": $name " >> "$nlist"'
-	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
-	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
-	      }
-	    ;;
-          esac
-	done
-
-	$opt_dry_run || {
-	  # Make sure we have at least an empty file.
-	  test -f "$nlist" || : > "$nlist"
-
-	  if test -n "$exclude_expsyms"; then
-	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
-	    $MV "$nlist"T "$nlist"
-	  fi
-
-	  # Try sorting and uniquifying the output.
-	  if $GREP -v "^: " < "$nlist" |
-	      if sort -k 3 </dev/null >/dev/null 2>&1; then
-		sort -k 3
-	      else
-		sort +2
-	      fi |
-	      uniq > "$nlist"S; then
-	    :
-	  else
-	    $GREP -v "^: " < "$nlist" > "$nlist"S
-	  fi
-
-	  if test -f "$nlist"S; then
-	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
-	  else
-	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
-	  fi
-
-	  func_show_eval '$RM "${nlist}I"'
-	  if test -n "$global_symbol_to_import"; then
-	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
-	  fi
-
-	  echo >> "$output_objdir/$my_dlsyms" "\
-
-/* The mapping between symbol names and symbols.  */
-typedef struct {
-  const char *name;
-  void *address;
-} lt_dlsymlist;
-extern LT_DLSYM_CONST lt_dlsymlist
-lt_${my_prefix}_LTX_preloaded_symbols[];\
-"
-
-	  if test -s "$nlist"I; then
-	    echo >> "$output_objdir/$my_dlsyms" "\
-static void lt_syminit(void)
-{
-  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
-  for (; symbol->name; ++symbol)
-    {"
-	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
-	    echo >> "$output_objdir/$my_dlsyms" "\
-    }
-}"
-	  fi
-	  echo >> "$output_objdir/$my_dlsyms" "\
-LT_DLSYM_CONST lt_dlsymlist
-lt_${my_prefix}_LTX_preloaded_symbols[] =
-{ {\"$my_originator\", (void *) 0},"
-
-	  if test -s "$nlist"I; then
-	    echo >> "$output_objdir/$my_dlsyms" "\
-  {\"@INIT@\", (void *) &lt_syminit},"
-	  fi
-
-	  case $need_lib_prefix in
-	  no)
-	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
-	    ;;
-	  *)
-	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
-	    ;;
-	  esac
-	  echo >> "$output_objdir/$my_dlsyms" "\
-  {0, (void *) 0}
-};
-
-/* This works around a problem in FreeBSD linker */
-#ifdef FREEBSD_WORKAROUND
-static const void *lt_preloaded_setup() {
-  return lt_${my_prefix}_LTX_preloaded_symbols;
-}
-#endif
-
-#ifdef __cplusplus
-}
-#endif\
-"
-	} # !$opt_dry_run
-
-	pic_flag_for_symtable=
-	case "$compile_command " in
-	*" -static "*) ;;
-	*)
-	  case $host in
-	  # compiling the symbol table file with pic_flag works around
-	  # a FreeBSD bug that causes programs to crash when -lm is
-	  # linked before any other PIC object.  But we must not use
-	  # pic_flag when linking with -static.  The problem exists in
-	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
-	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
-	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
-	  *-*-hpux*)
-	    pic_flag_for_symtable=" $pic_flag"  ;;
-	  *)
-	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
-	    ;;
-	  esac
-	  ;;
-	esac
-	symtab_cflags=
-	for arg in $LTCFLAGS; do
-	  case $arg in
-	  -pie | -fpie | -fPIE) ;;
-	  *) func_append symtab_cflags " $arg" ;;
-	  esac
-	done
-
-	# Now compile the dynamic symbol file.
-	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
-
-	# Clean up the generated files.
-	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
-
-	# Transform the symbol file into the correct name.
-	symfileobj=$output_objdir/${my_outputname}S.$objext
-	case $host in
-	*cygwin* | *mingw* | *cegcc* )
-	  if test -f "$output_objdir/$my_outputname.def"; then
-	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
-	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
-	  else
-	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	  fi
-	  ;;
-	*)
-	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
-	  ;;
-	esac
-	;;
-      *)
-	func_fatal_error "unknown suffix for '$my_dlsyms'"
-	;;
-      esac
-    else
-      # We keep going just in case the user didn't refer to
-      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
-      # really was required.
-
-      # Nullify the symbol file.
-      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
-      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
-    fi
-}
-
-# func_cygming_gnu_implib_p ARG
-# This predicate returns with zero status (TRUE) if
-# ARG is a GNU/binutils-style import library. Returns
-# with nonzero status (FALSE) otherwise.
-func_cygming_gnu_implib_p ()
-{
-  $debug_cmd
-
-  func_to_tool_file "$1" func_convert_file_msys_to_w32
-  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
-  test -n "$func_cygming_gnu_implib_tmp"
-}
-
-# func_cygming_ms_implib_p ARG
-# This predicate returns with zero status (TRUE) if
-# ARG is an MS-style import library. Returns
-# with nonzero status (FALSE) otherwise.
-func_cygming_ms_implib_p ()
-{
-  $debug_cmd
-
-  func_to_tool_file "$1" func_convert_file_msys_to_w32
-  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
-  test -n "$func_cygming_ms_implib_tmp"
-}
-
-# func_win32_libid arg
-# return the library type of file 'arg'
-#
-# Need a lot of goo to handle *both* DLLs and import libs
-# Has to be a shell function in order to 'eat' the argument
-# that is supplied when $file_magic_command is called.
-# Despite the name, also deal with 64 bit binaries.
-func_win32_libid ()
-{
-  $debug_cmd
-
-  win32_libid_type=unknown
-  win32_fileres=`file -L $1 2>/dev/null`
-  case $win32_fileres in
-  *ar\ archive\ import\ library*) # definitely import
-    win32_libid_type="x86 archive import"
-    ;;
-  *ar\ archive*) # could be an import, or static
-    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
-    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
-       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
-      case $nm_interface in
-      "MS dumpbin")
-	if func_cygming_ms_implib_p "$1" ||
-	   func_cygming_gnu_implib_p "$1"
-	then
-	  win32_nmres=import
-	else
-	  win32_nmres=
-	fi
-	;;
-      *)
-	func_to_tool_file "$1" func_convert_file_msys_to_w32
-	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
-	  $SED -n -e '
-	    1,100{
-		/ I /{
-		    s|.*|import|
-		    p
-		    q
-		}
-	    }'`
-	;;
-      esac
-      case $win32_nmres in
-      import*)  win32_libid_type="x86 archive import";;
-      *)        win32_libid_type="x86 archive static";;
-      esac
-    fi
-    ;;
-  *DLL*)
-    win32_libid_type="x86 DLL"
-    ;;
-  *executable*) # but shell scripts are "executable" too...
-    case $win32_fileres in
-    *MS\ Windows\ PE\ Intel*)
-      win32_libid_type="x86 DLL"
-      ;;
-    esac
-    ;;
-  esac
-  $ECHO "$win32_libid_type"
-}
-
-# func_cygming_dll_for_implib ARG
-#
-# Platform-specific function to extract the
-# name of the DLL associated with the specified
-# import library ARG.
-# Invoked by eval'ing the libtool variable
-#    $sharedlib_from_linklib_cmd
-# Result is available in the variable
-#    $sharedlib_from_linklib_result
-func_cygming_dll_for_implib ()
-{
-  $debug_cmd
-
-  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
-}
-
-# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
-#
-# The is the core of a fallback implementation of a
-# platform-specific function to extract the name of the
-# DLL associated with the specified import library LIBNAME.
-#
-# SECTION_NAME is either .idata$6 or .idata$7, depending
-# on the platform and compiler that created the implib.
-#
-# Echos the name of the DLL associated with the
-# specified import library.
-func_cygming_dll_for_implib_fallback_core ()
-{
-  $debug_cmd
-
-  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
-  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
-    $SED '/^Contents of section '"$match_literal"':/{
-      # Place marker at beginning of archive member dllname section
-      s/.*/====MARK====/
-      p
-      d
-    }
-    # These lines can sometimes be longer than 43 characters, but
-    # are always uninteresting
-    /:[	 ]*file format pe[i]\{,1\}-/d
-    /^In archive [^:]*:/d
-    # Ensure marker is printed
-    /^====MARK====/p
-    # Remove all lines with less than 43 characters
-    /^.\{43\}/!d
-    # From remaining lines, remove first 43 characters
-    s/^.\{43\}//' |
-    $SED -n '
-      # Join marker and all lines until next marker into a single line
-      /^====MARK====/ b para
-      H
-      $ b para
-      b
-      :para
-      x
-      s/\n//g
-      # Remove the marker
-      s/^====MARK====//
-      # Remove trailing dots and whitespace
-      s/[\. \t]*$//
-      # Print
-      /./p' |
-    # we now have a list, one entry per line, of the stringified
-    # contents of the appropriate section of all members of the
-    # archive that possess that section. Heuristic: eliminate
-    # all those that have a first or second character that is
-    # a '.' (that is, objdump's representation of an unprintable
-    # character.) This should work for all archives with less than
-    # 0x302f exports -- but will fail for DLLs whose name actually
-    # begins with a literal '.' or a single character followed by
-    # a '.'.
-    #
-    # Of those that remain, print the first one.
-    $SED -e '/^\./d;/^.\./d;q'
-}
-
-# func_cygming_dll_for_implib_fallback ARG
-# Platform-specific function to extract the
-# name of the DLL associated with the specified
-# import library ARG.
-#
-# This fallback implementation is for use when $DLLTOOL
-# does not support the --identify-strict option.
-# Invoked by eval'ing the libtool variable
-#    $sharedlib_from_linklib_cmd
-# Result is available in the variable
-#    $sharedlib_from_linklib_result
-func_cygming_dll_for_implib_fallback ()
-{
-  $debug_cmd
-
-  if func_cygming_gnu_implib_p "$1"; then
-    # binutils import library
-    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
-  elif func_cygming_ms_implib_p "$1"; then
-    # ms-generated import library
-    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
-  else
-    # unknown
-    sharedlib_from_linklib_result=
-  fi
-}
-
-
-# func_extract_an_archive dir oldlib
-func_extract_an_archive ()
-{
-    $debug_cmd
-
-    f_ex_an_ar_dir=$1; shift
-    f_ex_an_ar_oldlib=$1
-    if test yes = "$lock_old_archive_extraction"; then
-      lockfile=$f_ex_an_ar_oldlib.lock
-      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
-	func_echo "Waiting for $lockfile to be removed"
-	sleep 2
-      done
-    fi
-    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
-		   'stat=$?; rm -f "$lockfile"; exit $stat'
-    if test yes = "$lock_old_archive_extraction"; then
-      $opt_dry_run || rm -f "$lockfile"
-    fi
-    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
-     :
-    else
-      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
-    fi
-}
-
-
-# func_extract_archives gentop oldlib ...
-func_extract_archives ()
-{
-    $debug_cmd
-
-    my_gentop=$1; shift
-    my_oldlibs=${1+"$@"}
-    my_oldobjs=
-    my_xlib=
-    my_xabs=
-    my_xdir=
-
-    for my_xlib in $my_oldlibs; do
-      # Extract the objects.
-      case $my_xlib in
-	[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
-	*) my_xabs=`pwd`"/$my_xlib" ;;
-      esac
-      func_basename "$my_xlib"
-      my_xlib=$func_basename_result
-      my_xlib_u=$my_xlib
-      while :; do
-        case " $extracted_archives " in
-	*" $my_xlib_u "*)
-	  func_arith $extracted_serial + 1
-	  extracted_serial=$func_arith_result
-	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
-	*) break ;;
-	esac
-      done
-      extracted_archives="$extracted_archives $my_xlib_u"
-      my_xdir=$my_gentop/$my_xlib_u
-
-      func_mkdir_p "$my_xdir"
-
-      case $host in
-      *-darwin*)
-	func_verbose "Extracting $my_xabs"
-	# Do not bother doing anything if just a dry run
-	$opt_dry_run || {
-	  darwin_orig_dir=`pwd`
-	  cd $my_xdir || exit $?
-	  darwin_archive=$my_xabs
-	  darwin_curdir=`pwd`
-	  func_basename "$darwin_archive"
-	  darwin_base_archive=$func_basename_result
-	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
-	  if test -n "$darwin_arches"; then
-	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
-	    darwin_arch=
-	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
-	    for darwin_arch in  $darwin_arches; do
-	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
-	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
-	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
-	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
-	      cd "$darwin_curdir"
-	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
-	    done # $darwin_arches
-            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
-	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
-	    darwin_file=
-	    darwin_files=
-	    for darwin_file in $darwin_filelist; do
-	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
-	      $LIPO -create -output "$darwin_file" $darwin_files
-	    done # $darwin_filelist
-	    $RM -rf unfat-$$
-	    cd "$darwin_orig_dir"
-	  else
-	    cd $darwin_orig_dir
-	    func_extract_an_archive "$my_xdir" "$my_xabs"
-	  fi # $darwin_arches
-	} # !$opt_dry_run
-	;;
-      *)
-        func_extract_an_archive "$my_xdir" "$my_xabs"
-	;;
-      esac
-      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
-    done
-
-    func_extract_archives_result=$my_oldobjs
-}
-
-
-# func_emit_wrapper [arg=no]
-#
-# Emit a libtool wrapper script on stdout.
-# Don't directly open a file because we may want to
-# incorporate the script contents within a cygwin/mingw
-# wrapper executable.  Must ONLY be called from within
-# func_mode_link because it depends on a number of variables
-# set therein.
-#
-# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
-# variable will take.  If 'yes', then the emitted script
-# will assume that the directory where it is stored is
-# the $objdir directory.  This is a cygwin/mingw-specific
-# behavior.
-func_emit_wrapper ()
-{
-	func_emit_wrapper_arg1=${1-no}
-
-	$ECHO "\
-#! $SHELL
-
-# $output - temporary wrapper script for $objdir/$outputname
-# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
-#
-# The $output program cannot be directly executed until all the libtool
-# libraries that it depends on are installed.
-#
-# This wrapper script should never be moved out of the build directory.
-# If it is, it will not operate correctly.
-
-# Sed substitution that helps us do robust quoting.  It backslashifies
-# metacharacters that are still active within double-quoted strings.
-sed_quote_subst='$sed_quote_subst'
-
-# Be Bourne compatible
-if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
-  emulate sh
-  NULLCMD=:
-  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
-fi
-BIN_SH=xpg4; export BIN_SH # for Tru64
-DUALCASE=1; export DUALCASE # for MKS sh
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-relink_command=\"$relink_command\"
-
-# This environment variable determines our operation mode.
-if test \"\$libtool_install_magic\" = \"$magic\"; then
-  # install mode needs the following variables:
-  generated_by_libtool_version='$macro_version'
-  notinst_deplibs='$notinst_deplibs'
-else
-  # When we are sourced in execute mode, \$file and \$ECHO are already set.
-  if test \"\$libtool_execute_magic\" != \"$magic\"; then
-    file=\"\$0\""
-
-    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
-    $ECHO "\
-
-# A function that is used when there is no print builtin or printf.
-func_fallback_echo ()
-{
-  eval 'cat <<_LTECHO_EOF
-\$1
-_LTECHO_EOF'
-}
-    ECHO=\"$qECHO\"
-  fi
-
-# Very basic option parsing. These options are (a) specific to
-# the libtool wrapper, (b) are identical between the wrapper
-# /script/ and the wrapper /executable/ that is used only on
-# windows platforms, and (c) all begin with the string "--lt-"
-# (application programs are unlikely to have options that match
-# this pattern).
-#
-# There are only two supported options: --lt-debug and
-# --lt-dump-script. There is, deliberately, no --lt-help.
-#
-# The first argument to this parsing function should be the
-# script's $0 value, followed by "$@".
-lt_option_debug=
-func_parse_lt_options ()
-{
-  lt_script_arg0=\$0
-  shift
-  for lt_opt
-  do
-    case \"\$lt_opt\" in
-    --lt-debug) lt_option_debug=1 ;;
-    --lt-dump-script)
-        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
-        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
-        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
-        cat \"\$lt_dump_D/\$lt_dump_F\"
-        exit 0
-      ;;
-    --lt-*)
-        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
-        exit 1
-      ;;
-    esac
-  done
-
-  # Print the debug banner immediately:
-  if test -n \"\$lt_option_debug\"; then
-    echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
-  fi
-}
-
-# Used when --lt-debug. Prints its arguments to stdout
-# (redirection is the responsibility of the caller)
-func_lt_dump_args ()
-{
-  lt_dump_args_N=1;
-  for lt_arg
-  do
-    \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
-    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
-  done
-}
-
-# Core function for launching the target application
-func_exec_program_core ()
-{
-"
-  case $host in
-  # Backslashes separate directories on plain windows
-  *-*-mingw | *-*-os2* | *-cegcc*)
-    $ECHO "\
-      if test -n \"\$lt_option_debug\"; then
-        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
-        func_lt_dump_args \${1+\"\$@\"} 1>&2
-      fi
-      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
-"
-    ;;
-
-  *)
-    $ECHO "\
-      if test -n \"\$lt_option_debug\"; then
-        \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
-        func_lt_dump_args \${1+\"\$@\"} 1>&2
-      fi
-      exec \"\$progdir/\$program\" \${1+\"\$@\"}
-"
-    ;;
-  esac
-  $ECHO "\
-      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
-      exit 1
-}
-
-# A function to encapsulate launching the target application
-# Strips options in the --lt-* namespace from \$@ and
-# launches target application with the remaining arguments.
-func_exec_program ()
-{
-  case \" \$* \" in
-  *\\ --lt-*)
-    for lt_wr_arg
-    do
-      case \$lt_wr_arg in
-      --lt-*) ;;
-      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
-      esac
-      shift
-    done ;;
-  esac
-  func_exec_program_core \${1+\"\$@\"}
-}
-
-  # Parse options
-  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
-
-  # Find the directory that this script lives in.
-  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
-  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
-
-  # Follow symbolic links until we get to the real thisdir.
-  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
-  while test -n \"\$file\"; do
-    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
-
-    # If there was a directory component, then change thisdir.
-    if test \"x\$destdir\" != \"x\$file\"; then
-      case \"\$destdir\" in
-      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
-      *) thisdir=\"\$thisdir/\$destdir\" ;;
-      esac
-    fi
-
-    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
-    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
-  done
-
-  # Usually 'no', except on cygwin/mingw when embedded into
-  # the cwrapper.
-  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
-  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
-    # special case for '.'
-    if test \"\$thisdir\" = \".\"; then
-      thisdir=\`pwd\`
-    fi
-    # remove .libs from thisdir
-    case \"\$thisdir\" in
-    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
-    $objdir )   thisdir=. ;;
-    esac
-  fi
-
-  # Try to get the absolute directory name.
-  absdir=\`cd \"\$thisdir\" && pwd\`
-  test -n \"\$absdir\" && thisdir=\"\$absdir\"
-"
-
-	if test yes = "$fast_install"; then
-	  $ECHO "\
-  program=lt-'$outputname'$exeext
-  progdir=\"\$thisdir/$objdir\"
-
-  if test ! -f \"\$progdir/\$program\" ||
-     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
-       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
-
-    file=\"\$\$-\$program\"
-
-    if test ! -d \"\$progdir\"; then
-      $MKDIR \"\$progdir\"
-    else
-      $RM \"\$progdir/\$file\"
-    fi"
-
-	  $ECHO "\
-
-    # relink executable if necessary
-    if test -n \"\$relink_command\"; then
-      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
-      else
-	\$ECHO \"\$relink_command_output\" >&2
-	$RM \"\$progdir/\$file\"
-	exit 1
-      fi
-    fi
-
-    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
-    { $RM \"\$progdir/\$program\";
-      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
-    $RM \"\$progdir/\$file\"
-  fi"
-	else
-	  $ECHO "\
-  program='$outputname'
-  progdir=\"\$thisdir/$objdir\"
-"
-	fi
-
-	$ECHO "\
-
-  if test -f \"\$progdir/\$program\"; then"
-
-	# fixup the dll searchpath if we need to.
-	#
-	# Fix the DLL searchpath if we need to.  Do this before prepending
-	# to shlibpath, because on Windows, both are PATH and uninstalled
-	# libraries must come first.
-	if test -n "$dllsearchpath"; then
-	  $ECHO "\
-    # Add the dll search path components to the executable PATH
-    PATH=$dllsearchpath:\$PATH
-"
-	fi
-
-	# Export our shlibpath_var if we have one.
-	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
-	  $ECHO "\
-    # Add our own library path to $shlibpath_var
-    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
-
-    # Some systems cannot cope with colon-terminated $shlibpath_var
-    # The second colon is a workaround for a bug in BeOS R4 sed
-    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
-
-    export $shlibpath_var
-"
-	fi
-
-	$ECHO "\
-    if test \"\$libtool_execute_magic\" != \"$magic\"; then
-      # Run the actual program with our arguments.
-      func_exec_program \${1+\"\$@\"}
-    fi
-  else
-    # The program doesn't exist.
-    \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
-    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
-    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
-    exit 1
-  fi
-fi\
-"
-}
-
-
-# func_emit_cwrapperexe_src
-# emit the source code for a wrapper executable on stdout
-# Must ONLY be called from within func_mode_link because
-# it depends on a number of variable set therein.
-func_emit_cwrapperexe_src ()
-{
-	cat <<EOF
-
-/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
-   Generated by $PROGRAM (GNU $PACKAGE) $VERSION
-
-   The $output program cannot be directly executed until all the libtool
-   libraries that it depends on are installed.
-
-   This wrapper executable should never be moved out of the build directory.
-   If it is, it will not operate correctly.
-*/
-EOF
-	    cat <<"EOF"
-#ifdef _MSC_VER
-# define _CRT_SECURE_NO_DEPRECATE 1
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-#ifdef _MSC_VER
-# include <direct.h>
-# include <process.h>
-# include <io.h>
-#else
-# include <unistd.h>
-# include <stdint.h>
-# ifdef __CYGWIN__
-#  include <io.h>
-# endif
-#endif
-#include <malloc.h>
-#include <stdarg.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-
-#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
-
-/* declarations of non-ANSI functions */
-#if defined __MINGW32__
-# ifdef __STRICT_ANSI__
-int _putenv (const char *);
-# endif
-#elif defined __CYGWIN__
-# ifdef __STRICT_ANSI__
-char *realpath (const char *, char *);
-int putenv (char *);
-int setenv (const char *, const char *, int);
-# endif
-/* #elif defined other_platform || defined ... */
-#endif
-
-/* portability defines, excluding path handling macros */
-#if defined _MSC_VER
-# define setmode _setmode
-# define stat    _stat
-# define chmod   _chmod
-# define getcwd  _getcwd
-# define putenv  _putenv
-# define S_IXUSR _S_IEXEC
-#elif defined __MINGW32__
-# define setmode _setmode
-# define stat    _stat
-# define chmod   _chmod
-# define getcwd  _getcwd
-# define putenv  _putenv
-#elif defined __CYGWIN__
-# define HAVE_SETENV
-# define FOPEN_WB "wb"
-/* #elif defined other platforms ... */
-#endif
-
-#if defined PATH_MAX
-# define LT_PATHMAX PATH_MAX
-#elif defined MAXPATHLEN
-# define LT_PATHMAX MAXPATHLEN
-#else
-# define LT_PATHMAX 1024
-#endif
-
-#ifndef S_IXOTH
-# define S_IXOTH 0
-#endif
-#ifndef S_IXGRP
-# define S_IXGRP 0
-#endif
-
-/* path handling portability macros */
-#ifndef DIR_SEPARATOR
-# define DIR_SEPARATOR '/'
-# define PATH_SEPARATOR ':'
-#endif
-
-#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
-  defined __OS2__
-# define HAVE_DOS_BASED_FILE_SYSTEM
-# define FOPEN_WB "wb"
-# ifndef DIR_SEPARATOR_2
-#  define DIR_SEPARATOR_2 '\\'
-# endif
-# ifndef PATH_SEPARATOR_2
-#  define PATH_SEPARATOR_2 ';'
-# endif
-#endif
-
-#ifndef DIR_SEPARATOR_2
-# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
-#else /* DIR_SEPARATOR_2 */
-# define IS_DIR_SEPARATOR(ch) \
-	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
-#endif /* DIR_SEPARATOR_2 */
-
-#ifndef PATH_SEPARATOR_2
-# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
-#else /* PATH_SEPARATOR_2 */
-# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
-#endif /* PATH_SEPARATOR_2 */
-
-#ifndef FOPEN_WB
-# define FOPEN_WB "w"
-#endif
-#ifndef _O_BINARY
-# define _O_BINARY 0
-#endif
-
-#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
-#define XFREE(stale) do { \
-  if (stale) { free (stale); stale = 0; } \
-} while (0)
-
-#if defined LT_DEBUGWRAPPER
-static int lt_debug = 1;
-#else
-static int lt_debug = 0;
-#endif
-
-const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
-
-void *xmalloc (size_t num);
-char *xstrdup (const char *string);
-const char *base_name (const char *name);
-char *find_executable (const char *wrapper);
-char *chase_symlinks (const char *pathspec);
-int make_executable (const char *path);
-int check_executable (const char *path);
-char *strendzap (char *str, const char *pat);
-void lt_debugprintf (const char *file, int line, const char *fmt, ...);
-void lt_fatal (const char *file, int line, const char *message, ...);
-static const char *nonnull (const char *s);
-static const char *nonempty (const char *s);
-void lt_setenv (const char *name, const char *value);
-char *lt_extend_str (const char *orig_value, const char *add, int to_end);
-void lt_update_exe_path (const char *name, const char *value);
-void lt_update_lib_path (const char *name, const char *value);
-char **prepare_spawn (char **argv);
-void lt_dump_script (FILE *f);
-EOF
-
-	    cat <<EOF
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
-# define externally_visible volatile
-#else
-# define externally_visible __attribute__((externally_visible)) volatile
-#endif
-externally_visible const char * MAGIC_EXE = "$magic_exe";
-const char * LIB_PATH_VARNAME = "$shlibpath_var";
-EOF
-
-	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
-              func_to_host_path "$temp_rpath"
-	      cat <<EOF
-const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
-EOF
-	    else
-	      cat <<"EOF"
-const char * LIB_PATH_VALUE   = "";
-EOF
-	    fi
-
-	    if test -n "$dllsearchpath"; then
-              func_to_host_path "$dllsearchpath:"
-	      cat <<EOF
-const char * EXE_PATH_VARNAME = "PATH";
-const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
-EOF
-	    else
-	      cat <<"EOF"
-const char * EXE_PATH_VARNAME = "";
-const char * EXE_PATH_VALUE   = "";
-EOF
-	    fi
-
-	    if test yes = "$fast_install"; then
-	      cat <<EOF
-const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
-EOF
-	    else
-	      cat <<EOF
-const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
-EOF
-	    fi
-
-
-	    cat <<"EOF"
-
-#define LTWRAPPER_OPTION_PREFIX         "--lt-"
-
-static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
-static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
-static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
-
-int
-main (int argc, char *argv[])
-{
-  char **newargz;
-  int  newargc;
-  char *tmp_pathspec;
-  char *actual_cwrapper_path;
-  char *actual_cwrapper_name;
-  char *target_name;
-  char *lt_argv_zero;
-  int rval = 127;
-
-  int i;
-
-  program_name = (char *) xstrdup (base_name (argv[0]));
-  newargz = XMALLOC (char *, (size_t) argc + 1);
-
-  /* very simple arg parsing; don't want to rely on getopt
-   * also, copy all non cwrapper options to newargz, except
-   * argz[0], which is handled differently
-   */
-  newargc=0;
-  for (i = 1; i < argc; i++)
-    {
-      if (STREQ (argv[i], dumpscript_opt))
-	{
-EOF
-	    case $host in
-	      *mingw* | *cygwin* )
-		# make stdout use "unix" line endings
-		echo "          setmode(1,_O_BINARY);"
-		;;
-	      esac
-
-	    cat <<"EOF"
-	  lt_dump_script (stdout);
-	  return 0;
-	}
-      if (STREQ (argv[i], debug_opt))
-	{
-          lt_debug = 1;
-          continue;
-	}
-      if (STREQ (argv[i], ltwrapper_option_prefix))
-        {
-          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
-             namespace, but it is not one of the ones we know about and
-             have already dealt with, above (inluding dump-script), then
-             report an error. Otherwise, targets might begin to believe
-             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
-             namespace. The first time any user complains about this, we'll
-             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
-             or a configure.ac-settable value.
-           */
-          lt_fatal (__FILE__, __LINE__,
-		    "unrecognized %s option: '%s'",
-                    ltwrapper_option_prefix, argv[i]);
-        }
-      /* otherwise ... */
-      newargz[++newargc] = xstrdup (argv[i]);
-    }
-  newargz[++newargc] = NULL;
-
-EOF
-	    cat <<EOF
-  /* The GNU banner must be the first non-error debug message */
-  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
-EOF
-	    cat <<"EOF"
-  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
-  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
-
-  tmp_pathspec = find_executable (argv[0]);
-  if (tmp_pathspec == NULL)
-    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
-  lt_debugprintf (__FILE__, __LINE__,
-                  "(main) found exe (before symlink chase) at: %s\n",
-		  tmp_pathspec);
-
-  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
-  lt_debugprintf (__FILE__, __LINE__,
-                  "(main) found exe (after symlink chase) at: %s\n",
-		  actual_cwrapper_path);
-  XFREE (tmp_pathspec);
-
-  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
-  strendzap (actual_cwrapper_path, actual_cwrapper_name);
-
-  /* wrapper name transforms */
-  strendzap (actual_cwrapper_name, ".exe");
-  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
-  XFREE (actual_cwrapper_name);
-  actual_cwrapper_name = tmp_pathspec;
-  tmp_pathspec = 0;
-
-  /* target_name transforms -- use actual target program name; might have lt- prefix */
-  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
-  strendzap (target_name, ".exe");
-  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
-  XFREE (target_name);
-  target_name = tmp_pathspec;
-  tmp_pathspec = 0;
-
-  lt_debugprintf (__FILE__, __LINE__,
-		  "(main) libtool target name: %s\n",
-		  target_name);
-EOF
-
-	    cat <<EOF
-  newargz[0] =
-    XMALLOC (char, (strlen (actual_cwrapper_path) +
-		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
-  strcpy (newargz[0], actual_cwrapper_path);
-  strcat (newargz[0], "$objdir");
-  strcat (newargz[0], "/");
-EOF
-
-	    cat <<"EOF"
-  /* stop here, and copy so we don't have to do this twice */
-  tmp_pathspec = xstrdup (newargz[0]);
-
-  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
-  strcat (newargz[0], actual_cwrapper_name);
-
-  /* DO want the lt- prefix here if it exists, so use target_name */
-  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
-  XFREE (tmp_pathspec);
-  tmp_pathspec = NULL;
-EOF
-
-	    case $host_os in
-	      mingw*)
-	    cat <<"EOF"
-  {
-    char* p;
-    while ((p = strchr (newargz[0], '\\')) != NULL)
-      {
-	*p = '/';
-      }
-    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
-      {
-	*p = '/';
-      }
-  }
-EOF
-	    ;;
-	    esac
-
-	    cat <<"EOF"
-  XFREE (target_name);
-  XFREE (actual_cwrapper_path);
-  XFREE (actual_cwrapper_name);
-
-  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
-  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
-  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
-     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
-     because on Windows, both *_VARNAMEs are PATH but uninstalled
-     libraries must come first. */
-  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
-  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
-
-  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
-		  nonnull (lt_argv_zero));
-  for (i = 0; i < newargc; i++)
-    {
-      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
-		      i, nonnull (newargz[i]));
-    }
-
-EOF
-
-	    case $host_os in
-	      mingw*)
-		cat <<"EOF"
-  /* execv doesn't actually work on mingw as expected on unix */
-  newargz = prepare_spawn (newargz);
-  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
-  if (rval == -1)
-    {
-      /* failed to start process */
-      lt_debugprintf (__FILE__, __LINE__,
-		      "(main) failed to launch target \"%s\": %s\n",
-		      lt_argv_zero, nonnull (strerror (errno)));
-      return 127;
-    }
-  return rval;
-EOF
-		;;
-	      *)
-		cat <<"EOF"
-  execv (lt_argv_zero, newargz);
-  return rval; /* =127, but avoids unused variable warning */
-EOF
-		;;
-	    esac
-
-	    cat <<"EOF"
-}
-
-void *
-xmalloc (size_t num)
-{
-  void *p = (void *) malloc (num);
-  if (!p)
-    lt_fatal (__FILE__, __LINE__, "memory exhausted");
-
-  return p;
-}
-
-char *
-xstrdup (const char *string)
-{
-  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
-			  string) : NULL;
-}
-
-const char *
-base_name (const char *name)
-{
-  const char *base;
-
-#if defined HAVE_DOS_BASED_FILE_SYSTEM
-  /* Skip over the disk name in MSDOS pathnames. */
-  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
-    name += 2;
-#endif
-
-  for (base = name; *name; name++)
-    if (IS_DIR_SEPARATOR (*name))
-      base = name + 1;
-  return base;
-}
-
-int
-check_executable (const char *path)
-{
-  struct stat st;
-
-  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
-                  nonempty (path));
-  if ((!path) || (!*path))
-    return 0;
-
-  if ((stat (path, &st) >= 0)
-      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
-    return 1;
-  else
-    return 0;
-}
-
-int
-make_executable (const char *path)
-{
-  int rval = 0;
-  struct stat st;
-
-  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
-                  nonempty (path));
-  if ((!path) || (!*path))
-    return 0;
-
-  if (stat (path, &st) >= 0)
-    {
-      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
-    }
-  return rval;
-}
-
-/* Searches for the full path of the wrapper.  Returns
-   newly allocated full path name if found, NULL otherwise
-   Does not chase symlinks, even on platforms that support them.
-*/
-char *
-find_executable (const char *wrapper)
-{
-  int has_slash = 0;
-  const char *p;
-  const char *p_next;
-  /* static buffer for getcwd */
-  char tmp[LT_PATHMAX + 1];
-  size_t tmp_len;
-  char *concat_name;
-
-  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
-                  nonempty (wrapper));
-
-  if ((wrapper == NULL) || (*wrapper == '\0'))
-    return NULL;
-
-  /* Absolute path? */
-#if defined HAVE_DOS_BASED_FILE_SYSTEM
-  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
-    {
-      concat_name = xstrdup (wrapper);
-      if (check_executable (concat_name))
-	return concat_name;
-      XFREE (concat_name);
-    }
-  else
-    {
-#endif
-      if (IS_DIR_SEPARATOR (wrapper[0]))
-	{
-	  concat_name = xstrdup (wrapper);
-	  if (check_executable (concat_name))
-	    return concat_name;
-	  XFREE (concat_name);
-	}
-#if defined HAVE_DOS_BASED_FILE_SYSTEM
-    }
-#endif
-
-  for (p = wrapper; *p; p++)
-    if (*p == '/')
-      {
-	has_slash = 1;
-	break;
-      }
-  if (!has_slash)
-    {
-      /* no slashes; search PATH */
-      const char *path = getenv ("PATH");
-      if (path != NULL)
-	{
-	  for (p = path; *p; p = p_next)
-	    {
-	      const char *q;
-	      size_t p_len;
-	      for (q = p; *q; q++)
-		if (IS_PATH_SEPARATOR (*q))
-		  break;
-	      p_len = (size_t) (q - p);
-	      p_next = (*q == '\0' ? q : q + 1);
-	      if (p_len == 0)
-		{
-		  /* empty path: current directory */
-		  if (getcwd (tmp, LT_PATHMAX) == NULL)
-		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
-                              nonnull (strerror (errno)));
-		  tmp_len = strlen (tmp);
-		  concat_name =
-		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
-		  memcpy (concat_name, tmp, tmp_len);
-		  concat_name[tmp_len] = '/';
-		  strcpy (concat_name + tmp_len + 1, wrapper);
-		}
-	      else
-		{
-		  concat_name =
-		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
-		  memcpy (concat_name, p, p_len);
-		  concat_name[p_len] = '/';
-		  strcpy (concat_name + p_len + 1, wrapper);
-		}
-	      if (check_executable (concat_name))
-		return concat_name;
-	      XFREE (concat_name);
-	    }
-	}
-      /* not found in PATH; assume curdir */
-    }
-  /* Relative path | not found in path: prepend cwd */
-  if (getcwd (tmp, LT_PATHMAX) == NULL)
-    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
-              nonnull (strerror (errno)));
-  tmp_len = strlen (tmp);
-  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
-  memcpy (concat_name, tmp, tmp_len);
-  concat_name[tmp_len] = '/';
-  strcpy (concat_name + tmp_len + 1, wrapper);
-
-  if (check_executable (concat_name))
-    return concat_name;
-  XFREE (concat_name);
-  return NULL;
-}
-
-char *
-chase_symlinks (const char *pathspec)
-{
-#ifndef S_ISLNK
-  return xstrdup (pathspec);
-#else
-  char buf[LT_PATHMAX];
-  struct stat s;
-  char *tmp_pathspec = xstrdup (pathspec);
-  char *p;
-  int has_symlinks = 0;
-  while (strlen (tmp_pathspec) && !has_symlinks)
-    {
-      lt_debugprintf (__FILE__, __LINE__,
-		      "checking path component for symlinks: %s\n",
-		      tmp_pathspec);
-      if (lstat (tmp_pathspec, &s) == 0)
-	{
-	  if (S_ISLNK (s.st_mode) != 0)
-	    {
-	      has_symlinks = 1;
-	      break;
-	    }
-
-	  /* search backwards for last DIR_SEPARATOR */
-	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
-	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
-	    p--;
-	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
-	    {
-	      /* no more DIR_SEPARATORS left */
-	      break;
-	    }
-	  *p = '\0';
-	}
-      else
-	{
-	  lt_fatal (__FILE__, __LINE__,
-		    "error accessing file \"%s\": %s",
-		    tmp_pathspec, nonnull (strerror (errno)));
-	}
-    }
-  XFREE (tmp_pathspec);
-
-  if (!has_symlinks)
-    {
-      return xstrdup (pathspec);
-    }
-
-  tmp_pathspec = realpath (pathspec, buf);
-  if (tmp_pathspec == 0)
-    {
-      lt_fatal (__FILE__, __LINE__,
-		"could not follow symlinks for %s", pathspec);
-    }
-  return xstrdup (tmp_pathspec);
-#endif
-}
-
-char *
-strendzap (char *str, const char *pat)
-{
-  size_t len, patlen;
-
-  assert (str != NULL);
-  assert (pat != NULL);
-
-  len = strlen (str);
-  patlen = strlen (pat);
-
-  if (patlen <= len)
-    {
-      str += len - patlen;
-      if (STREQ (str, pat))
-	*str = '\0';
-    }
-  return str;
-}
-
-void
-lt_debugprintf (const char *file, int line, const char *fmt, ...)
-{
-  va_list args;
-  if (lt_debug)
-    {
-      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
-      va_start (args, fmt);
-      (void) vfprintf (stderr, fmt, args);
-      va_end (args);
-    }
-}
-
-static void
-lt_error_core (int exit_status, const char *file,
-	       int line, const char *mode,
-	       const char *message, va_list ap)
-{
-  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
-  vfprintf (stderr, message, ap);
-  fprintf (stderr, ".\n");
-
-  if (exit_status >= 0)
-    exit (exit_status);
-}
-
-void
-lt_fatal (const char *file, int line, const char *message, ...)
-{
-  va_list ap;
-  va_start (ap, message);
-  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
-  va_end (ap);
-}
-
-static const char *
-nonnull (const char *s)
-{
-  return s ? s : "(null)";
-}
-
-static const char *
-nonempty (const char *s)
-{
-  return (s && !*s) ? "(empty)" : nonnull (s);
-}
-
-void
-lt_setenv (const char *name, const char *value)
-{
-  lt_debugprintf (__FILE__, __LINE__,
-		  "(lt_setenv) setting '%s' to '%s'\n",
-                  nonnull (name), nonnull (value));
-  {
-#ifdef HAVE_SETENV
-    /* always make a copy, for consistency with !HAVE_SETENV */
-    char *str = xstrdup (value);
-    setenv (name, str, 1);
-#else
-    size_t len = strlen (name) + 1 + strlen (value) + 1;
-    char *str = XMALLOC (char, len);
-    sprintf (str, "%s=%s", name, value);
-    if (putenv (str) != EXIT_SUCCESS)
-      {
-        XFREE (str);
-      }
-#endif
-  }
-}
-
-char *
-lt_extend_str (const char *orig_value, const char *add, int to_end)
-{
-  char *new_value;
-  if (orig_value && *orig_value)
-    {
-      size_t orig_value_len = strlen (orig_value);
-      size_t add_len = strlen (add);
-      new_value = XMALLOC (char, add_len + orig_value_len + 1);
-      if (to_end)
-        {
-          strcpy (new_value, orig_value);
-          strcpy (new_value + orig_value_len, add);
-        }
-      else
-        {
-          strcpy (new_value, add);
-          strcpy (new_value + add_len, orig_value);
-        }
-    }
-  else
-    {
-      new_value = xstrdup (add);
-    }
-  return new_value;
-}
-
-void
-lt_update_exe_path (const char *name, const char *value)
-{
-  lt_debugprintf (__FILE__, __LINE__,
-		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
-                  nonnull (name), nonnull (value));
-
-  if (name && *name && value && *value)
-    {
-      char *new_value = lt_extend_str (getenv (name), value, 0);
-      /* some systems can't cope with a ':'-terminated path #' */
-      size_t len = strlen (new_value);
-      while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
-        {
-          new_value[--len] = '\0';
-        }
-      lt_setenv (name, new_value);
-      XFREE (new_value);
-    }
-}
-
-void
-lt_update_lib_path (const char *name, const char *value)
-{
-  lt_debugprintf (__FILE__, __LINE__,
-		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
-                  nonnull (name), nonnull (value));
-
-  if (name && *name && value && *value)
-    {
-      char *new_value = lt_extend_str (getenv (name), value, 0);
-      lt_setenv (name, new_value);
-      XFREE (new_value);
-    }
-}
-
-EOF
-	    case $host_os in
-	      mingw*)
-		cat <<"EOF"
-
-/* Prepares an argument vector before calling spawn().
-   Note that spawn() does not by itself call the command interpreter
-     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
-      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-         GetVersionEx(&v);
-         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
-      }) ? "cmd.exe" : "command.com").
-   Instead it simply concatenates the arguments, separated by ' ', and calls
-   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
-   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
-   special way:
-   - Space and tab are interpreted as delimiters. They are not treated as
-     delimiters if they are surrounded by double quotes: "...".
-   - Unescaped double quotes are removed from the input. Their only effect is
-     that within double quotes, space and tab are treated like normal
-     characters.
-   - Backslashes not followed by double quotes are not special.
-   - But 2*n+1 backslashes followed by a double quote become
-     n backslashes followed by a double quote (n >= 0):
-       \" -> "
-       \\\" -> \"
-       \\\\\" -> \\"
- */
-#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
-#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
-char **
-prepare_spawn (char **argv)
-{
-  size_t argc;
-  char **new_argv;
-  size_t i;
-
-  /* Count number of arguments.  */
-  for (argc = 0; argv[argc] != NULL; argc++)
-    ;
-
-  /* Allocate new argument vector.  */
-  new_argv = XMALLOC (char *, argc + 1);
-
-  /* Put quoted arguments into the new argument vector.  */
-  for (i = 0; i < argc; i++)
-    {
-      const char *string = argv[i];
-
-      if (string[0] == '\0')
-	new_argv[i] = xstrdup ("\"\"");
-      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
-	{
-	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
-	  size_t length;
-	  unsigned int backslashes;
-	  const char *s;
-	  char *quoted_string;
-	  char *p;
-
-	  length = 0;
-	  backslashes = 0;
-	  if (quote_around)
-	    length++;
-	  for (s = string; *s != '\0'; s++)
-	    {
-	      char c = *s;
-	      if (c == '"')
-		length += backslashes + 1;
-	      length++;
-	      if (c == '\\')
-		backslashes++;
-	      else
-		backslashes = 0;
-	    }
-	  if (quote_around)
-	    length += backslashes + 1;
-
-	  quoted_string = XMALLOC (char, length + 1);
-
-	  p = quoted_string;
-	  backslashes = 0;
-	  if (quote_around)
-	    *p++ = '"';
-	  for (s = string; *s != '\0'; s++)
-	    {
-	      char c = *s;
-	      if (c == '"')
-		{
-		  unsigned int j;
-		  for (j = backslashes + 1; j > 0; j--)
-		    *p++ = '\\';
-		}
-	      *p++ = c;
-	      if (c == '\\')
-		backslashes++;
-	      else
-		backslashes = 0;
-	    }
-	  if (quote_around)
-	    {
-	      unsigned int j;
-	      for (j = backslashes; j > 0; j--)
-		*p++ = '\\';
-	      *p++ = '"';
-	    }
-	  *p = '\0';
-
-	  new_argv[i] = quoted_string;
-	}
-      else
-	new_argv[i] = (char *) string;
-    }
-  new_argv[argc] = NULL;
-
-  return new_argv;
-}
-EOF
-		;;
-	    esac
-
-            cat <<"EOF"
-void lt_dump_script (FILE* f)
-{
-EOF
-	    func_emit_wrapper yes |
-	      $SED -n -e '
-s/^\(.\{79\}\)\(..*\)/\1\
-\2/
-h
-s/\([\\"]\)/\\\1/g
-s/$/\\n/
-s/\([^\n]*\).*/  fputs ("\1", f);/p
-g
-D'
-            cat <<"EOF"
-}
-EOF
-}
-# end: func_emit_cwrapperexe_src
-
-# func_win32_import_lib_p ARG
-# True if ARG is an import lib, as indicated by $file_magic_cmd
-func_win32_import_lib_p ()
-{
-    $debug_cmd
-
-    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
-    *import*) : ;;
-    *) false ;;
-    esac
-}
-
-# func_suncc_cstd_abi
-# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
-# Several compiler flags select an ABI that is incompatible with the
-# Cstd library. Avoid specifying it if any are in CXXFLAGS.
-func_suncc_cstd_abi ()
-{
-    $debug_cmd
-
-    case " $compile_command " in
-    *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
-      suncc_use_cstd_abi=no
-      ;;
-    *)
-      suncc_use_cstd_abi=yes
-      ;;
-    esac
-}
-
-# func_mode_link arg...
-func_mode_link ()
-{
-    $debug_cmd
-
-    case $host in
-    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
-      # It is impossible to link a dll without this setting, and
-      # we shouldn't force the makefile maintainer to figure out
-      # what system we are compiling for in order to pass an extra
-      # flag for every libtool invocation.
-      # allow_undefined=no
-
-      # FIXME: Unfortunately, there are problems with the above when trying
-      # to make a dll that has undefined symbols, in which case not
-      # even a static library is built.  For now, we need to specify
-      # -no-undefined on the libtool link line when we can be certain
-      # that all symbols are satisfied, otherwise we get a static library.
-      allow_undefined=yes
-      ;;
-    *)
-      allow_undefined=yes
-      ;;
-    esac
-    libtool_args=$nonopt
-    base_compile="$nonopt $@"
-    compile_command=$nonopt
-    finalize_command=$nonopt
-
-    compile_rpath=
-    finalize_rpath=
-    compile_shlibpath=
-    finalize_shlibpath=
-    convenience=
-    old_convenience=
-    deplibs=
-    old_deplibs=
-    compiler_flags=
-    linker_flags=
-    dllsearchpath=
-    lib_search_path=`pwd`
-    inst_prefix_dir=
-    new_inherited_linker_flags=
-
-    avoid_version=no
-    bindir=
-    dlfiles=
-    dlprefiles=
-    dlself=no
-    export_dynamic=no
-    export_symbols=
-    export_symbols_regex=
-    generated=
-    libobjs=
-    ltlibs=
-    module=no
-    no_install=no
-    objs=
-    os2dllname=
-    non_pic_objects=
-    precious_files_regex=
-    prefer_static_libs=no
-    preload=false
-    prev=
-    prevarg=
-    release=
-    rpath=
-    xrpath=
-    perm_rpath=
-    temp_rpath=
-    thread_safe=no
-    vinfo=
-    vinfo_number=no
-    weak_libs=
-    single_module=$wl-single_module
-    func_infer_tag $base_compile
-
-    # We need to know -static, to get the right output filenames.
-    for arg
-    do
-      case $arg in
-      -shared)
-	test yes != "$build_libtool_libs" \
-	  && func_fatal_configuration "cannot build a shared library"
-	build_old_libs=no
-	break
-	;;
-      -all-static | -static | -static-libtool-libs)
-	case $arg in
-	-all-static)
-	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
-	    func_warning "complete static linking is impossible in this configuration"
-	  fi
-	  if test -n "$link_static_flag"; then
-	    dlopen_self=$dlopen_self_static
-	  fi
-	  prefer_static_libs=yes
-	  ;;
-	-static)
-	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
-	    dlopen_self=$dlopen_self_static
-	  fi
-	  prefer_static_libs=built
-	  ;;
-	-static-libtool-libs)
-	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
-	    dlopen_self=$dlopen_self_static
-	  fi
-	  prefer_static_libs=yes
-	  ;;
-	esac
-	build_libtool_libs=no
-	build_old_libs=yes
-	break
-	;;
-      esac
-    done
-
-    # See if our shared archives depend on static archives.
-    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
-
-    # Go through the arguments, transforming them on the way.
-    while test "$#" -gt 0; do
-      arg=$1
-      shift
-      func_quote_for_eval "$arg"
-      qarg=$func_quote_for_eval_unquoted_result
-      func_append libtool_args " $func_quote_for_eval_result"
-
-      # If the previous option needs an argument, assign it.
-      if test -n "$prev"; then
-	case $prev in
-	output)
-	  func_append compile_command " @OUTPUT@"
-	  func_append finalize_command " @OUTPUT@"
-	  ;;
-	esac
-
-	case $prev in
-	bindir)
-	  bindir=$arg
-	  prev=
-	  continue
-	  ;;
-	dlfiles|dlprefiles)
-	  $preload || {
-	    # Add the symbol object into the linking commands.
-	    func_append compile_command " @SYMFILE@"
-	    func_append finalize_command " @SYMFILE@"
-	    preload=:
-	  }
-	  case $arg in
-	  *.la | *.lo) ;;  # We handle these cases below.
-	  force)
-	    if test no = "$dlself"; then
-	      dlself=needless
-	      export_dynamic=yes
-	    fi
-	    prev=
-	    continue
-	    ;;
-	  self)
-	    if test dlprefiles = "$prev"; then
-	      dlself=yes
-	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
-	      dlself=yes
-	    else
-	      dlself=needless
-	      export_dynamic=yes
-	    fi
-	    prev=
-	    continue
-	    ;;
-	  *)
-	    if test dlfiles = "$prev"; then
-	      func_append dlfiles " $arg"
-	    else
-	      func_append dlprefiles " $arg"
-	    fi
-	    prev=
-	    continue
-	    ;;
-	  esac
-	  ;;
-	expsyms)
-	  export_symbols=$arg
-	  test -f "$arg" \
-	    || func_fatal_error "symbol file '$arg' does not exist"
-	  prev=
-	  continue
-	  ;;
-	expsyms_regex)
-	  export_symbols_regex=$arg
-	  prev=
-	  continue
-	  ;;
-	framework)
-	  case $host in
-	    *-*-darwin*)
-	      case "$deplibs " in
-		*" $qarg.ltframework "*) ;;
-		*) func_append deplibs " $qarg.ltframework" # this is fixed later
-		   ;;
-	      esac
-	      ;;
-	  esac
-	  prev=
-	  continue
-	  ;;
-	inst_prefix)
-	  inst_prefix_dir=$arg
-	  prev=
-	  continue
-	  ;;
-	mllvm)
-	  # Clang does not use LLVM to link, so we can simply discard any
-	  # '-mllvm $arg' options when doing the link step.
-	  prev=
-	  continue
-	  ;;
-	objectlist)
-	  if test -f "$arg"; then
-	    save_arg=$arg
-	    moreargs=
-	    for fil in `cat "$save_arg"`
-	    do
-#	      func_append moreargs " $fil"
-	      arg=$fil
-	      # A libtool-controlled object.
-
-	      # Check to see that this really is a libtool object.
-	      if func_lalib_unsafe_p "$arg"; then
-		pic_object=
-		non_pic_object=
-
-		# Read the .lo file
-		func_source "$arg"
-
-		if test -z "$pic_object" ||
-		   test -z "$non_pic_object" ||
-		   test none = "$pic_object" &&
-		   test none = "$non_pic_object"; then
-		  func_fatal_error "cannot find name of object for '$arg'"
-		fi
-
-		# Extract subdirectory from the argument.
-		func_dirname "$arg" "/" ""
-		xdir=$func_dirname_result
-
-		if test none != "$pic_object"; then
-		  # Prepend the subdirectory the object is found in.
-		  pic_object=$xdir$pic_object
-
-		  if test dlfiles = "$prev"; then
-		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
-		      func_append dlfiles " $pic_object"
-		      prev=
-		      continue
-		    else
-		      # If libtool objects are unsupported, then we need to preload.
-		      prev=dlprefiles
-		    fi
-		  fi
-
-		  # CHECK ME:  I think I busted this.  -Ossama
-		  if test dlprefiles = "$prev"; then
-		    # Preload the old-style object.
-		    func_append dlprefiles " $pic_object"
-		    prev=
-		  fi
-
-		  # A PIC object.
-		  func_append libobjs " $pic_object"
-		  arg=$pic_object
-		fi
-
-		# Non-PIC object.
-		if test none != "$non_pic_object"; then
-		  # Prepend the subdirectory the object is found in.
-		  non_pic_object=$xdir$non_pic_object
-
-		  # A standard non-PIC object
-		  func_append non_pic_objects " $non_pic_object"
-		  if test -z "$pic_object" || test none = "$pic_object"; then
-		    arg=$non_pic_object
-		  fi
-		else
-		  # If the PIC object exists, use it instead.
-		  # $xdir was prepended to $pic_object above.
-		  non_pic_object=$pic_object
-		  func_append non_pic_objects " $non_pic_object"
-		fi
-	      else
-		# Only an error if not doing a dry-run.
-		if $opt_dry_run; then
-		  # Extract subdirectory from the argument.
-		  func_dirname "$arg" "/" ""
-		  xdir=$func_dirname_result
-
-		  func_lo2o "$arg"
-		  pic_object=$xdir$objdir/$func_lo2o_result
-		  non_pic_object=$xdir$func_lo2o_result
-		  func_append libobjs " $pic_object"
-		  func_append non_pic_objects " $non_pic_object"
-	        else
-		  func_fatal_error "'$arg' is not a valid libtool object"
-		fi
-	      fi
-	    done
-	  else
-	    func_fatal_error "link input file '$arg' does not exist"
-	  fi
-	  arg=$save_arg
-	  prev=
-	  continue
-	  ;;
-	os2dllname)
-	  os2dllname=$arg
-	  prev=
-	  continue
-	  ;;
-	precious_regex)
-	  precious_files_regex=$arg
-	  prev=
-	  continue
-	  ;;
-	release)
-	  release=-$arg
-	  prev=
-	  continue
-	  ;;
-	rpath | xrpath)
-	  # We need an absolute path.
-	  case $arg in
-	  [\\/]* | [A-Za-z]:[\\/]*) ;;
-	  *)
-	    func_fatal_error "only absolute run-paths are allowed"
-	    ;;
-	  esac
-	  if test rpath = "$prev"; then
-	    case "$rpath " in
-	    *" $arg "*) ;;
-	    *) func_append rpath " $arg" ;;
-	    esac
-	  else
-	    case "$xrpath " in
-	    *" $arg "*) ;;
-	    *) func_append xrpath " $arg" ;;
-	    esac
-	  fi
-	  prev=
-	  continue
-	  ;;
-	shrext)
-	  shrext_cmds=$arg
-	  prev=
-	  continue
-	  ;;
-	weak)
-	  func_append weak_libs " $arg"
-	  prev=
-	  continue
-	  ;;
-	xcclinker)
-	  func_append linker_flags " $qarg"
-	  func_append compiler_flags " $qarg"
-	  prev=
-	  func_append compile_command " $qarg"
-	  func_append finalize_command " $qarg"
-	  continue
-	  ;;
-	xcompiler)
-	  func_append compiler_flags " $qarg"
-	  prev=
-	  func_append compile_command " $qarg"
-	  func_append finalize_command " $qarg"
-	  continue
-	  ;;
-	xlinker)
-	  func_append linker_flags " $qarg"
-	  func_append compiler_flags " $wl$qarg"
-	  prev=
-	  func_append compile_command " $wl$qarg"
-	  func_append finalize_command " $wl$qarg"
-	  continue
-	  ;;
-	*)
-	  eval "$prev=\"\$arg\""
-	  prev=
-	  continue
-	  ;;
-	esac
-      fi # test -n "$prev"
-
-      prevarg=$arg
-
-      case $arg in
-      -all-static)
-	if test -n "$link_static_flag"; then
-	  # See comment for -static flag below, for more details.
-	  func_append compile_command " $link_static_flag"
-	  func_append finalize_command " $link_static_flag"
-	fi
-	continue
-	;;
-
-      -allow-undefined)
-	# FIXME: remove this flag sometime in the future.
-	func_fatal_error "'-allow-undefined' must not be used because it is the default"
-	;;
-
-      -avoid-version)
-	avoid_version=yes
-	continue
-	;;
-
-      -bindir)
-	prev=bindir
-	continue
-	;;
-
-      -dlopen)
-	prev=dlfiles
-	continue
-	;;
-
-      -dlpreopen)
-	prev=dlprefiles
-	continue
-	;;
-
-      -export-dynamic)
-	export_dynamic=yes
-	continue
-	;;
-
-      -export-symbols | -export-symbols-regex)
-	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
-	  func_fatal_error "more than one -exported-symbols argument is not allowed"
-	fi
-	if test X-export-symbols = "X$arg"; then
-	  prev=expsyms
-	else
-	  prev=expsyms_regex
-	fi
-	continue
-	;;
-
-      -framework)
-	prev=framework
-	continue
-	;;
-
-      -inst-prefix-dir)
-	prev=inst_prefix
-	continue
-	;;
-
-      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
-      # so, if we see these flags be careful not to treat them like -L
-      -L[A-Z][A-Z]*:*)
-	case $with_gcc/$host in
-	no/*-*-irix* | /*-*-irix*)
-	  func_append compile_command " $arg"
-	  func_append finalize_command " $arg"
-	  ;;
-	esac
-	continue
-	;;
-
-      -L*)
-	func_stripname "-L" '' "$arg"
-	if test -z "$func_stripname_result"; then
-	  if test "$#" -gt 0; then
-	    func_fatal_error "require no space between '-L' and '$1'"
-	  else
-	    func_fatal_error "need path for '-L' option"
-	  fi
-	fi
-	func_resolve_sysroot "$func_stripname_result"
-	dir=$func_resolve_sysroot_result
-	# We need an absolute path.
-	case $dir in
-	[\\/]* | [A-Za-z]:[\\/]*) ;;
-	*)
-	  absdir=`cd "$dir" && pwd`
-	  test -z "$absdir" && \
-	    func_fatal_error "cannot determine absolute directory name of '$dir'"
-	  dir=$absdir
-	  ;;
-	esac
-	case "$deplibs " in
-	*" -L$dir "* | *" $arg "*)
-	  # Will only happen for absolute or sysroot arguments
-	  ;;
-	*)
-	  # Preserve sysroot, but never include relative directories
-	  case $dir in
-	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
-	    *) func_append deplibs " -L$dir" ;;
-	  esac
-	  func_append lib_search_path " $dir"
-	  ;;
-	esac
-	case $host in
-	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
-	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
-	  case :$dllsearchpath: in
-	  *":$dir:"*) ;;
-	  ::) dllsearchpath=$dir;;
-	  *) func_append dllsearchpath ":$dir";;
-	  esac
-	  case :$dllsearchpath: in
-	  *":$testbindir:"*) ;;
-	  ::) dllsearchpath=$testbindir;;
-	  *) func_append dllsearchpath ":$testbindir";;
-	  esac
-	  ;;
-	esac
-	continue
-	;;
-
-      -l*)
-	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
-	  case $host in
-	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
-	    # These systems don't actually have a C or math library (as such)
-	    continue
-	    ;;
-	  *-*-os2*)
-	    # These systems don't actually have a C library (as such)
-	    test X-lc = "X$arg" && continue
-	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
-	    # Do not include libc due to us having libc/libc_r.
-	    test X-lc = "X$arg" && continue
-	    ;;
-	  *-*-rhapsody* | *-*-darwin1.[012])
-	    # Rhapsody C and math libraries are in the System framework
-	    func_append deplibs " System.ltframework"
-	    continue
-	    ;;
-	  *-*-sco3.2v5* | *-*-sco5v6*)
-	    # Causes problems with __ctype
-	    test X-lc = "X$arg" && continue
-	    ;;
-	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
-	    # Compiler inserts libc in the correct place for threads to work
-	    test X-lc = "X$arg" && continue
-	    ;;
-	  esac
-	elif test X-lc_r = "X$arg"; then
-	 case $host in
-	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
-	   # Do not include libc_r directly, use -pthread flag.
-	   continue
-	   ;;
-	 esac
-	fi
-	func_append deplibs " $arg"
-	continue
-	;;
-
-      -mllvm)
-	prev=mllvm
-	continue
-	;;
-
-      -module)
-	module=yes
-	continue
-	;;
-
-      # Tru64 UNIX uses -model [arg] to determine the layout of C++
-      # classes, name mangling, and exception handling.
-      # Darwin uses the -arch flag to determine output architecture.
-      -model|-arch|-isysroot|--sysroot)
-	func_append compiler_flags " $arg"
-	func_append compile_command " $arg"
-	func_append finalize_command " $arg"
-	prev=xcompiler
-	continue
-	;;
-
-      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
-      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
-	func_append compiler_flags " $arg"
-	func_append compile_command " $arg"
-	func_append finalize_command " $arg"
-	case "$new_inherited_linker_flags " in
-	    *" $arg "*) ;;
-	    * ) func_append new_inherited_linker_flags " $arg" ;;
-	esac
-	continue
-	;;
-
-      -multi_module)
-	single_module=$wl-multi_module
-	continue
-	;;
-
-      -no-fast-install)
-	fast_install=no
-	continue
-	;;
-
-      -no-install)
-	case $host in
-	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
-	  # The PATH hackery in wrapper scripts is required on Windows
-	  # and Darwin in order for the loader to find any dlls it needs.
-	  func_warning "'-no-install' is ignored for $host"
-	  func_warning "assuming '-no-fast-install' instead"
-	  fast_install=no
-	  ;;
-	*) no_install=yes ;;
-	esac
-	continue
-	;;
-
-      -no-undefined)
-	allow_undefined=no
-	continue
-	;;
-
-      -objectlist)
-	prev=objectlist
-	continue
-	;;
-
-      -os2dllname)
-	prev=os2dllname
-	continue
-	;;
-
-      -o) prev=output ;;
-
-      -precious-files-regex)
-	prev=precious_regex
-	continue
-	;;
-
-      -release)
-	prev=release
-	continue
-	;;
-
-      -rpath)
-	prev=rpath
-	continue
-	;;
-
-      -R)
-	prev=xrpath
-	continue
-	;;
-
-      -R*)
-	func_stripname '-R' '' "$arg"
-	dir=$func_stripname_result
-	# We need an absolute path.
-	case $dir in
-	[\\/]* | [A-Za-z]:[\\/]*) ;;
-	=*)
-	  func_stripname '=' '' "$dir"
-	  dir=$lt_sysroot$func_stripname_result
-	  ;;
-	*)
-	  func_fatal_error "only absolute run-paths are allowed"
-	  ;;
-	esac
-	case "$xrpath " in
-	*" $dir "*) ;;
-	*) func_append xrpath " $dir" ;;
-	esac
-	continue
-	;;
-
-      -shared)
-	# The effects of -shared are defined in a previous loop.
-	continue
-	;;
-
-      -shrext)
-	prev=shrext
-	continue
-	;;
-
-      -static | -static-libtool-libs)
-	# The effects of -static are defined in a previous loop.
-	# We used to do the same as -all-static on platforms that
-	# didn't have a PIC flag, but the assumption that the effects
-	# would be equivalent was wrong.  It would break on at least
-	# Digital Unix and AIX.
-	continue
-	;;
-
-      -thread-safe)
-	thread_safe=yes
-	continue
-	;;
-
-      -version-info)
-	prev=vinfo
-	continue
-	;;
-
-      -version-number)
-	prev=vinfo
-	vinfo_number=yes
-	continue
-	;;
-
-      -weak)
-        prev=weak
-	continue
-	;;
-
-      -Wc,*)
-	func_stripname '-Wc,' '' "$arg"
-	args=$func_stripname_result
-	arg=
-	save_ifs=$IFS; IFS=,
-	for flag in $args; do
-	  IFS=$save_ifs
-          func_quote_for_eval "$flag"
-	  func_append arg " $func_quote_for_eval_result"
-	  func_append compiler_flags " $func_quote_for_eval_result"
-	done
-	IFS=$save_ifs
-	func_stripname ' ' '' "$arg"
-	arg=$func_stripname_result
-	;;
-
-      -Wl,*)
-	func_stripname '-Wl,' '' "$arg"
-	args=$func_stripname_result
-	arg=
-	save_ifs=$IFS; IFS=,
-	for flag in $args; do
-	  IFS=$save_ifs
-          func_quote_for_eval "$flag"
-	  func_append arg " $wl$func_quote_for_eval_result"
-	  func_append compiler_flags " $wl$func_quote_for_eval_result"
-	  func_append linker_flags " $func_quote_for_eval_result"
-	done
-	IFS=$save_ifs
-	func_stripname ' ' '' "$arg"
-	arg=$func_stripname_result
-	;;
-
-      -Xcompiler)
-	prev=xcompiler
-	continue
-	;;
-
-      -Xlinker)
-	prev=xlinker
-	continue
-	;;
-
-      -XCClinker)
-	prev=xcclinker
-	continue
-	;;
-
-      # -msg_* for osf cc
-      -msg_*)
-	func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
-	;;
-
-      # Flags to be passed through unchanged, with rationale:
-      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
-      # -r[0-9][0-9]*        specify processor for the SGI compiler
-      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
-      # +DA*, +DD*           enable 64-bit mode for the HP compiler
-      # -q*                  compiler args for the IBM compiler
-      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
-      # -F/path              path to uninstalled frameworks, gcc on darwin
-      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
-      # -fstack-protector*   stack protector flags for GCC
-      # @file                GCC response files
-      # -tp=*                Portland pgcc target processor selection
-      # --sysroot=*          for sysroot support
-      # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
-      # -specs=*             GCC specs files
-      # -stdlib=*            select c++ std lib with clang
-      # -fsanitize=*         Clang/GCC memory and address sanitizer
-      # -fuse-ld=*           Linker select flags for GCC
-      # -static-*            direct GCC to link specific libraries statically
-      # -fcilkplus           Cilk Plus language extension features for C/C++
-      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
-      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
-      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
-      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
-        func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
-        func_append compile_command " $arg"
-        func_append finalize_command " $arg"
-        func_append compiler_flags " $arg"
-        continue
-        ;;
-
-      -Z*)
-        if test os2 = "`expr $host : '.*\(os2\)'`"; then
-          # OS/2 uses -Zxxx to specify OS/2-specific options
-	  compiler_flags="$compiler_flags $arg"
-	  func_append compile_command " $arg"
-	  func_append finalize_command " $arg"
-	  case $arg in
-	  -Zlinker | -Zstack)
-	    prev=xcompiler
-	    ;;
-	  esac
-	  continue
-        else
-	  # Otherwise treat like 'Some other compiler flag' below
-	  func_quote_for_eval "$arg"
-	  arg=$func_quote_for_eval_result
-        fi
-	;;
-
-      # Some other compiler flag.
-      -* | +*)
-        func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
-	;;
-
-      *.$objext)
-	# A standard object.
-	func_append objs " $arg"
-	;;
-
-      *.lo)
-	# A libtool-controlled object.
-
-	# Check to see that this really is a libtool object.
-	if func_lalib_unsafe_p "$arg"; then
-	  pic_object=
-	  non_pic_object=
-
-	  # Read the .lo file
-	  func_source "$arg"
-
-	  if test -z "$pic_object" ||
-	     test -z "$non_pic_object" ||
-	     test none = "$pic_object" &&
-	     test none = "$non_pic_object"; then
-	    func_fatal_error "cannot find name of object for '$arg'"
-	  fi
-
-	  # Extract subdirectory from the argument.
-	  func_dirname "$arg" "/" ""
-	  xdir=$func_dirname_result
-
-	  test none = "$pic_object" || {
-	    # Prepend the subdirectory the object is found in.
-	    pic_object=$xdir$pic_object
-
-	    if test dlfiles = "$prev"; then
-	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
-		func_append dlfiles " $pic_object"
-		prev=
-		continue
-	      else
-		# If libtool objects are unsupported, then we need to preload.
-		prev=dlprefiles
-	      fi
-	    fi
-
-	    # CHECK ME:  I think I busted this.  -Ossama
-	    if test dlprefiles = "$prev"; then
-	      # Preload the old-style object.
-	      func_append dlprefiles " $pic_object"
-	      prev=
-	    fi
-
-	    # A PIC object.
-	    func_append libobjs " $pic_object"
-	    arg=$pic_object
-	  }
-
-	  # Non-PIC object.
-	  if test none != "$non_pic_object"; then
-	    # Prepend the subdirectory the object is found in.
-	    non_pic_object=$xdir$non_pic_object
-
-	    # A standard non-PIC object
-	    func_append non_pic_objects " $non_pic_object"
-	    if test -z "$pic_object" || test none = "$pic_object"; then
-	      arg=$non_pic_object
-	    fi
-	  else
-	    # If the PIC object exists, use it instead.
-	    # $xdir was prepended to $pic_object above.
-	    non_pic_object=$pic_object
-	    func_append non_pic_objects " $non_pic_object"
-	  fi
-	else
-	  # Only an error if not doing a dry-run.
-	  if $opt_dry_run; then
-	    # Extract subdirectory from the argument.
-	    func_dirname "$arg" "/" ""
-	    xdir=$func_dirname_result
-
-	    func_lo2o "$arg"
-	    pic_object=$xdir$objdir/$func_lo2o_result
-	    non_pic_object=$xdir$func_lo2o_result
-	    func_append libobjs " $pic_object"
-	    func_append non_pic_objects " $non_pic_object"
-	  else
-	    func_fatal_error "'$arg' is not a valid libtool object"
-	  fi
-	fi
-	;;
-
-      *.$libext)
-	# An archive.
-	func_append deplibs " $arg"
-	func_append old_deplibs " $arg"
-	continue
-	;;
-
-      *.la)
-	# A libtool-controlled library.
-
-	func_resolve_sysroot "$arg"
-	if test dlfiles = "$prev"; then
-	  # This library was specified with -dlopen.
-	  func_append dlfiles " $func_resolve_sysroot_result"
-	  prev=
-	elif test dlprefiles = "$prev"; then
-	  # The library was specified with -dlpreopen.
-	  func_append dlprefiles " $func_resolve_sysroot_result"
-	  prev=
-	else
-	  func_append deplibs " $func_resolve_sysroot_result"
-	fi
-	continue
-	;;
-
-      # Some other compiler argument.
-      *)
-	# Unknown arguments in both finalize_command and compile_command need
-	# to be aesthetically quoted because they are evaled later.
-	func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
-	;;
-      esac # arg
-
-      # Now actually substitute the argument into the commands.
-      if test -n "$arg"; then
-	func_append compile_command " $arg"
-	func_append finalize_command " $arg"
-      fi
-    done # argument parsing loop
-
-    test -n "$prev" && \
-      func_fatal_help "the '$prevarg' option requires an argument"
-
-    if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
-      eval arg=\"$export_dynamic_flag_spec\"
-      func_append compile_command " $arg"
-      func_append finalize_command " $arg"
-    fi
-
-    oldlibs=
-    # calculate the name of the file, without its directory
-    func_basename "$output"
-    outputname=$func_basename_result
-    libobjs_save=$libobjs
-
-    if test -n "$shlibpath_var"; then
-      # get the directories listed in $shlibpath_var
-      eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
-    else
-      shlib_search_path=
-    fi
-    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
-    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
-
-    # Definition is injected by LT_CONFIG during libtool generation.
-    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
-
-    func_dirname "$output" "/" ""
-    output_objdir=$func_dirname_result$objdir
-    func_to_tool_file "$output_objdir/"
-    tool_output_objdir=$func_to_tool_file_result
-    # Create the object directory.
-    func_mkdir_p "$output_objdir"
-
-    # Determine the type of output
-    case $output in
-    "")
-      func_fatal_help "you must specify an output file"
-      ;;
-    *.$libext) linkmode=oldlib ;;
-    *.lo | *.$objext) linkmode=obj ;;
-    *.la) linkmode=lib ;;
-    *) linkmode=prog ;; # Anything else should be a program.
-    esac
-
-    specialdeplibs=
-
-    libs=
-    # Find all interdependent deplibs by searching for libraries
-    # that are linked more than once (e.g. -la -lb -la)
-    for deplib in $deplibs; do
-      if $opt_preserve_dup_deps; then
-	case "$libs " in
-	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
-	esac
-      fi
-      func_append libs " $deplib"
-    done
-
-    if test lib = "$linkmode"; then
-      libs="$predeps $libs $compiler_lib_search_path $postdeps"
-
-      # Compute libraries that are listed more than once in $predeps
-      # $postdeps and mark them as special (i.e., whose duplicates are
-      # not to be eliminated).
-      pre_post_deps=
-      if $opt_duplicate_compiler_generated_deps; then
-	for pre_post_dep in $predeps $postdeps; do
-	  case "$pre_post_deps " in
-	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
-	  esac
-	  func_append pre_post_deps " $pre_post_dep"
-	done
-      fi
-      pre_post_deps=
-    fi
-
-    deplibs=
-    newdependency_libs=
-    newlib_search_path=
-    need_relink=no # whether we're linking any uninstalled libtool libraries
-    notinst_deplibs= # not-installed libtool libraries
-    notinst_path= # paths that contain not-installed libtool libraries
-
-    case $linkmode in
-    lib)
-	passes="conv dlpreopen link"
-	for file in $dlfiles $dlprefiles; do
-	  case $file in
-	  *.la) ;;
-	  *)
-	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
-	    ;;
-	  esac
-	done
-	;;
-    prog)
-	compile_deplibs=
-	finalize_deplibs=
-	alldeplibs=false
-	newdlfiles=
-	newdlprefiles=
-	passes="conv scan dlopen dlpreopen link"
-	;;
-    *)  passes="conv"
-	;;
-    esac
-
-    for pass in $passes; do
-      # The preopen pass in lib mode reverses $deplibs; put it back here
-      # so that -L comes before libs that need it for instance...
-      if test lib,link = "$linkmode,$pass"; then
-	## FIXME: Find the place where the list is rebuilt in the wrong
-	##        order, and fix it there properly
-        tmp_deplibs=
-	for deplib in $deplibs; do
-	  tmp_deplibs="$deplib $tmp_deplibs"
-	done
-	deplibs=$tmp_deplibs
-      fi
-
-      if test lib,link = "$linkmode,$pass" ||
-	 test prog,scan = "$linkmode,$pass"; then
-	libs=$deplibs
-	deplibs=
-      fi
-      if test prog = "$linkmode"; then
-	case $pass in
-	dlopen) libs=$dlfiles ;;
-	dlpreopen) libs=$dlprefiles ;;
-	link)
-	  libs="$deplibs %DEPLIBS%"
-	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
-	  ;;
-	esac
-      fi
-      if test lib,dlpreopen = "$linkmode,$pass"; then
-	# Collect and forward deplibs of preopened libtool libs
-	for lib in $dlprefiles; do
-	  # Ignore non-libtool-libs
-	  dependency_libs=
-	  func_resolve_sysroot "$lib"
-	  case $lib in
-	  *.la)	func_source "$func_resolve_sysroot_result" ;;
-	  esac
-
-	  # Collect preopened libtool deplibs, except any this library
-	  # has declared as weak libs
-	  for deplib in $dependency_libs; do
-	    func_basename "$deplib"
-            deplib_base=$func_basename_result
-	    case " $weak_libs " in
-	    *" $deplib_base "*) ;;
-	    *) func_append deplibs " $deplib" ;;
-	    esac
-	  done
-	done
-	libs=$dlprefiles
-      fi
-      if test dlopen = "$pass"; then
-	# Collect dlpreopened libraries
-	save_deplibs=$deplibs
-	deplibs=
-      fi
-
-      for deplib in $libs; do
-	lib=
-	found=false
-	case $deplib in
-	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
-        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
-	  if test prog,link = "$linkmode,$pass"; then
-	    compile_deplibs="$deplib $compile_deplibs"
-	    finalize_deplibs="$deplib $finalize_deplibs"
-	  else
-	    func_append compiler_flags " $deplib"
-	    if test lib = "$linkmode"; then
-		case "$new_inherited_linker_flags " in
-		    *" $deplib "*) ;;
-		    * ) func_append new_inherited_linker_flags " $deplib" ;;
-		esac
-	    fi
-	  fi
-	  continue
-	  ;;
-	-l*)
-	  if test lib != "$linkmode" && test prog != "$linkmode"; then
-	    func_warning "'-l' is ignored for archives/objects"
-	    continue
-	  fi
-	  func_stripname '-l' '' "$deplib"
-	  name=$func_stripname_result
-	  if test lib = "$linkmode"; then
-	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
-	  else
-	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
-	  fi
-	  for searchdir in $searchdirs; do
-	    for search_ext in .la $std_shrext .so .a; do
-	      # Search the libtool library
-	      lib=$searchdir/lib$name$search_ext
-	      if test -f "$lib"; then
-		if test .la = "$search_ext"; then
-		  found=:
-		else
-		  found=false
-		fi
-		break 2
-	      fi
-	    done
-	  done
-	  if $found; then
-	    # deplib is a libtool library
-	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
-	    # We need to do some special things here, and not later.
-	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-	      case " $predeps $postdeps " in
-	      *" $deplib "*)
-		if func_lalib_p "$lib"; then
-		  library_names=
-		  old_library=
-		  func_source "$lib"
-		  for l in $old_library $library_names; do
-		    ll=$l
-		  done
-		  if test "X$ll" = "X$old_library"; then # only static version available
-		    found=false
-		    func_dirname "$lib" "" "."
-		    ladir=$func_dirname_result
-		    lib=$ladir/$old_library
-		    if test prog,link = "$linkmode,$pass"; then
-		      compile_deplibs="$deplib $compile_deplibs"
-		      finalize_deplibs="$deplib $finalize_deplibs"
-		    else
-		      deplibs="$deplib $deplibs"
-		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
-		    fi
-		    continue
-		  fi
-		fi
-		;;
-	      *) ;;
-	      esac
-	    fi
-	  else
-	    # deplib doesn't seem to be a libtool library
-	    if test prog,link = "$linkmode,$pass"; then
-	      compile_deplibs="$deplib $compile_deplibs"
-	      finalize_deplibs="$deplib $finalize_deplibs"
-	    else
-	      deplibs="$deplib $deplibs"
-	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
-	    fi
-	    continue
-	  fi
-	  ;; # -l
-	*.ltframework)
-	  if test prog,link = "$linkmode,$pass"; then
-	    compile_deplibs="$deplib $compile_deplibs"
-	    finalize_deplibs="$deplib $finalize_deplibs"
-	  else
-	    deplibs="$deplib $deplibs"
-	    if test lib = "$linkmode"; then
-		case "$new_inherited_linker_flags " in
-		    *" $deplib "*) ;;
-		    * ) func_append new_inherited_linker_flags " $deplib" ;;
-		esac
-	    fi
-	  fi
-	  continue
-	  ;;
-	-L*)
-	  case $linkmode in
-	  lib)
-	    deplibs="$deplib $deplibs"
-	    test conv = "$pass" && continue
-	    newdependency_libs="$deplib $newdependency_libs"
-	    func_stripname '-L' '' "$deplib"
-	    func_resolve_sysroot "$func_stripname_result"
-	    func_append newlib_search_path " $func_resolve_sysroot_result"
-	    ;;
-	  prog)
-	    if test conv = "$pass"; then
-	      deplibs="$deplib $deplibs"
-	      continue
-	    fi
-	    if test scan = "$pass"; then
-	      deplibs="$deplib $deplibs"
-	    else
-	      compile_deplibs="$deplib $compile_deplibs"
-	      finalize_deplibs="$deplib $finalize_deplibs"
-	    fi
-	    func_stripname '-L' '' "$deplib"
-	    func_resolve_sysroot "$func_stripname_result"
-	    func_append newlib_search_path " $func_resolve_sysroot_result"
-	    ;;
-	  *)
-	    func_warning "'-L' is ignored for archives/objects"
-	    ;;
-	  esac # linkmode
-	  continue
-	  ;; # -L
-	-R*)
-	  if test link = "$pass"; then
-	    func_stripname '-R' '' "$deplib"
-	    func_resolve_sysroot "$func_stripname_result"
-	    dir=$func_resolve_sysroot_result
-	    # Make sure the xrpath contains only unique directories.
-	    case "$xrpath " in
-	    *" $dir "*) ;;
-	    *) func_append xrpath " $dir" ;;
-	    esac
-	  fi
-	  deplibs="$deplib $deplibs"
-	  continue
-	  ;;
-	*.la)
-	  func_resolve_sysroot "$deplib"
-	  lib=$func_resolve_sysroot_result
-	  ;;
-	*.$libext)
-	  if test conv = "$pass"; then
-	    deplibs="$deplib $deplibs"
-	    continue
-	  fi
-	  case $linkmode in
-	  lib)
-	    # Linking convenience modules into shared libraries is allowed,
-	    # but linking other static libraries is non-portable.
-	    case " $dlpreconveniencelibs " in
-	    *" $deplib "*) ;;
-	    *)
-	      valid_a_lib=false
-	      case $deplibs_check_method in
-		match_pattern*)
-		  set dummy $deplibs_check_method; shift
-		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
-		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
-		    | $EGREP "$match_pattern_regex" > /dev/null; then
-		    valid_a_lib=:
-		  fi
-		;;
-		pass_all)
-		  valid_a_lib=:
-		;;
-	      esac
-	      if $valid_a_lib; then
-		echo
-		$ECHO "*** Warning: Linking the shared library $output against the"
-		$ECHO "*** static library $deplib is not portable!"
-		deplibs="$deplib $deplibs"
-	      else
-		echo
-		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
-		echo "*** I have the capability to make that library automatically link in when"
-		echo "*** you link to this library.  But I can only do this if you have a"
-		echo "*** shared version of the library, which you do not appear to have"
-		echo "*** because the file extensions .$libext of this argument makes me believe"
-		echo "*** that it is just a static archive that I should not use here."
-	      fi
-	      ;;
-	    esac
-	    continue
-	    ;;
-	  prog)
-	    if test link != "$pass"; then
-	      deplibs="$deplib $deplibs"
-	    else
-	      compile_deplibs="$deplib $compile_deplibs"
-	      finalize_deplibs="$deplib $finalize_deplibs"
-	    fi
-	    continue
-	    ;;
-	  esac # linkmode
-	  ;; # *.$libext
-	*.lo | *.$objext)
-	  if test conv = "$pass"; then
-	    deplibs="$deplib $deplibs"
-	  elif test prog = "$linkmode"; then
-	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
-	      # If there is no dlopen support or we're linking statically,
-	      # we need to preload.
-	      func_append newdlprefiles " $deplib"
-	      compile_deplibs="$deplib $compile_deplibs"
-	      finalize_deplibs="$deplib $finalize_deplibs"
-	    else
-	      func_append newdlfiles " $deplib"
-	    fi
-	  fi
-	  continue
-	  ;;
-	%DEPLIBS%)
-	  alldeplibs=:
-	  continue
-	  ;;
-	esac # case $deplib
-
-	$found || test -f "$lib" \
-	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
-
-	# Check to see that this really is a libtool archive.
-	func_lalib_unsafe_p "$lib" \
-	  || func_fatal_error "'$lib' is not a valid libtool archive"
-
-	func_dirname "$lib" "" "."
-	ladir=$func_dirname_result
-
-	dlname=
-	dlopen=
-	dlpreopen=
-	libdir=
-	library_names=
-	old_library=
-	inherited_linker_flags=
-	# If the library was installed with an old release of libtool,
-	# it will not redefine variables installed, or shouldnotlink
-	installed=yes
-	shouldnotlink=no
-	avoidtemprpath=
-
-
-	# Read the .la file
-	func_source "$lib"
-
-	# Convert "-framework foo" to "foo.ltframework"
-	if test -n "$inherited_linker_flags"; then
-	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
-	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
-	    case " $new_inherited_linker_flags " in
-	      *" $tmp_inherited_linker_flag "*) ;;
-	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
-	    esac
-	  done
-	fi
-	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	if test lib,link = "$linkmode,$pass" ||
-	   test prog,scan = "$linkmode,$pass" ||
-	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
-	  test -n "$dlopen" && func_append dlfiles " $dlopen"
-	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
-	fi
-
-	if test conv = "$pass"; then
-	  # Only check for convenience libraries
-	  deplibs="$lib $deplibs"
-	  if test -z "$libdir"; then
-	    if test -z "$old_library"; then
-	      func_fatal_error "cannot find name of link library for '$lib'"
-	    fi
-	    # It is a libtool convenience library, so add in its objects.
-	    func_append convenience " $ladir/$objdir/$old_library"
-	    func_append old_convenience " $ladir/$objdir/$old_library"
-	    tmp_libs=
-	    for deplib in $dependency_libs; do
-	      deplibs="$deplib $deplibs"
-	      if $opt_preserve_dup_deps; then
-		case "$tmp_libs " in
-		*" $deplib "*) func_append specialdeplibs " $deplib" ;;
-		esac
-	      fi
-	      func_append tmp_libs " $deplib"
-	    done
-	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
-	    func_fatal_error "'$lib' is not a convenience library"
-	  fi
-	  continue
-	fi # $pass = conv
-
-
-	# Get the name of the library we link against.
-	linklib=
-	if test -n "$old_library" &&
-	   { test yes = "$prefer_static_libs" ||
-	     test built,no = "$prefer_static_libs,$installed"; }; then
-	  linklib=$old_library
-	else
-	  for l in $old_library $library_names; do
-	    linklib=$l
-	  done
-	fi
-	if test -z "$linklib"; then
-	  func_fatal_error "cannot find name of link library for '$lib'"
-	fi
-
-	# This library was specified with -dlopen.
-	if test dlopen = "$pass"; then
-	  test -z "$libdir" \
-	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
-	  if test -z "$dlname" ||
-	     test yes != "$dlopen_support" ||
-	     test no = "$build_libtool_libs"
-	  then
-	    # If there is no dlname, no dlopen support or we're linking
-	    # statically, we need to preload.  We also need to preload any
-	    # dependent libraries so libltdl's deplib preloader doesn't
-	    # bomb out in the load deplibs phase.
-	    func_append dlprefiles " $lib $dependency_libs"
-	  else
-	    func_append newdlfiles " $lib"
-	  fi
-	  continue
-	fi # $pass = dlopen
-
-	# We need an absolute path.
-	case $ladir in
-	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
-	*)
-	  abs_ladir=`cd "$ladir" && pwd`
-	  if test -z "$abs_ladir"; then
-	    func_warning "cannot determine absolute directory name of '$ladir'"
-	    func_warning "passing it literally to the linker, although it might fail"
-	    abs_ladir=$ladir
-	  fi
-	  ;;
-	esac
-	func_basename "$lib"
-	laname=$func_basename_result
-
-	# Find the relevant object directory and library name.
-	if test yes = "$installed"; then
-	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
-	    func_warning "library '$lib' was moved."
-	    dir=$ladir
-	    absdir=$abs_ladir
-	    libdir=$abs_ladir
-	  else
-	    dir=$lt_sysroot$libdir
-	    absdir=$lt_sysroot$libdir
-	  fi
-	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
-	else
-	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
-	    dir=$ladir
-	    absdir=$abs_ladir
-	    # Remove this search path later
-	    func_append notinst_path " $abs_ladir"
-	  else
-	    dir=$ladir/$objdir
-	    absdir=$abs_ladir/$objdir
-	    # Remove this search path later
-	    func_append notinst_path " $abs_ladir"
-	  fi
-	fi # $installed = yes
-	func_stripname 'lib' '.la' "$laname"
-	name=$func_stripname_result
-
-	# This library was specified with -dlpreopen.
-	if test dlpreopen = "$pass"; then
-	  if test -z "$libdir" && test prog = "$linkmode"; then
-	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
-	  fi
-	  case $host in
-	    # special handling for platforms with PE-DLLs.
-	    *cygwin* | *mingw* | *cegcc* )
-	      # Linker will automatically link against shared library if both
-	      # static and shared are present.  Therefore, ensure we extract
-	      # symbols from the import library if a shared library is present
-	      # (otherwise, the dlopen module name will be incorrect).  We do
-	      # this by putting the import library name into $newdlprefiles.
-	      # We recover the dlopen module name by 'saving' the la file
-	      # name in a special purpose variable, and (later) extracting the
-	      # dlname from the la file.
-	      if test -n "$dlname"; then
-	        func_tr_sh "$dir/$linklib"
-	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
-	        func_append newdlprefiles " $dir/$linklib"
-	      else
-	        func_append newdlprefiles " $dir/$old_library"
-	        # Keep a list of preopened convenience libraries to check
-	        # that they are being used correctly in the link pass.
-	        test -z "$libdir" && \
-	          func_append dlpreconveniencelibs " $dir/$old_library"
-	      fi
-	    ;;
-	    * )
-	      # Prefer using a static library (so that no silly _DYNAMIC symbols
-	      # are required to link).
-	      if test -n "$old_library"; then
-	        func_append newdlprefiles " $dir/$old_library"
-	        # Keep a list of preopened convenience libraries to check
-	        # that they are being used correctly in the link pass.
-	        test -z "$libdir" && \
-	          func_append dlpreconveniencelibs " $dir/$old_library"
-	      # Otherwise, use the dlname, so that lt_dlopen finds it.
-	      elif test -n "$dlname"; then
-	        func_append newdlprefiles " $dir/$dlname"
-	      else
-	        func_append newdlprefiles " $dir/$linklib"
-	      fi
-	    ;;
-	  esac
-	fi # $pass = dlpreopen
-
-	if test -z "$libdir"; then
-	  # Link the convenience library
-	  if test lib = "$linkmode"; then
-	    deplibs="$dir/$old_library $deplibs"
-	  elif test prog,link = "$linkmode,$pass"; then
-	    compile_deplibs="$dir/$old_library $compile_deplibs"
-	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
-	  else
-	    deplibs="$lib $deplibs" # used for prog,scan pass
-	  fi
-	  continue
-	fi
-
-
-	if test prog = "$linkmode" && test link != "$pass"; then
-	  func_append newlib_search_path " $ladir"
-	  deplibs="$lib $deplibs"
-
-	  linkalldeplibs=false
-	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
-	     test no = "$build_libtool_libs"; then
-	    linkalldeplibs=:
-	  fi
-
-	  tmp_libs=
-	  for deplib in $dependency_libs; do
-	    case $deplib in
-	    -L*) func_stripname '-L' '' "$deplib"
-	         func_resolve_sysroot "$func_stripname_result"
-	         func_append newlib_search_path " $func_resolve_sysroot_result"
-		 ;;
-	    esac
-	    # Need to link against all dependency_libs?
-	    if $linkalldeplibs; then
-	      deplibs="$deplib $deplibs"
-	    else
-	      # Need to hardcode shared library paths
-	      # or/and link against static libraries
-	      newdependency_libs="$deplib $newdependency_libs"
-	    fi
-	    if $opt_preserve_dup_deps; then
-	      case "$tmp_libs " in
-	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
-	      esac
-	    fi
-	    func_append tmp_libs " $deplib"
-	  done # for deplib
-	  continue
-	fi # $linkmode = prog...
-
-	if test prog,link = "$linkmode,$pass"; then
-	  if test -n "$library_names" &&
-	     { { test no = "$prefer_static_libs" ||
-	         test built,yes = "$prefer_static_libs,$installed"; } ||
-	       test -z "$old_library"; }; then
-	    # We need to hardcode the library path
-	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
-	      # Make sure the rpath contains only unique directories.
-	      case $temp_rpath: in
-	      *"$absdir:"*) ;;
-	      *) func_append temp_rpath "$absdir:" ;;
-	      esac
-	    fi
-
-	    # Hardcode the library path.
-	    # Skip directories that are in the system default run-time
-	    # search path.
-	    case " $sys_lib_dlsearch_path " in
-	    *" $absdir "*) ;;
-	    *)
-	      case "$compile_rpath " in
-	      *" $absdir "*) ;;
-	      *) func_append compile_rpath " $absdir" ;;
-	      esac
-	      ;;
-	    esac
-	    case " $sys_lib_dlsearch_path " in
-	    *" $libdir "*) ;;
-	    *)
-	      case "$finalize_rpath " in
-	      *" $libdir "*) ;;
-	      *) func_append finalize_rpath " $libdir" ;;
-	      esac
-	      ;;
-	    esac
-	  fi # $linkmode,$pass = prog,link...
-
-	  if $alldeplibs &&
-	     { test pass_all = "$deplibs_check_method" ||
-	       { test yes = "$build_libtool_libs" &&
-		 test -n "$library_names"; }; }; then
-	    # We only need to search for static libraries
-	    continue
-	  fi
-	fi
-
-	link_static=no # Whether the deplib will be linked statically
-	use_static_libs=$prefer_static_libs
-	if test built = "$use_static_libs" && test yes = "$installed"; then
-	  use_static_libs=no
-	fi
-	if test -n "$library_names" &&
-	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
-	  case $host in
-	  *cygwin* | *mingw* | *cegcc* | *os2*)
-	      # No point in relinking DLLs because paths are not encoded
-	      func_append notinst_deplibs " $lib"
-	      need_relink=no
-	    ;;
-	  *)
-	    if test no = "$installed"; then
-	      func_append notinst_deplibs " $lib"
-	      need_relink=yes
-	    fi
-	    ;;
-	  esac
-	  # This is a shared library
-
-	  # Warn about portability, can't link against -module's on some
-	  # systems (darwin).  Don't bleat about dlopened modules though!
-	  dlopenmodule=
-	  for dlpremoduletest in $dlprefiles; do
-	    if test "X$dlpremoduletest" = "X$lib"; then
-	      dlopenmodule=$dlpremoduletest
-	      break
-	    fi
-	  done
-	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
-	    echo
-	    if test prog = "$linkmode"; then
-	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
-	    else
-	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
-	    fi
-	    $ECHO "*** $linklib is not portable!"
-	  fi
-	  if test lib = "$linkmode" &&
-	     test yes = "$hardcode_into_libs"; then
-	    # Hardcode the library path.
-	    # Skip directories that are in the system default run-time
-	    # search path.
-	    case " $sys_lib_dlsearch_path " in
-	    *" $absdir "*) ;;
-	    *)
-	      case "$compile_rpath " in
-	      *" $absdir "*) ;;
-	      *) func_append compile_rpath " $absdir" ;;
-	      esac
-	      ;;
-	    esac
-	    case " $sys_lib_dlsearch_path " in
-	    *" $libdir "*) ;;
-	    *)
-	      case "$finalize_rpath " in
-	      *" $libdir "*) ;;
-	      *) func_append finalize_rpath " $libdir" ;;
-	      esac
-	      ;;
-	    esac
-	  fi
-
-	  if test -n "$old_archive_from_expsyms_cmds"; then
-	    # figure out the soname
-	    set dummy $library_names
-	    shift
-	    realname=$1
-	    shift
-	    libname=`eval "\\$ECHO \"$libname_spec\""`
-	    # use dlname if we got it. it's perfectly good, no?
-	    if test -n "$dlname"; then
-	      soname=$dlname
-	    elif test -n "$soname_spec"; then
-	      # bleh windows
-	      case $host in
-	      *cygwin* | mingw* | *cegcc* | *os2*)
-	        func_arith $current - $age
-		major=$func_arith_result
-		versuffix=-$major
-		;;
-	      esac
-	      eval soname=\"$soname_spec\"
-	    else
-	      soname=$realname
-	    fi
-
-	    # Make a new name for the extract_expsyms_cmds to use
-	    soroot=$soname
-	    func_basename "$soroot"
-	    soname=$func_basename_result
-	    func_stripname 'lib' '.dll' "$soname"
-	    newlib=libimp-$func_stripname_result.a
-
-	    # If the library has no export list, then create one now
-	    if test -f "$output_objdir/$soname-def"; then :
-	    else
-	      func_verbose "extracting exported symbol list from '$soname'"
-	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
-	    fi
-
-	    # Create $newlib
-	    if test -f "$output_objdir/$newlib"; then :; else
-	      func_verbose "generating import library for '$soname'"
-	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
-	    fi
-	    # make sure the library variables are pointing to the new library
-	    dir=$output_objdir
-	    linklib=$newlib
-	  fi # test -n "$old_archive_from_expsyms_cmds"
-
-	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
-	    add_shlibpath=
-	    add_dir=
-	    add=
-	    lib_linked=yes
-	    case $hardcode_action in
-	    immediate | unsupported)
-	      if test no = "$hardcode_direct"; then
-		add=$dir/$linklib
-		case $host in
-		  *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
-		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
-		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
-		    *-*-unixware7*) add_dir=-L$dir ;;
-		  *-*-darwin* )
-		    # if the lib is a (non-dlopened) module then we cannot
-		    # link against it, someone is ignoring the earlier warnings
-		    if /usr/bin/file -L $add 2> /dev/null |
-			 $GREP ": [^:]* bundle" >/dev/null; then
-		      if test "X$dlopenmodule" != "X$lib"; then
-			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
-			if test -z "$old_library"; then
-			  echo
-			  echo "*** And there doesn't seem to be a static archive available"
-			  echo "*** The link will probably fail, sorry"
-			else
-			  add=$dir/$old_library
-			fi
-		      elif test -n "$old_library"; then
-			add=$dir/$old_library
-		      fi
-		    fi
-		esac
-	      elif test no = "$hardcode_minus_L"; then
-		case $host in
-		*-*-sunos*) add_shlibpath=$dir ;;
-		esac
-		add_dir=-L$dir
-		add=-l$name
-	      elif test no = "$hardcode_shlibpath_var"; then
-		add_shlibpath=$dir
-		add=-l$name
-	      else
-		lib_linked=no
-	      fi
-	      ;;
-	    relink)
-	      if test yes = "$hardcode_direct" &&
-	         test no = "$hardcode_direct_absolute"; then
-		add=$dir/$linklib
-	      elif test yes = "$hardcode_minus_L"; then
-		add_dir=-L$absdir
-		# Try looking first in the location we're being installed to.
-		if test -n "$inst_prefix_dir"; then
-		  case $libdir in
-		    [\\/]*)
-		      func_append add_dir " -L$inst_prefix_dir$libdir"
-		      ;;
-		  esac
-		fi
-		add=-l$name
-	      elif test yes = "$hardcode_shlibpath_var"; then
-		add_shlibpath=$dir
-		add=-l$name
-	      else
-		lib_linked=no
-	      fi
-	      ;;
-	    *) lib_linked=no ;;
-	    esac
-
-	    if test yes != "$lib_linked"; then
-	      func_fatal_configuration "unsupported hardcode properties"
-	    fi
-
-	    if test -n "$add_shlibpath"; then
-	      case :$compile_shlibpath: in
-	      *":$add_shlibpath:"*) ;;
-	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
-	      esac
-	    fi
-	    if test prog = "$linkmode"; then
-	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
-	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
-	    else
-	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
-	      test -n "$add" && deplibs="$add $deplibs"
-	      if test yes != "$hardcode_direct" &&
-		 test yes != "$hardcode_minus_L" &&
-		 test yes = "$hardcode_shlibpath_var"; then
-		case :$finalize_shlibpath: in
-		*":$libdir:"*) ;;
-		*) func_append finalize_shlibpath "$libdir:" ;;
-		esac
-	      fi
-	    fi
-	  fi
-
-	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
-	    add_shlibpath=
-	    add_dir=
-	    add=
-	    # Finalize command for both is simple: just hardcode it.
-	    if test yes = "$hardcode_direct" &&
-	       test no = "$hardcode_direct_absolute"; then
-	      add=$libdir/$linklib
-	    elif test yes = "$hardcode_minus_L"; then
-	      add_dir=-L$libdir
-	      add=-l$name
-	    elif test yes = "$hardcode_shlibpath_var"; then
-	      case :$finalize_shlibpath: in
-	      *":$libdir:"*) ;;
-	      *) func_append finalize_shlibpath "$libdir:" ;;
-	      esac
-	      add=-l$name
-	    elif test yes = "$hardcode_automatic"; then
-	      if test -n "$inst_prefix_dir" &&
-		 test -f "$inst_prefix_dir$libdir/$linklib"; then
-		add=$inst_prefix_dir$libdir/$linklib
-	      else
-		add=$libdir/$linklib
-	      fi
-	    else
-	      # We cannot seem to hardcode it, guess we'll fake it.
-	      add_dir=-L$libdir
-	      # Try looking first in the location we're being installed to.
-	      if test -n "$inst_prefix_dir"; then
-		case $libdir in
-		  [\\/]*)
-		    func_append add_dir " -L$inst_prefix_dir$libdir"
-		    ;;
-		esac
-	      fi
-	      add=-l$name
-	    fi
-
-	    if test prog = "$linkmode"; then
-	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
-	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
-	    else
-	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
-	      test -n "$add" && deplibs="$add $deplibs"
-	    fi
-	  fi
-	elif test prog = "$linkmode"; then
-	  # Here we assume that one of hardcode_direct or hardcode_minus_L
-	  # is not unsupported.  This is valid on all known static and
-	  # shared platforms.
-	  if test unsupported != "$hardcode_direct"; then
-	    test -n "$old_library" && linklib=$old_library
-	    compile_deplibs="$dir/$linklib $compile_deplibs"
-	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
-	  else
-	    compile_deplibs="-l$name -L$dir $compile_deplibs"
-	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
-	  fi
-	elif test yes = "$build_libtool_libs"; then
-	  # Not a shared library
-	  if test pass_all != "$deplibs_check_method"; then
-	    # We're trying link a shared library against a static one
-	    # but the system doesn't support it.
-
-	    # Just print a warning and add the library to dependency_libs so
-	    # that the program can be linked against the static library.
-	    echo
-	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
-	    echo "*** I have the capability to make that library automatically link in when"
-	    echo "*** you link to this library.  But I can only do this if you have a"
-	    echo "*** shared version of the library, which you do not appear to have."
-	    if test yes = "$module"; then
-	      echo "*** But as you try to build a module library, libtool will still create "
-	      echo "*** a static module, that should work as long as the dlopening application"
-	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
-	      if test -z "$global_symbol_pipe"; then
-		echo
-		echo "*** However, this would only work if libtool was able to extract symbol"
-		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
-		echo "*** not find such a program.  So, this module is probably useless."
-		echo "*** 'nm' from GNU binutils and a full rebuild may help."
-	      fi
-	      if test no = "$build_old_libs"; then
-		build_libtool_libs=module
-		build_old_libs=yes
-	      else
-		build_libtool_libs=no
-	      fi
-	    fi
-	  else
-	    deplibs="$dir/$old_library $deplibs"
-	    link_static=yes
-	  fi
-	fi # link shared/static library?
-
-	if test lib = "$linkmode"; then
-	  if test -n "$dependency_libs" &&
-	     { test yes != "$hardcode_into_libs" ||
-	       test yes = "$build_old_libs" ||
-	       test yes = "$link_static"; }; then
-	    # Extract -R from dependency_libs
-	    temp_deplibs=
-	    for libdir in $dependency_libs; do
-	      case $libdir in
-	      -R*) func_stripname '-R' '' "$libdir"
-	           temp_xrpath=$func_stripname_result
-		   case " $xrpath " in
-		   *" $temp_xrpath "*) ;;
-		   *) func_append xrpath " $temp_xrpath";;
-		   esac;;
-	      *) func_append temp_deplibs " $libdir";;
-	      esac
-	    done
-	    dependency_libs=$temp_deplibs
-	  fi
-
-	  func_append newlib_search_path " $absdir"
-	  # Link against this library
-	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
-	  # ... and its dependency_libs
-	  tmp_libs=
-	  for deplib in $dependency_libs; do
-	    newdependency_libs="$deplib $newdependency_libs"
-	    case $deplib in
-              -L*) func_stripname '-L' '' "$deplib"
-                   func_resolve_sysroot "$func_stripname_result";;
-              *) func_resolve_sysroot "$deplib" ;;
-            esac
-	    if $opt_preserve_dup_deps; then
-	      case "$tmp_libs " in
-	      *" $func_resolve_sysroot_result "*)
-                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
-	      esac
-	    fi
-	    func_append tmp_libs " $func_resolve_sysroot_result"
-	  done
-
-	  if test no != "$link_all_deplibs"; then
-	    # Add the search paths of all dependency libraries
-	    for deplib in $dependency_libs; do
-	      path=
-	      case $deplib in
-	      -L*) path=$deplib ;;
-	      *.la)
-	        func_resolve_sysroot "$deplib"
-	        deplib=$func_resolve_sysroot_result
-	        func_dirname "$deplib" "" "."
-		dir=$func_dirname_result
-		# We need an absolute path.
-		case $dir in
-		[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
-		*)
-		  absdir=`cd "$dir" && pwd`
-		  if test -z "$absdir"; then
-		    func_warning "cannot determine absolute directory name of '$dir'"
-		    absdir=$dir
-		  fi
-		  ;;
-		esac
-		if $GREP "^installed=no" $deplib > /dev/null; then
-		case $host in
-		*-*-darwin*)
-		  depdepl=
-		  eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
-		  if test -n "$deplibrary_names"; then
-		    for tmp in $deplibrary_names; do
-		      depdepl=$tmp
-		    done
-		    if test -f "$absdir/$objdir/$depdepl"; then
-		      depdepl=$absdir/$objdir/$depdepl
-		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
-                      if test -z "$darwin_install_name"; then
-                          darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
-                      fi
-		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
-		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
-		      path=
-		    fi
-		  fi
-		  ;;
-		*)
-		  path=-L$absdir/$objdir
-		  ;;
-		esac
-		else
-		  eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
-		  test -z "$libdir" && \
-		    func_fatal_error "'$deplib' is not a valid libtool archive"
-		  test "$absdir" != "$libdir" && \
-		    func_warning "'$deplib' seems to be moved"
-
-		  path=-L$absdir
-		fi
-		;;
-	      esac
-	      case " $deplibs " in
-	      *" $path "*) ;;
-	      *) deplibs="$path $deplibs" ;;
-	      esac
-	    done
-	  fi # link_all_deplibs != no
-	fi # linkmode = lib
-      done # for deplib in $libs
-      if test link = "$pass"; then
-	if test prog = "$linkmode"; then
-	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
-	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
-	else
-	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	fi
-      fi
-      dependency_libs=$newdependency_libs
-      if test dlpreopen = "$pass"; then
-	# Link the dlpreopened libraries before other libraries
-	for deplib in $save_deplibs; do
-	  deplibs="$deplib $deplibs"
-	done
-      fi
-      if test dlopen != "$pass"; then
-	test conv = "$pass" || {
-	  # Make sure lib_search_path contains only unique directories.
-	  lib_search_path=
-	  for dir in $newlib_search_path; do
-	    case "$lib_search_path " in
-	    *" $dir "*) ;;
-	    *) func_append lib_search_path " $dir" ;;
-	    esac
-	  done
-	  newlib_search_path=
-	}
-
-	if test prog,link = "$linkmode,$pass"; then
-	  vars="compile_deplibs finalize_deplibs"
-	else
-	  vars=deplibs
-	fi
-	for var in $vars dependency_libs; do
-	  # Add libraries to $var in reverse order
-	  eval tmp_libs=\"\$$var\"
-	  new_libs=
-	  for deplib in $tmp_libs; do
-	    # FIXME: Pedantically, this is the right thing to do, so
-	    #        that some nasty dependency loop isn't accidentally
-	    #        broken:
-	    #new_libs="$deplib $new_libs"
-	    # Pragmatically, this seems to cause very few problems in
-	    # practice:
-	    case $deplib in
-	    -L*) new_libs="$deplib $new_libs" ;;
-	    -R*) ;;
-	    *)
-	      # And here is the reason: when a library appears more
-	      # than once as an explicit dependence of a library, or
-	      # is implicitly linked in more than once by the
-	      # compiler, it is considered special, and multiple
-	      # occurrences thereof are not removed.  Compare this
-	      # with having the same library being listed as a
-	      # dependency of multiple other libraries: in this case,
-	      # we know (pedantically, we assume) the library does not
-	      # need to be listed more than once, so we keep only the
-	      # last copy.  This is not always right, but it is rare
-	      # enough that we require users that really mean to play
-	      # such unportable linking tricks to link the library
-	      # using -Wl,-lname, so that libtool does not consider it
-	      # for duplicate removal.
-	      case " $specialdeplibs " in
-	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
-	      *)
-		case " $new_libs " in
-		*" $deplib "*) ;;
-		*) new_libs="$deplib $new_libs" ;;
-		esac
-		;;
-	      esac
-	      ;;
-	    esac
-	  done
-	  tmp_libs=
-	  for deplib in $new_libs; do
-	    case $deplib in
-	    -L*)
-	      case " $tmp_libs " in
-	      *" $deplib "*) ;;
-	      *) func_append tmp_libs " $deplib" ;;
-	      esac
-	      ;;
-	    *) func_append tmp_libs " $deplib" ;;
-	    esac
-	  done
-	  eval $var=\"$tmp_libs\"
-	done # for var
-      fi
-
-      # Add Sun CC postdeps if required:
-      test CXX = "$tagname" && {
-        case $host_os in
-        linux*)
-          case `$CC -V 2>&1 | sed 5q` in
-          *Sun\ C*) # Sun C++ 5.9
-            func_suncc_cstd_abi
-
-            if test no != "$suncc_use_cstd_abi"; then
-              func_append postdeps ' -library=Cstd -library=Crun'
-            fi
-            ;;
-          esac
-          ;;
-
-        solaris*)
-          func_cc_basename "$CC"
-          case $func_cc_basename_result in
-          CC* | sunCC*)
-            func_suncc_cstd_abi
-
-            if test no != "$suncc_use_cstd_abi"; then
-              func_append postdeps ' -library=Cstd -library=Crun'
-            fi
-            ;;
-          esac
-          ;;
-        esac
-      }
-
-      # Last step: remove runtime libs from dependency_libs
-      # (they stay in deplibs)
-      tmp_libs=
-      for i in $dependency_libs; do
-	case " $predeps $postdeps $compiler_lib_search_path " in
-	*" $i "*)
-	  i=
-	  ;;
-	esac
-	if test -n "$i"; then
-	  func_append tmp_libs " $i"
-	fi
-      done
-      dependency_libs=$tmp_libs
-    done # for pass
-    if test prog = "$linkmode"; then
-      dlfiles=$newdlfiles
-    fi
-    if test prog = "$linkmode" || test lib = "$linkmode"; then
-      dlprefiles=$newdlprefiles
-    fi
-
-    case $linkmode in
-    oldlib)
-      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
-	func_warning "'-dlopen' is ignored for archives"
-      fi
-
-      case " $deplibs" in
-      *\ -l* | *\ -L*)
-	func_warning "'-l' and '-L' are ignored for archives" ;;
-      esac
-
-      test -n "$rpath" && \
-	func_warning "'-rpath' is ignored for archives"
-
-      test -n "$xrpath" && \
-	func_warning "'-R' is ignored for archives"
-
-      test -n "$vinfo" && \
-	func_warning "'-version-info/-version-number' is ignored for archives"
-
-      test -n "$release" && \
-	func_warning "'-release' is ignored for archives"
-
-      test -n "$export_symbols$export_symbols_regex" && \
-	func_warning "'-export-symbols' is ignored for archives"
-
-      # Now set the variables for building old libraries.
-      build_libtool_libs=no
-      oldlibs=$output
-      func_append objs "$old_deplibs"
-      ;;
-
-    lib)
-      # Make sure we only generate libraries of the form 'libNAME.la'.
-      case $outputname in
-      lib*)
-	func_stripname 'lib' '.la' "$outputname"
-	name=$func_stripname_result
-	eval shared_ext=\"$shrext_cmds\"
-	eval libname=\"$libname_spec\"
-	;;
-      *)
-	test no = "$module" \
-	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
-
-	if test no != "$need_lib_prefix"; then
-	  # Add the "lib" prefix for modules if required
-	  func_stripname '' '.la' "$outputname"
-	  name=$func_stripname_result
-	  eval shared_ext=\"$shrext_cmds\"
-	  eval libname=\"$libname_spec\"
-	else
-	  func_stripname '' '.la' "$outputname"
-	  libname=$func_stripname_result
-	fi
-	;;
-      esac
-
-      if test -n "$objs"; then
-	if test pass_all != "$deplibs_check_method"; then
-	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
-	else
-	  echo
-	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
-	  $ECHO "*** objects $objs is not portable!"
-	  func_append libobjs " $objs"
-	fi
-      fi
-
-      test no = "$dlself" \
-	|| func_warning "'-dlopen self' is ignored for libtool libraries"
-
-      set dummy $rpath
-      shift
-      test 1 -lt "$#" \
-	&& func_warning "ignoring multiple '-rpath's for a libtool library"
-
-      install_libdir=$1
-
-      oldlibs=
-      if test -z "$rpath"; then
-	if test yes = "$build_libtool_libs"; then
-	  # Building a libtool convenience library.
-	  # Some compilers have problems with a '.al' extension so
-	  # convenience libraries should have the same extension an
-	  # archive normally would.
-	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
-	  build_libtool_libs=convenience
-	  build_old_libs=yes
-	fi
-
-	test -n "$vinfo" && \
-	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
-
-	test -n "$release" && \
-	  func_warning "'-release' is ignored for convenience libraries"
-      else
-
-	# Parse the version information argument.
-	save_ifs=$IFS; IFS=:
-	set dummy $vinfo 0 0 0
-	shift
-	IFS=$save_ifs
-
-	test -n "$7" && \
-	  func_fatal_help "too many parameters to '-version-info'"
-
-	# convert absolute version numbers to libtool ages
-	# this retains compatibility with .la files and attempts
-	# to make the code below a bit more comprehensible
-
-	case $vinfo_number in
-	yes)
-	  number_major=$1
-	  number_minor=$2
-	  number_revision=$3
-	  #
-	  # There are really only two kinds -- those that
-	  # use the current revision as the major version
-	  # and those that subtract age and use age as
-	  # a minor version.  But, then there is irix
-	  # that has an extra 1 added just for fun
-	  #
-	  case $version_type in
-	  # correct linux to gnu/linux during the next big refactor
-	  darwin|freebsd-elf|linux|osf|windows|none)
-	    func_arith $number_major + $number_minor
-	    current=$func_arith_result
-	    age=$number_minor
-	    revision=$number_revision
-	    ;;
-	  freebsd-aout|qnx|sunos)
-	    current=$number_major
-	    revision=$number_minor
-	    age=0
-	    ;;
-	  irix|nonstopux)
-	    func_arith $number_major + $number_minor
-	    current=$func_arith_result
-	    age=$number_minor
-	    revision=$number_minor
-	    lt_irix_increment=no
-	    ;;
-	  *)
-	    func_fatal_configuration "$modename: unknown library version type '$version_type'"
-	    ;;
-	  esac
-	  ;;
-	no)
-	  current=$1
-	  revision=$2
-	  age=$3
-	  ;;
-	esac
-
-	# Check that each of the things are valid numbers.
-	case $current in
-	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
-	*)
-	  func_error "CURRENT '$current' must be a nonnegative integer"
-	  func_fatal_error "'$vinfo' is not valid version information"
-	  ;;
-	esac
-
-	case $revision in
-	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
-	*)
-	  func_error "REVISION '$revision' must be a nonnegative integer"
-	  func_fatal_error "'$vinfo' is not valid version information"
-	  ;;
-	esac
-
-	case $age in
-	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
-	*)
-	  func_error "AGE '$age' must be a nonnegative integer"
-	  func_fatal_error "'$vinfo' is not valid version information"
-	  ;;
-	esac
-
-	if test "$age" -gt "$current"; then
-	  func_error "AGE '$age' is greater than the current interface number '$current'"
-	  func_fatal_error "'$vinfo' is not valid version information"
-	fi
-
-	# Calculate the version variables.
-	major=
-	versuffix=
-	verstring=
-	case $version_type in
-	none) ;;
-
-	darwin)
-	  # Like Linux, but with the current version available in
-	  # verstring for coding it into the library header
-	  func_arith $current - $age
-	  major=.$func_arith_result
-	  versuffix=$major.$age.$revision
-	  # Darwin ld doesn't like 0 for these options...
-	  func_arith $current + 1
-	  minor_current=$func_arith_result
-	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
-	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
-          # On Darwin other compilers
-          case $CC in
-              nagfor*)
-                  verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
-                  ;;
-              *)
-                  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
-                  ;;
-          esac
-	  ;;
-
-	freebsd-aout)
-	  major=.$current
-	  versuffix=.$current.$revision
-	  ;;
-
-	freebsd-elf)
-	  func_arith $current - $age
-	  major=.$func_arith_result
-	  versuffix=$major.$age.$revision
-	  ;;
-
-	irix | nonstopux)
-	  if test no = "$lt_irix_increment"; then
-	    func_arith $current - $age
-	  else
-	    func_arith $current - $age + 1
-	  fi
-	  major=$func_arith_result
-
-	  case $version_type in
-	    nonstopux) verstring_prefix=nonstopux ;;
-	    *)         verstring_prefix=sgi ;;
-	  esac
-	  verstring=$verstring_prefix$major.$revision
-
-	  # Add in all the interfaces that we are compatible with.
-	  loop=$revision
-	  while test 0 -ne "$loop"; do
-	    func_arith $revision - $loop
-	    iface=$func_arith_result
-	    func_arith $loop - 1
-	    loop=$func_arith_result
-	    verstring=$verstring_prefix$major.$iface:$verstring
-	  done
-
-	  # Before this point, $major must not contain '.'.
-	  major=.$major
-	  versuffix=$major.$revision
-	  ;;
-
-	linux) # correct to gnu/linux during the next big refactor
-	  func_arith $current - $age
-	  major=.$func_arith_result
-	  versuffix=$major.$age.$revision
-	  ;;
-
-	osf)
-	  func_arith $current - $age
-	  major=.$func_arith_result
-	  versuffix=.$current.$age.$revision
-	  verstring=$current.$age.$revision
-
-	  # Add in all the interfaces that we are compatible with.
-	  loop=$age
-	  while test 0 -ne "$loop"; do
-	    func_arith $current - $loop
-	    iface=$func_arith_result
-	    func_arith $loop - 1
-	    loop=$func_arith_result
-	    verstring=$verstring:$iface.0
-	  done
-
-	  # Make executables depend on our current version.
-	  func_append verstring ":$current.0"
-	  ;;
-
-	qnx)
-	  major=.$current
-	  versuffix=.$current
-	  ;;
-
-	sco)
-	  major=.$current
-	  versuffix=.$current
-	  ;;
-
-	sunos)
-	  major=.$current
-	  versuffix=.$current.$revision
-	  ;;
-
-	windows)
-	  # Use '-' rather than '.', since we only want one
-	  # extension on DOS 8.3 file systems.
-	  func_arith $current - $age
-	  major=$func_arith_result
-	  versuffix=-$major
-	  ;;
-
-	*)
-	  func_fatal_configuration "unknown library version type '$version_type'"
-	  ;;
-	esac
-
-	# Clear the version info if we defaulted, and they specified a release.
-	if test -z "$vinfo" && test -n "$release"; then
-	  major=
-	  case $version_type in
-	  darwin)
-	    # we can't check for "0.0" in archive_cmds due to quoting
-	    # problems, so we reset it completely
-	    verstring=
-	    ;;
-	  *)
-	    verstring=0.0
-	    ;;
-	  esac
-	  if test no = "$need_version"; then
-	    versuffix=
-	  else
-	    versuffix=.0.0
-	  fi
-	fi
-
-	# Remove version info from name if versioning should be avoided
-	if test yes,no = "$avoid_version,$need_version"; then
-	  major=
-	  versuffix=
-	  verstring=
-	fi
-
-	# Check to see if the archive will have undefined symbols.
-	if test yes = "$allow_undefined"; then
-	  if test unsupported = "$allow_undefined_flag"; then
-	    if test yes = "$build_old_libs"; then
-	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
-	      build_libtool_libs=no
-	    else
-	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
-	    fi
-	  fi
-	else
-	  # Don't allow undefined symbols.
-	  allow_undefined_flag=$no_undefined_flag
-	fi
-
-      fi
-
-      func_generate_dlsyms "$libname" "$libname" :
-      func_append libobjs " $symfileobj"
-      test " " = "$libobjs" && libobjs=
-
-      if test relink != "$opt_mode"; then
-	# Remove our outputs, but don't remove object files since they
-	# may have been created when compiling PIC objects.
-	removelist=
-	tempremovelist=`$ECHO "$output_objdir/*"`
-	for p in $tempremovelist; do
-	  case $p in
-	    *.$objext | *.gcno)
-	       ;;
-	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
-	       if test -n "$precious_files_regex"; then
-		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
-		 then
-		   continue
-		 fi
-	       fi
-	       func_append removelist " $p"
-	       ;;
-	    *) ;;
-	  esac
-	done
-	test -n "$removelist" && \
-	  func_show_eval "${RM}r \$removelist"
-      fi
-
-      # Now set the variables for building old libraries.
-      if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
-	func_append oldlibs " $output_objdir/$libname.$libext"
-
-	# Transform .lo files to .o files.
-	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
-      fi
-
-      # Eliminate all temporary directories.
-      #for path in $notinst_path; do
-      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
-      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
-      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
-      #done
-
-      if test -n "$xrpath"; then
-	# If the user specified any rpath flags, then add them.
-	temp_xrpath=
-	for libdir in $xrpath; do
-	  func_replace_sysroot "$libdir"
-	  func_append temp_xrpath " -R$func_replace_sysroot_result"
-	  case "$finalize_rpath " in
-	  *" $libdir "*) ;;
-	  *) func_append finalize_rpath " $libdir" ;;
-	  esac
-	done
-	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
-	  dependency_libs="$temp_xrpath $dependency_libs"
-	fi
-      fi
-
-      # Make sure dlfiles contains only unique files that won't be dlpreopened
-      old_dlfiles=$dlfiles
-      dlfiles=
-      for lib in $old_dlfiles; do
-	case " $dlprefiles $dlfiles " in
-	*" $lib "*) ;;
-	*) func_append dlfiles " $lib" ;;
-	esac
-      done
-
-      # Make sure dlprefiles contains only unique files
-      old_dlprefiles=$dlprefiles
-      dlprefiles=
-      for lib in $old_dlprefiles; do
-	case "$dlprefiles " in
-	*" $lib "*) ;;
-	*) func_append dlprefiles " $lib" ;;
-	esac
-      done
-
-      if test yes = "$build_libtool_libs"; then
-	if test -n "$rpath"; then
-	  case $host in
-	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
-	    # these systems don't actually have a c library (as such)!
-	    ;;
-	  *-*-rhapsody* | *-*-darwin1.[012])
-	    # Rhapsody C library is in the System framework
-	    func_append deplibs " System.ltframework"
-	    ;;
-	  *-*-netbsd*)
-	    # Don't link with libc until the a.out ld.so is fixed.
-	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
-	    # Do not include libc due to us having libc/libc_r.
-	    ;;
-	  *-*-sco3.2v5* | *-*-sco5v6*)
-	    # Causes problems with __ctype
-	    ;;
-	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
-	    # Compiler inserts libc in the correct place for threads to work
-	    ;;
-	  *)
-	    # Add libc to deplibs on all other systems if necessary.
-	    if test yes = "$build_libtool_need_lc"; then
-	      func_append deplibs " -lc"
-	    fi
-	    ;;
-	  esac
-	fi
-
-	# Transform deplibs into only deplibs that can be linked in shared.
-	name_save=$name
-	libname_save=$libname
-	release_save=$release
-	versuffix_save=$versuffix
-	major_save=$major
-	# I'm not sure if I'm treating the release correctly.  I think
-	# release should show up in the -l (ie -lgmp5) so we don't want to
-	# add it in twice.  Is that correct?
-	release=
-	versuffix=
-	major=
-	newdeplibs=
-	droppeddeps=no
-	case $deplibs_check_method in
-	pass_all)
-	  # Don't check for shared/static.  Everything works.
-	  # This might be a little naive.  We might want to check
-	  # whether the library exists or not.  But this is on
-	  # osf3 & osf4 and I'm not really sure... Just
-	  # implementing what was already the behavior.
-	  newdeplibs=$deplibs
-	  ;;
-	test_compile)
-	  # This code stresses the "libraries are programs" paradigm to its
-	  # limits. Maybe even breaks it.  We compile a program, linking it
-	  # against the deplibs as a proxy for the library.  Then we can check
-	  # whether they linked in statically or dynamically with ldd.
-	  $opt_dry_run || $RM conftest.c
-	  cat > conftest.c <<EOF
-	  int main() { return 0; }
-EOF
-	  $opt_dry_run || $RM conftest
-	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
-	    ldd_output=`ldd conftest`
-	    for i in $deplibs; do
-	      case $i in
-	      -l*)
-		func_stripname -l '' "$i"
-		name=$func_stripname_result
-		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-		  case " $predeps $postdeps " in
-		  *" $i "*)
-		    func_append newdeplibs " $i"
-		    i=
-		    ;;
-		  esac
-		fi
-		if test -n "$i"; then
-		  libname=`eval "\\$ECHO \"$libname_spec\""`
-		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
-		  set dummy $deplib_matches; shift
-		  deplib_match=$1
-		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
-		    func_append newdeplibs " $i"
-		  else
-		    droppeddeps=yes
-		    echo
-		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
-		    echo "*** I have the capability to make that library automatically link in when"
-		    echo "*** you link to this library.  But I can only do this if you have a"
-		    echo "*** shared version of the library, which I believe you do not have"
-		    echo "*** because a test_compile did reveal that the linker did not use it for"
-		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
-		  fi
-		fi
-		;;
-	      *)
-		func_append newdeplibs " $i"
-		;;
-	      esac
-	    done
-	  else
-	    # Error occurred in the first compile.  Let's try to salvage
-	    # the situation: Compile a separate program for each library.
-	    for i in $deplibs; do
-	      case $i in
-	      -l*)
-		func_stripname -l '' "$i"
-		name=$func_stripname_result
-		$opt_dry_run || $RM conftest
-		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
-		  ldd_output=`ldd conftest`
-		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-		    case " $predeps $postdeps " in
-		    *" $i "*)
-		      func_append newdeplibs " $i"
-		      i=
-		      ;;
-		    esac
-		  fi
-		  if test -n "$i"; then
-		    libname=`eval "\\$ECHO \"$libname_spec\""`
-		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
-		    set dummy $deplib_matches; shift
-		    deplib_match=$1
-		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
-		      func_append newdeplibs " $i"
-		    else
-		      droppeddeps=yes
-		      echo
-		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
-		      echo "*** I have the capability to make that library automatically link in when"
-		      echo "*** you link to this library.  But I can only do this if you have a"
-		      echo "*** shared version of the library, which you do not appear to have"
-		      echo "*** because a test_compile did reveal that the linker did not use this one"
-		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
-		    fi
-		  fi
-		else
-		  droppeddeps=yes
-		  echo
-		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
-		  echo "*** make it link in!  You will probably need to install it or some"
-		  echo "*** library that it depends on before this library will be fully"
-		  echo "*** functional.  Installing it before continuing would be even better."
-		fi
-		;;
-	      *)
-		func_append newdeplibs " $i"
-		;;
-	      esac
-	    done
-	  fi
-	  ;;
-	file_magic*)
-	  set dummy $deplibs_check_method; shift
-	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
-	  for a_deplib in $deplibs; do
-	    case $a_deplib in
-	    -l*)
-	      func_stripname -l '' "$a_deplib"
-	      name=$func_stripname_result
-	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-		case " $predeps $postdeps " in
-		*" $a_deplib "*)
-		  func_append newdeplibs " $a_deplib"
-		  a_deplib=
-		  ;;
-		esac
-	      fi
-	      if test -n "$a_deplib"; then
-		libname=`eval "\\$ECHO \"$libname_spec\""`
-		if test -n "$file_magic_glob"; then
-		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
-		else
-		  libnameglob=$libname
-		fi
-		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
-		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
-		  if test yes = "$want_nocaseglob"; then
-		    shopt -s nocaseglob
-		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
-		    $nocaseglob
-		  else
-		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
-		  fi
-		  for potent_lib in $potential_libs; do
-		      # Follow soft links.
-		      if ls -lLd "$potent_lib" 2>/dev/null |
-			 $GREP " -> " >/dev/null; then
-			continue
-		      fi
-		      # The statement above tries to avoid entering an
-		      # endless loop below, in case of cyclic links.
-		      # We might still enter an endless loop, since a link
-		      # loop can be closed while we follow links,
-		      # but so what?
-		      potlib=$potent_lib
-		      while test -h "$potlib" 2>/dev/null; do
-			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
-			case $potliblink in
-			[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
-			*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
-			esac
-		      done
-		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
-			 $SED -e 10q |
-			 $EGREP "$file_magic_regex" > /dev/null; then
-			func_append newdeplibs " $a_deplib"
-			a_deplib=
-			break 2
-		      fi
-		  done
-		done
-	      fi
-	      if test -n "$a_deplib"; then
-		droppeddeps=yes
-		echo
-		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
-		echo "*** I have the capability to make that library automatically link in when"
-		echo "*** you link to this library.  But I can only do this if you have a"
-		echo "*** shared version of the library, which you do not appear to have"
-		echo "*** because I did check the linker path looking for a file starting"
-		if test -z "$potlib"; then
-		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
-		else
-		  $ECHO "*** with $libname and none of the candidates passed a file format test"
-		  $ECHO "*** using a file magic. Last file checked: $potlib"
-		fi
-	      fi
-	      ;;
-	    *)
-	      # Add a -L argument.
-	      func_append newdeplibs " $a_deplib"
-	      ;;
-	    esac
-	  done # Gone through all deplibs.
-	  ;;
-	match_pattern*)
-	  set dummy $deplibs_check_method; shift
-	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
-	  for a_deplib in $deplibs; do
-	    case $a_deplib in
-	    -l*)
-	      func_stripname -l '' "$a_deplib"
-	      name=$func_stripname_result
-	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-		case " $predeps $postdeps " in
-		*" $a_deplib "*)
-		  func_append newdeplibs " $a_deplib"
-		  a_deplib=
-		  ;;
-		esac
-	      fi
-	      if test -n "$a_deplib"; then
-		libname=`eval "\\$ECHO \"$libname_spec\""`
-		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
-		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
-		  for potent_lib in $potential_libs; do
-		    potlib=$potent_lib # see symlink-check above in file_magic test
-		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
-		       $EGREP "$match_pattern_regex" > /dev/null; then
-		      func_append newdeplibs " $a_deplib"
-		      a_deplib=
-		      break 2
-		    fi
-		  done
-		done
-	      fi
-	      if test -n "$a_deplib"; then
-		droppeddeps=yes
-		echo
-		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
-		echo "*** I have the capability to make that library automatically link in when"
-		echo "*** you link to this library.  But I can only do this if you have a"
-		echo "*** shared version of the library, which you do not appear to have"
-		echo "*** because I did check the linker path looking for a file starting"
-		if test -z "$potlib"; then
-		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
-		else
-		  $ECHO "*** with $libname and none of the candidates passed a file format test"
-		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
-		fi
-	      fi
-	      ;;
-	    *)
-	      # Add a -L argument.
-	      func_append newdeplibs " $a_deplib"
-	      ;;
-	    esac
-	  done # Gone through all deplibs.
-	  ;;
-	none | unknown | *)
-	  newdeplibs=
-	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
-	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
-	    for i in $predeps $postdeps; do
-	      # can't use Xsed below, because $i might contain '/'
-	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
-	    done
-	  fi
-	  case $tmp_deplibs in
-	  *[!\	\ ]*)
-	    echo
-	    if test none = "$deplibs_check_method"; then
-	      echo "*** Warning: inter-library dependencies are not supported in this platform."
-	    else
-	      echo "*** Warning: inter-library dependencies are not known to be supported."
-	    fi
-	    echo "*** All declared inter-library dependencies are being dropped."
-	    droppeddeps=yes
-	    ;;
-	  esac
-	  ;;
-	esac
-	versuffix=$versuffix_save
-	major=$major_save
-	release=$release_save
-	libname=$libname_save
-	name=$name_save
-
-	case $host in
-	*-*-rhapsody* | *-*-darwin1.[012])
-	  # On Rhapsody replace the C library with the System framework
-	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
-	  ;;
-	esac
-
-	if test yes = "$droppeddeps"; then
-	  if test yes = "$module"; then
-	    echo
-	    echo "*** Warning: libtool could not satisfy all declared inter-library"
-	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
-	    echo "*** a static module, that should work as long as the dlopening"
-	    echo "*** application is linked with the -dlopen flag."
-	    if test -z "$global_symbol_pipe"; then
-	      echo
-	      echo "*** However, this would only work if libtool was able to extract symbol"
-	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
-	      echo "*** not find such a program.  So, this module is probably useless."
-	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
-	    fi
-	    if test no = "$build_old_libs"; then
-	      oldlibs=$output_objdir/$libname.$libext
-	      build_libtool_libs=module
-	      build_old_libs=yes
-	    else
-	      build_libtool_libs=no
-	    fi
-	  else
-	    echo "*** The inter-library dependencies that have been dropped here will be"
-	    echo "*** automatically added whenever a program is linked with this library"
-	    echo "*** or is declared to -dlopen it."
-
-	    if test no = "$allow_undefined"; then
-	      echo
-	      echo "*** Since this library must not contain undefined symbols,"
-	      echo "*** because either the platform does not support them or"
-	      echo "*** it was explicitly requested with -no-undefined,"
-	      echo "*** libtool will only create a static version of it."
-	      if test no = "$build_old_libs"; then
-		oldlibs=$output_objdir/$libname.$libext
-		build_libtool_libs=module
-		build_old_libs=yes
-	      else
-		build_libtool_libs=no
-	      fi
-	    fi
-	  fi
-	fi
-	# Done checking deplibs!
-	deplibs=$newdeplibs
-      fi
-      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
-      case $host in
-	*-*-darwin*)
-	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	  ;;
-      esac
-
-      # move library search paths that coincide with paths to not yet
-      # installed libraries to the beginning of the library search list
-      new_libs=
-      for path in $notinst_path; do
-	case " $new_libs " in
-	*" -L$path/$objdir "*) ;;
-	*)
-	  case " $deplibs " in
-	  *" -L$path/$objdir "*)
-	    func_append new_libs " -L$path/$objdir" ;;
-	  esac
-	  ;;
-	esac
-      done
-      for deplib in $deplibs; do
-	case $deplib in
-	-L*)
-	  case " $new_libs " in
-	  *" $deplib "*) ;;
-	  *) func_append new_libs " $deplib" ;;
-	  esac
-	  ;;
-	*) func_append new_libs " $deplib" ;;
-	esac
-      done
-      deplibs=$new_libs
-
-      # All the library-specific variables (install_libdir is set above).
-      library_names=
-      old_library=
-      dlname=
-
-      # Test again, we may have decided not to build it any more
-      if test yes = "$build_libtool_libs"; then
-	# Remove $wl instances when linking with ld.
-	# FIXME: should test the right _cmds variable.
-	case $archive_cmds in
-	  *\$LD\ *) wl= ;;
-        esac
-	if test yes = "$hardcode_into_libs"; then
-	  # Hardcode the library paths
-	  hardcode_libdirs=
-	  dep_rpath=
-	  rpath=$finalize_rpath
-	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
-	  for libdir in $rpath; do
-	    if test -n "$hardcode_libdir_flag_spec"; then
-	      if test -n "$hardcode_libdir_separator"; then
-		func_replace_sysroot "$libdir"
-		libdir=$func_replace_sysroot_result
-		if test -z "$hardcode_libdirs"; then
-		  hardcode_libdirs=$libdir
-		else
-		  # Just accumulate the unique libdirs.
-		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
-		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
-		    ;;
-		  *)
-		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
-		    ;;
-		  esac
-		fi
-	      else
-		eval flag=\"$hardcode_libdir_flag_spec\"
-		func_append dep_rpath " $flag"
-	      fi
-	    elif test -n "$runpath_var"; then
-	      case "$perm_rpath " in
-	      *" $libdir "*) ;;
-	      *) func_append perm_rpath " $libdir" ;;
-	      esac
-	    fi
-	  done
-	  # Substitute the hardcoded libdirs into the rpath.
-	  if test -n "$hardcode_libdir_separator" &&
-	     test -n "$hardcode_libdirs"; then
-	    libdir=$hardcode_libdirs
-	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
-	  fi
-	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
-	    # We should set the runpath_var.
-	    rpath=
-	    for dir in $perm_rpath; do
-	      func_append rpath "$dir:"
-	    done
-	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
-	  fi
-	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
-	fi
-
-	shlibpath=$finalize_shlibpath
-	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
-	if test -n "$shlibpath"; then
-	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
-	fi
-
-	# Get the real and link names of the library.
-	eval shared_ext=\"$shrext_cmds\"
-	eval library_names=\"$library_names_spec\"
-	set dummy $library_names
-	shift
-	realname=$1
-	shift
-
-	if test -n "$soname_spec"; then
-	  eval soname=\"$soname_spec\"
-	else
-	  soname=$realname
-	fi
-	if test -z "$dlname"; then
-	  dlname=$soname
-	fi
-
-	lib=$output_objdir/$realname
-	linknames=
-	for link
-	do
-	  func_append linknames " $link"
-	done
-
-	# Use standard objects if they are pic
-	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
-	test "X$libobjs" = "X " && libobjs=
-
-	delfiles=
-	if test -n "$export_symbols" && test -n "$include_expsyms"; then
-	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
-	  export_symbols=$output_objdir/$libname.uexp
-	  func_append delfiles " $export_symbols"
-	fi
-
-	orig_export_symbols=
-	case $host_os in
-	cygwin* | mingw* | cegcc*)
-	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
-	    # exporting using user supplied symfile
-	    func_dll_def_p "$export_symbols" || {
-	      # and it's NOT already a .def file. Must figure out
-	      # which of the given symbols are data symbols and tag
-	      # them as such. So, trigger use of export_symbols_cmds.
-	      # export_symbols gets reassigned inside the "prepare
-	      # the list of exported symbols" if statement, so the
-	      # include_expsyms logic still works.
-	      orig_export_symbols=$export_symbols
-	      export_symbols=
-	      always_export_symbols=yes
-	    }
-	  fi
-	  ;;
-	esac
-
-	# Prepare the list of exported symbols
-	if test -z "$export_symbols"; then
-	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
-	    func_verbose "generating symbol list for '$libname.la'"
-	    export_symbols=$output_objdir/$libname.exp
-	    $opt_dry_run || $RM $export_symbols
-	    cmds=$export_symbols_cmds
-	    save_ifs=$IFS; IFS='~'
-	    for cmd1 in $cmds; do
-	      IFS=$save_ifs
-	      # Take the normal branch if the nm_file_list_spec branch
-	      # doesn't work or if tool conversion is not needed.
-	      case $nm_file_list_spec~$to_tool_file_cmd in
-		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
-		  try_normal_branch=yes
-		  eval cmd=\"$cmd1\"
-		  func_len " $cmd"
-		  len=$func_len_result
-		  ;;
-		*)
-		  try_normal_branch=no
-		  ;;
-	      esac
-	      if test yes = "$try_normal_branch" \
-		 && { test "$len" -lt "$max_cmd_len" \
-		      || test "$max_cmd_len" -le -1; }
-	      then
-		func_show_eval "$cmd" 'exit $?'
-		skipped_export=false
-	      elif test -n "$nm_file_list_spec"; then
-		func_basename "$output"
-		output_la=$func_basename_result
-		save_libobjs=$libobjs
-		save_output=$output
-		output=$output_objdir/$output_la.nm
-		func_to_tool_file "$output"
-		libobjs=$nm_file_list_spec$func_to_tool_file_result
-		func_append delfiles " $output"
-		func_verbose "creating $NM input file list: $output"
-		for obj in $save_libobjs; do
-		  func_to_tool_file "$obj"
-		  $ECHO "$func_to_tool_file_result"
-		done > "$output"
-		eval cmd=\"$cmd1\"
-		func_show_eval "$cmd" 'exit $?'
-		output=$save_output
-		libobjs=$save_libobjs
-		skipped_export=false
-	      else
-		# The command line is too long to execute in one step.
-		func_verbose "using reloadable object file for export list..."
-		skipped_export=:
-		# Break out early, otherwise skipped_export may be
-		# set to false by a later but shorter cmd.
-		break
-	      fi
-	    done
-	    IFS=$save_ifs
-	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
-	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
-	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
-	    fi
-	  fi
-	fi
-
-	if test -n "$export_symbols" && test -n "$include_expsyms"; then
-	  tmp_export_symbols=$export_symbols
-	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
-	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
-	fi
-
-	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
-	  # The given exports_symbols file has to be filtered, so filter it.
-	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
-	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
-	  # 's' commands, which not all seds can handle. GNU sed should be fine
-	  # though. Also, the filter scales superlinearly with the number of
-	  # global variables. join(1) would be nice here, but unfortunately
-	  # isn't a blessed tool.
-	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
-	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
-	  export_symbols=$output_objdir/$libname.def
-	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
-	fi
-
-	tmp_deplibs=
-	for test_deplib in $deplibs; do
-	  case " $convenience " in
-	  *" $test_deplib "*) ;;
-	  *)
-	    func_append tmp_deplibs " $test_deplib"
-	    ;;
-	  esac
-	done
-	deplibs=$tmp_deplibs
-
-	if test -n "$convenience"; then
-	  if test -n "$whole_archive_flag_spec" &&
-	    test yes = "$compiler_needs_object" &&
-	    test -z "$libobjs"; then
-	    # extract the archives, so we have objects to list.
-	    # TODO: could optimize this to just extract one archive.
-	    whole_archive_flag_spec=
-	  fi
-	  if test -n "$whole_archive_flag_spec"; then
-	    save_libobjs=$libobjs
-	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
-	    test "X$libobjs" = "X " && libobjs=
-	  else
-	    gentop=$output_objdir/${outputname}x
-	    func_append generated " $gentop"
-
-	    func_extract_archives $gentop $convenience
-	    func_append libobjs " $func_extract_archives_result"
-	    test "X$libobjs" = "X " && libobjs=
-	  fi
-	fi
-
-	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
-	  eval flag=\"$thread_safe_flag_spec\"
-	  func_append linker_flags " $flag"
-	fi
-
-	# Make a backup of the uninstalled library when relinking
-	if test relink = "$opt_mode"; then
-	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
-	fi
-
-	# Do each of the archive commands.
-	if test yes = "$module" && test -n "$module_cmds"; then
-	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
-	    eval test_cmds=\"$module_expsym_cmds\"
-	    cmds=$module_expsym_cmds
-	  else
-	    eval test_cmds=\"$module_cmds\"
-	    cmds=$module_cmds
-	  fi
-	else
-	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
-	    eval test_cmds=\"$archive_expsym_cmds\"
-	    cmds=$archive_expsym_cmds
-	  else
-	    eval test_cmds=\"$archive_cmds\"
-	    cmds=$archive_cmds
-	  fi
-	fi
-
-	if test : != "$skipped_export" &&
-	   func_len " $test_cmds" &&
-	   len=$func_len_result &&
-	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
-	  :
-	else
-	  # The command line is too long to link in one step, link piecewise
-	  # or, if using GNU ld and skipped_export is not :, use a linker
-	  # script.
-
-	  # Save the value of $output and $libobjs because we want to
-	  # use them later.  If we have whole_archive_flag_spec, we
-	  # want to use save_libobjs as it was before
-	  # whole_archive_flag_spec was expanded, because we can't
-	  # assume the linker understands whole_archive_flag_spec.
-	  # This may have to be revisited, in case too many
-	  # convenience libraries get linked in and end up exceeding
-	  # the spec.
-	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
-	    save_libobjs=$libobjs
-	  fi
-	  save_output=$output
-	  func_basename "$output"
-	  output_la=$func_basename_result
-
-	  # Clear the reloadable object creation command queue and
-	  # initialize k to one.
-	  test_cmds=
-	  concat_cmds=
-	  objlist=
-	  last_robj=
-	  k=1
-
-	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
-	    output=$output_objdir/$output_la.lnkscript
-	    func_verbose "creating GNU ld script: $output"
-	    echo 'INPUT (' > $output
-	    for obj in $save_libobjs
-	    do
-	      func_to_tool_file "$obj"
-	      $ECHO "$func_to_tool_file_result" >> $output
-	    done
-	    echo ')' >> $output
-	    func_append delfiles " $output"
-	    func_to_tool_file "$output"
-	    output=$func_to_tool_file_result
-	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
-	    output=$output_objdir/$output_la.lnk
-	    func_verbose "creating linker input file list: $output"
-	    : > $output
-	    set x $save_libobjs
-	    shift
-	    firstobj=
-	    if test yes = "$compiler_needs_object"; then
-	      firstobj="$1 "
-	      shift
-	    fi
-	    for obj
-	    do
-	      func_to_tool_file "$obj"
-	      $ECHO "$func_to_tool_file_result" >> $output
-	    done
-	    func_append delfiles " $output"
-	    func_to_tool_file "$output"
-	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
-	  else
-	    if test -n "$save_libobjs"; then
-	      func_verbose "creating reloadable object files..."
-	      output=$output_objdir/$output_la-$k.$objext
-	      eval test_cmds=\"$reload_cmds\"
-	      func_len " $test_cmds"
-	      len0=$func_len_result
-	      len=$len0
-
-	      # Loop over the list of objects to be linked.
-	      for obj in $save_libobjs
-	      do
-		func_len " $obj"
-		func_arith $len + $func_len_result
-		len=$func_arith_result
-		if test -z "$objlist" ||
-		   test "$len" -lt "$max_cmd_len"; then
-		  func_append objlist " $obj"
-		else
-		  # The command $test_cmds is almost too long, add a
-		  # command to the queue.
-		  if test 1 -eq "$k"; then
-		    # The first file doesn't have a previous command to add.
-		    reload_objs=$objlist
-		    eval concat_cmds=\"$reload_cmds\"
-		  else
-		    # All subsequent reloadable object files will link in
-		    # the last one created.
-		    reload_objs="$objlist $last_robj"
-		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
-		  fi
-		  last_robj=$output_objdir/$output_la-$k.$objext
-		  func_arith $k + 1
-		  k=$func_arith_result
-		  output=$output_objdir/$output_la-$k.$objext
-		  objlist=" $obj"
-		  func_len " $last_robj"
-		  func_arith $len0 + $func_len_result
-		  len=$func_arith_result
-		fi
-	      done
-	      # Handle the remaining objects by creating one last
-	      # reloadable object file.  All subsequent reloadable object
-	      # files will link in the last one created.
-	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
-	      reload_objs="$objlist $last_robj"
-	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
-	      if test -n "$last_robj"; then
-	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
-	      fi
-	      func_append delfiles " $output"
-
-	    else
-	      output=
-	    fi
-
-	    ${skipped_export-false} && {
-	      func_verbose "generating symbol list for '$libname.la'"
-	      export_symbols=$output_objdir/$libname.exp
-	      $opt_dry_run || $RM $export_symbols
-	      libobjs=$output
-	      # Append the command to create the export file.
-	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
-	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
-	      if test -n "$last_robj"; then
-		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
-	      fi
-	    }
-
-	    test -n "$save_libobjs" &&
-	      func_verbose "creating a temporary reloadable object file: $output"
-
-	    # Loop through the commands generated above and execute them.
-	    save_ifs=$IFS; IFS='~'
-	    for cmd in $concat_cmds; do
-	      IFS=$save_ifs
-	      $opt_quiet || {
-		  func_quote_for_expand "$cmd"
-		  eval "func_echo $func_quote_for_expand_result"
-	      }
-	      $opt_dry_run || eval "$cmd" || {
-		lt_exit=$?
-
-		# Restore the uninstalled library and exit
-		if test relink = "$opt_mode"; then
-		  ( cd "$output_objdir" && \
-		    $RM "${realname}T" && \
-		    $MV "${realname}U" "$realname" )
-		fi
-
-		exit $lt_exit
-	      }
-	    done
-	    IFS=$save_ifs
-
-	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
-	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
-	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
-	    fi
-	  fi
-
-          ${skipped_export-false} && {
-	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
-	      tmp_export_symbols=$export_symbols
-	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
-	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
-	    fi
-
-	    if test -n "$orig_export_symbols"; then
-	      # The given exports_symbols file has to be filtered, so filter it.
-	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
-	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
-	      # 's' commands, which not all seds can handle. GNU sed should be fine
-	      # though. Also, the filter scales superlinearly with the number of
-	      # global variables. join(1) would be nice here, but unfortunately
-	      # isn't a blessed tool.
-	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
-	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
-	      export_symbols=$output_objdir/$libname.def
-	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
-	    fi
-	  }
-
-	  libobjs=$output
-	  # Restore the value of output.
-	  output=$save_output
-
-	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
-	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
-	    test "X$libobjs" = "X " && libobjs=
-	  fi
-	  # Expand the library linking commands again to reset the
-	  # value of $libobjs for piecewise linking.
-
-	  # Do each of the archive commands.
-	  if test yes = "$module" && test -n "$module_cmds"; then
-	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
-	      cmds=$module_expsym_cmds
-	    else
-	      cmds=$module_cmds
-	    fi
-	  else
-	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
-	      cmds=$archive_expsym_cmds
-	    else
-	      cmds=$archive_cmds
-	    fi
-	  fi
-	fi
-
-	if test -n "$delfiles"; then
-	  # Append the command to remove temporary files to $cmds.
-	  eval cmds=\"\$cmds~\$RM $delfiles\"
-	fi
-
-	# Add any objects from preloaded convenience libraries
-	if test -n "$dlprefiles"; then
-	  gentop=$output_objdir/${outputname}x
-	  func_append generated " $gentop"
-
-	  func_extract_archives $gentop $dlprefiles
-	  func_append libobjs " $func_extract_archives_result"
-	  test "X$libobjs" = "X " && libobjs=
-	fi
-
-	save_ifs=$IFS; IFS='~'
-	for cmd in $cmds; do
-	  IFS=$sp$nl
-	  eval cmd=\"$cmd\"
-	  IFS=$save_ifs
-	  $opt_quiet || {
-	    func_quote_for_expand "$cmd"
-	    eval "func_echo $func_quote_for_expand_result"
-	  }
-	  $opt_dry_run || eval "$cmd" || {
-	    lt_exit=$?
-
-	    # Restore the uninstalled library and exit
-	    if test relink = "$opt_mode"; then
-	      ( cd "$output_objdir" && \
-	        $RM "${realname}T" && \
-		$MV "${realname}U" "$realname" )
-	    fi
-
-	    exit $lt_exit
-	  }
-	done
-	IFS=$save_ifs
-
-	# Restore the uninstalled library and exit
-	if test relink = "$opt_mode"; then
-	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
-
-	  if test -n "$convenience"; then
-	    if test -z "$whole_archive_flag_spec"; then
-	      func_show_eval '${RM}r "$gentop"'
-	    fi
-	  fi
-
-	  exit $EXIT_SUCCESS
-	fi
-
-	# Create links to the real library.
-	for linkname in $linknames; do
-	  if test "$realname" != "$linkname"; then
-	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
-	  fi
-	done
-
-	# If -module or -export-dynamic was specified, set the dlname.
-	if test yes = "$module" || test yes = "$export_dynamic"; then
-	  # On all known operating systems, these are identical.
-	  dlname=$soname
-	fi
-      fi
-      ;;
-
-    obj)
-      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
-	func_warning "'-dlopen' is ignored for objects"
-      fi
-
-      case " $deplibs" in
-      *\ -l* | *\ -L*)
-	func_warning "'-l' and '-L' are ignored for objects" ;;
-      esac
-
-      test -n "$rpath" && \
-	func_warning "'-rpath' is ignored for objects"
-
-      test -n "$xrpath" && \
-	func_warning "'-R' is ignored for objects"
-
-      test -n "$vinfo" && \
-	func_warning "'-version-info' is ignored for objects"
-
-      test -n "$release" && \
-	func_warning "'-release' is ignored for objects"
-
-      case $output in
-      *.lo)
-	test -n "$objs$old_deplibs" && \
-	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
-
-	libobj=$output
-	func_lo2o "$libobj"
-	obj=$func_lo2o_result
-	;;
-      *)
-	libobj=
-	obj=$output
-	;;
-      esac
-
-      # Delete the old objects.
-      $opt_dry_run || $RM $obj $libobj
-
-      # Objects from convenience libraries.  This assumes
-      # single-version convenience libraries.  Whenever we create
-      # different ones for PIC/non-PIC, this we'll have to duplicate
-      # the extraction.
-      reload_conv_objs=
-      gentop=
-      # if reload_cmds runs $LD directly, get rid of -Wl from
-      # whole_archive_flag_spec and hope we can get by with turning comma
-      # into space.
-      case $reload_cmds in
-        *\$LD[\ \$]*) wl= ;;
-      esac
-      if test -n "$convenience"; then
-	if test -n "$whole_archive_flag_spec"; then
-	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
-	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
-	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
-	else
-	  gentop=$output_objdir/${obj}x
-	  func_append generated " $gentop"
-
-	  func_extract_archives $gentop $convenience
-	  reload_conv_objs="$reload_objs $func_extract_archives_result"
-	fi
-      fi
-
-      # If we're not building shared, we need to use non_pic_objs
-      test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
-
-      # Create the old-style object.
-      reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
-
-      output=$obj
-      func_execute_cmds "$reload_cmds" 'exit $?'
-
-      # Exit if we aren't doing a library object file.
-      if test -z "$libobj"; then
-	if test -n "$gentop"; then
-	  func_show_eval '${RM}r "$gentop"'
-	fi
-
-	exit $EXIT_SUCCESS
-      fi
-
-      test yes = "$build_libtool_libs" || {
-	if test -n "$gentop"; then
-	  func_show_eval '${RM}r "$gentop"'
-	fi
-
-	# Create an invalid libtool object if no PIC, so that we don't
-	# accidentally link it into a program.
-	# $show "echo timestamp > $libobj"
-	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
-	exit $EXIT_SUCCESS
-      }
-
-      if test -n "$pic_flag" || test default != "$pic_mode"; then
-	# Only do commands if we really have different PIC objects.
-	reload_objs="$libobjs $reload_conv_objs"
-	output=$libobj
-	func_execute_cmds "$reload_cmds" 'exit $?'
-      fi
-
-      if test -n "$gentop"; then
-	func_show_eval '${RM}r "$gentop"'
-      fi
-
-      exit $EXIT_SUCCESS
-      ;;
-
-    prog)
-      case $host in
-	*cygwin*) func_stripname '' '.exe' "$output"
-	          output=$func_stripname_result.exe;;
-      esac
-      test -n "$vinfo" && \
-	func_warning "'-version-info' is ignored for programs"
-
-      test -n "$release" && \
-	func_warning "'-release' is ignored for programs"
-
-      $preload \
-	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
-	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
-
-      case $host in
-      *-*-rhapsody* | *-*-darwin1.[012])
-	# On Rhapsody replace the C library is the System framework
-	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
-	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
-	;;
-      esac
-
-      case $host in
-      *-*-darwin*)
-	# Don't allow lazy linking, it breaks C++ global constructors
-	# But is supposedly fixed on 10.4 or later (yay!).
-	if test CXX = "$tagname"; then
-	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
-	    10.[0123])
-	      func_append compile_command " $wl-bind_at_load"
-	      func_append finalize_command " $wl-bind_at_load"
-	    ;;
-	  esac
-	fi
-	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
-	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-	;;
-      esac
-
-
-      # move library search paths that coincide with paths to not yet
-      # installed libraries to the beginning of the library search list
-      new_libs=
-      for path in $notinst_path; do
-	case " $new_libs " in
-	*" -L$path/$objdir "*) ;;
-	*)
-	  case " $compile_deplibs " in
-	  *" -L$path/$objdir "*)
-	    func_append new_libs " -L$path/$objdir" ;;
-	  esac
-	  ;;
-	esac
-      done
-      for deplib in $compile_deplibs; do
-	case $deplib in
-	-L*)
-	  case " $new_libs " in
-	  *" $deplib "*) ;;
-	  *) func_append new_libs " $deplib" ;;
-	  esac
-	  ;;
-	*) func_append new_libs " $deplib" ;;
-	esac
-      done
-      compile_deplibs=$new_libs
-
-
-      func_append compile_command " $compile_deplibs"
-      func_append finalize_command " $finalize_deplibs"
-
-      if test -n "$rpath$xrpath"; then
-	# If the user specified any rpath flags, then add them.
-	for libdir in $rpath $xrpath; do
-	  # This is the magic to use -rpath.
-	  case "$finalize_rpath " in
-	  *" $libdir "*) ;;
-	  *) func_append finalize_rpath " $libdir" ;;
-	  esac
-	done
-      fi
-
-      # Now hardcode the library paths
-      rpath=
-      hardcode_libdirs=
-      for libdir in $compile_rpath $finalize_rpath; do
-	if test -n "$hardcode_libdir_flag_spec"; then
-	  if test -n "$hardcode_libdir_separator"; then
-	    if test -z "$hardcode_libdirs"; then
-	      hardcode_libdirs=$libdir
-	    else
-	      # Just accumulate the unique libdirs.
-	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
-	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
-		;;
-	      *)
-		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
-		;;
-	      esac
-	    fi
-	  else
-	    eval flag=\"$hardcode_libdir_flag_spec\"
-	    func_append rpath " $flag"
-	  fi
-	elif test -n "$runpath_var"; then
-	  case "$perm_rpath " in
-	  *" $libdir "*) ;;
-	  *) func_append perm_rpath " $libdir" ;;
-	  esac
-	fi
-	case $host in
-	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
-	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
-	  case :$dllsearchpath: in
-	  *":$libdir:"*) ;;
-	  ::) dllsearchpath=$libdir;;
-	  *) func_append dllsearchpath ":$libdir";;
-	  esac
-	  case :$dllsearchpath: in
-	  *":$testbindir:"*) ;;
-	  ::) dllsearchpath=$testbindir;;
-	  *) func_append dllsearchpath ":$testbindir";;
-	  esac
-	  ;;
-	esac
-      done
-      # Substitute the hardcoded libdirs into the rpath.
-      if test -n "$hardcode_libdir_separator" &&
-	 test -n "$hardcode_libdirs"; then
-	libdir=$hardcode_libdirs
-	eval rpath=\" $hardcode_libdir_flag_spec\"
-      fi
-      compile_rpath=$rpath
-
-      rpath=
-      hardcode_libdirs=
-      for libdir in $finalize_rpath; do
-	if test -n "$hardcode_libdir_flag_spec"; then
-	  if test -n "$hardcode_libdir_separator"; then
-	    if test -z "$hardcode_libdirs"; then
-	      hardcode_libdirs=$libdir
-	    else
-	      # Just accumulate the unique libdirs.
-	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
-	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
-		;;
-	      *)
-		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
-		;;
-	      esac
-	    fi
-	  else
-	    eval flag=\"$hardcode_libdir_flag_spec\"
-	    func_append rpath " $flag"
-	  fi
-	elif test -n "$runpath_var"; then
-	  case "$finalize_perm_rpath " in
-	  *" $libdir "*) ;;
-	  *) func_append finalize_perm_rpath " $libdir" ;;
-	  esac
-	fi
-      done
-      # Substitute the hardcoded libdirs into the rpath.
-      if test -n "$hardcode_libdir_separator" &&
-	 test -n "$hardcode_libdirs"; then
-	libdir=$hardcode_libdirs
-	eval rpath=\" $hardcode_libdir_flag_spec\"
-      fi
-      finalize_rpath=$rpath
-
-      if test -n "$libobjs" && test yes = "$build_old_libs"; then
-	# Transform all the library objects into standard objects.
-	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
-	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
-      fi
-
-      func_generate_dlsyms "$outputname" "@PROGRAM@" false
-
-      # template prelinking step
-      if test -n "$prelink_cmds"; then
-	func_execute_cmds "$prelink_cmds" 'exit $?'
-      fi
-
-      wrappers_required=:
-      case $host in
-      *cegcc* | *mingw32ce*)
-        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
-        wrappers_required=false
-        ;;
-      *cygwin* | *mingw* )
-        test yes = "$build_libtool_libs" || wrappers_required=false
-        ;;
-      *)
-        if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
-          wrappers_required=false
-        fi
-        ;;
-      esac
-      $wrappers_required || {
-	# Replace the output file specification.
-	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
-	link_command=$compile_command$compile_rpath
-
-	# We have no uninstalled library dependencies, so finalize right now.
-	exit_status=0
-	func_show_eval "$link_command" 'exit_status=$?'
-
-	if test -n "$postlink_cmds"; then
-	  func_to_tool_file "$output"
-	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
-	  func_execute_cmds "$postlink_cmds" 'exit $?'
-	fi
-
-	# Delete the generated files.
-	if test -f "$output_objdir/${outputname}S.$objext"; then
-	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
-	fi
-
-	exit $exit_status
-      }
-
-      if test -n "$compile_shlibpath$finalize_shlibpath"; then
-	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
-      fi
-      if test -n "$finalize_shlibpath"; then
-	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
-      fi
-
-      compile_var=
-      finalize_var=
-      if test -n "$runpath_var"; then
-	if test -n "$perm_rpath"; then
-	  # We should set the runpath_var.
-	  rpath=
-	  for dir in $perm_rpath; do
-	    func_append rpath "$dir:"
-	  done
-	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
-	fi
-	if test -n "$finalize_perm_rpath"; then
-	  # We should set the runpath_var.
-	  rpath=
-	  for dir in $finalize_perm_rpath; do
-	    func_append rpath "$dir:"
-	  done
-	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
-	fi
-      fi
-
-      if test yes = "$no_install"; then
-	# We don't need to create a wrapper script.
-	link_command=$compile_var$compile_command$compile_rpath
-	# Replace the output file specification.
-	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
-	# Delete the old output file.
-	$opt_dry_run || $RM $output
-	# Link the executable and exit
-	func_show_eval "$link_command" 'exit $?'
-
-	if test -n "$postlink_cmds"; then
-	  func_to_tool_file "$output"
-	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
-	  func_execute_cmds "$postlink_cmds" 'exit $?'
-	fi
-
-	exit $EXIT_SUCCESS
-      fi
-
-      case $hardcode_action,$fast_install in
-        relink,*)
-	  # Fast installation is not supported
-	  link_command=$compile_var$compile_command$compile_rpath
-	  relink_command=$finalize_var$finalize_command$finalize_rpath
-
-	  func_warning "this platform does not like uninstalled shared libraries"
-	  func_warning "'$output' will be relinked during installation"
-	  ;;
-        *,yes)
-	  link_command=$finalize_var$compile_command$finalize_rpath
-	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
-          ;;
-	*,no)
-	  link_command=$compile_var$compile_command$compile_rpath
-	  relink_command=$finalize_var$finalize_command$finalize_rpath
-          ;;
-	*,needless)
-	  link_command=$finalize_var$compile_command$finalize_rpath
-	  relink_command=
-          ;;
-      esac
-
-      # Replace the output file specification.
-      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
-
-      # Delete the old output files.
-      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
-
-      func_show_eval "$link_command" 'exit $?'
-
-      if test -n "$postlink_cmds"; then
-	func_to_tool_file "$output_objdir/$outputname"
-	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
-	func_execute_cmds "$postlink_cmds" 'exit $?'
-      fi
-
-      # Now create the wrapper script.
-      func_verbose "creating $output"
-
-      # Quote the relink command for shipping.
-      if test -n "$relink_command"; then
-	# Preserve any variables that may affect compiler behavior
-	for var in $variables_saved_for_relink; do
-	  if eval test -z \"\${$var+set}\"; then
-	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
-	  elif eval var_value=\$$var; test -z "$var_value"; then
-	    relink_command="$var=; export $var; $relink_command"
-	  else
-	    func_quote_for_eval "$var_value"
-	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
-	  fi
-	done
-	relink_command="(cd `pwd`; $relink_command)"
-	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
-      fi
-
-      # Only actually do things if not in dry run mode.
-      $opt_dry_run || {
-	# win32 will think the script is a binary if it has
-	# a .exe suffix, so we strip it off here.
-	case $output in
-	  *.exe) func_stripname '' '.exe' "$output"
-	         output=$func_stripname_result ;;
-	esac
-	# test for cygwin because mv fails w/o .exe extensions
-	case $host in
-	  *cygwin*)
-	    exeext=.exe
-	    func_stripname '' '.exe' "$outputname"
-	    outputname=$func_stripname_result ;;
-	  *) exeext= ;;
-	esac
-	case $host in
-	  *cygwin* | *mingw* )
-	    func_dirname_and_basename "$output" "" "."
-	    output_name=$func_basename_result
-	    output_path=$func_dirname_result
-	    cwrappersource=$output_path/$objdir/lt-$output_name.c
-	    cwrapper=$output_path/$output_name.exe
-	    $RM $cwrappersource $cwrapper
-	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
-
-	    func_emit_cwrapperexe_src > $cwrappersource
-
-	    # The wrapper executable is built using the $host compiler,
-	    # because it contains $host paths and files. If cross-
-	    # compiling, it, like the target executable, must be
-	    # executed on the $host or under an emulation environment.
-	    $opt_dry_run || {
-	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
-	      $STRIP $cwrapper
-	    }
-
-	    # Now, create the wrapper script for func_source use:
-	    func_ltwrapper_scriptname $cwrapper
-	    $RM $func_ltwrapper_scriptname_result
-	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
-	    $opt_dry_run || {
-	      # note: this script will not be executed, so do not chmod.
-	      if test "x$build" = "x$host"; then
-		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
-	      else
-		func_emit_wrapper no > $func_ltwrapper_scriptname_result
-	      fi
-	    }
-	  ;;
-	  * )
-	    $RM $output
-	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
-
-	    func_emit_wrapper no > $output
-	    chmod +x $output
-	  ;;
-	esac
-      }
-      exit $EXIT_SUCCESS
-      ;;
-    esac
-
-    # See if we need to build an old-fashioned archive.
-    for oldlib in $oldlibs; do
-
-      case $build_libtool_libs in
-        convenience)
-	  oldobjs="$libobjs_save $symfileobj"
-	  addlibs=$convenience
-	  build_libtool_libs=no
-	  ;;
-	module)
-	  oldobjs=$libobjs_save
-	  addlibs=$old_convenience
-	  build_libtool_libs=no
-          ;;
-	*)
-	  oldobjs="$old_deplibs $non_pic_objects"
-	  $preload && test -f "$symfileobj" \
-	    && func_append oldobjs " $symfileobj"
-	  addlibs=$old_convenience
-	  ;;
-      esac
-
-      if test -n "$addlibs"; then
-	gentop=$output_objdir/${outputname}x
-	func_append generated " $gentop"
-
-	func_extract_archives $gentop $addlibs
-	func_append oldobjs " $func_extract_archives_result"
-      fi
-
-      # Do each command in the archive commands.
-      if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
-	cmds=$old_archive_from_new_cmds
-      else
-
-	# Add any objects from preloaded convenience libraries
-	if test -n "$dlprefiles"; then
-	  gentop=$output_objdir/${outputname}x
-	  func_append generated " $gentop"
-
-	  func_extract_archives $gentop $dlprefiles
-	  func_append oldobjs " $func_extract_archives_result"
-	fi
-
-	# POSIX demands no paths to be encoded in archives.  We have
-	# to avoid creating archives with duplicate basenames if we
-	# might have to extract them afterwards, e.g., when creating a
-	# static archive out of a convenience library, or when linking
-	# the entirety of a libtool archive into another (currently
-	# not supported by libtool).
-	if (for obj in $oldobjs
-	    do
-	      func_basename "$obj"
-	      $ECHO "$func_basename_result"
-	    done | sort | sort -uc >/dev/null 2>&1); then
-	  :
-	else
-	  echo "copying selected object files to avoid basename conflicts..."
-	  gentop=$output_objdir/${outputname}x
-	  func_append generated " $gentop"
-	  func_mkdir_p "$gentop"
-	  save_oldobjs=$oldobjs
-	  oldobjs=
-	  counter=1
-	  for obj in $save_oldobjs
-	  do
-	    func_basename "$obj"
-	    objbase=$func_basename_result
-	    case " $oldobjs " in
-	    " ") oldobjs=$obj ;;
-	    *[\ /]"$objbase "*)
-	      while :; do
-		# Make sure we don't pick an alternate name that also
-		# overlaps.
-		newobj=lt$counter-$objbase
-		func_arith $counter + 1
-		counter=$func_arith_result
-		case " $oldobjs " in
-		*[\ /]"$newobj "*) ;;
-		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
-		esac
-	      done
-	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
-	      func_append oldobjs " $gentop/$newobj"
-	      ;;
-	    *) func_append oldobjs " $obj" ;;
-	    esac
-	  done
-	fi
-	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
-	tool_oldlib=$func_to_tool_file_result
-	eval cmds=\"$old_archive_cmds\"
-
-	func_len " $cmds"
-	len=$func_len_result
-	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
-	  cmds=$old_archive_cmds
-	elif test -n "$archiver_list_spec"; then
-	  func_verbose "using command file archive linking..."
-	  for obj in $oldobjs
-	  do
-	    func_to_tool_file "$obj"
-	    $ECHO "$func_to_tool_file_result"
-	  done > $output_objdir/$libname.libcmd
-	  func_to_tool_file "$output_objdir/$libname.libcmd"
-	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
-	  cmds=$old_archive_cmds
-	else
-	  # the command line is too long to link in one step, link in parts
-	  func_verbose "using piecewise archive linking..."
-	  save_RANLIB=$RANLIB
-	  RANLIB=:
-	  objlist=
-	  concat_cmds=
-	  save_oldobjs=$oldobjs
-	  oldobjs=
-	  # Is there a better way of finding the last object in the list?
-	  for obj in $save_oldobjs
-	  do
-	    last_oldobj=$obj
-	  done
-	  eval test_cmds=\"$old_archive_cmds\"
-	  func_len " $test_cmds"
-	  len0=$func_len_result
-	  len=$len0
-	  for obj in $save_oldobjs
-	  do
-	    func_len " $obj"
-	    func_arith $len + $func_len_result
-	    len=$func_arith_result
-	    func_append objlist " $obj"
-	    if test "$len" -lt "$max_cmd_len"; then
-	      :
-	    else
-	      # the above command should be used before it gets too long
-	      oldobjs=$objlist
-	      if test "$obj" = "$last_oldobj"; then
-		RANLIB=$save_RANLIB
-	      fi
-	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
-	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
-	      objlist=
-	      len=$len0
-	    fi
-	  done
-	  RANLIB=$save_RANLIB
-	  oldobjs=$objlist
-	  if test -z "$oldobjs"; then
-	    eval cmds=\"\$concat_cmds\"
-	  else
-	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
-	  fi
-	fi
-      fi
-      func_execute_cmds "$cmds" 'exit $?'
-    done
-
-    test -n "$generated" && \
-      func_show_eval "${RM}r$generated"
-
-    # Now create the libtool archive.
-    case $output in
-    *.la)
-      old_library=
-      test yes = "$build_old_libs" && old_library=$libname.$libext
-      func_verbose "creating $output"
-
-      # Preserve any variables that may affect compiler behavior
-      for var in $variables_saved_for_relink; do
-	if eval test -z \"\${$var+set}\"; then
-	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
-	elif eval var_value=\$$var; test -z "$var_value"; then
-	  relink_command="$var=; export $var; $relink_command"
-	else
-	  func_quote_for_eval "$var_value"
-	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
-	fi
-      done
-      # Quote the link command for shipping.
-      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
-      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
-      if test yes = "$hardcode_automatic"; then
-	relink_command=
-      fi
-
-      # Only create the output if not a dry run.
-      $opt_dry_run || {
-	for installed in no yes; do
-	  if test yes = "$installed"; then
-	    if test -z "$install_libdir"; then
-	      break
-	    fi
-	    output=$output_objdir/${outputname}i
-	    # Replace all uninstalled libtool libraries with the installed ones
-	    newdependency_libs=
-	    for deplib in $dependency_libs; do
-	      case $deplib in
-	      *.la)
-		func_basename "$deplib"
-		name=$func_basename_result
-		func_resolve_sysroot "$deplib"
-		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
-		test -z "$libdir" && \
-		  func_fatal_error "'$deplib' is not a valid libtool archive"
-		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
-		;;
-	      -L*)
-		func_stripname -L '' "$deplib"
-		func_replace_sysroot "$func_stripname_result"
-		func_append newdependency_libs " -L$func_replace_sysroot_result"
-		;;
-	      -R*)
-		func_stripname -R '' "$deplib"
-		func_replace_sysroot "$func_stripname_result"
-		func_append newdependency_libs " -R$func_replace_sysroot_result"
-		;;
-	      *) func_append newdependency_libs " $deplib" ;;
-	      esac
-	    done
-	    dependency_libs=$newdependency_libs
-	    newdlfiles=
-
-	    for lib in $dlfiles; do
-	      case $lib in
-	      *.la)
-	        func_basename "$lib"
-		name=$func_basename_result
-		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
-		test -z "$libdir" && \
-		  func_fatal_error "'$lib' is not a valid libtool archive"
-		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
-		;;
-	      *) func_append newdlfiles " $lib" ;;
-	      esac
-	    done
-	    dlfiles=$newdlfiles
-	    newdlprefiles=
-	    for lib in $dlprefiles; do
-	      case $lib in
-	      *.la)
-		# Only pass preopened files to the pseudo-archive (for
-		# eventual linking with the app. that links it) if we
-		# didn't already link the preopened objects directly into
-		# the library:
-		func_basename "$lib"
-		name=$func_basename_result
-		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
-		test -z "$libdir" && \
-		  func_fatal_error "'$lib' is not a valid libtool archive"
-		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
-		;;
-	      esac
-	    done
-	    dlprefiles=$newdlprefiles
-	  else
-	    newdlfiles=
-	    for lib in $dlfiles; do
-	      case $lib in
-		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
-		*) abs=`pwd`"/$lib" ;;
-	      esac
-	      func_append newdlfiles " $abs"
-	    done
-	    dlfiles=$newdlfiles
-	    newdlprefiles=
-	    for lib in $dlprefiles; do
-	      case $lib in
-		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
-		*) abs=`pwd`"/$lib" ;;
-	      esac
-	      func_append newdlprefiles " $abs"
-	    done
-	    dlprefiles=$newdlprefiles
-	  fi
-	  $RM $output
-	  # place dlname in correct position for cygwin
-	  # In fact, it would be nice if we could use this code for all target
-	  # systems that can't hard-code library paths into their executables
-	  # and that have no shared library path variable independent of PATH,
-	  # but it turns out we can't easily determine that from inspecting
-	  # libtool variables, so we have to hard-code the OSs to which it
-	  # applies here; at the moment, that means platforms that use the PE
-	  # object format with DLL files.  See the long comment at the top of
-	  # tests/bindir.at for full details.
-	  tdlname=$dlname
-	  case $host,$output,$installed,$module,$dlname in
-	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
-	      # If a -bindir argument was supplied, place the dll there.
-	      if test -n "$bindir"; then
-		func_relative_path "$install_libdir" "$bindir"
-		tdlname=$func_relative_path_result/$dlname
-	      else
-		# Otherwise fall back on heuristic.
-		tdlname=../bin/$dlname
-	      fi
-	      ;;
-	  esac
-	  $ECHO > $output "\
-# $outputname - a libtool library file
-# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
-#
-# Please DO NOT delete this file!
-# It is necessary for linking the library.
-
-# The name that we can dlopen(3).
-dlname='$tdlname'
-
-# Names of this library.
-library_names='$library_names'
-
-# The name of the static archive.
-old_library='$old_library'
-
-# Linker flags that cannot go in dependency_libs.
-inherited_linker_flags='$new_inherited_linker_flags'
-
-# Libraries that this one depends upon.
-dependency_libs='$dependency_libs'
-
-# Names of additional weak libraries provided by this library
-weak_library_names='$weak_libs'
-
-# Version information for $libname.
-current=$current
-age=$age
-revision=$revision
-
-# Is this an already installed library?
-installed=$installed
-
-# Should we warn about portability when linking against -modules?
-shouldnotlink=$module
-
-# Files to dlopen/dlpreopen
-dlopen='$dlfiles'
-dlpreopen='$dlprefiles'
-
-# Directory that this library needs to be installed in:
-libdir='$install_libdir'"
-	  if test no,yes = "$installed,$need_relink"; then
-	    $ECHO >> $output "\
-relink_command=\"$relink_command\""
-	  fi
-	done
-      }
-
-      # Do a symbolic link so that the libtool archive can be found in
-      # LD_LIBRARY_PATH before the program is installed.
-      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
-      ;;
-    esac
-    exit $EXIT_SUCCESS
-}
-
-if test link = "$opt_mode" || test relink = "$opt_mode"; then
-  func_mode_link ${1+"$@"}
-fi
-
-
-# func_mode_uninstall arg...
-func_mode_uninstall ()
-{
-    $debug_cmd
-
-    RM=$nonopt
-    files=
-    rmforce=false
-    exit_status=0
-
-    # This variable tells wrapper scripts just to set variables rather
-    # than running their programs.
-    libtool_install_magic=$magic
-
-    for arg
-    do
-      case $arg in
-      -f) func_append RM " $arg"; rmforce=: ;;
-      -*) func_append RM " $arg" ;;
-      *) func_append files " $arg" ;;
-      esac
-    done
-
-    test -z "$RM" && \
-      func_fatal_help "you must specify an RM program"
-
-    rmdirs=
-
-    for file in $files; do
-      func_dirname "$file" "" "."
-      dir=$func_dirname_result
-      if test . = "$dir"; then
-	odir=$objdir
-      else
-	odir=$dir/$objdir
-      fi
-      func_basename "$file"
-      name=$func_basename_result
-      test uninstall = "$opt_mode" && odir=$dir
-
-      # Remember odir for removal later, being careful to avoid duplicates
-      if test clean = "$opt_mode"; then
-	case " $rmdirs " in
-	  *" $odir "*) ;;
-	  *) func_append rmdirs " $odir" ;;
-	esac
-      fi
-
-      # Don't error if the file doesn't exist and rm -f was used.
-      if { test -L "$file"; } >/dev/null 2>&1 ||
-	 { test -h "$file"; } >/dev/null 2>&1 ||
-	 test -f "$file"; then
-	:
-      elif test -d "$file"; then
-	exit_status=1
-	continue
-      elif $rmforce; then
-	continue
-      fi
-
-      rmfiles=$file
-
-      case $name in
-      *.la)
-	# Possibly a libtool archive, so verify it.
-	if func_lalib_p "$file"; then
-	  func_source $dir/$name
-
-	  # Delete the libtool libraries and symlinks.
-	  for n in $library_names; do
-	    func_append rmfiles " $odir/$n"
-	  done
-	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
-
-	  case $opt_mode in
-	  clean)
-	    case " $library_names " in
-	    *" $dlname "*) ;;
-	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
-	    esac
-	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
-	    ;;
-	  uninstall)
-	    if test -n "$library_names"; then
-	      # Do each command in the postuninstall commands.
-	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
-	    fi
-
-	    if test -n "$old_library"; then
-	      # Do each command in the old_postuninstall commands.
-	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
-	    fi
-	    # FIXME: should reinstall the best remaining shared library.
-	    ;;
-	  esac
-	fi
-	;;
-
-      *.lo)
-	# Possibly a libtool object, so verify it.
-	if func_lalib_p "$file"; then
-
-	  # Read the .lo file
-	  func_source $dir/$name
-
-	  # Add PIC object to the list of files to remove.
-	  if test -n "$pic_object" && test none != "$pic_object"; then
-	    func_append rmfiles " $dir/$pic_object"
-	  fi
-
-	  # Add non-PIC object to the list of files to remove.
-	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
-	    func_append rmfiles " $dir/$non_pic_object"
-	  fi
-	fi
-	;;
-
-      *)
-	if test clean = "$opt_mode"; then
-	  noexename=$name
-	  case $file in
-	  *.exe)
-	    func_stripname '' '.exe' "$file"
-	    file=$func_stripname_result
-	    func_stripname '' '.exe' "$name"
-	    noexename=$func_stripname_result
-	    # $file with .exe has already been added to rmfiles,
-	    # add $file without .exe
-	    func_append rmfiles " $file"
-	    ;;
-	  esac
-	  # Do a test to see if this is a libtool program.
-	  if func_ltwrapper_p "$file"; then
-	    if func_ltwrapper_executable_p "$file"; then
-	      func_ltwrapper_scriptname "$file"
-	      relink_command=
-	      func_source $func_ltwrapper_scriptname_result
-	      func_append rmfiles " $func_ltwrapper_scriptname_result"
-	    else
-	      relink_command=
-	      func_source $dir/$noexename
-	    fi
-
-	    # note $name still contains .exe if it was in $file originally
-	    # as does the version of $file that was added into $rmfiles
-	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
-	    if test yes = "$fast_install" && test -n "$relink_command"; then
-	      func_append rmfiles " $odir/lt-$name"
-	    fi
-	    if test "X$noexename" != "X$name"; then
-	      func_append rmfiles " $odir/lt-$noexename.c"
-	    fi
-	  fi
-	fi
-	;;
-      esac
-      func_show_eval "$RM $rmfiles" 'exit_status=1'
-    done
-
-    # Try to remove the $objdir's in the directories where we deleted files
-    for dir in $rmdirs; do
-      if test -d "$dir"; then
-	func_show_eval "rmdir $dir >/dev/null 2>&1"
-      fi
-    done
-
-    exit $exit_status
-}
-
-if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
-  func_mode_uninstall ${1+"$@"}
-fi
-
-test -z "$opt_mode" && {
-  help=$generic_help
-  func_fatal_help "you must specify a MODE"
-}
-
-test -z "$exec_cmd" && \
-  func_fatal_help "invalid operation mode '$opt_mode'"
-
-if test -n "$exec_cmd"; then
-  eval exec "$exec_cmd"
-  exit $EXIT_FAILURE
-fi
-
-exit $exit_status
-
-
-# The TAGs below are defined such that we never get into a situation
-# where we disable both kinds of libraries.  Given conflicting
-# choices, we go for a static library, that is the most portable,
-# since we can't tell whether shared libraries were disabled because
-# the user asked for that or because the platform doesn't support
-# them.  This is particularly important on AIX, because we don't
-# support having both static and shared libraries enabled at the same
-# time on that platform, so we default to a shared-only configuration.
-# If a disable-shared tag is given, we'll fallback to a static-only
-# configuration.  But we'll never go from static-only to shared-only.
-
-# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
-build_libtool_libs=no
-build_old_libs=yes
-# ### END LIBTOOL TAG CONFIG: disable-shared
-
-# ### BEGIN LIBTOOL TAG CONFIG: disable-static
-build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
-# ### END LIBTOOL TAG CONFIG: disable-static
-
-# Local Variables:
-# mode:shell-script
-# sh-indentation:2
-# End:
diff --git a/libssh2/libssh2/m4/autobuild.m4 b/libssh2/libssh2/m4/autobuild.m4
deleted file mode 100644
index 2f94844e..00000000
--- a/libssh2/libssh2/m4/autobuild.m4
+++ /dev/null
@@ -1,44 +0,0 @@
-# autobuild.m4 serial 3
-# Copyright (C) 2004, 2006 Simon Josefsson
-#
-# This file is free software, distributed under the terms of the GNU
-# General Public License.  As a special exception to the GNU General
-# Public License, this file may be distributed as part of a program
-# that contains a configuration script generated by Autoconf, under
-# the same distribution terms as the rest of that program.
-#
-# This file can can be used in projects which are not available under
-# the GNU General Public License or the GNU Library General Public
-# License but which still want to provide support for Autobuild.
-
-# Usage: AB_INIT([MODE]).
-AC_DEFUN([AB_INIT],
-[
-	AC_REQUIRE([AC_CANONICAL_BUILD])
-	AC_REQUIRE([AC_CANONICAL_HOST])
-
-	if test -z "$AB_PACKAGE"; then
-	   AB_PACKAGE=${PACKAGE_NAME:-$PACKAGE}
-	fi
-	AC_MSG_NOTICE([autobuild project... $AB_PACKAGE])
-
-	if test -z "$AB_VERSION"; then
-	   AB_VERSION=${PACKAGE_VERSION:-$VERSION}
-	fi
-	AC_MSG_NOTICE([autobuild revision... $AB_VERSION])
-
-	hostname=`hostname`
-	if test "$hostname"; then
-	   AC_MSG_NOTICE([autobuild hostname... $hostname])
-	fi
-
-	ifelse([$1],[],,[AC_MSG_NOTICE([autobuild mode... $1])])
-
-	date=`date +%Y%m%d-%H%M%S`
-	if test "$?" != 0; then
-	   date=`date`
-	fi
-	if test "$date"; then
-	   AC_MSG_NOTICE([autobuild timestamp... $date])
-	fi
-])
diff --git a/libssh2/libssh2/m4/lib-ld.m4 b/libssh2/libssh2/m4/lib-ld.m4
deleted file mode 100644
index 96c4e2c3..00000000
--- a/libssh2/libssh2/m4/lib-ld.m4
+++ /dev/null
@@ -1,110 +0,0 @@
-# lib-ld.m4 serial 3 (gettext-0.13)
-dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl Subroutines of libtool.m4,
-dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
-dnl with libtool.m4.
-
-dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.
-AC_DEFUN([AC_LIB_PROG_LD_GNU],
-[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld,
-[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  acl_cv_prog_gnu_ld=yes ;;
-*)
-  acl_cv_prog_gnu_ld=no ;;
-esac])
-with_gnu_ld=$acl_cv_prog_gnu_ld
-])
-
-dnl From libtool-1.4. Sets the variable LD.
-AC_DEFUN([AC_LIB_PROG_LD],
-[AC_ARG_WITH(gnu-ld,
-[  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
-test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_CANONICAL_HOST])dnl
-# Prepare PATH_SEPARATOR.
-# The user is always right.
-if test "${PATH_SEPARATOR+set}" != set; then
-  echo "#! /bin/sh" >conf$$.sh
-  echo  "exit 0"   >>conf$$.sh
-  chmod +x conf$$.sh
-  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
-    PATH_SEPARATOR=';'
-  else
-    PATH_SEPARATOR=:
-  fi
-  rm -f conf$$.sh
-fi
-ac_prog=ld
-if test "$GCC" = yes; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  AC_MSG_CHECKING([for ld used by GCC])
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [[\\/]* | [A-Za-z]:[\\/]*)]
-      [re_direlt='/[^/][^/]*/\.\./']
-      # Canonicalize the path of ld
-      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
-      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD="$ac_prog"
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test "$with_gnu_ld" = yes; then
-  AC_MSG_CHECKING([for GNU ld])
-else
-  AC_MSG_CHECKING([for non-GNU ld])
-fi
-AC_CACHE_VAL(acl_cv_path_LD,
-[if test -z "$LD"; then
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
-  for ac_dir in $PATH; do
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      acl_cv_path_LD="$ac_dir/$ac_prog"
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some GNU ld's only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
-      *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break ;;
-      *)
-	test "$with_gnu_ld" != yes && break ;;
-      esac
-    fi
-  done
-  IFS="$ac_save_ifs"
-else
-  acl_cv_path_LD="$LD" # Let the user override the test with a path.
-fi])
-LD="$acl_cv_path_LD"
-if test -n "$LD"; then
-  AC_MSG_RESULT($LD)
-else
-  AC_MSG_RESULT(no)
-fi
-test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
-AC_LIB_PROG_LD_GNU
-])
diff --git a/libssh2/libssh2/m4/lib-link.m4 b/libssh2/libssh2/m4/lib-link.m4
deleted file mode 100644
index f157d983..00000000
--- a/libssh2/libssh2/m4/lib-link.m4
+++ /dev/null
@@ -1,709 +0,0 @@
-# lib-link.m4 serial 13 (gettext-0.16.2)
-dnl Copyright (C) 2001-2007 Free Software Foundation, Inc.
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl From Bruno Haible.
-
-AC_PREREQ(2.54)
-
-dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
-dnl the libraries corresponding to explicit and implicit dependencies.
-dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
-dnl augments the CPPFLAGS variable.
-dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
-dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
-AC_DEFUN([AC_LIB_LINKFLAGS],
-[
-  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
-  AC_REQUIRE([AC_LIB_RPATH])
-  define([Name],[translit([$1],[./-], [___])])
-  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
-                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
-  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
-    AC_LIB_LINKFLAGS_BODY([$1], [$2])
-    ac_cv_lib[]Name[]_libs="$LIB[]NAME"
-    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
-    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
-    ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
-  ])
-  LIB[]NAME="$ac_cv_lib[]Name[]_libs"
-  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
-  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
-  LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
-  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
-  AC_SUBST([LIB]NAME)
-  AC_SUBST([LTLIB]NAME)
-  AC_SUBST([LIB]NAME[_PREFIX])
-  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
-  dnl results of this search when this library appears as a dependency.
-  HAVE_LIB[]NAME=yes
-  undefine([Name])
-  undefine([NAME])
-])
-
-dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)
-dnl searches for libname and the libraries corresponding to explicit and
-dnl implicit dependencies, together with the specified include files and
-dnl the ability to compile and link the specified testcode. If found, it
-dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
-dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
-dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
-dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
-dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
-dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
-AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
-[
-  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
-  AC_REQUIRE([AC_LIB_RPATH])
-  define([Name],[translit([$1],[./-], [___])])
-  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
-                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
-
-  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
-  dnl accordingly.
-  AC_LIB_LINKFLAGS_BODY([$1], [$2])
-
-  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
-  dnl because if the user has installed lib[]Name and not disabled its use
-  dnl via --without-lib[]Name-prefix, he wants to use it.
-  ac_save_CPPFLAGS="$CPPFLAGS"
-  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
-
-  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
-    ac_save_LIBS="$LIBS"
-    LIBS="$LIBS $LIB[]NAME"
-    AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
-    LIBS="$ac_save_LIBS"
-  ])
-  if test "$ac_cv_lib[]Name" = yes; then
-    HAVE_LIB[]NAME=yes
-    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
-    AC_MSG_CHECKING([how to link with lib[]$1])
-    AC_MSG_RESULT([$LIB[]NAME])
-  else
-    HAVE_LIB[]NAME=no
-    dnl If $LIB[]NAME didn't lead to a usable library, we don't need
-    dnl $INC[]NAME either.
-    CPPFLAGS="$ac_save_CPPFLAGS"
-    LIB[]NAME=
-    LTLIB[]NAME=
-    LIB[]NAME[]_PREFIX=
-  fi
-  AC_SUBST([HAVE_LIB]NAME)
-  AC_SUBST([LIB]NAME)
-  AC_SUBST([LTLIB]NAME)
-  AC_SUBST([LIB]NAME[_PREFIX])
-  undefine([Name])
-  undefine([NAME])
-])
-
-dnl Determine the platform dependent parameters needed to use rpath:
-dnl   acl_libext,
-dnl   acl_shlibext,
-dnl   acl_hardcode_libdir_flag_spec,
-dnl   acl_hardcode_libdir_separator,
-dnl   acl_hardcode_direct,
-dnl   acl_hardcode_minus_L.
-AC_DEFUN([AC_LIB_RPATH],
-[
-  dnl Tell automake >= 1.10 to complain if config.rpath is missing.
-  m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
-  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
-  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
-  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
-  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
-  AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [
-    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
-    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
-    . ./conftest.sh
-    rm -f ./conftest.sh
-    acl_cv_rpath=done
-  ])
-  wl="$acl_cv_wl"
-  acl_libext="$acl_cv_libext"
-  acl_shlibext="$acl_cv_shlibext"
-  acl_libname_spec="$acl_cv_libname_spec"
-  acl_library_names_spec="$acl_cv_library_names_spec"
-  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
-  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
-  acl_hardcode_direct="$acl_cv_hardcode_direct"
-  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
-  dnl Determine whether the user wants rpath handling at all.
-  AC_ARG_ENABLE(rpath,
-    [  --disable-rpath         do not hardcode runtime library paths],
-    :, enable_rpath=yes)
-])
-
-dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
-dnl the libraries corresponding to explicit and implicit dependencies.
-dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
-dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
-dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
-AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
-[
-  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
-  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
-                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
-  dnl Autoconf >= 2.61 supports dots in --with options.
-  define([N_A_M_E],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit([$1],[.],[_])],[$1])])
-  dnl By default, look in $includedir and $libdir.
-  use_additional=yes
-  AC_LIB_WITH_FINAL_PREFIX([
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-  ])
-  AC_LIB_ARG_WITH([lib]N_A_M_E[-prefix],
-[  --with-lib]N_A_M_E[-prefix[=DIR]  search for lib$1 in DIR/include and DIR/lib
-  --without-lib]N_A_M_E[-prefix     don't search for lib$1 in includedir and libdir],
-[
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-        AC_LIB_WITH_FINAL_PREFIX([
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-        ])
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-])
-  dnl Search the library and its dependencies in $additional_libdir and
-  dnl $LDFLAGS. Using breadth-first-seach.
-  LIB[]NAME=
-  LTLIB[]NAME=
-  INC[]NAME=
-  LIB[]NAME[]_PREFIX=
-  rpathdirs=
-  ltrpathdirs=
-  names_already_handled=
-  names_next_round='$1 $2'
-  while test -n "$names_next_round"; do
-    names_this_round="$names_next_round"
-    names_next_round=
-    for name in $names_this_round; do
-      already_handled=
-      for n in $names_already_handled; do
-        if test "$n" = "$name"; then
-          already_handled=yes
-          break
-        fi
-      done
-      if test -z "$already_handled"; then
-        names_already_handled="$names_already_handled $name"
-        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
-        dnl or AC_LIB_HAVE_LINKFLAGS call.
-        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
-        eval value=\"\$HAVE_LIB$uppername\"
-        if test -n "$value"; then
-          if test "$value" = yes; then
-            eval value=\"\$LIB$uppername\"
-            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
-            eval value=\"\$LTLIB$uppername\"
-            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
-          else
-            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
-            dnl that this library doesn't exist. So just drop it.
-            :
-          fi
-        else
-          dnl Search the library lib$name in $additional_libdir and $LDFLAGS
-          dnl and the already constructed $LIBNAME/$LTLIBNAME.
-          found_dir=
-          found_la=
-          found_so=
-          found_a=
-          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
-          if test -n "$acl_shlibext"; then
-            shrext=".$acl_shlibext"             # typically: shrext=.so
-          else
-            shrext=
-          fi
-          if test $use_additional = yes; then
-            dir="$additional_libdir"
-            dnl The same code as in the loop below:
-            dnl First look for a shared library.
-            if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-            dnl Then look for a static library.
-            if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIB[]NAME; do
-              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
-                  dnl First look for a shared library.
-                  if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
-                      found_dir="$dir"
-                      found_so="$dir/$libname$shrext"
-                    else
-                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                        ver=`(cd "$dir" && \
-                              for f in "$libname$shrext".*; do echo "$f"; done \
-                              | sed -e "s,^$libname$shrext\\\\.,," \
-                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                              | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                          found_dir="$dir"
-                          found_so="$dir/$libname$shrext.$ver"
-                        fi
-                      else
-                        eval library_names=\"$acl_library_names_spec\"
-                        for f in $library_names; do
-                          if test -f "$dir/$f"; then
-                            found_dir="$dir"
-                            found_so="$dir/$f"
-                            break
-                          fi
-                        done
-                      fi
-                    fi
-                  fi
-                  dnl Then look for a static library.
-                  if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
-                      found_dir="$dir"
-                      found_a="$dir/$libname.$acl_libext"
-                    fi
-                  fi
-                  if test "X$found_dir" != "X"; then
-                    if test -f "$dir/$libname.la"; then
-                      found_la="$dir/$libname.la"
-                    fi
-                  fi
-                  ;;
-              esac
-              if test "X$found_dir" != "X"; then
-                break
-              fi
-            done
-          fi
-          if test "X$found_dir" != "X"; then
-            dnl Found the library.
-            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
-            if test "X$found_so" != "X"; then
-              dnl Linking with a shared library. We attempt to hardcode its
-              dnl directory into the executable's runpath, unless it's the
-              dnl standard /usr/lib.
-              if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
-                dnl No hardcoding is needed.
-                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
-              else
-                dnl Use an explicit option to hardcode DIR into the resulting
-                dnl binary.
-                dnl Potentially add DIR to ltrpathdirs.
-                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
-                haveit=
-                for x in $ltrpathdirs; do
-                  if test "X$x" = "X$found_dir"; then
-                    haveit=yes
-                    break
-                  fi
-                done
-                if test -z "$haveit"; then
-                  ltrpathdirs="$ltrpathdirs $found_dir"
-                fi
-                dnl The hardcoding into $LIBNAME is system dependent.
-                if test "$acl_hardcode_direct" = yes; then
-                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the
-                  dnl resulting binary.
-                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
-                else
-                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-                    dnl Use an explicit option to hardcode DIR into the resulting
-                    dnl binary.
-                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
-                    dnl Potentially add DIR to rpathdirs.
-                    dnl The rpathdirs will be appended to $LIBNAME at the end.
-                    haveit=
-                    for x in $rpathdirs; do
-                      if test "X$x" = "X$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      rpathdirs="$rpathdirs $found_dir"
-                    fi
-                  else
-                    dnl Rely on "-L$found_dir".
-                    dnl But don't add it if it's already contained in the LDFLAGS
-                    dnl or the already constructed $LIBNAME
-                    haveit=
-                    for x in $LDFLAGS $LIB[]NAME; do
-                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                      if test "X$x" = "X-L$found_dir"; then
-                        haveit=yes
-                        break
-                      fi
-                    done
-                    if test -z "$haveit"; then
-                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
-                    fi
-                    if test "$acl_hardcode_minus_L" != no; then
-                      dnl FIXME: Not sure whether we should use
-                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
-                      dnl here.
-                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
-                    else
-                      dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
-                      dnl here, because this doesn't fit in flags passed to the
-                      dnl compiler. So give up. No hardcoding. This affects only
-                      dnl very old systems.
-                      dnl FIXME: Not sure whether we should use
-                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
-                      dnl here.
-                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
-                    fi
-                  fi
-                fi
-              fi
-            else
-              if test "X$found_a" != "X"; then
-                dnl Linking with a static library.
-                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
-              else
-                dnl We shouldn't come here, but anyway it's good to have a
-                dnl fallback.
-                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
-              fi
-            fi
-            dnl Assume the include files are nearby.
-            additional_includedir=
-            case "$found_dir" in
-              */$acl_libdirstem | */$acl_libdirstem/)
-                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
-                LIB[]NAME[]_PREFIX="$basedir"
-                additional_includedir="$basedir/include"
-                ;;
-            esac
-            if test "X$additional_includedir" != "X"; then
-              dnl Potentially add $additional_includedir to $INCNAME.
-              dnl But don't add it
-              dnl   1. if it's the standard /usr/include,
-              dnl   2. if it's /usr/local/include and we are using GCC on Linux,
-              dnl   3. if it's already present in $CPPFLAGS or the already
-              dnl      constructed $INCNAME,
-              dnl   4. if it doesn't exist as a directory.
-              if test "X$additional_includedir" != "X/usr/include"; then
-                haveit=
-                if test "X$additional_includedir" = "X/usr/local/include"; then
-                  if test -n "$GCC"; then
-                    case $host_os in
-                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                    esac
-                  fi
-                fi
-                if test -z "$haveit"; then
-                  for x in $CPPFLAGS $INC[]NAME; do
-                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                    if test "X$x" = "X-I$additional_includedir"; then
-                      haveit=yes
-                      break
-                    fi
-                  done
-                  if test -z "$haveit"; then
-                    if test -d "$additional_includedir"; then
-                      dnl Really add $additional_includedir to $INCNAME.
-                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
-                    fi
-                  fi
-                fi
-              fi
-            fi
-            dnl Look for dependencies.
-            if test -n "$found_la"; then
-              dnl Read the .la file. It defines the variables
-              dnl dlname, library_names, old_library, dependency_libs, current,
-              dnl age, revision, installed, dlopen, dlpreopen, libdir.
-              save_libdir="$libdir"
-              case "$found_la" in
-                */* | *\\*) . "$found_la" ;;
-                *) . "./$found_la" ;;
-              esac
-              libdir="$save_libdir"
-              dnl We use only dependency_libs.
-              for dep in $dependency_libs; do
-                case "$dep" in
-                  -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
-                    dnl But don't add it
-                    dnl   1. if it's the standard /usr/lib,
-                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
-                    dnl   3. if it's already present in $LDFLAGS or the already
-                    dnl      constructed $LIBNAME,
-                    dnl   4. if it doesn't exist as a directory.
-                    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-                      haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-                        if test -n "$GCC"; then
-                          case $host_os in
-                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-                          esac
-                        fi
-                      fi
-                      if test -z "$haveit"; then
-                        haveit=
-                        for x in $LDFLAGS $LIB[]NAME; do
-                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                            dnl Really add $additional_libdir to $LIBNAME.
-                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
-                          fi
-                        fi
-                        haveit=
-                        for x in $LDFLAGS $LTLIB[]NAME; do
-                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                          if test "X$x" = "X-L$additional_libdir"; then
-                            haveit=yes
-                            break
-                          fi
-                        done
-                        if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                            dnl Really add $additional_libdir to $LTLIBNAME.
-                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
-                          fi
-                        fi
-                      fi
-                    fi
-                    ;;
-                  -R*)
-                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
-                    if test "$enable_rpath" != no; then
-                      dnl Potentially add DIR to rpathdirs.
-                      dnl The rpathdirs will be appended to $LIBNAME at the end.
-                      haveit=
-                      for x in $rpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        rpathdirs="$rpathdirs $dir"
-                      fi
-                      dnl Potentially add DIR to ltrpathdirs.
-                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
-                      haveit=
-                      for x in $ltrpathdirs; do
-                        if test "X$x" = "X$dir"; then
-                          haveit=yes
-                          break
-                        fi
-                      done
-                      if test -z "$haveit"; then
-                        ltrpathdirs="$ltrpathdirs $dir"
-                      fi
-                    fi
-                    ;;
-                  -l*)
-                    dnl Handle this in the next round.
-                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
-                    ;;
-                  *.la)
-                    dnl Handle this in the next round. Throw away the .la's
-                    dnl directory; it is already contained in a preceding -L
-                    dnl option.
-                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
-                    ;;
-                  *)
-                    dnl Most likely an immediate library name.
-                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
-                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
-                    ;;
-                esac
-              done
-            fi
-          else
-            dnl Didn't find the library; assume it is in the system directories
-            dnl known to the linker and runtime loader. (All the system
-            dnl directories known to the linker should also be known to the
-            dnl runtime loader, otherwise the system is severely misconfigured.)
-            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
-            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
-          fi
-        fi
-      fi
-    done
-  done
-  if test "X$rpathdirs" != "X"; then
-    if test -n "$acl_hardcode_libdir_separator"; then
-      dnl Weird platform: only the last -rpath option counts, the user must
-      dnl pass all path elements in one option. We can arrange that for a
-      dnl single library, but not when more than one $LIBNAMEs are used.
-      alldirs=
-      for found_dir in $rpathdirs; do
-        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
-      done
-      dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
-      acl_save_libdir="$libdir"
-      libdir="$alldirs"
-      eval flag=\"$acl_hardcode_libdir_flag_spec\"
-      libdir="$acl_save_libdir"
-      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
-    else
-      dnl The -rpath options are cumulative.
-      for found_dir in $rpathdirs; do
-        acl_save_libdir="$libdir"
-        libdir="$found_dir"
-        eval flag=\"$acl_hardcode_libdir_flag_spec\"
-        libdir="$acl_save_libdir"
-        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
-      done
-    fi
-  fi
-  if test "X$ltrpathdirs" != "X"; then
-    dnl When using libtool, the option that works for both libraries and
-    dnl executables is -R. The -R options are cumulative.
-    for found_dir in $ltrpathdirs; do
-      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
-    done
-  fi
-])
-
-dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
-dnl unless already present in VAR.
-dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
-dnl contains two or three consecutive elements that belong together.
-AC_DEFUN([AC_LIB_APPENDTOVAR],
-[
-  for element in [$2]; do
-    haveit=
-    for x in $[$1]; do
-      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-      if test "X$x" = "X$element"; then
-        haveit=yes
-        break
-      fi
-    done
-    if test -z "$haveit"; then
-      [$1]="${[$1]}${[$1]:+ }$element"
-    fi
-  done
-])
-
-dnl For those cases where a variable contains several -L and -l options
-dnl referring to unknown libraries and directories, this macro determines the
-dnl necessary additional linker options for the runtime path.
-dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
-dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
-dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
-dnl otherwise linking without libtool is assumed.
-AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
-[
-  AC_REQUIRE([AC_LIB_RPATH])
-  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
-  $1=
-  if test "$enable_rpath" != no; then
-    if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
-      dnl Use an explicit option to hardcode directories into the resulting
-      dnl binary.
-      rpathdirs=
-      next=
-      for opt in $2; do
-        if test -n "$next"; then
-          dir="$next"
-          dnl No need to hardcode the standard /usr/lib.
-          if test "X$dir" != "X/usr/$acl_libdirstem"; then
-            rpathdirs="$rpathdirs $dir"
-          fi
-          next=
-        else
-          case $opt in
-            -L) next=yes ;;
-            -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
-                 dnl No need to hardcode the standard /usr/lib.
-                 if test "X$dir" != "X/usr/$acl_libdirstem"; then
-                   rpathdirs="$rpathdirs $dir"
-                 fi
-                 next= ;;
-            *) next= ;;
-          esac
-        fi
-      done
-      if test "X$rpathdirs" != "X"; then
-        if test -n ""$3""; then
-          dnl libtool is used for linking. Use -R options.
-          for dir in $rpathdirs; do
-            $1="${$1}${$1:+ }-R$dir"
-          done
-        else
-          dnl The linker is used for linking directly.
-          if test -n "$acl_hardcode_libdir_separator"; then
-            dnl Weird platform: only the last -rpath option counts, the user
-            dnl must pass all path elements in one option.
-            alldirs=
-            for dir in $rpathdirs; do
-              alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
-            done
-            acl_save_libdir="$libdir"
-            libdir="$alldirs"
-            eval flag=\"$acl_hardcode_libdir_flag_spec\"
-            libdir="$acl_save_libdir"
-            $1="$flag"
-          else
-            dnl The -rpath options are cumulative.
-            for dir in $rpathdirs; do
-              acl_save_libdir="$libdir"
-              libdir="$dir"
-              eval flag=\"$acl_hardcode_libdir_flag_spec\"
-              libdir="$acl_save_libdir"
-              $1="${$1}${$1:+ }$flag"
-            done
-          fi
-        fi
-      fi
-    fi
-  fi
-  AC_SUBST([$1])
-])
diff --git a/libssh2/libssh2/m4/lib-prefix.m4 b/libssh2/libssh2/m4/lib-prefix.m4
deleted file mode 100644
index a8684e17..00000000
--- a/libssh2/libssh2/m4/lib-prefix.m4
+++ /dev/null
@@ -1,185 +0,0 @@
-# lib-prefix.m4 serial 5 (gettext-0.15)
-dnl Copyright (C) 2001-2005 Free Software Foundation, Inc.
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl From Bruno Haible.
-
-dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
-dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
-dnl require excessive bracketing.
-ifdef([AC_HELP_STRING],
-[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
-[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
-
-dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
-dnl to access previously installed libraries. The basic assumption is that
-dnl a user will want packages to use other packages he previously installed
-dnl with the same --prefix option.
-dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
-dnl libraries, but is otherwise very convenient.
-AC_DEFUN([AC_LIB_PREFIX],
-[
-  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
-  AC_REQUIRE([AC_PROG_CC])
-  AC_REQUIRE([AC_CANONICAL_HOST])
-  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
-  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
-  dnl By default, look in $includedir and $libdir.
-  use_additional=yes
-  AC_LIB_WITH_FINAL_PREFIX([
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-  ])
-  AC_LIB_ARG_WITH([lib-prefix],
-[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
-  --without-lib-prefix    don't search for libraries in includedir and libdir],
-[
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-        AC_LIB_WITH_FINAL_PREFIX([
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-        ])
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-])
-  if test $use_additional = yes; then
-    dnl Potentially add $additional_includedir to $CPPFLAGS.
-    dnl But don't add it
-    dnl   1. if it's the standard /usr/include,
-    dnl   2. if it's already present in $CPPFLAGS,
-    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
-    dnl   4. if it doesn't exist as a directory.
-    if test "X$additional_includedir" != "X/usr/include"; then
-      haveit=
-      for x in $CPPFLAGS; do
-        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-        if test "X$x" = "X-I$additional_includedir"; then
-          haveit=yes
-          break
-        fi
-      done
-      if test -z "$haveit"; then
-        if test "X$additional_includedir" = "X/usr/local/include"; then
-          if test -n "$GCC"; then
-            case $host_os in
-              linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-            esac
-          fi
-        fi
-        if test -z "$haveit"; then
-          if test -d "$additional_includedir"; then
-            dnl Really add $additional_includedir to $CPPFLAGS.
-            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
-          fi
-        fi
-      fi
-    fi
-    dnl Potentially add $additional_libdir to $LDFLAGS.
-    dnl But don't add it
-    dnl   1. if it's the standard /usr/lib,
-    dnl   2. if it's already present in $LDFLAGS,
-    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
-    dnl   4. if it doesn't exist as a directory.
-    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-      haveit=
-      for x in $LDFLAGS; do
-        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-        if test "X$x" = "X-L$additional_libdir"; then
-          haveit=yes
-          break
-        fi
-      done
-      if test -z "$haveit"; then
-        if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-          if test -n "$GCC"; then
-            case $host_os in
-              linux*) haveit=yes;;
-            esac
-          fi
-        fi
-        if test -z "$haveit"; then
-          if test -d "$additional_libdir"; then
-            dnl Really add $additional_libdir to $LDFLAGS.
-            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
-          fi
-        fi
-      fi
-    fi
-  fi
-])
-
-dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
-dnl acl_final_exec_prefix, containing the values to which $prefix and
-dnl $exec_prefix will expand at the end of the configure script.
-AC_DEFUN([AC_LIB_PREPARE_PREFIX],
-[
-  dnl Unfortunately, prefix and exec_prefix get only finally determined
-  dnl at the end of configure.
-  if test "X$prefix" = "XNONE"; then
-    acl_final_prefix="$ac_default_prefix"
-  else
-    acl_final_prefix="$prefix"
-  fi
-  if test "X$exec_prefix" = "XNONE"; then
-    acl_final_exec_prefix='${prefix}'
-  else
-    acl_final_exec_prefix="$exec_prefix"
-  fi
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
-  prefix="$acl_save_prefix"
-])
-
-dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
-dnl variables prefix and exec_prefix bound to the values they will have
-dnl at the end of the configure script.
-AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
-[
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  $1
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-])
-
-dnl AC_LIB_PREPARE_MULTILIB creates a variable acl_libdirstem, containing
-dnl the basename of the libdir, either "lib" or "lib64".
-AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
-[
-  dnl There is no formal standard regarding lib and lib64. The current
-  dnl practice is that on a system supporting 32-bit and 64-bit instruction
-  dnl sets or ABIs, 64-bit libraries go under $prefix/lib64 and 32-bit
-  dnl libraries go under $prefix/lib. We determine the compiler's default
-  dnl mode by looking at the compiler's library search path. If at least
-  dnl of its elements ends in /lib64 or points to a directory whose absolute
-  dnl pathname ends in /lib64, we assume a 64-bit ABI. Otherwise we use the
-  dnl default, namely "lib".
-  acl_libdirstem=lib
-  searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
-  if test -n "$searchpath"; then
-    acl_save_IFS="${IFS= 	}"; IFS=":"
-    for searchdir in $searchpath; do
-      if test -d "$searchdir"; then
-        case "$searchdir" in
-          */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
-          *) searchdir=`cd "$searchdir" && pwd`
-             case "$searchdir" in
-               */lib64 ) acl_libdirstem=lib64 ;;
-             esac ;;
-        esac
-      fi
-    done
-    IFS="$acl_save_IFS"
-  fi
-])
diff --git a/libssh2/libssh2/m4/libtool.m4 b/libssh2/libssh2/m4/libtool.m4
deleted file mode 100644
index c4c02946..00000000
--- a/libssh2/libssh2/m4/libtool.m4
+++ /dev/null
@@ -1,8394 +0,0 @@
-# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
-#
-#   Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc.
-#   Written by Gordon Matzigkeit, 1996
-#
-# This file is free software; the Free Software Foundation gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-
-m4_define([_LT_COPYING], [dnl
-# Copyright (C) 2014 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# GNU Libtool is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of of the License, or
-# (at your option) any later version.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program or library that is built
-# using GNU Libtool, you may include this file under the  same
-# distribution terms that you use for the rest of that program.
-#
-# GNU Libtool is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-])
-
-# serial 58 LT_INIT
-
-
-# LT_PREREQ(VERSION)
-# ------------------
-# Complain and exit if this libtool version is less that VERSION.
-m4_defun([LT_PREREQ],
-[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
-       [m4_default([$3],
-		   [m4_fatal([Libtool version $1 or higher is required],
-		             63)])],
-       [$2])])
-
-
-# _LT_CHECK_BUILDDIR
-# ------------------
-# Complain if the absolute build directory name contains unusual characters
-m4_defun([_LT_CHECK_BUILDDIR],
-[case `pwd` in
-  *\ * | *\	*)
-    AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
-esac
-])
-
-
-# LT_INIT([OPTIONS])
-# ------------------
-AC_DEFUN([LT_INIT],
-[AC_PREREQ([2.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK
-AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
-AC_BEFORE([$0], [LT_LANG])dnl
-AC_BEFORE([$0], [LT_OUTPUT])dnl
-AC_BEFORE([$0], [LTDL_INIT])dnl
-m4_require([_LT_CHECK_BUILDDIR])dnl
-
-dnl Autoconf doesn't catch unexpanded LT_ macros by default:
-m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
-m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
-dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
-dnl unless we require an AC_DEFUNed macro:
-AC_REQUIRE([LTOPTIONS_VERSION])dnl
-AC_REQUIRE([LTSUGAR_VERSION])dnl
-AC_REQUIRE([LTVERSION_VERSION])dnl
-AC_REQUIRE([LTOBSOLETE_VERSION])dnl
-m4_require([_LT_PROG_LTMAIN])dnl
-
-_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])
-
-dnl Parse OPTIONS
-_LT_SET_OPTIONS([$0], [$1])
-
-# This can be used to rebuild libtool when needed
-LIBTOOL_DEPS=$ltmain
-
-# Always use our own libtool.
-LIBTOOL='$(SHELL) $(top_builddir)/libtool'
-AC_SUBST(LIBTOOL)dnl
-
-_LT_SETUP
-
-# Only expand once:
-m4_define([LT_INIT])
-])# LT_INIT
-
-# Old names:
-AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
-AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
-dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
-
-
-# _LT_PREPARE_CC_BASENAME
-# -----------------------
-m4_defun([_LT_PREPARE_CC_BASENAME], [
-# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
-func_cc_basename ()
-{
-    for cc_temp in @S|@*""; do
-      case $cc_temp in
-        compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
-        distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
-        \-*) ;;
-        *) break;;
-      esac
-    done
-    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
-}
-])# _LT_PREPARE_CC_BASENAME
-
-
-# _LT_CC_BASENAME(CC)
-# -------------------
-# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME,
-# but that macro is also expanded into generated libtool script, which
-# arranges for $SED and $ECHO to be set by different means.
-m4_defun([_LT_CC_BASENAME],
-[m4_require([_LT_PREPARE_CC_BASENAME])dnl
-AC_REQUIRE([_LT_DECL_SED])dnl
-AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
-func_cc_basename $1
-cc_basename=$func_cc_basename_result
-])
-
-
-# _LT_FILEUTILS_DEFAULTS
-# ----------------------
-# It is okay to use these file commands and assume they have been set
-# sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'.
-m4_defun([_LT_FILEUTILS_DEFAULTS],
-[: ${CP="cp -f"}
-: ${MV="mv -f"}
-: ${RM="rm -f"}
-])# _LT_FILEUTILS_DEFAULTS
-
-
-# _LT_SETUP
-# ---------
-m4_defun([_LT_SETUP],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl
-AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
-
-_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl
-dnl
-_LT_DECL([], [host_alias], [0], [The host system])dnl
-_LT_DECL([], [host], [0])dnl
-_LT_DECL([], [host_os], [0])dnl
-dnl
-_LT_DECL([], [build_alias], [0], [The build system])dnl
-_LT_DECL([], [build], [0])dnl
-_LT_DECL([], [build_os], [0])dnl
-dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([LT_PATH_LD])dnl
-AC_REQUIRE([LT_PATH_NM])dnl
-dnl
-AC_REQUIRE([AC_PROG_LN_S])dnl
-test -z "$LN_S" && LN_S="ln -s"
-_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
-dnl
-AC_REQUIRE([LT_CMD_MAX_LEN])dnl
-_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
-_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
-dnl
-m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_CHECK_SHELL_FEATURES])dnl
-m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl
-m4_require([_LT_CMD_RELOAD])dnl
-m4_require([_LT_CHECK_MAGIC_METHOD])dnl
-m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
-m4_require([_LT_CMD_OLD_ARCHIVE])dnl
-m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
-m4_require([_LT_WITH_SYSROOT])dnl
-m4_require([_LT_CMD_TRUNCATE])dnl
-
-_LT_CONFIG_LIBTOOL_INIT([
-# See if we are running on zsh, and set the options that allow our
-# commands through without removal of \ escapes INIT.
-if test -n "\${ZSH_VERSION+set}"; then
-   setopt NO_GLOB_SUBST
-fi
-])
-if test -n "${ZSH_VERSION+set}"; then
-   setopt NO_GLOB_SUBST
-fi
-
-_LT_CHECK_OBJDIR
-
-m4_require([_LT_TAG_COMPILER])dnl
-
-case $host_os in
-aix3*)
-  # AIX sometimes has problems with the GCC collect2 program.  For some
-  # reason, if we set the COLLECT_NAMES environment variable, the problems
-  # vanish in a puff of smoke.
-  if test set != "${COLLECT_NAMES+set}"; then
-    COLLECT_NAMES=
-    export COLLECT_NAMES
-  fi
-  ;;
-esac
-
-# Global variables:
-ofile=libtool
-can_build_shared=yes
-
-# All known linkers require a '.a' archive for static linking (except MSVC,
-# which needs '.lib').
-libext=a
-
-with_gnu_ld=$lt_cv_prog_gnu_ld
-
-old_CC=$CC
-old_CFLAGS=$CFLAGS
-
-# Set sane defaults for various variables
-test -z "$CC" && CC=cc
-test -z "$LTCC" && LTCC=$CC
-test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
-test -z "$LD" && LD=ld
-test -z "$ac_objext" && ac_objext=o
-
-_LT_CC_BASENAME([$compiler])
-
-# Only perform the check for file, if the check method requires it
-test -z "$MAGIC_CMD" && MAGIC_CMD=file
-case $deplibs_check_method in
-file_magic*)
-  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
-    _LT_PATH_MAGIC
-  fi
-  ;;
-esac
-
-# Use C for the default configuration in the libtool script
-LT_SUPPORTED_TAG([CC])
-_LT_LANG_C_CONFIG
-_LT_LANG_DEFAULT_CONFIG
-_LT_CONFIG_COMMANDS
-])# _LT_SETUP
-
-
-# _LT_PREPARE_SED_QUOTE_VARS
-# --------------------------
-# Define a few sed substitution that help us do robust quoting.
-m4_defun([_LT_PREPARE_SED_QUOTE_VARS],
-[# Backslashify metacharacters that are still active within
-# double-quoted strings.
-sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
-
-# Same as above, but do not quote variable references.
-double_quote_subst='s/\([["`\\]]\)/\\\1/g'
-
-# Sed substitution to delay expansion of an escaped shell variable in a
-# double_quote_subst'ed string.
-delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
-
-# Sed substitution to delay expansion of an escaped single quote.
-delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
-
-# Sed substitution to avoid accidental globbing in evaled expressions
-no_glob_subst='s/\*/\\\*/g'
-])
-
-# _LT_PROG_LTMAIN
-# ---------------
-# Note that this code is called both from 'configure', and 'config.status'
-# now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
-# 'config.status' has no value for ac_aux_dir unless we are using Automake,
-# so we pass a copy along to make sure it has a sensible value anyway.
-m4_defun([_LT_PROG_LTMAIN],
-[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
-_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
-ltmain=$ac_aux_dir/ltmain.sh
-])# _LT_PROG_LTMAIN
-
-
-## ------------------------------------- ##
-## Accumulate code for creating libtool. ##
-## ------------------------------------- ##
-
-# So that we can recreate a full libtool script including additional
-# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
-# in macros and then make a single call at the end using the 'libtool'
-# label.
-
-
-# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
-# ----------------------------------------
-# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
-m4_define([_LT_CONFIG_LIBTOOL_INIT],
-[m4_ifval([$1],
-          [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
-                     [$1
-])])])
-
-# Initialize.
-m4_define([_LT_OUTPUT_LIBTOOL_INIT])
-
-
-# _LT_CONFIG_LIBTOOL([COMMANDS])
-# ------------------------------
-# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
-m4_define([_LT_CONFIG_LIBTOOL],
-[m4_ifval([$1],
-          [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
-                     [$1
-])])])
-
-# Initialize.
-m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
-
-
-# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
-# -----------------------------------------------------
-m4_defun([_LT_CONFIG_SAVE_COMMANDS],
-[_LT_CONFIG_LIBTOOL([$1])
-_LT_CONFIG_LIBTOOL_INIT([$2])
-])
-
-
-# _LT_FORMAT_COMMENT([COMMENT])
-# -----------------------------
-# Add leading comment marks to the start of each line, and a trailing
-# full-stop to the whole comment if one is not present already.
-m4_define([_LT_FORMAT_COMMENT],
-[m4_ifval([$1], [
-m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
-              [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
-)])
-
-
-
-## ------------------------ ##
-## FIXME: Eliminate VARNAME ##
-## ------------------------ ##
-
-
-# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
-# -------------------------------------------------------------------
-# CONFIGNAME is the name given to the value in the libtool script.
-# VARNAME is the (base) name used in the configure script.
-# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
-# VARNAME.  Any other value will be used directly.
-m4_define([_LT_DECL],
-[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
-    [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
-	[m4_ifval([$1], [$1], [$2])])
-    lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
-    m4_ifval([$4],
-	[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
-    lt_dict_add_subkey([lt_decl_dict], [$2],
-	[tagged?], [m4_ifval([$5], [yes], [no])])])
-])
-
-
-# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
-# --------------------------------------------------------
-m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
-
-
-# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
-# ------------------------------------------------
-m4_define([lt_decl_tag_varnames],
-[_lt_decl_filter([tagged?], [yes], $@)])
-
-
-# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
-# ---------------------------------------------------------
-m4_define([_lt_decl_filter],
-[m4_case([$#],
-  [0], [m4_fatal([$0: too few arguments: $#])],
-  [1], [m4_fatal([$0: too few arguments: $#: $1])],
-  [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
-  [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
-  [lt_dict_filter([lt_decl_dict], $@)])[]dnl
-])
-
-
-# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
-# --------------------------------------------------
-m4_define([lt_decl_quote_varnames],
-[_lt_decl_filter([value], [1], $@)])
-
-
-# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
-# ---------------------------------------------------
-m4_define([lt_decl_dquote_varnames],
-[_lt_decl_filter([value], [2], $@)])
-
-
-# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
-# ---------------------------------------------------
-m4_define([lt_decl_varnames_tagged],
-[m4_assert([$# <= 2])dnl
-_$0(m4_quote(m4_default([$1], [[, ]])),
-    m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
-    m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
-m4_define([_lt_decl_varnames_tagged],
-[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
-
-
-# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
-# ------------------------------------------------
-m4_define([lt_decl_all_varnames],
-[_$0(m4_quote(m4_default([$1], [[, ]])),
-     m4_if([$2], [],
-	   m4_quote(lt_decl_varnames),
-	m4_quote(m4_shift($@))))[]dnl
-])
-m4_define([_lt_decl_all_varnames],
-[lt_join($@, lt_decl_varnames_tagged([$1],
-			lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
-])
-
-
-# _LT_CONFIG_STATUS_DECLARE([VARNAME])
-# ------------------------------------
-# Quote a variable value, and forward it to 'config.status' so that its
-# declaration there will have the same value as in 'configure'.  VARNAME
-# must have a single quote delimited value for this to work.
-m4_define([_LT_CONFIG_STATUS_DECLARE],
-[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])
-
-
-# _LT_CONFIG_STATUS_DECLARATIONS
-# ------------------------------
-# We delimit libtool config variables with single quotes, so when
-# we write them to config.status, we have to be sure to quote all
-# embedded single quotes properly.  In configure, this macro expands
-# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
-#
-#    <var>='`$ECHO "$<var>" | $SED "$delay_single_quote_subst"`'
-m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
-[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
-    [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
-
-
-# _LT_LIBTOOL_TAGS
-# ----------------
-# Output comment and list of tags supported by the script
-m4_defun([_LT_LIBTOOL_TAGS],
-[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
-available_tags='_LT_TAGS'dnl
-])
-
-
-# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
-# -----------------------------------
-# Extract the dictionary values for VARNAME (optionally with TAG) and
-# expand to a commented shell variable setting:
-#
-#    # Some comment about what VAR is for.
-#    visible_name=$lt_internal_name
-m4_define([_LT_LIBTOOL_DECLARE],
-[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
-					   [description])))[]dnl
-m4_pushdef([_libtool_name],
-    m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
-m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
-    [0], [_libtool_name=[$]$1],
-    [1], [_libtool_name=$lt_[]$1],
-    [2], [_libtool_name=$lt_[]$1],
-    [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
-m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
-])
-
-
-# _LT_LIBTOOL_CONFIG_VARS
-# -----------------------
-# Produce commented declarations of non-tagged libtool config variables
-# suitable for insertion in the LIBTOOL CONFIG section of the 'libtool'
-# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
-# section) are produced by _LT_LIBTOOL_TAG_VARS.
-m4_defun([_LT_LIBTOOL_CONFIG_VARS],
-[m4_foreach([_lt_var],
-    m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
-    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
-
-
-# _LT_LIBTOOL_TAG_VARS(TAG)
-# -------------------------
-m4_define([_LT_LIBTOOL_TAG_VARS],
-[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
-    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
-
-
-# _LT_TAGVAR(VARNAME, [TAGNAME])
-# ------------------------------
-m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
-
-
-# _LT_CONFIG_COMMANDS
-# -------------------
-# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
-# variables for single and double quote escaping we saved from calls
-# to _LT_DECL, we can put quote escaped variables declarations
-# into 'config.status', and then the shell code to quote escape them in
-# for loops in 'config.status'.  Finally, any additional code accumulated
-# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
-m4_defun([_LT_CONFIG_COMMANDS],
-[AC_PROVIDE_IFELSE([LT_OUTPUT],
-	dnl If the libtool generation code has been placed in $CONFIG_LT,
-	dnl instead of duplicating it all over again into config.status,
-	dnl then we will have config.status run $CONFIG_LT later, so it
-	dnl needs to know what name is stored there:
-        [AC_CONFIG_COMMANDS([libtool],
-            [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
-    dnl If the libtool generation code is destined for config.status,
-    dnl expand the accumulated commands and init code now:
-    [AC_CONFIG_COMMANDS([libtool],
-        [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
-])#_LT_CONFIG_COMMANDS
-
-
-# Initialize.
-m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
-[
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-
-sed_quote_subst='$sed_quote_subst'
-double_quote_subst='$double_quote_subst'
-delay_variable_subst='$delay_variable_subst'
-_LT_CONFIG_STATUS_DECLARATIONS
-LTCC='$LTCC'
-LTCFLAGS='$LTCFLAGS'
-compiler='$compiler_DEFAULT'
-
-# A function that is used when there is no print builtin or printf.
-func_fallback_echo ()
-{
-  eval 'cat <<_LTECHO_EOF
-\$[]1
-_LTECHO_EOF'
-}
-
-# Quote evaled strings.
-for var in lt_decl_all_varnames([[ \
-]], lt_decl_quote_varnames); do
-    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
-    *[[\\\\\\\`\\"\\\$]]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
-      ;;
-    *)
-      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
-      ;;
-    esac
-done
-
-# Double-quote double-evaled strings.
-for var in lt_decl_all_varnames([[ \
-]], lt_decl_dquote_varnames); do
-    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
-    *[[\\\\\\\`\\"\\\$]]*)
-      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
-      ;;
-    *)
-      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
-      ;;
-    esac
-done
-
-_LT_OUTPUT_LIBTOOL_INIT
-])
-
-# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])
-# ------------------------------------
-# Generate a child script FILE with all initialization necessary to
-# reuse the environment learned by the parent script, and make the
-# file executable.  If COMMENT is supplied, it is inserted after the
-# '#!' sequence but before initialization text begins.  After this
-# macro, additional text can be appended to FILE to form the body of
-# the child script.  The macro ends with non-zero status if the
-# file could not be fully written (such as if the disk is full).
-m4_ifdef([AS_INIT_GENERATED],
-[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],
-[m4_defun([_LT_GENERATED_FILE_INIT],
-[m4_require([AS_PREPARE])]dnl
-[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
-[lt_write_fail=0
-cat >$1 <<_ASEOF || lt_write_fail=1
-#! $SHELL
-# Generated by $as_me.
-$2
-SHELL=\${CONFIG_SHELL-$SHELL}
-export SHELL
-_ASEOF
-cat >>$1 <<\_ASEOF || lt_write_fail=1
-AS_SHELL_SANITIZE
-_AS_PREPARE
-exec AS_MESSAGE_FD>&1
-_ASEOF
-test 0 = "$lt_write_fail" && chmod +x $1[]dnl
-m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT
-
-# LT_OUTPUT
-# ---------
-# This macro allows early generation of the libtool script (before
-# AC_OUTPUT is called), incase it is used in configure for compilation
-# tests.
-AC_DEFUN([LT_OUTPUT],
-[: ${CONFIG_LT=./config.lt}
-AC_MSG_NOTICE([creating $CONFIG_LT])
-_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],
-[# Run this file to recreate a libtool stub with the current configuration.])
-
-cat >>"$CONFIG_LT" <<\_LTEOF
-lt_cl_silent=false
-exec AS_MESSAGE_LOG_FD>>config.log
-{
-  echo
-  AS_BOX([Running $as_me.])
-} >&AS_MESSAGE_LOG_FD
-
-lt_cl_help="\
-'$as_me' creates a local libtool stub from the current configuration,
-for use in further configure time tests before the real libtool is
-generated.
-
-Usage: $[0] [[OPTIONS]]
-
-  -h, --help      print this help, then exit
-  -V, --version   print version number, then exit
-  -q, --quiet     do not print progress messages
-  -d, --debug     don't remove temporary files
-
-Report bugs to <bug-libtool@gnu.org>."
-
-lt_cl_version="\
-m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
-m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
-configured by $[0], generated by m4_PACKAGE_STRING.
-
-Copyright (C) 2011 Free Software Foundation, Inc.
-This config.lt script is free software; the Free Software Foundation
-gives unlimited permision to copy, distribute and modify it."
-
-while test 0 != $[#]
-do
-  case $[1] in
-    --version | --v* | -V )
-      echo "$lt_cl_version"; exit 0 ;;
-    --help | --h* | -h )
-      echo "$lt_cl_help"; exit 0 ;;
-    --debug | --d* | -d )
-      debug=: ;;
-    --quiet | --q* | --silent | --s* | -q )
-      lt_cl_silent=: ;;
-
-    -*) AC_MSG_ERROR([unrecognized option: $[1]
-Try '$[0] --help' for more information.]) ;;
-
-    *) AC_MSG_ERROR([unrecognized argument: $[1]
-Try '$[0] --help' for more information.]) ;;
-  esac
-  shift
-done
-
-if $lt_cl_silent; then
-  exec AS_MESSAGE_FD>/dev/null
-fi
-_LTEOF
-
-cat >>"$CONFIG_LT" <<_LTEOF
-_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
-_LTEOF
-
-cat >>"$CONFIG_LT" <<\_LTEOF
-AC_MSG_NOTICE([creating $ofile])
-_LT_OUTPUT_LIBTOOL_COMMANDS
-AS_EXIT(0)
-_LTEOF
-chmod +x "$CONFIG_LT"
-
-# configure is writing to config.log, but config.lt does its own redirection,
-# appending to config.log, which fails on DOS, as config.log is still kept
-# open by configure.  Here we exec the FD to /dev/null, effectively closing
-# config.log, so it can be properly (re)opened and appended to by config.lt.
-lt_cl_success=:
-test yes = "$silent" &&
-  lt_config_lt_args="$lt_config_lt_args --quiet"
-exec AS_MESSAGE_LOG_FD>/dev/null
-$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
-exec AS_MESSAGE_LOG_FD>>config.log
-$lt_cl_success || AS_EXIT(1)
-])# LT_OUTPUT
-
-
-# _LT_CONFIG(TAG)
-# ---------------
-# If TAG is the built-in tag, create an initial libtool script with a
-# default configuration from the untagged config vars.  Otherwise add code
-# to config.status for appending the configuration named by TAG from the
-# matching tagged config vars.
-m4_defun([_LT_CONFIG],
-[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-_LT_CONFIG_SAVE_COMMANDS([
-  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
-  m4_if(_LT_TAG, [C], [
-    # See if we are running on zsh, and set the options that allow our
-    # commands through without removal of \ escapes.
-    if test -n "${ZSH_VERSION+set}"; then
-      setopt NO_GLOB_SUBST
-    fi
-
-    cfgfile=${ofile}T
-    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
-    $RM "$cfgfile"
-
-    cat <<_LT_EOF >> "$cfgfile"
-#! $SHELL
-# Generated automatically by $as_me ($PACKAGE) $VERSION
-# NOTE: Changes made to this file will be lost: look at ltmain.sh.
-
-# Provide generalized library-building support services.
-# Written by Gordon Matzigkeit, 1996
-
-_LT_COPYING
-_LT_LIBTOOL_TAGS
-
-# Configured defaults for sys_lib_dlsearch_path munging.
-: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
-
-# ### BEGIN LIBTOOL CONFIG
-_LT_LIBTOOL_CONFIG_VARS
-_LT_LIBTOOL_TAG_VARS
-# ### END LIBTOOL CONFIG
-
-_LT_EOF
-
-    cat <<'_LT_EOF' >> "$cfgfile"
-
-# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
-
-_LT_PREPARE_MUNGE_PATH_LIST
-_LT_PREPARE_CC_BASENAME
-
-# ### END FUNCTIONS SHARED WITH CONFIGURE
-
-_LT_EOF
-
-  case $host_os in
-  aix3*)
-    cat <<\_LT_EOF >> "$cfgfile"
-# AIX sometimes has problems with the GCC collect2 program.  For some
-# reason, if we set the COLLECT_NAMES environment variable, the problems
-# vanish in a puff of smoke.
-if test set != "${COLLECT_NAMES+set}"; then
-  COLLECT_NAMES=
-  export COLLECT_NAMES
-fi
-_LT_EOF
-    ;;
-  esac
-
-  _LT_PROG_LTMAIN
-
-  # We use sed instead of cat because bash on DJGPP gets confused if
-  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
-  # text mode, it properly converts lines to CR/LF.  This bash problem
-  # is reportedly fixed, but why not run on old versions too?
-  sed '$q' "$ltmain" >> "$cfgfile" \
-     || (rm -f "$cfgfile"; exit 1)
-
-   mv -f "$cfgfile" "$ofile" ||
-    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
-  chmod +x "$ofile"
-],
-[cat <<_LT_EOF >> "$ofile"
-
-dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
-dnl in a comment (ie after a #).
-# ### BEGIN LIBTOOL TAG CONFIG: $1
-_LT_LIBTOOL_TAG_VARS(_LT_TAG)
-# ### END LIBTOOL TAG CONFIG: $1
-_LT_EOF
-])dnl /m4_if
-],
-[m4_if([$1], [], [
-    PACKAGE='$PACKAGE'
-    VERSION='$VERSION'
-    RM='$RM'
-    ofile='$ofile'], [])
-])dnl /_LT_CONFIG_SAVE_COMMANDS
-])# _LT_CONFIG
-
-
-# LT_SUPPORTED_TAG(TAG)
-# ---------------------
-# Trace this macro to discover what tags are supported by the libtool
-# --tag option, using:
-#    autoconf --trace 'LT_SUPPORTED_TAG:$1'
-AC_DEFUN([LT_SUPPORTED_TAG], [])
-
-
-# C support is built-in for now
-m4_define([_LT_LANG_C_enabled], [])
-m4_define([_LT_TAGS], [])
-
-
-# LT_LANG(LANG)
-# -------------
-# Enable libtool support for the given language if not already enabled.
-AC_DEFUN([LT_LANG],
-[AC_BEFORE([$0], [LT_OUTPUT])dnl
-m4_case([$1],
-  [C],			[_LT_LANG(C)],
-  [C++],		[_LT_LANG(CXX)],
-  [Go],			[_LT_LANG(GO)],
-  [Java],		[_LT_LANG(GCJ)],
-  [Fortran 77],		[_LT_LANG(F77)],
-  [Fortran],		[_LT_LANG(FC)],
-  [Windows Resource],	[_LT_LANG(RC)],
-  [m4_ifdef([_LT_LANG_]$1[_CONFIG],
-    [_LT_LANG($1)],
-    [m4_fatal([$0: unsupported language: "$1"])])])dnl
-])# LT_LANG
-
-
-# _LT_LANG(LANGNAME)
-# ------------------
-m4_defun([_LT_LANG],
-[m4_ifdef([_LT_LANG_]$1[_enabled], [],
-  [LT_SUPPORTED_TAG([$1])dnl
-  m4_append([_LT_TAGS], [$1 ])dnl
-  m4_define([_LT_LANG_]$1[_enabled], [])dnl
-  _LT_LANG_$1_CONFIG($1)])dnl
-])# _LT_LANG
-
-
-m4_ifndef([AC_PROG_GO], [
-############################################################
-# NOTE: This macro has been submitted for inclusion into   #
-#  GNU Autoconf as AC_PROG_GO.  When it is available in    #
-#  a released version of Autoconf we should remove this    #
-#  macro and use it instead.                               #
-############################################################
-m4_defun([AC_PROG_GO],
-[AC_LANG_PUSH(Go)dnl
-AC_ARG_VAR([GOC],     [Go compiler command])dnl
-AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl
-_AC_ARG_VAR_LDFLAGS()dnl
-AC_CHECK_TOOL(GOC, gccgo)
-if test -z "$GOC"; then
-  if test -n "$ac_tool_prefix"; then
-    AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])
-  fi
-fi
-if test -z "$GOC"; then
-  AC_CHECK_PROG(GOC, gccgo, gccgo, false)
-fi
-])#m4_defun
-])#m4_ifndef
-
-
-# _LT_LANG_DEFAULT_CONFIG
-# -----------------------
-m4_defun([_LT_LANG_DEFAULT_CONFIG],
-[AC_PROVIDE_IFELSE([AC_PROG_CXX],
-  [LT_LANG(CXX)],
-  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
-
-AC_PROVIDE_IFELSE([AC_PROG_F77],
-  [LT_LANG(F77)],
-  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
-
-AC_PROVIDE_IFELSE([AC_PROG_FC],
-  [LT_LANG(FC)],
-  [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
-
-dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
-dnl pulling things in needlessly.
-AC_PROVIDE_IFELSE([AC_PROG_GCJ],
-  [LT_LANG(GCJ)],
-  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
-    [LT_LANG(GCJ)],
-    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
-      [LT_LANG(GCJ)],
-      [m4_ifdef([AC_PROG_GCJ],
-	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
-       m4_ifdef([A][M_PROG_GCJ],
-	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
-       m4_ifdef([LT_PROG_GCJ],
-	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
-
-AC_PROVIDE_IFELSE([AC_PROG_GO],
-  [LT_LANG(GO)],
-  [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])
-
-AC_PROVIDE_IFELSE([LT_PROG_RC],
-  [LT_LANG(RC)],
-  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
-])# _LT_LANG_DEFAULT_CONFIG
-
-# Obsolete macros:
-AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
-AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
-AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
-AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
-AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
-dnl AC_DEFUN([AC_LIBTOOL_F77], [])
-dnl AC_DEFUN([AC_LIBTOOL_FC], [])
-dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
-dnl AC_DEFUN([AC_LIBTOOL_RC], [])
-
-
-# _LT_TAG_COMPILER
-# ----------------
-m4_defun([_LT_TAG_COMPILER],
-[AC_REQUIRE([AC_PROG_CC])dnl
-
-_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
-_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
-_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
-_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
-
-# If no C compiler was specified, use CC.
-LTCC=${LTCC-"$CC"}
-
-# If no C compiler flags were specified, use CFLAGS.
-LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
-
-# Allow CC to be a program name with arguments.
-compiler=$CC
-])# _LT_TAG_COMPILER
-
-
-# _LT_COMPILER_BOILERPLATE
-# ------------------------
-# Check for compiler boilerplate output or warnings with
-# the simple compiler test code.
-m4_defun([_LT_COMPILER_BOILERPLATE],
-[m4_require([_LT_DECL_SED])dnl
-ac_outfile=conftest.$ac_objext
-echo "$lt_simple_compile_test_code" >conftest.$ac_ext
-eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_compiler_boilerplate=`cat conftest.err`
-$RM conftest*
-])# _LT_COMPILER_BOILERPLATE
-
-
-# _LT_LINKER_BOILERPLATE
-# ----------------------
-# Check for linker boilerplate output or warnings with
-# the simple link test code.
-m4_defun([_LT_LINKER_BOILERPLATE],
-[m4_require([_LT_DECL_SED])dnl
-ac_outfile=conftest.$ac_objext
-echo "$lt_simple_link_test_code" >conftest.$ac_ext
-eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
-_lt_linker_boilerplate=`cat conftest.err`
-$RM -r conftest*
-])# _LT_LINKER_BOILERPLATE
-
-# _LT_REQUIRED_DARWIN_CHECKS
-# -------------------------
-m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
-  case $host_os in
-    rhapsody* | darwin*)
-    AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
-    AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
-    AC_CHECK_TOOL([LIPO], [lipo], [:])
-    AC_CHECK_TOOL([OTOOL], [otool], [:])
-    AC_CHECK_TOOL([OTOOL64], [otool64], [:])
-    _LT_DECL([], [DSYMUTIL], [1],
-      [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
-    _LT_DECL([], [NMEDIT], [1],
-      [Tool to change global to local symbols on Mac OS X])
-    _LT_DECL([], [LIPO], [1],
-      [Tool to manipulate fat objects and archives on Mac OS X])
-    _LT_DECL([], [OTOOL], [1],
-      [ldd/readelf like tool for Mach-O binaries on Mac OS X])
-    _LT_DECL([], [OTOOL64], [1],
-      [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
-
-    AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
-      [lt_cv_apple_cc_single_mod=no
-      if test -z "$LT_MULTI_MODULE"; then
-	# By default we will add the -single_module flag. You can override
-	# by either setting the environment variable LT_MULTI_MODULE
-	# non-empty at configure time, or by adding -multi_module to the
-	# link flags.
-	rm -rf libconftest.dylib*
-	echo "int foo(void){return 1;}" > conftest.c
-	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
--dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
-	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
-	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
-        _lt_result=$?
-	# If there is a non-empty error log, and "single_module"
-	# appears in it, assume the flag caused a linker warning
-        if test -s conftest.err && $GREP single_module conftest.err; then
-	  cat conftest.err >&AS_MESSAGE_LOG_FD
-	# Otherwise, if the output was created with a 0 exit code from
-	# the compiler, it worked.
-	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
-	  lt_cv_apple_cc_single_mod=yes
-	else
-	  cat conftest.err >&AS_MESSAGE_LOG_FD
-	fi
-	rm -rf libconftest.dylib*
-	rm -f conftest.*
-      fi])
-
-    AC_CACHE_CHECK([for -exported_symbols_list linker flag],
-      [lt_cv_ld_exported_symbols_list],
-      [lt_cv_ld_exported_symbols_list=no
-      save_LDFLAGS=$LDFLAGS
-      echo "_main" > conftest.sym
-      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
-      AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
-	[lt_cv_ld_exported_symbols_list=yes],
-	[lt_cv_ld_exported_symbols_list=no])
-	LDFLAGS=$save_LDFLAGS
-    ])
-
-    AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
-      [lt_cv_ld_force_load=no
-      cat > conftest.c << _LT_EOF
-int forced_loaded() { return 2;}
-_LT_EOF
-      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
-      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
-      echo "$AR cr libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
-      $AR cr libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
-      echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
-      $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
-      cat > conftest.c << _LT_EOF
-int main() { return 0;}
-_LT_EOF
-      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD
-      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
-      _lt_result=$?
-      if test -s conftest.err && $GREP force_load conftest.err; then
-	cat conftest.err >&AS_MESSAGE_LOG_FD
-      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
-	lt_cv_ld_force_load=yes
-      else
-	cat conftest.err >&AS_MESSAGE_LOG_FD
-      fi
-        rm -f conftest.err libconftest.a conftest conftest.c
-        rm -rf conftest.dSYM
-    ])
-    case $host_os in
-    rhapsody* | darwin1.[[012]])
-      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
-    darwin1.*)
-      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[[912]]*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.[[012]][[,.]]*)
-	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-	10.*|11.*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-      esac
-    ;;
-  esac
-    if test yes = "$lt_cv_apple_cc_single_mod"; then
-      _lt_dar_single_mod='$single_module'
-    fi
-    if test yes = "$lt_cv_ld_exported_symbols_list"; then
-      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
-    else
-      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
-    fi
-    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
-      _lt_dsymutil='~$DSYMUTIL $lib || :'
-    else
-      _lt_dsymutil=
-    fi
-    ;;
-  esac
-])
-
-
-# _LT_DARWIN_LINKER_FEATURES([TAG])
-# ---------------------------------
-# Checks for linker and compiler features on darwin
-m4_defun([_LT_DARWIN_LINKER_FEATURES],
-[
-  m4_require([_LT_REQUIRED_DARWIN_CHECKS])
-  _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-  _LT_TAGVAR(hardcode_direct, $1)=no
-  _LT_TAGVAR(hardcode_automatic, $1)=yes
-  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
-  if test yes = "$lt_cv_ld_force_load"; then
-    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
-    m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
-                  [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])
-  else
-    _LT_TAGVAR(whole_archive_flag_spec, $1)=''
-  fi
-  _LT_TAGVAR(link_all_deplibs, $1)=yes
-  _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined
-  case $cc_basename in
-     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
-     *) _lt_dar_can_shared=$GCC ;;
-  esac
-  if test yes = "$_lt_dar_can_shared"; then
-    output_verbose_link_cmd=func_echo_all
-    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
-    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
-    m4_if([$1], [CXX],
-[   if test yes != "$lt_cv_apple_cc_single_mod"; then
-      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
-      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
-    fi
-],[])
-  else
-  _LT_TAGVAR(ld_shlibs, $1)=no
-  fi
-])
-
-# _LT_SYS_MODULE_PATH_AIX([TAGNAME])
-# ----------------------------------
-# Links a minimal program and checks the executable
-# for the system default hardcoded library path. In most cases,
-# this is /usr/lib:/lib, but when the MPI compilers are used
-# the location of the communication and MPI libs are included too.
-# If we don't find anything, use the default library path according
-# to the aix ld manual.
-# Store the results from the different compilers for each TAGNAME.
-# Allow to override them for all tags through lt_cv_aix_libpath.
-m4_defun([_LT_SYS_MODULE_PATH_AIX],
-[m4_require([_LT_DECL_SED])dnl
-if test set = "${lt_cv_aix_libpath+set}"; then
-  aix_libpath=$lt_cv_aix_libpath
-else
-  AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
-  [AC_LINK_IFELSE([AC_LANG_PROGRAM],[
-  lt_aix_libpath_sed='[
-      /Import File Strings/,/^$/ {
-	  /^0/ {
-	      s/^0  *\([^ ]*\) *$/\1/
-	      p
-	  }
-      }]'
-  _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  # Check for a 64-bit object if we didn't find anything.
-  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
-    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
-  fi],[])
-  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
-    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib
-  fi
-  ])
-  aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
-fi
-])# _LT_SYS_MODULE_PATH_AIX
-
-
-# _LT_SHELL_INIT(ARG)
-# -------------------
-m4_define([_LT_SHELL_INIT],
-[m4_divert_text([M4SH-INIT], [$1
-])])# _LT_SHELL_INIT
-
-
-
-# _LT_PROG_ECHO_BACKSLASH
-# -----------------------
-# Find how we can fake an echo command that does not interpret backslash.
-# In particular, with Autoconf 2.60 or later we add some code to the start
-# of the generated configure script that will find a shell with a builtin
-# printf (that we can use as an echo command).
-m4_defun([_LT_PROG_ECHO_BACKSLASH],
-[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
-ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
-
-AC_MSG_CHECKING([how to print strings])
-# Test print first, because it will be a builtin if present.
-if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
-   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='print -r --'
-elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
-  ECHO='printf %s\n'
-else
-  # Use this function as a fallback that always works.
-  func_fallback_echo ()
-  {
-    eval 'cat <<_LTECHO_EOF
-$[]1
-_LTECHO_EOF'
-  }
-  ECHO='func_fallback_echo'
-fi
-
-# func_echo_all arg...
-# Invoke $ECHO with all args, space-separated.
-func_echo_all ()
-{
-    $ECHO "$*"
-}
-
-case $ECHO in
-  printf*) AC_MSG_RESULT([printf]) ;;
-  print*) AC_MSG_RESULT([print -r]) ;;
-  *) AC_MSG_RESULT([cat]) ;;
-esac
-
-m4_ifdef([_AS_DETECT_SUGGESTED],
-[_AS_DETECT_SUGGESTED([
-  test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (
-    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
-    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
-    PATH=/empty FPATH=/empty; export PATH FPATH
-    test "X`printf %s $ECHO`" = "X$ECHO" \
-      || test "X`print -r -- $ECHO`" = "X$ECHO" )])])
-
-_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
-_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
-])# _LT_PROG_ECHO_BACKSLASH
-
-
-# _LT_WITH_SYSROOT
-# ----------------
-AC_DEFUN([_LT_WITH_SYSROOT],
-[AC_MSG_CHECKING([for sysroot])
-AC_ARG_WITH([sysroot],
-[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@],
-  [Search for dependent libraries within DIR (or the compiler's sysroot
-   if not specified).])],
-[], [with_sysroot=no])
-
-dnl lt_sysroot will always be passed unquoted.  We quote it here
-dnl in case the user passed a directory name.
-lt_sysroot=
-case $with_sysroot in #(
- yes)
-   if test yes = "$GCC"; then
-     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
-   fi
-   ;; #(
- /*)
-   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
-   ;; #(
- no|'')
-   ;; #(
- *)
-   AC_MSG_RESULT([$with_sysroot])
-   AC_MSG_ERROR([The sysroot must be an absolute path.])
-   ;;
-esac
-
- AC_MSG_RESULT([${lt_sysroot:-no}])
-_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
-[dependent libraries, and where our libraries should be installed.])])
-
-# _LT_ENABLE_LOCK
-# ---------------
-m4_defun([_LT_ENABLE_LOCK],
-[AC_ARG_ENABLE([libtool-lock],
-  [AS_HELP_STRING([--disable-libtool-lock],
-    [avoid locking (might break parallel builds)])])
-test no = "$enable_libtool_lock" || enable_libtool_lock=yes
-
-# Some flags need to be propagated to the compiler or linker for good
-# libtool support.
-case $host in
-ia64-*-hpux*)
-  # Find out what ABI is being produced by ac_compile, and set mode
-  # options accordingly.
-  echo 'int i;' > conftest.$ac_ext
-  if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.$ac_objext` in
-      *ELF-32*)
-	HPUX_IA64_MODE=32
-	;;
-      *ELF-64*)
-	HPUX_IA64_MODE=64
-	;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-*-*-irix6*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
-  if AC_TRY_EVAL(ac_compile); then
-    if test yes = "$lt_cv_prog_gnu_ld"; then
-      case `/usr/bin/file conftest.$ac_objext` in
-	*32-bit*)
-	  LD="${LD-ld} -melf32bsmip"
-	  ;;
-	*N32*)
-	  LD="${LD-ld} -melf32bmipn32"
-	  ;;
-	*64-bit*)
-	  LD="${LD-ld} -melf64bmip"
-	;;
-      esac
-    else
-      case `/usr/bin/file conftest.$ac_objext` in
-	*32-bit*)
-	  LD="${LD-ld} -32"
-	  ;;
-	*N32*)
-	  LD="${LD-ld} -n32"
-	  ;;
-	*64-bit*)
-	  LD="${LD-ld} -64"
-	  ;;
-      esac
-    fi
-  fi
-  rm -rf conftest*
-  ;;
-
-mips64*-*linux*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
-  if AC_TRY_EVAL(ac_compile); then
-    emul=elf
-    case `/usr/bin/file conftest.$ac_objext` in
-      *32-bit*)
-	emul="${emul}32"
-	;;
-      *64-bit*)
-	emul="${emul}64"
-	;;
-    esac
-    case `/usr/bin/file conftest.$ac_objext` in
-      *MSB*)
-	emul="${emul}btsmip"
-	;;
-      *LSB*)
-	emul="${emul}ltsmip"
-	;;
-    esac
-    case `/usr/bin/file conftest.$ac_objext` in
-      *N32*)
-	emul="${emul}n32"
-	;;
-    esac
-    LD="${LD-ld} -m $emul"
-  fi
-  rm -rf conftest*
-  ;;
-
-x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
-s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.  Note that the listed cases only cover the
-  # situations where additional linker options are needed (such as when
-  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
-  # vice versa); the common cases where no linker options are needed do
-  # not appear in the list.
-  echo 'int i;' > conftest.$ac_ext
-  if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.o` in
-      *32-bit*)
-	case $host in
-	  x86_64-*kfreebsd*-gnu)
-	    LD="${LD-ld} -m elf_i386_fbsd"
-	    ;;
-	  x86_64-*linux*)
-	    case `/usr/bin/file conftest.o` in
-	      *x86-64*)
-		LD="${LD-ld} -m elf32_x86_64"
-		;;
-	      *)
-		LD="${LD-ld} -m elf_i386"
-		;;
-	    esac
-	    ;;
-	  powerpc64le-*linux*)
-	    LD="${LD-ld} -m elf32lppclinux"
-	    ;;
-	  powerpc64-*linux*)
-	    LD="${LD-ld} -m elf32ppclinux"
-	    ;;
-	  s390x-*linux*)
-	    LD="${LD-ld} -m elf_s390"
-	    ;;
-	  sparc64-*linux*)
-	    LD="${LD-ld} -m elf32_sparc"
-	    ;;
-	esac
-	;;
-      *64-bit*)
-	case $host in
-	  x86_64-*kfreebsd*-gnu)
-	    LD="${LD-ld} -m elf_x86_64_fbsd"
-	    ;;
-	  x86_64-*linux*)
-	    LD="${LD-ld} -m elf_x86_64"
-	    ;;
-	  powerpcle-*linux*)
-	    LD="${LD-ld} -m elf64lppc"
-	    ;;
-	  powerpc-*linux*)
-	    LD="${LD-ld} -m elf64ppc"
-	    ;;
-	  s390*-*linux*|s390*-*tpf*)
-	    LD="${LD-ld} -m elf64_s390"
-	    ;;
-	  sparc*-*linux*)
-	    LD="${LD-ld} -m elf64_sparc"
-	    ;;
-	esac
-	;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-
-*-*-sco3.2v5*)
-  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
-  SAVE_CFLAGS=$CFLAGS
-  CFLAGS="$CFLAGS -belf"
-  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
-    [AC_LANG_PUSH(C)
-     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
-     AC_LANG_POP])
-  if test yes != "$lt_cv_cc_needs_belf"; then
-    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
-    CFLAGS=$SAVE_CFLAGS
-  fi
-  ;;
-*-*solaris*)
-  # Find out what ABI is being produced by ac_compile, and set linker
-  # options accordingly.
-  echo 'int i;' > conftest.$ac_ext
-  if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.o` in
-    *64-bit*)
-      case $lt_cv_prog_gnu_ld in
-      yes*)
-        case $host in
-        i?86-*-solaris*|x86_64-*-solaris*)
-          LD="${LD-ld} -m elf_x86_64"
-          ;;
-        sparc*-*-solaris*)
-          LD="${LD-ld} -m elf64_sparc"
-          ;;
-        esac
-        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
-        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
-          LD=${LD-ld}_sol2
-        fi
-        ;;
-      *)
-	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
-	  LD="${LD-ld} -64"
-	fi
-	;;
-      esac
-      ;;
-    esac
-  fi
-  rm -rf conftest*
-  ;;
-esac
-
-need_locks=$enable_libtool_lock
-])# _LT_ENABLE_LOCK
-
-
-# _LT_PROG_AR
-# -----------
-m4_defun([_LT_PROG_AR],
-[AC_CHECK_TOOLS(AR, [ar], false)
-: ${AR=ar}
-: ${AR_FLAGS=cr}
-_LT_DECL([], [AR], [1], [The archiver])
-_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])
-
-AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
-  [lt_cv_ar_at_file=no
-   AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
-     [echo conftest.$ac_objext > conftest.lst
-      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
-      AC_TRY_EVAL([lt_ar_try])
-      if test 0 -eq "$ac_status"; then
-	# Ensure the archiver fails upon bogus file names.
-	rm -f conftest.$ac_objext libconftest.a
-	AC_TRY_EVAL([lt_ar_try])
-	if test 0 -ne "$ac_status"; then
-          lt_cv_ar_at_file=@
-        fi
-      fi
-      rm -f conftest.* libconftest.a
-     ])
-  ])
-
-if test no = "$lt_cv_ar_at_file"; then
-  archiver_list_spec=
-else
-  archiver_list_spec=$lt_cv_ar_at_file
-fi
-_LT_DECL([], [archiver_list_spec], [1],
-  [How to feed a file listing to the archiver])
-])# _LT_PROG_AR
-
-
-# _LT_CMD_OLD_ARCHIVE
-# -------------------
-m4_defun([_LT_CMD_OLD_ARCHIVE],
-[_LT_PROG_AR
-
-AC_CHECK_TOOL(STRIP, strip, :)
-test -z "$STRIP" && STRIP=:
-_LT_DECL([], [STRIP], [1], [A symbol stripping program])
-
-AC_CHECK_TOOL(RANLIB, ranlib, :)
-test -z "$RANLIB" && RANLIB=:
-_LT_DECL([], [RANLIB], [1],
-    [Commands used to install an old-style archive])
-
-# Determine commands to create old-style static archives.
-old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
-old_postinstall_cmds='chmod 644 $oldlib'
-old_postuninstall_cmds=
-
-if test -n "$RANLIB"; then
-  case $host_os in
-  bitrig* | openbsd*)
-    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
-    ;;
-  *)
-    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
-    ;;
-  esac
-  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
-fi
-
-case $host_os in
-  darwin*)
-    lock_old_archive_extraction=yes ;;
-  *)
-    lock_old_archive_extraction=no ;;
-esac
-_LT_DECL([], [old_postinstall_cmds], [2])
-_LT_DECL([], [old_postuninstall_cmds], [2])
-_LT_TAGDECL([], [old_archive_cmds], [2],
-    [Commands used to build an old-style archive])
-_LT_DECL([], [lock_old_archive_extraction], [0],
-    [Whether to use a lock for old archive extraction])
-])# _LT_CMD_OLD_ARCHIVE
-
-
-# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
-#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
-# ----------------------------------------------------------------
-# Check whether the given compiler option works
-AC_DEFUN([_LT_COMPILER_OPTION],
-[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_DECL_SED])dnl
-AC_CACHE_CHECK([$1], [$2],
-  [$2=no
-   m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-   lt_compiler_flag="$3"  ## exclude from sc_useless_quotes_in_assignment
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   # The option is referenced via a variable to avoid confusing sed.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
-   (eval "$lt_compile" 2>conftest.err)
-   ac_status=$?
-   cat conftest.err >&AS_MESSAGE_LOG_FD
-   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
-   if (exit $ac_status) && test -s "$ac_outfile"; then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings other than the usual output.
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
-     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
-       $2=yes
-     fi
-   fi
-   $RM conftest*
-])
-
-if test yes = "[$]$2"; then
-    m4_if([$5], , :, [$5])
-else
-    m4_if([$6], , :, [$6])
-fi
-])# _LT_COMPILER_OPTION
-
-# Old name:
-AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])
-
-
-# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
-#                  [ACTION-SUCCESS], [ACTION-FAILURE])
-# ----------------------------------------------------
-# Check whether the given linker option works
-AC_DEFUN([_LT_LINKER_OPTION],
-[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_DECL_SED])dnl
-AC_CACHE_CHECK([$1], [$2],
-  [$2=no
-   save_LDFLAGS=$LDFLAGS
-   LDFLAGS="$LDFLAGS $3"
-   echo "$lt_simple_link_test_code" > conftest.$ac_ext
-   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
-     # The linker can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     if test -s conftest.err; then
-       # Append any errors to the config.log.
-       cat conftest.err 1>&AS_MESSAGE_LOG_FD
-       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
-       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
-       if diff conftest.exp conftest.er2 >/dev/null; then
-         $2=yes
-       fi
-     else
-       $2=yes
-     fi
-   fi
-   $RM -r conftest*
-   LDFLAGS=$save_LDFLAGS
-])
-
-if test yes = "[$]$2"; then
-    m4_if([$4], , :, [$4])
-else
-    m4_if([$5], , :, [$5])
-fi
-])# _LT_LINKER_OPTION
-
-# Old name:
-AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])
-
-
-# LT_CMD_MAX_LEN
-#---------------
-AC_DEFUN([LT_CMD_MAX_LEN],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-# find the maximum length of command line arguments
-AC_MSG_CHECKING([the maximum length of command line arguments])
-AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
-  i=0
-  teststring=ABCD
-
-  case $build_os in
-  msdosdjgpp*)
-    # On DJGPP, this test can blow up pretty badly due to problems in libc
-    # (any single argument exceeding 2000 bytes causes a buffer overrun
-    # during glob expansion).  Even if it were fixed, the result of this
-    # check would be larger than it should be.
-    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
-    ;;
-
-  gnu*)
-    # Under GNU Hurd, this test is not required because there is
-    # no limit to the length of command line arguments.
-    # Libtool will interpret -1 as no limit whatsoever
-    lt_cv_sys_max_cmd_len=-1;
-    ;;
-
-  cygwin* | mingw* | cegcc*)
-    # On Win9x/ME, this test blows up -- it succeeds, but takes
-    # about 5 minutes as the teststring grows exponentially.
-    # Worse, since 9x/ME are not pre-emptively multitasking,
-    # you end up with a "frozen" computer, even though with patience
-    # the test eventually succeeds (with a max line length of 256k).
-    # Instead, let's just punt: use the minimum linelength reported by
-    # all of the supported platforms: 8192 (on NT/2K/XP).
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  mint*)
-    # On MiNT this can take a long time and run out of memory.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  amigaos*)
-    # On AmigaOS with pdksh, this test takes hours, literally.
-    # So we just punt and use a minimum line length of 8192.
-    lt_cv_sys_max_cmd_len=8192;
-    ;;
-
-  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
-    # This has been around since 386BSD, at least.  Likely further.
-    if test -x /sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
-    elif test -x /usr/sbin/sysctl; then
-      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
-    else
-      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
-    fi
-    # And add a safety zone
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    ;;
-
-  interix*)
-    # We know the value 262144 and hardcode it with a safety zone (like BSD)
-    lt_cv_sys_max_cmd_len=196608
-    ;;
-
-  os2*)
-    # The test takes a long time on OS/2.
-    lt_cv_sys_max_cmd_len=8192
-    ;;
-
-  osf*)
-    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
-    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
-    # nice to cause kernel panics so lets avoid the loop below.
-    # First set a reasonable default.
-    lt_cv_sys_max_cmd_len=16384
-    #
-    if test -x /sbin/sysconfig; then
-      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
-        *1*) lt_cv_sys_max_cmd_len=-1 ;;
-      esac
-    fi
-    ;;
-  sco3.2v5*)
-    lt_cv_sys_max_cmd_len=102400
-    ;;
-  sysv5* | sco5v6* | sysv4.2uw2*)
-    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
-    if test -n "$kargmax"; then
-      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[	 ]]//'`
-    else
-      lt_cv_sys_max_cmd_len=32768
-    fi
-    ;;
-  *)
-    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
-    if test -n "$lt_cv_sys_max_cmd_len" && \
-       test undefined != "$lt_cv_sys_max_cmd_len"; then
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
-    else
-      # Make teststring a little bigger before we do anything with it.
-      # a 1K string should be a reasonable start.
-      for i in 1 2 3 4 5 6 7 8; do
-        teststring=$teststring$teststring
-      done
-      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
-      # If test is not a shell built-in, we'll probably end up computing a
-      # maximum length that is only half of the actual maximum length, but
-      # we can't tell.
-      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
-	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
-	      test 17 != "$i" # 1/2 MB should be enough
-      do
-        i=`expr $i + 1`
-        teststring=$teststring$teststring
-      done
-      # Only check the string length outside the loop.
-      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
-      teststring=
-      # Add a significant safety factor because C++ compilers can tack on
-      # massive amounts of additional arguments before passing them to the
-      # linker.  It appears as though 1/2 is a usable value.
-      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
-    fi
-    ;;
-  esac
-])
-if test -n "$lt_cv_sys_max_cmd_len"; then
-  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
-else
-  AC_MSG_RESULT(none)
-fi
-max_cmd_len=$lt_cv_sys_max_cmd_len
-_LT_DECL([], [max_cmd_len], [0],
-    [What is the maximum length of a command?])
-])# LT_CMD_MAX_LEN
-
-# Old name:
-AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])
-
-
-# _LT_HEADER_DLFCN
-# ----------------
-m4_defun([_LT_HEADER_DLFCN],
-[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
-])# _LT_HEADER_DLFCN
-
-
-# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
-#                      ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
-# ----------------------------------------------------------------
-m4_defun([_LT_TRY_DLOPEN_SELF],
-[m4_require([_LT_HEADER_DLFCN])dnl
-if test yes = "$cross_compiling"; then :
-  [$4]
-else
-  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
-  lt_status=$lt_dlunknown
-  cat > conftest.$ac_ext <<_LT_EOF
-[#line $LINENO "configure"
-#include "confdefs.h"
-
-#if HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-
-#include <stdio.h>
-
-#ifdef RTLD_GLOBAL
-#  define LT_DLGLOBAL		RTLD_GLOBAL
-#else
-#  ifdef DL_GLOBAL
-#    define LT_DLGLOBAL		DL_GLOBAL
-#  else
-#    define LT_DLGLOBAL		0
-#  endif
-#endif
-
-/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
-   find out it does not work in some platform. */
-#ifndef LT_DLLAZY_OR_NOW
-#  ifdef RTLD_LAZY
-#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
-#  else
-#    ifdef DL_LAZY
-#      define LT_DLLAZY_OR_NOW		DL_LAZY
-#    else
-#      ifdef RTLD_NOW
-#        define LT_DLLAZY_OR_NOW	RTLD_NOW
-#      else
-#        ifdef DL_NOW
-#          define LT_DLLAZY_OR_NOW	DL_NOW
-#        else
-#          define LT_DLLAZY_OR_NOW	0
-#        endif
-#      endif
-#    endif
-#  endif
-#endif
-
-/* When -fvisibility=hidden is used, assume the code has been annotated
-   correspondingly for the symbols needed.  */
-#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
-int fnord () __attribute__((visibility("default")));
-#endif
-
-int fnord () { return 42; }
-int main ()
-{
-  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
-  int status = $lt_dlunknown;
-
-  if (self)
-    {
-      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
-      else
-        {
-	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
-          else puts (dlerror ());
-	}
-      /* dlclose (self); */
-    }
-  else
-    puts (dlerror ());
-
-  return status;
-}]
-_LT_EOF
-  if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then
-    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
-    lt_status=$?
-    case x$lt_status in
-      x$lt_dlno_uscore) $1 ;;
-      x$lt_dlneed_uscore) $2 ;;
-      x$lt_dlunknown|x*) $3 ;;
-    esac
-  else :
-    # compilation failed
-    $3
-  fi
-fi
-rm -fr conftest*
-])# _LT_TRY_DLOPEN_SELF
-
-
-# LT_SYS_DLOPEN_SELF
-# ------------------
-AC_DEFUN([LT_SYS_DLOPEN_SELF],
-[m4_require([_LT_HEADER_DLFCN])dnl
-if test yes != "$enable_dlopen"; then
-  enable_dlopen=unknown
-  enable_dlopen_self=unknown
-  enable_dlopen_self_static=unknown
-else
-  lt_cv_dlopen=no
-  lt_cv_dlopen_libs=
-
-  case $host_os in
-  beos*)
-    lt_cv_dlopen=load_add_on
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=yes
-    ;;
-
-  mingw* | pw32* | cegcc*)
-    lt_cv_dlopen=LoadLibrary
-    lt_cv_dlopen_libs=
-    ;;
-
-  cygwin*)
-    lt_cv_dlopen=dlopen
-    lt_cv_dlopen_libs=
-    ;;
-
-  darwin*)
-    # if libdl is installed we need to link against it
-    AC_CHECK_LIB([dl], [dlopen],
-		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[
-    lt_cv_dlopen=dyld
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=yes
-    ])
-    ;;
-
-  tpf*)
-    # Don't try to run any link tests for TPF.  We know it's impossible
-    # because TPF is a cross-compiler, and we know how we open DSOs.
-    lt_cv_dlopen=dlopen
-    lt_cv_dlopen_libs=
-    lt_cv_dlopen_self=no
-    ;;
-
-  *)
-    AC_CHECK_FUNC([shl_load],
-	  [lt_cv_dlopen=shl_load],
-      [AC_CHECK_LIB([dld], [shl_load],
-	    [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld],
-	[AC_CHECK_FUNC([dlopen],
-	      [lt_cv_dlopen=dlopen],
-	  [AC_CHECK_LIB([dl], [dlopen],
-		[lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],
-	    [AC_CHECK_LIB([svld], [dlopen],
-		  [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld],
-	      [AC_CHECK_LIB([dld], [dld_link],
-		    [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld])
-	      ])
-	    ])
-	  ])
-	])
-      ])
-    ;;
-  esac
-
-  if test no = "$lt_cv_dlopen"; then
-    enable_dlopen=no
-  else
-    enable_dlopen=yes
-  fi
-
-  case $lt_cv_dlopen in
-  dlopen)
-    save_CPPFLAGS=$CPPFLAGS
-    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
-
-    save_LDFLAGS=$LDFLAGS
-    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
-
-    save_LIBS=$LIBS
-    LIBS="$lt_cv_dlopen_libs $LIBS"
-
-    AC_CACHE_CHECK([whether a program can dlopen itself],
-	  lt_cv_dlopen_self, [dnl
-	  _LT_TRY_DLOPEN_SELF(
-	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
-	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
-    ])
-
-    if test yes = "$lt_cv_dlopen_self"; then
-      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
-      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
-	  lt_cv_dlopen_self_static, [dnl
-	  _LT_TRY_DLOPEN_SELF(
-	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
-	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
-      ])
-    fi
-
-    CPPFLAGS=$save_CPPFLAGS
-    LDFLAGS=$save_LDFLAGS
-    LIBS=$save_LIBS
-    ;;
-  esac
-
-  case $lt_cv_dlopen_self in
-  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
-  *) enable_dlopen_self=unknown ;;
-  esac
-
-  case $lt_cv_dlopen_self_static in
-  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
-  *) enable_dlopen_self_static=unknown ;;
-  esac
-fi
-_LT_DECL([dlopen_support], [enable_dlopen], [0],
-	 [Whether dlopen is supported])
-_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
-	 [Whether dlopen of programs is supported])
-_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
-	 [Whether dlopen of statically linked programs is supported])
-])# LT_SYS_DLOPEN_SELF
-
-# Old name:
-AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])
-
-
-# _LT_COMPILER_C_O([TAGNAME])
-# ---------------------------
-# Check to see if options -c and -o are simultaneously supported by compiler.
-# This macro does not hard code the compiler like AC_PROG_CC_C_O.
-m4_defun([_LT_COMPILER_C_O],
-[m4_require([_LT_DECL_SED])dnl
-m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_TAG_COMPILER])dnl
-AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
-  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
-  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
-   $RM -r conftest 2>/dev/null
-   mkdir conftest
-   cd conftest
-   mkdir out
-   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-   lt_compiler_flag="-o out/conftest2.$ac_objext"
-   # Insert the option either (1) after the last *FLAGS variable, or
-   # (2) before a word containing "conftest.", or (3) at the end.
-   # Note that $ac_compile itself does not contain backslashes and begins
-   # with a dollar sign (not a hyphen), so the echo should work correctly.
-   lt_compile=`echo "$ac_compile" | $SED \
-   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
-   -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
-   (eval "$lt_compile" 2>out/conftest.err)
-   ac_status=$?
-   cat out/conftest.err >&AS_MESSAGE_LOG_FD
-   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
-   if (exit $ac_status) && test -s out/conftest2.$ac_objext
-   then
-     # The compiler can only warn and ignore the option if not recognized
-     # So say no if there are warnings
-     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
-     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
-     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
-       _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
-     fi
-   fi
-   chmod u+w . 2>&AS_MESSAGE_LOG_FD
-   $RM conftest*
-   # SGI C++ compiler will create directory out/ii_files/ for
-   # template instantiation
-   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
-   $RM out/* && rmdir out
-   cd ..
-   $RM -r conftest
-   $RM conftest*
-])
-_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
-	[Does compiler simultaneously support -c and -o options?])
-])# _LT_COMPILER_C_O
-
-
-# _LT_COMPILER_FILE_LOCKS([TAGNAME])
-# ----------------------------------
-# Check to see if we can do hard links to lock some files if needed
-m4_defun([_LT_COMPILER_FILE_LOCKS],
-[m4_require([_LT_ENABLE_LOCK])dnl
-m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-_LT_COMPILER_C_O([$1])
-
-hard_links=nottested
-if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then
-  # do not overwrite the value of need_locks provided by the user
-  AC_MSG_CHECKING([if we can lock with hard links])
-  hard_links=yes
-  $RM conftest*
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  touch conftest.a
-  ln conftest.a conftest.b 2>&5 || hard_links=no
-  ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  AC_MSG_RESULT([$hard_links])
-  if test no = "$hard_links"; then
-    AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe])
-    need_locks=warn
-  fi
-else
-  need_locks=no
-fi
-_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
-])# _LT_COMPILER_FILE_LOCKS
-
-
-# _LT_CHECK_OBJDIR
-# ----------------
-m4_defun([_LT_CHECK_OBJDIR],
-[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
-[rm -f .libs 2>/dev/null
-mkdir .libs 2>/dev/null
-if test -d .libs; then
-  lt_cv_objdir=.libs
-else
-  # MS-DOS does not allow filenames that begin with a dot.
-  lt_cv_objdir=_libs
-fi
-rmdir .libs 2>/dev/null])
-objdir=$lt_cv_objdir
-_LT_DECL([], [objdir], [0],
-         [The name of the directory that contains temporary libtool files])dnl
-m4_pattern_allow([LT_OBJDIR])dnl
-AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/",
-  [Define to the sub-directory where libtool stores uninstalled libraries.])
-])# _LT_CHECK_OBJDIR
-
-
-# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
-# --------------------------------------
-# Check hardcoding attributes.
-m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
-[AC_MSG_CHECKING([how to hardcode library paths into programs])
-_LT_TAGVAR(hardcode_action, $1)=
-if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
-   test -n "$_LT_TAGVAR(runpath_var, $1)" ||
-   test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then
-
-  # We can hardcode non-existent directories.
-  if test no != "$_LT_TAGVAR(hardcode_direct, $1)" &&
-     # If the only mechanism to avoid hardcoding is shlibpath_var, we
-     # have to relink, otherwise we might link with an installed library
-     # when we should be linking with a yet-to-be-installed one
-     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" &&
-     test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then
-    # Linking always hardcodes the temporary library directory.
-    _LT_TAGVAR(hardcode_action, $1)=relink
-  else
-    # We can link without hardcoding, and we can hardcode nonexisting dirs.
-    _LT_TAGVAR(hardcode_action, $1)=immediate
-  fi
-else
-  # We cannot hardcode anything, or else we can only hardcode existing
-  # directories.
-  _LT_TAGVAR(hardcode_action, $1)=unsupported
-fi
-AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
-
-if test relink = "$_LT_TAGVAR(hardcode_action, $1)" ||
-   test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then
-  # Fast installation is not supported
-  enable_fast_install=no
-elif test yes = "$shlibpath_overrides_runpath" ||
-     test no = "$enable_shared"; then
-  # Fast installation is not necessary
-  enable_fast_install=needless
-fi
-_LT_TAGDECL([], [hardcode_action], [0],
-    [How to hardcode a shared library path into an executable])
-])# _LT_LINKER_HARDCODE_LIBPATH
-
-
-# _LT_CMD_STRIPLIB
-# ----------------
-m4_defun([_LT_CMD_STRIPLIB],
-[m4_require([_LT_DECL_EGREP])
-striplib=
-old_striplib=
-AC_MSG_CHECKING([whether stripping libraries is possible])
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  AC_MSG_RESULT([yes])
-else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP"; then
-      striplib="$STRIP -x"
-      old_striplib="$STRIP -S"
-      AC_MSG_RESULT([yes])
-    else
-      AC_MSG_RESULT([no])
-    fi
-    ;;
-  *)
-    AC_MSG_RESULT([no])
-    ;;
-  esac
-fi
-_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
-_LT_DECL([], [striplib], [1])
-])# _LT_CMD_STRIPLIB
-
-
-# _LT_PREPARE_MUNGE_PATH_LIST
-# ---------------------------
-# Make sure func_munge_path_list() is defined correctly.
-m4_defun([_LT_PREPARE_MUNGE_PATH_LIST],
-[[# func_munge_path_list VARIABLE PATH
-# -----------------------------------
-# VARIABLE is name of variable containing _space_ separated list of
-# directories to be munged by the contents of PATH, which is string
-# having a format:
-# "DIR[:DIR]:"
-#       string "DIR[ DIR]" will be prepended to VARIABLE
-# ":DIR[:DIR]"
-#       string "DIR[ DIR]" will be appended to VARIABLE
-# "DIRP[:DIRP]::[DIRA:]DIRA"
-#       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
-#       "DIRA[ DIRA]" will be appended to VARIABLE
-# "DIR[:DIR]"
-#       VARIABLE will be replaced by "DIR[ DIR]"
-func_munge_path_list ()
-{
-    case x@S|@2 in
-    x)
-        ;;
-    *:)
-        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\"
-        ;;
-    x:*)
-        eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\"
-        ;;
-    *::*)
-        eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
-        eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\"
-        ;;
-    *)
-        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\"
-        ;;
-    esac
-}
-]])# _LT_PREPARE_PATH_LIST
-
-
-# _LT_SYS_DYNAMIC_LINKER([TAG])
-# -----------------------------
-# PORTME Fill in your ld.so characteristics
-m4_defun([_LT_SYS_DYNAMIC_LINKER],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-m4_require([_LT_DECL_EGREP])dnl
-m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_DECL_OBJDUMP])dnl
-m4_require([_LT_DECL_SED])dnl
-m4_require([_LT_CHECK_SHELL_FEATURES])dnl
-m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl
-AC_MSG_CHECKING([dynamic linker characteristics])
-m4_if([$1],
-	[], [
-if test yes = "$GCC"; then
-  case $host_os in
-    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
-    *) lt_awk_arg='/^libraries:/' ;;
-  esac
-  case $host_os in
-    mingw* | cegcc*) lt_sed_strip_eq='s|=\([[A-Za-z]]:\)|\1|g' ;;
-    *) lt_sed_strip_eq='s|=/|/|g' ;;
-  esac
-  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
-  case $lt_search_path_spec in
-  *\;*)
-    # if the path contains ";" then we assume it to be the separator
-    # otherwise default to the standard path separator (i.e. ":") - it is
-    # assumed that no part of a normal pathname contains ";" but that should
-    # okay in the real world where ";" in dirpaths is itself problematic.
-    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
-    ;;
-  *)
-    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
-    ;;
-  esac
-  # Ok, now we have the path, separated by spaces, we can step through it
-  # and add multilib dir if necessary...
-  lt_tmp_lt_search_path_spec=
-  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
-  # ...but if some path component already ends with the multilib dir we assume
-  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
-  case "$lt_multi_os_dir; $lt_search_path_spec " in
-  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
-    lt_multi_os_dir=
-    ;;
-  esac
-  for lt_sys_path in $lt_search_path_spec; do
-    if test -d "$lt_sys_path$lt_multi_os_dir"; then
-      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
-    elif test -n "$lt_multi_os_dir"; then
-      test -d "$lt_sys_path" && \
-	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
-    fi
-  done
-  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
-BEGIN {RS = " "; FS = "/|\n";} {
-  lt_foo = "";
-  lt_count = 0;
-  for (lt_i = NF; lt_i > 0; lt_i--) {
-    if ($lt_i != "" && $lt_i != ".") {
-      if ($lt_i == "..") {
-        lt_count++;
-      } else {
-        if (lt_count == 0) {
-          lt_foo = "/" $lt_i lt_foo;
-        } else {
-          lt_count--;
-        }
-      }
-    }
-  }
-  if (lt_foo != "") { lt_freq[[lt_foo]]++; }
-  if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
-}'`
-  # AWK program above erroneously prepends '/' to C:/dos/paths
-  # for these hosts.
-  case $host_os in
-    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
-      $SED 's|/\([[A-Za-z]]:\)|\1|g'` ;;
-  esac
-  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
-else
-  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-fi])
-library_names_spec=
-libname_spec='lib$name'
-soname_spec=
-shrext_cmds=.so
-postinstall_cmds=
-postuninstall_cmds=
-finish_cmds=
-finish_eval=
-shlibpath_var=
-shlibpath_overrides_runpath=unknown
-version_type=none
-dynamic_linker="$host_os ld.so"
-sys_lib_dlsearch_path_spec="/lib /usr/lib"
-need_lib_prefix=unknown
-hardcode_into_libs=no
-
-# when you set need_version to no, make sure it does not cause -set_version
-# flags to be left without arguments
-need_version=unknown
-
-AC_ARG_VAR([LT_SYS_LIBRARY_PATH],
-[User-defined run-time library search path.])
-
-case $host_os in
-aix3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
-  shlibpath_var=LIBPATH
-
-  # AIX 3 has no versioning support, so we append a major version to the name.
-  soname_spec='$libname$release$shared_ext$major'
-  ;;
-
-aix[[4-9]]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  hardcode_into_libs=yes
-  if test ia64 = "$host_cpu"; then
-    # AIX 5 supports IA64
-    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
-    shlibpath_var=LD_LIBRARY_PATH
-  else
-    # With GCC up to 2.95.x, collect2 would create an import file
-    # for dependence libraries.  The import file would start with
-    # the line '#! .'.  This would cause the generated library to
-    # depend on '.', always an invalid library.  This was fixed in
-    # development snapshots of GCC prior to 3.0.
-    case $host_os in
-      aix4 | aix4.[[01]] | aix4.[[01]].*)
-      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
-	   echo ' yes '
-	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
-	:
-      else
-	can_build_shared=no
-      fi
-      ;;
-    esac
-    # Using Import Files as archive members, it is possible to support
-    # filename-based versioning of shared library archives on AIX. While
-    # this would work for both with and without runtime linking, it will
-    # prevent static linking of such archives. So we do filename-based
-    # shared library versioning with .so extension only, which is used
-    # when both runtime linking and shared linking is enabled.
-    # Unfortunately, runtime linking may impact performance, so we do
-    # not want this to be the default eventually. Also, we use the
-    # versioned .so libs for executables only if there is the -brtl
-    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
-    # To allow for filename-based versioning support, we need to create
-    # libNAME.so.V as an archive file, containing:
-    # *) an Import File, referring to the versioned filename of the
-    #    archive as well as the shared archive member, telling the
-    #    bitwidth (32 or 64) of that shared object, and providing the
-    #    list of exported symbols of that shared object, eventually
-    #    decorated with the 'weak' keyword
-    # *) the shared object with the F_LOADONLY flag set, to really avoid
-    #    it being seen by the linker.
-    # At run time we better use the real file rather than another symlink,
-    # but for link time we create the symlink libNAME.so -> libNAME.so.V
-
-    case $with_aix_soname,$aix_use_runtimelinking in
-    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
-    # soname into executable. Probably we can add versioning support to
-    # collect2, so additional links can be useful in future.
-    aix,yes) # traditional libtool
-      dynamic_linker='AIX unversionable lib.so'
-      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
-      # instead of lib<name>.a to let people know that these are not
-      # typical AIX shared libraries.
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      ;;
-    aix,no) # traditional AIX only
-      dynamic_linker='AIX lib.a[(]lib.so.V[)]'
-      # We preserve .a as extension for shared libraries through AIX4.2
-      # and later when we are not doing run time linking.
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      ;;
-    svr4,*) # full svr4 only
-      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,yes) # both, prefer svr4
-      dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]"
-      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
-      # unpreferred sharedlib libNAME.a needs extra handling
-      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
-      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
-      # We do not specify a path in Import Files, so LIBPATH fires.
-      shlibpath_overrides_runpath=yes
-      ;;
-    *,no) # both, prefer aix
-      dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]"
-      library_names_spec='$libname$release.a $libname.a'
-      soname_spec='$libname$release$shared_ext$major'
-      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
-      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
-      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
-      ;;
-    esac
-    shlibpath_var=LIBPATH
-  fi
-  ;;
-
-amigaos*)
-  case $host_cpu in
-  powerpc)
-    # Since July 2007 AmigaOS4 officially supports .so libraries.
-    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    ;;
-  m68k)
-    library_names_spec='$libname.ixlibrary $libname.a'
-    # Create ${libname}_ixlibrary.a entries in /sys/libs.
-    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
-    ;;
-  esac
-  ;;
-
-beos*)
-  library_names_spec='$libname$shared_ext'
-  dynamic_linker="$host_os ld.so"
-  shlibpath_var=LIBRARY_PATH
-  ;;
-
-bsdi[[45]]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
-  # the default ld.so.conf also contains /usr/contrib/lib and
-  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
-  # libtool to hard-code these into programs
-  ;;
-
-cygwin* | mingw* | pw32* | cegcc*)
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-
-  case $GCC,$cc_basename in
-  yes,*)
-    # gcc
-    library_names_spec='$libname.dll.a'
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname~
-      chmod a+x \$dldir/$dlname~
-      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-      fi'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-
-    case $host_os in
-    cygwin*)
-      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
-m4_if([$1], [],[
-      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
-      ;;
-    mingw* | cegcc*)
-      # MinGW DLLs use traditional 'lib' prefix
-      soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
-      ;;
-    pw32*)
-      # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
-      ;;
-    esac
-    dynamic_linker='Win32 ld.exe'
-    ;;
-
-  *,cl*)
-    # Native MSVC
-    libname_spec='$name'
-    soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
-    library_names_spec='$libname.dll.lib'
-
-    case $build_os in
-    mingw*)
-      sys_lib_search_path_spec=
-      lt_save_ifs=$IFS
-      IFS=';'
-      for lt_path in $LIB
-      do
-        IFS=$lt_save_ifs
-        # Let DOS variable expansion print the short 8.3 style file name.
-        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
-        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
-      done
-      IFS=$lt_save_ifs
-      # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
-      ;;
-    cygwin*)
-      # Convert to unix form, then to dos form, then back to unix form
-      # but this time dos style (no spaces!) so that the unix form looks
-      # like /cygdrive/c/PROGRA~1:/cygdr...
-      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
-      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
-      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      ;;
-    *)
-      sys_lib_search_path_spec=$LIB
-      if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
-        # It is most probably a Windows format PATH.
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
-      else
-        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
-      fi
-      # FIXME: find the short name or the path components, as spaces are
-      # common. (e.g. "Program Files" -> "PROGRA~1")
-      ;;
-    esac
-
-    # DLL is installed to $(libdir)/../bin by postinstall_cmds
-    postinstall_cmds='base_file=`basename \$file`~
-      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
-      dldir=$destdir/`dirname \$dlpath`~
-      test -d \$dldir || mkdir -p \$dldir~
-      $install_prog $dir/$dlname \$dldir/$dlname'
-    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
-      dlpath=$dir/\$dldll~
-       $RM \$dlpath'
-    shlibpath_overrides_runpath=yes
-    dynamic_linker='Win32 link.exe'
-    ;;
-
-  *)
-    # Assume MSVC wrapper
-    library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib'
-    dynamic_linker='Win32 ld.exe'
-    ;;
-  esac
-  # FIXME: first we should search . and the directory the executable is in
-  shlibpath_var=PATH
-  ;;
-
-darwin* | rhapsody*)
-  dynamic_linker="$host_os dyld"
-  version_type=darwin
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$major$shared_ext'
-  shlibpath_overrides_runpath=yes
-  shlibpath_var=DYLD_LIBRARY_PATH
-  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
-m4_if([$1], [],[
-  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
-  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
-  ;;
-
-dgux*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-freebsd* | dragonfly*)
-  # DragonFly does not have aout.  When/if they implement a new
-  # versioning mechanism, adjust this.
-  if test -x /usr/bin/objformat; then
-    objformat=`/usr/bin/objformat`
-  else
-    case $host_os in
-    freebsd[[23]].*) objformat=aout ;;
-    *) objformat=elf ;;
-    esac
-  fi
-  version_type=freebsd-$objformat
-  case $version_type in
-    freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-      soname_spec='$libname$release$shared_ext$major'
-      need_version=no
-      need_lib_prefix=no
-      ;;
-    freebsd-*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-      need_version=yes
-      ;;
-  esac
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_os in
-  freebsd2.*)
-    shlibpath_overrides_runpath=yes
-    ;;
-  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
-  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
-    shlibpath_overrides_runpath=no
-    hardcode_into_libs=yes
-    ;;
-  *) # from 4.6 on, and DragonFly
-    shlibpath_overrides_runpath=yes
-    hardcode_into_libs=yes
-    ;;
-  esac
-  ;;
-
-haiku*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  dynamic_linker="$host_os runtime_loader"
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
-  hardcode_into_libs=yes
-  ;;
-
-hpux9* | hpux10* | hpux11*)
-  # Give a soname corresponding to the major version so that dld.sl refuses to
-  # link against other versions.
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  case $host_cpu in
-  ia64*)
-    shrext_cmds='.so'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.so"
-    shlibpath_var=LD_LIBRARY_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    if test 32 = "$HPUX_IA64_MODE"; then
-      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
-    else
-      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
-      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
-    fi
-    ;;
-  hppa*64*)
-    shrext_cmds='.sl'
-    hardcode_into_libs=yes
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
-    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-    ;;
-  *)
-    shrext_cmds='.sl'
-    dynamic_linker="$host_os dld.sl"
-    shlibpath_var=SHLIB_PATH
-    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    ;;
-  esac
-  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
-  postinstall_cmds='chmod 555 $lib'
-  # or fails outright, so override atomically:
-  install_override_mode=555
-  ;;
-
-interix[[3-9]]*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-irix5* | irix6* | nonstopux*)
-  case $host_os in
-    nonstopux*) version_type=nonstopux ;;
-    *)
-	if test yes = "$lt_cv_prog_gnu_ld"; then
-		version_type=linux # correct to gnu/linux during the next big refactor
-	else
-		version_type=irix
-	fi ;;
-  esac
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
-  case $host_os in
-  irix5* | nonstopux*)
-    libsuff= shlibsuff=
-    ;;
-  *)
-    case $LD in # libtool.m4 will add one of these switches to LD
-    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
-      libsuff= shlibsuff= libmagic=32-bit;;
-    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
-      libsuff=32 shlibsuff=N32 libmagic=N32;;
-    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
-      libsuff=64 shlibsuff=64 libmagic=64-bit;;
-    *) libsuff= shlibsuff= libmagic=never-match;;
-    esac
-    ;;
-  esac
-  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
-  shlibpath_overrides_runpath=no
-  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
-  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
-  hardcode_into_libs=yes
-  ;;
-
-# No shared lib support for Linux oldld, aout, or coff.
-linux*oldld* | linux*aout* | linux*coff*)
-  dynamic_linker=no
-  ;;
-
-linux*android*)
-  version_type=none # Android doesn't support versioned libraries.
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext'
-  soname_spec='$libname$release$shared_ext'
-  finish_cmds=
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  dynamic_linker='Android linker'
-  # Don't embed -rpath directories since the linker doesn't support them.
-  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-  ;;
-
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-
-  # Some binutils ld are patched to set DT_RUNPATH
-  AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath],
-    [lt_cv_shlibpath_overrides_runpath=no
-    save_LDFLAGS=$LDFLAGS
-    save_libdir=$libdir
-    eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
-	 LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
-    AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
-      [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
-	 [lt_cv_shlibpath_overrides_runpath=yes])])
-    LDFLAGS=$save_LDFLAGS
-    libdir=$save_libdir
-    ])
-  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
-
-  # This implies no fast_install, which is unacceptable.
-  # Some rework will be needed to allow for fast_install
-  # before this can be enabled.
-  hardcode_into_libs=yes
-
-  # Ideally, we could use ldconfig to report *all* directores which are
-  # searched for libraries, however this is still not possible.  Aside from not
-  # being certain /sbin/ldconfig is available, command
-  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
-  # even though it is searched at run-time.  Try to do the best guess by
-  # appending ld.so.conf contents (and includes) to the search path.
-  if test -f /etc/ld.so.conf; then
-    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
-    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
-  fi
-
-  # We used to test for /lib/ld.so.1 and disable shared libraries on
-  # powerpc, because MkLinux only supported shared libraries with the
-  # GNU dynamic linker.  Since this was broken with cross compilers,
-  # most powerpc-linux boxes support dynamic linking these days and
-  # people can always --disable-shared, the test was removed, and we
-  # assume the GNU/Linux dynamic linker is in use.
-  dynamic_linker='GNU/Linux ld.so'
-  ;;
-
-netbsdelf*-gnu)
-  version_type=linux
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
-  soname_spec='${libname}${release}${shared_ext}$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='NetBSD ld.elf_so'
-  ;;
-
-netbsd*)
-  version_type=sunos
-  need_lib_prefix=no
-  need_version=no
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-    dynamic_linker='NetBSD (a.out) ld.so'
-  else
-    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    soname_spec='$libname$release$shared_ext$major'
-    dynamic_linker='NetBSD ld.elf_so'
-  fi
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  ;;
-
-newsos6)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-*nto* | *qnx*)
-  version_type=qnx
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  dynamic_linker='ldqnx.so'
-  ;;
-
-openbsd* | bitrig*)
-  version_type=sunos
-  sys_lib_dlsearch_path_spec=/usr/lib
-  need_lib_prefix=no
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-    need_version=no
-  else
-    need_version=yes
-  fi
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  ;;
-
-os2*)
-  libname_spec='$name'
-  version_type=windows
-  shrext_cmds=.dll
-  need_version=no
-  need_lib_prefix=no
-  # OS/2 can only load a DLL with a base name of 8 characters or less.
-  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
-    v=$($ECHO $release$versuffix | tr -d .-);
-    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
-    $ECHO $n$v`$shared_ext'
-  library_names_spec='${libname}_dll.$libext'
-  dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=BEGINLIBPATH
-  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  postinstall_cmds='base_file=`basename \$file`~
-    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
-    dldir=$destdir/`dirname \$dlpath`~
-    test -d \$dldir || mkdir -p \$dldir~
-    $install_prog $dir/$dlname \$dldir/$dlname~
-    chmod a+x \$dldir/$dlname~
-    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
-      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
-    fi'
-  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
-    dlpath=$dir/\$dldll~
-    $RM \$dlpath'
-  ;;
-
-osf3* | osf4* | osf5*)
-  version_type=osf
-  need_lib_prefix=no
-  need_version=no
-  soname_spec='$libname$release$shared_ext$major'
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
-  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
-  ;;
-
-rdos*)
-  dynamic_linker=no
-  ;;
-
-solaris*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  # ldd complains unless libraries are executable
-  postinstall_cmds='chmod +x $lib'
-  ;;
-
-sunos4*)
-  version_type=sunos
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
-  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  if test yes = "$with_gnu_ld"; then
-    need_lib_prefix=no
-  fi
-  need_version=yes
-  ;;
-
-sysv4 | sysv4.3*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  case $host_vendor in
-    sni)
-      shlibpath_overrides_runpath=no
-      need_lib_prefix=no
-      runpath_var=LD_RUN_PATH
-      ;;
-    siemens)
-      need_lib_prefix=no
-      ;;
-    motorola)
-      need_lib_prefix=no
-      need_version=no
-      shlibpath_overrides_runpath=no
-      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
-      ;;
-  esac
-  ;;
-
-sysv4*MP*)
-  if test -d /usr/nec; then
-    version_type=linux # correct to gnu/linux during the next big refactor
-    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
-    soname_spec='$libname$shared_ext.$major'
-    shlibpath_var=LD_LIBRARY_PATH
-  fi
-  ;;
-
-sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=sco
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=yes
-  hardcode_into_libs=yes
-  if test yes = "$with_gnu_ld"; then
-    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
-  else
-    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
-    case $host_os in
-      sco3.2v5*)
-        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
-	;;
-    esac
-  fi
-  sys_lib_dlsearch_path_spec='/usr/lib'
-  ;;
-
-tpf*)
-  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
-  version_type=linux # correct to gnu/linux during the next big refactor
-  need_lib_prefix=no
-  need_version=no
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  shlibpath_var=LD_LIBRARY_PATH
-  shlibpath_overrides_runpath=no
-  hardcode_into_libs=yes
-  ;;
-
-uts4*)
-  version_type=linux # correct to gnu/linux during the next big refactor
-  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-  soname_spec='$libname$release$shared_ext$major'
-  shlibpath_var=LD_LIBRARY_PATH
-  ;;
-
-*)
-  dynamic_linker=no
-  ;;
-esac
-AC_MSG_RESULT([$dynamic_linker])
-test no = "$dynamic_linker" && can_build_shared=no
-
-variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test yes = "$GCC"; then
-  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
-fi
-
-if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
-  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
-fi
-
-if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
-  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
-fi
-
-# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
-configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
-
-# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
-func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
-
-# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
-configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
-
-_LT_DECL([], [variables_saved_for_relink], [1],
-    [Variables whose values should be saved in libtool wrapper scripts and
-    restored at link time])
-_LT_DECL([], [need_lib_prefix], [0],
-    [Do we need the "lib" prefix for modules?])
-_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
-_LT_DECL([], [version_type], [0], [Library versioning type])
-_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
-_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
-_LT_DECL([], [shlibpath_overrides_runpath], [0],
-    [Is shlibpath searched before the hard-coded library search path?])
-_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
-_LT_DECL([], [library_names_spec], [1],
-    [[List of archive names.  First name is the real one, the rest are links.
-    The last name is the one that the linker finds with -lNAME]])
-_LT_DECL([], [soname_spec], [1],
-    [[The coded name of the library, if different from the real name]])
-_LT_DECL([], [install_override_mode], [1],
-    [Permission mode override for installation of shared libraries])
-_LT_DECL([], [postinstall_cmds], [2],
-    [Command to use after installation of a shared archive])
-_LT_DECL([], [postuninstall_cmds], [2],
-    [Command to use after uninstallation of a shared archive])
-_LT_DECL([], [finish_cmds], [2],
-    [Commands used to finish a libtool library installation in a directory])
-_LT_DECL([], [finish_eval], [1],
-    [[As "finish_cmds", except a single script fragment to be evaled but
-    not shown]])
-_LT_DECL([], [hardcode_into_libs], [0],
-    [Whether we should hardcode library paths into libraries])
-_LT_DECL([], [sys_lib_search_path_spec], [2],
-    [Compile-time system search path for libraries])
-_LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2],
-    [Detected run-time system search path for libraries])
-_LT_DECL([], [configure_time_lt_sys_library_path], [2],
-    [Explicit LT_SYS_LIBRARY_PATH set during ./configure time])
-])# _LT_SYS_DYNAMIC_LINKER
-
-
-# _LT_PATH_TOOL_PREFIX(TOOL)
-# --------------------------
-# find a file program that can recognize shared library
-AC_DEFUN([_LT_PATH_TOOL_PREFIX],
-[m4_require([_LT_DECL_EGREP])dnl
-AC_MSG_CHECKING([for $1])
-AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
-[case $MAGIC_CMD in
-[[\\/*] |  ?:[\\/]*])
-  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
-  ;;
-*)
-  lt_save_MAGIC_CMD=$MAGIC_CMD
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-dnl $ac_dummy forces splitting on constant user-supplied paths.
-dnl POSIX.2 word splitting is done only on the output of word expansions,
-dnl not every word.  This closes a longstanding sh security hole.
-  ac_dummy="m4_if([$2], , $PATH, [$2])"
-  for ac_dir in $ac_dummy; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$1"; then
-      lt_cv_path_MAGIC_CMD=$ac_dir/"$1"
-      if test -n "$file_magic_test_file"; then
-	case $deplibs_check_method in
-	"file_magic "*)
-	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
-	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
-	    $EGREP "$file_magic_regex" > /dev/null; then
-	    :
-	  else
-	    cat <<_LT_EOF 1>&2
-
-*** Warning: the command libtool uses to detect shared libraries,
-*** $file_magic_cmd, produces output that libtool cannot recognize.
-*** The result is that libtool may fail to recognize shared libraries
-*** as such.  This will affect the creation of libtool libraries that
-*** depend on shared libraries, but programs linked with such libtool
-*** libraries will work regardless of this problem.  Nevertheless, you
-*** may want to report the problem to your system manager and/or to
-*** bug-libtool@gnu.org
-
-_LT_EOF
-	  fi ;;
-	esac
-      fi
-      break
-    fi
-  done
-  IFS=$lt_save_ifs
-  MAGIC_CMD=$lt_save_MAGIC_CMD
-  ;;
-esac])
-MAGIC_CMD=$lt_cv_path_MAGIC_CMD
-if test -n "$MAGIC_CMD"; then
-  AC_MSG_RESULT($MAGIC_CMD)
-else
-  AC_MSG_RESULT(no)
-fi
-_LT_DECL([], [MAGIC_CMD], [0],
-	 [Used to examine libraries when file_magic_cmd begins with "file"])dnl
-])# _LT_PATH_TOOL_PREFIX
-
-# Old name:
-AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
-
-
-# _LT_PATH_MAGIC
-# --------------
-# find a file program that can recognize a shared library
-m4_defun([_LT_PATH_MAGIC],
-[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
-if test -z "$lt_cv_path_MAGIC_CMD"; then
-  if test -n "$ac_tool_prefix"; then
-    _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
-  else
-    MAGIC_CMD=:
-  fi
-fi
-])# _LT_PATH_MAGIC
-
-
-# LT_PATH_LD
-# ----------
-# find the pathname to the GNU or non-GNU linker
-AC_DEFUN([LT_PATH_LD],
-[AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-m4_require([_LT_DECL_SED])dnl
-m4_require([_LT_DECL_EGREP])dnl
-m4_require([_LT_PROG_ECHO_BACKSLASH])dnl
-
-AC_ARG_WITH([gnu-ld],
-    [AS_HELP_STRING([--with-gnu-ld],
-	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
-    [test no = "$withval" || with_gnu_ld=yes],
-    [with_gnu_ld=no])dnl
-
-ac_prog=ld
-if test yes = "$GCC"; then
-  # Check if gcc -print-prog-name=ld gives a path.
-  AC_MSG_CHECKING([for ld used by $CC])
-  case $host in
-  *-*-mingw*)
-    # gcc leaves a trailing carriage return, which upsets mingw
-    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
-  *)
-    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
-  esac
-  case $ac_prog in
-    # Accept absolute paths.
-    [[\\/]]* | ?:[[\\/]]*)
-      re_direlt='/[[^/]][[^/]]*/\.\./'
-      # Canonicalize the pathname of ld
-      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
-      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
-      done
-      test -z "$LD" && LD=$ac_prog
-      ;;
-  "")
-    # If it fails, then pretend we aren't using GCC.
-    ac_prog=ld
-    ;;
-  *)
-    # If it is relative, then search for the first ld in PATH.
-    with_gnu_ld=unknown
-    ;;
-  esac
-elif test yes = "$with_gnu_ld"; then
-  AC_MSG_CHECKING([for GNU ld])
-else
-  AC_MSG_CHECKING([for non-GNU ld])
-fi
-AC_CACHE_VAL(lt_cv_path_LD,
-[if test -z "$LD"; then
-  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-  for ac_dir in $PATH; do
-    IFS=$lt_save_ifs
-    test -z "$ac_dir" && ac_dir=.
-    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
-      lt_cv_path_LD=$ac_dir/$ac_prog
-      # Check to see if the program is GNU ld.  I'd rather use --version,
-      # but apparently some variants of GNU ld only accept -v.
-      # Break only if it was the GNU/non-GNU ld that we prefer.
-      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
-      *GNU* | *'with BFD'*)
-	test no != "$with_gnu_ld" && break
-	;;
-      *)
-	test yes != "$with_gnu_ld" && break
-	;;
-      esac
-    fi
-  done
-  IFS=$lt_save_ifs
-else
-  lt_cv_path_LD=$LD # Let the user override the test with a path.
-fi])
-LD=$lt_cv_path_LD
-if test -n "$LD"; then
-  AC_MSG_RESULT($LD)
-else
-  AC_MSG_RESULT(no)
-fi
-test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
-_LT_PATH_LD_GNU
-AC_SUBST([LD])
-
-_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
-])# LT_PATH_LD
-
-# Old names:
-AU_ALIAS([AM_PROG_LD], [LT_PATH_LD])
-AU_ALIAS([AC_PROG_LD], [LT_PATH_LD])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AM_PROG_LD], [])
-dnl AC_DEFUN([AC_PROG_LD], [])
-
-
-# _LT_PATH_LD_GNU
-#- --------------
-m4_defun([_LT_PATH_LD_GNU],
-[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
-[# I'd rather use --version here, but apparently some GNU lds only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
-  lt_cv_prog_gnu_ld=yes
-  ;;
-*)
-  lt_cv_prog_gnu_ld=no
-  ;;
-esac])
-with_gnu_ld=$lt_cv_prog_gnu_ld
-])# _LT_PATH_LD_GNU
-
-
-# _LT_CMD_RELOAD
-# --------------
-# find reload flag for linker
-#   -- PORTME Some linkers may need a different reload flag.
-m4_defun([_LT_CMD_RELOAD],
-[AC_CACHE_CHECK([for $LD option to reload object files],
-  lt_cv_ld_reload_flag,
-  [lt_cv_ld_reload_flag='-r'])
-reload_flag=$lt_cv_ld_reload_flag
-case $reload_flag in
-"" | " "*) ;;
-*) reload_flag=" $reload_flag" ;;
-esac
-reload_cmds='$LD$reload_flag -o $output$reload_objs'
-case $host_os in
-  cygwin* | mingw* | pw32* | cegcc*)
-    if test yes != "$GCC"; then
-      reload_cmds=false
-    fi
-    ;;
-  darwin*)
-    if test yes = "$GCC"; then
-      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
-    else
-      reload_cmds='$LD$reload_flag -o $output$reload_objs'
-    fi
-    ;;
-esac
-_LT_TAGDECL([], [reload_flag], [1], [How to create reloadable object files])dnl
-_LT_TAGDECL([], [reload_cmds], [2])dnl
-])# _LT_CMD_RELOAD
-
-
-# _LT_PATH_DD
-# -----------
-# find a working dd
-m4_defun([_LT_PATH_DD],
-[AC_CACHE_CHECK([for a working dd], [ac_cv_path_lt_DD],
-[printf 0123456789abcdef0123456789abcdef >conftest.i
-cat conftest.i conftest.i >conftest2.i
-: ${lt_DD:=$DD}
-AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd],
-[if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
-  cmp -s conftest.i conftest.out \
-  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
-fi])
-rm -f conftest.i conftest2.i conftest.out])
-])# _LT_PATH_DD
-
-
-# _LT_CMD_TRUNCATE
-# ----------------
-# find command to truncate a binary pipe
-m4_defun([_LT_CMD_TRUNCATE],
-[m4_require([_LT_PATH_DD])
-AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin],
-[printf 0123456789abcdef0123456789abcdef >conftest.i
-cat conftest.i conftest.i >conftest2.i
-lt_cv_truncate_bin=
-if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
-  cmp -s conftest.i conftest.out \
-  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
-fi
-rm -f conftest.i conftest2.i conftest.out
-test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"])
-_LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1],
-  [Command to truncate a binary pipe])
-])# _LT_CMD_TRUNCATE
-
-
-# _LT_CHECK_MAGIC_METHOD
-# ----------------------
-# how to check for library dependencies
-#  -- PORTME fill in with the dynamic library characteristics
-m4_defun([_LT_CHECK_MAGIC_METHOD],
-[m4_require([_LT_DECL_EGREP])
-m4_require([_LT_DECL_OBJDUMP])
-AC_CACHE_CHECK([how to recognize dependent libraries],
-lt_cv_deplibs_check_method,
-[lt_cv_file_magic_cmd='$MAGIC_CMD'
-lt_cv_file_magic_test_file=
-lt_cv_deplibs_check_method='unknown'
-# Need to set the preceding variable on all platforms that support
-# interlibrary dependencies.
-# 'none' -- dependencies not supported.
-# 'unknown' -- same as none, but documents that we really don't know.
-# 'pass_all' -- all dependencies passed with no checks.
-# 'test_compile' -- check by making test program.
-# 'file_magic [[regex]]' -- check by looking for files in library path
-# that responds to the $file_magic_cmd with a given extended regex.
-# If you have 'file' or equivalent on your system and you're not sure
-# whether 'pass_all' will *always* work, you probably want this one.
-
-case $host_os in
-aix[[4-9]]*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-beos*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-bsdi[[45]]*)
-  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
-  lt_cv_file_magic_cmd='/usr/bin/file -L'
-  lt_cv_file_magic_test_file=/shlib/libc.so
-  ;;
-
-cygwin*)
-  # func_win32_libid is a shell function defined in ltmain.sh
-  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
-  lt_cv_file_magic_cmd='func_win32_libid'
-  ;;
-
-mingw* | pw32*)
-  # Base MSYS/MinGW do not provide the 'file' command needed by
-  # func_win32_libid shell function, so use a weaker test based on 'objdump',
-  # unless we find 'file', for example because we are cross-compiling.
-  if ( file / ) >/dev/null 2>&1; then
-    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
-    lt_cv_file_magic_cmd='func_win32_libid'
-  else
-    # Keep this pattern in sync with the one in func_win32_libid.
-    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
-    lt_cv_file_magic_cmd='$OBJDUMP -f'
-  fi
-  ;;
-
-cegcc*)
-  # use the weaker test based on 'objdump'. See mingw*.
-  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
-  lt_cv_file_magic_cmd='$OBJDUMP -f'
-  ;;
-
-darwin* | rhapsody*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-freebsd* | dragonfly*)
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
-    case $host_cpu in
-    i*86 )
-      # Not sure whether the presence of OpenBSD here was a mistake.
-      # Let's accept both of them until this is cleared up.
-      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
-      lt_cv_file_magic_cmd=/usr/bin/file
-      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
-      ;;
-    esac
-  else
-    lt_cv_deplibs_check_method=pass_all
-  fi
-  ;;
-
-haiku*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-hpux10.20* | hpux11*)
-  lt_cv_file_magic_cmd=/usr/bin/file
-  case $host_cpu in
-  ia64*)
-    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
-    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
-    ;;
-  hppa*64*)
-    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]']
-    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
-    ;;
-  *)
-    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library'
-    lt_cv_file_magic_test_file=/usr/lib/libc.sl
-    ;;
-  esac
-  ;;
-
-interix[[3-9]]*)
-  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
-  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
-  ;;
-
-irix5* | irix6* | nonstopux*)
-  case $LD in
-  *-32|*"-32 ") libmagic=32-bit;;
-  *-n32|*"-n32 ") libmagic=N32;;
-  *-64|*"-64 ") libmagic=64-bit;;
-  *) libmagic=never-match;;
-  esac
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-netbsd* | netbsdelf*-gnu)
-  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
-    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
-  else
-    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
-  fi
-  ;;
-
-newos6*)
-  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
-  lt_cv_file_magic_cmd=/usr/bin/file
-  lt_cv_file_magic_test_file=/usr/lib/libnls.so
-  ;;
-
-*nto* | *qnx*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-openbsd* | bitrig*)
-  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
-  else
-    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
-  fi
-  ;;
-
-osf3* | osf4* | osf5*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-rdos*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-solaris*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-
-sysv4 | sysv4.3*)
-  case $host_vendor in
-  motorola)
-    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
-    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
-    ;;
-  ncr)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  sequent)
-    lt_cv_file_magic_cmd='/bin/file'
-    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
-    ;;
-  sni)
-    lt_cv_file_magic_cmd='/bin/file'
-    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
-    lt_cv_file_magic_test_file=/lib/libc.so
-    ;;
-  siemens)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  pc)
-    lt_cv_deplibs_check_method=pass_all
-    ;;
-  esac
-  ;;
-
-tpf*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-os2*)
-  lt_cv_deplibs_check_method=pass_all
-  ;;
-esac
-])
-
-file_magic_glob=
-want_nocaseglob=no
-if test "$build" = "$host"; then
-  case $host_os in
-  mingw* | pw32*)
-    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
-      want_nocaseglob=yes
-    else
-      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"`
-    fi
-    ;;
-  esac
-fi
-
-file_magic_cmd=$lt_cv_file_magic_cmd
-deplibs_check_method=$lt_cv_deplibs_check_method
-test -z "$deplibs_check_method" && deplibs_check_method=unknown
-
-_LT_DECL([], [deplibs_check_method], [1],
-    [Method to check whether dependent libraries are shared objects])
-_LT_DECL([], [file_magic_cmd], [1],
-    [Command to use when deplibs_check_method = "file_magic"])
-_LT_DECL([], [file_magic_glob], [1],
-    [How to find potential files when deplibs_check_method = "file_magic"])
-_LT_DECL([], [want_nocaseglob], [1],
-    [Find potential files using nocaseglob when deplibs_check_method = "file_magic"])
-])# _LT_CHECK_MAGIC_METHOD
-
-
-# LT_PATH_NM
-# ----------
-# find the pathname to a BSD- or MS-compatible name lister
-AC_DEFUN([LT_PATH_NM],
-[AC_REQUIRE([AC_PROG_CC])dnl
-AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
-[if test -n "$NM"; then
-  # Let the user override the test.
-  lt_cv_path_NM=$NM
-else
-  lt_nm_to_check=${ac_tool_prefix}nm
-  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
-    lt_nm_to_check="$lt_nm_to_check nm"
-  fi
-  for lt_tmp_nm in $lt_nm_to_check; do
-    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
-    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
-      IFS=$lt_save_ifs
-      test -z "$ac_dir" && ac_dir=.
-      tmp_nm=$ac_dir/$lt_tmp_nm
-      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
-	# Check to see if the nm accepts a BSD-compat flag.
-	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
-	#   nm: unknown option "B" ignored
-	# Tru64's nm complains that /dev/null is an invalid object file
-	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
-	case $build_os in
-	mingw*) lt_bad_file=conftest.nm/nofile ;;
-	*) lt_bad_file=/dev/null ;;
-	esac
-	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
-	*$lt_bad_file* | *'Invalid file or object type'*)
-	  lt_cv_path_NM="$tmp_nm -B"
-	  break 2
-	  ;;
-	*)
-	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
-	  */dev/null*)
-	    lt_cv_path_NM="$tmp_nm -p"
-	    break 2
-	    ;;
-	  *)
-	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
-	    continue # so that we can try to find one that supports BSD flags
-	    ;;
-	  esac
-	  ;;
-	esac
-      fi
-    done
-    IFS=$lt_save_ifs
-  done
-  : ${lt_cv_path_NM=no}
-fi])
-if test no != "$lt_cv_path_NM"; then
-  NM=$lt_cv_path_NM
-else
-  # Didn't find any BSD compatible name lister, look for dumpbin.
-  if test -n "$DUMPBIN"; then :
-    # Let the user override the test.
-  else
-    AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
-    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
-    *COFF*)
-      DUMPBIN="$DUMPBIN -symbols -headers"
-      ;;
-    *)
-      DUMPBIN=:
-      ;;
-    esac
-  fi
-  AC_SUBST([DUMPBIN])
-  if test : != "$DUMPBIN"; then
-    NM=$DUMPBIN
-  fi
-fi
-test -z "$NM" && NM=nm
-AC_SUBST([NM])
-_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl
-
-AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
-  [lt_cv_nm_interface="BSD nm"
-  echo "int some_variable = 0;" > conftest.$ac_ext
-  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
-  (eval "$ac_compile" 2>conftest.err)
-  cat conftest.err >&AS_MESSAGE_LOG_FD
-  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
-  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
-  cat conftest.err >&AS_MESSAGE_LOG_FD
-  (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD)
-  cat conftest.out >&AS_MESSAGE_LOG_FD
-  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
-    lt_cv_nm_interface="MS dumpbin"
-  fi
-  rm -f conftest*])
-])# LT_PATH_NM
-
-# Old names:
-AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
-AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AM_PROG_NM], [])
-dnl AC_DEFUN([AC_PROG_NM], [])
-
-# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
-# --------------------------------
-# how to determine the name of the shared library
-# associated with a specific link library.
-#  -- PORTME fill in with the dynamic library characteristics
-m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB],
-[m4_require([_LT_DECL_EGREP])
-m4_require([_LT_DECL_OBJDUMP])
-m4_require([_LT_DECL_DLLTOOL])
-AC_CACHE_CHECK([how to associate runtime and link libraries],
-lt_cv_sharedlib_from_linklib_cmd,
-[lt_cv_sharedlib_from_linklib_cmd='unknown'
-
-case $host_os in
-cygwin* | mingw* | pw32* | cegcc*)
-  # two different shell functions defined in ltmain.sh;
-  # decide which one to use based on capabilities of $DLLTOOL
-  case `$DLLTOOL --help 2>&1` in
-  *--identify-strict*)
-    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
-    ;;
-  *)
-    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
-    ;;
-  esac
-  ;;
-*)
-  # fallback: assume linklib IS sharedlib
-  lt_cv_sharedlib_from_linklib_cmd=$ECHO
-  ;;
-esac
-])
-sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
-test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
-
-_LT_DECL([], [sharedlib_from_linklib_cmd], [1],
-    [Command to associate shared and link libraries])
-])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
-
-
-# _LT_PATH_MANIFEST_TOOL
-# ----------------------
-# locate the manifest tool
-m4_defun([_LT_PATH_MANIFEST_TOOL],
-[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :)
-test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
-AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool],
-  [lt_cv_path_mainfest_tool=no
-  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD
-  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
-  cat conftest.err >&AS_MESSAGE_LOG_FD
-  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
-    lt_cv_path_mainfest_tool=yes
-  fi
-  rm -f conftest*])
-if test yes != "$lt_cv_path_mainfest_tool"; then
-  MANIFEST_TOOL=:
-fi
-_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl
-])# _LT_PATH_MANIFEST_TOOL
-
-
-# _LT_DLL_DEF_P([FILE])
-# ---------------------
-# True iff FILE is a Windows DLL '.def' file.
-# Keep in sync with func_dll_def_p in the libtool script
-AC_DEFUN([_LT_DLL_DEF_P],
-[dnl
-  test DEF = "`$SED -n dnl
-    -e '\''s/^[[	 ]]*//'\'' dnl Strip leading whitespace
-    -e '\''/^\(;.*\)*$/d'\'' dnl      Delete empty lines and comments
-    -e '\''s/^\(EXPORTS\|LIBRARY\)\([[	 ]].*\)*$/DEF/p'\'' dnl
-    -e q dnl                          Only consider the first "real" line
-    $1`" dnl
-])# _LT_DLL_DEF_P
-
-
-# LT_LIB_M
-# --------
-# check for math library
-AC_DEFUN([LT_LIB_M],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-LIBM=
-case $host in
-*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*)
-  # These system don't have libm, or don't need it
-  ;;
-*-ncr-sysv4.3*)
-  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw)
-  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
-  ;;
-*)
-  AC_CHECK_LIB(m, cos, LIBM=-lm)
-  ;;
-esac
-AC_SUBST([LIBM])
-])# LT_LIB_M
-
-# Old name:
-AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_CHECK_LIBM], [])
-
-
-# _LT_COMPILER_NO_RTTI([TAGNAME])
-# -------------------------------
-m4_defun([_LT_COMPILER_NO_RTTI],
-[m4_require([_LT_TAG_COMPILER])dnl
-
-_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
-
-if test yes = "$GCC"; then
-  case $cc_basename in
-  nvcc*)
-    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;
-  *)
-    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;;
-  esac
-
-  _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
-    lt_cv_prog_compiler_rtti_exceptions,
-    [-fno-rtti -fno-exceptions], [],
-    [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
-fi
-_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
-	[Compiler flag to turn off builtin functions])
-])# _LT_COMPILER_NO_RTTI
-
-
-# _LT_CMD_GLOBAL_SYMBOLS
-# ----------------------
-m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_PROG_AWK])dnl
-AC_REQUIRE([LT_PATH_NM])dnl
-AC_REQUIRE([LT_PATH_LD])dnl
-m4_require([_LT_DECL_SED])dnl
-m4_require([_LT_DECL_EGREP])dnl
-m4_require([_LT_TAG_COMPILER])dnl
-
-# Check for command to grab the raw symbol name followed by C symbol from nm.
-AC_MSG_CHECKING([command to parse $NM output from $compiler object])
-AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
-[
-# These are sane defaults that work on at least a few old systems.
-# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
-
-# Character class describing NM global symbol codes.
-symcode='[[BCDEGRST]]'
-
-# Regexp to match symbols that can be accessed directly from C.
-sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
-
-# Define system-specific variables.
-case $host_os in
-aix*)
-  symcode='[[BCDT]]'
-  ;;
-cygwin* | mingw* | pw32* | cegcc*)
-  symcode='[[ABCDGISTW]]'
-  ;;
-hpux*)
-  if test ia64 = "$host_cpu"; then
-    symcode='[[ABCDEGRST]]'
-  fi
-  ;;
-irix* | nonstopux*)
-  symcode='[[BCDEGRST]]'
-  ;;
-osf*)
-  symcode='[[BCDEGQRST]]'
-  ;;
-solaris*)
-  symcode='[[BDRT]]'
-  ;;
-sco3.2v5*)
-  symcode='[[DT]]'
-  ;;
-sysv4.2uw2*)
-  symcode='[[DT]]'
-  ;;
-sysv5* | sco5v6* | unixware* | OpenUNIX*)
-  symcode='[[ABDT]]'
-  ;;
-sysv4)
-  symcode='[[DFNSTU]]'
-  ;;
-esac
-
-# If we're using GNU nm, then use its standard symbol codes.
-case `$NM -V 2>&1` in
-*GNU* | *'with BFD'*)
-  symcode='[[ABCDGIRSTW]]' ;;
-esac
-
-if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-  # Gets list of data symbols to import.
-  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
-  # Adjust the below global symbol transforms to fixup imported variables.
-  lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
-  lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
-  lt_c_name_lib_hook="\
-  -e 's/^I .* \(lib.*\)$/  {\"\1\", (void *) 0},/p'\
-  -e 's/^I .* \(.*\)$/  {\"lib\1\", (void *) 0},/p'"
-else
-  # Disable hooks by default.
-  lt_cv_sys_global_symbol_to_import=
-  lt_cdecl_hook=
-  lt_c_name_hook=
-  lt_c_name_lib_hook=
-fi
-
-# Transform an extracted symbol line into a proper C declaration.
-# Some systems (esp. on ia64) link data and code symbols differently,
-# so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n"\
-$lt_cdecl_hook\
-" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
-
-# Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
-$lt_c_name_hook\
-" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
-
-# Transform an extracted symbol line into symbol name with lib prefix and
-# symbol address.
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
-$lt_c_name_lib_hook\
-" -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/  {\"lib\1\", (void *) \&\1},/p'"
-
-# Handle CRLF in mingw tool chain
-opt_cr=
-case $build_os in
-mingw*)
-  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
-  ;;
-esac
-
-# Try without a prefix underscore, then with it.
-for ac_symprfx in "" "_"; do
-
-  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
-  symxfrm="\\1 $ac_symprfx\\2 \\2"
-
-  # Write the raw and C identifiers.
-  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-    # Fake it for dumpbin and say T for any non-static function,
-    # D for any global variable and I for any imported variable.
-    # Also find C++ and __fastcall symbols from MSVC++,
-    # which start with @ or ?.
-    lt_cv_sys_global_symbol_pipe="$AWK ['"\
-"     {last_section=section; section=\$ 3};"\
-"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
-"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
-"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\
-"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
-"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
-"     \$ 0!~/External *\|/{next};"\
-"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
-"     {if(hide[section]) next};"\
-"     {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\
-"     {split(\$ 0,a,/\||\r/); split(a[2],s)};"\
-"     s[1]~/^[@?]/{print f,s[1],s[1]; next};"\
-"     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
-"     ' prfx=^$ac_symprfx]"
-  else
-    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
-  fi
-  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
-
-  # Check to see that the pipe works correctly.
-  pipe_works=no
-
-  rm -f conftest*
-  cat > conftest.$ac_ext <<_LT_EOF
-#ifdef __cplusplus
-extern "C" {
-#endif
-char nm_test_var;
-void nm_test_func(void);
-void nm_test_func(void){}
-#ifdef __cplusplus
-}
-#endif
-int main(){nm_test_var='a';nm_test_func();return(0);}
-_LT_EOF
-
-  if AC_TRY_EVAL(ac_compile); then
-    # Now try to grab the symbols.
-    nlist=conftest.nm
-    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&AS_MESSAGE_LOG_FD
-    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&AS_MESSAGE_LOG_FD && test -s "$nlist"; then
-      # Try sorting and uniquifying the output.
-      if sort "$nlist" | uniq > "$nlist"T; then
-	mv -f "$nlist"T "$nlist"
-      else
-	rm -f "$nlist"T
-      fi
-
-      # Make sure that we snagged all the symbols we need.
-      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
-	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
-	  cat <<_LT_EOF > conftest.$ac_ext
-/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
-#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
-/* DATA imports from DLLs on WIN32 can't be const, because runtime
-   relocations are performed -- see ld's documentation on pseudo-relocs.  */
-# define LT@&t@_DLSYM_CONST
-#elif defined __osf__
-/* This system does not cope well with relocations in const data.  */
-# define LT@&t@_DLSYM_CONST
-#else
-# define LT@&t@_DLSYM_CONST const
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-_LT_EOF
-	  # Now generate the symbol file.
-	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
-
-	  cat <<_LT_EOF >> conftest.$ac_ext
-
-/* The mapping between symbol names and symbols.  */
-LT@&t@_DLSYM_CONST struct {
-  const char *name;
-  void       *address;
-}
-lt__PROGRAM__LTX_preloaded_symbols[[]] =
-{
-  { "@PROGRAM@", (void *) 0 },
-_LT_EOF
-	  $SED "s/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
-	  cat <<\_LT_EOF >> conftest.$ac_ext
-  {0, (void *) 0}
-};
-
-/* This works around a problem in FreeBSD linker */
-#ifdef FREEBSD_WORKAROUND
-static const void *lt_preloaded_setup() {
-  return lt__PROGRAM__LTX_preloaded_symbols;
-}
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-_LT_EOF
-	  # Now try linking the two files.
-	  mv conftest.$ac_objext conftstm.$ac_objext
-	  lt_globsym_save_LIBS=$LIBS
-	  lt_globsym_save_CFLAGS=$CFLAGS
-	  LIBS=conftstm.$ac_objext
-	  CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
-	  if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then
-	    pipe_works=yes
-	  fi
-	  LIBS=$lt_globsym_save_LIBS
-	  CFLAGS=$lt_globsym_save_CFLAGS
-	else
-	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
-	fi
-      else
-	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
-      fi
-    else
-      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
-    fi
-  else
-    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
-    cat conftest.$ac_ext >&5
-  fi
-  rm -rf conftest* conftst*
-
-  # Do not use the global_symbol_pipe unless it works.
-  if test yes = "$pipe_works"; then
-    break
-  else
-    lt_cv_sys_global_symbol_pipe=
-  fi
-done
-])
-if test -z "$lt_cv_sys_global_symbol_pipe"; then
-  lt_cv_sys_global_symbol_to_cdecl=
-fi
-if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
-  AC_MSG_RESULT(failed)
-else
-  AC_MSG_RESULT(ok)
-fi
-
-# Response file support.
-if test "$lt_cv_nm_interface" = "MS dumpbin"; then
-  nm_file_list_spec='@'
-elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then
-  nm_file_list_spec='@'
-fi
-
-_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
-    [Take the output of nm and produce a listing of raw symbols and C names])
-_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
-    [Transform the output of nm in a proper C declaration])
-_LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1],
-    [Transform the output of nm into a list of symbols to manually relocate])
-_LT_DECL([global_symbol_to_c_name_address],
-    [lt_cv_sys_global_symbol_to_c_name_address], [1],
-    [Transform the output of nm in a C name address pair])
-_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
-    [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
-    [Transform the output of nm in a C name address pair when lib prefix is needed])
-_LT_DECL([nm_interface], [lt_cv_nm_interface], [1],
-    [The name lister interface])
-_LT_DECL([], [nm_file_list_spec], [1],
-    [Specify filename containing input files for $NM])
-]) # _LT_CMD_GLOBAL_SYMBOLS
-
-
-# _LT_COMPILER_PIC([TAGNAME])
-# ---------------------------
-m4_defun([_LT_COMPILER_PIC],
-[m4_require([_LT_TAG_COMPILER])dnl
-_LT_TAGVAR(lt_prog_compiler_wl, $1)=
-_LT_TAGVAR(lt_prog_compiler_pic, $1)=
-_LT_TAGVAR(lt_prog_compiler_static, $1)=
-
-m4_if([$1], [CXX], [
-  # C++ specific cases for pic, static, wl, etc.
-  if test yes = "$GXX"; then
-    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-
-    case $host_os in
-    aix*)
-      # All AIX code is PIC.
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      fi
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-        ;;
-      m68k)
-            # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the '-m68020' flag to GCC prevents building anything better,
-            # like '-m68040'.
-            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
-        ;;
-      esac
-      ;;
-
-    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
-      # PIC is the default for these OSes.
-      ;;
-    mingw* | cygwin* | os2* | pw32* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      # Although the cygwin gcc ignores -fPIC, still need this for old-style
-      # (--disable-auto-import) libraries
-      m4_if([$1], [GCJ], [],
-	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
-      case $host_os in
-      os2*)
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
-	;;
-      esac
-      ;;
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
-      ;;
-    *djgpp*)
-      # DJGPP does not support shared libraries at all
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)=
-      ;;
-    haiku*)
-      # PIC is the default for Haiku.
-      # The "-static" flag exists, but is broken.
-      _LT_TAGVAR(lt_prog_compiler_static, $1)=
-      ;;
-    interix[[3-9]]*)
-      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
-      # Instead, we relocate shared libraries at runtime.
-      ;;
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
-      fi
-      ;;
-    hpux*)
-      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
-      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
-      # sets the default TLS model and affects inlining.
-      case $host_cpu in
-      hppa*64*)
-	;;
-      *)
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	;;
-      esac
-      ;;
-    *qnx* | *nto*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
-      ;;
-    *)
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-      ;;
-    esac
-  else
-    case $host_os in
-      aix[[4-9]]*)
-	# All AIX code is PIC.
-	if test ia64 = "$host_cpu"; then
-	  # AIX 5 now supports IA64 processor
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	else
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
-	fi
-	;;
-      chorus*)
-	case $cc_basename in
-	cxch68*)
-	  # Green Hills C++ Compiler
-	  # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
-	  ;;
-	esac
-	;;
-      mingw* | cygwin* | os2* | pw32* | cegcc*)
-	# This hack is so that the source file can tell whether it is being
-	# built for inclusion in a dll (and should export symbols for example).
-	m4_if([$1], [GCJ], [],
-	  [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
-	;;
-      dgux*)
-	case $cc_basename in
-	  ec++*)
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	    ;;
-	  ghcx*)
-	    # Green Hills C++ Compiler
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      freebsd* | dragonfly*)
-	# FreeBSD uses GNU C++
-	;;
-      hpux9* | hpux10* | hpux11*)
-	case $cc_basename in
-	  CC*)
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
-	    if test ia64 != "$host_cpu"; then
-	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
-	    fi
-	    ;;
-	  aCC*)
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
-	    case $host_cpu in
-	    hppa*64*|ia64*)
-	      # +Z the default
-	      ;;
-	    *)
-	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
-	      ;;
-	    esac
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      interix*)
-	# This is c89, which is MS Visual C++ (no shared libs)
-	# Anyone wants to do a port?
-	;;
-      irix5* | irix6* | nonstopux*)
-	case $cc_basename in
-	  CC*)
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-	    # CC pic flag -KPIC is the default.
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-	case $cc_basename in
-	  KCC*)
-	    # KAI C++ Compiler
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	    ;;
-	  ecpc* )
-	    # old Intel C++ for x86_64, which still supported -KPIC.
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-	    ;;
-	  icpc* )
-	    # Intel C++, used to be incompatible with GCC.
-	    # ICC 10 doesn't accept -KPIC any more.
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-	    ;;
-	  pgCC* | pgcpp*)
-	    # Portland Group C++ compiler
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	    ;;
-	  cxx*)
-	    # Compaq C++
-	    # Make sure the PIC flag is empty.  It appears that all Alpha
-	    # Linux and Compaq Tru64 Unix objects are PIC.
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-	    ;;
-	  xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*)
-	    # IBM XL 8.0, 9.0 on PPC and BlueGene
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
-	    ;;
-	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
-	    *Sun\ C*)
-	      # Sun C++ 5.9
-	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
-	      ;;
-	    esac
-	    ;;
-	esac
-	;;
-      lynxos*)
-	;;
-      m88k*)
-	;;
-      mvs*)
-	case $cc_basename in
-	  cxx*)
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      netbsd* | netbsdelf*-gnu)
-	;;
-      *qnx* | *nto*)
-        # QNX uses GNU C++, but need to define -shared option too, otherwise
-        # it will coredump.
-        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
-        ;;
-      osf3* | osf4* | osf5*)
-	case $cc_basename in
-	  KCC*)
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
-	    ;;
-	  RCC*)
-	    # Rational C++ 2.4.1
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
-	    ;;
-	  cxx*)
-	    # Digital/Compaq C++
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    # Make sure the PIC flag is empty.  It appears that all Alpha
-	    # Linux and Compaq Tru64 Unix objects are PIC.
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      psos*)
-	;;
-      solaris*)
-	case $cc_basename in
-	  CC* | sunCC*)
-	    # Sun C++ 4.2, 5.x and Centerline C++
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
-	    ;;
-	  gcx*)
-	    # Green Hills C++ Compiler
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      sunos4*)
-	case $cc_basename in
-	  CC*)
-	    # Sun C++ 4.x
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	    ;;
-	  lcc*)
-	    # Lucid
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
-	case $cc_basename in
-	  CC*)
-	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	    ;;
-	esac
-	;;
-      tandem*)
-	case $cc_basename in
-	  NCC*)
-	    # NonStop-UX NCC 3.20
-	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	    ;;
-	  *)
-	    ;;
-	esac
-	;;
-      vxworks*)
-	;;
-      *)
-	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
-	;;
-    esac
-  fi
-],
-[
-  if test yes = "$GCC"; then
-    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-
-    case $host_os in
-      aix*)
-      # All AIX code is PIC.
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      fi
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-        ;;
-      m68k)
-            # FIXME: we need at least 68020 code to build shared libraries, but
-            # adding the '-m68020' flag to GCC prevents building anything better,
-            # like '-m68040'.
-            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
-        ;;
-      esac
-      ;;
-
-    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
-      # PIC is the default for these OSes.
-      ;;
-
-    mingw* | cygwin* | pw32* | os2* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      # Although the cygwin gcc ignores -fPIC, still need this for old-style
-      # (--disable-auto-import) libraries
-      m4_if([$1], [GCJ], [],
-	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
-      case $host_os in
-      os2*)
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
-	;;
-      esac
-      ;;
-
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
-      ;;
-
-    haiku*)
-      # PIC is the default for Haiku.
-      # The "-static" flag exists, but is broken.
-      _LT_TAGVAR(lt_prog_compiler_static, $1)=
-      ;;
-
-    hpux*)
-      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
-      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
-      # sets the default TLS model and affects inlining.
-      case $host_cpu in
-      hppa*64*)
-	# +Z the default
-	;;
-      *)
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	;;
-      esac
-      ;;
-
-    interix[[3-9]]*)
-      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
-      # Instead, we relocate shared libraries at runtime.
-      ;;
-
-    msdosdjgpp*)
-      # Just because we use GCC doesn't mean we suddenly get shared libraries
-      # on systems that don't support them.
-      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
-      enable_shared=no
-      ;;
-
-    *nto* | *qnx*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
-      fi
-      ;;
-
-    *)
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-      ;;
-    esac
-
-    case $cc_basename in
-    nvcc*) # Cuda Compiler Driver 2.2
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker '
-      if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
-        _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)"
-      fi
-      ;;
-    esac
-  else
-    # PORTME Check for flag to pass linker flags through the system compiler.
-    case $host_os in
-    aix*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      if test ia64 = "$host_cpu"; then
-	# AIX 5 now supports IA64 processor
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      else
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
-      fi
-      ;;
-
-    darwin* | rhapsody*)
-      # PIC is the default on this platform
-      # Common symbols not allowed in MH_DYLIB files
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
-      case $cc_basename in
-      nagfor*)
-        # NAG Fortran compiler
-        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
-        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
-        _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-        ;;
-      esac
-      ;;
-
-    mingw* | cygwin* | pw32* | os2* | cegcc*)
-      # This hack is so that the source file can tell whether it is being
-      # built for inclusion in a dll (and should export symbols for example).
-      m4_if([$1], [GCJ], [],
-	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
-      case $host_os in
-      os2*)
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
-	;;
-      esac
-      ;;
-
-    hpux9* | hpux10* | hpux11*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
-      # not for PA HP-UX.
-      case $host_cpu in
-      hppa*64*|ia64*)
-	# +Z the default
-	;;
-      *)
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
-	;;
-      esac
-      # Is there a better lt_prog_compiler_static that works with the bundled CC?
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive'
-      ;;
-
-    irix5* | irix6* | nonstopux*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      # PIC (with -KPIC) is the default.
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-      ;;
-
-    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-      case $cc_basename in
-      # old Intel for x86_64, which still supported -KPIC.
-      ecc*)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-        ;;
-      # flang / f18. f95 an alias for gfortran or flang on Debian
-      flang* | f18* | f95*)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-        ;;
-      # icc used to be incompatible with GCC.
-      # ICC 10 doesn't accept -KPIC any more.
-      icc* | ifort*)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-        ;;
-      # Lahey Fortran 8.1.
-      lf95*)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
-	;;
-      nagfor*)
-	# NAG Fortran compiler
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	;;
-      tcc*)
-	# Fabrice Bellard et al's Tiny C Compiler
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-	;;
-      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
-        # Portland Group compilers (*not* the Pentium gcc compiler,
-	# which looks to be a dead project)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-        ;;
-      ccc*)
-        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-        # All Alpha code is PIC.
-        _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-        ;;
-      xl* | bgxl* | bgf* | mpixl*)
-	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
-	;;
-      *)
-	case `$CC -V 2>&1 | sed 5q` in
-	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)
-	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
-	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	  _LT_TAGVAR(lt_prog_compiler_wl, $1)=''
-	  ;;
-	*Sun\ F* | *Sun*Fortran*)
-	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
-	  ;;
-	*Sun\ C*)
-	  # Sun C 5.9
-	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	  ;;
-        *Intel*\ [[CF]]*Compiler*)
-	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
-	  ;;
-	*Portland\ Group*)
-	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
-	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-	  ;;
-	esac
-	;;
-      esac
-      ;;
-
-    newsos6)
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      ;;
-
-    *nto* | *qnx*)
-      # QNX uses GNU C++, but need to define -shared option too, otherwise
-      # it will coredump.
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
-      ;;
-
-    osf3* | osf4* | osf5*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      # All OSF/1 code is PIC.
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-      ;;
-
-    rdos*)
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
-      ;;
-
-    solaris*)
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      case $cc_basename in
-      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
-      *)
-	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
-      esac
-      ;;
-
-    sunos4*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      ;;
-
-    sysv4 | sysv4.2uw2* | sysv4.3*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
-	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      fi
-      ;;
-
-    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      ;;
-
-    unicos*)
-      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
-      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
-      ;;
-
-    uts4*)
-      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
-      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
-      ;;
-
-    *)
-      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
-      ;;
-    esac
-  fi
-])
-case $host_os in
-  # For platforms that do not support PIC, -DPIC is meaningless:
-  *djgpp*)
-    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
-    ;;
-  *)
-    _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
-    ;;
-esac
-
-AC_CACHE_CHECK([for $compiler option to produce PIC],
-  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)],
-  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
-_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)
-
-#
-# Check to make sure the PIC flag actually works.
-#
-if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
-  _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
-    [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
-    [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
-    [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
-     "" | " "*) ;;
-     *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
-     esac],
-    [_LT_TAGVAR(lt_prog_compiler_pic, $1)=
-     _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
-fi
-_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
-	[Additional compiler flags for building library objects])
-
-_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
-	[How to pass a linker flag through the compiler])
-#
-# Check to make sure the static flag actually works.
-#
-wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
-_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
-  _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
-  $lt_tmp_static_flag,
-  [],
-  [_LT_TAGVAR(lt_prog_compiler_static, $1)=])
-_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
-	[Compiler flag to prevent dynamic linking])
-])# _LT_COMPILER_PIC
-
-
-# _LT_LINKER_SHLIBS([TAGNAME])
-# ----------------------------
-# See if the linker supports building shared libraries.
-m4_defun([_LT_LINKER_SHLIBS],
-[AC_REQUIRE([LT_PATH_LD])dnl
-AC_REQUIRE([LT_PATH_NM])dnl
-m4_require([_LT_PATH_MANIFEST_TOOL])dnl
-m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_DECL_EGREP])dnl
-m4_require([_LT_DECL_SED])dnl
-m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
-m4_require([_LT_TAG_COMPILER])dnl
-AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
-m4_if([$1], [CXX], [
-  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
-  case $host_os in
-  aix[[4-9]]*)
-    # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
-    # Without the "-l" option, or with the "-B" option, AIX nm treats
-    # weak defined symbols like other global defined symbols, whereas
-    # GNU nm marks them as "W".
-    # While the 'weak' keyword is ignored in the Export File, we need
-    # it in the Import File for the 'aix-soname' feature, so we have
-    # to replace the "-B" option with "-P" for AIX nm.
-    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
-    else
-      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
-    fi
-    ;;
-  pw32*)
-    _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds
-    ;;
-  cygwin* | mingw* | cegcc*)
-    case $cc_basename in
-    cl*)
-      _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
-      ;;
-    *)
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
-      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
-      ;;
-    esac
-    ;;
-  linux* | k*bsd*-gnu | gnu*)
-    _LT_TAGVAR(link_all_deplibs, $1)=no
-    ;;
-  *)
-    _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-    ;;
-  esac
-], [
-  runpath_var=
-  _LT_TAGVAR(allow_undefined_flag, $1)=
-  _LT_TAGVAR(always_export_symbols, $1)=no
-  _LT_TAGVAR(archive_cmds, $1)=
-  _LT_TAGVAR(archive_expsym_cmds, $1)=
-  _LT_TAGVAR(compiler_needs_object, $1)=no
-  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-  _LT_TAGVAR(export_dynamic_flag_spec, $1)=
-  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
-  _LT_TAGVAR(hardcode_automatic, $1)=no
-  _LT_TAGVAR(hardcode_direct, $1)=no
-  _LT_TAGVAR(hardcode_direct_absolute, $1)=no
-  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
-  _LT_TAGVAR(hardcode_libdir_separator, $1)=
-  _LT_TAGVAR(hardcode_minus_L, $1)=no
-  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
-  _LT_TAGVAR(inherit_rpath, $1)=no
-  _LT_TAGVAR(link_all_deplibs, $1)=unknown
-  _LT_TAGVAR(module_cmds, $1)=
-  _LT_TAGVAR(module_expsym_cmds, $1)=
-  _LT_TAGVAR(old_archive_from_new_cmds, $1)=
-  _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
-  _LT_TAGVAR(thread_safe_flag_spec, $1)=
-  _LT_TAGVAR(whole_archive_flag_spec, $1)=
-  # include_expsyms should be a list of space-separated symbols to be *always*
-  # included in the symbol list
-  _LT_TAGVAR(include_expsyms, $1)=
-  # exclude_expsyms can be an extended regexp of symbols to exclude
-  # it will be wrapped by ' (' and ')$', so one must not match beginning or
-  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
-  # as well as any symbol that contains 'd'.
-  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
-  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
-  # platforms (ab)use it in PIC code, but their linkers get confused if
-  # the symbol is explicitly referenced.  Since portable code cannot
-  # rely on this symbol name, it's probably fine to never include it in
-  # preloaded symbol tables.
-  # Exclude shared library initialization/finalization symbols.
-dnl Note also adjust exclude_expsyms for C++ above.
-  extract_expsyms_cmds=
-
-  case $host_os in
-  cygwin* | mingw* | pw32* | cegcc*)
-    # FIXME: the MSVC++ port hasn't been tested in a loooong time
-    # When not using gcc, we currently assume that we are using
-    # Microsoft Visual C++.
-    if test yes != "$GCC"; then
-      with_gnu_ld=no
-    fi
-    ;;
-  interix*)
-    # we just hope/assume this is gcc and not c89 (= MSVC++)
-    with_gnu_ld=yes
-    ;;
-  openbsd* | bitrig*)
-    with_gnu_ld=no
-    ;;
-  linux* | k*bsd*-gnu | gnu*)
-    _LT_TAGVAR(link_all_deplibs, $1)=no
-    ;;
-  esac
-
-  _LT_TAGVAR(ld_shlibs, $1)=yes
-
-  # On some targets, GNU ld is compatible enough with the native linker
-  # that we're better off using the native interface for both.
-  lt_use_gnu_ld_interface=no
-  if test yes = "$with_gnu_ld"; then
-    case $host_os in
-      aix*)
-	# The AIX port of GNU ld has always aspired to compatibility
-	# with the native linker.  However, as the warning in the GNU ld
-	# block says, versions before 2.19.5* couldn't really create working
-	# shared libraries, regardless of the interface used.
-	case `$LD -v 2>&1` in
-	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
-	  *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;;
-	  *\ \(GNU\ Binutils\)\ [[3-9]]*) ;;
-	  *)
-	    lt_use_gnu_ld_interface=yes
-	    ;;
-	esac
-	;;
-      *)
-	lt_use_gnu_ld_interface=yes
-	;;
-    esac
-  fi
-
-  if test yes = "$lt_use_gnu_ld_interface"; then
-    # If archive_cmds runs LD, not CC, wlarc should be empty
-    wlarc='$wl'
-
-    # Set some defaults for GNU ld with shared library support. These
-    # are reset later if shared libraries are not supported. Putting them
-    # here allows them to be overridden if necessary.
-    runpath_var=LD_RUN_PATH
-    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-    # ancient GNU ld didn't support --whole-archive et. al.
-    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
-      _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-    else
-      _LT_TAGVAR(whole_archive_flag_spec, $1)=
-    fi
-    supports_anon_versioning=no
-    case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in
-      *GNU\ gold*) supports_anon_versioning=yes ;;
-      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
-      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
-      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
-      *\ 2.11.*) ;; # other 2.11 versions
-      *) supports_anon_versioning=yes ;;
-    esac
-
-    # See if GNU ld supports shared libraries.
-    case $host_os in
-    aix[[3-9]]*)
-      # On AIX/PPC, the GNU linker is very broken
-      if test ia64 != "$host_cpu"; then
-	_LT_TAGVAR(ld_shlibs, $1)=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: the GNU linker, at least up to release 2.19, is reported
-*** to be unable to reliably create shared libraries on AIX.
-*** Therefore, libtool is disabling shared libraries support.  If you
-*** really care for shared libraries, you may want to install binutils
-*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
-*** You will then need to restart the configuration process.
-
-_LT_EOF
-      fi
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-            _LT_TAGVAR(archive_expsym_cmds, $1)=''
-        ;;
-      m68k)
-            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
-            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-            _LT_TAGVAR(hardcode_minus_L, $1)=yes
-        ;;
-      esac
-      ;;
-
-    beos*)
-      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
-	# support --undefined.  This deserves some investigation.  FIXME
-	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-      else
-	_LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-
-    cygwin* | mingw* | pw32* | cegcc*)
-      # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
-      # as there is no search path for DLLs.
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
-      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      _LT_TAGVAR(always_export_symbols, $1)=no
-      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
-      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
-
-      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	# If the export-symbols file already is a .def file, use it as
-	# is; otherwise, prepend EXPORTS...
-	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
-          cp $export_symbols $output_objdir/$soname.def;
-        else
-          echo EXPORTS > $output_objdir/$soname.def;
-          cat $export_symbols >> $output_objdir/$soname.def;
-        fi~
-        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-      else
-	_LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-
-    haiku*)
-      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-      _LT_TAGVAR(link_all_deplibs, $1)=yes
-      ;;
-
-    os2*)
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      shrext_cmds=.dll
-      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	prefix_cmds="$SED"~
-	if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	  prefix_cmds="$prefix_cmds -e 1d";
-	fi~
-	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-      ;;
-
-    interix[[3-9]]*)
-      _LT_TAGVAR(hardcode_direct, $1)=no
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
-      # Instead, shared libraries are loaded at an image base (0x10000000 by
-      # default) and relocated if they conflict, which is a slow very memory
-      # consuming and fragmenting process.  To avoid this, we pick a random,
-      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
-      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      ;;
-
-    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
-      tmp_diet=no
-      if test linux-dietlibc = "$host_os"; then
-	case $cc_basename in
-	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
-	esac
-      fi
-      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
-	 && test no = "$tmp_diet"
-      then
-	tmp_addflag=' $pic_flag'
-	tmp_sharedflag='-shared'
-	case $cc_basename,$host_cpu in
-        pgcc*)				# Portland Group C compiler
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  tmp_addflag=' $pic_flag'
-	  ;;
-	pgf77* | pgf90* | pgf95* | pgfortran*)
-					# Portland Group f77 and f90 compilers
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  tmp_addflag=' $pic_flag -Mnomain' ;;
-	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
-	  tmp_addflag=' -i_dynamic' ;;
-	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
-	  tmp_addflag=' -i_dynamic -nofor_main' ;;
-	ifc* | ifort*)			# Intel Fortran compiler
-	  tmp_addflag=' -nofor_main' ;;
-	lf95*)				# Lahey Fortran 8.1
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)=
-	  tmp_sharedflag='--shared' ;;
-        nagfor*)                        # NAGFOR 5.3
-          tmp_sharedflag='-Wl,-shared' ;;
-	xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)
-	  tmp_sharedflag='-qmkshrobj'
-	  tmp_addflag= ;;
-	nvcc*)	# Cuda Compiler Driver 2.2
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  _LT_TAGVAR(compiler_needs_object, $1)=yes
-	  ;;
-	esac
-	case `$CC -V 2>&1 | sed 5q` in
-	*Sun\ C*)			# Sun C 5.9
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	  _LT_TAGVAR(compiler_needs_object, $1)=yes
-	  tmp_sharedflag='-G' ;;
-	*Sun\ F*)			# Sun Fortran 8.3
-	  tmp_sharedflag='-G' ;;
-	esac
-	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-
-        if test yes = "$supports_anon_versioning"; then
-          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-            echo "local: *; };" >> $output_objdir/$libname.ver~
-            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
-        fi
-
-	case $cc_basename in
-	tcc*)
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic'
-	  ;;
-	xlf* | bgf* | bgxlf* | mpixlf*)
-	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
-	  if test yes = "$supports_anon_versioning"; then
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-              echo "local: *; };" >> $output_objdir/$libname.ver~
-              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
-	  fi
-	  ;;
-	esac
-      else
-        _LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-
-    netbsd* | netbsdelf*-gnu)
-      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
-	wlarc=
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      fi
-      ;;
-
-    solaris*)
-      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
-	_LT_TAGVAR(ld_shlibs, $1)=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: The releases 2.8.* of the GNU linker cannot reliably
-*** create shared libraries on Solaris systems.  Therefore, libtool
-*** is disabling shared libraries support.  We urge you to upgrade GNU
-*** binutils to release 2.9.1 or newer.  Another option is to modify
-*** your PATH or compiler configuration so that the native linker is
-*** used, and then restart.
-
-_LT_EOF
-      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      else
-	_LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-
-    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
-      case `$LD -v 2>&1` in
-        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
-	_LT_TAGVAR(ld_shlibs, $1)=no
-	cat <<_LT_EOF 1>&2
-
-*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
-*** reliably create shared libraries on SCO systems.  Therefore, libtool
-*** is disabling shared libraries support.  We urge you to upgrade GNU
-*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
-*** your PATH or compiler configuration so that the native linker is
-*** used, and then restart.
-
-_LT_EOF
-	;;
-	*)
-	  # For security reasons, it is highly recommended that you always
-	  # use absolute paths for naming shared libraries, and exclude the
-	  # DT_RUNPATH tag from executables and libraries.  But doing so
-	  # requires that you compile everything twice, which is a pain.
-	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	  else
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	  fi
-	;;
-      esac
-      ;;
-
-    sunos4*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-      wlarc=
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    *)
-      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-      else
-	_LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-    esac
-
-    if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then
-      runpath_var=
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)=
-      _LT_TAGVAR(whole_archive_flag_spec, $1)=
-    fi
-  else
-    # PORTME fill in a description of your system's linker (not GNU ld)
-    case $host_os in
-    aix3*)
-      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      _LT_TAGVAR(always_export_symbols, $1)=yes
-      _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
-      # Note: this linker hardcodes the directories in LIBPATH if there
-      # are no directories specified by -L.
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
-	# Neither direct hardcoding nor static linking is supported with a
-	# broken collect2.
-	_LT_TAGVAR(hardcode_direct, $1)=unsupported
-      fi
-      ;;
-
-    aix[[4-9]]*)
-      if test ia64 = "$host_cpu"; then
-	# On IA64, the linker does run time linking by default, so we don't
-	# have to do anything special.
-	aix_use_runtimelinking=no
-	exp_sym_flag='-Bexport'
-	no_entry_flag=
-      else
-	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
-	# Without the "-l" option, or with the "-B" option, AIX nm treats
-	# weak defined symbols like other global defined symbols, whereas
-	# GNU nm marks them as "W".
-	# While the 'weak' keyword is ignored in the Export File, we need
-	# it in the Import File for the 'aix-soname' feature, so we have
-	# to replace the "-B" option with "-P" for AIX nm.
-	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
-	else
-	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
-	fi
-	aix_use_runtimelinking=no
-
-	# Test if we are trying to use run time linking or normal
-	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# have runtime linking enabled, and use it for executables.
-	# For shared libraries, we enable/disable runtime linking
-	# depending on the kind of the shared library created -
-	# when "with_aix_soname,aix_use_runtimelinking" is:
-	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
-	# "aix,yes"  lib.so          shared, rtl:yes, for executables
-	#            lib.a           static archive
-	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
-	#            lib.a(lib.so.V) shared, rtl:no,  for executables
-	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
-	#            lib.a(lib.so.V) shared, rtl:no
-	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
-	#            lib.a           static archive
-	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
-	  for ld_flag in $LDFLAGS; do
-	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
-	    aix_use_runtimelinking=yes
-	    break
-	  fi
-	  done
-	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
-	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
-	    # so we don't have lib.a shared libs to link our executables.
-	    # We have to force runtime linking in this case.
-	    aix_use_runtimelinking=yes
-	    LDFLAGS="$LDFLAGS -Wl,-brtl"
-	  fi
-	  ;;
-	esac
-
-	exp_sym_flag='-bexport'
-	no_entry_flag='-bnoentry'
-      fi
-
-      # When large executables or shared objects are built, AIX ld can
-      # have problems creating the table of contents.  If linking a library
-      # or program results in "error TOC overflow" add -mminimal-toc to
-      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
-      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
-      _LT_TAGVAR(archive_cmds, $1)=''
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
-      _LT_TAGVAR(link_all_deplibs, $1)=yes
-      _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
-      case $with_aix_soname,$aix_use_runtimelinking in
-      aix,*) ;; # traditional, no import file
-      svr4,* | *,yes) # use import file
-	# The Import File defines what to hardcode.
-	_LT_TAGVAR(hardcode_direct, $1)=no
-	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
-	;;
-      esac
-
-      if test yes = "$GCC"; then
-	case $host_os in aix4.[[012]]|aix4.[[012]].*)
-	# We only want to do this on AIX 4.2 and lower, the check
-	# below for broken collect2 doesn't work under 4.3+
-	  collect2name=`$CC -print-prog-name=collect2`
-	  if test -f "$collect2name" &&
-	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
-	  then
-	  # We have reworked collect2
-	  :
-	  else
-	  # We have old collect2
-	  _LT_TAGVAR(hardcode_direct, $1)=unsupported
-	  # It fails to find uninstalled libraries when the uninstalled
-	  # path is not listed in the libpath.  Setting hardcode_minus_L
-	  # to unsupported forces relinking
-	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-	  _LT_TAGVAR(hardcode_libdir_separator, $1)=
-	  fi
-	  ;;
-	esac
-	shared_flag='-shared'
-	if test yes = "$aix_use_runtimelinking"; then
-	  shared_flag="$shared_flag "'$wl-G'
-	fi
-	# Need to ensure runtime linking is disabled for the traditional
-	# shared library, or the linker may eventually find shared libraries
-	# /with/ Import File - we do not want to mix them.
-	shared_flag_aix='-shared'
-	shared_flag_svr4='-shared $wl-G'
-      else
-	# not using gcc
-	if test ia64 = "$host_cpu"; then
-	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
-	# chokes on -Wl,-G. The following line is correct:
-	  shared_flag='-G'
-	else
-	  if test yes = "$aix_use_runtimelinking"; then
-	    shared_flag='$wl-G'
-	  else
-	    shared_flag='$wl-bM:SRE'
-	  fi
-	  shared_flag_aix='$wl-bM:SRE'
-	  shared_flag_svr4='$wl-G'
-	fi
-      fi
-
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
-      # It seems that -bexpall does not export symbols beginning with
-      # underscore (_), so it is better to generate a list of symbols to export.
-      _LT_TAGVAR(always_export_symbols, $1)=yes
-      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
-	# Warning - without using the other runtime loading flags (-brtl),
-	# -berok will link without error, but may produce a broken library.
-	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
-        # Determine the default libpath from the value encoded in an
-        # empty executable.
-        _LT_SYS_MODULE_PATH_AIX([$1])
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
-        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
-      else
-	if test ia64 = "$host_cpu"; then
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
-	  _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
-	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
-	else
-	 # Determine the default libpath from the value encoded in an
-	 # empty executable.
-	 _LT_SYS_MODULE_PATH_AIX([$1])
-	 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
-	  # Warning - without using the other run time loading flags,
-	  # -berok will link without error, but may produce a broken library.
-	  _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
-	  _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
-	  if test yes = "$with_gnu_ld"; then
-	    # We only use this code for GNU lds that support --whole-archive.
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
-	  else
-	    # Exported symbols can be pulled into shared objects from archives
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
-	  fi
-	  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
-	  # -brtl affects multiple linker settings, -berok does not and is overridden later
-	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
-	  if test svr4 != "$with_aix_soname"; then
-	    # This is similar to how AIX traditionally builds its shared libraries.
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
-	  fi
-	  if test aix != "$with_aix_soname"; then
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
-	  else
-	    # used by -dlpreopen to get the symbols
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
-	  fi
-	  _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
-	fi
-      fi
-      ;;
-
-    amigaos*)
-      case $host_cpu in
-      powerpc)
-            # see comment about AmigaOS4 .so support
-            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-            _LT_TAGVAR(archive_expsym_cmds, $1)=''
-        ;;
-      m68k)
-            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
-            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-            _LT_TAGVAR(hardcode_minus_L, $1)=yes
-        ;;
-      esac
-      ;;
-
-    bsdi[[45]]*)
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
-      ;;
-
-    cygwin* | mingw* | pw32* | cegcc*)
-      # When not using gcc, we currently assume that we are using
-      # Microsoft Visual C++.
-      # hardcode_libdir_flag_spec is actually meaningless, as there is
-      # no search path for DLLs.
-      case $cc_basename in
-      cl*)
-	# Native MSVC
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
-	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	_LT_TAGVAR(always_export_symbols, $1)=yes
-	_LT_TAGVAR(file_list_spec, $1)='@'
-	# Tell ltmain to make .lib files, not .a files.
-	libext=lib
-	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=.dll
-	# FIXME: Setting linknames here is a bad hack.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
-	_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
-            cp "$export_symbols" "$output_objdir/$soname.def";
-            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
-          else
-            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
-          fi~
-          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-          linknames='
-	# The linker will not automatically build a static lib if we build a DLL.
-	# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
-	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-	_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
-	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
-	# Don't use ranlib
-	_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
-	_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
-          lt_tool_outputfile="@TOOL_OUTPUT@"~
-          case $lt_outputfile in
-            *.exe|*.EXE) ;;
-            *)
-              lt_outputfile=$lt_outputfile.exe
-              lt_tool_outputfile=$lt_tool_outputfile.exe
-              ;;
-          esac~
-          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
-            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-            $RM "$lt_outputfile.manifest";
-          fi'
-	;;
-      *)
-	# Assume MSVC wrapper
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
-	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	# Tell ltmain to make .lib files, not .a files.
-	libext=lib
-	# Tell ltmain to make .dll files, not .so files.
-	shrext_cmds=.dll
-	# FIXME: Setting linknames here is a bad hack.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
-	# The linker will automatically build a .lib file if we build a DLL.
-	_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
-	# FIXME: Should let the user specify the lib program.
-	_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
-	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-	;;
-      esac
-      ;;
-
-    darwin* | rhapsody*)
-      _LT_DARWIN_LINKER_FEATURES($1)
-      ;;
-
-    dgux*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
-    # support.  Future versions do this automatically, but an explicit c++rt0.o
-    # does not break anything, and helps significantly (at the cost of a little
-    # extra space).
-    freebsd2.2*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
-    freebsd2.*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
-      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    hpux9*)
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-      fi
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-
-      # hardcode_minus_L: Not really in the search PATH,
-      # but as the default location of the library.
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-      ;;
-
-    hpux10*)
-      if test yes,no = "$GCC,$with_gnu_ld"; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
-      fi
-      if test no = "$with_gnu_ld"; then
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
-	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
-	_LT_TAGVAR(hardcode_direct, $1)=yes
-	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-	# hardcode_minus_L: Not really in the search PATH,
-	# but as the default location of the library.
-	_LT_TAGVAR(hardcode_minus_L, $1)=yes
-      fi
-      ;;
-
-    hpux11*)
-      if test yes,no = "$GCC,$with_gnu_ld"; then
-	case $host_cpu in
-	hppa*64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	ia64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	esac
-      else
-	case $host_cpu in
-	hppa*64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	ia64*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-	m4_if($1, [], [
-	  # Older versions of the 11.00 compiler do not understand -b yet
-	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
-	  _LT_LINKER_OPTION([if $CC understands -b],
-	    _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],
-	    [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
-	    [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],
-	  [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
-	  ;;
-	esac
-      fi
-      if test no = "$with_gnu_ld"; then
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
-	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-	case $host_cpu in
-	hppa*64*|ia64*)
-	  _LT_TAGVAR(hardcode_direct, $1)=no
-	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	  ;;
-	*)
-	  _LT_TAGVAR(hardcode_direct, $1)=yes
-	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-
-	  # hardcode_minus_L: Not really in the search PATH,
-	  # but as the default location of the library.
-	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
-	  ;;
-	esac
-      fi
-      ;;
-
-    irix5* | irix6* | nonstopux*)
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	# Try to use the -exported_symbol ld option, if it does not
-	# work, assume that -exports_file does not work either and
-	# implicitly export all symbols.
-	# This should be the same for all languages, so no per-tag cache variable.
-	AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],
-	  [lt_cv_irix_exported_symbol],
-	  [save_LDFLAGS=$LDFLAGS
-	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
-	   AC_LINK_IFELSE(
-	     [AC_LANG_SOURCE(
-	        [AC_LANG_CASE([C], [[int foo (void) { return 0; }]],
-			      [C++], [[int foo (void) { return 0; }]],
-			      [Fortran 77], [[
-      subroutine foo
-      end]],
-			      [Fortran], [[
-      subroutine foo
-      end]])])],
-	      [lt_cv_irix_exported_symbol=yes],
-	      [lt_cv_irix_exported_symbol=no])
-           LDFLAGS=$save_LDFLAGS])
-	if test yes = "$lt_cv_irix_exported_symbol"; then
-          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
-	fi
-	_LT_TAGVAR(link_all_deplibs, $1)=no
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
-      fi
-      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-      _LT_TAGVAR(inherit_rpath, $1)=yes
-      _LT_TAGVAR(link_all_deplibs, $1)=yes
-      ;;
-
-    linux*)
-      case $cc_basename in
-      tcc*)
-	# Fabrice Bellard et al's Tiny C Compiler
-	_LT_TAGVAR(ld_shlibs, $1)=yes
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	;;
-      esac
-      ;;
-
-    netbsd* | netbsdelf*-gnu)
-      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
-      fi
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    newsos6)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    *nto* | *qnx*)
-      ;;
-
-    openbsd* | bitrig*)
-      if test -f /usr/libexec/ld.so; then
-	_LT_TAGVAR(hardcode_direct, $1)=yes
-	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-	else
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	fi
-      else
-	_LT_TAGVAR(ld_shlibs, $1)=no
-      fi
-      ;;
-
-    os2*)
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      shrext_cmds=.dll
-      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	$ECHO EXPORTS >> $output_objdir/$libname.def~
-	prefix_cmds="$SED"~
-	if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	  prefix_cmds="$prefix_cmds -e 1d";
-	fi~
-	prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	emximp -o $lib $output_objdir/$libname.def'
-      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-      ;;
-
-    osf3*)
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-      else
-	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-      fi
-      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-      ;;
-
-    osf4* | osf5*)	# as osf3* with the addition of -msym flag
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-      else
-	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
-          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
-
-	# Both c and cxx compiler support -rpath directly
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
-      fi
-      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-      ;;
-
-    solaris*)
-      _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
-      if test yes = "$GCC"; then
-	wlarc='$wl'
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
-      else
-	case `$CC -V 2>&1` in
-	*"Compilers 5.0"*)
-	  wlarc=''
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
-	  ;;
-	*)
-	  wlarc='$wl'
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
-	  ;;
-	esac
-      fi
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      case $host_os in
-      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
-      *)
-	# The compiler driver will combine and reorder linker options,
-	# but understands '-z linker_flag'.  GCC discards it without '$wl',
-	# but is careful enough not to reorder.
-	# Supported since Solaris 2.6 (maybe 2.5.1?)
-	if test yes = "$GCC"; then
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
-	else
-	  _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
-	fi
-	;;
-      esac
-      _LT_TAGVAR(link_all_deplibs, $1)=yes
-      ;;
-
-    sunos4*)
-      if test sequent = "$host_vendor"; then
-	# Use $CC to link under sequent, because it throws in some extra .o
-	# files that make .init and .fini sections work.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
-      fi
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(hardcode_direct, $1)=yes
-      _LT_TAGVAR(hardcode_minus_L, $1)=yes
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    sysv4)
-      case $host_vendor in
-	sni)
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
-	;;
-	siemens)
-	  ## LD is ld it makes a PLAMLIB
-	  ## CC just makes a GrossModule.
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
-	  _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
-	  _LT_TAGVAR(hardcode_direct, $1)=no
-        ;;
-	motorola)
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	  _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
-	;;
-      esac
-      runpath_var='LD_RUN_PATH'
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    sysv4.3*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
-      ;;
-
-    sysv4*MP*)
-      if test -d /usr/nec; then
-	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	runpath_var=LD_RUN_PATH
-	hardcode_runpath_var=yes
-	_LT_TAGVAR(ld_shlibs, $1)=yes
-      fi
-      ;;
-
-    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
-      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
-      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      runpath_var='LD_RUN_PATH'
-
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      fi
-      ;;
-
-    sysv5* | sco3.2v5* | sco5v6*)
-      # Note: We CANNOT use -z defs as we might desire, because we do not
-      # link with -lc, and that would cause any symbols used from libc to
-      # always be unresolved, which means just about no library would
-      # ever link correctly.  If we're not using GNU ld we use -z text
-      # though, which does catch some bad symbols but isn't as heavy-handed
-      # as -z defs.
-      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
-      _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
-      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
-      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
-      _LT_TAGVAR(link_all_deplibs, $1)=yes
-      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
-      runpath_var='LD_RUN_PATH'
-
-      if test yes = "$GCC"; then
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      else
-	_LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-      fi
-      ;;
-
-    uts4*)
-      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
-      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      ;;
-
-    *)
-      _LT_TAGVAR(ld_shlibs, $1)=no
-      ;;
-    esac
-
-    if test sni = "$host_vendor"; then
-      case $host in
-      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym'
-	;;
-      esac
-    fi
-  fi
-])
-AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
-test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
-
-_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
-
-_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
-_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
-_LT_DECL([], [extract_expsyms_cmds], [2],
-    [The commands to extract the exported symbol list from a shared archive])
-
-#
-# Do we need to explicitly link libc?
-#
-case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
-x|xyes)
-  # Assume -lc should be added
-  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-
-  if test yes,yes = "$GCC,$enable_shared"; then
-    case $_LT_TAGVAR(archive_cmds, $1) in
-    *'~'*)
-      # FIXME: we may have to deal with multi-command sequences.
-      ;;
-    '$CC '*)
-      # Test whether the compiler implicitly links with -lc since on some
-      # systems, -lgcc has to come before -lc. If gcc already passes -lc
-      # to ld, don't add -lc before -lgcc.
-      AC_CACHE_CHECK([whether -lc should be explicitly linked in],
-	[lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1),
-	[$RM conftest*
-	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
-
-	if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
-	  soname=conftest
-	  lib=conftest
-	  libobjs=conftest.$ac_objext
-	  deplibs=
-	  wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
-	  pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
-	  compiler_flags=-v
-	  linker_flags=-v
-	  verstring=
-	  output_objdir=.
-	  libname=conftest
-	  lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
-	  _LT_TAGVAR(allow_undefined_flag, $1)=
-	  if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
-	  then
-	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-	  else
-	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	  fi
-	  _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
-	else
-	  cat conftest.err 1>&5
-	fi
-	$RM conftest*
-	])
-      _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)
-      ;;
-    esac
-  fi
-  ;;
-esac
-
-_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
-    [Whether or not to add -lc for building shared libraries])
-_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
-    [enable_shared_with_static_runtimes], [0],
-    [Whether or not to disallow shared libs when runtime libs are static])
-_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
-    [Compiler flag to allow reflexive dlopens])
-_LT_TAGDECL([], [whole_archive_flag_spec], [1],
-    [Compiler flag to generate shared objects directly from archives])
-_LT_TAGDECL([], [compiler_needs_object], [1],
-    [Whether the compiler copes with passing no objects directly])
-_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
-    [Create an old-style archive from a shared archive])
-_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
-    [Create a temporary old-style archive to link instead of a shared archive])
-_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
-_LT_TAGDECL([], [archive_expsym_cmds], [2])
-_LT_TAGDECL([], [module_cmds], [2],
-    [Commands used to build a loadable module if different from building
-    a shared archive.])
-_LT_TAGDECL([], [module_expsym_cmds], [2])
-_LT_TAGDECL([], [with_gnu_ld], [1],
-    [Whether we are building with GNU ld or not])
-_LT_TAGDECL([], [allow_undefined_flag], [1],
-    [Flag that allows shared libraries with undefined symbols to be built])
-_LT_TAGDECL([], [no_undefined_flag], [1],
-    [Flag that enforces no undefined symbols])
-_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
-    [Flag to hardcode $libdir into a binary during linking.
-    This must work even if $libdir does not exist])
-_LT_TAGDECL([], [hardcode_libdir_separator], [1],
-    [Whether we need a single "-rpath" flag with a separated argument])
-_LT_TAGDECL([], [hardcode_direct], [0],
-    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
-    DIR into the resulting binary])
-_LT_TAGDECL([], [hardcode_direct_absolute], [0],
-    [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes
-    DIR into the resulting binary and the resulting library dependency is
-    "absolute", i.e impossible to change by setting $shlibpath_var if the
-    library is relocated])
-_LT_TAGDECL([], [hardcode_minus_L], [0],
-    [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
-    into the resulting binary])
-_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
-    [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
-    into the resulting binary])
-_LT_TAGDECL([], [hardcode_automatic], [0],
-    [Set to "yes" if building a shared library automatically hardcodes DIR
-    into the library and all subsequent libraries and executables linked
-    against it])
-_LT_TAGDECL([], [inherit_rpath], [0],
-    [Set to yes if linker adds runtime paths of dependent libraries
-    to runtime path list])
-_LT_TAGDECL([], [link_all_deplibs], [0],
-    [Whether libtool must link a program against all its dependency libraries])
-_LT_TAGDECL([], [always_export_symbols], [0],
-    [Set to "yes" if exported symbols are required])
-_LT_TAGDECL([], [export_symbols_cmds], [2],
-    [The commands to list exported symbols])
-_LT_TAGDECL([], [exclude_expsyms], [1],
-    [Symbols that should not be listed in the preloaded symbols])
-_LT_TAGDECL([], [include_expsyms], [1],
-    [Symbols that must always be exported])
-_LT_TAGDECL([], [prelink_cmds], [2],
-    [Commands necessary for linking programs (against libraries) with templates])
-_LT_TAGDECL([], [postlink_cmds], [2],
-    [Commands necessary for finishing linking programs])
-_LT_TAGDECL([], [file_list_spec], [1],
-    [Specify filename containing input files])
-dnl FIXME: Not yet implemented
-dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
-dnl    [Compiler flag to generate thread safe objects])
-])# _LT_LINKER_SHLIBS
-
-
-# _LT_LANG_C_CONFIG([TAG])
-# ------------------------
-# Ensure that the configuration variables for a C compiler are suitably
-# defined.  These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_C_CONFIG],
-[m4_require([_LT_DECL_EGREP])dnl
-lt_save_CC=$CC
-AC_LANG_PUSH(C)
-
-# Source file extension for C test sources.
-ac_ext=c
-
-# Object file extension for compiled C test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="int some_variable = 0;"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='int main(){return(0);}'
-
-_LT_TAG_COMPILER
-# Save the default compiler, since it gets overwritten when the other
-# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
-compiler_DEFAULT=$CC
-
-# save warnings/boilerplate of simple test code
-_LT_COMPILER_BOILERPLATE
-_LT_LINKER_BOILERPLATE
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
-  _LT_COMPILER_NO_RTTI($1)
-  _LT_COMPILER_PIC($1)
-  _LT_COMPILER_C_O($1)
-  _LT_COMPILER_FILE_LOCKS($1)
-  _LT_LINKER_SHLIBS($1)
-  _LT_SYS_DYNAMIC_LINKER($1)
-  _LT_LINKER_HARDCODE_LIBPATH($1)
-  LT_SYS_DLOPEN_SELF
-  _LT_CMD_STRIPLIB
-
-  # Report what library types will actually be built
-  AC_MSG_CHECKING([if libtool supports shared libraries])
-  AC_MSG_RESULT([$can_build_shared])
-
-  AC_MSG_CHECKING([whether to build shared libraries])
-  test no = "$can_build_shared" && enable_shared=no
-
-  # On AIX, shared libraries and static libraries use the same namespace, and
-  # are all built from PIC.
-  case $host_os in
-  aix3*)
-    test yes = "$enable_shared" && enable_static=no
-    if test -n "$RANLIB"; then
-      archive_cmds="$archive_cmds~\$RANLIB \$lib"
-      postinstall_cmds='$RANLIB $lib'
-    fi
-    ;;
-
-  aix[[4-9]]*)
-    if test ia64 != "$host_cpu"; then
-      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
-      yes,aix,yes) ;;			# shared object as lib.so file only
-      yes,svr4,*) ;;			# shared object as lib.so archive member only
-      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
-      esac
-    fi
-    ;;
-  esac
-  AC_MSG_RESULT([$enable_shared])
-
-  AC_MSG_CHECKING([whether to build static libraries])
-  # Make sure either enable_shared or enable_static is yes.
-  test yes = "$enable_shared" || enable_static=yes
-  AC_MSG_RESULT([$enable_static])
-
-  _LT_CONFIG($1)
-fi
-AC_LANG_POP
-CC=$lt_save_CC
-])# _LT_LANG_C_CONFIG
-
-
-# _LT_LANG_CXX_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for a C++ compiler are suitably
-# defined.  These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_CXX_CONFIG],
-[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-m4_require([_LT_DECL_EGREP])dnl
-m4_require([_LT_PATH_MANIFEST_TOOL])dnl
-if test -n "$CXX" && ( test no != "$CXX" &&
-    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
-    (test g++ != "$CXX"))); then
-  AC_PROG_CXXCPP
-else
-  _lt_caught_CXX_error=yes
-fi
-
-AC_LANG_PUSH(C++)
-_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-_LT_TAGVAR(allow_undefined_flag, $1)=
-_LT_TAGVAR(always_export_symbols, $1)=no
-_LT_TAGVAR(archive_expsym_cmds, $1)=
-_LT_TAGVAR(compiler_needs_object, $1)=no
-_LT_TAGVAR(export_dynamic_flag_spec, $1)=
-_LT_TAGVAR(hardcode_direct, $1)=no
-_LT_TAGVAR(hardcode_direct_absolute, $1)=no
-_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
-_LT_TAGVAR(hardcode_libdir_separator, $1)=
-_LT_TAGVAR(hardcode_minus_L, $1)=no
-_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
-_LT_TAGVAR(hardcode_automatic, $1)=no
-_LT_TAGVAR(inherit_rpath, $1)=no
-_LT_TAGVAR(module_cmds, $1)=
-_LT_TAGVAR(module_expsym_cmds, $1)=
-_LT_TAGVAR(link_all_deplibs, $1)=unknown
-_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_TAGVAR(reload_flag, $1)=$reload_flag
-_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
-_LT_TAGVAR(no_undefined_flag, $1)=
-_LT_TAGVAR(whole_archive_flag_spec, $1)=
-_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-
-# Source file extension for C++ test sources.
-ac_ext=cpp
-
-# Object file extension for compiled C++ test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# No sense in running all these tests if we already determined that
-# the CXX compiler isn't working.  Some variables (like enable_shared)
-# are currently assumed to apply to all compilers on this platform,
-# and will be corrupted by setting them based on a non-working compiler.
-if test yes != "$_lt_caught_CXX_error"; then
-  # Code to be used in simple compile tests
-  lt_simple_compile_test_code="int some_variable = 0;"
-
-  # Code to be used in simple link tests
-  lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
-
-  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
-  _LT_TAG_COMPILER
-
-  # save warnings/boilerplate of simple test code
-  _LT_COMPILER_BOILERPLATE
-  _LT_LINKER_BOILERPLATE
-
-  # Allow CC to be a program name with arguments.
-  lt_save_CC=$CC
-  lt_save_CFLAGS=$CFLAGS
-  lt_save_LD=$LD
-  lt_save_GCC=$GCC
-  GCC=$GXX
-  lt_save_with_gnu_ld=$with_gnu_ld
-  lt_save_path_LD=$lt_cv_path_LD
-  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
-    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
-  else
-    $as_unset lt_cv_prog_gnu_ld
-  fi
-  if test -n "${lt_cv_path_LDCXX+set}"; then
-    lt_cv_path_LD=$lt_cv_path_LDCXX
-  else
-    $as_unset lt_cv_path_LD
-  fi
-  test -z "${LDCXX+set}" || LD=$LDCXX
-  CC=${CXX-"c++"}
-  CFLAGS=$CXXFLAGS
-  compiler=$CC
-  _LT_TAGVAR(compiler, $1)=$CC
-  _LT_CC_BASENAME([$compiler])
-
-  if test -n "$compiler"; then
-    # We don't want -fno-exception when compiling C++ code, so set the
-    # no_builtin_flag separately
-    if test yes = "$GXX"; then
-      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
-    else
-      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
-    fi
-
-    if test yes = "$GXX"; then
-      # Set up default GNU C++ configuration
-
-      LT_PATH_LD
-
-      # Check if GNU C++ uses GNU ld as the underlying linker, since the
-      # archiving commands below assume that GNU ld is being used.
-      if test yes = "$with_gnu_ld"; then
-        _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-
-        # If archive_cmds runs LD, not CC, wlarc should be empty
-        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
-        #     investigate it a little bit more. (MM)
-        wlarc='$wl'
-
-        # ancient GNU ld didn't support --whole-archive et. al.
-        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
-	  $GREP 'no-whole-archive' > /dev/null; then
-          _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-        else
-          _LT_TAGVAR(whole_archive_flag_spec, $1)=
-        fi
-      else
-        with_gnu_ld=no
-        wlarc=
-
-        # A generic and very simple default shared library creation
-        # command for GNU C++ for the case where it uses the native
-        # linker, instead of GNU ld.  If possible, this setting should
-        # overridden to take advantage of the native linker features on
-        # the platform it is being used on.
-        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-      fi
-
-      # Commands to make compiler produce verbose output that lists
-      # what "hidden" libraries, object files and flags are used when
-      # linking a shared library.
-      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-
-    else
-      GXX=no
-      with_gnu_ld=no
-      wlarc=
-    fi
-
-    # PORTME: fill in a description of your system's C++ link characteristics
-    AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
-    _LT_TAGVAR(ld_shlibs, $1)=yes
-    case $host_os in
-      aix3*)
-        # FIXME: insert proper C++ library support
-        _LT_TAGVAR(ld_shlibs, $1)=no
-        ;;
-      aix[[4-9]]*)
-        if test ia64 = "$host_cpu"; then
-          # On IA64, the linker does run time linking by default, so we don't
-          # have to do anything special.
-          aix_use_runtimelinking=no
-          exp_sym_flag='-Bexport'
-          no_entry_flag=
-        else
-          aix_use_runtimelinking=no
-
-          # Test if we are trying to use run time linking or normal
-          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # have runtime linking enabled, and use it for executables.
-          # For shared libraries, we enable/disable runtime linking
-          # depending on the kind of the shared library created -
-          # when "with_aix_soname,aix_use_runtimelinking" is:
-          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
-          # "aix,yes"  lib.so          shared, rtl:yes, for executables
-          #            lib.a           static archive
-          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
-          #            lib.a(lib.so.V) shared, rtl:no,  for executables
-          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
-          #            lib.a(lib.so.V) shared, rtl:no
-          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
-          #            lib.a           static archive
-          case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
-	    for ld_flag in $LDFLAGS; do
-	      case $ld_flag in
-	      *-brtl*)
-	        aix_use_runtimelinking=yes
-	        break
-	        ;;
-	      esac
-	    done
-	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
-	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
-	      # so we don't have lib.a shared libs to link our executables.
-	      # We have to force runtime linking in this case.
-	      aix_use_runtimelinking=yes
-	      LDFLAGS="$LDFLAGS -Wl,-brtl"
-	    fi
-	    ;;
-          esac
-
-          exp_sym_flag='-bexport'
-          no_entry_flag='-bnoentry'
-        fi
-
-        # When large executables or shared objects are built, AIX ld can
-        # have problems creating the table of contents.  If linking a library
-        # or program results in "error TOC overflow" add -mminimal-toc to
-        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
-        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
-        _LT_TAGVAR(archive_cmds, $1)=''
-        _LT_TAGVAR(hardcode_direct, $1)=yes
-        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-        _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
-        _LT_TAGVAR(link_all_deplibs, $1)=yes
-        _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
-        case $with_aix_soname,$aix_use_runtimelinking in
-        aix,*) ;;	# no import file
-        svr4,* | *,yes) # use import file
-          # The Import File defines what to hardcode.
-          _LT_TAGVAR(hardcode_direct, $1)=no
-          _LT_TAGVAR(hardcode_direct_absolute, $1)=no
-          ;;
-        esac
-
-        if test yes = "$GXX"; then
-          case $host_os in aix4.[[012]]|aix4.[[012]].*)
-          # We only want to do this on AIX 4.2 and lower, the check
-          # below for broken collect2 doesn't work under 4.3+
-	  collect2name=`$CC -print-prog-name=collect2`
-	  if test -f "$collect2name" &&
-	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
-	  then
-	    # We have reworked collect2
-	    :
-	  else
-	    # We have old collect2
-	    _LT_TAGVAR(hardcode_direct, $1)=unsupported
-	    # It fails to find uninstalled libraries when the uninstalled
-	    # path is not listed in the libpath.  Setting hardcode_minus_L
-	    # to unsupported forces relinking
-	    _LT_TAGVAR(hardcode_minus_L, $1)=yes
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-	    _LT_TAGVAR(hardcode_libdir_separator, $1)=
-	  fi
-          esac
-          shared_flag='-shared'
-	  if test yes = "$aix_use_runtimelinking"; then
-	    shared_flag=$shared_flag' $wl-G'
-	  fi
-	  # Need to ensure runtime linking is disabled for the traditional
-	  # shared library, or the linker may eventually find shared libraries
-	  # /with/ Import File - we do not want to mix them.
-	  shared_flag_aix='-shared'
-	  shared_flag_svr4='-shared $wl-G'
-        else
-          # not using gcc
-          if test ia64 = "$host_cpu"; then
-	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
-	  # chokes on -Wl,-G. The following line is correct:
-	  shared_flag='-G'
-          else
-	    if test yes = "$aix_use_runtimelinking"; then
-	      shared_flag='$wl-G'
-	    else
-	      shared_flag='$wl-bM:SRE'
-	    fi
-	    shared_flag_aix='$wl-bM:SRE'
-	    shared_flag_svr4='$wl-G'
-          fi
-        fi
-
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall'
-        # It seems that -bexpall does not export symbols beginning with
-        # underscore (_), so it is better to generate a list of symbols to
-	# export.
-        _LT_TAGVAR(always_export_symbols, $1)=yes
-	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
-          # Warning - without using the other runtime loading flags (-brtl),
-          # -berok will link without error, but may produce a broken library.
-          # The "-G" linker flag allows undefined symbols.
-          _LT_TAGVAR(no_undefined_flag, $1)='-bernotok'
-          # Determine the default libpath from the value encoded in an empty
-          # executable.
-          _LT_SYS_MODULE_PATH_AIX([$1])
-          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
-
-          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
-        else
-          if test ia64 = "$host_cpu"; then
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib'
-	    _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
-          else
-	    # Determine the default libpath from the value encoded in an
-	    # empty executable.
-	    _LT_SYS_MODULE_PATH_AIX([$1])
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath"
-	    # Warning - without using the other run time loading flags,
-	    # -berok will link without error, but may produce a broken library.
-	    _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok'
-	    _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok'
-	    if test yes = "$with_gnu_ld"; then
-	      # We only use this code for GNU lds that support --whole-archive.
-	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
-	    else
-	      # Exported symbols can be pulled into shared objects from archives
-	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
-	    fi
-	    _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
-	    # -brtl affects multiple linker settings, -berok does not and is overridden later
-	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`'
-	    if test svr4 != "$with_aix_soname"; then
-	      # This is similar to how AIX traditionally builds its shared
-	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
-	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
-	    fi
-	    if test aix != "$with_aix_soname"; then
-	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
-	    else
-	      # used by -dlpreopen to get the symbols
-	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
-	    fi
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
-          fi
-        fi
-        ;;
-
-      beos*)
-	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
-	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
-	  # support --undefined.  This deserves some investigation.  FIXME
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	else
-	  _LT_TAGVAR(ld_shlibs, $1)=no
-	fi
-	;;
-
-      chorus*)
-        case $cc_basename in
-          *)
-	  # FIXME: insert proper C++ library support
-	  _LT_TAGVAR(ld_shlibs, $1)=no
-	  ;;
-        esac
-        ;;
-
-      cygwin* | mingw* | pw32* | cegcc*)
-	case $GXX,$cc_basename in
-	,cl* | no,cl*)
-	  # Native MSVC
-	  # hardcode_libdir_flag_spec is actually meaningless, as there is
-	  # no search path for DLLs.
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
-	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	  _LT_TAGVAR(always_export_symbols, $1)=yes
-	  _LT_TAGVAR(file_list_spec, $1)='@'
-	  # Tell ltmain to make .lib files, not .a files.
-	  libext=lib
-	  # Tell ltmain to make .dll files, not .so files.
-	  shrext_cmds=.dll
-	  # FIXME: Setting linknames here is a bad hack.
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
-              cp "$export_symbols" "$output_objdir/$soname.def";
-              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
-            else
-              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
-            fi~
-            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
-            linknames='
-	  # The linker will not automatically build a static lib if we build a DLL.
-	  # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
-	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-	  # Don't use ranlib
-	  _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
-	  _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
-            lt_tool_outputfile="@TOOL_OUTPUT@"~
-            case $lt_outputfile in
-              *.exe|*.EXE) ;;
-              *)
-                lt_outputfile=$lt_outputfile.exe
-                lt_tool_outputfile=$lt_tool_outputfile.exe
-                ;;
-            esac~
-            func_to_tool_file "$lt_outputfile"~
-            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
-              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
-              $RM "$lt_outputfile.manifest";
-            fi'
-	  ;;
-	*)
-	  # g++
-	  # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
-	  # as there is no search path for DLLs.
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols'
-	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	  _LT_TAGVAR(always_export_symbols, $1)=no
-	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-
-	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	    # If the export-symbols file already is a .def file, use it as
-	    # is; otherwise, prepend EXPORTS...
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
-              cp $export_symbols $output_objdir/$soname.def;
-            else
-              echo EXPORTS > $output_objdir/$soname.def;
-              cat $export_symbols >> $output_objdir/$soname.def;
-            fi~
-            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
-	  else
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	  fi
-	  ;;
-	esac
-	;;
-      darwin* | rhapsody*)
-        _LT_DARWIN_LINKER_FEATURES($1)
-	;;
-
-      os2*)
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
-	_LT_TAGVAR(hardcode_minus_L, $1)=yes
-	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-	shrext_cmds=.dll
-	_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	  $ECHO EXPORTS >> $output_objdir/$libname.def~
-	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
-	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	  emximp -o $lib $output_objdir/$libname.def'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
-	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
-	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
-	  $ECHO EXPORTS >> $output_objdir/$libname.def~
-	  prefix_cmds="$SED"~
-	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
-	    prefix_cmds="$prefix_cmds -e 1d";
-	  fi~
-	  prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~
-	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
-	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
-	  emximp -o $lib $output_objdir/$libname.def'
-	_LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
-	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-	;;
-
-      dgux*)
-        case $cc_basename in
-          ec++*)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          ghcx*)
-	    # Green Hills C++ Compiler
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-        esac
-        ;;
-
-      freebsd2.*)
-        # C++ shared libraries reported to be fairly broken before
-	# switch to ELF
-        _LT_TAGVAR(ld_shlibs, $1)=no
-        ;;
-
-      freebsd-elf*)
-        _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-        ;;
-
-      freebsd* | dragonfly*)
-        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
-        # conventions
-        _LT_TAGVAR(ld_shlibs, $1)=yes
-        ;;
-
-      haiku*)
-        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-        _LT_TAGVAR(link_all_deplibs, $1)=yes
-        ;;
-
-      hpux9*)
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
-        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-        _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-        _LT_TAGVAR(hardcode_direct, $1)=yes
-        _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
-				             # but as the default
-				             # location of the library.
-
-        case $cc_basename in
-          CC*)
-            # FIXME: insert proper C++ library support
-            _LT_TAGVAR(ld_shlibs, $1)=no
-            ;;
-          aCC*)
-            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-            # Commands to make compiler produce verbose output that lists
-            # what "hidden" libraries, object files and flags are used when
-            # linking a shared library.
-            #
-            # There doesn't appear to be a way to prevent this compiler from
-            # explicitly linking system object files so we need to strip them
-            # from the output so that they don't get included in the library
-            # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-            ;;
-          *)
-            if test yes = "$GXX"; then
-              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
-            else
-              # FIXME: insert proper C++ library support
-              _LT_TAGVAR(ld_shlibs, $1)=no
-            fi
-            ;;
-        esac
-        ;;
-
-      hpux10*|hpux11*)
-        if test no = "$with_gnu_ld"; then
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir'
-	  _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-          case $host_cpu in
-            hppa*64*|ia64*)
-              ;;
-            *)
-	      _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-              ;;
-          esac
-        fi
-        case $host_cpu in
-          hppa*64*|ia64*)
-            _LT_TAGVAR(hardcode_direct, $1)=no
-            _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-            ;;
-          *)
-            _LT_TAGVAR(hardcode_direct, $1)=yes
-            _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-            _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
-					         # but as the default
-					         # location of the library.
-            ;;
-        esac
-
-        case $cc_basename in
-          CC*)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          aCC*)
-	    case $host_cpu in
-	      hppa*64*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	      ia64*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	      *)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	        ;;
-	    esac
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-	    ;;
-          *)
-	    if test yes = "$GXX"; then
-	      if test no = "$with_gnu_ld"; then
-	        case $host_cpu in
-	          hppa*64*)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	          ia64*)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	          *)
-	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	            ;;
-	        esac
-	      fi
-	    else
-	      # FIXME: insert proper C++ library support
-	      _LT_TAGVAR(ld_shlibs, $1)=no
-	    fi
-	    ;;
-        esac
-        ;;
-
-      interix[[3-9]]*)
-	_LT_TAGVAR(hardcode_direct, $1)=no
-	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
-	# Instead, shared libraries are loaded at an image base (0x10000000 by
-	# default) and relocated if they conflict, which is a slow very memory
-	# consuming and fragmenting process.  To avoid this, we pick a random,
-	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
-	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
-	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	;;
-      irix5* | irix6*)
-        case $cc_basename in
-          CC*)
-	    # SGI C++
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
-	    # necessary to make sure instantiated templates are included
-	    # in the archive.
-	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
-	    ;;
-          *)
-	    if test yes = "$GXX"; then
-	      if test no = "$with_gnu_ld"; then
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-	      else
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
-	      fi
-	    fi
-	    _LT_TAGVAR(link_all_deplibs, $1)=yes
-	    ;;
-        esac
-        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-        _LT_TAGVAR(inherit_rpath, $1)=yes
-        ;;
-
-      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
-        case $cc_basename in
-          KCC*)
-	    # Kuck and Associates, Inc. (KAI) C++ Compiler
-
-	    # KCC will only create a shared library if the output file
-	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
-	    # to its proper name (with version) after linking.
-	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
-	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
-	    ;;
-	  icpc* | ecpc* )
-	    # Intel C++
-	    with_gnu_ld=yes
-	    # version 8.0 and above of icpc choke on multiply defined symbols
-	    # if we add $predep_objects and $postdep_objects, however 7.1 and
-	    # earlier do not add the objects themselves.
-	    case `$CC -V 2>&1` in
-	      *"Version 7."*)
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-		;;
-	      *)  # Version 8.0 or newer
-	        tmp_idyn=
-	        case $host_cpu in
-		  ia64*) tmp_idyn=' -i_dynamic';;
-		esac
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-		;;
-	    esac
-	    _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive'
-	    ;;
-          pgCC* | pgcpp*)
-            # Portland Group C++ compiler
-	    case `$CC -V` in
-	    *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)
-	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
-               rm -rf $tpldir~
-               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
-               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
-	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
-                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
-                $RANLIB $oldlib'
-	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
-                rm -rf $tpldir~
-                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
-                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	      ;;
-	    *) # Version 6 and above use weak symbols
-	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
-	      ;;
-	    esac
-
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-            ;;
-	  cxx*)
-	    # Compaq C++
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
-
-	    runpath_var=LD_RUN_PATH
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
-	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
-	    ;;
-	  xl* | mpixl* | bgxl*)
-	    # IBM XL 8.0 on PPC, with GNU ld
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
-	    if test yes = "$supports_anon_versioning"; then
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
-                echo "local: *; };" >> $output_objdir/$libname.ver~
-                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
-	    fi
-	    ;;
-	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
-	    *Sun\ C*)
-	      # Sun C++ 5.9
-	      _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
-	      _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
-	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
-	      _LT_TAGVAR(compiler_needs_object, $1)=yes
-
-	      # Not sure whether something based on
-	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
-	      # would be better.
-	      output_verbose_link_cmd='func_echo_all'
-
-	      # Archives containing C++ object files must be created using
-	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
-	      # necessary to make sure instantiated templates are included
-	      # in the archive.
-	      _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
-	      ;;
-	    esac
-	    ;;
-	esac
-	;;
-
-      lynxos*)
-        # FIXME: insert proper C++ library support
-	_LT_TAGVAR(ld_shlibs, $1)=no
-	;;
-
-      m88k*)
-        # FIXME: insert proper C++ library support
-        _LT_TAGVAR(ld_shlibs, $1)=no
-	;;
-
-      mvs*)
-        case $cc_basename in
-          cxx*)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-	  *)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-	esac
-	;;
-
-      netbsd*)
-        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
-	  _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
-	  wlarc=
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-	  _LT_TAGVAR(hardcode_direct, $1)=yes
-	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	fi
-	# Workaround some broken pre-1.5 toolchains
-	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
-	;;
-
-      *nto* | *qnx*)
-        _LT_TAGVAR(ld_shlibs, $1)=yes
-	;;
-
-      openbsd* | bitrig*)
-	if test -f /usr/libexec/ld.so; then
-	  _LT_TAGVAR(hardcode_direct, $1)=yes
-	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
-	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
-	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E'
-	    _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
-	  fi
-	  output_verbose_link_cmd=func_echo_all
-	else
-	  _LT_TAGVAR(ld_shlibs, $1)=no
-	fi
-	;;
-
-      osf3* | osf4* | osf5*)
-        case $cc_basename in
-          KCC*)
-	    # Kuck and Associates, Inc. (KAI) C++ Compiler
-
-	    # KCC will only create a shared library if the output file
-	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
-	    # to its proper name (with version) after linking.
-	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir'
-	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-	    # Archives containing C++ object files must be created using
-	    # the KAI C++ compiler.
-	    case $host in
-	      osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
-	      *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
-	    esac
-	    ;;
-          RCC*)
-	    # Rational C++ 2.4.1
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          cxx*)
-	    case $host in
-	      osf3*)
-	        _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-		;;
-	      *)
-	        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
-	        _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
-                  echo "-hidden">> $lib.exp~
-                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
-                  $RM $lib.exp'
-	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
-		;;
-	    esac
-
-	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-	    # Commands to make compiler produce verbose output that lists
-	    # what "hidden" libraries, object files and flags are used when
-	    # linking a shared library.
-	    #
-	    # There doesn't appear to be a way to prevent this compiler from
-	    # explicitly linking system object files so we need to strip them
-	    # from the output so that they don't get included in the library
-	    # dependencies.
-	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
-	    ;;
-	  *)
-	    if test yes,no = "$GXX,$with_gnu_ld"; then
-	      _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
-	      case $host in
-	        osf3*)
-	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-		  ;;
-	        *)
-	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
-		  ;;
-	      esac
-
-	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
-	      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
-
-	      # Commands to make compiler produce verbose output that lists
-	      # what "hidden" libraries, object files and flags are used when
-	      # linking a shared library.
-	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-
-	    else
-	      # FIXME: insert proper C++ library support
-	      _LT_TAGVAR(ld_shlibs, $1)=no
-	    fi
-	    ;;
-        esac
-        ;;
-
-      psos*)
-        # FIXME: insert proper C++ library support
-        _LT_TAGVAR(ld_shlibs, $1)=no
-        ;;
-
-      sunos4*)
-        case $cc_basename in
-          CC*)
-	    # Sun C++ 4.x
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          lcc*)
-	    # Lucid
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-        esac
-        ;;
-
-      solaris*)
-        case $cc_basename in
-          CC* | sunCC*)
-	    # Sun C++ 4.2, 5.x and Centerline C++
-            _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
-	    _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
-	    _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	    case $host_os in
-	      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
-	      *)
-		# The compiler driver will combine and reorder linker options,
-		# but understands '-z linker_flag'.
-	        # Supported since Solaris 2.6 (maybe 2.5.1?)
-		_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
-	        ;;
-	    esac
-	    _LT_TAGVAR(link_all_deplibs, $1)=yes
-
-	    output_verbose_link_cmd='func_echo_all'
-
-	    # Archives containing C++ object files must be created using
-	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
-	    # necessary to make sure instantiated templates are included
-	    # in the archive.
-	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
-	    ;;
-          gcx*)
-	    # Green Hills C++ Compiler
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-
-	    # The C++ compiler must be used to create the archive.
-	    _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
-	    ;;
-          *)
-	    # GNU C++ compiler with Solaris linker
-	    if test yes,no = "$GXX,$with_gnu_ld"; then
-	      _LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs'
-	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	        # Commands to make compiler produce verbose output that lists
-	        # what "hidden" libraries, object files and flags are used when
-	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-	      else
-	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
-	        # platform.
-	        _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
-	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
-                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
-
-	        # Commands to make compiler produce verbose output that lists
-	        # what "hidden" libraries, object files and flags are used when
-	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
-	      fi
-
-	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'
-	      case $host_os in
-		solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
-		*)
-		  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
-		  ;;
-	      esac
-	    fi
-	    ;;
-        esac
-        ;;
-
-    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
-      _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
-      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
-      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-      runpath_var='LD_RUN_PATH'
-
-      case $cc_basename in
-        CC*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-	*)
-	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	  ;;
-      esac
-      ;;
-
-      sysv5* | sco3.2v5* | sco5v6*)
-	# Note: We CANNOT use -z defs as we might desire, because we do not
-	# link with -lc, and that would cause any symbols used from libc to
-	# always be unresolved, which means just about no library would
-	# ever link correctly.  If we're not using GNU ld we use -z text
-	# though, which does catch some bad symbols but isn't as heavy-handed
-	# as -z defs.
-	_LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text'
-	_LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs'
-	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
-	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir'
-	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
-	_LT_TAGVAR(link_all_deplibs, $1)=yes
-	_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport'
-	runpath_var='LD_RUN_PATH'
-
-	case $cc_basename in
-          CC*)
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~
-              '"$_LT_TAGVAR(old_archive_cmds, $1)"
-	    _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~
-              '"$_LT_TAGVAR(reload_cmds, $1)"
-	    ;;
-	  *)
-	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
-	    ;;
-	esac
-      ;;
-
-      tandem*)
-        case $cc_basename in
-          NCC*)
-	    # NonStop-UX NCC 3.20
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-          *)
-	    # FIXME: insert proper C++ library support
-	    _LT_TAGVAR(ld_shlibs, $1)=no
-	    ;;
-        esac
-        ;;
-
-      vxworks*)
-        # FIXME: insert proper C++ library support
-        _LT_TAGVAR(ld_shlibs, $1)=no
-        ;;
-
-      *)
-        # FIXME: insert proper C++ library support
-        _LT_TAGVAR(ld_shlibs, $1)=no
-        ;;
-    esac
-
-    AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
-    test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no
-
-    _LT_TAGVAR(GCC, $1)=$GXX
-    _LT_TAGVAR(LD, $1)=$LD
-
-    ## CAVEAT EMPTOR:
-    ## There is no encapsulation within the following macros, do not change
-    ## the running order or otherwise move them around unless you know exactly
-    ## what you are doing...
-    _LT_SYS_HIDDEN_LIBDEPS($1)
-    _LT_COMPILER_PIC($1)
-    _LT_COMPILER_C_O($1)
-    _LT_COMPILER_FILE_LOCKS($1)
-    _LT_LINKER_SHLIBS($1)
-    _LT_SYS_DYNAMIC_LINKER($1)
-    _LT_LINKER_HARDCODE_LIBPATH($1)
-
-    _LT_CONFIG($1)
-  fi # test -n "$compiler"
-
-  CC=$lt_save_CC
-  CFLAGS=$lt_save_CFLAGS
-  LDCXX=$LD
-  LD=$lt_save_LD
-  GCC=$lt_save_GCC
-  with_gnu_ld=$lt_save_with_gnu_ld
-  lt_cv_path_LDCXX=$lt_cv_path_LD
-  lt_cv_path_LD=$lt_save_path_LD
-  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
-  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
-fi # test yes != "$_lt_caught_CXX_error"
-
-AC_LANG_POP
-])# _LT_LANG_CXX_CONFIG
-
-
-# _LT_FUNC_STRIPNAME_CNF
-# ----------------------
-# func_stripname_cnf prefix suffix name
-# strip PREFIX and SUFFIX off of NAME.
-# PREFIX and SUFFIX must not contain globbing or regex special
-# characters, hashes, percent signs, but SUFFIX may contain a leading
-# dot (in which case that matches only a dot).
-#
-# This function is identical to the (non-XSI) version of func_stripname,
-# except this one can be used by m4 code that may be executed by configure,
-# rather than the libtool script.
-m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl
-AC_REQUIRE([_LT_DECL_SED])
-AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])
-func_stripname_cnf ()
-{
-  case @S|@2 in
-  .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;;
-  *)  func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;;
-  esac
-} # func_stripname_cnf
-])# _LT_FUNC_STRIPNAME_CNF
-
-
-# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
-# ---------------------------------
-# Figure out "hidden" library dependencies from verbose
-# compiler output when linking a shared library.
-# Parse the compiler output and extract the necessary
-# objects, libraries and library flags.
-m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
-[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
-AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl
-# Dependencies to place before and after the object being linked:
-_LT_TAGVAR(predep_objects, $1)=
-_LT_TAGVAR(postdep_objects, $1)=
-_LT_TAGVAR(predeps, $1)=
-_LT_TAGVAR(postdeps, $1)=
-_LT_TAGVAR(compiler_lib_search_path, $1)=
-
-dnl we can't use the lt_simple_compile_test_code here,
-dnl because it contains code intended for an executable,
-dnl not a library.  It's possible we should let each
-dnl tag define a new lt_????_link_test_code variable,
-dnl but it's only used here...
-m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
-int a;
-void foo (void) { a = 0; }
-_LT_EOF
-], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
-class Foo
-{
-public:
-  Foo (void) { a = 0; }
-private:
-  int a;
-};
-_LT_EOF
-], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
-      subroutine foo
-      implicit none
-      integer*4 a
-      a=0
-      return
-      end
-_LT_EOF
-], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
-      subroutine foo
-      implicit none
-      integer a
-      a=0
-      return
-      end
-_LT_EOF
-], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
-public class foo {
-  private int a;
-  public void bar (void) {
-    a = 0;
-  }
-};
-_LT_EOF
-], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF
-package foo
-func foo() {
-}
-_LT_EOF
-])
-
-_lt_libdeps_save_CFLAGS=$CFLAGS
-case "$CC $CFLAGS " in #(
-*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
-*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
-*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
-esac
-
-dnl Parse the compiler output and extract the necessary
-dnl objects, libraries and library flags.
-if AC_TRY_EVAL(ac_compile); then
-  # Parse the compiler output and extract the necessary
-  # objects, libraries and library flags.
-
-  # Sentinel used to keep track of whether or not we are before
-  # the conftest object file.
-  pre_test_object_deps_done=no
-
-  for p in `eval "$output_verbose_link_cmd"`; do
-    case $prev$p in
-
-    -L* | -R* | -l*)
-       # Some compilers place space between "-{L,R}" and the path.
-       # Remove the space.
-       if test x-L = "$p" ||
-          test x-R = "$p"; then
-	 prev=$p
-	 continue
-       fi
-
-       # Expand the sysroot to ease extracting the directories later.
-       if test -z "$prev"; then
-         case $p in
-         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
-         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
-         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
-         esac
-       fi
-       case $p in
-       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
-       esac
-       if test no = "$pre_test_object_deps_done"; then
-	 case $prev in
-	 -L | -R)
-	   # Internal compiler library paths should come after those
-	   # provided the user.  The postdeps already come after the
-	   # user supplied libs so there is no need to process them.
-	   if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
-	     _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p
-	   else
-	     _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $prev$p"
-	   fi
-	   ;;
-	 # The "-l" case would never come before the object being
-	 # linked, so don't bother handling this case.
-	 esac
-       else
-	 if test -z "$_LT_TAGVAR(postdeps, $1)"; then
-	   _LT_TAGVAR(postdeps, $1)=$prev$p
-	 else
-	   _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $prev$p"
-	 fi
-       fi
-       prev=
-       ;;
-
-    *.lto.$objext) ;; # Ignore GCC LTO objects
-    *.$objext)
-       # This assumes that the test object file only shows up
-       # once in the compiler output.
-       if test "$p" = "conftest.$objext"; then
-	 pre_test_object_deps_done=yes
-	 continue
-       fi
-
-       if test no = "$pre_test_object_deps_done"; then
-	 if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
-	   _LT_TAGVAR(predep_objects, $1)=$p
-	 else
-	   _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
-	 fi
-       else
-	 if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
-	   _LT_TAGVAR(postdep_objects, $1)=$p
-	 else
-	   _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
-	 fi
-       fi
-       ;;
-
-    *) ;; # Ignore the rest.
-
-    esac
-  done
-
-  # Clean up.
-  rm -f a.out a.exe
-else
-  echo "libtool.m4: error: problem compiling $1 test program"
-fi
-
-$RM -f confest.$objext
-CFLAGS=$_lt_libdeps_save_CFLAGS
-
-# PORTME: override above test on systems where it is broken
-m4_if([$1], [CXX],
-[case $host_os in
-interix[[3-9]]*)
-  # Interix 3.5 installs completely hosed .la files for C++, so rather than
-  # hack all around it, let's just trust "g++" to DTRT.
-  _LT_TAGVAR(predep_objects,$1)=
-  _LT_TAGVAR(postdep_objects,$1)=
-  _LT_TAGVAR(postdeps,$1)=
-  ;;
-esac
-])
-
-case " $_LT_TAGVAR(postdeps, $1) " in
-*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
-esac
- _LT_TAGVAR(compiler_lib_search_dirs, $1)=
-if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
- _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'`
-fi
-_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
-    [The directories searched by this compiler when creating a shared library])
-_LT_TAGDECL([], [predep_objects], [1],
-    [Dependencies to place before and after the objects being linked to
-    create a shared library])
-_LT_TAGDECL([], [postdep_objects], [1])
-_LT_TAGDECL([], [predeps], [1])
-_LT_TAGDECL([], [postdeps], [1])
-_LT_TAGDECL([], [compiler_lib_search_path], [1],
-    [The library search path used internally by the compiler when linking
-    a shared library])
-])# _LT_SYS_HIDDEN_LIBDEPS
-
-
-# _LT_LANG_F77_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for a Fortran 77 compiler are
-# suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_F77_CONFIG],
-[AC_LANG_PUSH(Fortran 77)
-if test -z "$F77" || test no = "$F77"; then
-  _lt_disable_F77=yes
-fi
-
-_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-_LT_TAGVAR(allow_undefined_flag, $1)=
-_LT_TAGVAR(always_export_symbols, $1)=no
-_LT_TAGVAR(archive_expsym_cmds, $1)=
-_LT_TAGVAR(export_dynamic_flag_spec, $1)=
-_LT_TAGVAR(hardcode_direct, $1)=no
-_LT_TAGVAR(hardcode_direct_absolute, $1)=no
-_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
-_LT_TAGVAR(hardcode_libdir_separator, $1)=
-_LT_TAGVAR(hardcode_minus_L, $1)=no
-_LT_TAGVAR(hardcode_automatic, $1)=no
-_LT_TAGVAR(inherit_rpath, $1)=no
-_LT_TAGVAR(module_cmds, $1)=
-_LT_TAGVAR(module_expsym_cmds, $1)=
-_LT_TAGVAR(link_all_deplibs, $1)=unknown
-_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_TAGVAR(reload_flag, $1)=$reload_flag
-_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
-_LT_TAGVAR(no_undefined_flag, $1)=
-_LT_TAGVAR(whole_archive_flag_spec, $1)=
-_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-
-# Source file extension for f77 test sources.
-ac_ext=f
-
-# Object file extension for compiled f77 test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# No sense in running all these tests if we already determined that
-# the F77 compiler isn't working.  Some variables (like enable_shared)
-# are currently assumed to apply to all compilers on this platform,
-# and will be corrupted by setting them based on a non-working compiler.
-if test yes != "$_lt_disable_F77"; then
-  # Code to be used in simple compile tests
-  lt_simple_compile_test_code="\
-      subroutine t
-      return
-      end
-"
-
-  # Code to be used in simple link tests
-  lt_simple_link_test_code="\
-      program t
-      end
-"
-
-  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
-  _LT_TAG_COMPILER
-
-  # save warnings/boilerplate of simple test code
-  _LT_COMPILER_BOILERPLATE
-  _LT_LINKER_BOILERPLATE
-
-  # Allow CC to be a program name with arguments.
-  lt_save_CC=$CC
-  lt_save_GCC=$GCC
-  lt_save_CFLAGS=$CFLAGS
-  CC=${F77-"f77"}
-  CFLAGS=$FFLAGS
-  compiler=$CC
-  _LT_TAGVAR(compiler, $1)=$CC
-  _LT_CC_BASENAME([$compiler])
-  GCC=$G77
-  if test -n "$compiler"; then
-    AC_MSG_CHECKING([if libtool supports shared libraries])
-    AC_MSG_RESULT([$can_build_shared])
-
-    AC_MSG_CHECKING([whether to build shared libraries])
-    test no = "$can_build_shared" && enable_shared=no
-
-    # On AIX, shared libraries and static libraries use the same namespace, and
-    # are all built from PIC.
-    case $host_os in
-      aix3*)
-        test yes = "$enable_shared" && enable_static=no
-        if test -n "$RANLIB"; then
-          archive_cmds="$archive_cmds~\$RANLIB \$lib"
-          postinstall_cmds='$RANLIB $lib'
-        fi
-        ;;
-      aix[[4-9]]*)
-	if test ia64 != "$host_cpu"; then
-	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
-	  yes,aix,yes) ;;		# shared object as lib.so file only
-	  yes,svr4,*) ;;		# shared object as lib.so archive member only
-	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
-	  esac
-	fi
-        ;;
-    esac
-    AC_MSG_RESULT([$enable_shared])
-
-    AC_MSG_CHECKING([whether to build static libraries])
-    # Make sure either enable_shared or enable_static is yes.
-    test yes = "$enable_shared" || enable_static=yes
-    AC_MSG_RESULT([$enable_static])
-
-    _LT_TAGVAR(GCC, $1)=$G77
-    _LT_TAGVAR(LD, $1)=$LD
-
-    ## CAVEAT EMPTOR:
-    ## There is no encapsulation within the following macros, do not change
-    ## the running order or otherwise move them around unless you know exactly
-    ## what you are doing...
-    _LT_COMPILER_PIC($1)
-    _LT_COMPILER_C_O($1)
-    _LT_COMPILER_FILE_LOCKS($1)
-    _LT_LINKER_SHLIBS($1)
-    _LT_SYS_DYNAMIC_LINKER($1)
-    _LT_LINKER_HARDCODE_LIBPATH($1)
-
-    _LT_CONFIG($1)
-  fi # test -n "$compiler"
-
-  GCC=$lt_save_GCC
-  CC=$lt_save_CC
-  CFLAGS=$lt_save_CFLAGS
-fi # test yes != "$_lt_disable_F77"
-
-AC_LANG_POP
-])# _LT_LANG_F77_CONFIG
-
-
-# _LT_LANG_FC_CONFIG([TAG])
-# -------------------------
-# Ensure that the configuration variables for a Fortran compiler are
-# suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_FC_CONFIG],
-[AC_LANG_PUSH(Fortran)
-
-if test -z "$FC" || test no = "$FC"; then
-  _lt_disable_FC=yes
-fi
-
-_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-_LT_TAGVAR(allow_undefined_flag, $1)=
-_LT_TAGVAR(always_export_symbols, $1)=no
-_LT_TAGVAR(archive_expsym_cmds, $1)=
-_LT_TAGVAR(export_dynamic_flag_spec, $1)=
-_LT_TAGVAR(hardcode_direct, $1)=no
-_LT_TAGVAR(hardcode_direct_absolute, $1)=no
-_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
-_LT_TAGVAR(hardcode_libdir_separator, $1)=
-_LT_TAGVAR(hardcode_minus_L, $1)=no
-_LT_TAGVAR(hardcode_automatic, $1)=no
-_LT_TAGVAR(inherit_rpath, $1)=no
-_LT_TAGVAR(module_cmds, $1)=
-_LT_TAGVAR(module_expsym_cmds, $1)=
-_LT_TAGVAR(link_all_deplibs, $1)=unknown
-_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_TAGVAR(reload_flag, $1)=$reload_flag
-_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
-_LT_TAGVAR(no_undefined_flag, $1)=
-_LT_TAGVAR(whole_archive_flag_spec, $1)=
-_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-
-# Source file extension for fc test sources.
-ac_ext=${ac_fc_srcext-f}
-
-# Object file extension for compiled fc test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# No sense in running all these tests if we already determined that
-# the FC compiler isn't working.  Some variables (like enable_shared)
-# are currently assumed to apply to all compilers on this platform,
-# and will be corrupted by setting them based on a non-working compiler.
-if test yes != "$_lt_disable_FC"; then
-  # Code to be used in simple compile tests
-  lt_simple_compile_test_code="\
-      subroutine t
-      return
-      end
-"
-
-  # Code to be used in simple link tests
-  lt_simple_link_test_code="\
-      program t
-      end
-"
-
-  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
-  _LT_TAG_COMPILER
-
-  # save warnings/boilerplate of simple test code
-  _LT_COMPILER_BOILERPLATE
-  _LT_LINKER_BOILERPLATE
-
-  # Allow CC to be a program name with arguments.
-  lt_save_CC=$CC
-  lt_save_GCC=$GCC
-  lt_save_CFLAGS=$CFLAGS
-  CC=${FC-"f95"}
-  CFLAGS=$FCFLAGS
-  compiler=$CC
-  GCC=$ac_cv_fc_compiler_gnu
-
-  _LT_TAGVAR(compiler, $1)=$CC
-  _LT_CC_BASENAME([$compiler])
-
-  if test -n "$compiler"; then
-    AC_MSG_CHECKING([if libtool supports shared libraries])
-    AC_MSG_RESULT([$can_build_shared])
-
-    AC_MSG_CHECKING([whether to build shared libraries])
-    test no = "$can_build_shared" && enable_shared=no
-
-    # On AIX, shared libraries and static libraries use the same namespace, and
-    # are all built from PIC.
-    case $host_os in
-      aix3*)
-        test yes = "$enable_shared" && enable_static=no
-        if test -n "$RANLIB"; then
-          archive_cmds="$archive_cmds~\$RANLIB \$lib"
-          postinstall_cmds='$RANLIB $lib'
-        fi
-        ;;
-      aix[[4-9]]*)
-	if test ia64 != "$host_cpu"; then
-	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
-	  yes,aix,yes) ;;		# shared object as lib.so file only
-	  yes,svr4,*) ;;		# shared object as lib.so archive member only
-	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
-	  esac
-	fi
-        ;;
-    esac
-    AC_MSG_RESULT([$enable_shared])
-
-    AC_MSG_CHECKING([whether to build static libraries])
-    # Make sure either enable_shared or enable_static is yes.
-    test yes = "$enable_shared" || enable_static=yes
-    AC_MSG_RESULT([$enable_static])
-
-    _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu
-    _LT_TAGVAR(LD, $1)=$LD
-
-    ## CAVEAT EMPTOR:
-    ## There is no encapsulation within the following macros, do not change
-    ## the running order or otherwise move them around unless you know exactly
-    ## what you are doing...
-    _LT_SYS_HIDDEN_LIBDEPS($1)
-    _LT_COMPILER_PIC($1)
-    _LT_COMPILER_C_O($1)
-    _LT_COMPILER_FILE_LOCKS($1)
-    _LT_LINKER_SHLIBS($1)
-    _LT_SYS_DYNAMIC_LINKER($1)
-    _LT_LINKER_HARDCODE_LIBPATH($1)
-
-    _LT_CONFIG($1)
-  fi # test -n "$compiler"
-
-  GCC=$lt_save_GCC
-  CC=$lt_save_CC
-  CFLAGS=$lt_save_CFLAGS
-fi # test yes != "$_lt_disable_FC"
-
-AC_LANG_POP
-])# _LT_LANG_FC_CONFIG
-
-
-# _LT_LANG_GCJ_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for the GNU Java Compiler compiler
-# are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_GCJ_CONFIG],
-[AC_REQUIRE([LT_PROG_GCJ])dnl
-AC_LANG_SAVE
-
-# Source file extension for Java test sources.
-ac_ext=java
-
-# Object file extension for compiled Java test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="class foo {}"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_TAG_COMPILER
-
-# save warnings/boilerplate of simple test code
-_LT_COMPILER_BOILERPLATE
-_LT_LINKER_BOILERPLATE
-
-# Allow CC to be a program name with arguments.
-lt_save_CC=$CC
-lt_save_CFLAGS=$CFLAGS
-lt_save_GCC=$GCC
-GCC=yes
-CC=${GCJ-"gcj"}
-CFLAGS=$GCJFLAGS
-compiler=$CC
-_LT_TAGVAR(compiler, $1)=$CC
-_LT_TAGVAR(LD, $1)=$LD
-_LT_CC_BASENAME([$compiler])
-
-# GCJ did not exist at the time GCC didn't implicitly link libc in.
-_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-
-_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_TAGVAR(reload_flag, $1)=$reload_flag
-_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
-  _LT_COMPILER_NO_RTTI($1)
-  _LT_COMPILER_PIC($1)
-  _LT_COMPILER_C_O($1)
-  _LT_COMPILER_FILE_LOCKS($1)
-  _LT_LINKER_SHLIBS($1)
-  _LT_LINKER_HARDCODE_LIBPATH($1)
-
-  _LT_CONFIG($1)
-fi
-
-AC_LANG_RESTORE
-
-GCC=$lt_save_GCC
-CC=$lt_save_CC
-CFLAGS=$lt_save_CFLAGS
-])# _LT_LANG_GCJ_CONFIG
-
-
-# _LT_LANG_GO_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for the GNU Go compiler
-# are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_GO_CONFIG],
-[AC_REQUIRE([LT_PROG_GO])dnl
-AC_LANG_SAVE
-
-# Source file extension for Go test sources.
-ac_ext=go
-
-# Object file extension for compiled Go test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="package main; func main() { }"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='package main; func main() { }'
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_TAG_COMPILER
-
-# save warnings/boilerplate of simple test code
-_LT_COMPILER_BOILERPLATE
-_LT_LINKER_BOILERPLATE
-
-# Allow CC to be a program name with arguments.
-lt_save_CC=$CC
-lt_save_CFLAGS=$CFLAGS
-lt_save_GCC=$GCC
-GCC=yes
-CC=${GOC-"gccgo"}
-CFLAGS=$GOFLAGS
-compiler=$CC
-_LT_TAGVAR(compiler, $1)=$CC
-_LT_TAGVAR(LD, $1)=$LD
-_LT_CC_BASENAME([$compiler])
-
-# Go did not exist at the time GCC didn't implicitly link libc in.
-_LT_TAGVAR(archive_cmds_need_lc, $1)=no
-
-_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_TAGVAR(reload_flag, $1)=$reload_flag
-_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
-  _LT_COMPILER_NO_RTTI($1)
-  _LT_COMPILER_PIC($1)
-  _LT_COMPILER_C_O($1)
-  _LT_COMPILER_FILE_LOCKS($1)
-  _LT_LINKER_SHLIBS($1)
-  _LT_LINKER_HARDCODE_LIBPATH($1)
-
-  _LT_CONFIG($1)
-fi
-
-AC_LANG_RESTORE
-
-GCC=$lt_save_GCC
-CC=$lt_save_CC
-CFLAGS=$lt_save_CFLAGS
-])# _LT_LANG_GO_CONFIG
-
-
-# _LT_LANG_RC_CONFIG([TAG])
-# -------------------------
-# Ensure that the configuration variables for the Windows resource compiler
-# are suitably defined.  These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to 'libtool'.
-m4_defun([_LT_LANG_RC_CONFIG],
-[AC_REQUIRE([LT_PROG_RC])dnl
-AC_LANG_SAVE
-
-# Source file extension for RC test sources.
-ac_ext=rc
-
-# Object file extension for compiled RC test sources.
-objext=o
-_LT_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
-
-# Code to be used in simple link tests
-lt_simple_link_test_code=$lt_simple_compile_test_code
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_TAG_COMPILER
-
-# save warnings/boilerplate of simple test code
-_LT_COMPILER_BOILERPLATE
-_LT_LINKER_BOILERPLATE
-
-# Allow CC to be a program name with arguments.
-lt_save_CC=$CC
-lt_save_CFLAGS=$CFLAGS
-lt_save_GCC=$GCC
-GCC=
-CC=${RC-"windres"}
-CFLAGS=
-compiler=$CC
-_LT_TAGVAR(compiler, $1)=$CC
-_LT_CC_BASENAME([$compiler])
-_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
-
-if test -n "$compiler"; then
-  :
-  _LT_CONFIG($1)
-fi
-
-GCC=$lt_save_GCC
-AC_LANG_RESTORE
-CC=$lt_save_CC
-CFLAGS=$lt_save_CFLAGS
-])# _LT_LANG_RC_CONFIG
-
-
-# LT_PROG_GCJ
-# -----------
-AC_DEFUN([LT_PROG_GCJ],
-[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
-  [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
-    [AC_CHECK_TOOL(GCJ, gcj,)
-      test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2"
-      AC_SUBST(GCJFLAGS)])])[]dnl
-])
-
-# Old name:
-AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([LT_AC_PROG_GCJ], [])
-
-
-# LT_PROG_GO
-# ----------
-AC_DEFUN([LT_PROG_GO],
-[AC_CHECK_TOOL(GOC, gccgo,)
-])
-
-
-# LT_PROG_RC
-# ----------
-AC_DEFUN([LT_PROG_RC],
-[AC_CHECK_TOOL(RC, windres,)
-])
-
-# Old name:
-AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([LT_AC_PROG_RC], [])
-
-
-# _LT_DECL_EGREP
-# --------------
-# If we don't have a new enough Autoconf to choose the best grep
-# available, choose the one first in the user's PATH.
-m4_defun([_LT_DECL_EGREP],
-[AC_REQUIRE([AC_PROG_EGREP])dnl
-AC_REQUIRE([AC_PROG_FGREP])dnl
-test -z "$GREP" && GREP=grep
-_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
-_LT_DECL([], [EGREP], [1], [An ERE matcher])
-_LT_DECL([], [FGREP], [1], [A literal string matcher])
-dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
-AC_SUBST([GREP])
-])
-
-
-# _LT_DECL_OBJDUMP
-# --------------
-# If we don't have a new enough Autoconf to choose the best objdump
-# available, choose the one first in the user's PATH.
-m4_defun([_LT_DECL_OBJDUMP],
-[AC_CHECK_TOOL(OBJDUMP, objdump, false)
-test -z "$OBJDUMP" && OBJDUMP=objdump
-_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
-AC_SUBST([OBJDUMP])
-])
-
-# _LT_DECL_DLLTOOL
-# ----------------
-# Ensure DLLTOOL variable is set.
-m4_defun([_LT_DECL_DLLTOOL],
-[AC_CHECK_TOOL(DLLTOOL, dlltool, false)
-test -z "$DLLTOOL" && DLLTOOL=dlltool
-_LT_DECL([], [DLLTOOL], [1], [DLL creation program])
-AC_SUBST([DLLTOOL])
-])
-
-# _LT_DECL_SED
-# ------------
-# Check for a fully-functional sed program, that truncates
-# as few characters as possible.  Prefer GNU sed if found.
-m4_defun([_LT_DECL_SED],
-[AC_PROG_SED
-test -z "$SED" && SED=sed
-Xsed="$SED -e 1s/^X//"
-_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
-_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
-    [Sed that helps us avoid accidentally triggering echo(1) options like -n])
-])# _LT_DECL_SED
-
-m4_ifndef([AC_PROG_SED], [
-############################################################
-# NOTE: This macro has been submitted for inclusion into   #
-#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
-#  a released version of Autoconf we should remove this    #
-#  macro and use it instead.                               #
-############################################################
-
-m4_defun([AC_PROG_SED],
-[AC_MSG_CHECKING([for a sed that does not truncate output])
-AC_CACHE_VAL(lt_cv_path_SED,
-[# Loop through the user's path and test for sed and gsed.
-# Then use that list of sed's as ones to test for truncation.
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for lt_ac_prog in sed gsed; do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
-        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
-      fi
-    done
-  done
-done
-IFS=$as_save_IFS
-lt_ac_max=0
-lt_ac_count=0
-# Add /usr/xpg4/bin/sed as it is typically found on Solaris
-# along with /bin/sed that truncates output.
-for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
-  test ! -f "$lt_ac_sed" && continue
-  cat /dev/null > conftest.in
-  lt_ac_count=0
-  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
-  # Check for GNU sed and select it if it is found.
-  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
-    lt_cv_path_SED=$lt_ac_sed
-    break
-  fi
-  while true; do
-    cat conftest.in conftest.in >conftest.tmp
-    mv conftest.tmp conftest.in
-    cp conftest.in conftest.nl
-    echo >>conftest.nl
-    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
-    cmp -s conftest.out conftest.nl || break
-    # 10000 chars as input seems more than enough
-    test 10 -lt "$lt_ac_count" && break
-    lt_ac_count=`expr $lt_ac_count + 1`
-    if test "$lt_ac_count" -gt "$lt_ac_max"; then
-      lt_ac_max=$lt_ac_count
-      lt_cv_path_SED=$lt_ac_sed
-    fi
-  done
-done
-])
-SED=$lt_cv_path_SED
-AC_SUBST([SED])
-AC_MSG_RESULT([$SED])
-])#AC_PROG_SED
-])#m4_ifndef
-
-# Old name:
-AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([LT_AC_PROG_SED], [])
-
-
-# _LT_CHECK_SHELL_FEATURES
-# ------------------------
-# Find out whether the shell is Bourne or XSI compatible,
-# or has some other useful features.
-m4_defun([_LT_CHECK_SHELL_FEATURES],
-[if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
-  lt_unset=unset
-else
-  lt_unset=false
-fi
-_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl
-
-# test EBCDIC or ASCII
-case `echo X|tr X '\101'` in
- A) # ASCII based system
-    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
-  lt_SP2NL='tr \040 \012'
-  lt_NL2SP='tr \015\012 \040\040'
-  ;;
- *) # EBCDIC based system
-  lt_SP2NL='tr \100 \n'
-  lt_NL2SP='tr \r\n \100\100'
-  ;;
-esac
-_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
-_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
-])# _LT_CHECK_SHELL_FEATURES
-
-
-# _LT_PATH_CONVERSION_FUNCTIONS
-# -----------------------------
-# Determine what file name conversion functions should be used by
-# func_to_host_file (and, implicitly, by func_to_host_path).  These are needed
-# for certain cross-compile configurations and native mingw.
-m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-AC_MSG_CHECKING([how to convert $build file names to $host format])
-AC_CACHE_VAL(lt_cv_to_host_file_cmd,
-[case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
-        ;;
-    esac
-    ;;
-  *-*-cygwin* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
-        ;;
-      *-*-cygwin* )
-        lt_cv_to_host_file_cmd=func_convert_file_noop
-        ;;
-      * ) # otherwise, assume *nix
-        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
-        ;;
-    esac
-    ;;
-  * ) # unhandled hosts (and "normal" native builds)
-    lt_cv_to_host_file_cmd=func_convert_file_noop
-    ;;
-esac
-])
-to_host_file_cmd=$lt_cv_to_host_file_cmd
-AC_MSG_RESULT([$lt_cv_to_host_file_cmd])
-_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd],
-         [0], [convert $build file names to $host format])dnl
-
-AC_MSG_CHECKING([how to convert $build file names to toolchain format])
-AC_CACHE_VAL(lt_cv_to_tool_file_cmd,
-[#assume ordinary cross tools, or native build.
-lt_cv_to_tool_file_cmd=func_convert_file_noop
-case $host in
-  *-*-mingw* )
-    case $build in
-      *-*-mingw* ) # actually msys
-        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
-        ;;
-    esac
-    ;;
-esac
-])
-to_tool_file_cmd=$lt_cv_to_tool_file_cmd
-AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])
-_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],
-         [0], [convert $build files to toolchain format])dnl
-])# _LT_PATH_CONVERSION_FUNCTIONS
diff --git a/libssh2/libssh2/m4/ltoptions.m4 b/libssh2/libssh2/m4/ltoptions.m4
deleted file mode 100644
index 94b08297..00000000
--- a/libssh2/libssh2/m4/ltoptions.m4
+++ /dev/null
@@ -1,437 +0,0 @@
-# Helper functions for option handling.                    -*- Autoconf -*-
-#
-#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
-#   Foundation, Inc.
-#   Written by Gary V. Vaughan, 2004
-#
-# This file is free software; the Free Software Foundation gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-
-# serial 8 ltoptions.m4
-
-# This is to help aclocal find these macros, as it can't see m4_define.
-AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
-
-
-# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
-# ------------------------------------------
-m4_define([_LT_MANGLE_OPTION],
-[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
-
-
-# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
-# ---------------------------------------
-# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
-# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
-# saved as a flag.
-m4_define([_LT_SET_OPTION],
-[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
-m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
-        _LT_MANGLE_DEFUN([$1], [$2]),
-    [m4_warning([Unknown $1 option '$2'])])[]dnl
-])
-
-
-# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
-# ------------------------------------------------------------
-# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
-m4_define([_LT_IF_OPTION],
-[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
-
-
-# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
-# -------------------------------------------------------
-# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
-# are set.
-m4_define([_LT_UNLESS_OPTIONS],
-[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
-	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
-		      [m4_define([$0_found])])])[]dnl
-m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
-])[]dnl
-])
-
-
-# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
-# ----------------------------------------
-# OPTION-LIST is a space-separated list of Libtool options associated
-# with MACRO-NAME.  If any OPTION has a matching handler declared with
-# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
-# the unknown option and exit.
-m4_defun([_LT_SET_OPTIONS],
-[# Set options
-m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
-    [_LT_SET_OPTION([$1], _LT_Option)])
-
-m4_if([$1],[LT_INIT],[
-  dnl
-  dnl Simply set some default values (i.e off) if boolean options were not
-  dnl specified:
-  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
-  ])
-  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
-  ])
-  dnl
-  dnl If no reference was made to various pairs of opposing options, then
-  dnl we run the default mode handler for the pair.  For example, if neither
-  dnl 'shared' nor 'disable-shared' was passed, we enable building of shared
-  dnl archives by default:
-  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
-  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
-  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
-  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
-		   [_LT_ENABLE_FAST_INSTALL])
-  _LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
-		   [_LT_WITH_AIX_SONAME([aix])])
-  ])
-])# _LT_SET_OPTIONS
-
-
-## --------------------------------- ##
-## Macros to handle LT_INIT options. ##
-## --------------------------------- ##
-
-# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
-# -----------------------------------------
-m4_define([_LT_MANGLE_DEFUN],
-[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
-
-
-# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
-# -----------------------------------------------
-m4_define([LT_OPTION_DEFINE],
-[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
-])# LT_OPTION_DEFINE
-
-
-# dlopen
-# ------
-LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
-])
-
-AU_DEFUN([AC_LIBTOOL_DLOPEN],
-[_LT_SET_OPTION([LT_INIT], [dlopen])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the 'dlopen' option into LT_INIT's first parameter.])
-])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
-
-
-# win32-dll
-# ---------
-# Declare package support for building win32 dll's.
-LT_OPTION_DEFINE([LT_INIT], [win32-dll],
-[enable_win32_dll=yes
-
-case $host in
-*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
-  AC_CHECK_TOOL(AS, as, false)
-  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
-  AC_CHECK_TOOL(OBJDUMP, objdump, false)
-  ;;
-esac
-
-test -z "$AS" && AS=as
-_LT_DECL([], [AS],      [1], [Assembler program])dnl
-
-test -z "$DLLTOOL" && DLLTOOL=dlltool
-_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
-
-test -z "$OBJDUMP" && OBJDUMP=objdump
-_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
-])# win32-dll
-
-AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-_LT_SET_OPTION([LT_INIT], [win32-dll])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the 'win32-dll' option into LT_INIT's first parameter.])
-])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
-
-
-# _LT_ENABLE_SHARED([DEFAULT])
-# ----------------------------
-# implement the --enable-shared flag, and supports the 'shared' and
-# 'disable-shared' LT_INIT options.
-# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
-m4_define([_LT_ENABLE_SHARED],
-[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([shared],
-    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
-	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
-    [p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_shared=yes ;;
-    no) enable_shared=no ;;
-    *)
-      enable_shared=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_shared=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac],
-    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
-
-    _LT_DECL([build_libtool_libs], [enable_shared], [0],
-	[Whether or not to build shared libraries])
-])# _LT_ENABLE_SHARED
-
-LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
-LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
-
-# Old names:
-AC_DEFUN([AC_ENABLE_SHARED],
-[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
-])
-
-AC_DEFUN([AC_DISABLE_SHARED],
-[_LT_SET_OPTION([LT_INIT], [disable-shared])
-])
-
-AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
-AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AM_ENABLE_SHARED], [])
-dnl AC_DEFUN([AM_DISABLE_SHARED], [])
-
-
-
-# _LT_ENABLE_STATIC([DEFAULT])
-# ----------------------------
-# implement the --enable-static flag, and support the 'static' and
-# 'disable-static' LT_INIT options.
-# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
-m4_define([_LT_ENABLE_STATIC],
-[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([static],
-    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
-	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
-    [p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_static=yes ;;
-    no) enable_static=no ;;
-    *)
-     enable_static=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_static=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac],
-    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
-
-    _LT_DECL([build_old_libs], [enable_static], [0],
-	[Whether or not to build static libraries])
-])# _LT_ENABLE_STATIC
-
-LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
-LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
-
-# Old names:
-AC_DEFUN([AC_ENABLE_STATIC],
-[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
-])
-
-AC_DEFUN([AC_DISABLE_STATIC],
-[_LT_SET_OPTION([LT_INIT], [disable-static])
-])
-
-AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
-AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AM_ENABLE_STATIC], [])
-dnl AC_DEFUN([AM_DISABLE_STATIC], [])
-
-
-
-# _LT_ENABLE_FAST_INSTALL([DEFAULT])
-# ----------------------------------
-# implement the --enable-fast-install flag, and support the 'fast-install'
-# and 'disable-fast-install' LT_INIT options.
-# DEFAULT is either 'yes' or 'no'.  If omitted, it defaults to 'yes'.
-m4_define([_LT_ENABLE_FAST_INSTALL],
-[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([fast-install],
-    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
-    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
-    [p=${PACKAGE-default}
-    case $enableval in
-    yes) enable_fast_install=yes ;;
-    no) enable_fast_install=no ;;
-    *)
-      enable_fast_install=no
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for pkg in $enableval; do
-	IFS=$lt_save_ifs
-	if test "X$pkg" = "X$p"; then
-	  enable_fast_install=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac],
-    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
-
-_LT_DECL([fast_install], [enable_fast_install], [0],
-	 [Whether or not to optimize for fast installation])dnl
-])# _LT_ENABLE_FAST_INSTALL
-
-LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
-LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
-
-# Old names:
-AU_DEFUN([AC_ENABLE_FAST_INSTALL],
-[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the 'fast-install' option into LT_INIT's first parameter.])
-])
-
-AU_DEFUN([AC_DISABLE_FAST_INSTALL],
-[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the 'disable-fast-install' option into LT_INIT's first parameter.])
-])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
-dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
-
-
-# _LT_WITH_AIX_SONAME([DEFAULT])
-# ----------------------------------
-# implement the --with-aix-soname flag, and support the `aix-soname=aix'
-# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
-# is either `aix', `both' or `svr4'.  If omitted, it defaults to `aix'.
-m4_define([_LT_WITH_AIX_SONAME],
-[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl
-shared_archive_member_spec=
-case $host,$enable_shared in
-power*-*-aix[[5-9]]*,yes)
-  AC_MSG_CHECKING([which variant of shared library versioning to provide])
-  AC_ARG_WITH([aix-soname],
-    [AS_HELP_STRING([--with-aix-soname=aix|svr4|both],
-      [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])],
-    [case $withval in
-    aix|svr4|both)
-      ;;
-    *)
-      AC_MSG_ERROR([Unknown argument to --with-aix-soname])
-      ;;
-    esac
-    lt_cv_with_aix_soname=$with_aix_soname],
-    [AC_CACHE_VAL([lt_cv_with_aix_soname],
-      [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)
-    with_aix_soname=$lt_cv_with_aix_soname])
-  AC_MSG_RESULT([$with_aix_soname])
-  if test aix != "$with_aix_soname"; then
-    # For the AIX way of multilib, we name the shared archive member
-    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
-    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
-    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
-    # the AIX toolchain works better with OBJECT_MODE set (default 32).
-    if test 64 = "${OBJECT_MODE-32}"; then
-      shared_archive_member_spec=shr_64
-    else
-      shared_archive_member_spec=shr
-    fi
-  fi
-  ;;
-*)
-  with_aix_soname=aix
-  ;;
-esac
-
-_LT_DECL([], [shared_archive_member_spec], [0],
-    [Shared archive member basename, for filename based shared library versioning on AIX])dnl
-])# _LT_WITH_AIX_SONAME
-
-LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])])
-LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])])
-LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])])
-
-
-# _LT_WITH_PIC([MODE])
-# --------------------
-# implement the --with-pic flag, and support the 'pic-only' and 'no-pic'
-# LT_INIT options.
-# MODE is either 'yes' or 'no'.  If omitted, it defaults to 'both'.
-m4_define([_LT_WITH_PIC],
-[AC_ARG_WITH([pic],
-    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
-	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
-    [lt_p=${PACKAGE-default}
-    case $withval in
-    yes|no) pic_mode=$withval ;;
-    *)
-      pic_mode=default
-      # Look at the argument we got.  We use all the common list separators.
-      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
-      for lt_pkg in $withval; do
-	IFS=$lt_save_ifs
-	if test "X$lt_pkg" = "X$lt_p"; then
-	  pic_mode=yes
-	fi
-      done
-      IFS=$lt_save_ifs
-      ;;
-    esac],
-    [pic_mode=m4_default([$1], [default])])
-
-_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
-])# _LT_WITH_PIC
-
-LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
-LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
-
-# Old name:
-AU_DEFUN([AC_LIBTOOL_PICMODE],
-[_LT_SET_OPTION([LT_INIT], [pic-only])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the 'pic-only' option into LT_INIT's first parameter.])
-])
-
-dnl aclocal-1.4 backwards compatibility:
-dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
-
-## ----------------- ##
-## LTDL_INIT Options ##
-## ----------------- ##
-
-m4_define([_LTDL_MODE], [])
-LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
-		 [m4_define([_LTDL_MODE], [nonrecursive])])
-LT_OPTION_DEFINE([LTDL_INIT], [recursive],
-		 [m4_define([_LTDL_MODE], [recursive])])
-LT_OPTION_DEFINE([LTDL_INIT], [subproject],
-		 [m4_define([_LTDL_MODE], [subproject])])
-
-m4_define([_LTDL_TYPE], [])
-LT_OPTION_DEFINE([LTDL_INIT], [installable],
-		 [m4_define([_LTDL_TYPE], [installable])])
-LT_OPTION_DEFINE([LTDL_INIT], [convenience],
-		 [m4_define([_LTDL_TYPE], [convenience])])
diff --git a/libssh2/libssh2/m4/ltsugar.m4 b/libssh2/libssh2/m4/ltsugar.m4
deleted file mode 100644
index 48bc9344..00000000
--- a/libssh2/libssh2/m4/ltsugar.m4
+++ /dev/null
@@ -1,124 +0,0 @@
-# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
-#
-# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
-# Foundation, Inc.
-# Written by Gary V. Vaughan, 2004
-#
-# This file is free software; the Free Software Foundation gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-
-# serial 6 ltsugar.m4
-
-# This is to help aclocal find these macros, as it can't see m4_define.
-AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
-
-
-# lt_join(SEP, ARG1, [ARG2...])
-# -----------------------------
-# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
-# associated separator.
-# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
-# versions in m4sugar had bugs.
-m4_define([lt_join],
-[m4_if([$#], [1], [],
-       [$#], [2], [[$2]],
-       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
-m4_define([_lt_join],
-[m4_if([$#$2], [2], [],
-       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
-
-
-# lt_car(LIST)
-# lt_cdr(LIST)
-# ------------
-# Manipulate m4 lists.
-# These macros are necessary as long as will still need to support
-# Autoconf-2.59, which quotes differently.
-m4_define([lt_car], [[$1]])
-m4_define([lt_cdr],
-[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
-       [$#], 1, [],
-       [m4_dquote(m4_shift($@))])])
-m4_define([lt_unquote], $1)
-
-
-# lt_append(MACRO-NAME, STRING, [SEPARATOR])
-# ------------------------------------------
-# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'.
-# Note that neither SEPARATOR nor STRING are expanded; they are appended
-# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
-# No SEPARATOR is output if MACRO-NAME was previously undefined (different
-# than defined and empty).
-#
-# This macro is needed until we can rely on Autoconf 2.62, since earlier
-# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
-m4_define([lt_append],
-[m4_define([$1],
-	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
-
-
-
-# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
-# ----------------------------------------------------------
-# Produce a SEP delimited list of all paired combinations of elements of
-# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
-# has the form PREFIXmINFIXSUFFIXn.
-# Needed until we can rely on m4_combine added in Autoconf 2.62.
-m4_define([lt_combine],
-[m4_if(m4_eval([$# > 3]), [1],
-       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
-[[m4_foreach([_Lt_prefix], [$2],
-	     [m4_foreach([_Lt_suffix],
-		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
-	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
-
-
-# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
-# -----------------------------------------------------------------------
-# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
-# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
-m4_define([lt_if_append_uniq],
-[m4_ifdef([$1],
-	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
-		 [lt_append([$1], [$2], [$3])$4],
-		 [$5])],
-	  [lt_append([$1], [$2], [$3])$4])])
-
-
-# lt_dict_add(DICT, KEY, VALUE)
-# -----------------------------
-m4_define([lt_dict_add],
-[m4_define([$1($2)], [$3])])
-
-
-# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
-# --------------------------------------------
-m4_define([lt_dict_add_subkey],
-[m4_define([$1($2:$3)], [$4])])
-
-
-# lt_dict_fetch(DICT, KEY, [SUBKEY])
-# ----------------------------------
-m4_define([lt_dict_fetch],
-[m4_ifval([$3],
-	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
-    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
-
-
-# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
-# -----------------------------------------------------------------
-m4_define([lt_if_dict_fetch],
-[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
-	[$5],
-    [$6])])
-
-
-# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
-# --------------------------------------------------------------
-m4_define([lt_dict_filter],
-[m4_if([$5], [], [],
-  [lt_join(m4_quote(m4_default([$4], [[, ]])),
-           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
-		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
-])
diff --git a/libssh2/libssh2/m4/ltversion.m4 b/libssh2/libssh2/m4/ltversion.m4
deleted file mode 100644
index fa04b52a..00000000
--- a/libssh2/libssh2/m4/ltversion.m4
+++ /dev/null
@@ -1,23 +0,0 @@
-# ltversion.m4 -- version numbers			-*- Autoconf -*-
-#
-#   Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
-#   Written by Scott James Remnant, 2004
-#
-# This file is free software; the Free Software Foundation gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-
-# @configure_input@
-
-# serial 4179 ltversion.m4
-# This file is part of GNU Libtool
-
-m4_define([LT_PACKAGE_VERSION], [2.4.6])
-m4_define([LT_PACKAGE_REVISION], [2.4.6])
-
-AC_DEFUN([LTVERSION_VERSION],
-[macro_version='2.4.6'
-macro_revision='2.4.6'
-_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
-_LT_DECL(, macro_revision, 0)
-])
diff --git a/libssh2/libssh2/m4/lt~obsolete.m4 b/libssh2/libssh2/m4/lt~obsolete.m4
deleted file mode 100644
index c6b26f88..00000000
--- a/libssh2/libssh2/m4/lt~obsolete.m4
+++ /dev/null
@@ -1,99 +0,0 @@
-# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
-#
-#   Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
-#   Foundation, Inc.
-#   Written by Scott James Remnant, 2004.
-#
-# This file is free software; the Free Software Foundation gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-
-# serial 5 lt~obsolete.m4
-
-# These exist entirely to fool aclocal when bootstrapping libtool.
-#
-# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN),
-# which have later been changed to m4_define as they aren't part of the
-# exported API, or moved to Autoconf or Automake where they belong.
-#
-# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
-# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
-# using a macro with the same name in our local m4/libtool.m4 it'll
-# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
-# and doesn't know about Autoconf macros at all.)
-#
-# So we provide this file, which has a silly filename so it's always
-# included after everything else.  This provides aclocal with the
-# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
-# because those macros already exist, or will be overwritten later.
-# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
-#
-# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
-# Yes, that means every name once taken will need to remain here until
-# we give up compatibility with versions before 1.7, at which point
-# we need to keep only those names which we still refer to.
-
-# This is to help aclocal find these macros, as it can't see m4_define.
-AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
-
-m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
-m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
-m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
-m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
-m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
-m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
-m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
-m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
-m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
-m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
-m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
-m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
-m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
-m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
-m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
-m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
-m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
-m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
-m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
-m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
-m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
-m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
-m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
-m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
-m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
-m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
-m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
-m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
-m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
-m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
-m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
-m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
-m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
-m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
-m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
-m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
-m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
-m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
-m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
-m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
-m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
-m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
-m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
-m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
-m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
-m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
-m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
-m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
-m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
-m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
-m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
-m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
-m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
-m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
-m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS],	[AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
-m4_ifndef([_LT_AC_PROG_CXXCPP],		[AC_DEFUN([_LT_AC_PROG_CXXCPP])])
-m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS],	[AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
-m4_ifndef([_LT_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
-m4_ifndef([_LT_PROG_F77],		[AC_DEFUN([_LT_PROG_F77])])
-m4_ifndef([_LT_PROG_FC],		[AC_DEFUN([_LT_PROG_FC])])
-m4_ifndef([_LT_PROG_CXX],		[AC_DEFUN([_LT_PROG_CXX])])
diff --git a/libssh2/libssh2/maketgz b/libssh2/libssh2/maketgz
deleted file mode 100755
index b88d9608..00000000
--- a/libssh2/libssh2/maketgz
+++ /dev/null
@@ -1,99 +0,0 @@
-#! /bin/sh
-# Script to build release-archives with
-#
-
-version=$1
-
-if [ -z "$version" ]; then
-  echo "Specify a version number!"
-  exit
-fi
-
-if [ "xonly" = "x$2" ]; then
-    echo "Setup version number only!"
-    only=1
-fi
-
-libversion="$version"
-
-major=`echo $libversion |cut -d. -f1 | sed -e "s/[^0-9]//g"`
-minor=`echo $libversion |cut -d. -f2 | sed -e "s/[^0-9]//g"`
-patch=`echo $libversion |cut -d. -f3 | cut -d- -f1 | sed -e "s/[^0-9]//g"`
-
-numeric=`perl -e 'printf("%02x%02x%02x\n", '"$major, $minor, $patch);"`
-
-HEADER=include/libssh2.h
-
-if test -z "$only"; then
-    ext=".dist"
-    # when not setting up version numbers locally
-    for a in $HEADER; do
-        cp $a "$a$ext"
-    done
-    HEADER="$HEADER$ext"
-fi
-
-# requires a date command that knows -u for UTC time zone
-datestamp=`LC_TIME=C date -u`
-
-# Replace in-place version number in header file:
-sed -i -e 's/^#define LIBSSH2_VERSION .*/#define LIBSSH2_VERSION "'$libversion'"/g' \
-    -e 's/^#define LIBSSH2_VERSION_NUM .*/#define LIBSSH2_VERSION_NUM 0x'$numeric'/g' \
-    -e 's/^#define LIBSSH2_VERSION_MAJOR .*/#define LIBSSH2_VERSION_MAJOR '$major'/g' \
-    -e 's/^#define LIBSSH2_VERSION_MINOR .*/#define LIBSSH2_VERSION_MINOR '$minor'/g' \
-    -e 's/^#define LIBSSH2_VERSION_PATCH .*/#define LIBSSH2_VERSION_PATCH '$patch'/g' \
-    -e "s/^#define LIBSSH2_TIMESTAMP .*/#define LIBSSH2_TIMESTAMP \"$datestamp\"/g" \
- $HEADER
-
-echo "libssh2 version $libversion"
-echo "libssh2 numerical $numeric"
-echo "datestamp $datestamp"
-
-if test -n "$only"; then
-    # done!
-    exit;
-fi
-
-findprog()
-{
-  file="$1"
-  for part in `echo $PATH| tr ':' ' '`; do
-    path="$part/$file"
-    if [ -x "$path" ]; then
-      # there it is!
-      return 1
-    fi
-  done
-
-  # no such executable
-  return 0
-}
-
-############################################################################
-#
-# automake is needed to run to make a non-GNU Makefile.in if Makefile.am has
-# been modified.
-#
-
-if { findprog automake >/dev/null 2>/dev/null; } then
-  echo "- Could not find or run automake, I hope you know what you're doing!"
-else
-  echo "Runs automake --include-deps"
-  automake --include-deps Makefile >/dev/null
-fi
-
-#######################################################################
-#
-# Generate the changelog
-#
-echo "generate NEWS"
-git log --pretty=fuller --no-color --date=short --decorate=full -1000 | ./git2news.pl > NEWS.dist
-
-############################################################################
-#
-# Now run make dist to generate a tar.gz archive
-#
-
-echo "make dist"
-targz="libssh2-$version.tar.gz"
-make -s dist VERSION=$version
diff --git a/libssh2/libssh2/missing b/libssh2/libssh2/missing
deleted file mode 100755
index 8d0eaad2..00000000
--- a/libssh2/libssh2/missing
+++ /dev/null
@@ -1,215 +0,0 @@
-#! /bin/sh
-# Common wrapper for a few potentially missing GNU programs.
-
-scriptversion=2018-03-07.03; # UTC
-
-# Copyright (C) 1996-2020 Free Software Foundation, Inc.
-# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-if test $# -eq 0; then
-  echo 1>&2 "Try '$0 --help' for more information"
-  exit 1
-fi
-
-case $1 in
-
-  --is-lightweight)
-    # Used by our autoconf macros to check whether the available missing
-    # script is modern enough.
-    exit 0
-    ;;
-
-  --run)
-    # Back-compat with the calling convention used by older automake.
-    shift
-    ;;
-
-  -h|--h|--he|--hel|--help)
-    echo "\
-$0 [OPTION]... PROGRAM [ARGUMENT]...
-
-Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
-to PROGRAM being missing or too old.
-
-Options:
-  -h, --help      display this help and exit
-  -v, --version   output version information and exit
-
-Supported PROGRAM values:
-  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
-  bison     yacc      flex         lex       help2man
-
-Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
-'g' are ignored when checking the name.
-
-Send bug reports to <bug-automake@gnu.org>."
-    exit $?
-    ;;
-
-  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
-    echo "missing $scriptversion (GNU Automake)"
-    exit $?
-    ;;
-
-  -*)
-    echo 1>&2 "$0: unknown '$1' option"
-    echo 1>&2 "Try '$0 --help' for more information"
-    exit 1
-    ;;
-
-esac
-
-# Run the given program, remember its exit status.
-"$@"; st=$?
-
-# If it succeeded, we are done.
-test $st -eq 0 && exit 0
-
-# Also exit now if we it failed (or wasn't found), and '--version' was
-# passed; such an option is passed most likely to detect whether the
-# program is present and works.
-case $2 in --version|--help) exit $st;; esac
-
-# Exit code 63 means version mismatch.  This often happens when the user
-# tries to use an ancient version of a tool on a file that requires a
-# minimum version.
-if test $st -eq 63; then
-  msg="probably too old"
-elif test $st -eq 127; then
-  # Program was missing.
-  msg="missing on your system"
-else
-  # Program was found and executed, but failed.  Give up.
-  exit $st
-fi
-
-perl_URL=https://www.perl.org/
-flex_URL=https://github.com/westes/flex
-gnu_software_URL=https://www.gnu.org/software
-
-program_details ()
-{
-  case $1 in
-    aclocal|automake)
-      echo "The '$1' program is part of the GNU Automake package:"
-      echo "<$gnu_software_URL/automake>"
-      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
-      echo "<$gnu_software_URL/autoconf>"
-      echo "<$gnu_software_URL/m4/>"
-      echo "<$perl_URL>"
-      ;;
-    autoconf|autom4te|autoheader)
-      echo "The '$1' program is part of the GNU Autoconf package:"
-      echo "<$gnu_software_URL/autoconf/>"
-      echo "It also requires GNU m4 and Perl in order to run:"
-      echo "<$gnu_software_URL/m4/>"
-      echo "<$perl_URL>"
-      ;;
-  esac
-}
-
-give_advice ()
-{
-  # Normalize program name to check for.
-  normalized_program=`echo "$1" | sed '
-    s/^gnu-//; t
-    s/^gnu//; t
-    s/^g//; t'`
-
-  printf '%s\n' "'$1' is $msg."
-
-  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
-  case $normalized_program in
-    autoconf*)
-      echo "You should only need it if you modified 'configure.ac',"
-      echo "or m4 files included by it."
-      program_details 'autoconf'
-      ;;
-    autoheader*)
-      echo "You should only need it if you modified 'acconfig.h' or"
-      echo "$configure_deps."
-      program_details 'autoheader'
-      ;;
-    automake*)
-      echo "You should only need it if you modified 'Makefile.am' or"
-      echo "$configure_deps."
-      program_details 'automake'
-      ;;
-    aclocal*)
-      echo "You should only need it if you modified 'acinclude.m4' or"
-      echo "$configure_deps."
-      program_details 'aclocal'
-      ;;
-   autom4te*)
-      echo "You might have modified some maintainer files that require"
-      echo "the 'autom4te' program to be rebuilt."
-      program_details 'autom4te'
-      ;;
-    bison*|yacc*)
-      echo "You should only need it if you modified a '.y' file."
-      echo "You may want to install the GNU Bison package:"
-      echo "<$gnu_software_URL/bison/>"
-      ;;
-    lex*|flex*)
-      echo "You should only need it if you modified a '.l' file."
-      echo "You may want to install the Fast Lexical Analyzer package:"
-      echo "<$flex_URL>"
-      ;;
-    help2man*)
-      echo "You should only need it if you modified a dependency" \
-           "of a man page."
-      echo "You may want to install the GNU Help2man package:"
-      echo "<$gnu_software_URL/help2man/>"
-    ;;
-    makeinfo*)
-      echo "You should only need it if you modified a '.texi' file, or"
-      echo "any other file indirectly affecting the aspect of the manual."
-      echo "You might want to install the Texinfo package:"
-      echo "<$gnu_software_URL/texinfo/>"
-      echo "The spurious makeinfo call might also be the consequence of"
-      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
-      echo "want to install GNU make:"
-      echo "<$gnu_software_URL/make/>"
-      ;;
-    *)
-      echo "You might have modified some files without having the proper"
-      echo "tools for further handling them.  Check the 'README' file, it"
-      echo "often tells you about the needed prerequisites for installing"
-      echo "this package.  You may also peek at any GNU archive site, in"
-      echo "case some other package contains this missing '$1' program."
-      ;;
-  esac
-}
-
-give_advice "$1" | sed -e '1s/^/WARNING: /' \
-                       -e '2,$s/^/         /' >&2
-
-# Propagate the correct exit status (expected to be 127 for a program
-# not found, 63 for a program that failed due to version mismatch).
-exit $st
-
-# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/libssh2/libssh2/nw/GNUmakefile b/libssh2/libssh2/nw/GNUmakefile
deleted file mode 100644
index 8899fdd8..00000000
--- a/libssh2/libssh2/nw/GNUmakefile
+++ /dev/null
@@ -1,630 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (NetWare version - gnu make)
-## Use: make [help|all|clean|dev|devclean|dist|distclean|lib|nlm|objclean]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Novell NDK.
-ifndef NDKBASE
-NDKBASE	= c:/novell
-endif
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-0.9.8zc
-endif
-
-# Edit the path below to point to your Distribution folder.
-ifndef DISTDIR
-DISTDIR	= libssh2-$(LIBSSH2_VERSION_STR)-bin-nw
-endif
-DISTARC	= $(DISTDIR).zip
-
-# Edit the path below to point to your Development folder.
-ifndef DEVLDIR
-DEVLDIR	= libssh2-$(LIBSSH2_VERSION_STR)-dev-nw
-endif
-DEVLARC	= $(DEVLDIR).zip
-
-# Edit the vars below to change NLM target settings.
-TARGET	= libssh2
-VERSION	= $(LIBSSH2_VERSION)
-CPRIGHT	= Copyright (c) $(LIBSSH2_COPYRIGHT_STR)
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(LIBSSH2_VERSION_STR) ($(LIBARCH)) - $(WWWURL)
-MTSAFE	= YES
-STACK	= 64000
-SCREEN	= none
-EXPORTS	= @$(TARGET).imp
-
-# Edit the var below to point to your lib architecture.
-ifndef LIBARCH
-LIBARCH = LIBC
-endif
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# The following lines defines your compiler.
-ifdef CWFolder
-	METROWERKS = $(CWFolder)
-endif
-ifdef METROWERKS
-	# MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support
-	MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support/Metrowerks Support
-	CC = mwccnlm
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-# If you want to mark the target as MTSAFE you will need a tool for
-# generating the xdc data for the linker; here's a minimal tool:
-# http://www.gknw.net/development/prgtools/mkxdc.zip
-MPKXDC	= mkxdc
-ZIP	= zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif     
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# LIBARCH_U = $(shell $(AWK) 'BEGIN {print toupper(ARGV[1])}' $(LIBARCH))
-LIBARCH_L = $(shell $(AWK) 'BEGIN {print tolower(ARGV[1])}' $(LIBARCH))
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	+= $(OPT) -D$(DB) -DNETWARE -nostdinc
-#CFLAGS	+= -DHAVE_CONFIG_H
-
-ifeq ($(CC),mwccnlm)
-LD	= mwldnlm
-LDFLAGS	= -nostdlib $(PRELUDE) $(OBJL) -o $@ -commandfile
-AR	= mwldnlm
-ARFLAGS	= -nostdlib -type library -o
-LIBEXT	= lib
-CFLAGS	+= -msgstyle gcc -gccinc -inline on -opt nointrinsics -proc 586
-CFLAGS	+= -relax_pointers
-#CFLAGS	+= -w on
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.o
-	CFLAGS += -align 4
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	PRELUDE = "$(MWCW_PATH)/libraries/runtime/prelude.obj"
-	# CFLAGS += -include "$(MWCW_PATH)/headers/nlm_clib_prefix.h"
-	CFLAGS += -align 1
-endif
-else
-LD	= $(CROSSPREFIX)nlmconv
-LDFLAGS	= -UT
-AR	= $(CROSSPREFIX)ar
-ARFLAGS	= -cq
-LIBEXT	= a
-RANLIB	= $(CROSSPREFIX)ranlib
-CFLAGS	+= -m32
-CFLAGS	+= -fno-builtin -fpcc-struct-return
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-#CFLAGS	+= -Wno-pointer-sign
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	# http://www.gknw.net/development/mk_nlm/gcc_pre.zip
-	PRELUDE = $(NDK_ROOT)/pre/prelude.o
-	CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h
-endif
-endif
-
-LDLIBS	=
-
-NDK_ROOT = $(NDKBASE)/ndk
-SDK_CLIB = $(NDK_ROOT)/nwsdk
-SDK_LIBC = $(NDK_ROOT)/libc
-SNPRINTF = $(NDKBASE)/snprintf
-
-INCLUDES = -I. -I../include
-
-ifdef WITH_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-ifdef LINK_STATIC
-	LDLIBS += $(ZLIB_PATH)/nw/$(LIBARCH)/libz.$(LIBEXT)
-else
-	MODULES += libz.nlm
-	IMPORTS += @$(ZLIB_PATH)/nw/$(LIBARCH)/libz.imp
-endif
-endif
-INCLUDES += -I$(OPENSSL_PATH)/outinc_nw_$(LIBARCH_L)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/ssl.$(LIBEXT)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/crypto.$(LIBEXT)
-IMPORTS += GetProcessSwitchCount RunningProcess
-
-ifeq ($(LIBARCH),LIBC)
-	INCLUDES += -I$(SDK_LIBC)/include
-	# INCLUDES += -I$(SDK_LIBC)/include/nks
-	# INCLUDES += -I$(SDK_LIBC)/include/winsock
-	CFLAGS += -D_POSIX_SOURCE
-else
-	INCLUDES += -I$(SDK_CLIB)/include/nlm
-	# INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete
-	# INCLUDES += -I$(SDK_CLIB)/include
-endif
-CFLAGS	+= $(INCLUDES)
-
-ifeq ($(MTSAFE),YES)
-	XDCOPT = -n
-endif
-ifeq ($(MTSAFE),NO)
-	XDCOPT = -u
-endif
-ifdef XDCOPT
-	XDCDATA = $(OBJDIR)/$(TARGET).xdc
-endif
-
-vpath %.c . ../src
-
-# only OpenSSL is supported with this build system
-CFLAGS += -DLIBSSH2_OPENSSL
-include ../Makefile.OpenSSL.inc
-
-# include Makefile.inc to get CSOURCES define
-include ../Makefile.inc
-
-OBJECTS := $(patsubst %.c,%.o,$(CSOURCES))
-ifeq ($(LIBARCH),CLIB)
-# CLIB lacks of snprint() function - here's a replacement:
-# https://www.ijs.si/software/snprintf/
-OBJECTS += snprintf.o
-vpath %.c $(SNPRINTF)
-endif
-
-OBJS	:= $(addprefix $(OBJDIR)/,$(OBJECTS))
-OBJL	= $(OBJS) $(OBJDIR)/nwlib.o $(LDLIBS)
-
-all: lib nlm
-
-nlm: prebuild $(TARGET).nlm
-
-lib: prebuild $(TARGET).$(LIBEXT)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc libssh2_config.h
-
-test: all
-	$(MAKE) -C test
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: ../get_ver.awk ../include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-dist: all $(DISTDIR) $(DISTDIR)/readme.txt
-	@$(call MKDIR, $(DISTDIR)/bin)
-	@$(call COPY, ../AUTHORS, $(DISTDIR))
-	@$(call COPY, ../COPYING, $(DISTDIR))
-	@$(call COPY, ../INSTALL, $(DISTDIR))
-	@$(call COPY, ../README, $(DISTDIR))
-	@$(call COPY, ../RELEASE-NOTES, $(DISTDIR))
-	@$(call COPY, $(TARGET).nlm, $(DISTDIR)/bin)
-	@echo Creating $(DISTARC)
-	@$(ZIP) $(DISTARC) $(DISTDIR)/* < $(DISTDIR)/readme.txt
-
-dev: all $(DEVLDIR) $(DEVLDIR)/readme.txt
-	@$(call MKDIR, $(DEVLDIR)/bin)
-	@$(call MKDIR, $(DEVLDIR)/include)
-	@$(call MKDIR, $(DEVLDIR)/nw)
-	@$(call COPY, ../AUTHORS, $(DEVLDIR))
-	@$(call COPY, ../COPYING, $(DEVLDIR))
-	@$(call COPY, ../INSTALL, $(DEVLDIR))
-	@$(call COPY, ../README, $(DEVLDIR))
-	@$(call COPY, ../RELEASE-NOTES, $(DEVLDIR))
-	@$(call COPY, ../include/*.h, $(DEVLDIR)/include)
-	@$(call COPY, libssh2_config.h, $(DEVLDIR)/include)
-	@$(call COPY, $(TARGET).nlm, $(DEVLDIR)/bin)
-	@$(call COPY, $(TARGET).imp, $(DEVLDIR)/nw)
-	@$(call COPY, $(TARGET).$(LIBEXT), $(DEVLDIR)/nw)
-	@echo Creating $(DEVLARC)
-	@$(ZIP) $(DEVLARC) $(DEVLDIR)/* < $(DEVLDIR)/readme.txt
-
-distclean: clean
-	$(call RMDIR, $(DISTDIR))
-	$(call DEL, $(DISTARC))
-
-devclean: clean
-	$(call RMDIR, $(DEVLDIR))
-	$(call DEL, $(DEVLARC))
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-testclean: clean
-	$(MAKE) -C test clean
-
-clean: objclean
-	$(call DEL, libssh2_config.h)
-	$(call DEL, $(TARGET).*)
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-$(DISTDIR):
-	@$(call MKDIR, $@)
-
-$(DEVLDIR):
-	@$(call MKDIR, $@)
-
-$(TARGET).$(LIBEXT): $(OBJS)
-	@echo Creating $@
-	@$(call DEL, $@)
-	@$(AR) $(ARFLAGS) $@ $^
-ifdef RANLIB
-	@$(RANLIB) $@
-endif
-
-$(TARGET).nlm: $(OBJDIR)/$(TARGET).def $(TARGET).imp $(OBJL) $(XDCDATA)
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $<
-
-$(OBJDIR)/%.xdc: GNUmakefile
-	@echo Creating $@
-	@$(MPKXDC) $(XDCOPT) $@
-
-$(OBJDIR)/%.def: GNUmakefile
-	@echo $(DL)# DEF file for linking with $(LD)$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)#$(DL) >> $@
-	@echo $(DL)copyright "$(CPRIGHT)"$(DL) >> $@
-	@echo $(DL)description "$(DESCR)"$(DL) >> $@
-	@echo $(DL)version $(VERSION)$(DL) >> $@
-ifdef NLMTYPE
-	@echo $(DL)type $(NLMTYPE)$(DL) >> $@
-endif
-ifdef STACK
-	@echo $(DL)stack $(STACK)$(DL) >> $@
-endif
-ifdef SCREEN
-	@echo $(DL)screenname "$(SCREEN)"$(DL) >> $@
-else
-	@echo $(DL)screenname "DEFAULT"$(DL) >> $@
-endif
-ifeq ($(DB),DEBUG)
-	@echo $(DL)debug$(DL) >> $@
-endif
-	@echo $(DL)threadname "$(TARGET)"$(DL) >> $@
-ifdef XDCDATA
-	@echo $(DL)xdcdata $(XDCDATA)$(DL) >> $@
-endif
-	@echo $(DL)flag_on 64$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)start _Prelude$(DL) >> $@
-	@echo $(DL)exit _Stop$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@
-	@echo $(DL)module clib$(DL) >> $@
-else
-	@echo $(DL)pseudopreemption$(DL) >> $@
-	@echo $(DL)start _LibCPrelude$(DL) >> $@
-	@echo $(DL)exit _LibCPostlude$(DL) >> $@
-	@echo $(DL)check _LibCCheckUnload$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@
-	@echo $(DL)module libc$(DL) >> $@
-endif
-ifdef MODULES
-	@echo $(DL)module $(MODULES)$(DL) >> $@
-endif
-ifdef EXPORTS
-	@echo $(DL)export $(EXPORTS)$(DL) >> $@
-endif
-ifdef IMPORTS
-	@echo $(DL)import $(IMPORTS)$(DL) >> $@
-endif
-ifeq ($(LD),nlmconv)
-	@echo $(DL)input $(OBJL)$(DL) >> $@
-	@echo $(DL)input $(PRELUDE)$(DL) >> $@
-	@echo $(DL)output $(TARGET).nlm$(DL) >> $@
-endif
-
-libssh2_config.h: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)/* $@ for NetWare target.$(DL) > $@
-	@echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)** All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)*/$(DL) >> $@
-	@echo $(DL)#define VERSION "$(LIBSSH2_VERSION_STR)"$(DL) >> $@
-	@echo $(DL)#define PACKAGE_BUGREPORT "https://github.com/libssh2/libssh2/issues"$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)#define OS "i586-pc-clib-NetWare"$(DL) >> $@
-	@echo $(DL)#define NETDB_USE_INTERNET 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRICMP 1$(DL) >> $@
-	@echo $(DL)#define socklen_t int$(DL) >> $@
-	@echo $(DL)#define sleep(s) delay(1000 * s)$(DL) >> $@
-	@echo $(DL)#define strcasecmp stricmp$(DL) >> $@
-	@echo $(DL)#define strncasecmp strnicmp$(DL) >> $@
-else
-	@echo $(DL)#define OS "i586-pc-libc-NetWare"$(DL) >> $@
-	@echo $(DL)#define HAVE_DLFCN_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_DLOPEN 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FTRUNCATE 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETTIMEOFDAY 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_PTON 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INTTYPES_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LONGLONG 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STDINT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRCASECMP 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRLCAT 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRLCPY 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRTOLL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_PARAM_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SELECT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_TERMIOS_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_AF_INET6 1$(DL) >> $@
-	@echo $(DL)#define HAVE_PF_INET6 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_IN6_ADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_SOCKADDR_IN6 1$(DL) >> $@
-	@echo $(DL)#define SIZEOF_STRUCT_IN6_ADDR 16$(DL) >> $@
-ifdef ENABLE_IPV6
-	@echo $(DL)#define ENABLE_IPV6 1$(DL) >> $@
-endif
-endif
-	@echo $(DL)#define HAVE_ARPA_INET_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ASSERT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_CTYPE_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ERR_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ERRNO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FCNTL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FIONBIO 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETHOSTBYADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETHOSTBYNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETPROTOBYNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GMTIME_R 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_ADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_NTOA 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LOCALTIME_R 1$(DL) >> $@
-	@echo $(DL)#define HAVE_MALLOC_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_NETINET_IN_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SELECT 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SETJMP_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIGNAL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIGNAL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIG_ATOMIC_T 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SOCKET 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STDLIB_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRDUP 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRFTIME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRING_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRSTR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_ADDRINFO 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_TIMEVAL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_IOCTL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_STAT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_TIME_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_TIME_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UNISTD_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UTIME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UTIME_H 1$(DL) >> $@
-	@echo $(DL)#define RETSIGTYPE void$(DL) >> $@
-	@echo $(DL)#define SIZEOF_STRUCT_IN_ADDR 4$(DL) >> $@
-	@echo $(DL)#define STDC_HEADERS 1$(DL) >> $@
-	@echo $(DL)#define TIME_WITH_SYS_TIME 1$(DL) >> $@
-	@echo $(DL)#define USE_SSLEAY 1$(DL) >> $@
-	@echo $(DL)#define USE_OPENSSL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_X509_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_SSL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_RSA_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_PEM_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_ERR_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_CRYPTO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_ENGINE_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_O_NONBLOCK 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBSSL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBCRYPTO 1$(DL) >> $@
-	@echo $(DL)#define OPENSSL_NO_KRB5 1$(DL) >> $@
-ifdef WITH_ZLIB
-	@echo $(DL)#define HAVE_ZLIB_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBZ 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_HAVE_ZLIB 1$(DL) >> $@
-endif
-ifdef NW_WINSOCK
-	@echo $(DL)#define HAVE_CLOSESOCKET 1$(DL) >> $@
-else
-	@echo $(DL)#define HAVE_SYS_TYPES_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SOCKET_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SOCKIO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_NETDB_H 1$(DL) >> $@
-endif
-ifdef OLD_NOVELLSDK
-	@echo $(DL)#define socklen_t int$(DL) >> $@
-endif
-	@echo $(DL)#define LIBSSH2_DH_GEX_NEW 1$(DL) >> $@
-ifeq ($(DB),DEBUG)
-	@echo $(DL)#define LIBSSH2_DEBUG_CONNECTION 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_ERRORS 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_KEX 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_PUBLICKEY 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_SCP 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_SFTP 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_TRANSPORT 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_USERAUTH 1$(DL) >> $@
-endif
-
-libssh2.imp: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)# $@ for NetWare target.$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)  (CLIB_LIBSSH2)$(DL) >> $@
-else
-	@echo $(DL)  (LIBC_LIBSSH2)$(DL) >> $@
-endif
-	@echo $(DL)  libssh2_banner_set,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_close,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_direct_tcpip_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_flush_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_free,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_get_exit_status,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_open_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_process_startup,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_read_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_request_pty_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_send_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_set_blocking,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_setenv_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_wait_closed,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_wait_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_write_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_exit,$(DL) >> $@
-	@echo $(DL)  libssh2_hostkey_hash,$(DL) >> $@
-	@echo $(DL)  libssh2_init,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_add,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_check,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_checkp,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_free,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_init,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_readfile,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_writefile,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_recv,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_recv2,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_send64,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_send_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_abstract,$(DL) >> $@
-	@echo $(DL)  libssh2_session_block_directions,$(DL) >> $@
-	@echo $(DL)  libssh2_session_callback_set,$(DL) >> $@
-	@echo $(DL)  libssh2_session_disconnect_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_free,$(DL) >> $@
-	@echo $(DL)  libssh2_session_handshake,$(DL) >> $@
-	@echo $(DL)  libssh2_session_hostkey,$(DL) >> $@
-	@echo $(DL)  libssh2_session_init_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_last_errno,$(DL) >> $@
-	@echo $(DL)  libssh2_session_last_error,$(DL) >> $@
-	@echo $(DL)  libssh2_session_method_pref,$(DL) >> $@
-	@echo $(DL)  libssh2_session_methods,$(DL) >> $@
-	@echo $(DL)  libssh2_session_set_blocking,$(DL) >> $@
-	@echo $(DL)  libssh2_session_startup,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_close_handle,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_fstat_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_init,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_last_error,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_mkdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_open_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_read,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_readdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_rename_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_rmdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_seek,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_seek64,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_shutdown,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_stat_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_symlink_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_tell,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_unlink_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_write,$(DL) >> $@
-	@echo $(DL)  libssh2_trace,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_authenticated,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_keyboard_interactive_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_list,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_password_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_publickey_fromfile_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_version$(DL) >> $@
-
-$(DISTDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a binary distribution for NetWare platform.$(DL) > $@
-	@echo $(DL)libssh2 version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-$(DEVLDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a development distribution for NetWare platform.$(DL) > $@
-	@echo $(DL)libssh2 version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh2 package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-ifeq ($(LIBARCH),LIBC)
-	@echo $(DL)Novell LibC NDK = $(SDK_LIBC)$(DL)
-else
-	@echo $(DL)Novell CLib NDK = $(SDK_CLIB)$(DL)
-endif
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) nlm$(DL)
-	@echo $(DL)$(MAKE) lib$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) dev$(DL)
-	@echo $(DL)$(MAKE) devclean$(DL)
-	@echo $(DL)$(MAKE) dist$(DL)
-	@echo $(DL)$(MAKE) distclean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)$(MAKE) test$(DL)
-	@echo $(DL)===========================================================$(DL)
-
-
diff --git a/libssh2/libssh2/nw/keepscreen.c b/libssh2/libssh2/nw/keepscreen.c
deleted file mode 100644
index c3471b3e..00000000
--- a/libssh2/libssh2/nw/keepscreen.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Simple _NonAppStop() implementation which can be linked to your 
- * NLM in order to keep the screen open when the NLM terminates
- * (the good old clib behaviour).
- * You dont have to call it, its done automatically from LibC.
- *
- * 2004-Aug-11  by Guenter Knauf 
- *
- * URL: http://www.gknw.net/development/mk_nlm/
- */
- 
-#include <stdio.h>
-#include <screen.h>
-
-void _NonAppStop()
-{
-    uint16_t row, col;
-    
-    GetScreenSize(&row, &col);
-    gotorowcol(row-1, 0);
-    /* pressanykey(); */
-    printf("<Press any key to close screen> ");
-    getcharacter();
-}
-
-
diff --git a/libssh2/libssh2/nw/nwlib.c b/libssh2/libssh2/nw/nwlib.c
deleted file mode 100644
index 43018e59..00000000
--- a/libssh2/libssh2/nw/nwlib.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/*********************************************************************
- * Universal NetWare library stub.                                   *
- * written by Ulrich Neuman and given to OpenSource copyright-free.  *
- * Extended for CLIB support by Guenter Knauf.                       *
- *********************************************************************/
-
-#ifdef NETWARE /* Novell NetWare */
-
-#include <stdlib.h>
-
-#ifdef __NOVELL_LIBC__
-/* For native LibC-based NLM we need to register as a real lib. */
-#include <errno.h>
-#include <string.h>
-#include <library.h>
-#include <netware.h>
-#include <screen.h>
-#include <nks/thread.h>
-#include <nks/synch.h>
-
-typedef struct
-{
-  int     _errno;
-  void    *twentybytes;
-} libthreaddata_t;
-
-typedef struct
-{
-  int         x;
-  int         y;
-  int         z;
-  void        *tenbytes;
-  NXKey_t     perthreadkey;   /* if -1, no key obtained... */
-  NXMutex_t   *lock;
-} libdata_t;
-
-int         gLibId      = -1;
-void        *gLibHandle = (void *) NULL;
-rtag_t      gAllocTag   = (rtag_t) NULL;
-NXMutex_t   *gLibLock   = (NXMutex_t *) NULL;
-
-/* internal library function prototypes... */
-int     DisposeLibraryData ( void * );
-void    DisposeThreadData ( void * );
-int     GetOrSetUpData ( int id, libdata_t **data, libthreaddata_t **threaddata );
-
-
-int _NonAppStart( void        *NLMHandle,
-                  void        *errorScreen,
-                  const char  *cmdLine,
-                  const char  *loadDirPath,
-                  size_t      uninitializedDataLength,
-                  void        *NLMFileHandle,
-                  int         (*readRoutineP)( int conn,
-                                               void *fileHandle, size_t offset,
-                                               size_t nbytes,
-                                               size_t *bytesRead,
-                                               void *buffer ),
-                  size_t      customDataOffset,
-                  size_t      customDataSize,
-                  int         messageCount,
-                  const char  **messages )
-{
-  NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);
-
-#ifndef __GNUC__
-#pragma unused(cmdLine)
-#pragma unused(loadDirPath)
-#pragma unused(uninitializedDataLength)
-#pragma unused(NLMFileHandle)
-#pragma unused(readRoutineP)
-#pragma unused(customDataOffset)
-#pragma unused(customDataSize)
-#pragma unused(messageCount)
-#pragma unused(messages)
-#endif
-
-/*
-** Here we process our command line, post errors (to the error screen),
-** perform initializations and anything else we need to do before being able
-** to accept calls into us. If we succeed, we return non-zero and the NetWare
-** Loader will leave us up, otherwise we fail to load and get dumped.
-*/
-  gAllocTag = AllocateResourceTag(NLMHandle,
-                   "<library-name> memory allocations", AllocSignature);
-
-  if (!gAllocTag) {
-    OutputToScreen(errorScreen, "Unable to allocate resource tag for "
-                     "library memory allocations.\n");
-    return -1;
-  }
-
-  gLibId = register_library(DisposeLibraryData);
-
-  if (gLibId < -1) {
-    OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
-    return -1;
-  }
-
-  gLibHandle = NLMHandle;
-
-  gLibLock = NXMutexAlloc(0, 0, &liblock);
-
-  if (!gLibLock) {
-    OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
-    return -1;
-  }
-
-  return 0;
-}
-
-/*
-** Here we clean up any resources we allocated. Resource tags is a big part
-** of what we created, but NetWare doesn't ask us to free those.
-*/
-void _NonAppStop( void )
-{
-  (void) unregister_library(gLibId);
-  NXMutexFree(gLibLock);
-}
-
-/*
-** This function cannot be the first in the file for if the file is linked
-** first, then the check-unload function's offset will be nlmname.nlm+0
-** which is how to tell that there isn't one. When the check function is
-** first in the linked objects, it is ambiguous. For this reason, we will
-** put it inside this file after the stop function.
-**
-** Here we check to see if it's alright to ourselves to be unloaded. If not,
-** we return a non-zero value. Right now, there isn't any reason not to allow
-** it.
-*/
-int _NonAppCheckUnload( void )
-{
-  return 0;
-}
-
-int GetOrSetUpData(int id, libdata_t **appData, libthreaddata_t **threadData)
-{
-  int              err;
-  libdata_t        *app_data;
-  libthreaddata_t  *thread_data;
-  NXKey_t          key;
-  NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);
-
-  err         = 0;
-  thread_data = (libthreaddata_t *) NULL;
-
-/*
-** Attempt to get our data for the application calling us. This is where we
-** store whatever application-specific information we need to carry in support
-** of calling applications.
-*/
-  app_data = (libdata_t *) get_app_data(id);
-
-  if (!app_data) {
-/*
-** This application hasn't called us before; set up application AND per-thread
-** data. Of course, just in case a thread from this same application is calling
-** us simultaneously, we better lock our application data-creation mutex. We
-** also need to recheck for data after we acquire the lock because WE might be
-** that other thread that was too late to create the data and the first thread
-** in will have created it.
-*/
-    NXLock(gLibLock);
-
-    if (!(app_data = (libdata_t *) get_app_data(id))) {
-      app_data = (libdata_t *) malloc(sizeof(libdata_t));
-
-      if (app_data) {
-        memset(app_data, 0, sizeof(libdata_t));
-
-        app_data->tenbytes = malloc(10);
-        app_data->lock     = NXMutexAlloc(0, 0, &liblock);
-
-        if (!app_data->tenbytes || !app_data->lock) {
-          if (app_data->lock)
-            NXMutexFree(app_data->lock);
-
-          free(app_data);
-          app_data = (libdata_t *) NULL;
-          err      = ENOMEM;
-        }
-
-        if (app_data) {
-/*
-** Here we burn in the application data that we were trying to get by calling
-** get_app_data(). Next time we call the first function, we'll get this data
-** we're just now setting. We also go on here to establish the per-thread data
-** for the calling thread, something we'll have to do on each application
-** thread the first time it calls us.
-*/
-          err = set_app_data(gLibId, app_data);
-
-          if (err) {
-            free(app_data);
-            app_data = (libdata_t *) NULL;
-            err      = ENOMEM;
-          }
-          else {
-            /* create key for thread-specific data... */
-            err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);
-
-            if (err)                /* (no more keys left?) */
-              key = -1;
-
-            app_data->perthreadkey = key;
-          }
-        }
-      }
-    }
-
-    NXUnlock(gLibLock);
-  }
-
-  if (app_data) {
-    key = app_data->perthreadkey;
-
-    if (key != -1 /* couldn't create a key? no thread data */
-        && !(err = NXKeyGetValue(key, (void **) &thread_data))
-        && !thread_data) {
-/*
-** Allocate the per-thread data for the calling thread. Regardless of whether
-** there was already application data or not, this may be the first call by a
-** a new thread. The fact that we allocation 20 bytes on a pointer is not very
-** important, this just helps to demonstrate that we can have arbitrarily
-** complex per-thread data.
-*/
-      thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));
-
-      if (thread_data) {
-        thread_data->_errno      = 0;
-        thread_data->twentybytes = malloc(20);
-
-        if (!thread_data->twentybytes) {
-          free(thread_data);
-          thread_data = (libthreaddata_t *) NULL;
-          err         = ENOMEM;
-        }
-
-        if ((err = NXKeySetValue(key, thread_data))) {
-          free(thread_data->twentybytes);
-          free(thread_data);
-          thread_data = (libthreaddata_t *) NULL;
-        }
-      }
-    }
-  }
-
-  if (appData)
-    *appData = app_data;
-
-  if (threadData)
-    *threadData = thread_data;
-
-  return err;
-}
-
-int DisposeLibraryData( void *data )
-{
-  if (data) {
-    void *tenbytes = ((libdata_t *) data)->tenbytes;
-
-    if (tenbytes)
-      free(tenbytes);
-
-    free(data);
-  }
-
-  return 0;
-}
-
-void DisposeThreadData( void *data )
-{
-  if (data) {
-    void *twentybytes = ((libthreaddata_t *) data)->twentybytes;
-
-    if (twentybytes)
-      free(twentybytes);
-
-    free(data);
-  }
-}
-
-#else /* __NOVELL_LIBC__ */
-/* For native CLib-based NLM seems we can do a bit more simple. */
-#include <nwthread.h>
-
-int main ( void )
-{
-  /* initialize any globals here... */
-
-  /* do this if any global initializing was done
-  SynchronizeStart();
-  */
-  ExitThread (TSR_THREAD, 0);
-  return 0;
-}
-
-#endif /* __NOVELL_LIBC__ */
-
-#endif /* NETWARE */
-
-
diff --git a/libssh2/libssh2/nw/test/GNUmakefile b/libssh2/libssh2/nw/test/GNUmakefile
deleted file mode 100644
index 86bf6b68..00000000
--- a/libssh2/libssh2/nw/test/GNUmakefile
+++ /dev/null
@@ -1,311 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (NetWare version - gnu make)
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Novell NDK.
-ifndef NDKBASE
-NDKBASE	= c:/novell
-endif
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8zc
-endif
-
-# Edit the var below to enable static linking of libssh2 and libz
-LINK_STATIC = 1
-
-# Edit the vars below to change NLM target settings.
-SAMPLES	= ../../example
-TARGETS := $(filter-out x11.nlm,$(patsubst $(SAMPLES)/%.c,%.nlm,$(strip $(wildcard $(SAMPLES)/*.c))))
-VERSION	= $(LIBSSH2_VERSION)
-COPYR   = Copyright (c) $(LIBSSH2_COPYRIGHT_STR)
-WWWURL	= http://www.libssh2.org/
-DESCR	= libssh2 $(notdir $(@:.def=)) $(LIBSSH2_VERSION_STR) ($(LIBARCH)) - $(WWWURL)
-MTSAFE	= YES
-STACK	= 64000
-SCREEN	= NONE
-#SCREEN	= libssh2 $(notdir $(@:.def=))
-# Comment the line below if you dont want to load protected automatically.
-#LDRING	= 3
-
-# Edit the var below to point to your lib architecture.
-ifndef LIBARCH
-LIBARCH = LIBC
-endif
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# The following lines defines your compiler.
-ifdef CWFolder
-	METROWERKS = $(CWFolder)
-endif
-ifdef METROWERKS
-	# MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support
-	MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support/Metrowerks Support
-	CC = mwccnlm
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-# If you want to mark the target as MTSAFE you will need a tool for
-# generating the xdc data for the linker; here's a minimal tool:
-# http://www.gknw.net/development/prgtools/mkxdc.zip
-MPKXDC	= mkxdc
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif     
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# LIBARCH_U = $(shell $(AWK) 'BEGIN {print toupper(ARGV[1])}' $(LIBARCH))
-LIBARCH_L = $(shell $(AWK) 'BEGIN {print tolower(ARGV[1])}' $(LIBARCH))
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	+= $(OPT) -D$(DB) -DNETWARE -nostdinc
-
-ifeq ($(CC),mwccnlm)
-LD	= mwldnlm
-LDFLAGS	= -nostdlib $(<:.def=.o) $(PRELUDE) $(LDLIBS) -o $@ -commandfile
-AR	= mwldnlm
-ARFLAGS	= -type library -w nocmdline $(OBJS) -o
-LIBEXT	= lib
-CFLAGS	+= -msgstyle gcc -gccinc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -relax_pointers
-#CFLAGS	+= -w on
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.o
-	CFLAGS += -align 4
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	PRELUDE = "$(MWCW_PATH)/libraries/runtime/prelude.obj"
-	# CFLAGS += -include "$(MWCW_PATH)/headers/nlm_clib_prefix.h"
-	CFLAGS += -align 1
-endif
-else
-LD	= nlmconv
-LDFLAGS	= -UT
-AR	= ar
-ARFLAGS	= -cq
-LIBEXT	= a
-CFLAGS	+= -m32
-CFLAGS	+= -fno-builtin -fpcc-struct-return
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o
-        # to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-        # http://www.gknw.net/development/mk_nlm/gcc_pre.zip
-        PRELUDE = $(NDK_ROOT)/pre/prelude.o
-	CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h
-endif
-endif
-
-NDK_ROOT = $(NDKBASE)/ndk
-SDK_CLIB = $(NDK_ROOT)/nwsdk
-SDK_LIBC = $(NDK_ROOT)/libc
-SNPRINTF = $(NDKBASE)/snprintf
-
-INCLUDES = -I.. -I../../include
-
-LDLIBS =
- 
-ifdef LINK_STATIC
-	LDLIBS += ../libssh2.$(LIBEXT)
-else
-	IMPORTS += @../libssh2.imp
-	MODULES += libssh2.nlm
-endif
-
-INCLUDES += -I$(OPENSSL_PATH)/outinc_nw_$(LIBARCH_L)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/ssl.$(LIBEXT)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/crypto.$(LIBEXT)
-IMPORTS += GetProcessSwitchCount RunningProcess
-
-ifdef WITH_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-ifdef LINK_STATIC
-	LDLIBS += $(ZLIB_PATH)/nw/$(LIBARCH)/libz.$(LIBEXT)
-else
-	MODULES += libz.nlm
-	IMPORTS += @$(ZLIB_PATH)/nw/$(LIBARCH)/libz.imp
-endif
-endif
-
-ifeq ($(LIBARCH),LIBC)
-	INCLUDES += -I$(SDK_LIBC)/include
-	# INCLUDES += -I$(SDK_LIBC)/include/nks
-	# INCLUDES += -I$(SDK_LIBC)/include/winsock
-	CFLAGS += -D_POSIX_SOURCE
-else
-	INCLUDES += -I$(SDK_CLIB)/include/nlm
-	# INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete
-	# INCLUDES += -I$(SDK_CLIB)/include
-	# CFLAGS += -DNETDB_USE_INTERNET
-endif
-CFLAGS	+= $(INCLUDES)
-
-ifeq ($(MTSAFE),YES)
-	XDCOPT = -n
-endif
-ifeq ($(MTSAFE),NO)
-	XDCOPT = -u
-endif
-
-vpath %.c $(SAMPLES)
-
-.PRECIOUS: $(OBJDIR)/%.o $(OBJDIR)/%.def $(OBJDIR)/%.xdc
-
-
-all: prebuild $(TARGETS) 
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: ../../get_ver.awk ../../include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-clean: objclean
-	$(foreach f, $(TARGETS), $(call DEL, $(f)))
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-%.nlm: $(OBJDIR)/%.def $(OBJDIR)/%.o $(OBJDIR)/%.xdc
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $<
-
-$(OBJDIR)/%.xdc: GNUmakefile
-	@echo Creating $@
-	@$(MPKXDC) $(XDCOPT) $@
-
-$(OBJDIR)/%.def: GNUmakefile
-	@echo $(DL)# DEF file for linking with $(LD)$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)#$(DL) >> $@
-	@echo $(DL)copyright "$(COPYR)"$(DL) >> $@
-	@echo $(DL)description "$(DESCR)"$(DL) >> $@
-	@echo $(DL)version $(VERSION)$(DL) >> $@
-ifdef NLMTYPE
-	@echo $(DL)type $(NLMTYPE)$(DL) >> $@
-endif
-ifdef STACK
-	@echo $(DL)stack $(STACK)$(DL) >> $@
-endif
-ifdef SCREEN
-	@echo $(DL)screenname "$(SCREEN)"$(DL) >> $@
-else
-	@echo $(DL)screenname "DEFAULT"$(DL) >> $@
-endif
-ifeq ($(DB),DEBUG)
-	@echo $(DL)debug$(DL) >> $@
-endif
-	@echo $(DL)threadname "$(notdir $(@:.def=))"$(DL) >> $@
-ifdef XDCOPT
-	@echo $(DL)xdcdata $(@:.def=.xdc)$(DL) >> $@
-endif
-ifeq ($(LDRING),0)
-	@echo $(DL)flag_on 16$(DL) >> $@
-endif
-ifeq ($(LDRING),3)
-	@echo $(DL)flag_on 512$(DL) >> $@
-endif
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)start _Prelude$(DL) >> $@
-	@echo $(DL)exit _Stop$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@
-	@echo $(DL)module clib$(DL) >> $@
-else
-	@echo $(DL)flag_on 64$(DL) >> $@
-	@echo $(DL)pseudopreemption$(DL) >> $@
-	@echo $(DL)start _LibCPrelude$(DL) >> $@
-	@echo $(DL)exit _LibCPostlude$(DL) >> $@
-	@echo $(DL)check _LibCCheckUnload$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@
-	@echo $(DL)module libc$(DL) >> $@
-endif
-ifdef MODULES
-	@echo $(DL)module $(MODULES)$(DL) >> $@
-endif
-ifdef EXPORTS
-	@echo $(DL)export $(EXPORTS)$(DL) >> $@
-endif
-ifdef IMPORTS
-	@echo $(DL)import $(IMPORTS)$(DL) >> $@
-endif
-ifeq ($(LD),nlmconv)
-	@echo $(DL)input $(@:.def=.o)$(DL) >> $@
-	@echo $(DL)input $(PRELUDE)$(DL) >> $@
-ifdef LDLIBS
-	@echo $(DL)input $(LDLIBS)$(DL) >> $@
-endif
-	@echo $(DL)output $(notdir $(@:.def=.nlm))$(DL) >> $@
-endif
-
diff --git a/libssh2/libssh2/os400/README400 b/libssh2/libssh2/os400/README400
deleted file mode 100644
index fdac7da5..00000000
--- a/libssh2/libssh2/os400/README400
+++ /dev/null
@@ -1,169 +0,0 @@
-
-Implementation notes:
-
-  This is a true OS/400 implementation, not a PASE implementation (for PASE,
-use AIX implementation).
-
-It uses ASCII as internal character set. This has been accomplished using the
-QADRT library and include files, a C and system procedures ASCII wrapper
-library. See IBM QADRT description for more information.
-  This results in libssh2 being an ASCII library: any function string
-argument is taken/returned in ASCII and a C/C++ calling program built around
-QADRT may use libssh2 functions as on any other platform.
-  QADRT does not define ASCII wrappers for all C/system procedures: an
-additional module (os400sys.c) define some more of them, that are used by
-libssh2 and that QADRT left out.
-  Since standard library entry points expect and return ASCII character strings,
-additional procedures are provided for string transcoding (see below). No
-wrappers to standard procedures are provided: however, nested calls to
-transcoding procedures may be used.
-
-Crypto API is provided by the IBM QC3 API library. It supports RSA, but not DSA.
-
-
-  Standard compilation environment does support neither autotools nor make;
-in fact, very few common utilities are available. As a consequence, the
-libssh2_config.h has been coded manually and the compilation scripts are
-a set of shell scripts stored in subdirectory os400.
-
-  The test environment is currently not supported on OS/400.
-
-
-
-Compiling on OS/400:
-
-  These instructions target people who knows about OS/400, compiling, IFS and
-archive extraction. Do not ask questions about these subjects if you're not
-familiar with.
-
-_ As a prerequisite, QADRT development environment must be installed.
-_ Install the libssh2 sources directory in IFS.
-_ Enter shell (QSH)
-_ Change current directory to the libssh2 sources installation directory
-_ Change current directory to os400
-_ Edit file iniscript.sh. You may want to change tunable configuration
-  parameters, like debug info generation, optimisation level, listing option,
-  target library, zlib availability and location, etc.
-_ Copy any file in the current directory to makelog (i.e.:
-  cp initscript.sh makelog): this is intended to create the makelog file with
-  an ASCII CCSID!
-_ Enter the command "sh make.sh > makelog 2>&1'
-_ Examine the makelog file to check for compilation errors.
-
-  Leaving file initscript.sh unchanged, this will produce the following OS/400
-objects:
-_ Library LIBSSH2. All other objects will be stored in this library.
-_ Modules for all libssh2 units.
-_ Binding directory LIBSSH2_A, to be used at calling program link time for
-  statically binding the modules (specify BNDSRVPGM(QADRTTS) when creating a
-  program using LIBSSH2_A. Also give access to the zlib BNDDIR/SRVPGM if
-  libssh2 is compiled with zlib).
-_ Service program LIBSSH2.<soname>, where <soname> is extracted from the
-  src/Makefile.am VERSION variable. To be used at calling program run-time
-  when this program has dynamically bound libssh2 at link time.
-_ Binding directory LIBSSH2. To be used to dynamically bind libssh2 when
-  linking a calling program.
-_ Source file H. It contains all the include members needed to compile a C/C++
-  module using libssh2.
-_ LIBSSH2, SSH2_PKEY, SSH2_SFTP members in file H. These are the C/C++ header
-  files. Original fames have been mangled to fit member name allowed syntax.
-_ Source file LIBSSH2RPG. It contains all the ILE/RPG /INCLUDE members
-  needed to compile an ILE/RPG program calling libssh2 procedures.
-_ LIBSSH2, SSH2_PKEY, SSH2_SFTP members in file LIBSSH2RPG. These are
-  ILE/RPG translations of the corresponding C header files.
-
-
-
-Special programming consideration:
-
-QADRT being used, the following points must be considered:
-_ If static binding is used, service program QADRTTS must be linked too.
-_ Likewise, if libssh2 has been compiled with zlib support, access to the
-  zlib objects must be provided at link time.
-_ The EBCDIC CCSID used by QADRT is 37 by default, NOT THE JOB'S CCSID. If
-  another EBCDIC CCSID is required, it must be set via a locale through a call
-  to setlocale_a (QADRT's setlocale() ASCII wrapper) with category LC_ALL or
-  LC_CTYPE, or by setting environment variable QADRT_ENV_LOCALE to the locale
-  object path before executing the program.
-_ Do not use original source include files unless you know what you are doing.
-  Use the installed members instead (in /QSYS.LIB/LIBSSH2.LIB/H.FILE).
-
-
-
-String transcoding support:
-
-  To help passing arbitrarily encoded string arguments and/or receiving string
-values from/to the libssh2 API, three non-standard additional procedures are
-provided. They use a session pointer and a "string cache" pointer.
-  Each time a string is transcoded, it is cached in the given cache. It is
-the responsibility of the caller to release the cache when its associted strings
-are no longer needed. These procedures and the string cache type are defined
-in a new libssh2_ccsid.h header file.
-  To create a string cache, use:
-
-#include <libssh2_ccsid.h>
-libssh2_string_cache *  cache = NULL;
-
-  To release all strings in a cache, call:
-
-libssh2_release_string_cache(session, &cache);
-
-  The transcoding procedures are:
-
-char * libssh2_from_ccsid(LIBSSH2_SESSION *session,
-                          libssh2_string_cache **cache,
-                          unsigned short ccsid,
-                          const char *string, ssize_t inlen,
-                          size_t *outlen);
-char * libssh2_to_ccsid(LIBSSH2_SESSION *session,
-                        libssh2_string_cache **cache,
-                        unsigned short ccsid,
-                        const char *string, ssize_t inlen,
-                        size_t *outlen);
-
-where:
-    session      is a libssh2 session used for memory allocation.
-    cache        is the address of a string cache.
-    ccsid        is the external (i.e.: non libssh2) coded character set id.
-                 65535 means no conversion and 0 means the current job's CCSID.
-    string       is the string to convert.
-    inlen        is the source string length in bytes: set to -1 if
-                 null-terminated.
-    outlen       if not NULL, is the address of a variable that will receive
-                 the transcoded string length upon return.
-
-  libssh2_from_ccsid() transcodes the string from the given CCSID to libssh2
-internal encoding (UTF-8). It is intended to be used to convert API input
-parameters.
-  libssh2_to_ccsid() transcodes the string from libssh2 internal encoding
-(UTF-8) to the given CCSID. This has been implemented to get standard API
-string results in a program's native encoding.
-
-  Both these functions return a pointer to the null-terminated converted string,
-or NULL if an error occurred. In addition, the variable pointed by outlen
-receives the effective byte length of the (cached) translated string, or -1
-in case of error.
-
-
-
-ILE/RPG support:
-
-  Since 95% of the OS/400 programmers use ILE/RPG exclusively, a definition
-  /INCLUDE member is provided for this language. To include libssh2
-  definitions in an ILE/RPG module, line
-
-     h bnddir('LIBSSH2/LIBSSH2')
-
-must figure in the program header, and line
-
-     d/include libssh2/libssh2rpg,libssh2
-
-in the global data section of the module's source code.
-If required, members ssh2_sftp, ssh2_pkey and ssh2_ccsid may also be included.
-
-For IFS source compilations, include members are located in directory
-/libssh2/include/libssh2rpg and have their original names retained.
-
-ILE/RPG lacks a serious macro preprocessor, thus C macros requiring this
-feature have not been translated. However, function-like C macros have been
-implemented as procedures and therefore supported in ILE/RPG.
diff --git a/libssh2/libssh2/os400/ccsid.c b/libssh2/libssh2/os400/ccsid.c
deleted file mode 100644
index ef02f1d3..00000000
--- a/libssh2/libssh2/os400/ccsid.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Character encoding wrappers. */
-
-#include "libssh2_priv.h"
-#include "libssh2_ccsid.h"
-
-#include <qtqiconv.h>
-#include <iconv.h>
-#include <errno.h>
-#include <string.h>
-#include <stdio.h>
-
-
-
-#define CCSID_UTF8      1208
-#define CCSID_UTF16BE   13488
-#define STRING_GRANULE  256
-#define MAX_CHAR_SIZE   4
-
-#define OFFSET_OF(t, f) ((size_t) ((char *) &((t *) 0)->f - (char *) 0))
-
-
-struct _libssh2_string_cache {
-    libssh2_string_cache *  next;
-    char                    string[1];
-};
-
-
-static const QtqCode_T  utf8code = { CCSID_UTF8 };
-
-
-static ssize_t
-terminator_size(unsigned short ccsid)
-{
-    QtqCode_T outcode;
-    iconv_t cd;
-    char *inp;
-    char *outp;
-    size_t ilen;
-    size_t olen;
-    char buf[MAX_CHAR_SIZE];
-
-    /* Return the null-terminator size for the given CCSID. */
-
-    /* Fast check usual CCSIDs. */
-    switch (ccsid) {
-    case CCSID_UTF8:
-    case 0:                                 /* Job CCSID is SBCS EBCDIC. */
-        return 1;
-    case CCSID_UTF16BE:
-        return 2;
-    }
-
-    /* Convert an UTF-8 NUL to the target CCSID: use the converted size as
-       result. */
-    memset((void *) &outcode, 0, sizeof outcode);
-    outcode.CCSID = ccsid;
-    cd = QtqIconvOpen(&outcode, (QtqCode_T *) &utf8code);
-    if (cd.return_value == -1)
-        return -1;
-    inp = "";
-    ilen = 1;
-    outp = buf;
-    olen = sizeof buf;
-    iconv(cd, &inp, &ilen, &outp, &olen);
-    iconv_close(cd);
-    olen = sizeof buf - olen;
-    return olen? olen: -1;
-}
-
-static char *
-convert_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
-              unsigned short outccsid, unsigned short inccsid,
-              const char *instring, ssize_t inlen, size_t *outlen)
-{
-    char *inp;
-    char *outp;
-    size_t olen;
-    size_t ilen;
-    size_t buflen;
-    size_t curlen;
-    ssize_t termsize;
-    int i;
-    char *dst;
-    libssh2_string_cache *outstring;
-    QtqCode_T incode;
-    QtqCode_T outcode;
-    iconv_t cd;
-
-    if (!instring) {
-        if (outlen)
-            *outlen = 0;
-        return NULL;
-    }
-    if (outlen)
-        *outlen = -1;
-    if (!session || !cache)
-        return NULL;
-
-    /* Get terminator size. */
-    termsize = terminator_size(outccsid);
-    if (termsize < 0)
-        return NULL;
- 
-    /* Prepare conversion parameters. */
-    memset((void *) &incode, 0, sizeof incode);
-    memset((void *) &outcode, 0, sizeof outcode);
-    incode.CCSID = inccsid;
-    outcode.CCSID = outccsid;
-    curlen = OFFSET_OF(libssh2_string_cache, string);
-    inp = (char *) instring;
-    ilen = inlen;
-    buflen = inlen + curlen;
-    if (inlen < 0) {
-        incode.length_option = 1;
-        buflen = STRING_GRANULE;
-        ilen = 0;
-    }
-
-    /* Allocate output string buffer and open conversion descriptor. */
-    dst = LIBSSH2_ALLOC(session, buflen + termsize);
-    if (!dst)
-        return NULL;
-    cd = QtqIconvOpen(&outcode, &incode);
-    if (cd.return_value == -1) {
-        LIBSSH2_FREE(session, (char *) dst);
-        return NULL;
-    }
-
-    /* Convert string. */
-    for (;;) {
-        outp = dst + curlen;
-        olen = buflen - curlen;
-        i = iconv(cd, &inp, &ilen, &outp, &olen);
-        if (inlen < 0 && olen == buflen - curlen) {
-            /* Special case: converted 0-length (sub)strings do not store the
-               terminator. */
-            if (termsize) {
-                memset(outp, 0, termsize);
-                olen -= termsize;
-            }
-        }
-        curlen = buflen - olen;
-        if (i >= 0 || errno != E2BIG)
-            break;
-        /* Must expand buffer. */
-        buflen += STRING_GRANULE;
-        outp = LIBSSH2_REALLOC(session, dst, buflen + termsize);
-        if (!outp)
-            break;
-        dst = outp;
-    }
-
-    iconv_close(cd);
-
-    /* Check for error. */
-    if (i < 0 || !outp) {
-        LIBSSH2_FREE(session, dst);
-        return NULL;
-    }
-
-    /* Process terminator. */
-    if (inlen < 0)
-        curlen -= termsize;
-    else if (termsize)
-        memset(dst + curlen, 0, termsize);
-
-    /* Shorten buffer if possible. */
-    if (curlen < buflen)
-        dst = LIBSSH2_REALLOC(session, dst, curlen + termsize);
-
-    /* Link to cache. */
-    outstring = (libssh2_string_cache *) dst;
-    outstring->next = *cache;
-    *cache = outstring;
-
-    /* Return length if required. */
-    if (outlen)
-        *outlen = curlen - OFFSET_OF(libssh2_string_cache, string);
-
-    return outstring->string;
-}
-
-LIBSSH2_API char *
-libssh2_from_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
-                   unsigned short ccsid, const char *string, ssize_t inlen,
-                   size_t *outlen)
-{
-    return convert_ccsid(session, cache,
-                         CCSID_UTF8, ccsid, string, inlen, outlen);
-}
-
-LIBSSH2_API char *
-libssh2_to_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
-                 unsigned short ccsid, const char *string, ssize_t inlen,
-                 size_t *outlen)
-{
-    return convert_ccsid(session, cache,
-                         ccsid, CCSID_UTF8, string, inlen, outlen);
-}
-
-LIBSSH2_API void
-libssh2_release_string_cache(LIBSSH2_SESSION *session,
-                             libssh2_string_cache **cache)
-{
-    libssh2_string_cache *p;
-
-    if (session && cache)
-        while ((p = *cache)) {
-            *cache = p->next;
-            LIBSSH2_FREE(session, (char *) p);
-        }
-}
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/libssh2/os400/include/stdio.h b/libssh2/libssh2/os400/include/stdio.h
deleted file mode 100644
index 7ac9d993..00000000
--- a/libssh2/libssh2/os400/include/stdio.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_STDIO_H
-#define LIBSSH2_STDIO_H
-
-/*
- *  <stdio.h> wrapper.
- *  Its goal is to redefine snprintf/vsnprintf which are not supported by QADRT.
- */
-
-#include <qadrt.h>
-
-#if __ILEC400_TGTVRM__ >= 710
-# include_next <stdio.h>
-#elif __ILEC400_TGTVRM__ >= 510
-# ifndef __SRCSTMF__
-#  include <QADRT/h/stdio>
-# else
-#  include </QIBM/ProdData/qadrt/include/stdio.h>
-# endif
-#endif
-
-extern int  _libssh2_os400_vsnprintf(char *dst, size_t len,
-                                     const char *fmt, va_list args);
-extern int  _libssh2_os400_snprintf(char *dst, size_t len,
-                                    const char *fmt, ...);
-
-#ifndef LIBSSH2_DISABLE_QADRT_EXT
-# define vsnprintf(dst, len, fmt, args)                                     \
-                        _libssh2_os400_vsnprintf((dst), (len), (fmt), (args))
-# define snprintf       _libssh2_os400_snprintf
-#endif
-
-#endif
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/libssh2/os400/include/sys/socket.h b/libssh2/libssh2/os400/include/sys/socket.h
deleted file mode 100644
index 4c771218..00000000
--- a/libssh2/libssh2/os400/include/sys/socket.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_SYS_SOCKET_H
-#define LIBSSH2_SYS_SOCKET_H
-
-/*
- *  <sys/socket.h> wrapper.
- *  Redefines connect().
- */
-
-#include <qadrt.h>
-
-#ifndef _QADRT_LT
-# define _QADRT_LT <
-#endif
-#ifndef _QADRT_GT
-# define _QADRT_GT >
-#endif
-
-#ifdef QADRT_SYSINC
-# include _QADRT_LT QADRT_SYSINC/sys/socket.h _QADRT_GT
-#elif __ILEC400_TGTVRM__ >= 710
-# include_next <sys/socket.h>
-#elif !defined(__SRCSTMF__)
-# include <QSYSINC/sys/socket>
-#else
-# include </QIBM/include/sys/socket.h>
-#endif
-
-extern int  _libssh2_os400_connect(int sd,
-                                   struct sockaddr * destaddr, int addrlen);
-
-#ifndef LIBSSH2_DISABLE_QADRT_EXT
-#define connect(sd, addr, len)  _libssh2_os400_connect((sd), (addr), (len))
-#endif
-
-#endif
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/libssh2/os400/initscript.sh b/libssh2/libssh2/os400/initscript.sh
deleted file mode 100644
index a18e24cf..00000000
--- a/libssh2/libssh2/os400/initscript.sh
+++ /dev/null
@@ -1,243 +0,0 @@
-#!/bin/sh
-
-
-setenv()
-
-{
-        #       Define and export.
-
-        eval ${1}="${2}"
-        export ${1}
-}
-
-
-case "${SCRIPTDIR}" in
-/*)     ;;
-*)      SCRIPTDIR="`pwd`/${SCRIPTDIR}"
-esac
-
-while true
-do      case "${SCRIPTDIR}" in
-        */.)    SCRIPTDIR="${SCRIPTDIR%/.}";;
-        *)      break;;
-        esac
-done
-
-#  The script directory is supposed to be in $TOPDIR/os400.
-
-TOPDIR=`dirname "${SCRIPTDIR}"`
-export SCRIPTDIR TOPDIR
-
-#  Extract the SONAME from the library makefile.
-
-SONAME=`sed -e '/^VERSION=/!d' -e 's/^.* \([0-9]*\):.*$/\1/' -e 'q'     \
-                                                < "${TOPDIR}/src/Makefile.am"`
-export SONAME
-
-
-################################################################################
-#
-#                       Tunable configuration parameters.
-#
-################################################################################
-
-setenv TARGETLIB        'LIBSSH2'               # Target OS/400 program library.
-setenv STATBNDDIR       'LIBSSH2_A'             # Static binding directory.
-setenv DYNBNDDIR        'LIBSSH2'               # Dynamic binding directory.
-setenv SRVPGM           "LIBSSH2.${SONAME}"     # Service program.
-setenv TGTCCSID         '500'                   # Target CCSID of objects.
-setenv DEBUG            '*ALL'                  # Debug level.
-setenv OPTIMIZE         '10'                    # Optimisation level
-setenv OUTPUT           '*NONE'                 # Compilation output option.
-setenv TGTRLS           'V6R1M0'                # Target OS release.
-setenv IFSDIR           '/libssh2'              # Installation IFS directory.
-
-#       Define ZLIB availability and locations.
-
-setenv WITH_ZLIB        0                       # Define to 1 to enable.
-setenv ZLIB_INCLUDE     '/zlib/include'         # ZLIB include IFS directory.
-setenv ZLIB_LIB         'ZLIB'                  # ZLIB library.
-setenv ZLIB_BNDDIR      'ZLIB_A'                # ZLIB binding directory.
-
-
-################################################################################
-
-#       Need to get the version definitions.
-
-LIBSSH2_VERSION=`grep '^#define  *LIBSSH2_VERSION '                     \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/.*"\(.*\)".*/\1/'`
-LIBSSH2_VERSION_MAJOR=`grep '^#define  *LIBSSH2_VERSION_MAJOR '         \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_MAJOR  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_MINOR=`grep '^#define  *LIBSSH2_VERSION_MINOR '         \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_MINOR  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_PATCH=`grep '^#define  *LIBSSH2_VERSION_PATCH '         \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_PATCH  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_NUM=`grep '^#define  *LIBSSH2_VERSION_NUM '             \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_NUM  *0x\([^ ]*\).*/\1/'`
-LIBSSH2_TIMESTAMP=`grep '^#define  *LIBSSH2_TIMESTAMP '                 \
-                        "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/.*"\(.*\)".*/\1/'`
-export LIBSSH2_VERSION
-export LIBSSH2_VERSION_MAJOR LIBSSH2_VERSION_MINOR LIBSSH2_VERSION_PATCH
-export LIBSSH2_VERSION_NUM LIBSSH2_TIMESTAMP
-
-################################################################################
-#
-#                       OS/400 specific definitions.
-#
-################################################################################
-
-LIBIFSNAME="/QSYS.LIB/${TARGETLIB}.LIB"
-
-
-################################################################################
-#
-#                               Procedures.
-#
-################################################################################
-
-#       action_needed dest [src]
-#
-#       dest is an object to build
-#       if specified, src is an object on which dest depends.
-#
-#       exit 0 (succeeds) if some action has to be taken, else 1.
-
-action_needed()
-
-{
-        [ ! -e "${1}" ] && return 0
-        [ "${2}" ] || return 1
-        [ "${1}" -ot "${2}" ] && return 0
-        return 1
-}
-
-
-#       canonicalize_path path
-#
-#       Return canonicalized path as:
-#       - Absolute
-#       - No . or .. component.
-
-canonicalize_path()
-
-{
-        if expr "${1}" : '^/' > /dev/null
-        then    P="${1}"
-        else    P="`pwd`/${1}"
-        fi
-
-        R=
-        IFSSAVE="${IFS}"
-        IFS="/"
-
-        for C in ${P}
-        do      IFS="${IFSSAVE}"
-                case "${C}" in
-                .)      ;;
-                ..)     R=`expr "${R}" : '^\(.*/\)..*'`
-                        ;;
-                ?*)     R="${R}${C}/"
-                        ;;
-                *)      ;;
-                esac
-        done
-
-        IFS="${IFSSAVE}"
-        echo "/`expr "${R}" : '^\(.*\)/'`"
-}
-
-
-#       make_module module_name source_name [additional_definitions]
-#
-#       Compile source name into ASCII module if needed.
-#       As side effect, append the module name to variable MODULES.
-#       Set LINK to "YES" if the module has been compiled.
-
-make_module()
-
-{
-        MODULES="${MODULES} ${1}"
-        MODIFSNAME="${LIBIFSNAME}/${1}.MODULE"
-        action_needed "${MODIFSNAME}" "${2}" || return 0;
-        SRCDIR=`dirname \`canonicalize_path "${2}"\``
-
-        #       #pragma convert has to be in the source file itself, i.e.
-        #               putting it in an include file makes it only active
-        #               for that include file.
-        #       Thus we build a temporary file with the pragma prepended to
-        #               the source file and we compile that temporary file.
-
-        echo "#line 1 \"${2}\"" > __tmpsrcf.c
-        echo "#pragma convert(819)" >> __tmpsrcf.c
-        echo "#line 1" >> __tmpsrcf.c
-        cat "${2}" >> __tmpsrcf.c
-        CMD="CRTCMOD MODULE(${TARGETLIB}/${1}) SRCSTMF('__tmpsrcf.c')"
-#       CMD="${CMD} SYSIFCOPT(*IFS64IO) OPTION(*INCDIRFIRST *SHOWINC *SHOWSYS)"
-        CMD="${CMD} SYSIFCOPT(*IFS64IO) OPTION(*INCDIRFIRST)"
-        CMD="${CMD} LOCALETYPE(*LOCALE) FLAG(10)"
-        CMD="${CMD} INCDIR('${TOPDIR}/os400/include'"
-        CMD="${CMD} '/QIBM/ProdData/qadrt/include' '${TOPDIR}/include'"
-        CMD="${CMD} '${TOPDIR}/os400' '${SRCDIR}'"
-
-        if [ "${WITH_ZLIB}" != "0" ]
-        then    CMD="${CMD} '${ZLIB_INCLUDE}'"
-        fi
-
-        CMD="${CMD} ${INCLUDES})"
-        CMD="${CMD} TGTCCSID(${TGTCCSID}) TGTRLS(${TGTRLS})"
-        CMD="${CMD} OUTPUT(${OUTPUT})"
-        CMD="${CMD} OPTIMIZE(${OPTIMIZE})"
-        CMD="${CMD} DBGVIEW(${DEBUG})"
-
-        DEFINES="${3}"
-
-        if [ "${WITH_ZLIB}" != "0" ]
-        then    DEFINES="${DEFINES} HAVE_LIBZ LIBSSH2_HAVE_ZLIB"
-        fi
-
-        if [ "${DEFINES}" ]
-        then    CMD="${CMD} DEFINE(${DEFINES})"
-        fi
-
-        system "${CMD}"
-        rm -f __tmpsrcf.c
-        LINK=YES
-}
-
-
-#       Determine DB2 object name from IFS name.
-
-db2_name()
-
-{
-        if [ "${2}" = 'nomangle' ]
-        then    basename "${1}"                                         |
-                tr 'a-z-' 'A-Z_'                                        |
-                sed -e 's/\..*//;s/^\(.\).*\(.........\)$/\1\2/'
-        else    basename "${1}"                                         |
-                tr 'a-z-' 'A-Z_'                                        |
-                sed -e 's/\..*//;s/^LIBSSH2_/SSH2_/'                    \
-                    -e 's/^\(.\).*\(.........\)$/\1\2/'                 \
-                    -e 's/^SPUBLICKEY$/SSH2_PKEY/'
-        fi
-}
-
-
-#       Copy stream replacing version info.
-
-versioned_copy()
-
-{
-        sed -e "s/@LIBSSH2_VERSION@/${LIBSSH2_VERSION}/g"               \
-            -e "s/@LIBSSH2_VERSION_MAJOR@/${LIBSSH2_VERSION_MAJOR}/g"   \
-            -e "s/@LIBSSH2_VERSION_MINOR@/${LIBSSH2_VERSION_MINOR}/g"   \
-            -e "s/@LIBSSH2_VERSION_PATCH@/${LIBSSH2_VERSION_PATCH}/g"   \
-            -e "s/@LIBSSH2_VERSION_NUM@/${LIBSSH2_VERSION_NUM}/g"       \
-            -e "s/@LIBSSH2_TIMESTAMP@/${LIBSSH2_TIMESTAMP}/g"
-}
diff --git a/libssh2/libssh2/os400/libssh2_ccsid.h b/libssh2/libssh2/os400/libssh2_ccsid.h
deleted file mode 100644
index 632effa3..00000000
--- a/libssh2/libssh2/os400/libssh2_ccsid.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* CCSID conversion support. */
-
-#ifndef LIBSSH2_CCSID_H_
-#define LIBSSH2_CCSID_H_
-
-#include "libssh2.h"
-
-typedef struct _libssh2_string_cache    libssh2_string_cache;
-
-
-LIBSSH2_API char *
-libssh2_from_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
-                   unsigned short ccsid, const char *string, ssize_t inlen,
-                   size_t *outlen);
-LIBSSH2_API char *
-libssh2_to_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
-                 unsigned short ccsid, const char *string, ssize_t inlen,
-                 size_t *outlen);
-LIBSSH2_API void
-libssh2_release_string_cache(LIBSSH2_SESSION *session,
-                             libssh2_string_cache **cache);
-
-#endif
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/libssh2/os400/libssh2_config.h b/libssh2/libssh2/os400/libssh2_config.h
deleted file mode 100644
index 2e34c4c3..00000000
--- a/libssh2/libssh2/os400/libssh2_config.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_CONFIG_H
-#define LIBSSH2_CONFIG_H
-
-/* Define if building universal (internal helper macro) */
-#undef AC_APPLE_UNIVERSAL_BUILD
-
-/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
-   systems. This function is required for `alloca.c' support on those systems.
-*/
-#undef CRAY_STACKSEG_END
-
-/* Define to 1 if using `alloca.c'. */
-#undef C_ALLOCA
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#define HAVE_ALLOCA 1
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
-#define HAVE_ALLOCA_H 1
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#define HAVE_ARPA_INET_H 1
-
-/* Define to 1 if you have the declaration of `SecureZeroMemory', and to 0 if
-   you don't. */
-#undef HAVE_DECL_SECUREZEROMEMORY
-
-/* disabled non-blocking sockets */
-#undef HAVE_DISABLED_NONBLOCKING
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#define HAVE_ERRNO_H 1
-
-/* Define to 1 if you have the `EVP_aes_128_ctr' function. */
-#undef HAVE_EVP_AES_128_CTR
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
-/* use FIONBIO for non-blocking sockets */
-#undef HAVE_FIONBIO
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#define HAVE_GETTIMEOFDAY 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* use ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET
-
-/* use Ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET_CASE
-
-/* Define if you have the bcrypt library. */
-#undef HAVE_LIBBCRYPT
-
-/* Define if you have the crypt32 library. */
-#undef HAVE_LIBCRYPT32
-
-/* Define if you have the gcrypt library. */
-#undef HAVE_LIBGCRYPT
-
-/* Define if you have the ssl library. */
-#undef HAVE_LIBSSL
-
-/* Define if you have the z library. */
-/* #undef HAVE_LIBZ */
-
-/* Define to 1 if the compiler supports the 'long long' data type. */
-#define HAVE_LONGLONG 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#define HAVE_NETINET_IN_H 1
-
-/* Define to 1 if you have the <ntdef.h> header file. */
-#undef HAVE_NTDEF_H
-
-/* Define to 1 if you have the <ntstatus.h> header file. */
-#undef HAVE_NTSTATUS_H
-
-/* use O_NONBLOCK for non-blocking sockets */
-#define HAVE_O_NONBLOCK 1
-
-/* Define to 1 if you have the `poll' function. */
-#undef HAVE_POLL
-
-/* Define to 1 if you have the select function. */
-#define HAVE_SELECT 1
-
-/* use SO_NONBLOCK for non-blocking sockets */
-#undef HAVE_SO_NONBLOCK
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#define HAVE_STDIO_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the `strtoll' function. */
-#define HAVE_STRTOLL 1
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#define HAVE_SYS_IOCTL_H 1
-
-/* Define to 1 if you have the <sys/select.h> header file. */
-#undef HAVE_SYS_SELECT_H
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#define HAVE_SYS_SOCKET_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#define HAVE_SYS_TIME_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <sys/uio.h> header file. */
-#define HAVE_SYS_UIO_H 1
-
-/* Define to 1 if you have the <sys/un.h> header file. */
-#define HAVE_SYS_UN_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the <windows.h> header file. */
-#undef HAVE_WINDOWS_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to 1 if you have the <ws2tcpip.h> header file. */
-#undef HAVE_WS2TCPIP_H
-
-/* to make a symbol visible */
-#undef LIBSSH2_API
-
-/* Enable clearing of memory before being freed */
-#define LIBSSH2_CLEAR_MEMORY 1
-
-/* Enable "none" cipher -- NOT RECOMMENDED */
-#undef LIBSSH2_CRYPT_NONE
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#define LIBSSH2_DH_GEX_NEW 1
-
-/* Compile in zlib support */
-/* #undef LIBSSH2_HAVE_ZLIB */
-
-/* Use libgcrypt */
-#undef LIBSSH2_LIBGCRYPT
-
-/* Enable "none" MAC -- NOT RECOMMENDED */
-#undef LIBSSH2_MAC_NONE
-
-/* Use OpenSSL */
-#undef LIBSSH2_OPENSSL
-
-/* Use Windows CNG */
-#undef LIBSSH2_WINCNG
-
-/* Use OS/400 Qc3 */
-#define LIBSSH2_OS400QC3
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-*/
-#define LT_OBJDIR ".libs/"
-
-/* Define to 1 if _REENTRANT preprocessor symbol must be defined. */
-#undef NEED_REENTRANT
-
-/* Name of package */
-#define PACKAGE "libssh2"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "libssh2-devel@cool.haxx.se"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "libssh2"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "libssh2 -"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "libssh2"
-
-/* Define to the home page for this package. */
-#define PACKAGE_URL ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "-"
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at runtime.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown */
-#undef STACK_DIRECTION
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Version number of package */
-#define VERSION "-"
-
-/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
-   significant byte first (like Motorola and SPARC, unlike Intel). */
-#define WORDS_BIGENDIAN 1
-
-/* Enable large inode numbers on Mac OS X 10.5.  */
-#ifndef _DARWIN_USE_64_BIT_INODE
-# define _DARWIN_USE_64_BIT_INODE 1
-#endif
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#define inline
-#endif
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
-
-
-#ifndef LIBSSH2_DISABLE_QADRT_EXT
-/* Remap zlib procedures to ASCII versions. */
-#pragma map(inflateInit_, "_libssh2_os400_inflateInit_")
-#pragma map(deflateInit_, "_libssh2_os400_deflateInit_")
-#endif
-
-#endif
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/libssh2/os400/libssh2rpg/libssh2.rpgle.in b/libssh2/libssh2/os400/libssh2rpg/libssh2.rpgle.in
deleted file mode 100644
index 7b7fdd94..00000000
--- a/libssh2/libssh2/os400/libssh2rpg/libssh2.rpgle.in
+++ /dev/null
@@ -1,1704 +0,0 @@
-      * Copyright (c) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
-      * 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 any other contributors may be used to endorse or
-      *   promote products derived from this software without
-      *   specific prior written permission.
-      *
-      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-      * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-      * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-      * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-      * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-      * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-      * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-      * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-      * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-      * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-      * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-      * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-      * OF SUCH DAMAGE.
-
-      /if not defined(LIBSSH2_H_)
-      /define LIBSSH2_H_
-
-     d LIBSSH2_COPYRIGHT...
-     d                 c                   '2004-2015 The libssh2 project and +
-     d                                     its contributors.'
-
-      * We use underscore instead of dash when appending DEV in dev versions
-      * just to make the BANNER define (used by src/session.c) be a valid SSH
-      * banner. Release versions have no appended strings and may of course not
-      * have dashes either.
-     d LIBSSH2_VERSION...
-     d                 c                   '@LIBSSH2_VERSION@'
-
-      * The numeric version number is also available "in parts" by using these
-      * defines:
-     d LIBSSH2_VERSION_MAJOR...
-     d                 c                   @LIBSSH2_VERSION_MAJOR@
-     d LIBSSH2_VERSION_MINOR...
-     d                 c                   @LIBSSH2_VERSION_MINOR@
-     d LIBSSH2_VERSION_PATCH...
-     d                 c                   @LIBSSH2_VERSION_PATCH@
-
-      * This is the numeric version of the libssh2 version number, meant for
-      * easier parsing and comparions by programs. The LIBSSH2_VERSION_NUM
-      * define will always follow this syntax:
-      *
-      *  X'XXYYZZ'
-      *
-      * Where XX, YY and ZZ are the main version, release and patch numbers in
-      * hexadecimal (using 8 bits each). All three numbers are always
-      * represented using two digits.  1.2 would appear as "0x010200" while
-      * version 9.11.7 appears as X'090b07'.
-      *
-      * This 6-digit (24 bits) hexadecimal number does not show pre-release
-      * number, and it is always a greater number in a more recent release. It
-      * makes comparisons with greater than and less than work.
-
-     d LIBSSH2_VERSION_NUM...
-     d                 c                   X'@LIBSSH2_VERSION_NUM@'
-
-      * This is the date and time when the full source package was created. The
-      * timestamp is not stored in the source code repo, as the timestamp is
-      * properly set in the tarballs by the maketgz script.
-      *
-      * The format of the date should follow this template:
-      *
-      * "Mon Feb 12 11:35:33 UTC 2007"
-
-     d LIBSSH2_TIMESTAMP...
-     d                 c                   '@LIBSSH2_TIMESTAMP@'
-
-     d libssh2_Cchar   s              3i 0 based(######typedef######)
-     d libssh2_Cuchar  s              3u 0 based(######typedef######)
-     d libssh2_Cshort  s              5i 0 based(######typedef######)
-     d libssh2_Cushort...
-     d                 s              5u 0 based(######typedef######)
-     d libssh2_Cint    s             10i 0 based(######typedef######)
-     d libssh2_CuInt   s             10u 0 based(######typedef######)
-     d libssh2_Clong   s             10i 0 based(######typedef######)
-     d libssh2_Culong  s             10u 0 based(######typedef######)
-     d libssh2_Clonglong...
-     d                 s             20i 0 based(######typedef######)
-     d libssh2_Culonglong...
-     d                 s             20u 0 based(######typedef######)
-     d libssh2_Cenum   s             10i 0 based(######typedef######)
-     d libssh2_Cssize_t...
-     d                 s             10i 0 based(######typedef######)
-     d libssh2_Csize_t...
-     d                 s             10u 0 based(######typedef######)
-     d libssh2_Cfloat  s              4f   based(######typedef######)
-     d libssh2_Cdouble...
-     d                 s              8f   based(######typedef######)
-
-     d libssh2_uint8_t...
-     d                 s              3u 0 based(######typedef######)
-     d libssh2_uint32_t...
-     d                 s             10u 0 based(######typedef######)
-     d libssh2_uint64_t...
-     d                 s             20u 0 based(######typedef######)
-     d libssh2_int64_t...
-     d                 s             20i 0 based(######typedef######)
-
-     d libssh2_socket_t...
-     d                 s             10i 0 based(######typedef######)
-     d LIBSSH2_INVALID_SOCKET...
-     d                 c                   -1
-
-     d libssh2_mode_t  s             10u 0 based(######typedef######)
-     d libssh2_ino_t   s             10u 0 based(######typedef######)
-     d libssh2_uid_t   s             10u 0 based(######typedef######)
-     d libssh2_gid_t   s             10u 0 based(######typedef######)
-     d libssh2_dev_t   s             10u 0 based(######typedef######)
-     d libssh2_off_t   s             20i 0 based(######typedef######)           Use *IFS64IO
-     d libssh2_time_t  s             10i 0 based(######typedef######)
-     d libssh2_nlink_t...
-     d                 s              5u 0 based(######typedef######)
-     d libssh2_qp0l_objtype_t...                                                AS400 object type
-     d                 s             11
-
-     d libssh2_struct_stat_size...
-     d                 s                   based(######typedef######)
-     d                                     like(libssh2_off_t)
-
-     d libssh2_struct_stat...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  st_mode                            like(libssh2_mode_t)                 Mode flags
-     d  st_ino                             like(libssh2_ino_t)                  File serial number
-     d  st_nlink                           like(libssh2_nlink_t)                Number of links
-     d  st_uid                             like(libssh2_uid_t)                  Owner ID
-     d  st_gid                             like(libssh2_gid_t)                  Group ID
-     d  st_size                            like(libssh2_off_t)                  File size
-     d  st_atime                           like(libssh2_time_t)                 Last access time
-     d  st_mtime                           like(libssh2_time_t)                 Last update time
-     d  st_ctime                           like(libssh2_time_t)                 Creation time
-     d  st_dev                             like(libssh2_dev_t)                  File root device
-     d  st_blksize                         like(libssh2_Csize_t)                Block size
-     d  st_allocsize                       like(libssh2_Culong)                 Allocation size
-     d  st_objtype                         like(libssh2_qp0l_objtype_t)         AS400 object type
-     d  st_codepage                        like(libssh2_Cushort)                Object data codepage
-     d                               62                                         Reserved
-     d  st_ino_gen_id                      like(libssh2_Cuint)                  File SN gen. ID
-
-     d LIBSSH2_STRUCT_STAT_SIZE_FORMAT...
-     d                 c                   '%lld'
-
-      * Part of every banner, user specified or not.
-     d LIBSSH2_SSH_BANNER...
-     d                 c                   'SSH-2.0-libssh2_1.6.1_DEV'
-     d LIBSSH2_SSH_DEFAULT_BANNER...
-     d                 c                   'SSH-2.0-libssh2_1.6.1_DEV'
-
-      * Default generate and safe prime sizes for
-      * diffie-hellman-group-exchange-sha1.
-     d LIBSSH2_DH_GEX_MINGROUP...
-     d                 c                   1024
-     d LIBSSH2_DH_GEX_OPTGROUP...
-     d                 c                   1536
-     d LIBSSH2_DH_GEX_MAXGROUP...
-     d                 c                   2048
-
-      * Defaults for pty requests.
-     d LIBSSH2_TERM_WIDTH...
-     d                 c                   80
-     d LIBSSH2_TERM_HEIGHT...
-     d                 c                   24
-     d LIBSSH2_TERM_WIDTH_PX...
-     d                 c                   0
-     d LIBSSH2_TERM_HEIGHT_PX...
-     d                 c                   0
-
-      * 1/4 second.
-     d LIBSSH2_SOCKET_POLL_UDELAY...
-     d                 c                   250000
-      * 0.25 * 120 == 30 seconds.
-     d LIBSSH2_SOCKET_POLL_MAXLOOPS...
-     d                 c                   120
-
-      * Maximum size to allow a payload to compress to, plays it safe by
-      * falling short of spec limits.
-     d LIBSSH2_PACKET_MAXCOMP...
-     d                 c                   32000
-
-      * Maximum size to allow a payload to deccompress to, plays it safe by
-      * allowing more than spec requires.
-     d LIBSSH2_PACKET_MAXDECOMP...
-     d                 c                   40000
-
-      * Maximum size for an inbound compressed payload, plays it safe by
-      * overshooting spec limits.
-     d LIBSSH2_PACKET_MAXPAYLOAD...
-     d                 c                   40000
-
-     d LIBSSH2_USERAUTH_KBDINT_PROMPT...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  text                           *                                        char *
-     d  length                             like(libssh2_Cuint)
-     d  echo                               like(libssh2_Cuchar)
-
-     d LIBSSH2_USERAUTH_KBDINT_RESPONSE...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  text                           *                                        char *
-     d  length                             like(libssh2_Cuint)
-
-      * libssh2_session_callback_set() constants.
-     d LIBSSH2_CALLBACK_IGNORE...
-     d                 c                   0
-     d LIBSSH2_CALLBACK_DEBUG...
-     d                 c                   1
-     d LIBSSH2_CALLBACK_DISCONNECT...
-     d                 c                   2
-     d LIBSSH2_CALLBACK_MACERROR...
-     d                 c                   3
-     d LIBSSH2_CALLBACK_X11...
-     d                 c                   4
-     d LIBSSH2_CALLBACK_SEND...
-     d                 c                   5
-     d LIBSSH2_CALLBACK_RECV...
-     d                 c                   6
-
-      * libssh2_session_method_pref() constants.
-     d LIBSSH2_METHOD_KEX...
-     d                 c                   0
-     d LIBSSH2_METHOD_HOSTKEY...
-     d                 c                   1
-     d LIBSSH2_METHOD_CRYPT_CS...
-     d                 c                   2
-     d LIBSSH2_METHOD_CRYPT_SC...
-     d                 c                   3
-     d LIBSSH2_METHOD_MAC_CS...
-     d                 c                   4
-     d LIBSSH2_METHOD_MAC_SC...
-     d                 c                   5
-     d LIBSSH2_METHOD_COMP_CS...
-     d                 c                   6
-     d LIBSSH2_METHOD_COMP_SC...
-     d                 c                   7
-     d LIBSSH2_METHOD_LANG_CS...
-     d                 c                   8
-     d LIBSSH2_METHOD_LANG_SC...
-     d                 c                   9
-
-      * flags.
-     d LIBSSH2_FLAG_SIGPIPE...
-     d                 c                   X'0001'
-     d LIBSSH2_FLAG_COMPRESS...
-     d                 c                   X'0002'
-
-     d LIBSSH2_POLLFD  ds                  based(######typedef######)
-     d                                     align qualified
-     d  type                               like(libssh2_Cuchar)
-     d  fd                             *                                        Union
-     d   socket                            overlay(fd) like(libssh2_socket_t)
-     d   channel                       *   overlay(fd)                          LIBSSH2_CHANNEL *
-     d   listener                      *   overlay(fd)                          LIBSSH2_LISTENER *
-     d  events                             like(libssh2_Culong)
-     d  revents                            like(libssh2_Culong)
-
-      * Poll FD Descriptor Types.
-     d LIBSSH2_POLLFD_SOCKET...
-     d                 c                   1
-     d LIBSSH2_POLLFD_CHANNEL...
-     d                 c                   2
-     d LIBSSH2_POLLFD_LISTENER...
-     d                 c                   3
-
-      * Poll FD events/revents -- Match sys/poll.h where possible.
-     d LIBSSH2_POLLFD_POLLIN...                                                 Input data ready or
-     d                 c                   X'0001'                              connection available
-     d LIBSSH2_POLLFD_POLLPRI...                                                Prio data ready to
-     d                 c                   X'0002'                              be read. Socket only
-     d LIBSSH2_POLLFD_POLLEXT...                                                Ext data ready to be
-     d                 c                   X'0002'                              read. Channel only
-     d LIBSSH2_POLLFD_POLLOUT...                                                Can may be written:
-     d                 c                   X'0004'                              Socket/Channel
-
-      * revents only.
-     d LIBSSH2_POLLFD_POLLERR...                                                Error Condition:
-     d                 c                   X'0008'                              Socket
-     d LIBSSH2_POLLFD_POLLHUP...                                                HangUp/EOF
-     d                 c                   X'0010'                              Socket
-     d LIBSSH2_POLLFD_SESSION_CLOSED...                                         Session Disconnect
-     d                 c                   X'0010'
-     d LIBSSH2_POLLFD_POLLNVAL...                                               Invalid request
-     d                 c                   X'0020'                              Socket
-     d LIBSSH2_POLLFD_POLLEX...                                                 Exception Condition
-     d                 c                   X'0040'                              Socket/Win32
-     d LIBSSH2_POLLFD_CHANNEL_CLOSED...                                         Channel Disconnect
-     d                 c                   X'0080'
-     d LIBSSH2_POLLFD_LISTENER_CLOSED...                                        Listener Disconnect
-     d                 c                   X'0080'
-
-      /define HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
-      * Block Direction Types.
-     d LIBSSH2_SESSION_BLOCK_INBOUND...
-     d                 c                   X'0001'
-     d LIBSSH2_SESSION_BLOCK_OUTBOUND...
-     d                 c                   X'0002'
-
-      * Hash Types.
-     d LIBSSH2_HOSTKEY_HASH_MD5...
-     d                 c                   1
-     d LIBSSH2_HOSTKEY_HASH_SHA1...
-     d                 c                   2
-
-      * Hostkey Types.
-     d LIBSSH2_HOSTKEY_TYPE_UNKNOWN...
-     d                 c                   0
-     d LIBSSH2_HOSTKEY_TYPE_RSA...
-     d                 c                   1
-     d LIBSSH2_HOSTKEY_TYPE_DSS...
-     d                 c                   2
-
-      * Disconnect Codes (defined by SSH protocol).
-     d SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT...
-     d                 c                   1
-     d SSH_DISCONNECT_PROTOCOL_ERROR...
-     d                 c                   2
-     d SSH_DISCONNECT_KEY_EXCHANGE_FAILED...
-     d                 c                   3
-     d SSH_DISCONNECT_RESERVED...
-     d                 c                   4
-     d SSH_DISCONNECT_MAC_ERROR...
-     d                 c                   5
-     d SSH_DISCONNECT_COMPRESSION_ERROR...
-     d                 c                   6
-     d SSH_DISCONNECT_SERVICE_NOT_AVAILABLE...
-     d                 c                   7
-     d SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED...
-     d                 c                   8
-     d SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE...
-     d                 c                   9
-     d SSH_DISCONNECT_CONNECTION_LOST...
-     d                 c                   10
-     d SSH_DISCONNECT_BY_APPLICATION...
-     d                 c                   11
-     d SSH_DISCONNECT_TOO_MANY_CONNECTIONS...
-     d                 c                   12
-     d SSH_DISCONNECT_AUTH_CANCELLED_BY_USER...
-     d                 c                   13
-     d SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE...
-     d                 c                   14
-     d SSH_DISCONNECT_ILLEGAL_USER_NAME...
-     d                 c                   15
-
-      * Error Codes (defined by libssh2).
-     d LIBSSH2_ERROR_NONE...
-     d                 c                   0
-
-      * The library once used -1 as a generic error return value on numerous
-      * places through the code, which subsequently was converted to
-      * LIBSSH2_ERROR_SOCKET_NONE uses over time. As this is a generic error
-      * code, the goal is to never ever return this code but instead make sure
-      * that a more accurate and descriptive error code is used.
-     d  LIBSSH2_ERROR_SOCKET_NONE...
-     d                 c                   -1
-
-     d LIBSSH2_ERROR_BANNER_RECV...
-     d                 c                   -2
-     d LIBSSH2_ERROR_BANNER_SEND...
-     d                 c                   -3
-     d LIBSSH2_ERROR_INVALID_MAC...
-     d                 c                   -4
-     d LIBSSH2_ERROR_KEX_FAILURE...
-     d                 c                   -5
-     d LIBSSH2_ERROR_ALLOC...
-     d                 c                   -6
-     d LIBSSH2_ERROR_SOCKET_SEND...
-     d                 c                   -7
-     d LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE...
-     d                 c                   -8
-     d LIBSSH2_ERROR_TIMEOUT...
-     d                 c                   -9
-     d LIBSSH2_ERROR_HOSTKEY_INIT...
-     d                 c                   -10
-     d LIBSSH2_ERROR_HOSTKEY_SIGN...
-     d                 c                   -11
-     d LIBSSH2_ERROR_DECRYPT...
-     d                 c                   -12
-     d LIBSSH2_ERROR_SOCKET_DISCONNECT...
-     d                 c                   -13
-     d LIBSSH2_ERROR_PROTO...
-     d                 c                   -14
-     d LIBSSH2_ERROR_PASSWORD_EXPIRED...
-     d                 c                   -15
-     d LIBSSH2_ERROR_FILE...
-     d                 c                   -16
-     d LIBSSH2_ERROR_METHOD_NONE...
-     d                 c                   -17
-     d LIBSSH2_ERROR_AUTHENTICATION_FAILED...
-     d                 c                   -18
-     d LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED...
-     d                 c                   -18
-     d LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED...
-     d                 c                   -19
-     d LIBSSH2_ERROR_CHANNEL_OUTOFORDER...
-     d                 c                   -20
-     d LIBSSH2_ERROR_CHANNEL_FAILURE...
-     d                 c                   -21
-     d LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED...
-     d                 c                   -22
-     d LIBSSH2_ERROR_CHANNEL_UNKNOWN...
-     d                 c                   -23
-     d LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED...
-     d                 c                   -24
-     d LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED...
-     d                 c                   -25
-     d LIBSSH2_ERROR_CHANNEL_CLOSED...
-     d                 c                   -26
-     d LIBSSH2_ERROR_CHANNEL_EOF_SENT...
-     d                 c                   -27
-     d LIBSSH2_ERROR_SCP_PROTOCOL...
-     d                 c                   -28
-     d LIBSSH2_ERROR_ZLIB...
-     d                 c                   -29
-     d LIBSSH2_ERROR_SOCKET_TIMEOUT...
-     d                 c                   -30
-     d LIBSSH2_ERROR_SFTP_PROTOCOL...
-     d                 c                   -31
-     d LIBSSH2_ERROR_REQUEST_DENIED...
-     d                 c                   -32
-     d LIBSSH2_ERROR_METHOD_NOT_SUPPORTED...
-     d                 c                   -33
-     d LIBSSH2_ERROR_INVAL...
-     d                 c                   -34
-     d LIBSSH2_ERROR_INVALID_POLL_TYPE...
-     d                 c                   -35
-     d LIBSSH2_ERROR_PUBLICKEY_PROTOCOL...
-     d                 c                   -36
-     d LIBSSH2_ERROR_EAGAIN...
-     d                 c                   -37
-     d LIBSSH2_ERROR_BUFFER_TOO_SMALL...
-     d                 c                   -38
-     d LIBSSH2_ERROR_BAD_USE...
-     d                 c                   -39
-     d LIBSSH2_ERROR_COMPRESS...
-     d                 c                   -40
-     d LIBSSH2_ERROR_OUT_OF_BOUNDARY...
-     d                 c                   -41
-     d LIBSSH2_ERROR_AGENT_PROTOCOL...
-     d                 c                   -42
-     d LIBSSH2_ERROR_SOCKET_RECV...
-     d                 c                   -43
-     d LIBSSH2_ERROR_ENCRYPT...
-     d                 c                   -44
-     d LIBSSH2_ERROR_BAD_SOCKET...
-     d                 c                   -45
-     d LIBSSH2_ERROR_KNOWN_HOSTS...
-     d                 c                   -46
-
-      * this is a define to provide the old (<= 1.2.7) name.
-     d LIBSSH2_ERROR_BANNER_NONE...
-     d                 c                   -2
-
-      * Global API.
-     d LIBSSH2_INIT_NO_CRYPTO...
-     d                 c                   X'0001'
-
-      * libssh2_init()
-      *
-      * Initialize the libssh2 functions.  This typically initialize the
-      * crypto library.  It uses a global state, and is not thread safe --
-      * you must make sure this function is not called concurrently.
-      *
-      * Flags can be:
-      * 0:                              Normal initialize
-      * LIBSSH2_INIT_NO_CRYPTO:         Do not initialize the crypto library
-      *                                 (ie. OPENSSL_add_cipher_algorithms() for
-      *                                 OpenSSL)
-      *
-      * Returns 0 if succeeded, or a negative value for error.
-
-     d libssh2_init    pr                  extproc('libssh2_init')
-     d                                     like(libssh2_Cint)
-     d  flags                              value like(libssh2_Cint)
-
-      * libssh2_exit()
-      *
-      * Exit the libssh2 functions and free's all memory used internal.
-
-     d libssh2_exit    pr                  extproc('libssh2_exit')
-
-      * libssh2_free()
-      *
-      * Deallocate memory allocated by earlier call to libssh2 functions.
-
-     d libssh2_free    pr                  extproc('libssh2_free')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  ptr                            *   value                                void *
-
-      * libssh2_session_supported_algs()
-      *
-      * Fills algs with a list of supported cryptographic algorithms. Returns a
-      * non-negative number (number of supported algorithms) on success or a
-      * negative number (an eror code) on failure.
-      *
-      * NOTE: on success, algs must be deallocated (by calling libssh2_free)
-      * when not needed anymore
-
-     d libssh2_session_supported_algs...
-     d                 pr                  extproc(
-     d                                       'libssh2_session_supported_algs')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  method_type                        value like(libssh2_Cint)
-     d  algs                           *                                        const char **(*)
-
-      * Session API.
-     d libssh2_session_init_ex...
-     d                 pr              *   extproc('libssh2_session_init_ex')   LIBSSH2_SESSION *
-     d  my_alloc                       *   value procptr
-     d  my_free                        *   value procptr
-     d  my_realloc                     *   value procptr
-     d  abstract                       *   value                                void *
-
-      * Implementation of C macro.
-     d libssh2_session_init...
-     d                 pr              *   extproc('libssh2_session_init')      LIBSSH2_SESSION *
-
-     d libssh2_session_abstract...
-     d                 pr              *   extproc('libssh2_session_abstract')  void * *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_session_callback_set...
-     d                 pr              *   extproc(                             void *
-     d                                     'libssh2_session_callback_set')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  cbtype                             value like(libssh2_Cint)
-     d  callback                       *   value                                void *
-
-     d libssh2_session_banner_set...
-     d                 pr                  extproc('libssh2_session_banner_set')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  banner                         *   value options(*string)               const char *
-
-     d libssh2_banner_set...
-     d                 pr                  extproc('libssh2_banner_set')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  banner                         *   value options(*string)               const char *
-
-     d libssh2_session_startup...
-     d                 pr                  extproc('libssh2_session_startup')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  sock                               value like(libssh2_Cint)
-
-     d libssh2_session_handshake...
-     d                 pr                  extproc('libssh2_session_handshake')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  sock                               value like(libssh2_socket_t)
-
-     d libssh2_session_disconnect_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_disconnect_ex')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  reason                             value like(libssh2_Cint)
-     d  description                    *   value options(*string)               const char *
-     d  lang                           *   value options(*string)               const char *
-
-      * Implementation of C macro.
-     d libssh2_session_disconnect...
-     d                 pr                  extproc('libssh2_session_disconnect')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  description                    *   value options(*string)               const char *
-
-     d libssh2_session_free...
-     d                 pr                  extproc('libssh2_session_free')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_hostkey_hash...
-     d                 pr              *   extproc('libssh2_hostkey_hash')      const char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  hash_type                          value like(libssh2_Cint)
-
-     d libssh2_session_hostkey...
-     d                 pr              *   extproc('libssh2_session_hostkey')   const char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  len                                like(libssh2_Csize_t)
-     d  type                               like(libssh2_Cint)
-
-     d libssh2_session_method_pref...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_method_pref')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  method_type                        value like(libssh2_Cint)
-     d  prefs                          *   value options(*string)               const char *
-
-     d libssh2_session_methods...
-     d                 pr              *   extproc('libssh2_session_methods')   const char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  method_type                        value like(libssh2_Cint)
-
-     d libssh2_session_last_error...
-     d                 pr                  extproc('libssh2_session_last_error')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  errmsg                         *                                        char *(*)
-     d  errmsg_len                         like(libssh2_Cint)
-     d  want_buf                           value like(libssh2_Cint)
-
-     d libssh2_session_last_errno...
-     d                 pr                  extproc('libssh2_session_last_errno')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_session_set_last_error...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_set_last_error')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  errcode                            value like(libssh2_Cint)
-     d  errmsg                         *   value options(*string)               const char *
-
-     d libssh2_session_block_directions...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_block_directions')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_session_flag...
-     d                 pr                  extproc('libssh2_session_flag')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  flag                               value like(libssh2_Cint)
-     d  value                              value like(libssh2_Cint)
-
-     d libssh2_session_banner_get...
-     d                 pr              *   extproc('libssh2_session_banner_get') const char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-      * Userauth API.
-
-     d libssh2_userauth_list...
-     d                 pr              *   extproc('libssh2_userauth_list')     char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Cuint)
-
-     d libssh2_userauth_authenticated...
-     d                 pr                  extproc(
-     d                                     'libssh2_userauth_authenticated')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_userauth_password_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_userauth_password_ex')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Cuint)
-     d  password                       *   value options(*string)               const char *
-     d  password_len                       value like(libssh2_Cuint)
-     d  passwd_change_cb...
-     d                                 *   value procptr
-
-      * Implementation of C macro.
-     d libssh2_userauth_password...
-     d                 pr                  extproc('libssh2_userauth_password')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  password                       *   value options(*string)               const char *
-
-     d libssh2_userauth_publickey_fromfile_ex...
-     d                 pr                  extproc('libssh2_userauth_publickey_-
-     d                                     fromfile_ex')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Cuint)
-     d  publickey                      *   value options(*string)               const char *
-     d  privatekey                     *   value options(*string)               const char *
-     d  passphrase                     *   value options(*string)               const char *
-
-      * Implementation of C macro.
-     d libssh2_userauth_publickey_fromfile...
-     d                 pr                  extproc(
-     d                                     'libssh2_userauth_publickey_fromfile'
-     d                                     )
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  publickey                      *   value options(*string)               const char *
-     d  privatekey                     *   value options(*string)               const char *
-     d  passphrase                     *   value options(*string)               const char *
-
-     d libssh2_userauth_publickey...
-     d                 pr                  extproc('libssh2_userauth_publickey')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  pubkeydata                     *   value options(*string)               const unsigned char*
-     d  pubkeydata_len...
-     d                                     value like(libssh2_Csize_t)
-     d  sign_callback                  *   value procptr
-     d  abstract                       *                                        void *(*)
-
-     d libssh2_userauth_hostbased_fromfile_ex...
-     d                 pr                  extproc('libssh2_userauth_hostbased_-
-     d                                     fromfile_ex')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Cuint)
-     d  publickey                      *   value options(*string)               const char *
-     d  privatekey                     *   value options(*string)               const char *
-     d  passphrase                     *   value options(*string)               const char *
-     d  hostname                       *   value options(*string)               const char *
-     d  hostname_len                       value like(libssh2_Cuint)
-     d  local_username...
-     d                                 *   value options(*string)               const char *
-     d  local_username_len...
-     d                                     value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_userauth_hostbased_fromfile...
-     d                 pr                  extproc(
-     d                                     'libssh2_userauth_hostbased_fromfile'
-     d                                     )
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  publickey                      *   value options(*string)               const char *
-     d  privatekey                     *   value options(*string)               const char *
-     d  passphrase                     *   value options(*string)               const char *
-     d  hostname                       *   value options(*string)               const char *
-
-     d libssh2_userauth_publickey_frommemory...
-     d                 pr                  extproc('libssh2_userauth_publickey_-
-     d                                     frommemory')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Csize_t)
-     d  publickeyfiledata...
-     d                                 *   value options(*string)               const char *
-     d  publickeyfiledata_len...
-     d                                     value like(libssh2_Csize_t)
-     d  privatekeyfiledata...
-     d                                 *   value options(*string)               const char *
-     d  privatekeyfiledata_len...
-     d                                     value like(libssh2_Csize_t)
-     d  passphrase                     *   value options(*string)               const char *
-
-      * response_callback is provided with filled by library prompts array,
-      * but client must allocate and fill individual responses. Responses
-      * array is already allocated. Responses data will be freed by libssh2
-      * after callback return, but before subsequent callback invokation.
-
-     d libssh2_userauth_keyboard_interactive_ex...
-     d                 pr                  extproc('libssh2_userauth_keyboard_i-
-     d                                     nteractive_ex')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  username_len                       value like(libssh2_Cuint)
-     d  response_callback...
-     d                                 *   value procptr
-
-      * C macro implementation.
-     d libssh2_userauth_keyboard_interactive...
-     d                 pr                  extproc('libssh2_userauth_keyboard_i-
-     d                                     nteractive')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  username                       *   value options(*string)               const char *
-     d  response_callback...
-     d                                 *   value procptr
-
-     d libssh2_poll    pr                  extproc('libssh2_poll')
-     d                                     like(libssh2_Cint)
-     d  fds                            *   value                                LIBSSH2_POLLFD *
-     d  nfds                               value like(libssh2_Cuint)
-     d  timeout                            value like(libssh2_Clong)
-
-      * Channel API.
-     d LIBSSH2_CHANNEL_WINDOW_DEFAULT...
-     d                 c                   X'00200000'
-     d LIBSSH2_CHANNEL_PACKET_DEFAULT...
-     d                 c                   32768
-     d LIBSSH2_CHANNEL_MINADJUST...
-     d                 c                   1024
-
-      * Extended Data Handling.
-     d LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL...
-     d                 c                   0
-     d LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE...
-     d                 c                   1
-     d LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE...
-     d                 c                   2
-
-     d SSH_EXTENDED_DATA_STDERR...
-     d                 c                   1
-
-      * Returned by any function that would block during a read/write
-      * operation.
-     d LIBSSH2CHANNEL_EAGAIN...                                                 LIBSSH2_ERROR_EAGAIN
-     d                 c                   -37
-
-     d libssh2_channel_open_ex...
-     d                 pr              *   extproc('libssh2_channel_open_ex')   LIBSSH2_CHANNEL *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  channel_type                   *   value options(*string)               const char *
-     d  channel_type_len...
-     d                                     value like(libssh2_Cuint)
-     d  window_size                        value like(libssh2_Cuint)
-     d  packet_size                        value like(libssh2_Cuint)
-     d  message                        *   value options(*string)               const char *
-     d  message_len                        value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_channel_open_session...
-     d                 pr              *   extproc(                             LIBSSH2_CHANNEL *
-     d                                     'libssh2_channel_open_session')
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_channel_direct_tcpip_ex...
-     d                 pr              *   extproc(                             LIBSSH2_CHANNEL *
-     d                                     'libssh2_channel_direct_tcpip_ex')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  host                           *   value options(*string)               const char *
-     d  port                               value like(libssh2_Cint)
-     d  shost                          *   value options(*string)               const char *
-     d  sport                              value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_direct_tcpip...
-     d                 pr              *   extproc(                             LIBSSH2_CHANNEL *
-     d                                     'libssh2_channel_direct_tcpip')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  host                           *   value options(*string)               const char *
-     d  port                               value like(libssh2_Cint)
-
-     d libssh2_channel_forward_listen_ex...
-     d                 pr              *   extproc(                             LIBSSH2_LISTENER *
-     d                                     'libssh2_channel_forward_listen_ex')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  host                           *   value options(*string)               const char *
-     d  port                               value like(libssh2_Cint)
-     d  bound_port                         like(libssh2_Cint)
-     d  queue_maxsize                      value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_forward_listen...
-     d                 pr              *   extproc(                             LIBSSH2_LISTENER *
-     d                                     'libssh2_channel_forward_listen')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  port                               value like(libssh2_Cint)
-
-     d libssh2_channel_forward_cancel...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_forward_cancel')
-     d                                     like(libssh2_Cint)
-     d  listener                       *   value                                LIBSSH2_LISTENER *
-
-     d libssh2_channel_forward_accept...
-     d                 pr              *   extproc(                             LIBSSH2_CHANNEL *
-     d                                     'libssh2_channel_forward_accept')
-     d  listener                       *   value                                LIBSSH2_LISTENER *
-
-     d libssh2_channel_setenv_ex...
-     d                 pr                  extproc('libssh2_channel_setenv_ex')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  varname                        *   value options(*string)               const char *
-     d  varname_len                        value like(libssh2_Cuint)
-     d  value                          *   value options(*string)               const char *
-     d  value_len                          value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_channel_setenv...
-     d                 pr                  extproc('libssh2_channel_setenv')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  varname                        *   value options(*string)               const char *
-     d  value                          *   value options(*string)               const char *
-
-     d libssh2_channel_request_pty_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_request_pty_ex')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  term                           *   value options(*string)               const char *
-     d  term_len                           value like(libssh2_Cuint)
-     d  modes                          *   value options(*string)               const char *
-     d  modes_len                          value like(libssh2_Cuint)
-     d  width                              value like(libssh2_Cint)
-     d  height                             value like(libssh2_Cint)
-     d  width_px                           value like(libssh2_Cint)
-     d  height_px                          value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_request_pty...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_request_pty')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  term                           *   value options(*string)               const char *
-
-     d libssh2_channel_request_pty_size_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_request_pty_size_ex'
-     d                                     )
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  width                              value like(libssh2_Cint)
-     d  height                             value like(libssh2_Cint)
-     d  width_px                           value like(libssh2_Cint)
-     d  height_px                          value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_request_pty_size...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_request_pty_size')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  width                              value like(libssh2_Cint)
-     d  height                             value like(libssh2_Cint)
-
-     d libssh2_channel_x11_req_ex...
-     d                 pr                  extproc('libssh2_channel_x11_req_ex')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  single_connection...
-     d                                     value like(libssh2_Cint)
-     d  auth_proto                     *   value options(*string)               const char *
-     d  auth_cookie                    *   value options(*string)               const char *
-     d  screen_number                      value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_x11_req...
-     d                 pr                  extproc('libssh2_channel_x11_req')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  screen_number                      value like(libssh2_Cint)
-
-     d libssh2_channel_process_startup...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_process_startup')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  request                        *   value options(*string)               const char *
-     d  request_len                        value like(libssh2_Cuint)
-     d  message                        *   value options(*string)               const char *
-     d  message_len                        value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_channel_shell...
-     d                 pr                  extproc('libssh2_channel_shell')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-      * C macro implementation.
-     d libssh2_channel_exec...
-     d                 pr                  extproc('libssh2_channel_exec')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  command                        *   value options(*string)               const char *
-
-      * C macro implementation.
-     d libssh2_channel_subsystem...
-     d                 pr                  extproc('libssh2_channel_subsystem')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  subsystem                      *   value options(*string)               const char *
-
-     d libssh2_channel_read_ex...
-     d                 pr                  extproc('libssh2_channel_read_ex')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  stream_id                          value like(libssh2_Cint)
-     d  buf                            *   value                                char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-      * C macro implementation.
-     d libssh2_channel_read...
-     d                 pr                  extproc('libssh2_channel_read')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  buf                            *   value                                char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-      * C macro implementation.
-     d libssh2_channel_read_stderr...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_read_stderr')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  buf                            *   value                                char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-     d libssh2_poll_channel_read...
-     d                 pr                  extproc('libssh2_poll_channel_read')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  extended                           value like(libssh2_Cint)
-
-     d libssh2_channel_window_read_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_window_read_ex')
-     d                                     like(libssh2_Culong)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  read_avail                         like(libssh2_Culong)
-     d  window_size_initial...
-     d                                     like(libssh2_Culong)
-
-      * C macro implementation.
-     d libssh2_channel_window_read...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_window_read')
-     d                                     like(libssh2_Culong)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_receive_window_adjust2...
-     d                 pr                  extproc('libssh2_channel_receive_win-
-     d                                     dow_adjust2')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  adjustment                         value like(libssh2_Culong)
-     d  force                              value like(libssh2_Cuchar)
-     d  storewindow                        like(libssh2_Cuint)
-
-     d libssh2_channel_write_ex...
-     d                 pr                  extproc('libssh2_channel_write_ex')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  stream_id                          value like(libssh2_Cint)
-     d  buf                            *   value options(*string)               const char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-      * C macro implementation.
-     d libssh2_channel_write...
-     d                 pr                  extproc('libssh2_channel_write')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  buf                            *   value options(*string)               const char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-      * C macro implementation.
-     d libssh2_channel_write_stderr...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_write_stderr')
-     d                                     like(libssh2_Cssize_t)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  buf                            *   value options(*string)               const char *
-     d  buflen                             value like(libssh2_Csize_t)
-
-     d libssh2_channel_window_write_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_window_write_ex')
-     d                                     like(libssh2_Culong)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  window_size_initial...
-     d                                     like(libssh2_Culong)
-
-      * C macro implementation.
-     d libssh2_channel_window_write...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_window_write')
-     d                                     like(libssh2_Culong)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_session_set_blocking...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_set_blocking')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  blocking                           value like(libssh2_Cint)
-
-     d libssh2_session_get_blocking...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_get_blocking')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_channel_set_blocking...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_set_blocking')
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  blocking                           value like(libssh2_Cint)
-
-     d libssh2_session_set_timeout...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_set_timeout')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  timeout                            value like(libssh2_Clong)
-
-     d libssh2_session_get_timeout...
-     d                 pr                  extproc(
-     d                                     'libssh2_session_get_timeout')
-     d                                     like(libssh2_Clong)
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_channel_handle_extended_data2...
-     d                 pr                  extproc('libssh2_channel_handle_exte-
-     d                                     nded_data2')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  ignore_mode                        value like(libssh2_Cint)
-
-      * libssh2_channel_ignore_extended_data() is defined below for BC with
-      * version 0.1.
-
-     d LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA...
-     d                 c                   -1
-     d LIBSSH2_CHANNEL_FLUSH_ALL...
-     d                 c                   -2
-
-     d libssh2_channel_flush_ex...
-     d                 pr                  extproc('libssh2_channel_flush_ex')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  streamid                           value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_channel_flush...
-     d                 pr                  extproc('libssh2_channel_flush')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-      * C macro implementation.
-     d libssh2_channel_flush_stderr...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_flush_stderr')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_get_exit_status...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_get_exit_status')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_get_exit_signal...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_get_exit_signal')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-     d  exitsignal                     *                                        char *(*)
-     d  exitsignal_len...
-     d                                     like(libssh2_Csize_t)
-     d  errmsg                         *                                        char *(*)
-     d  errmsg_len                         like(libssh2_Csize_t)
-     d  langtag                        *                                        char *(*)
-     d  langtag_len                        like(libssh2_Csize_t)
-
-     d libssh2_channel_send_eof...
-     d                 pr                  extproc('libssh2_channel_send_eof')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_eof...
-     d                 pr                  extproc('libssh2_channel_eof')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_wait_eof...
-     d                 pr                  extproc('libssh2_channel_wait_eof')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_close...
-     d                 pr                  extproc('libssh2_channel_close')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_wait_closed...
-     d                 pr                  extproc(
-     d                                     'libssh2_channel_wait_closed')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-     d libssh2_channel_free...
-     d                 pr                  extproc('libssh2_channel_free')
-     d                                     like(libssh2_Cint)
-     d  channel                        *   value                                LIBSSH2_CHANNEL *
-
-      * Use libssh2_scp_recv2 for large (> 2GB) file support.
-     d libssh2_scp_recv2...
-     d                 pr              *   extproc('libssh2_scp_recv2')         LIBSSH2_CHANNEL *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  path                           *   value options(*string)               const char *
-     d  sb                                 likeds(libssh2_struct_stat)
-
-     d libssh2_scp_send_ex...
-     d                 pr              *   extproc('libssh2_scp_send_ex')       LIBSSH2_CHANNEL *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  path                           *   value options(*string)               const char *
-     d  mode                               value like(libssh2_Cint)
-     d  size                               value like(libssh2_Csize_t)
-     d  mtime                              value like(libssh2_Clong)
-     d  atime                              value like(libssh2_Clong)
-
-     d libssh2_scp_send64...
-     d                 pr              *   extproc('libssh2_scp_send64')        LIBSSH2_CHANNEL *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  path                           *   value options(*string)               const char *
-     d  mode                               value like(libssh2_Cint)
-     d  size                               value like(libssh2_int64_t)
-     d  mtime                              value like(libssh2_time_t)
-     d  atime                              value like(libssh2_time_t)
-
-      * C macro implementation.
-     d libssh2_scp_send...
-     d                 pr              *   extproc('libssh2_scp_send')          LIBSSH2_CHANNEL *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  path                           *   value options(*string)               const char *
-     d  mode                               value like(libssh2_Cint)
-     d  size                               value like(libssh2_int64_t)
-
-     d libssh2_base64_decode...
-     d                 pr                  extproc('libssh2_base64_decode')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  dest                           *   value                                char * *
-     d  dest_len                       *   value                                unsigned int *
-     d  src                            *   value options(*string)               const char *
-     d  src_len                            value like(libssh2_Cuint)
-
-      * Procedure libssh2_version renamed to avoid upper/lower case name clash.
-     d libssh2_get_version...
-     d                 pr              *   extproc('libssh2_version')           const char *
-     d  req_version_num...
-     d                                     value like(libssh2_Cint)
-
-     d HAVE_LIBSSH2_KNOWNHOST_API...                                            since 1.1.1
-     d                 c                   X'010101'
-     d HAVE_LIBSSH2_VERSION_API...                                              since 1.1
-     d                 c                   X'010100'
-
-     d libssh2_knownhost...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  magic                              like(libssh2_Cuint)
-     d  node                           *                                        void *
-     d  name                           *                                        char *
-     d  key                            *                                        char *
-     d  typemask                           like(libssh2_Cint)
-
-      * libssh2_knownhost_init
-      *
-      * Init a collection of known hosts. Returns the pointer to a collection.
-
-     d libssh2_knownhost_init...
-     d                 pr              *   extproc('libssh2_knownhost_init')    LIBSSH2_KNOWNHOSTS *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-      * libssh2_knownhost_add
-      *
-      * Add a host and its associated key to the collection of known hosts.
-      *
-      * The 'type' argument specifies on what format the given host and
-      * keys are:
-      *
-      * plain  - ascii "hostname.domain.tld"
-      * sha1   - SHA1(<salt> <host>) base64-encoded!
-      * custom - another hash
-      *
-      * If 'sha1' is selected as type, the salt must be provided to the salt
-      * argument. This too base64 encoded.
-      *
-      * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.
-      * If a custom type is used, salt is ignored and you must provide the host
-      * pre-hashed when checking for it in the libssh2_knownhost_check()
-      * function.
-      *
-      * The keylen parameter may be omitted (zero) if the key is provided as a
-      * NULL-terminated base64-encoded string.
-
-      * host format (2 bits).
-     d LIBSSH2_KNOWNHOST_TYPE_MASK...
-     d                 c                   X'FFFF'
-     d  LIBSSH2_KNOWNHOST_TYPE_PLAIN...
-     d                 c                   1
-     d LIBSSH2_KNOWNHOST_TYPE_SHA1...                                           always base64 ncoded
-     d                 c                   2
-     d LIBSSH2_KNOWNHOST_TYPE_CUSTOM...
-     d                 c                   3
-
-      * key format (2 bits).
-     d LIBSSH2_KNOWNHOST_KEYENC_MASK...
-     d                 c                   X'00030000'
-     d LIBSSH2_KNOWNHOST_KEYENC_RAW...
-     d                 c                   X'00010000'
-     d LIBSSH2_KNOWNHOST_KEYENC_BASE64...
-     d                 c                   X'00020000'
-
-      * type of key (3 bits).
-     d LIBSSH2_KNOWNHOST_KEY_MASK...
-     d                 c                   X'001C0000'
-     d LIBSSH2_KNOWNHOST_KEY_SHIFT...
-     d                 c                   18
-     d LIBSSH2_KNOWNHOST_KEY_RSA1...
-     d                 c                   X'00040000'
-     d LIBSSH2_KNOWNHOST_KEY_SSHRSA...
-     d                 c                   X'00080000'
-     d LIBSSH2_KNOWNHOST_KEY_SSHDSS...
-     d                 c                   X'000C0000'
-     d LIBSSH2_KNOWNHOST_KEY_UNKNOWN...
-     d                 c                   X'001C0000'
-
-     d libssh2_knownhost_add...
-     d                 pr                  extproc('libssh2_knownhost_add')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  host                           *   value options(*string)               const char *
-     d  salt                           *   value options(*string)               const char *
-     d  key                            *   value options(*string)               const char *
-     d  keylen                             value like(libssh2_Csize_t)
-     d  typemask                           value like(libssh2_Cint)
-     d  store                          *                                        libssh2_knownhost *
-
-      * libssh2_knownhost_addc
-      *
-      * Add a host and its associated key to the collection of known hosts.
-      *
-      * Takes a comment argument that may be NULL.  A NULL comment indicates
-      * there is no comment and the entry will end directly after the key
-      * when written out to a file.  An empty string "" comment will indicate an
-      * empty comment which will cause a single space to be written after the
-      * key.
-      *
-      * The 'type' argument specifies on what format the given host and keys
-      * are:
-      *
-      * plain  - ascii "hostname.domain.tld"
-      * sha1   - SHA1(<salt> <host>) base64-encoded!
-      * custom - another hash
-      *
-      * If 'sha1' is selected as type, the salt must be provided to the salt
-      * argument. This too base64 encoded.
-      *
-      * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.
-      * If a custom type is used, salt is ignored and you must provide the host
-      * pre-hashed when checking for it in the libssh2_knownhost_check()
-      * function.
-      *
-      * The keylen parameter may be omitted (zero) if the key is provided as a
-      * NULL-terminated base64-encoded string.
-
-     d libssh2_knownhost_addc...
-     d                 pr                  extproc('libssh2_knownhost_addc')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  host                           *   value options(*string)               const char *
-     d  salt                           *   value options(*string)               const char *
-     d  key                            *   value options(*string)               const char *
-     d  keylen                             value like(libssh2_Csize_t)
-     d  comment                        *   value options(*string)               const char *
-     d  commentlen                         value like(libssh2_Csize_t)
-     d  typemask                           value like(libssh2_Cint)
-     d  store                          *                                        libssh2_knownhost *
-
-
-      * libssh2_knownhost_check
-      *
-      * Check a host and its associated key against the collection of known
-      * hosts.
-      *
-      * The type is the type/format of the given host name.
-      *
-      * plain  - ascii "hostname.domain.tld"
-      * custom - prehashed base64 encoded. Note that this cannot use any salts.
-      *
-      *
-      * 'knownhost' may be set to NULL if you don't care about that info.
-      *
-      * Returns:
-      *
-      * LIBSSH2_KNOWNHOST_CHECK_* values, see below.
-
-     d LIBSSH2_KNOWNHOST_CHECK_MATCH...
-     d                 c                   0
-     d LIBSSH2_KNOWNHOST_CHECK_MISMATCH...
-     d                 c                   1
-     d LIBSSH2_KNOWNHOST_CHECK_NOTFOUND...
-     d                 c                   2
-     d LIBSSH2_KNOWNHOST_CHECK_FAILURE...
-     d                 c                   3
-
-     d libssh2_knownhost_check...
-     d                 pr                  extproc('libssh2_knownhost_check')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  host                           *   value options(*string)               const char *
-     d  key                            *   value options(*string)               const char *
-     d  keylen                             value like(libssh2_Csize_t)
-     d  typemask                           value like(libssh2_Cint)
-     d  knownhost                      *                                        libssh2_knownhost *
-
-      * this function is identital to the above one, but also takes a port
-      * argument that allows libssh2 to do a better check.
-     d libssh2_knownhost_checkp...
-     d                 pr                  extproc('libssh2_knownhost_checkp')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  host                           *   value options(*string)               const char *
-     d  port                               value like(libssh2_Cint)
-     d  key                            *   value options(*string)               const char *
-     d  keylen                             value like(libssh2_Csize_t)
-     d  typemask                           value like(libssh2_Cint)
-     d  knownhost                      *                                        libssh2_knownhost *
-
-      * libssh2_knownhost_del
-      *
-      * Remove a host from the collection of known hosts. The 'entry' struct is
-      * retrieved by a call to libssh2_knownhost_check().
-
-     d libssh2_knownhost_del...
-     d                 pr                  extproc('libssh2_knownhost_del')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  entry                              likeds(libssh2_knownhost)
-
-      * libssh2_knownhost_free
-      *
-      * Free an entire collection of known hosts.
-
-     d libssh2_knownhost_free...
-     d                 pr                  extproc('libssh2_knownhost_free')
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-
-      * libssh2_knownhost_readline()
-      *
-      * Pass in a line of a file of 'type'. It makes libssh2 read this line.
-      *
-      * LIBSSH2_KNOWNHOST_FILE_OPENSSH is the only supported type.
-
-     d libssh2_knownhost_readline...
-     d                 pr                  extproc('libssh2_knownhost_readline')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  line                           *   value options(*string)               const char *
-     d  len                                value like(libssh2_Csize_t)
-     d  type                               value like(libssh2_Cint)
-
-      * libssh2_knownhost_readfile
-      *
-      * Add hosts+key pairs from a given file.
-      *
-      * Returns a negative value for error or number of successfully added
-      * hosts.
-      *
-      * This implementation currently only knows one 'type' (openssh), all
-      * others are reserved for future use.
-
-     d LIBSSH2_KNOWNHOST_FILE_OPENSSH...
-     d                 c                   1
-
-     d libssh2_knownhost_readfile...
-     d                 pr                  extproc('libssh2_knownhost_readfile')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  filename                       *   value options(*string)               const char *
-     d  type                               value like(libssh2_Cint)
-
-      * libssh2_knownhost_writeline()
-      *
-      * Ask libssh2 to convert a known host to an output line for storage.
-      *
-      * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the
-      * given output buffer is too small to hold the desired output.
-      *
-      * This implementation currently only knows one 'type' (openssh), all
-      * others are reserved for future use.
-
-     d libssh2_knownhost_writeline...
-     d                 pr                  extproc(
-     d                                     'libssh2_knownhost_writeline')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  known                              likeds(libssh2_knownhost)
-     d  buffer                         *   value options(*string)               char *
-     d  buflen                             value like(libssh2_Csize_t)
-     d  outlen                             like(libssh2_Csize_t)                Written data amount
-     d  type                               value like(libssh2_Cint)
-
-      * libssh2_knownhost_writefile
-      *
-      * Write hosts+key pairs to a given file.
-      *
-      * This implementation currently only knows one 'type' (openssh), all
-      * others are reserved for future use.
-
-     d libssh2_knownhost_writefile...
-     d                 pr                  extproc(
-     d                                     'libssh2_knownhost_writefile')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  filename                       *   value options(*string)               const char *
-     d  type                               value like(libssh2_Cint)
-
-      * libssh2_knownhost_get()
-      *
-      * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
-      * the first one. Or pass a poiner to the previously returned one to
-      * get the next.
-      *
-      * Returns:
-      * 0 if a fine host was stored in 'store'
-      * 1 if end of hosts
-      * [negative] on errors
-
-     d libssh2_knownhost_get...
-     d                 pr                  extproc('libssh2_knownhost_get')
-     d                                     like(libssh2_Cint)
-     d  hosts                          *   value                                LIBSSH2_KNOWNHOSTS *
-     d  store                          *                                        libssh2_knownhost *
-     d  prev                               likeds(libssh2_knownhost)
-
-     d HAVE_LIBSSH2_AGENT_API...                                                since 1.2.2
-     d                 c                   X'010202'
-
-     d libssh2_agent_publickey...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  magic                              like(libssh2_Cuint)
-     d  node                           *                                        void *
-     d  blob                           *                                        unsigned char *
-     d  blob_len                           like(libssh2_Csize_t)
-     d  comment                        *                                        char *
-
-      * libssh2_agent_init
-      *
-      * Init an ssh-agent handle. Returns the pointer to the handle.
-
-     d libssh2_agent_init...
-     d                 pr              *   extproc('libssh2_agent_init')        LIBSSH2_AGENT *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-      * libssh2_agent_connect()
-      *
-      * Connect to an ssh-agent.
-      *
-      * Returns 0 if succeeded, or a negative value for error.
-
-     d libssh2_agent_connect...
-     d                 pr                  extproc('libssh2_agent_connect')
-     d                                     like(libssh2_Cint)
-     d  agent                          *   value                                LIBSSH2_AGENT *
-
-      * libssh2_agent_list_identities()
-      *
-      * Request an ssh-agent to list identities.
-      *
-      * Returns 0 if succeeded, or a negative value for error.
-
-     d libssh2_agent_list_identities...
-     d                 pr                  extproc(
-     d                                     'libssh2_agent_list_identities')
-     d                                     like(libssh2_Cint)
-     d  agent                          *   value                                LIBSSH2_AGENT *
-
-      * libssh2_agent_get_identity()
-      *
-      * Traverse the internal list of public keys. Pass NULL to 'prev' to get
-      * the first one. Or pass a poiner to the previously returned one to
-      * get the next.
-      *
-      * Returns:
-      * 0 if a fine public key was stored in 'store'
-      * 1 if end of public keys
-      * [negative] on errors
-
-     d libssh2_agent_get_identity...
-     d                 pr                  extproc('libssh2_agent_get_identity')
-     d                                     like(libssh2_Cint)
-     d  agent                          *   value                                LIBSSH2_AGENT *
-     d  store                          *                                        libssh2_agent_...
-     d                                                                          publickey *(*)
-     d  prev                               likeds(libssh2_agent_publickey)
-
-      * libssh2_agent_userauth()
-      *
-      * Do publickey user authentication with the help of ssh-agent.
-      *
-      * Returns 0 if succeeded, or a negative value for error.
-
-     d libssh2_agent_userauth...
-     d                 pr                  extproc('libssh2_agent_userauth')
-     d                                     like(libssh2_Cint)
-     d  agent                          *   value                                LIBSSH2_AGENT *
-     d  username                       *   value options(*string)               const char *
-     d  identity                           likeds(libssh2_agent_publickey)
-
-      * libssh2_agent_disconnect()
-      *
-      * Close a connection to an ssh-agent.
-      *
-      * Returns 0 if succeeded, or a negative value for error.
-
-     d libssh2_agent_disconnect...
-     d                 pr                  extproc('libssh2_agent_disconnect')
-     d                                     like(libssh2_Cint)
-     d  agent                          *   value                                LIBSSH2_AGENT *
-
-      * libssh2_agent_free()
-      *
-      * Free an ssh-agent handle. This function also frees the internal
-      * collection of public keys.
-
-     d libssh2_agent_free...
-     d                 pr                  extproc('libssh2_agent_free')
-     d  agent                          *   value                                LIBSSH2_AGENT *
-
-
-      * libssh2_keepalive_config()
-      *
-      * Set how often keepalive messages should be sent.  WANT_REPLY
-      * indicates whether the keepalive messages should request a response
-      * from the server.  INTERVAL is number of seconds that can pass
-      * without any I/O, use 0 (the default) to disable keepalives.  To
-      * avoid some busy-loop corner-cases, if you specify an interval of 1
-      * it will be treated as 2.
-      *
-      * Note that non-blocking applications are responsible for sending the
-      * keepalive messages using libssh2_keepalive_send().
-
-     d libssh2_keepalive_config...
-     d                 pr                  extproc('libssh2_keepalive_config')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  want_reply                         value like(libssh2_Cint)
-     d  interval                           value like(libssh2_Cuint)
-
-      * libssh2_keepalive_send()
-      *
-      * Send a keepalive message if needed.  SECONDS_TO_NEXT indicates how
-      * many seconds you can sleep after this call before you need to call
-      * it again.  Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on
-      * I/O errors.
-
-     d libssh2_keepalive_send...
-     d                 pr                  extproc('libssh2_keepalive_send')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  seconds_to_next...
-     d                                     like(libssh2_Cint)
-
-      * NOTE NOTE NOTE
-      * libssh2_trace() has no function in builds that aren't built with debug
-      * enabled.
-
-     d libssh2_trace   pr                  extproc('libssh2_trace')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  bitmask                            value like(libssh2_Cint)
-
-     d LIBSSH2_TRACE_TRANS...
-     d                 c                   X'0002'
-     d LIBSSH2_TRACE_KEX...
-     d                 c                   X'0004'
-     d LIBSSH2_TRACE_AUTH...
-     d                 c                   X'0008'
-     d LIBSSH2_TRACE_CONN...
-     d                 c                   X'0010'
-     d LIBSSH2_TRACE_SCP...
-     d                 c                   X'0020'
-     d LIBSSH2_TRACE_SFTP...
-     d                 c                   X'0040'
-     d LIBSSH2_TRACE_ERROR...
-     d                 c                   X'0080'
-     d LIBSSH2_TRACE_PUBLICKEY...
-     d                 c                   X'0100'
-     d LIBSSH2_TRACE_SOCKET...
-     d                 c                   X'0200'
-
-     d libssh2_trace_handler_func...
-     d                 s               *   based(######typedef######) procptr
-
-     d libssh2_trace_sethandler...
-     d                 pr                  extproc('libssh2_trace_sethandler')
-     d                                     like(libssh2_Cint)
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  context                        *   value                                void *
-     d  callback                           value
-     d                                     like(libssh2_trace_handler_func)
-
-      /endif                                                                    LIBSSH2_H_
diff --git a/libssh2/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in b/libssh2/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in
deleted file mode 100644
index 345fa630..00000000
--- a/libssh2/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in
+++ /dev/null
@@ -1,69 +0,0 @@
-      * Copyright (c) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
-      * 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 any other contributors may be used to endorse or
-      *   promote products derived from this software without
-      *   specific prior written permission.
-      *
-      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-      * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-      * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-      * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-      * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-      * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-      * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-      * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-      * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-      * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-      * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-      * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-      * OF SUCH DAMAGE.
-
-      /if not defined(LIBSSH2_CCSID_H_)
-      /define LIBSSH2_CCSID_H_
-
-      /include "libssh2rpg/libssh2"
-
-     d libssh2_from_ccsid...
-     d                 pr              *   extproc('libssh2_from_ccsid')        char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  cache                          *                                        libssh2_string_cache
-     d                                                                          *(*)
-     d  ccsid                              value like(libssh2_Cushort)
-     d  string                         *   value options(*string)               const char *
-     d  inlen                              value like(libssh2_Cssize_t)
-     d  outlen                             like(libssh2_Csize_t) options(*omit)
-
-     d libssh2_to_ccsid...
-     d                 pr              *   extproc('libssh2_to_ccsid')          char *
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  cache                          *                                        libssh2_string_cache
-     d                                                                          *(*)
-     d  ccsid                              value like(libssh2_Cushort)
-     d  string                         *   value options(*string)               const char *
-     d  inlen                              value like(libssh2_Cssize_t)
-     d  outlen                             like(libssh2_Csize_t) options(*omit)
-
-     d libssh2_release_string_cache...
-     d                 pr                  extproc(
-     d                                     'libssh2_release_string_cache')
-     d  session                        *   value                                LIBSSH2_SESSION *
-     d  cache                          *                                        libssh2_string_cache
-     d                                                                          *(*)
-
-      /endif                                                                    LIBSSH2_CCSID_H_
diff --git a/libssh2/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle b/libssh2/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle
deleted file mode 100644
index 4387b0d3..00000000
--- a/libssh2/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle
+++ /dev/null
@@ -1,141 +0,0 @@
-      * Copyright (c) 2015, Patrick Monnerat, D+H <patrick.monnerat@dh.com>
-      * 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 any other contributors may be used to endorse or
-      *   promote products derived from this software without
-      *   specific prior written permission.
-      *
-      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-      * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-      * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-      * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-      * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-      * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-      * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-      * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-      * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-      * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-      * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-      * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-      * OF SUCH DAMAGE.
-
-      * Note: This include file is only needed for using the
-      * publickey SUBSYSTEM which is not the same as publickey
-      * authentication.  For authentication you only need libssh2.h
-      *
-      * For more information on the publickey subsystem,
-      * refer to IETF draft: secsh-publickey
-
-      /if not defined(LIBSSH2_PUBLICKEY_H_)
-      /define LIBSSH2_PUBLICKEY_H_
-
-      /include "libssh2rpg/libssh2"
-
-     d libssh2_publickey_attribute...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  name                           *                                        const char *
-     d  name_len                           like(libssh2_Culong)
-     d  value                          *                                        const char *
-     d  value_len                          like(libssh2_Culong)
-     d  mandatory                          like(libssh2_Cchar)
-
-     d libssh2_publickey_list...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  name                           *                                        const char *
-     d  name_len                           like(libssh2_Culong)
-     d  blob                           *                                        const uns char *
-     d  blob_len                           like(libssh2_Culong)
-     d  num_attrs                          like(libssh2_Culong)
-     d  attrs                          *                                        libssh2_publickey...
-     d                                                                          attribute *
-
-      * Publickey Subsystem.
-     d libssh2_publickey_init...
-     d                 pr              *   extproc('libssh2_publickey_init')    LIBSSH2_PUBLICKEY *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_publickey_add_ex...
-     d                 pr                  extproc('libssh2_publickey_add_ex')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  name                           *   value options(*string)               const uns char *
-     d  name_len                           value like(libssh2_Culong)
-     d  blob                           *   value options(*string)               const uns char *
-     d  blob_len                           value like(libssh2_Culong)
-     d  overwrite                          value like(libssh2_Cchar)
-     d  num_attrs                          value like(libssh2_Culong)
-     d  attrs                              likeds(libssh2_publickey_attribute)
-     d                                     dim(1000)
-
-      * C macro implementation.
-     d libssh2_publickey_add...
-     d                 pr                  extproc('libssh2_publickey_add')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  name                           *   value options(*string)               const unsigned char
-     d                                                                          *
-     d  blob                           *   value options(*string)               const unsigned char
-     d                                                                          *
-     d  blob_len                           value like(libssh2_Culong)
-     d  overwrite                          value like(libssh2_Cchar)
-     d  num_attrs                          value like(libssh2_Culong)
-     d  attrs                              likeds(libssh2_publickey_attribute)
-     d                                     dim(1000)
-
-     d libssh2_publickey_remove_ex...
-     d                 pr                  extproc(
-     d                                     'libssh2_publickey_remove_ex')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  name                           *   value options(*string)               const uns char *
-     d  name_len                           value like(libssh2_Culong)
-     d  blob                           *   value options(*string)               const uns char *
-     d  blob_len                           value like(libssh2_Culong)
-
-      * C macro implementation.
-     d libssh2_publickey_remove...
-     d                 pr                  extproc('libssh2_publickey_remove')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  name                           *   value options(*string)               const uns char *
-     d  blob                           *   value options(*string)               const uns char *
-     d  blob_len                           value like(libssh2_Culong)
-
-     d libssh2_publickey_list_fetch...
-     d                 pr                  extproc(
-     d                                     'libssh2_publickey_list_fetch')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  num_keys                       *   value                                unsigned long *
-     d  pkey_list                      *                                        libssh2_publickey...
-     d                                                                          _list *(*)
-
-     d libssh2_publickey_list_free...
-     d                 pr                  extproc(
-     d                                     'libssh2_publickey_list_free')
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-     d  pkey_list                          likeds(libssh2_publickey_list)
-
-     d libssh2_publickey_shutdown...
-     d                 pr                  extproc('libssh2_publickey_shutdown')
-     d                                     like(libssh2_Cint)
-     d  pkey                           *   value                                LIBSSH2_PUBLICKEY *
-
-      /endif                                                                    LIBSSH2_PUBLICKEY_H_
diff --git a/libssh2/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle b/libssh2/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle
deleted file mode 100644
index f4068fc8..00000000
--- a/libssh2/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle
+++ /dev/null
@@ -1,621 +0,0 @@
-      * Copyright (c) 2015, Patrick Monnerat, D+H <patrick.monnerat@dh.com>
-      * 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 any other contributors may be used to endorse or
-      *   promote products derived from this software without
-      *   specific prior written permission.
-      *
-      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-      * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-      * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-      * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-      * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-      * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-      * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-      * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-      * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-      * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-      * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-      * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-      * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-      * OF SUCH DAMAGE.
-
-      /if not defined(LIBSSH2_SFTP_H_)
-      /define LIBSSH2_SFTP_H_
-
-      /include "libssh2rpg/libssh2"
-
-      * Note: Version 6 was documented at the time of writing
-      * However it was marked as "DO NOT IMPLEMENT" due to pending changes
-      *
-      * Let's start with Version 3 (The version found in OpenSSH) and go from
-      * there.
-     d LIBSSH2_SFTP_VERSION...
-     d                 c                   3
-
-      * Flags for open_ex().
-     d LIBSSH2_SFTP_OPENFILE...
-     d                 c                   0
-     d LIBSSH2_SFTP_OPENDIR...
-     d                 c                   1
-
-      * Flags for rename_ex().
-     d LIBSSH2_SFTP_RENAME_OVERWRITE...
-     d                 c                   X'00000001'
-     d LIBSSH2_SFTP_RENAME_ATOMIC...
-     d                 c                   X'00000002'
-     d LIBSSH2_SFTP_RENAME_NATIVE...
-     d                 c                   X'00000004'
-
-      * Flags for stat_ex().
-     d LIBSSH2_SFTP_STAT...
-     d                 c                   0
-     d LIBSSH2_SFTP_LSTAT...
-     d                 c                   1
-     d LIBSSH2_SFTP_SETSTAT...
-     d                 c                   2
-
-      * Flags for symlink_ex().
-     d LIBSSH2_SFTP_SYMLINK...
-     d                 c                   0
-     d LIBSSH2_SFTP_READLINK...
-     d                 c                   1
-     d LIBSSH2_SFTP_REALPATH...
-     d                 c                   2
-
-      * SFTP attribute flag bits.
-     d LIBSSH2_SFTP_ATTR_SIZE...
-     d                 c                   X'00000001'
-     d LIBSSH2_SFTP_ATTR_UIDGID...
-     d                 c                   X'00000002'
-     d LIBSSH2_SFTP_ATTR_PERMISSIONS...
-     d                 c                   X'00000004'
-     d LIBSSH2_SFTP_ATTR_ACMODTIME...
-     d                 c                   X'00000008'
-     d LIBSSH2_SFTP_ATTR_EXTENDED...
-     d                 c                   X'80000000'
-
-      * SFTP statvfs flag bits.
-     d LIBSSH2_SFTP_ST_RDONLY...
-     d                 c                   X'00000001'
-     d LIBSSH2_SFTP_ST_NOSUID...
-     d                 c                   X'00000002'
-
-     d #LIBSSH2_SFTP_ATTRIBUTES...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-      * If flags & ATTR_* bit is set, then the value in this struct will be
-      * meaningful Otherwise it should be ignored.
-     d  flags                              like(libssh2_Culong)
-     d  filesize                           like(libssh2_uint64_t)
-     d  uid                                like(libssh2_Culong)
-     d  gid                                like(libssh2_Culong)
-     d  permissions                        like(libssh2_Culong)
-     d  atime                              like(libssh2_Culong)
-     d  mtime                              like(libssh2_Culong)
-
-     d #LIBSSH2_SFTP_STATVFS...
-     d                 ds                  based(######typedef######)
-     d                                     align qualified
-     d  f_bsize                            like(libssh2_uint64_t)               Filesys block size
-     d  f_frsize                           like(libssh2_uint64_t)               Fragment size
-     d  f_blocks                           like(libssh2_uint64_t)               FS size in f_frsize
-     d  f_bfree                            like(libssh2_uint64_t)               Free blocks
-     d  f_bavail                           like(libssh2_uint64_t)               Free blks f. nonroot
-     d  f_files                            like(libssh2_uint64_t)               Inodes
-     d  f_ffree                            like(libssh2_uint64_t)               Free inodes
-     d  f_favail                           like(libssh2_uint64_t)               Free inds f. nonroot
-     d  f_fsid                             like(libssh2_uint64_t)               File system ID
-     d  f_flag                             like(libssh2_uint64_t)               Mount flags
-     d  f_namemax                          like(libssh2_uint64_t)               Max filename length
-
-      * SFTP filetypes.
-     d LIBSSH2_SFTP_TYPE_REGULAR...
-     d                 c                   1
-     d LIBSSH2_SFTP_TYPE_DIRECTORY...
-     d                 c                   2
-     d LIBSSH2_SFTP_TYPE_SYMLINK...
-     d                 c                   3
-     d LIBSSH2_SFTP_TYPE_SPECIAL...
-     d                 c                   4
-     d LIBSSH2_SFTP_TYPE_UNKNOWN...
-     d                 c                   5
-     d LIBSSH2_SFTP_TYPE_SOCKET...
-     d                 c                   6
-     d LIBSSH2_SFTP_TYPE_CHAR_DEVICE...
-     d                 c                   7
-     d LIBSSH2_SFTP_TYPE_BLOCK_DEVICE...
-     d                 c                   8
-     d LIBSSH2_SFTP_TYPE_FIFO...
-     d                 c                   9
-
-      * Reproduce the POSIX file modes here for systems that are not POSIX
-      * compliant.
-      *
-      * These is used in "permissions" of "struct _LIBSSH2_SFTP_ATTRIBUTES"
-
-      * File type.
-     d LIBSSH2_SFTP_S_IFMT...                                                   type of file mask
-     d                 c                   X'F000'
-     d LIBSSH2_SFTP_S_IFIFO...                                                  named pipe (fifo)
-     d                 c                   X'1000'
-     d LIBSSH2_SFTP_S_IFCHR...                                                  character special
-     d                 c                   X'2000'
-     d LIBSSH2_SFTP_S_IFDIR...                                                  directory
-     d                 c                   X'4000'
-     d LIBSSH2_SFTP_S_IFBLK...                                                  block special
-     d                 c                   X'6000'
-     d LIBSSH2_SFTP_S_IFREG...                                                  regular
-     d                 c                   X'8000'
-     d LIBSSH2_SFTP_S_IFLNK...                                                  symbolic link
-     d                 c                   X'A000'
-     d LIBSSH2_SFTP_S_IFSOCK...                                                 socket
-     d                 c                   X'C000'
-
-      * File mode.
-      * Read, write, execute/search by owner.
-     d LIBSSH2_SFTP_S_IRWXU...                                                  RWX mask for owner
-     d                 c                   X'01C0'
-     d LIBSSH2_SFTP_S_IRUSR...                                                  R for owner
-     d                 c                   X'0100'
-     d LIBSSH2_SFTP_S_IWUSR...                                                  W for owner
-     d                 c                   X'0080'
-     d LIBSSH2_SFTP_S_IXUSR...                                                  X for owner
-     d                 c                   X'0040'
-      * Read, write, execute/search by group.
-     d LIBSSH2_SFTP_S_IRWXG...                                                  RWX mask for group
-     d                 c                   X'0038'
-     d LIBSSH2_SFTP_S_IRGRP...                                                  R for group
-     d                 c                   X'0020'
-     d LIBSSH2_SFTP_S_IWGRP...                                                  W for group
-     d                 c                   X'0010'
-     d LIBSSH2_SFTP_S_IXGRP...                                                  X for group
-     d                 c                   X'0008'
-      * Read, write, execute/search by others.
-     d LIBSSH2_SFTP_S_IRWXO...                                                  RWX mask for other
-     d                 c                   X'0007'
-     d LIBSSH2_SFTP_S_IROTH...                                                  R for other
-     d                 c                   X'0004'
-     d LIBSSH2_SFTP_S_IWOTH...                                                  W for other
-     d                 c                   X'0002'
-     d LIBSSH2_SFTP_S_IXOTH...                                                  X for other
-     d                 c                   X'0001'
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISLNK...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISLNK')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISREG...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISREG')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISDIR...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISDIR')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISCHR...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISCHR')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISBLK...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISBLK')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISFIFO...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISFIFO')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * C macro implementation.
-     d LIBSSH2_SFTP_S_ISSOCK...
-     d                 pr                  extproc('LIBSSH2_SFTP_S_ISSOCK')
-     d                                     like(libssh2_Cint)
-     d  permissions                        value like(libssh2_Culong)
-
-      * SFTP File Transfer Flags -- (e.g. flags parameter to sftp_open())
-      * Danger will robinson... APPEND doesn't have any effect on OpenSSH
-      * servers.
-     d LIBSSH2_FXF_READ...
-     d                 c                   X'00000001'
-     d LIBSSH2_FXF_WRITE...
-     d                 c                   X'00000002'
-     d LIBSSH2_FXF_APPEND...
-     d                 c                   X'00000004'
-     d LIBSSH2_FXF_CREAT...
-     d                 c                   X'00000008'
-     d LIBSSH2_FXF_TRUNC...
-     d                 c                   X'00000010'
-     d LIBSSH2_FXF_EXCL...
-     d                 c                   X'00000020'
-
-      * SFTP Status Codes (returned by libssh2_sftp_last_error()).
-     d LIBSSH2_FX_OK...
-     d                 c                   0
-     d LIBSSH2_FX_EOF...
-     d                 c                   1
-     d LIBSSH2_FX_NO_SUCH_FILE...
-     d                 c                   2
-     d LIBSSH2_FX_PERMISSION_DENIED...
-     d                 c                   3
-     d LIBSSH2_FX_FAILURE...
-     d                 c                   4
-     d LIBSSH2_FX_BAD_MESSAGE...
-     d                 c                   5
-     d LIBSSH2_FX_NO_CONNECTION...
-     d                 c                   6
-     d LIBSSH2_FX_CONNECTION_LOST...
-     d                 c                   7
-     d LIBSSH2_FX_OP_UNSUPPORTED...
-     d                 c                   8
-     d LIBSSH2_FX_INVALID_HANDLE...
-     d                 c                   9
-     d LIBSSH2_FX_NO_SUCH_PATH...
-     d                 c                   10
-     d LIBSSH2_FX_FILE_ALREADY_EXISTS...
-     d                 c                   11
-     d LIBSSH2_FX_WRITE_PROTECT...
-     d                 c                   12
-     d LIBSSH2_FX_NO_MEDIA...
-     d                 c                   13
-     d LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM...
-     d                 c                   14
-     d LIBSSH2_FX_QUOTA_EXCEEDED...
-     d                 c                   15
-     d LIBSSH2_FX_UNKNOWN_PRINCIPAL...
-     d                 c                   16
-     d LIBSSH2_FX_LOCK_CONFLICT...
-     d                 c                   17
-     d LIBSSH2_FX_DIR_NOT_EMPTY...
-     d                 c                   18
-     d LIBSSH2_FX_NOT_A_DIRECTORY...
-     d                 c                   19
-     d LIBSSH2_FX_INVALID_FILENAME...
-     d                 c                   20
-     d LIBSSH2_FX_LINK_LOOP...
-     d                 c                   21
-
-      * Returned by any function that would block during a read/write operation.
-     d LIBSSH2SFTP_EAGAIN...
-     d                 c                   -37
-
-      * SFTP API.
-     d libssh2_sftp_init...
-     d                 pr              *   extproc('libssh2_sftp_init')         LIBSSH2_SFTP *
-     d  session                        *   value                                LIBSSH2_SESSION *
-
-     d libssh2_sftp_shutdown...
-     d                 pr                  extproc('libssh2_sftp_shutdown')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-
-     d libssh2_sftp_last_error...
-     d                 pr                  extproc('libssh2_sftp_last_error')
-     d                                     like(libssh2_Culong)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-
-     d libssh2_sftp_get_channel...
-     d                 pr              *   extproc('libssh2_sftp_get_channel')  LIBSSH2_CHANNEL *
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-
-      * File / Directory Ops.
-     d libssh2_sftp_open_ex...
-     d                 pr              *   extproc('libssh2_sftp_open_ex')      LIBSSH2_SFTP_HANDLE*
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  filename                       *   value options(*string)               const char *
-     d  filename_len                       value like(libssh2_Cuint)
-     d  flags                              value like(libssh2_Culong)
-     d  mode                               value like(libssh2_Clong)
-     d  open_type                          value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_sftp_open...
-     d                 pr              *   extproc('libssh2_sftp_open')         LIBSSH2_SFTP_HANDLE
-     d                                                                          *
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  filename                       *   value options(*string)               const char *
-     d  flags                              value like(libssh2_Culong)
-     d  mode                               value like(libssh2_Clong)
-
-      * C macro libssh2_sftp_opendir implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_open_dir...
-     d                 pr              *   extproc('libssh2_sftp_opendir')      LIBSSH2_SFTP_HANDLE
-     d                                                                          *
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-
-     d libssh2_sftp_read...
-     d                 pr                  extproc('libssh2_sftp_read')
-     d                                     like(libssh2_Cssize_t)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  buffer                         *   value options(*string)               char *
-     d  buffer_maxlen                      value like(libssh2_Csize_t)
-
-     d libssh2_sftp_readdir_ex...
-     d                 pr                  extproc('libssh2_sftp_readdir_ex')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  buffer                         *   value                                char *
-     d  buffer_maxlen                      value like(libssh2_Csize_t)
-     d  longentry                      *   value                                char *
-     d  longentry_maxlen...
-     d                                     value like(libssh2_Csize_t)
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * C macro implementation.
-     d libssh2_sftp_readdir...
-     d                 pr                  extproc('libssh2_sftp_readdir')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  buffer                         *   value                                char *
-     d  buffer_maxlen                      value like(libssh2_Csize_t)
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-     d libssh2_sftp_write...
-     d                 pr                  extproc('libssh2_sftp_write')
-     d                                     like(libssh2_Cssize_t)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  buffer                         *   value options(*string)               const char *
-     d  count                              value like(libssh2_Csize_t)
-
-     d libssh2_sftp_fsync...
-     d                 pr                  extproc('libssh2_sftp_fsync')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-     d libssh2_sftp_close_handle...
-     d                 pr                  extproc('libssh2_sftp_close_handle')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-      * C macro implementation.
-     d libssh2_sftp_close...
-     d                 pr                  extproc('libssh2_sftp_close_handle')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-      * C macro implementation.
-     d libssh2_sftp_closedir...
-     d                 pr                  extproc('libssh2_sftp_close_handle')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-     d libssh2_sftp_seek...
-     d                 pr                  extproc('libssh2_sftp_seek')
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  offset                             value like(libssh2_Csize_t)
-
-     d libssh2_sftp_seek64...
-     d                 pr                  extproc('libssh2_sftp_seek64')
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  offset                             value like(libssh2_uint64_t)
-
-      * C macro implementation.
-     d libssh2_sftp_rewind...
-     d                 pr                  extproc('libssh2_sftp_rewind')
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-     d libssh2_sftp_tell...
-     d                 pr                  extproc('libssh2_sftp_tell')
-     d                                     like(libssh2_Csize_t)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-     d libssh2_sftp_tell64...
-     d                 pr                  extproc('libssh2_sftp_tell64')
-     d                                     like(libssh2_uint64_t)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-
-     d libssh2_sftp_fstat_ex...
-     d                 pr                  extproc('libssh2_sftp_fstat_ex')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-     d  setstat                            value like(libssh2_Cint)
-
-      * C macro implementation.
-     d libssh2_sftp_fstat...
-     d                 pr                  extproc('libssh2_sftp_fstat')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * C macro implementation.
-     d libssh2_sftp_fsetstat...
-     d                 pr                  extproc('libssh2_sftp_fsetstat')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * Miscellaneous Ops.
-     d libssh2_sftp_rename_ex...
-     d                 pr                  extproc('libssh2_sftp_rename_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  source_filename...
-     d                                 *   value options(*string)               const char *
-     d  source_filename_len...
-     d                                     value like(libssh2_Cuint)
-     d  dest_filename                  *   value options(*string)               const char *
-     d  dest_filename_len...
-     d                                     value like(libssh2_Cuint)
-     d  flags                              value like(libssh2_Clong)
-
-      * C macro implementation.
-     d libssh2_sftp_rename...
-     d                 pr                  extproc('libssh2_sftp_rename')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  source_filename...
-     d                                 *   value options(*string)               const char *
-     d  dest_filename                  *   value options(*string)               const char *
-
-     d libssh2_sftp_unlink_ex...
-     d                 pr                  extproc('libssh2_sftp_unlink_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  filename                       *   value options(*string)               const char *
-     d  filename_len                       value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_sftp_unlink...
-     d                 pr                  extproc('libssh2_sftp_unlink')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  filename                       *   value options(*string)               const char *
-
-     d libssh2_sftp_fstatvfs...
-     d                 pr                  extproc('libssh2_sftp_fstatvfs')
-     d                                     like(libssh2_Cint)
-     d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  st                             *   value                                LIBSSH2_SFTP_STATVFS
-     d                                                                          *
-
-     d libssh2_sftp_statvfs...
-     d                 pr                  extproc('libssh2_sftp_statvfs')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  path_len                           value like(libssh2_Csize_t)
-     d  st                             *   value                                LIBSSH2_SFTP_STATVFS
-     d                                                                          *
-
-     d libssh2_sftp_mkdir_ex...
-     d                 pr                  extproc('libssh2_sftp_mkdir_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  path_len                           value like(libssh2_Cuint)
-     d  mode                               value like(libssh2_Clong)
-
-      * C macro implementation.
-     d libssh2_sftp_mkdir...
-     d                 pr                  extproc('libssh2_sftp_mkdir')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  mode                               value like(libssh2_Clong)
-
-     d libssh2_sftp_rmdir_ex...
-     d                 pr                  extproc('libssh2_sftp_rmdir_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  path_len                           value like(libssh2_Cuint)
-
-      * C macro implementation.
-     d libssh2_sftp_rmdir...
-     d                 pr                  extproc('libssh2_sftp_rmdir')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-
-     d libssh2_sftp_stat_ex...
-     d                 pr                  extproc('libssh2_sftp_stat_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  path_len                           value like(libssh2_Cuint)
-     d  stat_type                          value like(libssh2_Cint)
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * C macro libssh2_sftp_stat implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_get_stat...
-     d                 pr                  extproc('libssh2_sftp_stat')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * C macro libssh2_sftp_lstat implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_get_lstat...
-     d                 pr                  extproc('libssh2_sftp_lstat')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-      * C macro libssh2_sftp_setstat implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_set_stat...
-     d                 pr                  extproc('libssh2_sftp_setstat')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  attrs                          *   value                                LIBSSH2_SFTP_...
-     d                                                                          ATTRIBUTES *
-
-     d libssh2_sftp_symlink_ex...
-     d                 pr                  extproc('libssh2_sftp_symlink_ex')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  path_len                           value like(libssh2_Cuint)
-     d  target                         *   value options(*string)               char *
-     d  target_len                         value like(libssh2_Cuint)
-     d  link_type                          value like(libssh2_Cint)
-
-      * C macro libssh2_sftp_symlink implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_sym_link...
-     d                 pr                  extproc('libssh2_sftp_symlink')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  orig                           *   value options(*string)               const char *
-     d  linkpath                       *   value options(*string)               char *
-
-      * C macro libssh2_sftp_readlink implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_read_link...
-     d                 pr                  extproc('libssh2_sftp_readlink')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  target                         *   value                                char *
-     d  maxlen                             value like(libssh2_Cuint)
-
-      * C macro libssh2_sftp_realpath implementation.
-      * Renamed to avoid upper/lower case name clash.
-     d libssh2_sftp_real_path...
-     d                 pr                  extproc('libssh2_sftp_realpath')
-     d                                     like(libssh2_Cint)
-     d  sftp                           *   value                                LIBSSH2_SFTP *
-     d  path                           *   value options(*string)               const char *
-     d  target                         *   value                                char *
-     d  maxlen                             value like(libssh2_Cuint)
-
-      /endif                                                                    LIBSSH2_SFTP_H_
diff --git a/libssh2/libssh2/os400/macros.h b/libssh2/libssh2/os400/macros.h
deleted file mode 100644
index 408b98d0..00000000
--- a/libssh2/libssh2/os400/macros.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_MACROS_H_
-#define LIBSSH2_MACROS_H_
-
-#include "libssh2.h"
-#include "libssh2_publickey.h"
-#include "libssh2_sftp.h"
-
-/*
- * Dummy prototypes to generate wrapper procedures to C macros.
- * This is a helper for languages without a clever preprocessor (ILE/RPG).
- */
-
-LIBSSH2_API LIBSSH2_SESSION * libssh2_session_init(void);
-LIBSSH2_API int libssh2_session_disconnect(LIBSSH2_SESSION *session,
-                                           const char *description);
-LIBSSH2_API int libssh2_userauth_password(LIBSSH2_SESSION *session,
-                                          const char *username,
-                                          const char *password);
-LIBSSH2_API int
-libssh2_userauth_publickey_fromfile(LIBSSH2_SESSION *session,
-                                    const char *username,
-                                    const char *publickey,
-                                    const char *privatekey,
-                                    const char *passphrase);
-LIBSSH2_API int
-libssh2_userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
-                                    const char *username,
-                                    const char *publickey,
-                                    const char *privatekey,
-                                    const char *passphrase,
-                                    const char *hostname);
-LIBSSH2_API int
-libssh2_userauth_keyboard_interactive(LIBSSH2_SESSION* session,
-                                      const char *username,
-                                      LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(
-                                                       (*response_callback)));
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_open_session(LIBSSH2_SESSION *session);
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host,
-                             int port);
-LIBSSH2_API LIBSSH2_LISTENER *
-libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);
-LIBSSH2_API int
-libssh2_channel_setenv(LIBSSH2_CHANNEL *channel,
-                       const char *varname, const char *value);
-LIBSSH2_API int
-libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, const char *term);
-LIBSSH2_API int
-libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel,
-                                 int width, int height);
-LIBSSH2_API int
-libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
-LIBSSH2_API int
-libssh2_channel_shell(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int
-libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);
-LIBSSH2_API int
-libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);
-LIBSSH2_API ssize_t
-libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-LIBSSH2_API ssize_t
-libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-LIBSSH2_API unsigned long
-libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API ssize_t
-libssh2_channel_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
-LIBSSH2_API ssize_t
-libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel,
-                             const char *buf, size_t buflen);
-LIBSSH2_API unsigned long
-libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API int libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_send(LIBSSH2_SESSION *session,
-                 const char *path, int mode, libssh2_int64_t size);
-
-LIBSSH2_API int
-libssh2_publickey_add(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-		      const unsigned char *blob, unsigned long blob_len,
-                      char overwrite, unsigned long num_attrs,
-		      const libssh2_publickey_attribute attrs[]);
-LIBSSH2_API int
-libssh2_publickey_remove(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-                         const unsigned char *blob, unsigned long blob_len);
-
-LIBSSH2_API int LIBSSH2_SFTP_S_ISLNK(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISREG(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISDIR(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISCHR(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISBLK(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISFIFO(unsigned long permissions);
-LIBSSH2_API int LIBSSH2_SFTP_S_ISSOCK(unsigned long permissions);
-LIBSSH2_API LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
-                  unsigned long flags, long mode);
-LIBSSH2_API LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_opendir(LIBSSH2_SFTP *sftp, const char *path);
-LIBSSH2_API int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle,
-                                     char *buffer, size_t buffer_maxlen,
-                                     LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_close(LIBSSH2_SFTP_HANDLE *handle);
-LIBSSH2_API int libssh2_sftp_closedir(LIBSSH2_SFTP_HANDLE *handle);
-LIBSSH2_API void libssh2_sftp_rewind(LIBSSH2_SFTP_HANDLE *handle);
-LIBSSH2_API int libssh2_sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
-                                   LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_fsetstat(LIBSSH2_SFTP_HANDLE *handle,
-                                      LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_rename(LIBSSH2_SFTP *sftp,
-                                    const char *source_filename,
-                                    const char *dest_filename);
-LIBSSH2_API int libssh2_sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename);
-LIBSSH2_API int libssh2_sftp_mkdir(LIBSSH2_SFTP *sftp,
-                                   const char *path, long mode);
-LIBSSH2_API int libssh2_sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path);
-LIBSSH2_API int libssh2_sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
-                                  LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_lstat(LIBSSH2_SFTP *sftp, const char *path,
-                                   LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_setstat(LIBSSH2_SFTP *sftp, const char *path,
-                                     LIBSSH2_SFTP_ATTRIBUTES *attrs);
-LIBSSH2_API int libssh2_sftp_symlink(LIBSSH2_SFTP *sftp, const char *orig,
-                                     char *linkpath);
-LIBSSH2_API int libssh2_sftp_readlink(LIBSSH2_SFTP *sftp, const char *path,
-                                      char *target, unsigned int maxlen);
-LIBSSH2_API int libssh2_sftp_realpath(LIBSSH2_SFTP *sftp, const char *path,
-                                      char *target, unsigned int maxlen);
-
-#endif
diff --git a/libssh2/libssh2/os400/make-include.sh b/libssh2/libssh2/os400/make-include.sh
deleted file mode 100644
index 2cb7b726..00000000
--- a/libssh2/libssh2/os400/make-include.sh
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/bin/sh
-#
-#       Installation of the header files in the OS/400 library.
-#
-
-SCRIPTDIR=`dirname "${0}"`
-. "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/include"
-
-
-#       Create the OS/400 source program file for the header files.
-
-SRCPF="${LIBIFSNAME}/H.FILE"
-
-if action_needed "${SRCPF}"
-then    CMD="CRTSRCPF FILE(${TARGETLIB}/H) RCDLEN(112)"
-        CMD="${CMD} CCSID(${TGTCCSID}) TEXT('libssh2: Header files')"
-        system "${CMD}"
-fi
-
-
-#       Create the IFS directory for the header files.
-
-IFSINCLUDE="${IFSDIR}/include"
-
-if action_needed "${IFSINCLUDE}"
-then    mkdir -p "${IFSINCLUDE}"
-fi
-
-
-copy_hfile()
-
-{
-        destfile="${1}"
-        srcfile="${2}"
-        shift
-        shift
-        sed -e '1i\
-#pragma datamodel(P128)\
-' "${@}" -e '$a\
-#pragma datamodel(pop)\
-' < "${srcfile}" > "${destfile}"
-}
-
-#       Copy the header files.
-
-for HFILE in *.h "${TOPDIR}/os400/libssh2_ccsid.h"
-do      DEST="${SRCPF}/`db2_name \"${HFILE}\"`.MBR"
-
-        if action_needed "${DEST}" "${HFILE}"
-        then    copy_hfile "${DEST}" "${HFILE}"
-                IFSDEST="${IFSINCLUDE}/`basename \"${HFILE}\"`"
-                rm -f "${IFSDEST}"
-                ln -s "${DEST}" "${IFSDEST}"
-        fi
-done
diff --git a/libssh2/libssh2/os400/make-rpg.sh b/libssh2/libssh2/os400/make-rpg.sh
deleted file mode 100644
index c8a26472..00000000
--- a/libssh2/libssh2/os400/make-rpg.sh
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/bin/sh
-#
-#       Installation of the ILE/RPG header files in the OS/400 library.
-#
-
-SCRIPTDIR=`dirname "${0}"`
-. "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/os400/libssh2rpg"
-
-
-#       Create the OS/400 source program file for the ILE/RPG header files.
-
-SRCPF="${LIBIFSNAME}/LIBSSH2RPG.FILE"
-
-if action_needed "${SRCPF}"
-then    CMD="CRTSRCPF FILE(${TARGETLIB}/LIBSSH2RPG) RCDLEN(112)"
-        CMD="${CMD} CCSID(${TGTCCSID}) TEXT('libssh2: ILE/RPG header files')"
-        system "${CMD}"
-fi
-
-
-#       Map file names to DB2 name syntax.
-
-for HFILE in *.rpgle *.rpgle.in
-do      NAME="`basename \"${HFILE}\" .in`"
-        VAR="`basename \"${NAME}\" .rpgle`"
-        VAL="`db2_name \"${NAME}\"`"
-
-        eval "VAR_${VAR}=\"${VAL}\""
-        echo "${VAR} s/${VAR}/${VAL}/g"
-done > tmpsubstfile1
-
-#       Order substitution commands so that a prefix appears after all
-#               file names beginning with the prefix.
-
-sort -r tmpsubstfile1 | sed 's/^[^ ]*[ ]*//' > tmpsubstfile2
-
-
-change_include()
-
-{
-        sed -e '\#^....../include  *"libssh2rpg/#{'                     \
-            -e 's///'                                                   \
-            -e 's/".*//'                                                \
-            -f tmpsubstfile2                                            \
-            -e 's#.*#      /include libssh2rpg,&#'                      \
-            -e '}'
-}
-
-
-#       Create the IFS directory for the ILE/RPG header files.
-
-RPGIFSDIR="${IFSDIR}/include/libssh2rpg"
-
-if action_needed "${RPGIFSDIR}"
-then    mkdir -p "${RPGIFSDIR}"
-fi
-
-#       Copy the header files to IFS ILE/RPG include directory.
-#       Copy them with include path editing to the DB2 library.
-
-for HFILE in *.rpgle *.rpgle.in
-do      IFSCMD="cat \"${HFILE}\""
-        DB2CMD="change_include < \"${HFILE}\""
-        IFSFILE="`basename \"${HFILE}\" .in`"
-
-        case "${HFILE}" in
-
-        *.in)   IFSCMD="${IFSCMD} | versioned_copy"
-                DB2CMD="${DB2CMD} | versioned_copy"
-                ;;
-        esac
-
-        IFSDEST="${RPGIFSDIR}/${IFSFILE}"
-
-        if action_needed "${IFSDEST}" "${HFILE}"
-        then    eval "${IFSCMD}" > "${IFSDEST}"
-        fi
-
-        eval DB2MBR="\"\${VAR_`basename \"${IFSDEST}\" .rpgle`}\""
-        DB2DEST="${SRCPF}/${DB2MBR}.MBR"
-
-        if action_needed "${DB2DEST}" "${HFILE}"
-        then    eval "${DB2CMD}" | change_include > tmphdrfile
-
-                #       Need to translate to target CCSID.
-
-                CMD="CPY OBJ('`pwd`/tmphdrfile') TOOBJ('${DB2DEST}')"
-                CMD="${CMD} TOCCSID(${TGTCCSID}) DTAFMT(*TEXT) REPLACE(*YES)"
-                system "${CMD}"
-        fi
-done
diff --git a/libssh2/libssh2/os400/make-src.sh b/libssh2/libssh2/os400/make-src.sh
deleted file mode 100644
index 2e9a3c43..00000000
--- a/libssh2/libssh2/os400/make-src.sh
+++ /dev/null
@@ -1,208 +0,0 @@
-#!/bin/sh
-#
-#       libssh2 compilation script for the OS/400.
-#
-
-SCRIPTDIR=`dirname "${0}"`
-. "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/src"
-
-
-#       Function to extract external prototypes from header files.
-#       Input: concatenated header files.
-#       Output: external prototypes, one per (long) line.
-
-extproto()
-{
-        sed -e 'x;G;s/^\n//;s/\n/ /g'                                   \
-            -e 's#[[:space:]]*/\*[^*]*\(\*\([^/*][^*]*\)\{0,1\}\)*\*/[[:space:]]*##g' \
-            -e 'h'                                                      \
-            -e '/\/\*/!{'                                               \
-            -e '/^#/{s/^.*[^\\]$//;h;d'                                 \
-            -e '}'                                                      \
-            -e 's/[{}]/;/g;s/\\$//'                                     \
-            -e ':loop1'                                                 \
-            -e '/;/{'                                                   \
-            -e 's/^[^;]*;//;x;s/;.*//'                                  \
-            -e '/^[[:space:]]*LIBSSH2_API[[:space:]].*(/{'              \
-            -e 's/^[[:space:]]*LIBSSH2_API[[:space:]]*//'               \
-            -e 's/[[:space:]]*$//'                                      \
-            -e 's/[[:space:]][[:space:]]*/ /g'                          \
-            -e 'p'                                                      \
-            -e '}'                                                      \
-            -e 'g;bloop1'                                               \
-            -e '}'                                                      \
-            -e '}'                                                      \
-            -n
-}
-
-#       Need to have IFS access to the mih/modasa header file.
-
-if action_needed modasa.mih '/QSYS.LIB/QSYSINC.LIB/MIH.FILE/MODASA.MBR'
-then    rm -f modasa.mih
-        ln -s '/QSYS.LIB/QSYSINC.LIB/MIH.FILE/MODASA.MBR' modasa.mih
-fi
-
-
-#      Create and compile the identification source file.
-
-echo '#pragma comment(user, "libssh2 version '"${LIBSSH2_VERSION}"'")' > os400.c
-echo '#pragma comment(user, __DATE__)' >> os400.c
-echo '#pragma comment(user, __TIME__)' >> os400.c
-echo '#pragma comment(copyright, "See COPYING file. OS/400 version by P. Monnerat")' >> os400.c
-make_module     OS400           os400.c
-LINK=                           # No need to rebuild service program yet.
-MODULES=
-
-
-#       Generate the procedures implementing macros.
-
-if action_needed macros.c "${TOPDIR}/os400/macros.h"
-then    (
-                echo '#include "libssh2_publickey.h"'
-                echo '#include "libssh2_sftp.h"'
-                extproto < "${TOPDIR}/os400/macros.h"                   |
-                sed -e 'h;s/^[^(]*[ *]\([^ (]*\) *(.*/\1/'              \
-                    -e 's/.*/#pragma map(_&, "&")/;p'                   \
-                    -e 'g;s/^\([^(]*[ *]\)\([^ (]*\)\( *(.*\)/\1_\2\3 {/;p' \
-                    -e 'g;s/^[^(]*(\(.*\))$/,\1,/;s/[^A-Za-z0-9_,]/ /g' \
-                    -e 's/  *,/,/g;s/,[^,]* \([^ ,]*\)/,\1/g'           \
-                    -e 's/ //g;s/^,void,$/,,/'                          \
-                    -e 's/^,\(.*\),$/(\1); }/;s/,/, /g'                 \
-                    -e 'x;s/(.*//;s/ *$//;G;s/\n//g'                    \
-                    -e 's/^void\([ *]\)/\1/;s/^ *//'                    \
-                    -e 's/^[^(]*[ *]\([A-Za-z][A-Za-z0-9_]* *(\)/return \1/' \
-                    -e 's/.*/    &/'
-        ) > macros.c
-fi
-
-#       Get source list.
-
-cat ../Makefile.inc ../Makefile.os400qc3.inc                            |
-  sed -e ':begin'                                                       \
-    -e '/\\$/{'                                                         \
-    -e 's/\\$/ /'                                                       \
-    -e 'N'                                                              \
-    -e 'bbegin'                                                         \
-    -e '}'                                                              \
-    -e 's/\n//g'                                                        \
-    -e 's/[[:space:]]*$//'                                              \
-    -e 's/^\([A-Za-z][A-Za-z0-9_]*\)[[:space:]]*=[[:space:]]*\(.*\)/\1="\2"/' \
-    -e 's/\$(\([A-Za-z][A-Za-z0-9_]*\))/${\1}/g'                        \
-        > tmpscript.sh
-. ./tmpscript.sh
-
-
-#       Compile the sources into modules.
-
-INCLUDES="'`pwd`'"
-
-for SRC in "${TOPDIR}/os400/os400sys.c" "${TOPDIR}/os400/ccsid.c"       \
-           ${CSOURCES} ${CRYPTO_CSOURCES} macros.c
-do      MODULE=`db2_name "${SRC}"`
-        make_module "${MODULE}" "${SRC}"
-done
-
-
-#       If needed, (re)create the static binding directory.
-
-if action_needed "${LIBIFSNAME}/${STATBNDDIR}.BNDDIR"
-then    LINK=YES
-fi
-
-if [ "${LINK}" ]
-then    rm -rf "${LIBIFSNAME}/${STATBNDDIR}.BNDDIR"
-        CMD="CRTBNDDIR BNDDIR(${TARGETLIB}/${STATBNDDIR})"
-        CMD="${CMD} TEXT('libssh2 API static binding directory')"
-        system "${CMD}"
-
-        for MODULE in ${MODULES}
-        do      CMD="ADDBNDDIRE BNDDIR(${TARGETLIB}/${STATBNDDIR})"
-                CMD="${CMD} OBJ((${TARGETLIB}/${MODULE} *MODULE))"
-                system "${CMD}"
-        done
-
-#       V6R1M0 does not list system service program QC3PBEXT in the
-#       implicit binding directory: thus we add it here in ours.
-
-        CMD="ADDBNDDIRE BNDDIR(${TARGETLIB}/${STATBNDDIR})"
-        CMD="${CMD} OBJ((QSYS/QC3PBEXT *SRVPGM))"
-        system "${CMD}"
-fi
-
-
-#       The exportation file for service program creation must be in a DB2
-#               source file, so make sure it exists.
-
-if action_needed "${LIBIFSNAME}/TOOLS.FILE"
-then    CMD="CRTSRCPF FILE(${TARGETLIB}/TOOLS) RCDLEN(112)"
-        CMD="${CMD} TEXT('libssh2: build tools')"
-        system "${CMD}"
-fi
-
-
-#       Gather the list of symbols to export.
-
-EXPORTS=`cat "${TOPDIR}"/include/*.h "${TOPDIR}/os400/macros.h"         \
-             "${TOPDIR}/os400/libssh2_ccsid.h"                          |
-         extproto                                                       |
-         sed -e 's/(.*//;s/[^A-Za-z0-9_]/ /g;s/ *$//;s/^.* //'`
-
-#       Create the service program exportation file in DB2 member if needed.
-
-BSF="${LIBIFSNAME}/TOOLS.FILE/BNDSRC.MBR"
-
-if action_needed "${BSF}" Makefile.am
-then    LINK=YES
-fi
-
-if [ "${LINK}" ]
-then    echo " STRPGMEXP PGMLVL(*CURRENT) SIGNATURE('LIBSSH2_${SONAME}')" \
-            > "${BSF}"
-        for EXPORT in ${EXPORTS}
-        do      echo ' EXPORT    SYMBOL("'"${EXPORT}"'")' >> "${BSF}"
-        done
-
-        echo ' ENDPGMEXP' >> "${BSF}"
-fi
-
-
-#       Build the service program if needed.
-
-if action_needed "${LIBIFSNAME}/${SRVPGM}.SRVPGM"
-then    LINK=YES
-fi
-
-if [ "${LINK}" ]
-then    CMD="CRTSRVPGM SRVPGM(${TARGETLIB}/${SRVPGM})"
-        CMD="${CMD} SRCFILE(${TARGETLIB}/TOOLS) SRCMBR(BNDSRC)"
-        CMD="${CMD} MODULE(${TARGETLIB}/OS400)"
-        CMD="${CMD} BNDDIR(${TARGETLIB}/${STATBNDDIR}"
-        if [ "${WITH_ZLIB}" != 0 ]
-        then    CMD="${CMD} ${ZLIB_LIB}/${ZLIB_BNDDIR}"
-                liblist -a "${ZLIB_LIB}"
-        fi
-        CMD="${CMD})"
-        CMD="${CMD} BNDSRVPGM(QADRTTS)"
-        CMD="${CMD} TEXT('libssh2 API library')"
-        CMD="${CMD} TGTRLS(${TGTRLS})"
-        system "${CMD}"
-        LINK=YES
-fi
-
-
-#       If needed, (re)create the dynamic binding directory.
-
-if action_needed "${LIBIFSNAME}/${DYNBNDDIR}.BNDDIR"
-then    LINK=YES
-fi
-
-if [ "${LINK}" ]
-then    rm -rf "${LIBIFSNAME}/${DYNBNDDIR}.BNDDIR"
-        CMD="CRTBNDDIR BNDDIR(${TARGETLIB}/${DYNBNDDIR})"
-        CMD="${CMD} TEXT('libssh2 API dynamic binding directory')"
-        system "${CMD}"
-        CMD="ADDBNDDIRE BNDDIR(${TARGETLIB}/${DYNBNDDIR})"
-        CMD="${CMD} OBJ((*LIBL/${SRVPGM} *SRVPGM))"
-        system "${CMD}"
-fi
diff --git a/libssh2/libssh2/os400/make.sh b/libssh2/libssh2/os400/make.sh
deleted file mode 100644
index 0c9e3dec..00000000
--- a/libssh2/libssh2/os400/make.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/bin/sh
-#
-#       libssh2 compilation script for the OS/400.
-#
-#
-#       This is a shell script since make is not a standard component of OS/400.
-
-SCRIPTDIR=`dirname "${0}"`
-. "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}"
-
-
-#       Create the OS/400 library if it does not exist.
-
-if action_needed "${LIBIFSNAME}"
-then    CMD="CRTLIB LIB(${TARGETLIB}) TEXT('libssh2: SSH2 protocol API')"
-        system "${CMD}"
-fi
-
-
-#       Create the DOCS source file if it does not exist.
-
-if action_needed "${LIBIFSNAME}/DOCS.FILE"
-then    CMD="CRTSRCPF FILE(${TARGETLIB}/DOCS) RCDLEN(240)"
-        CMD="${CMD} CCSID(${TGTCCSID}) TEXT('Documentation texts')"
-        system "${CMD}"
-fi
-
-
-#       Copy some documentation files if needed.
-
-for TEXT in "${TOPDIR}/COPYING" "${SCRIPTDIR}/README400"                \
-    "${TOPDIR}/NEWS" "${TOPDIR}/README" "${TOPDIR}/docs/AUTHORS"        \
-    "${TOPDIR}/docs/BINDINGS"
-do      MEMBER="${LIBIFSNAME}/DOCS.FILE/`db2_name \"${TEXT}\"`.MBR"
-
-        if action_needed "${MEMBER}" "${TEXT}"
-        then    CMD="CPY OBJ('${TEXT}') TOOBJ('${MEMBER}') TOCCSID(${TGTCCSID})"
-                CMD="${CMD} DTAFMT(*TEXT) REPLACE(*YES)"
-                system "${CMD}"
-        fi
-done
-
-
-#       Build in each directory.
-
-for SUBDIR in include rpg src
-do      "${SCRIPTDIR}/make-${SUBDIR}.sh"
-done
diff --git a/libssh2/libssh2/os400/os400sys.c b/libssh2/libssh2/os400/os400sys.c
deleted file mode 100644
index db67876b..00000000
--- a/libssh2/libssh2/os400/os400sys.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* OS/400 additional support. */
-
-#define LIBSSH2_DISABLE_QADRT_EXT
-
-#include "libssh2_priv.h"
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdarg.h>
-#include <string.h>
-#include <alloca.h>
-#include <netdb.h>
-#include <qadrt.h>
-#include <errno.h>
-
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#ifdef LIBSSH2_HAVE_ZLIB
-# include <zlib.h>
-#endif
-
-
-/**
-***     QADRT OS/400 ASCII runtime defines only the most used procedures, but
-***             a lot of them are not supported. This module implements
-***             ASCII wrappers for those that are used by libssh2, but not
-***             defined by QADRT.
-**/
-
-#pragma convert(37)                             /* Restore EBCDIC. */
-
-
-static int
-convert_sockaddr(struct sockaddr_storage * dstaddr,
-                                const struct sockaddr * srcaddr, int srclen)
-
-{
-  const struct sockaddr_un * srcu;
-  struct sockaddr_un * dstu;
-  unsigned int i;
-  unsigned int dstsize;
-
-  /* Convert a socket address into job CCSID, if needed. */
-
-  if(!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
-     sizeof srcaddr->sa_family || srclen > sizeof *dstaddr) {
-    errno = EINVAL;
-    return -1;
-    }
-
-  memcpy((char *) dstaddr, (char *) srcaddr, srclen);
-
-  switch (srcaddr->sa_family) {
-
-  case AF_UNIX:
-    srcu = (const struct sockaddr_un *) srcaddr;
-    dstu = (struct sockaddr_un *) dstaddr;
-    dstsize = sizeof *dstaddr - offsetof(struct sockaddr_un, sun_path);
-    srclen -= offsetof(struct sockaddr_un, sun_path);
-    i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path, dstsize - 1, srclen);
-    dstu->sun_path[i] = '\0';
-    i += offsetof(struct sockaddr_un, sun_path);
-    srclen = i;
-    }
-
-  return srclen;
-}
-
-
-int
-_libssh2_os400_connect(int sd, struct sockaddr * destaddr, int addrlen)
-
-{
-  int i;
-  struct sockaddr_storage laddr;
-
-  i = convert_sockaddr(&laddr, destaddr, addrlen);
-
-  if(i < 0)
-    return -1;
-
-  return connect(sd, (struct sockaddr *) &laddr, i);
-}
-
-
-int
-_libssh2_os400_vsnprintf(char *dst, size_t len, const char *fmt, va_list args)
-{
-    size_t l = 4096;
-    int i;
-    char *buf;
-
-    if (!dst || !len) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    if (l < len)
-        l = len;
-
-    buf = alloca(l);
-
-    if (!buf) {
-        errno = ENOMEM;
-        return -1;
-    }
-
-    i = vsprintf(buf, fmt, args);
-
-    if (i < 0)
-        return i;
-
-    if (--len > i)
-        len = i;
-
-    if (len)
-        memcpy(dst, buf, len);
-
-    dst[len] = '\0';
-    return len;
-}
-
-/* VARARGS3 */
-int
-_libssh2_os400_snprintf(char *dst, size_t len, const char *fmt, ...)
-{
-    va_list args;
-    int ret;
-
-    va_start(args, fmt);
-    ret = _libssh2_os400_vsnprintf(dst, len, fmt, args);
-    va_end(args);
-    return ret;
-}
-
-
-#ifdef LIBSSH2_HAVE_ZLIB
-int
-_libssh2_os400_inflateInit_(z_streamp strm,
-                            const char *version, int stream_size)
-{
-    char *ebcversion;
-    int i;
-
-    if (!version)
-        return Z_VERSION_ERROR;
-    i = strlen(version);
-    ebcversion = alloca(i + 1);
-    if (!ebcversion)
-        return Z_VERSION_ERROR;
-    i = QadrtConvertA2E(ebcversion, version, i, i - 1);
-    ebcversion[i] = '\0';
-    return inflateInit_(strm, ebcversion, stream_size);
-}
-
-int
-_libssh2_os400_deflateInit_(z_streamp strm, int level,
-                            const char *version, int stream_size)
-{
-    char *ebcversion;
-    int i;
-
-    if (!version)
-        return Z_VERSION_ERROR;
-    i = strlen(version);
-    ebcversion = alloca(i + 1);
-    if (!ebcversion)
-        return Z_VERSION_ERROR;
-    i = QadrtConvertA2E(ebcversion, version, i, i - 1);
-    ebcversion[i] = '\0';
-    return deflateInit_(strm, level, ebcversion, stream_size);
-}
-
-#endif
diff --git a/libssh2/libssh2/src/CMakeLists.txt b/libssh2/libssh2/src/CMakeLists.txt
deleted file mode 100644
index eee1a80d..00000000
--- a/libssh2/libssh2/src/CMakeLists.txt
+++ /dev/null
@@ -1,433 +0,0 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-include(CheckFunctionExists)
-include(CheckSymbolExists)
-include(CheckFunctionExistsMayNeedLibrary)
-include(CheckIncludeFiles)
-include(CheckTypeSize)
-include(CheckSymbolExists)
-include(CheckNonblockingSocketSupport)
-include(SocketLibraries)
-
-## Cryptography backend choice
-
-set(CRYPTO_BACKEND
-  ""
-  CACHE
-  STRING
-  "The backend to use for cryptography: OpenSSL, Libgcrypt or WinCNG, mbedTLS
-or empty to try any available")
-
-# If the crypto backend was given, rather than searching for the first
-# we are able to find, the find_package commands must abort configuration
-# and report to the user.
-if(CRYPTO_BACKEND)
-  set(SPECIFIC_CRYPTO_REQUIREMENT REQUIRED)
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "OpenSSL" OR NOT CRYPTO_BACKEND)
-
-  find_package(OpenSSL ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(OPENSSL_FOUND)
-    set(CRYPTO_BACKEND "OpenSSL")
-    set(CRYPTO_SOURCES openssl.c openssl.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_OPENSSL)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${OPENSSL_INCLUDE_DIR})
-    list(APPEND LIBRARIES ${OPENSSL_LIBRARIES})
-    list(APPEND PC_REQUIRES_PRIVATE libssl libcrypto)
-
-    if (WIN32)
-      # Statically linking to OpenSSL requires crypt32 for some Windows APIs.
-      # This should really be handled by FindOpenSSL.cmake.
-      list(APPEND LIBRARIES crypt32)
-      list(APPEND PC_LIBS -lcrypt32)
-
-      find_file(DLL_LIBEAY32
-        NAMES libeay32.dll crypto.dll libcrypto-1_1.dll libcrypto-1_1-x64.dll
-        HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS}
-        PATH_SUFFIXES bin)
-      if (NOT DLL_LIBEAY32)
-        message(WARNING
-          "Unable to find OpenSSL crypto (aka libeay32) DLL, executables may not run")
-      endif()
-
-      find_file(DLL_SSLEAY32
-        NAMES ssleay32.dll ssl.dll libssl-1_1.dll libssl-1_1-x64.dll
-        HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS}
-        PATH_SUFFIXES bin)
-      if (NOT DLL_SSLEAY32)
-        message(WARNING
-          "Unable to find OpenSSL ssl (aka ssleay32) DLL, executables may not run")
-      endif()
-
-      if(DLL_LIBEAY32 AND DLL_SSLEAY32)
-        list(APPEND _RUNTIME_DEPENDENCIES ${DLL_LIBEAY32} ${DLL_SSLEAY32})
-      endif()
-    endif()
-
-    # Not all OpenSSL have AES-CTR functions.
-    set(SAVE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
-    check_function_exists(EVP_aes_128_ctr HAVE_EVP_AES_128_CTR)
-    set(CMAKE_REQUIRED_LIBRARIES ${SAVE_CMAKE_REQUIRED_LIBRARIES})
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "Libgcrypt" OR NOT CRYPTO_BACKEND)
-
-  find_package(Libgcrypt ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(LIBGCRYPT_FOUND)
-    set(CRYPTO_BACKEND "Libgcrypt")
-    set(CRYPTO_SOURCES libgcrypt.c libgcrypt.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_LIBGCRYPT)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${LIBGCRYPT_INCLUDE_DIRS})
-    list(APPEND LIBRARIES ${LIBGCRYPT_LIBRARIES})
-    list(APPEND PC_LIBS -lgcrypt)
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "WinCNG" OR NOT CRYPTO_BACKEND)
-
-  # The check actually compiles the header.  This requires windows.h.
-  check_include_files("windows.h;bcrypt.h" HAVE_BCRYPT_H)
-
-  if(HAVE_BCRYPT_H)
-    set(CRYPTO_BACKEND "WinCNG")
-    set(CRYPTO_SOURCES wincng.c wincng.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_WINCNG)
-
-    set(HAVE_LIBCRYPT32 TRUE)
-    list(APPEND LIBRARIES bcrypt)
-    list(APPEND PC_LIBS -lbcrypt)
-
-    check_include_files(ntdef.h HAVE_NTDEF_H)
-    check_include_files(ntstatus.h HAVE_NTSTATUS_H)
-
-    # Reading keys from files is optional and depends on Wincrypt
-    check_include_files("windows.h;wincrypt.h" HAVE_WINCRYPT_H)
-
-    if(HAVE_WINCRYPT_H)
-      list(APPEND LIBRARIES crypt32)
-      list(APPEND PC_LIBS -lcrypt32)
-    endif()
-
-  elseif(${SPECIFIC_CRYPTO_REQUIREMENT} STREQUAL ${REQUIRED})
-    message(FATAL_ERROR "WinCNG not available")
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "mbedTLS" OR NOT CRYPTO_BACKEND)
-
-  find_package(mbedTLS ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(MBEDTLS_FOUND)
-    set(CRYPTO_BACKEND "mbedTLS")
-    set(CRYPTO_SOURCES mbedtls.c mbedtls.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_MBEDTLS)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${MBEDTLS_INCLUDE_DIR})
-    list(APPEND LIBRARIES ${MBEDTLS_LIBRARIES})
-    list(APPEND PC_LIBS -lmbedcrypto)
-    link_directories(${MBEDTLS_LIBRARY_DIR})
-  endif()
-endif()
-
-if(NOT CRYPTO_BACKEND)
-  message(FATAL_ERROR "No suitable cryptography backend found.")
-endif()
-
-## Library definition
-
-include(GNUInstallDirs)
-set(SOURCES
-  ${CRYPTO_SOURCES}
-  agent.c
-  agent_win.c
-  blf.h
-  bcrypt_pbkdf.c
-  blowfish.c
-  channel.c
-  channel.h
-  comp.c
-  comp.h
-  crypt.c
-  crypto.h
-  global.c
-  hostkey.c
-  keepalive.c
-  kex.c
-  knownhost.c
-  libssh2_priv.h
-  mac.c
-  mac.h
-  misc.c
-  misc.h
-  packet.c
-  packet.h
-  pem.c
-  publickey.c
-  scp.c
-  session.c
-  session.h
-  sftp.c
-  sftp.h
-  transport.c
-  transport.h
-  userauth.c
-  userauth.h
-  version.c)
-
-if(WIN32)
-  list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/win32/libssh2.rc)
-endif()
-
-add_library(libssh2 ${SOURCES})
-# we want it to be called libssh2 on all platforms
-set_target_properties(libssh2 PROPERTIES PREFIX "")
-
-target_compile_definitions(libssh2 PRIVATE ${PRIVATE_COMPILE_DEFINITIONS})
-target_include_directories(libssh2
-  PRIVATE "${PROJECT_SOURCE_DIR}/include/" ${PRIVATE_INCLUDE_DIRECTORIES}
-  PUBLIC
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>)
-
-## Options
-
-option(CLEAR_MEMORY "Enable clearing of memory before being freed" ON)
-if(CLEAR_MEMORY)
-    add_definitions(-DLIBSSH2_CLEAR_MEMORY)
-endif(CLEAR_MEMORY)
-
-add_feature_info("Shared library" BUILD_SHARED_LIBS
-  "creating libssh2 as a shared library (.so/.dll)")
-
-option(ENABLE_ZLIB_COMPRESSION "Use zlib for compression")
-add_feature_info(Compression ENABLE_ZLIB_COMPRESSION
-  "using zlib for compression")
-if(ENABLE_ZLIB_COMPRESSION)
-  find_package(ZLIB REQUIRED)
-
-  target_include_directories(libssh2 PRIVATE ${ZLIB_INCLUDE_DIRS})
-  list(APPEND LIBRARIES ${ZLIB_LIBRARIES})
-  list(APPEND PC_REQUIRES_PRIVATE zlib)
-  if(ZLIB_FOUND)
-    target_compile_definitions(libssh2 PRIVATE LIBSSH2_HAVE_ZLIB=1)
-  endif()
-endif()
-
-option(ENABLE_CRYPT_NONE "Permit \"none\" cipher -- NOT RECOMMENDED")
-add_feature_info("\"none\" cipher" ENABLE_CRYPT_NONE "")
-if(ENABLE_CRYPT_NONE)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_CRYPT_NONE=1)
-endif()
-
-option(ENABLE_MAC_NONE "Permit \"none\" MAC -- NOT RECOMMMENDED")
-add_feature_info("\"none\" MAC" ENABLE_MAC_NONE "")
-if(ENABLE_MAC_NONE)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_MAC_NONE=1)
-endif()
-
-option(ENABLE_GEX_NEW
-  "Enable diffie-hellman-group-exchange-sha1 method" ON)
-add_feature_info("diffie-hellman-group-exchange-sha1" ENABLE_GEX_NEW
-  "\"new\" diffie-hellman-group-exchange-sha1 method")
-if(ENABLE_GEX_NEW)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_DH_GEX_NEW=1)
-endif()
-
-# Enable debugging logging by default if the user configured a debug build
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-  set(DEBUG_LOGGING_DEFAULT ON)
-else()
-  set(DEBUG_LOGGING_DEFAULT OFF)
-endif()
-option(ENABLE_DEBUG_LOGGING "log execution with debug trace"
-  ${DEBUG_LOGGING_DEFAULT})
-add_feature_info(Logging ENABLE_DEBUG_LOGGING
-   "Logging of execution with debug trace")
-if(ENABLE_DEBUG_LOGGING)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2DEBUG)
-endif()
-
-## Platform checks
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(stdlib.h HAVE_STDLIB_H)
-check_include_files(sys/select.h HAVE_SYS_SELECT_H)
-
-check_include_files(sys/uio.h HAVE_SYS_UIO_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(sys/ioctl.h HAVE_SYS_IOCTL_H)
-check_include_files(sys/time.h HAVE_SYS_TIME_H)
-check_include_files(sys/un.h HAVE_SYS_UN_H)
-check_include_files(windows.h HAVE_WINDOWS_H)
-check_include_files(ws2tcpip.h HAVE_WS2TCPIP_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-
-check_type_size("long long" LONGLONG)
-
-if(HAVE_SYS_TIME_H)
-  check_symbol_exists(gettimeofday sys/time.h HAVE_GETTIMEOFDAY)
-else()
-  check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-endif()
-if(HAVE_STDLIB_H)
-  check_symbol_exists(strtoll stdlib.h HAVE_STRTOLL)
-else()
-  check_function_exists(strtoll HAVE_STRTOLL)
-endif()
-if (NOT HAVE_STRTOLL)
-  # Try _strtoi64 if strtoll isn't available
-  check_symbol_exists(_strtoi64 stdlib.h HAVE_STRTOI64)
-endif()
-check_symbol_exists(snprintf stdio.h HAVE_SNPRINTF)
-check_symbol_exists(memset_s string.h HAVE_MEMSET_S)
-
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" OR
-   ${CMAKE_SYSTEM_NAME} STREQUAL "Interix")
-  # poll() does not work on these platforms
-  #
-  # Interix: "does provide poll(), but the implementing developer must
-  # have been in a bad mood, because poll() only works on the /proc
-  # filesystem here"
-  #
-  # Mac OS X's poll has funny behaviors, like:
-  # not being able to do poll on no filedescriptors (10.3?)
-  # not being able to poll on some files (like anything in /dev)
-  # not having reliable timeout support
-  # inconsistent return of POLLHUP where other implementations give POLLIN
-  message("poll use is disabled on this platform")
-else()
-  check_function_exists(poll HAVE_POLL)
-endif()
-
-append_needed_socket_libraries(LIBRARIES)
-
-# Non-blocking socket support tests.  Must be after library tests to
-# link correctly
-set(SAVE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-set(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})
-check_nonblocking_socket_support()
-set(CMAKE_REQUIRED_LIBRARIES ${SAVE_CMAKE_REQUIRED_LIBRARIES})
-
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h)
-# to find generated header
-target_include_directories(libssh2 PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-
-# Check for the OS.
-# Daniel's note: this should not be necessary and we need to work to
-# get this removed.
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_WIN32)
-elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_DARWIN)
-endif()
-
-if(MSVC)
-  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Zi /Od")
-  set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /DEBUG")
-endif()
-
-if(CMAKE_VERSION VERSION_LESS "2.8.12")
-  # Fall back to over-linking dependencies
-  target_link_libraries(libssh2 ${LIBRARIES})
-else()
-  target_link_libraries(libssh2 PRIVATE ${LIBRARIES})
-endif()
-
-## Installation
-
-install(FILES
-  ${PROJECT_SOURCE_DIR}/include/libssh2.h
-  ${PROJECT_SOURCE_DIR}/include/libssh2_publickey.h
-  ${PROJECT_SOURCE_DIR}/include/libssh2_sftp.h
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-install(TARGETS libssh2
-  EXPORT Libssh2Config
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-if(BUILD_SHARED_LIBS)
-  list(APPEND _RUNTIME_DEPENDENCIES $<TARGET_FILE:libssh2>)
-endif()
-
-set(RUNTIME_DEPENDENCIES ${_RUNTIME_DEPENDENCIES} CACHE INTERNAL
-    "Files that must be in the same directory as the executables at runtime.")
-
-# Package config
-
-## During package installation, install Libssh2Config.cmake
-install(EXPORT Libssh2Config
-  NAMESPACE Libssh2::
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libssh2)
-
-## During build, register directly from build tree
-# create Libssh2Config.cmake
-export(TARGETS libssh2 NAMESPACE Libssh2:: FILE Libssh2Config.cmake)
-export(PACKAGE Libssh2) # register it
-
-## Export a .pc file for client projects not using CMaek
-if(PC_REQUIRES_PRIVATE)
-  string(REPLACE ";" "," PC_REQUIRES_PRIVATE "${PC_REQUIRES_PRIVATE}")
-endif()
-if(PC_LIBS)
-  string(REPLACE ";" " " PC_LIBS "${PC_LIBS}")
-endif()
-configure_file(libssh2.pc.in libssh2.pc @ONLY)
-install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/libssh2.pc
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-
-## Versioning
-
-set_target_properties(libssh2 PROPERTIES
-  SOVERSION 1
-  VERSION 1.0.1)
-
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/Libssh2ConfigVersion.cmake
-  VERSION "${LIBSSH2_VERSION_MAJOR}.${LIBSSH2_VERSION_MINOR}.${LIBSSH2_VERSION_PATCH}"
-  COMPATIBILITY SameMajorVersion)
-install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/Libssh2ConfigVersion.cmake
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libssh2)
diff --git a/libssh2/libssh2/src/Makefile.am b/libssh2/libssh2/src/Makefile.am
deleted file mode 100644
index 31d58ed5..00000000
--- a/libssh2/libssh2/src/Makefile.am
+++ /dev/null
@@ -1,65 +0,0 @@
-# $Id: Makefile.am,v 1.21 2009/05/07 17:21:56 bagder Exp $
-AUTOMAKE_OPTIONS = foreign nostdinc
-
-# Get the CRYPTO_CSOURCES, CRYPTO_HHEADERS and CRYPTO_LTLIBS defines
-if OPENSSL
-include ../Makefile.OpenSSL.inc
-endif
-if LIBGCRYPT
-include ../Makefile.libgcrypt.inc
-endif
-if WINCNG
-include ../Makefile.WinCNG.inc
-endif
-if MBEDTLS
-include ../Makefile.mbedTLS.inc
-endif
-
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-include ../Makefile.inc
-
-libssh2_la_SOURCES = $(CSOURCES) $(HHEADERS)
-
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in libssh2.pc.in
-EXTRA_DIST += CMakeLists.txt NMakefile
-
-lib_LTLIBRARIES = libssh2.la
-
-# srcdir/include for the shipped headers
-# builddir/src for the generated config header when building out of the source
-# tree
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/src
-
-VERSION=-version-info 1:1:0
-
-# This flag accepts an argument of the form current[:revision[:age]]. So,
-# passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
-# 1.
-#
-# If either revision or age are omitted, they default to 0. Also note that age
-# must be less than or equal to the current interface number.
-#
-# Here are a set of rules to help you update your library version information:
-#
-# 1.Start with version information of 0:0:0 for each libtool library.
-#
-# 2.Update the version information only immediately before a public release of
-# your software. More frequent updates are unnecessary, and only guarantee
-# that the current interface number gets larger faster.
-#
-# 3.If the library source code has changed at all since the last update, then
-# increment revision (c:r+1:a)
-#
-# 4.If any interfaces have been added, removed, or changed since the last
-# update, increment current, and set revision to 0. (c+1:r=0:a)
-#
-# 5.If any interfaces have been added since the last public release, then
-# increment age. (c:r:a+1)
-#
-# 6.If any interfaces have been removed since the last public release, then
-# set age to 0. (c:r:a=0)
-#
-
-libssh2_la_LDFLAGS = $(VERSION) -no-undefined \
-	-export-symbols-regex '^libssh2_.*' \
-	$(CRYPTO_LTLIBS) $(LTLIBZ)
diff --git a/libssh2/libssh2/src/NMakefile b/libssh2/libssh2/src/NMakefile
deleted file mode 100644
index 0c4853f1..00000000
--- a/libssh2/libssh2/src/NMakefile
+++ /dev/null
@@ -1,30 +0,0 @@
-!include "win32/config.mk"
-
-!include "win32/objects.mk"
-
-CFLAGS=$(CFLAGS)
-
-AR = lib
-ARFLAGS = -nologo /LTCG
-
-RESOURCE=$(INTDIR)\libssh2.res
-DLL=libssh2$(SUFFIX).dll
-STATICLIB=$(INTDIR)\libssh2.lib
-
-!if "$(BUILD_STATIC_LIB)" == ""
-all: $(DLL)
-!else
-all: $(STATICLIB)
-!endif
-
-$(DLL): $(OBJECTS) $(RESOURCE)
-	$(CC) -o $(DLL) $(DLLFLAGS) $(OBJECTS) $(RESOURCE) $(LIBS)
-
-$(STATICLIB): $(OBJECTS)
-	$(AR) $(ARFLAGS) -out:$@ $(OBJECTS)
-
-$(RESOURCE): win32\libssh2.rc
-	$(RC) $(RCFLAGS) /Fo"$@" $?
-
-!include "win32/rules.mk"
-
diff --git a/libssh2/libssh2/src/agent.c b/libssh2/libssh2/src/agent.c
deleted file mode 100644
index 85c3e34a..00000000
--- a/libssh2/libssh2/src/agent.c
+++ /dev/null
@@ -1,857 +0,0 @@
-/*
- * Copyright (c) 2009 by Daiki Ueno
- * Copyright (C) 2010-2014 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "agent.h"
-#include "misc.h"
-#include <errno.h>
-#ifdef HAVE_SYS_UN_H
-#include <sys/un.h>
-#else
-/* Use the existence of sys/un.h as a test if Unix domain socket is
-   supported.  winsock*.h define PF_UNIX/AF_UNIX but do not actually
-   support them. */
-#undef PF_UNIX
-#endif
-#include "userauth.h"
-#include "session.h"
-#ifdef WIN32
-#include <stdlib.h>
-#endif
-
-/* Requests from client to agent for protocol 1 key operations */
-#define SSH_AGENTC_REQUEST_RSA_IDENTITIES 1
-#define SSH_AGENTC_RSA_CHALLENGE 3
-#define SSH_AGENTC_ADD_RSA_IDENTITY 7
-#define SSH_AGENTC_REMOVE_RSA_IDENTITY 8
-#define SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES 9
-#define SSH_AGENTC_ADD_RSA_ID_CONSTRAINED 24
-
-/* Requests from client to agent for protocol 2 key operations */
-#define SSH2_AGENTC_REQUEST_IDENTITIES 11
-#define SSH2_AGENTC_SIGN_REQUEST 13
-#define SSH2_AGENTC_ADD_IDENTITY 17
-#define SSH2_AGENTC_REMOVE_IDENTITY 18
-#define SSH2_AGENTC_REMOVE_ALL_IDENTITIES 19
-#define SSH2_AGENTC_ADD_ID_CONSTRAINED 25
-
-/* Key-type independent requests from client to agent */
-#define SSH_AGENTC_ADD_SMARTCARD_KEY 20
-#define SSH_AGENTC_REMOVE_SMARTCARD_KEY 21
-#define SSH_AGENTC_LOCK 22
-#define SSH_AGENTC_UNLOCK 23
-#define SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED 26
-
-/* Generic replies from agent to client */
-#define SSH_AGENT_FAILURE 5
-#define SSH_AGENT_SUCCESS 6
-
-/* Replies from agent to client for protocol 1 key operations */
-#define SSH_AGENT_RSA_IDENTITIES_ANSWER 2
-#define SSH_AGENT_RSA_RESPONSE 4
-
-/* Replies from agent to client for protocol 2 key operations */
-#define SSH2_AGENT_IDENTITIES_ANSWER 12
-#define SSH2_AGENT_SIGN_RESPONSE 14
-
-/* Key constraint identifiers */
-#define SSH_AGENT_CONSTRAIN_LIFETIME 1
-#define SSH_AGENT_CONSTRAIN_CONFIRM 2
-
-#ifdef PF_UNIX
-static int
-agent_connect_unix(LIBSSH2_AGENT *agent)
-{
-    const char *path;
-    struct sockaddr_un s_un;
-
-    path = agent->identity_agent_path;
-    if(!path) {
-        path = getenv("SSH_AUTH_SOCK");
-        if(!path)
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
-                                  "no auth sock variable");
-    }
-
-    agent->fd = socket(PF_UNIX, SOCK_STREAM, 0);
-    if(agent->fd < 0)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_SOCKET,
-                              "failed creating socket");
-
-    s_un.sun_family = AF_UNIX;
-    strncpy(s_un.sun_path, path, sizeof s_un.sun_path);
-    s_un.sun_path[sizeof(s_un.sun_path)-1] = 0; /* make sure there's a trailing
-                                                   zero */
-    if(connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
-        close(agent->fd);
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                              "failed connecting with agent");
-    }
-
-    return LIBSSH2_ERROR_NONE;
-}
-
-#define RECV_SEND_ALL(func, socket, buffer, length, flags, abstract) \
-    int rc;                                                          \
-    size_t finished = 0;                                             \
-                                                                     \
-    while(finished < length) {                                       \
-        rc = func(socket,                                            \
-                  (char *)buffer + finished, length - finished,      \
-                  flags, abstract);                                  \
-        if(rc < 0)                                                   \
-            return rc;                                               \
-                                                                     \
-        finished += rc;                                              \
-    }                                                                \
-                                                                     \
-    return finished;
-
-static ssize_t _send_all(LIBSSH2_SEND_FUNC(func), libssh2_socket_t socket,
-                         const void *buffer, size_t length,
-                         int flags, void **abstract)
-{
-    RECV_SEND_ALL(func, socket, buffer, length, flags, abstract);
-}
-
-static ssize_t _recv_all(LIBSSH2_RECV_FUNC(func), libssh2_socket_t socket,
-                         void *buffer, size_t length,
-                         int flags, void **abstract)
-{
-    RECV_SEND_ALL(func, socket, buffer, length, flags, abstract);
-}
-
-#undef RECV_SEND_ALL
-
-static int
-agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
-{
-    unsigned char buf[4];
-    int rc;
-
-    /* Send the length of the request */
-    if(transctx->state == agent_NB_state_request_created) {
-        _libssh2_htonu32(buf, transctx->request_len);
-        rc = _send_all(agent->session->send, agent->fd,
-                       buf, sizeof buf, 0, &agent->session->abstract);
-        if(rc == -EAGAIN)
-            return LIBSSH2_ERROR_EAGAIN;
-        else if(rc < 0)
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "agent send failed");
-        transctx->state = agent_NB_state_request_length_sent;
-    }
-
-    /* Send the request body */
-    if(transctx->state == agent_NB_state_request_length_sent) {
-        rc = _send_all(agent->session->send, agent->fd, transctx->request,
-                       transctx->request_len, 0, &agent->session->abstract);
-        if(rc == -EAGAIN)
-            return LIBSSH2_ERROR_EAGAIN;
-        else if(rc < 0)
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "agent send failed");
-        transctx->state = agent_NB_state_request_sent;
-    }
-
-    /* Receive the length of a response */
-    if(transctx->state == agent_NB_state_request_sent) {
-        rc = _recv_all(agent->session->recv, agent->fd,
-                       buf, sizeof buf, 0, &agent->session->abstract);
-        if(rc < 0) {
-            if(rc == -EAGAIN)
-                return LIBSSH2_ERROR_EAGAIN;
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_RECV,
-                                  "agent recv failed");
-        }
-        transctx->response_len = _libssh2_ntohu32(buf);
-        transctx->response = LIBSSH2_ALLOC(agent->session,
-                                           transctx->response_len);
-        if(!transctx->response)
-            return LIBSSH2_ERROR_ALLOC;
-
-        transctx->state = agent_NB_state_response_length_received;
-    }
-
-    /* Receive the response body */
-    if(transctx->state == agent_NB_state_response_length_received) {
-        rc = _recv_all(agent->session->recv, agent->fd, transctx->response,
-                       transctx->response_len, 0, &agent->session->abstract);
-        if(rc < 0) {
-            if(rc == -EAGAIN)
-                return LIBSSH2_ERROR_EAGAIN;
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "agent recv failed");
-        }
-        transctx->state = agent_NB_state_response_received;
-    }
-
-    return 0;
-}
-
-static int
-agent_disconnect_unix(LIBSSH2_AGENT *agent)
-{
-    int ret;
-    ret = close(agent->fd);
-    if(ret != -1)
-        agent->fd = LIBSSH2_INVALID_SOCKET;
-    else
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
-                              "failed closing the agent socket");
-    return LIBSSH2_ERROR_NONE;
-}
-
-struct agent_ops agent_ops_unix = {
-    agent_connect_unix,
-    agent_transact_unix,
-    agent_disconnect_unix
-};
-#endif  /* PF_UNIX */
-
-#ifdef WIN32
-/* Code to talk to Pageant was taken from PuTTY.
- *
- * Portions copyright Robert de Bath, Joris van Rantwijk, Delian
- * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas
- * Barry, Justin Bradford, Ben Harris, Malcolm Smith, Ahmad Khalifa,
- * Markus Kuhn, Colin Watson, and CORE SDI S.A.
- */
-#define PAGEANT_COPYDATA_ID 0x804e50ba   /* random goop */
-#define PAGEANT_MAX_MSGLEN  8192
-
-static int
-agent_connect_pageant(LIBSSH2_AGENT *agent)
-{
-    HWND hwnd;
-    hwnd = FindWindowA("Pageant", "Pageant");
-    if(!hwnd)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                              "failed connecting agent");
-    agent->fd = 0;         /* Mark as the connection has been established */
-    return LIBSSH2_ERROR_NONE;
-}
-
-static int
-agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
-{
-    HWND hwnd;
-    char mapname[23];
-    HANDLE filemap;
-    unsigned char *p;
-    unsigned char *p2;
-    int id;
-    COPYDATASTRUCT cds;
-
-    if(!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_INVAL,
-                              "illegal input");
-
-    hwnd = FindWindowA("Pageant", "Pageant");
-    if(!hwnd)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                              "found no pageant");
-
-    snprintf(mapname, sizeof(mapname),
-             "PageantRequest%08x%c", (unsigned)GetCurrentThreadId(), '\0');
-    filemap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
-                                 0, PAGEANT_MAX_MSGLEN, mapname);
-
-    if(filemap == NULL || filemap == INVALID_HANDLE_VALUE)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                              "failed setting up pageant filemap");
-
-    p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
-    if(p == NULL || p2 == NULL) {
-        CloseHandle(filemap);
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                              "failed to open pageant filemap for writing");
-    }
-
-    _libssh2_store_str(&p2, (const char *)transctx->request,
-                       transctx->request_len);
-
-    cds.dwData = PAGEANT_COPYDATA_ID;
-    cds.cbData = 1 + strlen(mapname);
-    cds.lpData = mapname;
-
-    id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds);
-    if(id > 0) {
-        transctx->response_len = _libssh2_ntohu32(p);
-        if(transctx->response_len > PAGEANT_MAX_MSGLEN) {
-            UnmapViewOfFile(p);
-            CloseHandle(filemap);
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-                                  "agent setup fail");
-        }
-        transctx->response = LIBSSH2_ALLOC(agent->session,
-                                           transctx->response_len);
-        if(!transctx->response) {
-            UnmapViewOfFile(p);
-            CloseHandle(filemap);
-            return _libssh2_error(agent->session, LIBSSH2_ERROR_ALLOC,
-                                  "agent malloc");
-        }
-        memcpy(transctx->response, p + 4, transctx->response_len);
-    }
-
-    UnmapViewOfFile(p);
-    CloseHandle(filemap);
-    return 0;
-}
-
-static int
-agent_disconnect_pageant(LIBSSH2_AGENT *agent)
-{
-    agent->fd = LIBSSH2_INVALID_SOCKET;
-    return 0;
-}
-
-struct agent_ops agent_ops_pageant = {
-    agent_connect_pageant,
-    agent_transact_pageant,
-    agent_disconnect_pageant
-};
-#endif  /* WIN32 */
-
-static struct {
-    const char *name;
-    struct agent_ops *ops;
-} supported_backends[] = {
-#ifdef WIN32
-    {"Pageant", &agent_ops_pageant},
-    {"OpenSSH", &agent_ops_openssh},
-#endif  /* WIN32 */
-#ifdef PF_UNIX
-    {"Unix", &agent_ops_unix},
-#endif  /* PF_UNIX */
-    {NULL, NULL}
-};
-
-static int
-agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
-           const unsigned char *data, size_t data_len, void **abstract)
-{
-    LIBSSH2_AGENT *agent = (LIBSSH2_AGENT *) (*abstract);
-    agent_transaction_ctx_t transctx = &agent->transctx;
-    struct agent_publickey *identity = agent->identity;
-    ssize_t len = 1 + 4 + identity->external.blob_len + 4 + data_len + 4;
-    ssize_t method_len;
-    unsigned char *s;
-    int rc;
-
-    /* Create a request to sign the data */
-    if(transctx->state == agent_NB_state_init) {
-        s = transctx->request = LIBSSH2_ALLOC(session, len);
-        if(!transctx->request)
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "out of memory");
-
-        *s++ = SSH2_AGENTC_SIGN_REQUEST;
-        /* key blob */
-        _libssh2_store_str(&s, (const char *)identity->external.blob,
-                           identity->external.blob_len);
-        /* data */
-        _libssh2_store_str(&s, (const char *)data, data_len);
-
-        /* flags */
-        _libssh2_store_u32(&s, 0);
-
-        transctx->request_len = s - transctx->request;
-        transctx->send_recv_total = 0;
-        transctx->state = agent_NB_state_request_created;
-    }
-
-    /* Make sure to be re-called as a result of EAGAIN. */
-    if(*transctx->request != SSH2_AGENTC_SIGN_REQUEST)
-        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-                              "illegal request");
-
-    if(!agent->ops)
-        /* if no agent has been connected, bail out */
-        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-                              "agent not connected");
-
-    rc = agent->ops->transact(agent, transctx);
-    if(rc) {
-        goto error;
-    }
-    LIBSSH2_FREE(session, transctx->request);
-    transctx->request = NULL;
-
-    len = transctx->response_len;
-    s = transctx->response;
-    len--;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    if(*s != SSH2_AGENT_SIGN_RESPONSE) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    s++;
-
-    /* Skip the entire length of the signature */
-    len -= 4;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    s += 4;
-
-    /* Skip signing method */
-    len -= 4;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    method_len = _libssh2_ntohu32(s);
-    s += 4;
-    len -= method_len;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    s += method_len;
-
-    /* Read the signature */
-    len -= 4;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    *sig_len = _libssh2_ntohu32(s);
-    s += 4;
-    len -= *sig_len;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-
-    *sig = LIBSSH2_ALLOC(session, *sig_len);
-    if(!*sig) {
-        rc = LIBSSH2_ERROR_ALLOC;
-        goto error;
-    }
-    memcpy(*sig, s, *sig_len);
-
-  error:
-    LIBSSH2_FREE(session, transctx->request);
-    transctx->request = NULL;
-
-    LIBSSH2_FREE(session, transctx->response);
-    transctx->response = NULL;
-
-    return _libssh2_error(session, rc, "agent sign failure");
-}
-
-static int
-agent_list_identities(LIBSSH2_AGENT *agent)
-{
-    agent_transaction_ctx_t transctx = &agent->transctx;
-    ssize_t len, num_identities;
-    unsigned char *s;
-    int rc;
-    unsigned char c = SSH2_AGENTC_REQUEST_IDENTITIES;
-
-    /* Create a request to list identities */
-    if(transctx->state == agent_NB_state_init) {
-        transctx->request = &c;
-        transctx->request_len = 1;
-        transctx->send_recv_total = 0;
-        transctx->state = agent_NB_state_request_created;
-    }
-
-    /* Make sure to be re-called as a result of EAGAIN. */
-    if(*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES)
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
-                              "illegal agent request");
-
-    if(!agent->ops)
-        /* if no agent has been connected, bail out */
-        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
-                              "agent not connected");
-
-    rc = agent->ops->transact(agent, transctx);
-    if(rc) {
-        LIBSSH2_FREE(agent->session, transctx->response);
-        transctx->response = NULL;
-        return rc;
-    }
-    transctx->request = NULL;
-
-    len = transctx->response_len;
-    s = transctx->response;
-    len--;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    if(*s != SSH2_AGENT_IDENTITIES_ANSWER) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    s++;
-
-    /* Read the length of identities */
-    len -= 4;
-    if(len < 0) {
-        rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-        goto error;
-    }
-    num_identities = _libssh2_ntohu32(s);
-    s += 4;
-
-    while(num_identities--) {
-        struct agent_publickey *identity;
-        ssize_t comment_len;
-
-        /* Read the length of the blob */
-        len -= 4;
-        if(len < 0) {
-            rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-            goto error;
-        }
-        identity = LIBSSH2_ALLOC(agent->session, sizeof *identity);
-        if(!identity) {
-            rc = LIBSSH2_ERROR_ALLOC;
-            goto error;
-        }
-        identity->external.blob_len = _libssh2_ntohu32(s);
-        s += 4;
-
-        /* Read the blob */
-        len -= identity->external.blob_len;
-        if(len < 0) {
-            rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-            LIBSSH2_FREE(agent->session, identity);
-            goto error;
-        }
-
-        identity->external.blob = LIBSSH2_ALLOC(agent->session,
-                                                identity->external.blob_len);
-        if(!identity->external.blob) {
-            rc = LIBSSH2_ERROR_ALLOC;
-            LIBSSH2_FREE(agent->session, identity);
-            goto error;
-        }
-        memcpy(identity->external.blob, s, identity->external.blob_len);
-        s += identity->external.blob_len;
-
-        /* Read the length of the comment */
-        len -= 4;
-        if(len < 0) {
-            rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-            LIBSSH2_FREE(agent->session, identity->external.blob);
-            LIBSSH2_FREE(agent->session, identity);
-            goto error;
-        }
-        comment_len = _libssh2_ntohu32(s);
-        s += 4;
-
-        /* Read the comment */
-        len -= comment_len;
-        if(len < 0) {
-            rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
-            LIBSSH2_FREE(agent->session, identity->external.blob);
-            LIBSSH2_FREE(agent->session, identity);
-            goto error;
-        }
-
-        identity->external.comment = LIBSSH2_ALLOC(agent->session,
-                                                   comment_len + 1);
-        if(!identity->external.comment) {
-            rc = LIBSSH2_ERROR_ALLOC;
-            LIBSSH2_FREE(agent->session, identity->external.blob);
-            LIBSSH2_FREE(agent->session, identity);
-            goto error;
-        }
-        identity->external.comment[comment_len] = '\0';
-        memcpy(identity->external.comment, s, comment_len);
-        s += comment_len;
-
-        _libssh2_list_add(&agent->head, &identity->node);
-    }
- error:
-    LIBSSH2_FREE(agent->session, transctx->response);
-    transctx->response = NULL;
-
-    return _libssh2_error(agent->session, rc,
-                          "agent list id failed");
-}
-
-static void
-agent_free_identities(LIBSSH2_AGENT *agent)
-{
-    struct agent_publickey *node;
-    struct agent_publickey *next;
-
-    for(node = _libssh2_list_first(&agent->head); node; node = next) {
-        next = _libssh2_list_next(&node->node);
-        LIBSSH2_FREE(agent->session, node->external.blob);
-        LIBSSH2_FREE(agent->session, node->external.comment);
-        LIBSSH2_FREE(agent->session, node);
-    }
-    _libssh2_list_init(&agent->head);
-}
-
-#define AGENT_PUBLICKEY_MAGIC 0x3bdefed2
-/*
- * agent_publickey_to_external()
- *
- * Copies data from the internal to the external representation struct.
- *
- */
-static struct libssh2_agent_publickey *
-agent_publickey_to_external(struct agent_publickey *node)
-{
-    struct libssh2_agent_publickey *ext = &node->external;
-
-    ext->magic = AGENT_PUBLICKEY_MAGIC;
-    ext->node = node;
-
-    return ext;
-}
-
-/*
- * libssh2_agent_init
- *
- * Init an ssh-agent handle. Returns the pointer to the handle.
- *
- */
-LIBSSH2_API LIBSSH2_AGENT *
-libssh2_agent_init(LIBSSH2_SESSION *session)
-{
-    LIBSSH2_AGENT *agent;
-
-    agent = LIBSSH2_CALLOC(session, sizeof *agent);
-    if(!agent) {
-        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                       "Unable to allocate space for agent connection");
-        return NULL;
-    }
-    agent->fd = LIBSSH2_INVALID_SOCKET;
-    agent->session = session;
-    agent->identity_agent_path = NULL;
-    _libssh2_list_init(&agent->head);
-
-#ifdef WIN32
-    agent->pipe = INVALID_HANDLE_VALUE;
-    memset(&agent->overlapped, 0, sizeof(OVERLAPPED));
-    agent->pending_io = FALSE;
-#endif
-
-    return agent;
-}
-
-/*
- * libssh2_agent_connect()
- *
- * Connect to an ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_connect(LIBSSH2_AGENT *agent)
-{
-    int i, rc = -1;
-    for(i = 0; supported_backends[i].name; i++) {
-        agent->ops = supported_backends[i].ops;
-        rc = (agent->ops->connect)(agent);
-        if(!rc)
-            return 0;
-    }
-    return rc;
-}
-
-/*
- * libssh2_agent_list_identities()
- *
- * Request ssh-agent to list identities.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_list_identities(LIBSSH2_AGENT *agent)
-{
-    memset(&agent->transctx, 0, sizeof agent->transctx);
-    /* Abandon the last fetched identities */
-    agent_free_identities(agent);
-    return agent_list_identities(agent);
-}
-
-/*
- * libssh2_agent_get_identity()
- *
- * Traverse the internal list of public keys. Pass NULL to 'prev' to get
- * the first one. Or pass a pointer to the previously returned one to get the
- * next.
- *
- * Returns:
- * 0 if a fine public key was stored in 'store'
- * 1 if end of public keys
- * [negative] on errors
- */
-LIBSSH2_API int
-libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
-                           struct libssh2_agent_publickey **ext,
-                           struct libssh2_agent_publickey *oprev)
-{
-    struct agent_publickey *node;
-    if(oprev && oprev->node) {
-        /* we have a starting point */
-        struct agent_publickey *prev = oprev->node;
-
-        /* get the next node in the list */
-        node = _libssh2_list_next(&prev->node);
-    }
-    else
-        node = _libssh2_list_first(&agent->head);
-
-    if(!node)
-        /* no (more) node */
-        return 1;
-
-    *ext = agent_publickey_to_external(node);
-
-    return 0;
-}
-
-/*
- * libssh2_agent_userauth()
- *
- * Do publickey user authentication with the help of ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_userauth(LIBSSH2_AGENT *agent,
-                       const char *username,
-                       struct libssh2_agent_publickey *identity)
-{
-    void *abstract = agent;
-    int rc;
-
-    if(agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
-        memset(&agent->transctx, 0, sizeof agent->transctx);
-        agent->identity = identity->node;
-    }
-
-    BLOCK_ADJUST(rc, agent->session,
-                 _libssh2_userauth_publickey(agent->session, username,
-                                             strlen(username),
-                                             identity->blob,
-                                             identity->blob_len,
-                                             agent_sign,
-                                             &abstract));
-    return rc;
-}
-
-/*
- * libssh2_agent_disconnect()
- *
- * Close a connection to an ssh-agent.
- *
- * Returns 0 if succeeded, or a negative value for error.
- */
-LIBSSH2_API int
-libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
-{
-    if(agent->ops && agent->fd != LIBSSH2_INVALID_SOCKET)
-        return agent->ops->disconnect(agent);
-    return 0;
-}
-
-/*
- * libssh2_agent_free()
- *
- * Free an ssh-agent handle.  This function also frees the internal
- * collection of public keys.
- */
-LIBSSH2_API void
-libssh2_agent_free(LIBSSH2_AGENT *agent)
-{
-    /* Allow connection freeing when the socket has lost its connection */
-    if(agent->fd != LIBSSH2_INVALID_SOCKET) {
-        libssh2_agent_disconnect(agent);
-    }
-
-    if(agent->identity_agent_path != NULL)
-        LIBSSH2_FREE(agent->session, agent->identity_agent_path);
-
-    agent_free_identities(agent);
-    LIBSSH2_FREE(agent->session, agent);
-}
-
-/*
- * libssh2_agent_set_identity_path()
- *
- * Allows a custom agent socket path beyond SSH_AUTH_SOCK env
- *
- */
-LIBSSH2_API void
-libssh2_agent_set_identity_path(LIBSSH2_AGENT *agent, const char *path)
-{
-    if(agent->identity_agent_path) {
-        LIBSSH2_FREE(agent->session, agent->identity_agent_path);
-        agent->identity_agent_path = NULL;
-    }
-
-    if(path) {
-        size_t path_len = strlen(path);
-        if(path_len < SIZE_MAX - 1) {
-            char *path_buf = LIBSSH2_ALLOC(agent->session, path_len + 1);
-            memcpy(path_buf, path, path_len);
-            path_buf[path_len] = '\0';
-            agent->identity_agent_path = path_buf;
-        }
-    }
-}
-
-/*
- * libssh2_agent_get_identity_path()
- *
- * Returns the custom agent socket path if set
- *
- */
-LIBSSH2_API const char *libssh2_agent_get_identity_path(LIBSSH2_AGENT *agent)
-{
-    return agent->identity_agent_path;
-}
diff --git a/libssh2/libssh2/src/agent.h b/libssh2/libssh2/src/agent.h
deleted file mode 100644
index dfac0715..00000000
--- a/libssh2/libssh2/src/agent.h
+++ /dev/null
@@ -1,112 +0,0 @@
-#ifndef __LIBSSH2_AGENT_H
-#define __LIBSSH2_AGENT_H
-/*
- * Copyright (c) 2009 by Daiki Ueno
- * Copyright (C) 2010-2014 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "misc.h"
-#include "session.h"
-#ifdef WIN32
-#include <stdlib.h>
-#endif
-
-/* non-blocking mode on agent connection is not yet implemented, but
-   for future use. */
-typedef enum {
-    agent_NB_state_init = 0,
-    agent_NB_state_request_created,
-    agent_NB_state_request_length_sent,
-    agent_NB_state_request_sent,
-    agent_NB_state_response_length_received,
-    agent_NB_state_response_received
-} agent_nonblocking_states;
-
-typedef struct agent_transaction_ctx {
-    unsigned char *request;
-    size_t request_len;
-    unsigned char *response;
-    size_t response_len;
-    agent_nonblocking_states state;
-    size_t send_recv_total;
-} *agent_transaction_ctx_t;
-
-typedef int (*agent_connect_func)(LIBSSH2_AGENT *agent);
-typedef int (*agent_transact_func)(LIBSSH2_AGENT *agent,
-                                   agent_transaction_ctx_t transctx);
-typedef int (*agent_disconnect_func)(LIBSSH2_AGENT *agent);
-
-struct agent_publickey {
-    struct list_node node;
-
-    /* this is the struct we expose externally */
-    struct libssh2_agent_publickey external;
-};
-
-struct agent_ops {
-    agent_connect_func connect;
-    agent_transact_func transact;
-    agent_disconnect_func disconnect;
-};
-
-struct _LIBSSH2_AGENT
-{
-    LIBSSH2_SESSION *session;  /* the session this "belongs to" */
-
-    libssh2_socket_t fd;
-
-    struct agent_ops *ops;
-
-    struct agent_transaction_ctx transctx;
-    struct agent_publickey *identity;
-    struct list_head head;              /* list of public keys */
-
-    char *identity_agent_path; /* Path to a custom identity agent socket */
-
-#ifdef WIN32
-    OVERLAPPED overlapped;
-    HANDLE pipe;
-    BOOL pending_io;
-#endif
-};
-
-#ifdef WIN32
-extern struct agent_ops agent_ops_openssh;
-#endif
-
-#endif /* __LIBSSH2_AGENT_H */
diff --git a/libssh2/libssh2/src/bcrypt_pbkdf.c b/libssh2/libssh2/src/bcrypt_pbkdf.c
deleted file mode 100644
index f782bcac..00000000
--- a/libssh2/libssh2/src/bcrypt_pbkdf.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/* $OpenBSD: bcrypt_pbkdf.c,v 1.4 2013/07/29 00:55:53 tedu Exp $ */
-/*
- * Copyright (c) 2013 Ted Unangst <tedu@openbsd.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-
-#ifndef HAVE_BCRYPT_PBKDF
-
-#include "libssh2_priv.h"
-#include <stdlib.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-
-#include "blf.h"
-
-#define MINIMUM(a,b) (((a) < (b)) ? (a) : (b))
-
-/*
- * pkcs #5 pbkdf2 implementation using the "bcrypt" hash
- *
- * The bcrypt hash function is derived from the bcrypt password hashing
- * function with the following modifications:
- * 1. The input password and salt are preprocessed with SHA512.
- * 2. The output length is expanded to 256 bits.
- * 3. Subsequently the magic string to be encrypted is lengthened and modified
- *    to "OxychromaticBlowfishSwatDynamite"
- * 4. The hash function is defined to perform 64 rounds of initial state
- *    expansion. (More rounds are performed by iterating the hash.)
- *
- * Note that this implementation pulls the SHA512 operations into the caller
- * as a performance optimization.
- *
- * One modification from official pbkdf2. Instead of outputting key material
- * linearly, we mix it. pbkdf2 has a known weakness where if one uses it to
- * generate (i.e.) 512 bits of key material for use as two 256 bit keys, an
- * attacker can merely run once through the outer loop below, but the user
- * always runs it twice. Shuffling output bytes requires computing the
- * entirety of the key material to assemble any subkey. This is something a
- * wise caller could do; we just do it for you.
- */
-
-#define BCRYPT_BLOCKS 8
-#define BCRYPT_HASHSIZE (BCRYPT_BLOCKS * 4)
-
-static void
-bcrypt_hash(uint8_t *sha2pass, uint8_t *sha2salt, uint8_t *out)
-{
-    blf_ctx state;
-    uint8_t ciphertext[BCRYPT_HASHSIZE] =
-        "OxychromaticBlowfishSwatDynamite";
-    uint32_t cdata[BCRYPT_BLOCKS];
-    int i;
-    uint16_t j;
-    size_t shalen = SHA512_DIGEST_LENGTH;
-
-    /* key expansion */
-    Blowfish_initstate(&state);
-    Blowfish_expandstate(&state, sha2salt, shalen, sha2pass, shalen);
-    for(i = 0; i < 64; i++) {
-        Blowfish_expand0state(&state, sha2salt, shalen);
-        Blowfish_expand0state(&state, sha2pass, shalen);
-    }
-
-    /* encryption */
-    j = 0;
-    for(i = 0; i < BCRYPT_BLOCKS; i++)
-        cdata[i] = Blowfish_stream2word(ciphertext, sizeof(ciphertext),
-                                        &j);
-    for(i = 0; i < 64; i++)
-        blf_enc(&state, cdata, BCRYPT_BLOCKS / 2);
-
-    /* copy out */
-    for(i = 0; i < BCRYPT_BLOCKS; i++) {
-        out[4 * i + 3] = (cdata[i] >> 24) & 0xff;
-        out[4 * i + 2] = (cdata[i] >> 16) & 0xff;
-        out[4 * i + 1] = (cdata[i] >> 8) & 0xff;
-        out[4 * i + 0] = cdata[i] & 0xff;
-    }
-
-    /* zap */
-    _libssh2_explicit_zero(ciphertext, sizeof(ciphertext));
-    _libssh2_explicit_zero(cdata, sizeof(cdata));
-    _libssh2_explicit_zero(&state, sizeof(state));
-}
-
-int
-bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
-             size_t saltlen,
-             uint8_t *key, size_t keylen, unsigned int rounds)
-{
-    uint8_t sha2pass[SHA512_DIGEST_LENGTH];
-    uint8_t sha2salt[SHA512_DIGEST_LENGTH];
-    uint8_t out[BCRYPT_HASHSIZE];
-    uint8_t tmpout[BCRYPT_HASHSIZE];
-    uint8_t *countsalt;
-    size_t i, j, amt, stride;
-    uint32_t count;
-    size_t origkeylen = keylen;
-    libssh2_sha512_ctx ctx;
-
-    /* nothing crazy */
-    if(rounds < 1)
-        return -1;
-    if(passlen == 0 || saltlen == 0 || keylen == 0 ||
-       keylen > sizeof(out) * sizeof(out) || saltlen > 1<<20)
-        return -1;
-    countsalt = calloc(1, saltlen + 4);
-    if(countsalt == NULL)
-        return -1;
-    stride = (keylen + sizeof(out) - 1) / sizeof(out);
-    amt = (keylen + stride - 1) / stride;
-
-    memcpy(countsalt, salt, saltlen);
-
-    /* collapse password */
-    libssh2_sha512_init(&ctx);
-    libssh2_sha512_update(ctx, pass, passlen);
-    libssh2_sha512_final(ctx, sha2pass);
-
-    /* generate key, sizeof(out) at a time */
-    for(count = 1; keylen > 0; count++) {
-        countsalt[saltlen + 0] = (count >> 24) & 0xff;
-        countsalt[saltlen + 1] = (count >> 16) & 0xff;
-        countsalt[saltlen + 2] = (count >> 8) & 0xff;
-        countsalt[saltlen + 3] = count & 0xff;
-
-        /* first round, salt is salt */
-        libssh2_sha512_init(&ctx);
-        libssh2_sha512_update(ctx, countsalt, saltlen + 4);
-        libssh2_sha512_final(ctx, sha2salt);
-
-        bcrypt_hash(sha2pass, sha2salt, tmpout);
-        memcpy(out, tmpout, sizeof(out));
-
-        for(i = 1; i < rounds; i++) {
-            /* subsequent rounds, salt is previous output */
-            libssh2_sha512_init(&ctx);
-            libssh2_sha512_update(ctx, tmpout, sizeof(tmpout));
-            libssh2_sha512_final(ctx, sha2salt);
-
-            bcrypt_hash(sha2pass, sha2salt, tmpout);
-            for(j = 0; j < sizeof(out); j++)
-                out[j] ^= tmpout[j];
-        }
-
-        /*
-         * pbkdf2 deviation: output the key material non-linearly.
-         */
-        amt = MINIMUM(amt, keylen);
-        for(i = 0; i < amt; i++) {
-            size_t dest = i * stride + (count - 1);
-            if(dest >= origkeylen) {
-                break;
-            }
-            key[dest] = out[i];
-        }
-        keylen -= i;
-    }
-
-    /* zap */
-    _libssh2_explicit_zero(out, sizeof(out));
-    free(countsalt);
-
-    return 0;
-}
-#endif /* HAVE_BCRYPT_PBKDF */
diff --git a/libssh2/libssh2/src/blf.h b/libssh2/libssh2/src/blf.h
deleted file mode 100644
index 5b7c8aae..00000000
--- a/libssh2/libssh2/src/blf.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef __LIBSSH2_BLF_H
-#define __LIBSSH2_BLF_H
-/* $OpenBSD: blf.h,v 1.7 2007/03/14 17:59:41 grunk Exp $ */
-/*
- * Blowfish - a fast block cipher designed by Bruce Schneier
- *
- * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
- * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-#if !defined(HAVE_BCRYPT_PBKDF) && !defined(HAVE_BLH_H)
-
-/* Schneier specifies a maximum key length of 56 bytes.
- * This ensures that every key bit affects every cipher
- * bit.  However, the subkeys can hold up to 72 bytes.
- * Warning: For normal blowfish encryption only 56 bytes
- * of the key affect all cipherbits.
- */
-
-#define BLF_N   16                      /* Number of Subkeys */
-#define BLF_MAXKEYLEN ((BLF_N-2)*4)     /* 448 bits */
-#define BLF_MAXUTILIZED ((BLF_N + 2)*4)   /* 576 bits */
-
-/* Blowfish context */
-typedef struct BlowfishContext {
-        uint32_t S[4][256];     /* S-Boxes */
-        uint32_t P[BLF_N + 2];  /* Subkeys */
-} blf_ctx;
-
-/* Raw access to customized Blowfish
- *      blf_key is just:
- *      Blowfish_initstate( state )
- *      Blowfish_expand0state( state, key, keylen )
- */
-
-void Blowfish_encipher(blf_ctx *, uint32_t *, uint32_t *);
-void Blowfish_decipher(blf_ctx *, uint32_t *, uint32_t *);
-void Blowfish_initstate(blf_ctx *);
-void Blowfish_expand0state(blf_ctx *, const uint8_t *, uint16_t);
-void Blowfish_expandstate
-(blf_ctx *, const uint8_t *, uint16_t, const uint8_t *, uint16_t);
-
-/* Standard Blowfish */
-
-void blf_key(blf_ctx *, const uint8_t *, uint16_t);
-void blf_enc(blf_ctx *, uint32_t *, uint16_t);
-void blf_dec(blf_ctx *, uint32_t *, uint16_t);
-
-void blf_ecb_encrypt(blf_ctx *, uint8_t *, uint32_t);
-void blf_ecb_decrypt(blf_ctx *, uint8_t *, uint32_t);
-
-void blf_cbc_encrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
-void blf_cbc_decrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
-
-/* Converts uint8_t to uint32_t */
-uint32_t Blowfish_stream2word(const uint8_t *, uint16_t, uint16_t *);
-
-/* bcrypt with pbkd */
-int bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
-                 size_t saltlen,
-                 uint8_t *key, size_t keylen, unsigned int rounds);
-
-#endif /* !defined(HAVE_BCRYPT_PBKDF) && !defined(HAVE_BLH_H) */
-#endif /* __LIBSSH2_BLF_H */
diff --git a/libssh2/libssh2/src/blowfish.c b/libssh2/libssh2/src/blowfish.c
deleted file mode 100644
index 4aefc66a..00000000
--- a/libssh2/libssh2/src/blowfish.c
+++ /dev/null
@@ -1,697 +0,0 @@
-/* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */
-/*
- * Blowfish block cipher for OpenBSD
- * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
- * All rights reserved.
- *
- * Implementation advice by David Mazieres <dm@lcs.mit.edu>.
- *
- * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-/*
- * This code is derived from section 14.3 and the given source
- * in section V of Applied Cryptography, second edition.
- * Blowfish is an unpatented fast block cipher designed by
- * Bruce Schneier.
- */
-
-
-#if !defined(HAVE_BCRYPT_PBKDF) && (!defined(HAVE_BLOWFISH_INITSTATE) || \
-                                    !defined(HAVE_BLOWFISH_EXPAND0STATE) || \
-                                    !defined(HAVE_BLF_ENC))
-
-#if 0
-#include <stdio.h>              /* used for debugging */
-#include <string.h>
-#endif
-
-#include <sys/types.h>
-
-#include "libssh2.h"
-#include "blf.h"
-
-#undef inline
-#ifdef __GNUC__
-#define inline __inline
-#else                           /* !__GNUC__ */
-#define inline
-#endif                          /* !__GNUC__ */
-
-/* Function for Feistel Networks */
-
-#define F(s, x) ((((s)[        (((x)>>24)&0xFF)]        \
-                   + (s)[0x100 + (((x)>>16)&0xFF)])     \
-                  ^ (s)[0x200 + (((x)>> 8)&0xFF)])      \
-                 + (s)[0x300 + ( (x)     &0xFF)])
-
-#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
-
-void
-Blowfish_encipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
-{
-    uint32_t Xl;
-    uint32_t Xr;
-    uint32_t *s = c->S[0];
-    uint32_t *p = c->P;
-
-    Xl = *xl;
-    Xr = *xr;
-
-    Xl ^= p[0];
-    BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2);
-    BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4);
-    BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6);
-    BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8);
-    BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10);
-    BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12);
-    BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14);
-    BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16);
-
-    *xl = Xr ^ p[17];
-    *xr = Xl;
-}
-
-void
-Blowfish_decipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
-{
-    uint32_t Xl;
-    uint32_t Xr;
-    uint32_t *s = c->S[0];
-    uint32_t *p = c->P;
-
-    Xl = *xl;
-    Xr = *xr;
-
-    Xl ^= p[17];
-    BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15);
-    BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13);
-    BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11);
-    BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9);
-    BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7);
-    BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5);
-    BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3);
-    BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1);
-
-    *xl = Xr ^ p[0];
-    *xr = Xl;
-}
-
-void
-Blowfish_initstate(blf_ctx *c)
-{
-    /* P-box and S-box tables initialized with digits of Pi */
-
-    static const blf_ctx initstate =
-        { {
-                {
-                    0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
-                    0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
-                    0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-                    0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
-                    0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-                    0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-                    0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
-                    0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
-                    0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-                    0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-                    0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
-                    0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-                    0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
-                    0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
-                    0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-                    0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
-                    0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
-                    0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-                    0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
-                    0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-                    0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-                    0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
-                    0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
-                    0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-                    0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-                    0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
-                    0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-                    0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
-                    0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
-                    0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-                    0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
-                    0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
-                    0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-                    0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
-                    0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-                    0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-                    0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
-                    0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
-                    0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-                    0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-                    0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
-                    0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-                    0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
-                    0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
-                    0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-                    0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
-                    0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
-                    0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-                    0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
-                    0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-                    0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-                    0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
-                    0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
-                    0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-                    0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-                    0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
-                    0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-                    0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
-                    0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
-                    0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-                    0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
-                    0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
-                    0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-                    0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},
-                {
-                    0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-                    0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
-                    0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-                    0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
-                    0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
-                    0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-                    0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
-                    0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
-                    0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-                    0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
-                    0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-                    0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-                    0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
-                    0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
-                    0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-                    0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-                    0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
-                    0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-                    0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
-                    0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
-                    0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-                    0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
-                    0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
-                    0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-                    0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
-                    0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-                    0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-                    0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
-                    0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
-                    0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-                    0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-                    0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
-                    0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-                    0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
-                    0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
-                    0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-                    0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
-                    0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
-                    0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-                    0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
-                    0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-                    0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-                    0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
-                    0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
-                    0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-                    0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-                    0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
-                    0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-                    0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
-                    0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
-                    0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-                    0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
-                    0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
-                    0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-                    0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
-                    0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-                    0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-                    0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
-                    0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
-                    0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-                    0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-                    0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
-                    0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-                    0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},
-                {
-                    0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
-                    0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-                    0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-                    0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
-                    0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
-                    0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-                    0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-                    0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
-                    0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-                    0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
-                    0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
-                    0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-                    0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
-                    0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
-                    0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-                    0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
-                    0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-                    0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-                    0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
-                    0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
-                    0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-                    0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-                    0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
-                    0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-                    0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
-                    0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
-                    0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-                    0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
-                    0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
-                    0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-                    0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
-                    0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-                    0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-                    0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
-                    0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
-                    0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-                    0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-                    0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
-                    0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-                    0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
-                    0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
-                    0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-                    0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
-                    0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
-                    0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-                    0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
-                    0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-                    0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-                    0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
-                    0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
-                    0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-                    0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-                    0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
-                    0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-                    0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
-                    0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
-                    0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-                    0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
-                    0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
-                    0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-                    0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
-                    0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-                    0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-                    0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},
-                {
-                    0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
-                    0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
-                    0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-                    0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
-                    0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
-                    0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-                    0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
-                    0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-                    0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-                    0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
-                    0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
-                    0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-                    0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-                    0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
-                    0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-                    0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
-                    0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
-                    0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-                    0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
-                    0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
-                    0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-                    0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
-                    0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-                    0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-                    0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
-                    0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
-                    0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-                    0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-                    0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
-                    0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-                    0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
-                    0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
-                    0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-                    0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
-                    0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
-                    0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-                    0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
-                    0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-                    0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-                    0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
-                    0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
-                    0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-                    0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-                    0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
-                    0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-                    0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
-                    0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
-                    0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-                    0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
-                    0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
-                    0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-                    0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
-                    0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-                    0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-                    0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
-                    0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
-                    0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-                    0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-                    0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
-                    0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-                    0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
-                    0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
-                    0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-                    0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}
-            },
-          {
-              0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
-              0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
-              0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
-              0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
-              0x9216d5d9, 0x8979fb1b
-          } };
-
-    *c = initstate;
-}
-
-uint32_t
-Blowfish_stream2word(const uint8_t *data, uint16_t databytes,
-                     uint16_t *current)
-{
-    uint8_t i;
-    uint16_t j;
-    uint32_t temp;
-
-    temp = 0x00000000;
-    j = *current;
-
-    for(i = 0; i < 4; i++, j++) {
-        if(j >= databytes)
-            j = 0;
-        temp = (temp << 8) | data[j];
-    }
-
-    *current = j;
-    return temp;
-}
-
-void
-Blowfish_expand0state(blf_ctx *c, const uint8_t *key, uint16_t keybytes)
-{
-    uint16_t i;
-    uint16_t j;
-    uint16_t k;
-    uint32_t temp;
-    uint32_t datal;
-    uint32_t datar;
-
-    j = 0;
-    for(i = 0; i < BLF_N + 2; i++) {
-        /* Extract 4 int8 to 1 int32 from keystream */
-        temp = Blowfish_stream2word(key, keybytes, &j);
-        c->P[i] = c->P[i] ^ temp;
-    }
-
-    j = 0;
-    datal = 0x00000000;
-    datar = 0x00000000;
-    for(i = 0; i < BLF_N + 2; i += 2) {
-        Blowfish_encipher(c, &datal, &datar);
-
-        c->P[i] = datal;
-        c->P[i + 1] = datar;
-    }
-
-    for(i = 0; i < 4; i++) {
-        for(k = 0; k < 256; k += 2) {
-            Blowfish_encipher(c, &datal, &datar);
-
-            c->S[i][k] = datal;
-            c->S[i][k + 1] = datar;
-        }
-    }
-}
-
-
-void
-Blowfish_expandstate(blf_ctx *c, const uint8_t *data, uint16_t databytes,
-                     const uint8_t *key, uint16_t keybytes)
-{
-    uint16_t i;
-    uint16_t j;
-    uint16_t k;
-    uint32_t temp;
-    uint32_t datal;
-    uint32_t datar;
-
-    j = 0;
-    for(i = 0; i < BLF_N + 2; i++) {
-        /* Extract 4 int8 to 1 int32 from keystream */
-        temp = Blowfish_stream2word(key, keybytes, &j);
-        c->P[i] = c->P[i] ^ temp;
-    }
-
-    j = 0;
-    datal = 0x00000000;
-    datar = 0x00000000;
-    for(i = 0; i < BLF_N + 2; i += 2) {
-        datal ^= Blowfish_stream2word(data, databytes, &j);
-        datar ^= Blowfish_stream2word(data, databytes, &j);
-        Blowfish_encipher(c, &datal, &datar);
-
-        c->P[i] = datal;
-        c->P[i + 1] = datar;
-    }
-
-    for(i = 0; i < 4; i++) {
-        for(k = 0; k < 256; k += 2) {
-            datal ^= Blowfish_stream2word(data, databytes, &j);
-            datar ^= Blowfish_stream2word(data, databytes, &j);
-            Blowfish_encipher(c, &datal, &datar);
-
-            c->S[i][k] = datal;
-            c->S[i][k + 1] = datar;
-        }
-    }
-
-}
-
-void
-blf_key(blf_ctx *c, const uint8_t *k, uint16_t len)
-{
-    /* Initialize S-boxes and subkeys with Pi */
-    Blowfish_initstate(c);
-
-    /* Transform S-boxes and subkeys with key */
-    Blowfish_expand0state(c, k, len);
-}
-
-void
-blf_enc(blf_ctx *c, uint32_t *data, uint16_t blocks)
-{
-    uint32_t *d;
-    uint16_t i;
-
-    d = data;
-    for(i = 0; i < blocks; i++) {
-        Blowfish_encipher(c, d, d + 1);
-        d += 2;
-    }
-}
-
-void
-blf_dec(blf_ctx *c, uint32_t *data, uint16_t blocks)
-{
-    uint32_t *d;
-    uint16_t i;
-
-    d = data;
-    for(i = 0; i < blocks; i++) {
-        Blowfish_decipher(c, d, d + 1);
-        d += 2;
-    }
-}
-
-void
-blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
-{
-    uint32_t l, r;
-    uint32_t i;
-
-    for(i = 0; i < len; i += 8) {
-        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
-        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
-        Blowfish_encipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
-        data[1] = l >> 16 & 0xff;
-        data[2] = l >> 8 & 0xff;
-        data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
-        data[5] = r >> 16 & 0xff;
-        data[6] = r >> 8 & 0xff;
-        data[7] = r & 0xff;
-        data += 8;
-    }
-}
-
-void
-blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
-{
-    uint32_t l, r;
-    uint32_t i;
-
-    for(i = 0; i < len; i += 8) {
-        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
-        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
-        Blowfish_decipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
-        data[1] = l >> 16 & 0xff;
-        data[2] = l >> 8 & 0xff;
-        data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
-        data[5] = r >> 16 & 0xff;
-        data[6] = r >> 8 & 0xff;
-        data[7] = r & 0xff;
-        data += 8;
-    }
-}
-
-void
-blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
-{
-    uint32_t l, r;
-    uint32_t i, j;
-
-    for(i = 0; i < len; i += 8) {
-        for(j = 0; j < 8; j++)
-            data[j] ^= iv[j];
-        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
-        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
-        Blowfish_encipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
-        data[1] = l >> 16 & 0xff;
-        data[2] = l >> 8 & 0xff;
-        data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
-        data[5] = r >> 16 & 0xff;
-        data[6] = r >> 8 & 0xff;
-        data[7] = r & 0xff;
-        iv = data;
-        data += 8;
-    }
-}
-
-void
-blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
-{
-    uint32_t l, r;
-    uint8_t *iv;
-    uint32_t i, j;
-
-    iv = data + len - 16;
-    data = data + len - 8;
-    for(i = len - 8; i >= 8; i -= 8) {
-        l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
-        r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
-        Blowfish_decipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
-        data[1] = l >> 16 & 0xff;
-        data[2] = l >> 8 & 0xff;
-        data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
-        data[5] = r >> 16 & 0xff;
-        data[6] = r >> 8 & 0xff;
-        data[7] = r & 0xff;
-        for(j = 0; j < 8; j++)
-            data[j] ^= iv[j];
-        iv -= 8;
-        data -= 8;
-    }
-    l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
-    r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
-    Blowfish_decipher(c, &l, &r);
-    data[0] = l >> 24 & 0xff;
-    data[1] = l >> 16 & 0xff;
-    data[2] = l >> 8 & 0xff;
-    data[3] = l & 0xff;
-    data[4] = r >> 24 & 0xff;
-    data[5] = r >> 16 & 0xff;
-    data[6] = r >> 8 & 0xff;
-    data[7] = r & 0xff;
-    for(j = 0; j < 8; j++)
-        data[j] ^= iva[j];
-}
-
-#if 0
-void
-report(uint32_t data[], uint16_t len)
-{
-    uint16_t i;
-    for(i = 0; i < len; i += 2)
-        printf("Block %0hd: %08lx %08lx.\n",
-               i / 2, data[i], data[i + 1]);
-}
-void
-main(void)
-{
-
-    blf_ctx c;
-    char    key[] = "AAAAA";
-    char    key2[] = "abcdefghijklmnopqrstuvwxyz";
-
-    uint32_t data[10];
-    uint32_t data2[] =
-        {0x424c4f57l, 0x46495348l};
-
-    uint16_t i;
-
-    /* First test */
-    for(i = 0; i < 10; i++)
-        data[i] = i;
-
-    blf_key(&c, (uint8_t *) key, 5);
-    blf_enc(&c, data, 5);
-    blf_dec(&c, data, 1);
-    blf_dec(&c, data + 2, 4);
-    printf("Should read as 0 - 9.\n");
-    report(data, 10);
-
-    /* Second test */
-    blf_key(&c, (uint8_t *) key2, strlen(key2));
-    blf_enc(&c, data2, 1);
-    printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
-    report(data2, 2);
-    blf_dec(&c, data2, 1);
-    report(data2, 2);
-}
-#endif
-
-#endif /* !defined(HAVE_BCRYPT_PBKDF) && \
-          (!defined(HAVE_BLOWFISH_INITSTATE) ||   \
-          !defined(HAVE_BLOWFISH_EXPAND0STATE) || \
-          '!defined(HAVE_BLF_ENC)) */
diff --git a/libssh2/libssh2/src/channel.c b/libssh2/libssh2/src/channel.c
deleted file mode 100644
index 78ed40e8..00000000
--- a/libssh2/libssh2/src/channel.c
+++ /dev/null
@@ -1,2895 +0,0 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2008-2019 by Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-#include <assert.h>
-
-#include "channel.h"
-#include "transport.h"
-#include "packet.h"
-#include "session.h"
-
-/*
- *  _libssh2_channel_nextid
- *
- * Determine the next channel ID we can use at our end
- */
-uint32_t
-_libssh2_channel_nextid(LIBSSH2_SESSION * session)
-{
-    uint32_t id = session->next_channel;
-    LIBSSH2_CHANNEL *channel;
-
-    channel = _libssh2_list_first(&session->channels);
-
-    while(channel) {
-        if(channel->local.id > id) {
-            id = channel->local.id;
-        }
-        channel = _libssh2_list_next(&channel->node);
-    }
-
-    /* This is a shortcut to avoid waiting for close packets on channels we've
-     * forgotten about, This *could* be a problem if we request and close 4
-     * billion or so channels in too rapid succession for the remote end to
-     * respond, but the worst case scenario is that some data meant for
-     * another channel Gets picked up by the new one.... Pretty unlikely all
-     * told...
-     */
-    session->next_channel = id + 1;
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Allocated new channel ID#%lu",
-                   id);
-    return id;
-}
-
-/*
- * _libssh2_channel_locate
- *
- * Locate a channel pointer by number
- */
-LIBSSH2_CHANNEL *
-_libssh2_channel_locate(LIBSSH2_SESSION *session, uint32_t channel_id)
-{
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_LISTENER *l;
-
-    for(channel = _libssh2_list_first(&session->channels);
-        channel;
-        channel = _libssh2_list_next(&channel->node)) {
-        if(channel->local.id == channel_id)
-            return channel;
-    }
-
-    /* We didn't find the channel in the session, let's then check its
-       listeners since each listener may have its own set of pending channels
-    */
-    for(l = _libssh2_list_first(&session->listeners); l;
-        l = _libssh2_list_next(&l->node)) {
-        for(channel = _libssh2_list_first(&l->queue);
-            channel;
-            channel = _libssh2_list_next(&channel->node)) {
-            if(channel->local.id == channel_id)
-                return channel;
-        }
-    }
-
-    return NULL;
-}
-
-/*
- * _libssh2_channel_open
- *
- * Establish a generic session channel
- */
-LIBSSH2_CHANNEL *
-_libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
-                      uint32_t channel_type_len,
-                      uint32_t window_size,
-                      uint32_t packet_size,
-                      const unsigned char *message,
-                      size_t message_len)
-{
-    static const unsigned char reply_codes[3] = {
-        SSH_MSG_CHANNEL_OPEN_CONFIRMATION,
-        SSH_MSG_CHANNEL_OPEN_FAILURE,
-        0
-    };
-    unsigned char *s;
-    int rc;
-
-    if(session->open_state == libssh2_NB_state_idle) {
-        session->open_channel = NULL;
-        session->open_packet = NULL;
-        session->open_data = NULL;
-        /* 17 = packet_type(1) + channel_type_len(4) + sender_channel(4) +
-         * window_size(4) + packet_size(4) */
-        session->open_packet_len = channel_type_len + 17;
-        session->open_local_channel = _libssh2_channel_nextid(session);
-
-        /* Zero the whole thing out */
-        memset(&session->open_packet_requirev_state, 0,
-               sizeof(session->open_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Opening Channel - win %d pack %d", window_size,
-                       packet_size);
-        session->open_channel =
-            LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-        if(!session->open_channel) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate space for channel data");
-            return NULL;
-        }
-        session->open_channel->channel_type_len = channel_type_len;
-        session->open_channel->channel_type =
-            LIBSSH2_ALLOC(session, channel_type_len);
-        if(!session->open_channel->channel_type) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Failed allocating memory for channel type name");
-            LIBSSH2_FREE(session, session->open_channel);
-            session->open_channel = NULL;
-            return NULL;
-        }
-        memcpy(session->open_channel->channel_type, channel_type,
-               channel_type_len);
-
-        /* REMEMBER: local as in locally sourced */
-        session->open_channel->local.id = session->open_local_channel;
-        session->open_channel->remote.window_size = window_size;
-        session->open_channel->remote.window_size_initial = window_size;
-        session->open_channel->remote.packet_size = packet_size;
-        session->open_channel->session = session;
-
-        _libssh2_list_add(&session->channels,
-                          &session->open_channel->node);
-
-        s = session->open_packet =
-            LIBSSH2_ALLOC(session, session->open_packet_len);
-        if(!session->open_packet) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate temporary space for packet");
-            goto channel_error;
-        }
-        *(s++) = SSH_MSG_CHANNEL_OPEN;
-        _libssh2_store_str(&s, channel_type, channel_type_len);
-        _libssh2_store_u32(&s, session->open_local_channel);
-        _libssh2_store_u32(&s, window_size);
-        _libssh2_store_u32(&s, packet_size);
-
-        /* Do not copy the message */
-
-        session->open_state = libssh2_NB_state_created;
-    }
-
-    if(session->open_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session,
-                                     session->open_packet,
-                                     session->open_packet_len,
-                                     message, message_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending channel-open request");
-            return NULL;
-        }
-        else if(rc) {
-            _libssh2_error(session, rc,
-                           "Unable to send channel-open request");
-            goto channel_error;
-        }
-
-        session->open_state = libssh2_NB_state_sent;
-    }
-
-    if(session->open_state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_requirev(session, reply_codes,
-                                      &session->open_data,
-                                      &session->open_data_len, 1,
-                                      session->open_packet + 5 +
-                                      channel_type_len, 4,
-                                      &session->open_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-            return NULL;
-        }
-        else if(rc) {
-            _libssh2_error(session, rc, "Unexpected error");
-            goto channel_error;
-        }
-
-        if(session->open_data_len < 1) {
-            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Unexpected packet size");
-            goto channel_error;
-        }
-
-        if(session->open_data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
-
-            if(session->open_data_len < 17) {
-                _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                               "Unexpected packet size");
-                goto channel_error;
-            }
-
-            session->open_channel->remote.id =
-                _libssh2_ntohu32(session->open_data + 5);
-            session->open_channel->local.window_size =
-                _libssh2_ntohu32(session->open_data + 9);
-            session->open_channel->local.window_size_initial =
-                _libssh2_ntohu32(session->open_data + 9);
-            session->open_channel->local.packet_size =
-                _libssh2_ntohu32(session->open_data + 13);
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Connection Established - ID: %lu/%lu win: %lu/%lu"
-                           " pack: %lu/%lu",
-                           session->open_channel->local.id,
-                           session->open_channel->remote.id,
-                           session->open_channel->local.window_size,
-                           session->open_channel->remote.window_size,
-                           session->open_channel->local.packet_size,
-                           session->open_channel->remote.packet_size);
-            LIBSSH2_FREE(session, session->open_packet);
-            session->open_packet = NULL;
-            LIBSSH2_FREE(session, session->open_data);
-            session->open_data = NULL;
-
-            session->open_state = libssh2_NB_state_idle;
-            return session->open_channel;
-        }
-
-        if(session->open_data[0] == SSH_MSG_CHANNEL_OPEN_FAILURE) {
-            unsigned int reason_code =
-                _libssh2_ntohu32(session->open_data + 5);
-            switch(reason_code) {
-            case SSH_OPEN_ADMINISTRATIVELY_PROHIBITED:
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Channel open failure "
-                               "(administratively prohibited)");
-                break;
-            case SSH_OPEN_CONNECT_FAILED:
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Channel open failure (connect failed)");
-                break;
-            case SSH_OPEN_UNKNOWN_CHANNELTYPE:
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Channel open failure (unknown channel type)");
-                break;
-            case SSH_OPEN_RESOURCE_SHORTAGE:
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Channel open failure (resource shortage)");
-                break;
-            default:
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Channel open failure");
-            }
-        }
-    }
-
-  channel_error:
-
-    if(session->open_data) {
-        LIBSSH2_FREE(session, session->open_data);
-        session->open_data = NULL;
-    }
-    if(session->open_packet) {
-        LIBSSH2_FREE(session, session->open_packet);
-        session->open_packet = NULL;
-    }
-    if(session->open_channel) {
-        unsigned char channel_id[4];
-        LIBSSH2_FREE(session, session->open_channel->channel_type);
-
-        _libssh2_list_remove(&session->open_channel->node);
-
-        /* Clear out packets meant for this channel */
-        _libssh2_htonu32(channel_id, session->open_channel->local.id);
-        while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA,
-                                    &session->open_data,
-                                    &session->open_data_len, 1,
-                                    channel_id, 4) >= 0)
-               ||
-               (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA,
-                                    &session->open_data,
-                                    &session->open_data_len, 1,
-                                    channel_id, 4) >= 0)) {
-            LIBSSH2_FREE(session, session->open_data);
-            session->open_data = NULL;
-        }
-
-        LIBSSH2_FREE(session, session->open_channel);
-        session->open_channel = NULL;
-    }
-
-    session->open_state = libssh2_NB_state_idle;
-    return NULL;
-}
-
-/*
- * libssh2_channel_open_ex
- *
- * Establish a generic session channel
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *type,
-                        unsigned int type_len,
-                        unsigned int window_size, unsigned int packet_size,
-                        const char *msg, unsigned int msg_len)
-{
-    LIBSSH2_CHANNEL *ptr;
-
-    if(!session)
-        return NULL;
-
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       _libssh2_channel_open(session, type, type_len,
-                                             window_size, packet_size,
-                                             (unsigned char *)msg,
-                                             msg_len));
-    return ptr;
-}
-
-/*
- * libssh2_channel_direct_tcpip_ex
- *
- * Tunnel TCP/IP connect through the SSH session to direct host/port
- */
-static LIBSSH2_CHANNEL *
-channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
-                     int port, const char *shost, int sport)
-{
-    LIBSSH2_CHANNEL *channel;
-    unsigned char *s;
-
-    if(session->direct_state == libssh2_NB_state_idle) {
-        session->direct_host_len = strlen(host);
-        session->direct_shost_len = strlen(shost);
-        /* host_len(4) + port(4) + shost_len(4) + sport(4) */
-        session->direct_message_len =
-            session->direct_host_len + session->direct_shost_len + 16;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting direct-tcpip session from %s:%d to %s:%d",
-                       shost, sport, host, port);
-
-        s = session->direct_message =
-            LIBSSH2_ALLOC(session, session->direct_message_len);
-        if(!session->direct_message) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for "
-                           "direct-tcpip connection");
-            return NULL;
-        }
-        _libssh2_store_str(&s, host, session->direct_host_len);
-        _libssh2_store_u32(&s, port);
-        _libssh2_store_str(&s, shost, session->direct_shost_len);
-        _libssh2_store_u32(&s, sport);
-    }
-
-    channel =
-        _libssh2_channel_open(session, "direct-tcpip",
-                              sizeof("direct-tcpip") - 1,
-                              LIBSSH2_CHANNEL_WINDOW_DEFAULT,
-                              LIBSSH2_CHANNEL_PACKET_DEFAULT,
-                              session->direct_message,
-                              session->direct_message_len);
-
-    if(!channel &&
-        libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
-        /* The error code is still set to LIBSSH2_ERROR_EAGAIN, set our state
-           to created to avoid re-creating the package on next invoke */
-        session->direct_state = libssh2_NB_state_created;
-        return NULL;
-    }
-    /* by default we set (keep?) idle state... */
-    session->direct_state = libssh2_NB_state_idle;
-
-    LIBSSH2_FREE(session, session->direct_message);
-    session->direct_message = NULL;
-
-    return channel;
-}
-
-/*
- * libssh2_channel_direct_tcpip_ex
- *
- * Tunnel TCP/IP connect through the SSH session to direct host/port
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
-                                int port, const char *shost, int sport)
-{
-    LIBSSH2_CHANNEL *ptr;
-
-    if(!session)
-        return NULL;
-
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       channel_direct_tcpip(session, host, port,
-                                            shost, sport));
-    return ptr;
-}
-
-/*
- * channel_forward_listen
- *
- * Bind a port on the remote host and listen for connections
- */
-static LIBSSH2_LISTENER *
-channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
-                       int port, int *bound_port, int queue_maxsize)
-{
-    unsigned char *s;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_REQUEST_SUCCESS, SSH_MSG_REQUEST_FAILURE, 0 };
-    int rc;
-
-    if(!host)
-        host = "0.0.0.0";
-
-    if(session->fwdLstn_state == libssh2_NB_state_idle) {
-        session->fwdLstn_host_len = strlen(host);
-        /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4)
-           + port(4) */
-        session->fwdLstn_packet_len =
-            session->fwdLstn_host_len + (sizeof("tcpip-forward") - 1) + 14;
-
-        /* Zero the whole thing out */
-        memset(&session->fwdLstn_packet_requirev_state, 0,
-               sizeof(session->fwdLstn_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting tcpip-forward session for %s:%d", host,
-                       port);
-
-        s = session->fwdLstn_packet =
-            LIBSSH2_ALLOC(session, session->fwdLstn_packet_len);
-        if(!session->fwdLstn_packet) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for setenv packet");
-            return NULL;
-        }
-
-        *(s++) = SSH_MSG_GLOBAL_REQUEST;
-        _libssh2_store_str(&s, "tcpip-forward", sizeof("tcpip-forward") - 1);
-        *(s++) = 0x01;          /* want_reply */
-
-        _libssh2_store_str(&s, host, session->fwdLstn_host_len);
-        _libssh2_store_u32(&s, port);
-
-        session->fwdLstn_state = libssh2_NB_state_created;
-    }
-
-    if(session->fwdLstn_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session,
-                                     session->fwdLstn_packet,
-                                     session->fwdLstn_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block sending global-request packet for "
-                           "forward listen request");
-            return NULL;
-        }
-        else if(rc) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send global-request packet for forward "
-                           "listen request");
-            LIBSSH2_FREE(session, session->fwdLstn_packet);
-            session->fwdLstn_packet = NULL;
-            session->fwdLstn_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-        LIBSSH2_FREE(session, session->fwdLstn_packet);
-        session->fwdLstn_packet = NULL;
-
-        session->fwdLstn_state = libssh2_NB_state_sent;
-    }
-
-    if(session->fwdLstn_state == libssh2_NB_state_sent) {
-        unsigned char *data;
-        size_t data_len;
-        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
-                                      0, NULL, 0,
-                                      &session->fwdLstn_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block");
-            return NULL;
-        }
-        else if(rc || (data_len < 1)) {
-            _libssh2_error(session, LIBSSH2_ERROR_PROTO, "Unknown");
-            session->fwdLstn_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-
-        if(data[0] == SSH_MSG_REQUEST_SUCCESS) {
-            LIBSSH2_LISTENER *listener;
-
-            listener = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_LISTENER));
-            if(!listener)
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "Unable to allocate memory for listener queue");
-            else {
-                listener->host =
-                    LIBSSH2_ALLOC(session, session->fwdLstn_host_len + 1);
-                if(!listener->host) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory "
-                                   "for listener queue");
-                    LIBSSH2_FREE(session, listener);
-                    listener = NULL;
-                }
-                else {
-                    listener->session = session;
-                    memcpy(listener->host, host, session->fwdLstn_host_len);
-                    listener->host[session->fwdLstn_host_len] = 0;
-                    if(data_len >= 5 && !port) {
-                        listener->port = _libssh2_ntohu32(data + 1);
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                       "Dynamic tcpip-forward port "
-                                       "allocated: %d",
-                                       listener->port);
-                    }
-                    else
-                        listener->port = port;
-
-                    listener->queue_size = 0;
-                    listener->queue_maxsize = queue_maxsize;
-
-                    /* append this to the parent's list of listeners */
-                    _libssh2_list_add(&session->listeners, &listener->node);
-
-                    if(bound_port) {
-                        *bound_port = listener->port;
-                    }
-                }
-            }
-
-            LIBSSH2_FREE(session, data);
-            session->fwdLstn_state = libssh2_NB_state_idle;
-            return listener;
-        }
-        else if(data[0] == SSH_MSG_REQUEST_FAILURE) {
-            LIBSSH2_FREE(session, data);
-            _libssh2_error(session, LIBSSH2_ERROR_REQUEST_DENIED,
-                           "Unable to complete request for forward-listen");
-            session->fwdLstn_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-    }
-
-    session->fwdLstn_state = libssh2_NB_state_idle;
-
-    return NULL;
-}
-
-/*
- * libssh2_channel_forward_listen_ex
- *
- * Bind a port on the remote host and listen for connections
- */
-LIBSSH2_API LIBSSH2_LISTENER *
-libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host,
-                                  int port, int *bound_port, int queue_maxsize)
-{
-    LIBSSH2_LISTENER *ptr;
-
-    if(!session)
-        return NULL;
-
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       channel_forward_listen(session, host, port, bound_port,
-                                              queue_maxsize));
-    return ptr;
-}
-
-/*
- * _libssh2_channel_forward_cancel
- *
- * Stop listening on a remote port and free the listener
- * Toss out any pending (un-accept()ed) connections
- *
- * Return 0 on success, LIBSSH2_ERROR_EAGAIN if would block, -1 on error
- */
-int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
-{
-    LIBSSH2_SESSION *session = listener->session;
-    LIBSSH2_CHANNEL *queued;
-    unsigned char *packet, *s;
-    size_t host_len = strlen(listener->host);
-    /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4) +
-       port(4) */
-    size_t packet_len =
-        host_len + 14 + sizeof("cancel-tcpip-forward") - 1;
-    int rc;
-    int retcode = 0;
-
-    if(listener->chanFwdCncl_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Cancelling tcpip-forward session for %s:%d",
-                       listener->host, listener->port);
-
-        s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!packet) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for setenv packet");
-            return LIBSSH2_ERROR_ALLOC;
-        }
-
-        *(s++) = SSH_MSG_GLOBAL_REQUEST;
-        _libssh2_store_str(&s, "cancel-tcpip-forward",
-                           sizeof("cancel-tcpip-forward") - 1);
-        *(s++) = 0x00;          /* want_reply */
-
-        _libssh2_store_str(&s, listener->host, host_len);
-        _libssh2_store_u32(&s, listener->port);
-
-        listener->chanFwdCncl_state = libssh2_NB_state_created;
-    }
-    else {
-        packet = listener->chanFwdCncl_data;
-    }
-
-    if(listener->chanFwdCncl_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, packet, packet_len, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending forward request");
-            listener->chanFwdCncl_data = packet;
-            return rc;
-        }
-        else if(rc) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send global-request packet for forward "
-                           "listen request");
-            /* set the state to something we don't check for, for the
-               unfortunate situation where we get an EAGAIN further down
-               when trying to bail out due to errors! */
-            listener->chanFwdCncl_state = libssh2_NB_state_sent;
-            retcode = LIBSSH2_ERROR_SOCKET_SEND;
-        }
-        LIBSSH2_FREE(session, packet);
-
-        listener->chanFwdCncl_state = libssh2_NB_state_sent;
-    }
-
-    queued = _libssh2_list_first(&listener->queue);
-    while(queued) {
-        LIBSSH2_CHANNEL *next = _libssh2_list_next(&queued->node);
-
-        rc = _libssh2_channel_free(queued);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        queued = next;
-    }
-    LIBSSH2_FREE(session, listener->host);
-
-    /* remove this entry from the parent's list of listeners */
-    _libssh2_list_remove(&listener->node);
-
-    LIBSSH2_FREE(session, listener);
-
-    return retcode;
-}
-
-/*
- * libssh2_channel_forward_cancel
- *
- * Stop listening on a remote port and free the listener
- * Toss out any pending (un-accept()ed) connections
- *
- * Return 0 on success, LIBSSH2_ERROR_EAGAIN if would block, -1 on error
- */
-LIBSSH2_API int
-libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
-{
-    int rc;
-
-    if(!listener)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, listener->session,
-                 _libssh2_channel_forward_cancel(listener));
-    return rc;
-}
-
-/*
- * channel_forward_accept
- *
- * Accept a connection
- */
-static LIBSSH2_CHANNEL *
-channel_forward_accept(LIBSSH2_LISTENER *listener)
-{
-    int rc;
-
-    do {
-        rc = _libssh2_transport_read(listener->session);
-    } while(rc > 0);
-
-    if(_libssh2_list_first(&listener->queue)) {
-        LIBSSH2_CHANNEL *channel = _libssh2_list_first(&listener->queue);
-
-        /* detach channel from listener's queue */
-        _libssh2_list_remove(&channel->node);
-
-        listener->queue_size--;
-
-        /* add channel to session's channel list */
-        _libssh2_list_add(&channel->session->channels, &channel->node);
-
-        return channel;
-    }
-
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        _libssh2_error(listener->session, LIBSSH2_ERROR_EAGAIN,
-                       "Would block waiting for packet");
-    }
-    else
-        _libssh2_error(listener->session, LIBSSH2_ERROR_CHANNEL_UNKNOWN,
-                       "Channel not found");
-    return NULL;
-}
-
-/*
- * libssh2_channel_forward_accept
- *
- * Accept a connection
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener)
-{
-    LIBSSH2_CHANNEL *ptr;
-
-    if(!listener)
-        return NULL;
-
-    BLOCK_ADJUST_ERRNO(ptr, listener->session,
-                       channel_forward_accept(listener));
-    return ptr;
-
-}
-
-/*
- * channel_setenv
- *
- * Set an environment variable prior to requesting a shell/program/subsystem
- */
-static int channel_setenv(LIBSSH2_CHANNEL *channel,
-                          const char *varname, unsigned int varname_len,
-                          const char *value, unsigned int value_len)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s, *data;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
-    size_t data_len;
-    int rc;
-
-    if(channel->setenv_state == libssh2_NB_state_idle) {
-        /* 21 = packet_type(1) + channel_id(4) + request_len(4) +
-         * request(3)"env" + want_reply(1) + varname_len(4) + value_len(4) */
-        channel->setenv_packet_len = varname_len + value_len + 21;
-
-        /* Zero the whole thing out */
-        memset(&channel->setenv_packet_requirev_state, 0,
-               sizeof(channel->setenv_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Setting remote environment variable: %s=%s on "
-                       "channel %lu/%lu",
-                       varname, value, channel->local.id, channel->remote.id);
-
-        s = channel->setenv_packet =
-            LIBSSH2_ALLOC(session, channel->setenv_packet_len);
-        if(!channel->setenv_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory "
-                                  "for setenv packet");
-        }
-
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, "env", sizeof("env") - 1);
-        *(s++) = 0x01;
-        _libssh2_store_str(&s, varname, varname_len);
-        _libssh2_store_str(&s, value, value_len);
-
-        channel->setenv_state = libssh2_NB_state_created;
-    }
-
-    if(channel->setenv_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session,
-                                     channel->setenv_packet,
-                                     channel->setenv_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending setenv request");
-            return rc;
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, channel->setenv_packet);
-            channel->setenv_packet = NULL;
-            channel->setenv_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send channel-request packet for "
-                                  "setenv request");
-        }
-        LIBSSH2_FREE(session, channel->setenv_packet);
-        channel->setenv_packet = NULL;
-
-        _libssh2_htonu32(channel->setenv_local_channel, channel->local.id);
-
-        channel->setenv_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->setenv_state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
-                                      1, channel->setenv_local_channel, 4,
-                                      &channel->
-                                      setenv_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        if(rc) {
-            channel->setenv_state = libssh2_NB_state_idle;
-            return rc;
-        }
-        else if(data_len < 1) {
-            channel->setenv_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Unexpected packet size");
-        }
-
-        if(data[0] == SSH_MSG_CHANNEL_SUCCESS) {
-            LIBSSH2_FREE(session, data);
-            channel->setenv_state = libssh2_NB_state_idle;
-            return 0;
-        }
-
-        LIBSSH2_FREE(session, data);
-    }
-
-    channel->setenv_state = libssh2_NB_state_idle;
-    return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
-                          "Unable to complete request for channel-setenv");
-}
-
-/*
- * libssh2_channel_setenv_ex
- *
- * Set an environment variable prior to requesting a shell/program/subsystem
- */
-LIBSSH2_API int
-libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel,
-                          const char *varname, unsigned int varname_len,
-                          const char *value, unsigned int value_len)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 channel_setenv(channel, varname, varname_len,
-                                value, value_len));
-    return rc;
-}
-
-/*
- * channel_request_pty
- * Duh... Request a PTY
- */
-static int channel_request_pty(LIBSSH2_CHANNEL *channel,
-                               const char *term, unsigned int term_len,
-                               const char *modes, unsigned int modes_len,
-                               int width, int height,
-                               int width_px, int height_px)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
-    int rc;
-
-    if(channel->reqPTY_state == libssh2_NB_state_idle) {
-        /* 41 = packet_type(1) + channel(4) + pty_req_len(4) + "pty_req"(7) +
-         * want_reply(1) + term_len(4) + width(4) + height(4) + width_px(4) +
-         * height_px(4) + modes_len(4) */
-        if(term_len + modes_len > 256) {
-            return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                                  "term + mode lengths too large");
-        }
-
-        channel->reqPTY_packet_len = term_len + modes_len + 41;
-
-        /* Zero the whole thing out */
-        memset(&channel->reqPTY_packet_requirev_state, 0,
-               sizeof(channel->reqPTY_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Allocating tty on channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
-
-        s = channel->reqPTY_packet;
-
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, (char *)"pty-req", sizeof("pty-req") - 1);
-
-        *(s++) = 0x01;
-
-        _libssh2_store_str(&s, term, term_len);
-        _libssh2_store_u32(&s, width);
-        _libssh2_store_u32(&s, height);
-        _libssh2_store_u32(&s, width_px);
-        _libssh2_store_u32(&s, height_px);
-        _libssh2_store_str(&s, modes, modes_len);
-
-        channel->reqPTY_state = libssh2_NB_state_created;
-    }
-
-    if(channel->reqPTY_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, channel->reqPTY_packet,
-                                     channel->reqPTY_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending pty request");
-            return rc;
-        }
-        else if(rc) {
-            channel->reqPTY_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "Unable to send pty-request packet");
-        }
-        _libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id);
-
-        channel->reqPTY_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->reqPTY_state == libssh2_NB_state_sent) {
-        unsigned char *data;
-        size_t data_len;
-        unsigned char code;
-        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
-                                      1, channel->reqPTY_local_channel, 4,
-                                      &channel->reqPTY_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc || data_len < 1) {
-            channel->reqPTY_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Failed to require the PTY package");
-        }
-
-        code = data[0];
-
-        LIBSSH2_FREE(session, data);
-        channel->reqPTY_state = libssh2_NB_state_idle;
-
-        if(code == SSH_MSG_CHANNEL_SUCCESS)
-            return 0;
-    }
-
-    return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
-                          "Unable to complete request for "
-                          "channel request-pty");
-}
-
-/**
- * channel_request_auth_agent
- * The actual re-entrant method which requests an auth agent.
- * */
-static int channel_request_auth_agent(LIBSSH2_CHANNEL *channel,
-                                      const char *request_str,
-                                      int request_str_len)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
-    int rc;
-
-    if(channel->req_auth_agent_state == libssh2_NB_state_idle) {
-        /* Only valid options are "auth-agent-req" and
-         * "auth-agent-req_at_openssh.com" so we make sure it is not
-         * actually longer than the longest possible. */
-        if(request_str_len > 26) {
-            return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                                  "request_str length too large");
-        }
-
-        /*
-         *  Length: 24 or 36 = packet_type(1) + channel(4) + req_len(4) +
-         *    request_str (variable) + want_reply (1) */
-        channel->req_auth_agent_packet_len = 10 + request_str_len;
-
-        /* Zero out the requireev state to reset */
-        memset(&channel->req_auth_agent_requirev_state, 0,
-               sizeof(channel->req_auth_agent_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting auth agent on channel %lu/%lu",
-                       channel->local.id, channel->remote.id);
-
-        /*
-         *  byte      SSH_MSG_CHANNEL_REQUEST
-         *  uint32    recipient channel
-         *  string    "auth-agent-req"
-         *  boolean   want reply
-         * */
-        s = channel->req_auth_agent_packet;
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, (char *)request_str, request_str_len);
-        *(s++) = 0x01;
-
-        channel->req_auth_agent_state = libssh2_NB_state_created;
-    }
-
-    if(channel->req_auth_agent_state == libssh2_NB_state_created) {
-        /* Send the packet, we can use sizeof() on the packet because it
-         * is always completely filled; there are no variable length fields. */
-        rc = _libssh2_transport_send(session, channel->req_auth_agent_packet,
-                                     channel->req_auth_agent_packet_len,
-                                     NULL, 0);
-
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending auth-agent request");
-        }
-        else if(rc) {
-            channel->req_auth_agent_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "Unable to send auth-agent request");
-        }
-        _libssh2_htonu32(channel->req_auth_agent_local_channel,
-                         channel->local.id);
-        channel->req_auth_agent_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->req_auth_agent_state == libssh2_NB_state_sent) {
-        unsigned char *data;
-        size_t data_len;
-        unsigned char code;
-
-        rc = _libssh2_packet_requirev(
-            session, reply_codes, &data, &data_len, 1,
-            channel->req_auth_agent_local_channel,
-            4, &channel->req_auth_agent_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            channel->req_auth_agent_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Failed to request auth-agent");
-        }
-
-        code = data[0];
-
-        LIBSSH2_FREE(session, data);
-        channel->req_auth_agent_state = libssh2_NB_state_idle;
-
-        if(code == SSH_MSG_CHANNEL_SUCCESS)
-            return 0;
-    }
-
-    return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
-                          "Unable to complete request for auth-agent");
-}
-
-/**
- * libssh2_channel_request_auth_agent
- * Requests that agent forwarding be enabled for the session. The
- * request must be sent over a specific channel, which starts the agent
- * listener on the remote side. Once the channel is closed, the agent
- * listener continues to exist.
- * */
-LIBSSH2_API int
-libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    /* The current RFC draft for agent forwarding says you're supposed to
-     * send "auth-agent-req," but most SSH servers out there right now
-     * actually expect "auth-agent-req@openssh.com", so we try that
-     * first. */
-    if(channel->req_auth_agent_try_state == libssh2_NB_state_idle) {
-        BLOCK_ADJUST(rc, channel->session,
-                     channel_request_auth_agent(channel,
-                                                "auth-agent-req@openssh.com",
-                                                26));
-
-        /* If we failed (but not with EAGAIN), then we move onto
-         * the next step to try another request type. */
-        if(rc != 0 && rc != LIBSSH2_ERROR_EAGAIN)
-            channel->req_auth_agent_try_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->req_auth_agent_try_state == libssh2_NB_state_sent) {
-        BLOCK_ADJUST(rc, channel->session,
-                     channel_request_auth_agent(channel,
-                                                "auth-agent-req", 14));
-
-        /* If we failed without an EAGAIN, then move on with this
-         * state machine. */
-        if(rc != 0 && rc != LIBSSH2_ERROR_EAGAIN)
-            channel->req_auth_agent_try_state = libssh2_NB_state_sent1;
-    }
-
-    /* If things are good, reset the try state. */
-    if(rc == 0)
-        channel->req_auth_agent_try_state = libssh2_NB_state_idle;
-
-    return rc;
-}
-
-/*
- * libssh2_channel_request_pty_ex
- * Duh... Request a PTY
- */
-LIBSSH2_API int
-libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term,
-                               unsigned int term_len, const char *modes,
-                               unsigned int modes_len, int width, int height,
-                               int width_px, int height_px)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 channel_request_pty(channel, term, term_len, modes,
-                                     modes_len, width, height,
-                                     width_px, height_px));
-    return rc;
-}
-
-static int
-channel_request_pty_size(LIBSSH2_CHANNEL * channel, int width,
-                         int height, int width_px, int height_px)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s;
-    int rc;
-    int retcode = LIBSSH2_ERROR_PROTO;
-
-    if(channel->reqPTY_state == libssh2_NB_state_idle) {
-        channel->reqPTY_packet_len = 39;
-
-        /* Zero the whole thing out */
-        memset(&channel->reqPTY_packet_requirev_state, 0,
-               sizeof(channel->reqPTY_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-            "changing tty size on channel %lu/%lu",
-            channel->local.id,
-            channel->remote.id);
-
-        s = channel->reqPTY_packet;
-
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, (char *)"window-change",
-                           sizeof("window-change") - 1);
-        *(s++) = 0x00; /* Don't reply */
-        _libssh2_store_u32(&s, width);
-        _libssh2_store_u32(&s, height);
-        _libssh2_store_u32(&s, width_px);
-        _libssh2_store_u32(&s, height_px);
-
-        channel->reqPTY_state = libssh2_NB_state_created;
-    }
-
-    if(channel->reqPTY_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, channel->reqPTY_packet,
-                                     channel->reqPTY_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending window-change request");
-            return rc;
-        }
-        else if(rc) {
-            channel->reqPTY_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "Unable to send window-change packet");
-        }
-        _libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id);
-        retcode = LIBSSH2_ERROR_NONE;
-    }
-
-    channel->reqPTY_state = libssh2_NB_state_idle;
-    return retcode;
-}
-
-LIBSSH2_API int
-libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel, int width,
-                                    int height, int width_px, int height_px)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 channel_request_pty_size(channel, width, height, width_px,
-                                          height_px));
-    return rc;
-}
-
-/* Keep this an even number */
-#define LIBSSH2_X11_RANDOM_COOKIE_LEN       32
-
-/*
- * channel_x11_req
- * Request X11 forwarding
- */
-static int
-channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
-                const char *auth_proto, const char *auth_cookie,
-                int screen_number)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
-    size_t proto_len =
-        auth_proto ? strlen(auth_proto) : (sizeof("MIT-MAGIC-COOKIE-1") - 1);
-    size_t cookie_len =
-        auth_cookie ? strlen(auth_cookie) : LIBSSH2_X11_RANDOM_COOKIE_LEN;
-    int rc;
-
-    if(channel->reqX11_state == libssh2_NB_state_idle) {
-        /* 30 = packet_type(1) + channel(4) + x11_req_len(4) + "x11-req"(7) +
-         * want_reply(1) + single_cnx(1) + proto_len(4) + cookie_len(4) +
-         * screen_num(4) */
-        channel->reqX11_packet_len = proto_len + cookie_len + 30;
-
-        /* Zero the whole thing out */
-        memset(&channel->reqX11_packet_requirev_state, 0,
-               sizeof(channel->reqX11_packet_requirev_state));
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting x11-req for channel %lu/%lu: single=%d "
-                       "proto=%s cookie=%s screen=%d",
-                       channel->local.id, channel->remote.id,
-                       single_connection,
-                       auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
-                       auth_cookie ? auth_cookie : "<random>", screen_number);
-
-        s = channel->reqX11_packet =
-            LIBSSH2_ALLOC(session, channel->reqX11_packet_len);
-        if(!channel->reqX11_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for pty-request");
-        }
-
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, "x11-req", sizeof("x11-req") - 1);
-
-        *(s++) = 0x01;          /* want_reply */
-        *(s++) = single_connection ? 0x01 : 0x00;
-
-        _libssh2_store_str(&s, auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
-                           proto_len);
-
-        _libssh2_store_u32(&s, cookie_len);
-        if(auth_cookie) {
-            memcpy(s, auth_cookie, cookie_len);
-        }
-        else {
-            int i;
-            /* note: the extra +1 below is necessary since the sprintf()
-               loop will always write 3 bytes so the last one will write
-               the trailing zero at the LIBSSH2_X11_RANDOM_COOKIE_LEN/2
-               border */
-            unsigned char buffer[(LIBSSH2_X11_RANDOM_COOKIE_LEN / 2) + 1];
-
-            if(_libssh2_random(buffer, LIBSSH2_X11_RANDOM_COOKIE_LEN / 2)) {
-                return _libssh2_error(session, LIBSSH2_ERROR_RANDGEN,
-                                      "Unable to get random bytes "
-                                      "for x11-req cookie");
-            }
-            for(i = 0; i < (LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); i++) {
-                snprintf((char *)&s[i*2], 3, "%02X", buffer[i]);
-            }
-        }
-        s += cookie_len;
-
-        _libssh2_store_u32(&s, screen_number);
-        channel->reqX11_state = libssh2_NB_state_created;
-    }
-
-    if(channel->reqX11_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, channel->reqX11_packet,
-                                     channel->reqX11_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending X11-req packet");
-            return rc;
-        }
-        if(rc) {
-            LIBSSH2_FREE(session, channel->reqX11_packet);
-            channel->reqX11_packet = NULL;
-            channel->reqX11_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "Unable to send x11-req packet");
-        }
-        LIBSSH2_FREE(session, channel->reqX11_packet);
-        channel->reqX11_packet = NULL;
-
-        _libssh2_htonu32(channel->reqX11_local_channel, channel->local.id);
-
-        channel->reqX11_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->reqX11_state == libssh2_NB_state_sent) {
-        size_t data_len;
-        unsigned char *data;
-        unsigned char code;
-
-        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
-                                      1, channel->reqX11_local_channel, 4,
-                                      &channel->reqX11_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc || data_len < 1) {
-            channel->reqX11_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "waiting for x11-req response packet");
-        }
-
-        code = data[0];
-        LIBSSH2_FREE(session, data);
-        channel->reqX11_state = libssh2_NB_state_idle;
-
-        if(code == SSH_MSG_CHANNEL_SUCCESS)
-            return 0;
-    }
-
-    return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
-                          "Unable to complete request for channel x11-req");
-}
-
-/*
- * libssh2_channel_x11_req_ex
- * Request X11 forwarding
- */
-LIBSSH2_API int
-libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection,
-                           const char *auth_proto, const char *auth_cookie,
-                           int screen_number)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 channel_x11_req(channel, single_connection, auth_proto,
-                                 auth_cookie, screen_number));
-    return rc;
-}
-
-
-/*
- * _libssh2_channel_process_startup
- *
- * Primitive for libssh2_channel_(shell|exec|subsystem)
- */
-int
-_libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                 const char *request, size_t request_len,
-                                 const char *message, size_t message_len)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *s;
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
-    int rc;
-
-    if(channel->process_state == libssh2_NB_state_end) {
-        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-                              "Channel can not be reused");
-    }
-
-    if(channel->process_state == libssh2_NB_state_idle) {
-        /* 10 = packet_type(1) + channel(4) + request_len(4) + want_reply(1) */
-        channel->process_packet_len = request_len + 10;
-
-        /* Zero the whole thing out */
-        memset(&channel->process_packet_requirev_state, 0,
-               sizeof(channel->process_packet_requirev_state));
-
-        if(message)
-            channel->process_packet_len += + 4;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "starting request(%s) on channel %lu/%lu, message=%s",
-                       request, channel->local.id, channel->remote.id,
-                       message ? message : "<null>");
-        s = channel->process_packet =
-            LIBSSH2_ALLOC(session, channel->process_packet_len);
-        if(!channel->process_packet)
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory "
-                                  "for channel-process request");
-
-        *(s++) = SSH_MSG_CHANNEL_REQUEST;
-        _libssh2_store_u32(&s, channel->remote.id);
-        _libssh2_store_str(&s, request, request_len);
-        *(s++) = 0x01;
-
-        if(message)
-            _libssh2_store_u32(&s, message_len);
-
-        channel->process_state = libssh2_NB_state_created;
-    }
-
-    if(channel->process_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session,
-                                     channel->process_packet,
-                                     channel->process_packet_len,
-                                     (unsigned char *)message, message_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending channel request");
-            return rc;
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, channel->process_packet);
-            channel->process_packet = NULL;
-            channel->process_state = libssh2_NB_state_end;
-            return _libssh2_error(session, rc,
-                                  "Unable to send channel request");
-        }
-        LIBSSH2_FREE(session, channel->process_packet);
-        channel->process_packet = NULL;
-
-        _libssh2_htonu32(channel->process_local_channel, channel->local.id);
-
-        channel->process_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->process_state == libssh2_NB_state_sent) {
-        unsigned char *data;
-        size_t data_len;
-        unsigned char code;
-        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
-                                      1, channel->process_local_channel, 4,
-                                      &channel->process_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc || data_len < 1) {
-            channel->process_state = libssh2_NB_state_end;
-            return _libssh2_error(session, rc,
-                                  "Failed waiting for channel success");
-        }
-
-        code = data[0];
-        LIBSSH2_FREE(session, data);
-        channel->process_state = libssh2_NB_state_end;
-
-        if(code == SSH_MSG_CHANNEL_SUCCESS)
-            return 0;
-    }
-
-    return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
-                          "Unable to complete request for "
-                          "channel-process-startup");
-}
-
-/*
- * libssh2_channel_process_startup
- *
- * Primitive for libssh2_channel_(shell|exec|subsystem)
- */
-LIBSSH2_API int
-libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                const char *req, unsigned int req_len,
-                                const char *msg, unsigned int msg_len)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_process_startup(channel, req, req_len,
-                                                  msg, msg_len));
-    return rc;
-}
-
-
-/*
- * libssh2_channel_set_blocking
- *
- * Set a channel's BEHAVIOR blocking on or off. The socket will remain non-
- * blocking.
- */
-LIBSSH2_API void
-libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking)
-{
-    if(channel)
-        (void) _libssh2_session_set_blocking(channel->session, blocking);
-}
-
-/*
- * _libssh2_channel_flush
- *
- * Flush data from one (or all) stream
- * Returns number of bytes flushed, or negative on failure
- */
-int
-_libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
-{
-    if(channel->flush_state == libssh2_NB_state_idle) {
-        LIBSSH2_PACKET *packet =
-            _libssh2_list_first(&channel->session->packets);
-        channel->flush_refund_bytes = 0;
-        channel->flush_flush_bytes = 0;
-
-        while(packet) {
-            unsigned char packet_type;
-            LIBSSH2_PACKET *next = _libssh2_list_next(&packet->node);
-
-            if(packet->data_len < 1) {
-                packet = next;
-                _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                               "Unexpected packet length");
-                continue;
-            }
-
-            packet_type = packet->data[0];
-
-            if(((packet_type == SSH_MSG_CHANNEL_DATA)
-                || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
-               && ((packet->data_len >= 5)
-                   && (_libssh2_ntohu32(packet->data + 1)
-                       == channel->local.id))) {
-                /* It's our channel at least */
-                int packet_stream_id;
-
-                if(packet_type == SSH_MSG_CHANNEL_DATA) {
-                    packet_stream_id = 0;
-                }
-                else if(packet->data_len >= 9) {
-                    packet_stream_id = _libssh2_ntohu32(packet->data + 5);
-                }
-                else {
-                    channel->flush_state = libssh2_NB_state_idle;
-                    return _libssh2_error(channel->session,
-                                          LIBSSH2_ERROR_PROTO,
-                                          "Unexpected packet length");
-                }
-
-                if((streamid == LIBSSH2_CHANNEL_FLUSH_ALL)
-                    || ((packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA)
-                        && ((streamid == LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA)
-                            || (streamid == packet_stream_id)))
-                    || ((packet_type == SSH_MSG_CHANNEL_DATA)
-                        && (streamid == 0))) {
-                    size_t bytes_to_flush = packet->data_len -
-                        packet->data_head;
-
-                    _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                                   "Flushing %d bytes of data from stream "
-                                   "%lu on channel %lu/%lu",
-                                   bytes_to_flush, packet_stream_id,
-                                   channel->local.id, channel->remote.id);
-
-                    /* It's one of the streams we wanted to flush */
-                    channel->flush_refund_bytes += packet->data_len - 13;
-                    channel->flush_flush_bytes += bytes_to_flush;
-
-                    LIBSSH2_FREE(channel->session, packet->data);
-
-                    /* remove this packet from the parent's list */
-                    _libssh2_list_remove(&packet->node);
-                    LIBSSH2_FREE(channel->session, packet);
-                }
-            }
-            packet = next;
-        }
-
-        channel->flush_state = libssh2_NB_state_created;
-    }
-
-    channel->read_avail -= channel->flush_flush_bytes;
-    channel->remote.window_size -= channel->flush_flush_bytes;
-
-    if(channel->flush_refund_bytes) {
-        int rc =
-            _libssh2_channel_receive_window_adjust(channel,
-                                                   channel->flush_refund_bytes,
-                                                   1, NULL);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-    }
-
-    channel->flush_state = libssh2_NB_state_idle;
-
-    return channel->flush_flush_bytes;
-}
-
-/*
- * libssh2_channel_flush_ex
- *
- * Flush data from one (or all) stream
- * Returns number of bytes flushed, or negative on failure
- */
-LIBSSH2_API int
-libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int stream)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_flush(channel, stream));
-    return rc;
-}
-
-/*
- * libssh2_channel_get_exit_status
- *
- * Return the channel's program exit status. Note that the actual protocol
- * provides the full 32bit this function returns.  We cannot abuse it to
- * return error values in case of errors so we return a zero if channel is
- * NULL.
- */
-LIBSSH2_API int
-libssh2_channel_get_exit_status(LIBSSH2_CHANNEL *channel)
-{
-    if(!channel)
-        return 0;
-
-    return channel->exit_status;
-}
-
-/*
- * libssh2_channel_get_exit_signal
- *
- * Get exit signal (without leading "SIG"), error message, and language
- * tag into newly allocated buffers of indicated length.  Caller can
- * use NULL pointers to indicate that the value should not be set.  The
- * *_len variables are set if they are non-NULL even if the
- * corresponding string parameter is NULL.  Returns LIBSSH2_ERROR_NONE
- * on success, or an API error code.
- */
-LIBSSH2_API int
-libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel,
-                                char **exitsignal,
-                                size_t *exitsignal_len,
-                                char **errmsg,
-                                size_t *errmsg_len,
-                                char **langtag,
-                                size_t *langtag_len)
-{
-    size_t namelen = 0;
-
-    if(channel) {
-        LIBSSH2_SESSION *session = channel->session;
-
-        if(channel->exit_signal) {
-            namelen = strlen(channel->exit_signal);
-            if(exitsignal) {
-                *exitsignal = LIBSSH2_ALLOC(session, namelen + 1);
-                if(!*exitsignal) {
-                    return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                        "Unable to allocate memory for signal name");
-                }
-                memcpy(*exitsignal, channel->exit_signal, namelen);
-                (*exitsignal)[namelen] = '\0';
-            }
-            if(exitsignal_len)
-                *exitsignal_len = namelen;
-        }
-        else {
-            if(exitsignal)
-                *exitsignal = NULL;
-            if(exitsignal_len)
-                *exitsignal_len = 0;
-        }
-
-        /* TODO: set error message and language tag */
-
-        if(errmsg)
-            *errmsg = NULL;
-
-        if(errmsg_len)
-            *errmsg_len = 0;
-
-        if(langtag)
-            *langtag = NULL;
-
-        if(langtag_len)
-            *langtag_len = 0;
-    }
-
-    return LIBSSH2_ERROR_NONE;
-}
-
-/*
- * _libssh2_channel_receive_window_adjust
- *
- * Adjust the receive window for a channel by adjustment bytes. If the amount
- * to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
- * adjustment amount will be queued for a later packet.
- *
- * Calls _libssh2_error() !
- */
-int
-_libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
-                                       uint32_t adjustment,
-                                       unsigned char force,
-                                       unsigned int *store)
-{
-    int rc;
-
-    if(store)
-        *store = channel->remote.window_size;
-
-    if(channel->adjust_state == libssh2_NB_state_idle) {
-        if(!force
-            && (adjustment + channel->adjust_queue <
-                LIBSSH2_CHANNEL_MINADJUST)) {
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                           "Queueing %lu bytes for receive window adjustment "
-                           "for channel %lu/%lu",
-                           adjustment, channel->local.id, channel->remote.id);
-            channel->adjust_queue += adjustment;
-            return 0;
-        }
-
-        if(!adjustment && !channel->adjust_queue) {
-            return 0;
-        }
-
-        adjustment += channel->adjust_queue;
-        channel->adjust_queue = 0;
-
-        /* Adjust the window based on the block we just freed */
-        channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
-        _libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id);
-        _libssh2_htonu32(&channel->adjust_adjust[5], adjustment);
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Adjusting window %lu bytes for data on "
-                       "channel %lu/%lu",
-                       adjustment, channel->local.id, channel->remote.id);
-
-        channel->adjust_state = libssh2_NB_state_created;
-    }
-
-    rc = _libssh2_transport_send(channel->session, channel->adjust_adjust, 9,
-                                 NULL, 0);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        _libssh2_error(channel->session, rc,
-                       "Would block sending window adjust");
-        return rc;
-    }
-    else if(rc) {
-        channel->adjust_queue = adjustment;
-        return _libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND,
-                              "Unable to send transfer-window adjustment "
-                              "packet, deferring");
-    }
-    else {
-        channel->remote.window_size += adjustment;
-    }
-
-    channel->adjust_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/*
- * libssh2_channel_receive_window_adjust
- *
- * DEPRECATED
- *
- * Adjust the receive window for a channel by adjustment bytes. If the amount
- * to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
- * adjustment amount will be queued for a later packet.
- *
- * Returns the new size of the receive window (as understood by remote end).
- * Note that it might return EAGAIN too which is highly stupid.
- *
- */
-LIBSSH2_API unsigned long
-libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
-                                      unsigned long adj,
-                                      unsigned char force)
-{
-    unsigned int window;
-    int rc;
-
-    if(!channel)
-        return (unsigned long)LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_receive_window_adjust(channel, adj,
-                                                        force, &window));
-
-    /* stupid - but this is how it was made to work before and this is just
-       kept for backwards compatibility */
-    return rc ? (unsigned long)rc : window;
-}
-
-/*
- * libssh2_channel_receive_window_adjust2
- *
- * Adjust the receive window for a channel by adjustment bytes. If the amount
- * to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
- * adjustment amount will be queued for a later packet.
- *
- * Stores the new size of the receive window in the data 'window' points to.
- *
- * Returns the "normal" error code: 0 for success, negative for failure.
- */
-LIBSSH2_API int
-libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
-                                       unsigned long adj,
-                                       unsigned char force,
-                                       unsigned int *window)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_receive_window_adjust(channel, adj, force,
-                                                        window));
-    return rc;
-}
-
-int
-_libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
-{
-    if(channel->extData2_state == libssh2_NB_state_idle) {
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Setting channel %lu/%lu handle_extended_data"
-                       " mode to %d",
-                       channel->local.id, channel->remote.id, ignore_mode);
-        channel->remote.extended_data_ignore_mode = (char)ignore_mode;
-
-        channel->extData2_state = libssh2_NB_state_created;
-    }
-
-    if(channel->extData2_state == libssh2_NB_state_idle) {
-        if(ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) {
-            int rc =
-                _libssh2_channel_flush(channel,
-                                       LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA);
-            if(LIBSSH2_ERROR_EAGAIN == rc)
-                return rc;
-        }
-    }
-
-    channel->extData2_state = libssh2_NB_state_idle;
-    return 0;
-}
-
-/*
- * libssh2_channel_handle_extended_data2()
- *
- */
-LIBSSH2_API int
-libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
-                                      int mode)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, _libssh2_channel_extended_data(channel,
-                                                                      mode));
-    return rc;
-}
-
-/*
- * libssh2_channel_handle_extended_data
- *
- * DEPRECATED DO NOTE USE!
- *
- * How should extended data look to the calling app?  Keep it in separate
- * channels[_read() _read_stdder()]? (NORMAL) Merge the extended data to the
- * standard data? [everything via _read()]? (MERGE) Ignore it entirely [toss
- * out packets as they come in]? (IGNORE)
- */
-LIBSSH2_API void
-libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
-                                     int ignore_mode)
-{
-    (void)libssh2_channel_handle_extended_data2(channel, ignore_mode);
-}
-
-
-
-/*
- * _libssh2_channel_read
- *
- * Read data from a channel
- *
- * It is important to not return 0 until the currently read channel is
- * complete. If we read stuff from the wire but it was no payload data to fill
- * in the buffer with, we MUST make sure to return LIBSSH2_ERROR_EAGAIN.
- *
- * The receive window must be maintained (enlarged) by the user of this
- * function.
- */
-ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
-                              char *buf, size_t buflen)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    int rc;
-    size_t bytes_read = 0;
-    size_t bytes_want;
-    int unlink_packet;
-    LIBSSH2_PACKET *read_packet;
-    LIBSSH2_PACKET *read_next;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "channel_read() wants %d bytes from channel %lu/%lu "
-                   "stream #%d",
-                   (int) buflen, channel->local.id, channel->remote.id,
-                   stream_id);
-
-    /* expand the receiving window first if it has become too narrow */
-    if((channel->read_state == libssh2_NB_state_jump1) ||
-       (channel->remote.window_size <
-        channel->remote.window_size_initial / 4 * 3 + buflen) ) {
-
-        uint32_t adjustment = channel->remote.window_size_initial + buflen -
-            channel->remote.window_size;
-        if(adjustment < LIBSSH2_CHANNEL_MINADJUST)
-            adjustment = LIBSSH2_CHANNEL_MINADJUST;
-
-        /* the actual window adjusting may not finish so we need to deal with
-           this special state here */
-        channel->read_state = libssh2_NB_state_jump1;
-        rc = _libssh2_channel_receive_window_adjust(channel, adjustment,
-                                                    0, NULL);
-        if(rc)
-            return rc;
-
-        channel->read_state = libssh2_NB_state_idle;
-    }
-
-    /* Process all pending incoming packets. Tests prove that this way
-       produces faster transfers. */
-    do {
-        rc = _libssh2_transport_read(session);
-    } while(rc > 0);
-
-    if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN))
-        return _libssh2_error(session, rc, "transport read");
-
-    read_packet = _libssh2_list_first(&session->packets);
-    while(read_packet && (bytes_read < buflen)) {
-        /* previously this loop condition also checked for
-           !channel->remote.close but we cannot let it do this:
-
-           We may have a series of packets to read that are still pending even
-           if a close has been received. Acknowledging the close too early
-           makes us flush buffers prematurely and loose data.
-        */
-
-        LIBSSH2_PACKET *readpkt = read_packet;
-
-        /* In case packet gets destroyed during this iteration */
-        read_next = _libssh2_list_next(&readpkt->node);
-
-        if(readpkt->data_len < 5) {
-            read_packet = read_next;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
-            continue;
-        }
-
-        channel->read_local_id =
-            _libssh2_ntohu32(readpkt->data + 1);
-
-        /*
-         * Either we asked for a specific extended data stream
-         * (and data was available),
-         * or the standard stream (and data was available),
-         * or the standard stream with extended_data_merge
-         * enabled and data was available
-         */
-        if((stream_id
-             && (readpkt->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
-             && (channel->local.id == channel->read_local_id)
-             && (readpkt->data_len >= 9)
-             && (stream_id == (int) _libssh2_ntohu32(readpkt->data + 5)))
-            || (!stream_id && (readpkt->data[0] == SSH_MSG_CHANNEL_DATA)
-                && (channel->local.id == channel->read_local_id))
-            || (!stream_id
-                && (readpkt->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
-                && (channel->local.id == channel->read_local_id)
-                && (channel->remote.extended_data_ignore_mode ==
-                    LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
-
-            /* figure out much more data we want to read */
-            bytes_want = buflen - bytes_read;
-            unlink_packet = FALSE;
-
-            if(bytes_want >= (readpkt->data_len - readpkt->data_head)) {
-                /* we want more than this node keeps, so adjust the number and
-                   delete this node after the copy */
-                bytes_want = readpkt->data_len - readpkt->data_head;
-                unlink_packet = TRUE;
-            }
-
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "channel_read() got %d of data from %lu/%lu/%d%s",
-                           bytes_want, channel->local.id,
-                           channel->remote.id, stream_id,
-                           unlink_packet?" [ul]":"");
-
-            /* copy data from this struct to the target buffer */
-            memcpy(&buf[bytes_read],
-                   &readpkt->data[readpkt->data_head], bytes_want);
-
-            /* advance pointer and counter */
-            readpkt->data_head += bytes_want;
-            bytes_read += bytes_want;
-
-            /* if drained, remove from list */
-            if(unlink_packet) {
-                /* detach readpkt from session->packets list */
-                _libssh2_list_remove(&readpkt->node);
-
-                LIBSSH2_FREE(session, readpkt->data);
-                LIBSSH2_FREE(session, readpkt);
-            }
-        }
-
-        /* check the next struct in the chain */
-        read_packet = read_next;
-    }
-
-    if(!bytes_read) {
-        /* If the channel is already at EOF or even closed, we need to signal
-           that back. We may have gotten that info while draining the incoming
-           transport layer until EAGAIN so we must not be fooled by that
-           return code. */
-        if(channel->remote.eof || channel->remote.close)
-            return 0;
-        else if(rc != LIBSSH2_ERROR_EAGAIN)
-            return 0;
-
-        /* if the transport layer said EAGAIN then we say so as well */
-        return _libssh2_error(session, rc, "would block");
-    }
-
-    channel->read_avail -= bytes_read;
-    channel->remote.window_size -= bytes_read;
-
-    return bytes_read;
-}
-
-/*
- * libssh2_channel_read_ex
- *
- * Read data from a channel (blocking or non-blocking depending on set state)
- *
- * When this is done non-blocking, it is important to not return 0 until the
- * currently read channel is complete. If we read stuff from the wire but it
- * was no payload data to fill in the buffer with, we MUST make sure to return
- * LIBSSH2_ERROR_EAGAIN.
- *
- * This function will first make sure there's a receive window enough to
- * receive a full buffer's wort of contents. An application may choose to
- * adjust the receive window more to increase transfer performance.
- */
-LIBSSH2_API ssize_t
-libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf,
-                        size_t buflen)
-{
-    int rc;
-    unsigned long recv_window;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    recv_window = libssh2_channel_window_read_ex(channel, NULL, NULL);
-
-    if(buflen > recv_window) {
-        BLOCK_ADJUST(rc, channel->session,
-                     _libssh2_channel_receive_window_adjust(channel, buflen,
-                                                            1, NULL));
-    }
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_read(channel, stream_id, buf, buflen));
-    return rc;
-}
-
-/*
- * _libssh2_channel_packet_data_len
- *
- * Return the size of the data block of the current packet, or 0 if there
- * isn't a packet.
- */
-size_t
-_libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    LIBSSH2_PACKET *read_packet;
-    LIBSSH2_PACKET *next_packet;
-    uint32_t read_local_id;
-
-    read_packet = _libssh2_list_first(&session->packets);
-    if(read_packet == NULL)
-        return 0;
-
-    while(read_packet) {
-
-        next_packet = _libssh2_list_next(&read_packet->node);
-
-        if(read_packet->data_len < 5) {
-            read_packet = next_packet;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
-            continue;
-        }
-
-        read_local_id = _libssh2_ntohu32(read_packet->data + 1);
-
-        /*
-         * Either we asked for a specific extended data stream
-         * (and data was available),
-         * or the standard stream (and data was available),
-         * or the standard stream with extended_data_merge
-         * enabled and data was available
-         */
-        if((stream_id
-             && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
-             && (channel->local.id == read_local_id)
-             && (read_packet->data_len >= 9)
-             && (stream_id == (int) _libssh2_ntohu32(read_packet->data + 5)))
-            ||
-            (!stream_id
-             && (read_packet->data[0] == SSH_MSG_CHANNEL_DATA)
-             && (channel->local.id == read_local_id))
-            ||
-            (!stream_id
-             && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
-             && (channel->local.id == read_local_id)
-             && (channel->remote.extended_data_ignore_mode
-                 == LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
-            return (read_packet->data_len - read_packet->data_head);
-        }
-
-        read_packet = next_packet;
-    }
-
-    return 0;
-}
-
-/*
- * _libssh2_channel_write
- *
- * Send data to a channel. Note that if this returns EAGAIN, the caller must
- * call this function again with the SAME input arguments.
- *
- * Returns: number of bytes sent, or if it returns a negative number, that is
- * the error code!
- */
-ssize_t
-_libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
-                       const unsigned char *buf, size_t buflen)
-{
-    int rc = 0;
-    LIBSSH2_SESSION *session = channel->session;
-    ssize_t wrote = 0; /* counter for this specific this call */
-
-    /* In theory we could split larger buffers into several smaller packets
-     * but it turns out to be really hard and nasty to do while still offering
-     * the API/prototype.
-     *
-     * Instead we only deal with the first 32K in this call and for the parent
-     * function to call it again with the remainder! 32K is a conservative
-     * limit based on the text in RFC4253 section 6.1.
-     */
-    if(buflen > 32700)
-        buflen = 32700;
-
-    if(channel->write_state == libssh2_NB_state_idle) {
-        unsigned char *s = channel->write_packet;
-
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Writing %d bytes on channel %lu/%lu, stream #%d",
-                       (int) buflen, channel->local.id, channel->remote.id,
-                       stream_id);
-
-        if(channel->local.close)
-            return _libssh2_error(channel->session,
-                                  LIBSSH2_ERROR_CHANNEL_CLOSED,
-                                  "We've already closed this channel");
-        else if(channel->local.eof)
-            return _libssh2_error(channel->session,
-                                  LIBSSH2_ERROR_CHANNEL_EOF_SENT,
-                                  "EOF has already been received, "
-                                  "data might be ignored");
-
-        /* drain the incoming flow first, mostly to make sure we get all
-         * pending window adjust packets */
-        do
-            rc = _libssh2_transport_read(session);
-        while(rc > 0);
-
-        if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {
-            return _libssh2_error(channel->session, rc,
-                                  "Failure while draining incoming flow");
-        }
-
-        if(channel->local.window_size <= 0) {
-            /* there's no room for data so we stop */
-
-            /* Waiting on the socket to be writable would be wrong because we
-             * would be back here immediately, but a readable socket might
-             * herald an incoming window adjustment.
-             */
-            session->socket_block_directions = LIBSSH2_SESSION_BLOCK_INBOUND;
-
-            return (rc == LIBSSH2_ERROR_EAGAIN?rc:0);
-        }
-
-        channel->write_bufwrite = buflen;
-
-        *(s++) = stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA :
-            SSH_MSG_CHANNEL_DATA;
-        _libssh2_store_u32(&s, channel->remote.id);
-        if(stream_id)
-            _libssh2_store_u32(&s, stream_id);
-
-        /* Don't exceed the remote end's limits */
-        /* REMEMBER local means local as the SOURCE of the data */
-        if(channel->write_bufwrite > channel->local.window_size) {
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Splitting write block due to %lu byte "
-                           "window_size on %lu/%lu/%d",
-                           channel->local.window_size, channel->local.id,
-                           channel->remote.id, stream_id);
-            channel->write_bufwrite = channel->local.window_size;
-        }
-        if(channel->write_bufwrite > channel->local.packet_size) {
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Splitting write block due to %lu byte "
-                           "packet_size on %lu/%lu/%d",
-                           channel->local.packet_size, channel->local.id,
-                           channel->remote.id, stream_id);
-            channel->write_bufwrite = channel->local.packet_size;
-        }
-        /* store the size here only, the buffer is passed in as-is to
-           _libssh2_transport_send() */
-        _libssh2_store_u32(&s, channel->write_bufwrite);
-        channel->write_packet_len = s - channel->write_packet;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Sending %d bytes on channel %lu/%lu, stream_id=%d",
-                       (int) channel->write_bufwrite, channel->local.id,
-                       channel->remote.id, stream_id);
-
-        channel->write_state = libssh2_NB_state_created;
-    }
-
-    if(channel->write_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, channel->write_packet,
-                                     channel->write_packet_len,
-                                     buf, channel->write_bufwrite);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, rc,
-                                  "Unable to send channel data");
-        }
-        else if(rc) {
-            channel->write_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "Unable to send channel data");
-        }
-        /* Shrink local window size */
-        channel->local.window_size -= channel->write_bufwrite;
-
-        wrote += channel->write_bufwrite;
-
-        /* Since _libssh2_transport_write() succeeded, we must return
-           now to allow the caller to provide the next chunk of data.
-
-           We cannot move on to send the next piece of data that may
-           already have been provided in this same function call, as we
-           risk getting EAGAIN for that and we can't return information
-           both about sent data as well as EAGAIN. So, by returning short
-           now, the caller will call this function again with new data to
-           send */
-
-        channel->write_state = libssh2_NB_state_idle;
-
-        return wrote;
-    }
-
-    return LIBSSH2_ERROR_INVAL; /* reaching this point is really bad */
-}
-
-/*
- * libssh2_channel_write_ex
- *
- * Send data to a channel
- */
-LIBSSH2_API ssize_t
-libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id,
-                         const char *buf, size_t buflen)
-{
-    ssize_t rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_write(channel, stream_id,
-                                        (unsigned char *)buf, buflen));
-    return rc;
-}
-
-/*
- * channel_send_eof
- *
- * Send EOF on channel
- */
-static int channel_send_eof(LIBSSH2_CHANNEL *channel)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char packet[5];    /* packet_type(1) + channelno(4) */
-    int rc;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "Sending EOF on channel %lu/%lu",
-                   channel->local.id, channel->remote.id);
-    packet[0] = SSH_MSG_CHANNEL_EOF;
-    _libssh2_htonu32(packet + 1, channel->remote.id);
-    rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        _libssh2_error(session, rc,
-                       "Would block sending EOF");
-        return rc;
-    }
-    else if(rc) {
-        return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                              "Unable to send EOF on channel");
-    }
-    channel->local.eof = 1;
-
-    return 0;
-}
-
-/*
- * libssh2_channel_send_eof
- *
- * Send EOF on channel
- */
-LIBSSH2_API int
-libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, channel_send_eof(channel));
-    return rc;
-}
-
-/*
- * libssh2_channel_eof
- *
- * Read channel's eof status
- */
-LIBSSH2_API int
-libssh2_channel_eof(LIBSSH2_CHANNEL * channel)
-{
-    LIBSSH2_SESSION *session;
-    LIBSSH2_PACKET *packet;
-    LIBSSH2_PACKET *next_packet;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    session = channel->session;
-    packet = _libssh2_list_first(&session->packets);
-
-    while(packet) {
-
-        next_packet = _libssh2_list_next(&packet->node);
-
-        if(packet->data_len < 1) {
-            packet = next_packet;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
-            continue;
-        }
-
-        if(((packet->data[0] == SSH_MSG_CHANNEL_DATA)
-            || (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA))
-            && ((packet->data_len >= 5)
-            && (channel->local.id == _libssh2_ntohu32(packet->data + 1)))) {
-            /* There's data waiting to be read yet, mask the EOF status */
-            return 0;
-        }
-        packet = next_packet;
-    }
-
-    return channel->remote.eof;
-}
-
-/*
- * channel_wait_eof
- *
- * Awaiting channel EOF
- */
-static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    int rc;
-
-    if(channel->wait_eof_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Awaiting EOF for channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
-
-        channel->wait_eof_state = libssh2_NB_state_created;
-    }
-
-    /*
-     * While channel is not eof, read more packets from the network.
-     * Either the EOF will be set or network timeout will occur.
-     */
-    do {
-        if(channel->remote.eof) {
-            break;
-        }
-
-        if((channel->remote.window_size == channel->read_avail) &&
-            session->api_block_mode)
-            return _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_WINDOW_FULL,
-                                  "Receiving channel window "
-                                  "has been exhausted");
-
-        rc = _libssh2_transport_read(session);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc < 0) {
-            channel->wait_eof_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, rc,
-                                  "_libssh2_transport_read() bailed out!");
-        }
-    } while(1);
-
-    channel->wait_eof_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/*
- * libssh2_channel_wait_eof
- *
- * Awaiting channel EOF
- */
-LIBSSH2_API int
-libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, channel_wait_eof(channel));
-    return rc;
-}
-
-int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    int rc = 0;
-
-    if(channel->local.close) {
-        /* Already closed, act like we sent another close,
-         * even though we didn't... shhhhhh */
-        channel->close_state = libssh2_NB_state_idle;
-        return 0;
-    }
-
-    if(!channel->local.eof) {
-        rc = channel_send_eof(channel);
-        if(rc) {
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                return rc;
-            }
-            _libssh2_error(session, rc,
-                "Unable to send EOF, but closing channel anyway");
-        }
-    }
-
-    /* ignore if we have received a remote eof or not, as it is now too
-       late for us to wait for it. Continue closing! */
-
-    if(channel->close_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Closing channel %lu/%lu",
-                       channel->local.id, channel->remote.id);
-
-        channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE;
-        _libssh2_htonu32(channel->close_packet + 1, channel->remote.id);
-
-        channel->close_state = libssh2_NB_state_created;
-    }
-
-    if(channel->close_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, channel->close_packet, 5,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, rc,
-                           "Would block sending close-channel");
-            return rc;
-
-        }
-        else if(rc) {
-            _libssh2_error(session, rc,
-                           "Unable to send close-channel request, "
-                           "but closing anyway");
-            /* skip waiting for the response and fall through to
-               LIBSSH2_CHANNEL_CLOSE below */
-
-        }
-        else
-            channel->close_state = libssh2_NB_state_sent;
-    }
-
-    if(channel->close_state == libssh2_NB_state_sent) {
-        /* We must wait for the remote SSH_MSG_CHANNEL_CLOSE message */
-
-        while(!channel->remote.close && !rc &&
-               (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED))
-            rc = _libssh2_transport_read(session);
-    }
-
-    if(rc != LIBSSH2_ERROR_EAGAIN) {
-        /* set the local close state first when we're perfectly confirmed to
-           not do any more EAGAINs */
-        channel->local.close = 1;
-
-        /* We call the callback last in this function to make it keep the local
-           data as long as EAGAIN is returned. */
-        if(channel->close_cb) {
-            LIBSSH2_CHANNEL_CLOSE(session, channel);
-        }
-
-        channel->close_state = libssh2_NB_state_idle;
-    }
-
-    /* return 0 or an error */
-    return rc >= 0 ? 0 : rc;
-}
-
-/*
- * libssh2_channel_close
- *
- * Close a channel
- */
-LIBSSH2_API int
-libssh2_channel_close(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, _libssh2_channel_close(channel) );
-    return rc;
-}
-
-/*
- * channel_wait_closed
- *
- * Awaiting channel close after EOF
- */
-static int channel_wait_closed(LIBSSH2_CHANNEL *channel)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    int rc;
-
-    if(!channel->remote.eof) {
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                              "libssh2_channel_wait_closed() invoked when "
-                              "channel is not in EOF state");
-    }
-
-    if(channel->wait_closed_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Awaiting close of channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
-
-        channel->wait_closed_state = libssh2_NB_state_created;
-    }
-
-    /*
-     * While channel is not closed, read more packets from the network.
-     * Either the channel will be closed or network timeout will occur.
-     */
-    if(!channel->remote.close) {
-        do {
-            rc = _libssh2_transport_read(session);
-            if(channel->remote.close)
-                /* it is now closed, move on! */
-                break;
-        } while(rc > 0);
-        if(rc < 0)
-            return rc;
-    }
-
-    channel->wait_closed_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/*
- * libssh2_channel_wait_closed
- *
- * Awaiting channel close after EOF
- */
-LIBSSH2_API int
-libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, channel_wait_closed(channel));
-    return rc;
-}
-
-/*
- * _libssh2_channel_free
- *
- * Make sure a channel is closed, then remove the channel from the session
- * and free its resource(s)
- *
- * Returns 0 on success, negative on failure
- */
-int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
-{
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char channel_id[4];
-    unsigned char *data;
-    size_t data_len;
-    int rc;
-
-    assert(session);
-
-    if(channel->free_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Freeing channel %lu/%lu resources", channel->local.id,
-                       channel->remote.id);
-
-        channel->free_state = libssh2_NB_state_created;
-    }
-
-    /* Allow channel freeing even when the socket has lost its connection */
-    if(!channel->local.close
-        && (session->socket_state == LIBSSH2_SOCKET_CONNECTED)) {
-        rc = _libssh2_channel_close(channel);
-
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-
-        /* ignore all other errors as they otherwise risk blocking the channel
-           free from happening */
-    }
-
-    channel->free_state = libssh2_NB_state_idle;
-
-    if(channel->exit_signal) {
-        LIBSSH2_FREE(session, channel->exit_signal);
-    }
-
-    /*
-     * channel->remote.close *might* not be set yet, Well...
-     * We've sent the close packet, what more do you want?
-     * Just let packet_add ignore it when it finally arrives
-     */
-
-    /* Clear out packets meant for this channel */
-    _libssh2_htonu32(channel_id, channel->local.id);
-    while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data,
-                                &data_len, 1, channel_id, 4) >= 0)
-           ||
-           (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data,
-                                &data_len, 1, channel_id, 4) >= 0)) {
-        LIBSSH2_FREE(session, data);
-    }
-
-    /* free "channel_type" */
-    if(channel->channel_type) {
-        LIBSSH2_FREE(session, channel->channel_type);
-    }
-
-    /* Unlink from channel list */
-    _libssh2_list_remove(&channel->node);
-
-    /*
-     * Make sure all memory used in the state variables are free
-     */
-    if(channel->setenv_packet) {
-        LIBSSH2_FREE(session, channel->setenv_packet);
-    }
-    if(channel->reqX11_packet) {
-        LIBSSH2_FREE(session, channel->reqX11_packet);
-    }
-    if(channel->process_packet) {
-        LIBSSH2_FREE(session, channel->process_packet);
-    }
-
-    LIBSSH2_FREE(session, channel);
-
-    return 0;
-}
-
-/*
- * libssh2_channel_free
- *
- * Make sure a channel is closed, then remove the channel from the session
- * and free its resource(s)
- *
- * Returns 0 on success, negative on failure
- */
-LIBSSH2_API int
-libssh2_channel_free(LIBSSH2_CHANNEL *channel)
-{
-    int rc;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, channel->session, _libssh2_channel_free(channel));
-    return rc;
-}
-/*
- * libssh2_channel_window_read_ex
- *
- * Check the status of the read window. Returns the number of bytes which the
- * remote end may send without overflowing the window limit read_avail (if
- * passed) will be populated with the number of bytes actually available to be
- * read window_size_initial (if passed) will be populated with the
- * window_size_initial as defined by the channel_open request
- */
-LIBSSH2_API unsigned long
-libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
-                               unsigned long *read_avail,
-                               unsigned long *window_size_initial)
-{
-    if(!channel)
-        return 0; /* no channel, no window! */
-
-    if(window_size_initial) {
-        *window_size_initial = channel->remote.window_size_initial;
-    }
-
-    if(read_avail) {
-        size_t bytes_queued = 0;
-        LIBSSH2_PACKET *next_packet;
-        LIBSSH2_PACKET *packet =
-            _libssh2_list_first(&channel->session->packets);
-
-        while(packet) {
-            unsigned char packet_type;
-               next_packet = _libssh2_list_next(&packet->node);
-
-            if(packet->data_len < 1) {
-                packet = next_packet;
-                _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                               "Unexpected packet length");
-                continue;
-            }
-
-            packet_type = packet->data[0];
-
-            if(((packet_type == SSH_MSG_CHANNEL_DATA)
-                || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
-               && ((packet->data_len >= 5)
-                   && (_libssh2_ntohu32(packet->data + 1) ==
-                       channel->local.id))) {
-                bytes_queued += packet->data_len - packet->data_head;
-            }
-
-            packet = next_packet;
-        }
-
-        *read_avail = bytes_queued;
-    }
-
-    return channel->remote.window_size;
-}
-
-/*
- * libssh2_channel_window_write_ex
- *
- * Check the status of the write window Returns the number of bytes which may
- * be safely written on the channel without blocking window_size_initial (if
- * passed) will be populated with the size of the initial window as defined by
- * the channel_open request
- */
-LIBSSH2_API unsigned long
-libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
-                                unsigned long *window_size_initial)
-{
-    if(!channel)
-        return 0; /* no channel, no window! */
-
-    if(window_size_initial) {
-        /* For locally initiated channels this is very often 0, so it's not
-         * *that* useful as information goes */
-        *window_size_initial = channel->local.window_size_initial;
-    }
-
-    return channel->local.window_size;
-}
diff --git a/libssh2/libssh2/src/channel.h b/libssh2/libssh2/src/channel.h
deleted file mode 100644
index dc0ee376..00000000
--- a/libssh2/libssh2/src/channel.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#ifndef __LIBSSH2_CHANNEL_H
-#define __LIBSSH2_CHANNEL_H
-/* Copyright (c) 2008-2010 by Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/*
- * _libssh2_channel_receive_window_adjust
- *
- * Adjust the receive window for a channel by adjustment bytes. If the amount
- * to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
- * adjustment amount will be queued for a later packet.
- *
- * Always non-blocking.
- */
-int _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
-                                           uint32_t adjustment,
-                                           unsigned char force,
-                                           unsigned int *store);
-
-/*
- * _libssh2_channel_flush
- *
- * Flush data from one (or all) stream
- * Returns number of bytes flushed, or negative on failure
- */
-int _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid);
-
-/*
- * _libssh2_channel_free
- *
- * Make sure a channel is closed, then remove the channel from the session
- * and free its resource(s)
- *
- * Returns 0 on success, negative on failure
- */
-int _libssh2_channel_free(LIBSSH2_CHANNEL *channel);
-
-int
-_libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);
-
-/*
- * _libssh2_channel_write
- *
- * Send data to a channel
- */
-ssize_t
-_libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
-                       const unsigned char *buf, size_t buflen);
-
-/*
- * _libssh2_channel_open
- *
- * Establish a generic session channel
- */
-LIBSSH2_CHANNEL *
-_libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
-                      uint32_t channel_type_len,
-                      uint32_t window_size,
-                      uint32_t packet_size,
-                      const unsigned char *message, size_t message_len);
-
-
-/*
- * _libssh2_channel_process_startup
- *
- * Primitive for libssh2_channel_(shell|exec|subsystem)
- */
-int
-_libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
-                                 const char *request, size_t request_len,
-                                 const char *message, size_t message_len);
-
-/*
- * _libssh2_channel_read
- *
- * Read data from a channel
- *
- * It is important to not return 0 until the currently read channel is
- * complete. If we read stuff from the wire but it was no payload data to fill
- * in the buffer with, we MUST make sure to return PACKET_EAGAIN.
- */
-ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
-                              char *buf, size_t buflen);
-
-uint32_t _libssh2_channel_nextid(LIBSSH2_SESSION * session);
-
-LIBSSH2_CHANNEL *_libssh2_channel_locate(LIBSSH2_SESSION * session,
-                                         uint32_t channel_id);
-
-size_t _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel,
-                                        int stream_id);
-
-int _libssh2_channel_close(LIBSSH2_CHANNEL * channel);
-
-/*
- * _libssh2_channel_forward_cancel
- *
- * Stop listening on a remote port and free the listener
- * Toss out any pending (un-accept()ed) connections
- *
- * Return 0 on success, LIBSSH2_ERROR_EAGAIN if would block, -1 on error
- */
-int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
-
-#endif /* __LIBSSH2_CHANNEL_H */
-
diff --git a/libssh2/libssh2/src/comp.c b/libssh2/libssh2/src/comp.c
deleted file mode 100644
index 90ab30c8..00000000
--- a/libssh2/libssh2/src/comp.c
+++ /dev/null
@@ -1,377 +0,0 @@
-/* Copyright (c) 2004-2007, 2019, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2014, Daniel Stenberg <daniel@haxx.se>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#ifdef LIBSSH2_HAVE_ZLIB
-#include <zlib.h>
-#undef compress /* dodge name clash with ZLIB macro */
-#endif
-
-#include "comp.h"
-
-/* ********
- * none *
- ******** */
-
-/*
- * comp_method_none_comp
- *
- * Minimalist compression: Absolutely none
- */
-static int
-comp_method_none_comp(LIBSSH2_SESSION *session,
-                      unsigned char *dest,
-                      size_t *dest_len,
-                      const unsigned char *src,
-                      size_t src_len,
-                      void **abstract)
-{
-    (void) session;
-    (void) abstract;
-    (void) dest;
-    (void) dest_len;
-    (void) src;
-    (void) src_len;
-
-    return 0;
-}
-
-/*
- * comp_method_none_decomp
- *
- * Minimalist decompression: Absolutely none
- */
-static int
-comp_method_none_decomp(LIBSSH2_SESSION * session,
-                        unsigned char **dest,
-                        size_t *dest_len,
-                        size_t payload_limit,
-                        const unsigned char *src,
-                        size_t src_len, void **abstract)
-{
-    (void) session;
-    (void) payload_limit;
-    (void) abstract;
-    *dest = (unsigned char *) src;
-    *dest_len = src_len;
-    return 0;
-}
-
-
-
-static const LIBSSH2_COMP_METHOD comp_method_none = {
-    "none",
-    0, /* not really compressing */
-    0, /* isn't used in userauth, go figure */
-    NULL,
-    comp_method_none_comp,
-    comp_method_none_decomp,
-    NULL
-};
-
-#ifdef LIBSSH2_HAVE_ZLIB
-/* ********
- * zlib *
- ******** */
-
-/* Memory management wrappers
- * Yes, I realize we're doing a callback to a callback,
- * Deal...
- */
-
-static voidpf
-comp_method_zlib_alloc(voidpf opaque, uInt items, uInt size)
-{
-    LIBSSH2_SESSION *session = (LIBSSH2_SESSION *) opaque;
-
-    return (voidpf) LIBSSH2_ALLOC(session, items * size);
-}
-
-static void
-comp_method_zlib_free(voidpf opaque, voidpf address)
-{
-    LIBSSH2_SESSION *session = (LIBSSH2_SESSION *) opaque;
-
-    LIBSSH2_FREE(session, address);
-}
-
-
-
-/* libssh2_comp_method_zlib_init
- * All your bandwidth are belong to us (so save some)
- */
-static int
-comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
-                      void **abstract)
-{
-    z_stream *strm;
-    int status;
-
-    strm = LIBSSH2_CALLOC(session, sizeof(z_stream));
-    if(!strm) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for "
-                              "zlib compression/decompression");
-    }
-
-    strm->opaque = (voidpf) session;
-    strm->zalloc = (alloc_func) comp_method_zlib_alloc;
-    strm->zfree = (free_func) comp_method_zlib_free;
-    if(compr) {
-        /* deflate */
-        status = deflateInit(strm, Z_DEFAULT_COMPRESSION);
-    }
-    else {
-        /* inflate */
-        status = inflateInit(strm);
-    }
-
-    if(status != Z_OK) {
-        LIBSSH2_FREE(session, strm);
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "unhandled zlib error %d", status);
-        return LIBSSH2_ERROR_COMPRESS;
-    }
-    *abstract = strm;
-
-    return LIBSSH2_ERROR_NONE;
-}
-
-/*
- * libssh2_comp_method_zlib_comp
- *
- * Compresses source to destination. Without allocation.
- */
-static int
-comp_method_zlib_comp(LIBSSH2_SESSION *session,
-                      unsigned char *dest,
-
-                      /* dest_len is a pointer to allow this function to
-                         update it with the final actual size used */
-                      size_t *dest_len,
-                      const unsigned char *src,
-                      size_t src_len,
-                      void **abstract)
-{
-    z_stream *strm = *abstract;
-    int out_maxlen = *dest_len;
-    int status;
-
-    strm->next_in = (unsigned char *) src;
-    strm->avail_in = src_len;
-    strm->next_out = dest;
-    strm->avail_out = out_maxlen;
-
-    status = deflate(strm, Z_PARTIAL_FLUSH);
-
-    if((status == Z_OK) && (strm->avail_out > 0)) {
-        *dest_len = out_maxlen - strm->avail_out;
-        return 0;
-    }
-
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                   "unhandled zlib compression error %d, avail_out",
-                   status, strm->avail_out);
-    return _libssh2_error(session, LIBSSH2_ERROR_ZLIB, "compression failure");
-}
-
-/*
- * libssh2_comp_method_zlib_decomp
- *
- * Decompresses source to destination. Allocates the output memory.
- */
-static int
-comp_method_zlib_decomp(LIBSSH2_SESSION * session,
-                        unsigned char **dest,
-                        size_t *dest_len,
-                        size_t payload_limit,
-                        const unsigned char *src,
-                        size_t src_len, void **abstract)
-{
-    z_stream *strm = *abstract;
-    /* A short-term alloc of a full data chunk is better than a series of
-       reallocs */
-    char *out;
-    size_t out_maxlen = src_len;
-
-    if(src_len <= SIZE_MAX / 4)
-        out_maxlen = src_len * 4;
-    else
-        out_maxlen = payload_limit;
-
-    /* If strm is null, then we have not yet been initialized. */
-    if(strm == NULL)
-        return _libssh2_error(session, LIBSSH2_ERROR_COMPRESS,
-                              "decompression uninitialized");;
-
-    /* In practice they never come smaller than this */
-    if(out_maxlen < 25)
-        out_maxlen = 25;
-
-    if(out_maxlen > payload_limit)
-        out_maxlen = payload_limit;
-
-    strm->next_in = (unsigned char *) src;
-    strm->avail_in = src_len;
-    strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen);
-    out = (char *) strm->next_out;
-    strm->avail_out = out_maxlen;
-    if(!strm->next_out)
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate decompression buffer");
-
-    /* Loop until it's all inflated or hit error */
-    for(;;) {
-        int status;
-        size_t out_ofs;
-        char *newout;
-
-        status = inflate(strm, Z_PARTIAL_FLUSH);
-
-        if(status == Z_OK) {
-            if(strm->avail_out > 0)
-                /* status is OK and the output buffer has not been exhausted
-                   so we're done */
-                break;
-        }
-        else if(status == Z_BUF_ERROR) {
-            /* the input data has been exhausted so we are done */
-            break;
-        }
-        else {
-            /* error state */
-            LIBSSH2_FREE(session, out);
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                           "unhandled zlib error %d", status);
-            return _libssh2_error(session, LIBSSH2_ERROR_ZLIB,
-                                  "decompression failure");
-        }
-
-        if(out_maxlen > payload_limit || out_maxlen > SIZE_MAX / 2) {
-            LIBSSH2_FREE(session, out);
-            return _libssh2_error(session, LIBSSH2_ERROR_ZLIB,
-                                  "Excessive growth in decompression phase");
-        }
-
-        /* If we get here we need to grow the output buffer and try again */
-        out_ofs = out_maxlen - strm->avail_out;
-        out_maxlen *= 2;
-        newout = LIBSSH2_REALLOC(session, out, out_maxlen);
-        if(!newout) {
-            LIBSSH2_FREE(session, out);
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to expand decompression buffer");
-        }
-        out = newout;
-        strm->next_out = (unsigned char *) out + out_ofs;
-        strm->avail_out = out_maxlen - out_ofs;
-    }
-
-    *dest = (unsigned char *) out;
-    *dest_len = out_maxlen - strm->avail_out;
-
-    return 0;
-}
-
-
-/* libssh2_comp_method_zlib_dtor
- * All done, no more compression for you
- */
-static int
-comp_method_zlib_dtor(LIBSSH2_SESSION *session, int compr, void **abstract)
-{
-    z_stream *strm = *abstract;
-
-    if(strm) {
-        if(compr)
-            deflateEnd(strm);
-        else
-            inflateEnd(strm);
-        LIBSSH2_FREE(session, strm);
-    }
-
-    *abstract = NULL;
-    return 0;
-}
-
-static const LIBSSH2_COMP_METHOD comp_method_zlib = {
-    "zlib",
-    1, /* yes, this compresses */
-    1, /* do compression during userauth */
-    comp_method_zlib_init,
-    comp_method_zlib_comp,
-    comp_method_zlib_decomp,
-    comp_method_zlib_dtor,
-};
-
-static const LIBSSH2_COMP_METHOD comp_method_zlib_openssh = {
-    "zlib@openssh.com",
-    1, /* yes, this compresses */
-    0, /* don't use compression during userauth */
-    comp_method_zlib_init,
-    comp_method_zlib_comp,
-    comp_method_zlib_decomp,
-    comp_method_zlib_dtor,
-};
-#endif /* LIBSSH2_HAVE_ZLIB */
-
-/* If compression is enabled by the API, then this array is used which then
-   may allow compression if zlib is available at build time */
-static const LIBSSH2_COMP_METHOD *comp_methods[] = {
-#ifdef LIBSSH2_HAVE_ZLIB
-    &comp_method_zlib,
-    &comp_method_zlib_openssh,
-#endif /* LIBSSH2_HAVE_ZLIB */
-    &comp_method_none,
-    NULL
-};
-
-/* If compression is disabled by the API, then this array is used */
-static const LIBSSH2_COMP_METHOD *no_comp_methods[] = {
-    &comp_method_none,
-    NULL
-};
-
-const LIBSSH2_COMP_METHOD **
-_libssh2_comp_methods(LIBSSH2_SESSION *session)
-{
-    if(session->flag.compress)
-        return comp_methods;
-    else
-        return no_comp_methods;
-}
diff --git a/libssh2/libssh2/src/comp.h b/libssh2/libssh2/src/comp.h
deleted file mode 100644
index 82ac2dc9..00000000
--- a/libssh2/libssh2/src/comp.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef __LIBSSH2_COMP_H
-#define __LIBSSH2_COMP_H
-/* Copyright (C) 2009-2010 by Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-#include "libssh2_priv.h"
-
-const LIBSSH2_COMP_METHOD **_libssh2_comp_methods(LIBSSH2_SESSION *session);
-
-#endif /* __LIBSSH2_COMP_H */
diff --git a/libssh2/libssh2/src/crypt.c b/libssh2/libssh2/src/crypt.c
deleted file mode 100644
index 8d493b48..00000000
--- a/libssh2/libssh2/src/crypt.c
+++ /dev/null
@@ -1,349 +0,0 @@
-/* Copyright (c) 2009, 2010 Simon Josefsson <simon@josefsson.org>
- * Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_CRYPT_NONE
-
-/* crypt_none_crypt
- * Minimalist cipher: VERY secure *wink*
- */
-static int
-crypt_none_crypt(LIBSSH2_SESSION * session, unsigned char *buf,
-                         void **abstract)
-{
-    /* Do nothing to the data! */
-    return 0;
-}
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = {
-    "none",
-    "DEK-Info: NONE",
-    8,                /* blocksize (SSH2 defines minimum blocksize as 8) */
-    0,                /* iv_len */
-    0,                /* secret_len */
-    0,                /* flags */
-    NULL,
-    crypt_none_crypt,
-    NULL
-};
-#endif /* LIBSSH2_CRYPT_NONE */
-
-struct crypt_ctx
-{
-    int encrypt;
-    _libssh2_cipher_type(algo);
-    _libssh2_cipher_ctx h;
-};
-
-static int
-crypt_init(LIBSSH2_SESSION * session,
-           const LIBSSH2_CRYPT_METHOD * method,
-           unsigned char *iv, int *free_iv,
-           unsigned char *secret, int *free_secret,
-           int encrypt, void **abstract)
-{
-    struct crypt_ctx *ctx = LIBSSH2_ALLOC(session,
-                                          sizeof(struct crypt_ctx));
-    if(!ctx)
-        return LIBSSH2_ERROR_ALLOC;
-
-    ctx->encrypt = encrypt;
-    ctx->algo = method->algo;
-    if(_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) {
-        LIBSSH2_FREE(session, ctx);
-        return -1;
-    }
-    *abstract = ctx;
-    *free_iv = 1;
-    *free_secret = 1;
-    return 0;
-}
-
-static int
-crypt_encrypt(LIBSSH2_SESSION * session, unsigned char *block,
-              size_t blocksize, void **abstract)
-{
-    struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
-    (void) session;
-    return _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
-                                 blocksize);
-}
-
-static int
-crypt_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    struct crypt_ctx **cctx = (struct crypt_ctx **) abstract;
-    if(cctx && *cctx) {
-        _libssh2_cipher_dtor(&(*cctx)->h);
-        LIBSSH2_FREE(session, *cctx);
-        *abstract = NULL;
-    }
-    return 0;
-}
-
-#if LIBSSH2_AES_CTR
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_ctr = {
-    "aes128-ctr",
-    "",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    16,                         /* secret length -- 16*8 == 128bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes128ctr
-};
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_ctr = {
-    "aes192-ctr",
-    "",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    24,                         /* secret length -- 24*8 == 192bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes192ctr
-};
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_ctr = {
-    "aes256-ctr",
-    "",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    32,                         /* secret length -- 32*8 == 256bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes256ctr
-};
-#endif
-
-#if LIBSSH2_AES
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
-    "aes128-cbc",
-    "DEK-Info: AES-128-CBC",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    16,                         /* secret length -- 16*8 == 128bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes128
-};
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
-    "aes192-cbc",
-    "DEK-Info: AES-192-CBC",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    24,                         /* secret length -- 24*8 == 192bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes192
-};
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
-    "aes256-cbc",
-    "DEK-Info: AES-256-CBC",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    32,                         /* secret length -- 32*8 == 256bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes256
-};
-
-/* rijndael-cbc@lysator.liu.se == aes256-cbc */
-static const LIBSSH2_CRYPT_METHOD
-    libssh2_crypt_method_rijndael_cbc_lysator_liu_se = {
-    "rijndael-cbc@lysator.liu.se",
-    "DEK-Info: AES-256-CBC",
-    16,                         /* blocksize */
-    16,                         /* initial value length */
-    32,                         /* secret length -- 32*8 == 256bit */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_aes256
-};
-#endif /* LIBSSH2_AES */
-
-#if LIBSSH2_BLOWFISH
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
-    "blowfish-cbc",
-    "",
-    8,                          /* blocksize */
-    8,                          /* initial value length */
-    16,                         /* secret length */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_blowfish
-};
-#endif /* LIBSSH2_BLOWFISH */
-
-#if LIBSSH2_RC4
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
-    "arcfour",
-    "DEK-Info: RC4",
-    8,                          /* blocksize */
-    8,                          /* initial value length */
-    16,                         /* secret length */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_arcfour
-};
-
-static int
-crypt_init_arcfour128(LIBSSH2_SESSION * session,
-                      const LIBSSH2_CRYPT_METHOD * method,
-                      unsigned char *iv, int *free_iv,
-                      unsigned char *secret, int *free_secret,
-                      int encrypt, void **abstract)
-{
-    int rc;
-
-    rc = crypt_init(session, method, iv, free_iv, secret, free_secret,
-                    encrypt, abstract);
-    if(rc == 0) {
-        struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
-        unsigned char block[8];
-        size_t discard = 1536;
-        for(; discard; discard -= 8)
-            _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
-                                  method->blocksize);
-    }
-
-    return rc;
-}
-
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour128 = {
-    "arcfour128",
-    "",
-    8,                          /* blocksize */
-    8,                          /* initial value length */
-    16,                         /* secret length */
-    0,                          /* flags */
-    &crypt_init_arcfour128,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_arcfour
-};
-#endif /* LIBSSH2_RC4 */
-
-#if LIBSSH2_CAST
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
-    "cast128-cbc",
-    "",
-    8,                          /* blocksize */
-    8,                          /* initial value length */
-    16,                         /* secret length */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_cast5
-};
-#endif /* LIBSSH2_CAST */
-
-#if LIBSSH2_3DES
-static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
-    "3des-cbc",
-    "DEK-Info: DES-EDE3-CBC",
-    8,                          /* blocksize */
-    8,                          /* initial value length */
-    24,                         /* secret length */
-    0,                          /* flags */
-    &crypt_init,
-    &crypt_encrypt,
-    &crypt_dtor,
-    _libssh2_cipher_3des
-};
-#endif
-
-static const LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
-#if LIBSSH2_AES_CTR
-  &libssh2_crypt_method_aes128_ctr,
-  &libssh2_crypt_method_aes192_ctr,
-  &libssh2_crypt_method_aes256_ctr,
-#endif /* LIBSSH2_AES */
-#if LIBSSH2_AES
-    &libssh2_crypt_method_aes256_cbc,
-    &libssh2_crypt_method_rijndael_cbc_lysator_liu_se,  /* == aes256-cbc */
-    &libssh2_crypt_method_aes192_cbc,
-    &libssh2_crypt_method_aes128_cbc,
-#endif /* LIBSSH2_AES */
-#if LIBSSH2_BLOWFISH
-    &libssh2_crypt_method_blowfish_cbc,
-#endif /* LIBSSH2_BLOWFISH */
-#if LIBSSH2_RC4
-    &libssh2_crypt_method_arcfour128,
-    &libssh2_crypt_method_arcfour,
-#endif /* LIBSSH2_RC4 */
-#if LIBSSH2_CAST
-    &libssh2_crypt_method_cast128_cbc,
-#endif /* LIBSSH2_CAST */
-#if LIBSSH2_3DES
-    &libssh2_crypt_method_3des_cbc,
-#endif /*  LIBSSH2_DES */
-#ifdef LIBSSH2_CRYPT_NONE
-    &libssh2_crypt_method_none,
-#endif
-    NULL
-};
-
-/* Expose to kex.c */
-const LIBSSH2_CRYPT_METHOD **
-libssh2_crypt_methods(void)
-{
-    return _libssh2_crypt_methods;
-}
diff --git a/libssh2/libssh2/src/crypto.h b/libssh2/libssh2/src/crypto.h
deleted file mode 100644
index f512d603..00000000
--- a/libssh2/libssh2/src/crypto.h
+++ /dev/null
@@ -1,248 +0,0 @@
-#ifndef __LIBSSH2_CRYPTO_H
-#define __LIBSSH2_CRYPTO_H
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2010-2019 Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifdef LIBSSH2_OPENSSL
-#include "openssl.h"
-#endif
-
-#ifdef LIBSSH2_LIBGCRYPT
-#include "libgcrypt.h"
-#endif
-
-#ifdef LIBSSH2_WINCNG
-#include "wincng.h"
-#endif
-
-#ifdef LIBSSH2_OS400QC3
-#include "os400qc3.h"
-#endif
-
-#ifdef LIBSSH2_MBEDTLS
-#include "mbedtls.h"
-#endif
-
-#define LIBSSH2_ED25519_KEY_LEN 32
-#define LIBSSH2_ED25519_PRIVATE_KEY_LEN 64
-#define LIBSSH2_ED25519_SIG_LEN 64
-
-#if LIBSSH2_RSA
-int _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
-                     const unsigned char *edata,
-                     unsigned long elen,
-                     const unsigned char *ndata,
-                     unsigned long nlen,
-                     const unsigned char *ddata,
-                     unsigned long dlen,
-                     const unsigned char *pdata,
-                     unsigned long plen,
-                     const unsigned char *qdata,
-                     unsigned long qlen,
-                     const unsigned char *e1data,
-                     unsigned long e1len,
-                     const unsigned char *e2data,
-                     unsigned long e2len,
-                     const unsigned char *coeffdata, unsigned long coefflen);
-int _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
-                             LIBSSH2_SESSION * session,
-                             const char *filename,
-                             unsigned const char *passphrase);
-int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
-                             const unsigned char *sig,
-                             unsigned long sig_len,
-                             const unsigned char *m, unsigned long m_len);
-int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
-                           libssh2_rsa_ctx * rsactx,
-                           const unsigned char *hash,
-                           size_t hash_len,
-                           unsigned char **signature,
-                           size_t *signature_len);
-int _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
-                                        LIBSSH2_SESSION * session,
-                                        const char *filedata,
-                                        size_t filedata_len,
-                                        unsigned const char *passphrase);
-#endif
-
-#if LIBSSH2_DSA
-int _libssh2_dsa_new(libssh2_dsa_ctx ** dsa,
-                     const unsigned char *pdata,
-                     unsigned long plen,
-                     const unsigned char *qdata,
-                     unsigned long qlen,
-                     const unsigned char *gdata,
-                     unsigned long glen,
-                     const unsigned char *ydata,
-                     unsigned long ylen,
-                     const unsigned char *x, unsigned long x_len);
-int _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
-                             LIBSSH2_SESSION * session,
-                             const char *filename,
-                             unsigned const char *passphrase);
-int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
-                             const unsigned char *sig,
-                             const unsigned char *m, unsigned long m_len);
-int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
-                           const unsigned char *hash,
-                           unsigned long hash_len, unsigned char *sig);
-int _libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
-                                        LIBSSH2_SESSION * session,
-                                        const char *filedata,
-                                        size_t filedata_len,
-                                        unsigned const char *passphrase);
-#endif
-
-#if LIBSSH2_ECDSA
-int
-_libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ecdsactx,
-                                         const unsigned char *k,
-                                         size_t k_len,
-                                         libssh2_curve_type type);
-int
-_libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
-                           LIBSSH2_SESSION * session,
-                           const char *filename,
-                           unsigned const char *passphrase);
-
-int
-_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
-                      const unsigned char *r, size_t r_len,
-                      const unsigned char *s, size_t s_len,
-                      const unsigned char *m, size_t m_len);
-
-int
-_libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
-                          _libssh2_ec_key **out_private_key,
-                          unsigned char **out_public_key_octal,
-                          size_t *out_public_key_octal_len,
-                          libssh2_curve_type curve_type);
-
-int
-_libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
-                    const unsigned char *server_public_key,
-                    size_t server_public_key_len);
-
-int
-_libssh2_ecdsa_sign(LIBSSH2_SESSION *session, libssh2_ecdsa_ctx *ec_ctx,
-                    const unsigned char *hash, unsigned long hash_len,
-                    unsigned char **signature, size_t *signature_len);
-
-int _libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
-                                          LIBSSH2_SESSION * session,
-                                          const char *filedata,
-                                          size_t filedata_len,
-                                          unsigned const char *passphrase);
-
-libssh2_curve_type
-_libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx);
-
-int
-_libssh2_ecdsa_curve_type_from_name(const char *name,
-                                    libssh2_curve_type *out_type);
-
-#endif /* LIBSSH2_ECDSA */
-
-#if LIBSSH2_ED25519
-
-int
-_libssh2_curve25519_new(LIBSSH2_SESSION *session, uint8_t **out_public_key,
-                        uint8_t **out_private_key);
-
-int
-_libssh2_curve25519_gen_k(_libssh2_bn **k,
-                          uint8_t private_key[LIBSSH2_ED25519_KEY_LEN],
-                          uint8_t server_public_key[LIBSSH2_ED25519_KEY_LEN]);
-
-int
-_libssh2_ed25519_verify(libssh2_ed25519_ctx *ctx, const uint8_t *s,
-                        size_t s_len, const uint8_t *m, size_t m_len);
-
-int
-_libssh2_ed25519_new_private(libssh2_ed25519_ctx **ed_ctx,
-                            LIBSSH2_SESSION *session,
-                            const char *filename, const uint8_t *passphrase);
-
-int
-_libssh2_ed25519_new_public(libssh2_ed25519_ctx **ed_ctx,
-                            LIBSSH2_SESSION *session,
-                            const unsigned char *raw_pub_key,
-                            const uint8_t key_len);
-
-int
-_libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
-                      uint8_t **out_sig, size_t *out_sig_len,
-                      const uint8_t *message, size_t message_len);
-
-int
-_libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx **ed_ctx,
-                                        LIBSSH2_SESSION *session,
-                                        const char *filedata,
-                                        size_t filedata_len,
-                                        unsigned const char *passphrase);
-
-#endif /* LIBSSH2_ED25519 */
-
-
-int _libssh2_cipher_init(_libssh2_cipher_ctx * h,
-                         _libssh2_cipher_type(algo),
-                         unsigned char *iv,
-                         unsigned char *secret, int encrypt);
-
-int _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
-                          _libssh2_cipher_type(algo),
-                          int encrypt, unsigned char *block, size_t blocksize);
-
-int _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                              unsigned char **method,
-                              size_t *method_len,
-                              unsigned char **pubkeydata,
-                              size_t *pubkeydata_len,
-                              const char *privatekey,
-                              const char *passphrase);
-
-int _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                    unsigned char **method,
-                                    size_t *method_len,
-                                    unsigned char **pubkeydata,
-                                    size_t *pubkeydata_len,
-                                    const char *privatekeydata,
-                                    size_t privatekeydata_len,
-                                    const char *passphrase);
-
-#endif /* __LIBSSH2_CRYPTO_H */
diff --git a/libssh2/libssh2/src/global.c b/libssh2/libssh2/src/global.c
deleted file mode 100644
index 68289845..00000000
--- a/libssh2/libssh2/src/global.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/* Copyright (c) 2010 Lars Nordin <Lars.Nordin@SDlabs.se>
- * Copyright (C) 2010 Simon Josefsson <simon@josefsson.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-static int _libssh2_initialized = 0;
-static int _libssh2_init_flags = 0;
-
-LIBSSH2_API int
-libssh2_init(int flags)
-{
-    if(_libssh2_initialized == 0 && !(flags & LIBSSH2_INIT_NO_CRYPTO)) {
-        libssh2_crypto_init();
-    }
-
-    _libssh2_initialized++;
-    _libssh2_init_flags |= flags;
-
-    return 0;
-}
-
-LIBSSH2_API void
-libssh2_exit(void)
-{
-    if(_libssh2_initialized == 0)
-        return;
-
-    _libssh2_initialized--;
-
-    if(_libssh2_initialized == 0 &&
-       !(_libssh2_init_flags & LIBSSH2_INIT_NO_CRYPTO)) {
-        libssh2_crypto_exit();
-    }
-
-    return;
-}
-
-void
-_libssh2_init_if_needed(void)
-{
-    if(_libssh2_initialized == 0)
-        (void)libssh2_init (0);
-}
diff --git a/libssh2/libssh2/src/hostkey.c b/libssh2/libssh2/src/hostkey.c
deleted file mode 100644
index d87a4c74..00000000
--- a/libssh2/libssh2/src/hostkey.c
+++ /dev/null
@@ -1,1168 +0,0 @@
-/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2019 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "misc.h"
-
-/* Needed for struct iovec on some platforms */
-#ifdef HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif
-
-#if LIBSSH2_RSA
-/* ***********
- * ssh-rsa *
- *********** */
-
-static int hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session,
-                                       void **abstract);
-
-/*
- * hostkey_method_ssh_rsa_init
- *
- * Initialize the server hostkey working area with e/n pair
- */
-static int
-hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
-                            const unsigned char *hostkey_data,
-                            size_t hostkey_data_len,
-                            void **abstract)
-{
-    libssh2_rsa_ctx *rsactx;
-    unsigned char *e, *n;
-    size_t e_len, n_len;
-    struct string_buf buf;
-
-    if(*abstract) {
-        hostkey_method_ssh_rsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    if(hostkey_data_len < 19) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
-        return -1;
-    }
-
-    buf.data = (unsigned char *)hostkey_data;
-    buf.dataptr = buf.data;
-    buf.len = hostkey_data_len;
-
-    if(_libssh2_match_string(&buf, "ssh-rsa"))
-        return -1;
-
-    if(_libssh2_get_string(&buf, &e, &e_len))
-        return -1;
-
-    if(_libssh2_get_string(&buf, &n, &n_len))
-        return -1;
-
-    if(_libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0,
-                        NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0)) {
-        return -1;
-    }
-
-    *abstract = rsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_rsa_initPEM
- *
- * Load a Private Key from a PEM file
- */
-static int
-hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session,
-                               const char *privkeyfile,
-                               unsigned const char *passphrase,
-                               void **abstract)
-{
-    libssh2_rsa_ctx *rsactx;
-    int ret;
-
-    if(*abstract) {
-        hostkey_method_ssh_rsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_rsa_new_private(&rsactx, session, privkeyfile, passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    *abstract = rsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_rsa_initPEMFromMemory
- *
- * Load a Private Key from a memory
- */
-static int
-hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
-                                         const char *privkeyfiledata,
-                                         size_t privkeyfiledata_len,
-                                         unsigned const char *passphrase,
-                                         void **abstract)
-{
-    libssh2_rsa_ctx *rsactx;
-    int ret;
-
-    if(*abstract) {
-        hostkey_method_ssh_rsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_rsa_new_private_frommemory(&rsactx, session,
-                                              privkeyfiledata,
-                                              privkeyfiledata_len, passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    *abstract = rsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_rsa_sign
- *
- * Verify signature created by remote
- */
-static int
-hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session,
-                                  const unsigned char *sig,
-                                  size_t sig_len,
-                                  const unsigned char *m,
-                                  size_t m_len, void **abstract)
-{
-    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
-    (void) session;
-
-    /* Skip past keyname_len(4) + keyname(7){"ssh-rsa"} + signature_len(4) */
-    if(sig_len < 15)
-        return -1;
-
-    sig += 15;
-    sig_len -= 15;
-    return _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len);
-}
-
-/*
- * hostkey_method_ssh_rsa_signv
- *
- * Construct a signature from an array of vectors
- */
-static int
-hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
-                             unsigned char **signature,
-                             size_t *signature_len,
-                             int veccount,
-                             const struct iovec datavec[],
-                             void **abstract)
-{
-    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
-
-#ifdef _libssh2_rsa_sha1_signv
-    return _libssh2_rsa_sha1_signv(session, signature, signature_len,
-                                   veccount, datavec, rsactx);
-#else
-    int ret;
-    int i;
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    libssh2_sha1_ctx ctx;
-
-    libssh2_sha1_init(&ctx);
-    for(i = 0; i < veccount; i++) {
-        libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
-    }
-    libssh2_sha1_final(ctx, hash);
-
-    ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH,
-                                 signature, signature_len);
-    if(ret) {
-        return -1;
-    }
-
-    return 0;
-#endif
-}
-
-/*
- * hostkey_method_ssh_rsa_dtor
- *
- * Shutdown the hostkey
- */
-static int
-hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
-    (void) session;
-
-    _libssh2_rsa_free(rsactx);
-
-    *abstract = NULL;
-
-    return 0;
-}
-
-#ifdef OPENSSL_NO_MD5
-#define MD5_DIGEST_LENGTH 16
-#endif
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa = {
-    "ssh-rsa",
-    MD5_DIGEST_LENGTH,
-    hostkey_method_ssh_rsa_init,
-    hostkey_method_ssh_rsa_initPEM,
-    hostkey_method_ssh_rsa_initPEMFromMemory,
-    hostkey_method_ssh_rsa_sig_verify,
-    hostkey_method_ssh_rsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_rsa_dtor,
-};
-#endif /* LIBSSH2_RSA */
-
-#if LIBSSH2_DSA
-/* ***********
- * ssh-dss *
- *********** */
-
-static int hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session,
-                                       void **abstract);
-
-/*
- * hostkey_method_ssh_dss_init
- *
- * Initialize the server hostkey working area with p/q/g/y set
- */
-static int
-hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
-                            const unsigned char *hostkey_data,
-                            size_t hostkey_data_len,
-                            void **abstract)
-{
-    libssh2_dsa_ctx *dsactx;
-    unsigned char *p, *q, *g, *y;
-    size_t p_len, q_len, g_len, y_len;
-    struct string_buf buf;
-
-    if(*abstract) {
-        hostkey_method_ssh_dss_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    if(hostkey_data_len < 27) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
-        return -1;
-    }
-
-    buf.data = (unsigned char *)hostkey_data;
-    buf.dataptr = buf.data;
-    buf.len = hostkey_data_len;
-
-    if(_libssh2_match_string(&buf, "ssh-dss"))
-        return -1;
-
-    if(_libssh2_get_string(&buf, &p, &p_len))
-       return -1;
-
-    if(_libssh2_get_string(&buf, &q, &q_len))
-        return -1;
-
-    if(_libssh2_get_string(&buf, &g, &g_len))
-        return -1;
-
-    if(_libssh2_get_string(&buf, &y, &y_len))
-        return -1;
-
-    if(_libssh2_dsa_new(&dsactx, p, p_len, q, q_len,
-                        g, g_len, y, y_len, NULL, 0)) {
-        return -1;
-    }
-
-    *abstract = dsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_dss_initPEM
- *
- * Load a Private Key from a PEM file
- */
-static int
-hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session,
-                               const char *privkeyfile,
-                               unsigned const char *passphrase,
-                               void **abstract)
-{
-    libssh2_dsa_ctx *dsactx;
-    int ret;
-
-    if(*abstract) {
-        hostkey_method_ssh_dss_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_dsa_new_private(&dsactx, session, privkeyfile, passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    *abstract = dsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_dss_initPEMFromMemory
- *
- * Load a Private Key from memory
- */
-static int
-hostkey_method_ssh_dss_initPEMFromMemory(LIBSSH2_SESSION * session,
-                                         const char *privkeyfiledata,
-                                         size_t privkeyfiledata_len,
-                                         unsigned const char *passphrase,
-                                         void **abstract)
-{
-    libssh2_dsa_ctx *dsactx;
-    int ret;
-
-    if(*abstract) {
-        hostkey_method_ssh_dss_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_dsa_new_private_frommemory(&dsactx, session,
-                                              privkeyfiledata,
-                                              privkeyfiledata_len, passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    *abstract = dsactx;
-
-    return 0;
-}
-
-/*
- * libssh2_hostkey_method_ssh_dss_sign
- *
- * Verify signature created by remote
- */
-static int
-hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session,
-                                  const unsigned char *sig,
-                                  size_t sig_len,
-                                  const unsigned char *m,
-                                  size_t m_len, void **abstract)
-{
-    libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
-
-    /* Skip past keyname_len(4) + keyname(7){"ssh-dss"} + signature_len(4) */
-    if(sig_len != 55) {
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "Invalid DSS signature length");
-    }
-
-    sig += 15;
-    sig_len -= 15;
-
-    return _libssh2_dsa_sha1_verify(dsactx, sig, m, m_len);
-}
-
-/*
- * hostkey_method_ssh_dss_signv
- *
- * Construct a signature from an array of vectors
- */
-static int
-hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
-                             unsigned char **signature,
-                             size_t *signature_len,
-                             int veccount,
-                             const struct iovec datavec[],
-                             void **abstract)
-{
-    libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    libssh2_sha1_ctx ctx;
-    int i;
-
-    *signature = LIBSSH2_CALLOC(session, 2 * SHA_DIGEST_LENGTH);
-    if(!*signature) {
-        return -1;
-    }
-
-    *signature_len = 2 * SHA_DIGEST_LENGTH;
-
-    libssh2_sha1_init(&ctx);
-    for(i = 0; i < veccount; i++) {
-        libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
-    }
-    libssh2_sha1_final(ctx, hash);
-
-    if(_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
-        LIBSSH2_FREE(session, *signature);
-        return -1;
-    }
-
-    return 0;
-}
-
-/*
- * libssh2_hostkey_method_ssh_dss_dtor
- *
- * Shutdown the hostkey method
- */
-static int
-hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
-    (void) session;
-
-    _libssh2_dsa_free(dsactx);
-
-    *abstract = NULL;
-
-    return 0;
-}
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_dss = {
-    "ssh-dss",
-    MD5_DIGEST_LENGTH,
-    hostkey_method_ssh_dss_init,
-    hostkey_method_ssh_dss_initPEM,
-    hostkey_method_ssh_dss_initPEMFromMemory,
-    hostkey_method_ssh_dss_sig_verify,
-    hostkey_method_ssh_dss_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_dss_dtor,
-};
-#endif /* LIBSSH2_DSA */
-
-#if LIBSSH2_ECDSA
-
-/* ***********
- * ecdsa-sha2-nistp256/384/521 *
- *********** */
-
-static int
-hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session,
-                              void **abstract);
-
-/*
- * hostkey_method_ssh_ecdsa_init
- *
- * Initialize the server hostkey working area with e/n pair
- */
-static int
-hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
-                          const unsigned char *hostkey_data,
-                          size_t hostkey_data_len,
-                          void **abstract)
-{
-    libssh2_ecdsa_ctx *ecdsactx = NULL;
-    unsigned char *type_str, *domain, *public_key;
-    size_t key_len, len;
-    libssh2_curve_type type;
-    struct string_buf buf;
-
-    if(abstract != NULL && *abstract) {
-        hostkey_method_ssh_ecdsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    if(hostkey_data_len < 39) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
-        return -1;
-    }
-
-    buf.data = (unsigned char *)hostkey_data;
-    buf.dataptr = buf.data;
-    buf.len = hostkey_data_len;
-
-    if(_libssh2_get_string(&buf, &type_str, &len) || len != 19)
-        return -1;
-
-    if(strncmp((char *) type_str, "ecdsa-sha2-nistp256", 19) == 0) {
-        type = LIBSSH2_EC_CURVE_NISTP256;
-    }
-    else if(strncmp((char *) type_str, "ecdsa-sha2-nistp384", 19) == 0) {
-        type = LIBSSH2_EC_CURVE_NISTP384;
-    }
-    else if(strncmp((char *) type_str, "ecdsa-sha2-nistp521", 19) == 0) {
-        type = LIBSSH2_EC_CURVE_NISTP521;
-    }
-    else {
-        return -1;
-    }
-
-    if(_libssh2_get_string(&buf, &domain, &len) || len != 8)
-        return -1;
-
-    if(type == LIBSSH2_EC_CURVE_NISTP256 &&
-       strncmp((char *)domain, "nistp256", 8) != 0) {
-        return -1;
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP384 &&
-            strncmp((char *)domain, "nistp384", 8) != 0) {
-        return -1;
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP521 &&
-            strncmp((char *)domain, "nistp521", 8) != 0) {
-        return -1;
-    }
-
-    /* public key */
-    if(_libssh2_get_string(&buf, &public_key, &key_len))
-        return -1;
-
-    if(_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, public_key,
-                                                key_len, type))
-        return -1;
-
-    if(abstract != NULL)
-        *abstract = ecdsactx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_ecdsa_initPEM
- *
- * Load a Private Key from a PEM file
- */
-static int
-hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
-                             const char *privkeyfile,
-                             unsigned const char *passphrase,
-                             void **abstract)
-{
-    libssh2_ecdsa_ctx *ec_ctx = NULL;
-    int ret;
-
-    if(abstract != NULL && *abstract) {
-        hostkey_method_ssh_ecdsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_ecdsa_new_private(&ec_ctx, session,
-                                     privkeyfile, passphrase);
-
-    if(abstract != NULL)
-        *abstract = ec_ctx;
-
-    return ret;
-}
-
-/*
- * hostkey_method_ssh_ecdsa_initPEMFromMemory
- *
- * Load a Private Key from memory
- */
-static int
-hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
-                                         const char *privkeyfiledata,
-                                         size_t privkeyfiledata_len,
-                                         unsigned const char *passphrase,
-                                         void **abstract)
-{
-    libssh2_ecdsa_ctx *ec_ctx = NULL;
-    int ret;
-
-    if(abstract != NULL && *abstract) {
-        hostkey_method_ssh_ecdsa_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_ecdsa_new_private_frommemory(&ec_ctx, session,
-                                                privkeyfiledata,
-                                                privkeyfiledata_len,
-                                                passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    if(abstract != NULL)
-        *abstract = ec_ctx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ecdsa_sig_verify
- *
- * Verify signature created by remote
- */
-static int
-hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
-                                    const unsigned char *sig,
-                                    size_t sig_len,
-                                    const unsigned char *m,
-                                    size_t m_len, void **abstract)
-{
-    unsigned char *r, *s, *name;
-    size_t r_len, s_len, name_len;
-    uint32_t len;
-    struct string_buf buf;
-    libssh2_ecdsa_ctx *ctx = (libssh2_ecdsa_ctx *) (*abstract);
-
-    (void) session;
-
-    if(sig_len < 35)
-        return -1;
-
-    /* keyname_len(4) + keyname(19){"ecdsa-sha2-nistp256"} +
-       signature_len(4) */
-    buf.data = (unsigned char *)sig;
-    buf.dataptr = buf.data;
-    buf.len = sig_len;
-
-   if(_libssh2_get_string(&buf, &name, &name_len) || name_len != 19)
-        return -1;
-
-    if(_libssh2_get_u32(&buf, &len) != 0 || len < 8)
-        return -1;
-
-    if(_libssh2_get_string(&buf, &r, &r_len))
-       return -1;
-
-    if(_libssh2_get_string(&buf, &s, &s_len))
-        return -1;
-
-    return _libssh2_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len);
-}
-
-
-#define LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(digest_type)               \
-    {                                                                   \
-        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
-        libssh2_sha##digest_type##_ctx ctx;                             \
-        int i;                                                          \
-        libssh2_sha##digest_type##_init(&ctx);                          \
-        for(i = 0; i < veccount; i++) {                                 \
-            libssh2_sha##digest_type##_update(ctx, datavec[i].iov_base, \
-                                              datavec[i].iov_len);      \
-        }                                                               \
-        libssh2_sha##digest_type##_final(ctx, hash);                    \
-        ret = _libssh2_ecdsa_sign(session, ec_ctx, hash,                \
-                                  SHA##digest_type##_DIGEST_LENGTH,     \
-                                  signature, signature_len);            \
-    }
-
-
-/*
- * hostkey_method_ecdsa_signv
- *
- * Construct a signature from an array of vectors
- */
-static int
-hostkey_method_ssh_ecdsa_signv(LIBSSH2_SESSION * session,
-                               unsigned char **signature,
-                               size_t *signature_len,
-                               int veccount,
-                               const struct iovec datavec[],
-                               void **abstract)
-{
-    libssh2_ecdsa_ctx *ec_ctx = (libssh2_ecdsa_ctx *) (*abstract);
-    libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ec_ctx);
-    int ret = 0;
-
-    if(type == LIBSSH2_EC_CURVE_NISTP256) {
-        LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(256);
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
-        LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(384);
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
-        LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(512);
-    }
-    else {
-        return -1;
-    }
-
-    return ret;
-}
-
-/*
- * hostkey_method_ssh_ecdsa_dtor
- *
- * Shutdown the hostkey by freeing EC_KEY context
- */
-static int
-hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    libssh2_ecdsa_ctx *keyctx = (libssh2_ecdsa_ctx *) (*abstract);
-    (void) session;
-
-    if(keyctx != NULL)
-        _libssh2_ecdsa_free(keyctx);
-
-    *abstract = NULL;
-
-    return 0;
-}
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp256 = {
-    "ecdsa-sha2-nistp256",
-    SHA256_DIGEST_LENGTH,
-    hostkey_method_ssh_ecdsa_init,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    hostkey_method_ssh_ecdsa_sig_verify,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp384 = {
-    "ecdsa-sha2-nistp384",
-    SHA384_DIGEST_LENGTH,
-    hostkey_method_ssh_ecdsa_init,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    hostkey_method_ssh_ecdsa_sig_verify,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp521 = {
-    "ecdsa-sha2-nistp521",
-    SHA512_DIGEST_LENGTH,
-    hostkey_method_ssh_ecdsa_init,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    hostkey_method_ssh_ecdsa_sig_verify,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp256_cert = {
-    "ecdsa-sha2-nistp256-cert-v01@openssh.com",
-    SHA256_DIGEST_LENGTH,
-    NULL,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    NULL,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp384_cert = {
-    "ecdsa-sha2-nistp384-cert-v01@openssh.com",
-    SHA384_DIGEST_LENGTH,
-    NULL,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    NULL,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ecdsa_ssh_nistp521_cert = {
-    "ecdsa-sha2-nistp521-cert-v01@openssh.com",
-    SHA512_DIGEST_LENGTH,
-    NULL,
-    hostkey_method_ssh_ecdsa_initPEM,
-    hostkey_method_ssh_ecdsa_initPEMFromMemory,
-    NULL,
-    hostkey_method_ssh_ecdsa_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ecdsa_dtor,
-};
-
-#endif /* LIBSSH2_ECDSA */
-
-#if LIBSSH2_ED25519
-
-/* ***********
- * ed25519 *
- *********** */
-
-static int hostkey_method_ssh_ed25519_dtor(LIBSSH2_SESSION * session,
-                                           void **abstract);
-
-/*
- * hostkey_method_ssh_ed25519_init
- *
- * Initialize the server hostkey working area with e/n pair
- */
-static int
-hostkey_method_ssh_ed25519_init(LIBSSH2_SESSION * session,
-                                const unsigned char *hostkey_data,
-                                size_t hostkey_data_len,
-                                void **abstract)
-{
-    const unsigned char *s;
-    unsigned long len, key_len;
-    libssh2_ed25519_ctx *ctx = NULL;
-
-    if(*abstract) {
-        hostkey_method_ssh_ed25519_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    if(hostkey_data_len < 19) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
-        return -1;
-    }
-
-    s = hostkey_data;
-    len = _libssh2_ntohu32(s);
-    s += 4;
-
-    if(len != 11 || strncmp((char *) s, "ssh-ed25519", 11) != 0) {
-        return -1;
-    }
-
-    s += 11;
-
-    /* public key */
-    key_len = _libssh2_ntohu32(s);
-    s += 4;
-
-    if(_libssh2_ed25519_new_public(&ctx, session, s, key_len) != 0) {
-        return -1;
-    }
-
-    *abstract = ctx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_ed25519_initPEM
- *
- * Load a Private Key from a PEM file
- */
-static int
-hostkey_method_ssh_ed25519_initPEM(LIBSSH2_SESSION * session,
-                             const char *privkeyfile,
-                             unsigned const char *passphrase,
-                             void **abstract)
-{
-    libssh2_ed25519_ctx *ec_ctx = NULL;
-    int ret;
-
-    if(*abstract) {
-        hostkey_method_ssh_ed25519_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_ed25519_new_private(&ec_ctx, session,
-                                       privkeyfile, passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    *abstract = ec_ctx;
-
-    return ret;
-}
-
-/*
- * hostkey_method_ssh_ed25519_initPEMFromMemory
- *
- * Load a Private Key from memory
- */
-static int
-hostkey_method_ssh_ed25519_initPEMFromMemory(LIBSSH2_SESSION * session,
-                                             const char *privkeyfiledata,
-                                             size_t privkeyfiledata_len,
-                                             unsigned const char *passphrase,
-                                             void **abstract)
-{
-    libssh2_ed25519_ctx *ed_ctx = NULL;
-    int ret;
-
-    if(abstract != NULL && *abstract) {
-        hostkey_method_ssh_ed25519_dtor(session, abstract);
-        *abstract = NULL;
-    }
-
-    ret = _libssh2_ed25519_new_private_frommemory(&ed_ctx, session,
-                                                  privkeyfiledata,
-                                                  privkeyfiledata_len,
-                                                  passphrase);
-    if(ret) {
-        return -1;
-    }
-
-    if(abstract != NULL)
-        *abstract = ed_ctx;
-
-    return 0;
-}
-
-/*
- * hostkey_method_ssh_ed25519_sig_verify
- *
- * Verify signature created by remote
- */
-static int
-hostkey_method_ssh_ed25519_sig_verify(LIBSSH2_SESSION * session,
-                                      const unsigned char *sig,
-                                      size_t sig_len,
-                                      const unsigned char *m,
-                                      size_t m_len, void **abstract)
-{
-    libssh2_ed25519_ctx *ctx = (libssh2_ed25519_ctx *) (*abstract);
-    (void) session;
-
-    if(sig_len < 19)
-        return -1;
-
-    /* Skip past keyname_len(4) + keyname(11){"ssh-ed25519"} +
-       signature_len(4) */
-    sig += 19;
-    sig_len -= 19;
-
-    if(sig_len != LIBSSH2_ED25519_SIG_LEN)
-        return -1;
-
-    return _libssh2_ed25519_verify(ctx, sig, sig_len, m, m_len);
-}
-
-/*
- * hostkey_method_ssh_ed25519_signv
- *
- * Construct a signature from an array of vectors
- */
-static int
-hostkey_method_ssh_ed25519_signv(LIBSSH2_SESSION * session,
-                           unsigned char **signature,
-                           size_t *signature_len,
-                           int veccount,
-                           const struct iovec datavec[],
-                           void **abstract)
-{
-    libssh2_ed25519_ctx *ctx = (libssh2_ed25519_ctx *) (*abstract);
-
-    if(veccount != 1) {
-        return -1;
-    }
-
-    return _libssh2_ed25519_sign(ctx, session, signature, signature_len,
-                                 datavec[0].iov_base, datavec[0].iov_len);
-}
-
-
-/*
- * hostkey_method_ssh_ed25519_dtor
- *
- * Shutdown the hostkey by freeing key context
- */
-static int
-hostkey_method_ssh_ed25519_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    libssh2_ed25519_ctx *keyctx = (libssh2_ed25519_ctx*) (*abstract);
-    (void) session;
-
-    if(keyctx)
-        _libssh2_ed25519_free(keyctx);
-
-    *abstract = NULL;
-
-    return 0;
-}
-
-static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_ed25519 = {
-    "ssh-ed25519",
-    SHA256_DIGEST_LENGTH,
-    hostkey_method_ssh_ed25519_init,
-    hostkey_method_ssh_ed25519_initPEM,
-    hostkey_method_ssh_ed25519_initPEMFromMemory,
-    hostkey_method_ssh_ed25519_sig_verify,
-    hostkey_method_ssh_ed25519_signv,
-    NULL,                       /* encrypt */
-    hostkey_method_ssh_ed25519_dtor,
-};
-
-#endif /*LIBSSH2_ED25519*/
-
-
-static const LIBSSH2_HOSTKEY_METHOD *hostkey_methods[] = {
-#if LIBSSH2_ECDSA
-    &hostkey_method_ecdsa_ssh_nistp256,
-    &hostkey_method_ecdsa_ssh_nistp384,
-    &hostkey_method_ecdsa_ssh_nistp521,
-    &hostkey_method_ecdsa_ssh_nistp256_cert,
-    &hostkey_method_ecdsa_ssh_nistp384_cert,
-    &hostkey_method_ecdsa_ssh_nistp521_cert,
-#endif
-#if LIBSSH2_ED25519
-    &hostkey_method_ssh_ed25519,
-#endif
-#if LIBSSH2_RSA
-    &hostkey_method_ssh_rsa,
-#endif /* LIBSSH2_RSA */
-#if LIBSSH2_DSA
-    &hostkey_method_ssh_dss,
-#endif /* LIBSSH2_DSA */
-    NULL
-};
-
-const LIBSSH2_HOSTKEY_METHOD **
-libssh2_hostkey_methods(void)
-{
-    return hostkey_methods;
-}
-
-/*
- * libssh2_hostkey_hash
- *
- * Returns hash signature
- * Returned buffer should NOT be freed
- * Length of buffer is determined by hash type
- * i.e. MD5 == 16, SHA1 == 20, SHA256 == 32
- */
-LIBSSH2_API const char *
-libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type)
-{
-    switch(hash_type) {
-#if LIBSSH2_MD5
-    case LIBSSH2_HOSTKEY_HASH_MD5:
-        return (session->server_hostkey_md5_valid)
-          ? (char *) session->server_hostkey_md5
-          : NULL;
-        break;
-#endif /* LIBSSH2_MD5 */
-    case LIBSSH2_HOSTKEY_HASH_SHA1:
-        return (session->server_hostkey_sha1_valid)
-          ? (char *) session->server_hostkey_sha1
-          : NULL;
-        break;
-    case LIBSSH2_HOSTKEY_HASH_SHA256:
-        return (session->server_hostkey_sha256_valid)
-          ? (char *) session->server_hostkey_sha256
-          : NULL;
-        break;
-    default:
-        return NULL;
-    }
-}
-
-static int hostkey_type(const unsigned char *hostkey, size_t len)
-{
-    static const unsigned char rsa[] = {
-        0, 0, 0, 0x07, 's', 's', 'h', '-', 'r', 's', 'a'
-    };
-    static const unsigned char dss[] = {
-        0, 0, 0, 0x07, 's', 's', 'h', '-', 'd', 's', 's'
-    };
-    static const unsigned char ecdsa_256[] = {
-        0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-',
-        'n', 'i', 's', 't', 'p', '2', '5', '6'
-    };
-    static const unsigned char ecdsa_384[] = {
-        0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-',
-        'n', 'i', 's', 't', 'p', '3', '8', '4'
-    };
-    static const unsigned char ecdsa_521[] = {
-        0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-',
-        'n', 'i', 's', 't', 'p', '5', '2', '1'
-    };
-    static const unsigned char ed25519[] = {
-        0, 0, 0, 0x0b, 's', 's', 'h', '-', 'e', 'd', '2', '5', '5', '1', '9'
-    };
-
-    if(len < 11)
-        return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
-
-    if(!memcmp(rsa, hostkey, 11))
-        return LIBSSH2_HOSTKEY_TYPE_RSA;
-
-    if(!memcmp(dss, hostkey, 11))
-        return LIBSSH2_HOSTKEY_TYPE_DSS;
-
-    if(len < 15)
-        return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
-
-    if(!memcmp(ed25519, hostkey, 15))
-        return LIBSSH2_HOSTKEY_TYPE_ED25519;
-
-    if(len < 23)
-        return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
-
-    if(!memcmp(ecdsa_256, hostkey, 23))
-        return LIBSSH2_HOSTKEY_TYPE_ECDSA_256;
-
-    if(!memcmp(ecdsa_384, hostkey, 23))
-        return LIBSSH2_HOSTKEY_TYPE_ECDSA_384;
-
-    if(!memcmp(ecdsa_521, hostkey, 23))
-        return LIBSSH2_HOSTKEY_TYPE_ECDSA_521;
-
-    return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
-}
-
-/*
- * libssh2_session_hostkey()
- *
- * Returns the server key and length.
- *
- */
-LIBSSH2_API const char *
-libssh2_session_hostkey(LIBSSH2_SESSION *session, size_t *len, int *type)
-{
-    if(session->server_hostkey_len) {
-        if(len)
-            *len = session->server_hostkey_len;
-        if(type)
-            *type = hostkey_type(session->server_hostkey,
-                                 session->server_hostkey_len);
-        return (char *) session->server_hostkey;
-    }
-    if(len)
-        *len = 0;
-    return NULL;
-}
diff --git a/libssh2/libssh2/src/keepalive.c b/libssh2/libssh2/src/keepalive.c
deleted file mode 100644
index 2151b171..00000000
--- a/libssh2/libssh2/src/keepalive.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/* Copyright (C) 2010  Simon Josefsson
- * Author: Simon Josefsson
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-#include "libssh2_priv.h"
-#include "transport.h" /* _libssh2_transport_write */
-
-/* Keep-alive stuff. */
-
-LIBSSH2_API void
-libssh2_keepalive_config (LIBSSH2_SESSION *session,
-                          int want_reply,
-                          unsigned interval)
-{
-    if(interval == 1)
-        session->keepalive_interval = 2;
-    else
-        session->keepalive_interval = interval;
-    session->keepalive_want_reply = want_reply ? 1 : 0;
-}
-
-LIBSSH2_API int
-libssh2_keepalive_send (LIBSSH2_SESSION *session,
-                        int *seconds_to_next)
-{
-    time_t now;
-
-    if(!session->keepalive_interval) {
-        if(seconds_to_next)
-            *seconds_to_next = 0;
-        return 0;
-    }
-
-    now = time(NULL);
-
-    if(session->keepalive_last_sent + session->keepalive_interval <= now) {
-        /* Format is
-           "SSH_MSG_GLOBAL_REQUEST || 4-byte len || str || want-reply". */
-        unsigned char keepalive_data[]
-            = "\x50\x00\x00\x00\x15keepalive@libssh2.orgW";
-        size_t len = sizeof(keepalive_data) - 1;
-        int rc;
-
-        keepalive_data[len - 1] =
-            (unsigned char)session->keepalive_want_reply;
-
-        rc = _libssh2_transport_send(session, keepalive_data, len, NULL, 0);
-        /* Silently ignore PACKET_EAGAIN here: if the write buffer is
-           already full, sending another keepalive is not useful. */
-        if(rc && rc != LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send keepalive message");
-            return rc;
-        }
-
-        session->keepalive_last_sent = now;
-        if(seconds_to_next)
-            *seconds_to_next = session->keepalive_interval;
-    }
-    else if(seconds_to_next) {
-        *seconds_to_next = (int) (session->keepalive_last_sent - now)
-            + session->keepalive_interval;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/src/kex.c b/libssh2/libssh2/src/kex.c
deleted file mode 100644
index 9f3ef799..00000000
--- a/libssh2/libssh2/src/kex.c
+++ /dev/null
@@ -1,4141 +0,0 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2019, Daniel Stenberg <daniel@haxx.se>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#include "transport.h"
-#include "comp.h"
-#include "mac.h"
-
-#include <assert.h>
-
-/* define SHA1_DIGEST_LENGTH for the macro below */
-#ifndef SHA1_DIGEST_LENGTH
-#define SHA1_DIGEST_LENGTH SHA_DIGEST_LENGTH
-#endif
-
-/* TODO: Switch this to an inline and handle alloc() failures */
-/* Helper macro called from
-   kex_method_diffie_hellman_group1_sha1_key_exchange */
-
-#define LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(value, reqlen, version)        \
-    {                                                                       \
-        if(type == LIBSSH2_EC_CURVE_NISTP256) {                             \
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, value, reqlen, version); \
-        }                                                                   \
-        else if(type == LIBSSH2_EC_CURVE_NISTP384) {                        \
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(384, value, reqlen, version); \
-        }                                                                   \
-        else if(type == LIBSSH2_EC_CURVE_NISTP521) {                        \
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(512, value, reqlen, version); \
-        }                                                                   \
-    }                                                                       \
-
-
-#define LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(digest_type, value,               \
-                                          reqlen, version)                  \
-{                                                                           \
-    libssh2_sha##digest_type##_ctx hash;                                    \
-    unsigned long len = 0;                                                  \
-    if(!(value)) {                                                          \
-        value = LIBSSH2_ALLOC(session,                                      \
-                              reqlen + SHA##digest_type##_DIGEST_LENGTH);   \
-    }                                                                       \
-    if(value)                                                               \
-        while(len < (unsigned long)reqlen) {                                \
-            libssh2_sha##digest_type##_init(&hash);                         \
-            libssh2_sha##digest_type##_update(hash,                         \
-                                              exchange_state->k_value,      \
-                                              exchange_state->k_value_len); \
-            libssh2_sha##digest_type##_update(hash,                         \
-                                              exchange_state->h_sig_comp,   \
-                                         SHA##digest_type##_DIGEST_LENGTH); \
-            if(len > 0) {                                                   \
-                libssh2_sha##digest_type##_update(hash, value, len);        \
-            }                                                               \
-            else {                                                          \
-                libssh2_sha##digest_type##_update(hash, (version), 1);      \
-                libssh2_sha##digest_type##_update(hash, session->session_id,\
-                                                  session->session_id_len); \
-            }                                                               \
-            libssh2_sha##digest_type##_final(hash, (value) + len);          \
-            len += SHA##digest_type##_DIGEST_LENGTH;                        \
-        }                                                                   \
-}
-
-/*!
- * @note The following are wrapper functions used by diffie_hellman_sha_algo().
- * TODO: Switch backend SHA macros to functions to allow function pointers
- * @discussion Ideally these would be function pointers but the backend macros
- * don't allow it so we have to wrap them up in helper functions
- */
-
-static void _libssh2_sha_algo_ctx_init(int sha_algo, void *ctx)
-{
-    if(sha_algo == 512) {
-        libssh2_sha512_init((libssh2_sha512_ctx*)ctx);
-    }
-    else if(sha_algo == 384) {
-        libssh2_sha384_init((libssh2_sha384_ctx*)ctx);
-    }
-    else if(sha_algo == 256) {
-        libssh2_sha256_init((libssh2_sha256_ctx*)ctx);
-    }
-    else if(sha_algo == 1) {
-        libssh2_sha1_init((libssh2_sha1_ctx*)ctx);
-    }
-    else {
-        assert(0);
-    }
-}
-
-static void _libssh2_sha_algo_ctx_update(int sha_algo, void *ctx,
-                                         void *data, size_t len)
-{
-    if(sha_algo == 512) {
-        libssh2_sha512_ctx *_ctx = (libssh2_sha512_ctx*)ctx;
-        libssh2_sha512_update(*_ctx, data, len);
-    }
-    else if(sha_algo == 384) {
-        libssh2_sha384_ctx *_ctx = (libssh2_sha384_ctx*)ctx;
-        libssh2_sha384_update(*_ctx, data, len);
-    }
-    else if(sha_algo == 256) {
-        libssh2_sha256_ctx *_ctx = (libssh2_sha256_ctx*)ctx;
-        libssh2_sha256_update(*_ctx, data, len);
-    }
-    else if(sha_algo == 1) {
-        libssh2_sha1_ctx *_ctx = (libssh2_sha1_ctx*)ctx;
-        libssh2_sha1_update(*_ctx, data, len);
-    }
-    else {
-#if LIBSSH2DEBUG
-        assert(0);
-#endif
-    }
-}
-
-static void _libssh2_sha_algo_ctx_final(int sha_algo, void *ctx,
-                                        void *hash)
-{
-    if(sha_algo == 512) {
-        libssh2_sha512_ctx *_ctx = (libssh2_sha512_ctx*)ctx;
-        libssh2_sha512_final(*_ctx, hash);
-    }
-    else if(sha_algo == 384) {
-        libssh2_sha384_ctx *_ctx = (libssh2_sha384_ctx*)ctx;
-        libssh2_sha384_final(*_ctx, hash);
-    }
-    else if(sha_algo == 256) {
-        libssh2_sha256_ctx *_ctx = (libssh2_sha256_ctx*)ctx;
-        libssh2_sha256_final(*_ctx, hash);
-    }
-    else if(sha_algo == 1) {
-        libssh2_sha1_ctx *_ctx = (libssh2_sha1_ctx*)ctx;
-        libssh2_sha1_final(*_ctx, hash);
-    }
-    else {
-#if LIBSSH2DEBUG
-        assert(0);
-#endif
-    }
-}
-
-static void _libssh2_sha_algo_value_hash(int sha_algo,
-                                      LIBSSH2_SESSION *session,
-                                      kmdhgGPshakex_state_t *exchange_state,
-                                      unsigned char **data, size_t data_len,
-                                      const unsigned char *version)
-{
-    if(sha_algo == 512) {
-        LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(512, *data, data_len, version);
-    }
-    else if(sha_algo == 384) {
-        LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(384, *data, data_len, version);
-    }
-    else if(sha_algo == 256) {
-        LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, *data, data_len, version);
-    }
-    else if(sha_algo == 1) {
-        LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(1, *data, data_len, version);
-    }
-    else {
-#if LIBSSH2DEBUG
-        assert(0);
-#endif
-    }
-}
-
-
-/*!
- * @function diffie_hellman_sha_algo
- * @abstract Diffie Hellman Key Exchange, Group Agnostic,
- * SHA Algorithm Agnostic
- * @result 0 on success, error code on failure
- */
-static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
-                                   _libssh2_bn *g,
-                                   _libssh2_bn *p,
-                                   int group_order,
-                                   int sha_algo_value,
-                                   void *exchange_hash_ctx,
-                                   unsigned char packet_type_init,
-                                   unsigned char packet_type_reply,
-                                   unsigned char *midhash,
-                                   unsigned long midhash_len,
-                                   kmdhgGPshakex_state_t *exchange_state)
-{
-    int ret = 0;
-    int rc;
-
-    int digest_len = 0;
-
-    if(sha_algo_value == 512)
-        digest_len = SHA512_DIGEST_LENGTH;
-    else if(sha_algo_value == 384)
-        digest_len = SHA384_DIGEST_LENGTH;
-    else if(sha_algo_value == 256)
-        digest_len = SHA256_DIGEST_LENGTH;
-    else if(sha_algo_value == 1)
-        digest_len = SHA1_DIGEST_LENGTH;
-    else {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                            "sha algo value is unimplemented");
-        goto clean_exit;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_idle) {
-        /* Setup initial values */
-        exchange_state->e_packet = NULL;
-        exchange_state->s_packet = NULL;
-        exchange_state->k_value = NULL;
-        exchange_state->ctx = _libssh2_bn_ctx_new();
-        libssh2_dh_init(&exchange_state->x);
-        exchange_state->e = _libssh2_bn_init(); /* g^x mod p */
-        exchange_state->f = _libssh2_bn_init_from_bin(); /* g^(Random from
-                                                            server) mod p */
-        exchange_state->k = _libssh2_bn_init(); /* The shared secret: f^x mod
-                                                   p */
-
-        /* Zero the whole thing out */
-        memset(&exchange_state->req_state, 0, sizeof(packet_require_state_t));
-
-        /* Generate x and e */
-        if(_libssh2_bn_bits(p) > LIBSSH2_DH_MAX_MODULUS_BITS) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                                 "dh modulus value is too large");
-            goto clean_exit;
-        }
-
-        rc = libssh2_dh_key_pair(&exchange_state->x, exchange_state->e, g, p,
-                                 group_order, exchange_state->ctx);
-        if(rc)
-            goto clean_exit;
-
-        /* Send KEX init */
-        /* packet_type(1) + String Length(4) + leading 0(1) */
-        exchange_state->e_packet_len =
-            _libssh2_bn_bytes(exchange_state->e) + 6;
-        if(_libssh2_bn_bits(exchange_state->e) % 8) {
-            /* Leading 00 not needed */
-            exchange_state->e_packet_len--;
-        }
-
-        exchange_state->e_packet =
-            LIBSSH2_ALLOC(session, exchange_state->e_packet_len);
-        if(!exchange_state->e_packet) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Out of memory error");
-            goto clean_exit;
-        }
-        exchange_state->e_packet[0] = packet_type_init;
-        _libssh2_htonu32(exchange_state->e_packet + 1,
-                         exchange_state->e_packet_len - 5);
-        if(_libssh2_bn_bits(exchange_state->e) % 8) {
-            _libssh2_bn_to_bin(exchange_state->e,
-                               exchange_state->e_packet + 5);
-        }
-        else {
-            exchange_state->e_packet[5] = 0;
-            _libssh2_bn_to_bin(exchange_state->e,
-                               exchange_state->e_packet + 6);
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending KEX packet %d",
-                       (int) packet_type_init);
-        exchange_state->state = libssh2_NB_state_created;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, exchange_state->e_packet,
-                                     exchange_state->e_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send KEX init message");
-            goto clean_exit;
-        }
-        exchange_state->state = libssh2_NB_state_sent;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent) {
-        if(session->burn_optimistic_kexinit) {
-            /* The first KEX packet to come along will be the guess initially
-             * sent by the server.  That guess turned out to be wrong so we
-             * need to silently ignore it */
-            int burn_type;
-
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Waiting for badly guessed KEX packet "
-                           "(to be ignored)");
-            burn_type =
-                _libssh2_packet_burn(session, &exchange_state->burn_state);
-            if(burn_type == LIBSSH2_ERROR_EAGAIN) {
-                return burn_type;
-            }
-            else if(burn_type <= 0) {
-                /* Failed to receive a packet */
-                ret = burn_type;
-                goto clean_exit;
-            }
-            session->burn_optimistic_kexinit = 0;
-
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Burnt packet of type: %02x",
-                           (unsigned int) burn_type);
-        }
-
-        exchange_state->state = libssh2_NB_state_sent1;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent1) {
-        /* Wait for KEX reply */
-        struct string_buf buf;
-        size_t host_key_len;
-
-        rc = _libssh2_packet_require(session, packet_type_reply,
-                                     &exchange_state->s_packet,
-                                     &exchange_state->s_packet_len, 0, NULL,
-                                     0, &exchange_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        if(rc) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
-                                 "Timed out waiting for KEX reply");
-            goto clean_exit;
-        }
-
-        /* Parse KEXDH_REPLY */
-        if(exchange_state->s_packet_len < 5) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected packet length");
-            goto clean_exit;
-        }
-
-        buf.data = exchange_state->s_packet;
-        buf.len = exchange_state->s_packet_len;
-        buf.dataptr = buf.data;
-        buf.dataptr++; /* advance past type */
-
-        if(session->server_hostkey)
-            LIBSSH2_FREE(session, session->server_hostkey);
-
-        if(_libssh2_copy_string(session, &buf, &(session->server_hostkey),
-                                &host_key_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Could not copy host key");
-            goto clean_exit;
-        }
-
-        session->server_hostkey_len = (uint32_t)host_key_len;
-
-#if LIBSSH2_MD5
-        {
-            libssh2_md5_ctx fingerprint_ctx;
-
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
-                session->server_hostkey_md5_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_md5_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[50], *fprint = fingerprint;
-            int i;
-            for(i = 0; i < 16; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's MD5 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-#endif /* ! LIBSSH2_MD5 */
-
-        {
-            libssh2_sha1_ctx fingerprint_ctx;
-
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
-                session->server_hostkey_sha1_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha1_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[64], *fprint = fingerprint;
-            int i;
-
-            for(i = 0; i < 20; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's SHA1 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-
-        {
-            libssh2_sha256_ctx fingerprint_ctx;
-
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
-                session->server_hostkey_sha256_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha256_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session,
-                                   (const char *)
-                                   session->server_hostkey_sha256,
-                                   SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                               "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
-                LIBSSH2_FREE(session, base64Fingerprint);
-            }
-        }
-#endif /* LIBSSH2DEBUG */
-
-
-        if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
-            goto clean_exit;
-        }
-
-        if(_libssh2_get_string(&buf, &(exchange_state->f_value),
-                               &(exchange_state->f_value_len))) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to get f value");
-            goto clean_exit;
-        }
-
-        _libssh2_bn_from_bin(exchange_state->f, exchange_state->f_value_len,
-                             exchange_state->f_value);
-
-        if(_libssh2_get_string(&buf, &(exchange_state->h_sig),
-                               &(exchange_state->h_sig_len))) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to get h sig");
-            goto clean_exit;
-        }
-
-        /* Compute the shared secret */
-        libssh2_dh_secret(&exchange_state->x, exchange_state->k,
-                          exchange_state->f, p, exchange_state->ctx);
-        exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            /* don't need leading 00 */
-            exchange_state->k_value_len--;
-        }
-        exchange_state->k_value =
-            LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if(!exchange_state->k_value) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate buffer for K");
-            goto clean_exit;
-        }
-        _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        }
-        else {
-            exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
-        }
-
-        exchange_state->exchange_hash = (void *)&exchange_hash_ctx;
-        _libssh2_sha_algo_ctx_init(sha_algo_value, exchange_hash_ctx);
-
-        if(session->local.banner) {
-            _libssh2_htonu32(exchange_state->h_sig_comp,
-                             strlen((char *) session->local.banner) - 2);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                session->local.banner,
-                                strlen((char *) session->local.banner) - 2);
-        }
-        else {
-            _libssh2_htonu32(exchange_state->h_sig_comp,
-                             sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                    (unsigned char *)
-                                    LIBSSH2_SSH_DEFAULT_BANNER,
-                                    sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
-        }
-
-        _libssh2_htonu32(exchange_state->h_sig_comp,
-                         strlen((char *) session->remote.banner));
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->remote.banner,
-                                     strlen((char *) session->remote.banner));
-
-        _libssh2_htonu32(exchange_state->h_sig_comp,
-                         session->local.kexinit_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->local.kexinit,
-                                     session->local.kexinit_len);
-
-        _libssh2_htonu32(exchange_state->h_sig_comp,
-                         session->remote.kexinit_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->remote.kexinit,
-                                     session->remote.kexinit_len);
-
-        _libssh2_htonu32(exchange_state->h_sig_comp,
-                         session->server_hostkey_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->server_hostkey,
-                                     session->server_hostkey_len);
-
-        if(packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
-            /* diffie-hellman-group-exchange hashes additional fields */
-#ifdef LIBSSH2_DH_GEX_NEW
-            _libssh2_htonu32(exchange_state->h_sig_comp,
-                             LIBSSH2_DH_GEX_MINGROUP);
-            _libssh2_htonu32(exchange_state->h_sig_comp + 4,
-                             LIBSSH2_DH_GEX_OPTGROUP);
-            _libssh2_htonu32(exchange_state->h_sig_comp + 8,
-                             LIBSSH2_DH_GEX_MAXGROUP);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 12);
-#else
-            _libssh2_htonu32(exchange_state->h_sig_comp,
-                             LIBSSH2_DH_GEX_OPTGROUP);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-#endif
-        }
-
-        if(midhash) {
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         midhash, midhash_len);
-        }
-
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->e_packet + 1,
-                                     exchange_state->e_packet_len - 1);
-
-        _libssh2_htonu32(exchange_state->h_sig_comp,
-                         exchange_state->f_value_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->f_value,
-                                     exchange_state->f_value_len);
-
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->k_value,
-                                     exchange_state->k_value_len);
-
-        _libssh2_sha_algo_ctx_final(sha_algo_value, exchange_hash_ctx,
-                                    exchange_state->h_sig_comp);
-
-        if(session->hostkey->
-           sig_verify(session, exchange_state->h_sig,
-                      exchange_state->h_sig_len, exchange_state->h_sig_comp,
-                      digest_len, &session->server_hostkey_abstract)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
-            goto clean_exit;
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending NEWKEYS message");
-        exchange_state->c = SSH_MSG_NEWKEYS;
-
-        exchange_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent2) {
-        rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
-            goto clean_exit;
-        }
-
-        exchange_state->state = libssh2_NB_state_sent3;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent3) {
-        rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
-                                     &exchange_state->tmp,
-                                     &exchange_state->tmp_len, 0, NULL, 0,
-                                     &exchange_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
-            goto clean_exit;
-        }
-        /* The first key exchange has been performed,
-           switch to active crypt/comp/mac mode */
-        session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
-
-        /* This will actually end up being just packet_type(1)
-           for this packet type anyway */
-        LIBSSH2_FREE(session, exchange_state->tmp);
-
-        if(!session->session_id) {
-            session->session_id = LIBSSH2_ALLOC(session, digest_len);
-            if(!session->session_id) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                     "Unable to allocate buffer for "
-                                     "SHA digest");
-                goto clean_exit;
-            }
-            memcpy(session->session_id, exchange_state->h_sig_comp,
-                   digest_len);
-            session->session_id_len = digest_len;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
-        }
-
-        /* Cleanup any existing cipher */
-        if(session->local.crypt->dtor) {
-            session->local.crypt->dtor(session,
-                                       &session->local.crypt_abstract);
-        }
-
-        /* Calculate IV/Secret/Key for each direction */
-        if(session->local.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &iv,
-                                         session->local.crypt->iv_len,
-                                         (const unsigned char *)"A");
-
-            if(!iv) {
-                ret = -1;
-                goto clean_exit;
-            }
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &secret,
-                                         session->local.crypt->secret_len,
-                                         (const unsigned char *)"C");
-
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->local.crypt->
-                init(session, session->local.crypt, iv, &free_iv, secret,
-                     &free_secret, 1, &session->local.crypt_abstract)) {
-                LIBSSH2_FREE(session, iv);
-                LIBSSH2_FREE(session, secret);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->local.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->local.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server IV and Key calculated");
-
-        if(session->remote.crypt->dtor) {
-            /* Cleanup any existing cipher */
-            session->remote.crypt->dtor(session,
-                                        &session->remote.crypt_abstract);
-        }
-
-        if(session->remote.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &iv,
-                                         session->remote.crypt->iv_len,
-                                         (const unsigned char *)"B");
-            if(!iv) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &secret,
-                                         session->remote.crypt->secret_len,
-                                         (const unsigned char *)"D");
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->remote.crypt->
-                init(session, session->remote.crypt, iv, &free_iv, secret,
-                     &free_secret, 0, &session->remote.crypt_abstract)) {
-                LIBSSH2_FREE(session, iv);
-                LIBSSH2_FREE(session, secret);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->remote.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->remote.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client IV and Key calculated");
-
-        if(session->local.mac->dtor) {
-            session->local.mac->dtor(session, &session->local.mac_abstract);
-        }
-
-        if(session->local.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &key,
-                                         session->local.mac->key_len,
-                                         (const unsigned char *)"E");
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->local.mac->init(session, key, &free_key,
-                                     &session->local.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->local.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server HMAC Key calculated");
-
-        if(session->remote.mac->dtor) {
-            session->remote.mac->dtor(session, &session->remote.mac_abstract);
-        }
-
-        if(session->remote.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            _libssh2_sha_algo_value_hash(sha_algo_value, session,
-                                         exchange_state, &key,
-                                         session->remote.mac->key_len,
-                                         (const unsigned char *)"F");
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->remote.mac->init(session, key, &free_key,
-                                      &session->remote.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->remote.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client HMAC Key calculated");
-
-        /* Initialize compression for each direction */
-
-        /* Cleanup any existing compression */
-        if(session->local.comp && session->local.comp->dtor) {
-            session->local.comp->dtor(session, 1,
-                                      &session->local.comp_abstract);
-        }
-
-        if(session->local.comp && session->local.comp->init) {
-            if(session->local.comp->init(session, 1,
-                                          &session->local.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server compression initialized");
-
-        if(session->remote.comp && session->remote.comp->dtor) {
-            session->remote.comp->dtor(session, 0,
-                                       &session->remote.comp_abstract);
-        }
-
-        if(session->remote.comp && session->remote.comp->init) {
-            if(session->remote.comp->init(session, 0,
-                                           &session->remote.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client compression initialized");
-
-    }
-
-  clean_exit:
-    libssh2_dh_dtor(&exchange_state->x);
-    _libssh2_bn_free(exchange_state->e);
-    exchange_state->e = NULL;
-    _libssh2_bn_free(exchange_state->f);
-    exchange_state->f = NULL;
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-    _libssh2_bn_ctx_free(exchange_state->ctx);
-    exchange_state->ctx = NULL;
-
-    if(exchange_state->e_packet) {
-        LIBSSH2_FREE(session, exchange_state->e_packet);
-        exchange_state->e_packet = NULL;
-    }
-
-    if(exchange_state->s_packet) {
-        LIBSSH2_FREE(session, exchange_state->s_packet);
-        exchange_state->s_packet = NULL;
-    }
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
-    }
-
-    exchange_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-
-
-/* kex_method_diffie_hellman_group1_sha1_key_exchange
- * Diffie-Hellman Group1 (Actually Group2) Key Exchange using SHA1
- */
-static int
-kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
-                                                   key_exchange_state_low_t
-                                                   * key_state)
-{
-    static const unsigned char p_value[128] = {
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
-        0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
-        0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
-        0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22,
-        0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-        0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B,
-        0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
-        0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
-        0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
-        0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
-        0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-        0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5,
-        0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
-        0x49, 0x28, 0x66, 0x51, 0xEC, 0xE6, 0x53, 0x81,
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-    };
-
-    int ret;
-    libssh2_sha1_ctx exchange_hash_ctx;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        /* g == 2 */
-        key_state->p = _libssh2_bn_init_from_bin(); /* SSH2 defined value
-                                                       (p_value) */
-        key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
-
-        /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 128, p_value);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group1 Key Exchange");
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p, 128, 1,
-                                  (void *)&exchange_hash_ctx,
-                                  SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY,
-                                  NULL, 0, &key_state->exchange_state);
-    if(ret == LIBSSH2_ERROR_EAGAIN) {
-        return ret;
-    }
-
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    key_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-
-/* kex_method_diffie_hellman_group14_key_exchange
- * Diffie-Hellman Group14 Key Exchange with hash function callback
- */
-typedef int (*diffie_hellman_hash_func_t)(LIBSSH2_SESSION *,
-                                          _libssh2_bn *,
-                                          _libssh2_bn *,
-                                          int,
-                                          int,
-                                          void *,
-                                          unsigned char,
-                                          unsigned char,
-                                          unsigned char *,
-                                          unsigned long,
-                                          kmdhgGPshakex_state_t *);
-static int
-kex_method_diffie_hellman_group14_key_exchange(LIBSSH2_SESSION *session,
-                                               key_exchange_state_low_t
-                                               * key_state,
-                                               int sha_algo_value,
-                                               void *exchange_hash_ctx,
-                                               diffie_hellman_hash_func_t
-                                               hashfunc)
-{
-    static const unsigned char p_value[256] = {
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
-        0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
-        0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
-        0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22,
-        0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-        0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B,
-        0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
-        0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
-        0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
-        0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
-        0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-        0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5,
-        0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
-        0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
-        0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05,
-        0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A,
-        0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
-        0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96,
-        0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
-        0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
-        0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04,
-        0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C,
-        0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
-        0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03,
-        0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F,
-        0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
-        0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18,
-        0x39, 0x95, 0x49, 0x7C, 0xEA, 0x95, 0x6A, 0xE5,
-        0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
-        0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAC, 0xAA, 0x68,
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-    };
-    int ret;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        key_state->p = _libssh2_bn_init_from_bin(); /* SSH2 defined value
-                                                       (p_value) */
-        key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
-
-        /* g == 2 */
-        /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 256, p_value);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group14 Key Exchange");
-
-        key_state->state = libssh2_NB_state_created;
-    }
-    ret = hashfunc(session, key_state->g, key_state->p,
-                256, sha_algo_value, exchange_hash_ctx, SSH_MSG_KEXDH_INIT,
-                SSH_MSG_KEXDH_REPLY, NULL, 0, &key_state->exchange_state);
-    if(ret == LIBSSH2_ERROR_EAGAIN) {
-        return ret;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-
-    return ret;
-}
-
-
-
-/* kex_method_diffie_hellman_group14_sha1_key_exchange
- * Diffie-Hellman Group14 Key Exchange using SHA1
- */
-static int
-kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session,
-                                                    key_exchange_state_low_t
-                                                    * key_state)
-{
-    libssh2_sha1_ctx ctx;
-    return kex_method_diffie_hellman_group14_key_exchange(session,
-                                                    key_state, 1,
-                                                    &ctx,
-                                                    diffie_hellman_sha_algo);
-}
-
-
-
-/* kex_method_diffie_hellman_group14_sha256_key_exchange
- * Diffie-Hellman Group14 Key Exchange using SHA256
- */
-static int
-kex_method_diffie_hellman_group14_sha256_key_exchange(LIBSSH2_SESSION *session,
-                                                      key_exchange_state_low_t
-                                                      * key_state)
-{
-    libssh2_sha256_ctx ctx;
-    return kex_method_diffie_hellman_group14_key_exchange(session,
-                                                    key_state, 256,
-                                                    &ctx,
-                                                    diffie_hellman_sha_algo);
-}
-
-/* kex_method_diffie_hellman_group16_sha512_key_exchange
-* Diffie-Hellman Group16 Key Exchange using SHA512
-*/
-static int
-kex_method_diffie_hellman_group16_sha512_key_exchange(LIBSSH2_SESSION *session,
-                                                      key_exchange_state_low_t
-                                                      * key_state)
-
-{
-    static const unsigned char p_value[512] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
-    0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
-    0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
-    0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-    0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
-    0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
-    0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
-    0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-    0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
-    0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
-    0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
-    0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
-    0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
-    0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
-    0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
-    0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
-    0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
-    0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
-    0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
-    0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
-    0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, 0xAD, 0x33, 0x17, 0x0D,
-    0x04, 0x50, 0x7A, 0x33, 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64,
-    0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, 0x8A, 0xEA, 0x71, 0x57,
-    0x5D, 0x06, 0x0C, 0x7D, 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7,
-    0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, 0x1E, 0x8C, 0x94, 0xE0,
-    0x4A, 0x25, 0x61, 0x9D, 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B,
-    0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, 0xD8, 0x76, 0x02, 0x73,
-    0x3E, 0xC8, 0x6A, 0x64, 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C,
-    0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, 0x77, 0x09, 0x88, 0xC0,
-    0xBA, 0xD9, 0x46, 0xE2, 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31,
-    0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, 0x4B, 0x82, 0xD1, 0x20,
-    0xA9, 0x21, 0x08, 0x01, 0x1A, 0x72, 0x3C, 0x12, 0xA7, 0x87, 0xE6, 0xD7,
-    0x88, 0x71, 0x9A, 0x10, 0xBD, 0xBA, 0x5B, 0x26, 0x99, 0xC3, 0x27, 0x18,
-    0x6A, 0xF4, 0xE2, 0x3C, 0x1A, 0x94, 0x68, 0x34, 0xB6, 0x15, 0x0B, 0xDA,
-    0x25, 0x83, 0xE9, 0xCA, 0x2A, 0xD4, 0x4C, 0xE8, 0xDB, 0xBB, 0xC2, 0xDB,
-    0x04, 0xDE, 0x8E, 0xF9, 0x2E, 0x8E, 0xFC, 0x14, 0x1F, 0xBE, 0xCA, 0xA6,
-    0x28, 0x7C, 0x59, 0x47, 0x4E, 0x6B, 0xC0, 0x5D, 0x99, 0xB2, 0x96, 0x4F,
-    0xA0, 0x90, 0xC3, 0xA2, 0x23, 0x3B, 0xA1, 0x86, 0x51, 0x5B, 0xE7, 0xED,
-    0x1F, 0x61, 0x29, 0x70, 0xCE, 0xE2, 0xD7, 0xAF, 0xB8, 0x1B, 0xDD, 0x76,
-    0x21, 0x70, 0x48, 0x1C, 0xD0, 0x06, 0x91, 0x27, 0xD5, 0xB0, 0x5A, 0xA9,
-    0x93, 0xB4, 0xEA, 0x98, 0x8D, 0x8F, 0xDD, 0xC1, 0x86, 0xFF, 0xB7, 0xDC,
-    0x90, 0xA6, 0xC0, 0x8F, 0x4D, 0xF4, 0x35, 0xC9, 0x34, 0x06, 0x31, 0x99,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
-    };
-    int ret;
-    libssh2_sha512_ctx exchange_hash_ctx;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        key_state->p = _libssh2_bn_init_from_bin(); /* SSH2 defined value
-                                                       (p_value) */
-        key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
-
-        /* g == 2 */
-        /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 512, p_value);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group16 Key Exchange");
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p, 512,
-                                  512, (void *)&exchange_hash_ctx,
-                                  SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY,
-                                  NULL, 0, &key_state->exchange_state);
-    if(ret == LIBSSH2_ERROR_EAGAIN) {
-        return ret;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-
-    return ret;
-}
-
-/* kex_method_diffie_hellman_group16_sha512_key_exchange
-* Diffie-Hellman Group18 Key Exchange using SHA512
-*/
-static int
-kex_method_diffie_hellman_group18_sha512_key_exchange(LIBSSH2_SESSION *session,
-                                                      key_exchange_state_low_t
-                                                      * key_state)
-
-{
-    static const unsigned char p_value[1024] = {
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
-    0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
-    0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
-    0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
-    0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
-    0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
-    0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
-    0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
-    0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
-    0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
-    0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
-    0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
-    0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
-    0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
-    0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
-    0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
-    0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
-    0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
-    0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
-    0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
-    0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, 0xAD, 0x33, 0x17, 0x0D,
-    0x04, 0x50, 0x7A, 0x33, 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64,
-    0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, 0x8A, 0xEA, 0x71, 0x57,
-    0x5D, 0x06, 0x0C, 0x7D, 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7,
-    0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, 0x1E, 0x8C, 0x94, 0xE0,
-    0x4A, 0x25, 0x61, 0x9D, 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B,
-    0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, 0xD8, 0x76, 0x02, 0x73,
-    0x3E, 0xC8, 0x6A, 0x64, 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C,
-    0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, 0x77, 0x09, 0x88, 0xC0,
-    0xBA, 0xD9, 0x46, 0xE2, 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31,
-    0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, 0x4B, 0x82, 0xD1, 0x20,
-    0xA9, 0x21, 0x08, 0x01, 0x1A, 0x72, 0x3C, 0x12, 0xA7, 0x87, 0xE6, 0xD7,
-    0x88, 0x71, 0x9A, 0x10, 0xBD, 0xBA, 0x5B, 0x26, 0x99, 0xC3, 0x27, 0x18,
-    0x6A, 0xF4, 0xE2, 0x3C, 0x1A, 0x94, 0x68, 0x34, 0xB6, 0x15, 0x0B, 0xDA,
-    0x25, 0x83, 0xE9, 0xCA, 0x2A, 0xD4, 0x4C, 0xE8, 0xDB, 0xBB, 0xC2, 0xDB,
-    0x04, 0xDE, 0x8E, 0xF9, 0x2E, 0x8E, 0xFC, 0x14, 0x1F, 0xBE, 0xCA, 0xA6,
-    0x28, 0x7C, 0x59, 0x47, 0x4E, 0x6B, 0xC0, 0x5D, 0x99, 0xB2, 0x96, 0x4F,
-    0xA0, 0x90, 0xC3, 0xA2, 0x23, 0x3B, 0xA1, 0x86, 0x51, 0x5B, 0xE7, 0xED,
-    0x1F, 0x61, 0x29, 0x70, 0xCE, 0xE2, 0xD7, 0xAF, 0xB8, 0x1B, 0xDD, 0x76,
-    0x21, 0x70, 0x48, 0x1C, 0xD0, 0x06, 0x91, 0x27, 0xD5, 0xB0, 0x5A, 0xA9,
-    0x93, 0xB4, 0xEA, 0x98, 0x8D, 0x8F, 0xDD, 0xC1, 0x86, 0xFF, 0xB7, 0xDC,
-    0x90, 0xA6, 0xC0, 0x8F, 0x4D, 0xF4, 0x35, 0xC9, 0x34, 0x02, 0x84, 0x92,
-    0x36, 0xC3, 0xFA, 0xB4, 0xD2, 0x7C, 0x70, 0x26, 0xC1, 0xD4, 0xDC, 0xB2,
-    0x60, 0x26, 0x46, 0xDE, 0xC9, 0x75, 0x1E, 0x76, 0x3D, 0xBA, 0x37, 0xBD,
-    0xF8, 0xFF, 0x94, 0x06, 0xAD, 0x9E, 0x53, 0x0E, 0xE5, 0xDB, 0x38, 0x2F,
-    0x41, 0x30, 0x01, 0xAE, 0xB0, 0x6A, 0x53, 0xED, 0x90, 0x27, 0xD8, 0x31,
-    0x17, 0x97, 0x27, 0xB0, 0x86, 0x5A, 0x89, 0x18, 0xDA, 0x3E, 0xDB, 0xEB,
-    0xCF, 0x9B, 0x14, 0xED, 0x44, 0xCE, 0x6C, 0xBA, 0xCE, 0xD4, 0xBB, 0x1B,
-    0xDB, 0x7F, 0x14, 0x47, 0xE6, 0xCC, 0x25, 0x4B, 0x33, 0x20, 0x51, 0x51,
-    0x2B, 0xD7, 0xAF, 0x42, 0x6F, 0xB8, 0xF4, 0x01, 0x37, 0x8C, 0xD2, 0xBF,
-    0x59, 0x83, 0xCA, 0x01, 0xC6, 0x4B, 0x92, 0xEC, 0xF0, 0x32, 0xEA, 0x15,
-    0xD1, 0x72, 0x1D, 0x03, 0xF4, 0x82, 0xD7, 0xCE, 0x6E, 0x74, 0xFE, 0xF6,
-    0xD5, 0x5E, 0x70, 0x2F, 0x46, 0x98, 0x0C, 0x82, 0xB5, 0xA8, 0x40, 0x31,
-    0x90, 0x0B, 0x1C, 0x9E, 0x59, 0xE7, 0xC9, 0x7F, 0xBE, 0xC7, 0xE8, 0xF3,
-    0x23, 0xA9, 0x7A, 0x7E, 0x36, 0xCC, 0x88, 0xBE, 0x0F, 0x1D, 0x45, 0xB7,
-    0xFF, 0x58, 0x5A, 0xC5, 0x4B, 0xD4, 0x07, 0xB2, 0x2B, 0x41, 0x54, 0xAA,
-    0xCC, 0x8F, 0x6D, 0x7E, 0xBF, 0x48, 0xE1, 0xD8, 0x14, 0xCC, 0x5E, 0xD2,
-    0x0F, 0x80, 0x37, 0xE0, 0xA7, 0x97, 0x15, 0xEE, 0xF2, 0x9B, 0xE3, 0x28,
-    0x06, 0xA1, 0xD5, 0x8B, 0xB7, 0xC5, 0xDA, 0x76, 0xF5, 0x50, 0xAA, 0x3D,
-    0x8A, 0x1F, 0xBF, 0xF0, 0xEB, 0x19, 0xCC, 0xB1, 0xA3, 0x13, 0xD5, 0x5C,
-    0xDA, 0x56, 0xC9, 0xEC, 0x2E, 0xF2, 0x96, 0x32, 0x38, 0x7F, 0xE8, 0xD7,
-    0x6E, 0x3C, 0x04, 0x68, 0x04, 0x3E, 0x8F, 0x66, 0x3F, 0x48, 0x60, 0xEE,
-    0x12, 0xBF, 0x2D, 0x5B, 0x0B, 0x74, 0x74, 0xD6, 0xE6, 0x94, 0xF9, 0x1E,
-    0x6D, 0xBE, 0x11, 0x59, 0x74, 0xA3, 0x92, 0x6F, 0x12, 0xFE, 0xE5, 0xE4,
-    0x38, 0x77, 0x7C, 0xB6, 0xA9, 0x32, 0xDF, 0x8C, 0xD8, 0xBE, 0xC4, 0xD0,
-    0x73, 0xB9, 0x31, 0xBA, 0x3B, 0xC8, 0x32, 0xB6, 0x8D, 0x9D, 0xD3, 0x00,
-    0x74, 0x1F, 0xA7, 0xBF, 0x8A, 0xFC, 0x47, 0xED, 0x25, 0x76, 0xF6, 0x93,
-    0x6B, 0xA4, 0x24, 0x66, 0x3A, 0xAB, 0x63, 0x9C, 0x5A, 0xE4, 0xF5, 0x68,
-    0x34, 0x23, 0xB4, 0x74, 0x2B, 0xF1, 0xC9, 0x78, 0x23, 0x8F, 0x16, 0xCB,
-    0xE3, 0x9D, 0x65, 0x2D, 0xE3, 0xFD, 0xB8, 0xBE, 0xFC, 0x84, 0x8A, 0xD9,
-    0x22, 0x22, 0x2E, 0x04, 0xA4, 0x03, 0x7C, 0x07, 0x13, 0xEB, 0x57, 0xA8,
-    0x1A, 0x23, 0xF0, 0xC7, 0x34, 0x73, 0xFC, 0x64, 0x6C, 0xEA, 0x30, 0x6B,
-    0x4B, 0xCB, 0xC8, 0x86, 0x2F, 0x83, 0x85, 0xDD, 0xFA, 0x9D, 0x4B, 0x7F,
-    0xA2, 0xC0, 0x87, 0xE8, 0x79, 0x68, 0x33, 0x03, 0xED, 0x5B, 0xDD, 0x3A,
-    0x06, 0x2B, 0x3C, 0xF5, 0xB3, 0xA2, 0x78, 0xA6, 0x6D, 0x2A, 0x13, 0xF8,
-    0x3F, 0x44, 0xF8, 0x2D, 0xDF, 0x31, 0x0E, 0xE0, 0x74, 0xAB, 0x6A, 0x36,
-    0x45, 0x97, 0xE8, 0x99, 0xA0, 0x25, 0x5D, 0xC1, 0x64, 0xF3, 0x1C, 0xC5,
-    0x08, 0x46, 0x85, 0x1D, 0xF9, 0xAB, 0x48, 0x19, 0x5D, 0xED, 0x7E, 0xA1,
-    0xB1, 0xD5, 0x10, 0xBD, 0x7E, 0xE7, 0x4D, 0x73, 0xFA, 0xF3, 0x6B, 0xC3,
-    0x1E, 0xCF, 0xA2, 0x68, 0x35, 0x90, 0x46, 0xF4, 0xEB, 0x87, 0x9F, 0x92,
-    0x40, 0x09, 0x43, 0x8B, 0x48, 0x1C, 0x6C, 0xD7, 0x88, 0x9A, 0x00, 0x2E,
-    0xD5, 0xEE, 0x38, 0x2B, 0xC9, 0x19, 0x0D, 0xA6, 0xFC, 0x02, 0x6E, 0x47,
-    0x95, 0x58, 0xE4, 0x47, 0x56, 0x77, 0xE9, 0xAA, 0x9E, 0x30, 0x50, 0xE2,
-    0x76, 0x56, 0x94, 0xDF, 0xC8, 0x1F, 0x56, 0xE8, 0x80, 0xB9, 0x6E, 0x71,
-    0x60, 0xC9, 0x80, 0xDD, 0x98, 0xED, 0xD3, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF
-    };
-    int ret;
-    libssh2_sha512_ctx exchange_hash_ctx;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        key_state->p = _libssh2_bn_init_from_bin(); /* SSH2 defined value
-                                                       (p_value) */
-        key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
-
-        /* g == 2 */
-        /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 1024, p_value);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group18 Key Exchange");
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p, 1024,
-                                  512, (void *)&exchange_hash_ctx,
-                                  SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY,
-                                  NULL, 0, &key_state->exchange_state);
-    if(ret == LIBSSH2_ERROR_EAGAIN) {
-        return ret;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-
-    return ret;
-}
-
-/* kex_method_diffie_hellman_group_exchange_sha1_key_exchange
- * Diffie-Hellman Group Exchange Key Exchange using SHA1
- * Negotiates random(ish) group for secret derivation
- */
-static int
-kex_method_diffie_hellman_group_exchange_sha1_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
-{
-    int ret = 0;
-    int rc;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        key_state->p = _libssh2_bn_init_from_bin();
-        key_state->g = _libssh2_bn_init_from_bin();
-        /* Ask for a P and G pair */
-#ifdef LIBSSH2_DH_GEX_NEW
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP);
-        _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
-        _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
-        key_state->request_len = 13;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(New Method)");
-#else
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
-        key_state->request_len = 5;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(Old Method)");
-#endif
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    if(key_state->state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, key_state->request,
-                                     key_state->request_len, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send Group Exchange Request");
-            goto dh_gex_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP,
-                                     &key_state->data, &key_state->data_len,
-                                     0, NULL, 0, &key_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Timeout waiting for GEX_GROUP reply");
-            goto dh_gex_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent1;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent1) {
-        size_t p_len, g_len;
-        unsigned char *p, *g;
-        struct string_buf buf;
-        libssh2_sha1_ctx exchange_hash_ctx;
-
-        if(key_state->data_len < 9) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
-            goto dh_gex_clean_exit;
-        }
-
-        buf.data = key_state->data;
-        buf.dataptr = buf.data;
-        buf.len = key_state->data_len;
-
-        buf.dataptr++; /* increment to big num */
-
-        if(_libssh2_get_bignum_bytes(&buf, &p, &p_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
-            goto dh_gex_clean_exit;
-        }
-
-        if(_libssh2_get_bignum_bytes(&buf, &g, &g_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
-            goto dh_gex_clean_exit;
-        }
-
-        _libssh2_bn_from_bin(key_state->p, p_len, p);
-        _libssh2_bn_from_bin(key_state->g, g_len, g);
-
-        ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p,
-                                      p_len, 1,
-                                      (void *)&exchange_hash_ctx,
-                                      SSH_MSG_KEX_DH_GEX_INIT,
-                                      SSH_MSG_KEX_DH_GEX_REPLY,
-                                      key_state->data + 1,
-                                      key_state->data_len - 1,
-                                      &key_state->exchange_state);
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            return ret;
-        }
-
-        LIBSSH2_FREE(session, key_state->data);
-    }
-
-  dh_gex_clean_exit:
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-
-    return ret;
-}
-
-
-
-/* kex_method_diffie_hellman_group_exchange_sha256_key_exchange
- * Diffie-Hellman Group Exchange Key Exchange using SHA256
- * Negotiates random(ish) group for secret derivation
- */
-static int
-kex_method_diffie_hellman_group_exchange_sha256_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
-{
-    int ret = 0;
-    int rc;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        key_state->p = _libssh2_bn_init();
-        key_state->g = _libssh2_bn_init();
-        /* Ask for a P and G pair */
-#ifdef LIBSSH2_DH_GEX_NEW
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP);
-        _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
-        _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
-        key_state->request_len = 13;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(New Method SHA256)");
-#else
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
-        key_state->request_len = 5;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(Old Method SHA256)");
-#endif
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    if(key_state->state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, key_state->request,
-                                     key_state->request_len, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send "
-                                 "Group Exchange Request SHA256");
-            goto dh_gex_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_require(session, SSH_MSG_KEX_DH_GEX_GROUP,
-                                     &key_state->data, &key_state->data_len,
-                                     0, NULL, 0, &key_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Timeout waiting for GEX_GROUP reply SHA256");
-            goto dh_gex_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent1;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent1) {
-        unsigned char *p, *g;
-        size_t p_len, g_len;
-        struct string_buf buf;
-        libssh2_sha256_ctx exchange_hash_ctx;
-
-        if(key_state->data_len < 9) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
-            goto dh_gex_clean_exit;
-        }
-
-        buf.data = key_state->data;
-        buf.dataptr = buf.data;
-        buf.len = key_state->data_len;
-
-        buf.dataptr++; /* increment to big num */
-
-        if(_libssh2_get_bignum_bytes(&buf, &p, &p_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
-            goto dh_gex_clean_exit;
-        }
-
-        if(_libssh2_get_bignum_bytes(&buf, &g, &g_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
-            goto dh_gex_clean_exit;
-        }
-
-        _libssh2_bn_from_bin(key_state->p, p_len, p);
-        _libssh2_bn_from_bin(key_state->g, g_len, g);
-
-        ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p,
-                                      p_len, 256,
-                                      (void *)&exchange_hash_ctx,
-                                      SSH_MSG_KEX_DH_GEX_INIT,
-                                      SSH_MSG_KEX_DH_GEX_REPLY,
-                                      key_state->data + 1,
-                                      key_state->data_len - 1,
-                                      &key_state->exchange_state);
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            return ret;
-        }
-
-        LIBSSH2_FREE(session, key_state->data);
-    }
-
-  dh_gex_clean_exit:
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-
-    return ret;
-}
-
-
-/* LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY
- *
- * Macro that create and verifies EC SHA hash with a given digest bytes
- *
- * Payload format:
- *
- * string   V_C, client's identification string (CR and LF excluded)
- * string   V_S, server's identification string (CR and LF excluded)
- * string   I_C, payload of the client's SSH_MSG_KEXINIT
- * string   I_S, payload of the server's SSH_MSG_KEXINIT
- * string   K_S, server's public host key
- * string   Q_C, client's ephemeral public key octet string
- * string   Q_S, server's ephemeral public key octet string
- * mpint    K,   shared secret
- *
- */
-
-#define LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(digest_type)       \
-{                                                                       \
-    libssh2_sha##digest_type##_ctx ctx;                                 \
-    exchange_state->exchange_hash = (void *)&ctx;                       \
-    libssh2_sha##digest_type##_init(&ctx);                              \
-    if(session->local.banner) {                                         \
-        _libssh2_htonu32(exchange_state->h_sig_comp,                    \
-                         strlen((char *) session->local.banner) - 2);   \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          exchange_state->h_sig_comp, 4); \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          (char *) session->local.banner, \
-                                          strlen((char *)               \
-                                                 session->local.banner) \
-                                          - 2);                         \
-    }                                                                   \
-    else {                                                              \
-        _libssh2_htonu32(exchange_state->h_sig_comp,                    \
-                         sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);       \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          exchange_state->h_sig_comp, 4); \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          LIBSSH2_SSH_DEFAULT_BANNER,   \
-                                          sizeof(LIBSSH2_SSH_DEFAULT_BANNER) \
-                                          - 1);                         \
-    }                                                                   \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     strlen((char *) session->remote.banner));          \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->remote.banner,           \
-                                      strlen((char *)                   \
-                                             session->remote.banner));  \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->local.kexinit_len);                       \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->local.kexinit,           \
-                                      session->local.kexinit_len);      \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->remote.kexinit_len);                      \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->remote.kexinit,          \
-                                      session->remote.kexinit_len);     \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->server_hostkey_len);                      \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->server_hostkey,          \
-                                      session->server_hostkey_len);     \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     public_key_len);                                   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      public_key,                       \
-                                      public_key_len);                  \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     server_public_key_len);                            \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      server_public_key,                \
-                                      server_public_key_len);           \
-                                                                        \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->k_value,          \
-                                      exchange_state->k_value_len);     \
-                                                                        \
-    libssh2_sha##digest_type##_final(ctx, exchange_state->h_sig_comp);  \
-                                                                        \
-    if(session->hostkey->                                               \
-       sig_verify(session, exchange_state->h_sig,                       \
-                  exchange_state->h_sig_len, exchange_state->h_sig_comp, \
-                  SHA##digest_type##_DIGEST_LENGTH,                     \
-                  &session->server_hostkey_abstract)) {                 \
-        rc = -1;                                                        \
-    }                                                                   \
-}                                                                       \
-
-
-#if LIBSSH2_ECDSA
-
-/* kex_session_ecdh_curve_type
- * returns the EC curve type by name used in key exchange
- */
-
-static int
-kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
-{
-    int ret = 0;
-    libssh2_curve_type type;
-
-    if(name == NULL)
-        return -1;
-
-    if(strcmp(name, "ecdh-sha2-nistp256") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP256;
-    else if(strcmp(name, "ecdh-sha2-nistp384") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP384;
-    else if(strcmp(name, "ecdh-sha2-nistp521") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP521;
-    else {
-        ret = -1;
-    }
-
-    if(ret == 0 && out_type) {
-        *out_type = type;
-    }
-
-    return ret;
-}
-
-
-/* ecdh_sha2_nistp
- * Elliptic Curve Diffie Hellman Key Exchange
- */
-
-static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
-                           unsigned char *data, size_t data_len,
-                           unsigned char *public_key,
-                           size_t public_key_len, _libssh2_ec_key *private_key,
-                           kmdhgGPshakex_state_t *exchange_state)
-{
-    int ret = 0;
-    int rc;
-
-    if(data_len < 5) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                            "Host key data is too short");
-        return ret;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_idle) {
-
-        /* Setup initial values */
-        exchange_state->k = _libssh2_bn_init();
-
-        exchange_state->state = libssh2_NB_state_created;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_created) {
-        /* parse INIT reply data */
-
-        /* host key K_S */
-        unsigned char *server_public_key;
-        size_t server_public_key_len;
-        struct string_buf buf;
-
-        buf.data = data;
-        buf.len = data_len;
-        buf.dataptr = buf.data;
-        buf.dataptr++; /* Advance past packet type */
-
-         if(_libssh2_copy_string(session, &buf, &(session->server_hostkey),
-                                &server_public_key_len)) {
-             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for a copy "
-                                  "of the host key");
-            goto clean_exit;
-        }
-
-        session->server_hostkey_len = (uint32_t)server_public_key_len;
-
-#if LIBSSH2_MD5
-        {
-            libssh2_md5_ctx fingerprint_ctx;
-
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
-                session->server_hostkey_md5_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_md5_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[50], *fprint = fingerprint;
-            int i;
-            for(i = 0; i < 16; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's MD5 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-#endif /* ! LIBSSH2_MD5 */
-
-        {
-            libssh2_sha1_ctx fingerprint_ctx;
-
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
-                session->server_hostkey_sha1_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha1_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[64], *fprint = fingerprint;
-            int i;
-
-            for(i = 0; i < 20; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's SHA1 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-
-        /* SHA256 */
-        {
-            libssh2_sha256_ctx fingerprint_ctx;
-
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
-                session->server_hostkey_sha256_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha256_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session,
-                                   (const char *)
-                                   session->server_hostkey_sha256,
-                                   SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                               "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
-                LIBSSH2_FREE(session, base64Fingerprint);
-            }
-        }
-#endif /* LIBSSH2DEBUG */
-
-        if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
-            goto clean_exit;
-        }
-
-        /* server public key Q_S */
-        if(_libssh2_get_string(&buf, &server_public_key,
-                               &server_public_key_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                     "Unexpected key length");
-            goto clean_exit;
-        }
-
-        /* server signature */
-        if(_libssh2_get_string(&buf, &exchange_state->h_sig,
-           &(exchange_state->h_sig_len))) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unexpected ecdh server sig length");
-            goto clean_exit;
-        }
-
-        /* Compute the shared secret K */
-        rc = _libssh2_ecdh_gen_k(&exchange_state->k, private_key,
-                                 server_public_key, server_public_key_len);
-        if(rc != 0) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
-                                 "Unable to create ECDH shared secret");
-            goto clean_exit;
-        }
-
-        exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            /* don't need leading 00 */
-            exchange_state->k_value_len--;
-        }
-        exchange_state->k_value =
-        LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if(!exchange_state->k_value) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate buffer for K");
-            goto clean_exit;
-        }
-        _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        }
-        else {
-            exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
-        }
-
-        /* verify hash */
-
-        switch(type) {
-            case LIBSSH2_EC_CURVE_NISTP256:
-                LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(256);
-                break;
-
-            case LIBSSH2_EC_CURVE_NISTP384:
-                LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(384);
-                break;
-            case LIBSSH2_EC_CURVE_NISTP521:
-                LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(512);
-                break;
-        }
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
-            goto clean_exit;
-        }
-
-        exchange_state->c = SSH_MSG_NEWKEYS;
-        exchange_state->state = libssh2_NB_state_sent;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
-            goto clean_exit;
-        }
-
-        exchange_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent2) {
-        rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
-                                     &exchange_state->tmp,
-                                     &exchange_state->tmp_len, 0, NULL, 0,
-                                     &exchange_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
-            goto clean_exit;
-        }
-
-        /* The first key exchange has been performed,
-         switch to active crypt/comp/mac mode */
-        session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
-
-        /* This will actually end up being just packet_type(1)
-         for this packet type anyway */
-        LIBSSH2_FREE(session, exchange_state->tmp);
-
-        if(!session->session_id) {
-
-            size_t digest_length = 0;
-
-            if(type == LIBSSH2_EC_CURVE_NISTP256)
-                digest_length = SHA256_DIGEST_LENGTH;
-            else if(type == LIBSSH2_EC_CURVE_NISTP384)
-                digest_length = SHA384_DIGEST_LENGTH;
-            else if(type == LIBSSH2_EC_CURVE_NISTP521)
-                digest_length = SHA512_DIGEST_LENGTH;
-            else{
-                ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
-                                     "Unknown SHA digest for EC curve");
-                goto clean_exit;
-
-            }
-            session->session_id = LIBSSH2_ALLOC(session, digest_length);
-            if(!session->session_id) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                     "Unable to allocate buffer for "
-                                     "SHA digest");
-                goto clean_exit;
-            }
-            memcpy(session->session_id, exchange_state->h_sig_comp,
-                   digest_length);
-             session->session_id_len = digest_length;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
-        }
-
-        /* Cleanup any existing cipher */
-        if(session->local.crypt->dtor) {
-            session->local.crypt->dtor(session,
-                                       &session->local.crypt_abstract);
-        }
-
-        /* Calculate IV/Secret/Key for each direction */
-        if(session->local.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(iv,
-                                                 session->local.crypt->
-                                                 iv_len, "A");
-            if(!iv) {
-                ret = -1;
-                goto clean_exit;
-            }
-
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(secret,
-                                                session->local.crypt->
-                                                secret_len, "C");
-
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->local.crypt->
-                init(session, session->local.crypt, iv, &free_iv, secret,
-                     &free_secret, 1, &session->local.crypt_abstract)) {
-                    LIBSSH2_FREE(session, iv);
-                    LIBSSH2_FREE(session, secret);
-                    ret = LIBSSH2_ERROR_KEX_FAILURE;
-                    goto clean_exit;
-                }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->local.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->local.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server IV and Key calculated");
-
-        if(session->remote.crypt->dtor) {
-            /* Cleanup any existing cipher */
-            session->remote.crypt->dtor(session,
-                                        &session->remote.crypt_abstract);
-        }
-
-        if(session->remote.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(iv,
-                                                 session->remote.crypt->
-                                                 iv_len, "B");
-
-            if(!iv) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(secret,
-                                                 session->remote.crypt->
-                                                 secret_len, "D");
-
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->remote.crypt->
-                init(session, session->remote.crypt, iv, &free_iv, secret,
-                     &free_secret, 0, &session->remote.crypt_abstract)) {
-                    LIBSSH2_FREE(session, iv);
-                    LIBSSH2_FREE(session, secret);
-                    ret = LIBSSH2_ERROR_KEX_FAILURE;
-                    goto clean_exit;
-                }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->remote.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->remote.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client IV and Key calculated");
-
-        if(session->local.mac->dtor) {
-            session->local.mac->dtor(session, &session->local.mac_abstract);
-        }
-
-        if(session->local.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(key,
-                                                 session->local.mac->
-                                                 key_len, "E");
-
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->local.mac->init(session, key, &free_key,
-                                     &session->local.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->local.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server HMAC Key calculated");
-
-        if(session->remote.mac->dtor) {
-            session->remote.mac->dtor(session, &session->remote.mac_abstract);
-        }
-
-        if(session->remote.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(key,
-                                                 session->remote.mac->
-                                                 key_len, "F");
-
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->remote.mac->init(session, key, &free_key,
-                                      &session->remote.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->remote.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client HMAC Key calculated");
-
-        /* Initialize compression for each direction */
-
-        /* Cleanup any existing compression */
-        if(session->local.comp && session->local.comp->dtor) {
-            session->local.comp->dtor(session, 1,
-                                      &session->local.comp_abstract);
-        }
-
-        if(session->local.comp && session->local.comp->init) {
-            if(session->local.comp->init(session, 1,
-                                          &session->local.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server compression initialized");
-
-        if(session->remote.comp && session->remote.comp->dtor) {
-            session->remote.comp->dtor(session, 0,
-                                       &session->remote.comp_abstract);
-        }
-
-        if(session->remote.comp && session->remote.comp->init) {
-            if(session->remote.comp->init(session, 0,
-                                           &session->remote.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client compression initialized");
-
-    }
-
-clean_exit:
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
-    }
-
-    exchange_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-/* kex_method_ecdh_key_exchange
- *
- * Elliptic Curve Diffie Hellman Key Exchange
- * supports SHA256/384/512 hashes based on negotated ecdh method
- *
- */
-
-static int
-kex_method_ecdh_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
-{
-    int ret = 0;
-    int rc = 0;
-    unsigned char *s;
-    libssh2_curve_type type;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-
-        key_state->public_key_oct = NULL;
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    if(key_state->state == libssh2_NB_state_created) {
-        rc = kex_session_ecdh_curve_type(session->kex->name, &type);
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, -1,
-                                 "Unknown KEX nistp curve type");
-            goto ecdh_clean_exit;
-        }
-
-        rc = _libssh2_ecdsa_create_key(session, &key_state->private_key,
-                                       &key_state->public_key_oct,
-                                       &key_state->public_key_oct_len, type);
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to create private key");
-            goto ecdh_clean_exit;
-        }
-
-        key_state->request[0] = SSH2_MSG_KEX_ECDH_INIT;
-        s = key_state->request + 1;
-        _libssh2_store_str(&s, (const char *)key_state->public_key_oct,
-                           key_state->public_key_oct_len);
-        key_state->request_len = key_state->public_key_oct_len + 5;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating ECDH SHA2 NISTP256");
-
-        key_state->state = libssh2_NB_state_sent;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_transport_send(session, key_state->request,
-                                     key_state->request_len, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send ECDH_INIT");
-            goto ecdh_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent1;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent1) {
-        rc = _libssh2_packet_require(session, SSH2_MSG_KEX_ECDH_REPLY,
-                                     &key_state->data, &key_state->data_len,
-                                     0, NULL, 0, &key_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Timeout waiting for ECDH_REPLY reply");
-            goto ecdh_clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent2) {
-
-        (void)kex_session_ecdh_curve_type(session->kex->name, &type);
-
-        ret = ecdh_sha2_nistp(session, type, key_state->data,
-                              key_state->data_len,
-                              (unsigned char *)key_state->public_key_oct,
-                              key_state->public_key_oct_len,
-                              key_state->private_key,
-                              &key_state->exchange_state);
-
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            return ret;
-        }
-
-        LIBSSH2_FREE(session, key_state->data);
-    }
-
-ecdh_clean_exit:
-
-    if(key_state->public_key_oct) {
-        LIBSSH2_FREE(session, key_state->public_key_oct);
-        key_state->public_key_oct = NULL;
-    }
-
-    if(key_state->private_key) {
-        _libssh2_ecdsa_free(key_state->private_key);
-        key_state->private_key = NULL;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-#endif /*LIBSSH2_ECDSA*/
-
-
-#if LIBSSH2_ED25519
-
-/* curve25519_sha256
- * Elliptic Curve Key Exchange
- */
-
-static int
-curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
-                  size_t data_len,
-                  unsigned char public_key[LIBSSH2_ED25519_KEY_LEN],
-                  unsigned char private_key[LIBSSH2_ED25519_KEY_LEN],
-                  kmdhgGPshakex_state_t *exchange_state)
-{
-    int ret = 0;
-    int rc;
-    int public_key_len = LIBSSH2_ED25519_KEY_LEN;
-
-    if(data_len < 5) {
-        return _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                              "Data is too short");
-    }
-
-    if(exchange_state->state == libssh2_NB_state_idle) {
-
-        /* Setup initial values */
-        exchange_state->k = _libssh2_bn_init();
-
-        exchange_state->state = libssh2_NB_state_created;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_created) {
-        /* parse INIT reply data */
-        unsigned char *server_public_key, *server_host_key;
-        size_t server_public_key_len, hostkey_len;
-        struct string_buf buf;
-
-        if(data_len < 5) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
-            goto clean_exit;
-        }
-
-        buf.data = data;
-        buf.len = data_len;
-        buf.dataptr = buf.data;
-        buf.dataptr++; /* advance past packet type */
-
-        if(_libssh2_get_string(&buf, &server_host_key, &hostkey_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
-            goto clean_exit;
-        }
-
-        session->server_hostkey_len = (uint32_t)hostkey_len;
-        session->server_hostkey = LIBSSH2_ALLOC(session,
-                                                session->server_hostkey_len);
-        if(!session->server_hostkey) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate memory for a copy "
-                                 "of the host key");
-            goto clean_exit;
-        }
-
-        memcpy(session->server_hostkey, server_host_key,
-               session->server_hostkey_len);
-
-#if LIBSSH2_MD5
-        {
-            libssh2_md5_ctx fingerprint_ctx;
-
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
-                session->server_hostkey_md5_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_md5_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[50], *fprint = fingerprint;
-            int i;
-            for(i = 0; i < 16; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                             "Server's MD5 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-#endif /* ! LIBSSH2_MD5 */
-
-        {
-            libssh2_sha1_ctx fingerprint_ctx;
-
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
-                session->server_hostkey_sha1_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha1_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char fingerprint[64], *fprint = fingerprint;
-            int i;
-
-            for(i = 0; i < 20; i++, fprint += 3) {
-                snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
-            }
-            *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                             "Server's SHA1 Fingerprint: %s", fingerprint);
-        }
-#endif /* LIBSSH2DEBUG */
-
-        /* SHA256 */
-        {
-            libssh2_sha256_ctx fingerprint_ctx;
-
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
-                session->server_hostkey_sha256_valid = TRUE;
-            }
-            else {
-                session->server_hostkey_sha256_valid = FALSE;
-            }
-        }
-#ifdef LIBSSH2DEBUG
-        {
-            char *base64Fingerprint = NULL;
-            _libssh2_base64_encode(session,
-                                   (const char *)
-                                   session->server_hostkey_sha256,
-                                   SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                               "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
-                LIBSSH2_FREE(session, base64Fingerprint);
-            }
-        }
-#endif /* LIBSSH2DEBUG */
-
-        if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
-            goto clean_exit;
-        }
-
-        /* server public key Q_S */
-        if(_libssh2_get_string(&buf, &server_public_key,
-                               &server_public_key_len)) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                     "Unexpected key length");
-            goto clean_exit;
-        }
-
-        if(server_public_key_len != LIBSSH2_ED25519_KEY_LEN) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unexpected curve25519 server "
-                                 "public key length");
-            goto clean_exit;
-        }
-
-        /* server signature */
-        if(_libssh2_get_string(&buf, &exchange_state->h_sig,
-           &(exchange_state->h_sig_len))) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unexpected curve25519 server sig length");
-            goto clean_exit;
-        }
-
-        /* Compute the shared secret K */
-        rc = _libssh2_curve25519_gen_k(&exchange_state->k, private_key,
-                                       server_public_key);
-        if(rc != 0) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
-                                 "Unable to create ECDH shared secret");
-            goto clean_exit;
-        }
-
-        exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            /* don't need leading 00 */
-            exchange_state->k_value_len--;
-        }
-        exchange_state->k_value =
-        LIBSSH2_ALLOC(session, exchange_state->k_value_len);
-        if(!exchange_state->k_value) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate buffer for K");
-            goto clean_exit;
-        }
-        _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
-        if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
-        }
-        else {
-            exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
-        }
-
-        /*/ verify hash */
-        LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(256);
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
-            goto clean_exit;
-        }
-
-        exchange_state->c = SSH_MSG_NEWKEYS;
-        exchange_state->state = libssh2_NB_state_sent;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_transport_send(session, &exchange_state->c, 1, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
-            goto clean_exit;
-        }
-
-        exchange_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(exchange_state->state == libssh2_NB_state_sent2) {
-        rc = _libssh2_packet_require(session, SSH_MSG_NEWKEYS,
-                                     &exchange_state->tmp,
-                                     &exchange_state->tmp_len, 0, NULL, 0,
-                                     &exchange_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
-            goto clean_exit;
-        }
-
-        /* The first key exchange has been performed, switch to active
-           crypt/comp/mac mode */
-
-        session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
-
-        /* This will actually end up being just packet_type(1) for this packet
-           type anyway */
-        LIBSSH2_FREE(session, exchange_state->tmp);
-
-        if(!session->session_id) {
-
-            size_t digest_length = SHA256_DIGEST_LENGTH;
-            session->session_id = LIBSSH2_ALLOC(session, digest_length);
-            if(!session->session_id) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                     "Unable to allxcocate buffer for "
-                                     "SHA digest");
-                goto clean_exit;
-            }
-            memcpy(session->session_id, exchange_state->h_sig_comp,
-                   digest_length);
-            session->session_id_len = digest_length;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
-        }
-
-        /* Cleanup any existing cipher */
-        if(session->local.crypt->dtor) {
-            session->local.crypt->dtor(session,
-                                        &session->local.crypt_abstract);
-        }
-
-        /* Calculate IV/Secret/Key for each direction */
-        if(session->local.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, iv,
-                                              session->local.crypt->
-                                              iv_len, "A");
-            if(!iv) {
-                ret = -1;
-                goto clean_exit;
-            }
-
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, secret,
-                                              session->local.crypt->
-                                              secret_len, "C");
-
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->local.crypt->
-                init(session, session->local.crypt, iv, &free_iv, secret,
-                     &free_secret, 1, &session->local.crypt_abstract)) {
-                    LIBSSH2_FREE(session, iv);
-                    LIBSSH2_FREE(session, secret);
-                    ret = LIBSSH2_ERROR_KEX_FAILURE;
-                    goto clean_exit;
-                }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->local.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->local.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server IV and Key calculated");
-
-        if(session->remote.crypt->dtor) {
-            /* Cleanup any existing cipher */
-            session->remote.crypt->dtor(session,
-                                        &session->remote.crypt_abstract);
-        }
-
-        if(session->remote.crypt->init) {
-            unsigned char *iv = NULL, *secret = NULL;
-            int free_iv = 0, free_secret = 0;
-
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, iv,
-                                              session->remote.crypt->
-                                              iv_len, "B");
-
-            if(!iv) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, secret,
-                                              session->remote.crypt->
-                                              secret_len, "D");
-
-            if(!secret) {
-                LIBSSH2_FREE(session, iv);
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            if(session->remote.crypt->
-                init(session, session->remote.crypt, iv, &free_iv, secret,
-                     &free_secret, 0, &session->remote.crypt_abstract)) {
-                    LIBSSH2_FREE(session, iv);
-                    LIBSSH2_FREE(session, secret);
-                    ret = LIBSSH2_ERROR_KEX_FAILURE;
-                    goto clean_exit;
-                }
-
-            if(free_iv) {
-                _libssh2_explicit_zero(iv, session->remote.crypt->iv_len);
-                LIBSSH2_FREE(session, iv);
-            }
-
-            if(free_secret) {
-                _libssh2_explicit_zero(secret,
-                                       session->remote.crypt->secret_len);
-                LIBSSH2_FREE(session, secret);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client IV and Key calculated");
-
-        if(session->local.mac->dtor) {
-            session->local.mac->dtor(session, &session->local.mac_abstract);
-        }
-
-        if(session->local.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, key,
-                                              session->local.mac->
-                                              key_len, "E");
-
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->local.mac->init(session, key, &free_key,
-                                     &session->local.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->local.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server HMAC Key calculated");
-
-        if(session->remote.mac->dtor) {
-            session->remote.mac->dtor(session, &session->remote.mac_abstract);
-        }
-
-        if(session->remote.mac->init) {
-            unsigned char *key = NULL;
-            int free_key = 0;
-
-            LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, key,
-                                              session->remote.mac->
-                                              key_len, "F");
-
-            if(!key) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-            session->remote.mac->init(session, key, &free_key,
-                                      &session->remote.mac_abstract);
-
-            if(free_key) {
-                _libssh2_explicit_zero(key, session->remote.mac->key_len);
-                LIBSSH2_FREE(session, key);
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client HMAC Key calculated");
-
-        /* Initialize compression for each direction */
-
-        /* Cleanup any existing compression */
-        if(session->local.comp && session->local.comp->dtor) {
-            session->local.comp->dtor(session, 1,
-                                      &session->local.comp_abstract);
-        }
-
-        if(session->local.comp && session->local.comp->init) {
-            if(session->local.comp->init(session, 1,
-                                            &session->local.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server compression initialized");
-
-        if(session->remote.comp && session->remote.comp->dtor) {
-            session->remote.comp->dtor(session, 0,
-                                        &session->remote.comp_abstract);
-        }
-
-        if(session->remote.comp && session->remote.comp->init) {
-            if(session->remote.comp->init(session, 0,
-                                             &session->remote.comp_abstract)) {
-                ret = LIBSSH2_ERROR_KEX_FAILURE;
-                goto clean_exit;
-            }
-        }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client compression initialized");
-    }
-
-clean_exit:
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
-    }
-
-    exchange_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-/* kex_method_curve25519_key_exchange
- *
- * Elliptic Curve X25519 Key Exchange with SHA256 hash
- *
- */
-
-static int
-kex_method_curve25519_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
-{
-    int ret = 0;
-    int rc = 0;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-
-        key_state->public_key_oct = NULL;
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    if(key_state->state == libssh2_NB_state_created) {
-        unsigned char *s = NULL;
-
-        rc = strcmp(session->kex->name, "curve25519-sha256@libssh.org");
-        if(rc != 0)
-            rc = strcmp(session->kex->name, "curve25519-sha256");
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, -1,
-                                 "Unknown KEX curve25519 curve type");
-            goto clean_exit;
-        }
-
-        rc = _libssh2_curve25519_new(session,
-                                     &key_state->curve25519_public_key,
-                                     &key_state->curve25519_private_key);
-
-        if(rc != 0) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to create private key");
-            goto clean_exit;
-        }
-
-        key_state->request[0] = SSH2_MSG_KEX_ECDH_INIT;
-        s = key_state->request + 1;
-        _libssh2_store_str(&s, (const char *)key_state->curve25519_public_key,
-                           LIBSSH2_ED25519_KEY_LEN);
-        key_state->request_len = LIBSSH2_ED25519_KEY_LEN + 5;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Initiating curve25519 SHA2");
-
-        key_state->state = libssh2_NB_state_sent;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent) {
-        rc = _libssh2_transport_send(session, key_state->request,
-                                     key_state->request_len, NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Unable to send ECDH_INIT");
-            goto clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent1;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent1) {
-        rc = _libssh2_packet_require(session, SSH2_MSG_KEX_ECDH_REPLY,
-                                     &key_state->data, &key_state->data_len,
-                                     0, NULL, 0, &key_state->req_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            ret = _libssh2_error(session, rc,
-                                 "Timeout waiting for ECDH_REPLY reply");
-            goto clean_exit;
-        }
-
-        key_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(key_state->state == libssh2_NB_state_sent2) {
-
-        ret = curve25519_sha256(session, key_state->data, key_state->data_len,
-                                key_state->curve25519_public_key,
-                                key_state->curve25519_private_key,
-                                &key_state->exchange_state);
-
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            return ret;
-        }
-
-        LIBSSH2_FREE(session, key_state->data);
-    }
-
-clean_exit:
-
-    if(key_state->curve25519_public_key) {
-        _libssh2_explicit_zero(key_state->curve25519_public_key,
-                               LIBSSH2_ED25519_KEY_LEN);
-        LIBSSH2_FREE(session, key_state->curve25519_public_key);
-        key_state->curve25519_public_key = NULL;
-    }
-
-    if(key_state->curve25519_private_key) {
-        _libssh2_explicit_zero(key_state->curve25519_private_key,
-                               LIBSSH2_ED25519_KEY_LEN);
-        LIBSSH2_FREE(session, key_state->curve25519_private_key);
-        key_state->curve25519_private_key = NULL;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
-
-    return ret;
-}
-
-
-#endif /*LIBSSH2_ED25519*/
-
-
-#define LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY     0x0001
-#define LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY    0x0002
-
-static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group1_sha1 = {
-    "diffie-hellman-group1-sha1",
-    kex_method_diffie_hellman_group1_sha1_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group14_sha1 = {
-    "diffie-hellman-group14-sha1",
-    kex_method_diffie_hellman_group14_sha1_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group14_sha256 = {
-    "diffie-hellman-group14-sha256",
-    kex_method_diffie_hellman_group14_sha256_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group16_sha512 = {
-    "diffie-hellman-group16-sha512",
-    kex_method_diffie_hellman_group16_sha512_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group18_sha512 = {
-    "diffie-hellman-group18-sha512",
-    kex_method_diffie_hellman_group18_sha512_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD
-kex_method_diffie_helman_group_exchange_sha1 = {
-    "diffie-hellman-group-exchange-sha1",
-    kex_method_diffie_hellman_group_exchange_sha1_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD
-kex_method_diffie_helman_group_exchange_sha256 = {
-    "diffie-hellman-group-exchange-sha256",
-    kex_method_diffie_hellman_group_exchange_sha256_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-#if LIBSSH2_ECDSA
-static const LIBSSH2_KEX_METHOD
-kex_method_ecdh_sha2_nistp256 = {
-    "ecdh-sha2-nistp256",
-    kex_method_ecdh_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD
-kex_method_ecdh_sha2_nistp384 = {
-    "ecdh-sha2-nistp384",
-    kex_method_ecdh_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-
-static const LIBSSH2_KEX_METHOD
-kex_method_ecdh_sha2_nistp521 = {
-    "ecdh-sha2-nistp521",
-    kex_method_ecdh_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-#endif
-
-#if LIBSSH2_ED25519
-static const LIBSSH2_KEX_METHOD
-kex_method_ssh_curve25519_sha256_libssh = {
-    "curve25519-sha256@libssh.org",
-    kex_method_curve25519_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-static const LIBSSH2_KEX_METHOD
-kex_method_ssh_curve25519_sha256 = {
-    "curve25519-sha256",
-    kex_method_curve25519_key_exchange,
-    LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
-};
-#endif
-
-static const LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
-#if LIBSSH2_ED25519
-    &kex_method_ssh_curve25519_sha256,
-    &kex_method_ssh_curve25519_sha256_libssh,
-#endif
-#if LIBSSH2_ECDSA
-    &kex_method_ecdh_sha2_nistp256,
-    &kex_method_ecdh_sha2_nistp384,
-    &kex_method_ecdh_sha2_nistp521,
-#endif
-    &kex_method_diffie_helman_group_exchange_sha256,
-    &kex_method_diffie_helman_group16_sha512,
-    &kex_method_diffie_helman_group18_sha512,
-    &kex_method_diffie_helman_group14_sha256,
-    &kex_method_diffie_helman_group14_sha1,
-    &kex_method_diffie_helman_group1_sha1,
-    &kex_method_diffie_helman_group_exchange_sha1,
-  NULL
-};
-
-typedef struct _LIBSSH2_COMMON_METHOD
-{
-    const char *name;
-} LIBSSH2_COMMON_METHOD;
-
-/* kex_method_strlen
- * Calculate the length of a particular method list's resulting string
- * Includes SUM(strlen() of each individual method plus 1 (for coma)) - 1
- * (because the last coma isn't used)
- * Another sign of bad coding practices gone mad.  Pretend you don't see this.
- */
-static size_t
-kex_method_strlen(LIBSSH2_COMMON_METHOD ** method)
-{
-    size_t len = 0;
-
-    if(!method || !*method) {
-        return 0;
-    }
-
-    while(*method && (*method)->name) {
-        len += strlen((*method)->name) + 1;
-        method++;
-    }
-
-    return len - 1;
-}
-
-
-
-/* kex_method_list
- * Generate formatted preference list in buf
- */
-static size_t
-kex_method_list(unsigned char *buf, size_t list_strlen,
-                LIBSSH2_COMMON_METHOD ** method)
-{
-    _libssh2_htonu32(buf, list_strlen);
-    buf += 4;
-
-    if(!method || !*method) {
-        return 4;
-    }
-
-    while(*method && (*method)->name) {
-        int mlen = strlen((*method)->name);
-        memcpy(buf, (*method)->name, mlen);
-        buf += mlen;
-        *(buf++) = ',';
-        method++;
-    }
-
-    return list_strlen + 4;
-}
-
-
-
-#define LIBSSH2_METHOD_PREFS_LEN(prefvar, defaultvar)           \
-    ((prefvar) ? strlen(prefvar) :                              \
-     kex_method_strlen((LIBSSH2_COMMON_METHOD**)(defaultvar)))
-
-#define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar)  \
-    if(prefvar) {                                                       \
-        _libssh2_htonu32((buf), (prefvarlen));                          \
-        buf += 4;                                                       \
-        memcpy((buf), (prefvar), (prefvarlen));                         \
-        buf += (prefvarlen);                                            \
-    }                                                                   \
-    else {                                                              \
-        buf += kex_method_list((buf), (prefvarlen),                     \
-                               (LIBSSH2_COMMON_METHOD**)(defaultvar));  \
-    }
-
-/* kexinit
- * Send SSH_MSG_KEXINIT packet
- */
-static int kexinit(LIBSSH2_SESSION * session)
-{
-    /* 62 = packet_type(1) + cookie(16) + first_packet_follows(1) +
-       reserved(4) + length longs(40) */
-    size_t data_len = 62;
-    size_t kex_len, hostkey_len = 0;
-    size_t crypt_cs_len, crypt_sc_len;
-    size_t comp_cs_len, comp_sc_len;
-    size_t mac_cs_len, mac_sc_len;
-    size_t lang_cs_len, lang_sc_len;
-    unsigned char *data, *s;
-    int rc;
-
-    if(session->kexinit_state == libssh2_NB_state_idle) {
-        kex_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->kex_prefs, libssh2_kex_methods);
-        hostkey_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->hostkey_prefs,
-                                     libssh2_hostkey_methods());
-        crypt_cs_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->local.crypt_prefs,
-                                     libssh2_crypt_methods());
-        crypt_sc_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->remote.crypt_prefs,
-                                     libssh2_crypt_methods());
-        mac_cs_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->local.mac_prefs,
-                                     _libssh2_mac_methods());
-        mac_sc_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->remote.mac_prefs,
-                                     _libssh2_mac_methods());
-        comp_cs_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->local.comp_prefs,
-                                     _libssh2_comp_methods(session));
-        comp_sc_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->remote.comp_prefs,
-                                     _libssh2_comp_methods(session));
-        lang_cs_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->local.lang_prefs, NULL);
-        lang_sc_len =
-            LIBSSH2_METHOD_PREFS_LEN(session->remote.lang_prefs, NULL);
-
-        data_len += kex_len + hostkey_len + crypt_cs_len + crypt_sc_len +
-            comp_cs_len + comp_sc_len + mac_cs_len + mac_sc_len +
-            lang_cs_len + lang_sc_len;
-
-        s = data = LIBSSH2_ALLOC(session, data_len);
-        if(!data) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory");
-        }
-
-        *(s++) = SSH_MSG_KEXINIT;
-
-        if(_libssh2_random(s, 16)) {
-            return _libssh2_error(session, LIBSSH2_ERROR_RANDGEN,
-                                  "Unable to get random bytes "
-                                  "for KEXINIT cookie");
-        }
-        s += 16;
-
-        /* Ennumerating through these lists twice is probably (certainly?)
-           inefficient from a CPU standpoint, but it saves multiple
-           malloc/realloc calls */
-        LIBSSH2_METHOD_PREFS_STR(s, kex_len, session->kex_prefs,
-                                 libssh2_kex_methods);
-        LIBSSH2_METHOD_PREFS_STR(s, hostkey_len, session->hostkey_prefs,
-                                 libssh2_hostkey_methods());
-        LIBSSH2_METHOD_PREFS_STR(s, crypt_cs_len, session->local.crypt_prefs,
-                                 libssh2_crypt_methods());
-        LIBSSH2_METHOD_PREFS_STR(s, crypt_sc_len, session->remote.crypt_prefs,
-                                 libssh2_crypt_methods());
-        LIBSSH2_METHOD_PREFS_STR(s, mac_cs_len, session->local.mac_prefs,
-                                 _libssh2_mac_methods());
-        LIBSSH2_METHOD_PREFS_STR(s, mac_sc_len, session->remote.mac_prefs,
-                                 _libssh2_mac_methods());
-        LIBSSH2_METHOD_PREFS_STR(s, comp_cs_len, session->local.comp_prefs,
-                                 _libssh2_comp_methods(session));
-        LIBSSH2_METHOD_PREFS_STR(s, comp_sc_len, session->remote.comp_prefs,
-                                 _libssh2_comp_methods(session));
-        LIBSSH2_METHOD_PREFS_STR(s, lang_cs_len, session->local.lang_prefs,
-                                 NULL);
-        LIBSSH2_METHOD_PREFS_STR(s, lang_sc_len, session->remote.lang_prefs,
-                                 NULL);
-
-        /* No optimistic KEX packet follows */
-        /* Deal with optimistic packets
-         * session->flags |= KEXINIT_OPTIMISTIC
-         * session->flags |= KEXINIT_METHODSMATCH
-         */
-        *(s++) = 0;
-
-        /* Reserved == 0 */
-        _libssh2_htonu32(s, 0);
-
-#ifdef LIBSSH2DEBUG
-        {
-            /* Funnily enough, they'll all "appear" to be '\0' terminated */
-            unsigned char *p = data + 21;   /* type(1) + cookie(16) + len(4) */
-
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent KEX: %s", p);
-            p += kex_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent HOSTKEY: %s", p);
-            p += hostkey_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_CS: %s", p);
-            p += crypt_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_SC: %s", p);
-            p += crypt_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_CS: %s", p);
-            p += mac_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_SC: %s", p);
-            p += mac_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_CS: %s", p);
-            p += comp_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_SC: %s", p);
-            p += comp_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_CS: %s", p);
-            p += lang_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_SC: %s", p);
-            p += lang_sc_len + 4;
-        }
-#endif /* LIBSSH2DEBUG */
-
-        session->kexinit_state = libssh2_NB_state_created;
-    }
-    else {
-        data = session->kexinit_data;
-        data_len = session->kexinit_data_len;
-        /* zap the variables to ensure there is NOT a double free later */
-        session->kexinit_data = NULL;
-        session->kexinit_data_len = 0;
-    }
-
-    rc = _libssh2_transport_send(session, data, data_len, NULL, 0);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        session->kexinit_data = data;
-        session->kexinit_data_len = data_len;
-        return rc;
-    }
-    else if(rc) {
-        LIBSSH2_FREE(session, data);
-        session->kexinit_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Unable to send KEXINIT packet to remote host");
-
-    }
-
-    if(session->local.kexinit) {
-        LIBSSH2_FREE(session, session->local.kexinit);
-    }
-
-    session->local.kexinit = data;
-    session->local.kexinit_len = data_len;
-
-    session->kexinit_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/* kex_agree_instr
- * Kex specific variant of strstr()
- * Needle must be precede by BOL or ',', and followed by ',' or EOL
- */
-static unsigned char *
-kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
-                const unsigned char *needle, unsigned long needle_len)
-{
-    unsigned char *s;
-    unsigned char *end_haystack;
-    unsigned long left;
-
-    if(haystack == NULL || needle == NULL) {
-        return NULL;
-    }
-
-    /* Haystack too short to bother trying */
-    if(haystack_len < needle_len || needle_len == 0) {
-        return NULL;
-    }
-
-    s = haystack;
-    end_haystack = &haystack[haystack_len];
-    left = end_haystack - s;
-
-    /* Needle at start of haystack */
-    if((strncmp((char *) haystack, (char *) needle, needle_len) == 0) &&
-        (needle_len == haystack_len || haystack[needle_len] == ',')) {
-        return haystack;
-    }
-
-    /* Search until we run out of comas or we run out of haystack,
-       whichever comes first */
-    while((s = (unsigned char *) memchr((char *) s, ',', left))) {
-        /* Advance buffer past coma if we can */
-        left = end_haystack - s;
-        if((left >= 1) && (left <= haystack_len) && (left > needle_len)) {
-            s++;
-        }
-        else {
-            return NULL;
-        }
-
-        /* Needle at X position */
-        if((strncmp((char *) s, (char *) needle, needle_len) == 0) &&
-            (((s - haystack) + needle_len) == haystack_len
-             || s[needle_len] == ',')) {
-            return s;
-        }
-    }
-
-    return NULL;
-}
-
-
-
-/* kex_get_method_by_name
- */
-static const LIBSSH2_COMMON_METHOD *
-kex_get_method_by_name(const char *name, size_t name_len,
-                       const LIBSSH2_COMMON_METHOD ** methodlist)
-{
-    while(*methodlist) {
-        if((strlen((*methodlist)->name) == name_len) &&
-            (strncmp((*methodlist)->name, name, name_len) == 0)) {
-            return *methodlist;
-        }
-        methodlist++;
-    }
-    return NULL;
-}
-
-
-
-/* kex_agree_hostkey
- * Agree on a Hostkey which works with this kex
- */
-static int kex_agree_hostkey(LIBSSH2_SESSION * session,
-                             unsigned long kex_flags,
-                             unsigned char *hostkey, unsigned long hostkey_len)
-{
-    const LIBSSH2_HOSTKEY_METHOD **hostkeyp = libssh2_hostkey_methods();
-    unsigned char *s;
-
-    if(session->hostkey_prefs) {
-        s = (unsigned char *) session->hostkey_prefs;
-
-        while(s && *s) {
-            unsigned char *p = (unsigned char *) strchr((char *) s, ',');
-            size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            if(kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
-                const LIBSSH2_HOSTKEY_METHOD *method =
-                    (const LIBSSH2_HOSTKEY_METHOD *)
-                    kex_get_method_by_name((char *) s, method_len,
-                                           (const LIBSSH2_COMMON_METHOD **)
-                                           hostkeyp);
-
-                if(!method) {
-                    /* Invalid method -- Should never be reached */
-                    return -1;
-                }
-
-                /* So far so good, but does it suit our purposes? (Encrypting
-                   vs Signing) */
-                if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) ==
-                     0) || (method->encrypt)) {
-                    /* Either this hostkey can do encryption or this kex just
-                       doesn't require it */
-                    if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY)
-                         == 0) || (method->sig_verify)) {
-                        /* Either this hostkey can do signing or this kex just
-                           doesn't require it */
-                        session->hostkey = method;
-                        return 0;
-                    }
-                }
-            }
-
-            s = p ? p + 1 : NULL;
-        }
-        return -1;
-    }
-
-    while(hostkeyp && (*hostkeyp) && (*hostkeyp)->name) {
-        s = kex_agree_instr(hostkey, hostkey_len,
-                            (unsigned char *) (*hostkeyp)->name,
-                            strlen((*hostkeyp)->name));
-        if(s) {
-            /* So far so good, but does it suit our purposes? (Encrypting vs
-               Signing) */
-            if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) == 0) ||
-                ((*hostkeyp)->encrypt)) {
-                /* Either this hostkey can do encryption or this kex just
-                   doesn't require it */
-                if(((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY) ==
-                     0) || ((*hostkeyp)->sig_verify)) {
-                    /* Either this hostkey can do signing or this kex just
-                       doesn't require it */
-                    session->hostkey = *hostkeyp;
-                    return 0;
-                }
-            }
-        }
-        hostkeyp++;
-    }
-
-    return -1;
-}
-
-
-
-/* kex_agree_kex_hostkey
- * Agree on a Key Exchange method and a hostkey encoding type
- */
-static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
-                                 unsigned long kex_len, unsigned char *hostkey,
-                                 unsigned long hostkey_len)
-{
-    const LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
-    unsigned char *s;
-
-    if(session->kex_prefs) {
-        s = (unsigned char *) session->kex_prefs;
-
-        while(s && *s) {
-            unsigned char *q, *p = (unsigned char *) strchr((char *) s, ',');
-            size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            q = kex_agree_instr(kex, kex_len, s, method_len);
-            if(q) {
-                const LIBSSH2_KEX_METHOD *method = (const LIBSSH2_KEX_METHOD *)
-                    kex_get_method_by_name((char *) s, method_len,
-                                           (const LIBSSH2_COMMON_METHOD **)
-                                           kexp);
-
-                if(!method) {
-                    /* Invalid method -- Should never be reached */
-                    return -1;
-                }
-
-                /* We've agreed on a key exchange method,
-                 * Can we agree on a hostkey that works with this kex?
-                 */
-                if(kex_agree_hostkey(session, method->flags, hostkey,
-                                      hostkey_len) == 0) {
-                    session->kex = method;
-                    if(session->burn_optimistic_kexinit && (kex == q)) {
-                        /* Server sent an optimistic packet, and client agrees
-                         * with preference cancel burning the first KEX_INIT
-                         * packet that comes in */
-                        session->burn_optimistic_kexinit = 0;
-                    }
-                    return 0;
-                }
-            }
-
-            s = p ? p + 1 : NULL;
-        }
-        return -1;
-    }
-
-    while(*kexp && (*kexp)->name) {
-        s = kex_agree_instr(kex, kex_len,
-                            (unsigned char *) (*kexp)->name,
-                            strlen((*kexp)->name));
-        if(s) {
-            /* We've agreed on a key exchange method,
-             * Can we agree on a hostkey that works with this kex?
-             */
-            if(kex_agree_hostkey(session, (*kexp)->flags, hostkey,
-                                  hostkey_len) == 0) {
-                session->kex = *kexp;
-                if(session->burn_optimistic_kexinit && (kex == s)) {
-                    /* Server sent an optimistic packet, and client agrees
-                     * with preference cancel burning the first KEX_INIT
-                     * packet that comes in */
-                    session->burn_optimistic_kexinit = 0;
-                }
-                return 0;
-            }
-        }
-        kexp++;
-    }
-    return -1;
-}
-
-
-
-/* kex_agree_crypt
- * Agree on a cipher algo
- */
-static int kex_agree_crypt(LIBSSH2_SESSION * session,
-                           libssh2_endpoint_data *endpoint,
-                           unsigned char *crypt,
-                           unsigned long crypt_len)
-{
-    const LIBSSH2_CRYPT_METHOD **cryptp = libssh2_crypt_methods();
-    unsigned char *s;
-
-    (void) session;
-
-    if(endpoint->crypt_prefs) {
-        s = (unsigned char *) endpoint->crypt_prefs;
-
-        while(s && *s) {
-            unsigned char *p = (unsigned char *) strchr((char *) s, ',');
-            size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-
-            if(kex_agree_instr(crypt, crypt_len, s, method_len)) {
-                const LIBSSH2_CRYPT_METHOD *method =
-                    (const LIBSSH2_CRYPT_METHOD *)
-                    kex_get_method_by_name((char *) s, method_len,
-                                           (const LIBSSH2_COMMON_METHOD **)
-                                           cryptp);
-
-                if(!method) {
-                    /* Invalid method -- Should never be reached */
-                    return -1;
-                }
-
-                endpoint->crypt = method;
-                return 0;
-            }
-
-            s = p ? p + 1 : NULL;
-        }
-        return -1;
-    }
-
-    while(*cryptp && (*cryptp)->name) {
-        s = kex_agree_instr(crypt, crypt_len,
-                            (unsigned char *) (*cryptp)->name,
-                            strlen((*cryptp)->name));
-        if(s) {
-            endpoint->crypt = *cryptp;
-            return 0;
-        }
-        cryptp++;
-    }
-
-    return -1;
-}
-
-
-
-/* kex_agree_mac
- * Agree on a message authentication hash
- */
-static int kex_agree_mac(LIBSSH2_SESSION * session,
-                         libssh2_endpoint_data * endpoint, unsigned char *mac,
-                         unsigned long mac_len)
-{
-    const LIBSSH2_MAC_METHOD **macp = _libssh2_mac_methods();
-    unsigned char *s;
-    (void) session;
-
-    if(endpoint->mac_prefs) {
-        s = (unsigned char *) endpoint->mac_prefs;
-
-        while(s && *s) {
-            unsigned char *p = (unsigned char *) strchr((char *) s, ',');
-            size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-
-            if(kex_agree_instr(mac, mac_len, s, method_len)) {
-                const LIBSSH2_MAC_METHOD *method = (const LIBSSH2_MAC_METHOD *)
-                    kex_get_method_by_name((char *) s, method_len,
-                                           (const LIBSSH2_COMMON_METHOD **)
-                                           macp);
-
-                if(!method) {
-                    /* Invalid method -- Should never be reached */
-                    return -1;
-                }
-
-                endpoint->mac = method;
-                return 0;
-            }
-
-            s = p ? p + 1 : NULL;
-        }
-        return -1;
-    }
-
-    while(*macp && (*macp)->name) {
-        s = kex_agree_instr(mac, mac_len, (unsigned char *) (*macp)->name,
-                            strlen((*macp)->name));
-        if(s) {
-            endpoint->mac = *macp;
-            return 0;
-        }
-        macp++;
-    }
-
-    return -1;
-}
-
-
-
-/* kex_agree_comp
- * Agree on a compression scheme
- */
-static int kex_agree_comp(LIBSSH2_SESSION *session,
-                          libssh2_endpoint_data *endpoint, unsigned char *comp,
-                          unsigned long comp_len)
-{
-    const LIBSSH2_COMP_METHOD **compp = _libssh2_comp_methods(session);
-    unsigned char *s;
-    (void) session;
-
-    if(endpoint->comp_prefs) {
-        s = (unsigned char *) endpoint->comp_prefs;
-
-        while(s && *s) {
-            unsigned char *p = (unsigned char *) strchr((char *) s, ',');
-            size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-
-            if(kex_agree_instr(comp, comp_len, s, method_len)) {
-                const LIBSSH2_COMP_METHOD *method =
-                    (const LIBSSH2_COMP_METHOD *)
-                    kex_get_method_by_name((char *) s, method_len,
-                                           (const LIBSSH2_COMMON_METHOD **)
-                                           compp);
-
-                if(!method) {
-                    /* Invalid method -- Should never be reached */
-                    return -1;
-                }
-
-                endpoint->comp = method;
-                return 0;
-            }
-
-            s = p ? p + 1 : NULL;
-        }
-        return -1;
-    }
-
-    while(*compp && (*compp)->name) {
-        s = kex_agree_instr(comp, comp_len, (unsigned char *) (*compp)->name,
-                            strlen((*compp)->name));
-        if(s) {
-            endpoint->comp = *compp;
-            return 0;
-        }
-        compp++;
-    }
-
-    return -1;
-}
-
-
-/* TODO: When in server mode we need to turn this logic on its head
- * The Client gets to make the final call on "agreed methods"
- */
-
-/* kex_agree_methods
- * Decide which specific method to use of the methods offered by each party
- */
-static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
-                             unsigned data_len)
-{
-    unsigned char *kex, *hostkey, *crypt_cs, *crypt_sc, *comp_cs, *comp_sc,
-        *mac_cs, *mac_sc;
-    size_t kex_len, hostkey_len, crypt_cs_len, crypt_sc_len, comp_cs_len;
-    size_t comp_sc_len, mac_cs_len, mac_sc_len;
-    struct string_buf buf;
-
-    if(data_len < 17)
-        return -1;
-
-    buf.data = (unsigned char *)data;
-    buf.len = data_len;
-    buf.dataptr = buf.data;
-    buf.dataptr++; /* advance past packet type */
-
-    /* Skip cookie, don't worry, it's preserved in the kexinit field */
-    buf.dataptr += 16;
-
-    /* Locate each string */
-    if(_libssh2_get_string(&buf, &kex, &kex_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &hostkey, &hostkey_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &crypt_cs, &crypt_cs_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &crypt_sc, &crypt_sc_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &mac_cs, &mac_cs_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &mac_sc, &mac_sc_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &comp_cs, &comp_cs_len))
-        return -1;
-    if(_libssh2_get_string(&buf, &comp_sc, &comp_sc_len))
-        return -1;
-
-    /* If the server sent an optimistic packet, assume that it guessed wrong.
-     * If the guess is determined to be right (by kex_agree_kex_hostkey)
-     * This flag will be reset to zero so that it's not ignored */
-    if(_libssh2_check_length(&buf, 1)) {
-        session->burn_optimistic_kexinit = *(buf.dataptr++);
-    }
-    else {
-        return -1;
-    }
-
-    /* Next uint32 in packet is all zeros (reserved) */
-
-    if(kex_agree_kex_hostkey(session, kex, kex_len, hostkey, hostkey_len)) {
-        return -1;
-    }
-
-    if(kex_agree_crypt(session, &session->local, crypt_cs, crypt_cs_len)
-       || kex_agree_crypt(session, &session->remote, crypt_sc,
-                          crypt_sc_len)) {
-        return -1;
-    }
-
-    if(kex_agree_mac(session, &session->local, mac_cs, mac_cs_len) ||
-        kex_agree_mac(session, &session->remote, mac_sc, mac_sc_len)) {
-        return -1;
-    }
-
-    if(kex_agree_comp(session, &session->local, comp_cs, comp_cs_len) ||
-        kex_agree_comp(session, &session->remote, comp_sc, comp_sc_len)) {
-        return -1;
-    }
-
-#if 0
-    if(libssh2_kex_agree_lang(session, &session->local, lang_cs, lang_cs_len)
-        || libssh2_kex_agree_lang(session, &session->remote, lang_sc,
-                                  lang_sc_len)) {
-        return -1;
-    }
-#endif
-
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on KEX method: %s",
-                   session->kex->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on HOSTKEY method: %s",
-                   session->hostkey->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_CS method: %s",
-                   session->local.crypt->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_SC method: %s",
-                   session->remote.crypt->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_CS method: %s",
-                   session->local.mac->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_SC method: %s",
-                   session->remote.mac->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_CS method: %s",
-                   session->local.comp->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_SC method: %s",
-                   session->remote.comp->name);
-
-    return 0;
-}
-
-
-
-/* _libssh2_kex_exchange
- * Exchange keys
- * Returns 0 on success, non-zero on failure
- *
- * Returns some errors without _libssh2_error()
- */
-int
-_libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
-                      key_exchange_state_t * key_state)
-{
-    int rc = 0;
-    int retcode;
-
-    session->state |= LIBSSH2_STATE_KEX_ACTIVE;
-
-    if(key_state->state == libssh2_NB_state_idle) {
-        /* Prevent loop in packet_add() */
-        session->state |= LIBSSH2_STATE_EXCHANGING_KEYS;
-
-        if(reexchange) {
-            session->kex = NULL;
-
-            if(session->hostkey && session->hostkey->dtor) {
-                session->hostkey->dtor(session,
-                                       &session->server_hostkey_abstract);
-            }
-            session->hostkey = NULL;
-        }
-
-        key_state->state = libssh2_NB_state_created;
-    }
-
-    if(!session->kex || !session->hostkey) {
-        if(key_state->state == libssh2_NB_state_created) {
-            /* Preserve in case of failure */
-            key_state->oldlocal = session->local.kexinit;
-            key_state->oldlocal_len = session->local.kexinit_len;
-
-            session->local.kexinit = NULL;
-
-            key_state->state = libssh2_NB_state_sent;
-        }
-
-        if(key_state->state == libssh2_NB_state_sent) {
-            retcode = kexinit(session);
-            if(retcode == LIBSSH2_ERROR_EAGAIN) {
-                session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-                return retcode;
-            }
-            else if(retcode) {
-                session->local.kexinit = key_state->oldlocal;
-                session->local.kexinit_len = key_state->oldlocal_len;
-                key_state->state = libssh2_NB_state_idle;
-                session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-                session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
-                return -1;
-            }
-
-            key_state->state = libssh2_NB_state_sent1;
-        }
-
-        if(key_state->state == libssh2_NB_state_sent1) {
-            retcode =
-                _libssh2_packet_require(session, SSH_MSG_KEXINIT,
-                                        &key_state->data,
-                                        &key_state->data_len, 0, NULL, 0,
-                                        &key_state->req_state);
-            if(retcode == LIBSSH2_ERROR_EAGAIN) {
-                session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-                return retcode;
-            }
-            else if(retcode) {
-                if(session->local.kexinit) {
-                    LIBSSH2_FREE(session, session->local.kexinit);
-                }
-                session->local.kexinit = key_state->oldlocal;
-                session->local.kexinit_len = key_state->oldlocal_len;
-                key_state->state = libssh2_NB_state_idle;
-                session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-                session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
-                return -1;
-            }
-
-            if(session->remote.kexinit) {
-                LIBSSH2_FREE(session, session->remote.kexinit);
-            }
-            session->remote.kexinit = key_state->data;
-            session->remote.kexinit_len = key_state->data_len;
-
-            if(kex_agree_methods(session, key_state->data,
-                                  key_state->data_len))
-                rc = LIBSSH2_ERROR_KEX_FAILURE;
-
-            key_state->state = libssh2_NB_state_sent2;
-        }
-    }
-    else {
-        key_state->state = libssh2_NB_state_sent2;
-    }
-
-    if(rc == 0 && session->kex) {
-        if(key_state->state == libssh2_NB_state_sent2) {
-            retcode = session->kex->exchange_keys(session,
-                                                  &key_state->key_state_low);
-            if(retcode == LIBSSH2_ERROR_EAGAIN) {
-                session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-                return retcode;
-            }
-            else if(retcode) {
-                rc = _libssh2_error(session,
-                                    LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE,
-                                    "Unrecoverable error exchanging keys");
-            }
-        }
-    }
-
-    /* Done with kexinit buffers */
-    if(session->local.kexinit) {
-        LIBSSH2_FREE(session, session->local.kexinit);
-        session->local.kexinit = NULL;
-    }
-    if(session->remote.kexinit) {
-        LIBSSH2_FREE(session, session->remote.kexinit);
-        session->remote.kexinit = NULL;
-    }
-
-    session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
-    session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
-
-    key_state->state = libssh2_NB_state_idle;
-
-    return rc;
-}
-
-
-
-/* libssh2_session_method_pref
- * Set preferred method
- */
-LIBSSH2_API int
-libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
-                            const char *prefs)
-{
-    char **prefvar, *s, *newprefs;
-    int prefs_len = strlen(prefs);
-    const LIBSSH2_COMMON_METHOD **mlist;
-
-    switch(method_type) {
-    case LIBSSH2_METHOD_KEX:
-        prefvar = &session->kex_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
-        break;
-
-    case LIBSSH2_METHOD_HOSTKEY:
-        prefvar = &session->hostkey_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_hostkey_methods();
-        break;
-
-    case LIBSSH2_METHOD_CRYPT_CS:
-        prefvar = &session->local.crypt_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
-        break;
-
-    case LIBSSH2_METHOD_CRYPT_SC:
-        prefvar = &session->remote.crypt_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
-        break;
-
-    case LIBSSH2_METHOD_MAC_CS:
-        prefvar = &session->local.mac_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
-        break;
-
-    case LIBSSH2_METHOD_MAC_SC:
-        prefvar = &session->remote.mac_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
-        break;
-
-    case LIBSSH2_METHOD_COMP_CS:
-        prefvar = &session->local.comp_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
-        break;
-
-    case LIBSSH2_METHOD_COMP_SC:
-        prefvar = &session->remote.comp_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
-        break;
-
-    case LIBSSH2_METHOD_LANG_CS:
-        prefvar = &session->local.lang_prefs;
-        mlist = NULL;
-        break;
-
-    case LIBSSH2_METHOD_LANG_SC:
-        prefvar = &session->remote.lang_prefs;
-        mlist = NULL;
-        break;
-
-    default:
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                              "Invalid parameter specified for method_type");
-    }
-
-    s = newprefs = LIBSSH2_ALLOC(session, prefs_len + 1);
-    if(!newprefs) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Error allocated space for method preferences");
-    }
-    memcpy(s, prefs, prefs_len + 1);
-
-    while(s && *s && mlist) {
-        char *p = strchr(s, ',');
-        int method_len = p ? (p - s) : (int) strlen(s);
-
-        if(!kex_get_method_by_name(s, method_len, mlist)) {
-            /* Strip out unsupported method */
-            if(p) {
-                memcpy(s, p + 1, strlen(s) - method_len);
-            }
-            else {
-                if(s > newprefs) {
-                    *(--s) = '\0';
-                }
-                else {
-                    *s = '\0';
-                }
-            }
-        }
-        else {
-            s = p ? (p + 1) : NULL;
-        }
-    }
-
-    if(!*newprefs) {
-        LIBSSH2_FREE(session, newprefs);
-        return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "The requested method(s) are not currently "
-                              "supported");
-    }
-
-    if(*prefvar) {
-        LIBSSH2_FREE(session, *prefvar);
-    }
-    *prefvar = newprefs;
-
-    return 0;
-}
-
-/*
- * libssh2_session_supported_algs()
- * returns a number of returned algorithms (a positive number) on success,
- * a negative number on failure
- */
-
-LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
-                                               int method_type,
-                                               const char ***algs)
-{
-    unsigned int i;
-    unsigned int j;
-    unsigned int ialg;
-    const LIBSSH2_COMMON_METHOD **mlist;
-
-    /* to prevent coredumps due to dereferencing of NULL */
-    if(NULL == algs)
-        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-                              "algs must not be NULL");
-
-    switch(method_type) {
-    case LIBSSH2_METHOD_KEX:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
-        break;
-
-    case LIBSSH2_METHOD_HOSTKEY:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_hostkey_methods();
-        break;
-
-    case LIBSSH2_METHOD_CRYPT_CS:
-    case LIBSSH2_METHOD_CRYPT_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
-        break;
-
-    case LIBSSH2_METHOD_MAC_CS:
-    case LIBSSH2_METHOD_MAC_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
-        break;
-
-    case LIBSSH2_METHOD_COMP_CS:
-    case LIBSSH2_METHOD_COMP_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
-        break;
-
-    default:
-        return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unknown method type");
-    }  /* switch */
-
-    /* weird situation */
-    if(NULL == mlist)
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                              "No algorithm found");
-
-    /*
-      mlist is looped through twice. The first time to find the number od
-      supported algorithms (needed to allocate the proper size of array) and
-      the second time to actually copy the pointers.  Typically this function
-      will not be called often (typically at the beginning of a session) and
-      the number of algorithms (i.e. number of iterations in one loop) will
-      not be high (typically it will not exceed 20) for quite a long time.
-
-      So double looping really shouldn't be an issue and it is definitely a
-      better solution than reallocation several times.
-    */
-
-    /* count the number of supported algorithms */
-    for(i = 0, ialg = 0; NULL != mlist[i]; i++) {
-        /* do not count fields with NULL name */
-        if(mlist[i]->name)
-            ialg++;
-    }
-
-    /* weird situation, no algorithm found */
-    if(0 == ialg)
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                              "No algorithm found");
-
-    /* allocate buffer */
-    *algs = (const char **) LIBSSH2_ALLOC(session, ialg*sizeof(const char *));
-    if(NULL == *algs) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Memory allocation failed");
-    }
-    /* Past this point *algs must be deallocated in case of an error!! */
-
-    /* copy non-NULL pointers only */
-    for(i = 0, j = 0; NULL != mlist[i] && j < ialg; i++) {
-        if(NULL == mlist[i]->name) {
-            /* maybe a weird situation but if it occurs, do not include NULL
-               pointers */
-            continue;
-        }
-
-        /* note that [] has higher priority than * (dereferencing) */
-        (*algs)[j++] = mlist[i]->name;
-    }
-
-    /* correct number of pointers copied? (test the code above) */
-    if(j != ialg) {
-        /* deallocate buffer */
-        LIBSSH2_FREE(session, (void *)*algs);
-        *algs = NULL;
-
-        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-                              "Internal error");
-    }
-
-    return ialg;
-}
diff --git a/libssh2/libssh2/src/knownhost.c b/libssh2/libssh2/src/knownhost.c
deleted file mode 100644
index 77798fbf..00000000
--- a/libssh2/libssh2/src/knownhost.c
+++ /dev/null
@@ -1,1271 +0,0 @@
-/*
- * Copyright (c) 2009-2019 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "misc.h"
-
-struct known_host {
-    struct list_node node;
-    char *name;      /* points to the name or the hash (allocated) */
-    size_t name_len; /* needed for hashed data */
-    int port;        /* if non-zero, a specific port this key is for on this
-                        host */
-    int typemask;    /* plain, sha1, custom, ... */
-    char *salt;      /* points to binary salt (allocated) */
-    size_t salt_len; /* size of salt */
-    char *key;       /* the (allocated) associated key. This is kept base64
-                        encoded in memory. */
-    char *key_type_name; /* the (allocated) key type name */
-    size_t key_type_len; /* size of key_type_name */
-    char *comment;       /* the (allocated) optional comment text, may be
-                            NULL */
-    size_t comment_len;  /* the size of comment */
-
-    /* this is the struct we expose externally */
-    struct libssh2_knownhost external;
-};
-
-struct _LIBSSH2_KNOWNHOSTS
-{
-    LIBSSH2_SESSION *session;  /* the session this "belongs to" */
-    struct list_head head;
-};
-
-static void free_host(LIBSSH2_SESSION *session, struct known_host *entry)
-{
-    if(entry) {
-        if(entry->comment)
-            LIBSSH2_FREE(session, entry->comment);
-        if(entry->key_type_name)
-            LIBSSH2_FREE(session, entry->key_type_name);
-        if(entry->key)
-            LIBSSH2_FREE(session, entry->key);
-        if(entry->salt)
-            LIBSSH2_FREE(session, entry->salt);
-        if(entry->name)
-            LIBSSH2_FREE(session, entry->name);
-        LIBSSH2_FREE(session, entry);
-    }
-}
-
-/*
- * libssh2_knownhost_init
- *
- * Init a collection of known hosts. Returns the pointer to a collection.
- *
- */
-LIBSSH2_API LIBSSH2_KNOWNHOSTS *
-libssh2_knownhost_init(LIBSSH2_SESSION *session)
-{
-    LIBSSH2_KNOWNHOSTS *knh =
-        LIBSSH2_ALLOC(session, sizeof(struct _LIBSSH2_KNOWNHOSTS));
-
-    if(!knh) {
-        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                       "Unable to allocate memory for known-hosts "
-                       "collection");
-        return NULL;
-    }
-
-    knh->session = session;
-
-    _libssh2_list_init(&knh->head);
-
-    return knh;
-}
-
-#define KNOWNHOST_MAGIC 0xdeadcafe
-/*
- * knownhost_to_external()
- *
- * Copies data from the internal to the external representation struct.
- *
- */
-static struct libssh2_knownhost *knownhost_to_external(struct known_host *node)
-{
-    struct libssh2_knownhost *ext = &node->external;
-
-    ext->magic = KNOWNHOST_MAGIC;
-    ext->node = node;
-    ext->name = ((node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) ==
-                 LIBSSH2_KNOWNHOST_TYPE_PLAIN)? node->name:NULL;
-    ext->key = node->key;
-    ext->typemask = node->typemask;
-
-    return ext;
-}
-
-static int
-knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
-              const char *host, const char *salt,
-              const char *key_type_name, size_t key_type_len,
-              const char *key, size_t keylen,
-              const char *comment, size_t commentlen,
-              int typemask, struct libssh2_knownhost **store)
-{
-    struct known_host *entry;
-    size_t hostlen = strlen(host);
-    int rc;
-    char *ptr;
-    unsigned int ptrlen;
-
-    /* make sure we have a key type set */
-    if(!(typemask & LIBSSH2_KNOWNHOST_KEY_MASK))
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL,
-                              "No key type set");
-
-    entry = LIBSSH2_CALLOC(hosts->session, sizeof(struct known_host));
-    if(!entry)
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for known host "
-                              "entry");
-
-    entry->typemask = typemask;
-
-    switch(entry->typemask  & LIBSSH2_KNOWNHOST_TYPE_MASK) {
-    case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
-    case LIBSSH2_KNOWNHOST_TYPE_CUSTOM:
-        entry->name = LIBSSH2_ALLOC(hosts->session, hostlen + 1);
-        if(!entry->name) {
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for host name");
-            goto error;
-        }
-        memcpy(entry->name, host, hostlen + 1);
-        entry->name_len = hostlen;
-        break;
-    case LIBSSH2_KNOWNHOST_TYPE_SHA1:
-        rc = libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
-                                   host, hostlen);
-        if(rc)
-            goto error;
-        entry->name = ptr;
-        entry->name_len = ptrlen;
-
-        rc = libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
-                                   salt, strlen(salt));
-        if(rc)
-            goto error;
-        entry->salt = ptr;
-        entry->salt_len = ptrlen;
-        break;
-    default:
-        rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                            "Unknown host name type");
-        goto error;
-    }
-
-    if(typemask & LIBSSH2_KNOWNHOST_KEYENC_BASE64) {
-        /* the provided key is base64 encoded already */
-        if(!keylen)
-            keylen = strlen(key);
-        entry->key = LIBSSH2_ALLOC(hosts->session, keylen + 1);
-        if(!entry->key) {
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for key");
-            goto error;
-        }
-        memcpy(entry->key, key, keylen + 1);
-        entry->key[keylen] = 0; /* force a terminating zero trailer */
-    }
-    else {
-        /* key is raw, we base64 encode it and store it as such */
-        size_t nlen = _libssh2_base64_encode(hosts->session, key, keylen,
-                                             &ptr);
-        if(!nlen) {
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for "
-                                "base64-encoded key");
-            goto error;
-        }
-
-        entry->key = ptr;
-    }
-
-    if(key_type_name && ((typemask & LIBSSH2_KNOWNHOST_KEY_MASK) ==
-                          LIBSSH2_KNOWNHOST_KEY_UNKNOWN)) {
-        entry->key_type_name = LIBSSH2_ALLOC(hosts->session, key_type_len + 1);
-        if(!entry->key_type_name) {
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for key type");
-            goto error;
-        }
-        memcpy(entry->key_type_name, key_type_name, key_type_len);
-        entry->key_type_name[key_type_len] = 0;
-        entry->key_type_len = key_type_len;
-    }
-
-    if(comment) {
-        entry->comment = LIBSSH2_ALLOC(hosts->session, commentlen + 1);
-        if(!entry->comment) {
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for comment");
-            goto error;
-        }
-        memcpy(entry->comment, comment, commentlen + 1);
-        entry->comment[commentlen] = 0; /* force a terminating zero trailer */
-        entry->comment_len = commentlen;
-    }
-    else {
-        entry->comment = NULL;
-    }
-
-    /* add this new host to the big list of known hosts */
-    _libssh2_list_add(&hosts->head, &entry->node);
-
-    if(store)
-        *store = knownhost_to_external(entry);
-
-    return LIBSSH2_ERROR_NONE;
-  error:
-    free_host(hosts->session, entry);
-    return rc;
-}
-
-/*
- * libssh2_knownhost_add
- *
- * Add a host and its associated key to the collection of known hosts.
- *
- * The 'type' argument specifies on what format the given host and keys are:
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - SHA1(<salt> <host>) base64-encoded!
- * custom - another hash
- *
- * If 'sha1' is selected as type, the salt must be provided to the salt
- * argument. This too base64 encoded.
- *
- * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.  If
- * a custom type is used, salt is ignored and you must provide the host
- * pre-hashed when checking for it in the libssh2_knownhost_check() function.
- *
- * The keylen parameter may be omitted (zero) if the key is provided as a
- * NULL-terminated base64-encoded string.
- */
-
-LIBSSH2_API int
-libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
-                      const char *host, const char *salt,
-                      const char *key, size_t keylen,
-                      int typemask, struct libssh2_knownhost **store)
-{
-    return knownhost_add(hosts, host, salt, NULL, 0, key, keylen, NULL,
-                         0, typemask, store);
-}
-
-
-/*
- * libssh2_knownhost_addc
- *
- * Add a host and its associated key to the collection of known hosts.
- *
- * Takes a comment argument that may be NULL.  A NULL comment indicates
- * there is no comment and the entry will end directly after the key
- * when written out to a file.  An empty string "" comment will indicate an
- * empty comment which will cause a single space to be written after the key.
- *
- * The 'type' argument specifies on what format the given host and keys are:
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - SHA1(<salt> <host>) base64-encoded!
- * custom - another hash
- *
- * If 'sha1' is selected as type, the salt must be provided to the salt
- * argument. This too base64 encoded.
- *
- * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files.  If
- * a custom type is used, salt is ignored and you must provide the host
- * pre-hashed when checking for it in the libssh2_knownhost_check() function.
- *
- * The keylen parameter may be omitted (zero) if the key is provided as a
- * NULL-terminated base64-encoded string.
- */
-
-LIBSSH2_API int
-libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
-                       const char *host, const char *salt,
-                       const char *key, size_t keylen,
-                       const char *comment, size_t commentlen,
-                       int typemask, struct libssh2_knownhost **store)
-{
-    return knownhost_add(hosts, host, salt, NULL, 0, key, keylen,
-                         comment, commentlen, typemask, store);
-}
-
-/*
- * knownhost_check
- *
- * Check a host and its associated key against the collection of known hosts.
- *
- * The typemask is the type/format of the given host name and key
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - NOT SUPPORTED AS INPUT
- * custom - prehashed base64 encoded. Note that this cannot use any salts.
- *
- * Returns:
- *
- * LIBSSH2_KNOWNHOST_CHECK_FAILURE
- * LIBSSH2_KNOWNHOST_CHECK_NOTFOUND
- * LIBSSH2_KNOWNHOST_CHECK_MATCH
- * LIBSSH2_KNOWNHOST_CHECK_MISMATCH
- */
-static int
-knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
-                const char *hostp, int port,
-                const char *key, size_t keylen,
-                int typemask,
-                struct libssh2_knownhost **ext)
-{
-    struct known_host *node;
-    struct known_host *badkey = NULL;
-    int type = typemask & LIBSSH2_KNOWNHOST_TYPE_MASK;
-    char *keyalloc = NULL;
-    int rc = LIBSSH2_KNOWNHOST_CHECK_NOTFOUND;
-    char hostbuff[270]; /* most host names can't be longer than like 256 */
-    const char *host;
-    int numcheck; /* number of host combos to check */
-    int match = 0;
-
-    if(type == LIBSSH2_KNOWNHOST_TYPE_SHA1)
-        /* we can't work with a sha1 as given input */
-        return LIBSSH2_KNOWNHOST_CHECK_MISMATCH;
-
-    /* if a port number is given, check for a '[host]:port' first before the
-       plain 'host' */
-    if(port >= 0) {
-        int len = snprintf(hostbuff, sizeof(hostbuff), "[%s]:%d", hostp, port);
-        if(len < 0 || len >= (int)sizeof(hostbuff)) {
-            _libssh2_error(hosts->session,
-                           LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                           "Known-host write buffer too small");
-            return LIBSSH2_KNOWNHOST_CHECK_FAILURE;
-        }
-        host = hostbuff;
-        numcheck = 2; /* check both combos, start with this */
-    }
-    else {
-        host = hostp;
-        numcheck = 1; /* only check this host version */
-    }
-
-    if(!(typemask & LIBSSH2_KNOWNHOST_KEYENC_BASE64)) {
-        /* we got a raw key input, convert it to base64 for the checks below */
-        size_t nlen = _libssh2_base64_encode(hosts->session, key, keylen,
-                                             &keyalloc);
-        if(!nlen) {
-            _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for base64-encoded "
-                           "key");
-            return LIBSSH2_KNOWNHOST_CHECK_FAILURE;
-        }
-
-        /* make the key point to this */
-        key = keyalloc;
-    }
-
-    do {
-        node = _libssh2_list_first(&hosts->head);
-        while(node) {
-            switch(node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) {
-            case LIBSSH2_KNOWNHOST_TYPE_PLAIN:
-                if(type == LIBSSH2_KNOWNHOST_TYPE_PLAIN)
-                    match = !strcmp(host, node->name);
-                break;
-            case LIBSSH2_KNOWNHOST_TYPE_CUSTOM:
-                if(type == LIBSSH2_KNOWNHOST_TYPE_CUSTOM)
-                    match = !strcmp(host, node->name);
-                break;
-            case LIBSSH2_KNOWNHOST_TYPE_SHA1:
-                if(type == LIBSSH2_KNOWNHOST_TYPE_PLAIN) {
-                    /* when we have the sha1 version stored, we can use a
-                       plain input to produce a hash to compare with the
-                       stored hash.
-                    */
-                    unsigned char hash[SHA_DIGEST_LENGTH];
-                    libssh2_hmac_ctx ctx;
-                    libssh2_hmac_ctx_init(ctx);
-
-                    if(SHA_DIGEST_LENGTH != node->name_len) {
-                        /* the name hash length must be the sha1 size or
-                           we can't match it */
-                        break;
-                    }
-                    libssh2_hmac_sha1_init(&ctx, (unsigned char *)node->salt,
-                                           node->salt_len);
-                    libssh2_hmac_update(ctx, (unsigned char *)host,
-                                        strlen(host));
-                    libssh2_hmac_final(ctx, hash);
-                    libssh2_hmac_cleanup(&ctx);
-
-                    if(!memcmp(hash, node->name, SHA_DIGEST_LENGTH))
-                        /* this is a node we're interested in */
-                        match = 1;
-                }
-                break;
-            default: /* unsupported type */
-                break;
-            }
-            if(match) {
-                int host_key_type = typemask & LIBSSH2_KNOWNHOST_KEY_MASK;
-                int known_key_type =
-                    node->typemask & LIBSSH2_KNOWNHOST_KEY_MASK;
-                /* match on key type as follows:
-                   - never match on an unknown key type
-                   - if key_type is set to zero, ignore it an match always
-                   - otherwise match when both key types are equal
-                */
-                if(host_key_type != LIBSSH2_KNOWNHOST_KEY_UNKNOWN &&
-                     (host_key_type == 0 ||
-                      host_key_type == known_key_type)) {
-                    /* host name and key type match, now compare the keys */
-                    if(!strcmp(key, node->key)) {
-                        /* they match! */
-                        if(ext)
-                            *ext = knownhost_to_external(node);
-                        badkey = NULL;
-                        rc = LIBSSH2_KNOWNHOST_CHECK_MATCH;
-                        break;
-                    }
-                    else {
-                        /* remember the first node that had a host match but a
-                           failed key match since we continue our search from
-                           here */
-                        if(!badkey)
-                            badkey = node;
-                    }
-                }
-                match = 0; /* don't count this as a match anymore */
-            }
-            node = _libssh2_list_next(&node->node);
-        }
-        host = hostp;
-    } while(!match && --numcheck);
-
-    if(badkey) {
-        /* key mismatch */
-        if(ext)
-            *ext = knownhost_to_external(badkey);
-        rc = LIBSSH2_KNOWNHOST_CHECK_MISMATCH;
-    }
-
-    if(keyalloc)
-        LIBSSH2_FREE(hosts->session, keyalloc);
-
-    return rc;
-}
-
-/*
- * libssh2_knownhost_check
- *
- * Check a host and its associated key against the collection of known hosts.
- *
- * The typemask is the type/format of the given host name and key
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - NOT SUPPORTED AS INPUT
- * custom - prehashed base64 encoded. Note that this cannot use any salts.
- *
- * Returns:
- *
- * LIBSSH2_KNOWNHOST_CHECK_FAILURE
- * LIBSSH2_KNOWNHOST_CHECK_NOTFOUND
- * LIBSSH2_KNOWNHOST_CHECK_MATCH
- * LIBSSH2_KNOWNHOST_CHECK_MISMATCH
- */
-LIBSSH2_API int
-libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
-                        const char *hostp, const char *key, size_t keylen,
-                        int typemask,
-                        struct libssh2_knownhost **ext)
-{
-    return knownhost_check(hosts, hostp, -1, key, keylen,
-                           typemask, ext);
-}
-
-/*
- * libssh2_knownhost_checkp
- *
- * Check a host+port and its associated key against the collection of known
- * hosts.
- *
- * Note that if 'port' is specified as greater than zero, the check function
- * will be able to check for a dedicated key for this particular host+port
- * combo, and if 'port' is negative it only checks for the generic host key.
- *
- * The typemask is the type/format of the given host name and key
- *
- * plain  - ascii "hostname.domain.tld"
- * sha1   - NOT SUPPORTED AS INPUT
- * custom - prehashed base64 encoded. Note that this cannot use any salts.
- *
- * Returns:
- *
- * LIBSSH2_KNOWNHOST_CHECK_FAILURE
- * LIBSSH2_KNOWNHOST_CHECK_NOTFOUND
- * LIBSSH2_KNOWNHOST_CHECK_MATCH
- * LIBSSH2_KNOWNHOST_CHECK_MISMATCH
- */
-LIBSSH2_API int
-libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
-                         const char *hostp, int port,
-                         const char *key, size_t keylen,
-                         int typemask,
-                         struct libssh2_knownhost **ext)
-{
-    return knownhost_check(hosts, hostp, port, key, keylen,
-                           typemask, ext);
-}
-
-
-/*
- * libssh2_knownhost_del
- *
- * Remove a host from the collection of known hosts.
- *
- */
-LIBSSH2_API int
-libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
-                      struct libssh2_knownhost *entry)
-{
-    struct known_host *node;
-
-    /* check that this was retrieved the right way or get out */
-    if(!entry || (entry->magic != KNOWNHOST_MAGIC))
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL,
-                              "Invalid host information");
-
-    /* get the internal node pointer */
-    node = entry->node;
-
-    /* unlink from the list of all hosts */
-    _libssh2_list_remove(&node->node);
-
-    /* clear the struct now since the memory in which it is allocated is
-       about to be freed! */
-    memset(entry, 0, sizeof(struct libssh2_knownhost));
-
-    /* free all resources */
-    free_host(hosts->session, node);
-
-    return 0;
-}
-
-/*
- * libssh2_knownhost_free
- *
- * Free an entire collection of known hosts.
- *
- */
-LIBSSH2_API void
-libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts)
-{
-    struct known_host *node;
-    struct known_host *next;
-
-    for(node = _libssh2_list_first(&hosts->head); node; node = next) {
-        next = _libssh2_list_next(&node->node);
-        free_host(hosts->session, node);
-    }
-    LIBSSH2_FREE(hosts->session, hosts);
-}
-
-
-/* old style plain text: [name]([,][name])*
-
-   for the sake of simplicity, we add them as separate hosts with the same
-   key
-*/
-static int oldstyle_hostline(LIBSSH2_KNOWNHOSTS *hosts,
-                             const char *host, size_t hostlen,
-                             const char *key_type_name, size_t key_type_len,
-                             const char *key, size_t keylen, int key_type,
-                             const char *comment, size_t commentlen)
-{
-    int rc = 0;
-    size_t namelen = 0;
-    const char *name = host + hostlen;
-
-    if(hostlen < 1)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Failed to parse known_hosts line "
-                              "(no host names)");
-
-    while(name > host) {
-        --name;
-        ++namelen;
-
-        /* when we get the the start or see a comma coming up, add the host
-           name to the collection */
-        if((name == host) || (*(name-1) == ',')) {
-
-            char hostbuf[256];
-
-            /* make sure we don't overflow the buffer */
-            if(namelen >= sizeof(hostbuf)-1)
-                return _libssh2_error(hosts->session,
-                                      LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                                      "Failed to parse known_hosts line "
-                                      "(unexpected length)");
-
-            /* copy host name to the temp buffer and zero terminate */
-            memcpy(hostbuf, name, namelen);
-            hostbuf[namelen] = 0;
-
-            rc = knownhost_add(hosts, hostbuf, NULL,
-                               key_type_name, key_type_len,
-                               key, keylen,
-                               comment, commentlen,
-                               key_type | LIBSSH2_KNOWNHOST_TYPE_PLAIN |
-                               LIBSSH2_KNOWNHOST_KEYENC_BASE64, NULL);
-            if(rc)
-                return rc;
-
-            if(name > host) {
-                namelen = 0;
-                --name; /* skip comma */
-            }
-        }
-    }
-
-    return rc;
-}
-
-/* |1|[salt]|[hash] */
-static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
-                           const char *host, size_t hostlen,
-                           const char *key_type_name, size_t key_type_len,
-                           const char *key, size_t keylen, int key_type,
-                           const char *comment, size_t commentlen)
-{
-    const char *p;
-    char saltbuf[32];
-    char hostbuf[256];
-
-    const char *salt = &host[3]; /* skip the magic marker */
-    hostlen -= 3;    /* deduct the marker */
-
-    /* this is where the salt starts, find the end of it */
-    for(p = salt; *p && (*p != '|'); p++)
-        ;
-
-    if(*p == '|') {
-        const char *hash = NULL;
-        size_t saltlen = p - salt;
-        if(saltlen >= (sizeof(saltbuf)-1)) /* weird length */
-            return _libssh2_error(hosts->session,
-                                  LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                                  "Failed to parse known_hosts line "
-                                  "(unexpectedly long salt)");
-
-        memcpy(saltbuf, salt, saltlen);
-        saltbuf[saltlen] = 0; /* zero terminate */
-        salt = saltbuf; /* point to the stack based buffer */
-
-        hash = p + 1; /* the host hash is after the separator */
-
-        /* now make the host point to the hash */
-        host = hash;
-        hostlen -= saltlen + 1; /* deduct the salt and separator */
-
-        /* check that the lengths seem sensible */
-        if(hostlen >= sizeof(hostbuf)-1)
-            return _libssh2_error(hosts->session,
-                                  LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                                  "Failed to parse known_hosts line "
-                                  "(unexpected length)");
-
-        memcpy(hostbuf, host, hostlen);
-        hostbuf[hostlen] = 0;
-
-        return knownhost_add(hosts, hostbuf, salt,
-                             key_type_name, key_type_len,
-                             key, keylen,
-                             comment, commentlen,
-                             key_type | LIBSSH2_KNOWNHOST_TYPE_SHA1 |
-                             LIBSSH2_KNOWNHOST_KEYENC_BASE64, NULL);
-    }
-    else
-        return 0; /* XXX: This should be an error, shouldn't it? */
-}
-
-/*
- * hostline()
- *
- * Parse a single known_host line pre-split into host and key.
- *
- * The key part may include an optional comment which will be parsed here
- * for ssh-rsa and ssh-dsa keys.  Comments in other key types aren't handled.
- *
- * The function assumes new-lines have already been removed from the arguments.
- */
-static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
-                    const char *host, size_t hostlen,
-                    const char *key, size_t keylen)
-{
-    const char *comment = NULL;
-    const char *key_type_name = NULL;
-    size_t commentlen = 0;
-    size_t key_type_len = 0;
-    int key_type;
-
-    /* make some checks that the lengths seem sensible */
-    if(keylen < 20)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Failed to parse known_hosts line "
-                              "(key too short)");
-
-    switch(key[0]) {
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9':
-        key_type = LIBSSH2_KNOWNHOST_KEY_RSA1;
-
-        /* Note that the old-style keys (RSA1) aren't truly base64, but we
-         * claim it is for now since we can get away with strcmp()ing the
-         * entire anything anyway! We need to check and fix these to make them
-         * work properly.
-         */
-        break;
-
-    default:
-        key_type_name = key;
-        while(keylen && *key &&
-               (*key != ' ') && (*key != '\t')) {
-            key++;
-            keylen--;
-        }
-        key_type_len = key - key_type_name;
-
-        if(!strncmp(key_type_name, "ssh-dss", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
-        else if(!strncmp(key_type_name, "ssh-rsa", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
-        else if(!strncmp(key_type_name, "ecdsa-sha2-nistp256", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
-        else if(!strncmp(key_type_name, "ecdsa-sha2-nistp384", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
-        else if(!strncmp(key_type_name, "ecdsa-sha2-nistp521", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
-        else if(!strncmp(key_type_name, "ssh-ed25519", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_ED25519;
-        else
-            key_type = LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
-
-        /* skip whitespaces */
-        while((*key ==' ') || (*key == '\t')) {
-            key++;
-            keylen--;
-        }
-
-        comment = key;
-        commentlen = keylen;
-
-        /* move over key */
-        while(commentlen && *comment &&
-              (*comment != ' ') && (*comment != '\t')) {
-            comment++;
-            commentlen--;
-        }
-
-        /* reduce key by comment length */
-        keylen -= commentlen;
-
-        /* Distinguish empty comment (a space) from no comment (no space) */
-        if(commentlen == 0)
-            comment = NULL;
-
-        /* skip whitespaces */
-        while(commentlen && *comment &&
-              ((*comment ==' ') || (*comment == '\t'))) {
-            comment++;
-            commentlen--;
-        }
-        break;
-    }
-
-    /* Figure out host format */
-    if((hostlen >2) && memcmp(host, "|1|", 3)) {
-        /* old style plain text: [name]([,][name])*
-
-           for the sake of simplicity, we add them as separate hosts with the
-           same key
-        */
-        return oldstyle_hostline(hosts, host, hostlen, key_type_name,
-                                 key_type_len, key, keylen, key_type,
-                                 comment, commentlen);
-    }
-    else {
-        /* |1|[salt]|[hash] */
-        return hashed_hostline(hosts, host, hostlen, key_type_name,
-                               key_type_len, key, keylen, key_type,
-                               comment, commentlen);
-    }
-}
-
-/*
- * libssh2_knownhost_readline()
- *
- * Pass in a line of a file of 'type'.
- *
- * LIBSSH2_KNOWNHOST_FILE_OPENSSH is the only supported type.
- *
- * OpenSSH line format:
- *
- * <host> <key>
- *
- * Where the two parts can be created like:
- *
- * <host> can be either
- * <name> or <hash>
- *
- * <name> consists of
- * [name] optionally followed by [,name] one or more times
- *
- * <hash> consists of
- * |1|<salt>|hash
- *
- * <key> can be one of:
- * [RSA bits] [e] [n as a decimal number]
- * 'ssh-dss' [base64-encoded-key]
- * 'ssh-rsa' [base64-encoded-key]
- *
- */
-LIBSSH2_API int
-libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
-                           const char *line, size_t len, int type)
-{
-    const char *cp;
-    const char *hostp;
-    const char *keyp;
-    size_t hostlen;
-    size_t keylen;
-    int rc;
-
-    if(type != LIBSSH2_KNOWNHOST_FILE_OPENSSH)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unsupported type of known-host information "
-                              "store");
-
-    cp = line;
-
-    /* skip leading whitespaces */
-    while(len && ((*cp == ' ') || (*cp == '\t'))) {
-        cp++;
-        len--;
-    }
-
-    if(!len || !*cp || (*cp == '#') || (*cp == '\n'))
-        /* comment or empty line */
-        return LIBSSH2_ERROR_NONE;
-
-    /* the host part starts here */
-    hostp = cp;
-
-    /* move over the host to the separator */
-    while(len && *cp && (*cp != ' ') && (*cp != '\t')) {
-        cp++;
-        len--;
-    }
-
-    hostlen = cp - hostp;
-
-    /* the key starts after the whitespaces */
-    while(len && *cp && ((*cp == ' ') || (*cp == '\t'))) {
-        cp++;
-        len--;
-    }
-
-    if(!*cp || !len) /* illegal line */
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Failed to parse known_hosts line");
-
-    keyp = cp; /* the key starts here */
-    keylen = len;
-
-    /* check if the line (key) ends with a newline and if so kill it */
-    while(len && *cp && (*cp != '\n')) {
-        cp++;
-        len--;
-    }
-
-    /* zero terminate where the newline is */
-    if(*cp == '\n')
-        keylen--; /* don't include this in the count */
-
-    /* deal with this one host+key line */
-    rc = hostline(hosts, hostp, hostlen, keyp, keylen);
-    if(rc)
-        return rc; /* failed */
-
-    return LIBSSH2_ERROR_NONE; /* success */
-}
-
-/*
- * libssh2_knownhost_readfile
- *
- * Read hosts+key pairs from a given file.
- *
- * Returns a negative value for error or number of successfully added hosts.
- *
- */
-
-LIBSSH2_API int
-libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
-                           const char *filename, int type)
-{
-    FILE *file;
-    int num = 0;
-    char buf[4092];
-
-    if(type != LIBSSH2_KNOWNHOST_FILE_OPENSSH)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unsupported type of known-host information "
-                              "store");
-
-    file = fopen(filename, FOPEN_READTEXT);
-    if(file) {
-        while(fgets(buf, sizeof(buf), file)) {
-            if(libssh2_knownhost_readline(hosts, buf, strlen(buf), type)) {
-                num = _libssh2_error(hosts->session, LIBSSH2_ERROR_KNOWN_HOSTS,
-                                     "Failed to parse known hosts file");
-                break;
-            }
-            num++;
-        }
-        fclose(file);
-    }
-    else
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_FILE,
-                              "Failed to open file");
-
-    return num;
-}
-
-/*
- * knownhost_writeline()
- *
- * Ask libssh2 to convert a known host to an output line for storage.
- *
- * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the given
- * output buffer is too small to hold the desired output. The 'outlen' field
- * will then contain the size libssh2 wanted to store, which then is the
- * smallest sufficient buffer it would require.
- *
- */
-static int
-knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
-                    struct known_host *node,
-                    char *buf, size_t buflen,
-                    size_t *outlen, int type)
-{
-    size_t required_size;
-
-    const char *key_type_name;
-    size_t key_type_len;
-
-    /* we only support this single file type for now, bail out on all other
-       attempts */
-    if(type != LIBSSH2_KNOWNHOST_FILE_OPENSSH)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unsupported type of known-host information "
-                              "store");
-
-    switch(node->typemask & LIBSSH2_KNOWNHOST_KEY_MASK) {
-    case LIBSSH2_KNOWNHOST_KEY_RSA1:
-        key_type_name = NULL;
-        key_type_len = 0;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_SSHRSA:
-        key_type_name = "ssh-rsa";
-        key_type_len = 7;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_SSHDSS:
-        key_type_name = "ssh-dss";
-        key_type_len = 7;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_ECDSA_256:
-        key_type_name = "ecdsa-sha2-nistp256";
-        key_type_len = 19;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_ECDSA_384:
-        key_type_name = "ecdsa-sha2-nistp384";
-        key_type_len = 19;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_ECDSA_521:
-        key_type_name = "ecdsa-sha2-nistp521";
-        key_type_len = 19;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_ED25519:
-        key_type_name = "ssh-ed25519";
-        key_type_len = 11;
-        break;
-    case LIBSSH2_KNOWNHOST_KEY_UNKNOWN:
-        key_type_name = node->key_type_name;
-        if(key_type_name) {
-            key_type_len = node->key_type_len;
-            break;
-        }
-        /* otherwise fallback to default and error */
-        /* FALL-THROUGH */
-    default:
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unsupported type of known-host entry");
-    }
-
-    /* When putting together the host line there are three aspects to consider:
-       - Hashed (SHA1) or unhashed hostname
-       - key name or no key name (RSA1)
-       - comment or no comment
-
-       This means there are 2^3 different formats:
-       ("|1|%s|%s %s %s %s\n", salt, hashed_host, key_name, key, comment)
-       ("|1|%s|%s %s %s\n", salt, hashed_host, key_name, key)
-       ("|1|%s|%s %s %s\n", salt, hashed_host, key, comment)
-       ("|1|%s|%s %s\n", salt, hashed_host, key)
-       ("%s %s %s %s\n", host, key_name, key, comment)
-       ("%s %s %s\n", host, key_name, key)
-       ("%s %s %s\n", host, key, comment)
-       ("%s %s\n", host, key)
-
-       Even if the buffer is too small, we have to set outlen to the number of
-       characters the complete line would have taken.  We also don't write
-       anything to the buffer unless we are sure we can write everything to the
-       buffer. */
-
-    required_size = strlen(node->key);
-
-    if(key_type_len)
-        required_size += key_type_len + 1; /* ' ' = 1 */
-    if(node->comment)
-        required_size += node->comment_len + 1; /* ' ' = 1 */
-
-    if((node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) ==
-       LIBSSH2_KNOWNHOST_TYPE_SHA1) {
-        char *namealloc;
-        size_t name_base64_len;
-        char *saltalloc;
-        size_t salt_base64_len;
-
-        name_base64_len = _libssh2_base64_encode(hosts->session, node->name,
-                                                 node->name_len, &namealloc);
-        if(!name_base64_len)
-            return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "base64-encoded host name");
-
-        salt_base64_len = _libssh2_base64_encode(hosts->session,
-                                                 node->salt, node->salt_len,
-                                                 &saltalloc);
-        if(!salt_base64_len) {
-            LIBSSH2_FREE(hosts->session, namealloc);
-            return _libssh2_error(hosts->session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "base64-encoded salt");
-        }
-
-        required_size += salt_base64_len + name_base64_len + 7;
-        /* |1| + | + ' ' + \n + \0 = 7 */
-
-        if(required_size <= buflen) {
-            if(node->comment && key_type_len)
-                snprintf(buf, buflen, "|1|%s|%s %s %s %s\n", saltalloc,
-                         namealloc, key_type_name, node->key, node->comment);
-            else if(node->comment)
-                snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
-                         node->key, node->comment);
-            else if(key_type_len)
-                snprintf(buf, buflen, "|1|%s|%s %s %s\n", saltalloc, namealloc,
-                         key_type_name, node->key);
-            else
-                snprintf(buf, buflen, "|1|%s|%s %s\n", saltalloc, namealloc,
-                         node->key);
-        }
-
-        LIBSSH2_FREE(hosts->session, namealloc);
-        LIBSSH2_FREE(hosts->session, saltalloc);
-    }
-    else {
-        required_size += node->name_len + 3;
-        /* ' ' + '\n' + \0 = 3 */
-
-        if(required_size <= buflen) {
-            if(node->comment && key_type_len)
-                snprintf(buf, buflen, "%s %s %s %s\n", node->name,
-                         key_type_name, node->key, node->comment);
-            else if(node->comment)
-                snprintf(buf, buflen, "%s %s %s\n", node->name, node->key,
-                         node->comment);
-            else if(key_type_len)
-                snprintf(buf, buflen, "%s %s %s\n", node->name, key_type_name,
-                         node->key);
-            else
-                snprintf(buf, buflen, "%s %s\n", node->name, node->key);
-        }
-    }
-
-    /* we report the full length of the data with the trailing zero excluded */
-    *outlen = required_size-1;
-
-    if(required_size <= buflen)
-        return LIBSSH2_ERROR_NONE;
-    else
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                              "Known-host write buffer too small");
-}
-
-/*
- * libssh2_knownhost_writeline()
- *
- * Ask libssh2 to convert a known host to an output line for storage.
- *
- * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the given
- * output buffer is too small to hold the desired output.
- */
-LIBSSH2_API int
-libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
-                            struct libssh2_knownhost *known,
-                            char *buffer, size_t buflen,
-                            size_t *outlen, /* the amount of written data */
-                            int type)
-{
-    struct known_host *node;
-
-    if(known->magic != KNOWNHOST_MAGIC)
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_INVAL,
-                              "Invalid host information");
-
-    node = known->node;
-
-    return knownhost_writeline(hosts, node, buffer, buflen, outlen, type);
-}
-
-/*
- * libssh2_knownhost_writefile()
- *
- * Write hosts+key pairs to the given file.
- */
-LIBSSH2_API int
-libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
-                            const char *filename, int type)
-{
-    struct known_host *node;
-    FILE *file;
-    int rc = LIBSSH2_ERROR_NONE;
-    char buffer[4092];
-
-    /* we only support this single file type for now, bail out on all other
-       attempts */
-    if(type != LIBSSH2_KNOWNHOST_FILE_OPENSSH)
-        return _libssh2_error(hosts->session,
-                              LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                              "Unsupported type of known-host information "
-                              "store");
-
-    file = fopen(filename, FOPEN_WRITETEXT);
-    if(!file)
-        return _libssh2_error(hosts->session, LIBSSH2_ERROR_FILE,
-                              "Failed to open file");
-
-    for(node = _libssh2_list_first(&hosts->head);
-        node;
-        node = _libssh2_list_next(&node->node)) {
-        size_t wrote = 0;
-        size_t nwrote;
-        rc = knownhost_writeline(hosts, node, buffer, sizeof(buffer), &wrote,
-                                 type);
-        if(rc)
-            break;
-
-        nwrote = fwrite(buffer, 1, wrote, file);
-        if(nwrote != wrote) {
-            /* failed to write the whole thing, bail out */
-            rc = _libssh2_error(hosts->session, LIBSSH2_ERROR_FILE,
-                                "Write failed");
-            break;
-        }
-    }
-    fclose(file);
-
-    return rc;
-}
-
-
-/*
- * libssh2_knownhost_get()
- *
- * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
- * the first one.
- *
- * Returns:
- * 0 if a fine host was stored in 'store'
- * 1 if end of hosts
- * [negative] on errors
- */
-LIBSSH2_API int
-libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
-                      struct libssh2_knownhost **ext,
-                      struct libssh2_knownhost *oprev)
-{
-    struct known_host *node;
-    if(oprev && oprev->node) {
-        /* we have a starting point */
-        struct known_host *prev = oprev->node;
-
-        /* get the next node in the list */
-        node = _libssh2_list_next(&prev->node);
-
-    }
-    else
-        node = _libssh2_list_first(&hosts->head);
-
-    if(!node)
-        /* no (more) node */
-        return 1;
-
-    *ext = knownhost_to_external(node);
-
-    return 0;
-}
diff --git a/libssh2/libssh2/src/libgcrypt.c b/libssh2/libssh2/src/libgcrypt.c
deleted file mode 100644
index 0aff176a..00000000
--- a/libssh2/libssh2/src/libgcrypt.c
+++ /dev/null
@@ -1,667 +0,0 @@
-/* Copyright (C) 2008, 2009, Simon Josefsson
- * Copyright (C) 2006, 2007, The Written Word, Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms,
- * with or without modification, are permitted provided
- * that the following conditions are met:
- *
- *   Redistributions of source code must retain the above
- *   copyright notice, this list of conditions and the
- *   following disclaimer.
- *
- *   Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following
- *   disclaimer in the documentation and/or other materials
- *   provided with the distribution.
- *
- *   Neither the name of the copyright holder nor the names
- *   of any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_LIBGCRYPT /* compile only if we build with libgcrypt */
-
-#include <string.h>
-
-int
-_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
-                 const unsigned char *edata,
-                 unsigned long elen,
-                 const unsigned char *ndata,
-                 unsigned long nlen,
-                 const unsigned char *ddata,
-                 unsigned long dlen,
-                 const unsigned char *pdata,
-                 unsigned long plen,
-                 const unsigned char *qdata,
-                 unsigned long qlen,
-                 const unsigned char *e1data,
-                 unsigned long e1len,
-                 const unsigned char *e2data,
-                 unsigned long e2len,
-                 const unsigned char *coeffdata, unsigned long coefflen)
-{
-    int rc;
-    (void) e1data;
-    (void) e1len;
-    (void) e2data;
-    (void) e2len;
-
-    if(ddata) {
-        rc = gcry_sexp_build
-            (rsa, NULL,
-             "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
-             nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
-             qlen, qdata, coefflen, coeffdata);
-    }
-    else {
-        rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
-                             nlen, ndata, elen, edata);
-    }
-    if(rc) {
-        *rsa = NULL;
-        return -1;
-    }
-
-    return 0;
-}
-
-int
-_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
-                         const unsigned char *sig,
-                         unsigned long sig_len,
-                         const unsigned char *m, unsigned long m_len)
-{
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    gcry_sexp_t s_sig, s_hash;
-    int rc = -1;
-
-    libssh2_sha1(m, m_len, hash);
-
-    rc = gcry_sexp_build(&s_hash, NULL,
-                         "(data (flags pkcs1) (hash sha1 %b))",
-                         SHA_DIGEST_LENGTH, hash);
-    if(rc != 0) {
-        return -1;
-    }
-
-    rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig);
-    if(rc != 0) {
-        gcry_sexp_release(s_hash);
-        return -1;
-    }
-
-    rc = gcry_pk_verify(s_sig, s_hash, rsa);
-    gcry_sexp_release(s_sig);
-    gcry_sexp_release(s_hash);
-
-    return (rc == 0) ? 0 : -1;
-}
-
-int
-_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
-                 const unsigned char *p,
-                 unsigned long p_len,
-                 const unsigned char *q,
-                 unsigned long q_len,
-                 const unsigned char *g,
-                 unsigned long g_len,
-                 const unsigned char *y,
-                 unsigned long y_len,
-                 const unsigned char *x, unsigned long x_len)
-{
-    int rc;
-
-    if(x_len) {
-        rc = gcry_sexp_build
-            (dsactx, NULL,
-             "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
-             p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
-    }
-    else {
-        rc = gcry_sexp_build(dsactx, NULL,
-                             "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
-                             p_len, p, q_len, q, g_len, g, y_len, y);
-    }
-
-    if(rc) {
-        *dsactx = NULL;
-        return -1;
-    }
-
-    return 0;
-}
-
-int
-_libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
-{
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                         "Unable to extract private key from memory: "
-                         "Method unimplemented in libgcrypt backend");
-}
-
-int
-_libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
-                         LIBSSH2_SESSION * session,
-                         const char *filename, unsigned const char *passphrase)
-{
-    FILE *fp;
-    unsigned char *data, *save_data;
-    unsigned int datalen;
-    int ret;
-    unsigned char *n, *e, *d, *p, *q, *e1, *e2, *coeff;
-    unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;
-
-    fp = fopen(filename, FOPEN_READTEXT);
-    if(!fp) {
-        return -1;
-    }
-
-    ret = _libssh2_pem_parse(session,
-                             "-----BEGIN RSA PRIVATE KEY-----",
-                             "-----END RSA PRIVATE KEY-----",
-                             passphrase,
-                             fp, &data, &datalen);
-    fclose(fp);
-    if(ret) {
-        return -1;
-    }
-
-    save_data = data;
-
-    if(_libssh2_pem_decode_sequence(&data, &datalen)) {
-        ret = -1;
-        goto fail;
-    }
-/* First read Version field (should be 0). */
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if(ret != 0 || (nlen != 1 && *n != '\0')) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    if(_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
-                         q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = 0;
-
-  fail:
-    LIBSSH2_FREE(session, save_data);
-    return ret;
-}
-
-int
-_libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
-{
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                         "Unable to extract private key from memory: "
-                         "Method unimplemented in libgcrypt backend");
-}
-
-int
-_libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
-                         LIBSSH2_SESSION * session,
-                         const char *filename, unsigned const char *passphrase)
-{
-    FILE *fp;
-    unsigned char *data, *save_data;
-    unsigned int datalen;
-    int ret;
-    unsigned char *p, *q, *g, *y, *x;
-    unsigned int plen, qlen, glen, ylen, xlen;
-
-    fp = fopen(filename, FOPEN_READTEXT);
-    if(!fp) {
-        return -1;
-    }
-
-    ret = _libssh2_pem_parse(session,
-                             "-----BEGIN DSA PRIVATE KEY-----",
-                             "-----END DSA PRIVATE KEY-----",
-                             passphrase,
-                             fp, &data, &datalen);
-    fclose(fp);
-    if(ret) {
-        return -1;
-    }
-
-    save_data = data;
-
-    if(_libssh2_pem_decode_sequence(&data, &datalen)) {
-        ret = -1;
-        goto fail;
-    }
-
-/* First read Version field (should be 0). */
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0 || (plen != 1 && *p != '\0')) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen);
-    if(ret != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    if(datalen != 0) {
-        ret = -1;
-        goto fail;
-    }
-
-    if(_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) {
-        ret = -1;
-        goto fail;
-    }
-
-    ret = 0;
-
-  fail:
-    LIBSSH2_FREE(session, save_data);
-    return ret;
-}
-
-int
-_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
-                       libssh2_rsa_ctx * rsactx,
-                       const unsigned char *hash,
-                       size_t hash_len,
-                       unsigned char **signature, size_t *signature_len)
-{
-    gcry_sexp_t sig_sexp;
-    gcry_sexp_t data;
-    int rc;
-    const char *tmp;
-    size_t size;
-
-    if(hash_len != SHA_DIGEST_LENGTH) {
-        return -1;
-    }
-
-    if(gcry_sexp_build(&data, NULL,
-                        "(data (flags pkcs1) (hash sha1 %b))",
-                        hash_len, hash)) {
-        return -1;
-    }
-
-    rc = gcry_pk_sign(&sig_sexp, data, rsactx);
-
-    gcry_sexp_release(data);
-
-    if(rc != 0) {
-        return -1;
-    }
-
-    data = gcry_sexp_find_token(sig_sexp, "s", 0);
-    if(!data) {
-        return -1;
-    }
-
-    tmp = gcry_sexp_nth_data(data, 1, &size);
-    if(!tmp) {
-        gcry_sexp_release(data);
-        return -1;
-    }
-
-    if(tmp[0] == '\0') {
-        tmp++;
-        size--;
-    }
-
-    *signature = LIBSSH2_ALLOC(session, size);
-    if(!*signature) {
-        gcry_sexp_release(data);
-        return -1;
-    }
-    memcpy(*signature, tmp, size);
-    *signature_len = size;
-
-    gcry_sexp_release(data);
-
-    return rc;
-}
-
-int
-_libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
-                       const unsigned char *hash,
-                       unsigned long hash_len, unsigned char *sig)
-{
-    unsigned char zhash[SHA_DIGEST_LENGTH + 1];
-    gcry_sexp_t sig_sexp;
-    gcry_sexp_t data;
-    int ret;
-    const char *tmp;
-    size_t size;
-
-    if(hash_len != SHA_DIGEST_LENGTH) {
-        return -1;
-    }
-
-    memcpy(zhash + 1, hash, hash_len);
-    zhash[0] = 0;
-
-    if(gcry_sexp_build(&data, NULL, "(data (value %b))",
-                       hash_len + 1, zhash)) {
-        return -1;
-    }
-
-    ret = gcry_pk_sign(&sig_sexp, data, dsactx);
-
-    gcry_sexp_release(data);
-
-    if(ret != 0) {
-        return -1;
-    }
-
-    memset(sig, 0, 40);
-
-/* Extract R. */
-
-    data = gcry_sexp_find_token(sig_sexp, "r", 0);
-    if(!data)
-        goto err;
-
-    tmp = gcry_sexp_nth_data(data, 1, &size);
-    if(!tmp)
-        goto err;
-
-    if(tmp[0] == '\0') {
-        tmp++;
-        size--;
-    }
-
-    if(size < 1 || size > 20)
-        goto err;
-
-    memcpy(sig + (20 - size), tmp, size);
-
-    gcry_sexp_release(data);
-
-/* Extract S. */
-
-    data = gcry_sexp_find_token(sig_sexp, "s", 0);
-    if(!data)
-        goto err;
-
-    tmp = gcry_sexp_nth_data(data, 1, &size);
-    if(!tmp)
-        goto err;
-
-    if(tmp[0] == '\0') {
-        tmp++;
-        size--;
-    }
-
-    if(size < 1 || size > 20)
-        goto err;
-
-    memcpy(sig + 20 + (20 - size), tmp, size);
-    goto out;
-
-  err:
-    ret = -1;
-
-  out:
-    if(sig_sexp) {
-        gcry_sexp_release(sig_sexp);
-    }
-    if(data) {
-        gcry_sexp_release(data);
-    }
-    return ret;
-}
-
-int
-_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
-                         const unsigned char *sig,
-                         const unsigned char *m, unsigned long m_len)
-{
-    unsigned char hash[SHA_DIGEST_LENGTH + 1];
-    gcry_sexp_t s_sig, s_hash;
-    int rc = -1;
-
-    libssh2_sha1(m, m_len, hash + 1);
-    hash[0] = 0;
-
-    if(gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
-                        SHA_DIGEST_LENGTH + 1, hash)) {
-        return -1;
-    }
-
-    if(gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
-                        20, sig, 20, sig + 20)) {
-        gcry_sexp_release(s_hash);
-        return -1;
-    }
-
-    rc = gcry_pk_verify(s_sig, s_hash, dsactx);
-    gcry_sexp_release(s_sig);
-    gcry_sexp_release(s_hash);
-
-    return (rc == 0) ? 0 : -1;
-}
-
-int
-_libssh2_cipher_init(_libssh2_cipher_ctx * h,
-                     _libssh2_cipher_type(algo),
-                     unsigned char *iv, unsigned char *secret, int encrypt)
-{
-    int ret;
-    int cipher = _libssh2_gcry_cipher(algo);
-    int mode = _libssh2_gcry_mode(algo);
-    int keylen = gcry_cipher_get_algo_keylen(cipher);
-
-    (void) encrypt;
-
-    ret = gcry_cipher_open(h, cipher, mode, 0);
-    if(ret) {
-        return -1;
-    }
-
-    ret = gcry_cipher_setkey(*h, secret, keylen);
-    if(ret) {
-        gcry_cipher_close(*h);
-        return -1;
-    }
-
-    if(mode != GCRY_CIPHER_MODE_STREAM) {
-        int blklen = gcry_cipher_get_algo_blklen(cipher);
-        if(mode == GCRY_CIPHER_MODE_CTR)
-            ret = gcry_cipher_setctr(*h, iv, blklen);
-        else
-            ret = gcry_cipher_setiv(*h, iv, blklen);
-        if(ret) {
-            gcry_cipher_close(*h);
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-int
-_libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
-                      _libssh2_cipher_type(algo),
-                      int encrypt, unsigned char *block, size_t blklen)
-{
-    int cipher = _libssh2_gcry_cipher(algo);
-    int ret;
-
-    if(encrypt) {
-        ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen);
-    }
-    else {
-        ret = gcry_cipher_decrypt(*ctx, block, blklen, block, blklen);
-    }
-    return ret;
-}
-
-int
-_libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                unsigned char **method,
-                                size_t *method_len,
-                                unsigned char **pubkeydata,
-                                size_t *pubkeydata_len,
-                                const char *privatekeydata,
-                                size_t privatekeydata_len,
-                                const char *passphrase)
-{
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                          "Unable to extract public key from private "
-                          "key in memory: "
-                          "Method unimplemented in libgcrypt backend");
-}
-
-int
-_libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                          unsigned char **method,
-                          size_t *method_len,
-                          unsigned char **pubkeydata,
-                          size_t *pubkeydata_len,
-                          const char *privatekey,
-                          const char *passphrase)
-{
-    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                         "Unable to extract public key from private key file: "
-                         "Method unimplemented in libgcrypt backend");
-}
-
-void _libssh2_init_aes_ctr(void)
-{
-    /* no implementation */
-}
-
-void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx)
-{
-    *dhctx = gcry_mpi_new(0);                   /* Random from client */
-}
-
-int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                     _libssh2_bn *g, _libssh2_bn *p, int group_order)
-{
-    /* Generate x and e */
-    gcry_mpi_randomize(*dhctx, group_order * 8 - 1, GCRY_WEAK_RANDOM);
-    gcry_mpi_powm(public, g, *dhctx, p);
-    return 0;
-}
-
-int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                   _libssh2_bn *f, _libssh2_bn *p)
-{
-    /* Compute the shared secret */
-    gcry_mpi_powm(secret, f, *dhctx, p);
-    return 0;
-}
-
-void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
-{
-    gcry_mpi_release(*dhctx);
-    *dhctx = NULL;
-}
-
-#endif /* LIBSSH2_LIBGCRYPT */
diff --git a/libssh2/libssh2/src/libgcrypt.h b/libssh2/libssh2/src/libgcrypt.h
deleted file mode 100644
index 298c65ed..00000000
--- a/libssh2/libssh2/src/libgcrypt.h
+++ /dev/null
@@ -1,237 +0,0 @@
-#ifndef __LIBSSH2_LIBGCRYPT_H
-#define __LIBSSH2_LIBGCRYPT_H
-/*
- * Copyright (C) 2008, 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007, The Written Word, Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms,
- * with or without modification, are permitted provided
- * that the following conditions are met:
- *
- *   Redistributions of source code must retain the above
- *   copyright notice, this list of conditions and the
- *   following disclaimer.
- *
- *   Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following
- *   disclaimer in the documentation and/or other materials
- *   provided with the distribution.
- *
- *   Neither the name of the copyright holder nor the names
- *   of any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include <gcrypt.h>
-
-#define LIBSSH2_MD5 1
-
-#define LIBSSH2_HMAC_RIPEMD 1
-#define LIBSSH2_HMAC_SHA256 1
-#define LIBSSH2_HMAC_SHA512 1
-
-#define LIBSSH2_AES 1
-#define LIBSSH2_AES_CTR 1
-#define LIBSSH2_BLOWFISH 1
-#define LIBSSH2_RC4 1
-#define LIBSSH2_CAST 1
-#define LIBSSH2_3DES 1
-
-#define LIBSSH2_RSA 1
-#define LIBSSH2_DSA 1
-#define LIBSSH2_ECDSA 0
-#define LIBSSH2_ED25519 0
-
-#define MD5_DIGEST_LENGTH 16
-#define SHA_DIGEST_LENGTH 20
-#define SHA256_DIGEST_LENGTH 32
-#define SHA384_DIGEST_LENGTH 48
-#define SHA512_DIGEST_LENGTH 64
-
-#define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
-
-#define _libssh2_random(buf, len)                \
-  (gcry_randomize ((buf), (len), GCRY_STRONG_RANDOM), 0)
-
-#define libssh2_prepare_iovec(vec, len)  /* Empty. */
-
-#define libssh2_sha1_ctx gcry_md_hd_t
-
-/* returns 0 in case of failure */
-#define libssh2_sha1_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA1, 0))
-#define libssh2_sha1_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
-#define libssh2_sha1_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_sha1(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA1, out, message, len)
-
-#define libssh2_sha256_ctx gcry_md_hd_t
-
-#define libssh2_sha256_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA256, 0))
-#define libssh2_sha256_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
-#define libssh2_sha256_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_sha256(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA256, out, message, len)
-
-#define libssh2_sha384_ctx gcry_md_hd_t
-
-#define libssh2_sha384_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA384, 0))
-#define libssh2_sha384_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
-#define libssh2_sha384_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_sha384(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA384, out, message, len)
-
-#define libssh2_sha512_ctx gcry_md_hd_t
-
-#define libssh2_sha512_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA512, 0))
-#define libssh2_sha512_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
-#define libssh2_sha512_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_sha512(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA512, out, message, len)
-
-#define libssh2_md5_ctx gcry_md_hd_t
-
-/* returns 0 in case of failure */
-#define libssh2_md5_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_MD5, 0))
-
-#define libssh2_md5_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
-#define libssh2_md5_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_md5(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_MD5, out, message, len)
-
-#define libssh2_hmac_ctx gcry_md_hd_t
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  gcry_md_write(ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, data) \
-  memcpy(data, gcry_md_read(ctx, 0), \
-      gcry_md_get_algo_dlen(gcry_md_get_algo(ctx)))
-#define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx);
-
-#define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM)
-#define libssh2_crypto_exit()
-
-#define libssh2_rsa_ctx struct gcry_sexp
-
-#define _libssh2_rsa_free(rsactx)  gcry_sexp_release (rsactx)
-
-#define libssh2_dsa_ctx struct gcry_sexp
-
-#define _libssh2_dsa_free(dsactx)  gcry_sexp_release (dsactx)
-
-#if LIBSSH2_ECDSA
-#else
-#define _libssh2_ec_key void
-#endif
-
-#define _libssh2_cipher_type(name) int name
-#define _libssh2_cipher_ctx gcry_cipher_hd_t
-
-#define _libssh2_gcry_ciphermode(c,m) ((c << 8) | m)
-#define _libssh2_gcry_cipher(c) (c >> 8)
-#define _libssh2_gcry_mode(m) (m & 0xFF)
-
-#define _libssh2_cipher_aes256ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR)
-#define _libssh2_cipher_aes192ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR)
-#define _libssh2_cipher_aes128ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR)
-#define _libssh2_cipher_aes256 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC)
-#define _libssh2_cipher_aes192 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC)
-#define _libssh2_cipher_aes128 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC)
-#define _libssh2_cipher_blowfish \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC)
-#define _libssh2_cipher_arcfour \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM)
-#define _libssh2_cipher_cast5 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC)
-#define _libssh2_cipher_3des \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC)
-
-
-#define _libssh2_cipher_dtor(ctx) gcry_cipher_close(*(ctx))
-
-#define _libssh2_bn struct gcry_mpi
-#define _libssh2_bn_ctx int
-#define _libssh2_bn_ctx_new() 0
-#define _libssh2_bn_ctx_free(bnctx) ((void)0)
-#define _libssh2_bn_init() gcry_mpi_new(0)
-#define _libssh2_bn_init_from_bin() NULL /* because gcry_mpi_scan() creates a
-                                            new bignum */
-#define _libssh2_bn_set_word(bn, val) gcry_mpi_set_ui(bn, val)
-#define _libssh2_bn_from_bin(bn, len, val)                      \
-    gcry_mpi_scan(&((bn)), GCRYMPI_FMT_USG, val, len, NULL)
-#define _libssh2_bn_to_bin(bn, val)                                     \
-    gcry_mpi_print(GCRYMPI_FMT_USG, val, _libssh2_bn_bytes(bn), NULL, bn)
-#define _libssh2_bn_bytes(bn)                                           \
-    (gcry_mpi_get_nbits (bn) / 8 +                                      \
-     ((gcry_mpi_get_nbits (bn) % 8 == 0) ? 0 : 1))
-#define _libssh2_bn_bits(bn) gcry_mpi_get_nbits (bn)
-#define _libssh2_bn_free(bn) gcry_mpi_release(bn)
-
-#define _libssh2_dh_ctx struct gcry_mpi *
-#define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
-#define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
-#define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
-#define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
-extern void _libssh2_dh_init(_libssh2_dh_ctx *dhctx);
-extern int _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                                _libssh2_bn *g, _libssh2_bn *p,
-                                int group_order);
-extern int _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                              _libssh2_bn *f, _libssh2_bn *p);
-extern void _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
-
-#endif /* __LIBSSH2_LIBGCRYPT_H */
diff --git a/libssh2/libssh2/src/libssh2.pc.in b/libssh2/libssh2/src/libssh2.pc.in
deleted file mode 100644
index c070988b..00000000
--- a/libssh2/libssh2/src/libssh2.pc.in
+++ /dev/null
@@ -1,17 +0,0 @@
-###########################################################################
-# libssh2 installation details
-###########################################################################
-
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
-includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
-
-Name: @PROJECT_NAME@
-URL: @PROJECT_URL@
-Description: @PROJECT_DESCRIPTION@
-Version: @LIBSSH2_VERSION@
-Requires.private: @PC_REQUIRES_PRIVATE@
-Libs: -L${libdir} -lssh2 @PC_LIBS@
-Libs.private: @PC_LIBS@
-Cflags: -I${includedir}
\ No newline at end of file
diff --git a/libssh2/libssh2/src/libssh2_config_cmake.h.in b/libssh2/libssh2/src/libssh2_config_cmake.h.in
deleted file mode 100644
index 62723ede..00000000
--- a/libssh2/libssh2/src/libssh2_config_cmake.h.in
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- * Copyright (c) 1999-2011 Douglas Gilbert. 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#cmakedefine HAVE_UNISTD_H
-#cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_STDLIB_H
-#cmakedefine HAVE_SYS_SELECT_H
-#cmakedefine HAVE_SYS_UIO_H
-#cmakedefine HAVE_SYS_SOCKET_H
-#cmakedefine HAVE_SYS_IOCTL_H
-#cmakedefine HAVE_SYS_TIME_H
-#cmakedefine HAVE_SYS_UN_H
-#cmakedefine HAVE_WINDOWS_H
-#cmakedefine HAVE_WS2TCPIP_H
-#cmakedefine HAVE_WINSOCK2_H
-#cmakedefine HAVE_NTDEF_H
-#cmakedefine HAVE_NTSTATUS_H
-
-/* Libraries */
-#cmakedefine HAVE_LIBCRYPT32
-
-/* Types */
-#cmakedefine HAVE_LONGLONG
-
-/* Functions */
-#cmakedefine HAVE_GETTIMEOFDAY
-#cmakedefine HAVE_INET_ADDR
-#cmakedefine HAVE_POLL
-#cmakedefine HAVE_SELECT
-#cmakedefine HAVE_SOCKET
-#cmakedefine HAVE_STRTOLL
-#cmakedefine HAVE_STRTOI64
-#cmakedefine HAVE_SNPRINTF
-
-/* OpenSSL functions */
-#cmakedefine HAVE_EVP_AES_128_CTR
-
-/* Socket non-blocking support */
-#cmakedefine HAVE_O_NONBLOCK
-#cmakedefine HAVE_FIONBIO
-#cmakedefine HAVE_IOCTLSOCKET
-#cmakedefine HAVE_IOCTLSOCKET_CASE
-#cmakedefine HAVE_SO_NONBLOCK
-#cmakedefine HAVE_DISABLED_NONBLOCKING
-
-/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
-   We provide a safe wrapper if snprintf not found */
-#ifndef HAVE_SNPRINTF
-#include <stdio.h>
-#include <stdarg.h>
-/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
-* then assume cp is pointing to a null char and do nothing. Returns number
-* number of chars placed in cp excluding the trailing null char. So for
-* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
-* <= 0 the return value is 0 (and no chars are written to cp). */
-static int snprintf(char * cp, int cp_max_len, const char * fmt, ...)
-{
-    va_list args;
-    int n;
-
-    if (cp_max_len < 2)
-        return 0;
-    va_start(args, fmt);
-    n = vsnprintf(cp, cp_max_len, fmt, args);
-    va_end(args);
-    return (n < cp_max_len) ? n : (cp_max_len - 1);
-}
-
-#define HAVE_SNPRINTF
-#endif
diff --git a/libssh2/libssh2/src/libssh2_priv.h b/libssh2/libssh2/src/libssh2_priv.h
deleted file mode 100644
index da488b74..00000000
--- a/libssh2/libssh2/src/libssh2_priv.h
+++ /dev/null
@@ -1,1154 +0,0 @@
-#ifndef __LIBSSH2_PRIV_H
-#define __LIBSSH2_PRIV_H
-/* Copyright (c) 2004-2008, 2010, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2014 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#define LIBSSH2_LIBRARY
-#include "libssh2_config.h"
-
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef HAVE_WS2TCPIP_H
-#include <ws2tcpip.h>
-#endif
-
-#include <stdio.h>
-#include <time.h>
-
-/* The following CPP block should really only be in session.c and packet.c.
-   However, AIX have #define's for 'events' and 'revents' and we are using
-   those names in libssh2.h, so we need to include the AIX headers first, to
-   make sure all code is compiled with consistent names of these fields.
-   While arguable the best would to change libssh2.h to use other names, that
-   would break backwards compatibility.
-*/
-#ifdef HAVE_POLL
-# include <poll.h>
-#else
-# if defined(HAVE_SELECT) && !defined(WIN32)
-# ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-# else
-# include <sys/time.h>
-# include <sys/types.h>
-# endif
-# endif
-#endif
-
-/* Needed for struct iovec on some platforms */
-#ifdef HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif
-
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_IOCTL_H
-# include <sys/ioctl.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-
-#include "libssh2.h"
-#include "libssh2_publickey.h"
-#include "libssh2_sftp.h"
-#include "misc.h" /* for the linked list stuff */
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-#ifdef _MSC_VER
-/* "inline" keyword is valid only with C++ engine! */
-#define inline __inline
-#endif
-
-/* 3DS doesn't seem to have iovec */
-#if defined(WIN32) || defined(_3DS)
-
-struct iovec {
-    size_t iov_len;
-    void *iov_base;
-};
-
-#endif
-
-/* Provide iovec / writev on WIN32 platform. */
-#ifdef WIN32
-
-static inline int writev(int sock, struct iovec *iov, int nvecs)
-{
-    DWORD ret;
-    if(WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
-        return ret;
-    }
-    return -1;
-}
-
-#endif /* WIN32 */
-
-#ifdef __OS400__
-/* Force parameter type. */
-#define send(s, b, l, f)    send((s), (unsigned char *) (b), (l), (f))
-#endif
-
-#include "crypto.h"
-
-#ifdef HAVE_WINSOCK2_H
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#endif
-
-#ifndef SIZE_MAX
-#if _WIN64
-#define SIZE_MAX 0xFFFFFFFFFFFFFFFF
-#else
-#define SIZE_MAX 0xFFFFFFFF
-#endif
-#endif
-
-#ifndef UINT_MAX
-#define UINT_MAX 0xFFFFFFFF
-#endif
-
-/* RFC4253 section 6.1 Maximum Packet Length says:
- *
- * "All implementations MUST be able to process packets with
- * uncompressed payload length of 32768 bytes or less and
- * total packet size of 35000 bytes or less (including length,
- * padding length, payload, padding, and MAC.)."
- */
-#define MAX_SSH_PACKET_LEN 35000
-#define MAX_SHA_DIGEST_LEN SHA512_DIGEST_LENGTH
-
-#define LIBSSH2_ALLOC(session, count) \
-  session->alloc((count), &(session)->abstract)
-#define LIBSSH2_CALLOC(session, count) _libssh2_calloc(session, count)
-#define LIBSSH2_REALLOC(session, ptr, count) \
- ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : \
- session->alloc((count), &(session)->abstract))
-#define LIBSSH2_FREE(session, ptr) \
- session->free((ptr), &(session)->abstract)
-#define LIBSSH2_IGNORE(session, data, datalen) \
- session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract)
-#define LIBSSH2_DEBUG(session, always_display, message, message_len, \
-                      language, language_len)    \
-    session->ssh_msg_debug((session), (always_display), (message), \
-                           (message_len), (language), (language_len), \
-                           &(session)->abstract)
-#define LIBSSH2_DISCONNECT(session, reason, message, message_len, \
-                           language, language_len)                \
-    session->ssh_msg_disconnect((session), (reason), (message),   \
-                                (message_len), (language), (language_len), \
-                                &(session)->abstract)
-
-#define LIBSSH2_MACERROR(session, data, datalen)         \
-    session->macerror((session), (data), (datalen), &(session)->abstract)
-#define LIBSSH2_X11_OPEN(channel, shost, sport)          \
-    channel->session->x11(((channel)->session), (channel), \
-                          (shost), (sport), (&(channel)->session->abstract))
-
-#define LIBSSH2_CHANNEL_CLOSE(session, channel)          \
-    channel->close_cb((session), &(session)->abstract, \
-                      (channel), &(channel)->abstract)
-
-#define LIBSSH2_SEND_FD(session, fd, buffer, length, flags) \
-    (session->send)(fd, buffer, length, flags, &session->abstract)
-#define LIBSSH2_RECV_FD(session, fd, buffer, length, flags) \
-    (session->recv)(fd, buffer, length, flags, &session->abstract)
-
-#define LIBSSH2_SEND(session, buffer, length, flags)  \
-    LIBSSH2_SEND_FD(session, session->socket_fd, buffer, length, flags)
-#define LIBSSH2_RECV(session, buffer, length, flags)                    \
-    LIBSSH2_RECV_FD(session, session->socket_fd, buffer, length, flags)
-
-typedef struct _LIBSSH2_KEX_METHOD LIBSSH2_KEX_METHOD;
-typedef struct _LIBSSH2_HOSTKEY_METHOD LIBSSH2_HOSTKEY_METHOD;
-typedef struct _LIBSSH2_CRYPT_METHOD LIBSSH2_CRYPT_METHOD;
-typedef struct _LIBSSH2_COMP_METHOD LIBSSH2_COMP_METHOD;
-
-typedef struct _LIBSSH2_PACKET LIBSSH2_PACKET;
-
-typedef enum
-{
-    libssh2_NB_state_idle = 0,
-    libssh2_NB_state_allocated,
-    libssh2_NB_state_created,
-    libssh2_NB_state_sent,
-    libssh2_NB_state_sent1,
-    libssh2_NB_state_sent2,
-    libssh2_NB_state_sent3,
-    libssh2_NB_state_sent4,
-    libssh2_NB_state_sent5,
-    libssh2_NB_state_sent6,
-    libssh2_NB_state_sent7,
-    libssh2_NB_state_jump1,
-    libssh2_NB_state_jump2,
-    libssh2_NB_state_jump3,
-    libssh2_NB_state_jump4,
-    libssh2_NB_state_jump5,
-    libssh2_NB_state_end
-} libssh2_nonblocking_states;
-
-typedef struct packet_require_state_t
-{
-    libssh2_nonblocking_states state;
-    time_t start;
-} packet_require_state_t;
-
-typedef struct packet_requirev_state_t
-{
-    time_t start;
-} packet_requirev_state_t;
-
-typedef struct kmdhgGPshakex_state_t
-{
-    libssh2_nonblocking_states state;
-    unsigned char *e_packet;
-    unsigned char *s_packet;
-    unsigned char *tmp;
-    unsigned char h_sig_comp[MAX_SHA_DIGEST_LEN];
-    unsigned char c;
-    size_t e_packet_len;
-    size_t s_packet_len;
-    size_t tmp_len;
-    _libssh2_bn_ctx *ctx;
-    _libssh2_dh_ctx x;
-    _libssh2_bn *e;
-    _libssh2_bn *f;
-    _libssh2_bn *k;
-    unsigned char *f_value;
-    unsigned char *k_value;
-    unsigned char *h_sig;
-    size_t f_value_len;
-    size_t k_value_len;
-    size_t h_sig_len;
-    void *exchange_hash;
-    packet_require_state_t req_state;
-    libssh2_nonblocking_states burn_state;
-} kmdhgGPshakex_state_t;
-
-typedef struct key_exchange_state_low_t
-{
-    libssh2_nonblocking_states state;
-    packet_require_state_t req_state;
-    kmdhgGPshakex_state_t exchange_state;
-    _libssh2_bn *p;             /* SSH2 defined value (p_value) */
-    _libssh2_bn *g;             /* SSH2 defined value (2) */
-    unsigned char request[256]; /* Must fit EC_MAX_POINT_LEN + data */
-    unsigned char *data;
-    size_t request_len;
-    size_t data_len;
-    _libssh2_ec_key *private_key;   /* SSH2 ecdh private key */
-    unsigned char *public_key_oct;  /* SSH2 ecdh public key octal value */
-    size_t public_key_oct_len;      /* SSH2 ecdh public key octal value
-                                       length */
-    unsigned char *curve25519_public_key; /* curve25519 public key, 32
-                                             bytes */
-    unsigned char *curve25519_private_key; /* curve25519 private key, 32
-                                              bytes */
-} key_exchange_state_low_t;
-
-typedef struct key_exchange_state_t
-{
-    libssh2_nonblocking_states state;
-    packet_require_state_t req_state;
-    key_exchange_state_low_t key_state_low;
-    unsigned char *data;
-    size_t data_len;
-    unsigned char *oldlocal;
-    size_t oldlocal_len;
-} key_exchange_state_t;
-
-#define FwdNotReq "Forward not requested"
-
-typedef struct packet_queue_listener_state_t
-{
-    libssh2_nonblocking_states state;
-    unsigned char packet[17 + (sizeof(FwdNotReq) - 1)];
-    unsigned char *host;
-    unsigned char *shost;
-    uint32_t sender_channel;
-    uint32_t initial_window_size;
-    uint32_t packet_size;
-    uint32_t port;
-    uint32_t sport;
-    uint32_t host_len;
-    uint32_t shost_len;
-    LIBSSH2_CHANNEL *channel;
-} packet_queue_listener_state_t;
-
-#define X11FwdUnAvil "X11 Forward Unavailable"
-
-typedef struct packet_x11_open_state_t
-{
-    libssh2_nonblocking_states state;
-    unsigned char packet[17 + (sizeof(X11FwdUnAvil) - 1)];
-    unsigned char *shost;
-    uint32_t sender_channel;
-    uint32_t initial_window_size;
-    uint32_t packet_size;
-    uint32_t sport;
-    uint32_t shost_len;
-    LIBSSH2_CHANNEL *channel;
-} packet_x11_open_state_t;
-
-struct _LIBSSH2_PACKET
-{
-    struct list_node node; /* linked list header */
-
-    /* the raw unencrypted payload */
-    unsigned char *data;
-    size_t data_len;
-
-    /* Where to start reading data from,
-     * used for channel data that's been partially consumed */
-    size_t data_head;
-};
-
-typedef struct _libssh2_channel_data
-{
-    /* Identifier */
-    uint32_t id;
-
-    /* Limits and restrictions */
-    uint32_t window_size_initial, window_size, packet_size;
-
-    /* Set to 1 when CHANNEL_CLOSE / CHANNEL_EOF sent/received */
-    char close, eof, extended_data_ignore_mode;
-} libssh2_channel_data;
-
-struct _LIBSSH2_CHANNEL
-{
-    struct list_node node;
-
-    unsigned char *channel_type;
-    unsigned channel_type_len;
-
-    /* channel's program exit status */
-    int exit_status;
-
-    /* channel's program exit signal (without the SIG prefix) */
-    char *exit_signal;
-
-    libssh2_channel_data local, remote;
-    /* Amount of bytes to be refunded to receive window (but not yet sent) */
-    uint32_t adjust_queue;
-    /* Data immediately available for reading */
-    uint32_t read_avail;
-
-    LIBSSH2_SESSION *session;
-
-    void *abstract;
-      LIBSSH2_CHANNEL_CLOSE_FUNC((*close_cb));
-
-    /* State variables used in libssh2_channel_setenv_ex() */
-    libssh2_nonblocking_states setenv_state;
-    unsigned char *setenv_packet;
-    size_t setenv_packet_len;
-    unsigned char setenv_local_channel[4];
-    packet_requirev_state_t setenv_packet_requirev_state;
-
-    /* State variables used in libssh2_channel_request_pty_ex()
-       libssh2_channel_request_pty_size_ex() */
-    libssh2_nonblocking_states reqPTY_state;
-    unsigned char reqPTY_packet[41 + 256];
-    size_t reqPTY_packet_len;
-    unsigned char reqPTY_local_channel[4];
-    packet_requirev_state_t reqPTY_packet_requirev_state;
-
-    /* State variables used in libssh2_channel_x11_req_ex() */
-    libssh2_nonblocking_states reqX11_state;
-    unsigned char *reqX11_packet;
-    size_t reqX11_packet_len;
-    unsigned char reqX11_local_channel[4];
-    packet_requirev_state_t reqX11_packet_requirev_state;
-
-    /* State variables used in libssh2_channel_process_startup() */
-    libssh2_nonblocking_states process_state;
-    unsigned char *process_packet;
-    size_t process_packet_len;
-    unsigned char process_local_channel[4];
-    packet_requirev_state_t process_packet_requirev_state;
-
-    /* State variables used in libssh2_channel_flush_ex() */
-    libssh2_nonblocking_states flush_state;
-    size_t flush_refund_bytes;
-    size_t flush_flush_bytes;
-
-    /* State variables used in libssh2_channel_receive_window_adjust() */
-    libssh2_nonblocking_states adjust_state;
-    unsigned char adjust_adjust[9];     /* packet_type(1) + channel(4) +
-                                           adjustment(4) */
-
-    /* State variables used in libssh2_channel_read_ex() */
-    libssh2_nonblocking_states read_state;
-
-    uint32_t read_local_id;
-
-    /* State variables used in libssh2_channel_write_ex() */
-    libssh2_nonblocking_states write_state;
-    unsigned char write_packet[13];
-    size_t write_packet_len;
-    size_t write_bufwrite;
-
-    /* State variables used in libssh2_channel_close() */
-    libssh2_nonblocking_states close_state;
-    unsigned char close_packet[5];
-
-    /* State variables used in libssh2_channel_wait_closedeof() */
-    libssh2_nonblocking_states wait_eof_state;
-
-    /* State variables used in libssh2_channel_wait_closed() */
-    libssh2_nonblocking_states wait_closed_state;
-
-    /* State variables used in libssh2_channel_free() */
-    libssh2_nonblocking_states free_state;
-
-    /* State variables used in libssh2_channel_handle_extended_data2() */
-    libssh2_nonblocking_states extData2_state;
-
-    /* State variables used in libssh2_channel_request_auth_agent() */
-    libssh2_nonblocking_states req_auth_agent_try_state;
-    libssh2_nonblocking_states req_auth_agent_state;
-    unsigned char req_auth_agent_packet[36];
-    size_t req_auth_agent_packet_len;
-    unsigned char req_auth_agent_local_channel[4];
-    packet_requirev_state_t req_auth_agent_requirev_state;
-};
-
-struct _LIBSSH2_LISTENER
-{
-    struct list_node node; /* linked list header */
-
-    LIBSSH2_SESSION *session;
-
-    char *host;
-    int port;
-
-    /* a list of CHANNELs for this listener */
-    struct list_head queue;
-
-    int queue_size;
-    int queue_maxsize;
-
-    /* State variables used in libssh2_channel_forward_cancel() */
-    libssh2_nonblocking_states chanFwdCncl_state;
-    unsigned char *chanFwdCncl_data;
-    size_t chanFwdCncl_data_len;
-};
-
-typedef struct _libssh2_endpoint_data
-{
-    unsigned char *banner;
-
-    unsigned char *kexinit;
-    size_t kexinit_len;
-
-    const LIBSSH2_CRYPT_METHOD *crypt;
-    void *crypt_abstract;
-
-    const struct _LIBSSH2_MAC_METHOD *mac;
-    uint32_t seqno;
-    void *mac_abstract;
-
-    const LIBSSH2_COMP_METHOD *comp;
-    void *comp_abstract;
-
-    /* Method Preferences -- NULL yields "load order" */
-    char *crypt_prefs;
-    char *mac_prefs;
-    char *comp_prefs;
-    char *lang_prefs;
-} libssh2_endpoint_data;
-
-#define PACKETBUFSIZE (1024*16)
-
-struct transportpacket
-{
-    /* ------------- for incoming data --------------- */
-    unsigned char buf[PACKETBUFSIZE];
-    unsigned char init[5];  /* first 5 bytes of the incoming data stream,
-                               still encrypted */
-    size_t writeidx;        /* at what array index we do the next write into
-                               the buffer */
-    size_t readidx;         /* at what array index we do the next read from
-                               the buffer */
-    uint32_t packet_length; /* the most recent packet_length as read from the
-                               network data */
-    uint8_t padding_length; /* the most recent padding_length as read from the
-                               network data */
-    size_t data_num;        /* How much of the total package that has been read
-                               so far. */
-    size_t total_num;       /* How much a total package is supposed to be, in
-                               number of bytes. A full package is
-                               packet_length + padding_length + 4 +
-                               mac_length. */
-    unsigned char *payload; /* this is a pointer to a LIBSSH2_ALLOC()
-                               area to which we write decrypted data */
-    unsigned char *wptr;    /* write pointer into the payload to where we
-                               are currently writing decrypted data */
-
-    /* ------------- for outgoing data --------------- */
-    unsigned char outbuf[MAX_SSH_PACKET_LEN]; /* area for the outgoing data */
-
-    int ototal_num;         /* size of outbuf in number of bytes */
-    const unsigned char *odata; /* original pointer to the data */
-    size_t olen;            /* original size of the data we stored in
-                               outbuf */
-    size_t osent;           /* number of bytes already sent */
-};
-
-struct _LIBSSH2_PUBLICKEY
-{
-    LIBSSH2_CHANNEL *channel;
-    uint32_t version;
-
-    /* State variables used in libssh2_publickey_packet_receive() */
-    libssh2_nonblocking_states receive_state;
-    unsigned char *receive_packet;
-    size_t receive_packet_len;
-
-    /* State variables used in libssh2_publickey_add_ex() */
-    libssh2_nonblocking_states add_state;
-    unsigned char *add_packet;
-    unsigned char *add_s;
-
-    /* State variables used in libssh2_publickey_remove_ex() */
-    libssh2_nonblocking_states remove_state;
-    unsigned char *remove_packet;
-    unsigned char *remove_s;
-
-    /* State variables used in libssh2_publickey_list_fetch() */
-    libssh2_nonblocking_states listFetch_state;
-    unsigned char *listFetch_s;
-    unsigned char listFetch_buffer[12];
-    unsigned char *listFetch_data;
-    size_t listFetch_data_len;
-};
-
-#define LIBSSH2_SCP_RESPONSE_BUFLEN     256
-
-struct flags {
-    int sigpipe;  /* LIBSSH2_FLAG_SIGPIPE */
-    int compress; /* LIBSSH2_FLAG_COMPRESS */
-};
-
-struct _LIBSSH2_SESSION
-{
-    /* Memory management callbacks */
-    void *abstract;
-      LIBSSH2_ALLOC_FUNC((*alloc));
-      LIBSSH2_REALLOC_FUNC((*realloc));
-      LIBSSH2_FREE_FUNC((*free));
-
-    /* Other callbacks */
-      LIBSSH2_IGNORE_FUNC((*ssh_msg_ignore));
-      LIBSSH2_DEBUG_FUNC((*ssh_msg_debug));
-      LIBSSH2_DISCONNECT_FUNC((*ssh_msg_disconnect));
-      LIBSSH2_MACERROR_FUNC((*macerror));
-      LIBSSH2_X11_OPEN_FUNC((*x11));
-      LIBSSH2_SEND_FUNC((*send));
-      LIBSSH2_RECV_FUNC((*recv));
-
-    /* Method preferences -- NULL yields "load order" */
-    char *kex_prefs;
-    char *hostkey_prefs;
-
-    int state;
-
-    /* Flag options */
-    struct flags flag;
-
-    /* Agreed Key Exchange Method */
-    const LIBSSH2_KEX_METHOD *kex;
-    unsigned int burn_optimistic_kexinit:1;
-
-    unsigned char *session_id;
-    uint32_t session_id_len;
-
-    /* this is set to TRUE if a blocking API behavior is requested */
-    int api_block_mode;
-
-    /* Timeout used when blocking API behavior is active */
-    long api_timeout;
-
-    /* Server's public key */
-    const LIBSSH2_HOSTKEY_METHOD *hostkey;
-    void *server_hostkey_abstract;
-
-    /* Either set with libssh2_session_hostkey() (for server mode)
-     * Or read from server in (eg) KEXDH_INIT (for client mode)
-     */
-    unsigned char *server_hostkey;
-    uint32_t server_hostkey_len;
-#if LIBSSH2_MD5
-    unsigned char server_hostkey_md5[MD5_DIGEST_LENGTH];
-    int server_hostkey_md5_valid;
-#endif                          /* ! LIBSSH2_MD5 */
-    unsigned char server_hostkey_sha1[SHA_DIGEST_LENGTH];
-    int server_hostkey_sha1_valid;
-
-    unsigned char server_hostkey_sha256[SHA256_DIGEST_LENGTH];
-    int server_hostkey_sha256_valid;
-
-    /* (remote as source of data -- packet_read ) */
-    libssh2_endpoint_data remote;
-
-    /* (local as source of data -- packet_write ) */
-    libssh2_endpoint_data local;
-
-    /* Inbound Data linked list -- Sometimes the packet that comes in isn't the
-       packet we're ready for */
-    struct list_head packets;
-
-    /* Active connection channels */
-    struct list_head channels;
-
-    uint32_t next_channel;
-
-    struct list_head listeners; /* list of LIBSSH2_LISTENER structs */
-
-    /* Actual I/O socket */
-    libssh2_socket_t socket_fd;
-    int socket_state;
-    int socket_block_directions;
-    int socket_prev_blockstate; /* stores the state of the socket blockiness
-                                   when libssh2_session_startup() is called */
-
-    /* Error tracking */
-    const char *err_msg;
-    int err_code;
-    int err_flags;
-
-    /* struct members for packet-level reading */
-    struct transportpacket packet;
-#ifdef LIBSSH2DEBUG
-    int showmask;               /* what debug/trace messages to display */
-    libssh2_trace_handler_func tracehandler; /* callback to display trace
-                                                messages */
-    void *tracehandler_context; /* context for the trace handler */
-#endif
-
-    /* State variables used in libssh2_banner_send() */
-    libssh2_nonblocking_states banner_TxRx_state;
-    char banner_TxRx_banner[256];
-    ssize_t banner_TxRx_total_send;
-
-    /* State variables used in libssh2_kexinit() */
-    libssh2_nonblocking_states kexinit_state;
-    unsigned char *kexinit_data;
-    size_t kexinit_data_len;
-
-    /* State variables used in libssh2_session_startup() */
-    libssh2_nonblocking_states startup_state;
-    unsigned char *startup_data;
-    size_t startup_data_len;
-    unsigned char startup_service[sizeof("ssh-userauth") + 5 - 1];
-    size_t startup_service_length;
-    packet_require_state_t startup_req_state;
-    key_exchange_state_t startup_key_state;
-
-    /* State variables used in libssh2_session_free() */
-    libssh2_nonblocking_states free_state;
-
-    /* State variables used in libssh2_session_disconnect_ex() */
-    libssh2_nonblocking_states disconnect_state;
-    unsigned char disconnect_data[256 + 13];
-    size_t disconnect_data_len;
-
-    /* State variables used in libssh2_packet_read() */
-    libssh2_nonblocking_states readPack_state;
-    int readPack_encrypted;
-
-    /* State variables used in libssh2_userauth_list() */
-    libssh2_nonblocking_states userauth_list_state;
-    unsigned char *userauth_list_data;
-    size_t userauth_list_data_len;
-    packet_requirev_state_t userauth_list_packet_requirev_state;
-
-    /* State variables used in libssh2_userauth_password_ex() */
-    libssh2_nonblocking_states userauth_pswd_state;
-    unsigned char *userauth_pswd_data;
-    unsigned char userauth_pswd_data0;
-    size_t userauth_pswd_data_len;
-    char *userauth_pswd_newpw;
-    int userauth_pswd_newpw_len;
-    packet_requirev_state_t userauth_pswd_packet_requirev_state;
-
-    /* State variables used in libssh2_userauth_hostbased_fromfile_ex() */
-    libssh2_nonblocking_states userauth_host_state;
-    unsigned char *userauth_host_data;
-    size_t userauth_host_data_len;
-    unsigned char *userauth_host_packet;
-    size_t userauth_host_packet_len;
-    unsigned char *userauth_host_method;
-    size_t userauth_host_method_len;
-    unsigned char *userauth_host_s;
-    packet_requirev_state_t userauth_host_packet_requirev_state;
-
-    /* State variables used in libssh2_userauth_publickey_fromfile_ex() */
-    libssh2_nonblocking_states userauth_pblc_state;
-    unsigned char *userauth_pblc_data;
-    size_t userauth_pblc_data_len;
-    unsigned char *userauth_pblc_packet;
-    size_t userauth_pblc_packet_len;
-    unsigned char *userauth_pblc_method;
-    size_t userauth_pblc_method_len;
-    unsigned char *userauth_pblc_s;
-    unsigned char *userauth_pblc_b;
-    packet_requirev_state_t userauth_pblc_packet_requirev_state;
-
-    /* State variables used in libssh2_userauth_keyboard_interactive_ex() */
-    libssh2_nonblocking_states userauth_kybd_state;
-    unsigned char *userauth_kybd_data;
-    size_t userauth_kybd_data_len;
-    unsigned char *userauth_kybd_packet;
-    size_t userauth_kybd_packet_len;
-    unsigned int userauth_kybd_auth_name_len;
-    char *userauth_kybd_auth_name;
-    unsigned userauth_kybd_auth_instruction_len;
-    char *userauth_kybd_auth_instruction;
-    unsigned int userauth_kybd_num_prompts;
-    int userauth_kybd_auth_failure;
-    LIBSSH2_USERAUTH_KBDINT_PROMPT *userauth_kybd_prompts;
-    LIBSSH2_USERAUTH_KBDINT_RESPONSE *userauth_kybd_responses;
-    packet_requirev_state_t userauth_kybd_packet_requirev_state;
-
-    /* State variables used in libssh2_channel_open_ex() */
-    libssh2_nonblocking_states open_state;
-    packet_requirev_state_t open_packet_requirev_state;
-    LIBSSH2_CHANNEL *open_channel;
-    unsigned char *open_packet;
-    size_t open_packet_len;
-    unsigned char *open_data;
-    size_t open_data_len;
-    uint32_t open_local_channel;
-
-    /* State variables used in libssh2_channel_direct_tcpip_ex() */
-    libssh2_nonblocking_states direct_state;
-    unsigned char *direct_message;
-    size_t direct_host_len;
-    size_t direct_shost_len;
-    size_t direct_message_len;
-
-    /* State variables used in libssh2_channel_forward_listen_ex() */
-    libssh2_nonblocking_states fwdLstn_state;
-    unsigned char *fwdLstn_packet;
-    uint32_t fwdLstn_host_len;
-    uint32_t fwdLstn_packet_len;
-    packet_requirev_state_t fwdLstn_packet_requirev_state;
-
-    /* State variables used in libssh2_publickey_init() */
-    libssh2_nonblocking_states pkeyInit_state;
-    LIBSSH2_PUBLICKEY *pkeyInit_pkey;
-    LIBSSH2_CHANNEL *pkeyInit_channel;
-    unsigned char *pkeyInit_data;
-    size_t pkeyInit_data_len;
-    /* 19 = packet_len(4) + version_len(4) + "version"(7) + version_num(4) */
-    unsigned char pkeyInit_buffer[19];
-    size_t pkeyInit_buffer_sent; /* how much of buffer that has been sent */
-
-    /* State variables used in libssh2_packet_add() */
-    libssh2_nonblocking_states packAdd_state;
-    LIBSSH2_CHANNEL *packAdd_channelp; /* keeper of the channel during EAGAIN
-                                          states */
-    packet_queue_listener_state_t packAdd_Qlstn_state;
-    packet_x11_open_state_t packAdd_x11open_state;
-
-    /* State variables used in fullpacket() */
-    libssh2_nonblocking_states fullpacket_state;
-    int fullpacket_macstate;
-    size_t fullpacket_payload_len;
-    int fullpacket_packet_type;
-
-    /* State variables used in libssh2_sftp_init() */
-    libssh2_nonblocking_states sftpInit_state;
-    LIBSSH2_SFTP *sftpInit_sftp;
-    LIBSSH2_CHANNEL *sftpInit_channel;
-    unsigned char sftpInit_buffer[9];   /* sftp_header(5){excludes request_id}
-                                           + version_id(4) */
-    int sftpInit_sent; /* number of bytes from the buffer that have been
-                          sent */
-
-    /* State variables used in libssh2_scp_recv() / libssh_scp_recv2() */
-    libssh2_nonblocking_states scpRecv_state;
-    unsigned char *scpRecv_command;
-    size_t scpRecv_command_len;
-    unsigned char scpRecv_response[LIBSSH2_SCP_RESPONSE_BUFLEN];
-    size_t scpRecv_response_len;
-    long scpRecv_mode;
-#if defined(HAVE_LONGLONG) && defined(HAVE_STRTOLL)
-    /* we have the type and we can parse such numbers */
-    long long scpRecv_size;
-#define scpsize_strtol strtoll
-#elif defined(HAVE_STRTOI64)
-    __int64 scpRecv_size;
-#define scpsize_strtol _strtoi64
-#else
-    long scpRecv_size;
-#define scpsize_strtol strtol
-#endif
-    long scpRecv_mtime;
-    long scpRecv_atime;
-    LIBSSH2_CHANNEL *scpRecv_channel;
-
-    /* State variables used in libssh2_scp_send_ex() */
-    libssh2_nonblocking_states scpSend_state;
-    unsigned char *scpSend_command;
-    size_t scpSend_command_len;
-    unsigned char scpSend_response[LIBSSH2_SCP_RESPONSE_BUFLEN];
-    size_t scpSend_response_len;
-    LIBSSH2_CHANNEL *scpSend_channel;
-
-    /* Keepalive variables used by keepalive.c. */
-    int keepalive_interval;
-    int keepalive_want_reply;
-    time_t keepalive_last_sent;
-};
-
-/* session.state bits */
-#define LIBSSH2_STATE_EXCHANGING_KEYS   0x00000001
-#define LIBSSH2_STATE_NEWKEYS           0x00000002
-#define LIBSSH2_STATE_AUTHENTICATED     0x00000004
-#define LIBSSH2_STATE_KEX_ACTIVE        0x00000008
-
-/* session.flag helpers */
-#ifdef MSG_NOSIGNAL
-#define LIBSSH2_SOCKET_SEND_FLAGS(session)              \
-    (((session)->flag.sigpipe) ? 0 : MSG_NOSIGNAL)
-#define LIBSSH2_SOCKET_RECV_FLAGS(session)              \
-    (((session)->flag.sigpipe) ? 0 : MSG_NOSIGNAL)
-#else
-/* If MSG_NOSIGNAL isn't defined we're SOL on blocking SIGPIPE */
-#define LIBSSH2_SOCKET_SEND_FLAGS(session)      0
-#define LIBSSH2_SOCKET_RECV_FLAGS(session)      0
-#endif
-
-/* --------- */
-
-/* libssh2 extensible ssh api, ultimately I'd like to allow loading additional
-   methods via .so/.dll */
-
-struct _LIBSSH2_KEX_METHOD
-{
-    const char *name;
-
-    /* Key exchange, populates session->* and returns 0 on success, non-0 on
-       error */
-    int (*exchange_keys) (LIBSSH2_SESSION * session,
-                          key_exchange_state_low_t * key_state);
-
-    long flags;
-};
-
-struct _LIBSSH2_HOSTKEY_METHOD
-{
-    const char *name;
-    unsigned long hash_len;
-
-    int (*init) (LIBSSH2_SESSION * session, const unsigned char *hostkey_data,
-                 size_t hostkey_data_len, void **abstract);
-    int (*initPEM) (LIBSSH2_SESSION * session, const char *privkeyfile,
-                    unsigned const char *passphrase, void **abstract);
-    int (*initPEMFromMemory) (LIBSSH2_SESSION * session,
-                              const char *privkeyfiledata,
-                              size_t privkeyfiledata_len,
-                              unsigned const char *passphrase,
-                              void **abstract);
-    int (*sig_verify) (LIBSSH2_SESSION * session, const unsigned char *sig,
-                       size_t sig_len, const unsigned char *m,
-                       size_t m_len, void **abstract);
-    int (*signv) (LIBSSH2_SESSION * session, unsigned char **signature,
-                  size_t *signature_len, int veccount,
-                  const struct iovec datavec[], void **abstract);
-    int (*encrypt) (LIBSSH2_SESSION * session, unsigned char **dst,
-                    size_t *dst_len, const unsigned char *src,
-                    size_t src_len, void **abstract);
-    int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
-};
-
-struct _LIBSSH2_CRYPT_METHOD
-{
-    const char *name;
-    const char *pem_annotation;
-
-    int blocksize;
-
-    /* iv and key sizes (-1 for variable length) */
-    int iv_len;
-    int secret_len;
-
-    long flags;
-
-    int (*init) (LIBSSH2_SESSION * session,
-                 const LIBSSH2_CRYPT_METHOD * method, unsigned char *iv,
-                 int *free_iv, unsigned char *secret, int *free_secret,
-                 int encrypt, void **abstract);
-    int (*crypt) (LIBSSH2_SESSION * session, unsigned char *block,
-                  size_t blocksize, void **abstract);
-    int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
-
-      _libssh2_cipher_type(algo);
-};
-
-struct _LIBSSH2_COMP_METHOD
-{
-    const char *name;
-    int compress; /* 1 if it does compress, 0 if it doesn't */
-    int use_in_auth; /* 1 if compression should be used in userauth */
-    int (*init) (LIBSSH2_SESSION *session, int compress, void **abstract);
-    int (*comp) (LIBSSH2_SESSION *session,
-                 unsigned char *dest,
-                 size_t *dest_len,
-                 const unsigned char *src,
-                 size_t src_len,
-                 void **abstract);
-    int (*decomp) (LIBSSH2_SESSION *session,
-                   unsigned char **dest,
-                   size_t *dest_len,
-                   size_t payload_limit,
-                   const unsigned char *src,
-                   size_t src_len,
-                   void **abstract);
-    int (*dtor) (LIBSSH2_SESSION * session, int compress, void **abstract);
-};
-
-#ifdef LIBSSH2DEBUG
-void _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format,
-                    ...);
-#else
-#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||     \
-    defined(__GNUC__)
-/* C99 supported and also by older GCC */
-#define _libssh2_debug(x,y,z,...) do {} while (0)
-#else
-/* no gcc and not C99, do static and hopefully inline */
-static inline void
-_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
-{
-    (void)session;
-    (void)context;
-    (void)format;
-}
-#endif
-#endif
-
-#define LIBSSH2_SOCKET_UNKNOWN                   1
-#define LIBSSH2_SOCKET_CONNECTED                 0
-#define LIBSSH2_SOCKET_DISCONNECTED             -1
-
-/* Initial packet state, prior to MAC check */
-#define LIBSSH2_MAC_UNCONFIRMED                  1
-/* When MAC type is "none" (proto initiation phase) all packets are deemed
-   "confirmed" */
-#define LIBSSH2_MAC_CONFIRMED                    0
-/* Something very bad is going on */
-#define LIBSSH2_MAC_INVALID                     -1
-
-/* Flags for _libssh2_error_flags */
-/* Error message is allocated on the heap */
-#define LIBSSH2_ERR_FLAG_DUP                     1
-
-/* SSH Packet Types -- Defined by internet draft */
-/* Transport Layer */
-#define SSH_MSG_DISCONNECT                          1
-#define SSH_MSG_IGNORE                              2
-#define SSH_MSG_UNIMPLEMENTED                       3
-#define SSH_MSG_DEBUG                               4
-#define SSH_MSG_SERVICE_REQUEST                     5
-#define SSH_MSG_SERVICE_ACCEPT                      6
-
-#define SSH_MSG_KEXINIT                             20
-#define SSH_MSG_NEWKEYS                             21
-
-/* diffie-hellman-group1-sha1 */
-#define SSH_MSG_KEXDH_INIT                          30
-#define SSH_MSG_KEXDH_REPLY                         31
-
-/* diffie-hellman-group-exchange-sha1 and
-   diffie-hellman-group-exchange-sha256 */
-#define SSH_MSG_KEX_DH_GEX_REQUEST_OLD              30
-#define SSH_MSG_KEX_DH_GEX_REQUEST                  34
-#define SSH_MSG_KEX_DH_GEX_GROUP                    31
-#define SSH_MSG_KEX_DH_GEX_INIT                     32
-#define SSH_MSG_KEX_DH_GEX_REPLY                    33
-
-/* ecdh */
-#define SSH2_MSG_KEX_ECDH_INIT                      30
-#define SSH2_MSG_KEX_ECDH_REPLY                     31
-
-/* User Authentication */
-#define SSH_MSG_USERAUTH_REQUEST                    50
-#define SSH_MSG_USERAUTH_FAILURE                    51
-#define SSH_MSG_USERAUTH_SUCCESS                    52
-#define SSH_MSG_USERAUTH_BANNER                     53
-
-/* "public key" method */
-#define SSH_MSG_USERAUTH_PK_OK                      60
-/* "password" method */
-#define SSH_MSG_USERAUTH_PASSWD_CHANGEREQ           60
-/* "keyboard-interactive" method */
-#define SSH_MSG_USERAUTH_INFO_REQUEST               60
-#define SSH_MSG_USERAUTH_INFO_RESPONSE              61
-
-/* Channels */
-#define SSH_MSG_GLOBAL_REQUEST                      80
-#define SSH_MSG_REQUEST_SUCCESS                     81
-#define SSH_MSG_REQUEST_FAILURE                     82
-
-#define SSH_MSG_CHANNEL_OPEN                        90
-#define SSH_MSG_CHANNEL_OPEN_CONFIRMATION           91
-#define SSH_MSG_CHANNEL_OPEN_FAILURE                92
-#define SSH_MSG_CHANNEL_WINDOW_ADJUST               93
-#define SSH_MSG_CHANNEL_DATA                        94
-#define SSH_MSG_CHANNEL_EXTENDED_DATA               95
-#define SSH_MSG_CHANNEL_EOF                         96
-#define SSH_MSG_CHANNEL_CLOSE                       97
-#define SSH_MSG_CHANNEL_REQUEST                     98
-#define SSH_MSG_CHANNEL_SUCCESS                     99
-#define SSH_MSG_CHANNEL_FAILURE                     100
-
-/* Error codes returned in SSH_MSG_CHANNEL_OPEN_FAILURE message
-   (see RFC4254) */
-#define SSH_OPEN_ADMINISTRATIVELY_PROHIBITED 1
-#define SSH_OPEN_CONNECT_FAILED              2
-#define SSH_OPEN_UNKNOWN_CHANNELTYPE         3
-#define SSH_OPEN_RESOURCE_SHORTAGE           4
-
-ssize_t _libssh2_recv(libssh2_socket_t socket, void *buffer,
-                      size_t length, int flags, void **abstract);
-ssize_t _libssh2_send(libssh2_socket_t socket, const void *buffer,
-                      size_t length, int flags, void **abstract);
-
-#define LIBSSH2_READ_TIMEOUT 60 /* generic timeout in seconds used when
-                                   waiting for more data to arrive */
-
-
-int _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
-                          key_exchange_state_t * state);
-
-/* Let crypt.c/hostkey.c expose their method structs */
-const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void);
-const LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void);
-
-/* misc.c */
-int _libssh2_bcrypt_pbkdf(const char *pass,
-                          size_t passlen,
-                          const uint8_t *salt,
-                          size_t saltlen,
-                          uint8_t *key,
-                          size_t keylen,
-                          unsigned int rounds);
-
-/* pem.c */
-int _libssh2_pem_parse(LIBSSH2_SESSION * session,
-                       const char *headerbegin,
-                       const char *headerend,
-                       const unsigned char *passphrase,
-                       FILE * fp, unsigned char **data, unsigned int *datalen);
-int _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
-                              const char *headerbegin,
-                              const char *headerend,
-                              const char *filedata, size_t filedata_len,
-                              unsigned char **data, unsigned int *datalen);
- /* OpenSSL keys */
-int
-_libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
-                           const unsigned char *passphrase,
-                           FILE * fp, struct string_buf **decrypted_buf);
-int
-_libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
-                                  const unsigned char *passphrase,
-                                  const char *filedata, size_t filedata_len,
-                                  struct string_buf **decrypted_buf);
-
-int _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen);
-int _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
-                                unsigned char **i, unsigned int *ilen);
-
-/* global.c */
-void _libssh2_init_if_needed(void);
-
-
-#define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0]))
-
-/* define to output the libssh2_int64_t type in a *printf() */
-#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW32__)
-#define LIBSSH2_INT64_T_FORMAT "I64d"
-#else
-#define LIBSSH2_INT64_T_FORMAT "lld"
-#endif
-
-/* In Windows the default file mode is text but an application can override it.
-Therefore we specify it explicitly. https://github.com/curl/curl/pull/258
-*/
-#if defined(WIN32) || defined(MSDOS)
-#define FOPEN_READTEXT "rt"
-#define FOPEN_WRITETEXT "wt"
-#define FOPEN_APPENDTEXT "at"
-#elif defined(__CYGWIN__)
-/* Cygwin has specific behavior we need to address when WIN32 is not defined.
-https://cygwin.com/cygwin-ug-net/using-textbinary.html
-For write we want our output to have line endings of LF and be compatible with
-other Cygwin utilities. For read we want to handle input that may have line
-endings either CRLF or LF so 't' is appropriate.
-*/
-#define FOPEN_READTEXT "rt"
-#define FOPEN_WRITETEXT "w"
-#define FOPEN_APPENDTEXT "a"
-#else
-#define FOPEN_READTEXT "r"
-#define FOPEN_WRITETEXT "w"
-#define FOPEN_APPENDTEXT "a"
-#endif
-
-#endif /* __LIBSSH2_PRIV_H */
diff --git a/libssh2/libssh2/src/mac.c b/libssh2/libssh2/src/mac.c
deleted file mode 100644
index 5ac71df4..00000000
--- a/libssh2/libssh2/src/mac.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "mac.h"
-
-#ifdef LIBSSH2_MAC_NONE
-/* mac_none_MAC
- * Minimalist MAC: No MAC
- */
-static int
-mac_none_MAC(LIBSSH2_SESSION * session, unsigned char *buf,
-             uint32_t seqno, const unsigned char *packet,
-             uint32_t packet_len, const unsigned char *addtl,
-             uint32_t addtl_len, void **abstract)
-{
-    return 0;
-}
-
-
-
-
-static LIBSSH2_MAC_METHOD mac_method_none = {
-    "none",
-    0,
-    0,
-    NULL,
-    mac_none_MAC,
-    NULL
-};
-#endif /* LIBSSH2_MAC_NONE */
-
-/* mac_method_common_init
- * Initialize simple mac methods
- */
-static int
-mac_method_common_init(LIBSSH2_SESSION * session, unsigned char *key,
-                       int *free_key, void **abstract)
-{
-    *abstract = key;
-    *free_key = 0;
-    (void) session;
-
-    return 0;
-}
-
-
-
-/* mac_method_common_dtor
- * Cleanup simple mac methods
- */
-static int
-mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract)
-{
-    if(*abstract) {
-        LIBSSH2_FREE(session, *abstract);
-    }
-    *abstract = NULL;
-
-    return 0;
-}
-
-
-
-#if LIBSSH2_HMAC_SHA512
-/* mac_method_hmac_sha512_hash
- * Calculate hash using full sha512 value
- */
-static int
-mac_method_hmac_sha2_512_hash(LIBSSH2_SESSION * session,
-                          unsigned char *buf, uint32_t seqno,
-                          const unsigned char *packet,
-                          uint32_t packet_len,
-                          const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
-{
-    libssh2_hmac_ctx ctx;
-    unsigned char seqno_buf[4];
-    (void) session;
-
-    _libssh2_htonu32(seqno_buf, seqno);
-
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha512_init(&ctx, *abstract, 64);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_512 = {
-    "hmac-sha2-512",
-    64,
-    64,
-    mac_method_common_init,
-    mac_method_hmac_sha2_512_hash,
-    mac_method_common_dtor,
-};
-#endif
-
-
-
-#if LIBSSH2_HMAC_SHA256
-/* mac_method_hmac_sha256_hash
- * Calculate hash using full sha256 value
- */
-static int
-mac_method_hmac_sha2_256_hash(LIBSSH2_SESSION * session,
-                          unsigned char *buf, uint32_t seqno,
-                          const unsigned char *packet,
-                          uint32_t packet_len,
-                          const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
-{
-    libssh2_hmac_ctx ctx;
-    unsigned char seqno_buf[4];
-    (void) session;
-
-    _libssh2_htonu32(seqno_buf, seqno);
-
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha256_init(&ctx, *abstract, 32);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_256 = {
-    "hmac-sha2-256",
-    32,
-    32,
-    mac_method_common_init,
-    mac_method_hmac_sha2_256_hash,
-    mac_method_common_dtor,
-};
-#endif
-
-
-
-
-/* mac_method_hmac_sha1_hash
- * Calculate hash using full sha1 value
- */
-static int
-mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session,
-                          unsigned char *buf, uint32_t seqno,
-                          const unsigned char *packet,
-                          uint32_t packet_len,
-                          const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
-{
-    libssh2_hmac_ctx ctx;
-    unsigned char seqno_buf[4];
-    (void) session;
-
-    _libssh2_htonu32(seqno_buf, seqno);
-
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha1_init(&ctx, *abstract, 20);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_sha1 = {
-    "hmac-sha1",
-    20,
-    20,
-    mac_method_common_init,
-    mac_method_hmac_sha1_hash,
-    mac_method_common_dtor,
-};
-
-/* mac_method_hmac_sha1_96_hash
- * Calculate hash using first 96 bits of sha1 value
- */
-static int
-mac_method_hmac_sha1_96_hash(LIBSSH2_SESSION * session,
-                             unsigned char *buf, uint32_t seqno,
-                             const unsigned char *packet,
-                             uint32_t packet_len,
-                             const unsigned char *addtl,
-                             uint32_t addtl_len, void **abstract)
-{
-    unsigned char temp[SHA_DIGEST_LENGTH];
-
-    mac_method_hmac_sha1_hash(session, temp, seqno, packet, packet_len,
-                              addtl, addtl_len, abstract);
-    memcpy(buf, (char *) temp, 96 / 8);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_sha1_96 = {
-    "hmac-sha1-96",
-    12,
-    20,
-    mac_method_common_init,
-    mac_method_hmac_sha1_96_hash,
-    mac_method_common_dtor,
-};
-
-#if LIBSSH2_MD5
-/* mac_method_hmac_md5_hash
- * Calculate hash using full md5 value
- */
-static int
-mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf,
-                         uint32_t seqno,
-                         const unsigned char *packet,
-                         uint32_t packet_len,
-                         const unsigned char *addtl,
-                         uint32_t addtl_len, void **abstract)
-{
-    libssh2_hmac_ctx ctx;
-    unsigned char seqno_buf[4];
-    (void) session;
-
-    _libssh2_htonu32(seqno_buf, seqno);
-
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_md5_init(&ctx, *abstract, 16);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_md5 = {
-    "hmac-md5",
-    16,
-    16,
-    mac_method_common_init,
-    mac_method_hmac_md5_hash,
-    mac_method_common_dtor,
-};
-
-/* mac_method_hmac_md5_96_hash
- * Calculate hash using first 96 bits of md5 value
- */
-static int
-mac_method_hmac_md5_96_hash(LIBSSH2_SESSION * session,
-                            unsigned char *buf, uint32_t seqno,
-                            const unsigned char *packet,
-                            uint32_t packet_len,
-                            const unsigned char *addtl,
-                            uint32_t addtl_len, void **abstract)
-{
-    unsigned char temp[MD5_DIGEST_LENGTH];
-    mac_method_hmac_md5_hash(session, temp, seqno, packet, packet_len,
-                             addtl, addtl_len, abstract);
-    memcpy(buf, (char *) temp, 96 / 8);
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_md5_96 = {
-    "hmac-md5-96",
-    12,
-    16,
-    mac_method_common_init,
-    mac_method_hmac_md5_96_hash,
-    mac_method_common_dtor,
-};
-#endif /* LIBSSH2_MD5 */
-
-#if LIBSSH2_HMAC_RIPEMD
-/* mac_method_hmac_ripemd160_hash
- * Calculate hash using ripemd160 value
- */
-static int
-mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session,
-                               unsigned char *buf, uint32_t seqno,
-                               const unsigned char *packet,
-                               uint32_t packet_len,
-                               const unsigned char *addtl,
-                               uint32_t addtl_len,
-                               void **abstract)
-{
-    libssh2_hmac_ctx ctx;
-    unsigned char seqno_buf[4];
-    (void) session;
-
-    _libssh2_htonu32(seqno_buf, seqno);
-
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_ripemd160_init(&ctx, *abstract, 20);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
-}
-
-
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_ripemd160 = {
-    "hmac-ripemd160",
-    20,
-    20,
-    mac_method_common_init,
-    mac_method_hmac_ripemd160_hash,
-    mac_method_common_dtor,
-};
-
-static const LIBSSH2_MAC_METHOD mac_method_hmac_ripemd160_openssh_com = {
-    "hmac-ripemd160@openssh.com",
-    20,
-    20,
-    mac_method_common_init,
-    mac_method_hmac_ripemd160_hash,
-    mac_method_common_dtor,
-};
-#endif /* LIBSSH2_HMAC_RIPEMD */
-
-static const LIBSSH2_MAC_METHOD *mac_methods[] = {
-#if LIBSSH2_HMAC_SHA256
-    &mac_method_hmac_sha2_256,
-#endif
-#if LIBSSH2_HMAC_SHA512
-    &mac_method_hmac_sha2_512,
-#endif
-    &mac_method_hmac_sha1,
-    &mac_method_hmac_sha1_96,
-#if LIBSSH2_MD5
-    &mac_method_hmac_md5,
-    &mac_method_hmac_md5_96,
-#endif
-#if LIBSSH2_HMAC_RIPEMD
-    &mac_method_hmac_ripemd160,
-    &mac_method_hmac_ripemd160_openssh_com,
-#endif /* LIBSSH2_HMAC_RIPEMD */
-#ifdef LIBSSH2_MAC_NONE
-    &mac_method_none,
-#endif /* LIBSSH2_MAC_NONE */
-    NULL
-};
-
-const LIBSSH2_MAC_METHOD **
-_libssh2_mac_methods(void)
-{
-    return mac_methods;
-}
diff --git a/libssh2/libssh2/src/mac.h b/libssh2/libssh2/src/mac.h
deleted file mode 100644
index 46fce542..00000000
--- a/libssh2/libssh2/src/mac.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef __LIBSSH2_MAC_H
-#define __LIBSSH2_MAC_H
-/* Copyright (C) 2009-2010 by Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-#include "libssh2_priv.h"
-
-struct _LIBSSH2_MAC_METHOD
-{
-    const char *name;
-
-    /* The length of a given MAC packet */
-    int mac_len;
-
-    /* integrity key length */
-    int key_len;
-
-    /* Message Authentication Code Hashing algo */
-    int (*init) (LIBSSH2_SESSION * session, unsigned char *key, int *free_key,
-                 void **abstract);
-    int (*hash) (LIBSSH2_SESSION * session, unsigned char *buf,
-                 uint32_t seqno, const unsigned char *packet,
-                 uint32_t packet_len, const unsigned char *addtl,
-                 uint32_t addtl_len, void **abstract);
-    int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
-};
-
-typedef struct _LIBSSH2_MAC_METHOD LIBSSH2_MAC_METHOD;
-
-const LIBSSH2_MAC_METHOD **_libssh2_mac_methods(void);
-
-#endif /* __LIBSSH2_MAC_H */
diff --git a/libssh2/libssh2/src/mbedtls.c b/libssh2/libssh2/src/mbedtls.c
deleted file mode 100644
index 4629ce4a..00000000
--- a/libssh2/libssh2/src/mbedtls.c
+++ /dev/null
@@ -1,1251 +0,0 @@
-/* Copyright (c) 2016, Art <https://github.com/wildart>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_MBEDTLS /* compile only if we build with mbedtls */
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Global context handles
- */
-
-static mbedtls_entropy_context  _libssh2_mbedtls_entropy;
-static mbedtls_ctr_drbg_context _libssh2_mbedtls_ctr_drbg;
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Generic functions
- */
-
-void
-_libssh2_mbedtls_init(void)
-{
-    int ret;
-
-    mbedtls_entropy_init(&_libssh2_mbedtls_entropy);
-    mbedtls_ctr_drbg_init(&_libssh2_mbedtls_ctr_drbg);
-
-    ret = mbedtls_ctr_drbg_seed(&_libssh2_mbedtls_ctr_drbg,
-                                mbedtls_entropy_func,
-                                &_libssh2_mbedtls_entropy, NULL, 0);
-    if(ret != 0)
-        mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg);
-}
-
-void
-_libssh2_mbedtls_free(void)
-{
-    mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg);
-    mbedtls_entropy_free(&_libssh2_mbedtls_entropy);
-}
-
-int
-_libssh2_mbedtls_random(unsigned char *buf, int len)
-{
-    int ret;
-    ret = mbedtls_ctr_drbg_random(&_libssh2_mbedtls_ctr_drbg, buf, len);
-    return ret == 0 ? 0 : -1;
-}
-
-static void
-_libssh2_mbedtls_safe_free(void *buf, int len)
-{
-#ifndef LIBSSH2_CLEAR_MEMORY
-    (void)len;
-#endif
-
-    if(!buf)
-        return;
-
-#ifdef LIBSSH2_CLEAR_MEMORY
-    if(len > 0)
-        _libssh2_explicit_zero(buf, len);
-#endif
-
-    mbedtls_free(buf);
-}
-
-int
-_libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(algo),
-                             unsigned char *iv,
-                             unsigned char *secret,
-                             int encrypt)
-{
-    const mbedtls_cipher_info_t *cipher_info;
-    int ret, op;
-
-    if(!ctx)
-        return -1;
-
-    op = encrypt == 0 ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT;
-
-    cipher_info = mbedtls_cipher_info_from_type(algo);
-    if(!cipher_info)
-        return -1;
-
-    mbedtls_cipher_init(ctx);
-    ret = mbedtls_cipher_setup(ctx, cipher_info);
-    if(!ret)
-        ret = mbedtls_cipher_setkey(ctx, secret, cipher_info->key_bitlen, op);
-
-    if(!ret)
-        ret = mbedtls_cipher_set_iv(ctx, iv, cipher_info->iv_size);
-
-    return ret == 0 ? 0 : -1;
-}
-
-int
-_libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                              _libssh2_cipher_type(algo),
-                              int encrypt,
-                              unsigned char *block,
-                              size_t blocklen)
-{
-    int ret;
-    unsigned char *output;
-    size_t osize, olen, finish_olen;
-
-    (void) encrypt;
-    (void) algo;
-
-    osize = blocklen + mbedtls_cipher_get_block_size(ctx);
-
-    output = (unsigned char *)mbedtls_calloc(osize, sizeof(char));
-    if(output) {
-        ret = mbedtls_cipher_reset(ctx);
-
-        if(!ret)
-            ret = mbedtls_cipher_update(ctx, block, blocklen, output, &olen);
-
-        if(!ret)
-            ret = mbedtls_cipher_finish(ctx, output + olen, &finish_olen);
-
-        if(!ret) {
-            olen += finish_olen;
-            memcpy(block, output, olen);
-        }
-
-        _libssh2_mbedtls_safe_free(output, osize);
-    }
-    else
-        ret = -1;
-
-    return ret == 0 ? 0 : -1;
-}
-
-void
-_libssh2_mbedtls_cipher_dtor(_libssh2_cipher_ctx *ctx)
-{
-    mbedtls_cipher_free(ctx);
-}
-
-
-int
-_libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
-                          mbedtls_md_type_t mdtype,
-                          const unsigned char *key, unsigned long keylen)
-{
-    const mbedtls_md_info_t *md_info;
-    int ret, hmac;
-
-    md_info = mbedtls_md_info_from_type(mdtype);
-    if(!md_info)
-        return 0;
-
-    hmac = key == NULL ? 0 : 1;
-
-    mbedtls_md_init(ctx);
-    ret = mbedtls_md_setup(ctx, md_info, hmac);
-    if(!ret) {
-        if(hmac)
-            ret = mbedtls_md_hmac_starts(ctx, key, keylen);
-        else
-            ret = mbedtls_md_starts(ctx);
-    }
-
-    return ret == 0 ? 1 : 0;
-}
-
-int
-_libssh2_mbedtls_hash_final(mbedtls_md_context_t *ctx, unsigned char *hash)
-{
-    int ret;
-
-    ret = mbedtls_md_finish(ctx, hash);
-    mbedtls_md_free(ctx);
-
-    return ret == 0 ? 0 : -1;
-}
-
-int
-_libssh2_mbedtls_hash(const unsigned char *data, unsigned long datalen,
-                      mbedtls_md_type_t mdtype, unsigned char *hash)
-{
-    const mbedtls_md_info_t *md_info;
-    int ret;
-
-    md_info = mbedtls_md_info_from_type(mdtype);
-    if(!md_info)
-        return 0;
-
-    ret = mbedtls_md(md_info, data, datalen, hash);
-
-    return ret == 0 ? 0 : -1;
-}
-
-/*******************************************************************/
-/*
- * mbedTLS backend: BigNumber functions
- */
-
-_libssh2_bn *
-_libssh2_mbedtls_bignum_init(void)
-{
-    _libssh2_bn *bignum;
-
-    bignum = (_libssh2_bn *)mbedtls_calloc(1, sizeof(_libssh2_bn));
-    if(bignum) {
-        mbedtls_mpi_init(bignum);
-    }
-
-    return bignum;
-}
-
-void
-_libssh2_mbedtls_bignum_free(_libssh2_bn *bn)
-{
-    if(bn) {
-        mbedtls_mpi_free(bn);
-        mbedtls_free(bn);
-    }
-}
-
-static int
-_libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
-{
-    size_t len;
-    int err;
-    int i;
-
-    if(!bn || bits <= 0)
-        return -1;
-
-    len = (bits + 7) >> 3;
-    err = mbedtls_mpi_fill_random(bn, len, mbedtls_ctr_drbg_random,
-                                  &_libssh2_mbedtls_ctr_drbg);
-    if(err)
-        return -1;
-
-    /* Zero unused bits above the most significant bit*/
-    for(i = len*8 - 1; bits <= i; --i) {
-        err = mbedtls_mpi_set_bit(bn, i, 0);
-        if(err)
-            return -1;
-    }
-
-    /* If `top` is -1, the most significant bit of the random number can be
-       zero.  If top is 0, the most significant bit of the random number is
-       set to 1, and if top is 1, the two most significant bits of the number
-       will be set to 1, so that the product of two such random numbers will
-       always have 2*bits length.
-    */
-    for(i = 0; i <= top; ++i) {
-        err = mbedtls_mpi_set_bit(bn, bits-i-1, 1);
-        if(err)
-            return -1;
-    }
-
-    /* make odd by setting first bit in least significant byte */
-    if(bottom) {
-        err = mbedtls_mpi_set_bit(bn, 0, 1);
-        if(err)
-            return -1;
-    }
-
-    return 0;
-}
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: RSA functions
- */
-
-int
-_libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen)
-{
-    int ret;
-    libssh2_rsa_ctx *ctx;
-
-    ctx = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
-    if(ctx != NULL) {
-        mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V15, 0);
-    }
-    else
-        return -1;
-
-    /* !checksrc! disable ASSIGNWITHINCONDITION 1 */
-    if((ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 ||
-       (ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0) {
-        ret = -1;
-    }
-
-    if(!ret) {
-        ctx->len = mbedtls_mpi_size(&(ctx->N));
-    }
-
-    if(!ret && ddata) {
-        /* !checksrc! disable ASSIGNWITHINCONDITION 1 */
-        if((ret = mbedtls_mpi_read_binary(&(ctx->D), ddata, dlen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->P), pdata, plen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->Q), qdata, qlen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) )
-           != 0) {
-            ret = -1;
-        }
-        ret = mbedtls_rsa_check_privkey(ctx);
-    }
-    else if(!ret) {
-        ret = mbedtls_rsa_check_pubkey(ctx);
-    }
-
-    if(ret && ctx) {
-        _libssh2_mbedtls_rsa_free(ctx);
-        ctx = NULL;
-    }
-    *rsa = ctx;
-    return ret;
-}
-
-int
-_libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase)
-{
-    int ret;
-    mbedtls_pk_context pkey;
-    mbedtls_rsa_context *pk_rsa;
-
-    *rsa = (libssh2_rsa_ctx *) LIBSSH2_ALLOC(session, sizeof(libssh2_rsa_ctx));
-    if(*rsa == NULL)
-        return -1;
-
-    mbedtls_rsa_init(*rsa, MBEDTLS_RSA_PKCS_V15, 0);
-    mbedtls_pk_init(&pkey);
-
-    ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase);
-    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
-        mbedtls_pk_free(&pkey);
-        mbedtls_rsa_free(*rsa);
-        LIBSSH2_FREE(session, *rsa);
-        *rsa = NULL;
-        return -1;
-    }
-
-    pk_rsa = mbedtls_pk_rsa(pkey);
-    mbedtls_rsa_copy(*rsa, pk_rsa);
-    mbedtls_pk_free(&pkey);
-
-    return 0;
-}
-
-int
-_libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase)
-{
-    int ret;
-    mbedtls_pk_context pkey;
-    mbedtls_rsa_context *pk_rsa;
-    void *filedata_nullterm;
-    size_t pwd_len;
-
-    *rsa = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
-    if(*rsa == NULL)
-        return -1;
-
-    /*
-    mbedtls checks in "mbedtls/pkparse.c:1184" if "key[keylen - 1] != '\0'"
-    private-key from memory will fail if the last byte is not a null byte
-    */
-    filedata_nullterm = mbedtls_calloc(filedata_len + 1, 1);
-    if(filedata_nullterm == NULL) {
-        return -1;
-    }
-    memcpy(filedata_nullterm, filedata, filedata_len);
-
-    mbedtls_pk_init(&pkey);
-
-    pwd_len = passphrase != NULL ? strlen((const char *)passphrase) : 0;
-    ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata_nullterm,
-                               filedata_len + 1,
-                               passphrase, pwd_len);
-    _libssh2_mbedtls_safe_free(filedata_nullterm, filedata_len);
-
-    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
-        mbedtls_pk_free(&pkey);
-        mbedtls_rsa_free(*rsa);
-        LIBSSH2_FREE(session, *rsa);
-        *rsa = NULL;
-        return -1;
-    }
-
-    pk_rsa = mbedtls_pk_rsa(pkey);
-    mbedtls_rsa_copy(*rsa, pk_rsa);
-    mbedtls_pk_free(&pkey);
-
-    return 0;
-}
-
-int
-_libssh2_mbedtls_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len)
-{
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    int ret;
-
-    ret = _libssh2_mbedtls_hash(m, m_len, MBEDTLS_MD_SHA1, hash);
-    if(ret)
-        return -1; /* failure */
-
-    ret = mbedtls_rsa_pkcs1_verify(rsa, NULL, NULL, MBEDTLS_RSA_PUBLIC,
-                                   MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
-                                   hash, sig);
-
-    return (ret == 0) ? 0 : -1;
-}
-
-int
-_libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len)
-{
-    int ret;
-    unsigned char *sig;
-    unsigned int sig_len;
-
-    (void)hash_len;
-
-    sig_len = rsa->len;
-    sig = LIBSSH2_ALLOC(session, sig_len);
-    if(!sig) {
-        return -1;
-    }
-
-    ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
-                                 MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
-                                 hash, sig);
-    if(ret) {
-        LIBSSH2_FREE(session, sig);
-        return -1;
-    }
-
-    *signature = sig;
-    *signature_len = sig_len;
-
-    return (ret == 0) ? 0 : -1;
-}
-
-void
-_libssh2_mbedtls_rsa_free(libssh2_rsa_ctx *ctx)
-{
-    mbedtls_rsa_free(ctx);
-    mbedtls_free(ctx);
-}
-
-static unsigned char *
-gen_publickey_from_rsa(LIBSSH2_SESSION *session,
-                      mbedtls_rsa_context *rsa,
-                      size_t *keylen)
-{
-    int            e_bytes, n_bytes;
-    unsigned long  len;
-    unsigned char *key;
-    unsigned char *p;
-
-    e_bytes = mbedtls_mpi_size(&rsa->E);
-    n_bytes = mbedtls_mpi_size(&rsa->N);
-
-    /* Key form is "ssh-rsa" + e + n. */
-    len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
-
-    key = LIBSSH2_ALLOC(session, len);
-    if(!key) {
-        return NULL;
-    }
-
-    /* Process key encoding. */
-    p = key;
-
-    _libssh2_htonu32(p, 7);  /* Key type. */
-    p += 4;
-    memcpy(p, "ssh-rsa", 7);
-    p += 7;
-
-    _libssh2_htonu32(p, e_bytes);
-    p += 4;
-    mbedtls_mpi_write_binary(&rsa->E, p, e_bytes);
-
-    _libssh2_htonu32(p, n_bytes);
-    p += 4;
-    mbedtls_mpi_write_binary(&rsa->N, p, n_bytes);
-
-    *keylen = (size_t)(p - key);
-    return key;
-}
-
-static int
-_libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
-                               unsigned char **method,
-                               size_t *method_len,
-                               unsigned char **pubkeydata,
-                               size_t *pubkeydata_len,
-                               mbedtls_pk_context *pkey)
-{
-    unsigned char *key = NULL, *mth = NULL;
-    size_t keylen = 0, mthlen = 0;
-    int ret;
-    mbedtls_rsa_context *rsa;
-
-    if(mbedtls_pk_get_type(pkey) != MBEDTLS_PK_RSA) {
-        mbedtls_pk_free(pkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Key type not supported");
-    }
-
-    /* write method */
-    mthlen = 7;
-    mth = LIBSSH2_ALLOC(session, mthlen);
-    if(mth) {
-        memcpy(mth, "ssh-rsa", mthlen);
-    }
-    else {
-        ret = -1;
-    }
-
-    rsa = mbedtls_pk_rsa(*pkey);
-    key = gen_publickey_from_rsa(session, rsa, &keylen);
-    if(key == NULL) {
-        ret = -1;
-    }
-
-    /* write output */
-    if(ret) {
-        if(mth)
-            LIBSSH2_FREE(session, mth);
-        if(key)
-            LIBSSH2_FREE(session, key);
-    }
-    else {
-        *method = mth;
-        *method_len = mthlen;
-        *pubkeydata = key;
-        *pubkeydata_len = keylen;
-    }
-
-    return ret;
-}
-
-int
-_libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase)
-{
-    mbedtls_pk_context pkey;
-    char buf[1024];
-    int ret;
-
-    mbedtls_pk_init(&pkey);
-    ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase);
-    if(ret != 0) {
-        mbedtls_strerror(ret, (char *)buf, sizeof(buf));
-        mbedtls_pk_free(&pkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
-    }
-
-    ret = _libssh2_mbedtls_pub_priv_key(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, &pkey);
-
-    mbedtls_pk_free(&pkey);
-
-    return ret;
-}
-
-int
-_libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase)
-{
-    mbedtls_pk_context pkey;
-    char buf[1024];
-    int ret;
-    void *privatekeydata_nullterm;
-    size_t pwd_len;
-
-    /*
-    mbedtls checks in "mbedtls/pkparse.c:1184" if "key[keylen - 1] != '\0'"
-    private-key from memory will fail if the last byte is not a null byte
-    */
-    privatekeydata_nullterm = mbedtls_calloc(privatekeydata_len + 1, 1);
-    if(privatekeydata_nullterm == NULL) {
-        return -1;
-    }
-    memcpy(privatekeydata_nullterm, privatekeydata, privatekeydata_len);
-
-    mbedtls_pk_init(&pkey);
-
-    pwd_len = passphrase != NULL ? strlen((const char *)passphrase) : 0;
-    ret = mbedtls_pk_parse_key(&pkey,
-                               (unsigned char *)privatekeydata_nullterm,
-                               privatekeydata_len + 1,
-                               (const unsigned char *)passphrase, pwd_len);
-    _libssh2_mbedtls_safe_free(privatekeydata_nullterm, privatekeydata_len);
-
-    if(ret != 0) {
-        mbedtls_strerror(ret, (char *)buf, sizeof(buf));
-        mbedtls_pk_free(&pkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
-    }
-
-    ret = _libssh2_mbedtls_pub_priv_key(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, &pkey);
-
-    mbedtls_pk_free(&pkey);
-
-    return ret;
-}
-
-void _libssh2_init_aes_ctr(void)
-{
-    /* no implementation */
-}
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Diffie-Hellman functions
- */
-
-void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx)
-{
-    *dhctx = _libssh2_mbedtls_bignum_init();    /* Random from client */
-}
-
-int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                     _libssh2_bn *g, _libssh2_bn *p, int group_order)
-{
-    /* Generate x and e */
-    _libssh2_mbedtls_bignum_random(*dhctx, group_order * 8 - 1, 0, -1);
-    mbedtls_mpi_exp_mod(public, g, *dhctx, p, NULL);
-    return 0;
-}
-
-int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                   _libssh2_bn *f, _libssh2_bn *p)
-{
-    /* Compute the shared secret */
-    mbedtls_mpi_exp_mod(secret, f, *dhctx, p, NULL);
-    return 0;
-}
-
-void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
-{
-    _libssh2_mbedtls_bignum_free(*dhctx);
-    *dhctx = NULL;
-}
-
-#if LIBSSH2_ECDSA
-
-/*******************************************************************/
-/*
- * mbedTLS backend: ECDSA functions
- */
-
-/*
- * _libssh2_ecdsa_create_key
- *
- * Creates a local private key based on input curve
- * and returns octal value and octal length
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_create_key(LIBSSH2_SESSION *session,
-                                  _libssh2_ec_key **privkey,
-                                  unsigned char **pubkey_oct,
-                                  size_t *pubkey_oct_len,
-                                  libssh2_curve_type curve)
-{
-    size_t plen = 0;
-
-    *privkey = LIBSSH2_ALLOC(session, sizeof(mbedtls_ecp_keypair));
-
-    if(*privkey == NULL)
-        goto failed;
-
-    mbedtls_ecdsa_init(*privkey);
-
-    if(mbedtls_ecdsa_genkey(*privkey, (mbedtls_ecp_group_id)curve,
-                            mbedtls_ctr_drbg_random,
-                            &_libssh2_mbedtls_ctr_drbg) != 0)
-        goto failed;
-
-    plen = 2 * mbedtls_mpi_size(&(*privkey)->grp.P) + 1;
-    *pubkey_oct = LIBSSH2_ALLOC(session, plen);
-
-    if(*pubkey_oct == NULL)
-        goto failed;
-
-    if(mbedtls_ecp_point_write_binary(&(*privkey)->grp, &(*privkey)->Q,
-                                      MBEDTLS_ECP_PF_UNCOMPRESSED,
-                                      pubkey_oct_len, *pubkey_oct, plen) == 0)
-        return 0;
-
-failed:
-
-    _libssh2_mbedtls_ecdsa_free(*privkey);
-    _libssh2_mbedtls_safe_free(*pubkey_oct, plen);
-    *privkey = NULL;
-
-    return -1;
-}
-
-/* _libssh2_ecdsa_curve_name_with_octal_new
- *
- * Creates a new public key given an octal string, length and type
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx **ctx,
-                                                 const unsigned char *k,
-                                                 size_t k_len,
-                                                 libssh2_curve_type curve)
-{
-    *ctx = mbedtls_calloc(1, sizeof(mbedtls_ecp_keypair));
-
-    if(*ctx == NULL)
-        goto failed;
-
-    mbedtls_ecdsa_init(*ctx);
-
-    if(mbedtls_ecp_group_load(&(*ctx)->grp, (mbedtls_ecp_group_id)curve) != 0)
-        goto failed;
-
-    if(mbedtls_ecp_point_read_binary(&(*ctx)->grp, &(*ctx)->Q, k, k_len) != 0)
-        goto failed;
-
-    if(mbedtls_ecp_check_pubkey(&(*ctx)->grp, &(*ctx)->Q) == 0)
-        return 0;
-
-failed:
-
-    _libssh2_mbedtls_ecdsa_free(*ctx);
-    *ctx = NULL;
-
-    return -1;
-}
-
-/* _libssh2_ecdh_gen_k
- *
- * Computes the shared secret K given a local private key,
- * remote public key and length
- */
-
-int
-_libssh2_mbedtls_ecdh_gen_k(_libssh2_bn **k,
-                            _libssh2_ec_key *privkey,
-                            const unsigned char *server_pubkey,
-                            size_t server_pubkey_len)
-{
-    mbedtls_ecp_point pubkey;
-    int rc = 0;
-
-    if(*k == NULL)
-        return -1;
-
-    mbedtls_ecp_point_init(&pubkey);
-
-    if(mbedtls_ecp_point_read_binary(&privkey->grp, &pubkey,
-                                     server_pubkey, server_pubkey_len) != 0) {
-        rc = -1;
-        goto cleanup;
-    }
-
-    if(mbedtls_ecdh_compute_shared(&privkey->grp, *k,
-                                   &pubkey, &privkey->d,
-                                   mbedtls_ctr_drbg_random,
-                                   &_libssh2_mbedtls_ctr_drbg) != 0) {
-        rc = -1;
-        goto cleanup;
-    }
-
-    if(mbedtls_ecp_check_privkey(&privkey->grp, *k) != 0)
-        rc = -1;
-
-cleanup:
-
-    mbedtls_ecp_point_free(&pubkey);
-
-    return rc;
-}
-
-#define LIBSSH2_MBEDTLS_ECDSA_VERIFY(digest_type)                   \
-{                                                                   \
-    unsigned char hsh[SHA##digest_type##_DIGEST_LENGTH];            \
-                                                                    \
-    if(libssh2_sha##digest_type(m, m_len, hsh) == 0) {              \
-        rc = mbedtls_ecdsa_verify(&ctx->grp, hsh,                   \
-                                  SHA##digest_type##_DIGEST_LENGTH, \
-                                  &ctx->Q, &pr, &ps);               \
-    }                                                               \
-                                                                    \
-}
-
-/* _libssh2_ecdsa_sign
- *
- * Verifies the ECDSA signature of a hashed message
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_verify(libssh2_ecdsa_ctx *ctx,
-                              const unsigned char *r, size_t r_len,
-                              const unsigned char *s, size_t s_len,
-                              const unsigned char *m, size_t m_len)
-{
-    mbedtls_mpi pr, ps;
-    int rc = -1;
-
-    mbedtls_mpi_init(&pr);
-    mbedtls_mpi_init(&ps);
-
-    if(mbedtls_mpi_read_binary(&pr, r, r_len) != 0)
-        goto cleanup;
-
-    if(mbedtls_mpi_read_binary(&ps, s, s_len) != 0)
-        goto cleanup;
-
-    switch(_libssh2_ecdsa_get_curve_type(ctx)) {
-    case LIBSSH2_EC_CURVE_NISTP256:
-        LIBSSH2_MBEDTLS_ECDSA_VERIFY(256);
-        break;
-    case LIBSSH2_EC_CURVE_NISTP384:
-        LIBSSH2_MBEDTLS_ECDSA_VERIFY(384);
-        break;
-    case LIBSSH2_EC_CURVE_NISTP521:
-        LIBSSH2_MBEDTLS_ECDSA_VERIFY(512);
-        break;
-    default:
-        rc = -1;
-    }
-
-cleanup:
-
-    mbedtls_mpi_free(&pr);
-    mbedtls_mpi_free(&ps);
-
-    return (rc == 0) ? 0 : -1;
-}
-
-static int
-_libssh2_mbedtls_parse_eckey(libssh2_ecdsa_ctx **ctx,
-                             mbedtls_pk_context *pkey,
-                             LIBSSH2_SESSION *session,
-                             const unsigned char *data,
-                             size_t data_len,
-                             const unsigned char *pwd)
-{
-    size_t pwd_len;
-
-    pwd_len = pwd ? strlen((const char *) pwd) : 0;
-
-    if(mbedtls_pk_parse_key(pkey, data, data_len, pwd, pwd_len) != 0)
-        goto failed;
-
-    if(mbedtls_pk_get_type(pkey) != MBEDTLS_PK_ECKEY)
-        goto failed;
-
-    *ctx = LIBSSH2_ALLOC(session, sizeof(libssh2_ecdsa_ctx));
-
-    if(*ctx == NULL)
-        goto failed;
-
-    mbedtls_ecdsa_init(*ctx);
-
-    if(mbedtls_ecdsa_from_keypair(*ctx, mbedtls_pk_ec(*pkey)) == 0)
-        return 0;
-
-failed:
-
-    _libssh2_mbedtls_ecdsa_free(*ctx);
-    *ctx = NULL;
-
-    return -1;
-}
-
-static int
-_libssh2_mbedtls_parse_openssh_key(libssh2_ecdsa_ctx **ctx,
-                                   LIBSSH2_SESSION *session,
-                                   const unsigned char *data,
-                                   size_t data_len,
-                                   const unsigned char *pwd)
-{
-    libssh2_curve_type type;
-    unsigned char *name = NULL;
-    struct string_buf *decrypted = NULL;
-    size_t curvelen, exponentlen, pointlen;
-    unsigned char *curve, *exponent, *point_buf;
-
-    if(_libssh2_openssh_pem_parse_memory(session, pwd,
-                                         (const char *)data, data_len,
-                                         &decrypted) != 0)
-        goto failed;
-
-    if(_libssh2_get_string(decrypted, &name, NULL) != 0)
-        goto failed;
-
-    if(_libssh2_mbedtls_ecdsa_curve_type_from_name((const char *)name,
-                                                   &type) != 0)
-        goto failed;
-
-    if(_libssh2_get_string(decrypted, &curve, &curvelen) != 0)
-        goto failed;
-
-    if(_libssh2_get_string(decrypted, &point_buf, &pointlen) != 0)
-        goto failed;
-
-    if(_libssh2_get_bignum_bytes(decrypted, &exponent, &exponentlen) != 0)
-        goto failed;
-
-    *ctx = LIBSSH2_ALLOC(session, sizeof(libssh2_ecdsa_ctx));
-
-    if(*ctx == NULL)
-        goto failed;
-
-    mbedtls_ecdsa_init(*ctx);
-
-    if(mbedtls_ecp_group_load(&(*ctx)->grp, (mbedtls_ecp_group_id)type) != 0)
-        goto failed;
-
-    if(mbedtls_mpi_read_binary(&(*ctx)->d, exponent, exponentlen) != 0)
-        goto failed;
-
-    if(mbedtls_ecp_mul(&(*ctx)->grp, &(*ctx)->Q,
-                       &(*ctx)->d, &(*ctx)->grp.G,
-                       mbedtls_ctr_drbg_random,
-                       &_libssh2_mbedtls_ctr_drbg) != 0)
-        goto failed;
-
-    if(mbedtls_ecp_check_privkey(&(*ctx)->grp, &(*ctx)->d) == 0)
-        goto cleanup;
-
-failed:
-
-    _libssh2_mbedtls_ecdsa_free(*ctx);
-    *ctx = NULL;
-
-cleanup:
-
-    if(decrypted) {
-        _libssh2_string_buf_free(session, decrypted);
-    }
-
-    return (*ctx == NULL) ? -1 : 0;
-}
-
-/* _libssh2_ecdsa_new_private
- *
- * Creates a new private key given a file path and password
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_new_private(libssh2_ecdsa_ctx **ctx,
-                                   LIBSSH2_SESSION *session,
-                                   const char *filename,
-                                   const unsigned char *pwd)
-{
-    mbedtls_pk_context pkey;
-    unsigned char *data;
-    size_t data_len;
-
-    if(mbedtls_pk_load_file(filename, &data, &data_len) != 0)
-        goto cleanup;
-
-    mbedtls_pk_init(&pkey);
-
-    if(_libssh2_mbedtls_parse_eckey(ctx, &pkey, session,
-                                    data, data_len, pwd) == 0)
-        goto cleanup;
-
-    _libssh2_mbedtls_parse_openssh_key(ctx, session, data, data_len, pwd);
-
-cleanup:
-
-    mbedtls_pk_free(&pkey);
-
-    _libssh2_mbedtls_safe_free(data, data_len);
-
-    return (*ctx == NULL) ? -1 : 0;
-}
-
-/* _libssh2_ecdsa_new_private
- *
- * Creates a new private key given a file data and password
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx **ctx,
-                                              LIBSSH2_SESSION *session,
-                                              const char *data,
-                                              size_t data_len,
-                                              const unsigned char *pwd)
-{
-    unsigned char *ntdata;
-    mbedtls_pk_context pkey;
-
-    mbedtls_pk_init(&pkey);
-
-    ntdata = LIBSSH2_ALLOC(session, data_len + 1);
-
-    if(ntdata == NULL)
-        goto cleanup;
-
-    memcpy(ntdata, data, data_len);
-
-    if(_libssh2_mbedtls_parse_eckey(ctx, &pkey, session,
-                                    ntdata, data_len + 1, pwd) == 0)
-        goto cleanup;
-
-    _libssh2_mbedtls_parse_openssh_key(ctx, session,
-                                       ntdata, data_len + 1, pwd);
-
-cleanup:
-
-    mbedtls_pk_free(&pkey);
-
-    _libssh2_mbedtls_safe_free(ntdata, data_len);
-
-    return (*ctx == NULL) ? -1 : 0;
-}
-
-static unsigned char *
-_libssh2_mbedtls_mpi_write_binary(unsigned char *buf,
-                                  const mbedtls_mpi *mpi,
-                                  size_t bytes)
-{
-    unsigned char *p = buf;
-
-    if(sizeof(&p) / sizeof(p[0]) < 4) {
-        goto done;
-    }
-
-    p += 4;
-    *p = 0;
-
-    if(bytes > 0) {
-        mbedtls_mpi_write_binary(mpi, p + 1, bytes - 1);
-    }
-
-    if(bytes > 0 && !(*(p + 1) & 0x80)) {
-        memmove(p, p + 1, --bytes);
-    }
-
-    _libssh2_htonu32(p - 4, bytes);
-
-done:
-
-    return p + bytes;
-}
-
-/* _libssh2_ecdsa_sign
- *
- * Computes the ECDSA signature of a previously-hashed message
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
-                            libssh2_ecdsa_ctx *ctx,
-                            const unsigned char *hash,
-                            unsigned long hash_len,
-                            unsigned char **sign,
-                            size_t *sign_len)
-{
-    size_t r_len, s_len, tmp_sign_len = 0;
-    unsigned char *sp, *tmp_sign = NULL;
-    mbedtls_mpi pr, ps;
-
-    mbedtls_mpi_init(&pr);
-    mbedtls_mpi_init(&ps);
-
-    if(mbedtls_ecdsa_sign(&ctx->grp, &pr, &ps, &ctx->d,
-                          hash, hash_len,
-                          mbedtls_ctr_drbg_random,
-                          &_libssh2_mbedtls_ctr_drbg) != 0)
-        goto cleanup;
-
-    r_len = mbedtls_mpi_size(&pr) + 1;
-    s_len = mbedtls_mpi_size(&ps) + 1;
-    tmp_sign_len = r_len + s_len + 8;
-
-    tmp_sign = LIBSSH2_CALLOC(session, tmp_sign_len);
-
-    if(tmp_sign == NULL)
-        goto cleanup;
-
-    sp = tmp_sign;
-    sp = _libssh2_mbedtls_mpi_write_binary(sp, &pr, r_len);
-    sp = _libssh2_mbedtls_mpi_write_binary(sp, &ps, s_len);
-
-    *sign_len = (size_t)(sp - tmp_sign);
-
-    *sign = LIBSSH2_CALLOC(session, *sign_len);
-
-    if(*sign == NULL)
-        goto cleanup;
-
-    memcpy(*sign, tmp_sign, *sign_len);
-
-cleanup:
-
-    mbedtls_mpi_free(&pr);
-    mbedtls_mpi_free(&ps);
-
-    _libssh2_mbedtls_safe_free(tmp_sign, tmp_sign_len);
-
-    return (*sign == NULL) ? -1 : 0;
-}
-
-/* _libssh2_ecdsa_get_curve_type
- *
- * returns key curve type that maps to libssh2_curve_type
- *
- */
-
-libssh2_curve_type
-_libssh2_mbedtls_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ctx)
-{
-    return (libssh2_curve_type) ctx->grp.id;
-}
-
-/* _libssh2_ecdsa_curve_type_from_name
- *
- * returns 0 for success, key curve type that maps to libssh2_curve_type
- *
- */
-
-int
-_libssh2_mbedtls_ecdsa_curve_type_from_name(const char *name,
-                                            libssh2_curve_type *out_type)
-{
-    int ret = 0;
-    libssh2_curve_type type;
-
-    if(name == NULL || strlen(name) != 19)
-        return -1;
-
-    if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP256;
-    else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP384;
-    else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP521;
-    else {
-        ret = -1;
-    }
-
-    if(ret == 0 && out_type) {
-        *out_type = type;
-    }
-
-    return ret;
-}
-
-void
-_libssh2_mbedtls_ecdsa_free(libssh2_ecdsa_ctx *ctx)
-{
-    mbedtls_ecdsa_free(ctx);
-    mbedtls_free(ctx);
-}
-
-#endif /* LIBSSH2_ECDSA */
-#endif /* LIBSSH2_MBEDTLS */
diff --git a/libssh2/libssh2/src/mbedtls.h b/libssh2/libssh2/src/mbedtls.h
deleted file mode 100644
index 671932c5..00000000
--- a/libssh2/libssh2/src/mbedtls.h
+++ /dev/null
@@ -1,586 +0,0 @@
-#ifndef __LIBSSH2_MBEDTLS_H
-#define __LIBSSH2_MBEDTLS_H
-/* Copyright (c) 2016, Art <https://github.com/wildart>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <mbedtls/platform.h>
-#include <mbedtls/md.h>
-#include <mbedtls/rsa.h>
-#include <mbedtls/bignum.h>
-#include <mbedtls/cipher.h>
-#ifdef MBEDTLS_ECDH_C
-# include <mbedtls/ecdh.h>
-#endif
-#ifdef MBEDTLS_ECDSA_C
-# include <mbedtls/ecdsa.h>
-#endif
-#include <mbedtls/entropy.h>
-#include <mbedtls/ctr_drbg.h>
-#include <mbedtls/pk.h>
-#include <mbedtls/error.h>
-
-/* Define which features are supported. */
-#define LIBSSH2_MD5             1
-
-#define LIBSSH2_HMAC_RIPEMD     1
-#define LIBSSH2_HMAC_SHA256     1
-#define LIBSSH2_HMAC_SHA512     1
-
-#define LIBSSH2_AES             1
-#define LIBSSH2_AES_CTR         1
-#define LIBSSH2_BLOWFISH        1
-#define LIBSSH2_RC4             1
-#define LIBSSH2_CAST            0
-#define LIBSSH2_3DES            1
-
-#define LIBSSH2_RSA             1
-#define LIBSSH2_DSA             0
-#ifdef MBEDTLS_ECDSA_C
-# define LIBSSH2_ECDSA          1
-#else
-# define LIBSSH2_ECDSA          0
-#endif
-#define LIBSSH2_ED25519         0
-
-#define MD5_DIGEST_LENGTH      16
-#define SHA_DIGEST_LENGTH      20
-#define SHA256_DIGEST_LENGTH   32
-#define SHA384_DIGEST_LENGTH   48
-#define SHA512_DIGEST_LENGTH   64
-
-#define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Generic functions
- */
-
-#define libssh2_crypto_init() \
-  _libssh2_mbedtls_init()
-#define libssh2_crypto_exit() \
-  _libssh2_mbedtls_free()
-
-#define _libssh2_random(buf, len) \
-  _libssh2_mbedtls_random(buf, len)
-
-#define libssh2_prepare_iovec(vec, len)  /* Empty. */
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: HMAC functions
- */
-
-#define libssh2_hmac_ctx    mbedtls_md_context_t
-
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_cleanup(pctx) \
-  mbedtls_md_free(pctx)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  mbedtls_md_hmac_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, hash) \
-  mbedtls_md_hmac_finish(&ctx, hash)
-
-#define libssh2_hmac_sha1_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA1, key, keylen)
-#define libssh2_hmac_md5_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_MD5, key, keylen)
-#define libssh2_hmac_ripemd160_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_RIPEMD160, key, keylen)
-#define libssh2_hmac_sha256_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA256, key, keylen)
-#define libssh2_hmac_sha384_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA384, key, keylen)
-#define libssh2_hmac_sha512_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA512, key, keylen)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: SHA1 functions
- */
-
-#define libssh2_sha1_ctx      mbedtls_md_context_t
-
-#define libssh2_sha1_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA1, NULL, 0)
-#define libssh2_sha1_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha1_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_sha1(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA1, hash)
-
-/*******************************************************************/
-/*
- * mbedTLS backend: SHA256 functions
- */
-
-#define libssh2_sha256_ctx      mbedtls_md_context_t
-
-#define libssh2_sha256_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA256, NULL, 0)
-#define libssh2_sha256_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha256_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_sha256(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA256, hash)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: SHA384 functions
- */
-
-#define libssh2_sha384_ctx      mbedtls_md_context_t
-
-#define libssh2_sha384_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA384, NULL, 0)
-#define libssh2_sha384_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha384_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_sha384(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA384, hash)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: SHA512 functions
- */
-
-#define libssh2_sha512_ctx      mbedtls_md_context_t
-
-#define libssh2_sha512_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA512, NULL, 0)
-#define libssh2_sha512_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha512_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_sha512(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA512, hash)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: MD5 functions
- */
-
-#define libssh2_md5_ctx      mbedtls_md_context_t
-
-#define libssh2_md5_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_MD5, NULL, 0)
-#define libssh2_md5_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_md5_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_md5(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_MD5, hash)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: RSA functions
- */
-
-#define libssh2_rsa_ctx  mbedtls_rsa_context
-
-#define _libssh2_rsa_new(rsactx, e, e_len, n, n_len, \
-                         d, d_len, p, p_len, q, q_len, \
-                         e1, e1_len, e2, e2_len, c, c_len) \
-  _libssh2_mbedtls_rsa_new(rsactx, e, e_len, n, n_len, \
-                          d, d_len, p, p_len, q, q_len, \
-                          e1, e1_len, e2, e2_len, c, c_len)
-
-#define _libssh2_rsa_new_private(rsactx, s, filename, passphrase) \
-  _libssh2_mbedtls_rsa_new_private(rsactx, s, filename, passphrase)
-
-#define _libssh2_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                            filedata_len, passphrase) \
-  _libssh2_mbedtls_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                             filedata_len, passphrase)
-
-#define _libssh2_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len) \
-  _libssh2_mbedtls_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
-
-#define _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len) \
-  _libssh2_mbedtls_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
-
-#define _libssh2_rsa_free(rsactx) \
-  _libssh2_mbedtls_rsa_free(rsactx)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: ECDSA structures
- */
-
-#if LIBSSH2_ECDSA
-
-typedef enum {
-#ifdef MBEDTLS_ECP_DP_SECP256R1_ENABLED
-    LIBSSH2_EC_CURVE_NISTP256 = MBEDTLS_ECP_DP_SECP256R1,
-#else
-    LIBSSH2_EC_CURVE_NISTP256 = MBEDTLS_ECP_DP_NONE,
-#endif
-#ifdef MBEDTLS_ECP_DP_SECP384R1_ENABLED
-    LIBSSH2_EC_CURVE_NISTP384 = MBEDTLS_ECP_DP_SECP384R1,
-#else
-    LIBSSH2_EC_CURVE_NISTP384 = MBEDTLS_ECP_DP_NONE,
-#endif
-#ifdef MBEDTLS_ECP_DP_SECP521R1_ENABLED
-    LIBSSH2_EC_CURVE_NISTP521 = MBEDTLS_ECP_DP_SECP521R1
-#else
-    LIBSSH2_EC_CURVE_NISTP521 = MBEDTLS_ECP_DP_NONE,
-#endif
-} libssh2_curve_type;
-
-# define _libssh2_ec_key mbedtls_ecp_keypair
-#else
-# define _libssh2_ec_key void
-#endif /* LIBSSH2_ECDSA */
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: ECDSA functions
- */
-
-#if LIBSSH2_ECDSA
-
-#define libssh2_ecdsa_ctx mbedtls_ecdsa_context
-
-#define _libssh2_ecdsa_create_key(session, privkey, pubkey_octal, \
-                                  pubkey_octal_len, curve) \
-  _libssh2_mbedtls_ecdsa_create_key(session, privkey, pubkey_octal, \
-                                    pubkey_octal_len, curve)
-
-#define _libssh2_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve) \
-  _libssh2_mbedtls_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve)
-
-#define _libssh2_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len) \
-  _libssh2_mbedtls_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len)
-
-#define _libssh2_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len) \
-  _libssh2_mbedtls_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len)
-
-#define _libssh2_ecdsa_new_private(ctx, session, filename, passphrase) \
-  _libssh2_mbedtls_ecdsa_new_private(ctx, session, filename, passphrase)
-
-#define _libssh2_ecdsa_new_private_frommemory(ctx, session, filedata, \
-                                              filedata_len, passphrase) \
-  _libssh2_mbedtls_ecdsa_new_private_frommemory(ctx, session, filedata, \
-                                                filedata_len, passphrase)
-
-#define _libssh2_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len) \
-  _libssh2_mbedtls_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len)
-
-#define _libssh2_ecdsa_get_curve_type(ctx) \
-  _libssh2_mbedtls_ecdsa_get_curve_type(ctx)
-
-#define _libssh2_ecdsa_free(ctx) \
-  _libssh2_mbedtls_ecdsa_free(ctx)
-
-#endif /* LIBSSH2_ECDSA */
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Key functions
- */
-
-#define _libssh2_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw) \
-  _libssh2_mbedtls_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
-#define _libssh2_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                     pk, pk_len, pw) \
-  _libssh2_mbedtls_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                      pk, pk_len, pw)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Cipher Context structure
- */
-
-#define _libssh2_cipher_ctx         mbedtls_cipher_context_t
-
-#define _libssh2_cipher_type(algo)  mbedtls_cipher_type_t algo
-
-#define _libssh2_cipher_aes256ctr MBEDTLS_CIPHER_AES_256_CTR
-#define _libssh2_cipher_aes192ctr MBEDTLS_CIPHER_AES_192_CTR
-#define _libssh2_cipher_aes128ctr MBEDTLS_CIPHER_AES_128_CTR
-#define _libssh2_cipher_aes256    MBEDTLS_CIPHER_AES_256_CBC
-#define _libssh2_cipher_aes192    MBEDTLS_CIPHER_AES_192_CBC
-#define _libssh2_cipher_aes128    MBEDTLS_CIPHER_AES_128_CBC
-#define _libssh2_cipher_blowfish  MBEDTLS_CIPHER_BLOWFISH_CBC
-#define _libssh2_cipher_arcfour   MBEDTLS_CIPHER_ARC4_128
-#define _libssh2_cipher_cast5     MBEDTLS_CIPHER_NULL
-#define _libssh2_cipher_3des      MBEDTLS_CIPHER_DES_EDE3_CBC
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Cipher functions
- */
-
-#define _libssh2_cipher_init(ctx, type, iv, secret, encrypt) \
-  _libssh2_mbedtls_cipher_init(ctx, type, iv, secret, encrypt)
-#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen) \
-  _libssh2_mbedtls_cipher_crypt(ctx, type, encrypt, block, blocklen)
-#define _libssh2_cipher_dtor(ctx) \
-  _libssh2_mbedtls_cipher_dtor(ctx)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: BigNumber Support
- */
-
-#define _libssh2_bn_ctx int /* not used */
-#define _libssh2_bn_ctx_new() 0 /* not used */
-#define _libssh2_bn_ctx_free(bnctx) ((void)0) /* not used */
-
-#define _libssh2_bn mbedtls_mpi
-
-#define _libssh2_bn_init() \
-  _libssh2_mbedtls_bignum_init()
-#define _libssh2_bn_init_from_bin() \
-  _libssh2_mbedtls_bignum_init()
-#define _libssh2_bn_set_word(bn, word) \
-  mbedtls_mpi_lset(bn, word)
-#define _libssh2_bn_from_bin(bn, len, bin) \
-  mbedtls_mpi_read_binary(bn, bin, len)
-#define _libssh2_bn_to_bin(bn, bin) \
-  mbedtls_mpi_write_binary(bn, bin, mbedtls_mpi_size(bn))
-#define _libssh2_bn_bytes(bn) \
-  mbedtls_mpi_size(bn)
-#define _libssh2_bn_bits(bn) \
-  mbedtls_mpi_bitlen(bn)
-#define _libssh2_bn_free(bn) \
-  _libssh2_mbedtls_bignum_free(bn)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: Diffie-Hellman support.
- */
-
-#define _libssh2_dh_ctx mbedtls_mpi *
-#define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
-#define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
-#define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
-#define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
-
-
-/*******************************************************************/
-/*
- * mbedTLS backend: forward declarations
- */
-
-void
-_libssh2_mbedtls_init(void);
-
-void
-_libssh2_mbedtls_free(void);
-
-int
-_libssh2_mbedtls_random(unsigned char *buf, int len);
-
-int
-_libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
-                            _libssh2_cipher_type(type),
-                            unsigned char *iv,
-                            unsigned char *secret,
-                            int encrypt);
-int
-_libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(type),
-                             int encrypt,
-                             unsigned char *block,
-                             size_t blocklen);
-void
-_libssh2_mbedtls_cipher_dtor(_libssh2_cipher_ctx *ctx);
-
-int
-_libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
-                          mbedtls_md_type_t mdtype,
-                          const unsigned char *key, unsigned long keylen);
-
-int
-_libssh2_mbedtls_hash_final(mbedtls_md_context_t *ctx, unsigned char *hash);
-int
-_libssh2_mbedtls_hash(const unsigned char *data, unsigned long datalen,
-                      mbedtls_md_type_t mdtype, unsigned char *hash);
-
-_libssh2_bn *
-_libssh2_mbedtls_bignum_init(void);
-
-void
-_libssh2_mbedtls_bignum_free(_libssh2_bn *bn);
-
-int
-_libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen);
-
-int
-_libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-
-int
-_libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_mbedtls_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len);
-void
-_libssh2_mbedtls_rsa_free(libssh2_rsa_ctx *rsa);
-
-int
-_libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase);
-int
-_libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase);
-#if LIBSSH2_ECDSA
-int
-_libssh2_mbedtls_ecdsa_create_key(LIBSSH2_SESSION *session,
-                                  _libssh2_ec_key **privkey,
-                                  unsigned char **pubkey_octal,
-                                  size_t *pubkey_octal_len,
-                                  libssh2_curve_type curve);
-int
-_libssh2_mbedtls_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx **ctx,
-                                                 const unsigned char *k,
-                                                 size_t k_len,
-                                                 libssh2_curve_type curve);
-int
-_libssh2_mbedtls_ecdh_gen_k(_libssh2_bn **k,
-                            _libssh2_ec_key *privkey,
-                            const unsigned char *server_pubkey,
-                            size_t server_pubkey_len);
-int
-_libssh2_mbedtls_ecdsa_verify(libssh2_ecdsa_ctx *ctx,
-                              const unsigned char *r, size_t r_len,
-                              const unsigned char *s, size_t s_len,
-                              const unsigned char *m, size_t m_len);
-int
-_libssh2_mbedtls_ecdsa_new_private(libssh2_ecdsa_ctx **ctx,
-                                  LIBSSH2_SESSION *session,
-                                  const char *filename,
-                                  const unsigned char *passphrase);
-int
-_libssh2_mbedtls_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx **ctx,
-                                              LIBSSH2_SESSION *session,
-                                              const char *filedata,
-                                              size_t filedata_len,
-                                              const unsigned char *passphrase);
-int
-_libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
-                            libssh2_ecdsa_ctx *ctx,
-                            const unsigned char *hash,
-                            unsigned long hash_len,
-                            unsigned char **signature,
-                            size_t *signature_len);
-libssh2_curve_type
-_libssh2_mbedtls_ecdsa_key_get_curve_type(libssh2_ecdsa_ctx *ctx);
-int
-_libssh2_mbedtls_ecdsa_curve_type_from_name(const char *name,
-                                            libssh2_curve_type *type);
-void
-_libssh2_mbedtls_ecdsa_free(libssh2_ecdsa_ctx *ctx);
-#endif /* LIBSSH2_ECDSA */
-
-extern void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx);
-extern int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                    _libssh2_bn *g, _libssh2_bn *p, int group_order);
-extern int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                  _libssh2_bn *f, _libssh2_bn *p);
-extern void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
-
-#endif /* __LIBSSH2_MBEDTLS_H */
diff --git a/libssh2/libssh2/src/misc.c b/libssh2/libssh2/src/misc.c
deleted file mode 100644
index 594b2d1f..00000000
--- a/libssh2/libssh2/src/misc.c
+++ /dev/null
@@ -1,872 +0,0 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2019 by Daniel Stenberg
- * Copyright (c) 2010  Simon Josefsson
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "misc.h"
-#include "blf.h"
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#if defined(HAVE_DECL_SECUREZEROMEMORY) && HAVE_DECL_SECUREZEROMEMORY
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-
-int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode,
-                         const char *errmsg, int errflags)
-{
-    if(session->err_flags & LIBSSH2_ERR_FLAG_DUP)
-        LIBSSH2_FREE(session, (char *)session->err_msg);
-
-    session->err_code = errcode;
-    session->err_flags = 0;
-
-    if((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
-        size_t len = strlen(errmsg);
-        char *copy = LIBSSH2_ALLOC(session, len + 1);
-        if(copy) {
-            memcpy(copy, errmsg, len + 1);
-            session->err_flags = LIBSSH2_ERR_FLAG_DUP;
-            session->err_msg = copy;
-        }
-        else
-            /* Out of memory: this code path is very unlikely */
-            session->err_msg = "former error forgotten (OOM)";
-    }
-    else
-        session->err_msg = errmsg;
-
-#ifdef LIBSSH2DEBUG
-    if((errcode == LIBSSH2_ERROR_EAGAIN) && !session->api_block_mode)
-        /* if this is EAGAIN and we're in non-blocking mode, don't generate
-           a debug output for this */
-        return errcode;
-    _libssh2_debug(session, LIBSSH2_TRACE_ERROR, "%d - %s", session->err_code,
-                   session->err_msg);
-#endif
-
-    return errcode;
-}
-
-int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg)
-{
-    return _libssh2_error_flags(session, errcode, errmsg, 0);
-}
-
-#ifdef WIN32
-static int wsa2errno(void)
-{
-    switch(WSAGetLastError()) {
-    case WSAEWOULDBLOCK:
-        return EAGAIN;
-
-    case WSAENOTSOCK:
-        return EBADF;
-
-    case WSAEINTR:
-        return EINTR;
-
-    default:
-        /* It is most important to ensure errno does not stay at EAGAIN
-         * when a different error occurs so just set errno to a generic
-         * error */
-        return EIO;
-    }
-}
-#endif
-
-/* _libssh2_recv
- *
- * Replacement for the standard recv, return -errno on failure.
- */
-ssize_t
-_libssh2_recv(libssh2_socket_t sock, void *buffer, size_t length,
-              int flags, void **abstract)
-{
-    ssize_t rc;
-
-    (void) abstract;
-
-    rc = recv(sock, buffer, length, flags);
-#ifdef WIN32
-    if(rc < 0)
-        return -wsa2errno();
-#else
-    if(rc < 0) {
-        /* Sometimes the first recv() function call sets errno to ENOENT on
-           Solaris and HP-UX */
-        if(errno == ENOENT)
-            return -EAGAIN;
-#ifdef EWOULDBLOCK /* For VMS and other special unixes */
-        else if(errno == EWOULDBLOCK)
-          return -EAGAIN;
-#endif
-        else
-            return -errno;
-    }
-#endif
-    return rc;
-}
-
-/* _libssh2_send
- *
- * Replacement for the standard send, return -errno on failure.
- */
-ssize_t
-_libssh2_send(libssh2_socket_t sock, const void *buffer, size_t length,
-              int flags, void **abstract)
-{
-    ssize_t rc;
-
-    (void) abstract;
-
-    rc = send(sock, buffer, length, flags);
-#ifdef WIN32
-    if(rc < 0)
-        return -wsa2errno();
-#else
-    if(rc < 0) {
-#ifdef EWOULDBLOCK /* For VMS and other special unixes */
-      if(errno == EWOULDBLOCK)
-        return -EAGAIN;
-#endif
-      return -errno;
-    }
-#endif
-    return rc;
-}
-
-/* libssh2_ntohu32
- */
-unsigned int
-_libssh2_ntohu32(const unsigned char *buf)
-{
-    return (((unsigned int)buf[0] << 24)
-           | ((unsigned int)buf[1] << 16)
-           | ((unsigned int)buf[2] << 8)
-           | ((unsigned int)buf[3]));
-}
-
-
-/* _libssh2_ntohu64
- */
-libssh2_uint64_t
-_libssh2_ntohu64(const unsigned char *buf)
-{
-    unsigned long msl, lsl;
-
-    msl = ((libssh2_uint64_t)buf[0] << 24) | ((libssh2_uint64_t)buf[1] << 16)
-        | ((libssh2_uint64_t)buf[2] << 8) | (libssh2_uint64_t)buf[3];
-    lsl = ((libssh2_uint64_t)buf[4] << 24) | ((libssh2_uint64_t)buf[5] << 16)
-        | ((libssh2_uint64_t)buf[6] << 8) | (libssh2_uint64_t)buf[7];
-
-    return ((libssh2_uint64_t)msl <<32) | lsl;
-}
-
-/* _libssh2_htonu32
- */
-void
-_libssh2_htonu32(unsigned char *buf, uint32_t value)
-{
-    buf[0] = (value >> 24) & 0xFF;
-    buf[1] = (value >> 16) & 0xFF;
-    buf[2] = (value >> 8) & 0xFF;
-    buf[3] = value & 0xFF;
-}
-
-/* _libssh2_store_u32
- */
-void _libssh2_store_u32(unsigned char **buf, uint32_t value)
-{
-    _libssh2_htonu32(*buf, value);
-    *buf += sizeof(uint32_t);
-}
-
-/* _libssh2_store_str
- */
-void _libssh2_store_str(unsigned char **buf, const char *str, size_t len)
-{
-    _libssh2_store_u32(buf, (uint32_t)len);
-    if(len) {
-        memcpy(*buf, str, len);
-        *buf += len;
-    }
-}
-
-/* Base64 Conversion */
-
-static const short base64_reverse_table[256] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-    -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-};
-
-/* libssh2_base64_decode
- *
- * Decode a base64 chunk and store it into a newly alloc'd buffer
- */
-LIBSSH2_API int
-libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
-                      unsigned int *datalen, const char *src,
-                      unsigned int src_len)
-{
-    unsigned char *s, *d;
-    short v;
-    int i = 0, len = 0;
-
-    *data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1);
-    d = (unsigned char *) *data;
-    if(!d) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for base64 decoding");
-    }
-
-    for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) {
-        v = base64_reverse_table[*s];
-        if(v < 0)
-            continue;
-        switch(i % 4) {
-        case 0:
-            d[len] = (unsigned char)(v << 2);
-            break;
-        case 1:
-            d[len++] |= v >> 4;
-            d[len] = (unsigned char)(v << 4);
-            break;
-        case 2:
-            d[len++] |= v >> 2;
-            d[len] = (unsigned char)(v << 6);
-            break;
-        case 3:
-            d[len++] |= v;
-            break;
-        }
-        i++;
-    }
-    if((i % 4) == 1) {
-        /* Invalid -- We have a byte which belongs exclusively to a partial
-           octet */
-        LIBSSH2_FREE(session, *data);
-        *data = NULL;
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL, "Invalid base64");
-    }
-
-    *datalen = len;
-    return 0;
-}
-
-/* ---- Base64 Encoding/Decoding Table --- */
-static const char table64[]=
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/*
- * _libssh2_base64_encode()
- *
- * Returns the length of the newly created base64 string. The third argument
- * is a pointer to an allocated area holding the base64 data. If something
- * went wrong, 0 is returned.
- *
- */
-size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
-                              const char *inp, size_t insize, char **outptr)
-{
-    unsigned char ibuf[3];
-    unsigned char obuf[4];
-    int i;
-    int inputparts;
-    char *output;
-    char *base64data;
-    const char *indata = inp;
-
-    *outptr = NULL; /* set to NULL in case of failure before we reach the
-                       end */
-
-    if(0 == insize)
-        insize = strlen(indata);
-
-    base64data = output = LIBSSH2_ALLOC(session, insize * 4 / 3 + 4);
-    if(NULL == output)
-        return 0;
-
-    while(insize > 0) {
-        for(i = inputparts = 0; i < 3; i++) {
-            if(insize > 0) {
-                inputparts++;
-                ibuf[i] = *indata;
-                indata++;
-                insize--;
-            }
-            else
-                ibuf[i] = 0;
-        }
-
-        obuf[0] = (unsigned char)  ((ibuf[0] & 0xFC) >> 2);
-        obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
-                                   ((ibuf[1] & 0xF0) >> 4));
-        obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
-                                   ((ibuf[2] & 0xC0) >> 6));
-        obuf[3] = (unsigned char)   (ibuf[2] & 0x3F);
-
-        switch(inputparts) {
-        case 1: /* only one byte read */
-            snprintf(output, 5, "%c%c==",
-                     table64[obuf[0]],
-                     table64[obuf[1]]);
-            break;
-        case 2: /* two bytes read */
-            snprintf(output, 5, "%c%c%c=",
-                     table64[obuf[0]],
-                     table64[obuf[1]],
-                     table64[obuf[2]]);
-            break;
-        default:
-            snprintf(output, 5, "%c%c%c%c",
-                     table64[obuf[0]],
-                     table64[obuf[1]],
-                     table64[obuf[2]],
-                     table64[obuf[3]]);
-            break;
-        }
-        output += 4;
-    }
-    *output = 0;
-    *outptr = base64data; /* make it return the actual data memory */
-
-    return strlen(base64data); /* return the length of the new data */
-}
-/* ---- End of Base64 Encoding ---- */
-
-LIBSSH2_API void
-libssh2_free(LIBSSH2_SESSION *session, void *ptr)
-{
-    LIBSSH2_FREE(session, ptr);
-}
-
-#ifdef LIBSSH2DEBUG
-#include <stdarg.h>
-
-LIBSSH2_API int
-libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
-{
-    session->showmask = bitmask;
-    return 0;
-}
-
-LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
-                         libssh2_trace_handler_func callback)
-{
-    session->tracehandler = callback;
-    session->tracehandler_context = handler_context;
-    return 0;
-}
-
-void
-_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
-{
-    char buffer[1536];
-    int len, msglen, buflen = sizeof(buffer);
-    va_list vargs;
-    struct timeval now;
-    static int firstsec;
-    static const char *const contexts[] = {
-        "Unknown",
-        "Transport",
-        "Key Ex",
-        "Userauth",
-        "Conn",
-        "SCP",
-        "SFTP",
-        "Failure Event",
-        "Publickey",
-        "Socket",
-    };
-    const char *contexttext = contexts[0];
-    unsigned int contextindex;
-
-    if(!(session->showmask & context)) {
-        /* no such output asked for */
-        return;
-    }
-
-    /* Find the first matching context string for this message */
-    for(contextindex = 0; contextindex < ARRAY_SIZE(contexts);
-         contextindex++) {
-        if((context & (1 << contextindex)) != 0) {
-            contexttext = contexts[contextindex];
-            break;
-        }
-    }
-
-    _libssh2_gettimeofday(&now, NULL);
-    if(!firstsec) {
-        firstsec = now.tv_sec;
-    }
-    now.tv_sec -= firstsec;
-
-    len = snprintf(buffer, buflen, "[libssh2] %d.%06d %s: ",
-                   (int)now.tv_sec, (int)now.tv_usec, contexttext);
-
-    if(len >= buflen)
-        msglen = buflen - 1;
-    else {
-        buflen -= len;
-        msglen = len;
-        va_start(vargs, format);
-        len = vsnprintf(buffer + msglen, buflen, format, vargs);
-        va_end(vargs);
-        msglen += len < buflen ? len : buflen - 1;
-    }
-
-    if(session->tracehandler)
-        (session->tracehandler)(session, session->tracehandler_context, buffer,
-                                msglen);
-    else
-        fprintf(stderr, "%s\n", buffer);
-}
-
-#else
-LIBSSH2_API int
-libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
-{
-    (void) session;
-    (void) bitmask;
-    return 0;
-}
-
-LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
-                         libssh2_trace_handler_func callback)
-{
-    (void) session;
-    (void) handler_context;
-    (void) callback;
-    return 0;
-}
-#endif
-
-/* init the list head */
-void _libssh2_list_init(struct list_head *head)
-{
-    head->first = head->last = NULL;
-}
-
-/* add a node to the list */
-void _libssh2_list_add(struct list_head *head,
-                       struct list_node *entry)
-{
-    /* store a pointer to the head */
-    entry->head = head;
-
-    /* we add this entry at the "top" so it has no next */
-    entry->next = NULL;
-
-    /* make our prev point to what the head thinks is last */
-    entry->prev = head->last;
-
-    /* and make head's last be us now */
-    head->last = entry;
-
-    /* make sure our 'prev' node points to us next */
-    if(entry->prev)
-        entry->prev->next = entry;
-    else
-        head->first = entry;
-}
-
-/* return the "first" node in the list this head points to */
-void *_libssh2_list_first(struct list_head *head)
-{
-    return head->first;
-}
-
-/* return the next node in the list */
-void *_libssh2_list_next(struct list_node *node)
-{
-    return node->next;
-}
-
-/* return the prev node in the list */
-void *_libssh2_list_prev(struct list_node *node)
-{
-    return node->prev;
-}
-
-/* remove this node from the list */
-void _libssh2_list_remove(struct list_node *entry)
-{
-    if(entry->prev)
-        entry->prev->next = entry->next;
-    else
-        entry->head->first = entry->next;
-
-    if(entry->next)
-        entry->next->prev = entry->prev;
-    else
-        entry->head->last = entry->prev;
-}
-
-#if 0
-/* insert a node before the given 'after' entry */
-void _libssh2_list_insert(struct list_node *after, /* insert before this */
-                          struct list_node *entry)
-{
-    /* 'after' is next to 'entry' */
-    bentry->next = after;
-
-    /* entry's prev is then made to be the prev after current has */
-    entry->prev = after->prev;
-
-    /* the node that is now before 'entry' was previously before 'after'
-       and must be made to point to 'entry' correctly */
-    if(entry->prev)
-        entry->prev->next = entry;
-    else
-      /* there was no node before this, so we make sure we point the head
-         pointer to this node */
-      after->head->first = entry;
-
-    /* after's prev entry points back to entry */
-    after->prev = entry;
-
-    /* after's next entry is still the same as before */
-
-    /* entry's head is the same as after's */
-    entry->head = after->head;
-}
-
-#endif
-
-/* this define is defined in misc.h for the correct platforms */
-#ifdef LIBSSH2_GETTIMEOFDAY_WIN32
-/*
- * gettimeofday
- * Implementation according to:
- * The Open Group Base Specifications Issue 6
- * IEEE Std 1003.1, 2004 Edition
- */
-
-/*
- *  THIS SOFTWARE IS NOT COPYRIGHTED
- *
- *  This source code is offered for use in the public domain. You may
- *  use, modify or distribute it freely.
- *
- *  This code is distributed in the hope that it will be useful but
- *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
- *  DISCLAIMED. This includes but is not limited to warranties of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- *  Contributed by:
- *  Danny Smith <dannysmith@users.sourceforge.net>
- */
-
-/* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
-#define _W32_FT_OFFSET (116444736000000000)
-
-int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp)
-{
-    union {
-        unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */
-        FILETIME ft;
-    } _now;
-    (void)tzp;
-    if(tp) {
-        GetSystemTimeAsFileTime(&_now.ft);
-        tp->tv_usec = (long)((_now.ns100 / 10) % 1000000);
-        tp->tv_sec = (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
-    }
-    /* Always return 0 as per Open Group Base Specifications Issue 6.
-       Do not set errno on error.  */
-    return 0;
-}
-
-
-#endif
-
-void *_libssh2_calloc(LIBSSH2_SESSION* session, size_t size)
-{
-    void *p = LIBSSH2_ALLOC(session, size);
-    if(p) {
-        memset(p, 0, size);
-    }
-    return p;
-}
-
-/* XOR operation on buffers input1 and input2, result in output.
-   It is safe to use an input buffer as the output buffer. */
-void _libssh2_xor_data(unsigned char *output,
-                       const unsigned char *input1,
-                       const unsigned char *input2,
-                       size_t length)
-{
-    size_t i;
-
-    for(i = 0; i < length; i++)
-        *output++ = *input1++ ^ *input2++;
-}
-
-/* Increments an AES CTR buffer to prepare it for use with the
-   next AES block. */
-void _libssh2_aes_ctr_increment(unsigned char *ctr,
-                                size_t length)
-{
-    unsigned char *pc;
-    unsigned int val, carry;
-
-    pc = ctr + length - 1;
-    carry = 1;
-
-    while(pc >= ctr) {
-        val = (unsigned int)*pc + carry;
-        *pc-- = val & 0xFF;
-        carry = val >> 8;
-    }
-}
-
-#ifdef WIN32
-static void * (__cdecl * const volatile memset_libssh)(void *, int, size_t) =
-    memset;
-#else
-static void * (* const volatile memset_libssh)(void *, int, size_t) = memset;
-#endif
-
-void _libssh2_explicit_zero(void *buf, size_t size)
-{
-#if defined(HAVE_DECL_SECUREZEROMEMORY) && HAVE_DECL_SECUREZEROMEMORY
-    SecureZeroMemory(buf, size);
-    (void)memset_libssh; /* Silence unused variable warning */
-#elif defined(HAVE_MEMSET_S)
-    (void)memset_s(buf, size, 0, size);
-    (void)memset_libssh; /* Silence unused variable warning */
-#else
-    memset_libssh(buf, 0, size);
-#endif
-}
-
-/* String buffer */
-
-struct string_buf* _libssh2_string_buf_new(LIBSSH2_SESSION *session)
-{
-    struct string_buf *ret;
-
-    ret = _libssh2_calloc(session, sizeof(*ret));
-    if(ret == NULL)
-        return NULL;
-
-    return ret;
-}
-
-void _libssh2_string_buf_free(LIBSSH2_SESSION *session, struct string_buf *buf)
-{
-    if(buf == NULL)
-        return;
-
-    if(buf->data != NULL)
-        LIBSSH2_FREE(session, buf->data);
-
-    LIBSSH2_FREE(session, buf);
-    buf = NULL;
-}
-
-int _libssh2_get_u32(struct string_buf *buf, uint32_t *out)
-{
-    if(!_libssh2_check_length(buf, 4)) {
-        return -1;
-    }
-
-    *out = _libssh2_ntohu32(buf->dataptr);
-    buf->dataptr += 4;
-    return 0;
-}
-
-int _libssh2_get_u64(struct string_buf *buf, libssh2_uint64_t *out)
-{
-    if(!_libssh2_check_length(buf, 8)) {
-        return -1;
-    }
-
-    *out = _libssh2_ntohu64(buf->dataptr);
-    buf->dataptr += 8;
-    return 0;
-}
-
-int _libssh2_match_string(struct string_buf *buf, const char *match)
-{
-    unsigned char *out;
-    size_t len = 0;
-    if(_libssh2_get_string(buf, &out, &len) || len != strlen(match) ||
-        strncmp((char *)out, match, strlen(match)) != 0) {
-        return -1;
-    }
-    return 0;
-}
-
-int _libssh2_get_string(struct string_buf *buf, unsigned char **outbuf,
-                        size_t *outlen)
-{
-    uint32_t data_len;
-    if(_libssh2_get_u32(buf, &data_len) != 0) {
-        return -1;
-    }
-    if(!_libssh2_check_length(buf, data_len)) {
-        return -1;
-    }
-    *outbuf = buf->dataptr;
-    buf->dataptr += data_len;
-
-    if(outlen)
-        *outlen = (size_t)data_len;
-
-    return 0;
-}
-
-int _libssh2_copy_string(LIBSSH2_SESSION *session, struct string_buf *buf,
-                         unsigned char **outbuf, size_t *outlen)
-{
-    size_t str_len;
-    unsigned char *str;
-
-    if(_libssh2_get_string(buf, &str, &str_len)) {
-        return -1;
-    }
-
-    *outbuf = LIBSSH2_ALLOC(session, str_len);
-    if(*outbuf) {
-        memcpy(*outbuf, str, str_len);
-    }
-    else {
-        return -1;
-    }
-
-    if(outlen)
-        *outlen = str_len;
-
-    return 0;
-}
-
-int _libssh2_get_bignum_bytes(struct string_buf *buf, unsigned char **outbuf,
-                              size_t *outlen)
-{
-    uint32_t data_len;
-    uint32_t bn_len;
-    unsigned char *bnptr;
-
-    if(_libssh2_get_u32(buf, &data_len)) {
-        return -1;
-    }
-    if(!_libssh2_check_length(buf, data_len)) {
-        return -1;
-    }
-
-    bn_len = data_len;
-    bnptr = buf->dataptr;
-
-    /* trim leading zeros */
-    while(bn_len > 0 && *bnptr == 0x00) {
-        bn_len--;
-        bnptr++;
-    }
-
-    *outbuf = bnptr;
-    buf->dataptr += data_len;
-
-    if(outlen)
-        *outlen = (size_t)bn_len;
-
-    return 0;
-}
-
-/* Given the current location in buf, _libssh2_check_length ensures
-   callers can read the next len number of bytes out of the buffer
-   before reading the buffer content */
-
-int _libssh2_check_length(struct string_buf *buf, size_t len)
-{
-    unsigned char *endp = &buf->data[buf->len];
-    size_t left = endp - buf->dataptr;
-    return ((len <= left) && (left <= buf->len));
-}
-
-/* Wrappers */
-
-int _libssh2_bcrypt_pbkdf(const char *pass,
-                          size_t passlen,
-                          const uint8_t *salt,
-                          size_t saltlen,
-                          uint8_t *key,
-                          size_t keylen,
-                          unsigned int rounds)
-{
-    /* defined in bcrypt_pbkdf.c */
-    return bcrypt_pbkdf(pass,
-                        passlen,
-                        salt,
-                        saltlen,
-                        key,
-                        keylen,
-                        rounds);
-}
diff --git a/libssh2/libssh2/src/misc.h b/libssh2/libssh2/src/misc.h
deleted file mode 100644
index 5481e666..00000000
--- a/libssh2/libssh2/src/misc.h
+++ /dev/null
@@ -1,125 +0,0 @@
-#ifndef __LIBSSH2_MISC_H
-#define __LIBSSH2_MISC_H
-/* Copyright (c) 2009-2019 by Daniel Stenberg
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-struct list_head {
-    struct list_node *last;
-    struct list_node *first;
-};
-
-struct list_node {
-    struct list_node *next;
-    struct list_node *prev;
-    struct list_head *head;
-};
-
-struct string_buf {
-    unsigned char *data;
-    unsigned char *dataptr;
-    size_t len;
-};
-
-int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode,
-                         const char *errmsg, int errflags);
-int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg);
-
-void _libssh2_list_init(struct list_head *head);
-
-/* add a node last in the list */
-void _libssh2_list_add(struct list_head *head,
-                       struct list_node *entry);
-
-/* return the "first" node in the list this head points to */
-void *_libssh2_list_first(struct list_head *head);
-
-/* return the next node in the list */
-void *_libssh2_list_next(struct list_node *node);
-
-/* return the prev node in the list */
-void *_libssh2_list_prev(struct list_node *node);
-
-/* remove this node from the list */
-void _libssh2_list_remove(struct list_node *entry);
-
-size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
-                              const char *inp, size_t insize, char **outptr);
-
-unsigned int _libssh2_ntohu32(const unsigned char *buf);
-libssh2_uint64_t _libssh2_ntohu64(const unsigned char *buf);
-void _libssh2_htonu32(unsigned char *buf, uint32_t val);
-void _libssh2_store_u32(unsigned char **buf, uint32_t value);
-void _libssh2_store_str(unsigned char **buf, const char *str, size_t len);
-void *_libssh2_calloc(LIBSSH2_SESSION *session, size_t size);
-void _libssh2_explicit_zero(void *buf, size_t size);
-
-struct string_buf* _libssh2_string_buf_new(LIBSSH2_SESSION *session);
-void _libssh2_string_buf_free(LIBSSH2_SESSION *session,
-                              struct string_buf *buf);
-int _libssh2_get_u32(struct string_buf *buf, uint32_t *out);
-int _libssh2_get_u64(struct string_buf *buf, libssh2_uint64_t *out);
-int _libssh2_match_string(struct string_buf *buf, const char *match);
-int _libssh2_get_string(struct string_buf *buf, unsigned char **outbuf,
-                        size_t *outlen);
-int _libssh2_copy_string(LIBSSH2_SESSION* session, struct string_buf *buf,
-                         unsigned char **outbuf, size_t *outlen);
-int _libssh2_get_bignum_bytes(struct string_buf *buf, unsigned char **outbuf,
-                              size_t *outlen);
-int _libssh2_check_length(struct string_buf *buf, size_t requested_len);
-
-#if defined(LIBSSH2_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-/* provide a private one */
-#undef HAVE_GETTIMEOFDAY
-int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp);
-#define HAVE_LIBSSH2_GETTIMEOFDAY
-#define LIBSSH2_GETTIMEOFDAY_WIN32 /* enable the win32 implementation */
-#else
-#ifdef HAVE_GETTIMEOFDAY
-#define _libssh2_gettimeofday(x,y) gettimeofday(x,y)
-#define HAVE_LIBSSH2_GETTIMEOFDAY
-#endif
-#endif
-
-void _libssh2_xor_data(unsigned char *output,
-                       const unsigned char *input1,
-                       const unsigned char *input2,
-                       size_t length);
-
-void _libssh2_aes_ctr_increment(unsigned char *ctr, size_t length);
-
-#endif /* _LIBSSH2_MISC_H */
diff --git a/libssh2/libssh2/src/openssl.c b/libssh2/libssh2/src/openssl.c
deleted file mode 100644
index 7a6810f1..00000000
--- a/libssh2/libssh2/src/openssl.c
+++ /dev/null
@@ -1,3286 +0,0 @@
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
- *
- * Author: Simon Josefsson
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_OPENSSL /* compile only if we build with openssl */
-
-#include <string.h>
-#include "misc.h"
-
-#ifndef EVP_MAX_BLOCK_LENGTH
-#define EVP_MAX_BLOCK_LENGTH 32
-#endif
-
-int
-read_openssh_private_key_from_memory(void **key_ctx, LIBSSH2_SESSION *session,
-                                     const char *key_type,
-                                     const char *filedata,
-                                     size_t filedata_len,
-                                     unsigned const char *passphrase);
-
-static unsigned char *
-write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
-{
-    unsigned char *p = buf;
-
-    /* Left space for bn size which will be written below. */
-    p += 4;
-
-    *p = 0;
-    BN_bn2bin(bn, p + 1);
-    if(!(*(p + 1) & 0x80)) {
-        memmove(p, p + 1, --bn_bytes);
-    }
-    _libssh2_htonu32(p - 4, bn_bytes);  /* Post write bn size. */
-
-    return p + bn_bytes;
-}
-
-int
-_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
-                 const unsigned char *edata,
-                 unsigned long elen,
-                 const unsigned char *ndata,
-                 unsigned long nlen,
-                 const unsigned char *ddata,
-                 unsigned long dlen,
-                 const unsigned char *pdata,
-                 unsigned long plen,
-                 const unsigned char *qdata,
-                 unsigned long qlen,
-                 const unsigned char *e1data,
-                 unsigned long e1len,
-                 const unsigned char *e2data,
-                 unsigned long e2len,
-                 const unsigned char *coeffdata, unsigned long coefflen)
-{
-    BIGNUM * e;
-    BIGNUM * n;
-    BIGNUM * d = 0;
-    BIGNUM * p = 0;
-    BIGNUM * q = 0;
-    BIGNUM * dmp1 = 0;
-    BIGNUM * dmq1 = 0;
-    BIGNUM * iqmp = 0;
-
-    e = BN_new();
-    BN_bin2bn(edata, elen, e);
-
-    n = BN_new();
-    BN_bin2bn(ndata, nlen, n);
-
-    if(ddata) {
-        d = BN_new();
-        BN_bin2bn(ddata, dlen, d);
-
-        p = BN_new();
-        BN_bin2bn(pdata, plen, p);
-
-        q = BN_new();
-        BN_bin2bn(qdata, qlen, q);
-
-        dmp1 = BN_new();
-        BN_bin2bn(e1data, e1len, dmp1);
-
-        dmq1 = BN_new();
-        BN_bin2bn(e2data, e2len, dmq1);
-
-        iqmp = BN_new();
-        BN_bin2bn(coeffdata, coefflen, iqmp);
-    }
-
-    *rsa = RSA_new();
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_set0_key(*rsa, n, e, d);
-#else
-    (*rsa)->e = e;
-    (*rsa)->n = n;
-    (*rsa)->d = d;
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_set0_factors(*rsa, p, q);
-#else
-    (*rsa)->p = p;
-    (*rsa)->q = q;
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_set0_crt_params(*rsa, dmp1, dmq1, iqmp);
-#else
-    (*rsa)->dmp1 = dmp1;
-    (*rsa)->dmq1 = dmq1;
-    (*rsa)->iqmp = iqmp;
-#endif
-    return 0;
-}
-
-int
-_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
-                         const unsigned char *sig,
-                         unsigned long sig_len,
-                         const unsigned char *m, unsigned long m_len)
-{
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    int ret;
-
-    if(_libssh2_sha1(m, m_len, hash))
-        return -1; /* failure */
-    ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,
-                     (unsigned char *) sig, sig_len, rsactx);
-    return (ret == 1) ? 0 : -1;
-}
-
-#if LIBSSH2_DSA
-int
-_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
-                 const unsigned char *p,
-                 unsigned long p_len,
-                 const unsigned char *q,
-                 unsigned long q_len,
-                 const unsigned char *g,
-                 unsigned long g_len,
-                 const unsigned char *y,
-                 unsigned long y_len,
-                 const unsigned char *x, unsigned long x_len)
-{
-    BIGNUM * p_bn;
-    BIGNUM * q_bn;
-    BIGNUM * g_bn;
-    BIGNUM * pub_key;
-    BIGNUM * priv_key = NULL;
-
-    p_bn = BN_new();
-    BN_bin2bn(p, p_len, p_bn);
-
-    q_bn = BN_new();
-    BN_bin2bn(q, q_len, q_bn);
-
-    g_bn = BN_new();
-    BN_bin2bn(g, g_len, g_bn);
-
-    pub_key = BN_new();
-    BN_bin2bn(y, y_len, pub_key);
-
-    if(x_len) {
-        priv_key = BN_new();
-        BN_bin2bn(x, x_len, priv_key);
-    }
-
-    *dsactx = DSA_new();
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_set0_pqg(*dsactx, p_bn, q_bn, g_bn);
-#else
-    (*dsactx)->p = p_bn;
-    (*dsactx)->g = g_bn;
-    (*dsactx)->q = q_bn;
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_set0_key(*dsactx, pub_key, priv_key);
-#else
-    (*dsactx)->pub_key = pub_key;
-    (*dsactx)->priv_key = priv_key;
-#endif
-    return 0;
-}
-
-int
-_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
-                         const unsigned char *sig,
-                         const unsigned char *m, unsigned long m_len)
-{
-    unsigned char hash[SHA_DIGEST_LENGTH];
-    DSA_SIG * dsasig;
-    BIGNUM * r;
-    BIGNUM * s;
-    int ret = -1;
-
-    r = BN_new();
-    BN_bin2bn(sig, 20, r);
-    s = BN_new();
-    BN_bin2bn(sig + 20, 20, s);
-
-    dsasig = DSA_SIG_new();
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_SIG_set0(dsasig, r, s);
-#else
-    dsasig->r = r;
-    dsasig->s = s;
-#endif
-    if(!_libssh2_sha1(m, m_len, hash))
-        /* _libssh2_sha1() succeeded */
-        ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);
-
-    DSA_SIG_free(dsasig);
-
-    return (ret == 1) ? 0 : -1;
-}
-#endif /* LIBSSH_DSA */
-
-#if LIBSSH2_ECDSA
-
-/* _libssh2_ecdsa_get_curve_type
- *
- * returns key curve type that maps to libssh2_curve_type
- *
- */
-
-libssh2_curve_type
-_libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx)
-{
-    const EC_GROUP *group = EC_KEY_get0_group(ec_ctx);
-    return EC_GROUP_get_curve_name(group);
-}
-
-/* _libssh2_ecdsa_curve_type_from_name
- *
- * returns 0 for success, key curve type that maps to libssh2_curve_type
- *
- */
-
-int
-_libssh2_ecdsa_curve_type_from_name(const char *name,
-                                    libssh2_curve_type *out_type)
-{
-    int ret = 0;
-    libssh2_curve_type type;
-
-    if(name == NULL || strlen(name) != 19)
-        return -1;
-
-    if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP256;
-    else if(strcmp(name, "ecdsa-sha2-nistp384") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP384;
-    else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
-        type = LIBSSH2_EC_CURVE_NISTP521;
-    else {
-        ret = -1;
-    }
-
-    if(ret == 0 && out_type) {
-        *out_type = type;
-    }
-
-    return ret;
-}
-
-/* _libssh2_ecdsa_curve_name_with_octal_new
- *
- * Creates a new public key given an octal string, length and type
- *
- */
-
-int
-_libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,
-     const unsigned char *k,
-     size_t k_len, libssh2_curve_type curve)
-{
-
-    int ret = 0;
-    const EC_GROUP *ec_group = NULL;
-    EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
-    EC_POINT *point = NULL;
-
-    if(ec_key) {
-        ec_group = EC_KEY_get0_group(ec_key);
-        point = EC_POINT_new(ec_group);
-        ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
-        ret = EC_KEY_set_public_key(ec_key, point);
-
-        if(point != NULL)
-            EC_POINT_free(point);
-
-        if(ec_ctx != NULL)
-            *ec_ctx = ec_key;
-    }
-
-    return (ret == 1) ? 0 : -1;
-}
-
-#define LIBSSH2_ECDSA_VERIFY(digest_type)                           \
-{                                                                   \
-    unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
-    libssh2_sha##digest_type(m, m_len, hash);                       \
-    ret = ECDSA_do_verify(hash, SHA##digest_type##_DIGEST_LENGTH,   \
-      ecdsa_sig, ec_key);                                           \
-                                                                    \
-}
-
-int
-_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
-      const unsigned char *r, size_t r_len,
-      const unsigned char *s, size_t s_len,
-      const unsigned char *m, size_t m_len)
-{
-    int ret = 0;
-    EC_KEY *ec_key = (EC_KEY*)ctx;
-    libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ec_key);
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    ECDSA_SIG *ecdsa_sig = ECDSA_SIG_new();
-    BIGNUM *pr = BN_new();
-    BIGNUM *ps = BN_new();
-
-    BN_bin2bn(r, r_len, pr);
-    BN_bin2bn(s, s_len, ps);
-    ECDSA_SIG_set0(ecdsa_sig, pr, ps);
-
-#else
-    ECDSA_SIG ecdsa_sig_;
-    ECDSA_SIG *ecdsa_sig = &ecdsa_sig_;
-    ecdsa_sig_.r = BN_new();
-    BN_bin2bn(r, r_len, ecdsa_sig_.r);
-    ecdsa_sig_.s = BN_new();
-    BN_bin2bn(s, s_len, ecdsa_sig_.s);
-#endif
-
-    if(type == LIBSSH2_EC_CURVE_NISTP256) {
-        LIBSSH2_ECDSA_VERIFY(256);
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
-        LIBSSH2_ECDSA_VERIFY(384);
-    }
-    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
-        LIBSSH2_ECDSA_VERIFY(512);
-    }
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    if(ecdsa_sig)
-        ECDSA_SIG_free(ecdsa_sig);
-#else
-    BN_clear_free(ecdsa_sig_.s);
-    BN_clear_free(ecdsa_sig_.r);
-#endif
-
-    return (ret == 1) ? 0 : -1;
-}
-
-#endif /* LIBSSH2_ECDSA */
-
-int
-_libssh2_cipher_init(_libssh2_cipher_ctx * h,
-                     _libssh2_cipher_type(algo),
-                     unsigned char *iv, unsigned char *secret, int encrypt)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *h = EVP_CIPHER_CTX_new();
-    return !EVP_CipherInit(*h, algo(), secret, iv, encrypt);
-#else
-    EVP_CIPHER_CTX_init(h);
-    return !EVP_CipherInit(h, algo(), secret, iv, encrypt);
-#endif
-}
-
-int
-_libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
-                      _libssh2_cipher_type(algo),
-                      int encrypt, unsigned char *block, size_t blocksize)
-{
-    unsigned char buf[EVP_MAX_BLOCK_LENGTH];
-    int ret;
-    (void) algo;
-    (void) encrypt;
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    ret = EVP_Cipher(*ctx, buf, block, blocksize);
-#else
-    ret = EVP_Cipher(ctx, buf, block, blocksize);
-#endif
-#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3
-    if(ret != -1) {
-#else
-    if(ret == 1) {
-#endif
-        memcpy(block, buf, blocksize);
-    }
-
-#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3
-    return ret != -1 ? 0 : 1;
-#else
-    return ret == 1 ? 0 : 1;
-#endif
-}
-
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-
-#include <openssl/aes.h>
-#include <openssl/evp.h>
-
-typedef struct
-{
-    AES_KEY       key;
-    EVP_CIPHER_CTX *aes_ctx;
-    unsigned char ctr[AES_BLOCK_SIZE];
-} aes_ctr_ctx;
-
-static EVP_CIPHER * aes_128_ctr_cipher = NULL;
-static EVP_CIPHER * aes_192_ctr_cipher = NULL;
-static EVP_CIPHER * aes_256_ctr_cipher = NULL;
-
-static int
-aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
-             const unsigned char *iv, int enc) /* init key */
-{
-    /*
-     * variable "c" is leaked from this scope, but is later freed
-     * in aes_ctr_cleanup
-     */
-    aes_ctr_ctx *c;
-    const EVP_CIPHER *aes_cipher;
-    (void) enc;
-
-    switch(EVP_CIPHER_CTX_key_length(ctx)) {
-    case 16:
-        aes_cipher = EVP_aes_128_ecb();
-        break;
-    case 24:
-        aes_cipher = EVP_aes_192_ecb();
-        break;
-    case 32:
-        aes_cipher = EVP_aes_256_ecb();
-        break;
-    default:
-        return 0;
-    }
-
-    c = malloc(sizeof(*c));
-    if(c == NULL)
-        return 0;
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    c->aes_ctx = EVP_CIPHER_CTX_new();
-#else
-    c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));
-#endif
-    if(c->aes_ctx == NULL) {
-        free(c);
-        return 0;
-    }
-
-    if(EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
-#ifdef HAVE_OPAQUE_STRUCTS
-        EVP_CIPHER_CTX_free(c->aes_ctx);
-#else
-        free(c->aes_ctx);
-#endif
-        free(c);
-        return 0;
-    }
-
-    EVP_CIPHER_CTX_set_padding(c->aes_ctx, 0);
-
-    memcpy(c->ctr, iv, AES_BLOCK_SIZE);
-
-    EVP_CIPHER_CTX_set_app_data(ctx, c);
-
-    return 1;
-}
-
-static int
-aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                  const unsigned char *in,
-                  size_t inl) /* encrypt/decrypt data */
-{
-    aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
-    unsigned char b1[AES_BLOCK_SIZE];
-    int outlen = 0;
-
-    if(inl != 16) /* libssh2 only ever encrypt one block */
-        return 0;
-
-    if(c == NULL) {
-        return 0;
-    }
-
-/*
-  To encrypt a packet P=P1||P2||...||Pn (where P1, P2, ..., Pn are each
-  blocks of length L), the encryptor first encrypts <X> with <cipher>
-  to obtain a block B1.  The block B1 is then XORed with P1 to generate
-  the ciphertext block C1.  The counter X is then incremented
-*/
-
-    if(EVP_EncryptUpdate(c->aes_ctx, b1, &outlen,
-                         c->ctr, AES_BLOCK_SIZE) != 1) {
-        return 0;
-    }
-
-    _libssh2_xor_data(out, in, b1, AES_BLOCK_SIZE);
-    _libssh2_aes_ctr_increment(c->ctr, AES_BLOCK_SIZE);
-
-    return 1;
-}
-
-static int
-aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */
-{
-    aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
-
-    if(c == NULL) {
-        return 1;
-    }
-
-    if(c->aes_ctx != NULL) {
-#ifdef HAVE_OPAQUE_STRUCTS
-        EVP_CIPHER_CTX_free(c->aes_ctx);
-#else
-        _libssh2_cipher_dtor(c->aes_ctx);
-        free(c->aes_ctx);
-#endif
-    }
-
-    free(c);
-
-    return 1;
-}
-
-static const EVP_CIPHER *
-make_ctr_evp (size_t keylen, EVP_CIPHER **aes_ctr_cipher, int type)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen);
-    if(*aes_ctr_cipher) {
-        EVP_CIPHER_meth_set_iv_length(*aes_ctr_cipher, 16);
-        EVP_CIPHER_meth_set_init(*aes_ctr_cipher, aes_ctr_init);
-        EVP_CIPHER_meth_set_do_cipher(*aes_ctr_cipher, aes_ctr_do_cipher);
-        EVP_CIPHER_meth_set_cleanup(*aes_ctr_cipher, aes_ctr_cleanup);
-    }
-#else
-    (*aes_ctr_cipher)->nid = type;
-    (*aes_ctr_cipher)->block_size = 16;
-    (*aes_ctr_cipher)->key_len = keylen;
-    (*aes_ctr_cipher)->iv_len = 16;
-    (*aes_ctr_cipher)->init = aes_ctr_init;
-    (*aes_ctr_cipher)->do_cipher = aes_ctr_do_cipher;
-    (*aes_ctr_cipher)->cleanup = aes_ctr_cleanup;
-#endif
-
-    return *aes_ctr_cipher;
-}
-
-const EVP_CIPHER *
-_libssh2_EVP_aes_128_ctr(void)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_128_ctr_cipher ?
-        make_ctr_evp(16, &aes_128_ctr_cipher, NID_aes_128_ctr) :
-        aes_128_ctr_cipher;
-#else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_128_ctr_cipher) {
-        aes_128_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(16, &aes_128_ctr_cipher, 0);
-    }
-    return aes_128_ctr_cipher;
-#endif
-}
-
-const EVP_CIPHER *
-_libssh2_EVP_aes_192_ctr(void)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_192_ctr_cipher ?
-        make_ctr_evp(24, &aes_192_ctr_cipher, NID_aes_192_ctr) :
-        aes_192_ctr_cipher;
-#else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_192_ctr_cipher) {
-        aes_192_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(24, &aes_192_ctr_cipher, 0);
-    }
-    return aes_192_ctr_cipher;
-#endif
-}
-
-const EVP_CIPHER *
-_libssh2_EVP_aes_256_ctr(void)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_256_ctr_cipher ?
-        make_ctr_evp(32, &aes_256_ctr_cipher, NID_aes_256_ctr) :
-        aes_256_ctr_cipher;
-#else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_256_ctr_cipher) {
-        aes_256_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(32, &aes_256_ctr_cipher, 0);
-    }
-    return aes_256_ctr_cipher;
-#endif
-}
-
-#endif /* LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR) */
-
-void _libssh2_openssl_crypto_init(void)
-{
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
-    !defined(LIBRESSL_VERSION_NUMBER)
-#ifndef OPENSSL_NO_ENGINE
-    ENGINE_load_builtin_engines();
-    ENGINE_register_all_complete();
-#endif
-#else
-    OpenSSL_add_all_algorithms();
-    OpenSSL_add_all_ciphers();
-    OpenSSL_add_all_digests();
-#ifndef OPENSSL_NO_ENGINE
-    ENGINE_load_builtin_engines();
-    ENGINE_register_all_complete();
-#endif
-#endif
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-    aes_128_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_128_ctr();
-    aes_192_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_192_ctr();
-    aes_256_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_256_ctr();
-#endif
-}
-
-void _libssh2_openssl_crypto_exit(void)
-{
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-#ifdef HAVE_OPAQUE_STRUCTS
-    if(aes_128_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_128_ctr_cipher);
-    }
-
-    if(aes_192_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_192_ctr_cipher);
-    }
-
-    if(aes_256_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_256_ctr_cipher);
-    }
-#endif
-
-    aes_128_ctr_cipher = NULL;
-    aes_192_ctr_cipher = NULL;
-    aes_256_ctr_cipher = NULL;
-#endif
-}
-
-/* TODO: Optionally call a passphrase callback specified by the
- * calling program
- */
-static int
-passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
-{
-    int passphrase_len = strlen(passphrase);
-    (void) rwflag;
-
-    if(passphrase_len > (size - 1)) {
-        passphrase_len = size - 1;
-    }
-    memcpy(buf, passphrase, passphrase_len);
-    buf[passphrase_len] = '\0';
-
-    return passphrase_len;
-}
-
-typedef void * (*pem_read_bio_func)(BIO *, void **, pem_password_cb *,
-                                    void *u);
-
-static int
-read_private_key_from_memory(void **key_ctx,
-                             pem_read_bio_func read_private_key,
-                             const char *filedata,
-                             size_t filedata_len,
-                             unsigned const char *passphrase)
-{
-    BIO * bp;
-
-    *key_ctx = NULL;
-
-    bp = BIO_new_mem_buf((char *)filedata, filedata_len);
-    if(!bp) {
-        return -1;
-    }
-    *key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,
-                                (void *) passphrase);
-
-    BIO_free(bp);
-    return (*key_ctx) ? 0 : -1;
-}
-
-
-
-static int
-read_private_key_from_file(void **key_ctx,
-                           pem_read_bio_func read_private_key,
-                           const char *filename,
-                           unsigned const char *passphrase)
-{
-    BIO * bp;
-
-    *key_ctx = NULL;
-
-    bp = BIO_new_file(filename, "r");
-    if(!bp) {
-        return -1;
-    }
-
-    *key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,
-                                (void *) passphrase);
-
-    BIO_free(bp);
-    return (*key_ctx) ? 0 : -1;
-}
-
-int
-_libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_rsa =
-        (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_memory((void **) rsa, read_rsa,
-                                      filedata, filedata_len, passphrase);
-
-    if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)rsa, session,
-                        "ssh-rsa", filedata, filedata_len, passphrase);
-    }
-
-return rc;
-}
-
-static unsigned char *
-gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
-                       size_t *key_len)
-{
-    int            e_bytes, n_bytes;
-    unsigned long  len;
-    unsigned char *key;
-    unsigned char *p;
-    const BIGNUM * e;
-    const BIGNUM * n;
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_get0_key(rsa, &n, &e, NULL);
-#else
-    e = rsa->e;
-    n = rsa->n;
-#endif
-    e_bytes = BN_num_bytes(e) + 1;
-    n_bytes = BN_num_bytes(n) + 1;
-
-    /* Key form is "ssh-rsa" + e + n. */
-    len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
-
-    key = LIBSSH2_ALLOC(session, len);
-    if(key == NULL) {
-        return NULL;
-    }
-
-    /* Process key encoding. */
-    p = key;
-
-    _libssh2_htonu32(p, 7);  /* Key type. */
-    p += 4;
-    memcpy(p, "ssh-rsa", 7);
-    p += 7;
-
-    p = write_bn(p, e, e_bytes);
-    p = write_bn(p, n, n_bytes);
-
-    *key_len = (size_t)(p - key);
-    return key;
-}
-
-static int
-gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
-                           unsigned char **method,
-                           size_t *method_len,
-                           unsigned char **pubkeydata,
-                           size_t *pubkeydata_len,
-                           EVP_PKEY *pk)
-{
-    RSA*           rsa = NULL;
-    unsigned char *key;
-    unsigned char *method_buf = NULL;
-    size_t  key_len;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing public key from RSA private key envelope");
-
-    rsa = EVP_PKEY_get1_RSA(pk);
-    if(rsa == NULL) {
-        /* Assume memory allocation error... what else could it be ? */
-        goto __alloc_error;
-    }
-
-    method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-rsa. */
-    if(method_buf == NULL) {
-        goto __alloc_error;
-    }
-
-    key = gen_publickey_from_rsa(session, rsa, &key_len);
-    if(key == NULL) {
-        goto __alloc_error;
-    }
-    RSA_free(rsa);
-
-    memcpy(method_buf, "ssh-rsa", 7);
-    *method         = method_buf;
-    *method_len     = 7;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
-    return 0;
-
-  __alloc_error:
-    if(rsa != NULL) {
-        RSA_free(rsa);
-    }
-    if(method_buf != NULL) {
-        LIBSSH2_FREE(session, method_buf);
-    }
-
-    return _libssh2_error(session,
-                          LIBSSH2_ERROR_ALLOC,
-                          "Unable to allocate memory for private key data");
-}
-
-static int _libssh2_rsa_new_additional_parameters(RSA *rsa)
-{
-    BN_CTX *ctx = NULL;
-    BIGNUM *aux = NULL;
-    BIGNUM *dmp1 = NULL;
-    BIGNUM *dmq1 = NULL;
-    const BIGNUM *p = NULL;
-    const BIGNUM *q = NULL;
-    const BIGNUM *d = NULL;
-    int rc = 0;
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_get0_key(rsa, NULL, NULL, &d);
-    RSA_get0_factors(rsa, &p, &q);
-#else
-    d = (*rsa).d;
-    p = (*rsa).p;
-    q = (*rsa).q;
-#endif
-
-    ctx = BN_CTX_new();
-    if(ctx == NULL)
-        return -1;
-
-    aux = BN_new();
-    if(aux == NULL) {
-        rc = -1;
-        goto out;
-    }
-
-    dmp1 = BN_new();
-    if(dmp1 == NULL) {
-        rc = -1;
-        goto out;
-    }
-
-    dmq1 = BN_new();
-    if(dmq1 == NULL) {
-        rc = -1;
-        goto out;
-    }
-
-    if((BN_sub(aux, q, BN_value_one()) == 0) ||
-        (BN_mod(dmq1, d, aux, ctx) == 0) ||
-        (BN_sub(aux, p, BN_value_one()) == 0) ||
-        (BN_mod(dmp1, d, aux, ctx) == 0)) {
-        rc = -1;
-        goto out;
-    }
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    RSA_set0_crt_params(rsa, dmp1, dmq1, NULL);
-#else
-    (*rsa).dmp1 = dmp1;
-    (*rsa).dmq1 = dmq1;
-#endif
-
-out:
-    if(aux)
-        BN_clear_free(aux);
-    BN_CTX_free(ctx);
-
-    if(rc != 0) {
-        if(dmp1)
-            BN_clear_free(dmp1);
-        if(dmq1)
-            BN_clear_free(dmq1);
-    }
-
-    return rc;
-}
-
-static int
-gen_publickey_from_rsa_openssh_priv_data(LIBSSH2_SESSION *session,
-                                         struct string_buf *decrypted,
-                                         unsigned char **method,
-                                         size_t *method_len,
-                                         unsigned char **pubkeydata,
-                                         size_t *pubkeydata_len,
-                                         libssh2_rsa_ctx **rsa_ctx)
-{
-    int rc = 0;
-    size_t nlen, elen, dlen, plen, qlen, coefflen, commentlen;
-    unsigned char *n, *e, *d, *p, *q, *coeff, *comment;
-    RSA *rsa = NULL;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing RSA keys from private key data");
-
-    /* public key data */
-    if(_libssh2_get_bignum_bytes(decrypted, &n, &nlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no n");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &e, &elen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no e");
-        return -1;
-    }
-
-    /* private key data */
-    if(_libssh2_get_bignum_bytes(decrypted, &d, &dlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no d");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &coeff, &coefflen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no coeff");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &p, &plen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no p");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &q, &qlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no q");
-        return -1;
-    }
-
-    if(_libssh2_get_string(decrypted, &comment, &commentlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "RSA no comment");
-        return -1;
-    }
-
-    if((rc = _libssh2_rsa_new(&rsa, e, elen, n, nlen, d, dlen, p, plen,
-                              q, qlen, NULL, 0, NULL, 0,
-                              coeff, coefflen)) != 0) {
-        _libssh2_debug(session,
-                       LIBSSH2_TRACE_AUTH,
-                       "Could not create RSA private key");
-        goto fail;
-    }
-
-    if(rsa != NULL)
-        rc = _libssh2_rsa_new_additional_parameters(rsa);
-
-    if(rsa != NULL && pubkeydata != NULL && method != NULL) {
-        EVP_PKEY *pk = EVP_PKEY_new();
-        EVP_PKEY_set1_RSA(pk, rsa);
-
-        rc = gen_publickey_from_rsa_evp(session, method, method_len,
-                                        pubkeydata, pubkeydata_len,
-                                        pk);
-
-        if(pk)
-            EVP_PKEY_free(pk);
-    }
-
-    if(rsa_ctx != NULL)
-        *rsa_ctx = rsa;
-    else
-        RSA_free(rsa);
-
-    return rc;
-
-fail:
-
-    if(rsa != NULL)
-        RSA_free(rsa);
-
-    return _libssh2_error(session,
-                          LIBSSH2_ERROR_ALLOC,
-                          "Unable to allocate memory for private key data");
-}
-
-static int
-_libssh2_rsa_new_openssh_private(libssh2_rsa_ctx ** rsa,
-                                 LIBSSH2_SESSION * session,
-                                 const char *filename,
-                                 unsigned const char *passphrase)
-{
-    FILE *fp;
-    int rc;
-    unsigned char *buf = NULL;
-    struct string_buf *decrypted = NULL;
-
-    if(session == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Session is required");
-        return -1;
-    }
-
-    _libssh2_init_if_needed();
-
-    fp = fopen(filename, "r");
-    if(!fp) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unable to open OpenSSH RSA private key file");
-        return -1;
-    }
-
-    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
-    fclose(fp);
-    if(rc) {
-        return rc;
-    }
-
-    /* We have a new key file, now try and parse it using supported types  */
-    rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-    if(rc != 0 || buf == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Public key type in decrypted key data not found");
-        return -1;
-    }
-
-    if(strcmp("ssh-rsa", (const char *)buf) == 0) {
-        rc = gen_publickey_from_rsa_openssh_priv_data(session, decrypted,
-                                                      NULL, 0,
-                                                      NULL, 0, rsa);
-    }
-    else {
-        rc = -1;
-    }
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    return rc;
-}
-
-int
-_libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
-                         LIBSSH2_SESSION * session,
-                         const char *filename, unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_rsa =
-        (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_file((void **) rsa, read_rsa,
-                                    filename, passphrase);
-
-    if(rc) {
-        rc = _libssh2_rsa_new_openssh_private(rsa, session,
-                                              filename, passphrase);
-    }
-
-    return rc;
-}
-
-#if LIBSSH2_DSA
-int
-_libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_dsa =
-        (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_memory((void **)dsa, read_dsa,
-                                      filedata, filedata_len, passphrase);
-
-    if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)dsa, session,
-                            "ssh-dsa", filedata, filedata_len, passphrase);
-    }
-
-    return rc;
-}
-
-static unsigned char *
-gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
-                       size_t *key_len)
-{
-    int            p_bytes, q_bytes, g_bytes, k_bytes;
-    unsigned long  len;
-    unsigned char *key;
-    unsigned char *p;
-
-    const BIGNUM * p_bn;
-    const BIGNUM * q;
-    const BIGNUM * g;
-    const BIGNUM * pub_key;
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_get0_pqg(dsa, &p_bn, &q, &g);
-#else
-    p_bn = dsa->p;
-    q = dsa->q;
-    g = dsa->g;
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_get0_key(dsa, &pub_key, NULL);
-#else
-    pub_key = dsa->pub_key;
-#endif
-    p_bytes = BN_num_bytes(p_bn) + 1;
-    q_bytes = BN_num_bytes(q) + 1;
-    g_bytes = BN_num_bytes(g) + 1;
-    k_bytes = BN_num_bytes(pub_key) + 1;
-
-    /* Key form is "ssh-dss" + p + q + g + pub_key. */
-    len = 4 + 7 + 4 + p_bytes + 4 + q_bytes + 4 + g_bytes + 4 + k_bytes;
-
-    key = LIBSSH2_ALLOC(session, len);
-    if(key == NULL) {
-        return NULL;
-    }
-
-    /* Process key encoding. */
-    p = key;
-
-    _libssh2_htonu32(p, 7);  /* Key type. */
-    p += 4;
-    memcpy(p, "ssh-dss", 7);
-    p += 7;
-
-    p = write_bn(p, p_bn, p_bytes);
-    p = write_bn(p, q, q_bytes);
-    p = write_bn(p, g, g_bytes);
-    p = write_bn(p, pub_key, k_bytes);
-
-    *key_len = (size_t)(p - key);
-    return key;
-}
-
-static int
-gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
-                           unsigned char **method,
-                           size_t *method_len,
-                           unsigned char **pubkeydata,
-                           size_t *pubkeydata_len,
-                           EVP_PKEY *pk)
-{
-    DSA*           dsa = NULL;
-    unsigned char *key;
-    unsigned char *method_buf = NULL;
-    size_t  key_len;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing public key from DSA private key envelope");
-
-    dsa = EVP_PKEY_get1_DSA(pk);
-    if(dsa == NULL) {
-        /* Assume memory allocation error... what else could it be ? */
-        goto __alloc_error;
-    }
-
-    method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-dss. */
-    if(method_buf == NULL) {
-        goto __alloc_error;
-    }
-
-    key = gen_publickey_from_dsa(session, dsa, &key_len);
-    if(key == NULL) {
-        goto __alloc_error;
-    }
-    DSA_free(dsa);
-
-    memcpy(method_buf, "ssh-dss", 7);
-    *method         = method_buf;
-    *method_len     = 7;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
-    return 0;
-
-  __alloc_error:
-    if(dsa != NULL) {
-        DSA_free(dsa);
-    }
-    if(method_buf != NULL) {
-        LIBSSH2_FREE(session, method_buf);
-    }
-
-    return _libssh2_error(session,
-                          LIBSSH2_ERROR_ALLOC,
-                          "Unable to allocate memory for private key data");
-}
-
-static int
-gen_publickey_from_dsa_openssh_priv_data(LIBSSH2_SESSION *session,
-                                         struct string_buf *decrypted,
-                                         unsigned char **method,
-                                         size_t *method_len,
-                                         unsigned char **pubkeydata,
-                                         size_t *pubkeydata_len,
-                                         libssh2_dsa_ctx **dsa_ctx)
-{
-    int rc = 0;
-    size_t plen, qlen, glen, pub_len, priv_len;
-    unsigned char *p, *q, *g, *pub_key, *priv_key;
-    DSA *dsa = NULL;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing DSA keys from private key data");
-
-    if(_libssh2_get_bignum_bytes(decrypted, &p, &plen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "DSA no p");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &q, &qlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "DSA no q");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &g, &glen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "DSA no g");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &pub_key, &pub_len)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "DSA no public key");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &priv_key, &priv_len)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "DSA no private key");
-        return -1;
-    }
-
-    rc = _libssh2_dsa_new(&dsa, p, plen, q, qlen, g, glen, pub_key, pub_len,
-                          priv_key, priv_len);
-    if(rc != 0) {
-        _libssh2_debug(session,
-                       LIBSSH2_ERROR_PROTO,
-                       "Could not create DSA private key");
-        goto fail;
-    }
-
-    if(dsa != NULL && pubkeydata != NULL && method != NULL) {
-        EVP_PKEY *pk = EVP_PKEY_new();
-        EVP_PKEY_set1_DSA(pk, dsa);
-
-        rc = gen_publickey_from_dsa_evp(session, method, method_len,
-                                        pubkeydata, pubkeydata_len,
-                                        pk);
-
-        if(pk)
-            EVP_PKEY_free(pk);
-    }
-
-    if(dsa_ctx != NULL)
-        *dsa_ctx = dsa;
-    else
-        DSA_free(dsa);
-
-    return rc;
-
-fail:
-
-    if(dsa != NULL)
-        DSA_free(dsa);
-
-    return _libssh2_error(session,
-                          LIBSSH2_ERROR_ALLOC,
-                          "Unable to allocate memory for private key data");
-}
-
-static int
-_libssh2_dsa_new_openssh_private(libssh2_dsa_ctx ** dsa,
-                                 LIBSSH2_SESSION * session,
-                                 const char *filename,
-                                 unsigned const char *passphrase)
-{
-    FILE *fp;
-    int rc;
-    unsigned char *buf = NULL;
-    struct string_buf *decrypted = NULL;
-
-    if(session == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Session is required");
-        return -1;
-    }
-
-    _libssh2_init_if_needed();
-
-    fp = fopen(filename, "r");
-    if(!fp) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unable to open OpenSSH DSA private key file");
-        return -1;
-    }
-
-    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
-    fclose(fp);
-    if(rc) {
-        return rc;
-    }
-
-    /* We have a new key file, now try and parse it using supported types  */
-    rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-    if(rc != 0 || buf == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Public key type in decrypted key data not found");
-        return -1;
-    }
-
-    if(strcmp("ssh-dss", (const char *)buf) == 0) {
-        rc = gen_publickey_from_dsa_openssh_priv_data(session, decrypted,
-                                                      NULL, 0,
-                                                      NULL, 0, dsa);
-    }
-    else {
-        rc = -1;
-    }
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    return rc;
-}
-
-int
-_libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
-                         LIBSSH2_SESSION * session,
-                         const char *filename, unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_dsa =
-        (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_file((void **) dsa, read_dsa,
-                                    filename, passphrase);
-
-    if(rc) {
-        rc = _libssh2_dsa_new_openssh_private(dsa, session,
-                                              filename, passphrase);
-    }
-
-    return rc;
-}
-
-#endif /* LIBSSH_DSA */
-
-#if LIBSSH2_ECDSA
-
-int
-_libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_ec =
-        (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_memory((void **) ec_ctx, read_ec,
-                                      filedata, filedata_len, passphrase);
-
-    if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)ec_ctx, session,
-                                                  "ssh-ecdsa", filedata,
-                                                  filedata_len, passphrase);
-    }
-
-    return rc;
-}
-
-#endif /* LIBSSH2_ECDSA */
-
-
-#if LIBSSH2_ED25519
-
-int
-_libssh2_curve25519_new(LIBSSH2_SESSION *session,
-                        unsigned char **out_public_key,
-                        unsigned char **out_private_key)
-{
-    EVP_PKEY *key = NULL;
-    EVP_PKEY_CTX *pctx = NULL;
-    unsigned char *priv = NULL, *pub = NULL;
-    size_t privLen, pubLen;
-    int rc = -1;
-
-    pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_X25519, NULL);
-    if(pctx == NULL)
-        return -1;
-
-    if(EVP_PKEY_keygen_init(pctx) != 1 ||
-       EVP_PKEY_keygen(pctx, &key) != 1) {
-        goto cleanExit;
-    }
-
-    if(out_private_key != NULL) {
-        privLen = LIBSSH2_ED25519_KEY_LEN;
-        priv = LIBSSH2_ALLOC(session, privLen);
-        if(priv == NULL)
-            goto cleanExit;
-
-        if(EVP_PKEY_get_raw_private_key(key, priv, &privLen) != 1 ||
-           privLen != LIBSSH2_ED25519_KEY_LEN) {
-            goto cleanExit;
-        }
-
-        *out_private_key = priv;
-        priv = NULL;
-    }
-
-    if(out_public_key != NULL) {
-        pubLen = LIBSSH2_ED25519_KEY_LEN;
-        pub = LIBSSH2_ALLOC(session, pubLen);
-        if(pub == NULL)
-            goto cleanExit;
-
-        if(EVP_PKEY_get_raw_public_key(key, pub, &pubLen) != 1 ||
-           pubLen != LIBSSH2_ED25519_KEY_LEN) {
-            goto cleanExit;
-        }
-
-        *out_public_key = pub;
-        pub = NULL;
-    }
-
-    /* success */
-    rc = 0;
-
-cleanExit:
-
-    if(pctx)
-        EVP_PKEY_CTX_free(pctx);
-    if(key)
-        EVP_PKEY_free(key);
-    if(priv)
-        LIBSSH2_FREE(session, priv);
-    if(pub)
-        LIBSSH2_FREE(session, pub);
-
-    return rc;
-}
-
-
-static int
-gen_publickey_from_ed_evp(LIBSSH2_SESSION *session,
-                          unsigned char **method,
-                          size_t *method_len,
-                          unsigned char **pubkeydata,
-                          size_t *pubkeydata_len,
-                          EVP_PKEY *pk)
-{
-    const char methodName[] = "ssh-ed25519";
-    unsigned char *methodBuf = NULL;
-    size_t rawKeyLen = 0;
-    unsigned char *keyBuf = NULL;
-    size_t bufLen = 0;
-    unsigned char *bufPos = NULL;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                   "Computing public key from ED private key envelope");
-
-    methodBuf = LIBSSH2_ALLOC(session, sizeof(methodName) - 1);
-    if(!methodBuf) {
-        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                       "Unable to allocate memory for private key data");
-        goto fail;
-    }
-    memcpy(methodBuf, methodName, sizeof(methodName) - 1);
-
-    if(EVP_PKEY_get_raw_public_key(pk, NULL, &rawKeyLen) != 1) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "EVP_PKEY_get_raw_public_key failed");
-        goto fail;
-    }
-
-    /* Key form is: type_len(4) + type(11) + pub_key_len(4) + pub_key(32). */
-    bufLen = 4 + sizeof(methodName) - 1  + 4 + rawKeyLen;
-    bufPos = keyBuf = LIBSSH2_ALLOC(session, bufLen);
-    if(!keyBuf) {
-        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                       "Unable to allocate memory for private key data");
-        goto fail;
-    }
-
-    _libssh2_store_str(&bufPos, methodName, sizeof(methodName) - 1);
-    _libssh2_store_u32(&bufPos, rawKeyLen);
-
-    if(EVP_PKEY_get_raw_public_key(pk, bufPos, &rawKeyLen) != 1) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "EVP_PKEY_get_raw_public_key failed");
-        goto fail;
-    }
-
-    *method         = methodBuf;
-    *method_len     = sizeof(methodName) - 1;
-    *pubkeydata     = keyBuf;
-    *pubkeydata_len = bufLen;
-    return 0;
-
-fail:
-    if(methodBuf)
-        LIBSSH2_FREE(session, methodBuf);
-    if(keyBuf)
-        LIBSSH2_FREE(session, keyBuf);
-    return -1;
-}
-
-
-static int
-gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
-                                             struct string_buf *decrypted,
-                                             unsigned char **method,
-                                             size_t *method_len,
-                                             unsigned char **pubkeydata,
-                                             size_t *pubkeydata_len,
-                                             libssh2_ed25519_ctx **out_ctx)
-{
-    libssh2_ed25519_ctx *ctx = NULL;
-    unsigned char *method_buf = NULL;
-    unsigned char *key = NULL;
-    int i, ret = 0;
-    unsigned char *pub_key, *priv_key, *buf;
-    size_t key_len = 0, tmp_len = 0;
-    unsigned char *p;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing ED25519 keys from private key data");
-
-    if(_libssh2_get_string(decrypted, &pub_key, &tmp_len) ||
-       tmp_len != LIBSSH2_ED25519_KEY_LEN) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Wrong public key length");
-        return -1;
-    }
-
-    if(_libssh2_get_string(decrypted, &priv_key, &tmp_len) ||
-       tmp_len != LIBSSH2_ED25519_PRIVATE_KEY_LEN) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Wrong private key length");
-        ret = -1;
-        goto clean_exit;
-    }
-
-    /* first 32 bytes of priv_key is the private key, the last 32 bytes are
-       the public key */
-    ctx = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL,
-                                       (const unsigned char *)priv_key,
-                                       LIBSSH2_ED25519_KEY_LEN);
-
-    /* comment */
-    if(_libssh2_get_string(decrypted, &buf, &tmp_len)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Unable to read comment");
-        ret = -1;
-        goto clean_exit;
-    }
-
-    if(tmp_len > 0) {
-        unsigned char *comment = LIBSSH2_CALLOC(session, tmp_len + 1);
-        if(comment != NULL) {
-            memcpy(comment, buf, tmp_len);
-            memcpy(comment + tmp_len, "\0", 1);
-
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Key comment: %s",
-                           comment);
-
-            LIBSSH2_FREE(session, comment);
-        }
-    }
-
-    /* Padding */
-    i = 1;
-    while(decrypted->dataptr < decrypted->data + decrypted->len) {
-        if(*decrypted->dataptr != i) {
-            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Wrong padding");
-            ret = -1;
-            goto clean_exit;
-        }
-        i++;
-        decrypted->dataptr++;
-    }
-
-    if(ret == 0) {
-        _libssh2_debug(session,
-                       LIBSSH2_TRACE_AUTH,
-                       "Computing public key from ED25519 "
-                       "private key envelope");
-
-        method_buf = LIBSSH2_ALLOC(session, 11);  /* ssh-ed25519. */
-        if(method_buf == NULL) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for ED25519 key");
-            goto clean_exit;
-        }
-
-        /* Key form is: type_len(4) + type(11) + pub_key_len(4) +
-           pub_key(32). */
-        key_len = LIBSSH2_ED25519_KEY_LEN + 19;
-        key = LIBSSH2_CALLOC(session, key_len);
-        if(key == NULL) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for ED25519 key");
-            goto clean_exit;
-        }
-
-        p = key;
-
-        _libssh2_store_str(&p, "ssh-ed25519", 11);
-        _libssh2_store_str(&p, (const char *)pub_key, LIBSSH2_ED25519_KEY_LEN);
-
-        memcpy(method_buf, "ssh-ed25519", 11);
-
-        if(method != NULL)
-            *method = method_buf;
-        else
-            LIBSSH2_FREE(session, method_buf);
-
-        if(method_len != NULL)
-            *method_len = 11;
-
-        if(pubkeydata != NULL)
-            *pubkeydata = key;
-        else
-            LIBSSH2_FREE(session, key);
-
-        if(pubkeydata_len != NULL)
-            *pubkeydata_len = key_len;
-
-        if(out_ctx != NULL)
-            *out_ctx = ctx;
-        else if(ctx != NULL)
-            _libssh2_ed25519_free(ctx);
-
-        return 0;
-    }
-
-clean_exit:
-
-    if(ctx)
-        _libssh2_ed25519_free(ctx);
-
-    if(method_buf)
-        LIBSSH2_FREE(session, method_buf);
-
-    if(key)
-        LIBSSH2_FREE(session, key);
-
-    return -1;
-}
-
-int
-_libssh2_ed25519_new_private(libssh2_ed25519_ctx ** ed_ctx,
-                             LIBSSH2_SESSION * session,
-                             const char *filename, const uint8_t *passphrase)
-{
-    int rc;
-    FILE *fp;
-    unsigned char *buf;
-    struct string_buf *decrypted = NULL;
-    libssh2_ed25519_ctx *ctx = NULL;
-
-    if(session == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Session is required");
-        return -1;
-    }
-
-    _libssh2_init_if_needed();
-
-    fp = fopen(filename, "r");
-    if(!fp) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unable to open ED25519 private key file");
-        return -1;
-    }
-
-    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
-    fclose(fp);
-    if(rc) {
-        return rc;
-    }
-
-    /* We have a new key file, now try and parse it using supported types  */
-    rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-    if(rc != 0 || buf == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Public key type in decrypted key data not found");
-        return -1;
-    }
-
-    if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
-        rc = gen_publickey_from_ed25519_openssh_priv_data(session,
-                                                          decrypted,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
-                                                          &ctx);
-    }
-    else {
-        rc = -1;
-    }
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    if(rc == 0) {
-        if(ed_ctx != NULL)
-            *ed_ctx = ctx;
-        else if(ctx != NULL)
-            _libssh2_ed25519_free(ctx);
-    }
-
-    return rc;
-}
-
-int
-_libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx ** ed_ctx,
-                                        LIBSSH2_SESSION * session,
-                                        const char *filedata,
-                                        size_t filedata_len,
-                                        unsigned const char *passphrase)
-{
-    libssh2_ed25519_ctx *ctx = NULL;
-
-    _libssh2_init_if_needed();
-
-    if(read_private_key_from_memory((void **)&ctx,
-                                    (pem_read_bio_func)
-                                    &PEM_read_bio_PrivateKey,
-                                    filedata, filedata_len, passphrase) == 0) {
-        if(EVP_PKEY_id(ctx) != EVP_PKEY_ED25519) {
-            _libssh2_ed25519_free(ctx);
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Private key is not an ED25519 key");
-        }
-
-        *ed_ctx = ctx;
-        return 0;
-    }
-
-    return read_openssh_private_key_from_memory((void **)ed_ctx, session,
-                                                "ssh-ed25519",
-                                                filedata, filedata_len,
-                                                passphrase);
-}
-
-int
-_libssh2_ed25519_new_public(libssh2_ed25519_ctx ** ed_ctx,
-                            LIBSSH2_SESSION * session,
-                            const unsigned char *raw_pub_key,
-                            const uint8_t key_len)
-{
-    libssh2_ed25519_ctx *ctx = NULL;
-
-    if(ed_ctx == NULL)
-        return -1;
-
-    ctx = EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL,
-                                      raw_pub_key, key_len);
-    if(!ctx)
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "could not create ED25519 public key");
-
-    if(ed_ctx != NULL)
-        *ed_ctx = ctx;
-    else if(ctx)
-        _libssh2_ed25519_free(ctx);
-
-    return 0;
-}
-#endif /* LIBSSH2_ED25519 */
-
-
-int
-_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
-                       libssh2_rsa_ctx * rsactx,
-                       const unsigned char *hash,
-                       size_t hash_len,
-                       unsigned char **signature, size_t *signature_len)
-{
-    int ret;
-    unsigned char *sig;
-    unsigned int sig_len;
-
-    sig_len = RSA_size(rsactx);
-    sig = LIBSSH2_ALLOC(session, sig_len);
-
-    if(!sig) {
-        return -1;
-    }
-
-    ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
-
-    if(!ret) {
-        LIBSSH2_FREE(session, sig);
-        return -1;
-    }
-
-    *signature = sig;
-    *signature_len = sig_len;
-
-    return 0;
-}
-
-#if LIBSSH2_DSA
-int
-_libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
-                       const unsigned char *hash,
-                       unsigned long hash_len, unsigned char *signature)
-{
-    DSA_SIG *sig;
-    const BIGNUM * r;
-    const BIGNUM * s;
-    int r_len, s_len;
-    (void) hash_len;
-
-    sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx);
-    if(!sig) {
-        return -1;
-    }
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    DSA_SIG_get0(sig, &r, &s);
-#else
-    r = sig->r;
-    s = sig->s;
-#endif
-    r_len = BN_num_bytes(r);
-    if(r_len < 1 || r_len > 20) {
-        DSA_SIG_free(sig);
-        return -1;
-    }
-    s_len = BN_num_bytes(s);
-    if(s_len < 1 || s_len > 20) {
-        DSA_SIG_free(sig);
-        return -1;
-    }
-
-    memset(signature, 0, 40);
-
-    BN_bn2bin(r, signature + (20 - r_len));
-    BN_bn2bin(s, signature + 20 + (20 - s_len));
-
-    DSA_SIG_free(sig);
-
-    return 0;
-}
-#endif /* LIBSSH_DSA */
-
-#if LIBSSH2_ECDSA
-
-int
-_libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
-    const unsigned char *hash, unsigned long hash_len,
-    unsigned char **signature, size_t *signature_len)
-{
-    int r_len, s_len;
-    int rc = 0;
-    size_t out_buffer_len = 0;
-    unsigned char *sp;
-    const BIGNUM *pr = NULL, *ps = NULL;
-    unsigned char *temp_buffer = NULL;
-    unsigned char *out_buffer = NULL;
-
-    ECDSA_SIG *sig = ECDSA_do_sign(hash, hash_len, ec_ctx);
-    if(sig == NULL)
-        return -1;
-#ifdef HAVE_OPAQUE_STRUCTS
-    ECDSA_SIG_get0(sig, &pr, &ps);
-#else
-    pr = sig->r;
-    ps = sig->s;
-#endif
-
-    r_len = BN_num_bytes(pr) + 1;
-    s_len = BN_num_bytes(ps) + 1;
-
-    temp_buffer = malloc(r_len + s_len + 8);
-    if(temp_buffer == NULL) {
-        rc = -1;
-        goto clean_exit;
-    }
-
-    sp = temp_buffer;
-    sp = write_bn(sp, pr, r_len);
-    sp = write_bn(sp, ps, s_len);
-
-    out_buffer_len = (size_t)(sp - temp_buffer);
-
-    out_buffer = LIBSSH2_CALLOC(session, out_buffer_len);
-    if(out_buffer == NULL) {
-        rc = -1;
-        goto clean_exit;
-    }
-
-    memcpy(out_buffer, temp_buffer, out_buffer_len);
-
-    *signature = out_buffer;
-    *signature_len = out_buffer_len;
-
-clean_exit:
-
-    if(temp_buffer != NULL)
-        free(temp_buffer);
-
-    if(sig)
-        ECDSA_SIG_free(sig);
-
-    return rc;
-}
-#endif /* LIBSSH2_ECDSA */
-
-int
-_libssh2_sha1_init(libssh2_sha1_ctx *ctx)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *ctx = EVP_MD_CTX_new();
-
-    if(*ctx == NULL)
-        return 0;
-
-    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1")))
-        return 1;
-
-    EVP_MD_CTX_free(*ctx);
-    *ctx = NULL;
-
-    return 0;
-#else
-    EVP_MD_CTX_init(ctx);
-    return EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"));
-#endif
-}
-
-int
-_libssh2_sha1(const unsigned char *message, unsigned long len,
-              unsigned char *out)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    EVP_MD_CTX * ctx = EVP_MD_CTX_new();
-
-    if(ctx == NULL)
-        return 1; /* error */
-
-    if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) {
-        EVP_DigestUpdate(ctx, message, len);
-        EVP_DigestFinal(ctx, out, NULL);
-        EVP_MD_CTX_free(ctx);
-        return 0; /* success */
-    }
-    EVP_MD_CTX_free(ctx);
-#else
-    EVP_MD_CTX ctx;
-
-    EVP_MD_CTX_init(&ctx);
-    if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha1"))) {
-        EVP_DigestUpdate(&ctx, message, len);
-        EVP_DigestFinal(&ctx, out, NULL);
-        return 0; /* success */
-    }
-#endif
-    return 1; /* error */
-}
-
-int
-_libssh2_sha256_init(libssh2_sha256_ctx *ctx)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *ctx = EVP_MD_CTX_new();
-
-    if(*ctx == NULL)
-        return 0;
-
-    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256")))
-        return 1;
-
-    EVP_MD_CTX_free(*ctx);
-    *ctx = NULL;
-
-    return 0;
-#else
-    EVP_MD_CTX_init(ctx);
-    return EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"));
-#endif
-}
-
-int
-_libssh2_sha256(const unsigned char *message, unsigned long len,
-                unsigned char *out)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    EVP_MD_CTX * ctx = EVP_MD_CTX_new();
-
-    if(ctx == NULL)
-        return 1; /* error */
-
-    if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"))) {
-        EVP_DigestUpdate(ctx, message, len);
-        EVP_DigestFinal(ctx, out, NULL);
-        EVP_MD_CTX_free(ctx);
-        return 0; /* success */
-    }
-    EVP_MD_CTX_free(ctx);
-#else
-    EVP_MD_CTX ctx;
-
-    EVP_MD_CTX_init(&ctx);
-    if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha256"))) {
-        EVP_DigestUpdate(&ctx, message, len);
-        EVP_DigestFinal(&ctx, out, NULL);
-        return 0; /* success */
-    }
-#endif
-    return 1; /* error */
-}
-
-int
-_libssh2_sha384_init(libssh2_sha384_ctx *ctx)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *ctx = EVP_MD_CTX_new();
-
-    if(*ctx == NULL)
-        return 0;
-
-    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384")))
-        return 1;
-
-    EVP_MD_CTX_free(*ctx);
-    *ctx = NULL;
-
-    return 0;
-#else
-    EVP_MD_CTX_init(ctx);
-    return EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"));
-#endif
-}
-
-int
-_libssh2_sha384(const unsigned char *message, unsigned long len,
-    unsigned char *out)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    EVP_MD_CTX * ctx = EVP_MD_CTX_new();
-
-    if(ctx == NULL)
-        return 1; /* error */
-
-    if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"))) {
-        EVP_DigestUpdate(ctx, message, len);
-        EVP_DigestFinal(ctx, out, NULL);
-        EVP_MD_CTX_free(ctx);
-        return 0; /* success */
-    }
-    EVP_MD_CTX_free(ctx);
-#else
-    EVP_MD_CTX ctx;
-
-    EVP_MD_CTX_init(&ctx);
-    if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha384"))) {
-        EVP_DigestUpdate(&ctx, message, len);
-        EVP_DigestFinal(&ctx, out, NULL);
-        return 0; /* success */
-    }
-#endif
-    return 1; /* error */
-}
-
-int
-_libssh2_sha512_init(libssh2_sha512_ctx *ctx)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *ctx = EVP_MD_CTX_new();
-
-    if(*ctx == NULL)
-        return 0;
-
-    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512")))
-        return 1;
-
-    EVP_MD_CTX_free(*ctx);
-    *ctx = NULL;
-
-    return 0;
-#else
-    EVP_MD_CTX_init(ctx);
-    return EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"));
-#endif
-}
-
-int
-_libssh2_sha512(const unsigned char *message, unsigned long len,
-    unsigned char *out)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    EVP_MD_CTX * ctx = EVP_MD_CTX_new();
-
-    if(ctx == NULL)
-        return 1; /* error */
-
-    if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"))) {
-        EVP_DigestUpdate(ctx, message, len);
-        EVP_DigestFinal(ctx, out, NULL);
-        EVP_MD_CTX_free(ctx);
-        return 0; /* success */
-    }
-    EVP_MD_CTX_free(ctx);
-#else
-    EVP_MD_CTX ctx;
-
-    EVP_MD_CTX_init(&ctx);
-    if(EVP_DigestInit(&ctx, EVP_get_digestbyname("sha512"))) {
-        EVP_DigestUpdate(&ctx, message, len);
-        EVP_DigestFinal(&ctx, out, NULL);
-        return 0; /* success */
-    }
-#endif
-    return 1; /* error */
-}
-
-int
-_libssh2_md5_init(libssh2_md5_ctx *ctx)
-{
-    /* MD5 digest is not supported in OpenSSL FIPS mode
-     * Trying to init it will result in a latent OpenSSL error:
-     * "digital envelope routines:FIPS_DIGESTINIT:disabled for fips"
-     * So, just return 0 in FIPS mode
-     */
-#if OPENSSL_VERSION_NUMBER >= 0x000907000L && \
-    defined(OPENSSL_VERSION_MAJOR) && \
-    OPENSSL_VERSION_MAJOR < 3 && \
-    !defined(LIBRESSL_VERSION_NUMBER)
-     if(FIPS_mode() != 0)
-         return 0;
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    *ctx = EVP_MD_CTX_new();
-
-    if(*ctx == NULL)
-        return 0;
-
-    if(EVP_DigestInit(*ctx, EVP_get_digestbyname("md5")))
-        return 1;
-
-    EVP_MD_CTX_free(*ctx);
-    *ctx = NULL;
-
-    return 0;
-#else
-    EVP_MD_CTX_init(ctx);
-    return EVP_DigestInit(ctx, EVP_get_digestbyname("md5"));
-#endif
-}
-
-#if LIBSSH2_ECDSA
-
-static int
-gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
-                          unsigned char **method,
-                          size_t *method_len,
-                          unsigned char **pubkeydata,
-                          size_t *pubkeydata_len,
-                          EVP_PKEY *pk)
-{
-    int rc = 0;
-    EC_KEY *ec = NULL;
-    unsigned char *p;
-    unsigned char *method_buf = NULL;
-    unsigned char *key;
-    size_t  key_len = 0;
-    unsigned char *octal_value = NULL;
-    size_t octal_len;
-    const EC_POINT *public_key;
-    const EC_GROUP *group;
-    BN_CTX *bn_ctx;
-    libssh2_curve_type type;
-
-    _libssh2_debug(session,
-       LIBSSH2_TRACE_AUTH,
-       "Computing public key from EC private key envelope");
-
-    bn_ctx = BN_CTX_new();
-    if(bn_ctx == NULL)
-        return -1;
-
-    ec = EVP_PKEY_get1_EC_KEY(pk);
-    if(ec == NULL) {
-        rc = -1;
-        goto clean_exit;
-    }
-
-    public_key = EC_KEY_get0_public_key(ec);
-    group = EC_KEY_get0_group(ec);
-    type = _libssh2_ecdsa_get_curve_type(ec);
-
-    method_buf = LIBSSH2_ALLOC(session, 19);
-    if(method_buf == NULL) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-            "out of memory");
-    }
-
-    if(type == LIBSSH2_EC_CURVE_NISTP256)
-        memcpy(method_buf, "ecdsa-sha2-nistp256", 19);
-    else if(type == LIBSSH2_EC_CURVE_NISTP384)
-        memcpy(method_buf, "ecdsa-sha2-nistp384", 19);
-    else if(type == LIBSSH2_EC_CURVE_NISTP521)
-        memcpy(method_buf, "ecdsa-sha2-nistp521", 19);
-    else {
-        _libssh2_debug(session,
-            LIBSSH2_TRACE_ERROR,
-            "Unsupported EC private key type");
-        rc = -1;
-        goto clean_exit;
-    }
-
-    /* get length */
-    octal_len = EC_POINT_point2oct(group, public_key,
-                                   POINT_CONVERSION_UNCOMPRESSED,
-                                   NULL, 0, bn_ctx);
-    if(octal_len > EC_MAX_POINT_LEN) {
-        rc = -1;
-        goto clean_exit;
-    }
-
-    octal_value = malloc(octal_len);
-    if(octal_value == NULL) {
-        rc = -1;
-        goto clean_exit;
-    }
-
-    /* convert to octal */
-    if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
-       octal_value, octal_len, bn_ctx) != octal_len) {
-           rc = -1;
-           goto clean_exit;
-    }
-
-    /* Key form is: type_len(4) + type(19) + domain_len(4) + domain(8) +
-       pub_key_len(4) + pub_key(~65). */
-    key_len = 4 + 19 + 4 + 8 + 4 + octal_len;
-    key = LIBSSH2_ALLOC(session, key_len);
-    if(key == NULL) {
-        rc = -1;
-        goto  clean_exit;
-    }
-
-    /* Process key encoding. */
-    p = key;
-
-    /* Key type */
-    _libssh2_store_str(&p, (const char *)method_buf, 19);
-
-    /* Name domain */
-    _libssh2_store_str(&p, (const char *)method_buf + 11, 8);
-
-    /* Public key */
-    _libssh2_store_str(&p, (const char *)octal_value, octal_len);
-
-    *method         = method_buf;
-    *method_len     = 19;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
-
-clean_exit:
-
-    if(ec != NULL)
-        EC_KEY_free(ec);
-
-    if(bn_ctx != NULL) {
-        BN_CTX_free(bn_ctx);
-    }
-
-    if(octal_value != NULL)
-        free(octal_value);
-
-    if(rc == 0)
-        return 0;
-
-    if(method_buf != NULL)
-        LIBSSH2_FREE(session, method_buf);
-
-    return -1;
-}
-
-static int
-gen_publickey_from_ecdsa_openssh_priv_data(LIBSSH2_SESSION *session,
-                                           libssh2_curve_type curve_type,
-                                           struct string_buf *decrypted,
-                                           unsigned char **method,
-                                           size_t *method_len,
-                                           unsigned char **pubkeydata,
-                                           size_t *pubkeydata_len,
-                                           libssh2_ecdsa_ctx **ec_ctx)
-{
-    int rc = 0;
-    size_t curvelen, exponentlen, pointlen;
-    unsigned char *curve, *exponent, *point_buf;
-    EC_KEY *ec_key = NULL;
-    BIGNUM *bn_exponent;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing ECDSA keys from private key data");
-
-    if(_libssh2_get_string(decrypted, &curve, &curvelen) ||
-        curvelen == 0) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "ECDSA no curve");
-        return -1;
-    }
-
-    if(_libssh2_get_string(decrypted, &point_buf, &pointlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "ECDSA no point");
-        return -1;
-    }
-
-    if(_libssh2_get_bignum_bytes(decrypted, &exponent, &exponentlen)) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "ECDSA no exponent");
-        return -1;
-    }
-
-    if((rc = _libssh2_ecdsa_curve_name_with_octal_new(&ec_key, point_buf,
-        pointlen, curve_type)) != 0) {
-        rc = -1;
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "ECDSA could not create key");
-        goto fail;
-    }
-
-    bn_exponent = BN_new();
-    if(bn_exponent == NULL) {
-        rc = -1;
-        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                       "Unable to allocate memory for private key data");
-        goto fail;
-    }
-
-    BN_bin2bn(exponent, exponentlen, bn_exponent);
-    rc = (EC_KEY_set_private_key(ec_key, bn_exponent) != 1);
-
-    if(rc == 0 && ec_key != NULL && pubkeydata != NULL && method != NULL) {
-        EVP_PKEY *pk = EVP_PKEY_new();
-        EVP_PKEY_set1_EC_KEY(pk, ec_key);
-
-        rc = gen_publickey_from_ec_evp(session, method, method_len,
-                                       pubkeydata, pubkeydata_len,
-                                       pk);
-
-        if(pk)
-            EVP_PKEY_free(pk);
-    }
-
-    if(ec_ctx != NULL)
-        *ec_ctx = ec_key;
-    else
-        EC_KEY_free(ec_key);
-
-    return rc;
-
-fail:
-    if(ec_key != NULL)
-        EC_KEY_free(ec_key);
-
-    return rc;
-}
-
-static int
-_libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx ** ec_ctx,
-                                   LIBSSH2_SESSION * session,
-                                   const char *filename,
-                                   unsigned const char *passphrase)
-{
-    FILE *fp;
-    int rc;
-    unsigned char *buf = NULL;
-    libssh2_curve_type type;
-    struct string_buf *decrypted = NULL;
-
-    if(session == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Session is required");
-        return -1;
-    }
-
-    _libssh2_init_if_needed();
-
-    fp = fopen(filename, "r");
-    if(!fp) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unable to open OpenSSH ECDSA private key file");
-        return -1;
-    }
-
-    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
-    fclose(fp);
-    if(rc) {
-        return rc;
-    }
-
-    /* We have a new key file, now try and parse it using supported types  */
-    rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-    if(rc != 0 || buf == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Public key type in decrypted key data not found");
-        return -1;
-    }
-
-    rc = _libssh2_ecdsa_curve_type_from_name((const char *)buf, &type);
-
-    if(rc == 0) {
-        rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
-                                                        decrypted, NULL, 0,
-                                                        NULL, 0, ec_ctx);
-    }
-    else {
-        rc = -1;
-    }
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    return rc;
-}
-
-int
-_libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
-       LIBSSH2_SESSION * session,
-       const char *filename, unsigned const char *passphrase)
-{
-    int rc;
-
-    pem_read_bio_func read_ec = (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
-
-    _libssh2_init_if_needed();
-
-    rc = read_private_key_from_file((void **) ec_ctx, read_ec,
-      filename, passphrase);
-
-    if(rc) {
-        return _libssh2_ecdsa_new_openssh_private(ec_ctx, session,
-                                                  filename, passphrase);
-    }
-
-    return rc;
-}
-
-/*
- * _libssh2_ecdsa_create_key
- *
- * Creates a local private key based on input curve
- * and returns octal value and octal length
- *
- */
-
-int
-_libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
-                          _libssh2_ec_key **out_private_key,
-                          unsigned char **out_public_key_octal,
-                          size_t *out_public_key_octal_len,
-                          libssh2_curve_type curve_type)
-{
-    int ret = 1;
-    size_t octal_len = 0;
-    unsigned char octal_value[EC_MAX_POINT_LEN];
-    const EC_POINT *public_key = NULL;
-    EC_KEY *private_key = NULL;
-    const EC_GROUP *group = NULL;
-
-    /* create key */
-    BN_CTX *bn_ctx = BN_CTX_new();
-    if(!bn_ctx)
-        return -1;
-
-    private_key = EC_KEY_new_by_curve_name(curve_type);
-    group = EC_KEY_get0_group(private_key);
-
-    EC_KEY_generate_key(private_key);
-    public_key = EC_KEY_get0_public_key(private_key);
-
-    /* get length */
-    octal_len = EC_POINT_point2oct(group, public_key,
-                                   POINT_CONVERSION_UNCOMPRESSED,
-                                   NULL, 0, bn_ctx);
-    if(octal_len > EC_MAX_POINT_LEN) {
-        ret = -1;
-        goto clean_exit;
-    }
-
-    /* convert to octal */
-    if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
-       octal_value, octal_len, bn_ctx) != octal_len) {
-           ret = -1;
-           goto clean_exit;
-    }
-
-    if(out_private_key != NULL)
-        *out_private_key = private_key;
-
-    if(out_public_key_octal) {
-        *out_public_key_octal = LIBSSH2_ALLOC(session, octal_len);
-        if(*out_public_key_octal == NULL) {
-            ret = -1;
-            goto clean_exit;
-        }
-
-        memcpy(*out_public_key_octal, octal_value, octal_len);
-    }
-
-    if(out_public_key_octal_len != NULL)
-        *out_public_key_octal_len = octal_len;
-
-clean_exit:
-
-    if(bn_ctx)
-        BN_CTX_free(bn_ctx);
-
-    return (ret == 1) ? 0 : -1;
-}
-
-/* _libssh2_ecdh_gen_k
- *
- * Computes the shared secret K given a local private key,
- * remote public key and length
- */
-
-int
-_libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
-    const unsigned char *server_public_key, size_t server_public_key_len)
-{
-    int ret = 0;
-    int rc;
-    size_t secret_len;
-    unsigned char *secret = NULL;
-    const EC_GROUP *private_key_group;
-    EC_POINT *server_public_key_point;
-
-    BN_CTX *bn_ctx = BN_CTX_new();
-
-    if(!bn_ctx)
-        return -1;
-
-    if(k == NULL)
-        return -1;
-
-    private_key_group = EC_KEY_get0_group(private_key);
-
-    server_public_key_point = EC_POINT_new(private_key_group);
-    if(server_public_key_point == NULL)
-        return -1;
-
-    rc = EC_POINT_oct2point(private_key_group, server_public_key_point,
-                            server_public_key, server_public_key_len, bn_ctx);
-    if(rc != 1) {
-        ret = -1;
-        goto clean_exit;
-    }
-
-    secret_len = (EC_GROUP_get_degree(private_key_group) + 7) / 8;
-    secret = malloc(secret_len);
-    if(!secret) {
-        ret = -1;
-        goto clean_exit;
-    }
-
-    secret_len = ECDH_compute_key(secret, secret_len, server_public_key_point,
-                                  private_key, NULL);
-
-    if(secret_len <= 0 || secret_len > EC_MAX_POINT_LEN) {
-        ret = -1;
-        goto clean_exit;
-    }
-
-    BN_bin2bn(secret, secret_len, *k);
-
-clean_exit:
-
-    if(server_public_key_point != NULL)
-        EC_POINT_free(server_public_key_point);
-
-    if(bn_ctx != NULL)
-        BN_CTX_free(bn_ctx);
-
-    if(secret != NULL)
-        free(secret);
-
-    return ret;
-}
-
-
-#endif /* LIBSSH2_ECDSA */
-
-#if LIBSSH2_ED25519
-
-int
-_libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
-                      uint8_t **out_sig, size_t *out_sig_len,
-                      const uint8_t *message, size_t message_len)
-{
-    int rc = -1;
-    EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
-    size_t sig_len = 0;
-    unsigned char *sig = NULL;
-
-    if(md_ctx != NULL) {
-        if(EVP_DigestSignInit(md_ctx, NULL, NULL, NULL, ctx) != 1)
-            goto clean_exit;
-        if(EVP_DigestSign(md_ctx, NULL, &sig_len, message, message_len) != 1)
-            goto clean_exit;
-
-        if(sig_len != LIBSSH2_ED25519_SIG_LEN)
-            goto clean_exit;
-
-        sig = LIBSSH2_CALLOC(session, sig_len);
-        if(sig == NULL)
-            goto clean_exit;
-
-        rc = EVP_DigestSign(md_ctx, sig, &sig_len, message, message_len);
-    }
-
-    if(rc == 1) {
-        *out_sig = sig;
-        *out_sig_len = sig_len;
-    }
-    else {
-        *out_sig_len = 0;
-        *out_sig = NULL;
-        LIBSSH2_FREE(session, sig);
-    }
-
-clean_exit:
-
-    if(md_ctx)
-        EVP_MD_CTX_free(md_ctx);
-
-    return (rc == 1 ? 0 : -1);
-}
-
-int
-_libssh2_curve25519_gen_k(_libssh2_bn **k,
-                          uint8_t private_key[LIBSSH2_ED25519_KEY_LEN],
-                          uint8_t server_public_key[LIBSSH2_ED25519_KEY_LEN])
-{
-    int rc = -1;
-    unsigned char out_shared_key[LIBSSH2_ED25519_KEY_LEN];
-    EVP_PKEY *peer_key = NULL, *server_key = NULL;
-    EVP_PKEY_CTX *server_key_ctx = NULL;
-    BN_CTX *bn_ctx = NULL;
-    size_t out_len = 0;
-
-    if(k == NULL || *k == NULL)
-        return -1;
-
-    bn_ctx = BN_CTX_new();
-    if(bn_ctx == NULL)
-        return -1;
-
-    peer_key = EVP_PKEY_new_raw_public_key(EVP_PKEY_X25519, NULL,
-                                           server_public_key,
-                                           LIBSSH2_ED25519_KEY_LEN);
-
-    server_key = EVP_PKEY_new_raw_private_key(EVP_PKEY_X25519, NULL,
-                                              private_key,
-                                              LIBSSH2_ED25519_KEY_LEN);
-
-    if(peer_key == NULL || server_key == NULL) {
-        goto cleanExit;
-    }
-
-    server_key_ctx = EVP_PKEY_CTX_new(server_key, NULL);
-    if(server_key_ctx == NULL) {
-        goto cleanExit;
-    }
-
-    rc = EVP_PKEY_derive_init(server_key_ctx);
-    if(rc <= 0) goto cleanExit;
-
-    rc = EVP_PKEY_derive_set_peer(server_key_ctx, peer_key);
-    if(rc <= 0) goto cleanExit;
-
-    rc = EVP_PKEY_derive(server_key_ctx, NULL, &out_len);
-    if(rc <= 0) goto cleanExit;
-
-    if(out_len != LIBSSH2_ED25519_KEY_LEN) {
-        rc = -1;
-        goto cleanExit;
-    }
-
-    rc = EVP_PKEY_derive(server_key_ctx, out_shared_key, &out_len);
-
-    if(rc == 1 && out_len == LIBSSH2_ED25519_KEY_LEN) {
-        BN_bin2bn(out_shared_key, LIBSSH2_ED25519_KEY_LEN, *k);
-    }
-    else {
-        rc = -1;
-    }
-
-cleanExit:
-
-    if(server_key_ctx)
-        EVP_PKEY_CTX_free(server_key_ctx);
-    if(peer_key)
-        EVP_PKEY_free(peer_key);
-    if(server_key)
-        EVP_PKEY_free(server_key);
-    if(bn_ctx != NULL)
-        BN_CTX_free(bn_ctx);
-
-    return (rc == 1) ? 0 : -1;
-}
-
-
-int
-_libssh2_ed25519_verify(libssh2_ed25519_ctx *ctx, const uint8_t *s,
-                        size_t s_len, const uint8_t *m, size_t m_len)
-{
-    int ret = -1;
-
-    EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
-    if(NULL == md_ctx)
-        return -1;
-
-    ret = EVP_DigestVerifyInit(md_ctx, NULL, NULL, NULL, ctx);
-    if(ret != 1)
-        goto clean_exit;
-
-    ret = EVP_DigestVerify(md_ctx, s, s_len, m, m_len);
-
-    clean_exit:
-
-    EVP_MD_CTX_free(md_ctx);
-
-    return (ret == 1) ? 0 : -1;
-}
-
-#endif /* LIBSSH2_ED25519 */
-
-static int
-_libssh2_pub_priv_openssh_keyfile(LIBSSH2_SESSION *session,
-                                  unsigned char **method,
-                                  size_t *method_len,
-                                  unsigned char **pubkeydata,
-                                  size_t *pubkeydata_len,
-                                  const char *privatekey,
-                                  const char *passphrase)
-{
-    FILE *fp;
-    unsigned char *buf = NULL;
-    struct string_buf *decrypted = NULL;
-    int rc = 0;
-
-    if(session == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Session is required");
-        return -1;
-    }
-
-    _libssh2_init_if_needed();
-
-    fp = fopen(privatekey, "r");
-    if(!fp) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unable to open private key file");
-        return -1;
-    }
-
-    rc = _libssh2_openssh_pem_parse(session, (const unsigned char *)passphrase,
-                                    fp, &decrypted);
-    fclose(fp);
-    if(rc) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Not an OpenSSH key file");
-        return rc;
-    }
-
-    /* We have a new key file, now try and parse it using supported types  */
-    rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-    if(rc != 0 || buf == NULL) {
-        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Public key type in decrypted key data not found");
-        return -1;
-    }
-
-    rc = -1;
-
-#if LIBSSH2_ED25519
-    if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
-        rc = gen_publickey_from_ed25519_openssh_priv_data(session, decrypted,
-                                                          method, method_len,
-                                                          pubkeydata,
-                                                          pubkeydata_len,
-                                                          NULL);
-    }
-#endif
-#if LIBSSH2_RSA
-    if(strcmp("ssh-rsa", (const char *)buf) == 0) {
-        rc = gen_publickey_from_rsa_openssh_priv_data(session, decrypted,
-                                                      method, method_len,
-                                                      pubkeydata,
-                                                      pubkeydata_len,
-                                                      NULL);
-    }
-#endif
-#if LIBSSH2_DSA
-    if(strcmp("ssh-dss", (const char *)buf) == 0) {
-        rc = gen_publickey_from_dsa_openssh_priv_data(session, decrypted,
-                                                      method, method_len,
-                                                      pubkeydata,
-                                                      pubkeydata_len,
-                                                      NULL);
-    }
-#endif
-#if LIBSSH2_ECDSA
-    {
-        libssh2_curve_type type;
-
-        if(_libssh2_ecdsa_curve_type_from_name((const char *)buf,
-                                               &type) == 0) {
-            rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
-                                                            decrypted,
-                                                            method, method_len,
-                                                            pubkeydata,
-                                                            pubkeydata_len,
-                                                            NULL);
-        }
-    }
-#endif
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    if(rc != 0) {
-        _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                       "Unsupported OpenSSH key type");
-    }
-
-    return rc;
-}
-
-int
-_libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                          unsigned char **method,
-                          size_t *method_len,
-                          unsigned char **pubkeydata,
-                          size_t *pubkeydata_len,
-                          const char *privatekey,
-                          const char *passphrase)
-{
-    int       st;
-    BIO*      bp;
-    EVP_PKEY* pk;
-    int       pktype;
-    int       rc;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing public key from private key file: %s",
-                   privatekey);
-
-    bp = BIO_new_file(privatekey, "r");
-    if(bp == NULL) {
-        return _libssh2_error(session,
-                              LIBSSH2_ERROR_FILE,
-                              "Unable to extract public key from private key "
-                              "file: Unable to open private key file");
-    }
-
-    BIO_reset(bp);
-    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
-    BIO_free(bp);
-
-    if(pk == NULL) {
-
-        /* Try OpenSSH format */
-        rc = _libssh2_pub_priv_openssh_keyfile(session,
-                                               method,
-                                               method_len,
-                                               pubkeydata, pubkeydata_len,
-                                               privatekey, passphrase);
-        if(rc != 0) {
-            return _libssh2_error(session,
-                                  LIBSSH2_ERROR_FILE,
-                                  "Unable to extract public key "
-                                  "from private key file: "
-                                  "Wrong passphrase or invalid/unrecognized "
-                                  "private key file format");
-        }
-
-        return 0;
-    }
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    pktype = EVP_PKEY_id(pk);
-#else
-    pktype = pk->type;
-#endif
-
-    switch(pktype) {
-#if LIBSSH2_ED25519
-    case EVP_PKEY_ED25519 :
-        st = gen_publickey_from_ed_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
-        break;
-#endif /* LIBSSH2_ED25519 */
-    case EVP_PKEY_RSA :
-        st = gen_publickey_from_rsa_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
-        break;
-
-#if LIBSSH2_DSA
-    case EVP_PKEY_DSA :
-        st = gen_publickey_from_dsa_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
-        break;
-#endif /* LIBSSH_DSA */
-
-#if LIBSSH2_ECDSA
-    case EVP_PKEY_EC :
-        st = gen_publickey_from_ec_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
-    break;
-#endif
-
-    default :
-        st = _libssh2_error(session,
-                            LIBSSH2_ERROR_FILE,
-                            "Unable to extract public key "
-                            "from private key file: "
-                            "Unsupported private key file format");
-        break;
-    }
-
-    EVP_PKEY_free(pk);
-    return st;
-}
-
-static int
-_libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
-                                        void **key_ctx,
-                                        const char *key_type,
-                                        unsigned char **method,
-                                        size_t *method_len,
-                                        unsigned char **pubkeydata,
-                                        size_t *pubkeydata_len,
-                                        const char *privatekeydata,
-                                        size_t privatekeydata_len,
-                                        unsigned const char *passphrase)
-{
-    int rc;
-    unsigned char *buf = NULL;
-    struct string_buf *decrypted = NULL;
-
-    if(key_ctx != NULL)
-        *key_ctx = NULL;
-
-    if(session == NULL)
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "Session is required");
-
-    if(key_type != NULL && (strlen(key_type) > 11 || strlen(key_type) < 7))
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "type is invalid");
-
-    _libssh2_init_if_needed();
-
-    rc = _libssh2_openssh_pem_parse_memory(session, passphrase,
-                                           privatekeydata,
-                                           privatekeydata_len, &decrypted);
-
-    if(rc)
-        return rc;
-
-   /* We have a new key file, now try and parse it using supported types  */
-   rc = _libssh2_get_string(decrypted, &buf, NULL);
-
-   if(rc != 0 || buf == NULL)
-       return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "Public key type in decrypted "
-                             "key data not found");
-
-   rc = LIBSSH2_ERROR_FILE;
-
-#if LIBSSH2_ED25519
-    if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-ed25519", key_type) == 0) {
-            rc = gen_publickey_from_ed25519_openssh_priv_data(session,
-                                                              decrypted,
-                                                              method,
-                                                              method_len,
-                                                              pubkeydata,
-                                                              pubkeydata_len,
-                                              (libssh2_ed25519_ctx**)key_ctx);
-        }
-   }
-#endif
-#if LIBSSH2_RSA
-    if(strcmp("ssh-rsa", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-rsa", key_type) == 0) {
-            rc = gen_publickey_from_rsa_openssh_priv_data(session, decrypted,
-                                                          method, method_len,
-                                                          pubkeydata,
-                                                          pubkeydata_len,
-                                                (libssh2_rsa_ctx**)key_ctx);
-        }
-   }
-#endif
-#if LIBSSH2_DSA
-    if(strcmp("ssh-dss", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-dss", key_type) == 0) {
-            rc = gen_publickey_from_dsa_openssh_priv_data(session, decrypted,
-                                                         method, method_len,
-                                                          pubkeydata,
-                                                          pubkeydata_len,
-                                                 (libssh2_dsa_ctx**)key_ctx);
-        }
-   }
-#endif
-#if LIBSSH2_ECDSA
-{
-   libssh2_curve_type type;
-
-   if(_libssh2_ecdsa_curve_type_from_name((const char *)buf, &type) == 0) {
-       if(key_type == NULL || strcmp("ssh-ecdsa", key_type) == 0) {
-           rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
-                                                           decrypted,
-                                                           method, method_len,
-                                                           pubkeydata,
-                                                           pubkeydata_len,
-                                               (libssh2_ecdsa_ctx**)key_ctx);
-        }
-    }
-}
-#endif
-
-    if(rc == LIBSSH2_ERROR_FILE)
-        rc = _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                         "Unable to extract public key from private key file: "
-                         "invalid/unrecognized private key file format");
-
-    if(decrypted)
-        _libssh2_string_buf_free(session, decrypted);
-
-    return rc;
-}
-
-int
-read_openssh_private_key_from_memory(void **key_ctx, LIBSSH2_SESSION *session,
-                                     const char *key_type,
-                                     const char *filedata,
-                                     size_t filedata_len,
-                                     unsigned const char *passphrase)
-{
-    return _libssh2_pub_priv_openssh_keyfilememory(session, key_ctx, key_type,
-                                                   NULL, NULL, NULL, NULL,
-                                                   filedata, filedata_len,
-                                                   passphrase);
-}
-
-int
-_libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                unsigned char **method,
-                                size_t *method_len,
-                                unsigned char **pubkeydata,
-                                size_t *pubkeydata_len,
-                                const char *privatekeydata,
-                                size_t privatekeydata_len,
-                                const char *passphrase)
-{
-    int       st;
-    BIO*      bp;
-    EVP_PKEY* pk;
-    int       pktype;
-
-    _libssh2_debug(session,
-                   LIBSSH2_TRACE_AUTH,
-                   "Computing public key from private key.");
-
-    bp = BIO_new_mem_buf((char *)privatekeydata, privatekeydata_len);
-    if(!bp)
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory when"
-                              "computing public key");
-    BIO_reset(bp);
-    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
-    BIO_free(bp);
-
-    if(pk == NULL) {
-        /* Try OpenSSH format */
-        st = _libssh2_pub_priv_openssh_keyfilememory(session, NULL, NULL,
-                                                     method,
-                                                     method_len,
-                                                     pubkeydata,
-                                                     pubkeydata_len,
-                                                     privatekeydata,
-                                                     privatekeydata_len,
-                                           (unsigned const char *)passphrase);
-        if(st != 0)
-            return st;
-        return 0;
-    }
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    pktype = EVP_PKEY_id(pk);
-#else
-    pktype = pk->type;
-#endif
-
-    switch(pktype) {
-#if LIBSSH2_ED25519
-    case EVP_PKEY_ED25519 :
-        st = gen_publickey_from_ed_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
-        break;
-#endif /* LIBSSH2_ED25519 */
-    case EVP_PKEY_RSA :
-        st = gen_publickey_from_rsa_evp(session, method, method_len,
-                                        pubkeydata, pubkeydata_len, pk);
-        break;
-#if LIBSSH2_DSA
-    case EVP_PKEY_DSA :
-        st = gen_publickey_from_dsa_evp(session, method, method_len,
-                                        pubkeydata, pubkeydata_len, pk);
-        break;
-#endif /* LIBSSH_DSA */
-#if LIBSSH2_ECDSA
-    case EVP_PKEY_EC :
-        st = gen_publickey_from_ec_evp(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, pk);
-        break;
-#endif /* LIBSSH2_ECDSA */
-    default :
-        st = _libssh2_error(session,
-                            LIBSSH2_ERROR_FILE,
-                            "Unable to extract public key "
-                            "from private key file: "
-                            "Unsupported private key file format");
-        break;
-    }
-
-    EVP_PKEY_free(pk);
-    return st;
-}
-
-void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx)
-{
-    *dhctx = BN_new();                          /* Random from client */
-}
-
-int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                     _libssh2_bn *g, _libssh2_bn *p, int group_order,
-                     _libssh2_bn_ctx *bnctx)
-{
-    /* Generate x and e */
-    BN_rand(*dhctx, group_order * 8 - 1, 0, -1);
-    BN_mod_exp(public, g, *dhctx, p, bnctx);
-    return 0;
-}
-
-int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                   _libssh2_bn *f, _libssh2_bn *p,
-                   _libssh2_bn_ctx *bnctx)
-{
-    /* Compute the shared secret */
-    BN_mod_exp(secret, f, *dhctx, p, bnctx);
-    return 0;
-}
-
-void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
-{
-    BN_clear_free(*dhctx);
-    *dhctx = NULL;
-}
-
-#endif /* LIBSSH2_OPENSSL */
diff --git a/libssh2/libssh2/src/openssl.h b/libssh2/libssh2/src/openssl.h
deleted file mode 100644
index 658b040d..00000000
--- a/libssh2/libssh2/src/openssl.h
+++ /dev/null
@@ -1,396 +0,0 @@
-#ifndef __LIBSSH2_OPENSSL_H
-#define __LIBSSH2_OPENSSL_H
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- *
- * Author: Simon Josefsson
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include <openssl/opensslconf.h>
-#include <openssl/sha.h>
-#include <openssl/rsa.h>
-#ifndef OPENSSL_NO_ENGINE
-#include <openssl/engine.h>
-#endif
-#ifndef OPENSSL_NO_DSA
-#include <openssl/dsa.h>
-#endif
-#ifndef OPENSSL_NO_MD5
-#include <openssl/md5.h>
-#endif
-#include <openssl/evp.h>
-#include <openssl/hmac.h>
-#include <openssl/bn.h>
-#include <openssl/pem.h>
-#include <openssl/rand.h>
-
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
-    !defined(LIBRESSL_VERSION_NUMBER)
-# define HAVE_OPAQUE_STRUCTS 1
-#endif
-
-#ifdef OPENSSL_NO_RSA
-# define LIBSSH2_RSA 0
-#else
-# define LIBSSH2_RSA 1
-#endif
-
-#ifdef OPENSSL_NO_DSA
-# define LIBSSH2_DSA 0
-#else
-# define LIBSSH2_DSA 1
-#endif
-
-#ifdef OPENSSL_NO_ECDSA
-# define LIBSSH2_ECDSA 0
-#else
-# define LIBSSH2_ECDSA 1
-#endif
-
-#if OPENSSL_VERSION_NUMBER >= 0x10101000L && \
-!defined(LIBRESSL_VERSION_NUMBER)
-# define LIBSSH2_ED25519 1
-#else
-# define LIBSSH2_ED25519 0
-#endif
-
-
-#ifdef OPENSSL_NO_MD5
-# define LIBSSH2_MD5 0
-#else
-# define LIBSSH2_MD5 1
-#endif
-
-#ifdef OPENSSL_NO_RIPEMD
-# define LIBSSH2_HMAC_RIPEMD 0
-#else
-# define LIBSSH2_HMAC_RIPEMD 1
-#endif
-
-#define LIBSSH2_HMAC_SHA256 1
-#define LIBSSH2_HMAC_SHA512 1
-
-#if OPENSSL_VERSION_NUMBER >= 0x00907000L && !defined(OPENSSL_NO_AES)
-# define LIBSSH2_AES_CTR 1
-# define LIBSSH2_AES 1
-#else
-# define LIBSSH2_AES_CTR 0
-# define LIBSSH2_AES 0
-#endif
-
-#ifdef OPENSSL_NO_BF
-# define LIBSSH2_BLOWFISH 0
-#else
-# define LIBSSH2_BLOWFISH 1
-#endif
-
-#ifdef OPENSSL_NO_RC4
-# define LIBSSH2_RC4 0
-#else
-# define LIBSSH2_RC4 1
-#endif
-
-#ifdef OPENSSL_NO_CAST
-# define LIBSSH2_CAST 0
-#else
-# define LIBSSH2_CAST 1
-#endif
-
-#ifdef OPENSSL_NO_DES
-# define LIBSSH2_3DES 0
-#else
-# define LIBSSH2_3DES 1
-#endif
-
-#define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
-
-#define _libssh2_random(buf, len) (RAND_bytes((buf), (len)) == 1 ? 0 : -1)
-
-#define libssh2_prepare_iovec(vec, len)  /* Empty. */
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha1_ctx EVP_MD_CTX *
-#else
-#define libssh2_sha1_ctx EVP_MD_CTX
-#endif
-
-/* returns 0 in case of failure */
-int _libssh2_sha1_init(libssh2_sha1_ctx *ctx);
-#define libssh2_sha1_init(x) _libssh2_sha1_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha1_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha1_final(ctx, out) do { \
-                                         EVP_DigestFinal(ctx, out, NULL); \
-                                         EVP_MD_CTX_free(ctx); \
-                                     } while(0)
-#else
-#define libssh2_sha1_update(ctx, data, len) EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha1_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha1(const unsigned char *message, unsigned long len,
-                  unsigned char *out);
-#define libssh2_sha1(x,y,z) _libssh2_sha1(x,y,z)
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha256_ctx EVP_MD_CTX *
-#else
-#define libssh2_sha256_ctx EVP_MD_CTX
-#endif
-
-/* returns 0 in case of failure */
-int _libssh2_sha256_init(libssh2_sha256_ctx *ctx);
-#define libssh2_sha256_init(x) _libssh2_sha256_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha256_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha256_final(ctx, out) do { \
-                                           EVP_DigestFinal(ctx, out, NULL); \
-                                           EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
-#define libssh2_sha256_update(ctx, data, len) \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha256_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha256(const unsigned char *message, unsigned long len,
-                  unsigned char *out);
-#define libssh2_sha256(x,y,z) _libssh2_sha256(x,y,z)
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha384_ctx EVP_MD_CTX *
-#else
-#define libssh2_sha384_ctx EVP_MD_CTX
-#endif
-
-/* returns 0 in case of failure */
-int _libssh2_sha384_init(libssh2_sha384_ctx *ctx);
-#define libssh2_sha384_init(x) _libssh2_sha384_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha384_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha384_final(ctx, out) do { \
-                                            EVP_DigestFinal(ctx, out, NULL); \
-                                            EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
-#define libssh2_sha384_update(ctx, data, len)   \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha384_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha384(const unsigned char *message, unsigned long len,
-                    unsigned char *out);
-#define libssh2_sha384(x,y,z) _libssh2_sha384(x,y,z)
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha512_ctx EVP_MD_CTX *
-#else
-#define libssh2_sha512_ctx EVP_MD_CTX
-#endif
-
-/* returns 0 in case of failure */
-int _libssh2_sha512_init(libssh2_sha512_ctx *ctx);
-#define libssh2_sha512_init(x) _libssh2_sha512_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha512_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha512_final(ctx, out) do { \
-                                            EVP_DigestFinal(ctx, out, NULL); \
-                                            EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
-#define libssh2_sha512_update(ctx, data, len)   \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha512_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha512(const unsigned char *message, unsigned long len,
-                    unsigned char *out);
-#define libssh2_sha512(x,y,z) _libssh2_sha512(x,y,z)
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_md5_ctx EVP_MD_CTX *
-#else
-#define libssh2_md5_ctx EVP_MD_CTX
-#endif
-
-/* returns 0 in case of failure */
-int _libssh2_md5_init(libssh2_md5_ctx *ctx);
-#define libssh2_md5_init(x) _libssh2_md5_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_md5_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_md5_final(ctx, out) do { \
-                                        EVP_DigestFinal(ctx, out, NULL); \
-                                        EVP_MD_CTX_free(ctx); \
-                                    } while(0)
-#else
-#define libssh2_md5_update(ctx, data, len) EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_md5_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_hmac_ctx HMAC_CTX *
-#define libssh2_hmac_ctx_init(ctx) ctx = HMAC_CTX_new()
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha1(), NULL)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_md5(), NULL)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_ripemd160(), NULL)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha256(), NULL)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha512(), NULL)
-
-#define libssh2_hmac_update(ctx, data, datalen) \
-  HMAC_Update(ctx, data, datalen)
-#define libssh2_hmac_final(ctx, data) HMAC_Final(ctx, data, NULL)
-#define libssh2_hmac_cleanup(ctx) HMAC_CTX_free(*(ctx))
-#else
-#define libssh2_hmac_ctx HMAC_CTX
-#define libssh2_hmac_ctx_init(ctx) \
-  HMAC_CTX_init(&ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha1(), NULL)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_md5(), NULL)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_ripemd160(), NULL)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha256(), NULL)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha512(), NULL)
-
-#define libssh2_hmac_update(ctx, data, datalen) \
-  HMAC_Update(&(ctx), data, datalen)
-#define libssh2_hmac_final(ctx, data) HMAC_Final(&(ctx), data, NULL)
-#define libssh2_hmac_cleanup(ctx) HMAC_cleanup(ctx)
-#endif
-
-extern void _libssh2_openssl_crypto_init(void);
-extern void _libssh2_openssl_crypto_exit(void);
-#define libssh2_crypto_init() _libssh2_openssl_crypto_init()
-#define libssh2_crypto_exit() _libssh2_openssl_crypto_exit()
-
-#define libssh2_rsa_ctx RSA
-
-#define _libssh2_rsa_free(rsactx) RSA_free(rsactx)
-
-#define libssh2_dsa_ctx DSA
-
-#define _libssh2_dsa_free(dsactx) DSA_free(dsactx)
-
-#if LIBSSH2_ECDSA
-#define libssh2_ecdsa_ctx EC_KEY
-#define _libssh2_ecdsa_free(ecdsactx) EC_KEY_free(ecdsactx)
-#define _libssh2_ec_key EC_KEY
-
-typedef enum {
-    LIBSSH2_EC_CURVE_NISTP256 = NID_X9_62_prime256v1,
-    LIBSSH2_EC_CURVE_NISTP384 = NID_secp384r1,
-    LIBSSH2_EC_CURVE_NISTP521 = NID_secp521r1
-}
-libssh2_curve_type;
-#else
-#define _libssh2_ec_key void
-#endif /* LIBSSH2_ECDSA */
-
-#if LIBSSH2_ED25519
-#define libssh2_ed25519_ctx EVP_PKEY
-
-#define _libssh2_ed25519_free(ctx) EVP_PKEY_free(ctx)
-#endif /* ED25519 */
-
-#define _libssh2_cipher_type(name) const EVP_CIPHER *(*name)(void)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define _libssh2_cipher_ctx EVP_CIPHER_CTX *
-#else
-#define _libssh2_cipher_ctx EVP_CIPHER_CTX
-#endif
-
-#define _libssh2_cipher_aes256 EVP_aes_256_cbc
-#define _libssh2_cipher_aes192 EVP_aes_192_cbc
-#define _libssh2_cipher_aes128 EVP_aes_128_cbc
-#ifdef HAVE_EVP_AES_128_CTR
-#define _libssh2_cipher_aes128ctr EVP_aes_128_ctr
-#define _libssh2_cipher_aes192ctr EVP_aes_192_ctr
-#define _libssh2_cipher_aes256ctr EVP_aes_256_ctr
-#else
-#define _libssh2_cipher_aes128ctr _libssh2_EVP_aes_128_ctr
-#define _libssh2_cipher_aes192ctr _libssh2_EVP_aes_192_ctr
-#define _libssh2_cipher_aes256ctr _libssh2_EVP_aes_256_ctr
-#endif
-#define _libssh2_cipher_blowfish EVP_bf_cbc
-#define _libssh2_cipher_arcfour EVP_rc4
-#define _libssh2_cipher_cast5 EVP_cast5_cbc
-#define _libssh2_cipher_3des EVP_des_ede3_cbc
-
-#ifdef HAVE_OPAQUE_STRUCTS
-#define _libssh2_cipher_dtor(ctx) EVP_CIPHER_CTX_free(*(ctx))
-#else
-#define _libssh2_cipher_dtor(ctx) EVP_CIPHER_CTX_cleanup(ctx)
-#endif
-
-#define _libssh2_bn BIGNUM
-#define _libssh2_bn_ctx BN_CTX
-#define _libssh2_bn_ctx_new() BN_CTX_new()
-#define _libssh2_bn_ctx_free(bnctx) BN_CTX_free(bnctx)
-#define _libssh2_bn_init() BN_new()
-#define _libssh2_bn_init_from_bin() _libssh2_bn_init()
-#define _libssh2_bn_set_word(bn, val) BN_set_word(bn, val)
-#define _libssh2_bn_from_bin(bn, len, val) BN_bin2bn(val, len, bn)
-#define _libssh2_bn_to_bin(bn, val) BN_bn2bin(bn, val)
-#define _libssh2_bn_bytes(bn) BN_num_bytes(bn)
-#define _libssh2_bn_bits(bn) BN_num_bits(bn)
-#define _libssh2_bn_free(bn) BN_clear_free(bn)
-
-#define _libssh2_dh_ctx BIGNUM *
-#define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
-#define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx)
-#define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p, bnctx)
-#define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
-extern void _libssh2_dh_init(_libssh2_dh_ctx *dhctx);
-extern int _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                                _libssh2_bn *g, _libssh2_bn *p,
-                                int group_order,
-                                _libssh2_bn_ctx *bnctx);
-extern int _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                              _libssh2_bn *f, _libssh2_bn *p,
-                              _libssh2_bn_ctx *bnctx);
-extern void _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
-
-const EVP_CIPHER *_libssh2_EVP_aes_128_ctr(void);
-const EVP_CIPHER *_libssh2_EVP_aes_192_ctr(void);
-const EVP_CIPHER *_libssh2_EVP_aes_256_ctr(void);
-
-#endif /* __LIBSSH2_OPENSSL_H */
diff --git a/libssh2/libssh2/src/packet.c b/libssh2/libssh2/src/packet.c
deleted file mode 100644
index 04937d62..00000000
--- a/libssh2/libssh2/src/packet.c
+++ /dev/null
@@ -1,1338 +0,0 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005,2006 Mikhail Gusarov
- * Copyright (c) 2009-2014 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include <errno.h>
-#include <fcntl.h>
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-
-/* Needed for struct iovec on some platforms */
-#ifdef HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif
-
-#include <sys/types.h>
-
-#include "transport.h"
-#include "channel.h"
-#include "packet.h"
-
-/*
- * libssh2_packet_queue_listener
- *
- * Queue a connection request for a listener
- */
-static inline int
-packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
-                      unsigned long datalen,
-                      packet_queue_listener_state_t *listen_state)
-{
-    /*
-     * Look for a matching listener
-     */
-    /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
-    unsigned long packet_len = 17 + (sizeof(FwdNotReq) - 1);
-    unsigned char *p;
-    LIBSSH2_LISTENER *listn = _libssh2_list_first(&session->listeners);
-    char failure_code = SSH_OPEN_ADMINISTRATIVELY_PROHIBITED;
-    int rc;
-
-    if(listen_state->state == libssh2_NB_state_idle) {
-        unsigned long offset = (sizeof("forwarded-tcpip") - 1) + 5;
-        size_t temp_len = 0;
-        struct string_buf buf;
-        buf.data = data;
-        buf.dataptr = buf.data;
-        buf.len = datalen;
-
-        if(datalen < offset) {
-            return _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
-                                  "Unexpected packet size");
-        }
-
-        buf.dataptr += offset;
-
-        if(_libssh2_get_u32(&buf, &(listen_state->sender_channel))) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting channel");
-        }
-        if(_libssh2_get_u32(&buf, &(listen_state->initial_window_size))) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting window size");
-        }
-        if(_libssh2_get_u32(&buf, &(listen_state->packet_size))) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting packet");
-        }
-        if(_libssh2_get_string(&buf, &(listen_state->host), &temp_len)) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting host");
-        }
-        listen_state->host_len = (uint32_t)temp_len;
-
-        if(_libssh2_get_u32(&buf, &(listen_state->port))) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting port");
-        }
-        if(_libssh2_get_string(&buf, &(listen_state->shost), &temp_len)) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting shost");
-        }
-        listen_state->shost_len = (uint32_t)temp_len;
-
-        if(_libssh2_get_u32(&buf, &(listen_state->sport))) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Data too short extracting sport");
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Remote received connection from %s:%ld to %s:%ld",
-                       listen_state->shost, listen_state->sport,
-                       listen_state->host, listen_state->port);
-
-        listen_state->state = libssh2_NB_state_allocated;
-    }
-
-    if(listen_state->state != libssh2_NB_state_sent) {
-        while(listn) {
-            if((listn->port == (int) listen_state->port) &&
-                (strlen(listn->host) == listen_state->host_len) &&
-                (memcmp (listn->host, listen_state->host,
-                         listen_state->host_len) == 0)) {
-                /* This is our listener */
-                LIBSSH2_CHANNEL *channel = NULL;
-                listen_state->channel = NULL;
-
-                if(listen_state->state == libssh2_NB_state_allocated) {
-                    if(listn->queue_maxsize &&
-                        (listn->queue_maxsize <= listn->queue_size)) {
-                        /* Queue is full */
-                        failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                       "Listener queue full, ignoring");
-                        listen_state->state = libssh2_NB_state_sent;
-                        break;
-                    }
-
-                    channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-                    if(!channel) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate a channel for "
-                                       "new connection");
-                        failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                        listen_state->state = libssh2_NB_state_sent;
-                        break;
-                    }
-                    listen_state->channel = channel;
-
-                    channel->session = session;
-                    channel->channel_type_len = sizeof("forwarded-tcpip") - 1;
-                    channel->channel_type = LIBSSH2_ALLOC(session,
-                                                          channel->
-                                                          channel_type_len +
-                                                          1);
-                    if(!channel->channel_type) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate a channel for new"
-                                       " connection");
-                        LIBSSH2_FREE(session, channel);
-                        failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                        listen_state->state = libssh2_NB_state_sent;
-                        break;
-                    }
-                    memcpy(channel->channel_type, "forwarded-tcpip",
-                           channel->channel_type_len + 1);
-
-                    channel->remote.id = listen_state->sender_channel;
-                    channel->remote.window_size_initial =
-                        LIBSSH2_CHANNEL_WINDOW_DEFAULT;
-                    channel->remote.window_size =
-                        LIBSSH2_CHANNEL_WINDOW_DEFAULT;
-                    channel->remote.packet_size =
-                        LIBSSH2_CHANNEL_PACKET_DEFAULT;
-
-                    channel->local.id = _libssh2_channel_nextid(session);
-                    channel->local.window_size_initial =
-                        listen_state->initial_window_size;
-                    channel->local.window_size =
-                        listen_state->initial_window_size;
-                    channel->local.packet_size = listen_state->packet_size;
-
-                    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                   "Connection queued: channel %lu/%lu "
-                                   "win %lu/%lu packet %lu/%lu",
-                                   channel->local.id, channel->remote.id,
-                                   channel->local.window_size,
-                                   channel->remote.window_size,
-                                   channel->local.packet_size,
-                                   channel->remote.packet_size);
-
-                    p = listen_state->packet;
-                    *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
-                    _libssh2_store_u32(&p, channel->remote.id);
-                    _libssh2_store_u32(&p, channel->local.id);
-                    _libssh2_store_u32(&p,
-                                       channel->remote.window_size_initial);
-                    _libssh2_store_u32(&p, channel->remote.packet_size);
-
-                    listen_state->state = libssh2_NB_state_created;
-                }
-
-                if(listen_state->state == libssh2_NB_state_created) {
-                    rc = _libssh2_transport_send(session, listen_state->packet,
-                                                 17, NULL, 0);
-                    if(rc == LIBSSH2_ERROR_EAGAIN)
-                        return rc;
-                    else if(rc) {
-                        listen_state->state = libssh2_NB_state_idle;
-                        return _libssh2_error(session, rc,
-                                              "Unable to send channel "
-                                              "open confirmation");
-                    }
-
-                    /* Link the channel into the end of the queue list */
-                    if(listen_state->channel) {
-                        _libssh2_list_add(&listn->queue,
-                                          &listen_state->channel->node);
-                        listn->queue_size++;
-                    }
-
-                    listen_state->state = libssh2_NB_state_idle;
-                    return 0;
-                }
-            }
-
-            listn = _libssh2_list_next(&listn->node);
-        }
-
-        listen_state->state = libssh2_NB_state_sent;
-    }
-
-    /* We're not listening to you */
-    p = listen_state->packet;
-    *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
-    _libssh2_store_u32(&p, listen_state->sender_channel);
-    _libssh2_store_u32(&p, failure_code);
-    _libssh2_store_str(&p, FwdNotReq, sizeof(FwdNotReq) - 1);
-    _libssh2_htonu32(p, 0);
-
-    rc = _libssh2_transport_send(session, listen_state->packet,
-                                 packet_len, NULL, 0);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc) {
-        listen_state->state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc, "Unable to send open failure");
-
-    }
-    listen_state->state = libssh2_NB_state_idle;
-    return 0;
-}
-
-/*
- * packet_x11_open
- *
- * Accept a forwarded X11 connection
- */
-static inline int
-packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
-                unsigned long datalen,
-                packet_x11_open_state_t *x11open_state)
-{
-    int failure_code = SSH_OPEN_CONNECT_FAILED;
-    /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
-    unsigned long packet_len = 17 + (sizeof(X11FwdUnAvil) - 1);
-    unsigned char *p;
-    LIBSSH2_CHANNEL *channel = x11open_state->channel;
-    int rc;
-
-    if(x11open_state->state == libssh2_NB_state_idle) {
-
-        unsigned long offset = (sizeof("x11") - 1) + 5;
-        size_t temp_len = 0;
-        struct string_buf buf;
-        buf.data = data;
-        buf.dataptr = buf.data;
-        buf.len = datalen;
-
-        if(datalen < offset) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected data length");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-
-        buf.dataptr += offset;
-
-        if(_libssh2_get_u32(&buf, &(x11open_state->sender_channel))) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected sender channel size");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-        if(_libssh2_get_u32(&buf, &(x11open_state->initial_window_size))) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected window size");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-        if(_libssh2_get_u32(&buf, &(x11open_state->packet_size))) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected window size");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-        if(_libssh2_get_string(&buf, &(x11open_state->shost), &temp_len)) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected host size");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-        x11open_state->shost_len = (uint32_t)temp_len;
-
-        if(_libssh2_get_u32(&buf, &(x11open_state->sport))) {
-            _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                           "unexpected port size");
-            failure_code = SSH_OPEN_CONNECT_FAILED;
-            goto x11_exit;
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "X11 Connection Received from %s:%ld on channel %lu",
-                       x11open_state->shost, x11open_state->sport,
-                       x11open_state->sender_channel);
-
-        x11open_state->state = libssh2_NB_state_allocated;
-    }
-
-    if(session->x11) {
-        if(x11open_state->state == libssh2_NB_state_allocated) {
-            channel = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
-            if(!channel) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "allocate a channel for new connection");
-                failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                goto x11_exit;
-            }
-
-            channel->session = session;
-            channel->channel_type_len = sizeof("x11") - 1;
-            channel->channel_type = LIBSSH2_ALLOC(session,
-                                                  channel->channel_type_len +
-                                                  1);
-            if(!channel->channel_type) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "allocate a channel for new connection");
-                LIBSSH2_FREE(session, channel);
-                failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                goto x11_exit;
-            }
-            memcpy(channel->channel_type, "x11",
-                   channel->channel_type_len + 1);
-
-            channel->remote.id = x11open_state->sender_channel;
-            channel->remote.window_size_initial =
-                LIBSSH2_CHANNEL_WINDOW_DEFAULT;
-            channel->remote.window_size = LIBSSH2_CHANNEL_WINDOW_DEFAULT;
-            channel->remote.packet_size = LIBSSH2_CHANNEL_PACKET_DEFAULT;
-
-            channel->local.id = _libssh2_channel_nextid(session);
-            channel->local.window_size_initial =
-                x11open_state->initial_window_size;
-            channel->local.window_size = x11open_state->initial_window_size;
-            channel->local.packet_size = x11open_state->packet_size;
-
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "X11 Connection established: channel %lu/%lu "
-                           "win %lu/%lu packet %lu/%lu",
-                           channel->local.id, channel->remote.id,
-                           channel->local.window_size,
-                           channel->remote.window_size,
-                           channel->local.packet_size,
-                           channel->remote.packet_size);
-            p = x11open_state->packet;
-            *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
-            _libssh2_store_u32(&p, channel->remote.id);
-            _libssh2_store_u32(&p, channel->local.id);
-            _libssh2_store_u32(&p, channel->remote.window_size_initial);
-            _libssh2_store_u32(&p, channel->remote.packet_size);
-
-            x11open_state->state = libssh2_NB_state_created;
-        }
-
-        if(x11open_state->state == libssh2_NB_state_created) {
-            rc = _libssh2_transport_send(session, x11open_state->packet, 17,
-                                         NULL, 0);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                return rc;
-            }
-            else if(rc) {
-                x11open_state->state = libssh2_NB_state_idle;
-                return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                      "Unable to send channel open "
-                                      "confirmation");
-            }
-
-            /* Link the channel into the session */
-            _libssh2_list_add(&session->channels, &channel->node);
-
-            /*
-             * Pass control to the callback, they may turn right around and
-             * free the channel, or actually use it
-             */
-            LIBSSH2_X11_OPEN(channel, (char *)x11open_state->shost,
-                             x11open_state->sport);
-
-            x11open_state->state = libssh2_NB_state_idle;
-            return 0;
-        }
-    }
-    else
-        failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-    /* fall-trough */
-  x11_exit:
-    p = x11open_state->packet;
-    *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
-    _libssh2_store_u32(&p, x11open_state->sender_channel);
-    _libssh2_store_u32(&p, failure_code);
-    _libssh2_store_str(&p, X11FwdUnAvil, sizeof(X11FwdUnAvil) - 1);
-    _libssh2_htonu32(p, 0);
-
-    rc = _libssh2_transport_send(session, x11open_state->packet, packet_len,
-                                 NULL, 0);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc) {
-        x11open_state->state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc, "Unable to send open failure");
-    }
-    x11open_state->state = libssh2_NB_state_idle;
-    return 0;
-}
-
-/*
- * _libssh2_packet_add
- *
- * Create a new packet and attach it to the brigade. Called from the transport
- * layer when it has received a packet.
- *
- * The input pointer 'data' is pointing to allocated data that this function
- * is asked to deal with so on failure OR success, it must be freed fine.
- * The only exception is when the return code is LIBSSH2_ERROR_EAGAIN.
- *
- * This function will always be called with 'datalen' greater than zero.
- */
-int
-_libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
-                    size_t datalen, int macstate)
-{
-    int rc = 0;
-    unsigned char *message = NULL;
-    unsigned char *language = NULL;
-    size_t message_len = 0;
-    size_t language_len = 0;
-    LIBSSH2_CHANNEL *channelp = NULL;
-    size_t data_head = 0;
-    unsigned char msg = data[0];
-
-    switch(session->packAdd_state) {
-    case libssh2_NB_state_idle:
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Packet type %d received, length=%d",
-                       (int) msg, (int) datalen);
-
-        if((macstate == LIBSSH2_MAC_INVALID) &&
-            (!session->macerror ||
-             LIBSSH2_MACERROR(session, (char *) data, datalen))) {
-            /* Bad MAC input, but no callback set or non-zero return from the
-               callback */
-
-            LIBSSH2_FREE(session, data);
-            return _libssh2_error(session, LIBSSH2_ERROR_INVALID_MAC,
-                                  "Invalid MAC received");
-        }
-        session->packAdd_state = libssh2_NB_state_allocated;
-        break;
-    case libssh2_NB_state_jump1:
-        goto libssh2_packet_add_jump_point1;
-    case libssh2_NB_state_jump2:
-        goto libssh2_packet_add_jump_point2;
-    case libssh2_NB_state_jump3:
-        goto libssh2_packet_add_jump_point3;
-    case libssh2_NB_state_jump4:
-        goto libssh2_packet_add_jump_point4;
-    case libssh2_NB_state_jump5:
-        goto libssh2_packet_add_jump_point5;
-    default: /* nothing to do */
-        break;
-    }
-
-    if(session->packAdd_state == libssh2_NB_state_allocated) {
-        /* A couple exceptions to the packet adding rule: */
-        switch(msg) {
-
-            /*
-              byte      SSH_MSG_DISCONNECT
-              uint32    reason code
-              string    description in ISO-10646 UTF-8 encoding [RFC3629]
-              string    language tag [RFC3066]
-            */
-
-        case SSH_MSG_DISCONNECT:
-            if(datalen >= 5) {
-                uint32_t reason = 0;
-                struct string_buf buf;
-                buf.data = (unsigned char *)data;
-                buf.dataptr = buf.data;
-                buf.len = datalen;
-                buf.dataptr++; /* advance past type */
-
-                _libssh2_get_u32(&buf, &reason);
-                _libssh2_get_string(&buf, &message, &message_len);
-                _libssh2_get_string(&buf, &language, &language_len);
-
-                if(session->ssh_msg_disconnect) {
-                    LIBSSH2_DISCONNECT(session, reason, (const char *)message,
-                                       message_len, (const char *)language,
-                                       language_len);
-                }
-
-                _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                               "Disconnect(%d): %s(%s)", reason,
-                               message, language);
-            }
-
-            LIBSSH2_FREE(session, data);
-            session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
-            session->packAdd_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
-                                  "socket disconnect");
-            /*
-              byte      SSH_MSG_IGNORE
-              string    data
-            */
-
-        case SSH_MSG_IGNORE:
-            if(datalen >= 2) {
-                if(session->ssh_msg_ignore) {
-                    LIBSSH2_IGNORE(session, (char *) data + 1, datalen - 1);
-                }
-            }
-            else if(session->ssh_msg_ignore) {
-                LIBSSH2_IGNORE(session, "", 0);
-            }
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-
-            /*
-              byte      SSH_MSG_DEBUG
-              boolean   always_display
-              string    message in ISO-10646 UTF-8 encoding [RFC3629]
-              string    language tag [RFC3066]
-            */
-
-        case SSH_MSG_DEBUG:
-            if(datalen >= 2) {
-                int always_display = data[1];
-
-                if(datalen >= 6) {
-                    struct string_buf buf;
-                    buf.data = (unsigned char *)data;
-                    buf.dataptr = buf.data;
-                    buf.len = datalen;
-                    buf.dataptr += 2; /* advance past type & always display */
-
-                    _libssh2_get_string(&buf, &message, &message_len);
-                    _libssh2_get_string(&buf, &language, &language_len);
-                }
-
-                if(session->ssh_msg_debug) {
-                    LIBSSH2_DEBUG(session, always_display,
-                                  (const char *)message,
-                                  message_len, (const char *)language,
-                                  language_len);
-                }
-            }
-
-            /*
-             * _libssh2_debug will actually truncate this for us so
-             * that it's not an inordinate about of data
-             */
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                           "Debug Packet: %s", message);
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-
-            /*
-              byte      SSH_MSG_GLOBAL_REQUEST
-              string    request name in US-ASCII only
-              boolean   want reply
-              ....      request-specific data follows
-            */
-
-        case SSH_MSG_GLOBAL_REQUEST:
-            if(datalen >= 5) {
-                uint32_t len = 0;
-                unsigned char want_reply = 0;
-                len = _libssh2_ntohu32(data + 1);
-                if((len <= (UINT_MAX - 6)) && (datalen >= (6 + len))) {
-                    want_reply = data[5 + len];
-                    _libssh2_debug(session,
-                                   LIBSSH2_TRACE_CONN,
-                                   "Received global request type %.*s (wr %X)",
-                                   len, data + 5, want_reply);
-                }
-
-
-                if(want_reply) {
-                    static const unsigned char packet =
-                        SSH_MSG_REQUEST_FAILURE;
-                  libssh2_packet_add_jump_point5:
-                    session->packAdd_state = libssh2_NB_state_jump5;
-                    rc = _libssh2_transport_send(session, &packet, 1, NULL, 0);
-                    if(rc == LIBSSH2_ERROR_EAGAIN)
-                        return rc;
-                }
-            }
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-
-            /*
-              byte      SSH_MSG_CHANNEL_EXTENDED_DATA
-              uint32    recipient channel
-              uint32    data_type_code
-              string    data
-            */
-
-        case SSH_MSG_CHANNEL_EXTENDED_DATA:
-            /* streamid(4) */
-            data_head += 4;
-
-            /* fall-through */
-
-            /*
-              byte      SSH_MSG_CHANNEL_DATA
-              uint32    recipient channel
-              string    data
-            */
-
-        case SSH_MSG_CHANNEL_DATA:
-            /* packet_type(1) + channelno(4) + datalen(4) */
-            data_head += 9;
-
-            if(datalen >= data_head)
-                channelp =
-                    _libssh2_channel_locate(session,
-                                            _libssh2_ntohu32(data + 1));
-
-            if(!channelp) {
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN,
-                               "Packet received for unknown channel");
-                LIBSSH2_FREE(session, data);
-                session->packAdd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-#ifdef LIBSSH2DEBUG
-            {
-                uint32_t stream_id = 0;
-                if(msg == SSH_MSG_CHANNEL_EXTENDED_DATA)
-                    stream_id = _libssh2_ntohu32(data + 5);
-
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "%d bytes packet_add() for %lu/%lu/%lu",
-                               (int) (datalen - data_head),
-                               channelp->local.id,
-                               channelp->remote.id,
-                               stream_id);
-            }
-#endif
-            if((channelp->remote.extended_data_ignore_mode ==
-                 LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) &&
-                (msg == SSH_MSG_CHANNEL_EXTENDED_DATA)) {
-                /* Pretend we didn't receive this */
-                LIBSSH2_FREE(session, data);
-
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "Ignoring extended data and refunding %d bytes",
-                               (int) (datalen - 13));
-                if(channelp->read_avail + datalen - data_head >=
-                    channelp->remote.window_size)
-                    datalen = channelp->remote.window_size -
-                        channelp->read_avail + data_head;
-
-                channelp->remote.window_size -= datalen - data_head;
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "shrinking window size by %lu bytes to %lu, "
-                               "read_avail %lu",
-                               datalen - data_head,
-                               channelp->remote.window_size,
-                               channelp->read_avail);
-
-                session->packAdd_channelp = channelp;
-
-                /* Adjust the window based on the block we just freed */
-              libssh2_packet_add_jump_point1:
-                session->packAdd_state = libssh2_NB_state_jump1;
-                rc = _libssh2_channel_receive_window_adjust(session->
-                                                            packAdd_channelp,
-                                                            datalen - 13,
-                                                            1, NULL);
-                if(rc == LIBSSH2_ERROR_EAGAIN)
-                    return rc;
-
-                session->packAdd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-
-            /*
-             * REMEMBER! remote means remote as source of data,
-             * NOT remote window!
-             */
-            if(channelp->remote.packet_size < (datalen - data_head)) {
-                /*
-                 * Spec says we MAY ignore bytes sent beyond
-                 * packet_size
-                 */
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
-                               "Packet contains more data than we offered"
-                               " to receive, truncating");
-                datalen = channelp->remote.packet_size + data_head;
-            }
-            if(channelp->remote.window_size <= channelp->read_avail) {
-                /*
-                 * Spec says we MAY ignore bytes sent beyond
-                 * window_size
-                 */
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
-                               "The current receive window is full,"
-                               " data ignored");
-                LIBSSH2_FREE(session, data);
-                session->packAdd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-            /* Reset EOF status */
-            channelp->remote.eof = 0;
-
-            if(channelp->read_avail + datalen - data_head >
-                channelp->remote.window_size) {
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
-                               "Remote sent more data than current "
-                               "window allows, truncating");
-                datalen = channelp->remote.window_size -
-                    channelp->read_avail + data_head;
-            }
-
-            /* Update the read_avail counter. The window size will be
-             * updated once the data is actually read from the queue
-             * from an upper layer */
-            channelp->read_avail += datalen - data_head;
-
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "increasing read_avail by %lu bytes to %lu/%lu",
-                           (long)(datalen - data_head),
-                           (long)channelp->read_avail,
-                           (long)channelp->remote.window_size);
-
-            break;
-
-            /*
-              byte      SSH_MSG_CHANNEL_EOF
-              uint32    recipient channel
-            */
-
-        case SSH_MSG_CHANNEL_EOF:
-            if(datalen >= 5)
-                channelp =
-                    _libssh2_channel_locate(session,
-                                            _libssh2_ntohu32(data + 1));
-            if(!channelp)
-                /* We may have freed already, just quietly ignore this... */
-                ;
-            else {
-                _libssh2_debug(session,
-                               LIBSSH2_TRACE_CONN,
-                               "EOF received for channel %lu/%lu",
-                               channelp->local.id,
-                               channelp->remote.id);
-                channelp->remote.eof = 1;
-            }
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-
-            /*
-              byte      SSH_MSG_CHANNEL_REQUEST
-              uint32    recipient channel
-              string    request type in US-ASCII characters only
-              boolean   want reply
-              ....      type-specific data follows
-            */
-
-        case SSH_MSG_CHANNEL_REQUEST:
-            if(datalen >= 9) {
-                uint32_t channel = _libssh2_ntohu32(data + 1);
-                uint32_t len = _libssh2_ntohu32(data + 5);
-                unsigned char want_reply = 1;
-
-                if((len + 9) < datalen)
-                    want_reply = data[len + 9];
-
-                _libssh2_debug(session,
-                               LIBSSH2_TRACE_CONN,
-                               "Channel %d received request type %.*s (wr %X)",
-                               channel, len, data + 9, want_reply);
-
-                if(len == sizeof("exit-status") - 1
-                    && (sizeof("exit-status") - 1 + 9) <= datalen
-                    && !memcmp("exit-status", data + 9,
-                               sizeof("exit-status") - 1)) {
-
-                    /* we've got "exit-status" packet. Set the session value */
-                    if(datalen >= 20)
-                        channelp =
-                            _libssh2_channel_locate(session, channel);
-
-                    if(channelp && (sizeof("exit-status") + 13) <= datalen) {
-                        channelp->exit_status =
-                            _libssh2_ntohu32(data + 9 + sizeof("exit-status"));
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                       "Exit status %lu received for "
-                                       "channel %lu/%lu",
-                                       channelp->exit_status,
-                                       channelp->local.id,
-                                       channelp->remote.id);
-                    }
-
-                }
-                else if(len == sizeof("exit-signal") - 1
-                         && (sizeof("exit-signal") - 1 + 9) <= datalen
-                         && !memcmp("exit-signal", data + 9,
-                                    sizeof("exit-signal") - 1)) {
-                    /* command terminated due to signal */
-                    if(datalen >= 20)
-                        channelp = _libssh2_channel_locate(session, channel);
-
-                    if(channelp && (sizeof("exit-signal") + 13) <= datalen) {
-                        /* set signal name (without SIG prefix) */
-                        uint32_t namelen =
-                            _libssh2_ntohu32(data + 9 + sizeof("exit-signal"));
-
-                        if(namelen <= UINT_MAX - 1) {
-                            channelp->exit_signal =
-                                LIBSSH2_ALLOC(session, namelen + 1);
-                        }
-                        else {
-                            channelp->exit_signal = NULL;
-                        }
-
-                        if(!channelp->exit_signal)
-                            rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                                "memory for signal name");
-                        else if((sizeof("exit-signal") + 13 + namelen <=
-                                 datalen)) {
-                            memcpy(channelp->exit_signal,
-                                   data + 13 + sizeof("exit-signal"), namelen);
-                            channelp->exit_signal[namelen] = '\0';
-                            /* TODO: save error message and language tag */
-                            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                           "Exit signal %s received for "
-                                           "channel %lu/%lu",
-                                           channelp->exit_signal,
-                                           channelp->local.id,
-                                           channelp->remote.id);
-                        }
-                    }
-                }
-
-
-                if(want_reply) {
-                    unsigned char packet[5];
-                  libssh2_packet_add_jump_point4:
-                    session->packAdd_state = libssh2_NB_state_jump4;
-                    packet[0] = SSH_MSG_CHANNEL_FAILURE;
-                    memcpy(&packet[1], data + 1, 4);
-                    rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
-                    if(rc == LIBSSH2_ERROR_EAGAIN)
-                        return rc;
-                }
-            }
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return rc;
-
-            /*
-              byte      SSH_MSG_CHANNEL_CLOSE
-              uint32    recipient channel
-            */
-
-        case SSH_MSG_CHANNEL_CLOSE:
-            if(datalen >= 5)
-                channelp =
-                    _libssh2_channel_locate(session,
-                                            _libssh2_ntohu32(data + 1));
-            if(!channelp) {
-                /* We may have freed already, just quietly ignore this... */
-                LIBSSH2_FREE(session, data);
-                session->packAdd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Close received for channel %lu/%lu",
-                           channelp->local.id,
-                           channelp->remote.id);
-
-            channelp->remote.close = 1;
-            channelp->remote.eof = 1;
-
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-
-            /*
-              byte      SSH_MSG_CHANNEL_OPEN
-              string    "session"
-              uint32    sender channel
-              uint32    initial window size
-              uint32    maximum packet size
-            */
-
-        case SSH_MSG_CHANNEL_OPEN:
-            if(datalen < 17)
-                ;
-            else if((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
-                     ((sizeof("forwarded-tcpip") - 1) ==
-                      _libssh2_ntohu32(data + 1))
-                     &&
-                     (memcmp(data + 5, "forwarded-tcpip",
-                             sizeof("forwarded-tcpip") - 1) == 0)) {
-
-                /* init the state struct */
-                memset(&session->packAdd_Qlstn_state, 0,
-                       sizeof(session->packAdd_Qlstn_state));
-
-              libssh2_packet_add_jump_point2:
-                session->packAdd_state = libssh2_NB_state_jump2;
-                rc = packet_queue_listener(session, data, datalen,
-                                           &session->packAdd_Qlstn_state);
-            }
-            else if((datalen >= (sizeof("x11") + 4)) &&
-                     ((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) &&
-                     (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) {
-
-                /* init the state struct */
-                memset(&session->packAdd_x11open_state, 0,
-                       sizeof(session->packAdd_x11open_state));
-
-              libssh2_packet_add_jump_point3:
-                session->packAdd_state = libssh2_NB_state_jump3;
-                rc = packet_x11_open(session, data, datalen,
-                                     &session->packAdd_x11open_state);
-            }
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
-
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return rc;
-
-            /*
-              byte      SSH_MSG_CHANNEL_WINDOW_ADJUST
-              uint32    recipient channel
-              uint32    bytes to add
-            */
-        case SSH_MSG_CHANNEL_WINDOW_ADJUST:
-            if(datalen < 9)
-                ;
-            else {
-                uint32_t bytestoadd = _libssh2_ntohu32(data + 5);
-                channelp =
-                    _libssh2_channel_locate(session,
-                                            _libssh2_ntohu32(data + 1));
-                if(channelp) {
-                    channelp->local.window_size += bytestoadd;
-
-                    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                   "Window adjust for channel %lu/%lu, "
-                                   "adding %lu bytes, new window_size=%lu",
-                                   channelp->local.id,
-                                   channelp->remote.id,
-                                   bytestoadd,
-                                   channelp->local.window_size);
-                }
-            }
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return 0;
-        default:
-            break;
-        }
-
-        session->packAdd_state = libssh2_NB_state_sent;
-    }
-
-    if(session->packAdd_state == libssh2_NB_state_sent) {
-        LIBSSH2_PACKET *packetp =
-            LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
-        if(!packetp) {
-            _libssh2_debug(session, LIBSSH2_ERROR_ALLOC,
-                           "memory for packet");
-            LIBSSH2_FREE(session, data);
-            session->packAdd_state = libssh2_NB_state_idle;
-            return LIBSSH2_ERROR_ALLOC;
-        }
-        packetp->data = data;
-        packetp->data_len = datalen;
-        packetp->data_head = data_head;
-
-        _libssh2_list_add(&session->packets, &packetp->node);
-
-        session->packAdd_state = libssh2_NB_state_sent1;
-    }
-
-    if((msg == SSH_MSG_KEXINIT &&
-         !(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) ||
-        (session->packAdd_state == libssh2_NB_state_sent2)) {
-        if(session->packAdd_state == libssh2_NB_state_sent1) {
-            /*
-             * Remote wants new keys
-             * Well, it's already in the brigade,
-             * let's just call back into ourselves
-             */
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Renegotiating Keys");
-
-            session->packAdd_state = libssh2_NB_state_sent2;
-        }
-
-        /*
-         * The KEXINIT message has been added to the queue.  The packAdd and
-         * readPack states need to be reset because _libssh2_kex_exchange
-         * (eventually) calls upon _libssh2_transport_read to read the rest of
-         * the key exchange conversation.
-         */
-        session->readPack_state = libssh2_NB_state_idle;
-        session->packet.total_num = 0;
-        session->packAdd_state = libssh2_NB_state_idle;
-        session->fullpacket_state = libssh2_NB_state_idle;
-
-        memset(&session->startup_key_state, 0, sizeof(key_exchange_state_t));
-
-        /*
-         * If there was a key reexchange failure, let's just hope we didn't
-         * send NEWKEYS yet, otherwise remote will drop us like a rock
-         */
-        rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-    }
-
-    session->packAdd_state = libssh2_NB_state_idle;
-    return 0;
-}
-
-/*
- * _libssh2_packet_ask
- *
- * Scan the brigade for a matching packet type, optionally poll the socket for
- * a packet first
- */
-int
-_libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
-                    unsigned char **data, size_t *data_len,
-                    int match_ofs, const unsigned char *match_buf,
-                    size_t match_len)
-{
-    LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets);
-
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                   "Looking for packet of type: %d", (int) packet_type);
-
-    while(packet) {
-        if(packet->data[0] == packet_type
-            && (packet->data_len >= (match_ofs + match_len))
-            && (!match_buf ||
-                (memcmp(packet->data + match_ofs, match_buf,
-                        match_len) == 0))) {
-            *data = packet->data;
-            *data_len = packet->data_len;
-
-            /* unlink struct from session->packets */
-            _libssh2_list_remove(&packet->node);
-
-            LIBSSH2_FREE(session, packet);
-
-            return 0;
-        }
-        packet = _libssh2_list_next(&packet->node);
-    }
-    return -1;
-}
-
-/*
- * libssh2_packet_askv
- *
- * Scan for any of a list of packet types in the brigade, optionally poll the
- * socket for a packet first
- */
-int
-_libssh2_packet_askv(LIBSSH2_SESSION * session,
-                     const unsigned char *packet_types,
-                     unsigned char **data, size_t *data_len,
-                     int match_ofs,
-                     const unsigned char *match_buf,
-                     size_t match_len)
-{
-    int i, packet_types_len = strlen((char *) packet_types);
-
-    for(i = 0; i < packet_types_len; i++) {
-        if(0 == _libssh2_packet_ask(session, packet_types[i], data,
-                                     data_len, match_ofs,
-                                     match_buf, match_len)) {
-            return 0;
-        }
-    }
-
-    return -1;
-}
-
-/*
- * _libssh2_packet_require
- *
- * Loops _libssh2_transport_read() until the packet requested is available
- * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout
- *
- * Returns negative on error
- * Returns 0 when it has taken care of the requested packet.
- */
-int
-_libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
-                        unsigned char **data, size_t *data_len,
-                        int match_ofs,
-                        const unsigned char *match_buf,
-                        size_t match_len,
-                        packet_require_state_t *state)
-{
-    if(state->start == 0) {
-        if(_libssh2_packet_ask(session, packet_type, data, data_len,
-                                match_ofs, match_buf,
-                                match_len) == 0) {
-            /* A packet was available in the packet brigade */
-            return 0;
-        }
-
-        state->start = time(NULL);
-    }
-
-    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-        int ret = _libssh2_transport_read(session);
-        if(ret == LIBSSH2_ERROR_EAGAIN)
-            return ret;
-        else if(ret < 0) {
-            state->start = 0;
-            /* an error which is not just because of blocking */
-            return ret;
-        }
-        else if(ret == packet_type) {
-            /* Be lazy, let packet_ask pull it out of the brigade */
-            ret = _libssh2_packet_ask(session, packet_type, data, data_len,
-                                      match_ofs, match_buf, match_len);
-            state->start = 0;
-            return ret;
-        }
-        else if(ret == 0) {
-            /* nothing available, wait until data arrives or we time out */
-            long left = LIBSSH2_READ_TIMEOUT - (long)(time(NULL) -
-                                                      state->start);
-
-            if(left <= 0) {
-                state->start = 0;
-                return LIBSSH2_ERROR_TIMEOUT;
-            }
-            return -1; /* no packet available yet */
-        }
-    }
-
-    /* Only reached if the socket died */
-    return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-}
-
-/*
- * _libssh2_packet_burn
- *
- * Loops _libssh2_transport_read() until any packet is available and promptly
- * discards it.
- * Used during KEX exchange to discard badly guessed KEX_INIT packets
- */
-int
-_libssh2_packet_burn(LIBSSH2_SESSION * session,
-                     libssh2_nonblocking_states * state)
-{
-    unsigned char *data;
-    size_t data_len;
-    unsigned char i, all_packets[255];
-    int ret;
-
-    if(*state == libssh2_NB_state_idle) {
-        for(i = 1; i < 255; i++) {
-            all_packets[i - 1] = i;
-        }
-        all_packets[254] = 0;
-
-        if(_libssh2_packet_askv(session, all_packets, &data, &data_len, 0,
-                                 NULL, 0) == 0) {
-            i = data[0];
-            /* A packet was available in the packet brigade, burn it */
-            LIBSSH2_FREE(session, data);
-            return i;
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Blocking until packet becomes available to burn");
-        *state = libssh2_NB_state_created;
-    }
-
-    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-        ret = _libssh2_transport_read(session);
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            return ret;
-        }
-        else if(ret < 0) {
-            *state = libssh2_NB_state_idle;
-            return ret;
-        }
-        else if(ret == 0) {
-            /* FIXME: this might busyloop */
-            continue;
-        }
-
-        /* Be lazy, let packet_ask pull it out of the brigade */
-        if(0 ==
-            _libssh2_packet_ask(session, (unsigned char)ret,
-                                         &data, &data_len, 0, NULL, 0)) {
-            /* Smoke 'em if you got 'em */
-            LIBSSH2_FREE(session, data);
-            *state = libssh2_NB_state_idle;
-            return ret;
-        }
-    }
-
-    /* Only reached if the socket died */
-    return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-}
-
-/*
- * _libssh2_packet_requirev
- *
- * Loops _libssh2_transport_read() until one of a list of packet types
- * requested is available. SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause
- * a bailout. packet_types is a null terminated list of packet_type numbers
- */
-
-int
-_libssh2_packet_requirev(LIBSSH2_SESSION *session,
-                         const unsigned char *packet_types,
-                         unsigned char **data, size_t *data_len,
-                         int match_ofs,
-                         const unsigned char *match_buf, size_t match_len,
-                         packet_requirev_state_t * state)
-{
-    if(_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs,
-                             match_buf, match_len) == 0) {
-        /* One of the packets listed was available in the packet brigade */
-        state->start = 0;
-        return 0;
-    }
-
-    if(state->start == 0) {
-        state->start = time(NULL);
-    }
-
-    while(session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
-        int ret = _libssh2_transport_read(session);
-        if((ret < 0) && (ret != LIBSSH2_ERROR_EAGAIN)) {
-            state->start = 0;
-            return ret;
-        }
-        if(ret <= 0) {
-            long left = LIBSSH2_READ_TIMEOUT -
-                (long)(time(NULL) - state->start);
-
-            if(left <= 0) {
-                state->start = 0;
-                return LIBSSH2_ERROR_TIMEOUT;
-            }
-            else if(ret == LIBSSH2_ERROR_EAGAIN) {
-                return ret;
-            }
-        }
-
-        if(strchr((char *) packet_types, ret)) {
-            /* Be lazy, let packet_ask pull it out of the brigade */
-            int ret = _libssh2_packet_askv(session, packet_types, data,
-                                        data_len, match_ofs, match_buf,
-                                        match_len);
-            state->start = 0;
-            return ret;
-        }
-    }
-
-    /* Only reached if the socket died */
-    state->start = 0;
-    return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-}
-
diff --git a/libssh2/libssh2/src/packet.h b/libssh2/libssh2/src/packet.h
deleted file mode 100644
index 79018bcf..00000000
--- a/libssh2/libssh2/src/packet.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef __LIBSSH2_PACKET_H
-#define __LIBSSH2_PACKET_H
-/*
- * Copyright (C) 2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-int _libssh2_packet_read(LIBSSH2_SESSION * session);
-
-int _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
-                        unsigned char **data, size_t *data_len,
-                        int match_ofs,
-                        const unsigned char *match_buf,
-                        size_t match_len);
-
-int _libssh2_packet_askv(LIBSSH2_SESSION * session,
-                         const unsigned char *packet_types,
-                         unsigned char **data, size_t *data_len,
-                         int match_ofs,
-                         const unsigned char *match_buf,
-                         size_t match_len);
-int _libssh2_packet_require(LIBSSH2_SESSION * session,
-                            unsigned char packet_type, unsigned char **data,
-                            size_t *data_len, int match_ofs,
-                            const unsigned char *match_buf,
-                            size_t match_len,
-                            packet_require_state_t * state);
-int _libssh2_packet_requirev(LIBSSH2_SESSION *session,
-                             const unsigned char *packet_types,
-                             unsigned char **data, size_t *data_len,
-                             int match_ofs,
-                             const unsigned char *match_buf,
-                             size_t match_len,
-                             packet_requirev_state_t * state);
-int _libssh2_packet_burn(LIBSSH2_SESSION * session,
-                         libssh2_nonblocking_states * state);
-int _libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data,
-                          unsigned long data_len);
-int _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
-                        size_t datalen, int macstate);
-
-#endif /* __LIBSSH2_PACKET_H */
diff --git a/libssh2/libssh2/src/pem.c b/libssh2/libssh2/src/pem.c
deleted file mode 100644
index 3416bd52..00000000
--- a/libssh2/libssh2/src/pem.c
+++ /dev/null
@@ -1,911 +0,0 @@
-/* Copyright (C) 2007 The Written Word, Inc.
- * Copyright (C) 2008, Simon Josefsson
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-static int
-readline(char *line, int line_size, FILE * fp)
-{
-    size_t len;
-
-    if(!line) {
-        return -1;
-    }
-    if(!fgets(line, line_size, fp)) {
-        return -1;
-    }
-
-    if(*line) {
-        len = strlen(line);
-        if(len > 0 && line[len - 1] == '\n') {
-            line[len - 1] = '\0';
-        }
-    }
-
-    if(*line) {
-        len = strlen(line);
-        if(len > 0 && line[len - 1] == '\r') {
-            line[len - 1] = '\0';
-        }
-    }
-
-    return 0;
-}
-
-static int
-readline_memory(char *line, size_t line_size,
-                const char *filedata, size_t filedata_len,
-                size_t *filedata_offset)
-{
-    size_t off, len;
-
-    off = *filedata_offset;
-
-    for(len = 0; off + len < filedata_len && len < line_size - 1; len++) {
-        if(filedata[off + len] == '\n' ||
-            filedata[off + len] == '\r') {
-                break;
-        }
-    }
-
-    if(len) {
-        memcpy(line, filedata + off, len);
-        *filedata_offset += len;
-    }
-
-    line[len] = '\0';
-    *filedata_offset += 1;
-
-    return 0;
-}
-
-#define LINE_SIZE 128
-
-static const char *crypt_annotation = "Proc-Type: 4,ENCRYPTED";
-
-static unsigned char hex_decode(char digit)
-{
-    return (digit >= 'A') ? 0xA + (digit - 'A') : (digit - '0');
-}
-
-int
-_libssh2_pem_parse(LIBSSH2_SESSION * session,
-                   const char *headerbegin,
-                   const char *headerend,
-                   const unsigned char *passphrase,
-                   FILE * fp, unsigned char **data, unsigned int *datalen)
-{
-    char line[LINE_SIZE];
-    unsigned char iv[LINE_SIZE];
-    char *b64data = NULL;
-    unsigned int b64datalen = 0;
-    int ret;
-    const LIBSSH2_CRYPT_METHOD *method = NULL;
-
-    do {
-        *line = '\0';
-
-        if(readline(line, LINE_SIZE, fp)) {
-            return -1;
-        }
-    }
-    while(strcmp(line, headerbegin) != 0);
-
-    if(readline(line, LINE_SIZE, fp)) {
-        return -1;
-    }
-
-    if(passphrase &&
-            memcmp(line, crypt_annotation, strlen(crypt_annotation)) == 0) {
-        const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method;
-        int i;
-
-        if(readline(line, LINE_SIZE, fp)) {
-            ret = -1;
-            goto out;
-        }
-
-        all_methods = libssh2_crypt_methods();
-        while((cur_method = *all_methods++)) {
-            if(*cur_method->pem_annotation &&
-                    memcmp(line, cur_method->pem_annotation,
-                           strlen(cur_method->pem_annotation)) == 0) {
-                method = cur_method;
-                memcpy(iv, line + strlen(method->pem_annotation) + 1,
-                       2*method->iv_len);
-            }
-        }
-
-        /* None of the available crypt methods were able to decrypt the key */
-        if(method == NULL)
-            return -1;
-
-        /* Decode IV from hex */
-        for(i = 0; i < method->iv_len; ++i) {
-            iv[i]  = hex_decode(iv[2*i]) << 4;
-            iv[i] |= hex_decode(iv[2*i + 1]);
-        }
-
-        /* skip to the next line */
-        if(readline(line, LINE_SIZE, fp)) {
-            ret = -1;
-            goto out;
-        }
-    }
-
-    do {
-        if(*line) {
-            char *tmp;
-            size_t linelen;
-
-            linelen = strlen(line);
-            tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if(!tmp) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "Unable to allocate memory for PEM parsing");
-                ret = -1;
-                goto out;
-            }
-            memcpy(tmp + b64datalen, line, linelen);
-            b64data = tmp;
-            b64datalen += linelen;
-        }
-
-        *line = '\0';
-
-        if(readline(line, LINE_SIZE, fp)) {
-            ret = -1;
-            goto out;
-        }
-    } while(strcmp(line, headerend) != 0);
-
-    if(!b64data) {
-        return -1;
-    }
-
-    if(libssh2_base64_decode(session, (char **) data, datalen,
-                              b64data, b64datalen)) {
-        ret = -1;
-        goto out;
-    }
-
-    if(method) {
-        /* Set up decryption */
-        int free_iv = 0, free_secret = 0, len_decrypted = 0, padding = 0;
-        int blocksize = method->blocksize;
-        void *abstract;
-        unsigned char secret[2*MD5_DIGEST_LENGTH];
-        libssh2_md5_ctx fingerprint_ctx;
-
-        /* Perform key derivation (PBKDF1/MD5) */
-        if(!libssh2_md5_init(&fingerprint_ctx)) {
-            ret = -1;
-            goto out;
-        }
-        libssh2_md5_update(fingerprint_ctx, passphrase,
-                           strlen((char *)passphrase));
-        libssh2_md5_update(fingerprint_ctx, iv, 8);
-        libssh2_md5_final(fingerprint_ctx, secret);
-        if(method->secret_len > MD5_DIGEST_LENGTH) {
-            if(!libssh2_md5_init(&fingerprint_ctx)) {
-                ret = -1;
-                goto out;
-            }
-            libssh2_md5_update(fingerprint_ctx, secret, MD5_DIGEST_LENGTH);
-            libssh2_md5_update(fingerprint_ctx, passphrase,
-                               strlen((char *)passphrase));
-            libssh2_md5_update(fingerprint_ctx, iv, 8);
-            libssh2_md5_final(fingerprint_ctx, secret + MD5_DIGEST_LENGTH);
-        }
-
-        /* Initialize the decryption */
-        if(method->init(session, method, iv, &free_iv, secret,
-                         &free_secret, 0, &abstract)) {
-            _libssh2_explicit_zero((char *)secret, sizeof(secret));
-            LIBSSH2_FREE(session, data);
-            ret = -1;
-            goto out;
-        }
-
-        if(free_secret) {
-            _libssh2_explicit_zero((char *)secret, sizeof(secret));
-        }
-
-        /* Do the actual decryption */
-        if((*datalen % blocksize) != 0) {
-            _libssh2_explicit_zero((char *)secret, sizeof(secret));
-            method->dtor(session, &abstract);
-            _libssh2_explicit_zero(*data, *datalen);
-            LIBSSH2_FREE(session, *data);
-            ret = -1;
-            goto out;
-        }
-
-        while(len_decrypted <= (int)*datalen - blocksize) {
-            if(method->crypt(session, *data + len_decrypted, blocksize,
-                              &abstract)) {
-                ret = LIBSSH2_ERROR_DECRYPT;
-                _libssh2_explicit_zero((char *)secret, sizeof(secret));
-                method->dtor(session, &abstract);
-                _libssh2_explicit_zero(*data, *datalen);
-                LIBSSH2_FREE(session, *data);
-                goto out;
-            }
-
-            len_decrypted += blocksize;
-        }
-
-        /* Account for padding */
-        padding = (*data)[*datalen - 1];
-        memset(&(*data)[*datalen-padding], 0, padding);
-        *datalen -= padding;
-
-        /* Clean up */
-        _libssh2_explicit_zero((char *)secret, sizeof(secret));
-        method->dtor(session, &abstract);
-    }
-
-    ret = 0;
-  out:
-    if(b64data) {
-        _libssh2_explicit_zero(b64data, b64datalen);
-        LIBSSH2_FREE(session, b64data);
-    }
-    return ret;
-}
-
-int
-_libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
-                          const char *headerbegin,
-                          const char *headerend,
-                          const char *filedata, size_t filedata_len,
-                          unsigned char **data, unsigned int *datalen)
-{
-    char line[LINE_SIZE];
-    char *b64data = NULL;
-    unsigned int b64datalen = 0;
-    size_t off = 0;
-    int ret;
-
-    do {
-        *line = '\0';
-
-        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
-            return -1;
-        }
-    }
-    while(strcmp(line, headerbegin) != 0);
-
-    *line = '\0';
-
-    do {
-        if(*line) {
-            char *tmp;
-            size_t linelen;
-
-            linelen = strlen(line);
-            tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if(!tmp) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "Unable to allocate memory for PEM parsing");
-                ret = -1;
-                goto out;
-            }
-            memcpy(tmp + b64datalen, line, linelen);
-            b64data = tmp;
-            b64datalen += linelen;
-        }
-
-        *line = '\0';
-
-        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
-            ret = -1;
-            goto out;
-        }
-    } while(strcmp(line, headerend) != 0);
-
-    if(!b64data) {
-        return -1;
-    }
-
-    if(libssh2_base64_decode(session, (char **) data, datalen,
-                              b64data, b64datalen)) {
-        ret = -1;
-        goto out;
-    }
-
-    ret = 0;
-  out:
-    if(b64data) {
-        _libssh2_explicit_zero(b64data, b64datalen);
-        LIBSSH2_FREE(session, b64data);
-    }
-    return ret;
-}
-
-/* OpenSSH formatted keys */
-#define AUTH_MAGIC "openssh-key-v1"
-#define OPENSSH_HEADER_BEGIN "-----BEGIN OPENSSH PRIVATE KEY-----"
-#define OPENSSH_HEADER_END "-----END OPENSSH PRIVATE KEY-----"
-
-static int
-_libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
-                                const unsigned char *passphrase,
-                                const char *b64data, size_t b64datalen,
-                                struct string_buf **decrypted_buf)
-{
-    const LIBSSH2_CRYPT_METHOD *method = NULL;
-    struct string_buf decoded, decrypted, kdf_buf;
-    unsigned char *ciphername = NULL;
-    unsigned char *kdfname = NULL;
-    unsigned char *kdf = NULL;
-    unsigned char *buf = NULL;
-    unsigned char *salt = NULL;
-    uint32_t nkeys, check1, check2;
-    uint32_t rounds = 0;
-    unsigned char *key = NULL;
-    unsigned char *key_part = NULL;
-    unsigned char *iv_part = NULL;
-    unsigned char *f = NULL;
-    unsigned int f_len = 0;
-    int ret = 0, keylen = 0, ivlen = 0, total_len = 0;
-    size_t kdf_len = 0, tmp_len = 0, salt_len = 0;
-
-    if(decrypted_buf)
-        *decrypted_buf = NULL;
-
-    /* decode file */
-    if(libssh2_base64_decode(session, (char **)&f, &f_len,
-                             b64data, b64datalen)) {
-       ret = -1;
-       goto out;
-    }
-
-    /* Parse the file */
-    decoded.data = (unsigned char *)f;
-    decoded.dataptr = (unsigned char *)f;
-    decoded.len = f_len;
-
-    if(decoded.len < strlen(AUTH_MAGIC)) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO, "key too short");
-        goto out;
-    }
-
-    if(strncmp((char *) decoded.dataptr, AUTH_MAGIC,
-               strlen(AUTH_MAGIC)) != 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "key auth magic mismatch");
-        goto out;
-    }
-
-    decoded.dataptr += strlen(AUTH_MAGIC) + 1;
-
-    if(_libssh2_get_string(&decoded, &ciphername, &tmp_len) ||
-       tmp_len == 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "ciphername is missing");
-        goto out;
-    }
-
-    if(_libssh2_get_string(&decoded, &kdfname, &tmp_len) ||
-       tmp_len == 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "kdfname is missing");
-        goto out;
-    }
-
-    if(_libssh2_get_string(&decoded, &kdf, &kdf_len)) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "kdf is missing");
-        goto out;
-    }
-    else {
-        kdf_buf.data = kdf;
-        kdf_buf.dataptr = kdf;
-        kdf_buf.len = kdf_len;
-    }
-
-    if((passphrase == NULL || strlen((const char *)passphrase) == 0) &&
-        strcmp((const char *)ciphername, "none") != 0) {
-        /* passphrase required */
-        ret = LIBSSH2_ERROR_KEYFILE_AUTH_FAILED;
-        goto out;
-    }
-
-    if(strcmp((const char *)kdfname, "none") != 0 &&
-       strcmp((const char *)kdfname, "bcrypt") != 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "unknown cipher");
-        goto out;
-    }
-
-    if(!strcmp((const char *)kdfname, "none") &&
-       strcmp((const char *)ciphername, "none") != 0) {
-        ret =_libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                            "invalid format");
-        goto out;
-    }
-
-    if(_libssh2_get_u32(&decoded, &nkeys) != 0 || nkeys != 1) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "Multiple keys are unsupported");
-        goto out;
-    }
-
-    /* unencrypted public key */
-
-    if(_libssh2_get_string(&decoded, &buf, &tmp_len) || tmp_len == 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "Invalid private key; "
-                             "expect embedded public key");
-        goto out;
-    }
-
-    if(_libssh2_get_string(&decoded, &buf, &tmp_len) || tmp_len == 0) {
-        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Private key data not found");
-        goto out;
-    }
-
-    /* decode encrypted private key */
-    decrypted.data = decrypted.dataptr = buf;
-    decrypted.len = tmp_len;
-
-    if(ciphername && strcmp((const char *)ciphername, "none") != 0) {
-        const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method;
-
-        all_methods = libssh2_crypt_methods();
-        while((cur_method = *all_methods++)) {
-            if(*cur_method->name &&
-                memcmp(ciphername, cur_method->name,
-                       strlen(cur_method->name)) == 0) {
-                    method = cur_method;
-                }
-        }
-
-        /* None of the available crypt methods were able to decrypt the key */
-
-        if(method == NULL) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                "No supported cipher found");
-            goto out;
-        }
-    }
-
-    if(method) {
-        int free_iv = 0, free_secret = 0, len_decrypted = 0;
-        int blocksize;
-        void *abstract = NULL;
-
-        keylen = method->secret_len;
-        ivlen = method->iv_len;
-        total_len = keylen + ivlen;
-
-        key = LIBSSH2_CALLOC(session, total_len);
-        if(key == NULL) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Could not alloc key");
-            goto out;
-        }
-
-        if(strcmp((const char *)kdfname, "bcrypt") == 0 &&
-           passphrase != NULL) {
-            if((_libssh2_get_string(&kdf_buf, &salt, &salt_len)) ||
-                (_libssh2_get_u32(&kdf_buf, &rounds) != 0) ) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                     "kdf contains unexpected values");
-                LIBSSH2_FREE(session, key);
-                goto out;
-            }
-
-            if(_libssh2_bcrypt_pbkdf((const char *)passphrase,
-                                     strlen((const char *)passphrase),
-                                     salt, salt_len, key,
-                                     keylen + ivlen, rounds) < 0) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_DECRYPT,
-                                     "invalid format");
-                LIBSSH2_FREE(session, key);
-                goto out;
-            }
-        }
-        else {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_KEYFILE_AUTH_FAILED,
-                                            "bcrypted without passphrase");
-            LIBSSH2_FREE(session, key);
-            goto out;
-        }
-
-        /* Set up decryption */
-        blocksize = method->blocksize;
-
-        key_part = LIBSSH2_CALLOC(session, keylen);
-        if(key_part == NULL) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Could not alloc key part");
-            goto out;
-        }
-
-        iv_part = LIBSSH2_CALLOC(session, ivlen);
-        if(iv_part == NULL) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Could not alloc iv part");
-            goto out;
-        }
-
-        memcpy(key_part, key, keylen);
-        memcpy(iv_part, key + keylen, ivlen);
-
-        /* Initialize the decryption */
-        if(method->init(session, method, iv_part, &free_iv, key_part,
-                         &free_secret, 0, &abstract)) {
-            ret = LIBSSH2_ERROR_DECRYPT;
-            goto out;
-        }
-
-        /* Do the actual decryption */
-        if((decrypted.len % blocksize) != 0) {
-            method->dtor(session, &abstract);
-            ret = LIBSSH2_ERROR_DECRYPT;
-            goto out;
-        }
-
-        while((size_t)len_decrypted <= decrypted.len - blocksize) {
-            if(method->crypt(session, decrypted.data + len_decrypted,
-                             blocksize,
-                             &abstract)) {
-                ret = LIBSSH2_ERROR_DECRYPT;
-                method->dtor(session, &abstract);
-                goto out;
-            }
-
-            len_decrypted += blocksize;
-        }
-
-        /* No padding */
-
-        method->dtor(session, &abstract);
-    }
-
-    /* Check random bytes match */
-
-    if(_libssh2_get_u32(&decrypted, &check1) != 0 ||
-       _libssh2_get_u32(&decrypted, &check2) != 0 ||
-       check1 != check2) {
-       _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                      "Private key unpack failed (correct password?)");
-       ret = LIBSSH2_ERROR_KEYFILE_AUTH_FAILED;
-       goto out;
-    }
-
-    if(decrypted_buf != NULL) {
-        /* copy data to out-going buffer */
-        struct string_buf *out_buf = _libssh2_string_buf_new(session);
-        if(!out_buf) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate memory for "
-                                 "decrypted struct");
-            goto out;
-        }
-
-        out_buf->data = LIBSSH2_CALLOC(session, decrypted.len);
-        if(out_buf->data == NULL) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate memory for "
-                                 "decrypted struct");
-            _libssh2_string_buf_free(session, out_buf);
-            goto out;
-        }
-        memcpy(out_buf->data, decrypted.data, decrypted.len);
-        out_buf->dataptr = out_buf->data +
-            (decrypted.dataptr - decrypted.data);
-        out_buf->len = decrypted.len;
-
-        *decrypted_buf = out_buf;
-    }
-
-out:
-
-    /* Clean up */
-    if(key) {
-        _libssh2_explicit_zero(key, total_len);
-        LIBSSH2_FREE(session, key);
-    }
-    if(key_part) {
-        _libssh2_explicit_zero(key_part, keylen);
-        LIBSSH2_FREE(session, key_part);
-    }
-    if(iv_part) {
-        _libssh2_explicit_zero(iv_part, ivlen);
-        LIBSSH2_FREE(session, iv_part);
-    }
-    if(f) {
-        _libssh2_explicit_zero(f, f_len);
-        LIBSSH2_FREE(session, f);
-    }
-
-    return ret;
-}
-
-int
-_libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
-                           const unsigned char *passphrase,
-                           FILE * fp, struct string_buf **decrypted_buf)
-{
-    char line[LINE_SIZE];
-    char *b64data = NULL;
-    unsigned int b64datalen = 0;
-    int ret = 0;
-
-    /* read file */
-
-    do {
-        *line = '\0';
-
-        if(readline(line, LINE_SIZE, fp)) {
-            return -1;
-        }
-    }
-    while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
-
-    if(readline(line, LINE_SIZE, fp)) {
-        return -1;
-    }
-
-    do {
-        if(*line) {
-            char *tmp;
-            size_t linelen;
-
-            linelen = strlen(line);
-            tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if(!tmp) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "Unable to allocate memory for PEM parsing");
-                ret = -1;
-                goto out;
-            }
-            memcpy(tmp + b64datalen, line, linelen);
-            b64data = tmp;
-            b64datalen += linelen;
-        }
-
-        *line = '\0';
-
-        if(readline(line, LINE_SIZE, fp)) {
-            ret = -1;
-            goto out;
-        }
-    } while(strcmp(line, OPENSSH_HEADER_END) != 0);
-
-    if(!b64data) {
-        return -1;
-    }
-
-    ret = _libssh2_openssh_pem_parse_data(session,
-                                          passphrase,
-                                          (const char *)b64data,
-                                          (size_t)b64datalen,
-                                          decrypted_buf);
-
-    if(b64data) {
-        _libssh2_explicit_zero(b64data, b64datalen);
-        LIBSSH2_FREE(session, b64data);
-    }
-
-out:
-
-    return ret;
-}
-
-int
-_libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
-                                  const unsigned char *passphrase,
-                                  const char *filedata, size_t filedata_len,
-                                  struct string_buf **decrypted_buf)
-{
-    char line[LINE_SIZE];
-    char *b64data = NULL;
-    unsigned int b64datalen = 0;
-    size_t off = 0;
-    int ret;
-
-    if(filedata == NULL || filedata_len <= 0)
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "Error parsing PEM: filedata missing");
-
-    do {
-
-        *line = '\0';
-
-        if(off >= filedata_len)
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Error parsing PEM: offset out of bounds");
-
-        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
-            return -1;
-        }
-    }
-    while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
-
-    *line = '\0';
-
-    do {
-        if (*line) {
-            char *tmp;
-            size_t linelen;
-
-            linelen = strlen(line);
-            tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
-            if(!tmp) {
-                ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                     "Unable to allocate memory for "
-                                     "PEM parsing");
-                goto out;
-            }
-            memcpy(tmp + b64datalen, line, linelen);
-            b64data = tmp;
-            b64datalen += linelen;
-        }
-
-        *line = '\0';
-
-        if(off >= filedata_len) {
-            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Error parsing PEM: offset out of bounds");
-            goto out;
-        }
-
-        if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
-            ret = -1;
-            goto out;
-        }
-    } while(strcmp(line, OPENSSH_HEADER_END) != 0);
-
-    if(!b64data)
-        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                              "Error parsing PEM: base 64 data missing");
-
-    ret = _libssh2_openssh_pem_parse_data(session, passphrase, b64data,
-                                          b64datalen, decrypted_buf);
-
-out:
-    if(b64data) {
-        _libssh2_explicit_zero(b64data, b64datalen);
-        LIBSSH2_FREE(session, b64data);
-    }
-    return ret;
-
-}
-
-static int
-read_asn1_length(const unsigned char *data,
-                 unsigned int datalen, unsigned int *len)
-{
-    unsigned int lenlen;
-    int nextpos;
-
-    if(datalen < 1) {
-        return -1;
-    }
-    *len = data[0];
-
-    if(*len >= 0x80) {
-        lenlen = *len & 0x7F;
-        *len = data[1];
-        if(1 + lenlen > datalen) {
-            return -1;
-        }
-        if(lenlen > 1) {
-            *len <<= 8;
-            *len |= data[2];
-        }
-    }
-    else {
-        lenlen = 0;
-    }
-
-    nextpos = 1 + lenlen;
-    if(lenlen > 2 || 1 + lenlen + *len > datalen) {
-        return -1;
-    }
-
-    return nextpos;
-}
-
-int
-_libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
-{
-    unsigned int len;
-    int lenlen;
-
-    if(*datalen < 1) {
-        return -1;
-    }
-
-    if((*data)[0] != '\x30') {
-        return -1;
-    }
-
-    (*data)++;
-    (*datalen)--;
-
-    lenlen = read_asn1_length(*data, *datalen, &len);
-    if(lenlen < 0 || lenlen + len != *datalen) {
-        return -1;
-    }
-
-    *data += lenlen;
-    *datalen -= lenlen;
-
-    return 0;
-}
-
-int
-_libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
-                            unsigned char **i, unsigned int *ilen)
-{
-    unsigned int len;
-    int lenlen;
-
-    if(*datalen < 1) {
-        return -1;
-    }
-
-    if((*data)[0] != '\x02') {
-        return -1;
-    }
-
-    (*data)++;
-    (*datalen)--;
-
-    lenlen = read_asn1_length(*data, *datalen, &len);
-    if(lenlen < 0 || lenlen + len > *datalen) {
-        return -1;
-    }
-
-    *data += lenlen;
-    *datalen -= lenlen;
-
-    *i = *data;
-    *ilen = len;
-
-    *data += len;
-    *datalen -= len;
-
-    return 0;
-}
diff --git a/libssh2/libssh2/src/publickey.c b/libssh2/libssh2/src/publickey.c
deleted file mode 100644
index f26c6327..00000000
--- a/libssh2/libssh2/src/publickey.c
+++ /dev/null
@@ -1,1278 +0,0 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2014 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include "libssh2_publickey.h"
-#include "channel.h"
-#include "session.h"
-
-#define LIBSSH2_PUBLICKEY_VERSION               2
-
-/* Numericised response codes -- Not IETF, just local representation */
-#define LIBSSH2_PUBLICKEY_RESPONSE_STATUS       0
-#define LIBSSH2_PUBLICKEY_RESPONSE_VERSION      1
-#define LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY    2
-
-typedef struct _LIBSSH2_PUBLICKEY_CODE_LIST
-{
-    int code;
-    const char *name;
-    int name_len;
-} LIBSSH2_PUBLICKEY_CODE_LIST;
-
-static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_response_codes[] =
-{
-    {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1},
-    {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1},
-    {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey",
-     sizeof("publickey") - 1},
-    {0, NULL, 0}
-};
-
-/* PUBLICKEY status codes -- IETF defined */
-#define LIBSSH2_PUBLICKEY_SUCCESS               0
-#define LIBSSH2_PUBLICKEY_ACCESS_DENIED         1
-#define LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED      2
-#define LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED 3
-#define LIBSSH2_PUBLICKEY_KEY_NOT_FOUND         4
-#define LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED     5
-#define LIBSSH2_PUBLICKEY_KEY_ALREADY_PRESENT   6
-#define LIBSSH2_PUBLICKEY_GENERAL_FAILURE       7
-#define LIBSSH2_PUBLICKEY_REQUEST_NOT_SUPPORTED 8
-
-#define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX       8
-
-static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = {
-    {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1},
-    {LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied",
-     sizeof("access denied") - 1},
-    {LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded",
-     sizeof("storage exceeded") - 1},
-    {LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported",
-     sizeof("version not supported") - 1},
-    {LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found",
-     sizeof("key not found") - 1},
-    {LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported",
-     sizeof("key not supported") - 1},
-    {LIBSSH2_PUBLICKEY_KEY_ALREADY_PRESENT, "key already present",
-     sizeof("key already present") - 1},
-    {LIBSSH2_PUBLICKEY_GENERAL_FAILURE, "general failure",
-     sizeof("general failure") - 1},
-    {LIBSSH2_PUBLICKEY_REQUEST_NOT_SUPPORTED, "request not supported",
-     sizeof("request not supported") - 1},
-    {0, NULL, 0}
-};
-
-/*
- * publickey_status_error
- *
- * Format an error message from a status code
- */
-static void
-publickey_status_error(const LIBSSH2_PUBLICKEY *pkey,
-                       LIBSSH2_SESSION *session, int status)
-{
-    const char *msg;
-
-    /* GENERAL_FAILURE got remapped between version 1 and 2 */
-    if(status == 6 && pkey && pkey->version == 1) {
-        status = 7;
-    }
-
-    if(status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
-        msg = "unknown";
-    }
-    else {
-        msg = publickey_status_codes[status].name;
-    }
-
-    _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, msg);
-}
-
-/*
- * publickey_packet_receive
- *
- * Read a packet from the subsystem
- */
-static int
-publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
-                         unsigned char **data, size_t *data_len)
-{
-    LIBSSH2_CHANNEL *channel = pkey->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char buffer[4];
-    int rc;
-    *data = NULL; /* default to nothing returned */
-    *data_len = 0;
-
-    if(pkey->receive_state == libssh2_NB_state_idle) {
-        rc = _libssh2_channel_read(channel, 0, (char *) buffer, 4);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc != 4) {
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                                  "Invalid response from publickey subsystem");
-        }
-
-        pkey->receive_packet_len = _libssh2_ntohu32(buffer);
-        pkey->receive_packet =
-            LIBSSH2_ALLOC(session, pkey->receive_packet_len);
-        if(!pkey->receive_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate publickey response "
-                                  "buffer");
-        }
-
-        pkey->receive_state = libssh2_NB_state_sent;
-    }
-
-    if(pkey->receive_state == libssh2_NB_state_sent) {
-        rc = _libssh2_channel_read(channel, 0, (char *) pkey->receive_packet,
-                                   pkey->receive_packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc != (int)pkey->receive_packet_len) {
-            LIBSSH2_FREE(session, pkey->receive_packet);
-            pkey->receive_packet = NULL;
-            pkey->receive_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
-                                  "Timeout waiting for publickey subsystem "
-                                  "response packet");
-        }
-
-        *data = pkey->receive_packet;
-        *data_len = pkey->receive_packet_len;
-    }
-
-    pkey->receive_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/* publickey_response_id
- *
- * Translate a string response name to a numeric code
- * Data will be incremented by 4 + response_len on success only
- */
-static int
-publickey_response_id(unsigned char **pdata, size_t data_len)
-{
-    size_t response_len;
-    unsigned char *data = *pdata;
-    const LIBSSH2_PUBLICKEY_CODE_LIST *codes = publickey_response_codes;
-
-    if(data_len < 4) {
-        /* Malformed response */
-        return -1;
-    }
-    response_len = _libssh2_ntohu32(data);
-    data += 4;
-    data_len -= 4;
-    if(data_len < response_len) {
-        /* Malformed response */
-        return -1;
-    }
-
-    while(codes->name) {
-        if((unsigned long)codes->name_len == response_len &&
-            strncmp(codes->name, (char *) data, response_len) == 0) {
-            *pdata = data + response_len;
-            return codes->code;
-        }
-        codes++;
-    }
-
-    return -1;
-}
-
-/* publickey_response_success
- *
- * Generic helper routine to wait for success response and nothing else
- */
-static int
-publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
-{
-    LIBSSH2_SESSION *session = pkey->channel->session;
-    unsigned char *data, *s;
-    size_t data_len;
-    int response;
-
-    while(1) {
-        int rc = publickey_packet_receive(pkey, &data, &data_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
-                                  "Timeout waiting for response from "
-                                  "publickey subsystem");
-        }
-
-        if(data_len < 4) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Publickey response too small");
-        }
-
-        s = data;
-        response = publickey_response_id(&s, data_len);
-
-        switch(response) {
-        case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
-            /* Error, or processing complete */
-        {
-            unsigned long status = 0;
-
-            if(data_len < 8) {
-                return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                      "Publickey response too small");
-            }
-
-            status = _libssh2_ntohu32(s);
-
-            LIBSSH2_FREE(session, data);
-
-            if(status == LIBSSH2_PUBLICKEY_SUCCESS)
-                return 0;
-
-            publickey_status_error(pkey, session, status);
-            return -1;
-        }
-        default:
-            LIBSSH2_FREE(session, data);
-            if(response < 0) {
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                                      "Invalid publickey subsystem response");
-            }
-            /* Unknown/Unexpected */
-            _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                           "Unexpected publickey subsystem response");
-            data = NULL;
-        }
-    }
-    /* never reached, but include `return` to silence compiler warnings */
-    return -1;
-}
-
-/* *****************
- * Publickey API *
- ***************** */
-
-/*
- * publickey_init
- *
- * Startup the publickey subsystem
- */
-static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
-{
-    int response;
-    int rc;
-
-    if(session->pkeyInit_state == libssh2_NB_state_idle) {
-        session->pkeyInit_data = NULL;
-        session->pkeyInit_pkey = NULL;
-        session->pkeyInit_channel = NULL;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Initializing publickey subsystem");
-
-        session->pkeyInit_state = libssh2_NB_state_allocated;
-    }
-
-    if(session->pkeyInit_state == libssh2_NB_state_allocated) {
-
-        session->pkeyInit_channel =
-            _libssh2_channel_open(session, "session",
-                                  sizeof("session") - 1,
-                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
-                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
-                                  0);
-        if(!session->pkeyInit_channel) {
-            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN)
-                /* The error state is already set, so leave it */
-                return NULL;
-            _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                           "Unable to startup channel");
-            goto err_exit;
-        }
-
-        session->pkeyInit_state = libssh2_NB_state_sent;
-    }
-
-    if(session->pkeyInit_state == libssh2_NB_state_sent) {
-        rc = _libssh2_channel_process_startup(session->pkeyInit_channel,
-                                              "subsystem",
-                                              sizeof("subsystem") - 1,
-                                              "publickey",
-                                              sizeof("publickey") - 1);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block starting publickey subsystem");
-            return NULL;
-        }
-        else if(rc) {
-            _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                           "Unable to request publickey subsystem");
-            goto err_exit;
-        }
-
-        session->pkeyInit_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->pkeyInit_state == libssh2_NB_state_sent1) {
-        unsigned char *s;
-        rc = _libssh2_channel_extended_data(session->pkeyInit_channel,
-                                         LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block starting publickey subsystem");
-            return NULL;
-        }
-
-        session->pkeyInit_pkey =
-            LIBSSH2_CALLOC(session, sizeof(LIBSSH2_PUBLICKEY));
-        if(!session->pkeyInit_pkey) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate a new publickey structure");
-            goto err_exit;
-        }
-        session->pkeyInit_pkey->channel = session->pkeyInit_channel;
-        session->pkeyInit_pkey->version = 0;
-
-        s = session->pkeyInit_buffer;
-        _libssh2_htonu32(s, 4 + (sizeof("version") - 1) + 4);
-        s += 4;
-        _libssh2_htonu32(s, sizeof("version") - 1);
-        s += 4;
-        memcpy(s, "version", sizeof("version") - 1);
-        s += sizeof("version") - 1;
-        _libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION);
-
-        session->pkeyInit_buffer_sent = 0;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey advertising version %d support",
-                       (int) LIBSSH2_PUBLICKEY_VERSION);
-
-        session->pkeyInit_state = libssh2_NB_state_sent2;
-    }
-
-    if(session->pkeyInit_state == libssh2_NB_state_sent2) {
-        rc = _libssh2_channel_write(session->pkeyInit_channel, 0,
-                                    session->pkeyInit_buffer,
-                                    19 - session->pkeyInit_buffer_sent);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block sending publickey version packet");
-            return NULL;
-        }
-        else if(rc < 0) {
-            _libssh2_error(session, rc,
-                           "Unable to send publickey version packet");
-            goto err_exit;
-        }
-        session->pkeyInit_buffer_sent += rc;
-        if(session->pkeyInit_buffer_sent < 19) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Need to be called again to complete this");
-            return NULL;
-        }
-
-        session->pkeyInit_state = libssh2_NB_state_sent3;
-    }
-
-    if(session->pkeyInit_state == libssh2_NB_state_sent3) {
-        while(1) {
-            unsigned char *s;
-            rc = publickey_packet_receive(session->pkeyInit_pkey,
-                                          &session->pkeyInit_data,
-                                          &session->pkeyInit_data_len);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block waiting for response from "
-                               "publickey subsystem");
-                return NULL;
-            }
-            else if(rc) {
-                _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
-                               "Timeout waiting for response from "
-                               "publickey subsystem");
-                goto err_exit;
-            }
-
-            s = session->pkeyInit_data;
-            if((response =
-                 publickey_response_id(&s, session->pkeyInit_data_len)) < 0) {
-                _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                               "Invalid publickey subsystem response code");
-                goto err_exit;
-            }
-
-            if(session->pkeyInit_data_len < 4) {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "Public key init data too small");
-                goto err_exit;
-            }
-
-            switch(response) {
-            case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
-                /* Error */
-            {
-                unsigned long status, descr_len, lang_len;
-
-                if(session->pkeyInit_data_len >= 8) {
-                    status = _libssh2_ntohu32(s);
-                    s += 4;
-                    descr_len = _libssh2_ntohu32(s);
-                    s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "Public key init data too small");
-                    goto err_exit;
-                }
-
-                if(s + descr_len + 4 <=
-                   session->pkeyInit_data + session->pkeyInit_data_len) {
-                    /* description starts here */
-                    s += descr_len;
-                    lang_len = _libssh2_ntohu32(s);
-                    s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "Public key init data too small");
-                    goto err_exit;
-                }
-
-                if(s + lang_len <=
-                   session->pkeyInit_data + session->pkeyInit_data_len) {
-                    /* lang starts here */
-                    s += lang_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "Public key init data too small");
-                    goto err_exit;
-                }
-
-                if(s >
-                    session->pkeyInit_data + session->pkeyInit_data_len) {
-                    _libssh2_error(session,
-                                   LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                                   "Malformed publickey subsystem packet");
-                    goto err_exit;
-                }
-
-                publickey_status_error(NULL, session, status);
-
-                goto err_exit;
-            }
-
-            case LIBSSH2_PUBLICKEY_RESPONSE_VERSION:
-                /* What we want */
-                session->pkeyInit_pkey->version = _libssh2_ntohu32(s);
-                if(session->pkeyInit_pkey->version >
-                    LIBSSH2_PUBLICKEY_VERSION) {
-                    _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                                   "Truncate remote publickey version "
-                                   "from %lu",
-                                   session->pkeyInit_pkey->version);
-                    session->pkeyInit_pkey->version =
-                        LIBSSH2_PUBLICKEY_VERSION;
-                }
-                _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                               "Enabling publickey subsystem version %lu",
-                               session->pkeyInit_pkey->version);
-                LIBSSH2_FREE(session, session->pkeyInit_data);
-                session->pkeyInit_data = NULL;
-                session->pkeyInit_state = libssh2_NB_state_idle;
-                return session->pkeyInit_pkey;
-
-            default:
-                /* Unknown/Unexpected */
-                _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                               "Unexpected publickey subsystem response, "
-                               "ignoring");
-                LIBSSH2_FREE(session, session->pkeyInit_data);
-                session->pkeyInit_data = NULL;
-            }
-        }
-    }
-
-    /* Never reached except by direct goto */
-  err_exit:
-    session->pkeyInit_state = libssh2_NB_state_sent4;
-    if(session->pkeyInit_channel) {
-        rc = _libssh2_channel_close(session->pkeyInit_channel);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block closing channel");
-            return NULL;
-        }
-    }
-    if(session->pkeyInit_pkey) {
-        LIBSSH2_FREE(session, session->pkeyInit_pkey);
-        session->pkeyInit_pkey = NULL;
-    }
-    if(session->pkeyInit_data) {
-        LIBSSH2_FREE(session, session->pkeyInit_data);
-        session->pkeyInit_data = NULL;
-    }
-    session->pkeyInit_state = libssh2_NB_state_idle;
-    return NULL;
-}
-
-/*
- * libssh2_publickey_init
- *
- * Startup the publickey subsystem
- */
-LIBSSH2_API LIBSSH2_PUBLICKEY *
-libssh2_publickey_init(LIBSSH2_SESSION *session)
-{
-    LIBSSH2_PUBLICKEY *ptr;
-
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       publickey_init(session));
-    return ptr;
-}
-
-
-
-/*
- * libssh2_publickey_add_ex
- *
- * Add a new public key entry
- */
-LIBSSH2_API int
-libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-                         unsigned long name_len, const unsigned char *blob,
-                         unsigned long blob_len, char overwrite,
-                         unsigned long num_attrs,
-                         const libssh2_publickey_attribute attrs[])
-{
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session;
-    /*  19 = packet_len(4) + add_len(4) + "add"(3) + name_len(4) + {name}
-        blob_len(4) + {blob} */
-    unsigned long i, packet_len = 19 + name_len + blob_len;
-    unsigned char *comment = NULL;
-    unsigned long comment_len = 0;
-    int rc;
-
-    if(!pkey)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    channel = pkey->channel;
-    session = channel->session;
-
-    if(pkey->add_state == libssh2_NB_state_idle) {
-        pkey->add_packet = NULL;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey",
-                       name);
-
-        if(pkey->version == 1) {
-            for(i = 0; i < num_attrs; i++) {
-                /* Search for a comment attribute */
-                if(attrs[i].name_len == (sizeof("comment") - 1) &&
-                    strncmp(attrs[i].name, "comment",
-                            sizeof("comment") - 1) == 0) {
-                    comment = (unsigned char *) attrs[i].value;
-                    comment_len = attrs[i].value_len;
-                    break;
-                }
-            }
-            packet_len += 4 + comment_len;
-        }
-        else {
-            packet_len += 5;    /* overwrite(1) + attribute_count(4) */
-            for(i = 0; i < num_attrs; i++) {
-                packet_len += 9 + attrs[i].name_len + attrs[i].value_len;
-                /* name_len(4) + value_len(4) + mandatory(1) */
-            }
-        }
-
-        pkey->add_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!pkey->add_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "publickey \"add\" packet");
-        }
-
-        pkey->add_s = pkey->add_packet;
-        _libssh2_htonu32(pkey->add_s, packet_len - 4);
-        pkey->add_s += 4;
-        _libssh2_htonu32(pkey->add_s, sizeof("add") - 1);
-        pkey->add_s += 4;
-        memcpy(pkey->add_s, "add", sizeof("add") - 1);
-        pkey->add_s += sizeof("add") - 1;
-        if(pkey->version == 1) {
-            _libssh2_htonu32(pkey->add_s, comment_len);
-            pkey->add_s += 4;
-            if(comment) {
-                memcpy(pkey->add_s, comment, comment_len);
-                pkey->add_s += comment_len;
-            }
-
-            _libssh2_htonu32(pkey->add_s, name_len);
-            pkey->add_s += 4;
-            memcpy(pkey->add_s, name, name_len);
-            pkey->add_s += name_len;
-            _libssh2_htonu32(pkey->add_s, blob_len);
-            pkey->add_s += 4;
-            memcpy(pkey->add_s, blob, blob_len);
-            pkey->add_s += blob_len;
-        }
-        else {
-            /* Version == 2 */
-
-            _libssh2_htonu32(pkey->add_s, name_len);
-            pkey->add_s += 4;
-            memcpy(pkey->add_s, name, name_len);
-            pkey->add_s += name_len;
-            _libssh2_htonu32(pkey->add_s, blob_len);
-            pkey->add_s += 4;
-            memcpy(pkey->add_s, blob, blob_len);
-            pkey->add_s += blob_len;
-            *(pkey->add_s++) = overwrite ? 0x01 : 0;
-            _libssh2_htonu32(pkey->add_s, num_attrs);
-            pkey->add_s += 4;
-            for(i = 0; i < num_attrs; i++) {
-                _libssh2_htonu32(pkey->add_s, attrs[i].name_len);
-                pkey->add_s += 4;
-                memcpy(pkey->add_s, attrs[i].name, attrs[i].name_len);
-                pkey->add_s += attrs[i].name_len;
-                _libssh2_htonu32(pkey->add_s, attrs[i].value_len);
-                pkey->add_s += 4;
-                memcpy(pkey->add_s, attrs[i].value, attrs[i].value_len);
-                pkey->add_s += attrs[i].value_len;
-                *(pkey->add_s++) = attrs[i].mandatory ? 0x01 : 0;
-            }
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"add\" packet: "
-                       "type=%s blob_len=%ld num_attrs=%ld",
-                       name, blob_len, num_attrs);
-
-        pkey->add_state = libssh2_NB_state_created;
-    }
-
-    if(pkey->add_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, pkey->add_packet,
-                                    (pkey->add_s - pkey->add_packet));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((pkey->add_s - pkey->add_packet) != rc) {
-            LIBSSH2_FREE(session, pkey->add_packet);
-            pkey->add_packet = NULL;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send publickey add packet");
-        }
-        LIBSSH2_FREE(session, pkey->add_packet);
-        pkey->add_packet = NULL;
-
-        pkey->add_state = libssh2_NB_state_sent;
-    }
-
-    rc = publickey_response_success(pkey);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-
-    pkey->add_state = libssh2_NB_state_idle;
-
-    return rc;
-}
-
-/* libssh2_publickey_remove_ex
- * Remove an existing publickey so that authentication can no longer be
- * performed using it
- */
-LIBSSH2_API int
-libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
-                            const unsigned char *name, unsigned long name_len,
-                            const unsigned char *blob, unsigned long blob_len)
-{
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session;
-    /* 22 = packet_len(4) + remove_len(4) + "remove"(6) + name_len(4) + {name}
-       + blob_len(4) + {blob} */
-    unsigned long packet_len = 22 + name_len + blob_len;
-    int rc;
-
-    if(!pkey)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    channel = pkey->channel;
-    session = channel->session;
-
-    if(pkey->remove_state == libssh2_NB_state_idle) {
-        pkey->remove_packet = NULL;
-
-        pkey->remove_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!pkey->remove_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "publickey \"remove\" packet");
-        }
-
-        pkey->remove_s = pkey->remove_packet;
-        _libssh2_htonu32(pkey->remove_s, packet_len - 4);
-        pkey->remove_s += 4;
-        _libssh2_htonu32(pkey->remove_s, sizeof("remove") - 1);
-        pkey->remove_s += 4;
-        memcpy(pkey->remove_s, "remove", sizeof("remove") - 1);
-        pkey->remove_s += sizeof("remove") - 1;
-        _libssh2_htonu32(pkey->remove_s, name_len);
-        pkey->remove_s += 4;
-        memcpy(pkey->remove_s, name, name_len);
-        pkey->remove_s += name_len;
-        _libssh2_htonu32(pkey->remove_s, blob_len);
-        pkey->remove_s += 4;
-        memcpy(pkey->remove_s, blob, blob_len);
-        pkey->remove_s += blob_len;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"remove\" packet: "
-                       "type=%s blob_len=%ld",
-                       name, blob_len);
-
-        pkey->remove_state = libssh2_NB_state_created;
-    }
-
-    if(pkey->remove_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, pkey->remove_packet,
-                                    (pkey->remove_s - pkey->remove_packet));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((pkey->remove_s - pkey->remove_packet) != rc) {
-            LIBSSH2_FREE(session, pkey->remove_packet);
-            pkey->remove_packet = NULL;
-            pkey->remove_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send publickey remove packet");
-        }
-        LIBSSH2_FREE(session, pkey->remove_packet);
-        pkey->remove_packet = NULL;
-
-        pkey->remove_state = libssh2_NB_state_sent;
-    }
-
-    rc = publickey_response_success(pkey);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-
-    pkey->remove_state = libssh2_NB_state_idle;
-
-    return rc;
-}
-
-/* libssh2_publickey_list_fetch
- * Fetch a list of supported public key from a server
- */
-LIBSSH2_API int
-libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
-                             libssh2_publickey_list ** pkey_list)
-{
-    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session;
-    libssh2_publickey_list *list = NULL;
-    unsigned long buffer_len = 12, keys = 0, max_keys = 0, i;
-    /* 12 = packet_len(4) + list_len(4) + "list"(4) */
-    int response;
-    int rc;
-
-    if(!pkey)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    channel = pkey->channel;
-    session = channel->session;
-
-    if(pkey->listFetch_state == libssh2_NB_state_idle) {
-        pkey->listFetch_data = NULL;
-
-        pkey->listFetch_s = pkey->listFetch_buffer;
-        _libssh2_htonu32(pkey->listFetch_s, buffer_len - 4);
-        pkey->listFetch_s += 4;
-        _libssh2_htonu32(pkey->listFetch_s, sizeof("list") - 1);
-        pkey->listFetch_s += 4;
-        memcpy(pkey->listFetch_s, "list", sizeof("list") - 1);
-        pkey->listFetch_s += sizeof("list") - 1;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"list\" packet");
-
-        pkey->listFetch_state = libssh2_NB_state_created;
-    }
-
-    if(pkey->listFetch_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0,
-                                    pkey->listFetch_buffer,
-                                    (pkey->listFetch_s -
-                                     pkey->listFetch_buffer));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
-            pkey->listFetch_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send publickey list packet");
-        }
-
-        pkey->listFetch_state = libssh2_NB_state_sent;
-    }
-
-    while(1) {
-        rc = publickey_packet_receive(pkey, &pkey->listFetch_data,
-                                      &pkey->listFetch_data_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
-                           "Timeout waiting for response from "
-                           "publickey subsystem");
-            goto err_exit;
-        }
-
-        pkey->listFetch_s = pkey->listFetch_data;
-        if((response =
-             publickey_response_id(&pkey->listFetch_s,
-                                   pkey->listFetch_data_len)) < 0) {
-            _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                           "Invalid publickey subsystem response code");
-            goto err_exit;
-        }
-
-        switch(response) {
-        case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
-            /* Error, or processing complete */
-        {
-            unsigned long status, descr_len, lang_len;
-
-            if(pkey->listFetch_s + 8 <=
-               pkey->listFetch_data + pkey->listFetch_data_len) {
-                status = _libssh2_ntohu32(pkey->listFetch_s);
-                pkey->listFetch_s += 4;
-                descr_len = _libssh2_ntohu32(pkey->listFetch_s);
-                pkey->listFetch_s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "ListFetch data too short");
-                goto err_exit;
-            }
-
-            if(pkey->listFetch_s + descr_len + 4 <=
-               pkey->listFetch_data + pkey->listFetch_data_len) {
-                /* description starts at pkey->listFetch_s */
-                pkey->listFetch_s += descr_len;
-                lang_len = _libssh2_ntohu32(pkey->listFetch_s);
-                pkey->listFetch_s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "ListFetch data too short");
-                goto err_exit;
-            }
-
-            if(pkey->listFetch_s + lang_len <=
-               pkey->listFetch_data + pkey->listFetch_data_len) {
-                /* lang starts at pkey->listFetch_s */
-                pkey->listFetch_s += lang_len;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "ListFetch data too short");
-                goto err_exit;
-            }
-
-            if(pkey->listFetch_s >
-                pkey->listFetch_data + pkey->listFetch_data_len) {
-                _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                               "Malformed publickey subsystem packet");
-                goto err_exit;
-            }
-
-            if(status == LIBSSH2_PUBLICKEY_SUCCESS) {
-                LIBSSH2_FREE(session, pkey->listFetch_data);
-                pkey->listFetch_data = NULL;
-                *pkey_list = list;
-                *num_keys = keys;
-                pkey->listFetch_state = libssh2_NB_state_idle;
-                return 0;
-            }
-
-            publickey_status_error(pkey, session, status);
-            goto err_exit;
-        }
-        case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY:
-            /* What we want */
-            if(keys >= max_keys) {
-                libssh2_publickey_list *newlist;
-                /* Grow the key list if necessary */
-                max_keys += 8;
-                newlist =
-                    LIBSSH2_REALLOC(session, list,
-                                    (max_keys +
-                                     1) * sizeof(libssh2_publickey_list));
-                if(!newlist) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "publickey list");
-                    goto err_exit;
-                }
-                list = newlist;
-            }
-            if(pkey->version == 1) {
-                unsigned long comment_len;
-
-                if(pkey->listFetch_s + 4 <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    comment_len = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(comment_len) {
-                    list[keys].num_attrs = 1;
-                    list[keys].attrs =
-                        LIBSSH2_ALLOC(session,
-                                      sizeof(libssh2_publickey_attribute));
-                    if(!list[keys].attrs) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate memory for "
-                                       "publickey attributes");
-                        goto err_exit;
-                    }
-                    list[keys].attrs[0].name = "comment";
-                    list[keys].attrs[0].name_len = sizeof("comment") - 1;
-                    list[keys].attrs[0].value = (char *) pkey->listFetch_s;
-                    list[keys].attrs[0].value_len = comment_len;
-                    list[keys].attrs[0].mandatory = 0;
-
-                    pkey->listFetch_s += comment_len;
-                }
-                else {
-                    list[keys].num_attrs = 0;
-                    list[keys].attrs = NULL;
-                }
-
-                if(pkey->listFetch_s + 4 <=
-                    pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + list[keys].name_len <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].name = pkey->listFetch_s;
-                    pkey->listFetch_s += list[keys].name_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + 4 <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].blob_len = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + list[keys].blob_len <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].blob = pkey->listFetch_s;
-                    pkey->listFetch_s += list[keys].blob_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-            }
-            else {
-                /* Version == 2 */
-
-                if(pkey->listFetch_s + 4 <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].name_len = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + list[keys].name_len <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].name = pkey->listFetch_s;
-                    pkey->listFetch_s += list[keys].name_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + 4 <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].blob_len = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + list[keys].blob_len <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].blob = pkey->listFetch_s;
-                    pkey->listFetch_s += list[keys].blob_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(pkey->listFetch_s + 4 <=
-                   pkey->listFetch_data + pkey->listFetch_data_len) {
-                    list[keys].num_attrs = _libssh2_ntohu32(pkey->listFetch_s);
-                    pkey->listFetch_s += 4;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "ListFetch data too short");
-                    goto err_exit;
-                }
-
-                if(list[keys].num_attrs) {
-                    list[keys].attrs =
-                        LIBSSH2_ALLOC(session,
-                                      list[keys].num_attrs *
-                                      sizeof(libssh2_publickey_attribute));
-                    if(!list[keys].attrs) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate memory for "
-                                       "publickey attributes");
-                        goto err_exit;
-                    }
-                    for(i = 0; i < list[keys].num_attrs; i++) {
-                        if(pkey->listFetch_s + 4 <=
-                           pkey->listFetch_data + pkey->listFetch_data_len) {
-                            list[keys].attrs[i].name_len =
-                                _libssh2_ntohu32(pkey->listFetch_s);
-                            pkey->listFetch_s += 4;
-                        }
-                        else {
-                            _libssh2_error(session,
-                                           LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                           "ListFetch data too short");
-                            goto err_exit;
-                        }
-
-                        if(pkey->listFetch_s + list[keys].attrs[i].name_len <=
-                           pkey->listFetch_data + pkey->listFetch_data_len) {
-                            list[keys].attrs[i].name =
-                                (char *) pkey->listFetch_s;
-                            pkey->listFetch_s += list[keys].attrs[i].name_len;
-                        }
-                        else {
-                            _libssh2_error(session,
-                                           LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                           "ListFetch data too short");
-                            goto err_exit;
-                        }
-
-                        if(pkey->listFetch_s + 4 <=
-                           pkey->listFetch_data + pkey->listFetch_data_len) {
-                            list[keys].attrs[i].value_len =
-                                _libssh2_ntohu32(pkey->listFetch_s);
-                            pkey->listFetch_s += 4;
-                        }
-                        else {
-                            _libssh2_error(session,
-                                           LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                           "ListFetch data too short");
-                            goto err_exit;
-                        }
-
-                        if(pkey->listFetch_s +
-                           list[keys].attrs[i].value_len <=
-                           pkey->listFetch_data + pkey->listFetch_data_len) {
-                            list[keys].attrs[i].value =
-                                (char *) pkey->listFetch_s;
-                            pkey->listFetch_s += list[keys].attrs[i].value_len;
-                        }
-                        else {
-                            _libssh2_error(session,
-                                           LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                           "ListFetch data too short");
-                            goto err_exit;
-                        }
-
-                        /* actually an ignored value */
-                        list[keys].attrs[i].mandatory = 0;
-                    }
-                }
-                else {
-                    list[keys].attrs = NULL;
-                }
-            }
-            /* To be FREEd in libssh2_publickey_list_free() */
-            list[keys].packet = pkey->listFetch_data;
-            keys++;
-
-            list[keys].packet = NULL;   /* Terminate the list */
-            pkey->listFetch_data = NULL;
-            break;
-        default:
-            /* Unknown/Unexpected */
-            _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                           "Unexpected publickey subsystem response");
-            LIBSSH2_FREE(session, pkey->listFetch_data);
-            pkey->listFetch_data = NULL;
-        }
-    }
-
-    /* Only reached via explicit goto */
-  err_exit:
-    if(pkey->listFetch_data) {
-        LIBSSH2_FREE(session, pkey->listFetch_data);
-        pkey->listFetch_data = NULL;
-    }
-    if(list) {
-        libssh2_publickey_list_free(pkey, list);
-    }
-    pkey->listFetch_state = libssh2_NB_state_idle;
-    return -1;
-}
-
-/* libssh2_publickey_list_free
- * Free a previously fetched list of public keys
- */
-LIBSSH2_API void
-libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
-                            libssh2_publickey_list * pkey_list)
-{
-    LIBSSH2_SESSION *session;
-    libssh2_publickey_list *p = pkey_list;
-
-    if(!pkey || !p)
-        return;
-
-    session = pkey->channel->session;
-
-    while(p->packet) {
-        if(p->attrs) {
-            LIBSSH2_FREE(session, p->attrs);
-        }
-        LIBSSH2_FREE(session, p->packet);
-        p++;
-    }
-
-    LIBSSH2_FREE(session, pkey_list);
-}
-
-/* libssh2_publickey_shutdown
- * Shutdown the publickey subsystem
- */
-LIBSSH2_API int
-libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey)
-{
-    LIBSSH2_SESSION *session;
-    int rc;
-
-    if(!pkey)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    session = pkey->channel->session;
-
-    /*
-     * Make sure all memory used in the state variables are free
-     */
-    if(pkey->receive_packet) {
-        LIBSSH2_FREE(session, pkey->receive_packet);
-        pkey->receive_packet = NULL;
-    }
-    if(pkey->add_packet) {
-        LIBSSH2_FREE(session, pkey->add_packet);
-        pkey->add_packet = NULL;
-    }
-    if(pkey->remove_packet) {
-        LIBSSH2_FREE(session, pkey->remove_packet);
-        pkey->remove_packet = NULL;
-    }
-    if(pkey->listFetch_data) {
-        LIBSSH2_FREE(session, pkey->listFetch_data);
-        pkey->listFetch_data = NULL;
-    }
-
-    rc = _libssh2_channel_free(pkey->channel);
-    if(rc == LIBSSH2_ERROR_EAGAIN)
-        return rc;
-
-    LIBSSH2_FREE(session, pkey);
-    return 0;
-}
diff --git a/libssh2/libssh2/src/scp.c b/libssh2/libssh2/src/scp.c
deleted file mode 100644
index 8cb3d65c..00000000
--- a/libssh2/libssh2/src/scp.c
+++ /dev/null
@@ -1,1145 +0,0 @@
-/* Copyright (c) 2009-2019 by Daniel Stenberg
- * Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include <errno.h>
-#include <stdlib.h>
-
-#include "channel.h"
-#include "session.h"
-
-
-/* Max. length of a quoted string after libssh2_shell_quotearg() processing */
-#define _libssh2_shell_quotedsize(s)     (3 * strlen(s) + 2)
-
-/*
-  This function quotes a string in a way suitable to be used with a
-  shell, e.g. the file name
-  one two
-  becomes
-  'one two'
-
-  The resulting output string is crafted in a way that makes it usable
-  with the two most common shell types: Bourne Shell derived shells
-  (sh, ksh, ksh93, bash, zsh) and C-Shell derivates (csh, tcsh).
-
-  The following special cases are handled:
-  o  If the string contains an apostrophy itself, the apostrophy
-  character is written in quotation marks, e.g. "'".
-  The shell cannot handle the syntax 'doesn\'t', so we close the
-  current argument word, add the apostrophe in quotation marks "",
-  and open a new argument word instead (_ indicate the input
-  string characters):
-   _____   _   _
-  'doesn' "'" 't'
-
-  Sequences of apostrophes are combined in one pair of quotation marks:
-  a'''b
-  becomes
-   _  ___  _
-  'a'"'''"'b'
-
-  o  If the string contains an exclamation mark (!), the C-Shell
-  interprets it as an event number. Using \! (not within quotation
-  marks or single quotation marks) is a mechanism understood by
-  both Bourne Shell and C-Shell.
-
-  If a quotation was already started, the argument word is closed
-  first:
-  a!b
-
-  become
-   _  _ _
-  'a'\!'b'
-
-  The result buffer must be large enough for the expanded result. A
-  bad case regarding expansion is alternating characters and
-  apostrophes:
-
-  a'b'c'd'                   (length 8) gets converted to
-  'a'"'"'b'"'"'c'"'"'d'"'"   (length 24)
-
-  This is the worst case.
-
-  Maximum length of the result:
-  1 + 6 * (length(input) + 1) / 2) + 1
-
-  => 3 * length(input) + 2
-
-  Explanation:
-  o  leading apostrophe
-  o  one character / apostrophe pair (two characters) can get
-  represented as 6 characters: a' -> a'"'"'
-  o  String terminator (+1)
-
-  A result buffer three times the size of the input buffer + 2
-  characters should be safe.
-
-  References:
-  o  csh-compatible quotation (special handling for '!' etc.), see
-  http://www.grymoire.com/Unix/Csh.html#toc-uh-10
-
-  Return value:
-  Length of the resulting string (not counting the terminating '\0'),
-  or 0 in case of errors, e.g. result buffer too small
-
-  Note: this function could possible be used elsewhere within libssh2, but
-  until then it is kept static and in this source file.
-*/
-
-static unsigned
-shell_quotearg(const char *path, unsigned char *buf,
-               unsigned bufsize)
-{
-    const char *src;
-    unsigned char *dst, *endp;
-
-    /*
-     * Processing States:
-     *  UQSTRING:       unquoted string: ... -- used for quoting exclamation
-     *                  marks. This is the initial state
-     *  SQSTRING:       single-quoted-string: '... -- any character may follow
-     *  QSTRING:        quoted string: "... -- only apostrophes may follow
-     */
-    enum { UQSTRING, SQSTRING, QSTRING } state = UQSTRING;
-
-    endp = &buf[bufsize];
-    src = path;
-    dst = buf;
-    while(*src && dst < endp - 1) {
-
-        switch(*src) {
-            /*
-             * Special handling for apostrophe.
-             * An apostrophe is always written in quotation marks, e.g.
-             * ' -> "'".
-             */
-
-        case '\'':
-            switch(state) {
-            case UQSTRING:      /* Unquoted string */
-                if(dst + 1 >= endp)
-                    return 0;
-                *dst++ = '"';
-                break;
-            case QSTRING:       /* Continue quoted string */
-                break;
-            case SQSTRING:      /* Close single quoted string */
-                if(dst + 2 >= endp)
-                    return 0;
-                *dst++ = '\'';
-                *dst++ = '"';
-                break;
-            default:
-                break;
-            }
-            state = QSTRING;
-            break;
-
-            /*
-             * Special handling for exclamation marks. CSH interprets
-             * exclamation marks even when quoted with apostrophes. We convert
-             * it to the plain string \!, because both Bourne Shell and CSH
-             * interpret that as a verbatim exclamation mark.
-             */
-
-        case '!':
-            switch(state) {
-            case UQSTRING:
-                if(dst + 1 >= endp)
-                    return 0;
-                *dst++ = '\\';
-                break;
-            case QSTRING:
-                if(dst + 2 >= endp)
-                    return 0;
-                *dst++ = '"';           /* Closing quotation mark */
-                *dst++ = '\\';
-                break;
-            case SQSTRING:              /* Close single quoted string */
-                if(dst + 2 >= endp)
-                    return 0;
-                *dst++ = '\'';
-                *dst++ = '\\';
-                break;
-            default:
-                break;
-            }
-            state = UQSTRING;
-            break;
-
-            /*
-             * Ordinary character: prefer single-quoted string
-             */
-
-        default:
-            switch(state) {
-            case UQSTRING:
-                if(dst + 1 >= endp)
-                    return 0;
-                *dst++ = '\'';
-                break;
-            case QSTRING:
-                if(dst + 2 >= endp)
-                    return 0;
-                *dst++ = '"';           /* Closing quotation mark */
-                *dst++ = '\'';
-                break;
-            case SQSTRING:      /* Continue single quoted string */
-                break;
-            default:
-                break;
-            }
-            state = SQSTRING;   /* Start single-quoted string */
-            break;
-        }
-
-        if(dst + 1 >= endp)
-            return 0;
-        *dst++ = *src++;
-    }
-
-    switch(state) {
-    case UQSTRING:
-        break;
-    case QSTRING:           /* Close quoted string */
-        if(dst + 1 >= endp)
-            return 0;
-        *dst++ = '"';
-        break;
-    case SQSTRING:          /* Close single quoted string */
-        if(dst + 1 >= endp)
-            return 0;
-        *dst++ = '\'';
-        break;
-    default:
-        break;
-    }
-
-    if(dst + 1 >= endp)
-        return 0;
-    *dst = '\0';
-
-    /* The result cannot be larger than 3 * strlen(path) + 2 */
-    /* assert((dst - buf) <= (3 * (src - path) + 2)); */
-
-    return dst - buf;
-}
-
-/*
- * scp_recv
- *
- * Open a channel and request a remote file via SCP
- *
- */
-static LIBSSH2_CHANNEL *
-scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
-{
-    int cmd_len;
-    int rc;
-    int tmp_err_code;
-    const char *tmp_err_msg;
-
-    if(session->scpRecv_state == libssh2_NB_state_idle) {
-        session->scpRecv_mode = 0;
-        session->scpRecv_size = 0;
-        session->scpRecv_mtime = 0;
-        session->scpRecv_atime = 0;
-
-        session->scpRecv_command_len =
-            _libssh2_shell_quotedsize(path) + sizeof("scp -f ") + (sb?1:0);
-
-        session->scpRecv_command =
-            LIBSSH2_ALLOC(session, session->scpRecv_command_len);
-
-        if(!session->scpRecv_command) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate a command buffer for "
-                           "SCP session");
-            return NULL;
-        }
-
-        snprintf((char *)session->scpRecv_command,
-                 session->scpRecv_command_len,
-                 "scp -%sf ", sb?"p":"");
-
-        cmd_len = strlen((char *)session->scpRecv_command);
-        cmd_len += shell_quotearg(path,
-                                  &session->scpRecv_command[cmd_len],
-                                  session->scpRecv_command_len - cmd_len);
-
-        /* the command to exec should _not_ be NUL-terminated */
-        session->scpRecv_command_len = cmd_len;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                       "Opening channel for SCP receive");
-
-        session->scpRecv_state = libssh2_NB_state_created;
-    }
-
-    if(session->scpRecv_state == libssh2_NB_state_created) {
-        /* Allocate a channel */
-        session->scpRecv_channel =
-            _libssh2_channel_open(session, "session",
-                                  sizeof("session") - 1,
-                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
-                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
-                                  0);
-        if(!session->scpRecv_channel) {
-            if(libssh2_session_last_errno(session) !=
-                LIBSSH2_ERROR_EAGAIN) {
-                LIBSSH2_FREE(session, session->scpRecv_command);
-                session->scpRecv_command = NULL;
-                session->scpRecv_state = libssh2_NB_state_idle;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block starting up channel");
-            }
-            return NULL;
-        }
-
-        session->scpRecv_state = libssh2_NB_state_sent;
-    }
-
-    if(session->scpRecv_state == libssh2_NB_state_sent) {
-        /* Request SCP for the desired file */
-        rc = _libssh2_channel_process_startup(session->scpRecv_channel, "exec",
-                                              sizeof("exec") - 1,
-                                              (char *)session->scpRecv_command,
-                                              session->scpRecv_command_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block requesting SCP startup");
-            return NULL;
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, session->scpRecv_command);
-            session->scpRecv_command = NULL;
-            goto scp_recv_error;
-        }
-        LIBSSH2_FREE(session, session->scpRecv_command);
-        session->scpRecv_command = NULL;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sending initial wakeup");
-        /* SCP ACK */
-        session->scpRecv_response[0] = '\0';
-
-        session->scpRecv_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->scpRecv_state == libssh2_NB_state_sent1) {
-        rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                    session->scpRecv_response, 1);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block sending initial wakeup");
-            return NULL;
-        }
-        else if(rc != 1) {
-            goto scp_recv_error;
-        }
-
-        /* Parse SCP response */
-        session->scpRecv_response_len = 0;
-
-        session->scpRecv_state = libssh2_NB_state_sent2;
-    }
-
-    if((session->scpRecv_state == libssh2_NB_state_sent2)
-        || (session->scpRecv_state == libssh2_NB_state_sent3)) {
-        while(sb && (session->scpRecv_response_len <
-                      LIBSSH2_SCP_RESPONSE_BUFLEN)) {
-            unsigned char *s, *p;
-
-            if(session->scpRecv_state == libssh2_NB_state_sent2) {
-                rc = _libssh2_channel_read(session->scpRecv_channel, 0,
-                                           (char *) session->
-                                           scpRecv_response +
-                                           session->scpRecv_response_len, 1);
-                if(rc == LIBSSH2_ERROR_EAGAIN) {
-                    _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                   "Would block waiting for SCP response");
-                    return NULL;
-                }
-                else if(rc < 0) {
-                    /* error, give up */
-                    _libssh2_error(session, rc, "Failed reading SCP response");
-                    goto scp_recv_error;
-                }
-                else if(rc == 0)
-                    goto scp_recv_empty_channel;
-
-                session->scpRecv_response_len++;
-
-                if(session->scpRecv_response[0] != 'T') {
-                    size_t err_len;
-                    char *err_msg;
-
-                    /* there can be
-                       01 for warnings
-                       02 for errors
-
-                       The following string MUST be newline terminated
-                    */
-                    err_len =
-                        _libssh2_channel_packet_data_len(session->
-                                                         scpRecv_channel, 0);
-                    err_msg = LIBSSH2_ALLOC(session, err_len + 1);
-                    if(!err_msg) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Failed to get memory ");
-                        goto scp_recv_error;
-                    }
-
-                    /* Read the remote error message */
-                    (void)_libssh2_channel_read(session->scpRecv_channel, 0,
-                                                err_msg, err_len);
-                    /* If it failed for any reason, we ignore it anyway. */
-
-                    /* zero terminate the error */
-                    err_msg[err_len] = 0;
-
-                    _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                                   "got %02x %s", session->scpRecv_response[0],
-                                   err_msg);
-
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Failed to recv file");
-
-                    LIBSSH2_FREE(session, err_msg);
-                    goto scp_recv_error;
-                }
-
-                if((session->scpRecv_response_len > 1) &&
-                    ((session->
-                      scpRecv_response[session->scpRecv_response_len - 1] <
-                      '0')
-                     || (session->
-                         scpRecv_response[session->scpRecv_response_len - 1] >
-                         '9'))
-                    && (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        ' ')
-                    && (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        '\r')
-                    && (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        '\n')) {
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid data in SCP response");
-                    goto scp_recv_error;
-                }
-
-                if((session->scpRecv_response_len < 9)
-                    || (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        '\n')) {
-                    if(session->scpRecv_response_len ==
-                        LIBSSH2_SCP_RESPONSE_BUFLEN) {
-                        /* You had your chance */
-                        _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                       "Unterminated response from "
-                                       "SCP server");
-                        goto scp_recv_error;
-                    }
-                    /* Way too short to be an SCP response, or not done yet,
-                       short circuit */
-                    continue;
-                }
-
-                /* We're guaranteed not to go under response_len == 0 by the
-                   logic above */
-                while((session->
-                        scpRecv_response[session->scpRecv_response_len - 1] ==
-                        '\r')
-                       || (session->
-                           scpRecv_response[session->scpRecv_response_len -
-                                            1] == '\n'))
-                    session->scpRecv_response_len--;
-                session->scpRecv_response[session->scpRecv_response_len] =
-                    '\0';
-
-                if(session->scpRecv_response_len < 8) {
-                    /* EOL came too soon */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "too short");
-                    goto scp_recv_error;
-                }
-
-                s = session->scpRecv_response + 1;
-
-                p = (unsigned char *) strchr((char *) s, ' ');
-                if(!p || ((p - s) <= 0)) {
-                    /* No spaces or space in the wrong spot */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "malformed mtime");
-                    goto scp_recv_error;
-                }
-
-                *(p++) = '\0';
-                /* Make sure we don't get fooled by leftover values */
-                session->scpRecv_mtime = strtol((char *) s, NULL, 10);
-
-                s = (unsigned char *) strchr((char *) p, ' ');
-                if(!s || ((s - p) <= 0)) {
-                    /* No spaces or space in the wrong spot */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "malformed mtime.usec");
-                    goto scp_recv_error;
-                }
-
-                /* Ignore mtime.usec */
-                s++;
-                p = (unsigned char *) strchr((char *) s, ' ');
-                if(!p || ((p - s) <= 0)) {
-                    /* No spaces or space in the wrong spot */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "too short or malformed");
-                    goto scp_recv_error;
-                }
-
-                *p = '\0';
-                /* Make sure we don't get fooled by leftover values */
-                session->scpRecv_atime = strtol((char *) s, NULL, 10);
-
-                /* SCP ACK */
-                session->scpRecv_response[0] = '\0';
-
-                session->scpRecv_state = libssh2_NB_state_sent3;
-            }
-
-            if(session->scpRecv_state == libssh2_NB_state_sent3) {
-                rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                            session->scpRecv_response, 1);
-                if(rc == LIBSSH2_ERROR_EAGAIN) {
-                    _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                   "Would block waiting to send SCP ACK");
-                    return NULL;
-                }
-                else if(rc != 1) {
-                    goto scp_recv_error;
-                }
-
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                               "mtime = %ld, atime = %ld",
-                               session->scpRecv_mtime, session->scpRecv_atime);
-
-                /* We *should* check that atime.usec is valid, but why let
-                   that stop use? */
-                break;
-            }
-        }
-
-        session->scpRecv_state = libssh2_NB_state_sent4;
-    }
-
-    if(session->scpRecv_state == libssh2_NB_state_sent4) {
-        session->scpRecv_response_len = 0;
-
-        session->scpRecv_state = libssh2_NB_state_sent5;
-    }
-
-    if((session->scpRecv_state == libssh2_NB_state_sent5)
-        || (session->scpRecv_state == libssh2_NB_state_sent6)) {
-        while(session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) {
-            char *s, *p, *e = NULL;
-
-            if(session->scpRecv_state == libssh2_NB_state_sent5) {
-                rc = _libssh2_channel_read(session->scpRecv_channel, 0,
-                                           (char *) session->
-                                           scpRecv_response +
-                                           session->scpRecv_response_len, 1);
-                if(rc == LIBSSH2_ERROR_EAGAIN) {
-                    _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                   "Would block waiting for SCP response");
-                    return NULL;
-                }
-                else if(rc < 0) {
-                    /* error, bail out*/
-                    _libssh2_error(session, rc, "Failed reading SCP response");
-                    goto scp_recv_error;
-                }
-                else if(rc == 0)
-                    goto scp_recv_empty_channel;
-
-                session->scpRecv_response_len++;
-
-                if(session->scpRecv_response[0] != 'C') {
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server");
-                    goto scp_recv_error;
-                }
-
-                if((session->scpRecv_response_len > 1) &&
-                    (session->
-                     scpRecv_response[session->scpRecv_response_len - 1] !=
-                     '\r')
-                    && (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        '\n')
-                    &&
-                    (session->
-                     scpRecv_response[session->scpRecv_response_len - 1]
-                     < 32)) {
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid data in SCP response");
-                    goto scp_recv_error;
-                }
-
-                if((session->scpRecv_response_len < 7)
-                    || (session->
-                        scpRecv_response[session->scpRecv_response_len - 1] !=
-                        '\n')) {
-                    if(session->scpRecv_response_len ==
-                        LIBSSH2_SCP_RESPONSE_BUFLEN) {
-                        /* You had your chance */
-                        _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                       "Unterminated response "
-                                       "from SCP server");
-                        goto scp_recv_error;
-                    }
-                    /* Way too short to be an SCP response, or not done yet,
-                       short circuit */
-                    continue;
-                }
-
-                /* We're guaranteed not to go under response_len == 0 by the
-                   logic above */
-                while((session->
-                        scpRecv_response[session->scpRecv_response_len - 1] ==
-                        '\r')
-                       || (session->
-                           scpRecv_response[session->scpRecv_response_len -
-                                            1] == '\n')) {
-                    session->scpRecv_response_len--;
-                }
-                session->scpRecv_response[session->scpRecv_response_len] =
-                    '\0';
-
-                if(session->scpRecv_response_len < 6) {
-                    /* EOL came too soon */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "too short");
-                    goto scp_recv_error;
-                }
-
-                s = (char *) session->scpRecv_response + 1;
-
-                p = strchr(s, ' ');
-                if(!p || ((p - s) <= 0)) {
-                    /* No spaces or space in the wrong spot */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "malformed mode");
-                    goto scp_recv_error;
-                }
-
-                *(p++) = '\0';
-                /* Make sure we don't get fooled by leftover values */
-
-                session->scpRecv_mode = strtol(s, &e, 8);
-                if(e && *e) {
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "invalid mode");
-                    goto scp_recv_error;
-                }
-
-                s = strchr(p, ' ');
-                if(!s || ((s - p) <= 0)) {
-                    /* No spaces or space in the wrong spot */
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "too short or malformed");
-                    goto scp_recv_error;
-                }
-
-                *s = '\0';
-                /* Make sure we don't get fooled by leftover values */
-                session->scpRecv_size = scpsize_strtol(p, &e, 10);
-                if(e && *e) {
-                    _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                                   "Invalid response from SCP server, "
-                                   "invalid size");
-                    goto scp_recv_error;
-                }
-
-                /* SCP ACK */
-                session->scpRecv_response[0] = '\0';
-
-                session->scpRecv_state = libssh2_NB_state_sent6;
-            }
-
-            if(session->scpRecv_state == libssh2_NB_state_sent6) {
-                rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                            session->scpRecv_response, 1);
-                if(rc == LIBSSH2_ERROR_EAGAIN) {
-                    _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                   "Would block sending SCP ACK");
-                    return NULL;
-                }
-                else if(rc != 1) {
-                    goto scp_recv_error;
-                }
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                               "mode = 0%lo size = %ld", session->scpRecv_mode,
-                               session->scpRecv_size);
-
-                /* We *should* check that basename is valid, but why let that
-                   stop us? */
-                break;
-            }
-        }
-
-        session->scpRecv_state = libssh2_NB_state_sent7;
-    }
-
-    if(sb) {
-        memset(sb, 0, sizeof(libssh2_struct_stat));
-
-        sb->st_mtime = session->scpRecv_mtime;
-        sb->st_atime = session->scpRecv_atime;
-        sb->st_size = session->scpRecv_size;
-        sb->st_mode = (unsigned short)session->scpRecv_mode;
-    }
-
-    session->scpRecv_state = libssh2_NB_state_idle;
-    return session->scpRecv_channel;
-
-  scp_recv_empty_channel:
-    /* the code only jumps here as a result of a zero read from channel_read()
-       so we check EOF status to avoid getting stuck in a loop */
-    if(libssh2_channel_eof(session->scpRecv_channel))
-        _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                       "Unexpected channel close");
-    else
-        return session->scpRecv_channel;
-    /* fall-through */
-  scp_recv_error:
-    tmp_err_code = session->err_code;
-    tmp_err_msg = session->err_msg;
-    while(libssh2_channel_free(session->scpRecv_channel) ==
-           LIBSSH2_ERROR_EAGAIN);
-    session->err_code = tmp_err_code;
-    session->err_msg = tmp_err_msg;
-    session->scpRecv_channel = NULL;
-    session->scpRecv_state = libssh2_NB_state_idle;
-    return NULL;
-}
-
-/*
- * libssh2_scp_recv
- *
- * DEPRECATED
- *
- * Open a channel and request a remote file via SCP.  This receives files
- * larger than 2 GB, but is unable to report the proper size on platforms
- * where the st_size member of struct stat is limited to 2 GB (e.g. windows).
- *
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat * sb)
-{
-    LIBSSH2_CHANNEL *ptr;
-
-    /* scp_recv uses libssh2_struct_stat, so pass one if the caller gave us a
-       struct to populate... */
-    libssh2_struct_stat sb_intl;
-    libssh2_struct_stat *sb_ptr;
-    memset(&sb_intl, 0, sizeof(sb_intl));
-    sb_ptr = sb ? &sb_intl : NULL;
-
-    BLOCK_ADJUST_ERRNO(ptr, session, scp_recv(session, path, sb_ptr));
-
-    /* ...and populate the caller's with as much info as fits. */
-    if(sb) {
-        memset(sb, 0, sizeof(struct stat));
-
-        sb->st_mtime = sb_intl.st_mtime;
-        sb->st_atime = sb_intl.st_atime;
-        sb->st_size = (off_t)sb_intl.st_size;
-        sb->st_mode = sb_intl.st_mode;
-    }
-
-    return ptr;
-}
-
-/*
- * libssh2_scp_recv2
- *
- * Open a channel and request a remote file via SCP.  This supports files > 2GB
- * on platforms that support it.
- *
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_recv2(LIBSSH2_SESSION *session, const char *path,
-                  libssh2_struct_stat *sb)
-{
-    LIBSSH2_CHANNEL *ptr;
-    BLOCK_ADJUST_ERRNO(ptr, session, scp_recv(session, path, sb));
-    return ptr;
-}
-
-/*
- * scp_send()
- *
- * Send a file using SCP
- *
- */
-static LIBSSH2_CHANNEL *
-scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
-         libssh2_int64_t size, time_t mtime, time_t atime)
-{
-    int cmd_len;
-    int rc;
-    int tmp_err_code;
-    const char *tmp_err_msg;
-
-    if(session->scpSend_state == libssh2_NB_state_idle) {
-        session->scpSend_command_len =
-            _libssh2_shell_quotedsize(path) + sizeof("scp -t ") +
-            ((mtime || atime)?1:0);
-
-        session->scpSend_command =
-            LIBSSH2_ALLOC(session, session->scpSend_command_len);
-
-        if(!session->scpSend_command) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate a command buffer for "
-                           "SCP session");
-            return NULL;
-        }
-
-        snprintf((char *)session->scpSend_command,
-                 session->scpSend_command_len,
-                 "scp -%st ", (mtime || atime)?"p":"");
-
-        cmd_len = strlen((char *)session->scpSend_command);
-        cmd_len += shell_quotearg(path,
-                                  &session->scpSend_command[cmd_len],
-                                  session->scpSend_command_len - cmd_len);
-
-        /* the command to exec should _not_ be NUL-terminated */
-        session->scpSend_command_len = cmd_len;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                       "Opening channel for SCP send");
-        /* Allocate a channel */
-
-        session->scpSend_state = libssh2_NB_state_created;
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_created) {
-        session->scpSend_channel =
-            _libssh2_channel_open(session, "session", sizeof("session") - 1,
-                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
-                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
-        if(!session->scpSend_channel) {
-            if(libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
-                /* previous call set libssh2_session_last_error(), pass it
-                   through */
-                LIBSSH2_FREE(session, session->scpSend_command);
-                session->scpSend_command = NULL;
-                session->scpSend_state = libssh2_NB_state_idle;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block starting up channel");
-            }
-            return NULL;
-        }
-
-        session->scpSend_state = libssh2_NB_state_sent;
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_sent) {
-        /* Request SCP for the desired file */
-        rc = _libssh2_channel_process_startup(session->scpSend_channel, "exec",
-                                              sizeof("exec") - 1,
-                                              (char *)session->scpSend_command,
-                                              session->scpSend_command_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block requesting SCP startup");
-            return NULL;
-        }
-        else if(rc) {
-            /* previous call set libssh2_session_last_error(), pass it
-               through */
-            LIBSSH2_FREE(session, session->scpSend_command);
-            session->scpSend_command = NULL;
-            _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                           "Unknown error while getting error string");
-            goto scp_send_error;
-        }
-        LIBSSH2_FREE(session, session->scpSend_command);
-        session->scpSend_command = NULL;
-
-        session->scpSend_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_sent1) {
-        /* Wait for ACK */
-        rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                   (char *) session->scpSend_response, 1);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block waiting for response from remote");
-            return NULL;
-        }
-        else if(rc < 0) {
-            _libssh2_error(session, rc, "SCP failure");
-            goto scp_send_error;
-        }
-        else if(!rc)
-            /* remain in the same state */
-            goto scp_send_empty_channel;
-        else if(session->scpSend_response[0] != 0) {
-            _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                           "Invalid ACK response from remote");
-            goto scp_send_error;
-        }
-        if(mtime || atime) {
-            /* Send mtime and atime to be used for file */
-            session->scpSend_response_len =
-                snprintf((char *) session->scpSend_response,
-                         LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n",
-                         (long)mtime, (long)atime);
-            _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
-                           session->scpSend_response);
-        }
-
-        session->scpSend_state = libssh2_NB_state_sent2;
-    }
-
-    /* Send mtime and atime to be used for file */
-    if(mtime || atime) {
-        if(session->scpSend_state == libssh2_NB_state_sent2) {
-            rc = _libssh2_channel_write(session->scpSend_channel, 0,
-                                        session->scpSend_response,
-                                        session->scpSend_response_len);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block sending time data for SCP file");
-                return NULL;
-            }
-            else if(rc != (int)session->scpSend_response_len) {
-                _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                               "Unable to send time data for SCP file");
-                goto scp_send_error;
-            }
-
-            session->scpSend_state = libssh2_NB_state_sent3;
-        }
-
-        if(session->scpSend_state == libssh2_NB_state_sent3) {
-            /* Wait for ACK */
-            rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                       (char *) session->scpSend_response, 1);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block waiting for response");
-                return NULL;
-            }
-            else if(rc < 0) {
-                _libssh2_error(session, rc, "SCP failure");
-                goto scp_send_error;
-            }
-            else if(!rc)
-                /* remain in the same state */
-                goto scp_send_empty_channel;
-            else if(session->scpSend_response[0] != 0) {
-                _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                               "Invalid SCP ACK response");
-                goto scp_send_error;
-            }
-
-            session->scpSend_state = libssh2_NB_state_sent4;
-        }
-    }
-    else {
-        if(session->scpSend_state == libssh2_NB_state_sent2) {
-            session->scpSend_state = libssh2_NB_state_sent4;
-        }
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_sent4) {
-        /* Send mode, size, and basename */
-        const char *base = strrchr(path, '/');
-        if(base)
-            base++;
-        else
-            base = path;
-
-        session->scpSend_response_len =
-            snprintf((char *) session->scpSend_response,
-                     LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %"
-                     LIBSSH2_INT64_T_FORMAT " %s\n", mode,
-                     size, base);
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
-                       session->scpSend_response);
-
-        session->scpSend_state = libssh2_NB_state_sent5;
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_sent5) {
-        rc = _libssh2_channel_write(session->scpSend_channel, 0,
-                                    session->scpSend_response,
-                                    session->scpSend_response_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block send core file data for SCP file");
-            return NULL;
-        }
-        else if(rc != (int)session->scpSend_response_len) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send core file data for SCP file");
-            goto scp_send_error;
-        }
-
-        session->scpSend_state = libssh2_NB_state_sent6;
-    }
-
-    if(session->scpSend_state == libssh2_NB_state_sent6) {
-        /* Wait for ACK */
-        rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                   (char *) session->scpSend_response, 1);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block waiting for response");
-            return NULL;
-        }
-        else if(rc < 0) {
-            _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                           "Invalid ACK response from remote");
-            goto scp_send_error;
-        }
-        else if(rc == 0)
-            goto scp_send_empty_channel;
-
-        else if(session->scpSend_response[0] != 0) {
-            size_t err_len;
-            char *err_msg;
-
-            err_len =
-                _libssh2_channel_packet_data_len(session->scpSend_channel, 0);
-            err_msg = LIBSSH2_ALLOC(session, err_len + 1);
-            if(!err_msg) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "failed to get memory");
-                goto scp_send_error;
-            }
-
-            /* Read the remote error message */
-            rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                       err_msg, err_len);
-            if(rc > 0) {
-                err_msg[err_len] = 0;
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                               "got %02x %s", session->scpSend_response[0],
-                               err_msg);
-            }
-            LIBSSH2_FREE(session, err_msg);
-            _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                           "failed to send file");
-            goto scp_send_error;
-        }
-    }
-
-    session->scpSend_state = libssh2_NB_state_idle;
-    return session->scpSend_channel;
-
-  scp_send_empty_channel:
-    /* the code only jumps here as a result of a zero read from channel_read()
-       so we check EOF status to avoid getting stuck in a loop */
-    if(libssh2_channel_eof(session->scpSend_channel)) {
-        _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
-                       "Unexpected channel close");
-    }
-    else
-        return session->scpSend_channel;
-    /* fall-through */
-  scp_send_error:
-    tmp_err_code = session->err_code;
-    tmp_err_msg = session->err_msg;
-    while(libssh2_channel_free(session->scpSend_channel) ==
-          LIBSSH2_ERROR_EAGAIN);
-    session->err_code = tmp_err_code;
-    session->err_msg = tmp_err_msg;
-    session->scpSend_channel = NULL;
-    session->scpSend_state = libssh2_NB_state_idle;
-    return NULL;
-}
-
-/*
- * libssh2_scp_send_ex
- *
- * Send a file using SCP. Old API.
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_send_ex(LIBSSH2_SESSION *session, const char *path, int mode,
-                    size_t size, long mtime, long atime)
-{
-    LIBSSH2_CHANNEL *ptr;
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       scp_send(session, path, mode, size,
-                                (time_t)mtime, (time_t)atime));
-    return ptr;
-}
-
-/*
- * libssh2_scp_send64
- *
- * Send a file using SCP
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
-                   libssh2_int64_t size, time_t mtime, time_t atime)
-{
-    LIBSSH2_CHANNEL *ptr;
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       scp_send(session, path, mode, size, mtime, atime));
-    return ptr;
-}
diff --git a/libssh2/libssh2/src/session.c b/libssh2/libssh2/src/session.c
deleted file mode 100644
index 212560b8..00000000
--- a/libssh2/libssh2/src/session.c
+++ /dev/null
@@ -1,1832 +0,0 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2015 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-#include <errno.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <stdlib.h>
-#include <fcntl.h>
-
-#ifdef HAVE_GETTIMEOFDAY
-#include <sys/time.h>
-#endif
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include "transport.h"
-#include "session.h"
-#include "channel.h"
-#include "mac.h"
-#include "misc.h"
-
-/* libssh2_default_alloc
- */
-static
-LIBSSH2_ALLOC_FUNC(libssh2_default_alloc)
-{
-    (void) abstract;
-    return malloc(count);
-}
-
-/* libssh2_default_free
- */
-static
-LIBSSH2_FREE_FUNC(libssh2_default_free)
-{
-    (void) abstract;
-    free(ptr);
-}
-
-/* libssh2_default_realloc
- */
-static
-LIBSSH2_REALLOC_FUNC(libssh2_default_realloc)
-{
-    (void) abstract;
-    return realloc(ptr, count);
-}
-
-/*
- * banner_receive
- *
- * Wait for a hello from the remote host
- * Allocate a buffer and store the banner in session->remote.banner
- * Returns: 0 on success, LIBSSH2_ERROR_EAGAIN if read would block, negative
- * on failure
- */
-static int
-banner_receive(LIBSSH2_SESSION * session)
-{
-    int ret;
-    int banner_len;
-
-    if(session->banner_TxRx_state == libssh2_NB_state_idle) {
-        banner_len = 0;
-
-        session->banner_TxRx_state = libssh2_NB_state_created;
-    }
-    else {
-        banner_len = session->banner_TxRx_total_send;
-    }
-
-    while((banner_len < (int) sizeof(session->banner_TxRx_banner)) &&
-           ((banner_len == 0)
-            || (session->banner_TxRx_banner[banner_len - 1] != '\n'))) {
-        char c = '\0';
-
-        /* no incoming block yet! */
-        session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_INBOUND;
-
-        ret = LIBSSH2_RECV(session, &c, 1,
-                            LIBSSH2_SOCKET_RECV_FLAGS(session));
-        if(ret < 0) {
-            if(session->api_block_mode || (ret != -EAGAIN))
-                /* ignore EAGAIN when non-blocking */
-                _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                               "Error recving %d bytes: %d", 1, -ret);
-        }
-        else
-            _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                           "Recved %d bytes banner", ret);
-
-        if(ret < 0) {
-            if(ret == -EAGAIN) {
-                session->socket_block_directions =
-                    LIBSSH2_SESSION_BLOCK_INBOUND;
-                session->banner_TxRx_total_send = banner_len;
-                return LIBSSH2_ERROR_EAGAIN;
-            }
-
-            /* Some kinda error */
-            session->banner_TxRx_state = libssh2_NB_state_idle;
-            session->banner_TxRx_total_send = 0;
-            return LIBSSH2_ERROR_SOCKET_RECV;
-        }
-
-        if(ret == 0) {
-            session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
-            return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-        }
-
-        if(c == '\0') {
-            /* NULLs are not allowed in SSH banners */
-            session->banner_TxRx_state = libssh2_NB_state_idle;
-            session->banner_TxRx_total_send = 0;
-            return LIBSSH2_ERROR_BANNER_RECV;
-        }
-
-        session->banner_TxRx_banner[banner_len++] = c;
-    }
-
-    while(banner_len &&
-           ((session->banner_TxRx_banner[banner_len - 1] == '\n') ||
-            (session->banner_TxRx_banner[banner_len - 1] == '\r'))) {
-        banner_len--;
-    }
-
-    /* From this point on, we are done here */
-    session->banner_TxRx_state = libssh2_NB_state_idle;
-    session->banner_TxRx_total_send = 0;
-
-    if(!banner_len)
-        return LIBSSH2_ERROR_BANNER_RECV;
-
-    if(session->remote.banner)
-        LIBSSH2_FREE(session, session->remote.banner);
-
-    session->remote.banner = LIBSSH2_ALLOC(session, banner_len + 1);
-    if(!session->remote.banner) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Error allocating space for remote banner");
-    }
-    memcpy(session->remote.banner, session->banner_TxRx_banner, banner_len);
-    session->remote.banner[banner_len] = '\0';
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Received Banner: %s",
-                   session->remote.banner);
-    return LIBSSH2_ERROR_NONE;
-}
-
-/*
- * banner_send
- *
- * Send the default banner, or the one set via libssh2_setopt_string
- *
- * Returns LIBSSH2_ERROR_EAGAIN if it would block - and if it does so, you
- * should call this function again as soon as it is likely that more data can
- * be sent, and this function should then be called with the same argument set
- * (same data pointer and same data_len) until zero or failure is returned.
- */
-static int
-banner_send(LIBSSH2_SESSION * session)
-{
-    char *banner = (char *) LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF;
-    int banner_len = sizeof(LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF) - 1;
-    ssize_t ret;
-#ifdef LIBSSH2DEBUG
-    char banner_dup[256];
-#endif
-
-    if(session->banner_TxRx_state == libssh2_NB_state_idle) {
-        if(session->local.banner) {
-            /* setopt_string will have given us our \r\n characters */
-            banner_len = strlen((char *) session->local.banner);
-            banner = (char *) session->local.banner;
-        }
-#ifdef LIBSSH2DEBUG
-        /* Hack and slash to avoid sending CRLF in debug output */
-        if(banner_len < 256) {
-            memcpy(banner_dup, banner, banner_len - 2);
-            banner_dup[banner_len - 2] = '\0';
-        }
-        else {
-            memcpy(banner_dup, banner, 255);
-            banner_dup[255] = '\0';
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Sending Banner: %s",
-                       banner_dup);
-#endif
-
-        session->banner_TxRx_state = libssh2_NB_state_created;
-    }
-
-    /* no outgoing block yet! */
-    session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND;
-
-    ret = LIBSSH2_SEND(session,
-                        banner + session->banner_TxRx_total_send,
-                        banner_len - session->banner_TxRx_total_send,
-                        LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if(ret < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d",
-                       banner_len - session->banner_TxRx_total_send, -ret);
-    else
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Sent %d/%d bytes at %p+%d", ret,
-                       banner_len - session->banner_TxRx_total_send,
-                       banner, session->banner_TxRx_total_send);
-
-    if(ret != (banner_len - session->banner_TxRx_total_send)) {
-        if(ret >= 0 || ret == -EAGAIN) {
-            /* the whole packet could not be sent, save the what was */
-            session->socket_block_directions =
-                LIBSSH2_SESSION_BLOCK_OUTBOUND;
-            if(ret > 0)
-                session->banner_TxRx_total_send += ret;
-            return LIBSSH2_ERROR_EAGAIN;
-        }
-        session->banner_TxRx_state = libssh2_NB_state_idle;
-        session->banner_TxRx_total_send = 0;
-        return LIBSSH2_ERROR_SOCKET_RECV;
-    }
-
-    /* Set the state back to idle */
-    session->banner_TxRx_state = libssh2_NB_state_idle;
-    session->banner_TxRx_total_send = 0;
-
-    return 0;
-}
-
-/*
- * session_nonblock() sets the given socket to either blocking or
- * non-blocking mode based on the 'nonblock' boolean argument. This function
- * is copied from the libcurl sources with permission.
- */
-static int
-session_nonblock(libssh2_socket_t sockfd,   /* operate on this */
-                 int nonblock /* TRUE or FALSE */ )
-{
-#undef SETBLOCK
-#define SETBLOCK 0
-#ifdef HAVE_O_NONBLOCK
-    /* most recent unix versions */
-    int flags;
-
-    flags = fcntl(sockfd, F_GETFL, 0);
-    if(nonblock)
-        return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
-    else
-        return fcntl(sockfd, F_SETFL, flags & (~O_NONBLOCK));
-#undef SETBLOCK
-#define SETBLOCK 1
-#endif
-
-#if defined(HAVE_FIONBIO) && (SETBLOCK == 0)
-    /* older unix versions and VMS*/
-    int flags;
-
-    flags = nonblock;
-    return ioctl(sockfd, FIONBIO, &flags);
-#undef SETBLOCK
-#define SETBLOCK 2
-#endif
-
-#if defined(HAVE_IOCTLSOCKET) && (SETBLOCK == 0)
-    /* Windows? */
-    unsigned long flags;
-    flags = nonblock;
-
-    return ioctlsocket(sockfd, FIONBIO, &flags);
-#undef SETBLOCK
-#define SETBLOCK 3
-#endif
-
-#if defined(HAVE_IOCTLSOCKET_CASE) && (SETBLOCK == 0)
-    /* presumably for Amiga */
-    return IoctlSocket(sockfd, FIONBIO, (long) nonblock);
-#undef SETBLOCK
-#define SETBLOCK 4
-#endif
-
-#if defined(HAVE_SO_NONBLOCK) && (SETBLOCK == 0)
-    /* BeOS */
-    long b = nonblock ? 1 : 0;
-    return setsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-#undef SETBLOCK
-#define SETBLOCK 5
-#endif
-
-#ifdef HAVE_DISABLED_NONBLOCKING
-    return 0;                   /* returns success */
-#undef SETBLOCK
-#define SETBLOCK 6
-#endif
-
-#if(SETBLOCK == 0)
-#error "no non-blocking method was found/used/set"
-#endif
-}
-
-/*
- * get_socket_nonblocking()
- *
- * gets the given blocking or non-blocking state of the socket.
- */
-static int
-get_socket_nonblocking(int sockfd)
-{                               /* operate on this */
-#undef GETBLOCK
-#define GETBLOCK 0
-#ifdef HAVE_O_NONBLOCK
-    /* most recent unix versions */
-    int flags = fcntl(sockfd, F_GETFL, 0);
-
-    if(flags == -1) {
-        /* Assume blocking on error */
-        return 1;
-    }
-    return (flags & O_NONBLOCK);
-#undef GETBLOCK
-#define GETBLOCK 1
-#endif
-
-#if defined(WSAEWOULDBLOCK) && (GETBLOCK == 0)
-    /* Windows? */
-    unsigned int option_value;
-    socklen_t option_len = sizeof(option_value);
-
-    if(getsockopt
-        (sockfd, SOL_SOCKET, SO_ERROR, (void *) &option_value, &option_len)) {
-        /* Assume blocking on error */
-        return 1;
-    }
-    return (int) option_value;
-#undef GETBLOCK
-#define GETBLOCK 2
-#endif
-
-#if defined(HAVE_SO_NONBLOCK) && (GETBLOCK == 0)
-    /* BeOS */
-    long b;
-    if(getsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b))) {
-        /* Assume blocking on error */
-        return 1;
-    }
-    return (int) b;
-#undef GETBLOCK
-#define GETBLOCK 5
-#endif
-
-#if defined(SO_STATE) && defined(__VMS) && (GETBLOCK == 0)
-
-    /* VMS TCP/IP Services */
-
-    size_t sockstat = 0;
-    int    callstat = 0;
-    size_t size = sizeof(int);
-
-    callstat = getsockopt(sockfd, SOL_SOCKET, SO_STATE,
-                                  (char *)&sockstat, &size);
-    if(callstat == -1) return 0;
-    if((sockstat&SS_NBIO) != 0) return 1;
-    return 0;
-
-#undef GETBLOCK
-#define GETBLOCK 6
-#endif
-
-#ifdef HAVE_DISABLED_NONBLOCKING
-    return 1;                   /* returns blocking */
-#undef GETBLOCK
-#define GETBLOCK 7
-#endif
-
-#if(GETBLOCK == 0)
-#error "no non-blocking method was found/used/get"
-#endif
-}
-
-/* libssh2_session_banner_set
- * Set the local banner to use in the server handshake.
- */
-LIBSSH2_API int
-libssh2_session_banner_set(LIBSSH2_SESSION * session, const char *banner)
-{
-    size_t banner_len = banner ? strlen(banner) : 0;
-
-    if(session->local.banner) {
-        LIBSSH2_FREE(session, session->local.banner);
-        session->local.banner = NULL;
-    }
-
-    if(!banner_len)
-        return 0;
-
-    session->local.banner = LIBSSH2_ALLOC(session, banner_len + 3);
-    if(!session->local.banner) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for local banner");
-    }
-
-    memcpy(session->local.banner, banner, banner_len);
-
-    /* first zero terminate like this so that the debug output is nice */
-    session->local.banner[banner_len] = '\0';
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting local Banner: %s",
-                   session->local.banner);
-    session->local.banner[banner_len++] = '\r';
-    session->local.banner[banner_len++] = '\n';
-    session->local.banner[banner_len] = '\0';
-
-    return 0;
-}
-
-/* libssh2_banner_set
- * Set the local banner. DEPRECATED VERSION
- */
-LIBSSH2_API int
-libssh2_banner_set(LIBSSH2_SESSION * session, const char *banner)
-{
-    return libssh2_session_banner_set(session, banner);
-}
-
-/*
- * libssh2_session_init_ex
- *
- * Allocate and initialize a libssh2 session structure. Allows for malloc
- * callbacks in case the calling program has its own memory manager It's
- * allowable (but unadvisable) to define some but not all of the malloc
- * callbacks An additional pointer value may be optionally passed to be sent
- * to the callbacks (so they know who's asking)
- */
-LIBSSH2_API LIBSSH2_SESSION *
-libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
-                        LIBSSH2_FREE_FUNC((*my_free)),
-                        LIBSSH2_REALLOC_FUNC((*my_realloc)), void *abstract)
-{
-    LIBSSH2_ALLOC_FUNC((*local_alloc)) = libssh2_default_alloc;
-    LIBSSH2_FREE_FUNC((*local_free)) = libssh2_default_free;
-    LIBSSH2_REALLOC_FUNC((*local_realloc)) = libssh2_default_realloc;
-    LIBSSH2_SESSION *session;
-
-    if(my_alloc) {
-        local_alloc = my_alloc;
-    }
-    if(my_free) {
-        local_free = my_free;
-    }
-    if(my_realloc) {
-        local_realloc = my_realloc;
-    }
-
-    session = local_alloc(sizeof(LIBSSH2_SESSION), &abstract);
-    if(session) {
-        memset(session, 0, sizeof(LIBSSH2_SESSION));
-        session->alloc = local_alloc;
-        session->free = local_free;
-        session->realloc = local_realloc;
-        session->send = _libssh2_send;
-        session->recv = _libssh2_recv;
-        session->abstract = abstract;
-        session->api_timeout = 0; /* timeout-free API by default */
-        session->api_block_mode = 1; /* blocking API by default */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "New session resource allocated");
-        _libssh2_init_if_needed();
-    }
-    return session;
-}
-
-/*
- * libssh2_session_callback_set
- *
- * Set (or reset) a callback function
- * Returns the prior address
- *
- * ALERT: this function relies on that we can typecast function pointers
- * to void pointers, which isn't allowed in ISO C!
- */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-LIBSSH2_API void *
-libssh2_session_callback_set(LIBSSH2_SESSION * session,
-                             int cbtype, void *callback)
-{
-    void *oldcb;
-
-    switch(cbtype) {
-    case LIBSSH2_CALLBACK_IGNORE:
-        oldcb = session->ssh_msg_ignore;
-        session->ssh_msg_ignore = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_DEBUG:
-        oldcb = session->ssh_msg_debug;
-        session->ssh_msg_debug = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_DISCONNECT:
-        oldcb = session->ssh_msg_disconnect;
-        session->ssh_msg_disconnect = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_MACERROR:
-        oldcb = session->macerror;
-        session->macerror = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_X11:
-        oldcb = session->x11;
-        session->x11 = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_SEND:
-        oldcb = session->send;
-        session->send = callback;
-        return oldcb;
-
-    case LIBSSH2_CALLBACK_RECV:
-        oldcb = session->recv;
-        session->recv = callback;
-        return oldcb;
-    }
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting Callback %d",
-                   cbtype);
-
-    return NULL;
-}
-#pragma GCC diagnostic pop
-
-/*
- * _libssh2_wait_socket()
- *
- * Utility function that waits for action on the socket. Returns 0 when ready
- * to run again or error on timeout.
- */
-int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
-{
-    int rc;
-    int seconds_to_next;
-    int dir;
-    int has_timeout;
-    long ms_to_next = 0;
-    long elapsed_ms;
-
-    /* since libssh2 often sets EAGAIN internally before this function is
-       called, we can decrease some amount of confusion in user programs by
-       resetting the error code in this function to reduce the risk of EAGAIN
-       being stored as error when a blocking function has returned */
-    session->err_code = LIBSSH2_ERROR_NONE;
-
-    rc = libssh2_keepalive_send(session, &seconds_to_next);
-    if(rc)
-        return rc;
-
-    ms_to_next = seconds_to_next * 1000;
-
-    /* figure out what to wait for */
-    dir = libssh2_session_block_directions(session);
-
-    if(!dir) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Nothing to wait for in wait_socket");
-        /* To avoid that we hang below just because there's nothing set to
-           wait for, we timeout on 1 second to also avoid busy-looping
-           during this condition */
-        ms_to_next = 1000;
-    }
-
-    if(session->api_timeout > 0 &&
-        (seconds_to_next == 0 ||
-         ms_to_next > session->api_timeout)) {
-        time_t now = time(NULL);
-        elapsed_ms = (long)(1000*difftime(now, start_time));
-        if(elapsed_ms > session->api_timeout) {
-            return _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
-                                  "API timeout expired");
-        }
-        ms_to_next = (session->api_timeout - elapsed_ms);
-        has_timeout = 1;
-    }
-    else if(ms_to_next > 0) {
-        has_timeout = 1;
-    }
-    else
-        has_timeout = 0;
-
-#ifdef HAVE_POLL
-    {
-        struct pollfd sockets[1];
-
-        sockets[0].fd = session->socket_fd;
-        sockets[0].events = 0;
-        sockets[0].revents = 0;
-
-        if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
-            sockets[0].events |= POLLIN;
-
-        if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
-            sockets[0].events |= POLLOUT;
-
-        rc = poll(sockets, 1, has_timeout?ms_to_next: -1);
-    }
-#else
-    {
-        fd_set rfd;
-        fd_set wfd;
-        fd_set *writefd = NULL;
-        fd_set *readfd = NULL;
-        struct timeval tv;
-
-        tv.tv_sec = ms_to_next / 1000;
-        tv.tv_usec = (ms_to_next - tv.tv_sec*1000) * 1000;
-
-        if(dir & LIBSSH2_SESSION_BLOCK_INBOUND) {
-            FD_ZERO(&rfd);
-            FD_SET(session->socket_fd, &rfd);
-            readfd = &rfd;
-        }
-
-        if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
-            FD_ZERO(&wfd);
-            FD_SET(session->socket_fd, &wfd);
-            writefd = &wfd;
-        }
-
-        rc = select(session->socket_fd + 1, readfd, writefd, NULL,
-                    has_timeout ? &tv : NULL);
-    }
-#endif
-    if(rc == 0) {
-        return _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
-                              "Timed out waiting on socket");
-    }
-    if(rc < 0) {
-        return _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
-                              "Error waiting on socket");
-    }
-
-    return 0; /* ready to try again */
-}
-
-static int
-session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
-{
-    int rc;
-
-    if(session->startup_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "session_startup for socket %d", sock);
-        if(LIBSSH2_INVALID_SOCKET == sock) {
-            /* Did we forget something? */
-            return _libssh2_error(session, LIBSSH2_ERROR_BAD_SOCKET,
-                                  "Bad socket provided");
-        }
-        session->socket_fd = sock;
-
-        session->socket_prev_blockstate =
-            !get_socket_nonblocking(session->socket_fd);
-
-        if(session->socket_prev_blockstate) {
-            /* If in blocking state change to non-blocking */
-            rc = session_nonblock(session->socket_fd, 1);
-            if(rc) {
-                return _libssh2_error(session, rc,
-                                      "Failed changing socket's "
-                                      "blocking state to non-blocking");
-            }
-        }
-
-        session->startup_state = libssh2_NB_state_created;
-    }
-
-    if(session->startup_state == libssh2_NB_state_created) {
-        rc = banner_send(session);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-        else if(rc) {
-            return _libssh2_error(session, rc,
-                                  "Failed sending banner");
-        }
-        session->startup_state = libssh2_NB_state_sent;
-        session->banner_TxRx_state = libssh2_NB_state_idle;
-    }
-
-    if(session->startup_state == libssh2_NB_state_sent) {
-        do {
-            rc = banner_receive(session);
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
-            else if(rc)
-                return _libssh2_error(session, rc,
-                                      "Failed getting banner");
-        } while(strncmp("SSH-", (char *)session->remote.banner, 4));
-
-        session->startup_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->startup_state == libssh2_NB_state_sent1) {
-        rc = _libssh2_kex_exchange(session, 0, &session->startup_key_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-        else if(rc)
-            return _libssh2_error(session, rc,
-                                  "Unable to exchange encryption keys");
-
-        session->startup_state = libssh2_NB_state_sent2;
-    }
-
-    if(session->startup_state == libssh2_NB_state_sent2) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Requesting userauth service");
-
-        /* Request the userauth service */
-        session->startup_service[0] = SSH_MSG_SERVICE_REQUEST;
-        _libssh2_htonu32(session->startup_service + 1,
-                         sizeof("ssh-userauth") - 1);
-        memcpy(session->startup_service + 5, "ssh-userauth",
-               sizeof("ssh-userauth") - 1);
-
-        session->startup_state = libssh2_NB_state_sent3;
-    }
-
-    if(session->startup_state == libssh2_NB_state_sent3) {
-        rc = _libssh2_transport_send(session, session->startup_service,
-                                     sizeof("ssh-userauth") + 5 - 1,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-        else if(rc) {
-            return _libssh2_error(session, rc,
-                                  "Unable to ask for ssh-userauth service");
-        }
-
-        session->startup_state = libssh2_NB_state_sent4;
-    }
-
-    if(session->startup_state == libssh2_NB_state_sent4) {
-        rc = _libssh2_packet_require(session, SSH_MSG_SERVICE_ACCEPT,
-                                     &session->startup_data,
-                                     &session->startup_data_len, 0, NULL, 0,
-                                     &session->startup_req_state);
-        if(rc)
-            return rc;
-
-        if(session->startup_data_len < 5) {
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Unexpected packet length");
-        }
-
-        session->startup_service_length =
-            _libssh2_ntohu32(session->startup_data + 1);
-
-
-        if((session->startup_service_length != (sizeof("ssh-userauth") - 1))
-            || strncmp("ssh-userauth", (char *) session->startup_data + 5,
-                       session->startup_service_length)) {
-            LIBSSH2_FREE(session, session->startup_data);
-            session->startup_data = NULL;
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Invalid response received from server");
-        }
-        LIBSSH2_FREE(session, session->startup_data);
-        session->startup_data = NULL;
-
-        session->startup_state = libssh2_NB_state_idle;
-
-        return 0;
-    }
-
-    /* just for safety return some error */
-    return LIBSSH2_ERROR_INVAL;
-}
-
-/*
- * libssh2_session_handshake()
- *
- * session: LIBSSH2_SESSION struct allocated and owned by the calling program
- * sock:    *must* be populated with an opened and connected socket.
- *
- * Returns: 0 on success, or non-zero on failure
- */
-LIBSSH2_API int
-libssh2_session_handshake(LIBSSH2_SESSION *session, libssh2_socket_t sock)
-{
-    int rc;
-
-    BLOCK_ADJUST(rc, session, session_startup(session, sock) );
-
-    return rc;
-}
-
-/*
- * libssh2_session_startup()
- *
- * DEPRECATED. Use libssh2_session_handshake() instead! This function is not
- * portable enough.
- *
- * session: LIBSSH2_SESSION struct allocated and owned by the calling program
- * sock:    *must* be populated with an opened and connected socket.
- *
- * Returns: 0 on success, or non-zero on failure
- */
-LIBSSH2_API int
-libssh2_session_startup(LIBSSH2_SESSION *session, int sock)
-{
-    return libssh2_session_handshake(session, (libssh2_socket_t) sock);
-}
-
-/*
- * libssh2_session_free
- *
- * Frees the memory allocated to the session
- * Also closes and frees any channels attached to this session
- */
-static int
-session_free(LIBSSH2_SESSION *session)
-{
-    int rc;
-    LIBSSH2_PACKET *pkg;
-    LIBSSH2_CHANNEL *ch;
-    LIBSSH2_LISTENER *l;
-    int packets_left = 0;
-
-    if(session->free_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Freeing session resource",
-                       session->remote.banner);
-
-        session->free_state = libssh2_NB_state_created;
-    }
-
-    if(session->free_state == libssh2_NB_state_created) {
-        while((ch = _libssh2_list_first(&session->channels))) {
-
-            rc = _libssh2_channel_free(ch);
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
-        }
-
-        session->free_state = libssh2_NB_state_sent;
-    }
-
-    if(session->free_state == libssh2_NB_state_sent) {
-        while((l = _libssh2_list_first(&session->listeners))) {
-            rc = _libssh2_channel_forward_cancel(l);
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
-        }
-
-        session->free_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->state & LIBSSH2_STATE_NEWKEYS) {
-        /* hostkey */
-        if(session->hostkey && session->hostkey->dtor) {
-            session->hostkey->dtor(session, &session->server_hostkey_abstract);
-        }
-
-        /* Client to Server */
-        /* crypt */
-        if(session->local.crypt && session->local.crypt->dtor) {
-            session->local.crypt->dtor(session,
-                                       &session->local.crypt_abstract);
-        }
-        /* comp */
-        if(session->local.comp && session->local.comp->dtor) {
-            session->local.comp->dtor(session, 1,
-                                      &session->local.comp_abstract);
-        }
-        /* mac */
-        if(session->local.mac && session->local.mac->dtor) {
-            session->local.mac->dtor(session, &session->local.mac_abstract);
-        }
-
-        /* Server to Client */
-        /* crypt */
-        if(session->remote.crypt && session->remote.crypt->dtor) {
-            session->remote.crypt->dtor(session,
-                                        &session->remote.crypt_abstract);
-        }
-        /* comp */
-        if(session->remote.comp && session->remote.comp->dtor) {
-            session->remote.comp->dtor(session, 0,
-                                       &session->remote.comp_abstract);
-        }
-        /* mac */
-        if(session->remote.mac && session->remote.mac->dtor) {
-            session->remote.mac->dtor(session, &session->remote.mac_abstract);
-        }
-
-        /* session_id */
-        if(session->session_id) {
-            LIBSSH2_FREE(session, session->session_id);
-        }
-    }
-
-    /* Free banner(s) */
-    if(session->remote.banner) {
-        LIBSSH2_FREE(session, session->remote.banner);
-    }
-    if(session->local.banner) {
-        LIBSSH2_FREE(session, session->local.banner);
-    }
-
-    /* Free preference(s) */
-    if(session->kex_prefs) {
-        LIBSSH2_FREE(session, session->kex_prefs);
-    }
-    if(session->hostkey_prefs) {
-        LIBSSH2_FREE(session, session->hostkey_prefs);
-    }
-
-    if(session->local.kexinit) {
-        LIBSSH2_FREE(session, session->local.kexinit);
-    }
-    if(session->local.crypt_prefs) {
-        LIBSSH2_FREE(session, session->local.crypt_prefs);
-    }
-    if(session->local.mac_prefs) {
-        LIBSSH2_FREE(session, session->local.mac_prefs);
-    }
-    if(session->local.comp_prefs) {
-        LIBSSH2_FREE(session, session->local.comp_prefs);
-    }
-    if(session->local.lang_prefs) {
-        LIBSSH2_FREE(session, session->local.lang_prefs);
-    }
-
-    if(session->remote.kexinit) {
-        LIBSSH2_FREE(session, session->remote.kexinit);
-    }
-    if(session->remote.crypt_prefs) {
-        LIBSSH2_FREE(session, session->remote.crypt_prefs);
-    }
-    if(session->remote.mac_prefs) {
-        LIBSSH2_FREE(session, session->remote.mac_prefs);
-    }
-    if(session->remote.comp_prefs) {
-        LIBSSH2_FREE(session, session->remote.comp_prefs);
-    }
-    if(session->remote.lang_prefs) {
-        LIBSSH2_FREE(session, session->remote.lang_prefs);
-    }
-
-    /*
-     * Make sure all memory used in the state variables are free
-     */
-    if(session->kexinit_data) {
-        LIBSSH2_FREE(session, session->kexinit_data);
-    }
-    if(session->startup_data) {
-        LIBSSH2_FREE(session, session->startup_data);
-    }
-    if(session->userauth_list_data) {
-        LIBSSH2_FREE(session, session->userauth_list_data);
-    }
-    if(session->userauth_pswd_data) {
-        LIBSSH2_FREE(session, session->userauth_pswd_data);
-    }
-    if(session->userauth_pswd_newpw) {
-        LIBSSH2_FREE(session, session->userauth_pswd_newpw);
-    }
-    if(session->userauth_host_packet) {
-        LIBSSH2_FREE(session, session->userauth_host_packet);
-    }
-    if(session->userauth_host_method) {
-        LIBSSH2_FREE(session, session->userauth_host_method);
-    }
-    if(session->userauth_host_data) {
-        LIBSSH2_FREE(session, session->userauth_host_data);
-    }
-    if(session->userauth_pblc_data) {
-        LIBSSH2_FREE(session, session->userauth_pblc_data);
-    }
-    if(session->userauth_pblc_packet) {
-        LIBSSH2_FREE(session, session->userauth_pblc_packet);
-    }
-    if(session->userauth_pblc_method) {
-        LIBSSH2_FREE(session, session->userauth_pblc_method);
-    }
-    if(session->userauth_kybd_data) {
-        LIBSSH2_FREE(session, session->userauth_kybd_data);
-    }
-    if(session->userauth_kybd_packet) {
-        LIBSSH2_FREE(session, session->userauth_kybd_packet);
-    }
-    if(session->userauth_kybd_auth_instruction) {
-        LIBSSH2_FREE(session, session->userauth_kybd_auth_instruction);
-    }
-    if(session->open_packet) {
-        LIBSSH2_FREE(session, session->open_packet);
-    }
-    if(session->open_data) {
-        LIBSSH2_FREE(session, session->open_data);
-    }
-    if(session->direct_message) {
-        LIBSSH2_FREE(session, session->direct_message);
-    }
-    if(session->fwdLstn_packet) {
-        LIBSSH2_FREE(session, session->fwdLstn_packet);
-    }
-    if(session->pkeyInit_data) {
-        LIBSSH2_FREE(session, session->pkeyInit_data);
-    }
-    if(session->scpRecv_command) {
-        LIBSSH2_FREE(session, session->scpRecv_command);
-    }
-    if(session->scpSend_command) {
-        LIBSSH2_FREE(session, session->scpSend_command);
-    }
-    if(session->sftpInit_sftp) {
-        LIBSSH2_FREE(session, session->sftpInit_sftp);
-    }
-
-    /* Free payload buffer */
-    if(session->packet.total_num) {
-        LIBSSH2_FREE(session, session->packet.payload);
-    }
-
-    /* Cleanup all remaining packets */
-    while((pkg = _libssh2_list_first(&session->packets))) {
-        packets_left++;
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-            "packet left with id %d", pkg->data[0]);
-        /* unlink the node */
-        _libssh2_list_remove(&pkg->node);
-
-        /* free */
-        LIBSSH2_FREE(session, pkg->data);
-        LIBSSH2_FREE(session, pkg);
-    }
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-         "Extra packets left %d", packets_left);
-
-    if(session->socket_prev_blockstate) {
-        /* if the socket was previously blocking, put it back so */
-        rc = session_nonblock(session->socket_fd, 0);
-        if(rc) {
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-             "unable to reset socket's blocking state");
-        }
-    }
-
-    if(session->server_hostkey) {
-        LIBSSH2_FREE(session, session->server_hostkey);
-    }
-
-    /* error string */
-    if(session->err_msg &&
-       ((session->err_flags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
-        LIBSSH2_FREE(session, (char *)session->err_msg);
-    }
-
-    LIBSSH2_FREE(session, session);
-
-    return 0;
-}
-
-/*
- * libssh2_session_free
- *
- * Frees the memory allocated to the session
- * Also closes and frees any channels attached to this session
- */
-LIBSSH2_API int
-libssh2_session_free(LIBSSH2_SESSION * session)
-{
-    int rc;
-
-    BLOCK_ADJUST(rc, session, session_free(session) );
-
-    return rc;
-}
-
-/*
- * libssh2_session_disconnect_ex
- */
-static int
-session_disconnect(LIBSSH2_SESSION *session, int reason,
-                   const char *description,
-                   const char *lang)
-{
-    unsigned char *s;
-    unsigned long descr_len = 0, lang_len = 0;
-    int rc;
-
-    if(session->disconnect_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Disconnecting: reason=%d, desc=%s, lang=%s", reason,
-                       description, lang);
-        if(description)
-            descr_len = strlen(description);
-
-        if(lang)
-            lang_len = strlen(lang);
-
-        if(descr_len > 256)
-            return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                                  "too long description");
-
-        /* 13 = packet_type(1) + reason code(4) + descr_len(4) + lang_len(4) */
-        session->disconnect_data_len = descr_len + lang_len + 13;
-
-        s = session->disconnect_data;
-
-        *(s++) = SSH_MSG_DISCONNECT;
-        _libssh2_store_u32(&s, reason);
-        _libssh2_store_str(&s, description, descr_len);
-        /* store length only, lang is sent separately */
-        _libssh2_store_u32(&s, lang_len);
-
-        session->disconnect_state = libssh2_NB_state_created;
-    }
-
-    rc = _libssh2_transport_send(session, session->disconnect_data,
-                                 session->disconnect_data_len,
-                                 (unsigned char *)lang, lang_len);
-    if(rc == LIBSSH2_ERROR_EAGAIN)
-        return rc;
-
-    session->disconnect_state = libssh2_NB_state_idle;
-
-    return 0;
-}
-
-/*
- * libssh2_session_disconnect_ex
- */
-LIBSSH2_API int
-libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason,
-                              const char *desc, const char *lang)
-{
-    int rc;
-    session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
-    BLOCK_ADJUST(rc, session,
-                 session_disconnect(session, reason, desc, lang));
-
-    return rc;
-}
-
-/* libssh2_session_methods
- *
- * Return the currently active methods for method_type
- *
- * NOTE: Currently lang_cs and lang_sc are ALWAYS set to empty string
- * regardless of actual negotiation Strings should NOT be freed
- */
-LIBSSH2_API const char *
-libssh2_session_methods(LIBSSH2_SESSION * session, int method_type)
-{
-    /* All methods have char *name as their first element */
-    const LIBSSH2_KEX_METHOD *method = NULL;
-
-    switch(method_type) {
-    case LIBSSH2_METHOD_KEX:
-        method = session->kex;
-        break;
-
-    case LIBSSH2_METHOD_HOSTKEY:
-        method = (LIBSSH2_KEX_METHOD *) session->hostkey;
-        break;
-
-    case LIBSSH2_METHOD_CRYPT_CS:
-        method = (LIBSSH2_KEX_METHOD *) session->local.crypt;
-        break;
-
-    case LIBSSH2_METHOD_CRYPT_SC:
-        method = (LIBSSH2_KEX_METHOD *) session->remote.crypt;
-        break;
-
-    case LIBSSH2_METHOD_MAC_CS:
-        method = (LIBSSH2_KEX_METHOD *) session->local.mac;
-        break;
-
-    case LIBSSH2_METHOD_MAC_SC:
-        method = (LIBSSH2_KEX_METHOD *) session->remote.mac;
-        break;
-
-    case LIBSSH2_METHOD_COMP_CS:
-        method = (LIBSSH2_KEX_METHOD *) session->local.comp;
-        break;
-
-    case LIBSSH2_METHOD_COMP_SC:
-        method = (LIBSSH2_KEX_METHOD *) session->remote.comp;
-        break;
-
-    case LIBSSH2_METHOD_LANG_CS:
-        return "";
-
-    case LIBSSH2_METHOD_LANG_SC:
-        return "";
-
-    default:
-        _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                       "Invalid parameter specified for method_type");
-        return NULL;
-    }
-
-    if(!method) {
-        _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
-                       "No method negotiated");
-        return NULL;
-    }
-
-    return method->name;
-}
-
-/* libssh2_session_abstract
- * Retrieve a pointer to the abstract property
- */
-LIBSSH2_API void **
-libssh2_session_abstract(LIBSSH2_SESSION * session)
-{
-    return &session->abstract;
-}
-
-/* libssh2_session_last_error
- *
- * Returns error code and populates an error string into errmsg If want_buf is
- * non-zero then the string placed into errmsg must be freed by the calling
- * program. Otherwise it is assumed to be owned by libssh2
- */
-LIBSSH2_API int
-libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg,
-                           int *errmsg_len, int want_buf)
-{
-    size_t msglen = 0;
-
-    /* No error to report */
-    if(!session->err_code) {
-        if(errmsg) {
-            if(want_buf) {
-                *errmsg = LIBSSH2_ALLOC(session, 1);
-                if(*errmsg) {
-                    **errmsg = 0;
-                }
-            }
-            else {
-                *errmsg = (char *) "";
-            }
-        }
-        if(errmsg_len) {
-            *errmsg_len = 0;
-        }
-        return 0;
-    }
-
-    if(errmsg) {
-        const char *error = session->err_msg ? session->err_msg : "";
-
-        msglen = strlen(error);
-
-        if(want_buf) {
-            /* Make a copy so the calling program can own it */
-            *errmsg = LIBSSH2_ALLOC(session, msglen + 1);
-            if(*errmsg) {
-                memcpy(*errmsg, error, msglen);
-                (*errmsg)[msglen] = 0;
-            }
-        }
-        else
-            *errmsg = (char *)error;
-    }
-
-    if(errmsg_len) {
-        *errmsg_len = msglen;
-    }
-
-    return session->err_code;
-}
-
-/* libssh2_session_last_errno
- *
- * Returns error code
- */
-LIBSSH2_API int
-libssh2_session_last_errno(LIBSSH2_SESSION * session)
-{
-    return session->err_code;
-}
-
-/* libssh2_session_set_last_error
- *
- * Sets the internal error code for the session.
- *
- * This function is available specifically to be used by high level
- * language wrappers (i.e. Python or Perl) that may extend the library
- * features while still relying on its error reporting mechanism.
- */
-LIBSSH2_API int
-libssh2_session_set_last_error(LIBSSH2_SESSION* session,
-                               int errcode,
-                               const char *errmsg)
-{
-    return _libssh2_error_flags(session, errcode, errmsg,
-                                LIBSSH2_ERR_FLAG_DUP);
-}
-
-/* Libssh2_session_flag
- *
- * Set/Get session flags
- *
- * Return error code.
- */
-LIBSSH2_API int
-libssh2_session_flag(LIBSSH2_SESSION * session, int flag, int value)
-{
-    switch(flag) {
-    case LIBSSH2_FLAG_SIGPIPE:
-        session->flag.sigpipe = value;
-        break;
-    case LIBSSH2_FLAG_COMPRESS:
-        session->flag.compress = value;
-        break;
-    default:
-        /* unknown flag */
-        return LIBSSH2_ERROR_INVAL;
-    }
-
-    return LIBSSH2_ERROR_NONE;
-}
-
-/* _libssh2_session_set_blocking
- *
- * Set a session's blocking mode on or off, return the previous status when
- * this function is called. Note this function does not alter the state of the
- * actual socket involved.
- */
-int
-_libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking)
-{
-    int bl = session->api_block_mode;
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "Setting blocking mode %s", blocking?"ON":"OFF");
-    session->api_block_mode = blocking;
-
-    return bl;
-}
-
-/* libssh2_session_set_blocking
- *
- * Set a channel's blocking mode on or off, similar to a socket's
- * fcntl(fd, F_SETFL, O_NONBLOCK); type command
- */
-LIBSSH2_API void
-libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking)
-{
-    (void) _libssh2_session_set_blocking(session, blocking);
-}
-
-/* libssh2_session_get_blocking
- *
- * Returns a session's blocking mode on or off
- */
-LIBSSH2_API int
-libssh2_session_get_blocking(LIBSSH2_SESSION * session)
-{
-    return session->api_block_mode;
-}
-
-
-/* libssh2_session_set_timeout
- *
- * Set a session's timeout (in msec) for blocking mode,
- * or 0 to disable timeouts.
- */
-LIBSSH2_API void
-libssh2_session_set_timeout(LIBSSH2_SESSION * session, long timeout)
-{
-    session->api_timeout = timeout;
-}
-
-/* libssh2_session_get_timeout
- *
- * Returns a session's timeout, or 0 if disabled
- */
-LIBSSH2_API long
-libssh2_session_get_timeout(LIBSSH2_SESSION * session)
-{
-    return session->api_timeout;
-}
-
-/*
- * libssh2_poll_channel_read
- *
- * Returns 0 if no data is waiting on channel,
- * non-0 if data is available
- */
-LIBSSH2_API int
-libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended)
-{
-    LIBSSH2_SESSION *session;
-    LIBSSH2_PACKET *packet;
-
-    if(!channel)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    session = channel->session;
-    packet = _libssh2_list_first(&session->packets);
-
-    while(packet) {
-        if(packet->data_len < 5) {
-            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                  "Packet too small");
-        }
-
-        if(channel->local.id == _libssh2_ntohu32(packet->data + 1)) {
-            if(extended == 1 &&
-                (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA
-                 || packet->data[0] == SSH_MSG_CHANNEL_DATA)) {
-                return 1;
-            }
-            else if(extended == 0 &&
-                    packet->data[0] == SSH_MSG_CHANNEL_DATA) {
-                return 1;
-            }
-            /* else - no data of any type is ready to be read */
-        }
-        packet = _libssh2_list_next(&packet->node);
-    }
-
-    return 0;
-}
-
-/*
- * poll_channel_write
- *
- * Returns 0 if writing to channel would block,
- * non-0 if data can be written without blocking
- */
-static inline int
-poll_channel_write(LIBSSH2_CHANNEL * channel)
-{
-    return channel->local.window_size ? 1 : 0;
-}
-
-/* poll_listener_queued
- *
- * Returns 0 if no connections are waiting to be accepted
- * non-0 if one or more connections are available
- */
-static inline int
-poll_listener_queued(LIBSSH2_LISTENER * listener)
-{
-    return _libssh2_list_first(&listener->queue) ? 1 : 0;
-}
-
-/*
- * libssh2_poll
- *
- * Poll sockets, channels, and listeners for activity
- */
-LIBSSH2_API int
-libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
-{
-    long timeout_remaining;
-    unsigned int i, active_fds;
-#ifdef HAVE_POLL
-    LIBSSH2_SESSION *session = NULL;
-#ifdef HAVE_ALLOCA
-    struct pollfd *sockets = alloca(sizeof(struct pollfd) * nfds);
-#else
-    struct pollfd sockets[256];
-
-    if(nfds > 256)
-        /* systems without alloca use a fixed-size array, this can be fixed if
-           we really want to, at least if the compiler is a C99 capable one */
-        return -1;
-#endif
-    /* Setup sockets for polling */
-    for(i = 0; i < nfds; i++) {
-        fds[i].revents = 0;
-        switch(fds[i].type) {
-        case LIBSSH2_POLLFD_SOCKET:
-            sockets[i].fd = fds[i].fd.socket;
-            sockets[i].events = fds[i].events;
-            sockets[i].revents = 0;
-            break;
-
-        case LIBSSH2_POLLFD_CHANNEL:
-            sockets[i].fd = fds[i].fd.channel->session->socket_fd;
-            sockets[i].events = POLLIN;
-            sockets[i].revents = 0;
-            if(!session)
-                session = fds[i].fd.channel->session;
-            break;
-
-        case LIBSSH2_POLLFD_LISTENER:
-            sockets[i].fd = fds[i].fd.listener->session->socket_fd;
-            sockets[i].events = POLLIN;
-            sockets[i].revents = 0;
-            if(!session)
-                session = fds[i].fd.listener->session;
-            break;
-
-        default:
-            if(session)
-                _libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
-                               "Invalid descriptor passed to libssh2_poll()");
-            return -1;
-        }
-    }
-#elif defined(HAVE_SELECT)
-    LIBSSH2_SESSION *session = NULL;
-    libssh2_socket_t maxfd = 0;
-    fd_set rfds, wfds;
-    struct timeval tv;
-
-    FD_ZERO(&rfds);
-    FD_ZERO(&wfds);
-    for(i = 0; i < nfds; i++) {
-        fds[i].revents = 0;
-        switch(fds[i].type) {
-        case LIBSSH2_POLLFD_SOCKET:
-            if(fds[i].events & LIBSSH2_POLLFD_POLLIN) {
-                FD_SET(fds[i].fd.socket, &rfds);
-                if(fds[i].fd.socket > maxfd)
-                    maxfd = fds[i].fd.socket;
-            }
-            if(fds[i].events & LIBSSH2_POLLFD_POLLOUT) {
-                FD_SET(fds[i].fd.socket, &wfds);
-                if(fds[i].fd.socket > maxfd)
-                    maxfd = fds[i].fd.socket;
-            }
-            break;
-
-        case LIBSSH2_POLLFD_CHANNEL:
-            FD_SET(fds[i].fd.channel->session->socket_fd, &rfds);
-            if(fds[i].fd.channel->session->socket_fd > maxfd)
-                maxfd = fds[i].fd.channel->session->socket_fd;
-            if(!session)
-                session = fds[i].fd.channel->session;
-            break;
-
-        case LIBSSH2_POLLFD_LISTENER:
-            FD_SET(fds[i].fd.listener->session->socket_fd, &rfds);
-            if(fds[i].fd.listener->session->socket_fd > maxfd)
-                maxfd = fds[i].fd.listener->session->socket_fd;
-            if(!session)
-                session = fds[i].fd.listener->session;
-            break;
-
-        default:
-            if(session)
-                _libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
-                               "Invalid descriptor passed to libssh2_poll()");
-            return -1;
-        }
-    }
-#else
-    /* No select() or poll()
-     * no sockets structure to setup
-     */
-
-    timeout = 0;
-#endif /* HAVE_POLL or HAVE_SELECT */
-
-    timeout_remaining = timeout;
-    do {
-#if defined(HAVE_POLL) || defined(HAVE_SELECT)
-        int sysret;
-#endif
-
-        active_fds = 0;
-
-        for(i = 0; i < nfds; i++) {
-            if(fds[i].events != fds[i].revents) {
-                switch(fds[i].type) {
-                case LIBSSH2_POLLFD_CHANNEL:
-                    if((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
-                        /* Want to be ready for read */
-                        ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) {
-                        /* Not yet known to be ready for read */
-                        fds[i].revents |=
-                            libssh2_poll_channel_read(fds[i].fd.channel,
-                                                      0) ?
-                            LIBSSH2_POLLFD_POLLIN : 0;
-                    }
-                    if((fds[i].events & LIBSSH2_POLLFD_POLLEXT) &&
-                        /* Want to be ready for extended read */
-                        ((fds[i].revents & LIBSSH2_POLLFD_POLLEXT) == 0)) {
-                        /* Not yet known to be ready for extended read */
-                        fds[i].revents |=
-                            libssh2_poll_channel_read(fds[i].fd.channel,
-                                                      1) ?
-                            LIBSSH2_POLLFD_POLLEXT : 0;
-                    }
-                    if((fds[i].events & LIBSSH2_POLLFD_POLLOUT) &&
-                        /* Want to be ready for write */
-                        ((fds[i].revents & LIBSSH2_POLLFD_POLLOUT) == 0)) {
-                        /* Not yet known to be ready for write */
-                        fds[i].revents |=
-                            poll_channel_write(fds[i].fd. channel) ?
-                            LIBSSH2_POLLFD_POLLOUT : 0;
-                    }
-                    if(fds[i].fd.channel->remote.close
-                        || fds[i].fd.channel->local.close) {
-                        fds[i].revents |= LIBSSH2_POLLFD_CHANNEL_CLOSED;
-                    }
-                    if(fds[i].fd.channel->session->socket_state ==
-                        LIBSSH2_SOCKET_DISCONNECTED) {
-                        fds[i].revents |=
-                            LIBSSH2_POLLFD_CHANNEL_CLOSED |
-                            LIBSSH2_POLLFD_SESSION_CLOSED;
-                    }
-                    break;
-
-                case LIBSSH2_POLLFD_LISTENER:
-                    if((fds[i].events & LIBSSH2_POLLFD_POLLIN) &&
-                        /* Want a connection */
-                        ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) {
-                        /* No connections known of yet */
-                        fds[i].revents |=
-                            poll_listener_queued(fds[i].fd. listener) ?
-                            LIBSSH2_POLLFD_POLLIN : 0;
-                    }
-                    if(fds[i].fd.listener->session->socket_state ==
-                        LIBSSH2_SOCKET_DISCONNECTED) {
-                        fds[i].revents |=
-                            LIBSSH2_POLLFD_LISTENER_CLOSED |
-                            LIBSSH2_POLLFD_SESSION_CLOSED;
-                    }
-                    break;
-                }
-            }
-            if(fds[i].revents) {
-                active_fds++;
-            }
-        }
-
-        if(active_fds) {
-            /* Don't block on the sockets if we have channels/listeners which
-               are ready */
-            timeout_remaining = 0;
-        }
-#ifdef HAVE_POLL
-
-#ifdef HAVE_LIBSSH2_GETTIMEOFDAY
-        {
-            struct timeval tv_begin, tv_end;
-
-            _libssh2_gettimeofday((struct timeval *) &tv_begin, NULL);
-            sysret = poll(sockets, nfds, timeout_remaining);
-            _libssh2_gettimeofday((struct timeval *) &tv_end, NULL);
-            timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
-            timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
-        }
-#else
-        /* If the platform doesn't support gettimeofday,
-         * then just make the call non-blocking and walk away
-         */
-        sysret = poll(sockets, nfds, timeout_remaining);
-        timeout_remaining = 0;
-#endif /* HAVE_GETTIMEOFDAY */
-
-        if(sysret > 0) {
-            for(i = 0; i < nfds; i++) {
-                switch(fds[i].type) {
-                case LIBSSH2_POLLFD_SOCKET:
-                    fds[i].revents = sockets[i].revents;
-                    sockets[i].revents = 0; /* In case we loop again, be
-                                               nice */
-                    if(fds[i].revents) {
-                        active_fds++;
-                    }
-                    break;
-                case LIBSSH2_POLLFD_CHANNEL:
-                    if(sockets[i].events & POLLIN) {
-                        /* Spin session until no data available */
-                        while(_libssh2_transport_read(fds[i].fd.
-                                                      channel->session)
-                              > 0);
-                    }
-                    if(sockets[i].revents & POLLHUP) {
-                        fds[i].revents |=
-                            LIBSSH2_POLLFD_CHANNEL_CLOSED |
-                            LIBSSH2_POLLFD_SESSION_CLOSED;
-                    }
-                    sockets[i].revents = 0;
-                    break;
-                case LIBSSH2_POLLFD_LISTENER:
-                    if(sockets[i].events & POLLIN) {
-                        /* Spin session until no data available */
-                        while(_libssh2_transport_read(fds[i].fd.
-                                                      listener->session)
-                              > 0);
-                    }
-                    if(sockets[i].revents & POLLHUP) {
-                        fds[i].revents |=
-                            LIBSSH2_POLLFD_LISTENER_CLOSED |
-                            LIBSSH2_POLLFD_SESSION_CLOSED;
-                    }
-                    sockets[i].revents = 0;
-                    break;
-                }
-            }
-        }
-#elif defined(HAVE_SELECT)
-        tv.tv_sec = timeout_remaining / 1000;
-        tv.tv_usec = (timeout_remaining % 1000) * 1000;
-#ifdef HAVE_LIBSSH2_GETTIMEOFDAY
-        {
-            struct timeval tv_begin, tv_end;
-
-            _libssh2_gettimeofday((struct timeval *) &tv_begin, NULL);
-            sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
-            _libssh2_gettimeofday((struct timeval *) &tv_end, NULL);
-
-            timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
-            timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
-        }
-#else
-        /* If the platform doesn't support gettimeofday,
-         * then just make the call non-blocking and walk away
-         */
-        sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
-        timeout_remaining = 0;
-#endif
-
-        if(sysret > 0) {
-            for(i = 0; i < nfds; i++) {
-                switch(fds[i].type) {
-                case LIBSSH2_POLLFD_SOCKET:
-                    if(FD_ISSET(fds[i].fd.socket, &rfds)) {
-                        fds[i].revents |= LIBSSH2_POLLFD_POLLIN;
-                    }
-                    if(FD_ISSET(fds[i].fd.socket, &wfds)) {
-                        fds[i].revents |= LIBSSH2_POLLFD_POLLOUT;
-                    }
-                    if(fds[i].revents) {
-                        active_fds++;
-                    }
-                    break;
-
-                case LIBSSH2_POLLFD_CHANNEL:
-                    if(FD_ISSET(fds[i].fd.channel->session->socket_fd,
-                                &rfds)) {
-                        /* Spin session until no data available */
-                        while(_libssh2_transport_read(fds[i].fd.
-                                                      channel->session)
-                              > 0);
-                    }
-                    break;
-
-                case LIBSSH2_POLLFD_LISTENER:
-                    if(FD_ISSET
-                        (fds[i].fd.listener->session->socket_fd, &rfds)) {
-                        /* Spin session until no data available */
-                        while(_libssh2_transport_read(fds[i].fd.
-                                                      listener->session)
-                              > 0);
-                    }
-                    break;
-                }
-            }
-        }
-#endif /* else no select() or poll() -- timeout (and by extension
-        * timeout_remaining) will be equal to 0 */
-    } while((timeout_remaining > 0) && !active_fds);
-
-    return active_fds;
-}
-
-/*
- * libssh2_session_block_directions
- *
- * Get blocked direction when a function returns LIBSSH2_ERROR_EAGAIN
- * Returns LIBSSH2_SOCKET_BLOCK_INBOUND if recv() blocked
- * or LIBSSH2_SOCKET_BLOCK_OUTBOUND if send() blocked
- */
-LIBSSH2_API int
-libssh2_session_block_directions(LIBSSH2_SESSION *session)
-{
-    return session->socket_block_directions;
-}
-
-/* libssh2_session_banner_get
- * Get the remote banner (server ID string)
- */
-
-LIBSSH2_API const char *
-libssh2_session_banner_get(LIBSSH2_SESSION *session)
-{
-    /* to avoid a coredump when session is NULL */
-    if(NULL == session)
-        return NULL;
-
-    if(NULL == session->remote.banner)
-        return NULL;
-
-    return (const char *) session->remote.banner;
-}
diff --git a/libssh2/libssh2/src/session.h b/libssh2/libssh2/src/session.h
deleted file mode 100644
index 9f8f2c70..00000000
--- a/libssh2/libssh2/src/session.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef __LIBSSH2_SESSION_H
-#define __LIBSSH2_SESSION_H
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2010 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Conveniance-macros to allow code like this;
-
-   int rc = BLOCK_ADJUST(rc, session, session_startup(session, sock) );
-
-   int rc = BLOCK_ADJUST_ERRNO(ptr, session, session_startup(session, sock) );
-
-   The point of course being to make sure that while in non-blocking mode
-   these always return no matter what the return code is, but in blocking mode
-   it blocks if EAGAIN is the reason for the return from the underlying
-   function.
-
-*/
-#define BLOCK_ADJUST(rc, sess, x) \
-    do { \
-       time_t entry_time = time(NULL); \
-       do { \
-          rc = x; \
-          /* the order of the check below is important to properly deal with \
-             the case when the 'sess' is freed */ \
-          if((rc != LIBSSH2_ERROR_EAGAIN) || !sess->api_block_mode) \
-              break; \
-          rc = _libssh2_wait_socket(sess, entry_time);  \
-       } while(!rc);   \
-    } while(0)
-
-/*
- * For functions that returns a pointer, we need to check if the API is
- * non-blocking and return immediately. If the pointer is non-NULL we return
- * immediately. If the API is blocking and we get a NULL we check the errno
- * and *only* if that is EAGAIN we loop and wait for socket action.
- */
-#define BLOCK_ADJUST_ERRNO(ptr, sess, x) \
-    do { \
-       time_t entry_time = time(NULL); \
-       int rc; \
-       do { \
-           ptr = x; \
-           if(!sess->api_block_mode || \
-              (ptr != NULL) || \
-              (libssh2_session_last_errno(sess) != LIBSSH2_ERROR_EAGAIN) ) \
-               break; \
-           rc = _libssh2_wait_socket(sess, entry_time); \
-        } while(!rc); \
-    } while(0)
-
-
-int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t entry_time);
-
-/* this is the lib-internal set blocking function */
-int _libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking);
-
-#endif /* __LIBSSH2_SESSION_H */
diff --git a/libssh2/libssh2/src/sftp.c b/libssh2/libssh2/src/sftp.c
deleted file mode 100644
index ac7ee016..00000000
--- a/libssh2/libssh2/src/sftp.c
+++ /dev/null
@@ -1,3755 +0,0 @@
-/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2007 Eli Fant <elifantu@mail.ru>
- * Copyright (c) 2009-2019 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include <assert.h>
-
-#include "libssh2_priv.h"
-#include "libssh2_sftp.h"
-#include "channel.h"
-#include "session.h"
-#include "sftp.h"
-
-/* Note: Version 6 was documented at the time of writing
- * However it was marked as "DO NOT IMPLEMENT" due to pending changes
- *
- * This release of libssh2 implements Version 5 with automatic downgrade
- * based on server's declaration
- */
-
-/* SFTP packet types */
-#define SSH_FXP_INIT                            1
-#define SSH_FXP_VERSION                         2
-#define SSH_FXP_OPEN                            3
-#define SSH_FXP_CLOSE                           4
-#define SSH_FXP_READ                            5
-#define SSH_FXP_WRITE                           6
-#define SSH_FXP_LSTAT                           7
-#define SSH_FXP_FSTAT                           8
-#define SSH_FXP_SETSTAT                         9
-#define SSH_FXP_FSETSTAT                        10
-#define SSH_FXP_OPENDIR                         11
-#define SSH_FXP_READDIR                         12
-#define SSH_FXP_REMOVE                          13
-#define SSH_FXP_MKDIR                           14
-#define SSH_FXP_RMDIR                           15
-#define SSH_FXP_REALPATH                        16
-#define SSH_FXP_STAT                            17
-#define SSH_FXP_RENAME                          18
-#define SSH_FXP_READLINK                        19
-#define SSH_FXP_SYMLINK                         20
-#define SSH_FXP_STATUS                          101
-#define SSH_FXP_HANDLE                          102
-#define SSH_FXP_DATA                            103
-#define SSH_FXP_NAME                            104
-#define SSH_FXP_ATTRS                           105
-#define SSH_FXP_EXTENDED                        200
-#define SSH_FXP_EXTENDED_REPLY                  201
-
-/* S_IFREG */
-#define LIBSSH2_SFTP_ATTR_PFILETYPE_FILE        0100000
-/* S_IFDIR */
-#define LIBSSH2_SFTP_ATTR_PFILETYPE_DIR         0040000
-
-#define SSH_FXE_STATVFS_ST_RDONLY               0x00000001
-#define SSH_FXE_STATVFS_ST_NOSUID               0x00000002
-
-/* This is the maximum packet length to accept, as larger than this indicate
-   some kind of server problem. */
-#define LIBSSH2_SFTP_PACKET_MAXLEN  (256 * 1024)
-
-static int sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,
-                           uint32_t request_id, unsigned char **data,
-                           size_t *data_len);
-static void sftp_packet_flush(LIBSSH2_SFTP *sftp);
-
-/* sftp_attrsize
- * Size that attr with this flagset will occupy when turned into a bin struct
- */
-static int sftp_attrsize(unsigned long flags)
-{
-    return (4 +                                 /* flags(4) */
-            ((flags & LIBSSH2_SFTP_ATTR_SIZE) ? 8 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_UIDGID) ? 8 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) ? 4 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_ACMODTIME) ? 8 : 0));
-    /* atime + mtime as u32 */
-}
-
-/* _libssh2_store_u64
- */
-static void _libssh2_store_u64(unsigned char **ptr, libssh2_uint64_t value)
-{
-    uint32_t msl = (uint32_t)(value >> 32);
-    unsigned char *buf = *ptr;
-
-    buf[0] = (unsigned char)((msl >> 24) & 0xFF);
-    buf[1] = (unsigned char)((msl >> 16) & 0xFF);
-    buf[2] = (unsigned char)((msl >> 8)  & 0xFF);
-    buf[3] = (unsigned char)( msl        & 0xFF);
-
-    buf[4] = (unsigned char)((value >> 24) & 0xFF);
-    buf[5] = (unsigned char)((value >> 16) & 0xFF);
-    buf[6] = (unsigned char)((value >> 8)  & 0xFF);
-    buf[7] = (unsigned char)( value        & 0xFF);
-
-    *ptr += 8;
-}
-
-/*
- * Search list of zombied FXP_READ request IDs.
- *
- * Returns NULL if ID not in list.
- */
-static struct sftp_zombie_requests *
-find_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
-{
-    struct sftp_zombie_requests *zombie =
-        _libssh2_list_first(&sftp->zombie_requests);
-
-    while(zombie) {
-        if(zombie->request_id == request_id)
-            break;
-        else
-            zombie = _libssh2_list_next(&zombie->node);
-    }
-
-    return zombie;
-}
-
-static void
-remove_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
-{
-    LIBSSH2_SESSION *session = sftp->channel->session;
-
-    struct sftp_zombie_requests *zombie = find_zombie_request(sftp,
-                                                              request_id);
-    if(zombie) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Removing request ID %ld from the list of "
-                       "zombie requests",
-                       request_id);
-
-        _libssh2_list_remove(&zombie->node);
-        LIBSSH2_FREE(session, zombie);
-    }
-}
-
-static int
-add_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
-{
-    LIBSSH2_SESSION *session = sftp->channel->session;
-
-    struct sftp_zombie_requests *zombie;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Marking request ID %ld as a zombie request", request_id);
-
-    zombie = LIBSSH2_ALLOC(sftp->channel->session,
-                           sizeof(struct sftp_zombie_requests));
-    if(!zombie)
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "malloc fail for zombie request  ID");
-    else {
-        zombie->request_id = request_id;
-        _libssh2_list_add(&sftp->zombie_requests, &zombie->node);
-        return LIBSSH2_ERROR_NONE;
-    }
-}
-
-/*
- * sftp_packet_add
- *
- * Add a packet to the SFTP packet brigade
- */
-static int
-sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
-                size_t data_len)
-{
-    LIBSSH2_SESSION *session = sftp->channel->session;
-    LIBSSH2_SFTP_PACKET *packet;
-    uint32_t request_id;
-
-    if(data_len < 5) {
-        return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-    }
-
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Received packet type %d (len %d)",
-                   (int) data[0], data_len);
-
-    /*
-     * Experience shows that if we mess up EAGAIN handling somewhere or
-     * otherwise get out of sync with the channel, this is where we first get
-     * a wrong byte and if so we need to bail out at once to aid tracking the
-     * problem better.
-     */
-
-    switch(data[0]) {
-    case SSH_FXP_INIT:
-    case SSH_FXP_VERSION:
-    case SSH_FXP_OPEN:
-    case SSH_FXP_CLOSE:
-    case SSH_FXP_READ:
-    case SSH_FXP_WRITE:
-    case SSH_FXP_LSTAT:
-    case SSH_FXP_FSTAT:
-    case SSH_FXP_SETSTAT:
-    case SSH_FXP_FSETSTAT:
-    case SSH_FXP_OPENDIR:
-    case SSH_FXP_READDIR:
-    case SSH_FXP_REMOVE:
-    case SSH_FXP_MKDIR:
-    case SSH_FXP_RMDIR:
-    case SSH_FXP_REALPATH:
-    case SSH_FXP_STAT:
-    case SSH_FXP_RENAME:
-    case SSH_FXP_READLINK:
-    case SSH_FXP_SYMLINK:
-    case SSH_FXP_STATUS:
-    case SSH_FXP_HANDLE:
-    case SSH_FXP_DATA:
-    case SSH_FXP_NAME:
-    case SSH_FXP_ATTRS:
-    case SSH_FXP_EXTENDED:
-    case SSH_FXP_EXTENDED_REPLY:
-        break;
-    default:
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Out of sync with the world");
-    }
-
-    request_id = _libssh2_ntohu32(&data[1]);
-
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Received packet id %d",
-                   request_id);
-
-    /* Don't add the packet if it answers a request we've given up on. */
-    if((data[0] == SSH_FXP_STATUS || data[0] == SSH_FXP_DATA)
-       && find_zombie_request(sftp, request_id)) {
-
-        /* If we get here, the file ended before the response arrived. We
-           are no longer interested in the request so we discard it */
-
-        LIBSSH2_FREE(session, data);
-
-        remove_zombie_request(sftp, request_id);
-        return LIBSSH2_ERROR_NONE;
-    }
-
-    packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP_PACKET));
-    if(!packet) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate datablock for SFTP packet");
-    }
-
-    packet->data = data;
-    packet->data_len = data_len;
-    packet->request_id = request_id;
-
-    _libssh2_list_add(&sftp->packets, &packet->node);
-
-    return LIBSSH2_ERROR_NONE;
-}
-
-/*
- * sftp_packet_read
- *
- * Frame an SFTP packet off the channel
- */
-static int
-sftp_packet_read(LIBSSH2_SFTP *sftp)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    unsigned char *packet = NULL;
-    ssize_t rc;
-    unsigned long recv_window;
-    int packet_type;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "recv packet");
-
-    switch(sftp->packet_state) {
-    case libssh2_NB_state_sent: /* EAGAIN from window adjusting */
-        sftp->packet_state = libssh2_NB_state_idle;
-
-        packet = sftp->partial_packet;
-        goto window_adjust;
-
-    case libssh2_NB_state_sent1: /* EAGAIN from channel read */
-        sftp->packet_state = libssh2_NB_state_idle;
-
-        packet = sftp->partial_packet;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "partial read cont, len: %lu", sftp->partial_len);
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "partial read cont, already recvd: %lu",
-                       sftp->partial_received);
-        /* fall-through */
-    default:
-        if(!packet) {
-            /* only do this if there's not already a packet buffer allocated
-               to use */
-
-            /* each packet starts with a 32 bit length field */
-            rc = _libssh2_channel_read(channel, 0,
-                                       (char *)&sftp->partial_size[
-                                           sftp->partial_size_len],
-                                       4 - sftp->partial_size_len);
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
-            else if(rc < 0)
-                return _libssh2_error(session, rc, "channel read");
-
-            sftp->partial_size_len += rc;
-
-            if(4 != sftp->partial_size_len)
-                /* we got a short read for the length part */
-                return LIBSSH2_ERROR_EAGAIN;
-
-            sftp->partial_len = _libssh2_ntohu32(sftp->partial_size);
-            /* make sure we don't proceed if the packet size is unreasonably
-               large */
-            if(sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN) {
-                libssh2_channel_flush(channel);
-                sftp->partial_size_len = 0;
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
-                                      "SFTP packet too large");
-            }
-
-            if(sftp->partial_len == 0)
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_ALLOC,
-                                      "Unable to allocate empty SFTP packet");
-
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                           "Data begin - Packet Length: %lu",
-                           sftp->partial_len);
-            packet = LIBSSH2_ALLOC(session, sftp->partial_len);
-            if(!packet)
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "Unable to allocate SFTP packet");
-            sftp->partial_size_len = 0;
-            sftp->partial_received = 0; /* how much of the packet already
-                                           received */
-            sftp->partial_packet = packet;
-
-          window_adjust:
-            recv_window = libssh2_channel_window_read_ex(channel, NULL, NULL);
-
-            if(sftp->partial_len > recv_window) {
-                /* ask for twice the data amount we need at once */
-                rc = _libssh2_channel_receive_window_adjust(channel,
-                                                            sftp->partial_len
-                                                            * 2,
-                                                            1, NULL);
-                /* store the state so that we continue with the correct
-                   operation at next invoke */
-                sftp->packet_state = (rc == LIBSSH2_ERROR_EAGAIN)?
-                    libssh2_NB_state_sent:
-                    libssh2_NB_state_idle;
-
-                if(rc == LIBSSH2_ERROR_EAGAIN)
-                    return rc;
-            }
-        }
-
-        /* Read as much of the packet as we can */
-        while(sftp->partial_len > sftp->partial_received) {
-            rc = _libssh2_channel_read(channel, 0,
-                                       (char *)&packet[sftp->partial_received],
-                                       sftp->partial_len -
-                                       sftp->partial_received);
-
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                /*
-                 * We received EAGAIN, save what we have and return EAGAIN to
-                 * the caller. Set 'partial_packet' so that this function
-                 * knows how to continue on the next invoke.
-                 */
-                sftp->packet_state = libssh2_NB_state_sent1;
-                return rc;
-            }
-            else if(rc < 0) {
-                LIBSSH2_FREE(session, packet);
-                sftp->partial_packet = NULL;
-                return _libssh2_error(session, rc,
-                                      "Error waiting for SFTP packet");
-            }
-            sftp->partial_received += rc;
-        }
-
-        sftp->partial_packet = NULL;
-
-        /* sftp_packet_add takes ownership of the packet and might free it
-           so we take a copy of the packet type before we call it. */
-        packet_type = packet[0];
-        rc = sftp_packet_add(sftp, packet, sftp->partial_len);
-        if(rc) {
-            LIBSSH2_FREE(session, packet);
-            return rc;
-        }
-        else {
-            return packet_type;
-        }
-    }
-    /* WON'T REACH */
-}
-/*
- * sftp_packetlist_flush
- *
- * Remove all pending packets in the packet_list and the corresponding one(s)
- * in the SFTP packet brigade.
- */
-static void sftp_packetlist_flush(LIBSSH2_SFTP_HANDLE *handle)
-{
-    struct sftp_pipeline_chunk *chunk;
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_SESSION *session = sftp->channel->session;
-
-    /* remove pending packets, if any */
-    chunk = _libssh2_list_first(&handle->packet_list);
-    while(chunk) {
-        unsigned char *data;
-        size_t data_len;
-        int rc;
-        struct sftp_pipeline_chunk *next = _libssh2_list_next(&chunk->node);
-
-        rc = sftp_packet_ask(sftp, SSH_FXP_STATUS,
-                             chunk->request_id, &data, &data_len);
-        if(rc)
-            rc = sftp_packet_ask(sftp, SSH_FXP_DATA,
-                                 chunk->request_id, &data, &data_len);
-
-        if(!rc)
-            /* we found a packet, free it */
-            LIBSSH2_FREE(session, data);
-        else if(chunk->sent)
-            /* there was no incoming packet for this request, mark this
-               request as a zombie if it ever sent the request */
-            add_zombie_request(sftp, chunk->request_id);
-
-        _libssh2_list_remove(&chunk->node);
-        LIBSSH2_FREE(session, chunk);
-        chunk = next;
-    }
-}
-
-
-/*
- * sftp_packet_ask()
- *
- * Checks if there's a matching SFTP packet available.
- */
-static int
-sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,
-                uint32_t request_id, unsigned char **data,
-                size_t *data_len)
-{
-    LIBSSH2_SESSION *session = sftp->channel->session;
-    LIBSSH2_SFTP_PACKET *packet = _libssh2_list_first(&sftp->packets);
-
-    if(!packet)
-        return -1;
-
-    /* Special consideration when getting VERSION packet */
-
-    while(packet) {
-        if((packet->data[0] == packet_type) &&
-           ((packet_type == SSH_FXP_VERSION) ||
-            (packet->request_id == request_id))) {
-
-            /* Match! Fetch the data */
-            *data = packet->data;
-            *data_len = packet->data_len;
-
-            /* unlink and free this struct */
-            _libssh2_list_remove(&packet->node);
-            LIBSSH2_FREE(session, packet);
-
-            return 0;
-        }
-        /* check next struct in the list */
-        packet = _libssh2_list_next(&packet->node);
-    }
-    return -1;
-}
-
-/* sftp_packet_require
- * A la libssh2_packet_require
- */
-static int
-sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
-                    uint32_t request_id, unsigned char **data,
-                    size_t *data_len, size_t required_size)
-{
-    LIBSSH2_SESSION *session = sftp->channel->session;
-    int rc;
-
-    if(data == NULL || data_len == NULL || required_size == 0) {
-        return LIBSSH2_ERROR_BAD_USE;
-    }
-
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Requiring packet %d id %ld",
-                   (int) packet_type, request_id);
-
-    if(sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {
-        /* The right packet was available in the packet brigade */
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
-                       (int) packet_type);
-
-        if (*data_len < required_size) {
-            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        }
-
-        return LIBSSH2_ERROR_NONE;
-    }
-
-    while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-        rc = sftp_packet_read(sftp);
-        if(rc < 0)
-            return rc;
-
-        /* data was read, check the queue again */
-        if(!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {
-            /* The right packet was available in the packet brigade */
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
-                           (int) packet_type);
-
-            if (*data_len < required_size) {
-                return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-            }
-
-            return LIBSSH2_ERROR_NONE;
-        }
-    }
-
-    /* Only reached if the socket died */
-    return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-}
-
-/* sftp_packet_requirev
- * Require one of N possible responses
- */
-static int
-sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
-                     const unsigned char *valid_responses,
-                     uint32_t request_id, unsigned char **data,
-                     size_t *data_len, size_t required_size)
-{
-    int i;
-    int rc;
-
-    if(data == NULL || data_len == NULL || required_size == 0) {
-        return LIBSSH2_ERROR_BAD_USE;
-    }
-
-    /* If no timeout is active, start a new one */
-    if(sftp->requirev_start == 0)
-        sftp->requirev_start = time(NULL);
-
-    while(sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-        for(i = 0; i < num_valid_responses; i++) {
-            if(sftp_packet_ask(sftp, valid_responses[i], request_id,
-                                data, data_len) == 0) {
-                /*
-                 * Set to zero before all returns to say
-                 * the timeout is not active
-                 */
-                sftp->requirev_start = 0;
-
-                if (*data_len < required_size) {
-                    return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                }
-
-                return LIBSSH2_ERROR_NONE;
-            }
-        }
-
-        rc = sftp_packet_read(sftp);
-        if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {
-            sftp->requirev_start = 0;
-            return rc;
-        }
-        else if(rc <= 0) {
-            /* prevent busy-looping */
-            long left =
-                LIBSSH2_READ_TIMEOUT -
-                (long)(time(NULL) - sftp->requirev_start);
-
-            if(left <= 0) {
-                sftp->requirev_start = 0;
-                return LIBSSH2_ERROR_TIMEOUT;
-            }
-            else if(rc == LIBSSH2_ERROR_EAGAIN) {
-                return rc;
-            }
-        }
-    }
-
-    sftp->requirev_start = 0;
-
-    /* Only reached if the socket died */
-    return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-}
-
-/* sftp_attr2bin
- * Populate attributes into an SFTP block
- */
-static ssize_t
-sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs)
-{
-    unsigned char *s = p;
-    uint32_t flag_mask =
-        LIBSSH2_SFTP_ATTR_SIZE | LIBSSH2_SFTP_ATTR_UIDGID |
-        LIBSSH2_SFTP_ATTR_PERMISSIONS | LIBSSH2_SFTP_ATTR_ACMODTIME;
-
-    /* TODO: When we add SFTP4+ functionality flag_mask can get additional
-       bits */
-
-    if(!attrs) {
-        _libssh2_htonu32(s, 0);
-        return 4;
-    }
-
-    _libssh2_store_u32(&s, attrs->flags & flag_mask);
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
-        _libssh2_store_u64(&s, attrs->filesize);
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
-        _libssh2_store_u32(&s, attrs->uid);
-        _libssh2_store_u32(&s, attrs->gid);
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
-        _libssh2_store_u32(&s, attrs->permissions);
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
-        _libssh2_store_u32(&s, attrs->atime);
-        _libssh2_store_u32(&s, attrs->mtime);
-    }
-
-    return (s - p);
-}
-
-/* sftp_bin2attr
- */
-static int
-sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
-              size_t data_len)
-{
-    struct string_buf buf;
-    uint32_t flags = 0;
-    buf.data = (unsigned char *)p;
-    buf.dataptr = buf.data;
-    buf.len = data_len;
-
-    if(_libssh2_get_u32(&buf, &flags) != 0) {
-        return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-    }
-    attrs->flags = flags;
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
-        if(_libssh2_get_u64(&buf, &(attrs->filesize)) != 0) {
-            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        }
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
-        uint32_t uid = 0;
-        uint32_t gid = 0;
-        if(_libssh2_get_u32(&buf, &uid) != 0 ||
-           _libssh2_get_u32(&buf, &gid) != 0) {
-            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        }
-        attrs->uid = uid;
-        attrs->gid = gid;
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
-        uint32_t permissions;
-        if(_libssh2_get_u32(&buf, &permissions) != 0) {
-            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        }
-        attrs->permissions = permissions;
-    }
-
-    if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
-        uint32_t atime;
-        uint32_t mtime;
-        if(_libssh2_get_u32(&buf, &atime) != 0 ||
-           _libssh2_get_u32(&buf, &mtime) != 0) {
-            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        }
-        attrs->atime = atime;
-        attrs->mtime = mtime;
-    }
-
-    return (buf.dataptr - buf.data);
-}
-
-/* ************
- * SFTP API *
- ************ */
-
-LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor);
-
-/* libssh2_sftp_dtor
- * Shutdown an SFTP stream when the channel closes
- */
-LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor)
-{
-    LIBSSH2_SFTP *sftp = (LIBSSH2_SFTP *) (*channel_abstract);
-
-    (void) session_abstract;
-    (void) channel;
-
-    /* Free the partial packet storage for sftp_packet_read */
-    if(sftp->partial_packet) {
-        LIBSSH2_FREE(session, sftp->partial_packet);
-    }
-
-    /* Free the packet storage for _libssh2_sftp_packet_readdir */
-    if(sftp->readdir_packet) {
-        LIBSSH2_FREE(session, sftp->readdir_packet);
-    }
-
-    LIBSSH2_FREE(session, sftp);
-}
-
-/*
- * sftp_init
- *
- * Startup an SFTP session
- */
-static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
-{
-    unsigned char *data;
-    size_t data_len;
-    ssize_t rc;
-    LIBSSH2_SFTP *sftp_handle;
-    struct string_buf buf;
-    unsigned char *endp;
-
-    if(session->sftpInit_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Initializing SFTP subsystem");
-
-        /*
-         * The 'sftpInit_sftp' and 'sftpInit_channel' struct fields within the
-         * session struct are only to be used during the setup phase. As soon
-         * as the SFTP session is created they are cleared and can thus be
-         * re-used again to allow any amount of SFTP handles per sessions.
-         *
-         * Note that you MUST NOT try to call libssh2_sftp_init() again to get
-         * another handle until the previous call has finished and either
-         * successfully made a handle or failed and returned error (not
-         * including *EAGAIN).
-         */
-
-        assert(session->sftpInit_sftp == NULL);
-        session->sftpInit_sftp = NULL;
-        session->sftpInit_state = libssh2_NB_state_created;
-    }
-
-    sftp_handle = session->sftpInit_sftp;
-
-    if(session->sftpInit_state == libssh2_NB_state_created) {
-        session->sftpInit_channel =
-            _libssh2_channel_open(session, "session", sizeof("session") - 1,
-                                  LIBSSH2_CHANNEL_WINDOW_DEFAULT,
-                                  LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
-        if(!session->sftpInit_channel) {
-            if(libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
-                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                               "Would block starting up channel");
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                               "Unable to startup channel");
-                session->sftpInit_state = libssh2_NB_state_idle;
-            }
-            return NULL;
-        }
-
-        session->sftpInit_state = libssh2_NB_state_sent;
-    }
-
-    if(session->sftpInit_state == libssh2_NB_state_sent) {
-        int ret = _libssh2_channel_process_startup(session->sftpInit_channel,
-                                                   "subsystem",
-                                                   sizeof("subsystem") - 1,
-                                                   "sftp",
-                                                   strlen("sftp"));
-        if(ret == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block to request SFTP subsystem");
-            return NULL;
-        }
-        else if(ret) {
-            _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
-                           "Unable to request SFTP subsystem");
-            goto sftp_init_error;
-        }
-
-        session->sftpInit_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->sftpInit_state == libssh2_NB_state_sent1) {
-        rc = _libssh2_channel_extended_data(session->sftpInit_channel,
-                                         LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block requesting handle extended data");
-            return NULL;
-        }
-
-        sftp_handle =
-            session->sftpInit_sftp =
-            LIBSSH2_CALLOC(session, sizeof(LIBSSH2_SFTP));
-        if(!sftp_handle) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate a new SFTP structure");
-            goto sftp_init_error;
-        }
-        sftp_handle->channel = session->sftpInit_channel;
-        sftp_handle->request_id = 0;
-
-        _libssh2_htonu32(session->sftpInit_buffer, 5);
-        session->sftpInit_buffer[4] = SSH_FXP_INIT;
-        _libssh2_htonu32(session->sftpInit_buffer + 5, LIBSSH2_SFTP_VERSION);
-        session->sftpInit_sent = 0; /* nothing's sent yet */
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Sending FXP_INIT packet advertising "
-                       "version %d support",
-                       (int) LIBSSH2_SFTP_VERSION);
-
-        session->sftpInit_state = libssh2_NB_state_sent2;
-    }
-
-    if(session->sftpInit_state == libssh2_NB_state_sent2) {
-        /* sent off what's left of the init buffer to send */
-        rc = _libssh2_channel_write(session->sftpInit_channel, 0,
-                                    session->sftpInit_buffer +
-                                    session->sftpInit_sent,
-                                    9 - session->sftpInit_sent);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block sending SSH_FXP_INIT");
-            return NULL;
-        }
-        else if(rc < 0) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send SSH_FXP_INIT");
-            goto sftp_init_error;
-        }
-        else {
-            /* add up the number of bytes sent */
-            session->sftpInit_sent += rc;
-
-            if(session->sftpInit_sent == 9)
-                /* move on */
-                session->sftpInit_state = libssh2_NB_state_sent3;
-
-            /* if less than 9, we remain in this state to send more later on */
-        }
-    }
-
-    rc = sftp_packet_require(sftp_handle, SSH_FXP_VERSION,
-                             0, &data, &data_len, 5);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                       "Would block receiving SSH_FXP_VERSION");
-        return NULL;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                       "Invalid SSH_FXP_VERSION response");
-        goto sftp_init_error;
-    }
-    else if(rc) {
-        _libssh2_error(session, rc,
-                       "Timeout waiting for response from SFTP subsystem");
-        goto sftp_init_error;
-    }
-
-    buf.data = data;
-    buf.dataptr = buf.data + 1;
-    buf.len = data_len;
-    endp = &buf.data[data_len];
-
-    if(_libssh2_get_u32(&buf, &(sftp_handle->version)) != 0) {
-        LIBSSH2_FREE(session, data);
-        rc = LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-        goto sftp_init_error;
-    }
-
-    if(sftp_handle->version > LIBSSH2_SFTP_VERSION) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Truncating remote SFTP version from %lu",
-                       sftp_handle->version);
-        sftp_handle->version = LIBSSH2_SFTP_VERSION;
-    }
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Enabling SFTP version %lu compatibility",
-                   sftp_handle->version);
-    while(buf.dataptr < endp) {
-        unsigned char *extname, *extdata;
-
-        if(_libssh2_get_string(&buf, &extname, NULL)) {
-            LIBSSH2_FREE(session, data);
-            _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                           "Data too short when extracting extname");
-            goto sftp_init_error;
-        }
-
-        if(_libssh2_get_string(&buf, &extdata, NULL)) {
-            LIBSSH2_FREE(session, data);
-            _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                           "Data too short when extracting extdata");
-            goto sftp_init_error;
-        }
-    }
-    LIBSSH2_FREE(session, data);
-
-    /* Make sure that when the channel gets closed, the SFTP service is shut
-       down too */
-    sftp_handle->channel->abstract = sftp_handle;
-    sftp_handle->channel->close_cb = libssh2_sftp_dtor;
-
-    session->sftpInit_state = libssh2_NB_state_idle;
-
-    /* clear the sftp and channel pointers in this session struct now */
-    session->sftpInit_sftp = NULL;
-    session->sftpInit_channel = NULL;
-
-    _libssh2_list_init(&sftp_handle->sftp_handles);
-
-    return sftp_handle;
-
-  sftp_init_error:
-    while(_libssh2_channel_free(session->sftpInit_channel) ==
-           LIBSSH2_ERROR_EAGAIN);
-    session->sftpInit_channel = NULL;
-    if(session->sftpInit_sftp) {
-        LIBSSH2_FREE(session, session->sftpInit_sftp);
-        session->sftpInit_sftp = NULL;
-    }
-    session->sftpInit_state = libssh2_NB_state_idle;
-    return NULL;
-}
-
-/*
- * libssh2_sftp_init
- *
- * Startup an SFTP session
- */
-LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
-{
-    LIBSSH2_SFTP *ptr;
-
-    if(!session)
-        return NULL;
-
-    if(!(session->state & LIBSSH2_STATE_AUTHENTICATED)) {
-        _libssh2_error(session, LIBSSH2_ERROR_INVAL,
-                       "session not authenticated yet");
-        return NULL;
-    }
-
-    BLOCK_ADJUST_ERRNO(ptr, session, sftp_init(session));
-    return ptr;
-}
-
-/*
- * sftp_shutdown
- *
- * Shuts down the SFTP subsystem
- */
-static int
-sftp_shutdown(LIBSSH2_SFTP *sftp)
-{
-    int rc;
-    LIBSSH2_SESSION *session = sftp->channel->session;
-    /*
-     * Make sure all memory used in the state variables are free
-     */
-    if(sftp->partial_packet) {
-        LIBSSH2_FREE(session, sftp->partial_packet);
-        sftp->partial_packet = NULL;
-    }
-    if(sftp->open_packet) {
-        LIBSSH2_FREE(session, sftp->open_packet);
-        sftp->open_packet = NULL;
-    }
-    if(sftp->readdir_packet) {
-        LIBSSH2_FREE(session, sftp->readdir_packet);
-        sftp->readdir_packet = NULL;
-    }
-    if(sftp->fstat_packet) {
-        LIBSSH2_FREE(session, sftp->fstat_packet);
-        sftp->fstat_packet = NULL;
-    }
-    if(sftp->unlink_packet) {
-        LIBSSH2_FREE(session, sftp->unlink_packet);
-        sftp->unlink_packet = NULL;
-    }
-    if(sftp->rename_packet) {
-        LIBSSH2_FREE(session, sftp->rename_packet);
-        sftp->rename_packet = NULL;
-    }
-    if(sftp->fstatvfs_packet) {
-        LIBSSH2_FREE(session, sftp->fstatvfs_packet);
-        sftp->fstatvfs_packet = NULL;
-    }
-    if(sftp->statvfs_packet) {
-        LIBSSH2_FREE(session, sftp->statvfs_packet);
-        sftp->statvfs_packet = NULL;
-    }
-    if(sftp->mkdir_packet) {
-        LIBSSH2_FREE(session, sftp->mkdir_packet);
-        sftp->mkdir_packet = NULL;
-    }
-    if(sftp->rmdir_packet) {
-        LIBSSH2_FREE(session, sftp->rmdir_packet);
-        sftp->rmdir_packet = NULL;
-    }
-    if(sftp->stat_packet) {
-        LIBSSH2_FREE(session, sftp->stat_packet);
-        sftp->stat_packet = NULL;
-    }
-    if(sftp->symlink_packet) {
-        LIBSSH2_FREE(session, sftp->symlink_packet);
-        sftp->symlink_packet = NULL;
-    }
-    if(sftp->fsync_packet) {
-        LIBSSH2_FREE(session, sftp->fsync_packet);
-        sftp->fsync_packet = NULL;
-    }
-
-    sftp_packet_flush(sftp);
-
-    /* TODO: We should consider walking over the sftp_handles list and kill
-     * any remaining sftp handles ... */
-
-    rc = _libssh2_channel_free(sftp->channel);
-
-    return rc;
-}
-
-/* libssh2_sftp_shutdown
- * Shutsdown the SFTP subsystem
- */
-LIBSSH2_API int
-libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session, sftp_shutdown(sftp));
-    return rc;
-}
-
-/* *******************************
- * SFTP File and Directory Ops *
- ******************************* */
-
-/* sftp_open
- */
-static LIBSSH2_SFTP_HANDLE *
-sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
-          size_t filename_len, uint32_t flags, long mode,
-          int open_type)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    LIBSSH2_SFTP_HANDLE *fp;
-    LIBSSH2_SFTP_ATTRIBUTES attrs = {
-        LIBSSH2_SFTP_ATTR_PERMISSIONS, 0, 0, 0, 0, 0, 0
-    };
-    unsigned char *s;
-    ssize_t rc;
-    int open_file = (open_type == LIBSSH2_SFTP_OPENFILE)?1:0;
-
-    if(sftp->open_state == libssh2_NB_state_idle) {
-        /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) +
-           flags(4) */
-        sftp->open_packet_len = filename_len + 13 +
-            (open_file? (4 +
-                         sftp_attrsize(LIBSSH2_SFTP_ATTR_PERMISSIONS)) : 0);
-
-        /* surprise! this starts out with nothing sent */
-        sftp->open_packet_sent = 0;
-        s = sftp->open_packet = LIBSSH2_ALLOC(session, sftp->open_packet_len);
-        if(!sftp->open_packet) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for FXP_OPEN or "
-                           "FXP_OPENDIR packet");
-            return NULL;
-        }
-        /* Filetype in SFTP 3 and earlier */
-        attrs.permissions = mode |
-            (open_file ? LIBSSH2_SFTP_ATTR_PFILETYPE_FILE :
-             LIBSSH2_SFTP_ATTR_PFILETYPE_DIR);
-
-        _libssh2_store_u32(&s, sftp->open_packet_len - 4);
-        *(s++) = open_file? SSH_FXP_OPEN : SSH_FXP_OPENDIR;
-        sftp->open_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->open_request_id);
-        _libssh2_store_str(&s, filename, filename_len);
-
-        if(open_file) {
-            _libssh2_store_u32(&s, flags);
-            s += sftp_attr2bin(s, &attrs);
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Sending %s open request",
-                       open_file? "file" : "directory");
-
-        sftp->open_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->open_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->open_packet+
-                                    sftp->open_packet_sent,
-                                    sftp->open_packet_len -
-                                    sftp->open_packet_sent);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block sending FXP_OPEN or "
-                           "FXP_OPENDIR command");
-            return NULL;
-        }
-        else if(rc < 0) {
-            _libssh2_error(session, rc, "Unable to send FXP_OPEN*");
-            LIBSSH2_FREE(session, sftp->open_packet);
-            sftp->open_packet = NULL;
-            sftp->open_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-
-        /* bump the sent counter and remain in this state until the whole
-           data is off */
-        sftp->open_packet_sent += rc;
-
-        if(sftp->open_packet_len == sftp->open_packet_sent) {
-            LIBSSH2_FREE(session, sftp->open_packet);
-            sftp->open_packet = NULL;
-
-            sftp->open_state = libssh2_NB_state_sent;
-        }
-    }
-
-    if(sftp->open_state == libssh2_NB_state_sent) {
-        size_t data_len;
-        unsigned char *data;
-        static const unsigned char fopen_responses[2] =
-            { SSH_FXP_HANDLE, SSH_FXP_STATUS };
-        rc = sftp_packet_requirev(sftp, 2, fopen_responses,
-                                  sftp->open_request_id, &data,
-                                  &data_len, 1);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block waiting for status message");
-            return NULL;
-        }
-        else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-            if(data_len > 0) {
-                LIBSSH2_FREE(session, data);
-            }
-            _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                           "Response too small");
-            return NULL;
-        }
-        sftp->open_state = libssh2_NB_state_idle;
-        if(rc) {
-            _libssh2_error(session, rc, "Timeout waiting for status message");
-            return NULL;
-        }
-
-        /* OPEN can basically get STATUS or HANDLE back, where HANDLE implies
-           a fine response while STATUS means error. It seems though that at
-           times we get an SSH_FX_OK back in a STATUS, followed the "real"
-           HANDLE so we need to properly deal with that. */
-        if(data[0] == SSH_FXP_STATUS) {
-            int badness = 1;
-
-            if(data_len < 9) {
-                _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                               "Too small FXP_STATUS");
-                LIBSSH2_FREE(session, data);
-                return NULL;
-            }
-
-            sftp->last_errno = _libssh2_ntohu32(data + 5);
-
-            if(LIBSSH2_FX_OK == sftp->last_errno) {
-                _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                               "got HANDLE FXOK!");
-
-                LIBSSH2_FREE(session, data);
-
-                /* silly situation, but check for a HANDLE */
-                rc = sftp_packet_require(sftp, SSH_FXP_HANDLE,
-                                         sftp->open_request_id, &data,
-                                         &data_len, 10);
-                if(rc == LIBSSH2_ERROR_EAGAIN) {
-                    /* go back to sent state and wait for something else */
-                    sftp->open_state = libssh2_NB_state_sent;
-                    return NULL;
-                }
-                else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-                    if(data_len > 0) {
-                        LIBSSH2_FREE(session, data);
-                    }
-                    _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                   "Too small FXP_HANDLE");
-                    return NULL;
-                }
-                else if(!rc)
-                    /* we got the handle so this is not a bad situation */
-                    badness = 0;
-            }
-
-            if(badness) {
-                _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                               "Failed opening remote file");
-                _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                               "got FXP_STATUS %d",
-                               sftp->last_errno);
-                LIBSSH2_FREE(session, data);
-                return NULL;
-            }
-        }
-
-        if(data_len < 10) {
-            _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                           "Too small FXP_HANDLE");
-            LIBSSH2_FREE(session, data);
-            return NULL;
-        }
-
-        fp = LIBSSH2_CALLOC(session, sizeof(LIBSSH2_SFTP_HANDLE));
-        if(!fp) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate new SFTP handle structure");
-            LIBSSH2_FREE(session, data);
-            return NULL;
-        }
-        fp->handle_type = open_file ? LIBSSH2_SFTP_HANDLE_FILE :
-            LIBSSH2_SFTP_HANDLE_DIR;
-
-        fp->handle_len = _libssh2_ntohu32(data + 5);
-        if(fp->handle_len > SFTP_HANDLE_MAXLEN)
-            /* SFTP doesn't allow handles longer than 256 characters */
-            fp->handle_len = SFTP_HANDLE_MAXLEN;
-
-        if(fp->handle_len > (data_len - 9))
-            /* do not reach beyond the end of the data we got */
-            fp->handle_len = data_len - 9;
-
-        memcpy(fp->handle, data + 9, fp->handle_len);
-
-        LIBSSH2_FREE(session, data);
-
-        /* add this file handle to the list kept in the sftp session */
-        _libssh2_list_add(&sftp->sftp_handles, &fp->node);
-
-        fp->sftp = sftp; /* point to the parent struct */
-
-        fp->u.file.offset = 0;
-        fp->u.file.offset_sent = 0;
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Open command successful");
-        return fp;
-    }
-    return NULL;
-}
-
-/* libssh2_sftp_open_ex
- */
-LIBSSH2_API LIBSSH2_SFTP_HANDLE *
-libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, const char *filename,
-                     unsigned int filename_len, unsigned long flags, long mode,
-                     int open_type)
-{
-    LIBSSH2_SFTP_HANDLE *hnd;
-
-    if(!sftp)
-        return NULL;
-
-    BLOCK_ADJUST_ERRNO(hnd, sftp->channel->session,
-                       sftp_open(sftp, filename, filename_len, flags, mode,
-                                 open_type));
-    return hnd;
-}
-
-/*
- * sftp_read
- *
- * Read from an SFTP file handle
- *
- */
-static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
-                         size_t buffer_size)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t count = 0;
-    struct sftp_pipeline_chunk *chunk;
-    struct sftp_pipeline_chunk *next;
-    ssize_t rc;
-    struct _libssh2_sftp_handle_file_data *filep =
-        &handle->u.file;
-    size_t bytes_in_buffer = 0;
-    char *sliding_bufferp = buffer;
-
-    /* This function can be interrupted in three different places where it
-       might need to wait for data from the network.  It returns EAGAIN to
-       allow non-blocking clients to do other work but these client are
-       expected to call this function again (possibly many times) to finish
-       the operation.
-
-       The tricky part is that if we previously aborted a sftp_read due to
-       EAGAIN, we must continue at the same spot to continue the previously
-       interrupted operation.  This is done using a state machine to record
-       what phase of execution we were at.  The state is stored in
-       sftp->read_state.
-
-       libssh2_NB_state_idle: The first phase is where we prepare multiple
-       FXP_READ packets to do optimistic read-ahead.  We send off as many as
-       possible in the second phase without waiting for a response to each
-       one; this is the key to fast reads. But we may have to adjust the
-       channel window size to do this which may interrupt this function while
-       waiting.  The state machine saves the phase as libssh2_NB_state_idle so
-       it returns here on the next call.
-
-       libssh2_NB_state_sent: The second phase is where we send the FXP_READ
-       packets.  Writing them to the channel can be interrupted with EAGAIN
-       but the state machine ensures we skip the first phase on the next call
-       and resume sending.
-
-       libssh2_NB_state_sent2: In the third phase (indicated by ) we read the
-       data from the responses that have arrived so far.  Reading can be
-       interrupted with EAGAIN but the state machine ensures we skip the first
-       and second phases on the next call and resume sending.
-    */
-
-    switch(sftp->read_state) {
-    case libssh2_NB_state_idle:
-
-        /* Some data may already have been read from the server in the
-           previous call but didn't fit in the buffer at the time.  If so, we
-           return that now as we can't risk being interrupted later with data
-           partially written to the buffer. */
-        if(filep->data_left) {
-            size_t copy = MIN(buffer_size, filep->data_left);
-
-            memcpy(buffer, &filep->data[ filep->data_len - filep->data_left],
-                   copy);
-
-            filep->data_left -= copy;
-            filep->offset += copy;
-
-            if(!filep->data_left) {
-                LIBSSH2_FREE(session, filep->data);
-                filep->data = NULL;
-            }
-
-            return copy;
-        }
-
-        if(filep->eof) {
-            return 0;
-        }
-        else {
-            /* We allow a number of bytes being requested at any given time
-               without having been acked - until we reach EOF. */
-
-            /* Number of bytes asked for that haven't been acked yet */
-            size_t already = (size_t)(filep->offset_sent - filep->offset);
-
-            size_t max_read_ahead = buffer_size*4;
-            unsigned long recv_window;
-
-            if(max_read_ahead > LIBSSH2_CHANNEL_WINDOW_DEFAULT*4)
-                max_read_ahead = LIBSSH2_CHANNEL_WINDOW_DEFAULT*4;
-
-            /* if the buffer_size passed in now is smaller than what has
-               already been sent, we risk getting count become a very large
-               number */
-            if(max_read_ahead > already)
-                count = max_read_ahead - already;
-
-            /* 'count' is how much more data to ask for, and 'already' is how
-               much data that already has been asked for but not yet returned.
-               Specifically, 'count' means how much data that have or will be
-               asked for by the nodes that are already added to the linked
-               list. Some of those read requests may not actually have been
-               sent off successfully yet.
-
-               If 'already' is very large it should be perfectly fine to have
-               count set to 0 as then we don't have to ask for more data
-               (right now).
-
-               buffer_size*4 is just picked more or less out of the air. The
-               idea is that when reading SFTP from a remote server, we send
-               away multiple read requests guessing that the client will read
-               more than only this 'buffer_size' amount of memory. So we ask
-               for maximum buffer_size*4 amount of data so that we can return
-               them very fast in subsequent calls.
-            */
-
-            recv_window = libssh2_channel_window_read_ex(sftp->channel,
-                                                         NULL, NULL);
-            if(max_read_ahead > recv_window) {
-                /* more data will be asked for than what the window currently
-                   allows, expand it! */
-
-                rc = _libssh2_channel_receive_window_adjust(sftp->channel,
-                                                            max_read_ahead*8,
-                                                            1, NULL);
-                /* if this returns EAGAIN, we will get back to this function
-                   at next call */
-                assert(rc != LIBSSH2_ERROR_EAGAIN || !filep->data_left);
-                assert(rc != LIBSSH2_ERROR_EAGAIN || !filep->eof);
-                if(rc)
-                    return rc;
-            }
-        }
-
-        while(count > 0) {
-            unsigned char *s;
-
-            /* 25 = packet_len(4) + packet_type(1) + request_id(4) +
-               handle_len(4) + offset(8) + count(4) */
-            uint32_t packet_len = (uint32_t)handle->handle_len + 25;
-            uint32_t request_id;
-
-            uint32_t size = count;
-            if(size < buffer_size)
-                size = buffer_size;
-            if(size > MAX_SFTP_READ_SIZE)
-                size = MAX_SFTP_READ_SIZE;
-
-            chunk = LIBSSH2_ALLOC(session, packet_len +
-                                  sizeof(struct sftp_pipeline_chunk));
-            if(!chunk)
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "malloc fail for FXP_WRITE");
-
-            chunk->offset = filep->offset_sent;
-            chunk->len = size;
-            chunk->lefttosend = packet_len;
-            chunk->sent = 0;
-
-            s = chunk->packet;
-
-            _libssh2_store_u32(&s, packet_len - 4);
-            *s++ = SSH_FXP_READ;
-            request_id = sftp->request_id++;
-            chunk->request_id = request_id;
-            _libssh2_store_u32(&s, request_id);
-            _libssh2_store_str(&s, handle->handle, handle->handle_len);
-            _libssh2_store_u64(&s, filep->offset_sent);
-            filep->offset_sent += size; /* advance offset at once */
-            _libssh2_store_u32(&s, size);
-
-            /* add this new entry LAST in the list */
-            _libssh2_list_add(&handle->packet_list, &chunk->node);
-            count -= MIN(size, count); /* deduct the size we used, as we might
-                                        * have to create more packets */
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                           "read request id %d sent (offset: %d, size: %d)",
-                           request_id, (int)chunk->offset, (int)chunk->len);
-        }
-        /* FALL-THROUGH */
-    case libssh2_NB_state_sent:
-
-        sftp->read_state = libssh2_NB_state_idle;
-
-        /* move through the READ packets that haven't been sent and send as
-           many as possible - remember that we don't block */
-        chunk = _libssh2_list_first(&handle->packet_list);
-
-        while(chunk) {
-            if(chunk->lefttosend) {
-
-                rc = _libssh2_channel_write(channel, 0,
-                                            &chunk->packet[chunk->sent],
-                                            chunk->lefttosend);
-                if(rc < 0) {
-                    sftp->read_state = libssh2_NB_state_sent;
-                    return rc;
-                }
-
-                /* remember where to continue sending the next time */
-                chunk->lefttosend -= rc;
-                chunk->sent += rc;
-
-                if(chunk->lefttosend) {
-                    /* We still have data left to send for this chunk.
-                     * If there is at least one completely sent chunk,
-                     * we can get out of this loop and start reading.  */
-                    if(chunk != _libssh2_list_first(&handle->packet_list)) {
-                        break;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-            }
-
-            /* move on to the next chunk with data to send */
-            chunk = _libssh2_list_next(&chunk->node);
-        }
-        /* FALL-THROUGH */
-
-    case libssh2_NB_state_sent2:
-
-        sftp->read_state = libssh2_NB_state_idle;
-
-        /*
-         * Count all ACKed packets and act on the contents of them.
-         */
-        chunk = _libssh2_list_first(&handle->packet_list);
-
-        while(chunk) {
-            unsigned char *data;
-            size_t data_len;
-            uint32_t rc32;
-            static const unsigned char read_responses[2] = {
-                SSH_FXP_DATA, SSH_FXP_STATUS
-            };
-
-            if(chunk->lefttosend) {
-                /* if the chunk still has data left to send, we shouldn't wait
-                   for an ACK for it just yet */
-                if(bytes_in_buffer > 0) {
-                    return bytes_in_buffer;
-                }
-                else {
-                    /* we should never reach this point */
-                    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                          "sftp_read() internal error");
-                }
-            }
-
-            rc = sftp_packet_requirev(sftp, 2, read_responses,
-                                      chunk->request_id, &data, &data_len, 9);
-            if(rc == LIBSSH2_ERROR_EAGAIN && bytes_in_buffer != 0) {
-                /* do not return EAGAIN if we have already
-                 * written data into the buffer */
-                return bytes_in_buffer;
-            }
-
-            if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-                if(data_len > 0) {
-                    LIBSSH2_FREE(session, data);
-                }
-                return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                      "Response too small");
-            }
-            else if(rc < 0) {
-                sftp->read_state = libssh2_NB_state_sent2;
-                return rc;
-            }
-
-            /*
-             * We get DATA or STATUS back. STATUS can be error, or it is
-             * FX_EOF when we reach the end of the file.
-             */
-
-            switch(data[0]) {
-            case SSH_FXP_STATUS:
-                /* remove the chunk we just processed */
-
-                _libssh2_list_remove(&chunk->node);
-                LIBSSH2_FREE(session, chunk);
-
-                /* we must remove all outstanding READ requests, as either we
-                   got an error or we're at end of file */
-                sftp_packetlist_flush(handle);
-
-                rc32 = _libssh2_ntohu32(data + 5);
-                LIBSSH2_FREE(session, data);
-
-                if(rc32 == LIBSSH2_FX_EOF) {
-                    filep->eof = TRUE;
-                    return bytes_in_buffer;
-                }
-                else {
-                    sftp->last_errno = rc32;
-                    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                          "SFTP READ error");
-                }
-                break;
-
-            case SSH_FXP_DATA:
-                if(chunk->offset != filep->offset) {
-                    /* This could happen if the server returns less bytes than
-                       requested, which shouldn't happen for normal files. See:
-                       https://tools.ietf.org/html/draft-ietf-secsh-filexfer-02
-                       #section-6.4
-                    */
-                    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                          "Read Packet At Unexpected Offset");
-                }
-
-                rc32 = _libssh2_ntohu32(data + 5);
-                if(rc32 > (data_len - 9))
-                    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                          "SFTP Protocol badness");
-
-                if(rc32 > chunk->len) {
-                    /* A chunk larger than we requested was returned to us.
-                       This is a protocol violation and we don't know how to
-                       deal with it. Bail out! */
-                    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                          "FXP_READ response too big");
-                }
-
-                if(rc32 != chunk->len) {
-                    /* a short read does not imply end of file, but we must
-                       adjust the offset_sent since it was advanced with a
-                       full chunk->len before */
-                    filep->offset_sent -= (chunk->len - rc32);
-                }
-
-                if((bytes_in_buffer + rc32) > buffer_size) {
-                    /* figure out the overlap amount */
-                    filep->data_left = (bytes_in_buffer + rc32) - buffer_size;
-
-                    /* getting the full packet would overflow the buffer, so
-                       only get the correct amount and keep the remainder */
-                    rc32 = (uint32_t)buffer_size - bytes_in_buffer;
-
-                    /* store data to keep for next call */
-                    filep->data = data;
-                    filep->data_len = data_len;
-                }
-                else
-                    filep->data_len = 0;
-
-                /* copy the received data from the received FXP_DATA packet to
-                   the buffer at the correct index */
-                memcpy(sliding_bufferp, data + 9, rc32);
-                filep->offset += rc32;
-                bytes_in_buffer += rc32;
-                sliding_bufferp += rc32;
-
-                if(filep->data_len == 0)
-                    /* free the allocated data if not stored to keep */
-                    LIBSSH2_FREE(session, data);
-
-                /* remove the chunk we just processed keeping track of the
-                 * next one in case we need it */
-                next = _libssh2_list_next(&chunk->node);
-                _libssh2_list_remove(&chunk->node);
-                LIBSSH2_FREE(session, chunk);
-
-                /* check if we have space left in the buffer
-                 * and either continue to the next chunk or stop
-                 */
-                if(bytes_in_buffer < buffer_size) {
-                    chunk = next;
-                }
-                else {
-                    chunk = NULL;
-                }
-
-                break;
-            default:
-                return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                      "SFTP Protocol badness: unrecognised "
-                                      "read request response");
-            }
-        }
-
-        if(bytes_in_buffer > 0)
-            return bytes_in_buffer;
-
-        break;
-
-    default:
-        assert(!"State machine error; unrecognised read state");
-    }
-
-    /* we should never reach this point */
-    return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                          "sftp_read() internal error");
-}
-
-/* libssh2_sftp_read
- * Read from an SFTP file handle
- */
-LIBSSH2_API ssize_t
-libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *hnd, char *buffer,
-                  size_t buffer_maxlen)
-{
-    ssize_t rc;
-    if(!hnd)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session,
-                 sftp_read(hnd, buffer, buffer_maxlen));
-    return rc;
-}
-
-/* sftp_readdir
- * Read from an SFTP directory handle
- */
-static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
-                            size_t buffer_maxlen, char *longentry,
-                            size_t longentry_maxlen,
-                            LIBSSH2_SFTP_ATTRIBUTES *attrs)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    uint32_t num_names;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 13;
-    unsigned char *s, *data;
-    static const unsigned char read_responses[2] = {
-        SSH_FXP_NAME, SSH_FXP_STATUS };
-    ssize_t retcode;
-
-    if(sftp->readdir_state == libssh2_NB_state_idle) {
-        if(handle->u.dir.names_left) {
-            /*
-             * A prior request returned more than one directory entry,
-             * feed it back from the buffer
-             */
-            LIBSSH2_SFTP_ATTRIBUTES attrs_dummy;
-            size_t real_longentry_len;
-            size_t real_filename_len;
-            size_t filename_len;
-            size_t longentry_len;
-            size_t names_packet_len = handle->u.dir.names_packet_len;
-            int attr_len = 0;
-
-            if(names_packet_len >= 4) {
-                s = (unsigned char *) handle->u.dir.next_name;
-                real_filename_len = _libssh2_ntohu32(s);
-                s += 4;
-                names_packet_len -= 4;
-            }
-            else {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            filename_len = real_filename_len;
-            if(filename_len >= buffer_maxlen) {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            if(buffer_maxlen >= filename_len && names_packet_len >=
-               filename_len) {
-                memcpy(buffer, s, filename_len);
-                buffer[filename_len] = '\0';           /* zero terminate */
-                s += real_filename_len;
-                names_packet_len -= real_filename_len;
-            }
-            else {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            if(names_packet_len >= 4) {
-                real_longentry_len = _libssh2_ntohu32(s);
-                s += 4;
-                names_packet_len -= 4;
-            }
-            else {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            if(longentry && (longentry_maxlen>1)) {
-                longentry_len = real_longentry_len;
-
-                if(longentry_len >= longentry_maxlen ||
-                   longentry_len > names_packet_len) {
-                    filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                    goto end;
-                }
-
-                memcpy(longentry, s, longentry_len);
-                longentry[longentry_len] = '\0'; /* zero terminate */
-            }
-
-            if(real_longentry_len <= names_packet_len) {
-                s += real_longentry_len;
-                names_packet_len -= real_longentry_len;
-            }
-            else {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            if(attrs)
-                memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
-
-            attr_len = sftp_bin2attr(attrs ? attrs : &attrs_dummy, s,
-                                     names_packet_len);
-
-            if(attr_len >= 0) {
-                s += attr_len;
-                names_packet_len -= attr_len;
-            }
-            else {
-                filename_len = (size_t)LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-                goto end;
-            }
-
-            handle->u.dir.next_name = (char *) s;
-            handle->u.dir.names_packet_len = names_packet_len;
-          end:
-
-            if((--handle->u.dir.names_left) == 0)
-                LIBSSH2_FREE(session, handle->u.dir.names_packet);
-
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                           "libssh2_sftp_readdir_ex() return %d",
-                           filename_len);
-            return (ssize_t)filename_len;
-        }
-
-        /* Request another entry(entries?) */
-
-        s = sftp->readdir_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->readdir_packet)
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "FXP_READDIR packet");
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_READDIR;
-        sftp->readdir_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->readdir_request_id);
-        _libssh2_store_str(&s, handle->handle, handle->handle_len);
-
-        sftp->readdir_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->readdir_state == libssh2_NB_state_created) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Reading entries from directory handle");
-        retcode = _libssh2_channel_write(channel, 0, sftp->readdir_packet,
-                                         packet_len);
-        if(retcode == LIBSSH2_ERROR_EAGAIN) {
-            return retcode;
-        }
-        else if((ssize_t)packet_len != retcode) {
-            LIBSSH2_FREE(session, sftp->readdir_packet);
-            sftp->readdir_packet = NULL;
-            sftp->readdir_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "_libssh2_channel_write() failed");
-        }
-
-        LIBSSH2_FREE(session, sftp->readdir_packet);
-        sftp->readdir_packet = NULL;
-
-        sftp->readdir_state = libssh2_NB_state_sent;
-    }
-
-    retcode = sftp_packet_requirev(sftp, 2, read_responses,
-                                   sftp->readdir_request_id, &data,
-                                   &data_len, 9);
-    if(retcode == LIBSSH2_ERROR_EAGAIN)
-        return retcode;
-    else if(retcode == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Status message too short");
-    }
-    else if(retcode) {
-        sftp->readdir_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, retcode,
-                              "Timeout waiting for status message");
-    }
-
-    if(data[0] == SSH_FXP_STATUS) {
-        retcode = _libssh2_ntohu32(data + 5);
-        LIBSSH2_FREE(session, data);
-        if(retcode == LIBSSH2_FX_EOF) {
-            sftp->readdir_state = libssh2_NB_state_idle;
-            return 0;
-        }
-        else {
-            sftp->last_errno = retcode;
-            sftp->readdir_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                  "SFTP Protocol Error");
-        }
-    }
-
-    sftp->readdir_state = libssh2_NB_state_idle;
-
-    num_names = _libssh2_ntohu32(data + 5);
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%lu entries returned",
-                   num_names);
-    if(!num_names) {
-        LIBSSH2_FREE(session, data);
-        return 0;
-    }
-
-    handle->u.dir.names_left = num_names;
-    handle->u.dir.names_packet = data;
-    handle->u.dir.next_name = (char *) data + 9;
-    handle->u.dir.names_packet_len = data_len - 9;
-
-    /* use the name popping mechanism from the start of the function */
-    return sftp_readdir(handle, buffer, buffer_maxlen, longentry,
-                        longentry_maxlen, attrs);
-}
-
-/* libssh2_sftp_readdir_ex
- * Read from an SFTP directory handle
- */
-LIBSSH2_API int
-libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *hnd, char *buffer,
-                        size_t buffer_maxlen, char *longentry,
-                        size_t longentry_maxlen,
-                        LIBSSH2_SFTP_ATTRIBUTES *attrs)
-{
-    int rc;
-    if(!hnd)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session,
-                 sftp_readdir(hnd, buffer, buffer_maxlen, longentry,
-                              longentry_maxlen, attrs));
-    return rc;
-}
-
-/*
- * sftp_write
- *
- * Write data to an SFTP handle. Returns the number of bytes written, or
- * a negative error code.
- *
- * We recommend sending very large data buffers to this function!
- *
- * Concept:
- *
- * - Detect how much of the given buffer that was already sent in a previous
- *   call by inspecting the linked list of outgoing chunks. Make sure to skip
- *   passed the data that has already been taken care of.
- *
- * - Split all (new) outgoing data in chunks no larger than N.
- *
- * - Each N bytes chunk gets created as a separate SFTP packet.
- *
- * - Add all created outgoing packets to the linked list.
- *
- * - Walk through the list and send the chunks that haven't been sent,
- *   as many as possible until EAGAIN. Some of the chunks may have been put
- *   in the list in a previous invoke.
- *
- * - For all the chunks in the list that have been completely sent off, check
- *   for ACKs. If a chunk has been ACKed, it is removed from the linked
- *   list and the "acked" counter gets increased with that data amount.
- *
- * - Return TOTAL bytes acked so far.
- *
- * Caveats:
- * -  be careful: we must not return a higher number than what was given!
- *
- * TODO:
- *   Introduce an option that disables this sort of "speculative" ahead writing
- *   as there's a risk that it will do harm to some app.
- */
-
-static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
-                          size_t count)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    uint32_t retcode;
-    uint32_t packet_len;
-    unsigned char *s, *data;
-    ssize_t rc;
-    struct sftp_pipeline_chunk *chunk;
-    struct sftp_pipeline_chunk *next;
-    size_t acked = 0;
-    size_t org_count = count;
-    size_t already;
-
-    switch(sftp->write_state) {
-    default:
-    case libssh2_NB_state_idle:
-
-        /* Number of bytes sent off that haven't been acked and therefore we
-           will get passed in here again.
-
-           Also, add up the number of bytes that actually already have been
-           acked but we haven't been able to return as such yet, so we will
-           get that data as well passed in here again.
-        */
-        already = (size_t) (handle->u.file.offset_sent -
-                            handle->u.file.offset)+
-            handle->u.file.acked;
-
-        if(count >= already) {
-            /* skip the part already made into packets */
-            buffer += already;
-            count -= already;
-        }
-        else
-            /* there is more data already fine than what we got in this call */
-            count = 0;
-
-        sftp->write_state = libssh2_NB_state_idle;
-        while(count) {
-            /* TODO: Possibly this should have some logic to prevent a very
-               very small fraction to be left but lets ignore that for now */
-            uint32_t size = MIN(MAX_SFTP_OUTGOING_SIZE, count);
-            uint32_t request_id;
-
-            /* 25 = packet_len(4) + packet_type(1) + request_id(4) +
-               handle_len(4) + offset(8) + count(4) */
-            packet_len = handle->handle_len + size + 25;
-
-            chunk = LIBSSH2_ALLOC(session, packet_len +
-                                  sizeof(struct sftp_pipeline_chunk));
-            if(!chunk)
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "malloc fail for FXP_WRITE");
-
-            chunk->len = size;
-            chunk->sent = 0;
-            chunk->lefttosend = packet_len;
-
-            s = chunk->packet;
-            _libssh2_store_u32(&s, packet_len - 4);
-
-            *(s++) = SSH_FXP_WRITE;
-            request_id = sftp->request_id++;
-            chunk->request_id = request_id;
-            _libssh2_store_u32(&s, request_id);
-            _libssh2_store_str(&s, handle->handle, handle->handle_len);
-            _libssh2_store_u64(&s, handle->u.file.offset_sent);
-            handle->u.file.offset_sent += size; /* advance offset at once */
-            _libssh2_store_str(&s, buffer, size);
-
-            /* add this new entry LAST in the list */
-            _libssh2_list_add(&handle->packet_list, &chunk->node);
-
-            buffer += size;
-            count -= size; /* deduct the size we used, as we might have
-                              to create more packets */
-        }
-
-        /* move through the WRITE packets that haven't been sent and send as
-           many as possible - remember that we don't block */
-        chunk = _libssh2_list_first(&handle->packet_list);
-
-        while(chunk) {
-            if(chunk->lefttosend) {
-                rc = _libssh2_channel_write(channel, 0,
-                                            &chunk->packet[chunk->sent],
-                                            chunk->lefttosend);
-                if(rc < 0)
-                    /* remain in idle state */
-                    return rc;
-
-                /* remember where to continue sending the next time */
-                chunk->lefttosend -= rc;
-                chunk->sent += rc;
-
-                if(chunk->lefttosend)
-                    /* data left to send, get out of loop */
-                    break;
-            }
-
-            /* move on to the next chunk with data to send */
-            chunk = _libssh2_list_next(&chunk->node);
-        }
-
-        /* fall-through */
-    case libssh2_NB_state_sent:
-
-        sftp->write_state = libssh2_NB_state_idle;
-        /*
-         * Count all ACKed packets
-         */
-        chunk = _libssh2_list_first(&handle->packet_list);
-
-        while(chunk) {
-            if(chunk->lefttosend)
-                /* if the chunk still has data left to send, we shouldn't wait
-                   for an ACK for it just yet */
-                break;
-
-            else if(acked)
-                /* if we have sent data that is acked, we must return that
-                   info before we call a function that might return EAGAIN */
-                break;
-
-            /* we check the packets in order */
-            rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                                     chunk->request_id, &data, &data_len, 9);
-            if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-                if(data_len > 0) {
-                    LIBSSH2_FREE(session, data);
-                }
-                return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                      "FXP write packet too short");
-            }
-            else if(rc < 0) {
-                if(rc == LIBSSH2_ERROR_EAGAIN)
-                    sftp->write_state = libssh2_NB_state_sent;
-                return rc;
-            }
-
-            retcode = _libssh2_ntohu32(data + 5);
-            LIBSSH2_FREE(session, data);
-
-            sftp->last_errno = retcode;
-            if(retcode == LIBSSH2_FX_OK) {
-                acked += chunk->len; /* number of payload data that was acked
-                                        here */
-
-                /* we increase the offset value for all acks */
-                handle->u.file.offset += chunk->len;
-
-                next = _libssh2_list_next(&chunk->node);
-
-                _libssh2_list_remove(&chunk->node); /* remove from list */
-                LIBSSH2_FREE(session, chunk); /* free memory */
-
-                chunk = next;
-            }
-            else {
-                /* flush all pending packets from the outgoing list */
-                sftp_packetlist_flush(handle);
-
-                /* since we return error now, the application will not get any
-                   outstanding data acked, so we need to rewind the offset to
-                   where the application knows it has reached with acked
-                   data */
-                handle->u.file.offset -= handle->u.file.acked;
-
-                /* then reset the offset_sent to be the same as the offset */
-                handle->u.file.offset_sent = handle->u.file.offset;
-
-                /* clear the acked counter since we can have no pending data to
-                   ack after an error */
-                handle->u.file.acked = 0;
-
-                /* the server returned an error for that written chunk,
-                   propagate this back to our parent function */
-                return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                      "FXP write failed");
-            }
-        }
-        break;
-    }
-
-    /* if there were acked data in a previous call that wasn't returned then,
-       add that up and try to return it all now. This can happen if the app
-       first sends a huge buffer of data, and then in a second call it sends a
-       smaller one. */
-    acked += handle->u.file.acked;
-
-    if(acked) {
-        ssize_t ret = MIN(acked, org_count);
-        /* we got data acked so return that amount, but no more than what
-           was asked to get sent! */
-
-        /* store the remainder. 'ret' is always equal to or less than 'acked'
-           here */
-        handle->u.file.acked = acked - ret;
-
-        return ret;
-    }
-
-    else
-        return 0; /* nothing was acked, and no EAGAIN was received! */
-}
-
-/* libssh2_sftp_write
- * Write data to a file handle
- */
-LIBSSH2_API ssize_t
-libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *hnd, const char *buffer,
-                   size_t count)
-{
-    ssize_t rc;
-    if(!hnd)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session,
-                 sftp_write(hnd, buffer, count));
-    return rc;
-
-}
-
-static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    /* 34 = packet_len(4) + packet_type(1) + request_id(4) +
-       string_len(4) + strlen("fsync@openssh.com")(17) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 34;
-    size_t data_len;
-    unsigned char *packet, *s, *data;
-    ssize_t rc;
-    uint32_t retcode;
-
-    if(sftp->fsync_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Issuing fsync command");
-        s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_EXTENDED "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_EXTENDED;
-        sftp->fsync_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->fsync_request_id);
-        _libssh2_store_str(&s, "fsync@openssh.com", 17);
-        _libssh2_store_str(&s, handle->handle, handle->handle_len);
-
-        sftp->fsync_state = libssh2_NB_state_created;
-    }
-    else {
-        packet = sftp->fsync_packet;
-    }
-
-    if(sftp->fsync_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN ||
-            (0 <= rc && rc < (ssize_t)packet_len)) {
-            sftp->fsync_packet = packet;
-            return LIBSSH2_ERROR_EAGAIN;
-        }
-
-        LIBSSH2_FREE(session, packet);
-        sftp->fsync_packet = NULL;
-
-        if(rc < 0) {
-            sftp->fsync_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "_libssh2_channel_write() failed");
-        }
-        sftp->fsync_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                             sftp->fsync_request_id, &data, &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP fsync packet too short");
-    }
-    else if(rc) {
-        sftp->fsync_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP EXTENDED REPLY");
-    }
-
-    sftp->fsync_state = libssh2_NB_state_idle;
-
-    retcode = _libssh2_ntohu32(data + 5);
-    LIBSSH2_FREE(session, data);
-
-    if(retcode != LIBSSH2_FX_OK) {
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "fsync failed");
-    }
-
-    return 0;
-}
-
-/* libssh2_sftp_fsync
- * Commit data on the handle to disk.
- */
-LIBSSH2_API int
-libssh2_sftp_fsync(LIBSSH2_SFTP_HANDLE *hnd)
-{
-    int rc;
-    if(!hnd)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session,
-                 sftp_fsync(hnd));
-    return rc;
-}
-
-
-/*
- * sftp_fstat
- *
- * Get or Set stat on a file
- */
-static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
-                      LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len =
-        handle->handle_len + 13 + (setstat ? sftp_attrsize(attrs->flags) : 0);
-    unsigned char *s, *data;
-    static const unsigned char fstat_responses[2] =
-        { SSH_FXP_ATTRS, SSH_FXP_STATUS };
-    ssize_t rc;
-
-    if(sftp->fstat_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Issuing %s command",
-                       setstat ? "set-stat" : "stat");
-        s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->fstat_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "FSTAT/FSETSTAT packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = setstat ? SSH_FXP_FSETSTAT : SSH_FXP_FSTAT;
-        sftp->fstat_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->fstat_request_id);
-        _libssh2_store_str(&s, handle->handle, handle->handle_len);
-
-        if(setstat) {
-            s += sftp_attr2bin(s, attrs);
-        }
-
-        sftp->fstat_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->fstat_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->fstat_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((ssize_t)packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->fstat_packet);
-            sftp->fstat_packet = NULL;
-            sftp->fstat_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  (setstat ? "Unable to send FXP_FSETSTAT"
-                                   : "Unable to send FXP_FSTAT command"));
-        }
-        LIBSSH2_FREE(session, sftp->fstat_packet);
-        sftp->fstat_packet = NULL;
-
-        sftp->fstat_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_requirev(sftp, 2, fstat_responses,
-                              sftp->fstat_request_id, &data,
-                              &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN)
-        return rc;
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP fstat packet too short");
-    }
-    else if(rc) {
-        sftp->fstat_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Timeout waiting for status message");
-    }
-
-    sftp->fstat_state = libssh2_NB_state_idle;
-
-    if(data[0] == SSH_FXP_STATUS) {
-        uint32_t retcode;
-
-        retcode = _libssh2_ntohu32(data + 5);
-        LIBSSH2_FREE(session, data);
-        if(retcode == LIBSSH2_FX_OK) {
-            return 0;
-        }
-        else {
-            sftp->last_errno = retcode;
-            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                  "SFTP Protocol Error");
-        }
-    }
-
-    if(sftp_bin2attr(attrs, data + 5, data_len - 5) < 0) {
-        LIBSSH2_FREE(session, data);
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Attributes too short in SFTP fstat");
-    }
-
-    LIBSSH2_FREE(session, data);
-
-    return 0;
-}
-
-/* libssh2_sftp_fstat_ex
- * Get or Set stat on a file
- */
-LIBSSH2_API int
-libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *hnd,
-                      LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat)
-{
-    int rc;
-    if(!hnd || !attrs)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session,
-                 sftp_fstat(hnd, attrs, setstat));
-    return rc;
-}
-
-
-/* libssh2_sftp_seek64
- * Set the read/write pointer to an arbitrary position within the file
- */
-LIBSSH2_API void
-libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle, libssh2_uint64_t offset)
-{
-    if(!handle)
-        return;
-    if(handle->u.file.offset == offset && handle->u.file.offset_sent == offset)
-        return;
-
-    handle->u.file.offset = handle->u.file.offset_sent = offset;
-    /* discard all pending requests and currently read data */
-    sftp_packetlist_flush(handle);
-
-    /* free the left received buffered data */
-    if(handle->u.file.data_left) {
-        LIBSSH2_FREE(handle->sftp->channel->session, handle->u.file.data);
-        handle->u.file.data_left = handle->u.file.data_len = 0;
-        handle->u.file.data = NULL;
-    }
-
-    /* reset EOF to False */
-    handle->u.file.eof = FALSE;
-}
-
-/* libssh2_sftp_seek
- * Set the read/write pointer to an arbitrary position within the file
- */
-LIBSSH2_API void
-libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset)
-{
-    libssh2_sftp_seek64(handle, (libssh2_uint64_t)offset);
-}
-
-/* libssh2_sftp_tell
- * Return the current read/write pointer's offset
- */
-LIBSSH2_API size_t
-libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle)
-{
-    if(!handle)
-        return 0; /* no handle, no size */
-
-    /* NOTE: this may very well truncate the size if it is larger than what
-       size_t can hold, so libssh2_sftp_tell64() is really the function you
-       should use */
-    return (size_t)(handle->u.file.offset);
-}
-
-/* libssh2_sftp_tell64
- * Return the current read/write pointer's offset
- */
-LIBSSH2_API libssh2_uint64_t
-libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle)
-{
-    if(!handle)
-        return 0; /* no handle, no size */
-
-    return handle->u.file.offset;
-}
-
-/*
- * Flush all remaining incoming SFTP packets and zombies.
- */
-static void sftp_packet_flush(LIBSSH2_SFTP *sftp)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    LIBSSH2_SFTP_PACKET *packet = _libssh2_list_first(&sftp->packets);
-    struct sftp_zombie_requests *zombie =
-        _libssh2_list_first(&sftp->zombie_requests);
-
-    while(packet) {
-        LIBSSH2_SFTP_PACKET *next;
-
-        /* check next struct in the list */
-        next =  _libssh2_list_next(&packet->node);
-        _libssh2_list_remove(&packet->node);
-        LIBSSH2_FREE(session, packet->data);
-        LIBSSH2_FREE(session, packet);
-
-        packet = next;
-    }
-
-    while(zombie) {
-        /* figure out the next node */
-        struct sftp_zombie_requests *next = _libssh2_list_next(&zombie->node);
-        /* unlink the current one */
-        _libssh2_list_remove(&zombie->node);
-        /* free the memory */
-        LIBSSH2_FREE(session, zombie);
-        zombie = next;
-    }
-
-}
-
-/* sftp_close_handle
- *
- * Close a file or directory handle.
- * Also frees handle resource and unlinks it from the SFTP structure.
- * The handle is no longer usable after return of this function, unless
- * the return value is LIBSSH2_ERROR_EAGAIN in which case this function
- * should be called again.
- */
-static int
-sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 13;
-    unsigned char *s, *data = NULL;
-    int rc = 0;
-
-    if(handle->close_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Closing handle");
-        s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!handle->close_packet) {
-            handle->close_state = libssh2_NB_state_idle;
-            rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                "Unable to allocate memory for FXP_CLOSE "
-                                "packet");
-        }
-        else {
-
-            _libssh2_store_u32(&s, packet_len - 4);
-            *(s++) = SSH_FXP_CLOSE;
-            handle->close_request_id = sftp->request_id++;
-            _libssh2_store_u32(&s, handle->close_request_id);
-            _libssh2_store_str(&s, handle->handle, handle->handle_len);
-            handle->close_state = libssh2_NB_state_created;
-        }
-    }
-
-    if(handle->close_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, handle->close_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((ssize_t)packet_len != rc) {
-            handle->close_state = libssh2_NB_state_idle;
-            rc = _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                "Unable to send FXP_CLOSE command");
-        }
-        else
-            handle->close_state = libssh2_NB_state_sent;
-
-        LIBSSH2_FREE(session, handle->close_packet);
-        handle->close_packet = NULL;
-    }
-
-    if(handle->close_state == libssh2_NB_state_sent) {
-        rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                                 handle->close_request_id, &data,
-                                 &data_len, 9);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-            if(data_len > 0) {
-                LIBSSH2_FREE(session, data);
-            }
-            data = NULL;
-            _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                           "Packet too short in FXP_CLOSE command");
-        }
-        else if(rc) {
-            _libssh2_error(session, rc,
-                           "Error waiting for status message");
-        }
-
-        handle->close_state = libssh2_NB_state_sent1;
-    }
-
-    if(!data) {
-        /* if it reaches this point with data unset, something unwanted
-           happened for which we should have set an error code */
-        assert(rc);
-
-    }
-    else {
-        int retcode = _libssh2_ntohu32(data + 5);
-        LIBSSH2_FREE(session, data);
-
-        if(retcode != LIBSSH2_FX_OK) {
-            sftp->last_errno = retcode;
-            handle->close_state = libssh2_NB_state_idle;
-            rc = _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                "SFTP Protocol Error");
-        }
-    }
-
-    /* remove this handle from the parent's list */
-    _libssh2_list_remove(&handle->node);
-
-    if(handle->handle_type == LIBSSH2_SFTP_HANDLE_DIR) {
-        if(handle->u.dir.names_left)
-            LIBSSH2_FREE(session, handle->u.dir.names_packet);
-    }
-    else if(handle->handle_type == LIBSSH2_SFTP_HANDLE_FILE) {
-        if(handle->u.file.data)
-            LIBSSH2_FREE(session, handle->u.file.data);
-    }
-
-    sftp_packetlist_flush(handle);
-    sftp->read_state = libssh2_NB_state_idle;
-
-    handle->close_state = libssh2_NB_state_idle;
-
-    LIBSSH2_FREE(session, handle);
-
-    return rc;
-}
-
-/* libssh2_sftp_close_handle
- *
- * Close a file or directory handle
- * Also frees handle resource and unlinks it from the SFTP structure
- */
-LIBSSH2_API int
-libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *hnd)
-{
-    int rc;
-    if(!hnd)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, hnd->sftp->channel->session, sftp_close_handle(hnd));
-    return rc;
-}
-
-/* sftp_unlink
- * Delete a file from the remote server
- */
-static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
-                       size_t filename_len)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    int retcode;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) */
-    uint32_t packet_len = filename_len + 13;
-    unsigned char *s, *data;
-    int rc;
-
-    if(sftp->unlink_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Unlinking %s", filename);
-        s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->unlink_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_REMOVE "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_REMOVE;
-        sftp->unlink_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->unlink_request_id);
-        _libssh2_store_str(&s, filename, filename_len);
-        sftp->unlink_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->unlink_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->unlink_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((ssize_t)packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->unlink_packet);
-            sftp->unlink_packet = NULL;
-            sftp->unlink_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send FXP_REMOVE command");
-        }
-        LIBSSH2_FREE(session, sftp->unlink_packet);
-        sftp->unlink_packet = NULL;
-
-        sftp->unlink_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                             sftp->unlink_request_id, &data,
-                             &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP unlink packet too short");
-    }
-    else if(rc) {
-        sftp->unlink_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP STATUS");
-    }
-
-    sftp->unlink_state = libssh2_NB_state_idle;
-
-    retcode = _libssh2_ntohu32(data + 5);
-    LIBSSH2_FREE(session, data);
-
-    if(retcode == LIBSSH2_FX_OK) {
-        return 0;
-    }
-    else {
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error");
-    }
-}
-
-/* libssh2_sftp_unlink_ex
- * Delete a file from the remote server
- */
-LIBSSH2_API int
-libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename,
-                       unsigned int filename_len)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_unlink(sftp, filename, filename_len));
-    return rc;
-}
-
-/*
- * sftp_rename
- *
- * Rename a file on the remote server
- */
-static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
-                       unsigned int source_filename_len,
-                       const char *dest_filename,
-                       unsigned int dest_filename_len, long flags)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    int retcode;
-    uint32_t packet_len =
-        source_filename_len + dest_filename_len + 17 + (sftp->version >=
-                                                        5 ? 4 : 0);
-    /* packet_len(4) + packet_type(1) + request_id(4) +
-       source_filename_len(4) + dest_filename_len(4) + flags(4){SFTP5+) */
-    unsigned char *data;
-    ssize_t rc;
-
-    if(sftp->version < 2) {
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Server does not support RENAME");
-    }
-
-    if(sftp->rename_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Renaming %s to %s",
-                       source_filename, dest_filename);
-        sftp->rename_s = sftp->rename_packet =
-            LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->rename_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_RENAME "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&sftp->rename_s, packet_len - 4);
-        *(sftp->rename_s++) = SSH_FXP_RENAME;
-        sftp->rename_request_id = sftp->request_id++;
-        _libssh2_store_u32(&sftp->rename_s, sftp->rename_request_id);
-        _libssh2_store_str(&sftp->rename_s, source_filename,
-                           source_filename_len);
-        _libssh2_store_str(&sftp->rename_s, dest_filename, dest_filename_len);
-
-        if(sftp->version >= 5)
-            _libssh2_store_u32(&sftp->rename_s, flags);
-
-        sftp->rename_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->rename_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->rename_packet,
-                                    sftp->rename_s - sftp->rename_packet);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if((ssize_t)packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->rename_packet);
-            sftp->rename_packet = NULL;
-            sftp->rename_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send FXP_RENAME command");
-        }
-        LIBSSH2_FREE(session, sftp->rename_packet);
-        sftp->rename_packet = NULL;
-
-        sftp->rename_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                             sftp->rename_request_id, &data,
-                             &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP rename packet too short");
-    }
-    else if(rc) {
-        sftp->rename_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP STATUS");
-    }
-
-    sftp->rename_state = libssh2_NB_state_idle;
-
-    retcode = _libssh2_ntohu32(data + 5);
-    LIBSSH2_FREE(session, data);
-
-    sftp->last_errno = retcode;
-
-    /* now convert the SFTP error code to libssh2 return code or error
-       message */
-    switch(retcode) {
-    case LIBSSH2_FX_OK:
-        retcode = LIBSSH2_ERROR_NONE;
-        break;
-
-    case LIBSSH2_FX_FILE_ALREADY_EXISTS:
-        retcode = _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                 "File already exists and "
-                                 "SSH_FXP_RENAME_OVERWRITE not specified");
-        break;
-
-    case LIBSSH2_FX_OP_UNSUPPORTED:
-        retcode = _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                 "Operation Not Supported");
-        break;
-
-    default:
-        retcode = _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                 "SFTP Protocol Error");
-        break;
-    }
-
-    return retcode;
-}
-
-/* libssh2_sftp_rename_ex
- * Rename a file on the remote server
- */
-LIBSSH2_API int
-libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename,
-                       unsigned int source_filename_len,
-                       const char *dest_filename,
-                       unsigned int dest_filename_len, long flags)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_rename(sftp, source_filename, source_filename_len,
-                             dest_filename, dest_filename_len, flags));
-    return rc;
-}
-
-/*
- * sftp_fstatvfs
- *
- * Get file system statistics
- */
-static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
-{
-    LIBSSH2_SFTP *sftp = handle->sftp;
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    /* 17 = packet_len(4) + packet_type(1) + request_id(4) + ext_len(4)
-       + handle_len (4) */
-    /* 20 = strlen ("fstatvfs@openssh.com") */
-    uint32_t packet_len = handle->handle_len + 20 + 17;
-    unsigned char *packet, *s, *data;
-    ssize_t rc;
-    unsigned int flag;
-    static const unsigned char responses[2] =
-        { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
-
-    if(sftp->fstatvfs_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Getting file system statistics");
-        s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_EXTENDED "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_EXTENDED;
-        sftp->fstatvfs_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->fstatvfs_request_id);
-        _libssh2_store_str(&s, "fstatvfs@openssh.com", 20);
-        _libssh2_store_str(&s, handle->handle, handle->handle_len);
-
-        sftp->fstatvfs_state = libssh2_NB_state_created;
-    }
-    else {
-        packet = sftp->fstatvfs_packet;
-    }
-
-    if(sftp->fstatvfs_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN ||
-            (0 <= rc && rc < (ssize_t)packet_len)) {
-            sftp->fstatvfs_packet = packet;
-            return LIBSSH2_ERROR_EAGAIN;
-        }
-
-        LIBSSH2_FREE(session, packet);
-        sftp->fstatvfs_packet = NULL;
-
-        if(rc < 0) {
-            sftp->fstatvfs_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "_libssh2_channel_write() failed");
-        }
-        sftp->fstatvfs_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_requirev(sftp, 2, responses, sftp->fstatvfs_request_id,
-                              &data, &data_len, 9);
-
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP rename packet too short");
-    }
-    else if(rc) {
-        sftp->fstatvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP EXTENDED REPLY");
-    }
-
-    if(data[0] == SSH_FXP_STATUS) {
-        int retcode = _libssh2_ntohu32(data + 5);
-        sftp->fstatvfs_state = libssh2_NB_state_idle;
-        LIBSSH2_FREE(session, data);
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error");
-    }
-
-    if(data_len < 93) {
-        LIBSSH2_FREE(session, data);
-        sftp->fstatvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error: short response");
-    }
-
-    sftp->fstatvfs_state = libssh2_NB_state_idle;
-
-    st->f_bsize = _libssh2_ntohu64(data + 5);
-    st->f_frsize = _libssh2_ntohu64(data + 13);
-    st->f_blocks = _libssh2_ntohu64(data + 21);
-    st->f_bfree = _libssh2_ntohu64(data + 29);
-    st->f_bavail = _libssh2_ntohu64(data + 37);
-    st->f_files = _libssh2_ntohu64(data + 45);
-    st->f_ffree = _libssh2_ntohu64(data + 53);
-    st->f_favail = _libssh2_ntohu64(data + 61);
-    st->f_fsid = _libssh2_ntohu64(data + 69);
-    flag = (unsigned int)_libssh2_ntohu64(data + 77);
-    st->f_namemax = _libssh2_ntohu64(data + 85);
-
-    st->f_flag = (flag & SSH_FXE_STATVFS_ST_RDONLY)
-        ? LIBSSH2_SFTP_ST_RDONLY : 0;
-    st->f_flag |= (flag & SSH_FXE_STATVFS_ST_NOSUID)
-        ? LIBSSH2_SFTP_ST_NOSUID : 0;
-
-    LIBSSH2_FREE(session, data);
-    return 0;
-}
-
-/* libssh2_sftp_fstatvfs
- * Get filesystem space and inode utilization (requires fstatvfs@openssh.com
- * support on the server)
- */
-LIBSSH2_API int
-libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
-{
-    int rc;
-    if(!handle || !st)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, handle->sftp->channel->session,
-                 sftp_fstatvfs(handle, st));
-    return rc;
-}
-
-/*
- * sftp_statvfs
- *
- * Get file system statistics
- */
-static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
-                        unsigned int path_len, LIBSSH2_SFTP_STATVFS *st)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    /* 17 = packet_len(4) + packet_type(1) + request_id(4) + ext_len(4)
-       + path_len (4) */
-    /* 19 = strlen ("statvfs@openssh.com") */
-    uint32_t packet_len = path_len + 19 + 17;
-    unsigned char *packet, *s, *data;
-    ssize_t rc;
-    unsigned int flag;
-    static const unsigned char responses[2] =
-        { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
-
-    if(sftp->statvfs_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Getting file system statistics of %s", path);
-        s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_EXTENDED "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_EXTENDED;
-        sftp->statvfs_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->statvfs_request_id);
-        _libssh2_store_str(&s, "statvfs@openssh.com", 19);
-        _libssh2_store_str(&s, path, path_len);
-
-        sftp->statvfs_state = libssh2_NB_state_created;
-    }
-    else {
-        packet = sftp->statvfs_packet;
-    }
-
-    if(sftp->statvfs_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN ||
-            (0 <= rc && rc < (ssize_t)packet_len)) {
-            sftp->statvfs_packet = packet;
-            return LIBSSH2_ERROR_EAGAIN;
-        }
-
-        LIBSSH2_FREE(session, packet);
-        sftp->statvfs_packet = NULL;
-
-        if(rc < 0) {
-            sftp->statvfs_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "_libssh2_channel_write() failed");
-        }
-        sftp->statvfs_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_requirev(sftp, 2, responses, sftp->statvfs_request_id,
-                              &data, &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP fstat packet too short");
-    }
-    else if(rc) {
-        sftp->statvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP EXTENDED REPLY");
-    }
-
-    if(data[0] == SSH_FXP_STATUS) {
-        int retcode = _libssh2_ntohu32(data + 5);
-        sftp->statvfs_state = libssh2_NB_state_idle;
-        LIBSSH2_FREE(session, data);
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error");
-    }
-
-    if(data_len < 93) {
-        LIBSSH2_FREE(session, data);
-        sftp->statvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error: short response");
-    }
-
-    sftp->statvfs_state = libssh2_NB_state_idle;
-
-    st->f_bsize = _libssh2_ntohu64(data + 5);
-    st->f_frsize = _libssh2_ntohu64(data + 13);
-    st->f_blocks = _libssh2_ntohu64(data + 21);
-    st->f_bfree = _libssh2_ntohu64(data + 29);
-    st->f_bavail = _libssh2_ntohu64(data + 37);
-    st->f_files = _libssh2_ntohu64(data + 45);
-    st->f_ffree = _libssh2_ntohu64(data + 53);
-    st->f_favail = _libssh2_ntohu64(data + 61);
-    st->f_fsid = _libssh2_ntohu64(data + 69);
-    flag = (unsigned int)_libssh2_ntohu64(data + 77);
-    st->f_namemax = _libssh2_ntohu64(data + 85);
-
-    st->f_flag = (flag & SSH_FXE_STATVFS_ST_RDONLY)
-        ? LIBSSH2_SFTP_ST_RDONLY : 0;
-    st->f_flag |= (flag & SSH_FXE_STATVFS_ST_NOSUID)
-        ? LIBSSH2_SFTP_ST_NOSUID : 0;
-
-    LIBSSH2_FREE(session, data);
-    return 0;
-}
-
-/* libssh2_sftp_statvfs_ex
- * Get filesystem space and inode utilization (requires statvfs@openssh.com
- * support on the server)
- */
-LIBSSH2_API int
-libssh2_sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
-                     size_t path_len, LIBSSH2_SFTP_STATVFS *st)
-{
-    int rc;
-    if(!sftp || !st)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session, sftp_statvfs(sftp, path, path_len,
-                                                          st));
-    return rc;
-}
-
-
-/*
- * sftp_mkdir
- *
- * Create an SFTP directory
- */
-static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
-                      unsigned int path_len, long mode)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    LIBSSH2_SFTP_ATTRIBUTES attrs = {
-        0, 0, 0, 0, 0, 0, 0
-    };
-    size_t data_len;
-    int retcode;
-    ssize_t packet_len;
-    unsigned char *packet, *s, *data;
-    int rc;
-
-    if(mode != LIBSSH2_SFTP_DEFAULT_MODE) {
-        /* Filetype in SFTP 3 and earlier */
-        attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS;
-        attrs.permissions = mode | LIBSSH2_SFTP_ATTR_PFILETYPE_DIR;
-    }
-
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
-    packet_len = path_len + 13 + sftp_attrsize(attrs.flags);
-
-    if(sftp->mkdir_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Creating directory %s with mode 0%lo", path, mode);
-        s = packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_MKDIR "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_MKDIR;
-        sftp->mkdir_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->mkdir_request_id);
-        _libssh2_store_str(&s, path, path_len);
-
-        s += sftp_attr2bin(s, &attrs);
-
-        sftp->mkdir_state = libssh2_NB_state_created;
-    }
-    else {
-        packet = sftp->mkdir_packet;
-    }
-
-    if(sftp->mkdir_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            sftp->mkdir_packet = packet;
-            return rc;
-        }
-        if(packet_len != rc) {
-            LIBSSH2_FREE(session, packet);
-            sftp->mkdir_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "_libssh2_channel_write() failed");
-        }
-        LIBSSH2_FREE(session, packet);
-        sftp->mkdir_state = libssh2_NB_state_sent;
-        sftp->mkdir_packet = NULL;
-    }
-
-    rc = sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->mkdir_request_id,
-                             &data, &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP mkdir packet too short");
-    }
-    else if(rc) {
-        sftp->mkdir_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP STATUS");
-    }
-
-    sftp->mkdir_state = libssh2_NB_state_idle;
-
-    retcode = _libssh2_ntohu32(data + 5);
-    LIBSSH2_FREE(session, data);
-
-    if(retcode == LIBSSH2_FX_OK) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "OK!");
-        return 0;
-    }
-    else {
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error");
-    }
-}
-
-/*
- * libssh2_sftp_mkdir_ex
- *
- * Create an SFTP directory
- */
-LIBSSH2_API int
-libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, const char *path,
-                      unsigned int path_len, long mode)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_mkdir(sftp, path, path_len, mode));
-    return rc;
-}
-
-/* sftp_rmdir
- * Remove a directory
- */
-static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
-                      unsigned int path_len)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    int retcode;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
-    ssize_t packet_len = path_len + 13;
-    unsigned char *s, *data;
-    int rc;
-
-    if(sftp->rmdir_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Removing directory: %s",
-                       path);
-        s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->rmdir_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_RMDIR "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-        *(s++) = SSH_FXP_RMDIR;
-        sftp->rmdir_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->rmdir_request_id);
-        _libssh2_store_str(&s, path, path_len);
-
-        sftp->rmdir_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->rmdir_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->rmdir_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->rmdir_packet);
-            sftp->rmdir_packet = NULL;
-            sftp->rmdir_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send FXP_RMDIR command");
-        }
-        LIBSSH2_FREE(session, sftp->rmdir_packet);
-        sftp->rmdir_packet = NULL;
-
-        sftp->rmdir_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
-                             sftp->rmdir_request_id, &data, &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
-    }
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP rmdir packet too short");
-    }
-    else if(rc) {
-        sftp->rmdir_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Error waiting for FXP STATUS");
-    }
-
-    sftp->rmdir_state = libssh2_NB_state_idle;
-
-    retcode = _libssh2_ntohu32(data + 5);
-    LIBSSH2_FREE(session, data);
-
-    if(retcode == LIBSSH2_FX_OK) {
-        return 0;
-    }
-    else {
-        sftp->last_errno = retcode;
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP Protocol Error");
-    }
-}
-
-/* libssh2_sftp_rmdir_ex
- * Remove a directory
- */
-LIBSSH2_API int
-libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
-                      unsigned int path_len)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_rmdir(sftp, path, path_len));
-    return rc;
-}
-
-/* sftp_stat
- * Stat a file or symbolic link
- */
-static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
-                     unsigned int path_len, int stat_type,
-                     LIBSSH2_SFTP_ATTRIBUTES * attrs)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
-    ssize_t packet_len =
-        path_len + 13 +
-        ((stat_type ==
-          LIBSSH2_SFTP_SETSTAT) ? sftp_attrsize(attrs->flags) : 0);
-    unsigned char *s, *data;
-    static const unsigned char stat_responses[2] =
-        { SSH_FXP_ATTRS, SSH_FXP_STATUS };
-    int rc;
-
-    if(sftp->stat_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s",
-                       (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" :
-                       (stat_type ==
-                        LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
-        s = sftp->stat_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->stat_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for FXP_*STAT "
-                                  "packet");
-        }
-
-        _libssh2_store_u32(&s, packet_len - 4);
-
-        switch(stat_type) {
-        case LIBSSH2_SFTP_SETSTAT:
-            *(s++) = SSH_FXP_SETSTAT;
-            break;
-
-        case LIBSSH2_SFTP_LSTAT:
-            *(s++) = SSH_FXP_LSTAT;
-            break;
-
-        case LIBSSH2_SFTP_STAT:
-        default:
-            *(s++) = SSH_FXP_STAT;
-        }
-        sftp->stat_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->stat_request_id);
-        _libssh2_store_str(&s, path, path_len);
-
-        if(stat_type == LIBSSH2_SFTP_SETSTAT)
-            s += sftp_attr2bin(s, attrs);
-
-        sftp->stat_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->stat_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->stat_packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
-        }
-        else if(packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->stat_packet);
-            sftp->stat_packet = NULL;
-            sftp->stat_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send STAT/LSTAT/SETSTAT command");
-        }
-        LIBSSH2_FREE(session, sftp->stat_packet);
-        sftp->stat_packet = NULL;
-
-        sftp->stat_state = libssh2_NB_state_sent;
-    }
-
-    rc = sftp_packet_requirev(sftp, 2, stat_responses,
-                              sftp->stat_request_id, &data, &data_len, 9);
-    if(rc == LIBSSH2_ERROR_EAGAIN)
-        return rc;
-    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP stat packet too short");
-    }
-    else if(rc) {
-        sftp->stat_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
-                              "Timeout waiting for status message");
-    }
-
-    sftp->stat_state = libssh2_NB_state_idle;
-
-    if(data[0] == SSH_FXP_STATUS) {
-        int retcode;
-
-        retcode = _libssh2_ntohu32(data + 5);
-        LIBSSH2_FREE(session, data);
-        if(retcode == LIBSSH2_FX_OK) {
-            memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
-            return 0;
-        }
-        else {
-            sftp->last_errno = retcode;
-            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                  "SFTP Protocol Error");
-        }
-    }
-
-    memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
-    if(sftp_bin2attr(attrs, data + 5, data_len - 5) < 0) {
-        LIBSSH2_FREE(session, data);
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Attributes too short in SFTP fstat");
-    }
-
-    LIBSSH2_FREE(session, data);
-
-    return 0;
-}
-
-/* libssh2_sftp_stat_ex
- * Stat a file or symbolic link
- */
-LIBSSH2_API int
-libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path,
-                     unsigned int path_len, int stat_type,
-                     LIBSSH2_SFTP_ATTRIBUTES *attrs)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_stat(sftp, path, path_len, stat_type, attrs));
-    return rc;
-}
-
-/* sftp_symlink
- * Read or set a symlink
- */
-static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
-                        unsigned int path_len, char *target,
-                        unsigned int target_len, int link_type)
-{
-    LIBSSH2_CHANNEL *channel = sftp->channel;
-    LIBSSH2_SESSION *session = channel->session;
-    size_t data_len, link_len;
-    /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
-    ssize_t packet_len =
-        path_len + 13 +
-        ((link_type == LIBSSH2_SFTP_SYMLINK) ? (4 + target_len) : 0);
-    unsigned char *s, *data;
-    static const unsigned char link_responses[2] =
-        { SSH_FXP_NAME, SSH_FXP_STATUS };
-    int retcode;
-
-    if((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) {
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Server does not support SYMLINK or READLINK");
-    }
-
-    if(sftp->symlink_state == libssh2_NB_state_idle) {
-        s = sftp->symlink_packet = LIBSSH2_ALLOC(session, packet_len);
-        if(!sftp->symlink_packet) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "SYMLINK/READLINK/REALPATH packet");
-        }
-
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s on %s",
-                       (link_type ==
-                        LIBSSH2_SFTP_SYMLINK) ? "Creating" : "Reading",
-                       (link_type ==
-                        LIBSSH2_SFTP_REALPATH) ? "realpath" : "symlink", path);
-
-        _libssh2_store_u32(&s, packet_len - 4);
-
-        switch(link_type) {
-        case LIBSSH2_SFTP_REALPATH:
-            *(s++) = SSH_FXP_REALPATH;
-            break;
-
-        case LIBSSH2_SFTP_SYMLINK:
-            *(s++) = SSH_FXP_SYMLINK;
-            break;
-
-        case LIBSSH2_SFTP_READLINK:
-        default:
-            *(s++) = SSH_FXP_READLINK;
-        }
-        sftp->symlink_request_id = sftp->request_id++;
-        _libssh2_store_u32(&s, sftp->symlink_request_id);
-        _libssh2_store_str(&s, path, path_len);
-
-        if(link_type == LIBSSH2_SFTP_SYMLINK)
-            _libssh2_store_str(&s, target, target_len);
-
-        sftp->symlink_state = libssh2_NB_state_created;
-    }
-
-    if(sftp->symlink_state == libssh2_NB_state_created) {
-        ssize_t rc = _libssh2_channel_write(channel, 0, sftp->symlink_packet,
-                                            packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-        else if(packet_len != rc) {
-            LIBSSH2_FREE(session, sftp->symlink_packet);
-            sftp->symlink_packet = NULL;
-            sftp->symlink_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send SYMLINK/READLINK command");
-        }
-        LIBSSH2_FREE(session, sftp->symlink_packet);
-        sftp->symlink_packet = NULL;
-
-        sftp->symlink_state = libssh2_NB_state_sent;
-    }
-
-    retcode = sftp_packet_requirev(sftp, 2, link_responses,
-                                   sftp->symlink_request_id, &data,
-                                   &data_len, 9);
-    if(retcode == LIBSSH2_ERROR_EAGAIN)
-        return retcode;
-    else if(retcode == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP symlink packet too short");
-    }
-    else if(retcode) {
-        sftp->symlink_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, retcode,
-                              "Error waiting for status message");
-    }
-
-    sftp->symlink_state = libssh2_NB_state_idle;
-
-    if(data[0] == SSH_FXP_STATUS) {
-        retcode = _libssh2_ntohu32(data + 5);
-        LIBSSH2_FREE(session, data);
-        if(retcode == LIBSSH2_FX_OK)
-            return LIBSSH2_ERROR_NONE;
-        else {
-            sftp->last_errno = retcode;
-            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                                  "SFTP Protocol Error");
-        }
-    }
-
-    if(_libssh2_ntohu32(data + 5) < 1) {
-        LIBSSH2_FREE(session, data);
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Invalid READLINK/REALPATH response, "
-                              "no name entries");
-    }
-
-    if(data_len < 13) {
-        if(data_len > 0) {
-            LIBSSH2_FREE(session, data);
-        }
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "SFTP stat packet too short");
-    }
-
-    /* this reads a u32 and stores it into a signed 32bit value */
-    link_len = _libssh2_ntohu32(data + 9);
-    if(link_len < target_len) {
-        memcpy(target, data + 13, link_len);
-        target[link_len] = 0;
-        retcode = (int)link_len;
-    }
-    else
-        retcode = LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-    LIBSSH2_FREE(session, data);
-
-    return retcode;
-}
-
-/* libssh2_sftp_symlink_ex
- * Read or set a symlink
- */
-LIBSSH2_API int
-libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
-                        unsigned int path_len, char *target,
-                        unsigned int target_len, int link_type)
-{
-    int rc;
-    if(!sftp)
-        return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session,
-                 sftp_symlink(sftp, path, path_len, target, target_len,
-                              link_type));
-    return rc;
-}
-
-/* libssh2_sftp_last_error
- * Returns the last error code reported by SFTP
- */
-LIBSSH2_API unsigned long
-libssh2_sftp_last_error(LIBSSH2_SFTP *sftp)
-{
-    if(!sftp)
-        return 0;
-
-    return sftp->last_errno;
-}
-
-/* libssh2_sftp_get_channel
- * Return the channel of sftp, then caller can control the channel's behavior.
- */
-LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_sftp_get_channel(LIBSSH2_SFTP *sftp)
-{
-    if(!sftp)
-        return NULL;
-
-    return sftp->channel;
-}
diff --git a/libssh2/libssh2/src/sftp.h b/libssh2/libssh2/src/sftp.h
deleted file mode 100644
index 129b8f08..00000000
--- a/libssh2/libssh2/src/sftp.h
+++ /dev/null
@@ -1,238 +0,0 @@
-#ifndef __LIBSSH2_SFTP_H
-#define __LIBSSH2_SFTP_H
-/*
- * Copyright (C) 2010 - 2012 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-/*
- * MAX_SFTP_OUTGOING_SIZE MUST not be larger than 32500 or so. This is the
- * amount of data sent in each FXP_WRITE packet
- */
-#define MAX_SFTP_OUTGOING_SIZE 30000
-
-/* MAX_SFTP_READ_SIZE is how much data is asked for at max in each FXP_READ
- * packets.
- */
-#define MAX_SFTP_READ_SIZE 30000
-
-struct sftp_pipeline_chunk {
-    struct list_node node;
-    libssh2_uint64_t offset; /* READ: offset at which to start reading
-                                WRITE: not used */
-    size_t len; /* WRITE: size of the data to write
-                   READ: how many bytes that was asked for */
-    size_t sent;
-    ssize_t lefttosend; /* if 0, the entire packet has been sent off */
-    uint32_t request_id;
-    unsigned char packet[1]; /* data */
-};
-
-struct sftp_zombie_requests {
-    struct list_node node;
-    uint32_t request_id;
-};
-
-#ifndef MIN
-#define MIN(x,y) ((x)<(y)?(x):(y))
-#endif
-
-struct _LIBSSH2_SFTP_PACKET
-{
-    struct list_node node;   /* linked list header */
-    uint32_t request_id;
-    unsigned char *data;
-    size_t data_len;              /* payload size */
-};
-
-typedef struct _LIBSSH2_SFTP_PACKET LIBSSH2_SFTP_PACKET;
-
-#define SFTP_HANDLE_MAXLEN 256 /* according to spec! */
-
-struct _LIBSSH2_SFTP_HANDLE
-{
-    struct list_node node;
-
-    LIBSSH2_SFTP *sftp;
-
-    char handle[SFTP_HANDLE_MAXLEN];
-    size_t handle_len;
-
-    enum {
-        LIBSSH2_SFTP_HANDLE_FILE,
-        LIBSSH2_SFTP_HANDLE_DIR
-    } handle_type;
-
-    union _libssh2_sftp_handle_data
-    {
-        struct _libssh2_sftp_handle_file_data
-        {
-            libssh2_uint64_t offset;
-            libssh2_uint64_t offset_sent;
-            size_t acked; /* container for acked data that hasn't been
-                             returned to caller yet, used for sftp_write */
-
-            /* 'data' is used by sftp_read() and is allocated data that has
-               been received already from the server but wasn't returned to
-               the caller yet. It is of size 'data_len' and 'data_left is the
-               number of bytes not yet returned, counted from the end of the
-               buffer. */
-            unsigned char *data;
-            size_t data_len;
-            size_t data_left;
-
-            char eof; /* we have read to the end */
-        } file;
-        struct _libssh2_sftp_handle_dir_data
-        {
-            uint32_t names_left;
-            void *names_packet;
-            char *next_name;
-            size_t names_packet_len;
-        } dir;
-    } u;
-
-    /* State variables used in libssh2_sftp_close_handle() */
-    libssh2_nonblocking_states close_state;
-    uint32_t close_request_id;
-    unsigned char *close_packet;
-
-    /* list of outstanding packets sent to server */
-    struct list_head packet_list;
-
-};
-
-struct _LIBSSH2_SFTP
-{
-    LIBSSH2_CHANNEL *channel;
-
-    uint32_t request_id, version;
-
-    struct list_head packets;
-
-    /* List of FXP_READ responses to ignore because EOF already received. */
-    struct list_head zombie_requests;
-
-    /* a list of _LIBSSH2_SFTP_HANDLE structs */
-    struct list_head sftp_handles;
-
-    uint32_t last_errno;
-
-    /* Holder for partial packet, use in libssh2_sftp_packet_read() */
-    unsigned char partial_size[4];      /* buffer for size field   */
-    size_t partial_size_len;            /* size field length       */
-    unsigned char *partial_packet;      /* The data                */
-    uint32_t partial_len;               /* Desired number of bytes */
-    size_t partial_received;            /* Bytes received so far   */
-
-    /* Time that libssh2_sftp_packet_requirev() started reading */
-    time_t requirev_start;
-
-    /* State variables used in libssh2_sftp_open_ex() */
-    libssh2_nonblocking_states open_state;
-    unsigned char *open_packet;
-    uint32_t open_packet_len; /* 32 bit on the wire */
-    size_t open_packet_sent;
-    uint32_t open_request_id;
-
-    /* State variable used in sftp_read() */
-    libssh2_nonblocking_states read_state;
-
-    /* State variable used in sftp_packet_read() */
-    libssh2_nonblocking_states packet_state;
-
-    /* State variable used in sftp_write() */
-    libssh2_nonblocking_states write_state;
-
-    /* State variables used in sftp_fsync() */
-    libssh2_nonblocking_states fsync_state;
-    unsigned char *fsync_packet;
-    uint32_t fsync_request_id;
-
-    /* State variables used in libssh2_sftp_readdir() */
-    libssh2_nonblocking_states readdir_state;
-    unsigned char *readdir_packet;
-    uint32_t readdir_request_id;
-
-    /* State variables used in libssh2_sftp_fstat_ex() */
-    libssh2_nonblocking_states fstat_state;
-    unsigned char *fstat_packet;
-    uint32_t fstat_request_id;
-
-    /* State variables used in libssh2_sftp_unlink_ex() */
-    libssh2_nonblocking_states unlink_state;
-    unsigned char *unlink_packet;
-    uint32_t unlink_request_id;
-
-    /* State variables used in libssh2_sftp_rename_ex() */
-    libssh2_nonblocking_states rename_state;
-    unsigned char *rename_packet;
-    unsigned char *rename_s;
-    uint32_t rename_request_id;
-
-    /* State variables used in libssh2_sftp_fstatvfs() */
-    libssh2_nonblocking_states fstatvfs_state;
-    unsigned char *fstatvfs_packet;
-    uint32_t fstatvfs_request_id;
-
-    /* State variables used in libssh2_sftp_statvfs() */
-    libssh2_nonblocking_states statvfs_state;
-    unsigned char *statvfs_packet;
-    uint32_t statvfs_request_id;
-
-    /* State variables used in libssh2_sftp_mkdir() */
-    libssh2_nonblocking_states mkdir_state;
-    unsigned char *mkdir_packet;
-    uint32_t mkdir_request_id;
-
-    /* State variables used in libssh2_sftp_rmdir() */
-    libssh2_nonblocking_states rmdir_state;
-    unsigned char *rmdir_packet;
-    uint32_t rmdir_request_id;
-
-    /* State variables used in libssh2_sftp_stat() */
-    libssh2_nonblocking_states stat_state;
-    unsigned char *stat_packet;
-    uint32_t stat_request_id;
-
-    /* State variables used in libssh2_sftp_symlink() */
-    libssh2_nonblocking_states symlink_state;
-    unsigned char *symlink_packet;
-    uint32_t symlink_request_id;
-};
-
-#endif /* __LIBSSH2_SFTP_H */
diff --git a/libssh2/libssh2/src/transport.c b/libssh2/libssh2/src/transport.c
deleted file mode 100644
index 17af3e4d..00000000
--- a/libssh2/libssh2/src/transport.c
+++ /dev/null
@@ -1,924 +0,0 @@
-/* Copyright (C) 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2009-2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- * This file handles reading and writing to the SECSH transport layer. RFC4253.
- */
-
-#include "libssh2_priv.h"
-#include <errno.h>
-#include <fcntl.h>
-#include <ctype.h>
-#ifdef LIBSSH2DEBUG
-#include <stdio.h>
-#endif
-
-#include <assert.h>
-
-#include "transport.h"
-#include "mac.h"
-
-#define MAX_BLOCKSIZE 32    /* MUST fit biggest crypto block size we use/get */
-#define MAX_MACSIZE 64      /* MUST fit biggest MAC length we support */
-
-#ifdef LIBSSH2DEBUG
-#define UNPRINTABLE_CHAR '.'
-static void
-debugdump(LIBSSH2_SESSION * session,
-          const char *desc, const unsigned char *ptr, size_t size)
-{
-    size_t i;
-    size_t c;
-    unsigned int width = 0x10;
-    char buffer[256];  /* Must be enough for width*4 + about 30 or so */
-    size_t used;
-    static const char *hex_chars = "0123456789ABCDEF";
-
-    if(!(session->showmask & LIBSSH2_TRACE_TRANS)) {
-        /* not asked for, bail out */
-        return;
-    }
-
-    used = snprintf(buffer, sizeof(buffer), "=> %s (%d bytes)\n",
-                    desc, (int) size);
-    if(session->tracehandler)
-        (session->tracehandler)(session, session->tracehandler_context,
-                                buffer, used);
-    else
-        fprintf(stderr, "%s", buffer);
-
-    for(i = 0; i < size; i += width) {
-
-        used = snprintf(buffer, sizeof(buffer), "%04lx: ", (long)i);
-
-        /* hex not disabled, show it */
-        for(c = 0; c < width; c++) {
-            if(i + c < size) {
-                buffer[used++] = hex_chars[(ptr[i + c] >> 4) & 0xF];
-                buffer[used++] = hex_chars[ptr[i + c] & 0xF];
-            }
-            else {
-                buffer[used++] = ' ';
-                buffer[used++] = ' ';
-            }
-
-            buffer[used++] = ' ';
-            if((width/2) - 1 == c)
-                buffer[used++] = ' ';
-        }
-
-        buffer[used++] = ':';
-        buffer[used++] = ' ';
-
-        for(c = 0; (c < width) && (i + c < size); c++) {
-            buffer[used++] = isprint(ptr[i + c]) ?
-                ptr[i + c] : UNPRINTABLE_CHAR;
-        }
-        buffer[used++] = '\n';
-        buffer[used] = 0;
-
-        if(session->tracehandler)
-            (session->tracehandler)(session, session->tracehandler_context,
-                                    buffer, used);
-        else
-            fprintf(stderr, "%s", buffer);
-    }
-}
-#else
-#define debugdump(a,x,y,z)
-#endif
-
-
-/* decrypt() decrypts 'len' bytes from 'source' to 'dest'.
- *
- * returns 0 on success and negative on failure
- */
-
-static int
-decrypt(LIBSSH2_SESSION * session, unsigned char *source,
-        unsigned char *dest, int len)
-{
-    struct transportpacket *p = &session->packet;
-    int blocksize = session->remote.crypt->blocksize;
-
-    /* if we get called with a len that isn't an even number of blocksizes
-       we risk losing those extra bytes */
-    assert((len % blocksize) == 0);
-
-    while(len >= blocksize) {
-        if(session->remote.crypt->crypt(session, source, blocksize,
-                                         &session->remote.crypt_abstract)) {
-            LIBSSH2_FREE(session, p->payload);
-            return LIBSSH2_ERROR_DECRYPT;
-        }
-
-        /* if the crypt() function would write to a given address it
-           wouldn't have to memcpy() and we could avoid this memcpy()
-           too */
-        memcpy(dest, source, blocksize);
-
-        len -= blocksize;       /* less bytes left */
-        dest += blocksize;      /* advance write pointer */
-        source += blocksize;    /* advance read pointer */
-    }
-    return LIBSSH2_ERROR_NONE;         /* all is fine */
-}
-
-/*
- * fullpacket() gets called when a full packet has been received and properly
- * collected.
- */
-static int
-fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
-{
-    unsigned char macbuf[MAX_MACSIZE];
-    struct transportpacket *p = &session->packet;
-    int rc;
-    int compressed;
-
-    if(session->fullpacket_state == libssh2_NB_state_idle) {
-        session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED;
-        session->fullpacket_payload_len = p->packet_length - 1;
-
-        if(encrypted) {
-
-            /* Calculate MAC hash */
-            session->remote.mac->hash(session, macbuf,  /* store hash here */
-                                      session->remote.seqno,
-                                      p->init, 5,
-                                      p->payload,
-                                      session->fullpacket_payload_len,
-                                      &session->remote.mac_abstract);
-
-            /* Compare the calculated hash with the MAC we just read from
-             * the network. The read one is at the very end of the payload
-             * buffer. Note that 'payload_len' here is the packet_length
-             * field which includes the padding but not the MAC.
-             */
-            if(memcmp(macbuf, p->payload + session->fullpacket_payload_len,
-                       session->remote.mac->mac_len)) {
-                session->fullpacket_macstate = LIBSSH2_MAC_INVALID;
-            }
-        }
-
-        session->remote.seqno++;
-
-        /* ignore the padding */
-        session->fullpacket_payload_len -= p->padding_length;
-
-        /* Check for and deal with decompression */
-        compressed =
-            session->local.comp != NULL &&
-            session->local.comp->compress &&
-            ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
-             session->local.comp->use_in_auth);
-
-        if(compressed && session->remote.comp_abstract) {
-            /*
-             * The buffer for the decompression (remote.comp_abstract) is
-             * initialised in time when it is needed so as long it is NULL we
-             * cannot decompress.
-             */
-
-            unsigned char *data;
-            size_t data_len;
-            rc = session->remote.comp->decomp(session,
-                                              &data, &data_len,
-                                              LIBSSH2_PACKET_MAXDECOMP,
-                                              p->payload,
-                                              session->fullpacket_payload_len,
-                                              &session->remote.comp_abstract);
-            LIBSSH2_FREE(session, p->payload);
-            if(rc)
-                return rc;
-
-            p->payload = data;
-            session->fullpacket_payload_len = data_len;
-        }
-
-        session->fullpacket_packet_type = p->payload[0];
-
-        debugdump(session, "libssh2_transport_read() plain",
-                  p->payload, session->fullpacket_payload_len);
-
-        session->fullpacket_state = libssh2_NB_state_created;
-    }
-
-    if(session->fullpacket_state == libssh2_NB_state_created) {
-        rc = _libssh2_packet_add(session, p->payload,
-                                 session->fullpacket_payload_len,
-                                 session->fullpacket_macstate);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
-        if(rc) {
-            session->fullpacket_state = libssh2_NB_state_idle;
-            return rc;
-        }
-    }
-
-    session->fullpacket_state = libssh2_NB_state_idle;
-
-    return session->fullpacket_packet_type;
-}
-
-
-/*
- * _libssh2_transport_read
- *
- * Collect a packet into the input queue.
- *
- * Returns packet type added to input queue (0 if nothing added), or a
- * negative error number.
- */
-
-/*
- * This function reads the binary stream as specified in chapter 6 of RFC4253
- * "The Secure Shell (SSH) Transport Layer Protocol"
- *
- * DOES NOT call _libssh2_error() for ANY error case.
- */
-int _libssh2_transport_read(LIBSSH2_SESSION * session)
-{
-    int rc;
-    struct transportpacket *p = &session->packet;
-    int remainbuf;
-    int remainpack;
-    int numbytes;
-    int numdecrypt;
-    unsigned char block[MAX_BLOCKSIZE];
-    int blocksize;
-    int encrypted = 1;
-
-    /* default clear the bit */
-    session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_INBOUND;
-
-    /*
-     * All channels, systems, subsystems, etc eventually make it down here
-     * when looking for more incoming data. If a key exchange is going on
-     * (LIBSSH2_STATE_EXCHANGING_KEYS bit is set) then the remote end will
-     * ONLY send key exchange related traffic. In non-blocking mode, there is
-     * a chance to break out of the kex_exchange function with an EAGAIN
-     * status, and never come back to it. If LIBSSH2_STATE_EXCHANGING_KEYS is
-     * active, then we must redirect to the key exchange. However, if
-     * kex_exchange is active (as in it is the one that calls this execution
-     * of packet_read, then don't redirect, as that would be an infinite loop!
-     */
-
-    if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
-        !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
-
-        /* Whoever wants a packet won't get anything until the key re-exchange
-         * is done!
-         */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
-                       " key re-exchange from _libssh2_transport_read");
-        rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if(rc)
-            return rc;
-    }
-
-    /*
-     * =============================== NOTE ===============================
-     * I know this is very ugly and not a really good use of "goto", but
-     * this case statement would be even uglier to do it any other way
-     */
-    if(session->readPack_state == libssh2_NB_state_jump1) {
-        session->readPack_state = libssh2_NB_state_idle;
-        encrypted = session->readPack_encrypted;
-        goto libssh2_transport_read_point1;
-    }
-
-    do {
-        if(session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
-            return LIBSSH2_ERROR_SOCKET_DISCONNECT;
-        }
-
-        if(session->state & LIBSSH2_STATE_NEWKEYS) {
-            blocksize = session->remote.crypt->blocksize;
-        }
-        else {
-            encrypted = 0;      /* not encrypted */
-            blocksize = 5;      /* not strictly true, but we can use 5 here to
-                                   make the checks below work fine still */
-        }
-
-        /* read/use a whole big chunk into a temporary area stored in
-           the LIBSSH2_SESSION struct. We will decrypt data from that
-           buffer into the packet buffer so this temp one doesn't have
-           to be able to keep a whole SSH packet, just be large enough
-           so that we can read big chunks from the network layer. */
-
-        /* how much data there is remaining in the buffer to deal with
-           before we should read more from the network */
-        remainbuf = p->writeidx - p->readidx;
-
-        /* if remainbuf turns negative we have a bad internal error */
-        assert(remainbuf >= 0);
-
-        if(remainbuf < blocksize) {
-            /* If we have less than a blocksize left, it is too
-               little data to deal with, read more */
-            ssize_t nread;
-
-            /* move any remainder to the start of the buffer so
-               that we can do a full refill */
-            if(remainbuf) {
-                memmove(p->buf, &p->buf[p->readidx], remainbuf);
-                p->readidx = 0;
-                p->writeidx = remainbuf;
-            }
-            else {
-                /* nothing to move, just zero the indexes */
-                p->readidx = p->writeidx = 0;
-            }
-
-            /* now read a big chunk from the network into the temp buffer */
-            nread =
-                LIBSSH2_RECV(session, &p->buf[remainbuf],
-                              PACKETBUFSIZE - remainbuf,
-                              LIBSSH2_SOCKET_RECV_FLAGS(session));
-            if(nread <= 0) {
-                /* check if this is due to EAGAIN and return the special
-                   return code if so, error out normally otherwise */
-                if((nread < 0) && (nread == -EAGAIN)) {
-                    session->socket_block_directions |=
-                        LIBSSH2_SESSION_BLOCK_INBOUND;
-                    return LIBSSH2_ERROR_EAGAIN;
-                }
-                _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                               "Error recving %d bytes (got %d)",
-                               PACKETBUFSIZE - remainbuf, -nread);
-                return LIBSSH2_ERROR_SOCKET_RECV;
-            }
-            _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                           "Recved %d/%d bytes to %p+%d", nread,
-                           PACKETBUFSIZE - remainbuf, p->buf, remainbuf);
-
-            debugdump(session, "libssh2_transport_read() raw",
-                      &p->buf[remainbuf], nread);
-            /* advance write pointer */
-            p->writeidx += nread;
-
-            /* update remainbuf counter */
-            remainbuf = p->writeidx - p->readidx;
-        }
-
-        /* how much data to deal with from the buffer */
-        numbytes = remainbuf;
-
-        if(!p->total_num) {
-            size_t total_num;
-
-            /* No payload package area allocated yet. To know the
-               size of this payload, we need to decrypt the first
-               blocksize data. */
-
-            if(numbytes < blocksize) {
-                /* we can't act on anything less than blocksize, but this
-                   check is only done for the initial block since once we have
-                   got the start of a block we can in fact deal with fractions
-                */
-                session->socket_block_directions |=
-                    LIBSSH2_SESSION_BLOCK_INBOUND;
-                return LIBSSH2_ERROR_EAGAIN;
-            }
-
-            if(encrypted) {
-                rc = decrypt(session, &p->buf[p->readidx], block, blocksize);
-                if(rc != LIBSSH2_ERROR_NONE) {
-                    return rc;
-                }
-                /* save the first 5 bytes of the decrypted package, to be
-                   used in the hash calculation later down. */
-                memcpy(p->init, block, 5);
-            }
-            else {
-                /* the data is plain, just copy it verbatim to
-                   the working block buffer */
-                memcpy(block, &p->buf[p->readidx], blocksize);
-            }
-
-            /* advance the read pointer */
-            p->readidx += blocksize;
-
-            /* we now have the initial blocksize bytes decrypted,
-             * and we can extract packet and padding length from it
-             */
-            p->packet_length = _libssh2_ntohu32(block);
-            if(p->packet_length < 1) {
-                return LIBSSH2_ERROR_DECRYPT;
-            }
-            else if(p->packet_length > LIBSSH2_PACKET_MAXPAYLOAD) {
-                return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-            }
-
-            p->padding_length = block[4];
-            if(p->padding_length > p->packet_length - 1) {
-                return LIBSSH2_ERROR_DECRYPT;
-            }
-
-
-            /* total_num is the number of bytes following the initial
-               (5 bytes) packet length and padding length fields */
-            total_num =
-                p->packet_length - 1 +
-                (encrypted ? session->remote.mac->mac_len : 0);
-
-            /* RFC4253 section 6.1 Maximum Packet Length says:
-             *
-             * "All implementations MUST be able to process
-             * packets with uncompressed payload length of 32768
-             * bytes or less and total packet size of 35000 bytes
-             * or less (including length, padding length, payload,
-             * padding, and MAC.)."
-             */
-            if(total_num > LIBSSH2_PACKET_MAXPAYLOAD || total_num == 0) {
-                return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-            }
-
-            /* Get a packet handle put data into. We get one to
-               hold all data, including padding and MAC. */
-            p->payload = LIBSSH2_ALLOC(session, total_num);
-            if(!p->payload) {
-                return LIBSSH2_ERROR_ALLOC;
-            }
-            p->total_num = total_num;
-            /* init write pointer to start of payload buffer */
-            p->wptr = p->payload;
-
-            if(blocksize > 5) {
-                /* copy the data from index 5 to the end of
-                   the blocksize from the temporary buffer to
-                   the start of the decrypted buffer */
-                if(blocksize - 5 <= (int) total_num) {
-                    memcpy(p->wptr, &block[5], blocksize - 5);
-                    p->wptr += blocksize - 5;       /* advance write pointer */
-                }
-                else {
-                    if(p->payload)
-                        LIBSSH2_FREE(session, p->payload);
-                    return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-                }
-            }
-
-            /* init the data_num field to the number of bytes of
-               the package read so far */
-            p->data_num = p->wptr - p->payload;
-
-            /* we already dealt with a blocksize worth of data */
-            numbytes -= blocksize;
-        }
-
-        /* how much there is left to add to the current payload
-           package */
-        remainpack = p->total_num - p->data_num;
-
-        if(numbytes > remainpack) {
-            /* if we have more data in the buffer than what is going into this
-               particular packet, we limit this round to this packet only */
-            numbytes = remainpack;
-        }
-
-        if(encrypted) {
-            /* At the end of the incoming stream, there is a MAC,
-               and we don't want to decrypt that since we need it
-               "raw". We MUST however decrypt the padding data
-               since it is used for the hash later on. */
-            int skip = session->remote.mac->mac_len;
-
-            /* if what we have plus numbytes is bigger than the
-               total minus the skip margin, we should lower the
-               amount to decrypt even more */
-            if((p->data_num + numbytes) > (p->total_num - skip)) {
-                numdecrypt = (p->total_num - skip) - p->data_num;
-            }
-            else {
-                int frac;
-                numdecrypt = numbytes;
-                frac = numdecrypt % blocksize;
-                if(frac) {
-                    /* not an aligned amount of blocks,
-                       align it */
-                    numdecrypt -= frac;
-                    /* and make it no unencrypted data
-                       after it */
-                    numbytes = 0;
-                }
-            }
-        }
-        else {
-            /* unencrypted data should not be decrypted at all */
-            numdecrypt = 0;
-        }
-
-        /* if there are bytes to decrypt, do that */
-        if(numdecrypt > 0) {
-            /* now decrypt the lot */
-            rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt);
-            if(rc != LIBSSH2_ERROR_NONE) {
-                p->total_num = 0;   /* no packet buffer available */
-                return rc;
-            }
-
-            /* advance the read pointer */
-            p->readidx += numdecrypt;
-            /* advance write pointer */
-            p->wptr += numdecrypt;
-            /* increase data_num */
-            p->data_num += numdecrypt;
-
-            /* bytes left to take care of without decryption */
-            numbytes -= numdecrypt;
-        }
-
-        /* if there are bytes to copy that aren't decrypted, simply
-           copy them as-is to the target buffer */
-        if(numbytes > 0) {
-
-            if(numbytes <= (int)(p->total_num - (p->wptr - p->payload))) {
-                memcpy(p->wptr, &p->buf[p->readidx], numbytes);
-            }
-            else {
-                if(p->payload)
-                    LIBSSH2_FREE(session, p->payload);
-                return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-            }
-
-            /* advance the read pointer */
-            p->readidx += numbytes;
-            /* advance write pointer */
-            p->wptr += numbytes;
-            /* increase data_num */
-            p->data_num += numbytes;
-        }
-
-        /* now check how much data there's left to read to finish the
-           current packet */
-        remainpack = p->total_num - p->data_num;
-
-        if(!remainpack) {
-            /* we have a full packet */
-          libssh2_transport_read_point1:
-            rc = fullpacket(session, encrypted);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-
-                if(session->packAdd_state != libssh2_NB_state_idle) {
-                    /* fullpacket only returns LIBSSH2_ERROR_EAGAIN if
-                     * libssh2_packet_add returns LIBSSH2_ERROR_EAGAIN. If
-                     * that returns LIBSSH2_ERROR_EAGAIN but the packAdd_state
-                     * is idle, then the packet has been added to the brigade,
-                     * but some immediate action that was taken based on the
-                     * packet type (such as key re-exchange) is not yet
-                     * complete.  Clear the way for a new packet to be read
-                     * in.
-                     */
-                    session->readPack_encrypted = encrypted;
-                    session->readPack_state = libssh2_NB_state_jump1;
-                }
-
-                return rc;
-            }
-
-            p->total_num = 0;   /* no packet buffer available */
-
-            return rc;
-        }
-    } while(1);                /* loop */
-
-    return LIBSSH2_ERROR_SOCKET_RECV; /* we never reach this point */
-}
-
-static int
-send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
-              size_t data_len, ssize_t *ret)
-{
-    ssize_t rc;
-    ssize_t length;
-    struct transportpacket *p = &session->packet;
-
-    if(!p->olen) {
-        *ret = 0;
-        return LIBSSH2_ERROR_NONE;
-    }
-
-    /* send as much as possible of the existing packet */
-    if((data != p->odata) || (data_len != p->olen)) {
-        /* When we are about to complete the sending of a packet, it is vital
-           that the caller doesn't try to send a new/different packet since
-           we don't add this one up until the previous one has been sent. To
-           make the caller really notice his/hers flaw, we return error for
-           this case */
-        return LIBSSH2_ERROR_BAD_USE;
-    }
-
-    *ret = 1;                   /* set to make our parent return */
-
-    /* number of bytes left to send */
-    length = p->ototal_num - p->osent;
-
-    rc = LIBSSH2_SEND(session, &p->outbuf[p->osent], length,
-                       LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if(rc < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d", length, -rc);
-    else {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Sent %d/%d bytes at %p+%d", rc, length, p->outbuf,
-                       p->osent);
-        debugdump(session, "libssh2_transport_write send()",
-                  &p->outbuf[p->osent], rc);
-    }
-
-    if(rc == length) {
-        /* the remainder of the package was sent */
-        p->ototal_num = 0;
-        p->olen = 0;
-        /* we leave *ret set so that the parent returns as we MUST return back
-           a send success now, so that we don't risk sending EAGAIN later
-           which then would confuse the parent function */
-        return LIBSSH2_ERROR_NONE;
-
-    }
-    else if(rc < 0) {
-        /* nothing was sent */
-        if(rc != -EAGAIN)
-            /* send failure! */
-            return LIBSSH2_ERROR_SOCKET_SEND;
-
-        session->socket_block_directions |= LIBSSH2_SESSION_BLOCK_OUTBOUND;
-        return LIBSSH2_ERROR_EAGAIN;
-    }
-
-    p->osent += rc;         /* we sent away this much data */
-
-    return rc < length ? LIBSSH2_ERROR_EAGAIN : LIBSSH2_ERROR_NONE;
-}
-
-/*
- * libssh2_transport_send
- *
- * Send a packet, encrypting it and adding a MAC code if necessary
- * Returns 0 on success, non-zero on failure.
- *
- * The data is provided as _two_ data areas that are combined by this
- * function.  The 'data' part is sent immediately before 'data2'. 'data2' may
- * be set to NULL to only use a single part.
- *
- * Returns LIBSSH2_ERROR_EAGAIN if it would block or if the whole packet was
- * not sent yet. If it does so, the caller should call this function again as
- * soon as it is likely that more data can be sent, and this function MUST
- * then be called with the same argument set (same data pointer and same
- * data_len) until ERROR_NONE or failure is returned.
- *
- * This function DOES NOT call _libssh2_error() on any errors.
- */
-int _libssh2_transport_send(LIBSSH2_SESSION *session,
-                            const unsigned char *data, size_t data_len,
-                            const unsigned char *data2, size_t data2_len)
-{
-    int blocksize =
-        (session->state & LIBSSH2_STATE_NEWKEYS) ?
-        session->local.crypt->blocksize : 8;
-    int padding_length;
-    size_t packet_length;
-    int total_length;
-#ifdef RANDOM_PADDING
-    int rand_max;
-    int seed = data[0];         /* FIXME: make this random */
-#endif
-    struct transportpacket *p = &session->packet;
-    int encrypted;
-    int compressed;
-    ssize_t ret;
-    int rc;
-    const unsigned char *orgdata = data;
-    size_t orgdata_len = data_len;
-
-    /*
-     * If the last read operation was interrupted in the middle of a key
-     * exchange, we must complete that key exchange before continuing to write
-     * further data.
-     *
-     * See the similar block in _libssh2_transport_read for more details.
-     */
-    if(session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
-        !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
-        /* Don't write any new packets if we're still in the middle of a key
-         * exchange. */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
-                       " key re-exchange from _libssh2_transport_send");
-        rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
-        if(rc)
-            return rc;
-    }
-
-    debugdump(session, "libssh2_transport_write plain", data, data_len);
-    if(data2)
-        debugdump(session, "libssh2_transport_write plain2", data2, data2_len);
-
-    /* FIRST, check if we have a pending write to complete. send_existing
-       only sanity-check data and data_len and not data2 and data2_len!! */
-    rc = send_existing(session, data, data_len, &ret);
-    if(rc)
-        return rc;
-
-    session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND;
-
-    if(ret)
-        /* set by send_existing if data was sent */
-        return rc;
-
-    encrypted = (session->state & LIBSSH2_STATE_NEWKEYS) ? 1 : 0;
-
-    compressed =
-        session->local.comp != NULL &&
-        session->local.comp->compress &&
-        ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
-         session->local.comp->use_in_auth);
-
-    if(encrypted && compressed && session->local.comp_abstract) {
-        /* the idea here is that these function must fail if the output gets
-           larger than what fits in the assigned buffer so thus they don't
-           check the input size as we don't know how much it compresses */
-        size_t dest_len = MAX_SSH_PACKET_LEN-5-256;
-        size_t dest2_len = dest_len;
-
-        /* compress directly to the target buffer */
-        rc = session->local.comp->comp(session,
-                                       &p->outbuf[5], &dest_len,
-                                       data, data_len,
-                                       &session->local.comp_abstract);
-        if(rc)
-            return rc;     /* compression failure */
-
-        if(data2 && data2_len) {
-            /* compress directly to the target buffer right after where the
-               previous call put data */
-            dest2_len -= dest_len;
-
-            rc = session->local.comp->comp(session,
-                                           &p->outbuf[5 + dest_len],
-                                           &dest2_len,
-                                           data2, data2_len,
-                                           &session->local.comp_abstract);
-        }
-        else
-            dest2_len = 0;
-        if(rc)
-            return rc;     /* compression failure */
-
-        data_len = dest_len + dest2_len; /* use the combined length */
-    }
-    else {
-        if((data_len + data2_len) >= (MAX_SSH_PACKET_LEN-0x100))
-            /* too large packet, return error for this until we make this
-               function split it up and send multiple SSH packets */
-            return LIBSSH2_ERROR_INVAL;
-
-        /* copy the payload data */
-        memcpy(&p->outbuf[5], data, data_len);
-        if(data2 && data2_len)
-            memcpy(&p->outbuf[5 + data_len], data2, data2_len);
-        data_len += data2_len; /* use the combined length */
-    }
-
-
-    /* RFC4253 says: Note that the length of the concatenation of
-       'packet_length', 'padding_length', 'payload', and 'random padding'
-       MUST be a multiple of the cipher block size or 8, whichever is
-       larger. */
-
-    /* Plain math: (4 + 1 + packet_length + padding_length) % blocksize == 0 */
-
-    packet_length = data_len + 1 + 4;   /* 1 is for padding_length field
-                                           4 for the packet_length field */
-
-    /* at this point we have it all except the padding */
-
-    /* first figure out our minimum padding amount to make it an even
-       block size */
-    padding_length = blocksize - (packet_length % blocksize);
-
-    /* if the padding becomes too small we add another blocksize worth
-       of it (taken from the original libssh2 where it didn't have any
-       real explanation) */
-    if(padding_length < 4) {
-        padding_length += blocksize;
-    }
-#ifdef RANDOM_PADDING
-    /* FIXME: we can add padding here, but that also makes the packets
-       bigger etc */
-
-    /* now we can add 'blocksize' to the padding_length N number of times
-       (to "help thwart traffic analysis") but it must be less than 255 in
-       total */
-    rand_max = (255 - padding_length) / blocksize + 1;
-    padding_length += blocksize * (seed % rand_max);
-#endif
-
-    packet_length += padding_length;
-
-    /* append the MAC length to the total_length size */
-    total_length =
-        packet_length + (encrypted ? session->local.mac->mac_len : 0);
-
-    /* store packet_length, which is the size of the whole packet except
-       the MAC and the packet_length field itself */
-    _libssh2_htonu32(p->outbuf, packet_length - 4);
-    /* store padding_length */
-    p->outbuf[4] = (unsigned char)padding_length;
-
-    /* fill the padding area with random junk */
-    if(_libssh2_random(p->outbuf + 5 + data_len, padding_length)) {
-        return _libssh2_error(session, LIBSSH2_ERROR_RANDGEN,
-                              "Unable to get random bytes for packet padding");
-    }
-
-    if(encrypted) {
-        size_t i;
-
-        /* Calculate MAC hash. Put the output at index packet_length,
-           since that size includes the whole packet. The MAC is
-           calculated on the entire unencrypted packet, including all
-           fields except the MAC field itself. */
-        session->local.mac->hash(session, p->outbuf + packet_length,
-                                 session->local.seqno, p->outbuf,
-                                 packet_length, NULL, 0,
-                                 &session->local.mac_abstract);
-
-        /* Encrypt the whole packet data, one block size at a time.
-           The MAC field is not encrypted. */
-        for(i = 0; i < packet_length; i += session->local.crypt->blocksize) {
-            unsigned char *ptr = &p->outbuf[i];
-            if(session->local.crypt->crypt(session, ptr,
-                                            session->local.crypt->blocksize,
-                                            &session->local.crypt_abstract))
-                return LIBSSH2_ERROR_ENCRYPT;     /* encryption failure */
-        }
-    }
-
-    session->local.seqno++;
-
-    ret = LIBSSH2_SEND(session, p->outbuf, total_length,
-                        LIBSSH2_SOCKET_SEND_FLAGS(session));
-    if(ret < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d", total_length, -ret);
-    else {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET, "Sent %d/%d bytes at %p",
-                       ret, total_length, p->outbuf);
-        debugdump(session, "libssh2_transport_write send()", p->outbuf, ret);
-    }
-
-    if(ret != total_length) {
-        if(ret >= 0 || ret == -EAGAIN) {
-            /* the whole packet could not be sent, save the rest */
-            session->socket_block_directions |= LIBSSH2_SESSION_BLOCK_OUTBOUND;
-            p->odata = orgdata;
-            p->olen = orgdata_len;
-            p->osent = ret <= 0 ? 0 : ret;
-            p->ototal_num = total_length;
-            return LIBSSH2_ERROR_EAGAIN;
-        }
-        return LIBSSH2_ERROR_SOCKET_SEND;
-    }
-
-    /* the whole thing got sent away */
-    p->odata = NULL;
-    p->olen = 0;
-
-    return LIBSSH2_ERROR_NONE;         /* all is good */
-}
diff --git a/libssh2/libssh2/src/transport.h b/libssh2/libssh2/src/transport.h
deleted file mode 100644
index 7d395d0e..00000000
--- a/libssh2/libssh2/src/transport.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#ifndef __LIBSSH2_TRANSPORT_H
-#define __LIBSSH2_TRANSPORT_H
-/* Copyright (C) 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2009-2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- * This file handles reading and writing to the SECSH transport layer. RFC4253.
- */
-
-#include "libssh2_priv.h"
-#include "packet.h"
-
-
-/*
- * libssh2_transport_send
- *
- * Send a packet, encrypting it and adding a MAC code if necessary
- * Returns 0 on success, non-zero on failure.
- *
- * The data is provided as _two_ data areas that are combined by this
- * function.  The 'data' part is sent immediately before 'data2'. 'data2' can
- * be set to NULL (or data2_len to 0) to only use a single part.
- *
- * Returns LIBSSH2_ERROR_EAGAIN if it would block or if the whole packet was
- * not sent yet. If it does so, the caller should call this function again as
- * soon as it is likely that more data can be sent, and this function MUST
- * then be called with the same argument set (same data pointer and same
- * data_len) until ERROR_NONE or failure is returned.
- *
- * This function DOES NOT call _libssh2_error() on any errors.
- */
-int _libssh2_transport_send(LIBSSH2_SESSION *session,
-                            const unsigned char *data, size_t data_len,
-                            const unsigned char *data2, size_t data2_len);
-
-/*
- * _libssh2_transport_read
- *
- * Collect a packet into the input brigade block only controls whether or not
- * to wait for a packet to start.
- *
- * Returns packet type added to input brigade (PACKET_NONE if nothing added),
- * or PACKET_FAIL on failure and PACKET_EAGAIN if it couldn't process a full
- * packet.
- */
-
-/*
- * This function reads the binary stream as specified in chapter 6 of RFC4253
- * "The Secure Shell (SSH) Transport Layer Protocol"
- */
-int _libssh2_transport_read(LIBSSH2_SESSION * session);
-
-#endif /* __LIBSSH2_TRANSPORT_H */
diff --git a/libssh2/libssh2/src/userauth.c b/libssh2/libssh2/src/userauth.c
deleted file mode 100644
index 40ef9153..00000000
--- a/libssh2/libssh2/src/userauth.c
+++ /dev/null
@@ -1,2112 +0,0 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2009-2014 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#include <ctype.h>
-#include <stdio.h>
-
-#include <assert.h>
-
-/* Needed for struct iovec on some platforms */
-#ifdef HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif
-
-#include "transport.h"
-#include "session.h"
-#include "userauth.h"
-
-/* libssh2_userauth_list
- *
- * List authentication methods
- * Will yield successful login if "none" happens to be allowable for this user
- * Not a common configuration for any SSH server though
- * username should be NULL, or a null terminated string
- */
-static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
-                           unsigned int username_len)
-{
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
-    /* packet_type(1) + username_len(4) + service_len(4) +
-       service(14)"ssh-connection" + method_len(4) = 27 */
-    unsigned long methods_len;
-    unsigned char *s;
-    int rc;
-
-    if(session->userauth_list_state == libssh2_NB_state_idle) {
-        /* Zero the whole thing out */
-        memset(&session->userauth_list_packet_requirev_state, 0,
-               sizeof(session->userauth_list_packet_requirev_state));
-
-        session->userauth_list_data_len = username_len + 27;
-
-        s = session->userauth_list_data =
-            LIBSSH2_ALLOC(session, session->userauth_list_data_len);
-        if(!session->userauth_list_data) {
-            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                           "Unable to allocate memory for userauth_list");
-            return NULL;
-        }
-
-        *(s++) = SSH_MSG_USERAUTH_REQUEST;
-        _libssh2_store_str(&s, username, username_len);
-        _libssh2_store_str(&s, "ssh-connection", 14);
-        _libssh2_store_u32(&s, 4); /* send "none" separately */
-
-        session->userauth_list_state = libssh2_NB_state_created;
-    }
-
-    if(session->userauth_list_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, session->userauth_list_data,
-                                     session->userauth_list_data_len,
-                                     (unsigned char *)"none", 4);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block requesting userauth list");
-            return NULL;
-        }
-        /* now free the packet that was sent */
-        LIBSSH2_FREE(session, session->userauth_list_data);
-        session->userauth_list_data = NULL;
-
-        if(rc) {
-            _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                           "Unable to send userauth-none request");
-            session->userauth_list_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-
-        session->userauth_list_state = libssh2_NB_state_sent;
-    }
-
-    if(session->userauth_list_state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_requirev(session, reply_codes,
-                                      &session->userauth_list_data,
-                                      &session->userauth_list_data_len, 0,
-                                      NULL, 0,
-                               &session->userauth_list_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                           "Would block requesting userauth list");
-            return NULL;
-        }
-        else if(rc || (session->userauth_list_data_len < 1)) {
-            _libssh2_error(session, rc, "Failed getting response");
-            session->userauth_list_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-
-        if(session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-            /* Wow, who'dve thought... */
-            _libssh2_error(session, LIBSSH2_ERROR_NONE, "No error");
-            LIBSSH2_FREE(session, session->userauth_list_data);
-            session->userauth_list_data = NULL;
-            session->state |= LIBSSH2_STATE_AUTHENTICATED;
-            session->userauth_list_state = libssh2_NB_state_idle;
-            return NULL;
-        }
-
-        if(session->userauth_list_data_len < 5) {
-            LIBSSH2_FREE(session, session->userauth_list_data);
-            session->userauth_list_data = NULL;
-            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Unexpected packet size");
-            return NULL;
-        }
-
-        methods_len = _libssh2_ntohu32(session->userauth_list_data + 1);
-        if(methods_len >= session->userauth_list_data_len - 5) {
-            _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
-                           "Unexpected userauth list size");
-            return NULL;
-        }
-
-        /* Do note that the memory areas overlap! */
-        memmove(session->userauth_list_data, session->userauth_list_data + 5,
-                methods_len);
-        session->userauth_list_data[methods_len] = '\0';
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Permitted auth methods: %s",
-                       session->userauth_list_data);
-    }
-
-    session->userauth_list_state = libssh2_NB_state_idle;
-    return (char *) session->userauth_list_data;
-}
-
-/* libssh2_userauth_list
- *
- * List authentication methods
- * Will yield successful login if "none" happens to be allowable for this user
- * Not a common configuration for any SSH server though
- * username should be NULL, or a null terminated string
- */
-LIBSSH2_API char *
-libssh2_userauth_list(LIBSSH2_SESSION * session, const char *user,
-                      unsigned int user_len)
-{
-    char *ptr;
-    BLOCK_ADJUST_ERRNO(ptr, session,
-                       userauth_list(session, user, user_len));
-    return ptr;
-}
-
-/*
- * libssh2_userauth_authenticated
- *
- * Returns: 0 if not yet authenticated
- *          1 if already authenticated
- */
-LIBSSH2_API int
-libssh2_userauth_authenticated(LIBSSH2_SESSION * session)
-{
-    return (session->state & LIBSSH2_STATE_AUTHENTICATED)?1:0;
-}
-
-
-
-/* userauth_password
- * Plain ol' login
- */
-static int
-userauth_password(LIBSSH2_SESSION *session,
-                  const char *username, unsigned int username_len,
-                  const unsigned char *password, unsigned int password_len,
-                  LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)))
-{
-    unsigned char *s;
-    static const unsigned char reply_codes[4] =
-        { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE,
-          SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, 0
-        };
-    int rc;
-
-    if(session->userauth_pswd_state == libssh2_NB_state_idle) {
-        /* Zero the whole thing out */
-        memset(&session->userauth_pswd_packet_requirev_state, 0,
-               sizeof(session->userauth_pswd_packet_requirev_state));
-
-        /*
-         * 40 = packet_type(1) + username_len(4) + service_len(4) +
-         * service(14)"ssh-connection" + method_len(4) + method(8)"password" +
-         * chgpwdbool(1) + password_len(4) */
-        session->userauth_pswd_data_len = username_len + 40;
-
-        session->userauth_pswd_data0 =
-            (unsigned char) ~SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
-
-        /* TODO: remove this alloc with a fixed buffer in the session
-           struct */
-        s = session->userauth_pswd_data =
-            LIBSSH2_ALLOC(session, session->userauth_pswd_data_len);
-        if(!session->userauth_pswd_data) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "userauth-password request");
-        }
-
-        *(s++) = SSH_MSG_USERAUTH_REQUEST;
-        _libssh2_store_str(&s, username, username_len);
-        _libssh2_store_str(&s, "ssh-connection", sizeof("ssh-connection") - 1);
-        _libssh2_store_str(&s, "password", sizeof("password") - 1);
-        *s++ = '\0';
-        _libssh2_store_u32(&s, password_len);
-        /* 'password' is sent separately */
-
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting to login using password authentication");
-
-        session->userauth_pswd_state = libssh2_NB_state_created;
-    }
-
-    if(session->userauth_pswd_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, session->userauth_pswd_data,
-                                     session->userauth_pswd_data_len,
-                                     password, password_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block writing password request");
-        }
-
-        /* now free the sent packet */
-        LIBSSH2_FREE(session, session->userauth_pswd_data);
-        session->userauth_pswd_data = NULL;
-
-        if(rc) {
-            session->userauth_pswd_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send userauth-password request");
-        }
-
-        session->userauth_pswd_state = libssh2_NB_state_sent;
-    }
-
-  password_response:
-
-    if((session->userauth_pswd_state == libssh2_NB_state_sent)
-        || (session->userauth_pswd_state == libssh2_NB_state_sent1)
-        || (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
-        if(session->userauth_pswd_state == libssh2_NB_state_sent) {
-            rc = _libssh2_packet_requirev(session, reply_codes,
-                                          &session->userauth_pswd_data,
-                                          &session->userauth_pswd_data_len,
-                                          0, NULL, 0,
-                                          &session->
-                                          userauth_pswd_packet_requirev_state);
-
-            if(rc) {
-                if(rc != LIBSSH2_ERROR_EAGAIN)
-                    session->userauth_pswd_state = libssh2_NB_state_idle;
-
-                return _libssh2_error(session, rc,
-                                      "Waiting for password response");
-            }
-            else if(session->userauth_pswd_data_len < 1) {
-                session->userauth_pswd_state = libssh2_NB_state_idle;
-                return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                      "Unexpected packet size");
-            }
-
-            if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Password authentication successful");
-                LIBSSH2_FREE(session, session->userauth_pswd_data);
-                session->userauth_pswd_data = NULL;
-                session->state |= LIBSSH2_STATE_AUTHENTICATED;
-                session->userauth_pswd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-            else if(session->userauth_pswd_data[0] ==
-                    SSH_MSG_USERAUTH_FAILURE) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Password authentication failed");
-                LIBSSH2_FREE(session, session->userauth_pswd_data);
-                session->userauth_pswd_data = NULL;
-                session->userauth_pswd_state = libssh2_NB_state_idle;
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_AUTHENTICATION_FAILED,
-                                      "Authentication failed "
-                                      "(username/password)");
-            }
-
-            session->userauth_pswd_newpw = NULL;
-            session->userauth_pswd_newpw_len = 0;
-
-            session->userauth_pswd_state = libssh2_NB_state_sent1;
-        }
-
-        if(session->userauth_pswd_data_len < 1) {
-            session->userauth_pswd_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Unexpected packet size");
-        }
-
-        if((session->userauth_pswd_data[0] ==
-             SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)
-            || (session->userauth_pswd_data0 ==
-                SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)) {
-            session->userauth_pswd_data0 = SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
-
-            if((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
-                (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
-                if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
-                    _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                                   "Password change required");
-                    LIBSSH2_FREE(session, session->userauth_pswd_data);
-                    session->userauth_pswd_data = NULL;
-                }
-                if(passwd_change_cb) {
-                    if(session->userauth_pswd_state ==
-                       libssh2_NB_state_sent1) {
-                        passwd_change_cb(session,
-                                         &session->userauth_pswd_newpw,
-                                         &session->userauth_pswd_newpw_len,
-                                         &session->abstract);
-                        if(!session->userauth_pswd_newpw) {
-                            return _libssh2_error(session,
-                                                LIBSSH2_ERROR_PASSWORD_EXPIRED,
-                                                  "Password expired, and "
-                                                  "callback failed");
-                        }
-
-                        /* basic data_len + newpw_len(4) */
-                        if(username_len + password_len + 44 <= UINT_MAX) {
-                            session->userauth_pswd_data_len =
-                                username_len + password_len + 44;
-                            s = session->userauth_pswd_data =
-                                LIBSSH2_ALLOC(session,
-                                              session->userauth_pswd_data_len);
-                        }
-                        else {
-                            s = session->userauth_pswd_data = NULL;
-                            session->userauth_pswd_data_len = 0;
-                        }
-
-                        if(!session->userauth_pswd_data) {
-                            LIBSSH2_FREE(session,
-                                         session->userauth_pswd_newpw);
-                            session->userauth_pswd_newpw = NULL;
-                            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                                  "Unable to allocate memory "
-                                                  "for userauth password "
-                                                  "change request");
-                        }
-
-                        *(s++) = SSH_MSG_USERAUTH_REQUEST;
-                        _libssh2_store_str(&s, username, username_len);
-                        _libssh2_store_str(&s, "ssh-connection",
-                                           sizeof("ssh-connection") - 1);
-                        _libssh2_store_str(&s, "password",
-                                           sizeof("password") - 1);
-                        *s++ = 0x01;
-                        _libssh2_store_str(&s, (char *)password, password_len);
-                        _libssh2_store_u32(&s,
-                                           session->userauth_pswd_newpw_len);
-                        /* send session->userauth_pswd_newpw separately */
-
-                        session->userauth_pswd_state = libssh2_NB_state_sent2;
-                    }
-
-                    if(session->userauth_pswd_state ==
-                       libssh2_NB_state_sent2) {
-                        rc = _libssh2_transport_send(session,
-                                            session->userauth_pswd_data,
-                                            session->userauth_pswd_data_len,
-                                            (unsigned char *)
-                                            session->userauth_pswd_newpw,
-                                            session->userauth_pswd_newpw_len);
-                        if(rc == LIBSSH2_ERROR_EAGAIN) {
-                            return _libssh2_error(session,
-                                                  LIBSSH2_ERROR_EAGAIN,
-                                                  "Would block waiting");
-                        }
-
-                        /* free the allocated packets again */
-                        LIBSSH2_FREE(session, session->userauth_pswd_data);
-                        session->userauth_pswd_data = NULL;
-                        LIBSSH2_FREE(session, session->userauth_pswd_newpw);
-                        session->userauth_pswd_newpw = NULL;
-
-                        if(rc) {
-                            return _libssh2_error(session,
-                                                  LIBSSH2_ERROR_SOCKET_SEND,
-                                                  "Unable to send userauth "
-                                                  "password-change request");
-                        }
-
-                        /*
-                         * Ugliest use of goto ever.  Blame it on the
-                         * askN => requirev migration.
-                         */
-                        session->userauth_pswd_state = libssh2_NB_state_sent;
-                        goto password_response;
-                    }
-                }
-            }
-            else {
-                session->userauth_pswd_state = libssh2_NB_state_idle;
-                return _libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED,
-                                      "Password Expired, and no callback "
-                                      "specified");
-            }
-        }
-    }
-
-    /* FAILURE */
-    LIBSSH2_FREE(session, session->userauth_pswd_data);
-    session->userauth_pswd_data = NULL;
-    session->userauth_pswd_state = libssh2_NB_state_idle;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_AUTHENTICATION_FAILED,
-                          "Authentication failed");
-}
-
-/*
- * libssh2_userauth_password_ex
- *
- * Plain ol' login
- */
-
-LIBSSH2_API int
-libssh2_userauth_password_ex(LIBSSH2_SESSION *session, const char *username,
-                             unsigned int username_len, const char *password,
-                             unsigned int password_len,
-                             LIBSSH2_PASSWD_CHANGEREQ_FUNC
-                             ((*passwd_change_cb)))
-{
-    int rc;
-    BLOCK_ADJUST(rc, session,
-                 userauth_password(session, username, username_len,
-                                   (unsigned char *)password, password_len,
-                                   passwd_change_cb));
-    return rc;
-}
-
-static int
-memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
-                      size_t *method_len,
-                      unsigned char **pubkeydata,
-                      size_t *pubkeydata_len,
-                      const char *pubkeyfiledata,
-                      size_t pubkeyfiledata_len)
-{
-    unsigned char *pubkey = NULL, *sp1, *sp2, *tmp;
-    size_t pubkey_len = pubkeyfiledata_len;
-    unsigned int tmp_len;
-
-    if(pubkeyfiledata_len <= 1) {
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Invalid data in public key file");
-    }
-
-    pubkey = LIBSSH2_ALLOC(session, pubkeyfiledata_len);
-    if(!pubkey) {
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for public key data");
-    }
-
-    memcpy(pubkey, pubkeyfiledata, pubkeyfiledata_len);
-
-    /*
-     *   Remove trailing whitespace
-     */
-    while(pubkey_len && isspace(pubkey[pubkey_len - 1]))
-        pubkey_len--;
-
-    if(!pubkey_len) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Missing public key data");
-    }
-
-    sp1 = memchr(pubkey, ' ', pubkey_len);
-    if(sp1 == NULL) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Invalid public key data");
-    }
-
-    sp1++;
-
-    sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey));
-    if(sp2 == NULL) {
-        /* Assume that the id string is missing, but that it's okay */
-        sp2 = pubkey + pubkey_len;
-    }
-
-    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
-                              (char *) sp1, sp2 - sp1)) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                                  "Invalid key data, not base64 encoded");
-    }
-
-    /* Wasting some bytes here (okay, more than some), but since it's likely
-     * to be freed soon anyway, we'll just avoid the extra free/alloc and call
-     * it a wash
-     */
-    *method = pubkey;
-    *method_len = sp1 - pubkey - 1;
-
-    *pubkeydata = tmp;
-    *pubkeydata_len = tmp_len;
-
-    return 0;
-}
-
-/*
- * file_read_publickey
- *
- * Read a public key from an id_???.pub style file
- *
- * Returns an allocated string containing the decoded key in *pubkeydata
- * on success.
- * Returns an allocated string containing the key method (e.g. "ssh-dss")
- * in method on success.
- */
-static int
-file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
-                    size_t *method_len,
-                    unsigned char **pubkeydata,
-                    size_t *pubkeydata_len,
-                    const char *pubkeyfile)
-{
-    FILE *fd;
-    char c;
-    unsigned char *pubkey = NULL, *sp1, *sp2, *tmp;
-    size_t pubkey_len = 0, sp_len;
-    unsigned int tmp_len;
-
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading public key file: %s",
-                   pubkeyfile);
-    /* Read Public Key */
-    fd = fopen(pubkeyfile, FOPEN_READTEXT);
-    if(!fd) {
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Unable to open public key file");
-    }
-    while(!feof(fd) && 1 == fread(&c, 1, 1, fd) && c != '\r' && c != '\n') {
-        pubkey_len++;
-    }
-    rewind(fd);
-
-    if(pubkey_len <= 1) {
-        fclose(fd);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Invalid data in public key file");
-    }
-
-    pubkey = LIBSSH2_ALLOC(session, pubkey_len);
-    if(!pubkey) {
-        fclose(fd);
-        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "Unable to allocate memory for public key data");
-    }
-    if(fread(pubkey, 1, pubkey_len, fd) != pubkey_len) {
-        LIBSSH2_FREE(session, pubkey);
-        fclose(fd);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Unable to read public key from file");
-    }
-    fclose(fd);
-    /*
-     * Remove trailing whitespace
-     */
-    while(pubkey_len && isspace(pubkey[pubkey_len - 1])) {
-        pubkey_len--;
-    }
-
-    if(!pubkey_len) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Missing public key data");
-    }
-
-    sp1 = memchr(pubkey, ' ', pubkey_len);
-    if(sp1 == NULL) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Invalid public key data");
-    }
-
-    sp1++;
-
-    sp_len = sp1 > pubkey ? (sp1 - pubkey) : 0;
-    sp2 = memchr(sp1, ' ', pubkey_len - sp_len);
-    if(sp2 == NULL) {
-        /* Assume that the id string is missing, but that it's okay */
-        sp2 = pubkey + pubkey_len;
-    }
-
-    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
-                              (char *) sp1, sp2 - sp1)) {
-        LIBSSH2_FREE(session, pubkey);
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Invalid key data, not base64 encoded");
-    }
-
-    /* Wasting some bytes here (okay, more than some), but since it's likely
-     * to be freed soon anyway, we'll just avoid the extra free/alloc and call
-     * it a wash */
-    *method = pubkey;
-    *method_len = sp1 - pubkey - 1;
-
-    *pubkeydata = tmp;
-    *pubkeydata_len = tmp_len;
-
-    return 0;
-}
-
-static int
-memory_read_privatekey(LIBSSH2_SESSION * session,
-                       const LIBSSH2_HOSTKEY_METHOD ** hostkey_method,
-                       void **hostkey_abstract,
-                       const unsigned char *method, int method_len,
-                       const char *privkeyfiledata, size_t privkeyfiledata_len,
-                       const char *passphrase)
-{
-    const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail =
-        libssh2_hostkey_methods();
-
-    *hostkey_method = NULL;
-    *hostkey_abstract = NULL;
-    while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
-        if((*hostkey_methods_avail)->initPEMFromMemory
-             && strncmp((*hostkey_methods_avail)->name, (const char *) method,
-                        method_len) == 0) {
-            *hostkey_method = *hostkey_methods_avail;
-            break;
-        }
-        hostkey_methods_avail++;
-    }
-    if(!*hostkey_method) {
-        return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
-                              "No handler for specified private key");
-    }
-
-    if((*hostkey_method)->
-        initPEMFromMemory(session, privkeyfiledata, privkeyfiledata_len,
-                          (unsigned char *) passphrase,
-                          hostkey_abstract)) {
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Unable to initialize private key from file");
-    }
-
-    return 0;
-}
-
-/* libssh2_file_read_privatekey
- * Read a PEM encoded private key from an id_??? style file
- */
-static int
-file_read_privatekey(LIBSSH2_SESSION * session,
-                     const LIBSSH2_HOSTKEY_METHOD ** hostkey_method,
-                     void **hostkey_abstract,
-                     const unsigned char *method, int method_len,
-                     const char *privkeyfile, const char *passphrase)
-{
-    const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail =
-        libssh2_hostkey_methods();
-
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading private key file: %s",
-                   privkeyfile);
-    *hostkey_method = NULL;
-    *hostkey_abstract = NULL;
-    while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
-        if((*hostkey_methods_avail)->initPEM
-            && strncmp((*hostkey_methods_avail)->name, (const char *) method,
-                       method_len) == 0) {
-            *hostkey_method = *hostkey_methods_avail;
-            break;
-        }
-        hostkey_methods_avail++;
-    }
-    if(!*hostkey_method) {
-        return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
-                              "No handler for specified private key");
-    }
-
-    if((*hostkey_method)->
-        initPEM(session, privkeyfile, (unsigned char *) passphrase,
-                hostkey_abstract)) {
-        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Unable to initialize private key from file");
-    }
-
-    return 0;
-}
-
-struct privkey_file {
-    const char *filename;
-    const char *passphrase;
-};
-
-static int
-sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
-                const unsigned char *data, size_t data_len, void **abstract)
-{
-    struct privkey_file *pk_file = (struct privkey_file *) (*abstract);
-    const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
-    void *hostkey_abstract;
-    struct iovec datavec;
-    int rc;
-
-    rc = memory_read_privatekey(session, &privkeyobj, &hostkey_abstract,
-                                session->userauth_pblc_method,
-                                session->userauth_pblc_method_len,
-                                pk_file->filename,
-                                strlen(pk_file->filename),
-                                pk_file->passphrase);
-    if(rc)
-        return rc;
-
-    libssh2_prepare_iovec(&datavec, 1);
-    datavec.iov_base = (void *)data;
-    datavec.iov_len  = data_len;
-
-    if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
-                          &hostkey_abstract)) {
-        if(privkeyobj->dtor) {
-            privkeyobj->dtor(session, &hostkey_abstract);
-        }
-        return -1;
-    }
-
-    if(privkeyobj->dtor) {
-        privkeyobj->dtor(session, &hostkey_abstract);
-    }
-    return 0;
-}
-
-static int
-sign_fromfile(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
-              const unsigned char *data, size_t data_len, void **abstract)
-{
-    struct privkey_file *privkey_file = (struct privkey_file *) (*abstract);
-    const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
-    void *hostkey_abstract;
-    struct iovec datavec;
-    int rc;
-
-    rc = file_read_privatekey(session, &privkeyobj, &hostkey_abstract,
-                              session->userauth_pblc_method,
-                              session->userauth_pblc_method_len,
-                              privkey_file->filename,
-                              privkey_file->passphrase);
-    if(rc)
-        return rc;
-
-    libssh2_prepare_iovec(&datavec, 1);
-    datavec.iov_base = (void *)data;
-    datavec.iov_len  = data_len;
-
-    if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
-                          &hostkey_abstract)) {
-        if(privkeyobj->dtor) {
-            privkeyobj->dtor(session, &hostkey_abstract);
-        }
-        return -1;
-    }
-
-    if(privkeyobj->dtor) {
-        privkeyobj->dtor(session, &hostkey_abstract);
-    }
-    return 0;
-}
-
-
-
-/* userauth_hostbased_fromfile
- * Authenticate using a keypair found in the named files
- */
-static int
-userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
-                            const char *username, size_t username_len,
-                            const char *publickey, const char *privatekey,
-                            const char *passphrase, const char *hostname,
-                            size_t hostname_len,
-                            const char *local_username,
-                            size_t local_username_len)
-{
-    int rc;
-
-    if(session->userauth_host_state == libssh2_NB_state_idle) {
-        const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
-        unsigned char *pubkeydata = NULL;
-        unsigned char *sig = NULL;
-        size_t pubkeydata_len = 0;
-        size_t sig_len = 0;
-        void *abstract;
-        unsigned char buf[5];
-        struct iovec datavec[4];
-
-        /* Zero the whole thing out */
-        memset(&session->userauth_host_packet_requirev_state, 0,
-               sizeof(session->userauth_host_packet_requirev_state));
-
-        if(publickey) {
-            rc = file_read_publickey(session, &session->userauth_host_method,
-                                     &session->userauth_host_method_len,
-                                     &pubkeydata, &pubkeydata_len, publickey);
-            if(rc)
-                /* Note: file_read_publickey() calls _libssh2_error() */
-                return rc;
-        }
-        else {
-            /* Compute public key from private key. */
-            rc = _libssh2_pub_priv_keyfile(session,
-                                           &session->userauth_host_method,
-                                           &session->userauth_host_method_len,
-                                           &pubkeydata, &pubkeydata_len,
-                                           privatekey, passphrase);
-            if(rc)
-                /* libssh2_pub_priv_keyfile calls _libssh2_error() */
-                return rc;
-        }
-
-        /*
-         * 52 = packet_type(1) + username_len(4) + servicename_len(4) +
-         * service_name(14)"ssh-connection" + authmethod_len(4) +
-         * authmethod(9)"hostbased" + method_len(4) + pubkeydata_len(4) +
-         * hostname_len(4) + local_username_len(4)
-         */
-        session->userauth_host_packet_len =
-            username_len + session->userauth_host_method_len + hostname_len +
-            local_username_len + pubkeydata_len + 52;
-
-        /*
-         * Preallocate space for an overall length,  method name again,
-         * and the signature, which won't be any larger than the size of
-         * the publickeydata itself
-         */
-        session->userauth_host_s = session->userauth_host_packet =
-            LIBSSH2_ALLOC(session,
-                          session->userauth_host_packet_len + 4 +
-                          (4 + session->userauth_host_method_len) +
-                          (4 + pubkeydata_len));
-        if(!session->userauth_host_packet) {
-            LIBSSH2_FREE(session, session->userauth_host_method);
-            session->userauth_host_method = NULL;
-            LIBSSH2_FREE(session, pubkeydata);
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Out of memory");
-        }
-
-        *(session->userauth_host_s++) = SSH_MSG_USERAUTH_REQUEST;
-        _libssh2_store_str(&session->userauth_host_s, username, username_len);
-        _libssh2_store_str(&session->userauth_host_s, "ssh-connection", 14);
-        _libssh2_store_str(&session->userauth_host_s, "hostbased", 9);
-        _libssh2_store_str(&session->userauth_host_s,
-                           (const char *)session->userauth_host_method,
-                           session->userauth_host_method_len);
-        _libssh2_store_str(&session->userauth_host_s, (const char *)pubkeydata,
-                           pubkeydata_len);
-        LIBSSH2_FREE(session, pubkeydata);
-        _libssh2_store_str(&session->userauth_host_s, hostname, hostname_len);
-        _libssh2_store_str(&session->userauth_host_s, local_username,
-                           local_username_len);
-
-        rc = file_read_privatekey(session, &privkeyobj, &abstract,
-                                  session->userauth_host_method,
-                                  session->userauth_host_method_len,
-                                  privatekey, passphrase);
-        if(rc) {
-            /* Note: file_read_privatekey() calls _libssh2_error() */
-            LIBSSH2_FREE(session, session->userauth_host_method);
-            session->userauth_host_method = NULL;
-            LIBSSH2_FREE(session, session->userauth_host_packet);
-            session->userauth_host_packet = NULL;
-            return rc;
-        }
-
-        _libssh2_htonu32(buf, session->session_id_len);
-        libssh2_prepare_iovec(datavec, 4);
-        datavec[0].iov_base = (void *)buf;
-        datavec[0].iov_len = 4;
-        datavec[1].iov_base = (void *)session->session_id;
-        datavec[1].iov_len = session->session_id_len;
-        datavec[2].iov_base = (void *)session->userauth_host_packet;
-        datavec[2].iov_len = session->userauth_host_packet_len;
-
-        if(privkeyobj && privkeyobj->signv &&
-                          privkeyobj->signv(session, &sig, &sig_len, 3,
-                                            datavec, &abstract)) {
-            LIBSSH2_FREE(session, session->userauth_host_method);
-            session->userauth_host_method = NULL;
-            LIBSSH2_FREE(session, session->userauth_host_packet);
-            session->userauth_host_packet = NULL;
-            if(privkeyobj->dtor) {
-                privkeyobj->dtor(session, &abstract);
-            }
-            return -1;
-        }
-
-        if(privkeyobj && privkeyobj->dtor) {
-            privkeyobj->dtor(session, &abstract);
-        }
-
-        if(sig_len > pubkeydata_len) {
-            unsigned char *newpacket;
-            /* Should *NEVER* happen, but...well.. better safe than sorry */
-            newpacket = LIBSSH2_REALLOC(session, session->userauth_host_packet,
-                                        session->userauth_host_packet_len + 4 +
-                                        (4 + session->userauth_host_method_len)
-                                        + (4 + sig_len)); /* PK sigblob */
-            if(!newpacket) {
-                LIBSSH2_FREE(session, sig);
-                LIBSSH2_FREE(session, session->userauth_host_packet);
-                session->userauth_host_packet = NULL;
-                LIBSSH2_FREE(session, session->userauth_host_method);
-                session->userauth_host_method = NULL;
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "Failed allocating additional space for "
-                                      "userauth-hostbased packet");
-            }
-            session->userauth_host_packet = newpacket;
-        }
-
-        session->userauth_host_s =
-            session->userauth_host_packet + session->userauth_host_packet_len;
-
-        _libssh2_store_u32(&session->userauth_host_s,
-                           4 + session->userauth_host_method_len +
-                           4 + sig_len);
-        _libssh2_store_str(&session->userauth_host_s,
-                           (const char *)session->userauth_host_method,
-                           session->userauth_host_method_len);
-        LIBSSH2_FREE(session, session->userauth_host_method);
-        session->userauth_host_method = NULL;
-
-        _libssh2_store_str(&session->userauth_host_s, (const char *)sig,
-                           sig_len);
-        LIBSSH2_FREE(session, sig);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting hostbased authentication");
-
-        session->userauth_host_state = libssh2_NB_state_created;
-    }
-
-    if(session->userauth_host_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, session->userauth_host_packet,
-                                     session->userauth_host_s -
-                                     session->userauth_host_packet,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, session->userauth_host_packet);
-            session->userauth_host_packet = NULL;
-            session->userauth_host_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send userauth-hostbased request");
-        }
-        LIBSSH2_FREE(session, session->userauth_host_packet);
-        session->userauth_host_packet = NULL;
-
-        session->userauth_host_state = libssh2_NB_state_sent;
-    }
-
-    if(session->userauth_host_state == libssh2_NB_state_sent) {
-        static const unsigned char reply_codes[3] =
-            { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
-        size_t data_len;
-        rc = _libssh2_packet_requirev(session, reply_codes,
-                                      &session->userauth_host_data,
-                                      &data_len, 0, NULL, 0,
-                                      &session->
-                                      userauth_host_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-
-        session->userauth_host_state = libssh2_NB_state_idle;
-        if(rc || data_len < 1) {
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Auth failed");
-        }
-
-        if(session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                           "Hostbased authentication successful");
-            /* We are us and we've proved it. */
-            LIBSSH2_FREE(session, session->userauth_host_data);
-            session->userauth_host_data = NULL;
-            session->state |= LIBSSH2_STATE_AUTHENTICATED;
-            return 0;
-        }
-    }
-
-    /* This public key is not allowed for this user on this server */
-    LIBSSH2_FREE(session, session->userauth_host_data);
-    session->userauth_host_data = NULL;
-    return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                          "Invalid signature for supplied public key, or bad "
-                          "username/public key combination");
-}
-
-/* libssh2_userauth_hostbased_fromfile_ex
- * Authenticate using a keypair found in the named files
- */
-LIBSSH2_API int
-libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
-                                       const char *user,
-                                       unsigned int user_len,
-                                       const char *publickey,
-                                       const char *privatekey,
-                                       const char *passphrase,
-                                       const char *host,
-                                       unsigned int host_len,
-                                       const char *localuser,
-                                       unsigned int localuser_len)
-{
-    int rc;
-    BLOCK_ADJUST(rc, session,
-                 userauth_hostbased_fromfile(session, user, user_len,
-                                             publickey, privatekey,
-                                             passphrase, host, host_len,
-                                             localuser, localuser_len));
-    return rc;
-}
-
-static int plain_method_len(const char *method, size_t method_len)
-{
-    if(!strncmp("ecdsa-sha2-nistp256-cert-v01@openssh.com",
-                method,
-                method_len) ||
-       !strncmp("ecdsa-sha2-nistp384-cert-v01@openssh.com",
-                method,
-                method_len) ||
-       !strncmp("ecdsa-sha2-nistp521-cert-v01@openssh.com",
-                method,
-                method_len)) {
-        return 19;
-    }
-    return method_len;
-}
-
-int
-_libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                            const char *username,
-                            unsigned int username_len,
-                            const unsigned char *pubkeydata,
-                            unsigned long pubkeydata_len,
-                            LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                            ((*sign_callback)),
-                            void *abstract)
-{
-    unsigned char reply_codes[4] =
-        { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE,
-          SSH_MSG_USERAUTH_PK_OK, 0
-        };
-    int rc;
-    unsigned char *s;
-
-    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
-
-        /*
-         * The call to _libssh2_ntohu32 later relies on pubkeydata having at
-         * least 4 valid bytes containing the length of the method name.
-         */
-        if(pubkeydata_len < 4)
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Invalid public key, too short");
-
-        /* Zero the whole thing out */
-        memset(&session->userauth_pblc_packet_requirev_state, 0,
-               sizeof(session->userauth_pblc_packet_requirev_state));
-
-        /*
-         * As an optimisation, userauth_publickey_fromfile reuses a
-         * previously allocated copy of the method name to avoid an extra
-         * allocation/free.
-         * For other uses, we allocate and populate it here.
-         */
-        if(!session->userauth_pblc_method) {
-            session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata);
-
-            if(session->userauth_pblc_method_len > pubkeydata_len - 4)
-                /* the method length simply cannot be longer than the entire
-                   passed in data, so we use this to detect crazy input
-                   data */
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                      "Invalid public key");
-
-            session->userauth_pblc_method =
-                LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
-            if(!session->userauth_pblc_method) {
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "Unable to allocate memory "
-                                      "for public key data");
-            }
-            memcpy(session->userauth_pblc_method, pubkeydata + 4,
-                   session->userauth_pblc_method_len);
-        }
-        /*
-         * The length of the method name read from plaintext prefix in the
-         * file must match length embedded in the key.
-         * TODO: The data should match too but we don't check that. Should we?
-         */
-        else if(session->userauth_pblc_method_len !=
-                 _libssh2_ntohu32(pubkeydata))
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Invalid public key");
-
-        /*
-         * 45 = packet_type(1) + username_len(4) + servicename_len(4) +
-         * service_name(14)"ssh-connection" + authmethod_len(4) +
-         * authmethod(9)"publickey" + sig_included(1)'\0' + algmethod_len(4) +
-         * publickey_len(4)
-         */
-        session->userauth_pblc_packet_len =
-            username_len + session->userauth_pblc_method_len + pubkeydata_len +
-            45;
-
-        /*
-         * Preallocate space for an overall length, method name again, and the
-         * signature, which won't be any larger than the size of the
-         * publickeydata itself.
-         *
-         * Note that the 'pubkeydata_len' extra bytes allocated here will not
-         * be used in this first send, but will be used in the later one where
-         * this same allocation is re-used.
-         */
-        s = session->userauth_pblc_packet =
-            LIBSSH2_ALLOC(session,
-                          session->userauth_pblc_packet_len + 4 +
-                          (4 + session->userauth_pblc_method_len)
-                          + (4 + pubkeydata_len));
-        if(!session->userauth_pblc_packet) {
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Out of memory");
-        }
-
-        *s++ = SSH_MSG_USERAUTH_REQUEST;
-        _libssh2_store_str(&s, username, username_len);
-        _libssh2_store_str(&s, "ssh-connection", 14);
-        _libssh2_store_str(&s, "publickey", 9);
-
-        session->userauth_pblc_b = s;
-        /* Not sending signature with *this* packet */
-        *s++ = 0;
-
-        _libssh2_store_str(&s, (const char *)session->userauth_pblc_method,
-                           session->userauth_pblc_method_len);
-        _libssh2_store_str(&s, (const char *)pubkeydata, pubkeydata_len);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting publickey authentication");
-
-        session->userauth_pblc_state = libssh2_NB_state_created;
-    }
-
-    if(session->userauth_pblc_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
-                                     session->userauth_pblc_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN)
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        else if(rc) {
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send userauth-publickey request");
-        }
-
-        session->userauth_pblc_state = libssh2_NB_state_sent;
-    }
-
-    if(session->userauth_pblc_state == libssh2_NB_state_sent) {
-        rc = _libssh2_packet_requirev(session, reply_codes,
-                                      &session->userauth_pblc_data,
-                                      &session->userauth_pblc_data_len, 0,
-                                      NULL, 0,
-                                      &session->
-                                      userauth_pblc_packet_requirev_state);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-        else if(rc || (session->userauth_pblc_data_len < 1)) {
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Waiting for USERAUTH response");
-        }
-
-        if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                           "Pubkey authentication prematurely successful");
-            /*
-             * God help any SSH server that allows an UNVERIFIED
-             * public key to validate the user
-             */
-            LIBSSH2_FREE(session, session->userauth_pblc_data);
-            session->userauth_pblc_data = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            session->state |= LIBSSH2_STATE_AUTHENTICATED;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return 0;
-        }
-
-        if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) {
-            /* This public key is not allowed for this user on this server */
-            LIBSSH2_FREE(session, session->userauth_pblc_data);
-            session->userauth_pblc_data = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_AUTHENTICATION_FAILED,
-                                  "Username/PublicKey combination invalid");
-        }
-
-        /* Semi-Success! */
-        LIBSSH2_FREE(session, session->userauth_pblc_data);
-        session->userauth_pblc_data = NULL;
-
-        *session->userauth_pblc_b = 0x01;
-        session->userauth_pblc_state = libssh2_NB_state_sent1;
-    }
-
-    if(session->userauth_pblc_state == libssh2_NB_state_sent1) {
-        unsigned char *buf;
-        unsigned char *sig;
-        size_t sig_len;
-
-        s = buf = LIBSSH2_ALLOC(session, 4 + session->session_id_len
-                                + session->userauth_pblc_packet_len);
-        if(!buf) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "userauth-publickey signed data");
-        }
-
-        _libssh2_store_str(&s, (const char *)session->session_id,
-                           session->session_id_len);
-
-        memcpy(s, session->userauth_pblc_packet,
-               session->userauth_pblc_packet_len);
-        s += session->userauth_pblc_packet_len;
-
-        rc = sign_callback(session, &sig, &sig_len, buf, s - buf, abstract);
-        LIBSSH2_FREE(session, buf);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, session->userauth_pblc_method);
-            session->userauth_pblc_method = NULL;
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Callback returned error");
-        }
-
-        /*
-         * If this function was restarted, pubkeydata_len might still be 0
-         * which will cause an unnecessary but harmless realloc here.
-         */
-        if(sig_len > pubkeydata_len) {
-            unsigned char *newpacket;
-            /* Should *NEVER* happen, but...well.. better safe than sorry */
-            newpacket = LIBSSH2_REALLOC(session,
-                                        session->userauth_pblc_packet,
-                                        session->userauth_pblc_packet_len + 4 +
-                                        (4 + session->userauth_pblc_method_len)
-                                        + (4 + sig_len)); /* PK sigblob */
-            if(!newpacket) {
-                LIBSSH2_FREE(session, sig);
-                LIBSSH2_FREE(session, session->userauth_pblc_packet);
-                session->userauth_pblc_packet = NULL;
-                LIBSSH2_FREE(session, session->userauth_pblc_method);
-                session->userauth_pblc_method = NULL;
-                session->userauth_pblc_state = libssh2_NB_state_idle;
-                return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                      "Failed allocating additional space for "
-                                      "userauth-publickey packet");
-            }
-            session->userauth_pblc_packet = newpacket;
-        }
-
-        s = session->userauth_pblc_packet + session->userauth_pblc_packet_len;
-        session->userauth_pblc_b = NULL;
-
-        session->userauth_pblc_method_len =
-           plain_method_len((const char *)session->userauth_pblc_method,
-                            session->userauth_pblc_method_len);
-
-        _libssh2_store_u32(&s,
-                           4 + session->userauth_pblc_method_len + 4 +
-                           sig_len);
-        _libssh2_store_str(&s, (const char *)session->userauth_pblc_method,
-                           session->userauth_pblc_method_len);
-
-        LIBSSH2_FREE(session, session->userauth_pblc_method);
-        session->userauth_pblc_method = NULL;
-
-        _libssh2_store_str(&s, (const char *)sig, sig_len);
-        LIBSSH2_FREE(session, sig);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting publickey authentication -- phase 2");
-
-        session->userauth_pblc_s = s;
-        session->userauth_pblc_state = libssh2_NB_state_sent2;
-    }
-
-    if(session->userauth_pblc_state == libssh2_NB_state_sent2) {
-        rc = _libssh2_transport_send(session, session->userauth_pblc_packet,
-                                     session->userauth_pblc_s -
-                                     session->userauth_pblc_packet,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, session->userauth_pblc_packet);
-            session->userauth_pblc_packet = NULL;
-            session->userauth_pblc_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send userauth-publickey request");
-        }
-        LIBSSH2_FREE(session, session->userauth_pblc_packet);
-        session->userauth_pblc_packet = NULL;
-
-        session->userauth_pblc_state = libssh2_NB_state_sent3;
-    }
-
-    /* PK_OK is no longer valid */
-    reply_codes[2] = 0;
-
-    rc = _libssh2_packet_requirev(session, reply_codes,
-                               &session->userauth_pblc_data,
-                               &session->userauth_pblc_data_len, 0, NULL, 0,
-                               &session->userauth_pblc_packet_requirev_state);
-    if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                              "Would block requesting userauth list");
-    }
-    else if(rc || session->userauth_pblc_data_len < 1) {
-        session->userauth_pblc_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                              "Waiting for publickey USERAUTH response");
-    }
-
-    if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Publickey authentication successful");
-        /* We are us and we've proved it. */
-        LIBSSH2_FREE(session, session->userauth_pblc_data);
-        session->userauth_pblc_data = NULL;
-        session->state |= LIBSSH2_STATE_AUTHENTICATED;
-        session->userauth_pblc_state = libssh2_NB_state_idle;
-        return 0;
-    }
-
-    /* This public key is not allowed for this user on this server */
-    LIBSSH2_FREE(session, session->userauth_pblc_data);
-    session->userauth_pblc_data = NULL;
-    session->userauth_pblc_state = libssh2_NB_state_idle;
-    return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                          "Invalid signature for supplied public key, or bad "
-                          "username/public key combination");
-}
-
- /*
-  * userauth_publickey_frommemory
-  * Authenticate using a keypair from memory
-  */
-static int
-userauth_publickey_frommemory(LIBSSH2_SESSION *session,
-                              const char *username,
-                              size_t username_len,
-                              const char *publickeydata,
-                              size_t publickeydata_len,
-                              const char *privatekeydata,
-                              size_t privatekeydata_len,
-                              const char *passphrase)
-{
-    unsigned char *pubkeydata = NULL;
-    size_t pubkeydata_len = 0;
-    struct privkey_file privkey_file;
-    void *abstract = &privkey_file;
-    int rc;
-
-    privkey_file.filename = privatekeydata;
-    privkey_file.passphrase = passphrase;
-
-    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
-        if(publickeydata_len && publickeydata) {
-            rc = memory_read_publickey(session, &session->userauth_pblc_method,
-                                       &session->userauth_pblc_method_len,
-                                       &pubkeydata, &pubkeydata_len,
-                                       publickeydata, publickeydata_len);
-            if(rc)
-                return rc;
-        }
-        else if(privatekeydata_len && privatekeydata) {
-            /* Compute public key from private key. */
-            rc = _libssh2_pub_priv_keyfilememory(session,
-                                            &session->userauth_pblc_method,
-                                            &session->userauth_pblc_method_len,
-                                            &pubkeydata, &pubkeydata_len,
-                                            privatekeydata, privatekeydata_len,
-                                            passphrase);
-            if(rc)
-                return rc;
-        }
-        else {
-            return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                                  "Invalid data in public and private key.");
-        }
-    }
-
-    rc = _libssh2_userauth_publickey(session, username, username_len,
-                                     pubkeydata, pubkeydata_len,
-                                     sign_frommemory, &abstract);
-    if(pubkeydata)
-        LIBSSH2_FREE(session, pubkeydata);
-
-    return rc;
-}
-
-/*
- * userauth_publickey_fromfile
- * Authenticate using a keypair found in the named files
- */
-static int
-userauth_publickey_fromfile(LIBSSH2_SESSION *session,
-                            const char *username,
-                            size_t username_len,
-                            const char *publickey,
-                            const char *privatekey,
-                            const char *passphrase)
-{
-    unsigned char *pubkeydata = NULL;
-    size_t pubkeydata_len = 0;
-    struct privkey_file privkey_file;
-    void *abstract = &privkey_file;
-    int rc;
-
-    privkey_file.filename = privatekey;
-    privkey_file.passphrase = passphrase;
-
-    if(session->userauth_pblc_state == libssh2_NB_state_idle) {
-        if(publickey) {
-            rc = file_read_publickey(session, &session->userauth_pblc_method,
-                                     &session->userauth_pblc_method_len,
-                                     &pubkeydata, &pubkeydata_len, publickey);
-            if(rc)
-                return rc;
-        }
-        else {
-            /* Compute public key from private key. */
-            rc = _libssh2_pub_priv_keyfile(session,
-                                           &session->userauth_pblc_method,
-                                           &session->userauth_pblc_method_len,
-                                           &pubkeydata, &pubkeydata_len,
-                                           privatekey, passphrase);
-
-            /* _libssh2_pub_priv_keyfile calls _libssh2_error() */
-            if(rc)
-                return rc;
-        }
-    }
-
-    rc = _libssh2_userauth_publickey(session, username, username_len,
-                                     pubkeydata, pubkeydata_len,
-                                     sign_fromfile, &abstract);
-    if(pubkeydata)
-        LIBSSH2_FREE(session, pubkeydata);
-
-    return rc;
-}
-
-/* libssh2_userauth_publickey_frommemory
- * Authenticate using a keypair from memory
- */
-LIBSSH2_API int
-libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
-                                      const char *user,
-                                      size_t user_len,
-                                      const char *publickeyfiledata,
-                                      size_t publickeyfiledata_len,
-                                      const char *privatekeyfiledata,
-                                      size_t privatekeyfiledata_len,
-                                      const char *passphrase)
-{
-    int rc;
-
-    if(NULL == passphrase)
-        /* if given a NULL pointer, make it point to a zero-length
-           string to save us from having to check this all over */
-        passphrase = "";
-
-    BLOCK_ADJUST(rc, session,
-                 userauth_publickey_frommemory(session, user, user_len,
-                                               publickeyfiledata,
-                                               publickeyfiledata_len,
-                                               privatekeyfiledata,
-                                               privatekeyfiledata_len,
-                                               passphrase));
-    return rc;
-}
-
-/* libssh2_userauth_publickey_fromfile_ex
- * Authenticate using a keypair found in the named files
- */
-LIBSSH2_API int
-libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
-                                       const char *user,
-                                       unsigned int user_len,
-                                       const char *publickey,
-                                       const char *privatekey,
-                                       const char *passphrase)
-{
-    int rc;
-
-    if(NULL == passphrase)
-        /* if given a NULL pointer, make it point to a zero-length
-           string to save us from having to check this all over */
-        passphrase = "";
-
-    BLOCK_ADJUST(rc, session,
-                 userauth_publickey_fromfile(session, user, user_len,
-                                             publickey, privatekey,
-                                             passphrase));
-    return rc;
-}
-
-/* libssh2_userauth_publickey_ex
- * Authenticate using an external callback function
- */
-LIBSSH2_API int
-libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                           const char *user,
-                           const unsigned char *pubkeydata,
-                           size_t pubkeydata_len,
-                           LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                           ((*sign_callback)),
-                           void **abstract)
-{
-    int rc;
-
-    if(!session)
-        return LIBSSH2_ERROR_BAD_USE;
-
-    BLOCK_ADJUST(rc, session,
-                 _libssh2_userauth_publickey(session, user, strlen(user),
-                                             pubkeydata, pubkeydata_len,
-                                             sign_callback, abstract));
-    return rc;
-}
-
-
-
-/*
- * userauth_keyboard_interactive
- *
- * Authenticate using a challenge-response authentication
- */
-static int
-userauth_keyboard_interactive(LIBSSH2_SESSION * session,
-                              const char *username,
-                              unsigned int username_len,
-                              LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC
-                              ((*response_callback)))
-{
-    unsigned char *s;
-    int rc;
-
-    static const unsigned char reply_codes[4] = {
-        SSH_MSG_USERAUTH_SUCCESS,
-        SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_INFO_REQUEST, 0
-    };
-    unsigned int language_tag_len;
-    unsigned int i;
-
-    if(session->userauth_kybd_state == libssh2_NB_state_idle) {
-        session->userauth_kybd_auth_name = NULL;
-        session->userauth_kybd_auth_instruction = NULL;
-        session->userauth_kybd_num_prompts = 0;
-        session->userauth_kybd_auth_failure = 1;
-        session->userauth_kybd_prompts = NULL;
-        session->userauth_kybd_responses = NULL;
-
-        /* Zero the whole thing out */
-        memset(&session->userauth_kybd_packet_requirev_state, 0,
-               sizeof(session->userauth_kybd_packet_requirev_state));
-
-        session->userauth_kybd_packet_len =
-            1                   /* byte    SSH_MSG_USERAUTH_REQUEST */
-            + 4 + username_len  /* string  user name (ISO-10646 UTF-8, as
-                                   defined in [RFC-3629]) */
-            + 4 + 14            /* string  service name (US-ASCII) */
-            + 4 + 20            /* string  "keyboard-interactive" (US-ASCII) */
-            + 4 + 0             /* string  language tag (as defined in
-                                   [RFC-3066]) */
-            + 4 + 0             /* string  submethods (ISO-10646 UTF-8) */
-            ;
-
-        session->userauth_kybd_data = s =
-            LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
-        if(!s) {
-            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for "
-                                  "keyboard-interactive authentication");
-        }
-
-        *s++ = SSH_MSG_USERAUTH_REQUEST;
-
-        /* user name */
-        _libssh2_store_str(&s, username, username_len);
-
-        /* service name */
-        _libssh2_store_str(&s, "ssh-connection", sizeof("ssh-connection") - 1);
-
-        /* "keyboard-interactive" */
-        _libssh2_store_str(&s, "keyboard-interactive",
-                           sizeof("keyboard-interactive") - 1);
-        /* language tag */
-        _libssh2_store_u32(&s, 0);
-
-        /* submethods */
-        _libssh2_store_u32(&s, 0);
-
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting keyboard-interactive authentication");
-
-        session->userauth_kybd_state = libssh2_NB_state_created;
-    }
-
-    if(session->userauth_kybd_state == libssh2_NB_state_created) {
-        rc = _libssh2_transport_send(session, session->userauth_kybd_data,
-                                     session->userauth_kybd_packet_len,
-                                     NULL, 0);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                  "Would block");
-        }
-        else if(rc) {
-            LIBSSH2_FREE(session, session->userauth_kybd_data);
-            session->userauth_kybd_data = NULL;
-            session->userauth_kybd_state = libssh2_NB_state_idle;
-            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                                  "Unable to send keyboard-interactive"
-                                  " request");
-        }
-        LIBSSH2_FREE(session, session->userauth_kybd_data);
-        session->userauth_kybd_data = NULL;
-
-        session->userauth_kybd_state = libssh2_NB_state_sent;
-    }
-
-    for(;;) {
-        if(session->userauth_kybd_state == libssh2_NB_state_sent) {
-            rc = _libssh2_packet_requirev(session, reply_codes,
-                                          &session->userauth_kybd_data,
-                                          &session->userauth_kybd_data_len,
-                                          0, NULL, 0,
-                                          &session->
-                                          userauth_kybd_packet_requirev_state);
-            if(rc == LIBSSH2_ERROR_EAGAIN) {
-                return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                      "Would block");
-            }
-            else if(rc || session->userauth_kybd_data_len < 1) {
-                session->userauth_kybd_state = libssh2_NB_state_idle;
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_AUTHENTICATION_FAILED,
-                                      "Waiting for keyboard "
-                                      "USERAUTH response");
-            }
-
-            if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Keyboard-interactive "
-                               "authentication successful");
-                LIBSSH2_FREE(session, session->userauth_kybd_data);
-                session->userauth_kybd_data = NULL;
-                session->state |= LIBSSH2_STATE_AUTHENTICATED;
-                session->userauth_kybd_state = libssh2_NB_state_idle;
-                return 0;
-            }
-
-            if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Keyboard-interactive authentication failed");
-                LIBSSH2_FREE(session, session->userauth_kybd_data);
-                session->userauth_kybd_data = NULL;
-                session->userauth_kybd_state = libssh2_NB_state_idle;
-                return _libssh2_error(session,
-                                      LIBSSH2_ERROR_AUTHENTICATION_FAILED,
-                                      "Authentication failed "
-                                      "(keyboard-interactive)");
-            }
-
-            /* server requested PAM-like conversation */
-            s = session->userauth_kybd_data + 1;
-
-            if(session->userauth_kybd_data_len >= 5) {
-                /* string    name (ISO-10646 UTF-8) */
-                session->userauth_kybd_auth_name_len = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "to get length");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_auth_name_len) {
-                session->userauth_kybd_auth_name =
-                    LIBSSH2_ALLOC(session,
-                                  session->userauth_kybd_auth_name_len);
-                if(!session->userauth_kybd_auth_name) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive 'name' "
-                                   "request field");
-                    goto cleanup;
-                }
-                if(s + session->userauth_list_data_len <=
-                   session->userauth_kybd_data +
-                   session->userauth_kybd_data_len) {
-                    memcpy(session->userauth_kybd_auth_name, s,
-                           session->userauth_kybd_auth_name_len);
-                    s += session->userauth_kybd_auth_name_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "userauth keyboard data buffer too small"
-                                   "for auth name");
-                    goto cleanup;
-                }
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* string    instruction (ISO-10646 UTF-8) */
-                session->userauth_kybd_auth_instruction_len =
-                    _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth instruction length");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_auth_instruction_len) {
-                session->userauth_kybd_auth_instruction =
-                    LIBSSH2_ALLOC(session,
-                                  session->userauth_kybd_auth_instruction_len);
-                if(!session->userauth_kybd_auth_instruction) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive 'instruction' "
-                                   "request field");
-                    goto cleanup;
-                }
-                if(s + session->userauth_kybd_auth_instruction_len <=
-                   session->userauth_kybd_data +
-                   session->userauth_kybd_data_len) {
-                    memcpy(session->userauth_kybd_auth_instruction, s,
-                           session->userauth_kybd_auth_instruction_len);
-                    s += session->userauth_kybd_auth_instruction_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "userauth keyboard data buffer too small"
-                                   "for auth instruction");
-                    goto cleanup;
-                }
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* string    language tag (as defined in [RFC-3066]) */
-                language_tag_len = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth language tag length");
-                goto cleanup;
-            }
-
-            if(s + language_tag_len <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* ignoring this field as deprecated */
-                s += language_tag_len;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth language tag");
-                goto cleanup;
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* int       num-prompts */
-                session->userauth_kybd_num_prompts = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth num keyboard prompts");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_num_prompts > 100) {
-                _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
-                               "Too many replies for "
-                               "keyboard-interactive prompts");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_num_prompts) {
-                session->userauth_kybd_prompts =
-                    LIBSSH2_CALLOC(session,
-                                   sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
-                                   session->userauth_kybd_num_prompts);
-                if(!session->userauth_kybd_prompts) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive prompts array");
-                    goto cleanup;
-                }
-
-                session->userauth_kybd_responses =
-                    LIBSSH2_CALLOC(session,
-                                   sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
-                                   session->userauth_kybd_num_prompts);
-                if(!session->userauth_kybd_responses) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive responses array");
-                    goto cleanup;
-                }
-
-                for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                    if(s + 4 <= session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        /* string    prompt[1] (ISO-10646 UTF-8) */
-                        session->userauth_kybd_prompts[i].length =
-                            _libssh2_ntohu32(s);
-                        s += 4;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard "
-                                       "prompt length");
-                        goto cleanup;
-                    }
-
-                    session->userauth_kybd_prompts[i].text =
-                        LIBSSH2_CALLOC(session,
-                                       session->userauth_kybd_prompts[i].
-                                       length);
-                    if(!session->userauth_kybd_prompts[i].text) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate memory for "
-                                       "keyboard-interactive prompt message");
-                        goto cleanup;
-                    }
-
-                    if(s + session->userauth_kybd_prompts[i].length <=
-                       session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        memcpy(session->userauth_kybd_prompts[i].text, s,
-                               session->userauth_kybd_prompts[i].length);
-                        s += session->userauth_kybd_prompts[i].length;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard prompt");
-                        goto cleanup;
-                    }
-                    if(s < session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        /* boolean   echo[1] */
-                        session->userauth_kybd_prompts[i].echo = *s++;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard prompt echo");
-                        goto cleanup;
-                    }
-                }
-            }
-
-            response_callback(session->userauth_kybd_auth_name,
-                              session->userauth_kybd_auth_name_len,
-                              session->userauth_kybd_auth_instruction,
-                              session->userauth_kybd_auth_instruction_len,
-                              session->userauth_kybd_num_prompts,
-                              session->userauth_kybd_prompts,
-                              session->userauth_kybd_responses,
-                              &session->abstract);
-
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                           "Keyboard-interactive response callback function"
-                           " invoked");
-
-            session->userauth_kybd_packet_len =
-                1 /* byte      SSH_MSG_USERAUTH_INFO_RESPONSE */
-                + 4             /* int       num-responses */
-                ;
-
-            for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                /* string    response[1] (ISO-10646 UTF-8) */
-                if(session->userauth_kybd_responses[i].length <=
-                   (SIZE_MAX - 4 - session->userauth_kybd_packet_len) ) {
-                    session->userauth_kybd_packet_len +=
-                        4 + session->userauth_kybd_responses[i].length;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for keyboard-"
-                                   "interactive response packet");
-                    goto cleanup;
-                }
-            }
-
-            /* A new userauth_kybd_data area is to be allocated, free the
-               former one. */
-            LIBSSH2_FREE(session, session->userauth_kybd_data);
-
-            session->userauth_kybd_data = s =
-                LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
-            if(!s) {
-                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                               "Unable to allocate memory for keyboard-"
-                               "interactive response packet");
-                goto cleanup;
-            }
-
-            *s = SSH_MSG_USERAUTH_INFO_RESPONSE;
-            s++;
-            _libssh2_store_u32(&s, session->userauth_kybd_num_prompts);
-
-            for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                _libssh2_store_str(&s,
-                                   session->userauth_kybd_responses[i].text,
-                                   session->userauth_kybd_responses[i].length);
-            }
-
-            session->userauth_kybd_state = libssh2_NB_state_sent1;
-        }
-
-        if(session->userauth_kybd_state == libssh2_NB_state_sent1) {
-            rc = _libssh2_transport_send(session, session->userauth_kybd_data,
-                                         session->userauth_kybd_packet_len,
-                                         NULL, 0);
-            if(rc == LIBSSH2_ERROR_EAGAIN)
-                return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
-                                      "Would block");
-            if(rc) {
-                _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
-                               "Unable to send userauth-keyboard-interactive"
-                               " request");
-                goto cleanup;
-            }
-
-            session->userauth_kybd_auth_failure = 0;
-        }
-
-      cleanup:
-        /*
-         * It's safe to clean all the data here, because unallocated pointers
-         * are filled by zeroes
-         */
-
-        LIBSSH2_FREE(session, session->userauth_kybd_data);
-        session->userauth_kybd_data = NULL;
-
-        if(session->userauth_kybd_prompts) {
-            for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                LIBSSH2_FREE(session, session->userauth_kybd_prompts[i].text);
-                session->userauth_kybd_prompts[i].text = NULL;
-            }
-        }
-
-        if(session->userauth_kybd_responses) {
-            for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                LIBSSH2_FREE(session,
-                             session->userauth_kybd_responses[i].text);
-                session->userauth_kybd_responses[i].text = NULL;
-            }
-        }
-
-        if(session->userauth_kybd_prompts) {
-            LIBSSH2_FREE(session, session->userauth_kybd_prompts);
-            session->userauth_kybd_prompts = NULL;
-        }
-        if(session->userauth_kybd_responses) {
-            LIBSSH2_FREE(session, session->userauth_kybd_responses);
-            session->userauth_kybd_responses = NULL;
-        }
-        if(session->userauth_kybd_auth_name) {
-            LIBSSH2_FREE(session, session->userauth_kybd_auth_name);
-            session->userauth_kybd_auth_name = NULL;
-        }
-        if(session->userauth_kybd_auth_instruction) {
-            LIBSSH2_FREE(session, session->userauth_kybd_auth_instruction);
-            session->userauth_kybd_auth_instruction = NULL;
-        }
-
-        if(session->userauth_kybd_auth_failure) {
-            session->userauth_kybd_state = libssh2_NB_state_idle;
-            return -1;
-        }
-
-        session->userauth_kybd_state = libssh2_NB_state_sent;
-    }
-}
-
-/*
- * libssh2_userauth_keyboard_interactive_ex
- *
- * Authenticate using a challenge-response authentication
- */
-LIBSSH2_API int
-libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *session,
-                                         const char *user,
-                                         unsigned int user_len,
-                                         LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC
-                                         ((*response_callback)))
-{
-    int rc;
-    BLOCK_ADJUST(rc, session,
-                 userauth_keyboard_interactive(session, user, user_len,
-                                               response_callback));
-    return rc;
-}
diff --git a/libssh2/libssh2/src/userauth.h b/libssh2/libssh2/src/userauth.h
deleted file mode 100644
index 6b402ddb..00000000
--- a/libssh2/libssh2/src/userauth.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef __LIBSSH2_USERAUTH_H
-#define __LIBSSH2_USERAUTH_H
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2010 by Daniel Stenberg
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-int
-_libssh2_userauth_publickey(LIBSSH2_SESSION *session,
-                            const char *username,
-                            unsigned int username_len,
-                            const unsigned char *pubkeydata,
-                            unsigned long pubkeydata_len,
-                            LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                            ((*sign_callback)),
-                            void *abstract);
-
-#endif /* __LIBSSH2_USERAUTH_H */
diff --git a/libssh2/libssh2/src/version.c b/libssh2/libssh2/src/version.c
deleted file mode 100644
index 408f83a3..00000000
--- a/libssh2/libssh2/src/version.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/* Copyright (C) 2009 Daniel Stenberg.  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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- */
-
-#include "libssh2_priv.h"
-
-/*
-  libssh2_version() can be used like this:
-
-  if (!libssh2_version(LIBSSH2_VERSION_NUM)) {
-    fprintf (stderr, "Runtime libssh2 version too old!\n");
-    exit(1);
-  }
-*/
-LIBSSH2_API
-const char *libssh2_version(int req_version_num)
-{
-    if(req_version_num <= LIBSSH2_VERSION_NUM)
-        return LIBSSH2_VERSION;
-    return NULL; /* this is not a suitable library! */
-}
diff --git a/libssh2/libssh2/src/wincng.c b/libssh2/libssh2/src/wincng.c
deleted file mode 100644
index cbb2b61c..00000000
--- a/libssh2/libssh2/src/wincng.c
+++ /dev/null
@@ -1,2593 +0,0 @@
-/*
- * Copyright (C) 2013-2020 Marc Hoersken <info@marc-hoersken.de>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_WINCNG /* compile only if we build with wincng */
-
-/* required for cross-compilation against the w64 mingw-runtime package */
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
-#undef _WIN32_WINNT
-#endif
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT 0x0600
-#endif
-
-/* specify the required libraries for dependencies using MSVC */
-#ifdef _MSC_VER
-#pragma comment(lib, "bcrypt.lib")
-#ifdef HAVE_LIBCRYPT32
-#pragma comment(lib, "crypt32.lib")
-#endif
-#endif
-
-#include <windows.h>
-#include <bcrypt.h>
-#include <ntstatus.h>
-#include <math.h>
-#include "misc.h"
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_LIBCRYPT32
-#include <wincrypt.h>
-#endif
-
-#define PEM_RSA_HEADER "-----BEGIN RSA PRIVATE KEY-----"
-#define PEM_RSA_FOOTER "-----END RSA PRIVATE KEY-----"
-#define PEM_DSA_HEADER "-----BEGIN DSA PRIVATE KEY-----"
-#define PEM_DSA_FOOTER "-----END DSA PRIVATE KEY-----"
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Missing definitions (for MinGW[-w64])
- */
-#ifndef BCRYPT_SUCCESS
-#define BCRYPT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
-#endif
-
-#ifndef BCRYPT_RNG_ALGORITHM
-#define BCRYPT_RNG_ALGORITHM L"RNG"
-#endif
-
-#ifndef BCRYPT_MD5_ALGORITHM
-#define BCRYPT_MD5_ALGORITHM L"MD5"
-#endif
-
-#ifndef BCRYPT_SHA1_ALGORITHM
-#define BCRYPT_SHA1_ALGORITHM L"SHA1"
-#endif
-
-#ifndef BCRYPT_SHA256_ALGORITHM
-#define BCRYPT_SHA256_ALGORITHM L"SHA256"
-#endif
-
-#ifndef BCRYPT_SHA384_ALGORITHM
-#define BCRYPT_SHA384_ALGORITHM L"SHA384"
-#endif
-
-#ifndef BCRYPT_SHA512_ALGORITHM
-#define BCRYPT_SHA512_ALGORITHM L"SHA512"
-#endif
-
-#ifndef BCRYPT_RSA_ALGORITHM
-#define BCRYPT_RSA_ALGORITHM L"RSA"
-#endif
-
-#ifndef BCRYPT_DSA_ALGORITHM
-#define BCRYPT_DSA_ALGORITHM L"DSA"
-#endif
-
-#ifndef BCRYPT_AES_ALGORITHM
-#define BCRYPT_AES_ALGORITHM L"AES"
-#endif
-
-#ifndef BCRYPT_RC4_ALGORITHM
-#define BCRYPT_RC4_ALGORITHM L"RC4"
-#endif
-
-#ifndef BCRYPT_3DES_ALGORITHM
-#define BCRYPT_3DES_ALGORITHM L"3DES"
-#endif
-
-#ifndef BCRYPT_DH_ALGORITHM
-#define BCRYPT_DH_ALGORITHM L"DH"
-#endif
-
-/* BCRYPT_KDF_RAW_SECRET is available from Windows 8.1 and onwards */
-#ifndef BCRYPT_KDF_RAW_SECRET
-#define BCRYPT_KDF_RAW_SECRET L"TRUNCATE"
-#endif
-
-#ifndef BCRYPT_ALG_HANDLE_HMAC_FLAG
-#define BCRYPT_ALG_HANDLE_HMAC_FLAG 0x00000008
-#endif
-
-#ifndef BCRYPT_DSA_PUBLIC_BLOB
-#define BCRYPT_DSA_PUBLIC_BLOB L"DSAPUBLICBLOB"
-#endif
-
-#ifndef BCRYPT_DSA_PUBLIC_MAGIC
-#define BCRYPT_DSA_PUBLIC_MAGIC 0x42505344 /* DSPB */
-#endif
-
-#ifndef BCRYPT_DSA_PRIVATE_BLOB
-#define BCRYPT_DSA_PRIVATE_BLOB L"DSAPRIVATEBLOB"
-#endif
-
-#ifndef BCRYPT_DSA_PRIVATE_MAGIC
-#define BCRYPT_DSA_PRIVATE_MAGIC 0x56505344 /* DSPV */
-#endif
-
-#ifndef BCRYPT_RSAPUBLIC_BLOB
-#define BCRYPT_RSAPUBLIC_BLOB L"RSAPUBLICBLOB"
-#endif
-
-#ifndef BCRYPT_RSAPUBLIC_MAGIC
-#define BCRYPT_RSAPUBLIC_MAGIC 0x31415352 /* RSA1 */
-#endif
-
-#ifndef BCRYPT_RSAFULLPRIVATE_BLOB
-#define BCRYPT_RSAFULLPRIVATE_BLOB L"RSAFULLPRIVATEBLOB"
-#endif
-
-#ifndef BCRYPT_RSAFULLPRIVATE_MAGIC
-#define BCRYPT_RSAFULLPRIVATE_MAGIC 0x33415352 /* RSA3 */
-#endif
-
-#ifndef BCRYPT_KEY_DATA_BLOB
-#define BCRYPT_KEY_DATA_BLOB L"KeyDataBlob"
-#endif
-
-#ifndef BCRYPT_MESSAGE_BLOCK_LENGTH
-#define BCRYPT_MESSAGE_BLOCK_LENGTH L"MessageBlockLength"
-#endif
-
-#ifndef BCRYPT_NO_KEY_VALIDATION
-#define BCRYPT_NO_KEY_VALIDATION 0x00000008
-#endif
-
-#ifndef BCRYPT_BLOCK_PADDING
-#define BCRYPT_BLOCK_PADDING 0x00000001
-#endif
-
-#ifndef BCRYPT_PAD_NONE
-#define BCRYPT_PAD_NONE 0x00000001
-#endif
-
-#ifndef BCRYPT_PAD_PKCS1
-#define BCRYPT_PAD_PKCS1 0x00000002
-#endif
-
-#ifndef BCRYPT_PAD_OAEP
-#define BCRYPT_PAD_OAEP 0x00000004
-#endif
-
-#ifndef BCRYPT_PAD_PSS
-#define BCRYPT_PAD_PSS 0x00000008
-#endif
-
-#ifndef CRYPT_STRING_ANY
-#define CRYPT_STRING_ANY 0x00000007
-#endif
-
-#ifndef LEGACY_RSAPRIVATE_BLOB
-#define LEGACY_RSAPRIVATE_BLOB L"CAPIPRIVATEBLOB"
-#endif
-
-#ifndef PKCS_RSA_PRIVATE_KEY
-#define PKCS_RSA_PRIVATE_KEY (LPCSTR)43
-#endif
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Generic functions
- */
-
-struct _libssh2_wincng_ctx _libssh2_wincng;
-
-void
-_libssh2_wincng_init(void)
-{
-    int ret;
-
-    memset(&_libssh2_wincng, 0, sizeof(_libssh2_wincng));
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgRNG,
-                                      BCRYPT_RNG_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgRNG = NULL;
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashMD5,
-                                      BCRYPT_MD5_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHashMD5 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashSHA1,
-                                      BCRYPT_SHA1_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHashSHA1 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashSHA256,
-                                      BCRYPT_SHA256_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHashSHA256 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashSHA384,
-                                      BCRYPT_SHA384_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHashSHA384 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashSHA512,
-                                      BCRYPT_SHA512_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHashSHA512 = NULL;
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacMD5,
-                                      BCRYPT_MD5_ALGORITHM, NULL,
-                                      BCRYPT_ALG_HANDLE_HMAC_FLAG);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHmacMD5 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacSHA1,
-                                      BCRYPT_SHA1_ALGORITHM, NULL,
-                                      BCRYPT_ALG_HANDLE_HMAC_FLAG);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHmacSHA1 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacSHA256,
-                                      BCRYPT_SHA256_ALGORITHM, NULL,
-                                      BCRYPT_ALG_HANDLE_HMAC_FLAG);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHmacSHA256 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacSHA384,
-                                      BCRYPT_SHA384_ALGORITHM, NULL,
-                                      BCRYPT_ALG_HANDLE_HMAC_FLAG);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHmacSHA384 = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacSHA512,
-                                      BCRYPT_SHA512_ALGORITHM, NULL,
-                                      BCRYPT_ALG_HANDLE_HMAC_FLAG);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgHmacSHA512 = NULL;
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgRSA,
-                                      BCRYPT_RSA_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgRSA = NULL;
-    }
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgDSA,
-                                      BCRYPT_DSA_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgDSA = NULL;
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgAES_CBC,
-                                      BCRYPT_AES_ALGORITHM, NULL, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_CBC,
-                                BCRYPT_CHAINING_MODE,
-                                (PBYTE)BCRYPT_CHAIN_MODE_CBC,
-                                sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
-        if(!BCRYPT_SUCCESS(ret)) {
-            ret = BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgAES_CBC, 0);
-            if(BCRYPT_SUCCESS(ret)) {
-                _libssh2_wincng.hAlgAES_CBC = NULL;
-            }
-        }
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgAES_ECB,
-                                      BCRYPT_AES_ALGORITHM, NULL, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgAES_ECB,
-                                BCRYPT_CHAINING_MODE,
-                                (PBYTE)BCRYPT_CHAIN_MODE_ECB,
-                                sizeof(BCRYPT_CHAIN_MODE_ECB), 0);
-        if(!BCRYPT_SUCCESS(ret)) {
-            ret = BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgAES_ECB, 0);
-            if(BCRYPT_SUCCESS(ret)) {
-                _libssh2_wincng.hAlgAES_ECB = NULL;
-            }
-        }
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgRC4_NA,
-                                      BCRYPT_RC4_ALGORITHM, NULL, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlgRC4_NA,
-                                BCRYPT_CHAINING_MODE,
-                                (PBYTE)BCRYPT_CHAIN_MODE_NA,
-                                sizeof(BCRYPT_CHAIN_MODE_NA), 0);
-        if(!BCRYPT_SUCCESS(ret)) {
-            ret = BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRC4_NA, 0);
-            if(BCRYPT_SUCCESS(ret)) {
-                _libssh2_wincng.hAlgRC4_NA = NULL;
-            }
-        }
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlg3DES_CBC,
-                                      BCRYPT_3DES_ALGORITHM, NULL, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        ret = BCryptSetProperty(_libssh2_wincng.hAlg3DES_CBC,
-                                BCRYPT_CHAINING_MODE,
-                                (PBYTE)BCRYPT_CHAIN_MODE_CBC,
-                                sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
-        if(!BCRYPT_SUCCESS(ret)) {
-            ret = BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlg3DES_CBC,
-                                               0);
-            if(BCRYPT_SUCCESS(ret)) {
-                _libssh2_wincng.hAlg3DES_CBC = NULL;
-            }
-        }
-    }
-
-    ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgDH,
-                                      BCRYPT_DH_ALGORITHM, NULL, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng.hAlgDH = NULL;
-    }
-}
-
-void
-_libssh2_wincng_free(void)
-{
-    if(_libssh2_wincng.hAlgRNG)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRNG, 0);
-    if(_libssh2_wincng.hAlgHashMD5)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashMD5, 0);
-    if(_libssh2_wincng.hAlgHashSHA1)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA1, 0);
-    if(_libssh2_wincng.hAlgHashSHA256)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA256, 0);
-    if(_libssh2_wincng.hAlgHashSHA384)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA384, 0);
-    if(_libssh2_wincng.hAlgHashSHA512)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA512, 0);
-    if(_libssh2_wincng.hAlgHmacMD5)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacMD5, 0);
-    if(_libssh2_wincng.hAlgHmacSHA1)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacSHA1, 0);
-    if(_libssh2_wincng.hAlgHmacSHA256)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacSHA256, 0);
-    if(_libssh2_wincng.hAlgHmacSHA384)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacSHA384, 0);
-    if(_libssh2_wincng.hAlgHmacSHA512)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacSHA512, 0);
-    if(_libssh2_wincng.hAlgRSA)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRSA, 0);
-    if(_libssh2_wincng.hAlgDSA)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgDSA, 0);
-    if(_libssh2_wincng.hAlgAES_CBC)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgAES_CBC, 0);
-    if(_libssh2_wincng.hAlgRC4_NA)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRC4_NA, 0);
-    if(_libssh2_wincng.hAlg3DES_CBC)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlg3DES_CBC, 0);
-    if(_libssh2_wincng.hAlgDH)
-        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgDH, 0);
-
-    memset(&_libssh2_wincng, 0, sizeof(_libssh2_wincng));
-}
-
-int
-_libssh2_wincng_random(void *buf, int len)
-{
-    int ret;
-
-    ret = BCryptGenRandom(_libssh2_wincng.hAlgRNG, buf, len, 0);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-static void
-_libssh2_wincng_safe_free(void *buf, int len)
-{
-#ifndef LIBSSH2_CLEAR_MEMORY
-    (void)len;
-#endif
-
-    if(!buf)
-        return;
-
-#ifdef LIBSSH2_CLEAR_MEMORY
-    if(len > 0)
-        SecureZeroMemory(buf, len);
-#endif
-
-    free(buf);
-}
-
-/* Copy a big endian set of bits from src to dest.
- * if the size of src is smaller than dest then pad the "left" (MSB)
- * end with zeroes and copy the bits into the "right" (LSB) end. */
-static void
-memcpy_with_be_padding(unsigned char *dest, unsigned long dest_len,
-                       unsigned char *src, unsigned long src_len)
-{
-    if(dest_len > src_len) {
-        memset(dest, 0, dest_len - src_len);
-    }
-    memcpy((dest + dest_len) - src_len, src, src_len);
-}
-
-static int
-round_down(int number, int multiple)
-{
-    return (number / multiple) * multiple;
-}
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Hash functions
- */
-
-int
-_libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
-                          BCRYPT_ALG_HANDLE hAlg, unsigned long hashlen,
-                          unsigned char *key, unsigned long keylen)
-{
-    BCRYPT_HASH_HANDLE hHash;
-    unsigned char *pbHashObject;
-    unsigned long dwHashObject, dwHash, cbData;
-    int ret;
-
-    ret = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH,
-                            (unsigned char *)&dwHash,
-                            sizeof(dwHash),
-                            &cbData, 0);
-    if((!BCRYPT_SUCCESS(ret)) || dwHash != hashlen) {
-        return -1;
-    }
-
-    ret = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH,
-                            (unsigned char *)&dwHashObject,
-                            sizeof(dwHashObject),
-                            &cbData, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        return -1;
-    }
-
-    pbHashObject = malloc(dwHashObject);
-    if(!pbHashObject) {
-        return -1;
-    }
-
-
-    ret = BCryptCreateHash(hAlg, &hHash,
-                           pbHashObject, dwHashObject,
-                           key, keylen, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(pbHashObject, dwHashObject);
-        return -1;
-    }
-
-
-    ctx->hHash = hHash;
-    ctx->pbHashObject = pbHashObject;
-    ctx->dwHashObject = dwHashObject;
-    ctx->cbHash = dwHash;
-
-    return 0;
-}
-
-int
-_libssh2_wincng_hash_update(_libssh2_wincng_hash_ctx *ctx,
-                            const unsigned char *data, unsigned long datalen)
-{
-    int ret;
-
-    ret = BCryptHashData(ctx->hHash, (unsigned char *)data, datalen, 0);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-int
-_libssh2_wincng_hash_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash)
-{
-    int ret;
-
-    ret = BCryptFinishHash(ctx->hHash, hash, ctx->cbHash, 0);
-
-    BCryptDestroyHash(ctx->hHash);
-    ctx->hHash = NULL;
-
-    _libssh2_wincng_safe_free(ctx->pbHashObject, ctx->dwHashObject);
-    ctx->pbHashObject = NULL;
-    ctx->dwHashObject = 0;
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-int
-_libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
-                     BCRYPT_ALG_HANDLE hAlg,
-                     unsigned char *hash, unsigned long hashlen)
-{
-    _libssh2_wincng_hash_ctx ctx;
-    int ret;
-
-    ret = _libssh2_wincng_hash_init(&ctx, hAlg, hashlen, NULL, 0);
-    if(!ret) {
-        ret = _libssh2_wincng_hash_update(&ctx, data, datalen);
-        ret |= _libssh2_wincng_hash_final(&ctx, hash);
-    }
-
-    return ret;
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: HMAC functions
- */
-
-int
-_libssh2_wincng_hmac_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash)
-{
-    int ret;
-
-    ret = BCryptFinishHash(ctx->hHash, hash, ctx->cbHash, 0);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-void
-_libssh2_wincng_hmac_cleanup(_libssh2_wincng_hash_ctx *ctx)
-{
-    BCryptDestroyHash(ctx->hHash);
-    ctx->hHash = NULL;
-
-    _libssh2_wincng_safe_free(ctx->pbHashObject, ctx->dwHashObject);
-    ctx->pbHashObject = NULL;
-    ctx->dwHashObject = 0;
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Key functions
- */
-
-int
-_libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len,
-                                unsigned long flags)
-{
-    BCRYPT_PKCS1_PADDING_INFO paddingInfoPKCS1;
-    void *pPaddingInfo;
-    unsigned char *data, *hash;
-    unsigned long datalen, hashlen;
-    int ret;
-
-    datalen = m_len;
-    data = malloc(datalen);
-    if(!data) {
-        return -1;
-    }
-
-    hashlen = SHA_DIGEST_LENGTH;
-    hash = malloc(hashlen);
-    if(!hash) {
-        free(data);
-        return -1;
-    }
-
-    memcpy(data, m, datalen);
-
-    ret = _libssh2_wincng_hash(data, datalen,
-                               _libssh2_wincng.hAlgHashSHA1,
-                               hash, hashlen);
-
-    _libssh2_wincng_safe_free(data, datalen);
-
-    if(ret) {
-        _libssh2_wincng_safe_free(hash, hashlen);
-        return -1;
-    }
-
-    datalen = sig_len;
-    data = malloc(datalen);
-    if(!data) {
-        _libssh2_wincng_safe_free(hash, hashlen);
-        return -1;
-    }
-
-    if(flags & BCRYPT_PAD_PKCS1) {
-        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA1_ALGORITHM;
-        pPaddingInfo = &paddingInfoPKCS1;
-    }
-    else
-        pPaddingInfo = NULL;
-
-    memcpy(data, sig, datalen);
-
-    ret = BCryptVerifySignature(ctx->hKey, pPaddingInfo,
-                                hash, hashlen, data, datalen, flags);
-
-    _libssh2_wincng_safe_free(hash, hashlen);
-    _libssh2_wincng_safe_free(data, datalen);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-#ifdef HAVE_LIBCRYPT32
-static int
-_libssh2_wincng_load_pem(LIBSSH2_SESSION *session,
-                         const char *filename,
-                         const char *passphrase,
-                         const char *headerbegin,
-                         const char *headerend,
-                         unsigned char **data,
-                         unsigned int *datalen)
-{
-    FILE *fp;
-    int ret;
-
-    fp = fopen(filename, FOPEN_READTEXT);
-    if(!fp) {
-        return -1;
-    }
-
-    ret = _libssh2_pem_parse(session, headerbegin, headerend,
-                             passphrase,
-                             fp, data, datalen);
-
-    fclose(fp);
-
-    return ret;
-}
-
-static int
-_libssh2_wincng_load_private(LIBSSH2_SESSION *session,
-                             const char *filename,
-                             const char *passphrase,
-                             unsigned char **ppbEncoded,
-                             unsigned long *pcbEncoded,
-                             int tryLoadRSA, int tryLoadDSA)
-{
-    unsigned char *data = NULL;
-    unsigned int datalen = 0;
-    int ret = -1;
-
-    if(ret && tryLoadRSA) {
-        ret = _libssh2_wincng_load_pem(session, filename, passphrase,
-                                       PEM_RSA_HEADER, PEM_RSA_FOOTER,
-                                       &data, &datalen);
-    }
-
-    if(ret && tryLoadDSA) {
-        ret = _libssh2_wincng_load_pem(session, filename, passphrase,
-                                       PEM_DSA_HEADER, PEM_DSA_FOOTER,
-                                       &data, &datalen);
-    }
-
-    if(!ret) {
-        *ppbEncoded = data;
-        *pcbEncoded = datalen;
-    }
-
-    return ret;
-}
-
-static int
-_libssh2_wincng_load_private_memory(LIBSSH2_SESSION *session,
-                                    const char *privatekeydata,
-                                    size_t privatekeydata_len,
-                                    const char *passphrase,
-                                    unsigned char **ppbEncoded,
-                                    unsigned long *pcbEncoded,
-                                    int tryLoadRSA, int tryLoadDSA)
-{
-    unsigned char *data = NULL;
-    unsigned int datalen = 0;
-    int ret = -1;
-
-    (void)passphrase;
-
-    if(ret && tryLoadRSA) {
-        ret = _libssh2_pem_parse_memory(session,
-                                        PEM_RSA_HEADER, PEM_RSA_FOOTER,
-                                        privatekeydata, privatekeydata_len,
-                                        &data, &datalen);
-    }
-
-    if(ret && tryLoadDSA) {
-        ret = _libssh2_pem_parse_memory(session,
-                                        PEM_DSA_HEADER, PEM_DSA_FOOTER,
-                                        privatekeydata, privatekeydata_len,
-                                        &data, &datalen);
-    }
-
-    if(!ret) {
-        *ppbEncoded = data;
-        *pcbEncoded = datalen;
-    }
-
-    return ret;
-}
-
-static int
-_libssh2_wincng_asn_decode(unsigned char *pbEncoded,
-                           unsigned long cbEncoded,
-                           LPCSTR lpszStructType,
-                           unsigned char **ppbDecoded,
-                           unsigned long *pcbDecoded)
-{
-    unsigned char *pbDecoded = NULL;
-    unsigned long cbDecoded = 0;
-    int ret;
-
-    ret = CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
-                              lpszStructType,
-                              pbEncoded, cbEncoded, 0, NULL,
-                              NULL, &cbDecoded);
-    if(!ret) {
-        return -1;
-    }
-
-    pbDecoded = malloc(cbDecoded);
-    if(!pbDecoded) {
-        return -1;
-    }
-
-    ret = CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
-                              lpszStructType,
-                              pbEncoded, cbEncoded, 0, NULL,
-                              pbDecoded, &cbDecoded);
-    if(!ret) {
-        _libssh2_wincng_safe_free(pbDecoded, cbDecoded);
-        return -1;
-    }
-
-
-    *ppbDecoded = pbDecoded;
-    *pcbDecoded = cbDecoded;
-
-    return 0;
-}
-
-static int
-_libssh2_wincng_bn_ltob(unsigned char *pbInput,
-                        unsigned long cbInput,
-                        unsigned char **ppbOutput,
-                        unsigned long *pcbOutput)
-{
-    unsigned char *pbOutput;
-    unsigned long cbOutput, index, offset, length;
-
-    if(cbInput < 1) {
-        return 0;
-    }
-
-    offset = 0;
-    length = cbInput - 1;
-    cbOutput = cbInput;
-    if(pbInput[length] & (1 << 7)) {
-        offset++;
-        cbOutput += offset;
-    }
-
-    pbOutput = (unsigned char *)malloc(cbOutput);
-    if(!pbOutput) {
-        return -1;
-    }
-
-    pbOutput[0] = 0;
-    for(index = 0; ((index + offset) < cbOutput)
-                    && (index < cbInput); index++) {
-        pbOutput[index + offset] = pbInput[length - index];
-    }
-
-
-    *ppbOutput = pbOutput;
-    *pcbOutput = cbOutput;
-
-    return 0;
-}
-
-static int
-_libssh2_wincng_asn_decode_bn(unsigned char *pbEncoded,
-                              unsigned long cbEncoded,
-                              unsigned char **ppbDecoded,
-                              unsigned long *pcbDecoded)
-{
-    unsigned char *pbDecoded = NULL, *pbInteger;
-    unsigned long cbDecoded = 0, cbInteger;
-    int ret;
-
-    ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
-                                     X509_MULTI_BYTE_UINT,
-                                     &pbInteger, &cbInteger);
-    if(!ret) {
-        ret = _libssh2_wincng_bn_ltob(((PCRYPT_DATA_BLOB)pbInteger)->pbData,
-                                      ((PCRYPT_DATA_BLOB)pbInteger)->cbData,
-                                      &pbDecoded, &cbDecoded);
-        if(!ret) {
-            *ppbDecoded = pbDecoded;
-            *pcbDecoded = cbDecoded;
-        }
-        _libssh2_wincng_safe_free(pbInteger, cbInteger);
-    }
-
-    return ret;
-}
-
-static int
-_libssh2_wincng_asn_decode_bns(unsigned char *pbEncoded,
-                               unsigned long cbEncoded,
-                               unsigned char ***prpbDecoded,
-                               unsigned long **prcbDecoded,
-                               unsigned long *pcbCount)
-{
-    PCRYPT_DER_BLOB pBlob;
-    unsigned char *pbDecoded, **rpbDecoded;
-    unsigned long cbDecoded, *rcbDecoded, index, length;
-    int ret;
-
-    ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
-                                     X509_SEQUENCE_OF_ANY,
-                                     &pbDecoded, &cbDecoded);
-    if(!ret) {
-        length = ((PCRYPT_DATA_BLOB)pbDecoded)->cbData;
-
-        rpbDecoded = malloc(sizeof(PBYTE) * length);
-        if(rpbDecoded) {
-            rcbDecoded = malloc(sizeof(DWORD) * length);
-            if(rcbDecoded) {
-                for(index = 0; index < length; index++) {
-                    pBlob = &((PCRYPT_DER_BLOB)
-                              ((PCRYPT_DATA_BLOB)pbDecoded)->pbData)[index];
-                    ret = _libssh2_wincng_asn_decode_bn(pBlob->pbData,
-                                                        pBlob->cbData,
-                                                        &rpbDecoded[index],
-                                                        &rcbDecoded[index]);
-                    if(ret)
-                        break;
-                }
-
-                if(!ret) {
-                    *prpbDecoded = rpbDecoded;
-                    *prcbDecoded = rcbDecoded;
-                    *pcbCount = length;
-                }
-                else {
-                    for(length = 0; length < index; length++) {
-                        _libssh2_wincng_safe_free(rpbDecoded[length],
-                                                  rcbDecoded[length]);
-                        rpbDecoded[length] = NULL;
-                        rcbDecoded[length] = 0;
-                    }
-                    free(rpbDecoded);
-                    free(rcbDecoded);
-                }
-            }
-            else {
-                free(rpbDecoded);
-                ret = -1;
-            }
-        }
-        else {
-            ret = -1;
-        }
-
-        _libssh2_wincng_safe_free(pbDecoded, cbDecoded);
-    }
-
-    return ret;
-}
-#endif /* HAVE_LIBCRYPT32 */
-
-static unsigned long
-_libssh2_wincng_bn_size(const unsigned char *bignum,
-                        unsigned long length)
-{
-    unsigned long offset;
-
-    if(!bignum)
-        return 0;
-
-    length--;
-
-    offset = 0;
-    while(!(*(bignum + offset)) && (offset < length))
-        offset++;
-
-    length++;
-
-    return length - offset;
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: RSA functions
- */
-
-int
-_libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen)
-{
-    BCRYPT_KEY_HANDLE hKey;
-    BCRYPT_RSAKEY_BLOB *rsakey;
-    LPCWSTR lpszBlobType;
-    unsigned char *key;
-    unsigned long keylen, offset, mlen, p1len = 0, p2len = 0;
-    int ret;
-
-    mlen = max(_libssh2_wincng_bn_size(ndata, nlen),
-               _libssh2_wincng_bn_size(ddata, dlen));
-    offset = sizeof(BCRYPT_RSAKEY_BLOB);
-    keylen = offset + elen + mlen;
-    if(ddata && dlen > 0) {
-        p1len = max(_libssh2_wincng_bn_size(pdata, plen),
-                    _libssh2_wincng_bn_size(e1data, e1len));
-        p2len = max(_libssh2_wincng_bn_size(qdata, qlen),
-                    _libssh2_wincng_bn_size(e2data, e2len));
-        keylen += p1len * 3 + p2len * 2 + mlen;
-    }
-
-    key = malloc(keylen);
-    if(!key) {
-        return -1;
-    }
-
-    memset(key, 0, keylen);
-
-
-    /* https://msdn.microsoft.com/library/windows/desktop/aa375531.aspx */
-    rsakey = (BCRYPT_RSAKEY_BLOB *)key;
-    rsakey->BitLength = mlen * 8;
-    rsakey->cbPublicExp = elen;
-    rsakey->cbModulus = mlen;
-
-    memcpy(key + offset, edata, elen);
-    offset += elen;
-
-    if(nlen < mlen)
-        memcpy(key + offset + mlen - nlen, ndata, nlen);
-    else
-        memcpy(key + offset, ndata + nlen - mlen, mlen);
-
-    if(ddata && dlen > 0) {
-        offset += mlen;
-
-        if(plen < p1len)
-            memcpy(key + offset + p1len - plen, pdata, plen);
-        else
-            memcpy(key + offset, pdata + plen - p1len, p1len);
-        offset += p1len;
-
-        if(qlen < p2len)
-            memcpy(key + offset + p2len - qlen, qdata, qlen);
-        else
-            memcpy(key + offset, qdata + qlen - p2len, p2len);
-        offset += p2len;
-
-        if(e1len < p1len)
-            memcpy(key + offset + p1len - e1len, e1data, e1len);
-        else
-            memcpy(key + offset, e1data + e1len - p1len, p1len);
-        offset += p1len;
-
-        if(e2len < p2len)
-            memcpy(key + offset + p2len - e2len, e2data, e2len);
-        else
-            memcpy(key + offset, e2data + e2len - p2len, p2len);
-        offset += p2len;
-
-        if(coefflen < p1len)
-            memcpy(key + offset + p1len - coefflen, coeffdata, coefflen);
-        else
-            memcpy(key + offset, coeffdata + coefflen - p1len, p1len);
-        offset += p1len;
-
-        if(dlen < mlen)
-            memcpy(key + offset + mlen - dlen, ddata, dlen);
-        else
-            memcpy(key + offset, ddata + dlen - mlen, mlen);
-
-        lpszBlobType = BCRYPT_RSAFULLPRIVATE_BLOB;
-        rsakey->Magic = BCRYPT_RSAFULLPRIVATE_MAGIC;
-        rsakey->cbPrime1 = p1len;
-        rsakey->cbPrime2 = p2len;
-    }
-    else {
-        lpszBlobType = BCRYPT_RSAPUBLIC_BLOB;
-        rsakey->Magic = BCRYPT_RSAPUBLIC_MAGIC;
-        rsakey->cbPrime1 = 0;
-        rsakey->cbPrime2 = 0;
-    }
-
-
-    ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL, lpszBlobType,
-                              &hKey, key, keylen, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(key, keylen);
-        return -1;
-    }
-
-
-    *rsa = malloc(sizeof(libssh2_rsa_ctx));
-    if(!(*rsa)) {
-        BCryptDestroyKey(hKey);
-        _libssh2_wincng_safe_free(key, keylen);
-        return -1;
-    }
-
-    (*rsa)->hKey = hKey;
-    (*rsa)->pbKeyObject = key;
-    (*rsa)->cbKeyObject = keylen;
-
-    return 0;
-}
-
-#ifdef HAVE_LIBCRYPT32
-static int
-_libssh2_wincng_rsa_new_private_parse(libssh2_rsa_ctx **rsa,
-                                      LIBSSH2_SESSION *session,
-                                      unsigned char *pbEncoded,
-                                      unsigned long cbEncoded)
-{
-    BCRYPT_KEY_HANDLE hKey;
-    unsigned char *pbStructInfo;
-    unsigned long cbStructInfo;
-    int ret;
-
-    (void)session;
-
-    ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
-                                     PKCS_RSA_PRIVATE_KEY,
-                                     &pbStructInfo, &cbStructInfo);
-
-    _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
-
-    if(ret) {
-        return -1;
-    }
-
-
-    ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL,
-                              LEGACY_RSAPRIVATE_BLOB, &hKey,
-                              pbStructInfo, cbStructInfo, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(pbStructInfo, cbStructInfo);
-        return -1;
-    }
-
-
-    *rsa = malloc(sizeof(libssh2_rsa_ctx));
-    if(!(*rsa)) {
-        BCryptDestroyKey(hKey);
-        _libssh2_wincng_safe_free(pbStructInfo, cbStructInfo);
-        return -1;
-    }
-
-    (*rsa)->hKey = hKey;
-    (*rsa)->pbKeyObject = pbStructInfo;
-    (*rsa)->cbKeyObject = cbStructInfo;
-
-    return 0;
-}
-#endif /* HAVE_LIBCRYPT32 */
-
-int
-_libssh2_wincng_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    (void)session;
-
-    ret = _libssh2_wincng_load_private(session, filename,
-                                       (const char *)passphrase,
-                                       &pbEncoded, &cbEncoded, 1, 0);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_rsa_new_private_parse(rsa, session,
-                                                 pbEncoded, cbEncoded);
-#else
-    (void)rsa;
-    (void)filename;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                          "Unable to load RSA key from private key file: "
-                          "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-int
-_libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    (void)session;
-
-    ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
-                                              (const char *)passphrase,
-                                              &pbEncoded, &cbEncoded, 1, 0);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_rsa_new_private_parse(rsa, session,
-                                                 pbEncoded, cbEncoded);
-#else
-    (void)rsa;
-    (void)filedata;
-    (void)filedata_len;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                          "Unable to extract private key from memory: "
-                          "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-int
-_libssh2_wincng_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len)
-{
-    return _libssh2_wincng_key_sha1_verify(rsa, sig, sig_len, m, m_len,
-                                           BCRYPT_PAD_PKCS1);
-}
-
-int
-_libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len)
-{
-    BCRYPT_PKCS1_PADDING_INFO paddingInfo;
-    unsigned char *data, *sig;
-    unsigned long cbData, datalen, siglen;
-    int ret;
-
-    datalen = (unsigned long)hash_len;
-    data = malloc(datalen);
-    if(!data) {
-        return -1;
-    }
-
-    paddingInfo.pszAlgId = BCRYPT_SHA1_ALGORITHM;
-
-    memcpy(data, hash, datalen);
-
-    ret = BCryptSignHash(rsa->hKey, &paddingInfo,
-                         data, datalen, NULL, 0,
-                         &cbData, BCRYPT_PAD_PKCS1);
-    if(BCRYPT_SUCCESS(ret)) {
-        siglen = cbData;
-        sig = LIBSSH2_ALLOC(session, siglen);
-        if(sig) {
-            ret = BCryptSignHash(rsa->hKey, &paddingInfo,
-                                 data, datalen, sig, siglen,
-                                 &cbData, BCRYPT_PAD_PKCS1);
-            if(BCRYPT_SUCCESS(ret)) {
-                *signature_len = siglen;
-                *signature = sig;
-            }
-            else {
-                LIBSSH2_FREE(session, sig);
-            }
-        }
-        else
-            ret = STATUS_NO_MEMORY;
-    }
-
-    _libssh2_wincng_safe_free(data, datalen);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-void
-_libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa)
-{
-    if(!rsa)
-        return;
-
-    BCryptDestroyKey(rsa->hKey);
-    rsa->hKey = NULL;
-
-    _libssh2_wincng_safe_free(rsa->pbKeyObject, rsa->cbKeyObject);
-    _libssh2_wincng_safe_free(rsa, sizeof(libssh2_rsa_ctx));
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: DSA functions
- */
-
-#if LIBSSH2_DSA
-int
-_libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *gdata,
-                        unsigned long glen,
-                        const unsigned char *ydata,
-                        unsigned long ylen,
-                        const unsigned char *xdata,
-                        unsigned long xlen)
-{
-    BCRYPT_KEY_HANDLE hKey;
-    BCRYPT_DSA_KEY_BLOB *dsakey;
-    LPCWSTR lpszBlobType;
-    unsigned char *key;
-    unsigned long keylen, offset, length;
-    int ret;
-
-    length = max(max(_libssh2_wincng_bn_size(pdata, plen),
-                     _libssh2_wincng_bn_size(gdata, glen)),
-                 _libssh2_wincng_bn_size(ydata, ylen));
-    offset = sizeof(BCRYPT_DSA_KEY_BLOB);
-    keylen = offset + length * 3;
-    if(xdata && xlen > 0)
-        keylen += 20;
-
-    key = malloc(keylen);
-    if(!key) {
-        return -1;
-    }
-
-    memset(key, 0, keylen);
-
-
-    /* https://msdn.microsoft.com/library/windows/desktop/aa833126.aspx */
-    dsakey = (BCRYPT_DSA_KEY_BLOB *)key;
-    dsakey->cbKey = length;
-
-    memset(dsakey->Count, -1, sizeof(dsakey->Count));
-    memset(dsakey->Seed, -1, sizeof(dsakey->Seed));
-
-    if(qlen < 20)
-        memcpy(dsakey->q + 20 - qlen, qdata, qlen);
-    else
-        memcpy(dsakey->q, qdata + qlen - 20, 20);
-
-    if(plen < length)
-        memcpy(key + offset + length - plen, pdata, plen);
-    else
-        memcpy(key + offset, pdata + plen - length, length);
-    offset += length;
-
-    if(glen < length)
-        memcpy(key + offset + length - glen, gdata, glen);
-    else
-        memcpy(key + offset, gdata + glen - length, length);
-    offset += length;
-
-    if(ylen < length)
-        memcpy(key + offset + length - ylen, ydata, ylen);
-    else
-        memcpy(key + offset, ydata + ylen - length, length);
-
-    if(xdata && xlen > 0) {
-        offset += length;
-
-        if(xlen < 20)
-            memcpy(key + offset + 20 - xlen, xdata, xlen);
-        else
-            memcpy(key + offset, xdata + xlen - 20, 20);
-
-        lpszBlobType = BCRYPT_DSA_PRIVATE_BLOB;
-        dsakey->dwMagic = BCRYPT_DSA_PRIVATE_MAGIC;
-    }
-    else {
-        lpszBlobType = BCRYPT_DSA_PUBLIC_BLOB;
-        dsakey->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
-    }
-
-
-    ret = BCryptImportKeyPair(_libssh2_wincng.hAlgDSA, NULL, lpszBlobType,
-                              &hKey, key, keylen, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(key, keylen);
-        return -1;
-    }
-
-
-    *dsa = malloc(sizeof(libssh2_dsa_ctx));
-    if(!(*dsa)) {
-        BCryptDestroyKey(hKey);
-        _libssh2_wincng_safe_free(key, keylen);
-        return -1;
-    }
-
-    (*dsa)->hKey = hKey;
-    (*dsa)->pbKeyObject = key;
-    (*dsa)->cbKeyObject = keylen;
-
-    return 0;
-}
-
-#ifdef HAVE_LIBCRYPT32
-static int
-_libssh2_wincng_dsa_new_private_parse(libssh2_dsa_ctx **dsa,
-                                      LIBSSH2_SESSION *session,
-                                      unsigned char *pbEncoded,
-                                      unsigned long cbEncoded)
-{
-    unsigned char **rpbDecoded;
-    unsigned long *rcbDecoded, index, length;
-    int ret;
-
-    (void)session;
-
-    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, cbEncoded,
-                                         &rpbDecoded, &rcbDecoded, &length);
-
-    _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
-
-    if(ret) {
-        return -1;
-    }
-
-
-    if(length == 6) {
-        ret = _libssh2_wincng_dsa_new(dsa,
-                                      rpbDecoded[1], rcbDecoded[1],
-                                      rpbDecoded[2], rcbDecoded[2],
-                                      rpbDecoded[3], rcbDecoded[3],
-                                      rpbDecoded[4], rcbDecoded[4],
-                                      rpbDecoded[5], rcbDecoded[5]);
-    }
-    else {
-        ret = -1;
-    }
-
-    for(index = 0; index < length; index++) {
-        _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
-        rpbDecoded[index] = NULL;
-        rcbDecoded[index] = 0;
-    }
-
-    free(rpbDecoded);
-    free(rcbDecoded);
-
-    return ret;
-}
-#endif /* HAVE_LIBCRYPT32 */
-
-int
-_libssh2_wincng_dsa_new_private(libssh2_dsa_ctx **dsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    ret = _libssh2_wincng_load_private(session, filename,
-                                       (const char *)passphrase,
-                                       &pbEncoded, &cbEncoded, 0, 1);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_dsa_new_private_parse(dsa, session,
-                                                 pbEncoded, cbEncoded);
-#else
-    (void)dsa;
-    (void)filename;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                          "Unable to load DSA key from private key file: "
-                          "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-int
-_libssh2_wincng_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
-                                              (const char *)passphrase,
-                                              &pbEncoded, &cbEncoded, 0, 1);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_dsa_new_private_parse(dsa, session,
-                                                 pbEncoded, cbEncoded);
-#else
-    (void)dsa;
-    (void)filedata;
-    (void)filedata_len;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                          "Unable to extract private key from memory: "
-                          "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-int
-_libssh2_wincng_dsa_sha1_verify(libssh2_dsa_ctx *dsa,
-                                const unsigned char *sig_fixed,
-                                const unsigned char *m,
-                                unsigned long m_len)
-{
-    return _libssh2_wincng_key_sha1_verify(dsa, sig_fixed, 40, m, m_len, 0);
-}
-
-int
-_libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
-                              const unsigned char *hash,
-                              unsigned long hash_len,
-                              unsigned char *sig_fixed)
-{
-    unsigned char *data, *sig;
-    unsigned long cbData, datalen, siglen;
-    int ret;
-
-    datalen = hash_len;
-    data = malloc(datalen);
-    if(!data) {
-        return -1;
-    }
-
-    memcpy(data, hash, datalen);
-
-    ret = BCryptSignHash(dsa->hKey, NULL, data, datalen,
-                         NULL, 0, &cbData, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        siglen = cbData;
-        if(siglen == 40) {
-            sig = malloc(siglen);
-            if(sig) {
-                ret = BCryptSignHash(dsa->hKey, NULL, data, datalen,
-                                     sig, siglen, &cbData, 0);
-                if(BCRYPT_SUCCESS(ret)) {
-                    memcpy(sig_fixed, sig, siglen);
-                }
-
-                _libssh2_wincng_safe_free(sig, siglen);
-            }
-            else
-                ret = STATUS_NO_MEMORY;
-        }
-        else
-            ret = STATUS_NO_MEMORY;
-    }
-
-    _libssh2_wincng_safe_free(data, datalen);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-void
-_libssh2_wincng_dsa_free(libssh2_dsa_ctx *dsa)
-{
-    if(!dsa)
-        return;
-
-    BCryptDestroyKey(dsa->hKey);
-    dsa->hKey = NULL;
-
-    _libssh2_wincng_safe_free(dsa->pbKeyObject, dsa->cbKeyObject);
-    _libssh2_wincng_safe_free(dsa, sizeof(libssh2_dsa_ctx));
-}
-#endif
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Key functions
- */
-
-#ifdef HAVE_LIBCRYPT32
-static unsigned long
-_libssh2_wincng_pub_priv_write(unsigned char *key,
-                               unsigned long offset,
-                               const unsigned char *bignum,
-                               const unsigned long length)
-{
-    _libssh2_htonu32(key + offset, length);
-    offset += 4;
-
-    memcpy(key + offset, bignum, length);
-    offset += length;
-
-    return offset;
-}
-
-static int
-_libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       unsigned char *pbEncoded,
-                                       unsigned long cbEncoded)
-{
-    unsigned char **rpbDecoded;
-    unsigned long *rcbDecoded;
-    unsigned char *key = NULL, *mth = NULL;
-    unsigned long keylen = 0, mthlen = 0;
-    unsigned long index, offset, length;
-    int ret;
-
-    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, cbEncoded,
-                                         &rpbDecoded, &rcbDecoded, &length);
-
-    _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
-
-    if(ret) {
-        return -1;
-    }
-
-
-    if(length == 9) { /* private RSA key */
-        mthlen = 7;
-        mth = LIBSSH2_ALLOC(session, mthlen);
-        if(mth) {
-            memcpy(mth, "ssh-rsa", mthlen);
-        }
-        else {
-            ret = -1;
-        }
-
-
-        keylen = 4 + mthlen + 4 + rcbDecoded[2] + 4 + rcbDecoded[1];
-        key = LIBSSH2_ALLOC(session, keylen);
-        if(key) {
-            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
-
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[2],
-                                                    rcbDecoded[2]);
-
-            _libssh2_wincng_pub_priv_write(key, offset,
-                                           rpbDecoded[1],
-                                           rcbDecoded[1]);
-        }
-        else {
-            ret = -1;
-        }
-
-    }
-    else if(length == 6) { /* private DSA key */
-        mthlen = 7;
-        mth = LIBSSH2_ALLOC(session, mthlen);
-        if(mth) {
-            memcpy(mth, "ssh-dss", mthlen);
-        }
-        else {
-            ret = -1;
-        }
-
-        keylen = 4 + mthlen + 4 + rcbDecoded[1] + 4 + rcbDecoded[2]
-                            + 4 + rcbDecoded[3] + 4 + rcbDecoded[4];
-        key = LIBSSH2_ALLOC(session, keylen);
-        if(key) {
-            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
-
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[1],
-                                                    rcbDecoded[1]);
-
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[2],
-                                                    rcbDecoded[2]);
-
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[3],
-                                                    rcbDecoded[3]);
-
-            _libssh2_wincng_pub_priv_write(key, offset,
-                                           rpbDecoded[4],
-                                           rcbDecoded[4]);
-        }
-        else {
-            ret = -1;
-        }
-
-    }
-    else {
-        ret = -1;
-    }
-
-
-    for(index = 0; index < length; index++) {
-        _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
-        rpbDecoded[index] = NULL;
-        rcbDecoded[index] = 0;
-    }
-
-    free(rpbDecoded);
-    free(rcbDecoded);
-
-
-    if(ret) {
-        if(mth)
-            LIBSSH2_FREE(session, mth);
-        if(key)
-            LIBSSH2_FREE(session, key);
-    }
-    else {
-        *method = mth;
-        *method_len = mthlen;
-        *pubkeydata = key;
-        *pubkeydata_len = keylen;
-    }
-
-    return ret;
-}
-#endif /* HAVE_LIBCRYPT32 */
-
-int
-_libssh2_wincng_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    ret = _libssh2_wincng_load_private(session, privatekey, passphrase,
-                                       &pbEncoded, &cbEncoded, 1, 1);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_pub_priv_keyfile_parse(session, method, method_len,
-                                                  pubkeydata, pubkeydata_len,
-                                                  pbEncoded, cbEncoded);
-#else
-    (void)method;
-    (void)method_len;
-    (void)pubkeydata;
-    (void)pubkeydata_len;
-    (void)privatekey;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                          "Unable to load public key from private key file: "
-                          "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-int
-_libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase)
-{
-#ifdef HAVE_LIBCRYPT32
-    unsigned char *pbEncoded;
-    unsigned long cbEncoded;
-    int ret;
-
-    ret = _libssh2_wincng_load_private_memory(session, privatekeydata,
-                                              privatekeydata_len, passphrase,
-                                              &pbEncoded, &cbEncoded, 1, 1);
-    if(ret) {
-        return -1;
-    }
-
-    return _libssh2_wincng_pub_priv_keyfile_parse(session, method, method_len,
-                                                  pubkeydata, pubkeydata_len,
-                                                  pbEncoded, cbEncoded);
-#else
-    (void)method;
-    (void)method_len;
-    (void)pubkeydata_len;
-    (void)pubkeydata;
-    (void)privatekeydata;
-    (void)privatekeydata_len;
-    (void)passphrase;
-
-    return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-               "Unable to extract public key from private key in memory: "
-               "Method unsupported in Windows CNG backend");
-#endif /* HAVE_LIBCRYPT32 */
-}
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Cipher functions
- */
-
-int
-_libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
-                            _libssh2_cipher_type(type),
-                            unsigned char *iv,
-                            unsigned char *secret,
-                            int encrypt)
-{
-    BCRYPT_KEY_HANDLE hKey;
-    BCRYPT_KEY_DATA_BLOB_HEADER *header;
-    unsigned char *pbKeyObject, *pbIV, *key, *pbCtr, *pbIVCopy;
-    unsigned long dwKeyObject, dwIV, dwCtrLength, dwBlockLength,
-                  cbData, keylen;
-    int ret;
-
-    (void)encrypt;
-
-    ret = BCryptGetProperty(*type.phAlg, BCRYPT_OBJECT_LENGTH,
-                            (unsigned char *)&dwKeyObject,
-                            sizeof(dwKeyObject),
-                            &cbData, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        return -1;
-    }
-
-    ret = BCryptGetProperty(*type.phAlg, BCRYPT_BLOCK_LENGTH,
-                            (unsigned char *)&dwBlockLength,
-                            sizeof(dwBlockLength),
-                            &cbData, 0);
-    if(!BCRYPT_SUCCESS(ret)) {
-        return -1;
-    }
-
-    pbKeyObject = malloc(dwKeyObject);
-    if(!pbKeyObject) {
-        return -1;
-    }
-
-
-    keylen = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + type.dwKeyLength;
-    key = malloc(keylen);
-    if(!key) {
-        free(pbKeyObject);
-        return -1;
-    }
-
-
-    header = (BCRYPT_KEY_DATA_BLOB_HEADER *)key;
-    header->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
-    header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
-    header->cbKeyData = type.dwKeyLength;
-
-    memcpy(key + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER),
-           secret, type.dwKeyLength);
-
-    ret = BCryptImportKey(*type.phAlg, NULL, BCRYPT_KEY_DATA_BLOB, &hKey,
-                          pbKeyObject, dwKeyObject, key, keylen, 0);
-
-    _libssh2_wincng_safe_free(key, keylen);
-
-    if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(pbKeyObject, dwKeyObject);
-        return -1;
-    }
-
-    pbIV = NULL;
-    pbCtr = NULL;
-    dwIV = 0;
-    dwCtrLength = 0;
-
-    if(type.useIV || type.ctrMode) {
-        pbIVCopy = malloc(dwBlockLength);
-        if(!pbIVCopy) {
-            BCryptDestroyKey(hKey);
-            _libssh2_wincng_safe_free(pbKeyObject, dwKeyObject);
-            return -1;
-        }
-        memcpy(pbIVCopy, iv, dwBlockLength);
-
-        if(type.ctrMode) {
-            pbCtr = pbIVCopy;
-            dwCtrLength = dwBlockLength;
-        }
-        else if(type.useIV) {
-            pbIV = pbIVCopy;
-            dwIV = dwBlockLength;
-        }
-    }
-
-    ctx->hKey = hKey;
-    ctx->pbKeyObject = pbKeyObject;
-    ctx->pbIV = pbIV;
-    ctx->pbCtr = pbCtr;
-    ctx->dwKeyObject = dwKeyObject;
-    ctx->dwIV = dwIV;
-    ctx->dwBlockLength = dwBlockLength;
-    ctx->dwCtrLength = dwCtrLength;
-
-    return 0;
-}
-int
-_libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(type),
-                             int encrypt,
-                             unsigned char *block,
-                             size_t blocklen)
-{
-    unsigned char *pbOutput, *pbInput;
-    unsigned long cbOutput, cbInput;
-    int ret;
-
-    (void)type;
-
-    cbInput = (unsigned long)blocklen;
-
-    if(type.ctrMode) {
-        pbInput = ctx->pbCtr;
-    }
-    else {
-        pbInput = block;
-    }
-
-    if(encrypt || type.ctrMode) {
-        ret = BCryptEncrypt(ctx->hKey, pbInput, cbInput, NULL,
-                            ctx->pbIV, ctx->dwIV, NULL, 0, &cbOutput, 0);
-    }
-    else {
-        ret = BCryptDecrypt(ctx->hKey, pbInput, cbInput, NULL,
-                            ctx->pbIV, ctx->dwIV, NULL, 0, &cbOutput, 0);
-    }
-    if(BCRYPT_SUCCESS(ret)) {
-        pbOutput = malloc(cbOutput);
-        if(pbOutput) {
-            if(encrypt || type.ctrMode) {
-                ret = BCryptEncrypt(ctx->hKey, pbInput, cbInput, NULL,
-                                    ctx->pbIV, ctx->dwIV,
-                                    pbOutput, cbOutput, &cbOutput, 0);
-            }
-            else {
-                ret = BCryptDecrypt(ctx->hKey, pbInput, cbInput, NULL,
-                                    ctx->pbIV, ctx->dwIV,
-                                    pbOutput, cbOutput, &cbOutput, 0);
-            }
-            if(BCRYPT_SUCCESS(ret)) {
-                if(type.ctrMode) {
-                    _libssh2_xor_data(block, block, pbOutput, blocklen);
-                    _libssh2_aes_ctr_increment(ctx->pbCtr, ctx->dwCtrLength);
-                }
-                else {
-                    memcpy(block, pbOutput, cbOutput);
-                }
-            }
-
-            _libssh2_wincng_safe_free(pbOutput, cbOutput);
-        }
-        else
-            ret = STATUS_NO_MEMORY;
-    }
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-void
-_libssh2_wincng_cipher_dtor(_libssh2_cipher_ctx *ctx)
-{
-    BCryptDestroyKey(ctx->hKey);
-    ctx->hKey = NULL;
-
-    _libssh2_wincng_safe_free(ctx->pbKeyObject, ctx->dwKeyObject);
-    ctx->pbKeyObject = NULL;
-    ctx->dwKeyObject = 0;
-
-    _libssh2_wincng_safe_free(ctx->pbIV, ctx->dwBlockLength);
-    ctx->pbIV = NULL;
-    ctx->dwBlockLength = 0;
-
-    _libssh2_wincng_safe_free(ctx->pbCtr, ctx->dwCtrLength);
-    ctx->pbCtr = NULL;
-    ctx->dwCtrLength = 0;
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: BigNumber functions
- */
-
-_libssh2_bn *
-_libssh2_wincng_bignum_init(void)
-{
-    _libssh2_bn *bignum;
-
-    bignum = (_libssh2_bn *)malloc(sizeof(_libssh2_bn));
-    if(bignum) {
-        bignum->bignum = NULL;
-        bignum->length = 0;
-    }
-
-    return bignum;
-}
-
-static int
-_libssh2_wincng_bignum_resize(_libssh2_bn *bn, unsigned long length)
-{
-    unsigned char *bignum;
-
-    if(!bn)
-        return -1;
-
-    if(length == bn->length)
-        return 0;
-
-#ifdef LIBSSH2_CLEAR_MEMORY
-    if(bn->bignum && bn->length > 0 && length < bn->length) {
-        SecureZeroMemory(bn->bignum + length, bn->length - length);
-    }
-#endif
-
-    bignum = realloc(bn->bignum, length);
-    if(!bignum)
-        return -1;
-
-    bn->bignum = bignum;
-    bn->length = length;
-
-    return 0;
-}
-
-static int
-_libssh2_wincng_bignum_rand(_libssh2_bn *rnd, int bits, int top, int bottom)
-{
-    unsigned char *bignum;
-    unsigned long length;
-
-    if(!rnd)
-        return -1;
-
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
-    if(_libssh2_wincng_bignum_resize(rnd, length))
-        return -1;
-
-    bignum = rnd->bignum;
-
-    if(_libssh2_wincng_random(bignum, length))
-        return -1;
-
-    /* calculate significant bits in most significant byte */
-    bits %= 8;
-    if(bits == 0)
-        bits = 8;
-
-    /* fill most significant byte with zero padding */
-    bignum[0] &= ((1 << bits) - 1);
-
-    /* set most significant bits in most significant byte */
-    if(top == 0)
-        bignum[0] |= (1 << (bits - 1));
-    else if(top == 1)
-        bignum[0] |= (3 << (bits - 2));
-
-    /* make odd by setting first bit in least significant byte */
-    if(bottom)
-        bignum[length - 1] |= 1;
-
-    return 0;
-}
-
-static int
-_libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
-                               _libssh2_bn *a,
-                               _libssh2_bn *p,
-                               _libssh2_bn *m)
-{
-    BCRYPT_KEY_HANDLE hKey;
-    BCRYPT_RSAKEY_BLOB *rsakey;
-    unsigned char *key, *bignum;
-    unsigned long keylen, offset, length;
-    int ret;
-
-    if(!r || !a || !p || !m)
-        return -1;
-
-    offset = sizeof(BCRYPT_RSAKEY_BLOB);
-    keylen = offset + p->length + m->length;
-
-    key = malloc(keylen);
-    if(!key)
-        return -1;
-
-
-    /* https://msdn.microsoft.com/library/windows/desktop/aa375531.aspx */
-    rsakey = (BCRYPT_RSAKEY_BLOB *)key;
-    rsakey->Magic = BCRYPT_RSAPUBLIC_MAGIC;
-    rsakey->BitLength = m->length * 8;
-    rsakey->cbPublicExp = p->length;
-    rsakey->cbModulus = m->length;
-    rsakey->cbPrime1 = 0;
-    rsakey->cbPrime2 = 0;
-
-    memcpy(key + offset, p->bignum, p->length);
-    offset += p->length;
-
-    memcpy(key + offset, m->bignum, m->length);
-    offset = 0;
-
-    ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL,
-                              BCRYPT_RSAPUBLIC_BLOB, &hKey, key, keylen, 0);
-    if(BCRYPT_SUCCESS(ret)) {
-        ret = BCryptEncrypt(hKey, a->bignum, a->length, NULL, NULL, 0,
-                            NULL, 0, &length, BCRYPT_PAD_NONE);
-        if(BCRYPT_SUCCESS(ret)) {
-            if(!_libssh2_wincng_bignum_resize(r, length)) {
-                length = max(a->length, length);
-                bignum = malloc(length);
-                if(bignum) {
-                    memcpy_with_be_padding(bignum, length,
-                                           a->bignum, a->length);
-
-                    ret = BCryptEncrypt(hKey, bignum, length, NULL, NULL, 0,
-                                        r->bignum, r->length, &offset,
-                                        BCRYPT_PAD_NONE);
-
-                    _libssh2_wincng_safe_free(bignum, length);
-
-                    if(BCRYPT_SUCCESS(ret)) {
-                        _libssh2_wincng_bignum_resize(r, offset);
-                    }
-                }
-                else
-                    ret = STATUS_NO_MEMORY;
-            }
-            else
-                ret = STATUS_NO_MEMORY;
-        }
-
-        BCryptDestroyKey(hKey);
-    }
-
-    _libssh2_wincng_safe_free(key, keylen);
-
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
-}
-
-int
-_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word)
-{
-    unsigned long offset, number, bits, length;
-
-    if(!bn)
-        return -1;
-
-    bits = 0;
-    number = word;
-    while(number >>= 1)
-        bits++;
-    bits++;
-
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
-    if(_libssh2_wincng_bignum_resize(bn, length))
-        return -1;
-
-    for(offset = 0; offset < length; offset++)
-        bn->bignum[offset] = (word >> (offset * 8)) & 0xff;
-
-    return 0;
-}
-
-unsigned long
-_libssh2_wincng_bignum_bits(const _libssh2_bn *bn)
-{
-    unsigned char number;
-    unsigned long offset, length, bits;
-
-    if(!bn || !bn->bignum || !bn->length)
-        return 0;
-
-    offset = 0;
-    length = bn->length - 1;
-    while(!bn->bignum[offset] && offset < length)
-        offset++;
-
-    bits = (length - offset) * 8;
-    number = bn->bignum[offset];
-    while(number >>= 1)
-        bits++;
-    bits++;
-
-    return bits;
-}
-
-void
-_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
-                                const unsigned char *bin)
-{
-    unsigned char *bignum;
-    unsigned long offset, length, bits;
-
-    if(!bn || !bin || !len)
-        return;
-
-    if(_libssh2_wincng_bignum_resize(bn, len))
-        return;
-
-    memcpy(bn->bignum, bin, len);
-
-    bits = _libssh2_wincng_bignum_bits(bn);
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
-
-    offset = bn->length - length;
-    if(offset > 0) {
-        memmove(bn->bignum, bn->bignum + offset, length);
-
-#ifdef LIBSSH2_CLEAR_MEMORY
-        SecureZeroMemory(bn->bignum + length, offset);
-#endif
-
-        bignum = realloc(bn->bignum, length);
-        if(bignum) {
-            bn->bignum = bignum;
-            bn->length = length;
-        }
-    }
-}
-
-void
-_libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin)
-{
-    if(bin && bn && bn->bignum && bn->length > 0) {
-        memcpy(bin, bn->bignum, bn->length);
-    }
-}
-
-void
-_libssh2_wincng_bignum_free(_libssh2_bn *bn)
-{
-    if(bn) {
-        if(bn->bignum) {
-            _libssh2_wincng_safe_free(bn->bignum, bn->length);
-            bn->bignum = NULL;
-        }
-        bn->length = 0;
-        _libssh2_wincng_safe_free(bn, sizeof(_libssh2_bn));
-    }
-}
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Diffie-Hellman support.
- */
-
-void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx)
-{
-    /* Random from client */
-    dhctx->bn = NULL;
-    dhctx->dh_handle = NULL;
-    dhctx->dh_params = NULL;
-}
-
-void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
-{
-    if(dhctx->dh_handle) {
-        BCryptDestroyKey(dhctx->dh_handle);
-        dhctx->dh_handle = NULL;
-    }
-    if(dhctx->dh_params) {
-        /* Since public dh_params are shared in clear text,
-         * we don't need to securely zero them out here */
-        free(dhctx->dh_params);
-        dhctx->dh_params = NULL;
-    }
-    if(dhctx->bn) {
-        _libssh2_wincng_bignum_free(dhctx->bn);
-        dhctx->bn = NULL;
-    }
-}
-
-/* Generates a Diffie-Hellman key pair using base `g', prime `p' and the given
- * `group_order'. Can use the given big number context `bnctx' if needed.  The
- * private key is stored as opaque in the Diffie-Hellman context `*dhctx' and
- * the public key is returned in `public'.  0 is returned upon success, else
- * -1.  */
-int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                     _libssh2_bn *g, _libssh2_bn *p, int group_order)
-{
-    const int hasAlgDHwithKDF = _libssh2_wincng.hasAlgDHwithKDF;
-    while(_libssh2_wincng.hAlgDH && hasAlgDHwithKDF != -1) {
-        BCRYPT_DH_PARAMETER_HEADER *dh_params = NULL;
-        unsigned long dh_params_len;
-        unsigned char *blob = NULL;
-        int status;
-        /* Note that the DH provider requires that keys be multiples of 64 bits
-         * in length. At the time of writing a practical observed group_order
-         * value is 257, so we need to round down to 8 bytes of length (64/8)
-         * in order for kex to succeed */
-        DWORD key_length_bytes = max(round_down(group_order, 8),
-                                     max(g->length, p->length));
-        BCRYPT_DH_KEY_BLOB *dh_key_blob;
-        LPCWSTR key_type;
-
-        /* Prepare a key pair; pass the in the bit length of the key,
-         * but the key is not ready for consumption until it is finalized. */
-        status = BCryptGenerateKeyPair(_libssh2_wincng.hAlgDH,
-                                       &dhctx->dh_handle,
-                                       key_length_bytes * 8, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            return -1;
-        }
-
-        dh_params_len = sizeof(*dh_params) + 2 * key_length_bytes;
-        blob = malloc(dh_params_len);
-        if(!blob) {
-            return -1;
-        }
-
-        /* Populate DH parameters blob; after the header follows the `p`
-         * value and the `g` value. */
-        dh_params = (BCRYPT_DH_PARAMETER_HEADER*)blob;
-        dh_params->cbLength = dh_params_len;
-        dh_params->dwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
-        dh_params->cbKeyLength = key_length_bytes;
-        memcpy_with_be_padding(blob + sizeof(*dh_params), key_length_bytes,
-                               p->bignum, p->length);
-        memcpy_with_be_padding(blob + sizeof(*dh_params) + key_length_bytes,
-                               key_length_bytes, g->bignum, g->length);
-
-        status = BCryptSetProperty(dhctx->dh_handle, BCRYPT_DH_PARAMETERS,
-                                   blob, dh_params_len, 0);
-        if(hasAlgDHwithKDF == -1) {
-            /* We know that the raw KDF is not supported, so discard this. */
-            free(blob);
-        }
-        else {
-            /* Pass ownership to dhctx; these parameters will be freed when
-             * the context is destroyed. We need to keep the parameters more
-             * easily available so that we have access to the `g` value when
-             * _libssh2_dh_secret is called later. */
-            dhctx->dh_params = dh_params;
-        }
-        dh_params = NULL;
-        blob = NULL;
-
-        if(!BCRYPT_SUCCESS(status)) {
-            return -1;
-        }
-
-        status = BCryptFinalizeKeyPair(dhctx->dh_handle, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            return -1;
-        }
-
-        key_length_bytes = 0;
-        if(hasAlgDHwithKDF == 1) {
-            /* Now we need to extract the public portion of the key so that we
-             * set it in the `public` bignum to satisfy our caller.
-             * First measure up the size of the required buffer. */
-            key_type = BCRYPT_DH_PUBLIC_BLOB;
-        }
-        else {
-            /* We also need to extract the private portion of the key to
-             * set it in the `*dhctx' bignum if the raw KDF is not supported.
-             * First measure up the size of the required buffer. */
-            key_type = BCRYPT_DH_PRIVATE_BLOB;
-        }
-        status = BCryptExportKey(dhctx->dh_handle, NULL, key_type,
-                                 NULL, 0, &key_length_bytes, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            return -1;
-        }
-
-        blob = malloc(key_length_bytes);
-        if(!blob) {
-            return -1;
-        }
-
-        status = BCryptExportKey(dhctx->dh_handle, NULL, key_type,
-                                 blob, key_length_bytes,
-                                 &key_length_bytes, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            if(hasAlgDHwithKDF == 1) {
-                /* We have no private data, because raw KDF is supported */
-                free(blob);
-            }
-            else { /* we may have potentially private data, use secure free */
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
-            }
-            return -1;
-        }
-
-        if(hasAlgDHwithKDF == -1) {
-            /* We know that the raw KDF is not supported, so discard this */
-            BCryptDestroyKey(dhctx->dh_handle);
-            dhctx->dh_handle = NULL;
-        }
-
-        /* BCRYPT_DH_PUBLIC_BLOB corresponds to a BCRYPT_DH_KEY_BLOB header
-         * followed by the Modulus, Generator and Public data. Those components
-         * each have equal size, specified by dh_key_blob->cbKey. */
-        dh_key_blob = (BCRYPT_DH_KEY_BLOB*)blob;
-        if(_libssh2_wincng_bignum_resize(public, dh_key_blob->cbKey)) {
-            if(hasAlgDHwithKDF == 1) {
-                /* We have no private data, because raw KDF is supported */
-                free(blob);
-            }
-            else { /* we may have potentially private data, use secure free */
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
-            }
-            return -1;
-        }
-
-        /* Copy the public key data into the public bignum data buffer */
-        memcpy(public->bignum,
-               blob + sizeof(*dh_key_blob) + 2 * dh_key_blob->cbKey,
-               dh_key_blob->cbKey);
-
-        if(dh_key_blob->dwMagic == BCRYPT_DH_PRIVATE_MAGIC) {
-            /* BCRYPT_DH_PRIVATE_BLOB additionally contains the Private data */
-            dhctx->bn = _libssh2_wincng_bignum_init();
-            if(!dhctx->bn) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
-                return -1;
-            }
-            if(_libssh2_wincng_bignum_resize(dhctx->bn, dh_key_blob->cbKey)) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
-                return -1;
-            }
-
-            /* Copy the private key data into the dhctx bignum data buffer */
-            memcpy(dhctx->bn->bignum,
-                   blob + sizeof(*dh_key_blob) + 3 * dh_key_blob->cbKey,
-                   dh_key_blob->cbKey);
-
-            /* Make sure the private key is an odd number, because only
-             * odd primes can be used with the RSA-based fallback while
-             * DH itself does not seem to care about it being odd or not. */
-            if(!(dhctx->bn->bignum[dhctx->bn->length-1] % 2)) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
-                /* discard everything first, then try again */
-                _libssh2_dh_dtor(dhctx);
-                _libssh2_dh_init(dhctx);
-                continue;
-            }
-        }
-
-        return 0;
-    }
-
-    /* Generate x and e */
-    dhctx->bn = _libssh2_wincng_bignum_init();
-    if(!dhctx->bn)
-        return -1;
-    if(_libssh2_wincng_bignum_rand(dhctx->bn, group_order * 8 - 1, 0, -1))
-        return -1;
-    if(_libssh2_wincng_bignum_mod_exp(public, g, dhctx->bn, p))
-        return -1;
-
-    return 0;
-}
-
-/* Computes the Diffie-Hellman secret from the previously created context
- * `*dhctx', the public key `f' from the other party and the same prime `p'
- * used at context creation. The result is stored in `secret'.  0 is returned
- * upon success, else -1.  */
-int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                   _libssh2_bn *f, _libssh2_bn *p)
-{
-    if(_libssh2_wincng.hAlgDH && _libssh2_wincng.hasAlgDHwithKDF != -1 &&
-       dhctx->dh_handle && dhctx->dh_params && f) {
-        BCRYPT_KEY_HANDLE peer_public = NULL;
-        BCRYPT_SECRET_HANDLE agreement = NULL;
-        ULONG secret_len_bytes = 0;
-        unsigned char *blob;
-        int status;
-        unsigned char *start, *end;
-        BCRYPT_DH_KEY_BLOB *public_blob = NULL;
-        DWORD key_length_bytes = max(f->length, dhctx->dh_params->cbKeyLength);
-        DWORD public_blob_len = sizeof(*public_blob) + 3 * key_length_bytes;
-
-        {
-            /* Populate a BCRYPT_DH_KEY_BLOB; after the header follows the
-             * Modulus, Generator and Public data. Those components must have
-             * equal size in this representation. */
-            unsigned char *dest;
-            unsigned char *src;
-
-            blob = malloc(public_blob_len);
-            if(!blob) {
-                return -1;
-            }
-            public_blob = (BCRYPT_DH_KEY_BLOB*)blob;
-            public_blob->dwMagic = BCRYPT_DH_PUBLIC_MAGIC;
-            public_blob->cbKey = key_length_bytes;
-
-            dest = (unsigned char *)(public_blob + 1);
-            src = (unsigned char *)(dhctx->dh_params + 1);
-
-            /* Modulus (the p-value from the first call) */
-            memcpy_with_be_padding(dest, key_length_bytes, src,
-                                   dhctx->dh_params->cbKeyLength);
-            /* Generator (the g-value from the first call) */
-            memcpy_with_be_padding(dest + key_length_bytes, key_length_bytes,
-                                   src + dhctx->dh_params->cbKeyLength,
-                                   dhctx->dh_params->cbKeyLength);
-            /* Public from the peer */
-            memcpy_with_be_padding(dest + 2*key_length_bytes, key_length_bytes,
-                                   f->bignum, f->length);
-        }
-
-        /* Import the peer public key information */
-        status = BCryptImportKeyPair(_libssh2_wincng.hAlgDH, NULL,
-                                     BCRYPT_DH_PUBLIC_BLOB, &peer_public, blob,
-                                     public_blob_len, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            goto out;
-        }
-
-        /* Set up a handle that we can use to establish the shared secret
-         * between ourselves (our saved dh_handle) and the peer. */
-        status = BCryptSecretAgreement(dhctx->dh_handle, peer_public,
-                                       &agreement, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            goto out;
-        }
-
-        /* Compute the size of the buffer that is needed to hold the derived
-         * shared secret. */
-        status = BCryptDeriveKey(agreement, BCRYPT_KDF_RAW_SECRET, NULL, NULL,
-                                 0, &secret_len_bytes, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            if(status == STATUS_NOT_SUPPORTED) {
-                _libssh2_wincng.hasAlgDHwithKDF = -1;
-            }
-            goto out;
-        }
-
-        /* Expand the secret bignum to be ready to receive the derived secret
-         * */
-        if(_libssh2_wincng_bignum_resize(secret, secret_len_bytes)) {
-            status = STATUS_NO_MEMORY;
-            goto out;
-        }
-
-        /* And populate the secret bignum */
-        status = BCryptDeriveKey(agreement, BCRYPT_KDF_RAW_SECRET, NULL,
-                                 secret->bignum, secret_len_bytes,
-                                 &secret_len_bytes, 0);
-        if(!BCRYPT_SUCCESS(status)) {
-            if(status == STATUS_NOT_SUPPORTED) {
-                _libssh2_wincng.hasAlgDHwithKDF = -1;
-            }
-            goto out;
-        }
-
-        /* Counter to all the other data in the BCrypt APIs, the raw secret is
-         * returned to us in host byte order, so we need to swap it to big
-         * endian order. */
-        start = secret->bignum;
-        end = secret->bignum + secret->length - 1;
-        while(start < end) {
-            unsigned char tmp = *end;
-            *end = *start;
-            *start = tmp;
-            start++;
-            end--;
-        }
-
-        status = 0;
-        _libssh2_wincng.hasAlgDHwithKDF = 1;
-
-out:
-        if(peer_public) {
-            BCryptDestroyKey(peer_public);
-        }
-        if(agreement) {
-            BCryptDestroySecret(agreement);
-        }
-        if(status == STATUS_NOT_SUPPORTED &&
-           _libssh2_wincng.hasAlgDHwithKDF == -1) {
-            goto fb; /* fallback to RSA-based implementation */
-        }
-        return BCRYPT_SUCCESS(status) ? 0 : -1;
-    }
-
-fb:
-    /* Compute the shared secret */
-    return _libssh2_wincng_bignum_mod_exp(secret, f, dhctx->bn, p);
-}
-
-#endif /* LIBSSH2_WINCNG */
diff --git a/libssh2/libssh2/src/wincng.h b/libssh2/libssh2/src/wincng.h
deleted file mode 100755
index eaf6f905..00000000
--- a/libssh2/libssh2/src/wincng.h
+++ /dev/null
@@ -1,599 +0,0 @@
-#ifndef __LIBSSH2_WINCNG_H
-#define __LIBSSH2_WINCNG_H
-/*
- * Copyright (C) 2013-2020 Marc Hoersken <info@marc-hoersken.de>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* required for cross-compilation against the w64 mingw-runtime package */
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
-#undef _WIN32_WINNT
-#endif
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT 0x0600
-#endif
-
-#include <windows.h>
-#include <bcrypt.h>
-
-#define LIBSSH2_MD5 1
-
-#define LIBSSH2_HMAC_RIPEMD 0
-#define LIBSSH2_HMAC_SHA256 1
-#define LIBSSH2_HMAC_SHA512 1
-
-#define LIBSSH2_AES 1
-#define LIBSSH2_AES_CTR 1
-#define LIBSSH2_BLOWFISH 0
-#define LIBSSH2_RC4 1
-#define LIBSSH2_CAST 0
-#define LIBSSH2_3DES 1
-
-#define LIBSSH2_RSA 1
-#define LIBSSH2_DSA 1
-#define LIBSSH2_ECDSA 0
-#define LIBSSH2_ED25519 0
-
-#define MD5_DIGEST_LENGTH 16
-#define SHA_DIGEST_LENGTH 20
-#define SHA256_DIGEST_LENGTH 32
-#define SHA384_DIGEST_LENGTH 48
-#define SHA512_DIGEST_LENGTH 64
-
-#define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
-
-#if LIBSSH2_ECDSA
-#else
-#define _libssh2_ec_key void
-#endif
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Global context handles
- */
-
-struct _libssh2_wincng_ctx {
-    BCRYPT_ALG_HANDLE hAlgRNG;
-    BCRYPT_ALG_HANDLE hAlgHashMD5;
-    BCRYPT_ALG_HANDLE hAlgHashSHA1;
-    BCRYPT_ALG_HANDLE hAlgHashSHA256;
-    BCRYPT_ALG_HANDLE hAlgHashSHA384;
-    BCRYPT_ALG_HANDLE hAlgHashSHA512;
-    BCRYPT_ALG_HANDLE hAlgHmacMD5;
-    BCRYPT_ALG_HANDLE hAlgHmacSHA1;
-    BCRYPT_ALG_HANDLE hAlgHmacSHA256;
-    BCRYPT_ALG_HANDLE hAlgHmacSHA384;
-    BCRYPT_ALG_HANDLE hAlgHmacSHA512;
-    BCRYPT_ALG_HANDLE hAlgRSA;
-    BCRYPT_ALG_HANDLE hAlgDSA;
-    BCRYPT_ALG_HANDLE hAlgAES_CBC;
-    BCRYPT_ALG_HANDLE hAlgAES_ECB;
-    BCRYPT_ALG_HANDLE hAlgRC4_NA;
-    BCRYPT_ALG_HANDLE hAlg3DES_CBC;
-    BCRYPT_ALG_HANDLE hAlgDH;
-    volatile int hasAlgDHwithKDF; /* -1=no, 0=maybe, 1=yes */
-};
-
-extern struct _libssh2_wincng_ctx _libssh2_wincng;
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Generic functions
- */
-
-void _libssh2_wincng_init(void);
-void _libssh2_wincng_free(void);
-
-#define libssh2_crypto_init() \
-  _libssh2_wincng_init()
-#define libssh2_crypto_exit() \
-  _libssh2_wincng_free()
-
-#define _libssh2_random(buf, len) \
-  _libssh2_wincng_random(buf, len)
-
-#define libssh2_prepare_iovec(vec, len)  /* Empty. */
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Hash structure
- */
-
-typedef struct __libssh2_wincng_hash_ctx {
-    BCRYPT_HASH_HANDLE hHash;
-    unsigned char *pbHashObject;
-    unsigned long dwHashObject;
-    unsigned long cbHash;
-} _libssh2_wincng_hash_ctx;
-
-/*
- * Windows CNG backend: Hash functions
- */
-
-#define libssh2_sha1_ctx _libssh2_wincng_hash_ctx
-#define libssh2_sha1_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA1, \
-                            SHA_DIGEST_LENGTH, NULL, 0) == 0)
-#define libssh2_sha1_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha1_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_sha1(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA1, \
-                       hash, SHA_DIGEST_LENGTH)
-
-#define libssh2_sha256_ctx _libssh2_wincng_hash_ctx
-#define libssh2_sha256_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA256, \
-                            SHA256_DIGEST_LENGTH, NULL, 0) == 0)
-#define libssh2_sha256_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha256_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_sha256(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA256, \
-                       hash, SHA256_DIGEST_LENGTH)
-#define libssh2_sha384_ctx _libssh2_wincng_hash_ctx
-#define libssh2_sha384_init(ctx) \
- (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA384, \
-                           SHA384_DIGEST_LENGTH, NULL, 0) == 0)
-#define libssh2_sha384_update(ctx, data, datalen) \
- _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha384_final(ctx, hash) \
- _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_sha384(data, datalen, hash) \
-_libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA384, \
-                     hash, SHA384_DIGEST_LENGTH)
-#define libssh2_sha512_ctx _libssh2_wincng_hash_ctx
-#define libssh2_sha512_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA512, \
-                            SHA512_DIGEST_LENGTH, NULL, 0) == 0)
-#define libssh2_sha512_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_sha512_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_sha512(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA512, \
-                       hash, SHA512_DIGEST_LENGTH)
-
-#define libssh2_md5_ctx _libssh2_wincng_hash_ctx
-#define libssh2_md5_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashMD5, \
-                            MD5_DIGEST_LENGTH, NULL, 0) == 0)
-#define libssh2_md5_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_md5_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_md5(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashMD5, \
-                       hash, MD5_DIGEST_LENGTH)
-
-/*
- * Windows CNG backend: HMAC functions
- */
-
-#define libssh2_hmac_ctx _libssh2_wincng_hash_ctx
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA1, \
-                            SHA_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacMD5, \
-                            MD5_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen)
-  /* not implemented */
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA256, \
-                            SHA256_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA512, \
-                            SHA512_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, hash) \
-  _libssh2_wincng_hmac_final(&ctx, hash)
-#define libssh2_hmac_cleanup(ctx) \
-  _libssh2_wincng_hmac_cleanup(ctx)
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Key Context structure
- */
-
-typedef struct __libssh2_wincng_key_ctx {
-    BCRYPT_KEY_HANDLE hKey;
-    unsigned char *pbKeyObject;
-    unsigned long cbKeyObject;
-} _libssh2_wincng_key_ctx;
-
-
-/*
- * Windows CNG backend: RSA functions
- */
-
-#define libssh2_rsa_ctx _libssh2_wincng_key_ctx
-#define _libssh2_rsa_new(rsactx, e, e_len, n, n_len, \
-                         d, d_len, p, p_len, q, q_len, \
-                         e1, e1_len, e2, e2_len, c, c_len) \
-  _libssh2_wincng_rsa_new(rsactx, e, e_len, n, n_len, \
-                          d, d_len, p, p_len, q, q_len, \
-                          e1, e1_len, e2, e2_len, c, c_len)
-#define _libssh2_rsa_new_private(rsactx, s, filename, passphrase) \
-  _libssh2_wincng_rsa_new_private(rsactx, s, filename, passphrase)
-#define _libssh2_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                            filedata_len, passphrase) \
-  _libssh2_wincng_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                             filedata_len, passphrase)
-#define _libssh2_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len) \
-  _libssh2_wincng_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
-#define _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len) \
-  _libssh2_wincng_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
-#define _libssh2_rsa_free(rsactx) \
-  _libssh2_wincng_rsa_free(rsactx)
-
-/*
- * Windows CNG backend: DSA functions
- */
-
-#define libssh2_dsa_ctx _libssh2_wincng_key_ctx
-#define _libssh2_dsa_new(dsactx, p, p_len, q, q_len, \
-                         g, g_len, y, y_len, x, x_len) \
-  _libssh2_wincng_dsa_new(dsactx, p, p_len, q, q_len, \
-                          g, g_len, y, y_len, x, x_len)
-#define _libssh2_dsa_new_private(dsactx, s, filename, passphrase) \
-  _libssh2_wincng_dsa_new_private(dsactx, s, filename, passphrase)
-#define _libssh2_dsa_new_private_frommemory(dsactx, s, filedata, \
-                                            filedata_len, passphrase) \
-  _libssh2_wincng_dsa_new_private_frommemory(dsactx, s, filedata, \
-                                             filedata_len, passphrase)
-#define _libssh2_dsa_sha1_sign(dsactx, hash, hash_len, sig) \
-  _libssh2_wincng_dsa_sha1_sign(dsactx, hash, hash_len, sig)
-#define _libssh2_dsa_sha1_verify(dsactx, sig, m, m_len) \
-  _libssh2_wincng_dsa_sha1_verify(dsactx, sig, m, m_len)
-#define _libssh2_dsa_free(dsactx) \
-  _libssh2_wincng_dsa_free(dsactx)
-
-/*
- * Windows CNG backend: Key functions
- */
-
-#define _libssh2_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw) \
-  _libssh2_wincng_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
-#define _libssh2_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                     pk, pk_len, pw) \
-  _libssh2_wincng_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                      pk, pk_len, pw)
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: Cipher Context structure
- */
-
-struct _libssh2_wincng_cipher_ctx {
-    BCRYPT_KEY_HANDLE hKey;
-    unsigned char *pbKeyObject;
-    unsigned char *pbIV;
-    unsigned char *pbCtr;
-    unsigned long dwKeyObject;
-    unsigned long dwIV;
-    unsigned long dwBlockLength;
-    unsigned long dwCtrLength;
-};
-
-#define _libssh2_cipher_ctx struct _libssh2_wincng_cipher_ctx
-
-/*
- * Windows CNG backend: Cipher Type structure
- */
-
-struct _libssh2_wincng_cipher_type {
-    BCRYPT_ALG_HANDLE *phAlg;
-    unsigned long dwKeyLength;
-    int useIV;      /* TODO: Convert to bool when a C89 compatible bool type
-                       is defined */
-    int ctrMode;
-};
-
-#define _libssh2_cipher_type(type) struct _libssh2_wincng_cipher_type type
-
-#define _libssh2_cipher_aes256ctr { &_libssh2_wincng.hAlgAES_ECB, 32, 0, 1 }
-#define _libssh2_cipher_aes192ctr { &_libssh2_wincng.hAlgAES_ECB, 24, 0, 1 }
-#define _libssh2_cipher_aes128ctr { &_libssh2_wincng.hAlgAES_ECB, 16, 0, 1 }
-#define _libssh2_cipher_aes256 { &_libssh2_wincng.hAlgAES_CBC, 32, 1, 0 }
-#define _libssh2_cipher_aes192 { &_libssh2_wincng.hAlgAES_CBC, 24, 1, 0 }
-#define _libssh2_cipher_aes128 { &_libssh2_wincng.hAlgAES_CBC, 16, 1, 0 }
-#define _libssh2_cipher_arcfour { &_libssh2_wincng.hAlgRC4_NA, 16, 0, 0 }
-#define _libssh2_cipher_3des { &_libssh2_wincng.hAlg3DES_CBC, 24, 1, 0 }
-
-/*
- * Windows CNG backend: Cipher functions
- */
-
-#define _libssh2_cipher_init(ctx, type, iv, secret, encrypt) \
-  _libssh2_wincng_cipher_init(ctx, type, iv, secret, encrypt)
-#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen) \
-  _libssh2_wincng_cipher_crypt(ctx, type, encrypt, block, blocklen)
-#define _libssh2_cipher_dtor(ctx) \
-  _libssh2_wincng_cipher_dtor(ctx)
-
-/*******************************************************************/
-/*
- * Windows CNG backend: BigNumber Context
- */
-
-#define _libssh2_bn_ctx int /* not used */
-#define _libssh2_bn_ctx_new() 0 /* not used */
-#define _libssh2_bn_ctx_free(bnctx) ((void)0) /* not used */
-
-
-/*******************************************************************/
-/*
- * Windows CNG backend: BigNumber structure
- */
-
-struct _libssh2_wincng_bignum {
-    unsigned char *bignum;
-    unsigned long length;
-};
-
-#define _libssh2_bn struct _libssh2_wincng_bignum
-
-/*
- * Windows CNG backend: BigNumber functions
- */
-
-_libssh2_bn *_libssh2_wincng_bignum_init(void);
-
-#define _libssh2_bn_init() \
-  _libssh2_wincng_bignum_init()
-#define _libssh2_bn_init_from_bin() \
-  _libssh2_bn_init()
-#define _libssh2_bn_set_word(bn, word) \
-  _libssh2_wincng_bignum_set_word(bn, word)
-#define _libssh2_bn_from_bin(bn, len, bin) \
-  _libssh2_wincng_bignum_from_bin(bn, len, bin)
-#define _libssh2_bn_to_bin(bn, bin) \
-  _libssh2_wincng_bignum_to_bin(bn, bin)
-#define _libssh2_bn_bytes(bn) bn->length
-#define _libssh2_bn_bits(bn) \
-  _libssh2_wincng_bignum_bits(bn)
-#define _libssh2_bn_free(bn) \
-  _libssh2_wincng_bignum_free(bn)
-
-/*
- * Windows CNG backend: Diffie-Hellman support
- */
-
-typedef struct {
-    /* holds our private and public key components */
-    BCRYPT_KEY_HANDLE dh_handle;
-    /* records the parsed out modulus and generator
-     * parameters that are shared  with the peer */
-    BCRYPT_DH_PARAMETER_HEADER *dh_params;
-    /* records the parsed out private key component for
-     * fallback if the DH API raw KDF is not supported */
-    struct _libssh2_wincng_bignum *bn;
-} _libssh2_dh_ctx;
-
-#define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
-#define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
-#define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
-#define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
-
-/*******************************************************************/
-/*
- * Windows CNG backend: forward declarations
- */
-void _libssh2_wincng_init(void);
-void _libssh2_wincng_free(void);
-int _libssh2_wincng_random(void *buf, int len);
-
-int
-_libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
-                          BCRYPT_ALG_HANDLE hAlg, unsigned long hashlen,
-                          unsigned char *key, unsigned long keylen);
-int
-_libssh2_wincng_hash_update(_libssh2_wincng_hash_ctx *ctx,
-                            const unsigned char *data, unsigned long datalen);
-int
-_libssh2_wincng_hash_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash);
-int
-_libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
-                     BCRYPT_ALG_HANDLE hAlg,
-                     unsigned char *hash, unsigned long hashlen);
-
-int
-_libssh2_wincng_hmac_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash);
-void
-_libssh2_wincng_hmac_cleanup(_libssh2_wincng_hash_ctx *ctx);
-
-int
-_libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len,
-                                unsigned long flags);
-
-int
-_libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen);
-int
-_libssh2_wincng_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-int
-_libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_wincng_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len);
-void
-_libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa);
-
-#if LIBSSH2_DSA
-int
-_libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *gdata,
-                        unsigned long glen,
-                        const unsigned char *ydata,
-                        unsigned long ylen,
-                        const unsigned char *xdata,
-                        unsigned long xlen);
-int
-_libssh2_wincng_dsa_new_private(libssh2_dsa_ctx **dsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-int
-_libssh2_wincng_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_wincng_dsa_sha1_verify(libssh2_dsa_ctx *dsa,
-                                const unsigned char *sig_fixed,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
-                              const unsigned char *hash,
-                              unsigned long hash_len,
-                              unsigned char *sig_fixed);
-void
-_libssh2_wincng_dsa_free(libssh2_dsa_ctx *dsa);
-#endif
-
-int
-_libssh2_wincng_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase);
-int
-_libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase);
-
-int
-_libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
-                            _libssh2_cipher_type(type),
-                            unsigned char *iv,
-                            unsigned char *secret,
-                            int encrypt);
-int
-_libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(type),
-                             int encrypt,
-                             unsigned char *block,
-                             size_t blocklen);
-void
-_libssh2_wincng_cipher_dtor(_libssh2_cipher_ctx *ctx);
-
-_libssh2_bn *
-_libssh2_wincng_bignum_init(void);
-int
-_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word);
-unsigned long
-_libssh2_wincng_bignum_bits(const _libssh2_bn *bn);
-void
-_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
-                                const unsigned char *bin);
-void
-_libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin);
-void
-_libssh2_wincng_bignum_free(_libssh2_bn *bn);
-extern void
-_libssh2_dh_init(_libssh2_dh_ctx *dhctx);
-extern int
-_libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                     _libssh2_bn *g, _libssh2_bn *p, int group_order);
-extern int
-_libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                   _libssh2_bn *f, _libssh2_bn *p);
-extern void
-_libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
-
-#endif /* __LIBSSH2_WINCNG_H */
diff --git a/libssh2/libssh2/test-driver b/libssh2/libssh2/test-driver
deleted file mode 100755
index 9759384a..00000000
--- a/libssh2/libssh2/test-driver
+++ /dev/null
@@ -1,150 +0,0 @@
-#! /bin/sh
-# test-driver - basic testsuite driver script.
-
-scriptversion=2018-03-07.03; # UTC
-
-# Copyright (C) 2011-2020 Free Software Foundation, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# This file is maintained in Automake, please report
-# bugs to <bug-automake@gnu.org> or send patches to
-# <automake-patches@gnu.org>.
-
-# Make unconditional expansion of undefined variables an error.  This
-# helps a lot in preventing typo-related bugs.
-set -u
-
-usage_error ()
-{
-  echo "$0: $*" >&2
-  print_usage >&2
-  exit 2
-}
-
-print_usage ()
-{
-  cat <<END
-Usage:
-  test-driver --test-name NAME --log-file PATH --trs-file PATH
-              [--expect-failure {yes|no}] [--color-tests {yes|no}]
-              [--enable-hard-errors {yes|no}] [--]
-              TEST-SCRIPT [TEST-SCRIPT-ARGUMENTS]
-
-The '--test-name', '--log-file' and '--trs-file' options are mandatory.
-See the GNU Automake documentation for information.
-END
-}
-
-test_name= # Used for reporting.
-log_file=  # Where to save the output of the test script.
-trs_file=  # Where to save the metadata of the test run.
-expect_failure=no
-color_tests=no
-enable_hard_errors=yes
-while test $# -gt 0; do
-  case $1 in
-  --help) print_usage; exit $?;;
-  --version) echo "test-driver $scriptversion"; exit $?;;
-  --test-name) test_name=$2; shift;;
-  --log-file) log_file=$2; shift;;
-  --trs-file) trs_file=$2; shift;;
-  --color-tests) color_tests=$2; shift;;
-  --expect-failure) expect_failure=$2; shift;;
-  --enable-hard-errors) enable_hard_errors=$2; shift;;
-  --) shift; break;;
-  -*) usage_error "invalid option: '$1'";;
-   *) break;;
-  esac
-  shift
-done
-
-missing_opts=
-test x"$test_name" = x && missing_opts="$missing_opts --test-name"
-test x"$log_file"  = x && missing_opts="$missing_opts --log-file"
-test x"$trs_file"  = x && missing_opts="$missing_opts --trs-file"
-if test x"$missing_opts" != x; then
-  usage_error "the following mandatory options are missing:$missing_opts"
-fi
-
-if test $# -eq 0; then
-  usage_error "missing argument"
-fi
-
-if test $color_tests = yes; then
-  # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
-  red='' # Red.
-  grn='' # Green.
-  lgn='' # Light green.
-  blu='' # Blue.
-  mgn='' # Magenta.
-  std=''     # No color.
-else
-  red= grn= lgn= blu= mgn= std=
-fi
-
-do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
-trap "st=129; $do_exit" 1
-trap "st=130; $do_exit" 2
-trap "st=141; $do_exit" 13
-trap "st=143; $do_exit" 15
-
-# Test script is run here.
-"$@" >$log_file 2>&1
-estatus=$?
-
-if test $enable_hard_errors = no && test $estatus -eq 99; then
-  tweaked_estatus=1
-else
-  tweaked_estatus=$estatus
-fi
-
-case $tweaked_estatus:$expect_failure in
-  0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
-  0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
-  77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
-  99:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
-  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
-  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
-esac
-
-# Report the test outcome and exit status in the logs, so that one can
-# know whether the test passed or failed simply by looking at the '.log'
-# file, without the need of also peaking into the corresponding '.trs'
-# file (automake bug#11814).
-echo "$res $test_name (exit status: $estatus)" >>$log_file
-
-# Report outcome to console.
-echo "${col}${res}${std}: $test_name"
-
-# Register the test result, and other relevant metadata.
-echo ":test-result: $res" > $trs_file
-echo ":global-test-result: $res" >> $trs_file
-echo ":recheck: $recheck" >> $trs_file
-echo ":copy-in-global-log: $gcopy" >> $trs_file
-
-# Local Variables:
-# mode: shell-script
-# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
-# End:
diff --git a/libssh2/libssh2/tests/CMakeLists.txt b/libssh2/libssh2/tests/CMakeLists.txt
deleted file mode 100644
index cf4b3f76..00000000
--- a/libssh2/libssh2/tests/CMakeLists.txt
+++ /dev/null
@@ -1,186 +0,0 @@
-# Copyright (c) 2014-2016 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-include(CheckIncludeFiles)
-include(CheckFunctionExists)
-include(CheckSymbolExists)
-include(BundleUtilities)
-include(CopyRuntimeDependencies)
-include(SocketLibraries)
-
-## Platform checks
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(sys/param.h HAVE_SYS_PARAM_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(arpa/inet.h HAVE_ARPA_INET_H)
-check_include_files(windows.h HAVE_WINDOWS_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-check_include_files(netinet/in.h HAVE_NETINET_IN_H)
-configure_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h")
-append_needed_socket_libraries(LIBRARIES)
-
-## Cryptography backend choice
-
-set(CRYPTO_BACKEND
-  ""
-  CACHE
-  STRING
-  "The backend to use for cryptography: OpenSSL, Libgcrypt or WinCNG, mbedTLS
-or empty to try any available")
-
-# If the crypto backend was given, rather than searching for the first
-# we are able to find, the find_package commands must abort configuration
-# and report to the user.
-if(CRYPTO_BACKEND)
-  set(SPECIFIC_CRYPTO_REQUIREMENT REQUIRED)
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "OpenSSL" OR NOT CRYPTO_BACKEND)
-
-  find_package(OpenSSL ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(OPENSSL_FOUND)
-    set(CRYPTO_BACKEND "OpenSSL")
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "Libgcrypt" OR NOT CRYPTO_BACKEND)
-
-  find_package(Libgcrypt ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(LIBGCRYPT_FOUND)
-    set(CRYPTO_BACKEND "Libgcrypt")
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "WinCNG" OR NOT CRYPTO_BACKEND)
-
-  # The check actually compiles the header.  This requires windows.h.
-  check_include_files("windows.h;bcrypt.h" HAVE_BCRYPT_H)
-
-  if(HAVE_BCRYPT_H)
-    set(CRYPTO_BACKEND "WinCNG")
-  endif()
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "mbedTLS" OR NOT CRYPTO_BACKEND)
-
-  find_package(mbedTLS ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(MBEDTLS_FOUND)
-    set(CRYPTO_BACKEND "mbedTLS")
-  endif()
-endif()
-
-set(TESTS
-  hostkey
-  hostkey_hash
-  password_auth_succeeds_with_correct_credentials
-  password_auth_fails_with_wrong_password
-  password_auth_fails_with_wrong_username
-  public_key_auth_fails_with_wrong_key
-  public_key_auth_succeeds_with_correct_rsa_key
-  public_key_auth_succeeds_with_correct_encrypted_rsa_key
-  keyboard_interactive_auth_fails_with_wrong_response
-  keyboard_interactive_auth_succeeds_with_correct_response
-  agent_forward_succeeds
-  )
-
-if(CRYPTO_BACKEND STREQUAL "OpenSSL")
-    list(APPEND TESTS
-      public_key_auth_succeeds_with_correct_rsa_openssh_key
-    )
-    if(OPENSSL_VERSION VERSION_GREATER "1.1.0")
-      list(APPEND TESTS
-        public_key_auth_succeeds_with_correct_ed25519_key
-        public_key_auth_succeeds_with_correct_encrypted_ed25519_key
-        public_key_auth_succeeds_with_correct_ed25519_key_from_mem
-        public_key_auth_succeeds_with_correct_ecdsa_key
-        public_key_auth_succeeds_with_correct_signed_ecdsa_key
-       )
-    endif()
-endif()
-
-if(NOT CRYPTO_BACKEND STREQUAL "mbedTLS")
-  list(APPEND TESTS
-    public_key_auth_succeeds_with_correct_dsa_key
-    )
-endif()
-
-add_library(openssh_fixture STATIC openssh_fixture.h openssh_fixture.c)
-target_link_libraries(openssh_fixture ${LIBRARIES})
-target_include_directories(openssh_fixture PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-
-add_library(session_fixture STATIC session_fixture.h session_fixture.c)
-target_link_libraries(session_fixture ${LIBRARIES} openssh_fixture libssh2)
-target_include_directories(session_fixture PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-
-add_library(runner STATIC runner.c)
-target_link_libraries(runner session_fixture)
-target_include_directories(runner PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-
-foreach(test ${TESTS})
-  add_executable(test_${test} test_${test}.c)
-  target_link_libraries(test_${test} libssh2 runner ${LIBRARIES})
-  target_include_directories(test_${test} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-  list(APPEND TEST_TARGETS test_${test})
-  add_definitions(-DFIXTURE_WORKDIR="${CMAKE_CURRENT_SOURCE_DIR}")
-
-  add_test(
-    NAME test_${test} COMMAND $<TARGET_FILE:test_${test}>
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-endforeach()
-
-add_target_to_copy_dependencies(
-  TARGET copy_test_dependencies
-  DEPENDENCIES ${RUNTIME_DEPENDENCIES}
-  BEFORE_TARGETS ${TEST_TARGETS})
-
-
-# TODO convert mansyntax.sh into CMake script.
-# XXX Just because we can find all three programs, doesn't mean sh can
-# find man and grep
-find_program(SH_EXECUTABLE sh)
-find_program(MAN_EXECUTABLE man)
-find_program(GREP_EXECUTABLE grep)
-mark_as_advanced(SH_EXECUTABLE MAN_EXECUTABLE GREP_EXECUTABLE)
-if(SH_EXECUTABLE AND MAN_EXECUTABLE AND GREP_EXECUTABLE)
-  set(cmd "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
-  set(cmd "${cmd} ${CMAKE_CURRENT_SOURCE_DIR}/mansyntax.sh")
-  add_test(mansyntax ${SH_EXECUTABLE} -c "${cmd}")
-endif()
diff --git a/libssh2/libssh2/tests/Makefile.am b/libssh2/libssh2/tests/Makefile.am
deleted file mode 100644
index 27ddc2df..00000000
--- a/libssh2/libssh2/tests/Makefile.am
+++ /dev/null
@@ -1,78 +0,0 @@
-SUBDIRS = ossfuzz
-
-AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/include -I$(top_builddir)/src
-LDADD = ../src/libssh2.la
-
-if SSHD
-noinst_PROGRAMS = ssh2
-ssh2_SOURCES = ssh2.c
-endif
-
-ctests = simple$(EXEEXT)
-TESTS = $(ctests) mansyntax.sh
-if SSHD
-TESTS += ssh2.sh
-endif
-check_PROGRAMS = $(ctests)
-
-TESTS_ENVIRONMENT = SSHD=$(SSHD) EXEEXT=$(EXEEXT)
-TESTS_ENVIRONMENT += srcdir=$(top_srcdir)/tests builddir=$(top_builddir)/tests
-
-EXTRA_DIST =                                                           \
- CMakeLists.txt                                                        \
- etc/host                                                              \
- etc/host.pub                                                          \
- etc/user                                                              \
- etc/user.pub                                                          \
- key_dsa                                                               \
- key_dsa.pub                                                           \
- key_dsa_wrong                                                         \
- key_dsa_wrong.pub                                                     \
- key_ecdsa                                                             \
- key_ecdsa.pub                                                         \
- key_ed25519                                                           \
- key_ed25519.pub                                                       \
- key_ed25519_encrypted                                                 \
- key_ed25519_encrypted.pub                                             \
- key_rsa                                                               \
- key_rsa.pub                                                           \
- key_rsa_encrypted                                                     \
- key_rsa_encrypted.pub                                                 \
- key_rsa_openssh                                                       \
- key_rsa_openssh.pub                                                   \
- libssh2_config_cmake.h.in                                             \
- mansyntax.sh                                                          \
- openssh_fixture.c                                                     \
- openssh_fixture.h                                                     \
- openssh_server/Dockerfile                                             \
- openssh_server/authorized_keys                                        \
- openssh_server/ca_ecdsa                                               \
- openssh_server/ca_ecdsa.pub                                           \
- openssh_server/ssh_host_ecdsa_key                                     \
- openssh_server/ssh_host_ed25519_key                                   \
- openssh_server/ssh_host_rsa_key                                       \
- runner.c                                                              \
- session_fixture.c                                                     \
- session_fixture.h                                                     \
- simple.c                                                              \
- ssh2.c                                                                \
- ssh2.sh                                                               \
- sshd_fixture.sh.in                                                    \
- test_agent_forward_succeeds.c                                         \
- test_hostkey.c                                                        \
- test_hostkey_hash.c                                                   \
- test_keyboard_interactive_auth_fails_with_wrong_response.c            \
- test_keyboard_interactive_auth_succeeds_with_correct_response.c       \
- test_password_auth_fails_with_wrong_password.c                        \
- test_password_auth_fails_with_wrong_username.c                        \
- test_password_auth_succeeds_with_correct_credentials.c                \
- test_public_key_auth_fails_with_wrong_key.c                           \
- test_public_key_auth_succeeds_with_correct_dsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_ed25519_key.c              \
- test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c     \
- test_public_key_auth_succeeds_with_correct_ecdsa_key.c                \
- test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c         \
- test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c    \
- test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c        \
- test_public_key_auth_succeeds_with_correct_rsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
diff --git a/libssh2/libssh2/tests/Makefile.in b/libssh2/libssh2/tests/Makefile.in
deleted file mode 100644
index e5eb881a..00000000
--- a/libssh2/libssh2/tests/Makefile.in
+++ /dev/null
@@ -1,1224 +0,0 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-VPATH = @srcdir@
-am__is_gnu_make = { \
-  if test -z '$(MAKELEVEL)'; then \
-    false; \
-  elif test -n '$(MAKE_HOST)'; then \
-    true; \
-  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
-    true; \
-  else \
-    false; \
-  fi; \
-}
-am__make_running_with_option = \
-  case $${target_option-} in \
-      ?) ;; \
-      *) echo "am__make_running_with_option: internal error: invalid" \
-              "target option '$${target_option-}' specified" >&2; \
-         exit 1;; \
-  esac; \
-  has_opt=no; \
-  sane_makeflags=$$MAKEFLAGS; \
-  if $(am__is_gnu_make); then \
-    sane_makeflags=$$MFLAGS; \
-  else \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        bs=\\; \
-        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
-          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
-    esac; \
-  fi; \
-  skip_next=no; \
-  strip_trailopt () \
-  { \
-    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
-  }; \
-  for flg in $$sane_makeflags; do \
-    test $$skip_next = yes && { skip_next=no; continue; }; \
-    case $$flg in \
-      *=*|--*) continue;; \
-        -*I) strip_trailopt 'I'; skip_next=yes;; \
-      -*I?*) strip_trailopt 'I';; \
-        -*O) strip_trailopt 'O'; skip_next=yes;; \
-      -*O?*) strip_trailopt 'O';; \
-        -*l) strip_trailopt 'l'; skip_next=yes;; \
-      -*l?*) strip_trailopt 'l';; \
-      -[dEDm]) skip_next=yes;; \
-      -[JT]) skip_next=yes;; \
-    esac; \
-    case $$flg in \
-      *$$target_option*) has_opt=yes; break;; \
-    esac; \
-  done; \
-  test $$has_opt = yes
-am__make_dryrun = (target_option=n; $(am__make_running_with_option))
-am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-build_triplet = @build@
-host_triplet = @host@
-@SSHD_TRUE@noinst_PROGRAMS = ssh2$(EXEEXT)
-@SSHD_TRUE@am__append_1 = ssh2.sh
-subdir = tests
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
-CONFIG_CLEAN_FILES =
-CONFIG_CLEAN_VPATH_FILES =
-PROGRAMS = $(noinst_PROGRAMS)
-simple_SOURCES = simple.c
-simple_OBJECTS = simple.$(OBJEXT)
-simple_LDADD = $(LDADD)
-simple_DEPENDENCIES = ../src/libssh2.la
-AM_V_lt = $(am__v_lt_@AM_V@)
-am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
-am__v_lt_0 = --silent
-am__v_lt_1 = 
-am__ssh2_SOURCES_DIST = ssh2.c
-@SSHD_TRUE@am_ssh2_OBJECTS = ssh2.$(OBJEXT)
-ssh2_OBJECTS = $(am_ssh2_OBJECTS)
-ssh2_LDADD = $(LDADD)
-ssh2_DEPENDENCIES = ../src/libssh2.la
-AM_V_P = $(am__v_P_@AM_V@)
-am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
-am__v_P_0 = false
-am__v_P_1 = :
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN     " $@;
-am__v_GEN_1 = 
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-am__v_at_1 = 
-DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src
-depcomp = $(SHELL) $(top_srcdir)/depcomp
-am__maybe_remake_depfiles = depfiles
-am__depfiles_remade = ./$(DEPDIR)/simple.Po ./$(DEPDIR)/ssh2.Po
-am__mv = mv -f
-COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
-LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
-	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
-	$(AM_CFLAGS) $(CFLAGS)
-AM_V_CC = $(am__v_CC_@AM_V@)
-am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
-am__v_CC_0 = @echo "  CC      " $@;
-am__v_CC_1 = 
-CCLD = $(CC)
-LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
-	$(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CCLD = $(am__v_CCLD_@AM_V@)
-am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
-am__v_CCLD_0 = @echo "  CCLD    " $@;
-am__v_CCLD_1 = 
-SOURCES = simple.c $(ssh2_SOURCES)
-DIST_SOURCES = simple.c $(am__ssh2_SOURCES_DIST)
-RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
-	ctags-recursive dvi-recursive html-recursive info-recursive \
-	install-data-recursive install-dvi-recursive \
-	install-exec-recursive install-html-recursive \
-	install-info-recursive install-pdf-recursive \
-	install-ps-recursive install-recursive installcheck-recursive \
-	installdirs-recursive pdf-recursive ps-recursive \
-	tags-recursive uninstall-recursive
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
-  distclean-recursive maintainer-clean-recursive
-am__recursive_targets = \
-  $(RECURSIVE_TARGETS) \
-  $(RECURSIVE_CLEAN_TARGETS) \
-  $(am__extra_recursive_targets)
-AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
-	check recheck distdir distdir-am
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-# Read a list of newline-separated strings from the standard input,
-# and print each of them once, without duplicates.  Input order is
-# *not* preserved.
-am__uniquify_input = $(AWK) '\
-  BEGIN { nonempty = 0; } \
-  { items[$$0] = 1; nonempty = 1; } \
-  END { if (nonempty) { for (i in items) print i; }; } \
-'
-# Make sure the list of sources is unique.  This is necessary because,
-# e.g., the same source file might be shared among _SOURCES variables
-# for different programs/libraries.
-am__define_uniq_tagged_files = \
-  list='$(am__tagged_files)'; \
-  unique=`for i in $$list; do \
-    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-  done | $(am__uniquify_input)`
-am__tty_colors_dummy = \
-  mgn= red= grn= lgn= blu= brg= std=; \
-  am__color_tests=no
-am__tty_colors = { \
-  $(am__tty_colors_dummy); \
-  if test "X$(AM_COLOR_TESTS)" = Xno; then \
-    am__color_tests=no; \
-  elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
-    am__color_tests=yes; \
-  elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
-    am__color_tests=yes; \
-  fi; \
-  if test $$am__color_tests = yes; then \
-    red=''; \
-    grn=''; \
-    lgn=''; \
-    blu=''; \
-    mgn=''; \
-    brg=''; \
-    std=''; \
-  fi; \
-}
-am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
-am__vpath_adj = case $$p in \
-    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
-    *) f=$$p;; \
-  esac;
-am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
-am__install_max = 40
-am__nobase_strip_setup = \
-  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
-am__nobase_strip = \
-  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
-am__nobase_list = $(am__nobase_strip_setup); \
-  for p in $$list; do echo "$$p $$p"; done | \
-  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
-  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
-    if (++n[$$2] == $(am__install_max)) \
-      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
-    END { for (dir in files) print dir, files[dir] }'
-am__base_list = \
-  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
-  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
-am__uninstall_files_from_dir = { \
-  test -z "$$files" \
-    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
-    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
-         $(am__cd) "$$dir" && rm -f $$files; }; \
-  }
-am__recheck_rx = ^[ 	]*:recheck:[ 	]*
-am__global_test_result_rx = ^[ 	]*:global-test-result:[ 	]*
-am__copy_in_global_log_rx = ^[ 	]*:copy-in-global-log:[ 	]*
-# A command that, given a newline-separated list of test names on the
-# standard input, print the name of the tests that are to be re-run
-# upon "make recheck".
-am__list_recheck_tests = $(AWK) '{ \
-  recheck = 1; \
-  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
-    { \
-      if (rc < 0) \
-        { \
-          if ((getline line2 < ($$0 ".log")) < 0) \
-	    recheck = 0; \
-          break; \
-        } \
-      else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
-        { \
-          recheck = 0; \
-          break; \
-        } \
-      else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
-        { \
-          break; \
-        } \
-    }; \
-  if (recheck) \
-    print $$0; \
-  close ($$0 ".trs"); \
-  close ($$0 ".log"); \
-}'
-# A command that, given a newline-separated list of test names on the
-# standard input, create the global log from their .trs and .log files.
-am__create_global_log = $(AWK) ' \
-function fatal(msg) \
-{ \
-  print "fatal: making $@: " msg | "cat >&2"; \
-  exit 1; \
-} \
-function rst_section(header) \
-{ \
-  print header; \
-  len = length(header); \
-  for (i = 1; i <= len; i = i + 1) \
-    printf "="; \
-  printf "\n\n"; \
-} \
-{ \
-  copy_in_global_log = 1; \
-  global_test_result = "RUN"; \
-  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
-    { \
-      if (rc < 0) \
-         fatal("failed to read from " $$0 ".trs"); \
-      if (line ~ /$(am__global_test_result_rx)/) \
-        { \
-          sub("$(am__global_test_result_rx)", "", line); \
-          sub("[ 	]*$$", "", line); \
-          global_test_result = line; \
-        } \
-      else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
-        copy_in_global_log = 0; \
-    }; \
-  if (copy_in_global_log) \
-    { \
-      rst_section(global_test_result ": " $$0); \
-      while ((rc = (getline line < ($$0 ".log"))) != 0) \
-      { \
-        if (rc < 0) \
-          fatal("failed to read from " $$0 ".log"); \
-        print line; \
-      }; \
-      printf "\n"; \
-    }; \
-  close ($$0 ".trs"); \
-  close ($$0 ".log"); \
-}'
-# Restructured Text title.
-am__rst_title = { sed 's/.*/   &   /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
-# Solaris 10 'make', and several other traditional 'make' implementations,
-# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
-# by disabling -e (using the XSI extension "set +e") if it's set.
-am__sh_e_setup = case $$- in *e*) set +e;; esac
-# Default flags passed to test drivers.
-am__common_driver_flags = \
-  --color-tests "$$am__color_tests" \
-  --enable-hard-errors "$$am__enable_hard_errors" \
-  --expect-failure "$$am__expect_failure"
-# To be inserted before the command running the test.  Creates the
-# directory for the log if needed.  Stores in $dir the directory
-# containing $f, in $tst the test, in $log the log.  Executes the
-# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
-# passes TESTS_ENVIRONMENT.  Set up options for the wrapper that
-# will run the test scripts (or their associated LOG_COMPILER, if
-# thy have one).
-am__check_pre = \
-$(am__sh_e_setup);					\
-$(am__vpath_adj_setup) $(am__vpath_adj)			\
-$(am__tty_colors);					\
-srcdir=$(srcdir); export srcdir;			\
-case "$@" in						\
-  */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;;	\
-    *) am__odir=.;; 					\
-esac;							\
-test "x$$am__odir" = x"." || test -d "$$am__odir" 	\
-  || $(MKDIR_P) "$$am__odir" || exit $$?;		\
-if test -f "./$$f"; then dir=./;			\
-elif test -f "$$f"; then dir=;				\
-else dir="$(srcdir)/"; fi;				\
-tst=$$dir$$f; log='$@'; 				\
-if test -n '$(DISABLE_HARD_ERRORS)'; then		\
-  am__enable_hard_errors=no; 				\
-else							\
-  am__enable_hard_errors=yes; 				\
-fi; 							\
-case " $(XFAIL_TESTS) " in				\
-  *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
-    am__expect_failure=yes;;				\
-  *)							\
-    am__expect_failure=no;;				\
-esac; 							\
-$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
-# A shell command to get the names of the tests scripts with any registered
-# extension removed (i.e., equivalently, the names of the test logs, with
-# the '.log' extension removed).  The result is saved in the shell variable
-# '$bases'.  This honors runtime overriding of TESTS and TEST_LOGS.  Sadly,
-# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
-# since that might cause problem with VPATH rewrites for suffix-less tests.
-# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
-am__set_TESTS_bases = \
-  bases='$(TEST_LOGS)'; \
-  bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
-  bases=`echo $$bases`
-AM_TESTSUITE_SUMMARY_HEADER = ' for $(PACKAGE_STRING)'
-RECHECK_LOGS = $(TEST_LOGS)
-TEST_SUITE_LOG = test-suite.log
-TEST_EXTENSIONS = @EXEEXT@ .test
-LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
-LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
-am__set_b = \
-  case '$@' in \
-    */*) \
-      case '$*' in \
-        */*) b='$*';; \
-          *) b=`echo '$@' | sed 's/\.log$$//'`; \
-       esac;; \
-    *) \
-      b='$*';; \
-  esac
-am__test_logs1 = $(TESTS:=.log)
-am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
-TEST_LOGS = $(am__test_logs2:.test.log=.log)
-TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
-TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
-	$(TEST_LOG_FLAGS)
-DIST_SUBDIRS = $(SUBDIRS)
-am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp \
-	$(top_srcdir)/test-driver
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-am__relativize = \
-  dir0=`pwd`; \
-  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
-  sed_rest='s,^[^/]*/*,,'; \
-  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
-  sed_butlast='s,/*[^/]*$$,,'; \
-  while test -n "$$dir1"; do \
-    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
-    if test "$$first" != "."; then \
-      if test "$$first" = ".."; then \
-        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
-        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
-      else \
-        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
-        if test "$$first2" = "$$first"; then \
-          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
-        else \
-          dir2="../$$dir2"; \
-        fi; \
-        dir0="$$dir0"/"$$first"; \
-      fi; \
-    fi; \
-    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
-  done; \
-  reldir="$$dir2"
-ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AR = @AR@
-AS = @AS@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CSCOPE = @CSCOPE@
-CTAGS = @CTAGS@
-CXX = @CXX@
-CXXCPP = @CXXCPP@
-CXXDEPMODE = @CXXDEPMODE@
-CXXFLAGS = @CXXFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-DLLTOOL = @DLLTOOL@
-DSYMUTIL = @DSYMUTIL@
-DUMPBIN = @DUMPBIN@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EGREP = @EGREP@
-ETAGS = @ETAGS@
-EXEEXT = @EXEEXT@
-FGREP = @FGREP@
-GREP = @GREP@
-HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
-HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
-HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
-HAVE_LIBSSL = @HAVE_LIBSSL@
-HAVE_LIBZ = @HAVE_LIBZ@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBBCRYPT = @LIBBCRYPT@
-LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
-LIBGCRYPT = @LIBGCRYPT@
-LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
-LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
-LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
-LIBSSL = @LIBSSL@
-LIBSSL_PREFIX = @LIBSSL_PREFIX@
-LIBTOOL = @LIBTOOL@
-LIBZ = @LIBZ@
-LIBZ_PREFIX = @LIBZ_PREFIX@
-LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
-LIPO = @LIPO@
-LN_S = @LN_S@
-LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
-LTLIBGCRYPT = @LTLIBGCRYPT@
-LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
-LTLIBOBJS = @LTLIBOBJS@
-LTLIBSSL = @LTLIBSSL@
-LTLIBZ = @LTLIBZ@
-LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MANIFEST_TOOL = @MANIFEST_TOOL@
-MKDIR_P = @MKDIR_P@
-NM = @NM@
-NMEDIT = @NMEDIT@
-OBJDUMP = @OBJDUMP@
-OBJEXT = @OBJEXT@
-OTOOL = @OTOOL@
-OTOOL64 = @OTOOL64@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-RANLIB = @RANLIB@
-SED = @SED@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-SSHD = @SSHD@
-STRIP = @STRIP@
-VERSION = @VERSION@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_AR = @ac_ct_AR@
-ac_ct_CC = @ac_ct_CC@
-ac_ct_CXX = @ac_ct_CXX@
-ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build = @build@
-build_alias = @build_alias@
-build_cpu = @build_cpu@
-build_os = @build_os@
-build_vendor = @build_vendor@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-docdir = @docdir@
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-host = @host@
-host_alias = @host_alias@
-host_cpu = @host_cpu@
-host_os = @host_os@
-host_vendor = @host_vendor@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-runstatedir = @runstatedir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-SUBDIRS = ossfuzz
-AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/include -I$(top_builddir)/src
-LDADD = ../src/libssh2.la
-@SSHD_TRUE@ssh2_SOURCES = ssh2.c
-ctests = simple$(EXEEXT)
-TESTS = $(ctests) mansyntax.sh $(am__append_1)
-check_PROGRAMS = $(ctests)
-TESTS_ENVIRONMENT = SSHD=$(SSHD) EXEEXT=$(EXEEXT) \
-	srcdir=$(top_srcdir)/tests builddir=$(top_builddir)/tests
-EXTRA_DIST = \
- CMakeLists.txt                                                        \
- etc/host                                                              \
- etc/host.pub                                                          \
- etc/user                                                              \
- etc/user.pub                                                          \
- key_dsa                                                               \
- key_dsa.pub                                                           \
- key_dsa_wrong                                                         \
- key_dsa_wrong.pub                                                     \
- key_ecdsa                                                             \
- key_ecdsa.pub                                                         \
- key_ed25519                                                           \
- key_ed25519.pub                                                       \
- key_ed25519_encrypted                                                 \
- key_ed25519_encrypted.pub                                             \
- key_rsa                                                               \
- key_rsa.pub                                                           \
- key_rsa_encrypted                                                     \
- key_rsa_encrypted.pub                                                 \
- key_rsa_openssh                                                       \
- key_rsa_openssh.pub                                                   \
- libssh2_config_cmake.h.in                                             \
- mansyntax.sh                                                          \
- openssh_fixture.c                                                     \
- openssh_fixture.h                                                     \
- openssh_server/Dockerfile                                             \
- openssh_server/authorized_keys                                        \
- openssh_server/ca_ecdsa                                               \
- openssh_server/ca_ecdsa.pub                                           \
- openssh_server/ssh_host_ecdsa_key                                     \
- openssh_server/ssh_host_ed25519_key                                   \
- openssh_server/ssh_host_rsa_key                                       \
- runner.c                                                              \
- session_fixture.c                                                     \
- session_fixture.h                                                     \
- simple.c                                                              \
- ssh2.c                                                                \
- ssh2.sh                                                               \
- sshd_fixture.sh.in                                                    \
- test_agent_forward_succeeds.c                                         \
- test_hostkey.c                                                        \
- test_hostkey_hash.c                                                   \
- test_keyboard_interactive_auth_fails_with_wrong_response.c            \
- test_keyboard_interactive_auth_succeeds_with_correct_response.c       \
- test_password_auth_fails_with_wrong_password.c                        \
- test_password_auth_fails_with_wrong_username.c                        \
- test_password_auth_succeeds_with_correct_credentials.c                \
- test_public_key_auth_fails_with_wrong_key.c                           \
- test_public_key_auth_succeeds_with_correct_dsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_ed25519_key.c              \
- test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c     \
- test_public_key_auth_succeeds_with_correct_ecdsa_key.c                \
- test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c         \
- test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c    \
- test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c        \
- test_public_key_auth_succeeds_with_correct_rsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
-
-all: all-recursive
-
-.SUFFIXES:
-.SUFFIXES: .c .lo .log .o .obj .test .test$(EXEEXT) .trs
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
-	        && { if test -f $@; then exit 0; else break; fi; }; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign tests/Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign tests/Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
-	esac;
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-
-$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(am__aclocal_m4_deps):
-
-clean-checkPROGRAMS:
-	@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
-
-clean-noinstPROGRAMS:
-	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
-
-simple$(EXEEXT): $(simple_OBJECTS) $(simple_DEPENDENCIES) $(EXTRA_simple_DEPENDENCIES) 
-	@rm -f simple$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(simple_OBJECTS) $(simple_LDADD) $(LIBS)
-
-ssh2$(EXEEXT): $(ssh2_OBJECTS) $(ssh2_DEPENDENCIES) $(EXTRA_ssh2_DEPENDENCIES) 
-	@rm -f ssh2$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_OBJECTS) $(ssh2_LDADD) $(LIBS)
-
-mostlyclean-compile:
-	-rm -f *.$(OBJEXT)
-
-distclean-compile:
-	-rm -f *.tab.c
-
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2.Po@am__quote@ # am--include-marker
-
-$(am__depfiles_remade):
-	@$(MKDIR_P) $(@D)
-	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
-
-am--depfiles: $(am__depfiles_remade)
-
-.c.o:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
-
-.c.obj:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
-
-.c.lo:
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-
-# This directory's subdirectories are mostly independent; you can cd
-# into them and run 'make' without going through this Makefile.
-# To change the values of 'make' variables: instead of editing Makefiles,
-# (1) if the variable is set in 'config.status', edit 'config.status'
-#     (which will cause the Makefiles to be regenerated when you run 'make');
-# (2) otherwise, pass the desired values on the 'make' command line.
-$(am__recursive_targets):
-	@fail=; \
-	if $(am__make_keepgoing); then \
-	  failcom='fail=yes'; \
-	else \
-	  failcom='exit 1'; \
-	fi; \
-	dot_seen=no; \
-	target=`echo $@ | sed s/-recursive//`; \
-	case "$@" in \
-	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
-	  *) list='$(SUBDIRS)' ;; \
-	esac; \
-	for subdir in $$list; do \
-	  echo "Making $$target in $$subdir"; \
-	  if test "$$subdir" = "."; then \
-	    dot_seen=yes; \
-	    local_target="$$target-am"; \
-	  else \
-	    local_target="$$target"; \
-	  fi; \
-	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
-	  || eval $$failcom; \
-	done; \
-	if test "$$dot_seen" = "no"; then \
-	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
-	fi; test -z "$$fail"
-
-ID: $(am__tagged_files)
-	$(am__define_uniq_tagged_files); mkid -fID $$unique
-tags: tags-recursive
-TAGS: tags
-
-tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	set x; \
-	here=`pwd`; \
-	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
-	  include_option=--etags-include; \
-	  empty_fix=.; \
-	else \
-	  include_option=--include; \
-	  empty_fix=; \
-	fi; \
-	list='$(SUBDIRS)'; for subdir in $$list; do \
-	  if test "$$subdir" = .; then :; else \
-	    test ! -f $$subdir/TAGS || \
-	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
-	  fi; \
-	done; \
-	$(am__define_uniq_tagged_files); \
-	shift; \
-	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
-	  test -n "$$unique" || unique=$$empty_fix; \
-	  if test $$# -gt 0; then \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      "$$@" $$unique; \
-	  else \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      $$unique; \
-	  fi; \
-	fi
-ctags: ctags-recursive
-
-CTAGS: ctags
-ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	$(am__define_uniq_tagged_files); \
-	test -z "$(CTAGS_ARGS)$$unique" \
-	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
-	     $$unique
-
-GTAGS:
-	here=`$(am__cd) $(top_builddir) && pwd` \
-	  && $(am__cd) $(top_srcdir) \
-	  && gtags -i $(GTAGS_ARGS) "$$here"
-cscopelist: cscopelist-recursive
-
-cscopelist-am: $(am__tagged_files)
-	list='$(am__tagged_files)'; \
-	case "$(srcdir)" in \
-	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
-	  *) sdir=$(subdir)/$(srcdir) ;; \
-	esac; \
-	for i in $$list; do \
-	  if test -f "$$i"; then \
-	    echo "$(subdir)/$$i"; \
-	  else \
-	    echo "$$sdir/$$i"; \
-	  fi; \
-	done >> $(top_builddir)/cscope.files
-
-distclean-tags:
-	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-
-# Recover from deleted '.trs' file; this should ensure that
-# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
-# both 'foo.log' and 'foo.trs'.  Break the recipe in two subshells
-# to avoid problems with "make -n".
-.log.trs:
-	rm -f $< $@
-	$(MAKE) $(AM_MAKEFLAGS) $<
-
-# Leading 'am--fnord' is there to ensure the list of targets does not
-# expand to empty, as could happen e.g. with make check TESTS=''.
-am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
-am--force-recheck:
-	@:
-
-$(TEST_SUITE_LOG): $(TEST_LOGS)
-	@$(am__set_TESTS_bases); \
-	am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
-	redo_bases=`for i in $$bases; do \
-	              am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
-	            done`; \
-	if test -n "$$redo_bases"; then \
-	  redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
-	  redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
-	  if $(am__make_dryrun); then :; else \
-	    rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
-	  fi; \
-	fi; \
-	if test -n "$$am__remaking_logs"; then \
-	  echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
-	       "recursion detected" >&2; \
-	elif test -n "$$redo_logs"; then \
-	  am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
-	fi; \
-	if $(am__make_dryrun); then :; else \
-	  st=0;  \
-	  errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
-	  for i in $$redo_bases; do \
-	    test -f $$i.trs && test -r $$i.trs \
-	      || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
-	    test -f $$i.log && test -r $$i.log \
-	      || { echo "$$errmsg $$i.log" >&2; st=1; }; \
-	  done; \
-	  test $$st -eq 0 || exit 1; \
-	fi
-	@$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
-	ws='[ 	]'; \
-	results=`for b in $$bases; do echo $$b.trs; done`; \
-	test -n "$$results" || results=/dev/null; \
-	all=`  grep "^$$ws*:test-result:"           $$results | wc -l`; \
-	pass=` grep "^$$ws*:test-result:$$ws*PASS"  $$results | wc -l`; \
-	fail=` grep "^$$ws*:test-result:$$ws*FAIL"  $$results | wc -l`; \
-	skip=` grep "^$$ws*:test-result:$$ws*SKIP"  $$results | wc -l`; \
-	xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
-	xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
-	error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
-	if test `expr $$fail + $$xpass + $$error` -eq 0; then \
-	  success=true; \
-	else \
-	  success=false; \
-	fi; \
-	br='==================='; br=$$br$$br$$br$$br; \
-	result_count () \
-	{ \
-	    if test x"$$1" = x"--maybe-color"; then \
-	      maybe_colorize=yes; \
-	    elif test x"$$1" = x"--no-color"; then \
-	      maybe_colorize=no; \
-	    else \
-	      echo "$@: invalid 'result_count' usage" >&2; exit 4; \
-	    fi; \
-	    shift; \
-	    desc=$$1 count=$$2; \
-	    if test $$maybe_colorize = yes && test $$count -gt 0; then \
-	      color_start=$$3 color_end=$$std; \
-	    else \
-	      color_start= color_end=; \
-	    fi; \
-	    echo "$${color_start}# $$desc $$count$${color_end}"; \
-	}; \
-	create_testsuite_report () \
-	{ \
-	  result_count $$1 "TOTAL:" $$all   "$$brg"; \
-	  result_count $$1 "PASS: " $$pass  "$$grn"; \
-	  result_count $$1 "SKIP: " $$skip  "$$blu"; \
-	  result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
-	  result_count $$1 "FAIL: " $$fail  "$$red"; \
-	  result_count $$1 "XPASS:" $$xpass "$$red"; \
-	  result_count $$1 "ERROR:" $$error "$$mgn"; \
-	}; \
-	{								\
-	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
-	    $(am__rst_title);						\
-	  create_testsuite_report --no-color;				\
-	  echo;								\
-	  echo ".. contents:: :depth: 2";				\
-	  echo;								\
-	  for b in $$bases; do echo $$b; done				\
-	    | $(am__create_global_log);					\
-	} >$(TEST_SUITE_LOG).tmp || exit 1;				\
-	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
-	if $$success; then						\
-	  col="$$grn";							\
-	 else								\
-	  col="$$red";							\
-	  test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG);		\
-	fi;								\
-	echo "$${col}$$br$${std}"; 					\
-	echo "$${col}Testsuite summary"$(AM_TESTSUITE_SUMMARY_HEADER)"$${std}";	\
-	echo "$${col}$$br$${std}"; 					\
-	create_testsuite_report --maybe-color;				\
-	echo "$$col$$br$$std";						\
-	if $$success; then :; else					\
-	  echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}";		\
-	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
-	    echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}";	\
-	  fi;								\
-	  echo "$$col$$br$$std";					\
-	fi;								\
-	$$success || exit 1
-
-check-TESTS: $(check_PROGRAMS)
-	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
-	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
-	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
-	@set +e; $(am__set_TESTS_bases); \
-	log_list=`for i in $$bases; do echo $$i.log; done`; \
-	trs_list=`for i in $$bases; do echo $$i.trs; done`; \
-	log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
-	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
-	exit $$?;
-recheck: all $(check_PROGRAMS)
-	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
-	@set +e; $(am__set_TESTS_bases); \
-	bases=`for i in $$bases; do echo $$i; done \
-	         | $(am__list_recheck_tests)` || exit 1; \
-	log_list=`for i in $$bases; do echo $$i.log; done`; \
-	log_list=`echo $$log_list`; \
-	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
-	        am__force_recheck=am--force-recheck \
-	        TEST_LOGS="$$log_list"; \
-	exit $$?
-simple.log: simple$(EXEEXT)
-	@p='simple$(EXEEXT)'; \
-	b='simple'; \
-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
-	--log-file $$b.log --trs-file $$b.trs \
-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
-	"$$tst" $(AM_TESTS_FD_REDIRECT)
-mansyntax.sh.log: mansyntax.sh
-	@p='mansyntax.sh'; \
-	b='mansyntax.sh'; \
-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
-	--log-file $$b.log --trs-file $$b.trs \
-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
-	"$$tst" $(AM_TESTS_FD_REDIRECT)
-ssh2.sh.log: ssh2.sh
-	@p='ssh2.sh'; \
-	b='ssh2.sh'; \
-	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
-	--log-file $$b.log --trs-file $$b.trs \
-	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
-	"$$tst" $(AM_TESTS_FD_REDIRECT)
-.test.log:
-	@p='$<'; \
-	$(am__set_b); \
-	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
-	--log-file $$b.log --trs-file $$b.trs \
-	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
-	"$$tst" $(AM_TESTS_FD_REDIRECT)
-@am__EXEEXT_TRUE@.test$(EXEEXT).log:
-@am__EXEEXT_TRUE@	@p='$<'; \
-@am__EXEEXT_TRUE@	$(am__set_b); \
-@am__EXEEXT_TRUE@	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
-@am__EXEEXT_TRUE@	--log-file $$b.log --trs-file $$b.trs \
-@am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
-@am__EXEEXT_TRUE@	"$$tst" $(AM_TESTS_FD_REDIRECT)
-distdir: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
-	  if test "$$subdir" = .; then :; else \
-	    $(am__make_dryrun) \
-	      || test -d "$(distdir)/$$subdir" \
-	      || $(MKDIR_P) "$(distdir)/$$subdir" \
-	      || exit 1; \
-	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
-	    $(am__relativize); \
-	    new_distdir=$$reldir; \
-	    dir1=$$subdir; dir2="$(top_distdir)"; \
-	    $(am__relativize); \
-	    new_top_distdir=$$reldir; \
-	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
-	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
-	    ($(am__cd) $$subdir && \
-	      $(MAKE) $(AM_MAKEFLAGS) \
-	        top_distdir="$$new_top_distdir" \
-	        distdir="$$new_distdir" \
-		am__remove_distdir=: \
-		am__skip_length_check=: \
-		am__skip_mode_fix=: \
-	        distdir) \
-	      || exit 1; \
-	  fi; \
-	done
-check-am: all-am
-	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
-	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
-check: check-recursive
-all-am: Makefile $(PROGRAMS)
-installdirs: installdirs-recursive
-installdirs-am:
-install: install-recursive
-install-exec: install-exec-recursive
-install-data: install-data-recursive
-uninstall: uninstall-recursive
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-recursive
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
-	-test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
-	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-clean: clean-recursive
-
-clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
-	clean-noinstPROGRAMS mostlyclean-am
-
-distclean: distclean-recursive
-		-rm -f ./$(DEPDIR)/simple.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
-	-rm -f Makefile
-distclean-am: clean-am distclean-compile distclean-generic \
-	distclean-tags
-
-dvi: dvi-recursive
-
-dvi-am:
-
-html: html-recursive
-
-html-am:
-
-info: info-recursive
-
-info-am:
-
-install-data-am:
-
-install-dvi: install-dvi-recursive
-
-install-dvi-am:
-
-install-exec-am:
-
-install-html: install-html-recursive
-
-install-html-am:
-
-install-info: install-info-recursive
-
-install-info-am:
-
-install-man:
-
-install-pdf: install-pdf-recursive
-
-install-pdf-am:
-
-install-ps: install-ps-recursive
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-recursive
-		-rm -f ./$(DEPDIR)/simple.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-recursive
-
-mostlyclean-am: mostlyclean-compile mostlyclean-generic \
-	mostlyclean-libtool
-
-pdf: pdf-recursive
-
-pdf-am:
-
-ps: ps-recursive
-
-ps-am:
-
-uninstall-am:
-
-.MAKE: $(am__recursive_targets) check-am install-am install-strip
-
-.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
-	am--depfiles check check-TESTS check-am clean \
-	clean-checkPROGRAMS clean-generic clean-libtool \
-	clean-noinstPROGRAMS cscopelist-am ctags ctags-am distclean \
-	distclean-compile distclean-generic distclean-libtool \
-	distclean-tags distdir dvi dvi-am html html-am info info-am \
-	install install-am install-data install-data-am install-dvi \
-	install-dvi-am install-exec install-exec-am install-html \
-	install-html-am install-info install-info-am install-man \
-	install-pdf install-pdf-am install-ps install-ps-am \
-	install-strip installcheck installcheck-am installdirs \
-	installdirs-am maintainer-clean maintainer-clean-generic \
-	mostlyclean mostlyclean-compile mostlyclean-generic \
-	mostlyclean-libtool pdf pdf-am ps ps-am recheck tags tags-am \
-	uninstall uninstall-am
-
-.PRECIOUS: Makefile
-
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/libssh2/libssh2/tests/etc/host b/libssh2/libssh2/tests/etc/host
deleted file mode 100644
index c4ead711..00000000
--- a/libssh2/libssh2/tests/etc/host
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEogIBAAKCAQEAwJaOo3i1X3N401hMd92lRec0tPMBgaF6ZDanovBiQP+PNo6g
-VNtuF15AspbyxrViqtAyjLWQQlKGWgEFb2ga3ukzJll4dKPtNff3mO++W19ia0WQ
-ZFWTAGcYqet4fvSALIpG+t/3u5MZXMNZPyCU8u1l+QXX14f6dEjzgRw7s3fSy/uv
-Qawkgn8TQFvtSBOfvUTJPTAhhZqxZAt3nGH8d6vqD1hBNvdOpsohy6EgFh8V+kxn
-UdQntrYe9WSz0djt0RRrdAvRkM0hq1UY8C9FTQQWni1n168c7FVrf65+GdJOn7NQ
-Du0Whmh/R3flXR0kIBG+F7e8+e9W9OhlionkPwIBIwKCAQEAqpP6rgvT2DMTPtkt
-yUCoU9tpMo4XRu4b8lxLVc2Y2nvz391pb7sJvO0Uu2/BFmYkMORKB5l/xbbOxL8T
-cU2UJIVn0YJyAOj2rCTFW5KEB8mDDo4SLPtWUNBXrHF5WoDJTAVyEWdJInr5NOeJ
-j68k1yoJ3JAlkwNozWUvclrVytZNohPhiYdKkj2DPlWKL//0INGIo9TU31AGJx2R
-ymy105EFCXWDv1GAIWwqBjNNxzlyxDauuGTwWr2iYDyectBYApCkjyJzMpFn4Yiu
-Mq5XomwkQhefK3y32bRasm+HSrQsGswSvSyS8I5YosjSKMmiWdYj4WxrSciT6gG/
-KHanEwKBgQDucA7E/s9aKs6rECypXPaCORxvbLqdqAiwzJ0edufE+g0aQU/Zm3xj
-m6LGovdEcaBog4rfKCSB9NRKi35m4HV9PO4YBw6/lQ0NeO6jrb8OnZp/P97FbomT
-AXBibzUjQ8fhbPCaJF/2TUEoyhNbzJkpl+M0zu2aQ3MUYVd4dZ4y4wKBgQDOxfeA
-RH3ZPvdYI50jxW+/kKcio+APZZJ9xhtqOKzmEuJOPzlngWk5WQgS8B1aicHyFRhw
-UT2vKeJvqqoeLbIE9Fm6qlpN22594S88+LOiMda4wRswxG9wBZ2J4+rrYKpcb1gt
-JXvVKY7h5qLWGCR0x+ovOcNXABWsF8CAnOnb9QKBgA2gANgOj4F+yfslfuUbQUlF
-F5FWq5P6+S6sm0ORxBniZyYSXFWT2zjkUnHAK2L/LbzUURQQ7CSu5487K8tdSIrQ
-SB6hUUzGsEnppzyNleOT+jMoOJ2RSbCg/xuRU35bpQWRMlHzczKlVC43btILsPsP
-/lrJ/vLfSGeQiKfMNOz3AoGAC9DMUHjxP50ytJRSH00cVBbk+qpHUVZC4p2bKqQn
-IxcFnhI9y2Z7CpdfjA24iNSr/zRny+dinEuJSDWjUi5/M3utWx+tY4jhvgzeIL3B
-HzYMRRJZUz5sxJKbSbVAn7xhgZ/2aPrT4EuEge/sDDvk03kjUyffRszOCdV4tuRl
-IoMCgYEAnrexTd5GuxEEBg3qJgN4IMwoBzZlJ1voaI6I/AMuvQ5kVklYvHTPTZOI
-kSIrvaG8xaOdf0f76XNdT7U/dkx0C0vcesy5++hqakmeRCHjfsE1wN7m+hGo5WcR
-Jq8Ph9ZnH5RKjqDsHh7Y4BCewQNrMBqNQEzDebZCDBUTnK9OgOg=
------END RSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/etc/host.pub b/libssh2/libssh2/tests/etc/host.pub
deleted file mode 100644
index e1ad7f98..00000000
--- a/libssh2/libssh2/tests/etc/host.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwJaOo3i1X3N401hMd92lRec0tPMBgaF6ZDanovBiQP+PNo6gVNtuF15AspbyxrViqtAyjLWQQlKGWgEFb2ga3ukzJll4dKPtNff3mO++W19ia0WQZFWTAGcYqet4fvSALIpG+t/3u5MZXMNZPyCU8u1l+QXX14f6dEjzgRw7s3fSy/uvQawkgn8TQFvtSBOfvUTJPTAhhZqxZAt3nGH8d6vqD1hBNvdOpsohy6EgFh8V+kxnUdQntrYe9WSz0djt0RRrdAvRkM0hq1UY8C9FTQQWni1n168c7FVrf65+GdJOn7NQDu0Whmh/R3flXR0kIBG+F7e8+e9W9OhlionkPw== jas@mocca
diff --git a/libssh2/libssh2/tests/etc/user b/libssh2/libssh2/tests/etc/user
deleted file mode 100644
index 01bf6ac9..00000000
--- a/libssh2/libssh2/tests/etc/user
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEoQIBAAKCAQEAxIgBuZS39D4bFnWminE7svGQLdVKx1aWKnEYEa+XtNU4DKZ/
-pxUHg0zbEBya+IkX1yqQYWALoiOwI8XhdemLp8g03BX7o+DLSWisfiHpCDVGAuNq
-RDF7qnFyL/ZBH6e0XKMtsoB51TDuBc4Rxh6p1V2QL/fg8BoHcCrnKkoqN8PSoKUX
-2lPKJ3JIF/P8cDLbKYCvbSTFOdf56eqg0GJe7jFtSwweE9yz3IWZ3kSS1E/9E6sX
-aNCu/hUt1bvQthICQyBNoTtQP/igEUJ7n0GMetsnq9wiUSomLzWqIWNqmvOv62aC
-XRi5sYgpSAR4Zvnm3Cx/Wl0BEPz2rrFkG+G0SQIBIwKCAQEAgSYtBOyzZfztOqUV
-q277WFWZQrC8HJf8R8aparU3zpq+braOZnuImByP9KUVYX6pRECKw6WD/NWfonq4
-uzMSoXTviVBGRx6xeWIK880kG1Y1UlruD447Ur+ULiV7QLAIzylnLCiKk2lL9S+l
-R63AD95mEOS4Y0ROB+Gt2fY5ABHRMqhGLvRKK8qwn35C1Z9qnTGhgiRbeoc373A5
-ZAYyegyLnbvyV47UfPYS/TVzxZ9RCx3D3I/9fI7ZAFafkkIufQX3QPaVxf0zFUwW
-de/f+gTbySTL4RDF185Evunx+tYvzCyIimB0cTE5dfsCWcHDtO6DwehKiOgJsbeW
-IrpeTwKBgQDnEMfv7ORR35Ouj91iNCSfLU/v0TSzAJBfqYovByhXRsopgWAKXUmH
-mWpBBP5vcGu3NvKfiZcMMbBPfllvlxkafQwvCqrdn5mg01MdAHMWP/O9yfvuxMDE
-KycU2G2CT8j85mIPn19WeIgXC/kws+P0RAVNCBNeq89Gvp4IdLN67wKBgQDZvTYh
-TPCYG32jBK+CcWmOna2SLvBloDcNevhzfu3RGjLIXzUHGxLdx7slsP/tpndmXIAL
-CgV6GfrLxix5bO08203S2qnnwP8VrjjNIv1CyZIbbQFAFIeC3QxZMZHnXieLrO0z
-qF5CuUXcL3cMeGmF/0HN/rB+4sF0qfv8wD8kRwKBgFXTCG8O2HYueK6NNPiXBknA
-X4T17wCocCOIHWHstzZcHzP82oeBvDmuAuTzOe7gnQmJcA9e/ZbQoJKOA/Y/b7lh
-pXCO7wHcMb9kb1PqOWAJIASqG78V4TLrdOp8Re6Sqb0FHRu+2kSwbQ/f4DapN2lb
-F+lpZke8KGq71ExImm99AoGAN/10UbSy5UjlytVRs9QFM00eAQTBeTfTpGFzFmJ3
-qsw48bIU8zLY9zNcAmC21rXG7m+Oo8C/lG0UmsyPF+jPSinDjf22qU7iger4qccr
-Lm5YxTlJduC1IaaOJZBnWMBwkaF+0sTlCdfew5ctPbiQKcVLb3wBf7amxjpWvVYB
-m50CgYAT6t2/Suav21J5zpzyrrt+oMZQ3MMzBnPHFRUQ1FdqZnE4eW5a10g0P+E+
-YeTol+fYxL34+cI5PREK3dcnW1E8g8KOsOQqMgWdTfZEDHYRLqEyGIhu20aqfJCY
-qu9tBburQoSlym9aQp41CMxIyHrL4GnwRlJkTTEVhDuab1HmKw==
------END RSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/etc/user.pub b/libssh2/libssh2/tests/etc/user.pub
deleted file mode 100644
index c60e90d1..00000000
--- a/libssh2/libssh2/tests/etc/user.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAxIgBuZS39D4bFnWminE7svGQLdVKx1aWKnEYEa+XtNU4DKZ/pxUHg0zbEBya+IkX1yqQYWALoiOwI8XhdemLp8g03BX7o+DLSWisfiHpCDVGAuNqRDF7qnFyL/ZBH6e0XKMtsoB51TDuBc4Rxh6p1V2QL/fg8BoHcCrnKkoqN8PSoKUX2lPKJ3JIF/P8cDLbKYCvbSTFOdf56eqg0GJe7jFtSwweE9yz3IWZ3kSS1E/9E6sXaNCu/hUt1bvQthICQyBNoTtQP/igEUJ7n0GMetsnq9wiUSomLzWqIWNqmvOv62aCXRi5sYgpSAR4Zvnm3Cx/Wl0BEPz2rrFkG+G0SQ== jas@mocca
diff --git a/libssh2/libssh2/tests/key_dsa b/libssh2/libssh2/tests/key_dsa
deleted file mode 100644
index c8bc98df..00000000
--- a/libssh2/libssh2/tests/key_dsa
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN DSA PRIVATE KEY-----
-MIIBvAIBAAKBgQCtiYdgpPvFtfi7Ba44DiB+1x8kojjT0nRvn2hU2aa4p4fXI8kd
-6Hc57VQO/lLhR9eFpxjP7m+jGwF468Q6NU8xiC71ucep0OoXS7u8RcoIoWfLDtZi
-DDlahnZTW04mB5fFxo2y7dYl31vE4TPdSxhqpkvnIBIstMFh2M7Dl0w8/QIVAP95
-u6dg1OW6gGsRgiircsy1A9tzAoGBAIzwc5FCnJnzAJm9Hjv0AFV5l/i/DQulZ9pu
-EILkNiHCfDR+lTJ8VxAR7J3pgjmvYzeeRvi519ez1YriktDt66kIknQOcHB8ghyg
-U+dff79SkDcpg8LnX5xb3cVMgABujA0sSpaW1wwm64RXdvmoQvWu6ympUT0l0dEd
-oYVkb4ytAoGAJ+CGwV/1S4j1GVwa6pSP0nj4V86GWXosTTBg7GT+rKWu8lrxIcr6
-FzLWgFi/gHoMrgnKWGxO1yF7vkoYM5Yfo84oBYiH+MgpiBuOrZrgzacHsA66JJbU
-frESRFWZl2blIPr6Gyjj6cVGgMabK3yCiTRi0v7hwffpm0rKyKv7GooCFQCyaA6T
-tkJunHP+F0Xg/WAUV6tcqA==
------END DSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_dsa.pub b/libssh2/libssh2/tests/key_dsa.pub
deleted file mode 100644
index 6a247a51..00000000
--- a/libssh2/libssh2/tests/key_dsa.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-dss AAAAB3NzaC1kc3MAAACBAK2Jh2Ck+8W1+LsFrjgOIH7XHySiONPSdG+faFTZprinh9cjyR3odzntVA7+UuFH14WnGM/ub6MbAXjrxDo1TzGILvW5x6nQ6hdLu7xFygihZ8sO1mIMOVqGdlNbTiYHl8XGjbLt1iXfW8ThM91LGGqmS+cgEiy0wWHYzsOXTDz9AAAAFQD/ebunYNTluoBrEYIoq3LMtQPbcwAAAIEAjPBzkUKcmfMAmb0eO/QAVXmX+L8NC6Vn2m4QguQ2IcJ8NH6VMnxXEBHsnemCOa9jN55G+LnX17PViuKS0O3rqQiSdA5wcHyCHKBT519/v1KQNymDwudfnFvdxUyAAG6MDSxKlpbXDCbrhFd2+ahC9a7rKalRPSXR0R2hhWRvjK0AAACAJ+CGwV/1S4j1GVwa6pSP0nj4V86GWXosTTBg7GT+rKWu8lrxIcr6FzLWgFi/gHoMrgnKWGxO1yF7vkoYM5Yfo84oBYiH+MgpiBuOrZrgzacHsA66JJbUfrESRFWZl2blIPr6Gyjj6cVGgMabK3yCiTRi0v7hwffpm0rKyKv7Goo= awl03@bounty
diff --git a/libssh2/libssh2/tests/key_dsa_wrong b/libssh2/libssh2/tests/key_dsa_wrong
deleted file mode 100644
index 57005022..00000000
--- a/libssh2/libssh2/tests/key_dsa_wrong
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN DSA PRIVATE KEY-----
-MIIBuwIBAAKBgQCE1v/lL1VvjlJMyG7q0wAgl2tqVMzy5h1RVOtDS8bTlXLJg7ks
-T63wTmXlp2HedgKkfHCu7AKsjPyg1CTrvRBa8BFEvMoUDARonMwql34aiKVMy/t0
-/ehnmCQV+ZMFpsVFnphJpZuXLTW1F3pnEbSNud5sACjbWb51uly5AUynuwIVAOhj
-rbNOaAtC1oYki8CVwpkQ8rHhAoGAYSepXRF3GJSjseYgJ2bCgcJS0L9agcvKAf+F
-dc+ZDJOchhnZC/hGHsjAfg62KowwKuOYsbcR3S4LJxiERcmRabww+kUIL1E8bLaQ
-RbOygNsHU8LyBdSx3WqC2WEOpVkTAjYDWTkbN+qkb53IBoI0GwFt5P9GHvQcAGkj
-GJQAWWYCgYAt7vxpDC5Xs6GxbaUupfIP95ZTMx2LqqFjqfT/81nypIHVyIlCnWMi
-a0mWGe4qXmHSyk6ZYnsk7Ll6WxdwUrFhd75qERyXlRK2x/v/Q3h9IOwChpHdSFx/
-Tq1Zl9vMx3tmS1H0YF9tUdN7g8S5XTUSvYA+0Lzxs/9zOU5fa55+pAIVAKV45RLf
-hg2GNXvO68Q4tt3F6kSP
------END DSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_dsa_wrong.pub b/libssh2/libssh2/tests/key_dsa_wrong.pub
deleted file mode 100644
index 107046a6..00000000
--- a/libssh2/libssh2/tests/key_dsa_wrong.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-dss AAAAB3NzaC1kc3MAAACBAITW/+UvVW+OUkzIburTACCXa2pUzPLmHVFU60NLxtOVcsmDuSxPrfBOZeWnYd52AqR8cK7sAqyM/KDUJOu9EFrwEUS8yhQMBGiczCqXfhqIpUzL+3T96GeYJBX5kwWmxUWemEmlm5ctNbUXemcRtI253mwAKNtZvnW6XLkBTKe7AAAAFQDoY62zTmgLQtaGJIvAlcKZEPKx4QAAAIBhJ6ldEXcYlKOx5iAnZsKBwlLQv1qBy8oB/4V1z5kMk5yGGdkL+EYeyMB+DrYqjDAq45ixtxHdLgsnGIRFyZFpvDD6RQgvUTxstpBFs7KA2wdTwvIF1LHdaoLZYQ6lWRMCNgNZORs36qRvncgGgjQbAW3k/0Ye9BwAaSMYlABZZgAAAIAt7vxpDC5Xs6GxbaUupfIP95ZTMx2LqqFjqfT/81nypIHVyIlCnWMia0mWGe4qXmHSyk6ZYnsk7Ll6WxdwUrFhd75qERyXlRK2x/v/Q3h9IOwChpHdSFx/Tq1Zl9vMx3tmS1H0YF9tUdN7g8S5XTUSvYA+0Lzxs/9zOU5fa55+pA== awl03@bounty
diff --git a/libssh2/libssh2/tests/key_ecdsa b/libssh2/libssh2/tests/key_ecdsa
deleted file mode 100644
index 6ed60773..00000000
--- a/libssh2/libssh2/tests/key_ecdsa
+++ /dev/null
@@ -1,10 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAiAAAABNlY2RzYS
-1zaGEyLW5pc3RwMzg0AAAACG5pc3RwMzg0AAAAYQTosiScH/oRSazpIpPSEFcY4YVZyNby
-peARi49N3qy78OE118KGc5T8eifd+n1PSb7z8PnfDwOL4jBHxW5nWx0RCocIt7tb2a349J
-gfEl8PegHGcF/DwC+eesIKJvv0MfkAAADIKLgw6yi4MOsAAAATZWNkc2Etc2hhMi1uaXN0
-cDM4NAAAAAhuaXN0cDM4NAAAAGEE6LIknB/6EUms6SKT0hBXGOGFWcjW8qXgEYuPTd6su/
-DhNdfChnOU/Hon3fp9T0m+8/D53w8Di+IwR8VuZ1sdEQqHCLe7W9mt+PSYHxJfD3oBxnBf
-w8AvnnrCCib79DH5AAAAMGYdHu+u2/L8zC/0S9bao9y6vKiLSuTEfZpCIsyE5jWj/vrS0n
-r1lzv9kKj+5A86aQAAAAA=
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_ecdsa.pub b/libssh2/libssh2/tests/key_ecdsa.pub
deleted file mode 100644
index 597f63fc..00000000
--- a/libssh2/libssh2/tests/key_ecdsa.pub
+++ /dev/null
@@ -1 +0,0 @@
-ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBOiyJJwf+hFJrOkik9IQVxjhhVnI1vKl4BGLj03erLvw4TXXwoZzlPx6J936fU9JvvPw+d8PA4viMEfFbmdbHREKhwi3u1vZrfj0mB8SXw96AcZwX8PAL556wgom+/Qx+Q== 
diff --git a/libssh2/libssh2/tests/key_ed25519 b/libssh2/libssh2/tests/key_ed25519
deleted file mode 100644
index bfb1ad56..00000000
--- a/libssh2/libssh2/tests/key_ed25519
+++ /dev/null
@@ -1,7 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6JgAAAJg8nvUxPJ71
-MQAAAAtzc2gtZWQyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6Jg
-AAAECnhCuTDYdz3kUn48BXkaCXXdbKdH7wSIQ/CUx1cbnR0Ixtdyg2ZRXE70UwyPVUH3Uy
-fDBV8GX5cPF636P6hjomAAAAEHdpbGxAaUN1YmUubG9jYWwBAgMEBQ==
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_ed25519.pub b/libssh2/libssh2/tests/key_ed25519.pub
deleted file mode 100644
index cd592194..00000000
--- a/libssh2/libssh2/tests/key_ed25519.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom
diff --git a/libssh2/libssh2/tests/key_ed25519_encrypted b/libssh2/libssh2/tests/key_ed25519_encrypted
deleted file mode 100644
index 109de444..00000000
--- a/libssh2/libssh2/tests/key_ed25519_encrypted
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAACmFlczI1Ni1jdHIAAAAGYmNyeXB0AAAAGAAAABD4qdu8J/
-EAqXFQERrvzMerAAAAEAAAAAEAAAAzAAAAC3NzaC1lZDI1NTE5AAAAICHxEyUTOVHXvdMF
-ARedFQ+H9DW/n8Zy3daKKRqnTDMqAAAAoO05oxXUkLz8cMQcMeeRSc4UvsaWnCvfN4Qm15
-NaVwSjb/09AcGGVeF1xxwPEIjwsIRftAjjgLuauI6XpXzyeDOlr2HnwzgpZtmeaHzbB7lS
-NjpSENP+fXipXinSfgZqGOItPbbismEVWX4sQn/Zla6/f/JAcDV60TK2ZhVEZ5072t0NcA
-eZQeSzBnpoRhlB7IDO7/7pmu1kNysUzH94Bw8=
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_ed25519_encrypted.pub b/libssh2/libssh2/tests/key_ed25519_encrypted.pub
deleted file mode 100644
index bc331555..00000000
--- a/libssh2/libssh2/tests/key_ed25519_encrypted.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICHxEyUTOVHXvdMFARedFQ+H9DW/n8Zy3daKKRqnTDMq
diff --git a/libssh2/libssh2/tests/key_rsa b/libssh2/libssh2/tests/key_rsa
deleted file mode 100644
index d9643c44..00000000
--- a/libssh2/libssh2/tests/key_rsa
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEoQIBAAKCAQEAnak1T7zHJ+hVRFBDQ9pf1KVzmd5gaNc7y7NPmL13aOG3sYeJ
-evi1x1WM/R3tb8XnUnzZUX9GJN0MYovvZsw9bknG1mDP72LFbGp/gzPddGIKHBBp
-vceDaJ85sM/ME3XOtD7uuXQuNAuEHwEzSMMiSIEMcQS+lXIcMLr5xPLEkyNvqsO5
-RqSjMTLHKHgY8gLWx7oQ1avokhwuDxF7P3Pqtj+rW2Te6vR0i1H6EyFPsBkzkgNX
-b33cus8M1CnTmYTSgJgmHO2LLcGpjQ5sL8T/PWIWHaSqTnkrFXEMysgoteXnAYIL
-jzyBaqq2WV4KA3TluGdAP2p8gC32QtKmIuis3QIBIwKCAQB1Hpyhoi2LXCIVfXPM
-AU6AtWvRY12PtdSl8uqr+nX2JATNBZlUCTaUE6qQJNxEZyDeMNvzZdxV5gkzQ2Fi
-TpQIyRddbH01fJKoTxzlHzbLfAeCj9mFqicahOkHAMN8K6Ddqxe89zhD60w0SgjW
-91tLzZQ2sxE70RxBdPQOpbaZLxmUZSVxRgf5djotyZqB4CcGblKCEZYJ9ZemgCnF
-gEcSsqcn0Jxfu+aEJ4WinN2orWs+okfgsUu9G9Ozwcy9Ptq1LkIzcwwTIpL7TTDd
-LMvhql39a07SysepjFRHxjvXh8Gv+SsLvKQPJHheVv8XoG0dZd+9/Eden9rHKoVm
-vGPLAoGBANGDQtv5K/md/3sRGeJ6Ir3/Ao+WMe8C5onck+hW4y/2yQqm3ZLzyZon
-KdWRj2q4dnxFZyoyDgX0UHLpM4aSsMRjn4C6vcPLcYaZ9CGB5FWPGZrq+q6vuMGK
-V9/fo4ZNFkNK3wo4WCSgxC1Y8XUJc3klOvPVjsmVxZaeZnkukkAFAoGBAMCkqe/S
-hrKITzjZuyGN90a2Nq+3xMNGuc400Qvoi27D1OcSn7SJ/K3tVWbENOH3CAlkmlZT
-46IM2SRRmM0bxF3aThEwnsD5yPqgz+tcweX+gK3nXnP5JZfYF1kArXk80/eYhNE9
-PwnJNXDQMoxaM0/X6BVgQyt03/Q12lH9u0j5AoGAR9U7fp6Su/uoDO/rnhs/HJHy
-P9u5WULSsuyKe4uBF8JTjp+cbOXeuIJ0vkCI8WPQ2iZsg37gPI5Hd9rtGDJLPATm
-OsOuxslowG9MY0J6K/aMb6EFfbiXHckIL3/gS02hO6SkPgSwgZY0odVaGX+VThtk
-q18ppDNZr/vLXL+CmZsCgYEAlJxIlG80tZxaXw5dKIN1nPL2/JUUIZz1vFShQ7Nk
-P4EglP+9B52lqr5mc9kwHAe1vhpobns6kvP393IlawbKrsz6ZQg/8/PkLw5XQIli
-YPeH1pyKsTyKtvcn9DO5BcE1zaGLB9ApULEpOcUuTwPBLvcDfjRREuUhywT44Coi
-w0MCgYAX5yc7/Z3R6M30rGsrgb1Y2siHYsi2LCygUj7TDGQYpaZN4afPJOT5H/Nr
-7x7dgZkbOR6PQFm00VgML0XxKih59t0dcQ+2qk1LX5JDKRF/1kER3np6dpceteDu
-cC+MEHB/KvijnviAtBZGvD0O7oZgvbkKHESu2igXpAnfXPZFvw==
------END RSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_rsa.pub b/libssh2/libssh2/tests/key_rsa.pub
deleted file mode 100644
index 0417e8e6..00000000
--- a/libssh2/libssh2/tests/key_rsa.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAnak1T7zHJ+hVRFBDQ9pf1KVzmd5gaNc7y7NPmL13aOG3sYeJevi1x1WM/R3tb8XnUnzZUX9GJN0MYovvZsw9bknG1mDP72LFbGp/gzPddGIKHBBpvceDaJ85sM/ME3XOtD7uuXQuNAuEHwEzSMMiSIEMcQS+lXIcMLr5xPLEkyNvqsO5RqSjMTLHKHgY8gLWx7oQ1avokhwuDxF7P3Pqtj+rW2Te6vR0i1H6EyFPsBkzkgNXb33cus8M1CnTmYTSgJgmHO2LLcGpjQ5sL8T/PWIWHaSqTnkrFXEMysgoteXnAYILjzyBaqq2WV4KA3TluGdAP2p8gC32QtKmIuis3Q== awl03@bounty
diff --git a/libssh2/libssh2/tests/key_rsa_encrypted b/libssh2/libssh2/tests/key_rsa_encrypted
deleted file mode 100644
index 2f5e0575..00000000
--- a/libssh2/libssh2/tests/key_rsa_encrypted
+++ /dev/null
@@ -1,30 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: AES-128-CBC,E030CC29AE4C20669EE41DF3DE4C0886
-
-gLMMWawVUpqtAtpSVnr7HcH+P0gHKFU00hUhNY18TNJRfFIhPqc9R9xsLHgBac7k
-vHtD2nzUuWLVMIKQoS3+1IF/KO6Xj1zSqnyk49hyKWxFiD3U1YdZAiZNgJ/s6olg
-J/h4mNNsz8Nh6Swp3HwP2jtLHWHV8fOzsaE3dvnVYZ5gPnec7XAYcQycbOV0t2Wd
-NGlP09ooAQRWWuf1TaBewjj7Jm40l8OQat5EKZKzydUZZQYAqfJQ7fIw7jI/lQYF
-KJj9tq0ceFdxvk8LYMr5a+ixnDwirxgg4L0X3fjLocfLVt42qDKkfOGXGg9VI8CO
-gjTu/MbodGCWKe/5eeCSSLrKo486S/5B6RzN0Ax4QBb1iYAN5IECsV91Ekk0socY
-DBZmDMEGHppHJhNhbBzfMYeKssWbOQf9z0y+gDPesImV2gXNoMgTcmZrCLOJWj6L
-ifQAtTKc8P5fV+TLhg3dKmxCt1UMlCHpWWl7tPTsO3WaaXi50f9ypRfpbpH0hket
-SO//bZqF0lF+Ci8uC6ndXBniIfinFoMWPsY01bxyHvmEMwCTVApZEkrZtGlHnavy
-d2oYJ0Oc+eeSjnx2BccQ9GdoI3292CVJVgPiibr42updecFwTry+j//IY8H3d62m
-UYUXJQgIL04o2/1UIT0mPWwPigF3sJSZOwT5arn4MgUyBCC18p6OTmGmvIyrz3YB
-imbhndok/30sMwtJocgXKTdyreMUp0s8Hpw/2z4LQ0qlOstKwa8KnDcFAqaSFNGD
-8tGTobAcGRhqq93PRrn3aRibk1T3KDpMF/oqRaajgBmXFVYOk1yuLy6meB+wAJFD
-VVIokZaygYs13SMX+hau0Gd6PmVh8QF0RmvG69ga7k4dfJMbe2uU59wf9uABmyvd
-+Ju+uXGiF0wYfcyv6HJarPIqA3630TPKR/z8dDWC3rJ83xx7hIpoEAA+b7RA3Vtx
-Gv0EoDK6zeq4UJK0tqxMZJuy+FHBDZhv+gAeB/PmIGPIbF+jV+flmCrUgHg2Ka8I
-Iaap+lQKMj5lzOv/1bbcZ6cpj717MGvo3XOwOD4x5b3wRX6DWphB0+oRWiVU3Vrd
-PiZ0gtlX31Rj+h+QB4DrMKZWMu++qEDF6NPLz2ktNcjOYBT29VVqX8ALKKFO+jOK
-ZASnUXXE3XnwbccwU9VIQ+3mom3K+GjJRGxsWNZsrPy364eQHckomcOptgk5ldI1
-eF7t5w0xQ4hx6jrJBcKJL29SQAcmUO+vu+6Vg6synBpnlqM9mSe8Xlo3SQ9bROJ9
-1unhrml0Jr1tJZfbM/kX7xhFUVc2kQHqYz6pwYl3fYceHk5dVj9IWaJj82Sfi1QQ
-il3DQb9t3y4oJcYQxR9OzyjiKPiCAkIDakYshZP/bb/ZfDy1szIIL0e3mKLUcdFc
-3sqAvcBsPt+SngnTtodkAK1ddTuxjHUN3+XpIAUoNtqv02g47JCmvSQ0NGsPyXIz
-2krWQoMlmYaG3N74ybMajTXW3Y8+wbe5moJ+Yt4bPUo61d8rMOVI/+3lU7YIyUj1
-TqbwgHCvZRvaiXJQbC9lP7mbQipQhtwQgGMw9TdQB/oHldmDNETF4eNX11LC73+G
------END RSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_rsa_encrypted.pub b/libssh2/libssh2/tests/key_rsa_encrypted.pub
deleted file mode 100644
index 5c041d8e..00000000
--- a/libssh2/libssh2/tests/key_rsa_encrypted.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC92YlGoc4PJy6DzX916JJZhxkvmkWBLGJdWOL7R9B6iaYEKebBxzTE3P1RcnxnuI06kklVq/KcDP9sLlgawTZcDg7ifM7HncPOi18OON8vvVVzodikHzuupjhpI5YTT9wwV2fDVi2URsBjvX4AFiZ5WM3/NwqdKpYABzWieBikXGJ58Tsnw+zQw2qMmKKESBuzSN538loTAj5iEH/GAKYDbbH9t2a17qhNCNEw4vrtURT9JqwO1cOg7N1OKpmqCPEbK0wuSTljNC230VJ06X/8UqahWWSH6MreGy6gwpPi6i9wFiFLur301R0dTPiKVhz6bguhcC1EAlhSgjfelFJt awl03@bounty
diff --git a/libssh2/libssh2/tests/key_rsa_openssh b/libssh2/libssh2/tests/key_rsa_openssh
deleted file mode 100644
index 3562a163..00000000
--- a/libssh2/libssh2/tests/key_rsa_openssh
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABFwAAAAdzc2gtcn
-NhAAAAAwEAAQAAAQEA03tZTdi/8nrdDGtSc15EH97dX/qWrgC3nNhbBmcvOykSVtQDsXE0
-4nj45RcD9cn0itZVl0Prn9G+tYJCqqkedhQ5MtuByVrmJX15REDJ9nfzzQzVQw2zuE1ysj
-ccVBxSeqmDDXeJFozh/uq5mKFirFlft5g0Wx2oG1TxGC/MHqfDk6ijqq7lS1T82cmGZAbZ
-+FzhYulBPFioklXStQJtTuVMb5Q/ebd9nmHIesEPWs4DKo2urKXvy+VCYD/N0GRZJ1Qt8D
-2VpI6qJlRapdBaWkHJRDcMmPzmTMa9HE/3+2wi+rOAP9V6W7BpgtMWpOP0xx2zp/tC3SHo
-9pxlfCRaEQAAA8gL9Cg6C/QoOgAAAAdzc2gtcnNhAAABAQDTe1lN2L/yet0Ma1JzXkQf3t
-1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJ
-WuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVP
-EYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9a
-zgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4
-A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoRAAAAAwEAAQAAAQAykM27lVXf7oyoCYk/
-WIzFag5YgpxAop9Ee17YWxep95oQ9MSlSsIwXGh2rlgeDtnP0IvKjUzre8UztR+nmqRT62
-X5yQ5xTLC2yheSwEMKEYhTwPvE+qO8L5h7ED5Pxi3acmmJcMlwgOMQhqM14XCscPo39cae
-+qpVTqwO8m7F7Tu/GCQWKTDE6FekoX13/bYbnsgd7FZGTyc37rQ2kuergYeIRewrdTD3JB
-ne6LmRVbMEuGh9WbXfXFLr+5p79xgnTPs+whdoyQTY8+O3052D8yMV7UcU+T9A0zHFyU9E
-VT/SvTgMTF7icThTtVR6Vn095ahe77wh363N0JEe1rwBAAAAgQCSqhkKVowJSPw+Ho6PNk
-lKcXWCutA8sVg+x+MaIdnzTe9TbxItm/XW4zj1Ax1rJeEgAaCKQVwH5oJDeC3awNZZ5ZY9
-GK6h4ueyolzVP5wwalR9HeY/S+wdRgaIvYmIpHewLAj/o5ykE2Ijzgf3+HdaNlRxwWXz1i
-8ArMV1AwB8WwAAAIEA75OHcAo8RUM7EoU165FZp7nqBphKuGMb8Os/p2xbNC8MYz5CyDXy
-fzYZC3i67uGXyTTVLtl54+kzuciuZ/qLHJT49JY/AtOm+rmpXKACNQIZeEnCML8AewLDEg
-ugXuFCMIFR4/fupCjGv/tTVHvsh6LJ/td3+DQmisVG3uDnGDEAAACBAOH6xeQ5Z/VPFV1b
-+ZxutTMjFghLce50L6fSHpBbIN00vS+9I4TmXYI1XFvaFjHShYUrFifWiMFGBNjuoqRY+c
-9/8UDvptdiXLqqLkw3SNB/UqUQRtZkD384Eazxud+FMfMguFBrgmkWYwAh9EVAzXrbzxQd
-U9To5SerEitsWsfhAAAAEHdpbGxAaUN1YmUubG9jYWwBAg==
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/key_rsa_openssh.pub b/libssh2/libssh2/tests/key_rsa_openssh.pub
deleted file mode 100644
index 9fc4ac27..00000000
--- a/libssh2/libssh2/tests/key_rsa_openssh.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTe1lN2L/yet0Ma1JzXkQf3t1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJWuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVPEYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9azgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoR will@iCube.local
diff --git a/libssh2/libssh2/tests/libssh2_config_cmake.h.in b/libssh2/libssh2/tests/libssh2_config_cmake.h.in
deleted file mode 100644
index 4df27ecd..00000000
--- a/libssh2/libssh2/tests/libssh2_config_cmake.h.in
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#cmakedefine HAVE_UNISTD_H
-#cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_SYS_PARAM_H
-#cmakedefine HAVE_SYS_SOCKET_H
-#cmakedefine HAVE_ARPA_INET_H
-#cmakedefine HAVE_NETINET_IN_H
-#cmakedefine HAVE_WINDOWS_H
-#cmakedefine HAVE_WINSOCK2_H
-#cmakedefine HAVE_SNPRINTF
-
-/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
-   We provide a safe wrapper if snprintf not found */
-#ifndef HAVE_SNPRINTF
-#include <stdio.h>
-#include <stdarg.h>
-/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
-* then assume cp is pointing to a null char and do nothing. Returns number
-* number of chars placed in cp excluding the trailing null char. So for
-* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
-* <= 0 the return value is 0 (and no chars are written to cp). */
-static int snprintf(char *cp, int cp_max_len, const char *fmt, ...)
-{
-    va_list args;
-    int n;
-
-    if (cp_max_len < 2)
-        return 0;
-    va_start(args, fmt);
-    n = vsnprintf(cp, cp_max_len, fmt, args);
-    va_end(args);
-    return (n < cp_max_len) ? n : (cp_max_len - 1);
-}
-
-#define HAVE_SNPRINTF
-#endif
diff --git a/libssh2/libssh2/tests/mansyntax.sh b/libssh2/libssh2/tests/mansyntax.sh
deleted file mode 100755
index dd4aa773..00000000
--- a/libssh2/libssh2/tests/mansyntax.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/sh
-set -e
-
-# Written by Mikhail Gusarov
-#
-# Run syntax checks for all manpages in the documentation tree.
-#
-
-srcdir=${srcdir:-$PWD}
-dstdir=${builddir:-$PWD}
-mandir=${srcdir}/../docs
-
-#
-# Only test if suitable man is available
-#
-if ! man --help | grep -q warnings; then
-  echo "man version not suitable, skipping tests"
-  exit 0
-fi
-
-ec=0
-
-trap "rm -f $dstdir/man3" EXIT
-
-ln -sf "$mandir" "$dstdir/man3"
-
-for manpage in $mandir/libssh2_*.*; do
-  echo "$manpage"
-  warnings=$(LANG=en_US.UTF-8 MANWIDTH=80 man -M "$dstdir" --warnings \
-    -E UTF-8 -l "$manpage" 2>&1 >/dev/null)
-  if [ -n "$warnings" ]; then
-    echo "$warnings"
-    ec=1
-  fi
-done
-
-exit $ec
diff --git a/libssh2/libssh2/tests/openssh_fixture.c b/libssh2/libssh2/tests/openssh_fixture.c
deleted file mode 100644
index 0480c5d5..00000000
--- a/libssh2/libssh2/tests/openssh_fixture.c
+++ /dev/null
@@ -1,401 +0,0 @@
-/* Copyright (C) 2016 Alexander Lamaison
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "openssh_fixture.h"
-#include "libssh2_config.h"
-
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#include <netinet/in.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-
-static int run_command_varg(char **output, const char *command, va_list args)
-{
-    FILE *pipe;
-    char redirect_stderr[] = "%s 2>&1";
-    char command_buf[BUFSIZ];
-    char buf[BUFSIZ];
-    int ret;
-    size_t buf_len;
-
-    if(output) {
-        *output = NULL;
-    }
-
-    /* Format the command string */
-    ret = vsnprintf(command_buf, sizeof(command_buf), command, args);
-    if(ret < 0 || ret >= BUFSIZ) {
-        fprintf(stderr, "Unable to format command (%s)\n", command);
-        return -1;
-    }
-
-    /* Rewrite the command to redirect stderr to stdout to we can output it */
-    if(strlen(command_buf) + strlen(redirect_stderr) >= sizeof(buf)) {
-        fprintf(stderr, "Unable to rewrite command (%s)\n", command);
-        return -1;
-    }
-
-    ret = snprintf(buf, sizeof(buf), redirect_stderr, command_buf);
-    if(ret < 0 || ret >= BUFSIZ) {
-        fprintf(stderr, "Unable to rewrite command (%s)\n", command);
-        return -1;
-    }
-
-    fprintf(stdout, "Command: %s\n", command);
-#ifdef WIN32
-    pipe = _popen(buf, "r");
-#else
-    pipe = popen(buf, "r");
-#endif
-    if(!pipe) {
-        fprintf(stderr, "Unable to execute command '%s'\n", command);
-        return -1;
-    }
-    buf[0] = 0;
-    buf_len = 0;
-    while(buf_len < (sizeof(buf) - 1) &&
-        fgets(&buf[buf_len], sizeof(buf) - buf_len, pipe) != NULL) {
-        buf_len = strlen(buf);
-    }
-
-#ifdef WIN32
-    ret = _pclose(pipe);
-#else
-    ret = pclose(pipe);
-#endif
-    if(ret != 0) {
-        fprintf(stderr, "Error running command '%s' (exit %d): %s\n",
-                command, ret, buf);
-    }
-
-    if(output) {
-        /* command output may contain a trailing newline, so we trim
-         * whitespace here */
-        size_t end = strlen(buf);
-        while(end > 0 && isspace(buf[end - 1])) {
-            buf[end - 1] = '\0';
-        }
-
-        *output = strdup(buf);
-    }
-    return ret;
-}
-
-static int run_command(char **output, const char *command, ...)
-{
-    va_list args;
-    int ret;
-
-    va_start(args, command);
-    ret = run_command_varg(output, command, args);
-    va_end(args);
-
-    return ret;
-}
-
-static int build_openssh_server_docker_image(void)
-{
-    return run_command(NULL, "docker build -t libssh2/openssh_server "
-                             "openssh_server");
-}
-
-static const char *openssh_server_port(void)
-{
-    return getenv("OPENSSH_SERVER_PORT");
-}
-
-static int start_openssh_server(char **container_id_out)
-{
-    const char *container_host_port = openssh_server_port();
-    if(container_host_port != NULL) {
-        return run_command(container_id_out,
-                           "docker run --rm -d -p %s:22 "
-                           "libssh2/openssh_server",
-                           container_host_port);
-    }
-    else {
-        return run_command(container_id_out,
-                           "docker run --rm -d -p 22 "
-                           "libssh2/openssh_server");
-    }
-}
-
-static int stop_openssh_server(char *container_id)
-{
-    return run_command(NULL, "docker stop %s", container_id);
-}
-
-static const char *docker_machine_name(void)
-{
-    return getenv("DOCKER_MACHINE_NAME");
-}
-
-static int is_running_inside_a_container()
-{
-#ifdef WIN32
-    return 0;
-#else
-    const char *cgroup_filename = "/proc/self/cgroup";
-    FILE *f = NULL;
-    char *line = NULL;
-    size_t len = 0;
-    ssize_t read = 0;
-    int found = 0;
-    f = fopen(cgroup_filename, "r");
-    if(f == NULL) {
-        /* Don't go further, we are not in a container */
-        return 0;
-    }
-    while((read = getline(&line, &len, f)) != -1) {
-        if(strstr(line, "docker") != NULL) {
-            found = 1;
-            break;
-        }
-    }
-    fclose(f);
-    free(line);
-    return found;
-#endif
-}
-
-static unsigned int portable_sleep(unsigned int seconds)
-{
-#ifdef WIN32
-    Sleep(seconds);
-#else
-    sleep(seconds);
-#endif
-}
-
-static int ip_address_from_container(char *container_id, char **ip_address_out)
-{
-    const char *active_docker_machine = docker_machine_name();
-    if(active_docker_machine != NULL) {
-
-        /* This can be flaky when tests run in parallel (see
-           https://github.com/docker/machine/issues/2612), so we retry a few
-           times with exponential backoff if it fails */
-        int attempt_no = 0;
-        int wait_time = 500;
-        for(;;) {
-            int ret = run_command(ip_address_out, "docker-machine ip %s",
-                                  active_docker_machine);
-            if(ret == 0) {
-                return 0;
-            }
-            else if(attempt_no > 5) {
-                fprintf(
-                    stderr,
-                    "Unable to get IP from docker-machine after %d attempts\n",
-                    attempt_no);
-                return -1;
-            }
-            else {
-                portable_sleep(wait_time);
-                ++attempt_no;
-                wait_time *= 2;
-            }
-        }
-    }
-    else {
-        if(is_running_inside_a_container()) {
-            return run_command(ip_address_out,
-                               "docker inspect --format "
-                               "\"{{ .NetworkSettings.IPAddress }}\""
-                               " %s",
-                               container_id);
-        }
-        else {
-            return run_command(ip_address_out,
-                               "docker inspect --format "
-                               "\"{{ index (index (index "
-                               ".NetworkSettings.Ports "
-                               "\\\"22/tcp\\\") 0) \\\"HostIp\\\" }}\" %s",
-                               container_id);
-        }
-    }
-}
-
-static int port_from_container(char *container_id, char **port_out)
-{
-    if(is_running_inside_a_container()) {
-        *port_out = strdup("22");
-        return 0;
-    }
-    else {
-        return run_command(port_out,
-                           "docker inspect --format "
-                           "\"{{ index (index (index .NetworkSettings.Ports "
-                           "\\\"22/tcp\\\") 0) \\\"HostPort\\\" }}\" %s",
-                           container_id);
-    }
-}
-
-static int open_socket_to_container(char *container_id)
-{
-    char *ip_address = NULL;
-    char *port_string = NULL;
-    unsigned long hostaddr;
-    int sock;
-    struct sockaddr_in sin;
-    int counter = 0;
-
-    int ret = ip_address_from_container(container_id, &ip_address);
-    if(ret != 0) {
-        fprintf(stderr, "Failed to get IP address for container %s\n",
-                container_id);
-        ret = -1;
-        goto cleanup;
-    }
-
-    ret = port_from_container(container_id, &port_string);
-    if(ret != 0) {
-        fprintf(stderr, "Failed to get port for container %s\n",
-                container_id);
-        ret = -1;
-    }
-
-    /* 0.0.0.0 is returned by Docker for Windows, because the container
-       is reachable from anywhere. But we cannot connect to 0.0.0.0,
-       instead we assume localhost and try to connect to 127.0.0.1. */
-    if(ip_address && strcmp(ip_address, "0.0.0.0") == 0) {
-        free(ip_address);
-        ip_address = strdup("127.0.0.1");
-    }
-
-    hostaddr = inet_addr(ip_address);
-    if(hostaddr == (unsigned long)(-1)) {
-        fprintf(stderr, "Failed to convert %s host address\n", ip_address);
-        ret = -1;
-        goto cleanup;
-    }
-
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock <= 0) {
-        fprintf(stderr, "Failed to open socket (%d)\n", sock);
-        ret = -1;
-        goto cleanup;
-    }
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons((short)strtol(port_string, NULL, 0));
-    sin.sin_addr.s_addr = hostaddr;
-
-    for(counter = 0; counter < 3; ++counter) {
-        if(connect(sock, (struct sockaddr *)(&sin),
-                   sizeof(struct sockaddr_in)) != 0) {
-            ret = -1;
-            fprintf(stderr,
-                    "Connection to %s:%s attempt #%d failed: retrying...\n",
-                    ip_address, port_string, counter);
-            portable_sleep(1 + 2*counter);
-        }
-        else {
-            ret = sock;
-            break;
-        }
-    }
-    if(ret == -1) {
-        fprintf(stderr, "Failed to connect to %s:%s\n",
-                ip_address, port_string);
-        goto cleanup;
-    }
-
-cleanup:
-    free(ip_address);
-    free(port_string);
-
-    return ret;
-}
-
-static char *running_container_id = NULL;
-
-int start_openssh_fixture()
-{
-    int ret;
-#ifdef HAVE_WINSOCK2_H
-    WSADATA wsadata;
-
-    ret = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(ret != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", ret);
-        return 1;
-    }
-#endif
-
-    ret = build_openssh_server_docker_image();
-    if(ret == 0) {
-        return start_openssh_server(&running_container_id);
-    }
-    else {
-        fprintf(stderr, "Failed to build docker image\n");
-        return ret;
-    }
-}
-
-void stop_openssh_fixture()
-{
-    if(running_container_id) {
-        stop_openssh_server(running_container_id);
-        free(running_container_id);
-        running_container_id = NULL;
-    }
-    else {
-        fprintf(stderr, "Cannot stop container - none started");
-    }
-}
-
-int open_socket_to_openssh_server()
-{
-    return open_socket_to_container(running_container_id);
-}
diff --git a/libssh2/libssh2/tests/openssh_server/Dockerfile b/libssh2/libssh2/tests/openssh_server/Dockerfile
deleted file mode 100644
index c5ce2224..00000000
--- a/libssh2/libssh2/tests/openssh_server/Dockerfile
+++ /dev/null
@@ -1,91 +0,0 @@
-# Copyright (c) 2016 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-FROM debian:jessie
-
-RUN apt-get update \
- && apt-get install -y openssh-server \
- && apt-get clean \
- && rm -rf /var/lib/apt/lists/*
-RUN mkdir /var/run/sshd
-
-# Chmodding because, when building on Windows, files are copied in with
-# -rwxr-xr-x permissions.
-#
-# Copying to a temp location, then moving because chmodding the copied file has
-# no effect (Docker AUFS-related bug maybe?)
-COPY ssh_host_rsa_key /tmp/etc/ssh/ssh_host_rsa_key
-RUN mv /tmp/etc/ssh/ssh_host_rsa_key /etc/ssh/ssh_host_rsa_key
-RUN chmod 600 /etc/ssh/ssh_host_rsa_key
-
-COPY ssh_host_ecdsa_key /tmp/etc/ssh/ssh_host_ecdsa_key
-RUN mv /tmp/etc/ssh/ssh_host_ecdsa_key /etc/ssh/ssh_host_ecdsa_key
-RUN chmod 600 /etc/ssh/ssh_host_ecdsa_key
-
-COPY ssh_host_ed25519_key /tmp/etc/ssh/ssh_host_ed25519_key
-RUN mv /tmp/etc/ssh/ssh_host_ed25519_key /etc/ssh/ssh_host_ed25519_key
-RUN chmod 600 /etc/ssh/ssh_host_ed25519_key
-
-COPY ca_ecdsa.pub /tmp/etc/ssh/ca_ecdsa.pub
-RUN mv /tmp/etc/ssh/ca_ecdsa.pub /etc/ssh/ca_ecdsa.pub
-RUN chmod 600 /etc/ssh/ca_ecdsa.pub
-
-COPY ca_ecdsa /tmp/etc/ssh/ca_ecdsa
-RUN mv /tmp/etc/ssh/ca_ecdsa /etc/ssh/ca_ecdsa
-RUN chmod 600 /etc/ssh/ca_ecdsa
-
-RUN adduser --disabled-password --gecos 'Test user for libssh2 integration tests' libssh2
-RUN echo 'libssh2:my test password' | chpasswd
-
-RUN sed -i 's/ChallengeResponseAuthentication no/ChallengeResponseAuthentication yes/' /etc/ssh/sshd_config
-RUN echo "TrustedUserCAKeys /etc/ssh/ca_ecdsa.pub" >> /etc/ssh/sshd_config
-
-# SSH login fix. Otherwise user is kicked off after login
-RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
-
-USER libssh2
-
-RUN mkdir -p /home/libssh2/.ssh
-RUN mkdir -p /home/libssh2/sandbox
-
-COPY authorized_keys /tmp/libssh2/.ssh/authorized_keys
-RUN cp /tmp/libssh2/.ssh/authorized_keys /home/libssh2/.ssh/authorized_keys
-RUN chmod 600 /home/libssh2/.ssh/authorized_keys
-
-USER root
-
-EXPOSE 22
-# -e gives logs via 'docker logs'
-CMD ["/usr/sbin/sshd", "-D", "-e"]
diff --git a/libssh2/libssh2/tests/openssh_server/authorized_keys b/libssh2/libssh2/tests/openssh_server/authorized_keys
deleted file mode 100644
index cdd6eef5..00000000
--- a/libssh2/libssh2/tests/openssh_server/authorized_keys
+++ /dev/null
@@ -1,7 +0,0 @@
-ssh-dss AAAAB3NzaC1kc3MAAACBAK2Jh2Ck+8W1+LsFrjgOIH7XHySiONPSdG+faFTZprinh9cjyR3odzntVA7+UuFH14WnGM/ub6MbAXjrxDo1TzGILvW5x6nQ6hdLu7xFygihZ8sO1mIMOVqGdlNbTiYHl8XGjbLt1iXfW8ThM91LGGqmS+cgEiy0wWHYzsOXTDz9AAAAFQD/ebunYNTluoBrEYIoq3LMtQPbcwAAAIEAjPBzkUKcmfMAmb0eO/QAVXmX+L8NC6Vn2m4QguQ2IcJ8NH6VMnxXEBHsnemCOa9jN55G+LnX17PViuKS0O3rqQiSdA5wcHyCHKBT519/v1KQNymDwudfnFvdxUyAAG6MDSxKlpbXDCbrhFd2+ahC9a7rKalRPSXR0R2hhWRvjK0AAACAJ+CGwV/1S4j1GVwa6pSP0nj4V86GWXosTTBg7GT+rKWu8lrxIcr6FzLWgFi/gHoMrgnKWGxO1yF7vkoYM5Yfo84oBYiH+MgpiBuOrZrgzacHsA66JJbUfrESRFWZl2blIPr6Gyjj6cVGgMabK3yCiTRi0v7hwffpm0rKyKv7Goo= awl03@bounty
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAnak1T7zHJ+hVRFBDQ9pf1KVzmd5gaNc7y7NPmL13aOG3sYeJevi1x1WM/R3tb8XnUnzZUX9GJN0MYovvZsw9bknG1mDP72LFbGp/gzPddGIKHBBpvceDaJ85sM/ME3XOtD7uuXQuNAuEHwEzSMMiSIEMcQS+lXIcMLr5xPLEkyNvqsO5RqSjMTLHKHgY8gLWx7oQ1avokhwuDxF7P3Pqtj+rW2Te6vR0i1H6EyFPsBkzkgNXb33cus8M1CnTmYTSgJgmHO2LLcGpjQ5sL8T/PWIWHaSqTnkrFXEMysgoteXnAYILjzyBaqq2WV4KA3TluGdAP2p8gC32QtKmIuis3Q== awl03@bounty
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC92YlGoc4PJy6DzX916JJZhxkvmkWBLGJdWOL7R9B6iaYEKebBxzTE3P1RcnxnuI06kklVq/KcDP9sLlgawTZcDg7ifM7HncPOi18OON8vvVVzodikHzuupjhpI5YTT9wwV2fDVi2URsBjvX4AFiZ5WM3/NwqdKpYABzWieBikXGJ58Tsnw+zQw2qMmKKESBuzSN538loTAj5iEH/GAKYDbbH9t2a17qhNCNEw4vrtURT9JqwO1cOg7N1OKpmqCPEbK0wuSTljNC230VJ06X/8UqahWWSH6MreGy6gwpPi6i9wFiFLur301R0dTPiKVhz6bguhcC1EAlhSgjfelFJt awl03@bounty
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTe1lN2L/yet0Ma1JzXkQf3t1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJWuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVPEYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9azgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoR
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICHxEyUTOVHXvdMFARedFQ+H9DW/n8Zy3daKKRqnTDMq
-ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBOiyJJwf+hFJrOkik9IQVxjhhVnI1vKl4BGLj03erLvw4TXXwoZzlPx6J936fU9JvvPw+d8PA4viMEfFbmdbHREKhwi3u1vZrfj0mB8SXw96AcZwX8PAL556wgom+/Qx+Q==
diff --git a/libssh2/libssh2/tests/openssh_server/ca_ecdsa b/libssh2/libssh2/tests/openssh_server/ca_ecdsa
deleted file mode 100644
index d6b670c5..00000000
--- a/libssh2/libssh2/tests/openssh_server/ca_ecdsa
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAArAAAABNlY2RzYS
-1zaGEyLW5pc3RwNTIxAAAACG5pc3RwNTIxAAAAhQQAfv15s+G2xg56J+audKAM4G9qOTFr
-bZRo0CTwvkb/oHrf9/2RSWqYsx/0m5mYCZVlecnZqwRHAOolXbc/Yb4cGjsALUj3UDirsn
-YR7Ve+SwnunkpvW/H3a98sA3sS+HCpd5RbpfWClSBOI9JEAlPtS1CrEQ7EmO7hmlFOH2cL
-0qfHCyYAAAEA763VSe+t1UkAAAATZWNkc2Etc2hhMi1uaXN0cDUyMQAAAAhuaXN0cDUyMQ
-AAAIUEAH79ebPhtsYOeifmrnSgDOBvajkxa22UaNAk8L5G/6B63/f9kUlqmLMf9JuZmAmV
-ZXnJ2asERwDqJV23P2G+HBo7AC1I91A4q7J2Ee1XvksJ7p5Kb1vx92vfLAN7EvhwqXeUW6
-X1gpUgTiPSRAJT7UtQqxEOxJju4ZpRTh9nC9KnxwsmAAAAQgD8VJwi9RHYN13CAfhvdmjW
-xVjH55J5jDjPlENU2Z+cnm01SQ+9mPFEY4wDSvfiovD1VstNJX/P97WbHw+e5XL+HwAAAA
-JDQQ==
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/openssh_server/ca_ecdsa.pub b/libssh2/libssh2/tests/openssh_server/ca_ecdsa.pub
deleted file mode 100644
index 5086eabe..00000000
--- a/libssh2/libssh2/tests/openssh_server/ca_ecdsa.pub
+++ /dev/null
@@ -1 +0,0 @@
-ecdsa-sha2-nistp521 AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBAB+/Xmz4bbGDnon5q50oAzgb2o5MWttlGjQJPC+Rv+get/3/ZFJapizH/SbmZgJlWV5ydmrBEcA6iVdtz9hvhwaOwAtSPdQOKuydhHtV75LCe6eSm9b8fdr3ywDexL4cKl3lFul9YKVIE4j0kQCU+1LUKsRDsSY7uGaUU4fZwvSp8cLJg== CA
diff --git a/libssh2/libssh2/tests/openssh_server/ssh_host_ecdsa_key b/libssh2/libssh2/tests/openssh_server/ssh_host_ecdsa_key
deleted file mode 100644
index 0164b523..00000000
--- a/libssh2/libssh2/tests/openssh_server/ssh_host_ecdsa_key
+++ /dev/null
@@ -1,5 +0,0 @@
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIKdqGrp+52U1ehslMI4fX0cmvgHFmKSkMzQGmj6B07ecoAoGCCqGSM49
-AwEHoUQDQgAEL7+zLJ4okP10LZkf1DuIkZF5HhgzetQIyxLKeTJeiN19IKUYIxjs
-m9aW3fQRKNi/GhN9JEbHpa9qpgr+8+hhDg==
------END EC PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/openssh_server/ssh_host_ed25519_key b/libssh2/libssh2/tests/openssh_server/ssh_host_ed25519_key
deleted file mode 100644
index bfb1ad56..00000000
--- a/libssh2/libssh2/tests/openssh_server/ssh_host_ed25519_key
+++ /dev/null
@@ -1,7 +0,0 @@
------BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6JgAAAJg8nvUxPJ71
-MQAAAAtzc2gtZWQyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6Jg
-AAAECnhCuTDYdz3kUn48BXkaCXXdbKdH7wSIQ/CUx1cbnR0Ixtdyg2ZRXE70UwyPVUH3Uy
-fDBV8GX5cPF636P6hjomAAAAEHdpbGxAaUN1YmUubG9jYWwBAgMEBQ==
------END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/openssh_server/ssh_host_rsa_key b/libssh2/libssh2/tests/openssh_server/ssh_host_rsa_key
deleted file mode 100644
index ba0088c4..00000000
--- a/libssh2/libssh2/tests/openssh_server/ssh_host_rsa_key
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEoQIBAAKCAQEArrr/JuJmaZligyfS8vcNur+mWR2ddDQtVdhHzdKUUoR6/Om6
-cvxpe61H1YZO1xCpLUBXmkki4HoNtYOpPB2W4V+8U4BDeVBD5crypEOE1+7BAm99
-fnEDxYIOZq2/jTP0yQmzCpWYS3COyFmkOL7sfX1wQMeW5zQT2WKcxC6FSWbhDqrB
-eNEGi687hJJoJ7YXgY/IdiYW5NcOuqRSWljjGS3dAJsHHWk4nJbhjEDXbPaeduMA
-wQU9i6ELfP3r+q6wdu0P4jWaoo3De1aYxnToV/ldXykpipON4NPamsb6Ph2qlJQK
-ypq7J4iQgkIIbCU1A31+4ExvcIVoxLQw/aTSbwIBIwKCAQAd9Cu9heWrs+UAinvv
-Iwmq/EhnDGQijJoOt1zEMrpXSekyq7mQDgN0SZdJLPeSlSRQ5nVq5/dZroYB3A5i
-E7N3F7nibcJskWq5rcMyGjQHwod8wqfMiGcL6mjeZu2jLXprm0NDpJ3DyicbCA2G
-EhnpoHmktIBE5FsslI/nHer2o6OA/kVWSEjak+pvI1pm22T8QOBBfY0yAX7B0ebk
-8o4lB4cdLf3In7Q0ahpHNOwIPdRvQ2c4Tm/DcfUBkTW2ZYGUd45cFsyHqXZscNNy
-GX2Wcy/FLEvQ6zBFJsNLpxCYsUyBxfSDygn9dx9RQfiWFXjdRaRPpyRAr+BTXkLU
-yvabAoGBANt7sxfjvu/SLkRc7TnBoJ0h/AL7Mcuu9PJmOnis4boyF9ZxqbiRiS3J
-yK+EKxfC0S+xf5WJ5uf7dVGnOXHXKaRl4xH90iRtryNlvtILZwHw1DTqRFxv9jtz
-tTRrYMEHAnMKzadgDfV/lv4iJ6nwFzK76GQ7RQNZYiGTMEh3pUNjAoGBAMvNLGpz
-FxhpIh+fVvRjawKgGVP87T482WOUdsF18EEPFMe6D7DO5xpLuJi+C7QkvMI8WjvD
-/3RGvaSh9Wt7ikLZpeogiSJy121HsEqheTR5hTx2t72ClrjZvIhLbQMRu6PqGPu/
-HOC2urEGGYm7O2vnftwpuG3zIVVLM2KstPCFAoGBAM7w+VEJ7opYdMQdGi8kRvqN
-wbmrAxCAY0ryrCijALbexgS0T5DDu9q28Gr49W4stpquq35dc0/BNBnJje7+EVHc
-aGFrqOCErHHU9b66Sy23LnsIxBykFAwrRHNAq66u1mx35nk9Tv1pq58nhHun21u4
-fAa7ijZblwm2qd3tJsqBAoGAEXf8ficfPJtMEVbM8GBLADmbxV7Sga1xuBQKLdbo
-tR6MwKmMUPvKqnuE2eRnZzZZUnoznrkHRHsXkcS9Q7ohyzc6G2Hf3mGdb8RQ8HQ9
-lsiWZESwqdf+SlvOVNND27EQFV01V2gnC/JnxgfWTaJVjOf07ky4CWycdQZyHmaT
-Ko8CgYB58jOyXMdo2ggOCG/HX2H92KPPpFUBFCX27fCue8BZLD5quIltpXupx5oj
-EyltgvPcmNDgvdSadkHvP5s6nykS+n5we+d9yIIJF/BfETWsXjR3ooip+trqiirw
-0aHqUDFcYn9unm2wtrMYYViiDLRijNwLZ2sG0JIU4JHyseh+NA==
------END RSA PRIVATE KEY-----
diff --git a/libssh2/libssh2/tests/ossfuzz/Makefile.am b/libssh2/libssh2/tests/ossfuzz/Makefile.am
deleted file mode 100644
index a7e95825..00000000
--- a/libssh2/libssh2/tests/ossfuzz/Makefile.am
+++ /dev/null
@@ -1,32 +0,0 @@
-AM_CPPFLAGS = -I$(top_builddir)/include
-LDADD = $(top_builddir)/src/libssh2.la
-
-if USE_OSSFUZZ_FLAG
-FUZZ_FLAG = $(LIB_FUZZING_ENGINE)
-else
-if USE_OSSFUZZ_STATIC
-LDADD += $(LIB_FUZZING_ENGINE)
-FUZZ_FLAG =
-else
-LDADD += libstandaloneengine.a
-FUZZ_FLAG =
-endif
-endif
-
-noinst_PROGRAMS =
-noinst_LIBRARIES =
-
-if USE_OSSFUZZERS
-noinst_PROGRAMS += \
-	ssh2_client_fuzzer
-
-noinst_LIBRARIES += \
-	libstandaloneengine.a
-endif
-
-ssh2_client_fuzzer_SOURCES = ssh2_client_fuzzer.cc testinput.h
-ssh2_client_fuzzer_CXXFLAGS = $(AM_CXXFLAGS) $(FUZZ_FLAG)
-ssh2_client_fuzzer_LDFLAGS = $(AM_LDFLAGS) -static
-
-libstandaloneengine_a_SOURCES = standaloneengine.cc
-libstandaloneengine_a_CXXFLAGS = $(AM_CXXFLAGS)
diff --git a/libssh2/libssh2/tests/ossfuzz/Makefile.in b/libssh2/libssh2/tests/ossfuzz/Makefile.in
deleted file mode 100644
index 9fa6d259..00000000
--- a/libssh2/libssh2/tests/ossfuzz/Makefile.in
+++ /dev/null
@@ -1,731 +0,0 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
-# @configure_input@
-
-# Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-# This Makefile.in is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-# PARTICULAR PURPOSE.
-
-@SET_MAKE@
-
-
-VPATH = @srcdir@
-am__is_gnu_make = { \
-  if test -z '$(MAKELEVEL)'; then \
-    false; \
-  elif test -n '$(MAKE_HOST)'; then \
-    true; \
-  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
-    true; \
-  else \
-    false; \
-  fi; \
-}
-am__make_running_with_option = \
-  case $${target_option-} in \
-      ?) ;; \
-      *) echo "am__make_running_with_option: internal error: invalid" \
-              "target option '$${target_option-}' specified" >&2; \
-         exit 1;; \
-  esac; \
-  has_opt=no; \
-  sane_makeflags=$$MAKEFLAGS; \
-  if $(am__is_gnu_make); then \
-    sane_makeflags=$$MFLAGS; \
-  else \
-    case $$MAKEFLAGS in \
-      *\\[\ \	]*) \
-        bs=\\; \
-        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
-          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
-    esac; \
-  fi; \
-  skip_next=no; \
-  strip_trailopt () \
-  { \
-    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
-  }; \
-  for flg in $$sane_makeflags; do \
-    test $$skip_next = yes && { skip_next=no; continue; }; \
-    case $$flg in \
-      *=*|--*) continue;; \
-        -*I) strip_trailopt 'I'; skip_next=yes;; \
-      -*I?*) strip_trailopt 'I';; \
-        -*O) strip_trailopt 'O'; skip_next=yes;; \
-      -*O?*) strip_trailopt 'O';; \
-        -*l) strip_trailopt 'l'; skip_next=yes;; \
-      -*l?*) strip_trailopt 'l';; \
-      -[dEDm]) skip_next=yes;; \
-      -[JT]) skip_next=yes;; \
-    esac; \
-    case $$flg in \
-      *$$target_option*) has_opt=yes; break;; \
-    esac; \
-  done; \
-  test $$has_opt = yes
-am__make_dryrun = (target_option=n; $(am__make_running_with_option))
-am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
-pkgdatadir = $(datadir)/@PACKAGE@
-pkgincludedir = $(includedir)/@PACKAGE@
-pkglibdir = $(libdir)/@PACKAGE@
-pkglibexecdir = $(libexecdir)/@PACKAGE@
-am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
-install_sh_DATA = $(install_sh) -c -m 644
-install_sh_PROGRAM = $(install_sh) -c
-install_sh_SCRIPT = $(install_sh) -c
-INSTALL_HEADER = $(INSTALL_DATA)
-transform = $(program_transform_name)
-NORMAL_INSTALL = :
-PRE_INSTALL = :
-POST_INSTALL = :
-NORMAL_UNINSTALL = :
-PRE_UNINSTALL = :
-POST_UNINSTALL = :
-build_triplet = @build@
-host_triplet = @host@
-@USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_TRUE@am__append_1 = $(LIB_FUZZING_ENGINE)
-@USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_FALSE@am__append_2 = libstandaloneengine.a
-noinst_PROGRAMS = $(am__EXEEXT_1)
-@USE_OSSFUZZERS_TRUE@am__append_3 = \
-@USE_OSSFUZZERS_TRUE@	ssh2_client_fuzzer
-
-@USE_OSSFUZZERS_TRUE@am__append_4 = \
-@USE_OSSFUZZERS_TRUE@	libstandaloneengine.a
-
-subdir = tests/ossfuzz
-ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
-am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
-	$(ACLOCAL_M4)
-DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
-mkinstalldirs = $(install_sh) -d
-CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
-CONFIG_CLEAN_FILES =
-CONFIG_CLEAN_VPATH_FILES =
-@USE_OSSFUZZERS_TRUE@am__EXEEXT_1 = ssh2_client_fuzzer$(EXEEXT)
-PROGRAMS = $(noinst_PROGRAMS)
-LIBRARIES = $(noinst_LIBRARIES)
-ARFLAGS = cru
-AM_V_AR = $(am__v_AR_@AM_V@)
-am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
-am__v_AR_0 = @echo "  AR      " $@;
-am__v_AR_1 = 
-libstandaloneengine_a_AR = $(AR) $(ARFLAGS)
-libstandaloneengine_a_LIBADD =
-am_libstandaloneengine_a_OBJECTS =  \
-	libstandaloneengine_a-standaloneengine.$(OBJEXT)
-libstandaloneengine_a_OBJECTS = $(am_libstandaloneengine_a_OBJECTS)
-am_ssh2_client_fuzzer_OBJECTS =  \
-	ssh2_client_fuzzer-ssh2_client_fuzzer.$(OBJEXT)
-ssh2_client_fuzzer_OBJECTS = $(am_ssh2_client_fuzzer_OBJECTS)
-ssh2_client_fuzzer_LDADD = $(LDADD)
-am__DEPENDENCIES_1 =
-@USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_TRUE@am__DEPENDENCIES_2 = $(am__DEPENDENCIES_1)
-ssh2_client_fuzzer_DEPENDENCIES = $(top_builddir)/src/libssh2.la \
-	$(am__DEPENDENCIES_2) $(am__append_2)
-AM_V_lt = $(am__v_lt_@AM_V@)
-am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
-am__v_lt_0 = --silent
-am__v_lt_1 = 
-ssh2_client_fuzzer_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
-	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
-	$(ssh2_client_fuzzer_CXXFLAGS) $(CXXFLAGS) \
-	$(ssh2_client_fuzzer_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_P = $(am__v_P_@AM_V@)
-am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
-am__v_P_0 = false
-am__v_P_1 = :
-AM_V_GEN = $(am__v_GEN_@AM_V@)
-am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
-am__v_GEN_0 = @echo "  GEN     " $@;
-am__v_GEN_1 = 
-AM_V_at = $(am__v_at_@AM_V@)
-am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
-am__v_at_0 = @
-am__v_at_1 = 
-DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src
-depcomp = $(SHELL) $(top_srcdir)/depcomp
-am__maybe_remake_depfiles = depfiles
-am__depfiles_remade =  \
-	./$(DEPDIR)/libstandaloneengine_a-standaloneengine.Po \
-	./$(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po
-am__mv = mv -f
-CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
-	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
-	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
-	$(AM_CXXFLAGS) $(CXXFLAGS)
-AM_V_CXX = $(am__v_CXX_@AM_V@)
-am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
-am__v_CXX_0 = @echo "  CXX     " $@;
-am__v_CXX_1 = 
-CXXLD = $(CXX)
-CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
-	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
-am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
-am__v_CXXLD_0 = @echo "  CXXLD   " $@;
-am__v_CXXLD_1 = 
-COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
-LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
-	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
-	$(AM_CFLAGS) $(CFLAGS)
-AM_V_CC = $(am__v_CC_@AM_V@)
-am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
-am__v_CC_0 = @echo "  CC      " $@;
-am__v_CC_1 = 
-CCLD = $(CC)
-LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
-	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
-	$(AM_LDFLAGS) $(LDFLAGS) -o $@
-AM_V_CCLD = $(am__v_CCLD_@AM_V@)
-am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
-am__v_CCLD_0 = @echo "  CCLD    " $@;
-am__v_CCLD_1 = 
-SOURCES = $(libstandaloneengine_a_SOURCES) \
-	$(ssh2_client_fuzzer_SOURCES)
-DIST_SOURCES = $(libstandaloneengine_a_SOURCES) \
-	$(ssh2_client_fuzzer_SOURCES)
-am__can_run_installinfo = \
-  case $$AM_UPDATE_INFO_DIR in \
-    n|no|NO) false;; \
-    *) (install-info --version) >/dev/null 2>&1;; \
-  esac
-am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
-# Read a list of newline-separated strings from the standard input,
-# and print each of them once, without duplicates.  Input order is
-# *not* preserved.
-am__uniquify_input = $(AWK) '\
-  BEGIN { nonempty = 0; } \
-  { items[$$0] = 1; nonempty = 1; } \
-  END { if (nonempty) { for (i in items) print i; }; } \
-'
-# Make sure the list of sources is unique.  This is necessary because,
-# e.g., the same source file might be shared among _SOURCES variables
-# for different programs/libraries.
-am__define_uniq_tagged_files = \
-  list='$(am__tagged_files)'; \
-  unique=`for i in $$list; do \
-    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
-  done | $(am__uniquify_input)`
-am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp
-DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
-ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
-AMTAR = @AMTAR@
-AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
-AR = @AR@
-AS = @AS@
-AUTOCONF = @AUTOCONF@
-AUTOHEADER = @AUTOHEADER@
-AUTOMAKE = @AUTOMAKE@
-AWK = @AWK@
-CC = @CC@
-CCDEPMODE = @CCDEPMODE@
-CFLAGS = @CFLAGS@
-CPP = @CPP@
-CPPFLAGS = @CPPFLAGS@
-CSCOPE = @CSCOPE@
-CTAGS = @CTAGS@
-CXX = @CXX@
-CXXCPP = @CXXCPP@
-CXXDEPMODE = @CXXDEPMODE@
-CXXFLAGS = @CXXFLAGS@
-CYGPATH_W = @CYGPATH_W@
-DEFS = @DEFS@
-DEPDIR = @DEPDIR@
-DLLTOOL = @DLLTOOL@
-DSYMUTIL = @DSYMUTIL@
-DUMPBIN = @DUMPBIN@
-ECHO_C = @ECHO_C@
-ECHO_N = @ECHO_N@
-ECHO_T = @ECHO_T@
-EGREP = @EGREP@
-ETAGS = @ETAGS@
-EXEEXT = @EXEEXT@
-FGREP = @FGREP@
-GREP = @GREP@
-HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
-HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
-HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
-HAVE_LIBSSL = @HAVE_LIBSSL@
-HAVE_LIBZ = @HAVE_LIBZ@
-INSTALL = @INSTALL@
-INSTALL_DATA = @INSTALL_DATA@
-INSTALL_PROGRAM = @INSTALL_PROGRAM@
-INSTALL_SCRIPT = @INSTALL_SCRIPT@
-INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
-LD = @LD@
-LDFLAGS = @LDFLAGS@
-LIBBCRYPT = @LIBBCRYPT@
-LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
-LIBGCRYPT = @LIBGCRYPT@
-LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
-LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
-LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
-LIBOBJS = @LIBOBJS@
-LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
-LIBSSL = @LIBSSL@
-LIBSSL_PREFIX = @LIBSSL_PREFIX@
-LIBTOOL = @LIBTOOL@
-LIBZ = @LIBZ@
-LIBZ_PREFIX = @LIBZ_PREFIX@
-LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
-LIPO = @LIPO@
-LN_S = @LN_S@
-LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
-LTLIBGCRYPT = @LTLIBGCRYPT@
-LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
-LTLIBOBJS = @LTLIBOBJS@
-LTLIBSSL = @LTLIBSSL@
-LTLIBZ = @LTLIBZ@
-LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
-MAINT = @MAINT@
-MAKEINFO = @MAKEINFO@
-MANIFEST_TOOL = @MANIFEST_TOOL@
-MKDIR_P = @MKDIR_P@
-NM = @NM@
-NMEDIT = @NMEDIT@
-OBJDUMP = @OBJDUMP@
-OBJEXT = @OBJEXT@
-OTOOL = @OTOOL@
-OTOOL64 = @OTOOL64@
-PACKAGE = @PACKAGE@
-PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
-PACKAGE_NAME = @PACKAGE_NAME@
-PACKAGE_STRING = @PACKAGE_STRING@
-PACKAGE_TARNAME = @PACKAGE_TARNAME@
-PACKAGE_URL = @PACKAGE_URL@
-PACKAGE_VERSION = @PACKAGE_VERSION@
-PATH_SEPARATOR = @PATH_SEPARATOR@
-RANLIB = @RANLIB@
-SED = @SED@
-SET_MAKE = @SET_MAKE@
-SHELL = @SHELL@
-SSHD = @SSHD@
-STRIP = @STRIP@
-VERSION = @VERSION@
-abs_builddir = @abs_builddir@
-abs_srcdir = @abs_srcdir@
-abs_top_builddir = @abs_top_builddir@
-abs_top_srcdir = @abs_top_srcdir@
-ac_ct_AR = @ac_ct_AR@
-ac_ct_CC = @ac_ct_CC@
-ac_ct_CXX = @ac_ct_CXX@
-ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
-am__include = @am__include@
-am__leading_dot = @am__leading_dot@
-am__quote = @am__quote@
-am__tar = @am__tar@
-am__untar = @am__untar@
-bindir = @bindir@
-build = @build@
-build_alias = @build_alias@
-build_cpu = @build_cpu@
-build_os = @build_os@
-build_vendor = @build_vendor@
-builddir = @builddir@
-datadir = @datadir@
-datarootdir = @datarootdir@
-docdir = @docdir@
-dvidir = @dvidir@
-exec_prefix = @exec_prefix@
-host = @host@
-host_alias = @host_alias@
-host_cpu = @host_cpu@
-host_os = @host_os@
-host_vendor = @host_vendor@
-htmldir = @htmldir@
-includedir = @includedir@
-infodir = @infodir@
-install_sh = @install_sh@
-libdir = @libdir@
-libexecdir = @libexecdir@
-localedir = @localedir@
-localstatedir = @localstatedir@
-mandir = @mandir@
-mkdir_p = @mkdir_p@
-oldincludedir = @oldincludedir@
-pdfdir = @pdfdir@
-prefix = @prefix@
-program_transform_name = @program_transform_name@
-psdir = @psdir@
-runstatedir = @runstatedir@
-sbindir = @sbindir@
-sharedstatedir = @sharedstatedir@
-srcdir = @srcdir@
-sysconfdir = @sysconfdir@
-target_alias = @target_alias@
-top_build_prefix = @top_build_prefix@
-top_builddir = @top_builddir@
-top_srcdir = @top_srcdir@
-AM_CPPFLAGS = -I$(top_builddir)/include
-LDADD = $(top_builddir)/src/libssh2.la $(am__append_1) $(am__append_2)
-@USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_FALSE@FUZZ_FLAG = 
-@USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_TRUE@FUZZ_FLAG = 
-@USE_OSSFUZZ_FLAG_TRUE@FUZZ_FLAG = $(LIB_FUZZING_ENGINE)
-noinst_LIBRARIES = $(am__append_4)
-ssh2_client_fuzzer_SOURCES = ssh2_client_fuzzer.cc testinput.h
-ssh2_client_fuzzer_CXXFLAGS = $(AM_CXXFLAGS) $(FUZZ_FLAG)
-ssh2_client_fuzzer_LDFLAGS = $(AM_LDFLAGS) -static
-libstandaloneengine_a_SOURCES = standaloneengine.cc
-libstandaloneengine_a_CXXFLAGS = $(AM_CXXFLAGS)
-all: all-am
-
-.SUFFIXES:
-.SUFFIXES: .cc .lo .o .obj
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
-	@for dep in $?; do \
-	  case '$(am__configure_deps)' in \
-	    *$$dep*) \
-	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
-	        && { if test -f $@; then exit 0; else break; fi; }; \
-	      exit 1;; \
-	  esac; \
-	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign tests/ossfuzz/Makefile'; \
-	$(am__cd) $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign tests/ossfuzz/Makefile
-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
-	@case '$?' in \
-	  *config.status*) \
-	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
-	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
-	esac;
-
-$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-
-$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
-	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
-$(am__aclocal_m4_deps):
-
-clean-noinstPROGRAMS:
-	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
-
-clean-noinstLIBRARIES:
-	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
-
-libstandaloneengine.a: $(libstandaloneengine_a_OBJECTS) $(libstandaloneengine_a_DEPENDENCIES) $(EXTRA_libstandaloneengine_a_DEPENDENCIES) 
-	$(AM_V_at)-rm -f libstandaloneengine.a
-	$(AM_V_AR)$(libstandaloneengine_a_AR) libstandaloneengine.a $(libstandaloneengine_a_OBJECTS) $(libstandaloneengine_a_LIBADD)
-	$(AM_V_at)$(RANLIB) libstandaloneengine.a
-
-ssh2_client_fuzzer$(EXEEXT): $(ssh2_client_fuzzer_OBJECTS) $(ssh2_client_fuzzer_DEPENDENCIES) $(EXTRA_ssh2_client_fuzzer_DEPENDENCIES) 
-	@rm -f ssh2_client_fuzzer$(EXEEXT)
-	$(AM_V_CXXLD)$(ssh2_client_fuzzer_LINK) $(ssh2_client_fuzzer_OBJECTS) $(ssh2_client_fuzzer_LDADD) $(LIBS)
-
-mostlyclean-compile:
-	-rm -f *.$(OBJEXT)
-
-distclean-compile:
-	-rm -f *.tab.c
-
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libstandaloneengine_a-standaloneengine.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po@am__quote@ # am--include-marker
-
-$(am__depfiles_remade):
-	@$(MKDIR_P) $(@D)
-	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
-
-am--depfiles: $(am__depfiles_remade)
-
-.cc.o:
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
-
-.cc.obj:
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
-
-.cc.lo:
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
-
-libstandaloneengine_a-standaloneengine.o: standaloneengine.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstandaloneengine_a_CXXFLAGS) $(CXXFLAGS) -MT libstandaloneengine_a-standaloneengine.o -MD -MP -MF $(DEPDIR)/libstandaloneengine_a-standaloneengine.Tpo -c -o libstandaloneengine_a-standaloneengine.o `test -f 'standaloneengine.cc' || echo '$(srcdir)/'`standaloneengine.cc
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libstandaloneengine_a-standaloneengine.Tpo $(DEPDIR)/libstandaloneengine_a-standaloneengine.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='standaloneengine.cc' object='libstandaloneengine_a-standaloneengine.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstandaloneengine_a_CXXFLAGS) $(CXXFLAGS) -c -o libstandaloneengine_a-standaloneengine.o `test -f 'standaloneengine.cc' || echo '$(srcdir)/'`standaloneengine.cc
-
-libstandaloneengine_a-standaloneengine.obj: standaloneengine.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstandaloneengine_a_CXXFLAGS) $(CXXFLAGS) -MT libstandaloneengine_a-standaloneengine.obj -MD -MP -MF $(DEPDIR)/libstandaloneengine_a-standaloneengine.Tpo -c -o libstandaloneengine_a-standaloneengine.obj `if test -f 'standaloneengine.cc'; then $(CYGPATH_W) 'standaloneengine.cc'; else $(CYGPATH_W) '$(srcdir)/standaloneengine.cc'; fi`
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libstandaloneengine_a-standaloneengine.Tpo $(DEPDIR)/libstandaloneengine_a-standaloneengine.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='standaloneengine.cc' object='libstandaloneengine_a-standaloneengine.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libstandaloneengine_a_CXXFLAGS) $(CXXFLAGS) -c -o libstandaloneengine_a-standaloneengine.obj `if test -f 'standaloneengine.cc'; then $(CYGPATH_W) 'standaloneengine.cc'; else $(CYGPATH_W) '$(srcdir)/standaloneengine.cc'; fi`
-
-ssh2_client_fuzzer-ssh2_client_fuzzer.o: ssh2_client_fuzzer.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ssh2_client_fuzzer_CXXFLAGS) $(CXXFLAGS) -MT ssh2_client_fuzzer-ssh2_client_fuzzer.o -MD -MP -MF $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Tpo -c -o ssh2_client_fuzzer-ssh2_client_fuzzer.o `test -f 'ssh2_client_fuzzer.cc' || echo '$(srcdir)/'`ssh2_client_fuzzer.cc
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Tpo $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='ssh2_client_fuzzer.cc' object='ssh2_client_fuzzer-ssh2_client_fuzzer.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ssh2_client_fuzzer_CXXFLAGS) $(CXXFLAGS) -c -o ssh2_client_fuzzer-ssh2_client_fuzzer.o `test -f 'ssh2_client_fuzzer.cc' || echo '$(srcdir)/'`ssh2_client_fuzzer.cc
-
-ssh2_client_fuzzer-ssh2_client_fuzzer.obj: ssh2_client_fuzzer.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ssh2_client_fuzzer_CXXFLAGS) $(CXXFLAGS) -MT ssh2_client_fuzzer-ssh2_client_fuzzer.obj -MD -MP -MF $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Tpo -c -o ssh2_client_fuzzer-ssh2_client_fuzzer.obj `if test -f 'ssh2_client_fuzzer.cc'; then $(CYGPATH_W) 'ssh2_client_fuzzer.cc'; else $(CYGPATH_W) '$(srcdir)/ssh2_client_fuzzer.cc'; fi`
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Tpo $(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='ssh2_client_fuzzer.cc' object='ssh2_client_fuzzer-ssh2_client_fuzzer.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ssh2_client_fuzzer_CXXFLAGS) $(CXXFLAGS) -c -o ssh2_client_fuzzer-ssh2_client_fuzzer.obj `if test -f 'ssh2_client_fuzzer.cc'; then $(CYGPATH_W) 'ssh2_client_fuzzer.cc'; else $(CYGPATH_W) '$(srcdir)/ssh2_client_fuzzer.cc'; fi`
-
-mostlyclean-libtool:
-	-rm -f *.lo
-
-clean-libtool:
-	-rm -rf .libs _libs
-
-ID: $(am__tagged_files)
-	$(am__define_uniq_tagged_files); mkid -fID $$unique
-tags: tags-am
-TAGS: tags
-
-tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	set x; \
-	here=`pwd`; \
-	$(am__define_uniq_tagged_files); \
-	shift; \
-	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
-	  test -n "$$unique" || unique=$$empty_fix; \
-	  if test $$# -gt 0; then \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      "$$@" $$unique; \
-	  else \
-	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
-	      $$unique; \
-	  fi; \
-	fi
-ctags: ctags-am
-
-CTAGS: ctags
-ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
-	$(am__define_uniq_tagged_files); \
-	test -z "$(CTAGS_ARGS)$$unique" \
-	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
-	     $$unique
-
-GTAGS:
-	here=`$(am__cd) $(top_builddir) && pwd` \
-	  && $(am__cd) $(top_srcdir) \
-	  && gtags -i $(GTAGS_ARGS) "$$here"
-cscopelist: cscopelist-am
-
-cscopelist-am: $(am__tagged_files)
-	list='$(am__tagged_files)'; \
-	case "$(srcdir)" in \
-	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
-	  *) sdir=$(subdir)/$(srcdir) ;; \
-	esac; \
-	for i in $$list; do \
-	  if test -f "$$i"; then \
-	    echo "$(subdir)/$$i"; \
-	  else \
-	    echo "$$sdir/$$i"; \
-	  fi; \
-	done >> $(top_builddir)/cscope.files
-
-distclean-tags:
-	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-distdir: $(BUILT_SOURCES)
-	$(MAKE) $(AM_MAKEFLAGS) distdir-am
-
-distdir-am: $(DISTFILES)
-	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
-	list='$(DISTFILES)'; \
-	  dist_files=`for file in $$list; do echo $$file; done | \
-	  sed -e "s|^$$srcdirstrip/||;t" \
-	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
-	case $$dist_files in \
-	  */*) $(MKDIR_P) `echo "$$dist_files" | \
-			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
-			   sort -u` ;; \
-	esac; \
-	for file in $$dist_files; do \
-	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
-	  if test -d $$d/$$file; then \
-	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
-	    if test -d "$(distdir)/$$file"; then \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
-	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
-	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
-	    fi; \
-	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
-	  else \
-	    test -f "$(distdir)/$$file" \
-	    || cp -p $$d/$$file "$(distdir)/$$file" \
-	    || exit 1; \
-	  fi; \
-	done
-check-am: all-am
-check: check-am
-all-am: Makefile $(PROGRAMS) $(LIBRARIES)
-installdirs:
-install: install-am
-install-exec: install-exec-am
-install-data: install-data-am
-uninstall: uninstall-am
-
-install-am: all-am
-	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
-
-installcheck: installcheck-am
-install-strip:
-	if test -z '$(STRIP)'; then \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	      install; \
-	else \
-	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
-	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
-	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
-	fi
-mostlyclean-generic:
-
-clean-generic:
-
-distclean-generic:
-	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-
-maintainer-clean-generic:
-	@echo "This command is intended for maintainers to use"
-	@echo "it deletes files that may require special tools to rebuild."
-clean: clean-am
-
-clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \
-	clean-noinstPROGRAMS mostlyclean-am
-
-distclean: distclean-am
-		-rm -f ./$(DEPDIR)/libstandaloneengine_a-standaloneengine.Po
-	-rm -f ./$(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po
-	-rm -f Makefile
-distclean-am: clean-am distclean-compile distclean-generic \
-	distclean-tags
-
-dvi: dvi-am
-
-dvi-am:
-
-html: html-am
-
-html-am:
-
-info: info-am
-
-info-am:
-
-install-data-am:
-
-install-dvi: install-dvi-am
-
-install-dvi-am:
-
-install-exec-am:
-
-install-html: install-html-am
-
-install-html-am:
-
-install-info: install-info-am
-
-install-info-am:
-
-install-man:
-
-install-pdf: install-pdf-am
-
-install-pdf-am:
-
-install-ps: install-ps-am
-
-install-ps-am:
-
-installcheck-am:
-
-maintainer-clean: maintainer-clean-am
-		-rm -f ./$(DEPDIR)/libstandaloneengine_a-standaloneengine.Po
-	-rm -f ./$(DEPDIR)/ssh2_client_fuzzer-ssh2_client_fuzzer.Po
-	-rm -f Makefile
-maintainer-clean-am: distclean-am maintainer-clean-generic
-
-mostlyclean: mostlyclean-am
-
-mostlyclean-am: mostlyclean-compile mostlyclean-generic \
-	mostlyclean-libtool
-
-pdf: pdf-am
-
-pdf-am:
-
-ps: ps-am
-
-ps-am:
-
-uninstall-am:
-
-.MAKE: install-am install-strip
-
-.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
-	clean-generic clean-libtool clean-noinstLIBRARIES \
-	clean-noinstPROGRAMS cscopelist-am ctags ctags-am distclean \
-	distclean-compile distclean-generic distclean-libtool \
-	distclean-tags distdir dvi dvi-am html html-am info info-am \
-	install install-am install-data install-data-am install-dvi \
-	install-dvi-am install-exec install-exec-am install-html \
-	install-html-am install-info install-info-am install-man \
-	install-pdf install-pdf-am install-ps install-ps-am \
-	install-strip installcheck installcheck-am installdirs \
-	maintainer-clean maintainer-clean-generic mostlyclean \
-	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
-	pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am
-
-.PRECIOUS: Makefile
-
-
-# Tell versions [3.59,3.63) of GNU make to not export all variables.
-# Otherwise a system limit (for SysV at least) may be exceeded.
-.NOEXPORT:
diff --git a/libssh2/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc b/libssh2/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc
deleted file mode 100644
index d9f5ab51..00000000
--- a/libssh2/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-#include <assert.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#include <libssh2.h>
-#include "testinput.h"
-
-#define FUZZ_ASSERT(COND)                                                     \
-        if(!(COND))                                                           \
-        {                                                                     \
-          fprintf(stderr, "Assertion failed: " #COND "\n%s",                  \
-                  strerror(errno));                                           \
-          assert((COND));                                                     \
-        }
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
-  int socket_fds[2] = {-1, -1};
-  ssize_t written;
-  int rc;
-  LIBSSH2_SESSION *session = NULL;
-  int handshake_completed = 0;
-
-  rc = libssh2_init(0);
-
-  if(rc != 0) {
-    fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
-    goto EXIT_LABEL;
-  }
-
-  // Create a socket pair so data can be sent in.
-  rc = socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds);
-  FUZZ_ASSERT(rc == 0);
-
-  written = send(socket_fds[1], data, size, 0);
-
-  if (written != size)
-  {
-    // Handle whatever error case we're in.
-    fprintf(stderr, "send() of %zu bytes returned %zu (%d)\n",
-            size,
-            written,
-            errno);
-    goto EXIT_LABEL;
-  }
-
-  rc = shutdown(socket_fds[1], SHUT_WR);
-  if (rc != 0)
-  {
-    fprintf(stderr, "socket shutdown failed (%d)\n", rc);
-    goto EXIT_LABEL;
-  }
-
-  // Create a session and start the handshake using the fuzz data passed in.
-  session = libssh2_session_init();
-  if(session) {
-    libssh2_session_set_blocking(session, 1);
-  }
-
-  if(libssh2_session_handshake(session, socket_fds[0])) {
-    goto EXIT_LABEL;
-  }
-
-  // If we get here the handshake actually completed.
-  handshake_completed = 1;
-
-EXIT_LABEL:
-
-  if (session != NULL)
-  {
-    if (handshake_completed)
-    {
-      libssh2_session_disconnect(session,
-                                 "Normal Shutdown, Thank you for playing");
-    }
-
-    libssh2_session_free(session);
-  }
-
-  libssh2_exit();
-
-  close(socket_fds[0]);
-  close(socket_fds[1]);
-
-  return 0;
-}
diff --git a/libssh2/libssh2/tests/ossfuzz/standaloneengine.cc b/libssh2/libssh2/tests/ossfuzz/standaloneengine.cc
deleted file mode 100644
index 175360e4..00000000
--- a/libssh2/libssh2/tests/ossfuzz/standaloneengine.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "testinput.h"
-
-/**
- * Main procedure for standalone fuzzing engine.
- *
- * Reads filenames from the argument array. For each filename, read the file
- * into memory and then call the fuzzing interface with the data.
- */
-int main(int argc, char **argv)
-{
-  int ii;
-  for(ii = 1; ii < argc; ii++)
-  {
-    FILE *infile;
-    printf("[%s] ", argv[ii]);
-
-    /* Try and open the file. */
-    infile = fopen(argv[ii], "rb");
-    if(infile)
-    {
-      uint8_t *buffer = NULL;
-      size_t buffer_len;
-
-      printf("Opened.. ");
-
-      /* Get the length of the file. */
-      fseek(infile, 0L, SEEK_END);
-      buffer_len = ftell(infile);
-
-      /* Reset the file indicator to the beginning of the file. */
-      fseek(infile, 0L, SEEK_SET);
-
-      /* Allocate a buffer for the file contents. */
-      buffer = (uint8_t *)calloc(buffer_len, sizeof(uint8_t));
-      if(buffer)
-      {
-        /* Read all the text from the file into the buffer. */
-        fread(buffer, sizeof(uint8_t), buffer_len, infile);
-        printf("Read %zu bytes, fuzzing.. ", buffer_len);
-
-        /* Call the fuzzer with the data. */
-        LLVMFuzzerTestOneInput(buffer, buffer_len);
-
-        printf("complete !!");
-
-        /* Free the buffer as it's no longer needed. */
-        free(buffer);
-        buffer = NULL;
-      }
-      else
-      {
-        fprintf(stderr,
-                "[%s] Failed to allocate %zu bytes \n",
-                argv[ii],
-                buffer_len);
-      }
-
-      /* Close the file as it's no longer needed. */
-      fclose(infile);
-      infile = NULL;
-    }
-    else
-    {
-      /* Failed to open the file. Maybe wrong name or wrong permissions? */
-      fprintf(stderr, "[%s] Open failed. \n", argv[ii]);
-    }
-
-    printf("\n");
-  }
-}
diff --git a/libssh2/libssh2/tests/ossfuzz/testinput.h b/libssh2/libssh2/tests/ossfuzz/testinput.h
deleted file mode 100644
index 6ab9b515..00000000
--- a/libssh2/libssh2/tests/ossfuzz/testinput.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <inttypes.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
diff --git a/libssh2/libssh2/tests/runner.c b/libssh2/libssh2/tests/runner.c
deleted file mode 100644
index b9f9328d..00000000
--- a/libssh2/libssh2/tests/runner.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright (C) 2016 Alexander Lamaison
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "session_fixture.h"
-
-extern int test(LIBSSH2_SESSION *session);
-
-int main()
-{
-    int exit_code = 1;
-    LIBSSH2_SESSION *session = start_session_fixture();
-    if(session != NULL) {
-        exit_code = (test(session) == 0) ? 0 : 1;
-    }
-    stop_session_fixture();
-    return exit_code;
-}
diff --git a/libssh2/libssh2/tests/session_fixture.c b/libssh2/libssh2/tests/session_fixture.c
deleted file mode 100644
index 5d8fd215..00000000
--- a/libssh2/libssh2/tests/session_fixture.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/* Copyright (C) 2016 Alexander Lamaison
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include "session_fixture.h"
-#include "libssh2_config.h"
-#include "openssh_fixture.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-
-LIBSSH2_SESSION *connected_session = NULL;
-int connected_socket = -1;
-
-static int connect_to_server()
-{
-    int rc;
-    connected_socket = open_socket_to_openssh_server();
-    if(connected_socket <= 0) {
-        return -1;
-    }
-
-    rc = libssh2_session_handshake(connected_session, connected_socket);
-    if(rc != 0) {
-        print_last_session_error("libssh2_session_handshake");
-        return -1;
-    }
-
-    return 0;
-}
-
-void setup_fixture_workdir()
-{
-    char *wd = getenv("FIXTURE_WORKDIR");
-#ifdef FIXTURE_WORKDIR
-    if(!wd) {
-        wd = FIXTURE_WORKDIR;
-    }
-#endif
-    if(!wd) {
-#ifdef WIN32
-        char wd_buf[_MAX_PATH];
-#else
-        char wd_buf[MAXPATHLEN];
-#endif
-        getcwd(wd_buf, sizeof(wd_buf));
-        wd = wd_buf;
-    }
-
-    chdir(wd);
-}
-
-LIBSSH2_SESSION *start_session_fixture()
-{
-    int rc;
-
-    setup_fixture_workdir();
-
-    rc = start_openssh_fixture();
-    if(rc != 0) {
-        return NULL;
-    }
-    rc = libssh2_init(0);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2_init failed (%d)\n", rc);
-        return NULL;
-    }
-
-    connected_session = libssh2_session_init_ex(NULL, NULL, NULL, NULL);
-    libssh2_session_set_blocking(connected_session, 1);
-    if(connected_session == NULL) {
-        fprintf(stderr, "libssh2_session_init_ex failed\n");
-        return NULL;
-    }
-
-    rc = connect_to_server();
-    if(rc != 0) {
-        return NULL;
-    }
-
-    return connected_session;
-}
-
-void print_last_session_error(const char *function)
-{
-    if(connected_session) {
-        char *message;
-        int rc =
-            libssh2_session_last_error(connected_session, &message, NULL, 0);
-        fprintf(stderr, "%s failed (%d): %s\n", function, rc, message);
-    }
-    else {
-        fprintf(stderr, "No session");
-    }
-}
-
-void stop_session_fixture()
-{
-    if(connected_session) {
-        libssh2_session_disconnect(connected_session, "test ended");
-        libssh2_session_free(connected_session);
-        shutdown(connected_socket, 2);
-        connected_session = NULL;
-    }
-    else {
-        fprintf(stderr, "Cannot stop session - none started");
-    }
-
-    stop_openssh_fixture();
-}
diff --git a/libssh2/libssh2/tests/ssh2.c b/libssh2/libssh2/tests/ssh2.c
deleted file mode 100644
index f903e075..00000000
--- a/libssh2/libssh2/tests/ssh2.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/* Self test, based on examples/ssh2.c. */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-# ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 0;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    const char *pubkeyfile = "etc/user.pub";
-    const char *privkeyfile = "etc/user";
-    const char *username = "username";
-    const char *password = "password";
-    int ec = 1;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return -1;
-    }
-#endif
-
-    (void)argc;
-    (void)argv;
-
-    if(getenv("USER"))
-      username = getenv("USER");
-
-    if(getenv ("PRIVKEY"))
-      privkeyfile = getenv("PRIVKEY");
-
-    if(getenv("PUBKEY"))
-      pubkeyfile = getenv("PUBKEY");
-
-    hostaddr = htonl(0x7F000001);
-
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-#ifndef WIN32
-    fcntl(sock, F_SETFL, 0);
-#endif
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(4711);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return 1;
-    }
-
-    /* Create a session instance and start it up
-     * This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    session = libssh2_session_init();
-    if(libssh2_session_startup(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return 1;
-    }
-
-    /* At this point we haven't authenticated,
-     * The first thing to do is check the hostkey's
-     * fingerprint against our known hosts
-     * Your app may have it hard coded, may go to a file,
-     * may present it to the user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    printf("Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        printf("%02X ", (unsigned char)fingerprint[i]);
-    }
-    printf("\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    printf("Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    if(auth_pw & 4) {
-        /* Authenticate by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, pubkeyfile,
-                                               privkeyfile, password)) {
-            printf("\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        else {
-            printf("\tAuthentication by public key succeeded.\n");
-        }
-    }
-    else {
-        printf("No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    /* Request a shell */
-    channel = libssh2_channel_open_session(session);
-    if(!channel) {
-        fprintf(stderr, "Unable to open a session\n");
-        goto shutdown;
-    }
-
-    /* Some environment variables may be set,
-     * It's up to the server which ones it'll allow though
-     */
-    libssh2_channel_setenv(channel, "FOO", "bar");
-
-    /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
-     */
-    if(libssh2_channel_request_pty(channel, "vanilla")) {
-        fprintf(stderr, "Failed requesting pty\n");
-        goto skip_shell;
-    }
-
-    /* Open a SHELL on that pty */
-    if(libssh2_channel_shell(channel)) {
-        fprintf(stderr, "Unable to request shell on allocated pty\n");
-        goto shutdown;
-    }
-
-    ec = 0;
-
-  skip_shell:
-    if(channel) {
-        libssh2_channel_free(channel);
-        channel = NULL;
-    }
-
-  shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    Sleep(1000);
-    closesocket(sock);
-#else
-    sleep(1);
-    close(sock);
-#endif
-
-    return ec;
-}
diff --git a/libssh2/libssh2/tests/ssh2.sh b/libssh2/libssh2/tests/ssh2.sh
deleted file mode 100755
index 07795bb7..00000000
--- a/libssh2/libssh2/tests/ssh2.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/sh
-
-# Written by Simon Josefsson.
-
-# Start sshd, invoke parameters, saving exit code, kill sshd, and
-# return exit code.
-
-srcdir=${srcdir:-$PWD}
-SSHD=${SSHD:-/usr/sbin/sshd}
-
-cmd="./ssh2${EXEEXT}"
-srcdir=`cd "$srcdir"; pwd`
-
-PRIVKEY=$srcdir/etc/user
-export PRIVKEY
-PUBKEY=$srcdir/etc/user.pub
-export PUBKEY
-
-if test -n "$DEBUG"; then
-    libssh2_sshd_params="-d -d"
-fi
-
-chmod go-rwx "$srcdir"/etc/host*
-$SSHD -f /dev/null -h "$srcdir"/etc/host \
-    -o 'Port 4711' \
-    -o 'Protocol 2' \
-    -o "AuthorizedKeysFile $srcdir/etc/user.pub" \
-    -o 'UsePrivilegeSeparation no' \
-    -o 'StrictModes no' \
-    -D \
-    $libssh2_sshd_params &
-sshdpid=$!
-
-trap "kill ${sshdpid}; echo signal killing sshd; exit 1;" EXIT
-
-: "started sshd (${sshdpid})"
-
-sleep 3
-
-: Invoking $cmd...
-eval $cmd
-ec=$?
-: Self-test exit code $ec
-
-: "killing sshd (${sshdpid})"
-kill "${sshdpid}" > /dev/null 2>&1
-trap "" EXIT
-exit $ec
diff --git a/libssh2/libssh2/tests/sshd_fixture.sh.in b/libssh2/libssh2/tests/sshd_fixture.sh.in
deleted file mode 100644
index a76f4338..00000000
--- a/libssh2/libssh2/tests/sshd_fixture.sh.in
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/bin/sh
-
-# Written by Simon Josefsson.
-
-# Start sshd, invoke parameters, saving exit code, kill sshd, and
-# return exit code.
-
-srcdir="@SSHD_TEST_CONFIG_DIR@"
-SSHD="@SSHD_EXECUTABLE@"
-
-cmd="\"$1\""
-
-PRIVKEY=$srcdir/etc/user
-export PRIVKEY
-PUBKEY=$srcdir/etc/user.pub
-export PUBKEY
-
-if test -n "$DEBUG"; then
-    libssh2_sshd_params="-d -d"
-fi
-
-chmod go-rwx "$srcdir"/etc/host*
-"$SSHD" -f /dev/null -h "$srcdir/etc/host" \
-    -o 'Port 4711' \
-    -o 'Protocol 2' \
-    -o "AuthorizedKeysFile \"$srcdir/etc/user.pub\"" \
-    -o 'UsePrivilegeSeparation no' \
-    -o 'StrictModes no' \
-    -D \
-    $libssh2_sshd_params &
-sshdpid=$!
-
-trap "kill ${sshdpid}; echo signal killing sshd; exit 1;" EXIT
-
-: "started sshd (${sshdpid})"
-
-sleep 3
-
-if ! kill -0 ${sshdpid}
-then
-    echo "SSHD exited before test started"
-    exit 1
-fi
-
-: Invoking $cmd...
-eval "$cmd"
-ec=$?
-: Self-test exit code $ec
-
-: "killing sshd (${sshdpid})"
-kill "${sshdpid}" > /dev/null 2>&1
-trap "" EXIT
-exit $ec
diff --git a/libssh2/libssh2/tests/test_agent_forward_succeeds.c b/libssh2/libssh2/tests/test_agent_forward_succeeds.c
deleted file mode 100644
index daf7bd5a..00000000
--- a/libssh2/libssh2/tests/test_agent_forward_succeeds.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-const char *USERNAME = "libssh2"; /* set in Dockerfile */
-const char *KEY_FILE_PRIVATE = "key_rsa";
-const char *KEY_FILE_PUBLIC = "key_rsa.pub"; /* set in Dockerfile */
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    LIBSSH2_CHANNEL *channel;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    channel = libssh2_channel_open_session(session);
-    /* if(channel == NULL) { */
-    /*     printf("Error opening channel\n"); */
-    /*     return 1; */
-    /* } */
-
-    rc = libssh2_channel_request_auth_agent(channel);
-    if(rc != 0) {
-        fprintf(stderr, "Auth agent request for agent forwarding failed, "
-            "error code %d\n", rc);
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_hostkey.c b/libssh2/libssh2/tests/test_hostkey.c
deleted file mode 100644
index e33f68f9..00000000
--- a/libssh2/libssh2/tests/test_hostkey.c
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *EXPECTED_RSA_HOSTKEY =
-    "AAAAB3NzaC1yc2EAAAABIwAAAQEArrr/JuJmaZligyfS8vcNur+mWR2ddDQtVdhHzdKU"
-    "UoR6/Om6cvxpe61H1YZO1xCpLUBXmkki4HoNtYOpPB2W4V+8U4BDeVBD5crypEOE1+7B"
-    "Am99fnEDxYIOZq2/jTP0yQmzCpWYS3COyFmkOL7sfX1wQMeW5zQT2WKcxC6FSWbhDqrB"
-    "eNEGi687hJJoJ7YXgY/IdiYW5NcOuqRSWljjGS3dAJsHHWk4nJbhjEDXbPaeduMAwQU9"
-    "i6ELfP3r+q6wdu0P4jWaoo3De1aYxnToV/ldXykpipON4NPamsb6Ph2qlJQKypq7J4iQ"
-    "gkIIbCU1A31+4ExvcIVoxLQw/aTSbw==";
-
-static const char *EXPECTED_ECDSA_HOSTKEY =
-    "AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBC+/syyeKJD9dC2ZH"
-    "9Q7iJGReR4YM3rUCMsSynkyXojdfSClGCMY7JvWlt30ESjYvxoTfSRGx6WvaqYK/vPoYQ4=";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    size_t len;
-    int type;
-    unsigned int expected_len = 0;
-    char *expected_hostkey = NULL;
-
-    const char *hostkey = libssh2_session_hostkey(session, &len, &type);
-    if(hostkey == NULL) {
-        print_last_session_error("libssh2_session_hostkey");
-        return 1;
-    }
-
-    if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
-        rc = libssh2_base64_decode(session, &expected_hostkey, &expected_len,
-                                   EXPECTED_ECDSA_HOSTKEY,
-                                   strlen(EXPECTED_ECDSA_HOSTKEY));
-    }
-    else if(type == LIBSSH2_HOSTKEY_TYPE_RSA) {
-        rc = libssh2_base64_decode(session, &expected_hostkey, &expected_len,
-                                   EXPECTED_RSA_HOSTKEY,
-                                   strlen(EXPECTED_RSA_HOSTKEY));
-    }
-    else {
-        fprintf(stderr, "Unexpected type of hostkey: %i\n", type);
-        return 1;
-    }
-
-    if(rc != 0) {
-        print_last_session_error("libssh2_base64_decode");
-        return 1;
-    }
-
-    if(len != expected_len) {
-        fprintf(stderr, "Hostkey does not have the expected length %ld!=%d\n",
-                (unsigned long)len, expected_len);
-        return 1;
-    }
-
-    if(memcmp(hostkey, expected_hostkey, len) != 0) {
-        fprintf(stderr, "Hostkeys do not match\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_hostkey_hash.c b/libssh2/libssh2/tests/test_hostkey_hash.c
deleted file mode 100644
index 112b491f..00000000
--- a/libssh2/libssh2/tests/test_hostkey_hash.c
+++ /dev/null
@@ -1,184 +0,0 @@
-#include "session_fixture.h"
-#include "libssh2_config.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *EXPECTED_RSA_HOSTKEY =
-    "AAAAB3NzaC1yc2EAAAABIwAAAQEArrr/JuJmaZligyfS8vcNur+mWR2ddDQtVdhHzdKU"
-    "UoR6/Om6cvxpe61H1YZO1xCpLUBXmkki4HoNtYOpPB2W4V+8U4BDeVBD5crypEOE1+7B"
-    "Am99fnEDxYIOZq2/jTP0yQmzCpWYS3COyFmkOL7sfX1wQMeW5zQT2WKcxC6FSWbhDqrB"
-    "eNEGi687hJJoJ7YXgY/IdiYW5NcOuqRSWljjGS3dAJsHHWk4nJbhjEDXbPaeduMAwQU9"
-    "i6ELfP3r+q6wdu0P4jWaoo3De1aYxnToV/ldXykpipON4NPamsb6Ph2qlJQKypq7J4iQ"
-    "gkIIbCU1A31+4ExvcIVoxLQw/aTSbw==";
-
-static const char *EXPECTED_ECDSA_HOSTKEY =
-    "AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBC+/syyeKJD9dC2ZH"
-    "9Q7iJGReR4YM3rUCMsSynkyXojdfSClGCMY7JvWlt30ESjYvxoTfSRGx6WvaqYK/vPoYQ4=";
-
-static const char *EXPECTED_RSA_MD5_HASH_DIGEST =
-    "0C0ED1A5BB10275F76924CE187CE5C5E";
-
-static const char *EXPECTED_RSA_SHA1_HASH_DIGEST =
-    "F3CD59E2913F4422B80F7B0A82B2B89EAE449387";
-
-static const char *EXPECTED_RSA_SHA256_HASH_DIGEST =
-    "92E3DA49DF3C7F99A828F505ED8239397A5D1F62914459760F878F7510F563A3";
-
-static const char *EXPECTED_ECDSA_MD5_HASH_DIGEST =
-    "0402E4D897580BBC911379CBD88BCD3D";
-
-static const char *EXPECTED_ECDSA_SHA1_HASH_DIGEST =
-    "12FDAD1E3B31B10BABB00F2A8D1B9A62C326BD2F";
-
-static const char *EXPECTED_ECDSA_SHA256_HASH_DIGEST =
-    "56FCD975B166C3F0342D0036E44C311A86C0EAE40713B53FC776369BAE7F5264";
-
-static const int MD5_HASH_SIZE = 16;
-static const int SHA1_HASH_SIZE = 20;
-static const int SHA256_HASH_SIZE = 32;
-
-static void calculate_digest(const char *hash, size_t hash_len, char *buffer,
-                             size_t buffer_len)
-{
-    size_t i;
-    char *p = buffer;
-    char *end = buffer + buffer_len;
-
-    for(i = 0; i < hash_len && p < end; ++i) {
-        p += snprintf(p, end - p, "%02X", (unsigned char)hash[i]);
-    }
-}
-
-int test(LIBSSH2_SESSION *session)
-{
-    char buf[BUFSIZ];
-
-    const char *hostkey;
-    const char *md5_hash;
-    const char *sha1_hash;
-    const char *sha256_hash;
-    int type;
-    size_t len;
-
-    /* these are the host keys under test, they are currently unused */
-    (void)EXPECTED_RSA_HOSTKEY;
-    (void)EXPECTED_ECDSA_HOSTKEY;
-
-    hostkey = libssh2_session_hostkey(session, &len, &type);
-    if(hostkey == NULL) {
-        print_last_session_error("libssh2_session_hostkey");
-        return 1;
-    }
-
-    if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
-
-        md5_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
-        if(md5_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_MD5)");
-            return 1;
-        }
-
-        calculate_digest(md5_hash, MD5_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_ECDSA_MD5_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "ECDSA MD5 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_ECDSA_MD5_HASH_DIGEST);
-            return 1;
-        }
-
-        sha1_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-        if(sha1_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA1)");
-            return 1;
-        }
-
-        calculate_digest(sha1_hash, SHA1_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_ECDSA_SHA1_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "ECDSA SHA1 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_ECDSA_SHA1_HASH_DIGEST);
-            return 1;
-        }
-
-        sha256_hash = libssh2_hostkey_hash(session,
-                                           LIBSSH2_HOSTKEY_HASH_SHA256);
-        if(sha256_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA256)");
-            return 1;
-        }
-
-        calculate_digest(sha256_hash, SHA256_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_ECDSA_SHA256_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "ECDSA SHA256 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_ECDSA_SHA256_HASH_DIGEST);
-            return 1;
-        }
-
-    }
-    else if(type == LIBSSH2_HOSTKEY_TYPE_RSA) {
-
-        md5_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
-        if(md5_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_MD5)");
-            return 1;
-        }
-
-        calculate_digest(md5_hash, MD5_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_RSA_MD5_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "MD5 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_RSA_MD5_HASH_DIGEST);
-            return 1;
-        }
-
-        sha1_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-        if(sha1_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA1)");
-            return 1;
-        }
-
-        calculate_digest(sha1_hash, SHA1_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_RSA_SHA1_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "SHA1 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_RSA_SHA1_HASH_DIGEST);
-            return 1;
-        }
-
-        sha256_hash = libssh2_hostkey_hash(session,
-                                           LIBSSH2_HOSTKEY_HASH_SHA256);
-        if(sha256_hash == NULL) {
-            print_last_session_error(
-                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA256)");
-            return 1;
-        }
-
-        calculate_digest(sha256_hash, SHA256_HASH_SIZE, buf, BUFSIZ);
-
-        if(strcmp(buf, EXPECTED_RSA_SHA256_HASH_DIGEST) != 0) {
-            fprintf(stderr,
-                    "SHA256 hash not as expected - digest %s != %s\n",
-                    buf, EXPECTED_RSA_SHA256_HASH_DIGEST);
-            return 1;
-        }
-    }
-    else {
-        fprintf(stderr, "Unexpected type of hostkey: %i\n", type);
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c b/libssh2/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c
deleted file mode 100644
index 56b1ba54..00000000
--- a/libssh2/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *WRONG_PASSWORD = "i'm not the password";
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruct, int instruct_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    int i;
-    (void)abstract;
-    fprintf(stdout, "Kb-int name: %.*s\n", name_len, name);
-    fprintf(stdout, "Kb-int instruction: %.*s\n", instruct_len, instruct);
-    for(i = 0; i < num_prompts; ++i) {
-        fprintf(stdout, "Kb-int prompt %d: %.*s\n", i, prompts[i].length,
-                prompts[i].text);
-    }
-
-    if(num_prompts == 1) {
-        responses[0].text = strdup(WRONG_PASSWORD);
-        responses[0].length = strlen(WRONG_PASSWORD);
-    }
-}
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "keyboard-interactive") == NULL) {
-        fprintf(stderr,
-                "'keyboard-interactive' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_keyboard_interactive_ex(
-        session, USERNAME, strlen(USERNAME), kbd_callback);
-    if(rc == 0) {
-        fprintf(stderr,
-                "Keyboard-interactive auth succeeded with wrong response\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c b/libssh2/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c
deleted file mode 100644
index 0ccf5dd9..00000000
--- a/libssh2/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "my test password";
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruct, int instruct_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    int i;
-    (void)abstract;
-
-    fprintf(stdout, "Kb-int name: %.*s\n", name_len, name);
-    fprintf(stdout, "Kb-int instruction: %.*s\n", instruct_len, instruct);
-    for(i = 0; i < num_prompts; ++i) {
-        fprintf(stdout, "Kb-int prompt %d: %.*s\n", i, prompts[i].length,
-                prompts[i].text);
-    }
-
-    if(num_prompts == 1) {
-        responses[0].text = strdup(PASSWORD);
-        responses[0].length = strlen(PASSWORD);
-    }
-}
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "keyboard-interactive") == NULL) {
-        fprintf(stderr,
-                "'keyboard-interactive' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_keyboard_interactive_ex(
-        session, USERNAME, strlen(USERNAME), kbd_callback);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_keyboard_interactive_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_password.c b/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_password.c
deleted file mode 100644
index 2b895d08..00000000
--- a/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_password.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *WRONG_PASSWORD = "i'm not the password";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, USERNAME, strlen(USERNAME),
-                                      WRONG_PASSWORD, strlen(WRONG_PASSWORD),
-                                      NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Password auth succeeded with wrong password\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_username.c b/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_username.c
deleted file mode 100644
index b78617a4..00000000
--- a/libssh2/libssh2/tests/test_password_auth_fails_with_wrong_username.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *PASSWORD = "my test password";
-static const char *WRONG_USERNAME = "i dont exist";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, WRONG_USERNAME, strlen(WRONG_USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, WRONG_USERNAME,
-                                      strlen(WRONG_USERNAME), PASSWORD,
-                                      strlen(PASSWORD), NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Password auth succeeded with wrong username\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c b/libssh2/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c
deleted file mode 100644
index 94b86b87..00000000
--- a/libssh2/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "my test password";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, USERNAME, strlen(USERNAME),
-                                      PASSWORD, strlen(PASSWORD), NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_password_ex");
-        return 1;
-    }
-
-    if(libssh2_userauth_authenticated(session) == 0) {
-        fprintf(stderr, "Password auth appeared to succeed but "
-                        "libssh2_userauth_authenticated returned 0\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c b/libssh2/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c
deleted file mode 100644
index dd2d254f..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *KEY_FILE_PRIVATE = "key_dsa_wrong";
-static const char *KEY_FILE_PUBLIC = "key_dsa_wrong.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Public-key auth succeeded with wrong key\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c
deleted file mode 100644
index 187c1313..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_dsa";
-static const char *KEY_FILE_PUBLIC = "key_dsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c
deleted file mode 100644
index 2ea3a369..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ecdsa";
-static const char *KEY_FILE_PUBLIC = "key_ecdsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c
deleted file mode 100644
index c52830d9..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ed25519";
-static const char *KEY_FILE_PUBLIC = "key_ed25519.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
deleted file mode 100644
index a79d1b51..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *KEY_FILE_ED25519_PRIVATE = "key_ed25519";
-
-int read_file(const char *path, char **buf, size_t *len);
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    char *buffer = NULL;
-    size_t len = 0;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    if(read_file(KEY_FILE_ED25519_PRIVATE, &buffer, &len)) {
-        fprintf(stderr, "Reading key file failed.");
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_frommemory(session,
-                                               USERNAME, strlen(USERNAME),
-                                               NULL, 0,
-                                               buffer, len,
-                                               NULL);
-
-    free(buffer);
-
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
-
-int read_file(const char *path, char **out_buffer, size_t *out_len)
-{
-    FILE *fp = NULL;
-    char *buffer = NULL;
-    size_t len = 0;
-
-    if(out_buffer == NULL || out_len == NULL || path == NULL) {
-        fprintf(stderr, "invalid params.");
-        return 1;
-    }
-
-    *out_buffer = NULL;
-    *out_len = 0;
-
-    fp = fopen(path, "r");
-
-    if(!fp) {
-        fprintf(stderr, "File could not be read.");
-        return 1;
-    }
-
-    fseek(fp, 0L, SEEK_END);
-    len = ftell(fp);
-    rewind(fp);
-
-    buffer = calloc(1, len + 1);
-    if(!buffer) {
-        fclose(fp);
-        fprintf(stderr, "Could not alloc memory.");
-        return 1;
-    }
-
-    if(1 != fread(buffer, len, 1, fp)) {
-        fclose(fp);
-        free(buffer);
-        fprintf(stderr, "Could not read file into memory.");
-        return 1;
-    }
-
-    fclose(fp);
-
-    *out_buffer = buffer;
-    *out_len = len;
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c
deleted file mode 100644
index 553023a9..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ed25519_encrypted";
-static const char *KEY_FILE_PUBLIC = "key_ed25519_encrypted.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        PASSWORD);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c
deleted file mode 100644
index ba98ac7c..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa_encrypted";
-static const char *KEY_FILE_PUBLIC = "key_rsa_encrypted.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        PASSWORD);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c
deleted file mode 100644
index 0cf2a633..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa";
-static const char *KEY_FILE_PUBLIC = "key_rsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
deleted file mode 100644
index a067d729..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa_openssh";
-static const char *KEY_FILE_PUBLIC = "key_rsa_openssh.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c b/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c
deleted file mode 100644
index 10b33cbb..00000000
--- a/libssh2/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "signed_key_ecdsa";
-static const char *KEY_FILE_PUBLIC = "signed_key_ecdsa-cert.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/libssh2/vms/libssh2_config.h b/libssh2/libssh2/vms/libssh2_config.h
deleted file mode 100644
index b8f73e27..00000000
--- a/libssh2/libssh2/vms/libssh2_config.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#ifndef LIBSSH2_CONFIG_H
-#ifdef __VMS
-
-#define LIBSSH2_CONFIG_H
-
-/* VMS specific libssh2_config.h
- */
-
-#define ssize_t SSIZE_T
-
-typedef unsigned int uint32_t ;
-typedef unsigned int socklen_t; /* missing in headers on VMS */
-
-/* Have's */
-
-#define HAVE_UNISTD_H
-#define HAVE_STDLIB_H
-#define HAVE_INTTYPES_H
-#define HAVE_SYS_TIME_H
-#define HAVE_SELECT
-#define HAVE_UIO
-
-#define HAVE_SYS_SOCKET.H
-#define HAVE_NETINET_IN_H
-#define HAVE_ARPA_INET_H
-
-#define HAVE_GETTIMEOFDAY 1
-
-#define POSIX_C_SOURCE
-
-/* Enable the possibility of using tracing */
- 
-#define LIBSSH2DEBUG 1
-
-/* For selection of proper block/unblock function in session.c */
-
-#define HAVE_FIONBIO
-
-#include <stropts.h>
-
-/* In VMS TCP/IP Services and some BSD variants SO_STATE retrieves 
- * a bitmask revealing amongst others the blocking state of the 
- * socket. On VMS the bits are undocumented, but  SS_NBIO
- * works, I did not test the other bits. Below bitdefs are 
- * from Berkely source socketvar.h at   
- * http://ftp.fibranet.cat/UnixArchive/PDP-11/Trees/2.11BSD/sys/h/socketvar.h
- *  Socket state bits.
- *  #define SS_NOFDREF          0x001    no file table ref any more 
- *  #define SS_ISCONNECTED      0x002    socket connected to a peer 
- *  #define SS_ISCONNECTING     0x004    in process of connecting to peer 
- *  #define SS_ISDISCONNECTING  0x008    in process of disconnecting 
- *  #define SS_CANTSENDMORE     0x010    can't send more data to peer 
- *  #define SS_CANTRCVMORE      0x020    can't receive more data from peer 
- *  #define SS_RCVATMARK        0x040    at mark on input 
- *  #define SS_PRIV             0x080    privileged for broadcast, raw... 
- *  #define SS_NBIO             0x100    non-blocking ops 
- *  #define SS_ASYNC            0x200    async i/o notify 
- *
- */
-
-#ifdef SO_STATE
-
-/* SO_STATE is defined in stropts.h  by DECC
- * When running on Multinet, SO_STATE renders a protocol
- * not started error. Functionally this has no impact,
- * apart from libssh2 not being able to restore the socket
- * to the proper blocking/non-blocking state.  
- */
-
-#define SS_NBIO         0x100 
-
-#endif
-
-/* Use OpenSSL */
-#define LIBSSH2_OPENSSL 1
-
-/* Compile in zlib support. We link against gnv$libzshr, as available
- * from https://sourceforge.net/projects/vms-ports/files/.
- */
-
-#define LIBSSH2_HAVE_ZLIB
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-
-#define LIBSSH2_DH_GEX_NEW 1
-
-#endif /* __VMS */
-#endif /* LIBSSH2_CONFIG_H */                             
diff --git a/libssh2/libssh2/vms/libssh2_make_example.dcl b/libssh2/libssh2/vms/libssh2_make_example.dcl
deleted file mode 100644
index af4116dd..00000000
--- a/libssh2/libssh2/vms/libssh2_make_example.dcl
+++ /dev/null
@@ -1,125 +0,0 @@
-$!
-$!
-$ olddir = f$environment("default")
-$ on control_y then goto YExit
-$!
-$ gosub Init
-$ if .not. init_status then goto YExit
-$!
-$ if what .eqs. "ALL"
-$ then
-$	call MakeAll
-$ else
-$	call Make 
-$endif
-$!
-$YExit:
-$ set noon
-$! deassign exadir
-$! deassign objdir
-$ delete 'link_opts';*
-$ set default 'olddir'
-$exit 
-
-$MakeAll: subroutine
-$!
-$ set noon
-$Loop:
-$ this = f$search("exadir:*.c;0")
-$ if this .eqs. "" then goto EndLoop
-$!
-$ what = f$parse( this,,,"name")
-$ if what .eqs. "x11" then goto loop ! not portable yet
-$ call Make
-$!
-$ goto Loop
-$EndLoop:
-$!
-$exit
-$endsubroutine
-
-
-$Make: subroutine
-$!
-$ set noon
-$!
-$ cc 'cc_include' 'cc_flags'/object=objdir:'what' exadir:'what'
-$ sev = $severity
-$ if sev .and. 2 
-$ then
-$	say "Error compiling ''what', not linked."
-$ else
-$ 	if .not. (sev .and. 1)  
-$ 	then
-$		say "Compile warnings in  ''what'"
-$ 	endif
-$  link/exe='what'.exe objdir:'what'.obj, 'link_opts'/opt
-$ endif
-$!
-$!
-$End:
-$ delete objdir:'what'.obj;*
-$exit
-$endsubroutine 
-
-
-$Init: 
-$!
-$!
-$ init_status = 1
-$ thisid = f$integer( %x'f$getjpi(0,"pid")') + "''f$cvtime(,,"second")'"
-$ mdir   = f$environment("procedure") 
-$ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
-$ set default 'mdir'
-$!
-$ objdir = "[.example_objects]"
-$ exadir = "[-.example]"
-$!
-$ objdirfile = objdir - "[." - "]" + ".dir"
-$ if f$search( objdirfile ) .eqs. ""
-$ then
-$	create/directory 'objdir'
-$ endif
-$!
-$ define objdir 'objdir'
-$ define exadir 'exadir'
-$!
-$ cc_include = "/include=([],[-.include])"
-$ cc_flags   = "/name=shortened/show=all/define=(_USE_STD_STAT=1)"
-$ link_opts  = "objdir:libssh2_''thisid'.opt"
-$!
-$!
-$ what = "''p1'" 
-$ if what .eqs. "" .or. f$edit(p1,"trim,collapse,upcase") .eqs. "ALL" 
-$ then 
-$	what = "ALL"
-$ else
-$	what = f$parse(what,,,"name")
-$	if f$search("exadir:''what'.c") .eqs. ""
-$	then 
-$		write sys$output "Can't make ''what'"
-$		init_status = 0
-$	endif
-$ endif
-$!
-$ currentlib = f$search("libssh2*.exe")
-$!
-$ define libssh2 'currentlib'
-$!
-$ how  = "''p2'"
-$ if how .eqs. "" .or. f$edit(p2,"trim,collapse,upcase") .eqs. "STATIC" 
-$ then
-$ 	open/write lout 'link_opts'
-$ 	write lout "libssh2.olb/lib"
-$ 	write lout "sys$share:ssl$libcrypto_shr32.exe/share"
-$ 	write lout "sys$share:ssl$libssl_shr32.exe/share"
-$ 	write lout "gnv$libzshr/share"
-$ 	close lout
-$ else
-$	how = "SHARED"
-$ 	open/write lout 'link_opts'
-$ 	write lout "libssh2/share"
-$ 	close lout
-$ endif 
-$!
-$return
diff --git a/libssh2/libssh2/vms/libssh2_make_help.dcl b/libssh2/libssh2/vms/libssh2_make_help.dcl
deleted file mode 100644
index 652671da..00000000
--- a/libssh2/libssh2/vms/libssh2_make_help.dcl
+++ /dev/null
@@ -1,95 +0,0 @@
-$!
-$!
-$!
-$ olddir = f$environment( "default" )
-$ on control_y then goto End
-$ on error then goto End
-$!
-$ gosub Init
-$!
-$ man2help sys$input: libssh2.hlp -b 1
-
-LIBSSH2
-
-OpenVMS port of the libssh2 library, which provides an
-API to implement client SSH communication.
-
-License information is available at the Copying subtopic.
-
-$!
-$ open/append mh libssh2.hlp
-$ write mh helpversion
-$ close mh
-$!
-$ man2help -a [-]README.; libssh2.hlp        -b 2
-$ man2help -a [-]COPYING.; libssh2.hlp       -b 2
-$ man2help -a [-]NEWS.; libssh2.hlp          -b 2
-$ man2help -a [-]RELEASE-NOTES.; libssh2.hlp -b 2
-$ man2help -a [-.docs]AUTHORS.; libssh2.hlp  -b 2
-$ man2help -a [-.docs]BINDINGS.; libssh2.hlp -b 2
-$ man2help -a [-.docs]HACKING.; libssh2.hlp  -b 2
-$ if f$search("[]HACKING_CRYPTO.") .nes. "" then delete []HACKING_CRYPTO.;*
-$ copy [-.docs]HACKING-CRYPTO; []HACKING_CRYPTO.
-$ man2help -a []HACKING_CRYPTO.; libssh2.hlp -b 2
-$ man2help -a [-.docs]TODO.; libssh2.hlp     -b 2
-$!
-$ man2help -a sys$input: libssh2.hlp         -b 2
-
-API_Reference
-
-Reference of all implemented API calls in
-libssh2.
-
-$!
-$ man2help -a [-.docs]*.3 libssh2.hlp -b 3 -p
-$!
-$ library/help/create libssh2.hlb libssh2.hlp
-$!
-$End:
-$ set default 'olddir'
-$exit
-$!
-$!-------------------------------------------------------
-$!
-$Init:
-$!
-$ thisdir = f$environment( "procedure" )
-$ thisdir = f$parse(thisdir,,,"device") + f$parse(thisdir,,,"directory")
-$ set default 'thisdir'
-$!
-$ say = "write sys$output"
-$!
-$ pipe search [-.include]*.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
-       define/job majorv &l )
-$ pipe search [-.include]*.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
-       define/job minorv &l )
-$ pipe search [-.include]*.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
-       define/job patchv &l )
-$!
-$ majorv   = f$trnlnm("majorv")
-$ minorv   = f$integer(f$trnlnm("minorv"))
-$ patchv   = f$integer( f$trnlnm("patchv"))
-$!
-$ helpversion = "This help library is based on build version ''majorv'.''minorv'.''patchv' of libssh2."
-$!
-$ deassign/job majorv
-$ deassign/job minorv
-$ deassign/job patchv
-$!
-$ if f$search( "man2help.exe" ) .eqs. ""
-$ then
-$   cc man2help
-$   link man2help
-$ endif
-$!
-$ man2help := $'thisdir'man2help.exe
-$!
-$ if f$search("libssh2.hlp") .nes. ""
-$ then
-$   delete libssh2.hlp;*
-$ endif
-$ if f$search("libssh2.hlb") .nes. ""
-$ then
-$   delete libssh2.hlb;*
-$ endif
-$return
diff --git a/libssh2/libssh2/vms/libssh2_make_kit.dcl b/libssh2/libssh2/vms/libssh2_make_kit.dcl
deleted file mode 100644
index 6a149588..00000000
--- a/libssh2/libssh2/vms/libssh2_make_kit.dcl
+++ /dev/null
@@ -1,222 +0,0 @@
-$!
-$ olddir = f$environment("default")
-$ on error then goto End
-$!
-$ gosub Init
-$!
-$ call WriteProductDescriptionFile
-$ call WriteProductTextFile
-$!
-$! backup tree
-$!
-$ backup [-...]*.*;0/excl=([]*.exe,*.obj,*.opt,*.hlp,*.hlb,*.bck,*.com,*.pcsi*) -
-    libssh2-'versionname''datename'_src.bck/save
-$ purge libssh2-'versionname''datename'_src.bck
-$!
-$! backup examples
-$!
-$ backup [-.example]*.c;0 libssh2_examples-'versionname''datename'.bck/save
-$ dire  libssh2_examples-'versionname''datename'.bck
-$ purge libssh2_examples-'versionname''datename'.bck
-$!
-$ set default [-]
-$!
-$ defdir  = f$environment( "default" )
-$ thisdev = f$parse(defdir,,,"device","no_conceal") 
-$ thisdir = f$parse(defdir,,,"directory","no_conceal") - "][" - "][" - "][" - "]["
-$!
-$ libssh2_kf = thisdev + thisdir 
-$ libssh2_kf = libssh2_kf - "]" + ".]"
-$!
-$ set default 'mdir'
-$!
-$ define/translation_attributes=concealed libssh2_kf 'libssh2_kf'
-$!
-$ product package libssh2 - 
-    /base='arch' - 
-    /producer=jcb -
-    /source=[] - ! where to find PDF and PTF 
-    /destination=[] - ! where to put .PCSI file 
-    /material=libssh2_kf:[000000...] -      ! where to find product material 
-    /version="''vms_majorv'.''minorv'-''patchv'''datename'" -
-    /format=sequential 
-$!
-$End:
-$!
-$ set noon
-$ if f$search("*.pcsi$desc;*") .nes. "" then delete *.pcsi$desc;*
-$ if f$search("*.pcsi$text;*") .nes. "" then delete *.pcsi$text;*
-$ if f$search("libssh2-''versionname'''datename'_src.bck;*") .nes. "" then delete libssh2-'versionname''datename'_src.bck;*
-$ if f$search("libssh2_examples-''versionname'''datename'.bck;*") .nes. "" then delete libssh2_examples-'versionname''datename'.bck;*
-$!
-$ if f$trnlnm("libssh2_kf") .nes. "" then deassign libssh2_kf
-$ set default 'olddir'
-$!
-$exit 
-$!
-$!--------------------------------------------------------------------------------
-$!
-$Init:
-$ set process/parse=extended
-$!
-$ say    = "write sys$output"
-$!
-$ mdir   = f$environment("procedure") 
-$ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
-$!
-$ set default 'mdir'
-$!
-$ pipe search [-.include]*.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job majorv &l )
-$ pipe search [-.include]*.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job minorv &l )
-$ pipe search [-.include]*.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job patchv &l )
-$!
-$ majorv   = f$trnlnm("majorv")
-$ minorv   = f$integer(f$trnlnm("minorv")) 
-$ patchv   = f$integer( f$trnlnm("patchv"))
-$!
-$ deassign/job majorv
-$ deassign/job minorv
-$ deassign/job patchv
-$!
-$ vms_majorv =  f$trnlnm("vms_majorv")
-$ if vms_majorv .eqs. "" then vms_majorv = majorv
-$!
-$ arch = "UNKNOWN"
-$ if f$getsyi("arch_type") .eq. 2 then arch = "AXPVMS"
-$ if f$getsyi("arch_type") .eq. 3 then arch = "I64VMS"
-$!
-$ if arch .eqs. "UNKNOWN"
-$ then
-$   say "Unsupported or unknown architecture, only works on Alpha and Itanium"
-$   exit 2
-$ endif
-$!
-$! is this a proper release or a daily snapshot?
-$! crummy, but should work.
-$!
-$ daily = "TRUE"
-$ firstdash     = f$locate("-",mdir)
-$ restdir       = f$extract( firstdash + 1, 80, mdir)
-$ seconddash    = f$locate("-", restdir)
-$ if seconddash .ge. f$length( restdir )
-$ then
-$   daily    = "FALSE"
-$   datename = "Final"
-$ else
-$   datename = "D" + f$extract(seconddash+1,8,restdir)   
-$ endif
-$!
-$ if daily 
-$ then
-$   productname = "JCB ''arch' LIBSSH2 V''vms_majorv'.''minorv'-''patchv'''datename'"
-$ else
-$   productname = "JCB ''arch' LIBSSH2 V''vms_majorv'.''minorv'-''patchv'''datename'"
-$ endif
-$!
-$ productfilename  = "JCB-''arch'-LIBSSH2-" + f$fao("V!2ZL!2ZL-!2ZL!AS-1", f$integer(vms_majorv),minorv,patchv,datename)
-$!
-$ versionname   = "''vms_majorv'_''minorv'_''patchv'"
-$!
-$return
-$!
-$!--------------------------------------------------------------------------------
-$!
-$WriteProductDescriptionFile: subroutine
-$!
-$ open/write pd 'productfilename'.PCSI$DESC
-$!
-$ write pd "product ''productname' full ;"
-$ write pd "    software DEC ''arch' VMS ;"
-$ write pd "    if (not <software DEC ''arch' VMS version minimum V8.3>) ;
-$ write pd "        error NEED_VMS83 ;"
-$ write pd "    end if ;"
-$ write pd "    software HP ''arch' SSL version minimum V1.3;"
-$ write pd "    if (not <software HP ''arch' SSL version minimum V1.3>) ;
-$ write pd "        error NEED_SSL ;"
-$ write pd "    end if ;"
-$ write pd "    execute preconfigure (""set process/parse_type=extended"");"
-$ write pd "    execute postinstall (""set process/parse_type=extended"","
-$ write pd "    ""rename pcsi$destination:[gnv]usr.dir usr.DIR"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr]include.dir include.DIR"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.include]libssh2.dir libssh2.DIR"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.include.libssh2]libssh2.h libssh2.h"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.include.libssh2]libssh2_publickey.h libssh2_publickey.h"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.include.libssh2]libssh2_sftp.h libssh2_sftp.h"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.include.libssh2]libssh2_config.h libssh2_config.h"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr]lib.dir lib.DIR"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.lib]gnv$libssh2_''versionname'.exe gnv$libssh2_''versionname'.exe"","
-$ write pd "    ""rename pcsi$destination:[gnv.usr.share.doc.libssh2]libssh2.hlb libssh2.hlb"");"
-$ write pd "    information RELEASE_NOTES phase after ;"
-$ write pd "    option EXAMPLE default 0 ;"
-$ write pd "     directory ""[gnv.usr.share.doc.libssh2.examples]"" ;"
-$ write pd "     file ""[gnv.usr.share.doc.libssh2.examples]libssh2_examples-''versionname'''datename'.bck"";"
-$ write pd "    end option ;"
-$ write pd "    option SOURCE default 0 ;"
-$ write pd "     directory ""[gnv.common_src]"" ;"
-$ write pd "     file ""[gnv.common_src]libssh2-''versionname'''datename'_src.bck"";"
-$ write pd "    end option ;"
-$ write pd "    directory ""[gnv]"" ;"
-$ write pd "    directory ""[gnv.usr]"" ;"
-$ write pd "    directory ""[gnv.usr.lib]"" ;"
-$ write pd "    directory ""[gnv.usr.include]"" ;"
-$ write pd "    directory ""[gnv.usr.include.libssh2]"" ;"
-$ write pd "    directory ""[gnv.usr.share]"" ;"
-$ write pd "    directory ""[gnv.usr.share.doc]"" ;"
-$ write pd "    directory ""[gnv.usr.share.doc.libssh2]"" ;"
-$ write pd "    file ""[gnv.usr.include.libssh2]libssh2.h"" source ""[include]libssh2.h"";"
-$ write pd "    file ""[gnv.usr.include.libssh2]libssh2_publickey.h"" source ""[include]libssh2_publickey.h"";"
-$ write pd "    file ""[gnv.usr.include.libssh2]libssh2_sftp.h"" source ""[include]libssh2_sftp.h"";"
-$ write pd "    file ""[gnv.usr.include.libssh2]libssh2_config.h"" source ""[vms]libssh2_config.h"";"
-$ write pd "    file ""[gnv.usr.share.doc.libssh2]libssh2.hlb"" source ""[vms]libssh2.hlb"";"
-$ write pd "    file ""[gnv.usr.share.doc.libssh2]libssh2-''versionname'.news"" source ""[000000]NEWS."";"
-$ write pd "    file ""[gnv.usr.share.doc.libssh2]libssh2-''versionname'.release_notes"" source ""[vms]readme.vms"";"
-$ write pd "    file ""[gnv.usr.lib]gnv$libssh2_''versionname'.exe"" source ""[vms]libssh2_''versionname'.exe"";"
-$ write pd "end product ;"
-$ close pd
-$exit 
-$endsubroutine
-$!
-$!--------------------------------------------------------------------------------
-$!
-$WriteProductTextFile: subroutine
-$!
-$ open/write pt 'productfilename'.PCSI$TEXT
-$ write pt "=PRODUCT ''productname' Full"
-$ write pt "1 'PRODUCER"
-$ write pt "=prompt libssh2 is an open source product ported to VMS by Jose Baars"
-$ write pt "This software product is provided with no warranty."
-$ write pt "For license information see the LIBSSH2 help library."
-$ write pt "1 'PRODUCT"
-$ write pt "=prompt JCB LIBSSH2 for OpenVMS"
-$ write pt ""
-$ write pt "libssh2 is an open source client side library that aims to implement"
-$ write pt "the SSH protocol. This is the OpenVMS port of that library."
-$ write pt "Further information at https://www.libssh2.org."
-$ write pt ""
-$ write pt "1 NEED_VMS83"
-$ write pt "=prompt OpenVMS 8.3 or later is not installed on your system."
-$ write pt "This product requires OpenVMS 8.3 or later to function."
-$ write pt ""
-$ write pt "1 NEED_SSL"
-$ write pt "=prompt HP SSL 1.3 or later is not installed on your system."
-$ write pt "This product requires HP SSL 1.3 or later to function."
-$ write pt ""
-$ write pt "1 RELEASE_NOTES"
-$ write pt "=prompt Release notes and the libssh2 help library are available in [gnv.usr.share.doc.libssh2] directory."
-$ write pt ""
-$ write pt "1 EXAMPLE"
-$ write pt "=prompt Do you want the libssh2 C programming examples ? "
-$ write pt "The libssh2 coding examples will be available in backup saveset "
-$ write pt "[gnv.usr.share.doc.libssh2.examples]libssh2_examples_''versionname'.bck"
-$ write pt ""
-$ write pt "1 SOURCE"
-$ write pt "=prompt Do you want the complete libssh2 source tree ? "
-$ write pt "The libssh2 source tree will be available in backup saveset "
-$ write pt "[gnv.common_src]libssh2_''versionname'''datename'_src.bck"
-$close pt
-$exit
-$ endsubroutine
-
diff --git a/libssh2/libssh2/vms/libssh2_make_lib.dcl b/libssh2/libssh2/vms/libssh2_make_lib.dcl
deleted file mode 100644
index 56d168f2..00000000
--- a/libssh2/libssh2/vms/libssh2_make_lib.dcl
+++ /dev/null
@@ -1,345 +0,0 @@
-$!
-$!
-$ olddir = f$environment("default")
-$ on control_y then goto YExit
-$!
-$ gosub Init
-$ if .not. init_status then goto YExit
-$!
-$ call CompileAll
-$ call BuildTransferVectors
-$ call LinkShared
-$!
-$ call Cleanup
-$!
-$YExit:
-$ set noon
-$!
-$ deassign srcdir
-$ if f$search("objdir:*.*;*") .nes. "" then delete objdir:*.*;*
-$ deassign objdir
-$ delete library_objects.dir;*
-$!
-$ set default 'olddir'
-$exit 
-$!
-$!---------------------------------------------------------------------
-$!
-$Init: 
-$!
-$!
-$ init_status = 1
-$ thisid = f$integer( %x'f$getjpi(0,"pid")') 
-$ mdir   = f$environment("procedure") 
-$ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
-$ set default 'mdir'
-$!
-$ objdir = "[.library_objects]"
-$ srcdir = "[-.src]"
-$!
-$ objdirfile = objdir - "[." - "]" + ".dir"
-$ if f$search( objdirfile ) .eqs. ""
-$ then
-$   create/directory 'objdir'
-$ endif
-$!
-$ define objdir 'objdir'
-$ define srcdir 'srcdir'
-$!
-$ cc_include = "/include=([],[-.include],""/gnv$zlib_include"")"
-$ cc_define = "/DEFINE=(_USE_STD_STAT=1)"
-$ link_opts  = "objdir:libssh2_''thisid'.opt"
-$!
-$ pipe search [-.include]libssh2.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job majorv &l )
-$ pipe search [-.include]libssh2.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job minorv &l )
-$ pipe search [-.include]libssh2.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
-       define/job patchv &l )
-$!
-$ majorv   = f$trnlnm("majorv")
-$ minorv   = f$integer(f$trnlnm("minorv")) 
-$ patchv   = f$integer( f$trnlnm("patchv"))
-$!
-$ OLBONLY = "FALSE"
-$ if p1 .eqs. "OLBONLY"
-$ then
-$   OLBONLY = "TRUE"
-$ endif
-$!
-$ deassign/job majorv
-$ deassign/job minorv
-$ deassign/job patchv
-$!
-$return
-$!
-$!---------------------------------------------------------------------
-$!
-$Cleanup: subroutine
-$!
-$ set noon
-$ purge *.opt
-$ purge *.olb
-$ purge *.exe
-$! 
-$exit 1
-$endsubroutine
-$!
-$!---------------------------------------------------------------------
-$!
-$LinkShared: subroutine
-$!
-$!
-$!
-$ cversion = f$fao("!3ZL",minorv)  + f$fao("!3ZL",patchv)
-$!
-$! General linking options in link_libssh2_version...opt
-$! Vectors in link_libssh2_vectors...opt
-$!
-$ open/write uitv link_libssh2_version_'majorv'_'minorv'_'patchv'.opt
-$ write uitv "GSMATCH=LEQUAL,''majorv',''cversion'"
-$ write uitv "IDENTIFICATION=""LIBSSH2 ''majorv'.''minorv'.''patchv'"""
-$ write uitv "sys$share:ssl$libcrypto_shr32.exe/share"
-$ write uitv "sys$share:ssl$libssl_shr32.exe/share"
-$ write uitv "gnv$libzshr/share"
-$ close uitv
-$! 
-$ link/shared/exe=libssh2_'majorv'_'minorv'_'patchv'.exe -
-    libssh2.olb/lib, -
-    link_libssh2_version_'majorv'_'minorv'_'patchv'.opt/opt, -
-    link_libssh2_vectors_'majorv'_'minorv'_'patchv'.opt/opt
-$!
-$exit
-$endsubroutine
-$!
-$!---------------------------------------------------------------------
-$!
-$CompileAll: subroutine
-$!
-$ set noon
-$!
-$ if f$search("objdir:*.obj;*") .nes "" 
-$ then 
-$   delete objdir:*.obj;*
-$ endif
-$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$ then 
-$   delete [.cxx_repository]cxx$demangler_db.;*
-$ endif
-$!
-$! Compile all .c files in [-.src], first as_is
-$! and then as default all uppercase names
-$! and add the resulting object to object libraries
-$! libssh2_up.olb and libssh2_as_is.olb.
-$!
-$ case = 0
-$ if OLBONLY then case = 1
-$CaseLoop:
-$!
-$ if case .eq. 0 
-$ then!camel case names 
-$   cc_flags = "/names=(shortened,as_is)''cc_define'"
-$   objlib = "libssh2_asis.olb"
-$ endif
-$!
-$ if case .eq. 1 
-$ then!uppercase names 
-$   if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$   then 
-$      rename [.cxx_repository]cxx$demangler_db.; *.lowercase
-$      purge  [.cxx_repository]cxx$demangler_db.lowercase
-$   endif
-$!
-$   cc_flags = "/names=(shortened)''cc_define'"
-$   objlib = "libssh2_up.olb"
-$ endif
-$!
-$ if f$search("''objlib';*") .nes. "" then delete 'objlib';*
-$ library/create 'objlib'
-$!
-$Loop:
-$ this = f$search("srcdir:*.c;0")
-$ if this .eqs. "" then goto EndLoop
-$!
-$ what = f$parse( this,,,"name")
-$!
-$ call CompileAndAdd
-$!
-$ goto Loop
-$EndLoop:
-$ case = case + 1
-$ delete objdir:*.obj;*
-$ if case .lt 2 then goto CaseLoop
-$!
-$ rename libssh2_up.olb libssh2.olb
-$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$ then 
-$    rename [.cxx_repository]cxx$demangler_db.; *.uppercase
-$    purge  [.cxx_repository]cxx$demangler_db.uppercase
-$ endif
-$!
-$ if OLBONLY then exit 4
-$!
-$! For each function that is too long, create a global symbol
-$! low$'shortened-uppercase-name' with as value lowercase shortened
-$! name in it, so we can add the proper lower or mixed case 
-$! shortened name later when building the transfer vectors 
-$! for the shared image.
-$! This is to prevent two very long similar function names 
-$! that are shortened getting mixed up when sorted alphabetically.
-$!
-$ inputfile = "[.cxx_repository]cxx$demangler_db.lowercase"
-$ gosub GetShortened
-$!
-$ inputfile =  "[.cxx_repository]cxx$demangler_db.uppercase"
-$ gosub GetShortened
-$!
-$exit
-$!
-$GetShortened:
-$!
-$ open/read s 'inputfile'
-$ namecount = 0
-$ReadLoop:
-$!
-$ read/end=endreadloop s regel
-$!
-$ shortname = f$element(0,"$",regel) + "$"
-$ longname  = f$element(1,"$",regel)
-$!
-$ symvalue = ""
-$!
-$ if shortname .eqs. f$edit(shortname,"upcase")
-$ then
-$!  this is an uppercase shortname, add it 
-$   symname  = "u$''longname'"
-$   symvalue = "''shortname'"
-$   low$'shortname' == l$'longname'
-$!
-$   delete/symbol l$'longname'
-$!
-$ else
-$!  this is an lowercase shortname
-$   symname  = "l$''longname'"
-$   symvalue = "''shortname'"
-$   'symname' = "''symvalue'"
-$ endif
-$!
-$ namecount = namecount + 1
-$!
-$ goto ReadLoop
-$EndReadLoop:
-$!
-$close s
-$return
-$!
-$endsubroutine
-$!
-$!---------------------------------------------------------------------
-$!
-$CompileAndAdd: subroutine
-$!
-$ on error then goto End
-$!
-$ cc /warn=disable=longextern/lis=objdir:/show=all 'cc_include' 'cc_flags'/object=objdir:'what'.obj srcdir:'what'.c
-$ library/insert 'objlib' objdir:'what'.obj
-$!
-$End:
-$exit
-$endsubroutine 
-$!
-$!---------------------------------------------------------------------
-$!
-$BuildTransferVectors: subroutine
-$!
-$! Do a balanced read of the uppercase library names
-$! and the mixed case library names, and build the
-$! transfer vectors with uppercase entry points 
-$! with an alternative in mixed case.
-$! For shortened names, use the low$* symbols
-$! to avoid being fooled by the sort.
-$!
-$ thislib = "libssh2.olb"
-$ library/lis=libu.'thisid'/names libssh2.olb
-$ library/lis=lib_asisu.'thisid'/names libssh2_asis.olb
-$!
-$! case blind sort of all modules in both the uppercase
-$! as the case sensitive object library.
-$!
-$ sort libu.'thisid' lib.'thisid'/spec=sys$input
-/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD) 
-$ sort lib_asisu.'thisid' lib_asis.'thisid'/spec=sys$input
-/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD) 
-$!
-$ open/read  in  lib.'thisid'
-$ open/read  inasis  lib_asis.'thisid'
-$ open/write uit link_libssh2_vectors_'majorv'_'minorv'_'patchv'.opt
-$!
-$ write uit "CASE_SENSITIVE=YES"
-$ write uit "SYMBOL_VECTOR= ( -"
-$!
-$ mode = 0
-$ uitregel = ""
-$!
-$ReadLoop:
-$!
-$ read/end=ReadAsis in regel
-$ReadAsis:
-$ read/end=EndReadLoop inasis asisregel
-$!
-$ regel     = f$edit( regel, "trim,compress" )
-$ asisregel = f$edit( asisregel, "trim,compress" )
-$!
-$ if f$element(0," ",regel) .eqs. "Module" .or. -
-     f$extract(0,1,regel)   .eqs. "_" .or. -
-     f$element(1," ",regel) .nes. " " .or. -
-     regel .eqs. ""
-$ then
-$   goto ReadLoop
-$ endif
-$!
-$ if uitregel .nes. "" .and. mode .eq. 1
-$ then
-$   write uit "''uitregel'=PROCEDURE, -" 
-$   write uit "''uitasis'/''uitregel'=PROCEDURE, -" 
-$!
-$   uitregel = ""
-$   uitasis  = ""
-$ endif 
-$!
-$ uitregel = regel
-$ if f$type( low$'uitregel' ) .nes. ""
-$ then
-$   uitasis = low$'uitregel'
-$   delete/symbol/global low$'uitregel'
-$ else
-$   uitasis  = asisregel
-$ endif
-$!
-$ mode = 1
-$!
-$ goto ReadLoop
-$EndreadLoop:
-$! 
-$! To get the closing brace after the last procedure
-$! keyword.
-$!
-$ if uitregel .nes. ""
-$ then 
-$   write uit "''uitregel'=PROCEDURE, -" 
-$   write uit "''uitasis'/''uitregel'=PROCEDURE)" 
-$ endif
-$!
-$ write uit "CASE_SENSITIVE=NO"
-$!
-$ close in
-$ close inasis
-$ close uit
-$!
-$ delete lib*.'thisid';*
-$!
-$exit
-$endsubroutine
-$!
-$!---------------------------------------------------------------------
-$!
diff --git a/libssh2/libssh2/vms/man2help.c b/libssh2/libssh2/vms/man2help.c
deleted file mode 100644
index 92e5f2b9..00000000
--- a/libssh2/libssh2/vms/man2help.c
+++ /dev/null
@@ -1,516 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-
-#include <starlet.h>
-#include <lib$routines.h>
-#include <ssdef.h>
-#include <descrip.h>
-#include <rms.h>
-
-typedef struct manl{
-    struct manl *next;
-    char *filename;
-}man, *manPtr;
- 
-typedef struct pf_fabnam{
-    struct FAB dfab;
-    struct RAB drab;
-    struct namldef dnam;
-    char   expanded_filename[NAM$C_MAXRSS + 1]; 
-} pfn, *pfnPtr;
-
-/*----------------------------------------------------------*/
-
-fpcopy( char *output, char *input, int len )
-{
-char    *is, *os;
-int i;
-
-if ( len ){
-    for ( is = input, os = output, i = 0; i < len ; ++i, ++is, ++os){
-            *os = *is;
-    }
-    *os = 0;
-}else{
-    output[0] = 0;
-}
-}           
-
-
-/*----------------------------------------------------------*/
-/* give part of ilename in partname. See code for proper
-   value of i ( 0 = node, 1 = dev, 2 = dir,3 = name etc.
-*/ 
-
-int fnamepart( char *inputfile, char *part, int whatpart )
-{
-pfnPtr pf;
-int     status;
-char    ipart[6][256], *i, *p;
-
-pf = calloc( 1, sizeof( pfn ) );
-
-pf->dfab = cc$rms_fab;
-pf->drab = cc$rms_rab;
-pf->dnam = cc$rms_naml;
-
-pf->dfab.fab$l_naml = &pf->dnam;
-
-pf->dfab.fab$l_fna = (char *) -1; 
-pf->dfab.fab$l_dna = (char *) -1; 
-pf->dfab.fab$b_fns = 0;
-pf->dfab.fab$w_ifi = 0;
-
-pf->dnam.naml$l_long_defname = NULL; //inputfile;
-pf->dnam.naml$l_long_defname_size = 0;//strlen( inputfile );
-
-pf->dnam.naml$l_long_filename = inputfile;
-pf->dnam.naml$l_long_filename_size = strlen( inputfile);
-
-pf->dnam.naml$l_long_expand = pf->expanded_filename;
-pf->dnam.naml$l_long_expand_alloc = NAM$C_MAXRSS ;
-
-pf->dnam.naml$b_nop |= NAML$M_SYNCHK | NAML$M_PWD;
-
-status = sys$parse( &pf->dfab, 0,0);
-if ( !(status&1) ){
-    free( pf );
-    return( status );
-}
-
-fpcopy ( ipart[0], pf->dnam.naml$l_long_node , pf->dnam.naml$l_long_node_size);
-fpcopy ( ipart[1], pf->dnam.naml$l_long_dev , pf->dnam.naml$l_long_dev_size);
-fpcopy ( ipart[2], pf->dnam.naml$l_long_dir , pf->dnam.naml$l_long_dir_size);
-fpcopy ( ipart[3], pf->dnam.naml$l_long_name , pf->dnam.naml$l_long_name_size);
-fpcopy ( ipart[4], pf->dnam.naml$l_long_type , pf->dnam.naml$l_long_type_size);                                               
-fpcopy ( ipart[5], pf->dnam.naml$l_long_ver , pf->dnam.naml$l_long_ver_size);
-
-for( i = ipart[ whatpart ], p = part; *i; ++i, ++p){
-   if ( p == part ){
-      *p = toupper( *i );
-   }else{
-      *p = tolower( *i );
-   }        
-}
-*p = 0;
-
-free( pf );
-return(1);
-}
-/*----------------------------------------------------------*/
-
-int find_file(char *filename,char *gevonden,int *findex)
-{
-int     status;
-struct  dsc$descriptor gevondend;
-struct  dsc$descriptor filespec;
-char    gevonden_file[NAM$C_MAXRSS + 1];
-
-filespec.dsc$w_length = strlen(filename);
-filespec.dsc$b_dtype  = DSC$K_DTYPE_T;
-filespec.dsc$b_class  = DSC$K_CLASS_S; 
-filespec.dsc$a_pointer = filename;
-
-gevondend.dsc$w_length = NAM$C_MAXRSS;
-gevondend.dsc$b_dtype  = DSC$K_DTYPE_T;
-gevondend.dsc$b_class  = DSC$K_CLASS_S; 
-gevondend.dsc$a_pointer = gevonden_file;
-
-status=lib$find_file(&filespec,&gevondend,findex,0,0,0,0);
-    
-if ( (status & 1) == 1 ){
-       strcpy(gevonden,strtok(gevonden_file," "));
-}else{
-       gevonden[0] = 0;
-}
-
-return(status);
-}
-
-
-/*--------------------------------------------*/
-
-manPtr addman( manPtr *manroot,char *filename )
-{
-manPtr m,f;
-
-m = calloc( 1, sizeof( man) );
-if ( !m ) return( NULL );
-
-m->filename = strdup( filename );
-
-if ( *manroot == NULL ){
-   *manroot = m;    
-}else{
-   for( f = *manroot; f->next ; f = f->next );
-   f->next = m;
-}
-return(m);
-}
-
-/*--------------------------------------------*/
-void freeman( manPtr *manroot )
-{
-manPtr m,n;
-
-for( m = *manroot; m ; m = n ){
-     free( m->filename );
-     n = m->next;
-     free ( m );
-}
-*manroot = NULL;
-}
-
-/*--------------------------------------------*/
-
-int listofmans( char *filespec, manPtr *manroot )
-{
-manPtr  r;
-int     status;
-int     ffindex=0;
-char    gevonden[NAM$C_MAXRSS + 1];
-
-while(1){
-    status = find_file( filespec, gevonden, &ffindex );
-
-    if ( (status&1) ){
-        r = addman( manroot, gevonden );
-        if ( r == NULL ) return(2);
-    }else{
-        if ( !( status&1)) break;
-    }
-}
-
-lib$find_file_end( &ffindex);
-if ( status == RMS$_NMF) status = 1;
-
-
-return( status );
-}
-
-/*--------------------------------------------*/
-
-int convertman ( char *filespec, FILE *hlp , int base_level, int add_parentheses )
-{
-FILE    *man;
-char    *in, *uit;
-char    *m,*h;
-size_t  len, thislen, maxlen= 50000;
-int     bol,mode, return_status=1;
-char subjectname[ NAM$C_MAXRSS + 1 ];
-
-in  = calloc( 1, maxlen + 1 );
-uit = calloc( 1, maxlen + 1 );
-
-if ( in == NULL || uit == NULL ) return(2);
-
-man = fopen( filespec, "r");
-if ( man == NULL ) return(vaxc$errno);
-
-for( len = 0; !feof( man ) && len < maxlen ; len += thislen ){
-    thislen = fread( in + len, 1, maxlen - len, man );
-}
-
-fclose (man);
-
-m = in;
-h = uit;
-
-*(m + len ) = 0;
-
-for ( mode = 0, bol = 1 ; *m; ++m ){
-
-    switch ( mode ){
-        case 0:
-          switch(*m){
-            case '.':
-                if ( bol ){
-                    mode = 1;
-                }else{
-                    *h = *m;
-                    ++h;
-                }
-                break;
-            case '\\':
-                if ( bol ){
-                   *h = ' ';++h;
-                   *h = ' ';++h;
-                }
-                mode = 2;
-                break;
-            default:
-                if ( bol ){
-                   *h = ' ';++h;
-                   *h = ' ';++h;
-                }
-                *h = *m;
-                ++h;
-                break;
-          }
-          break;
-        case 1: /* after . at bol */
-
-          switch(*m){
-            case '\\':
-                while( *m != '\n' && *m != '\r' && *m )++m;
-                mode = 0;
-                break;
-            case 'B':
-                   ++m; 
-                   *h = ' ';++h;
-                   mode = 0;
-                   break;   
-            case 'I':
-                    /* remove preceding eol */
-                    if ( *(m+1) != 'P' ){
-                        --h;
-                        while ( (*h == '\n' || *h == '\r') && h > uit )--h;
-                        ++h;
-                    }
-
-                    /* skip .Ix */
-                    for(;*m != ' ' && *m != '\n' && *m != '\r'; ++m); 
-
-                    /* copy line up to EOL */
-
-                    for(;*m != '\n' && *m != '\r' && *m; ++m, ++h)*h = *m;
-
-                    /* if line ends in ., this is an EOL */
-
-                    if ( *(h-1) == '.'){
-                         --h; 
-                         --m;
-                    }else{
-                        /* if line does not end in ., skip EOL in source */
-
-                        if ( *(m+1) == '\n' || *(m+1) == '\r')++m;
-                    }
-                    mode = 0;
-                    break;
-            case 'S':
-                 if ( *(m+1) == 'H' ){
-                    *h = '\n';++h;
-                    if ( strncmp( m+3 ,"NAME",4) == 0 || 
-                         strncmp( m+3 ,"SYNOPSIS",8) == 0 ||
-                         strncmp( m+3 ,"DESCRIPTION",11) == 0 ){
-                        while( *m != '\n' && *m != '\r')++m;
-                        mode = 0;
-                    }else{
-                        ++m;
-
-                        /* write help level, and flag it */
-
-                        *h = '0' + base_level + 1;++h;
-                        return_status |= 2;
-
-                        *h = ' ';++h; 
-
-                        /* skip H (or whatever after S) and blank */
-                        ++m;++m;
-
-                        for(;*m != '\n' && *m != '\r' && *m; ++m, ++h){
-
-                           /* write help label in lowercase, skip quotes */
-                           /* fill blanks with underscores */
-
-                           if ( *m != '\"' ){
-                                *h = tolower( *m );
-                                if (*h == ' ') *h = '_';    
-                           }else{
-                                --h;
-                           }    
-                        } 
-
-                        /* Add a linefeed or two */
-
-                        *h = *m;++h;
-                        *h = *m;++h;
-
-                        mode = 0;
-                    }   
-                 }
-                 break;
-            case 'T':
-                 if ( *(m+1) == 'H' ){
-                    *h = '0' + base_level; ++h;
-                    return_status |= 2;
-                    *h = ' ';++h;
-                    for ( m = m + 3; *m != ' ' && *m ; ++m, ++h ){
-                          *h = *m;
-                    }
-					if ( add_parentheses ){
-						 *h = '(';++h;
-						 *h = ')';++h;
-					}
-                    while( *m != '\n' && *m != '\r' && *m )++m;
-                    mode = 0;
-                 }
-                 break;
-            default:
-                ++m;
-                mode = 0;
-                break;
-           }
-           break;
-        case 2: /* after \ skip two characters or print the backslash */            
-          switch(*m){
-            case '\\':
-                *h = *m;
-                ++h;
-                mode = 0;
-                break;
-            default:
-                ++m;
-                mode = 0;
-                break;
-           }
-           break;   
-    } /*end switch mode */
-
-    bol = 0;
-    if ( *m == '\n' || *m == '\r') bol = 1;
-
-}/* end for mode */
-
-*h = 0;
-
-
-if ( (return_status&2) ){
-    fprintf( hlp, "%s\n\n", uit);
-}else{
-    fnamepart( filespec, subjectname,3);
-    if ( *subjectname ){
-        fprintf( hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
-    }else{
-        /* No filename (as is the case with a logical), use first word as subject name */
-        char *n,*s;
-
-        for(n = in; isspace( *n );++n);
-        for(s = subjectname; !(isspace( *n )); ++n,++s)*s = *n;
-        *s = 0;
-
-        fprintf( hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
-    }
-}
-
-/*
- printf( "read %d from %s, written %d to helpfile, return_status = %d\n",
-    len, filespec, strlen(uit), return_status );
-*/
-
-free( m ); 
-free( h ); 
-
-return ( 1);
-}
-
-/*--------------------------------------------*/
-
-int convertmans( char *filespec, char *hlpfilename, int base_level, int append, int add_parentheses )
-{
-int status=1;
-manPtr  manroot=NULL, m;
-FILE    *hlp;
-
-if ( append ){
-    hlp = fopen( hlpfilename,"a+");
-}else{
-    hlp = fopen( hlpfilename,"w");
-}
-
-if ( hlp == NULL ) return( vaxc$errno );
-
-status = listofmans( filespec, &manroot );
-if ( !(status&1) ) return( status );
-
-for ( m = manroot ; m ; m = m->next ){
-    status = convertman( m->filename, hlp , base_level, add_parentheses );
-    if ( !(status&1) ){
-        fprintf(stderr,"Convertman of %s went wrong\n", m->filename);
-        break;
-    }
-}
-freeman( &manroot );
-return( status );
-}
-
-/*--------------------------------------------*/
-void print_help()
-{
-   fprintf( stderr, "Usage: [-a] [-b x] convertman <manfilespec> <helptextfile>\n" );
-   fprintf( stderr, "       -a append <manfilespec> to <helptextfile>\n" );
-   fprintf( stderr, "       -b <baselevel> if no headers found create one with level <baselevel>\n" );
-   fprintf( stderr, "          and the filename as title.\n" );
-   fprintf( stderr, "       -p add parentheses() to baselevel help items.\n" );
-
-}
-/*--------------------------------------------*/
-
-main ( int argc, char **argv )
-{
-int     status;
-int     i,j;
-int     append, base_level, basechange, add_parentheses;
-char    *manfile=NULL;
-char    *helpfile=NULL;
-
-if ( argc < 3 ){
-   print_help();
-   return( 1 ) ;
-}
-
-append     = 0;
-base_level = 1;
-basechange = 0;
-add_parentheses = 0;
-
-for ( i = 1; i < argc; ++i){
-    if ( argv[i][0] == '-' ){
-        for( j = 1; argv[i][j] ; ++j ){
-            switch( argv[i][j] ){
-                case 'a':
-                    append = 1;
-                    break;
-                case 'b':   
-                    if ( (i+1) < argc ){
-                        base_level = atoi( argv[ i + 1 ] );
-                        basechange = 1;
-                    }
-                    break;
-                case 'p':
-                    add_parentheses = 1;
-                    break;
-            }
-        }
-        if ( basechange){
-            basechange = 0;
-            i = i + 1;
-        }
-    }else{
-        if ( manfile == NULL ){
-            manfile = strdup( argv[i]);
-        } else if ( helpfile == NULL ){
-            helpfile = strdup( argv[i]);
-        } else {
-            fprintf( stderr, "Unrecognized parameter : %s\n", argv[i]);
-        }
-    }
-}
-
-
-/* fprintf( stderr,"manfile: %s, helpfile: %s, append: %d, base_level : %d\n",
-        manfile, helpfile, append, base_level);
-*/
-
-status = convertmans( manfile, helpfile, base_level, append, add_parentheses );
-
-free( manfile );
-free( helpfile );
-
-return( status );
-}
-
- 
diff --git a/libssh2/libssh2/vms/readme.vms b/libssh2/libssh2/vms/readme.vms
deleted file mode 100644
index 978da197..00000000
--- a/libssh2/libssh2/vms/readme.vms
+++ /dev/null
@@ -1,319 +0,0 @@
-*These are the porting notes to OpenVMS, as of 7 April 2010
-by Jose Baars. This file will be installed as 
-libssh2*.release_notes by the product install kit.
-
-
-LIBSSH2 
--------
-
-LIBSSH2 is a client-side library written in C that aims to 
-implement the SSH2 protocol. It is an open source project, 
-to be found at https://libssh2.org.
-
-GNV
----
-
-The library uses the GNV prefix, on advise of the kind supporter
-of the GNV project, John Malmberg.
-
-Installing the PCSI kit
-=======================
-
-Prerequisites 
--------------
-- VMS version 8.3 minimal. 
-  See the remarks at prerequisites for building the kit
-- TCP/IP stack, both TCP/IP services and Multinet should work. 
-  See the remarks at prerequisites for building the kit
-- HP OPENSSL V1.3 minimal. 
-  See the remarks at prerequisites for building the kit
-- JEM  ZLIB V1.2-3E1 minimal. 
-  See the remarks at prerequisites for building the kit
-  
-The first three dependencies are tested at installation time, and 
-installation will fail if any these products are not installed.
-The ZLIB dependency is not tested by the product installation
-procedure, as libssh2 will probably be installed as part of 
-multiple libraries including zlib.
-
-Install
--------
-
-
-The kit will install gnv$libssh2.exe in a directory tree that might 
-already be available on your system if you have installed other gnv* 
-libraries or utilities. 
-
-The directory tree for gnv$libssh2.exe will be like this:
-
-[gnv] -- [usr] -- [include] -- [libssh2] include files for libssh2
-                  [lib] gnv$libssh2_x_y_z.exe
-                  [share]   -- [doc] -- [libssh2] libssh2.hlb, 
-                                        release notes (this file), 
-                                        libssh2 release notes   
-
-optional:
-                                        [example] libssh2_examples-x_y_z.bck 
-                  [common_src] libssh2-x_y_z_src.bck
-
-By default, it will install the shared image and include files to 
-SYS$COMMON:[GNV...].
-
-You can override this destination by specifying the destination
-directory after /DESTINATION= on the product install command line.
-This is particularly of use when installing the library on a cluster
-without a common system disk.
-
-Please ignore the following warnings, as the kit is not signed :
-
-%PCSI-I-CANNOTVAL, cannot validate dev:[dir]JCB-AXPVMS-LIBSSH2-V0102-05D20100402-1.PCSI
--PCSI-I-NOTSIGNED, product kit is not signed and therefore has no manifest file
-
-Optionally, you can install a backup saveset with some programming examples,
-or a backupo saveset with the complete libssh2 source tree.
- 
-you will need to answer 'NO' to the question 
-'Do you want the default for all options'. 
-
-and 'YES' to either or both the following questions:
-
-    Do you want the libssh2 C programming examples ?  [NO]
-
-    Do you want the complete libssh2 source tree ?  [NO]
-
-
-Post installation tasks
------------------------
-
-Although we will try to maintain upward compatibility of libssh2,
-this can not be guaranteed by the libssh2 project itself for OpenVMS,
-nor eternally by us.
-
-To use libssh2 effectively, you will have to define a system logical
-to point to the shared image. If you are willing to take the gamble,
-define this logical in your systartup like so:
-
-$ define/system/executive gnv$libssh2 dev:[dir..]gnv$libssh2_x_y_z.exe
-
-Optionally, you can install the executbale like so:
-
-$ mc sysgen install dev:[dir..]gnv$libssh2_x_y_z.exe/open/share/header
-
-Link your programs against gnv$libssh2, and when upgrading libssh2 
-test thoroughly.
-
-If you want to be extra cautious define a system logical like this:
-
-$ define/system/executive gnv$libssh2_x_y_z dev:[dir..]gnv$libssh2_x_y_z.exe
-
-Link  programs against gnv$libssh2_x_y_z, and when upgrading libssh2 
-link against new versions. 
-
-It is probably more convenient in the last case to link against the object 
-library provided in the source backup saveset. Both an uppercase and a
-mixed case object library, called libssh2.olb and libssh2_asis.olb 
-are provided.
-
-
-Compiling and linking against libssh2
--------------------------------------
-
-The  shared image library has a vector table with both uppercase and 
-mixed case entry points, allowing to link directly against the shared 
-image wether you need the /NAMES=AS_IS or not.
-
-To link successfully, you MUST use /NAMES=shortened, as some function
-names in libssh2 are longer than the VMS maximum of 32 characters.
-
-If you chose to install the examples, you can unpack the backup
-saveset by 
-
-backup/sel=*.c device:[gnv.usr.share.doc.libssh2.examples]libssh2_examples-x_y_z.bck -
- []
-
-They can by compiled and linked by these commands ( provided you have defined
-the gnv$libssh2 logical) :
-
-$ cc/include=dev:[gnv.usr.include.libssh2] xxx.c/names=shortened
-$ link/opt=sys$input: xxx.obj
-gnv$libssh2/share
-
-
-
-
-Building gnv$libssh2
-====================
-
-You can build gnv$libssh2 yourself, which may have advantages, as the library is
-in full development, very regularly new features are added.
-
-For production use, it is probably advisable to use a stable version, and 
-link against that. To check out new features, statically linking against
-the object library is probably more practical, to avoid compatibility
-issues.
-
-
-Prerequisites
--------------
-
-You will need to have the following available:
-
-- An Alpha or Itanium VMS system. Due to dependencies on zlib, ssl and ODS-5,
-  support on VAXen would be cumbersome at least.
-
-- VMS version 8.3 minimal. This is a requirement of gnv$zlibshr.exe against 
-  which shared image library libssh2 is linked. If you use another zlib
-  to link against, you can make it work under lower versions of VMS.
-  I have made it work on VMS 7.3-2 with not a lot of difficulty.
-  Also, if you are not interested in compression, you can choose not
-  to link against zlib at all; in that case comment out the 
-  #define  LIBSSH2_HAVE_ZLIB in libssh2_config.h.
-
-- TCP/IP services or Multinet for OpenVMS.
-  TCPWare has not been tested.
-
-- The HP OpenSSL product. Of course, with tweaking, you can probably link 
-  it against the OpenSSL library, but that is not what I have used.
- 
-- A C compiler. I don't know any other working C compilers than 
-  the DEC/Compac/HP-C compiler on VMS.
-
-- An ODS-5 disk. With tweaking you'll get it to work on an ODS-2
-  disk, but it is unpractical to do so.
-
-- A version of VMSTAR that understands ODS-5 disks and extended
-  filenames. Look here:
-  http://ftp.process.com/ftp/vms-freeware/fileserv/vmstar.zip
-
-- gunzip, available for instance at Steven M Schweda's website:
-  http://antinode.info/ftp/gzip/gzip-1_3_12b_vms/gzip-1_3_12b_vms.zip
-
-Optional:
-
-- curl, to be found at  https://curl.haxx.se
-  You might want to use curl to download the libssh2 kit directly
-  to you VMS machine. Interestingly, sftp in curl is implemented using
-  libssh2, soon to be expected on VMS as well, hopefully.
-
-Downloading libssh2
--------------------
-
-At the website of libssh2, you can find stable and daily gzipped
-tarballs. if you have a computer connected to internet you can 
-download a daily build yourself by a procedure that looks a lot like
-this ( fill out your own proxy user/password, set up right symbols to
-gunzip, vmstar and curl and set up the libssh2 build version):
-
-$ libssh2_version = "1.2.6"
-$!
-$ proxy_line = " ""-U"" ""''proxy_userpass'""  ""-x"" ""''proxy_hostport'"" "
-$!
-$ currentday = f$cvtime(,,"date") - "-" - "-"
-$!
-$ set def mydev:[mydir.libssh2]
-$!
-$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.gz") .nes. "" 
-$ then 
-$   delete libssh2-'libssh2_version'-'currentday'.tar.gz;*
-$ endif
-$!
-$ curl 'proxy_line' "https://libssh2.org/snapshots/libssh2-''libssh2_version'-''currentday'.tar.gz" -
-                    -o libssh2-'libssh2_version'-'currentday'.tar.gz
-$!
-$!
-$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.;") .nes. "" 
-$ then 
-$   delete libssh2-'libssh2_version'-'currentday'.tar.;*
-$ endif
-$!
-$ gunzip libssh2-'libssh2_version'-'currentday'.tar.gz
-$!
-$ tarfile = f$search("libssh2-''libssh2_version'-''currentday'.tar.;")
-$ vmstar xf 'tarfile' 
-
-Downloading a stable build will need you to get rid of the currentday.
-
-After the download, you should have a directory tree with a toplevel
-directory called [libssh2-x.y.z-yyyymmdd].
-One of the subdirectories is called vms.
-
-Getting the libssh2 sources from the source backup in the binary kit
---------------------------------------------------------------------
-
-During installation of the binary kit, you are given the option
-of installing the sources. If chosen, a backup saveset with 
-the complete libssh2 directory is made available in 
-[gnv.common_src].
-
-By restoring this backup saveset, you end up with the same
-set of files as by the direct download from libssh2.org.
-
-
-Building the library
---------------------
-
-To avoid all kinds of misunderstandings caused by firewalls thinking that
-a .com file must be an MS-DOS executable, all command procedures are called
-.dcl.
-
-Go to the vms subdirectory in the download tree, and issue the following
-command:
-
-@libssh2_make_lib.dcl
-
-This should produce libssh2_x_y_z.exe in this same vms directory.
- 
-
-
-Building the examples
----------------------
-
-A number of examples are also part of the full libssh2 delivery.
-You can compile and link them either against the object library
-produced when building the shared image, or against the shared image
-produced in the step before.
-
-You can compile only one of the examples by giving only the
-name part of the filename of the example as p1 to the 
-build procedure:
-
-@libssh2_make_example.dcl 
-
-or for instance
-
-@libssh2_make_example.dcl sftp 
-
-By default, libssh2_make_example.dcl links to the object libraries 
-produced by the libssh2_make_lib.dcl procedure. If you want to link
-against the shared image library made in the same procedure, invoke
-the procedure like so:
-
-@libssh2_make_example.dcl sftp "SHARED"
-
-The procdure defines a process logical gnv$libssh2 pointing to the shared
-image library in the directory, which obviously will not survive a logout. 
-
-
-Building the help library
--------------------------
-
-The man pages can be converted to a VMS help library by issuing
-this command :
-
-@libssh2_make_help.dcl
-
-It uses a simple but fairly effective c program man2help.c
-to achieve this.
-
-Building a PCSI kit
--------------------
-
-When you have built the shared library and the help library,
-you can build a PCSI kit by issueing this command:
-
-@libssh2_make_kit.dcl
-
-
-
-
-
diff --git a/libssh2/libssh2/win32/GNUmakefile b/libssh2/libssh2/win32/GNUmakefile
deleted file mode 100644
index 0971d891..00000000
--- a/libssh2/libssh2/win32/GNUmakefile
+++ /dev/null
@@ -1,365 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (Win32 version - gnu make)
-## Use: make -f GNUmakefile [help|all|clean|dev|devclean|dist|distclean|dll|objclean]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-1.0.2d
-endif
-
-# Edit the path below to point to your Distribution folder.
-ifndef DISTDIR
-DISTDIR	= libssh2-$(LIBSSH2_VERSION_STR)-bin-$(ARCH)
-endif
-DISTARC	= $(DISTDIR).zip
-
-# Edit the path below to point to your Development folder.
-ifndef DEVLDIR
-DEVLDIR	= libssh2-$(LIBSSH2_VERSION_STR)-dev-$(ARCH)
-endif
-DEVLARC	= $(DEVLDIR).zip
-
-# Project root
-PROOT	= ..
-
-# Edit the vars below to change target settings.
-TARGET	= libssh2
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(LIBSSH2_VERSION_STR)
-#STACK	= 64000
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-ZIP	= zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-ifeq ($(LIBSSH2_CC),)
-LIBSSH2_CC := $(CROSSPREFIX)gcc
-endif
-ifeq ($(LIBSSH2_AR),)
-LIBSSH2_AR := $(CROSSPREFIX)ar
-endif
-ifeq ($(LIBSSH2_RANLIB),)
-LIBSSH2_RANLIB := $(CROSSPREFIX)ranlib
-endif
-ifeq ($(LIBSSH2_DLL_A_SUFFIX),)
-LIBSSH2_DLL_A_SUFFIX := dll
-endif
-
-libssh2_dll_LIBRARY = $(TARGET)$(LIBSSH2_DLL_SUFFIX).dll
-
-# The following line defines your compiler.
-ifdef METROWERKS
-	CC = mwcc
-else
-	CC = $(LIBSSH2_CC)
-endif
-
-# Set environment var ARCH to your architecture to override autodetection.
-ifndef ARCH
-ifeq ($(findstring gcc,$(CC)),gcc)
-ifeq ($(findstring x86_64,$(shell $(CC) -dumpmachine)),x86_64)
-ARCH	= w64
-else
-ARCH	= w32
-endif
-else
-ARCH	= w32
-endif
-endif
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	= $(LIBSSH2_CFLAG_EXTRAS) $(OPT) -D$(DB) -DLIBSSH2_WIN32 -DHAVE_WINDOWS_H # -DHAVE_CONFIG_H
-LDFLAGS = $(LIBSSH2_LDFLAG_EXTRAS)
-
-ifeq ($(CC),mwcc)
-LD	= mwld
-RC	= mwwinrc
-LDFLAGS	+= -nostdlib
-AR	= $(LD)
-ARFLAGS	= -nostdlib -library -o
-LIBEXT	= lib
-#RANLIB	=
-LIBPATH	+= -lr "$(METROWERKS)/MSL" -lr "$(METROWERKS)/Win32-x86 Support"
-LDLIBS	+= -lMSL_Runtime_x86.lib -lMSL_C_x86.lib -lMSL_Extras_x86.lib
-RCFLAGS	=
-CFLAGS	+= -nostdinc -gccinc -msgstyle gcc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -ir "$(METROWERKS)/MSL" -ir "$(METROWERKS)/Win32-x86 Support"
-CFLAGS	+= -w on,nounused,nounusedexpr # -ansi strict
-else
-LIBEXT	= a
-LD	= $(LIBSSH2_CC)
-RC	= $(CROSSPREFIX)windres
-LDFLAGS	+= -s -shared -Wl,--output-def,$(libssh2_dll_LIBRARY:.dll=.def),--out-implib,$(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT)
-AR	= $(LIBSSH2_AR)
-ARFLAGS	= cru
-RANLIB	= $(LIBSSH2_RANLIB)
-RCFLAGS	= -I $(PROOT)/include -O coff
-CFLAGS	+= -fno-builtin
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-ifeq ($(ARCH),w64)
-CFLAGS	+= -m64 -D_AMD64_
-LDFLAGS += -m64
-RCFLAGS	+= -F pe-x86-64
-else
-CFLAGS	+= -m32
-LDFLAGS += -m32
-RCFLAGS	+= -F pe-i386
-endif
-endif
-
-INCLUDES = -I$(PROOT)/win32 -I$(PROOT)/include
-
-ifdef WITH_WINCNG
-CFLAGS	+= -DLIBSSH2_WINCNG
-LDLIBS	+= -lbcrypt -lcrypt32
-else
-CFLAGS	+= -DLIBSSH2_OPENSSL
-ifndef OPENSSL_INCLUDE
-	ifeq "$(wildcard $(OPENSSL_PATH)/outinc)" "$(OPENSSL_PATH)/outinc"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/outinc
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/include)" "$(OPENSSL_PATH)/include"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/include
-	endif
-endif
-ifneq "$(wildcard $(OPENSSL_INCLUDE)/openssl/opensslv.h)" "$(OPENSSL_INCLUDE)/openssl/opensslv.h"
-$(error Invalid OPENSSL_PATH: $(OPENSSL_PATH))
-endif
-INCLUDES += -I"$(OPENSSL_INCLUDE)"
-ifndef OPENSSL_LIBPATH
-	OPENSSL_LIBS_STAT = crypto ssl
-	ifeq "$(wildcard $(OPENSSL_PATH)/out)" "$(OPENSSL_PATH)/out"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/out
-		OPENSSL_LIBS_DYN = eay32 ssl32
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/lib)" "$(OPENSSL_PATH)/lib"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/lib
-		OPENSSL_LIBS_DYN = crypto.dll ssl.dll
-	endif
-endif
-ifdef LINK_OPENSSL_STATIC
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_STAT)) -lgdi32
-else
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_DYN))
-endif
-endif
-ifeq ($(CC),mwcc)
-LDLIBS	+= -lkernel32.lib -luser32.lib -lwsock32.lib
-else
-#LDLIBS	+= -lwsock32
-LDLIBS	+= -lws2_32
-endif
-
-ifdef WITH_ZLIB
-	CFLAGS += -DLIBSSH2_HAVE_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-	ifdef LINK_ZLIB_STATIC
-		LDLIBS += $(ZLIB_PATH)/libz.$(LIBEXT)
-	else
-		LDLIBS += $(ZLIB_PATH)/libz.dll.$(LIBEXT)
-	endif
-endif
-
-CFLAGS	+= $(INCLUDES)
-
-vpath %.c $(PROOT)/src
-
-ifdef WITH_WINCNG
-include $(PROOT)/Makefile.WinCNG.inc
-else
-include $(PROOT)/Makefile.OpenSSL.inc
-endif
-
-# include Makefile.inc to get CSOURCES define
-include $(PROOT)/Makefile.inc
-
-OBJECTS	:= $(patsubst %.c,%.o,$(CSOURCES))
-OBJS	:= $(addprefix $(OBJDIR)/,$(OBJECTS))
-OBJL	= $(OBJS) $(OBJDIR)/$(TARGET).res
-
-
-all: lib dll
-
-dll: prebuild $(libssh2_dll_LIBRARY)
-
-lib: prebuild $(TARGET).$(LIBEXT)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-# libssh2_config.h
-
-test: all
-	$(MAKE) -C test -f GNUmakefile
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: $(PROOT)/get_ver.awk $(PROOT)/include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-dist: all $(DISTDIR) $(DISTDIR)/readme.txt
-	@$(call MKDIR, $(DISTDIR)/bin)
-	@$(call COPY, $(PROOT)/AUTHORS, $(DISTDIR))
-	@$(call COPY, $(PROOT)/COPYING, $(DISTDIR))
-	@$(call COPY, $(PROOT)/INSTALL, $(DISTDIR))
-	@$(call COPY, $(PROOT)/README, $(DISTDIR))
-	@$(call COPY, $(PROOT)/RELEASE-NOTES, $(DISTDIR))
-	@$(call COPY, $(libssh2_dll_LIBRARY), $(DISTDIR)/bin)
-	@echo Creating $(DISTARC)
-	@$(ZIP) $(DISTARC) $(DISTDIR)/* < $(DISTDIR)/readme.txt
-
-dev: all $(DEVLDIR) $(DEVLDIR)/readme.txt
-	@$(call MKDIR, $(DEVLDIR)/bin)
-	@$(call MKDIR, $(DEVLDIR)/include)
-	@$(call MKDIR, $(DEVLDIR)/win32)
-	@$(call COPY, $(PROOT)/AUTHORS, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/COPYING, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/INSTALL, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/README, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/RELEASE-NOTES, $(DEVLDIR))
-	@$(call COPY, $(libssh2_dll_LIBRARY), $(DEVLDIR)/bin)
-	@$(call COPY, $(PROOT)/include/*.h, $(DEVLDIR)/include)
-	@$(call COPY, libssh2_config.h, $(DEVLDIR)/include)
-	@$(call COPY, *.$(LIBEXT), $(DEVLDIR)/win32)
-	@echo Creating $(DEVLARC)
-	@$(ZIP) $(DEVLARC) $(DEVLDIR)/* < $(DEVLDIR)/readme.txt
-
-distclean vclean: clean
-	$(call RMDIR, $(DISTDIR))
-	$(call DEL, $(DISTARC))
-
-devclean: clean
-	$(call RMDIR, $(DEVLDIR))
-	$(call DEL, $(DEVLARC))
-
-objclean: all
-	$(call RMDIR, $(OBJDIR))
-
-testclean: clean
-	$(MAKE) -C test -f GNUmakefile clean
-
-clean:
-#	$(call DEL, libssh2_config.h)
-	$(call DEL, $(libssh2_dll_LIBRARY) $(libssh2_dll_LIBRARY:.dll=.def) $(TARGET).$(LIBEXT) $(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT))
-	$(call RMDIR, $(OBJDIR))
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-$(DISTDIR):
-	@$(call MKDIR, $@)
-
-$(DEVLDIR):
-	@$(call MKDIR, $@)
-
-$(TARGET).$(LIBEXT): $(OBJS)
-	@echo Creating $@
-	@$(call DEL, $@)
-	@$(AR) $(ARFLAGS) $@ $^
-ifdef RANLIB
-	@$(RANLIB) $@
-endif
-
-$(libssh2_dll_LIBRARY) $(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT): $(OBJL)
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $^ -o $@ $(LIBPATH) $(LDLIBS)
-
-
-$(OBJDIR)/%.res: %.rc
-	@echo Creating $@
-	@$(RC) $(RCFLAGS) -i $< -o $@
-
-
-$(DISTDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a binary distribution for Win32 platform.$(DL) > $@
-	@echo $(DL)libssh version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-$(DEVLDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a development distribution for Win32 platform.$(DL) > $@
-	@echo $(DL)libssh version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) dll$(DL)
-	@echo $(DL)$(MAKE) lib$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) dev$(DL)
-	@echo $(DL)$(MAKE) devclean$(DL)
-	@echo $(DL)$(MAKE) dist$(DL)
-	@echo $(DL)$(MAKE) distclean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)$(MAKE) test$(DL)
-	@echo $(DL)===========================================================$(DL)
diff --git a/libssh2/libssh2/win32/Makefile.Watcom b/libssh2/libssh2/win32/Makefile.Watcom
deleted file mode 100644
index 1e8cede6..00000000
--- a/libssh2/libssh2/win32/Makefile.Watcom
+++ /dev/null
@@ -1,190 +0,0 @@
-#
-#  Watcom / OpenWatcom Win32 makefile for libssh2.
-#
-#  Comments to: Guenter Knauf http://www.gknw.net/phpbb
-#
-
-!ifndef %watcom
-!error WATCOM environment variable not set!
-!else
-SYS_INCL = -I$(%watcom)\h\nt -I$(%watcom)\h
-SYS_LIBS = $(%watcom)\lib386\nt;$(%watcom)\lib386
-!endif
-
-!ifdef %libname
-LIBNAME = $(%libname)
-!else
-LIBNAME = libssh2
-!endif
-TARGETS = $(LIBNAME).dll $(LIBNAME)_imp.lib $(LIBNAME).lib
-
-CC = wcc386
-LD = wlink
-AR = wlib
-RC = wrc
-
-!ifdef __LOADDLL__
-!  loaddll wcc386  wccd386
-!  loaddll wpp386  wppd386
-!  loaddll wlib    wlibd
-!  if $(__VERSION__) > 1270
-!    loaddll wlink   wlinkd
-!  else
-!    loaddll wlink   wlink
-!  endif
-!endif
-
-!if $(__VERSION__) < 1250                                                                                                           
-RM = del /q /f 2>NUL
-!else                                                                                                                               
-RM = rm -f                                                                                                                          
-!endif
-MD = mkdir
-RD = rmdir /q /s 2>NUL
-CP = copy
-
-CFLAGS = -3r -mf -hc -zff -zgf -zq -zm -zc -s -fr=nul -w2 -fpi -oilrtfm &
-         -wcd=201 -bt=nt -d+ -dWIN32 -DLIBSSH2_WIN32 &
-         -I. -I..\include $(SYS_INCL)
-
-!ifdef %debug
-DEBUG  = -dDEBUG=1 -dDEBUGBUILD
-CFLAGS += -d3 $(DEBUG)
-!else
-CFLAGS += -d0
-!endif
-
-!ifdef %use_ipv6
-CFLAGS += -d_WIN32_WINNT=0x0501 -dENABLE_IPV6
-!endif
-
-#
-# Change to suite.
-#
-!ifdef %zlib_root
-ZLIB_ROOT = $(%zlib_root)
-!else
-ZLIB_ROOT = ..\..\zlib-1.2.8
-!endif
-
-!ifdef %openssl_root
-OPENSSL_ROOT = $(%openssl_root)
-!else
-OPENSSL_ROOT = ..\..\openssl-0.9.8zc
-!endif
-
-!ifdef %use_zlib
-CFLAGS += -DLIBSSH2_HAVE_ZLIB -I$(ZLIB_ROOT)
-!endif
-
-!ifdef %use_wincng
-CFLAGS += -DLIBSSH2_WINCNG
-!else
-CFLAGS += -wcd=138 -dLIBSSH2_OPENSSL -I$(OPENSSL_ROOT)\inc32
-!endif
-
-!ifdef %use_watt32
-CFLAGS += -dUSE_WATT32 -I$(%watt_root)\inc
-!endif
-
-OBJ_BASE = WC_Win32.obj
-LINK_ARG = $(OBJ_BASE)\dyn\wlink.arg
-LIB_ARG  = $(OBJ_BASE)\stat\wlib.arg
-
-# In order to process Makefile.inc wmake must be called with -u switch!
-!ifndef %MAKEFLAGS
-!error You MUST call wmake with the -u switch!
-!else
-!ifdef %use_wincng
-!include ..\Makefile.WinCNG.inc
-!else
-!include ..\Makefile.OpenSSL.inc
-!endif
-!include ..\Makefile.inc
-!endif
-
-OBJS = $(CSOURCES:.c=.obj)
-OBJS = $OBJ_DIR\$(OBJS: = $OBJ_DIR\)
-
-#
-# Use $(OBJS) as a template to generate $(OBJS_STAT) and $(OBJS_DYN).
-#
-OBJ_DIR    = $(OBJ_BASE)\stat
-OBJS_STAT  = $+ $(OBJS) $-
-
-OBJ_DIR    = $(OBJ_BASE)\dyn
-OBJS_DYN   = $+ $(OBJS) $-
-
-RESOURCE   = $(OBJ_BASE)\dyn\libssh2.res
-
-.c: ..\src
-
-
-all: $(OBJ_BASE) $(TARGETS) .SYMBOLIC
-	@echo Welcome to libssh2
-
-clean: .SYMBOLIC
-	-$(RM) $(OBJS_STAT)
-	-$(RM) $(OBJS_DYN)
-	-$(RM) $(RESOURCE) $(LINK_ARG) $(LIB_ARG)
-
-vclean realclean: clean .SYMBOLIC
-	-$(RM) $(TARGETS) $(LIBNAME).map $(LIBNAME).sym
-	-$(RD) $(OBJ_BASE)\stat
-	-$(RD) $(OBJ_BASE)\dyn
-	-$(RD) $(OBJ_BASE)
-
-$(OBJ_BASE):
-	-$(MD) $^@
-	-$(MD) $^@\stat
-	-$(MD) $^@\dyn
-
-$(LIBNAME).dll: $(OBJS_DYN) $(RESOURCE) $(LINK_ARG)
-	$(LD) name $^@ @$]@
-
-$(LIBNAME).lib: $(OBJS_STAT) $(LIB_ARG)
-	$(AR) -q -b -c $^@ @$]@
-
-.ERASE
-$(RESOURCE): libssh2.rc
-	$(RC) $(DEBUG) -q -r -zm -I..\include $(SYS_INCL) $[@ -fo=$^@
-
-.ERASE
-.c{$(OBJ_BASE)\dyn}.obj:
-	$(CC) $(CFLAGS) -bd -br $[@ -fo=$^@
-
-.ERASE
-.c{$(OBJ_BASE)\stat}.obj:
-	$(CC) $(CFLAGS) $[@ -fo=$^@
-
-$(LINK_ARG): $(__MAKEFILES__)
-	%create $^@
-	@%append $^@ system nt dll
-	@%append $^@ file { $(OBJS_DYN) }
-!ifdef %debug
-	@%append $^@ debug all
-	@%append $^@ option symfile
-!endif
-	@%append $^@ option quiet, map, caseexact, eliminate, implib=$(LIBNAME)_imp.lib,
-	@%append $^@ res=$(RESOURCE) libpath $(SYS_LIBS)
-!ifdef %use_watt32
-	@%append $^@ library $(%watt_root)\lib\wattcpw_imp.lib
-!else
-	@%append $^@ library ws2_32.lib
-!endif
-!ifdef %use_zlib
-	@%append $^@ library '$(ZLIB_ROOT)\zlib.lib'
-!endif
-!ifdef %use_wincng
-	@%append $^@ library bcrypt.lib
-	@%append $^@ library crypt32.lib
-!else
-	@%append $^@ library '$(OPENSSL_ROOT)\out32\libeay32.lib'
-	@%append $^@ library '$(OPENSSL_ROOT)\out32\ssleay32.lib'
-!endif
-
-$(LIB_ARG): $(__MAKEFILES__)
-	%create $^@
-	@for %f in ($(OBJS_STAT)) do @%append $^@ +- %f
-
-
diff --git a/libssh2/libssh2/win32/config.mk b/libssh2/libssh2/win32/config.mk
deleted file mode 100644
index 21fe2e55..00000000
--- a/libssh2/libssh2/win32/config.mk
+++ /dev/null
@@ -1,54 +0,0 @@
-
-# Tweak these for your system
-!if "$(OPENSSLINC)" == ""
-OPENSSLINC=..\openssl-0.9.8zc\inc32
-!endif
-
-!if "$(OPENSSLLIB)" == ""
-OPENSSLLIB=..\openssl-0.9.8zc\out32dll
-!endif
-
-!if "$(ZLIBINC)" == ""
-ZLIBINC=..\zlib-1.2.8
-!endif
-
-!if "$(ZLIBLIB)" == ""
-ZLIBLIB=..\zlib-1.2.8
-!endif
-
-!if "$(TARGET)" == ""
-TARGET=Release
-!endif
-
-!if "$(TARGET)" == "Debug"
-SUFFIX=_debug
-CPPFLAGS=/Od /MDd
-DLLFLAGS=/DEBUG /LDd
-!else
-CPPFLAGS=/Oi /O2 /Oy /GF /Y- /MD /DNDEBUG
-DLLFLAGS=/DEBUG /LD
-!endif
-
-CPPFLAGS=/nologo /GL /Zi /EHsc $(CPPFLAGS) /Iwin32 /Iinclude
-
-!if "$(WITH_WINCNG)" == "1"
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_WINCNG
-# LIBS=bcrypt.lib crypt32.lib
-!else
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_OPENSSL /I$(OPENSSLINC)
-LIBS=$(LIBS) $(OPENSSLLIB)\libeay32.lib $(OPENSSLLIB)\ssleay32.lib
-!endif
-
-!if "$(WITH_ZLIB)" == "1"
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_HAVE_ZLIB /I$(ZLIBINC)
-LIBS=$(LIBS) $(ZLIBLIB)\zlib.lib
-!endif
-
-CFLAGS=$(CPPFLAGS)
-RCFLAGS=/Iinclude
-DLLFLAGS=$(CFLAGS) $(DLLFLAGS)
-LIBS=$(LIBS) ws2_32.lib user32.lib advapi32.lib gdi32.lib
-
-INTDIR=$(TARGET)\$(SUBDIR)
-
-
diff --git a/libssh2/libssh2/win32/libssh2.dsp b/libssh2/libssh2/win32/libssh2.dsp
deleted file mode 100644
index 1657c7bf..00000000
--- a/libssh2/libssh2/win32/libssh2.dsp
+++ /dev/null
@@ -1,439 +0,0 @@
-# Microsoft Developer Studio Project File - Name="libssh2" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-# only OpenSSL and WinCNG are supported with this build system
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=libssh2 - Win32 OpenSSL Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak" CFG="libssh2 - Win32 DLL Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ENDIF
-
-# Begin Target
-
-# Name "libssh2 - Win32 OpenSSL DLL Release"
-# Name "libssh2 - Win32 OpenSSL DLL Debug"
-# Name "libssh2 - Win32 OpenSSL LIB Release"
-# Name "libssh2 - Win32 OpenSSL LIB Debug"
-# Name "libssh2 - Win32 WinCNG DLL Release"
-# Name "libssh2 - Win32 WinCNG DLL Debug"
-# Name "libssh2 - Win32 WinCNG LIB Release"
-# Name "libssh2 - Win32 WinCNG LIB Debug"
-
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx"
-# Begin Source File
-
-SOURCE=..\src\agent.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\agent_win.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\bcrypt_pbkdf.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\blowfish.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\channel.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\comp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\crypt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\global.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\hostkey.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\keepalive.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\kex.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\knownhost.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mac.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mbedtls.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\misc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\openssl.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\packet.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\pem.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\publickey.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\scp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\session.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\sftp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\transport.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\userauth.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\version.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\wincng.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx"
-# Begin Source File
-
-SOURCE=..\src\agent.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\blf.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\channel.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\comp.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\crypto.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\libssh2_config.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\libssh2_priv.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mac.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mbedtls.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\misc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\openssl.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\packet.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\session.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\sftp.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\transport.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\userauth.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\wincng.h
-# End Source File
-# End Group
-# End Target
-# End Project
-
diff --git a/libssh2/libssh2/win32/libssh2.dsw b/libssh2/libssh2/win32/libssh2.dsw
deleted file mode 100644
index 36ad8fc0..00000000
--- a/libssh2/libssh2/win32/libssh2.dsw
+++ /dev/null
@@ -1,41 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "libssh2"=".\libssh2.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Project: "tests"=".\tests.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
diff --git a/libssh2/libssh2/win32/libssh2.rc b/libssh2/libssh2/win32/libssh2.rc
deleted file mode 100644
index f5d607a7..00000000
--- a/libssh2/libssh2/win32/libssh2.rc
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************
-* libssh2 Win32 resource file                                              *
-***************************************************************************/
-#include <winver.h>
-#include "../include/libssh2.h"
-
-LANGUAGE  0x09,0x01
-
-#define RC_VERSION  LIBSSH2_VERSION_MAJOR, LIBSSH2_VERSION_MINOR, LIBSSH2_VERSION_PATCH, 0
-
-VS_VERSION_INFO VERSIONINFO
-  FILEVERSION     RC_VERSION
-  PRODUCTVERSION  RC_VERSION
-  FILEFLAGSMASK   0x3fL
-#if defined(DEBUGBUILD) || defined(_DEBUG)
-  FILEFLAGS 1
-#else
-  FILEFLAGS 0
-#endif
-  FILEOS      VOS__WINDOWS32
-  FILETYPE    VFT_DLL
-  FILESUBTYPE 0x0L
-
-BEGIN
-  BLOCK "StringFileInfo"
-  BEGIN
-    BLOCK "040904b0"
-    BEGIN
-      VALUE "CompanyName",      "The libssh2 library, https://www.libssh2.org/\0"
-      VALUE "FileDescription",  "libssh2 Shared Library\0"
-      VALUE "FileVersion",      LIBSSH2_VERSION "\0"
-      VALUE "InternalName",     "libssh2\0"
-      VALUE "OriginalFilename", "libssh2.dll\0"
-      VALUE "ProductName",      "The libssh2 library\0"
-      VALUE "ProductVersion",   LIBSSH2_VERSION "\0"
-      VALUE "LegalCopyright",   "© " LIBSSH2_COPYRIGHT "\0"
-      VALUE "License",          "https://www.libssh2.org/license.html\0"
-    END
-  END
-
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x409, 1200
-  END
-END
diff --git a/libssh2/libssh2/win32/libssh2_config.h b/libssh2/libssh2/win32/libssh2_config.h
deleted file mode 100644
index 6ac2ef43..00000000
--- a/libssh2/libssh2/win32/libssh2_config.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef LIBSSH2_CONFIG_H
-#define LIBSSH2_CONFIG_H
-
-#ifndef WIN32
-#define WIN32
-#endif
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE 1
-#endif /* _CRT_SECURE_NO_DEPRECATE */
-#include <winsock2.h>
-#include <mswsock.h>
-#include <ws2tcpip.h>
-
-#ifdef __MINGW32__
-#define HAVE_UNISTD_H
-#define HAVE_INTTYPES_H
-#define HAVE_SYS_TIME_H
-#define HAVE_GETTIMEOFDAY
-#endif /* __MINGW32__ */
-
-#define HAVE_LIBCRYPT32
-#define HAVE_WINSOCK2_H
-#define HAVE_IOCTLSOCKET
-#define HAVE_SELECT
-
-#ifdef _MSC_VER
-#if _MSC_VER < 1900
-#define snprintf _snprintf
-#if _MSC_VER < 1500
-#define vsnprintf _vsnprintf
-#endif
-#define strdup _strdup
-#define strncasecmp _strnicmp
-#define strcasecmp _stricmp
-#endif
-#else
-#ifndef __MINGW32__
-#define strncasecmp strnicmp
-#define strcasecmp stricmp
-#endif /* __MINGW32__ */
-#endif /* _MSC_VER */
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#define LIBSSH2_DH_GEX_NEW 1
-
-#endif /* LIBSSH2_CONFIG_H */
-
diff --git a/libssh2/libssh2/win32/msvcproj.foot b/libssh2/libssh2/win32/msvcproj.foot
deleted file mode 100644
index 07defa46..00000000
--- a/libssh2/libssh2/win32/msvcproj.foot
+++ /dev/null
@@ -1,3 +0,0 @@
-# End Target
-# End Project
-
diff --git a/libssh2/libssh2/win32/msvcproj.head b/libssh2/libssh2/win32/msvcproj.head
deleted file mode 100644
index eb820201..00000000
--- a/libssh2/libssh2/win32/msvcproj.head
+++ /dev/null
@@ -1,256 +0,0 @@
-# Microsoft Developer Studio Project File - Name="libssh2" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-# only OpenSSL and WinCNG are supported with this build system
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=libssh2 - Win32 OpenSSL Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak" CFG="libssh2 - Win32 DLL Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ENDIF
-
-# Begin Target
-
-# Name "libssh2 - Win32 OpenSSL DLL Release"
-# Name "libssh2 - Win32 OpenSSL DLL Debug"
-# Name "libssh2 - Win32 OpenSSL LIB Release"
-# Name "libssh2 - Win32 OpenSSL LIB Debug"
-# Name "libssh2 - Win32 WinCNG DLL Release"
-# Name "libssh2 - Win32 WinCNG DLL Debug"
-# Name "libssh2 - Win32 WinCNG LIB Release"
-# Name "libssh2 - Win32 WinCNG LIB Debug"
-
diff --git a/libssh2/libssh2/win32/rules.mk b/libssh2/libssh2/win32/rules.mk
deleted file mode 100644
index bfb77847..00000000
--- a/libssh2/libssh2/win32/rules.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-
-all-sub: $(INTDIR) all
-
-clean-sub: clean
-
-$(INTDIR):
-!if "$(SRCDIR)" == ""
-	@if not exist $(TARGET) mkdir $(TARGET)
-!endif
-	@if not exist $(INTDIR) mkdir $(INTDIR)
-
-{$(SUBDIR)}.c{$(INTDIR)}.obj::
-	$(CC) -c $(CFLAGS) /Fo"$(INTDIR)\\" $<
-
-
diff --git a/libssh2/libssh2/win32/test/GNUmakefile b/libssh2/libssh2/win32/test/GNUmakefile
deleted file mode 100644
index 5cf6e8cf..00000000
--- a/libssh2/libssh2/win32/test/GNUmakefile
+++ /dev/null
@@ -1,283 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 samples (Win32 version - gnu make)
-## Use: make -f GNUmakefile [help]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8zc
-endif
-
-# Project root
-PROOT	= ../..
-
-# Edit the var below to enable static linking of libssh2 and libz
-LINK_STATIC = 1
-
-# Edit the vars below to change target settings.
-SAMPLES	= $(PROOT)/example
-TARGETS := $(filter-out x11.exe,$(patsubst $(SAMPLES)/%.c,%.exe,$(strip $(wildcard $(SAMPLES)/*.c))))
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(subst .rc,,$(notdir $@)) $(LIBSSH2_VERSION_STR)
-#STACK	= 64000
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OBJDIR	= debug
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK     = awk
-ZIP     = zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# The following line defines your compiler.
-ifdef METROWERKS
-	CC = mwcc
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Set environment var ARCH to your architecture to override autodetection.
-ifndef ARCH
-ifeq ($(findstring gcc,$(CC)),gcc)
-ifeq ($(findstring x86_64,$(shell $(CC) -dumpmachine)),x86_64)
-ARCH	= w64
-else
-ARCH	= w32
-endif
-else
-ARCH	= w32
-endif
-endif
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	= $(OPT) -D$(DB) -DLIBSSH2_WIN32 # -DHAVE_CONFIG_H
-
-ifeq ($(CC),mwcc)
-LD	= mwld
-RC	= mwwinrc
-LDFLAGS	= -nostdlib
-AR	= $(LD)
-ARFLAGS	= -nostdlib -library -o
-LIBEXT	= lib
-LIBPATH	+= -lr "$(METROWERKS)/MSL" -lr "$(METROWERKS)/Win32-x86 Support"
-LDLIBS	+= -lMSL_Runtime_x86.lib -lMSL_C_x86.lib -lMSL_Extras_x86.lib
-LDLIBS	+= -lkernel32.lib -luser32.lib -lwsock32.lib
-RCFLAGS	=
-CFLAGS	+= -nostdinc -gccinc -msgstyle gcc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -ir "$(METROWERKS)/MSL" -ir "$(METROWERKS)/Win32-x86 Support"
-CFLAGS	+= -w on,nounused,nounusedexpr # -ansi strict
-else
-LD	= $(CROSSPREFIX)gcc
-RC	= $(CROSSPREFIX)windres
-LDFLAGS	= -s
-AR	= $(CROSSPREFIX)ar
-ARFLAGS	= -cq
-LIBEXT	= a
-#LDLIBS	+= -lwsock32
-LDLIBS	+= -lws2_32
-RCFLAGS	= -I $(PROOT)/include -O coff
-CFLAGS	+= -fno-builtin
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall #-Wno-unused #-pedantic
-ifeq ($(ARCH),w64)
-CFLAGS	+= -D_AMD64_
-RCFLAGS	+= -F pe-x86-64
-else
-CFLAGS	+= -m32
-RCFLAGS	+= -F pe-i386
-endif
-endif
-
-INCLUDES = -I$(PROOT)/win32 -I$(PROOT)/include
-LIBPATH += -L$(PROOT)/win32
-
-ifdef LINK_STATIC
-	LDLIBS += -llibssh2
-else
-	LDLIBS += -llibssh2dll
-endif
-
-ifdef WITH_WINCNG
-# CFLAGS	+= -DLIBSSH2_WINCNG
-LDLIBS	+= -lbcrypt -lcrypt32
-else
-# CFLAGS	+= -DLIBSSH2_OPENSSL
-ifndef OPENSSL_INCLUDE
-	ifeq "$(wildcard $(OPENSSL_PATH)/outinc)" "$(OPENSSL_PATH)/outinc"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/outinc
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/include)" "$(OPENSSL_PATH)/include"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/include
-	endif
-endif
-ifneq "$(wildcard $(OPENSSL_INCLUDE)/openssl/opensslv.h)" "$(OPENSSL_INCLUDE)/openssl/opensslv.h"
-$(error Invalid OPENSSL_PATH: $(OPENSSL_PATH))
-endif
-INCLUDES += -I"$(OPENSSL_INCLUDE)"
-ifndef OPENSSL_LIBPATH
-	OPENSSL_LIBS_STAT = crypto ssl
-	ifeq "$(wildcard $(OPENSSL_PATH)/out)" "$(OPENSSL_PATH)/out"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/out
-		OPENSSL_LIBS_DYN = eay32 ssl32
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/lib)" "$(OPENSSL_PATH)/lib"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/lib
-		OPENSSL_LIBS_DYN = crypto.dll ssl.dll
-	endif
-endif
-ifdef LINK_STATIC
-ifdef LINK_OPENSSL_STATIC
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_STAT)) -lgdi32
-else
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_DYN))
-endif
-endif
-endif
-
-ifdef WITH_ZLIB
-	CFLAGS += -DLIBSSH2_HAVE_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-	ifdef LINK_ZLIB_STATIC
-		LDLIBS += $(ZLIB_PATH)/libz.$(LIBEXT)
-	else
-		LDLIBS += $(ZLIB_PATH)/libzdll.$(LIBEXT)
-	endif
-endif
-
-CFLAGS	+= $(INCLUDES)
-
-vpath %.c $(PROOT)/example
-
-.PRECIOUS: $(OBJDIR)/%.o $(OBJDIR)/%.rc $(OBJDIR)/%.res
-
-
-all: prebuild $(TARGETS)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: $(PROOT)/include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $(PROOT)/get_ver.awk $< > $@
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-clean: objclean
-	$(call DEL, $(TARGETS))
-
-$(OBJDIR):
-	$(call MKDIR, $@)
-
-%.exe: $(OBJDIR)/%.o $(OBJDIR)/%.res
-	@echo Linking $@
-	@$(call DEL, $@)
-	$(LD) $(LDFLAGS) $^ -o $@ $(LIBPATH) $(LDLIBS)
-
-$(OBJDIR)/%.res: $(OBJDIR)/%.rc
-	@echo Creating $@
-	@$(RC) $(RCFLAGS) -i $< -o $@
-
-$(OBJDIR)/%.rc: GNUmakefile $(OBJDIR)/version.inc
-	@echo $(DL)1 VERSIONINFO$(DL) > $@
-	@echo $(DL) FILEVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) PRODUCTVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) FILEFLAGSMASK 0x3fL$(DL) >> $@
-	@echo $(DL) FILEOS 0x40004L$(DL) >> $@
-	@echo $(DL) FILEFLAGS 0x0L$(DL) >> $@
-	@echo $(DL) FILETYPE 0x1L$(DL) >> $@
-	@echo $(DL) FILESUBTYPE 0x0L$(DL) >> $@
-	@echo $(DL)BEGIN$(DL) >> $@
-	@echo $(DL)  BLOCK "StringFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    BLOCK "040904E4"$(DL) >> $@
-	@echo $(DL)    BEGIN$(DL) >> $@
-	@echo $(DL)      VALUE "LegalCopyright","\xA9 $(LIBSSH2_COPYRIGHT_STR)\0"$(DL) >> $@
-ifdef COMPANY
-	@echo $(DL)      VALUE "CompanyName","$(COMPANY)\0"$(DL) >> $@
-endif
-	@echo $(DL)      VALUE "ProductName","$(notdir $(@:.rc=.exe))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "ProductVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "License","Released under GPL.\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileDescription","$(DESCR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "InternalName","$(notdir $(@:.rc=))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "OriginalFilename","$(notdir $(@:.rc=.exe))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "WWW","$(WWWURL)\0"$(DL) >> $@
-	@echo $(DL)    END$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)  BLOCK "VarFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    VALUE "Translation", 0x409, 1252$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)END$(DL) >> $@
-ifdef ICON
-	@echo $(DL)10 ICON DISCARDABLE "$(ICON)"$(DL) >> $@
-endif
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)===========================================================$(DL)
-
-
diff --git a/libssh2/libssh2/win32/tests.dsp b/libssh2/libssh2/win32/tests.dsp
deleted file mode 100644
index b6df3241..00000000
--- a/libssh2/libssh2/win32/tests.dsp
+++ /dev/null
@@ -1,102 +0,0 @@
-# Microsoft Developer Studio Project File - Name="tests" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=tests - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "tests.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "tests.mak" CFG="tests - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "tests - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "tests - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "tests - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "tests___Win32_Release"
-# PROP BASE Intermediate_Dir "tests___Win32_Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\include" /I "..\win32" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2.lib /nologo /subsystem:console /machine:I386 /libpath:"Release" /out:"simple.exe"
-
-!ELSEIF  "$(CFG)" == "tests - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "tests___Win32_Debug"
-# PROP BASE Intermediate_Dir "tests___Win32_Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\include" /I "..\win32" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2d.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /pdbtype:sept /libpath:"Debug" /out:"simple.exe"
-
-!ENDIF 
-
-# Begin Target
-
-# Name "tests - Win32 Release"
-# Name "tests - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\tests\simple.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project
diff --git a/libssh2/ltmain.sh b/libssh2/ltmain.sh
index 21e5e078..9b12fbb7 100755
--- a/libssh2/ltmain.sh
+++ b/libssh2/ltmain.sh
@@ -1,12 +1,12 @@
-#! /bin/sh
+#! /usr/bin/env sh
 ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
-##               by inline-source v2014-01-03.01
+##               by inline-source v2019-02-19.15
 
-# libtool (GNU libtool) 2.4.6
+# libtool (GNU libtool) 2.4.7
 # Provide generalized library-building support services.
 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
-# Copyright (C) 1996-2015 Free Software Foundation, Inc.
+# Copyright (C) 1996-2019, 2021-2022 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
@@ -31,8 +31,8 @@
 
 PROGRAM=libtool
 PACKAGE=libtool
-VERSION="2.4.6 Debian-2.4.6-15"
-package_revision=2.4.6
+VERSION="2.4.7 Debian-2.4.7-5"
+package_revision=2.4.7
 
 
 ## ------ ##
@@ -64,34 +64,25 @@ package_revision=2.4.6
 # libraries, which are installed to $pkgauxdir.
 
 # Set a version string for this script.
-scriptversion=2015-01-20.17; # UTC
+scriptversion=2019-02-19.15; # UTC
 
 # General shell script boiler plate, and helper functions.
 # Written by Gary V. Vaughan, 2004
 
-# Copyright (C) 2004-2015 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-
-# As a special exception to the GNU General Public License, if you distribute
-# this file as part of a program or library that is built using GNU Libtool,
-# you may include this file under the same distribution terms that you use
-# for the rest of that program.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
-# General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# This is free software.  There is NO warranty; not even for
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Copyright (C) 2004-2019, 2021 Bootstrap Authors
+#
+# This file is dual licensed under the terms of the MIT license
+# <https://opensource.org/license/MIT>, and GPL version 2 or later
+# <http://www.gnu.org/licenses/gpl-2.0.html>.  You must apply one of
+# these licenses when using or redistributing this software or any of
+# the files within it.  See the URLs above, or the file `LICENSE`
+# included in the Bootstrap distribution for the full license texts.
 
-# Please report bugs or propose patches to gary@gnu.org.
+# Please report bugs or propose patches to:
+# <https://github.com/gnulib-modules/bootstrap/issues>
 
 
 ## ------ ##
@@ -139,9 +130,12 @@ do
 	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
 	fi"
 done
-
-# CDPATH.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+# These NLS vars are set unconditionally (bootstrap issue #24).  Unset those
+# in case the environment reset is needed later and the $save_* variant is not
+# defined (see the code above).
+LC_ALL=C
+LANGUAGE=C
+export LANGUAGE LC_ALL
 
 # Make sure IFS has a sensible default
 sp=' '
@@ -159,6 +153,26 @@ if test "${PATH_SEPARATOR+set}" != set; then
 fi
 
 
+# func_unset VAR
+# --------------
+# Portably unset VAR.
+# In some shells, an 'unset VAR' statement leaves a non-zero return
+# status if VAR is already unset, which might be problematic if the
+# statement is used at the end of a function (thus poisoning its return
+# value) or when 'set -e' is active (causing even a spurious abort of
+# the script in this case).
+func_unset ()
+{
+    { eval $1=; (eval unset $1) >/dev/null 2>&1 && eval unset $1 || : ; }
+}
+
+
+# Make sure CDPATH doesn't cause `cd` commands to output the target dir.
+func_unset CDPATH
+
+# Make sure ${,E,F}GREP behave sanely.
+func_unset GREP_OPTIONS
+
 
 ## ------------------------- ##
 ## Locate command utilities. ##
@@ -259,7 +273,7 @@ test -z "$SED" && {
     rm -f conftest.in conftest.tmp conftest.nl conftest.out
   }
 
-  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  func_path_progs "sed gsed" func_check_prog_sed "$PATH:/usr/xpg4/bin"
   rm -f conftest.sed
   SED=$func_path_progs_result
 }
@@ -295,7 +309,7 @@ test -z "$GREP" && {
     rm -f conftest.in conftest.tmp conftest.nl conftest.out
   }
 
-  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  func_path_progs "grep ggrep" func_check_prog_grep "$PATH:/usr/xpg4/bin"
   GREP=$func_path_progs_result
 }
 
@@ -360,6 +374,35 @@ sed_double_backslash="\
   s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
   s/\n//g"
 
+# require_check_ifs_backslash
+# ---------------------------
+# Check if we can use backslash as IFS='\' separator, and set
+# $check_ifs_backshlash_broken to ':' or 'false'.
+require_check_ifs_backslash=func_require_check_ifs_backslash
+func_require_check_ifs_backslash ()
+{
+  _G_save_IFS=$IFS
+  IFS='\'
+  _G_check_ifs_backshlash='a\\b'
+  for _G_i in $_G_check_ifs_backshlash
+  do
+  case $_G_i in
+  a)
+    check_ifs_backshlash_broken=false
+    ;;
+  '')
+    break
+    ;;
+  *)
+    check_ifs_backshlash_broken=:
+    break
+    ;;
+  esac
+  done
+  IFS=$_G_save_IFS
+  require_check_ifs_backslash=:
+}
+
 
 ## ----------------- ##
 ## Global variables. ##
@@ -580,16 +623,16 @@ if test yes = "$_G_HAVE_PLUSEQ_OP"; then
   {
     $debug_cmd
 
-    func_quote_for_eval "$2"
-    eval "$1+=\\ \$func_quote_for_eval_result"
+    func_quote_arg pretty "$2"
+    eval "$1+=\\ \$func_quote_arg_result"
   }'
 else
   func_append_quoted ()
   {
     $debug_cmd
 
-    func_quote_for_eval "$2"
-    eval "$1=\$$1\\ \$func_quote_for_eval_result"
+    func_quote_arg pretty "$2"
+    eval "$1=\$$1\\ \$func_quote_arg_result"
   }
 fi
 
@@ -1091,85 +1134,203 @@ func_relative_path ()
 }
 
 
-# func_quote_for_eval ARG...
-# --------------------------
-# Aesthetically quote ARGs to be evaled later.
-# This function returns two values:
-#   i) func_quote_for_eval_result
-#      double-quoted, suitable for a subsequent eval
-#  ii) func_quote_for_eval_unquoted_result
-#      has all characters that are still active within double
-#      quotes backslashified.
-func_quote_for_eval ()
+# func_quote_portable EVAL ARG
+# ----------------------------
+# Internal function to portably implement func_quote_arg.  Note that we still
+# keep attention to performance here so we as much as possible try to avoid
+# calling sed binary (so far O(N) complexity as long as func_append is O(1)).
+func_quote_portable ()
 {
     $debug_cmd
 
-    func_quote_for_eval_unquoted_result=
-    func_quote_for_eval_result=
-    while test 0 -lt $#; do
-      case $1 in
-        *[\\\`\"\$]*)
-	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
-        *)
-          _G_unquoted_arg=$1 ;;
-      esac
-      if test -n "$func_quote_for_eval_unquoted_result"; then
-	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
-      else
-        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
+    $require_check_ifs_backslash
+
+    func_quote_portable_result=$2
+
+    # one-time-loop (easy break)
+    while true
+    do
+      if $1; then
+        func_quote_portable_result=`$ECHO "$2" | $SED \
+          -e "$sed_double_quote_subst" -e "$sed_double_backslash"`
+        break
       fi
 
-      case $_G_unquoted_arg in
-        # Double-quote args containing shell metacharacters to delay
-        # word splitting, command substitution and variable expansion
-        # for a subsequent eval.
-        # Many Bourne shells cannot handle close brackets correctly
-        # in scan sets, so we specify it separately.
-        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-          _G_quoted_arg=\"$_G_unquoted_arg\"
+      # Quote for eval.
+      case $func_quote_portable_result in
+        *[\\\`\"\$]*)
+          # Fallback to sed for $func_check_bs_ifs_broken=:, or when the string
+          # contains the shell wildcard characters.
+          case $check_ifs_backshlash_broken$func_quote_portable_result in
+            :*|*[\[\*\?]*)
+              func_quote_portable_result=`$ECHO "$func_quote_portable_result" \
+                  | $SED "$sed_quote_subst"`
+              break
+              ;;
+          esac
+
+          func_quote_portable_old_IFS=$IFS
+          for _G_char in '\' '`' '"' '$'
+          do
+            # STATE($1) PREV($2) SEPARATOR($3)
+            set start "" ""
+            func_quote_portable_result=dummy"$_G_char$func_quote_portable_result$_G_char"dummy
+            IFS=$_G_char
+            for _G_part in $func_quote_portable_result
+            do
+              case $1 in
+              quote)
+                func_append func_quote_portable_result "$3$2"
+                set quote "$_G_part" "\\$_G_char"
+                ;;
+              start)
+                set first "" ""
+                func_quote_portable_result=
+                ;;
+              first)
+                set quote "$_G_part" ""
+                ;;
+              esac
+            done
+          done
+          IFS=$func_quote_portable_old_IFS
           ;;
-        *)
-          _G_quoted_arg=$_G_unquoted_arg
-	  ;;
+        *) ;;
       esac
-
-      if test -n "$func_quote_for_eval_result"; then
-	func_append func_quote_for_eval_result " $_G_quoted_arg"
-      else
-        func_append func_quote_for_eval_result "$_G_quoted_arg"
-      fi
-      shift
+      break
     done
+
+    func_quote_portable_unquoted_result=$func_quote_portable_result
+    case $func_quote_portable_result in
+      # double-quote args containing shell metacharacters to delay
+      # word splitting, command substitution and variable expansion
+      # for a subsequent eval.
+      # many bourne shells cannot handle close brackets correctly
+      # in scan sets, so we specify it separately.
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
+        func_quote_portable_result=\"$func_quote_portable_result\"
+        ;;
+    esac
 }
 
 
-# func_quote_for_expand ARG
-# -------------------------
-# Aesthetically quote ARG to be evaled later; same as above,
-# but do not quote variable references.
-func_quote_for_expand ()
-{
-    $debug_cmd
+# func_quotefast_eval ARG
+# -----------------------
+# Quote one ARG (internal).  This is equivalent to 'func_quote_arg eval ARG',
+# but optimized for speed.  Result is stored in $func_quotefast_eval.
+if test xyes = `(x=; printf -v x %q yes; echo x"$x") 2>/dev/null`; then
+  printf -v _GL_test_printf_tilde %q '~'
+  if test '\~' = "$_GL_test_printf_tilde"; then
+    func_quotefast_eval ()
+    {
+      printf -v func_quotefast_eval_result %q "$1"
+    }
+  else
+    # Broken older Bash implementations.  Make those faster too if possible.
+    func_quotefast_eval ()
+    {
+      case $1 in
+        '~'*)
+          func_quote_portable false "$1"
+          func_quotefast_eval_result=$func_quote_portable_result
+          ;;
+        *)
+          printf -v func_quotefast_eval_result %q "$1"
+          ;;
+      esac
+    }
+  fi
+else
+  func_quotefast_eval ()
+  {
+    func_quote_portable false "$1"
+    func_quotefast_eval_result=$func_quote_portable_result
+  }
+fi
 
-    case $1 in
-      *[\\\`\"]*)
-	_G_arg=`$ECHO "$1" | $SED \
-	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
-      *)
-        _G_arg=$1 ;;
+
+# func_quote_arg MODEs ARG
+# ------------------------
+# Quote one ARG to be evaled later.  MODEs argument may contain zero or more
+# specifiers listed below separated by ',' character.  This function returns two
+# values:
+#   i) func_quote_arg_result
+#      double-quoted (when needed), suitable for a subsequent eval
+#  ii) func_quote_arg_unquoted_result
+#      has all characters that are still active within double
+#      quotes backslashified.  Available only if 'unquoted' is specified.
+#
+# Available modes:
+# ----------------
+# 'eval' (default)
+#       - escape shell special characters
+# 'expand'
+#       - the same as 'eval';  but do not quote variable references
+# 'pretty'
+#       - request aesthetic output, i.e. '"a b"' instead of 'a\ b'.  This might
+#         be used later in func_quote to get output like: 'echo "a b"' instead
+#         of 'echo a\ b'.  This is slower than default on some shells.
+# 'unquoted'
+#       - produce also $func_quote_arg_unquoted_result which does not contain
+#         wrapping double-quotes.
+#
+# Examples for 'func_quote_arg pretty,unquoted string':
+#
+#   string      | *_result              | *_unquoted_result
+#   ------------+-----------------------+-------------------
+#   "           | \"                    | \"
+#   a b         | "a b"                 | a b
+#   "a b"       | "\"a b\""             | \"a b\"
+#   *           | "*"                   | *
+#   z="${x-$y}" | "z=\"\${x-\$y}\""     | z=\"\${x-\$y}\"
+#
+# Examples for 'func_quote_arg pretty,unquoted,expand string':
+#
+#   string        |   *_result          |  *_unquoted_result
+#   --------------+---------------------+--------------------
+#   z="${x-$y}"   | "z=\"${x-$y}\""     | z=\"${x-$y}\"
+func_quote_arg ()
+{
+    _G_quote_expand=false
+    case ,$1, in
+      *,expand,*)
+        _G_quote_expand=:
+        ;;
     esac
 
-    case $_G_arg in
-      # Double-quote args containing shell metacharacters to delay
-      # word splitting and command substitution for a subsequent eval.
-      # Many Bourne shells cannot handle close brackets correctly
-      # in scan sets, so we specify it separately.
-      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
-        _G_arg=\"$_G_arg\"
+    case ,$1, in
+      *,pretty,*|*,expand,*|*,unquoted,*)
+        func_quote_portable $_G_quote_expand "$2"
+        func_quote_arg_result=$func_quote_portable_result
+        func_quote_arg_unquoted_result=$func_quote_portable_unquoted_result
+        ;;
+      *)
+        # Faster quote-for-eval for some shells.
+        func_quotefast_eval "$2"
+        func_quote_arg_result=$func_quotefast_eval_result
         ;;
     esac
+}
+
 
-    func_quote_for_expand_result=$_G_arg
+# func_quote MODEs ARGs...
+# ------------------------
+# Quote all ARGs to be evaled later and join them into single command.  See
+# func_quote_arg's description for more info.
+func_quote ()
+{
+    $debug_cmd
+    _G_func_quote_mode=$1 ; shift
+    func_quote_result=
+    while test 0 -lt $#; do
+      func_quote_arg "$_G_func_quote_mode" "$1"
+      if test -n "$func_quote_result"; then
+        func_append func_quote_result " $func_quote_arg_result"
+      else
+        func_append func_quote_result "$func_quote_arg_result"
+      fi
+      shift
+    done
 }
 
 
@@ -1215,8 +1376,8 @@ func_show_eval ()
     _G_cmd=$1
     _G_fail_exp=${2-':'}
 
-    func_quote_for_expand "$_G_cmd"
-    eval "func_notquiet $func_quote_for_expand_result"
+    func_quote_arg pretty,expand "$_G_cmd"
+    eval "func_notquiet $func_quote_arg_result"
 
     $opt_dry_run || {
       eval "$_G_cmd"
@@ -1241,8 +1402,8 @@ func_show_eval_locale ()
     _G_fail_exp=${2-':'}
 
     $opt_quiet || {
-      func_quote_for_expand "$_G_cmd"
-      eval "func_echo $func_quote_for_expand_result"
+      func_quote_arg expand,pretty "$_G_cmd"
+      eval "func_echo $func_quote_arg_result"
     }
 
     $opt_dry_run || {
@@ -1369,30 +1530,26 @@ func_lt_ver ()
 # End:
 #! /bin/sh
 
-# Set a version string for this script.
-scriptversion=2015-10-07.11; # UTC
-
 # A portable, pluggable option parser for Bourne shell.
 # Written by Gary V. Vaughan, 2010
 
-# Copyright (C) 2010-2015 Free Software Foundation, Inc.
-# This is free software; see the source for copying conditions.  There is NO
-# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
+# This is free software.  There is NO warranty; not even for
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# Copyright (C) 2010-2019, 2021 Bootstrap Authors
+#
+# This file is dual licensed under the terms of the MIT license
+# <https://opensource.org/license/MIT>, and GPL version 2 or later
+# <http://www.gnu.org/licenses/gpl-2.0.html>.  You must apply one of
+# these licenses when using or redistributing this software or any of
+# the files within it.  See the URLs above, or the file `LICENSE`
+# included in the Bootstrap distribution for the full license texts.
 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
+# Please report bugs or propose patches to:
+# <https://github.com/gnulib-modules/bootstrap/issues>
 
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-# Please report bugs or propose patches to gary@gnu.org.
+# Set a version string for this script.
+scriptversion=2019-02-19.15; # UTC
 
 
 ## ------ ##
@@ -1415,7 +1572,7 @@ scriptversion=2015-10-07.11; # UTC
 #
 # In order for the '--version' option to work, you will need to have a
 # suitably formatted comment like the one at the top of this file
-# starting with '# Written by ' and ending with '# warranty; '.
+# starting with '# Written by ' and ending with '# Copyright'.
 #
 # For '-h' and '--help' to work, you will also need a one line
 # description of your script's purpose in a comment directly above the
@@ -1427,7 +1584,7 @@ scriptversion=2015-10-07.11; # UTC
 # to display verbose messages only when your user has specified
 # '--verbose'.
 #
-# After sourcing this file, you can plug processing for additional
+# After sourcing this file, you can plug in processing for additional
 # options by amending the variables from the 'Configuration' section
 # below, and following the instructions in the 'Option parsing'
 # section further down.
@@ -1476,8 +1633,8 @@ fatal_help="Try '\$progname --help' for more information."
 ## ------------------------- ##
 
 # This section contains functions for adding, removing, and running hooks
-# to the main code.  A hook is just a named list of of function, that can
-# be run in order later on.
+# in the main code.  A hook is just a list of function names that can be
+# run in order later on.
 
 # func_hookable FUNC_NAME
 # -----------------------
@@ -1510,7 +1667,8 @@ func_add_hook ()
 
 # func_remove_hook FUNC_NAME HOOK_FUNC
 # ------------------------------------
-# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
+# Remove HOOK_FUNC from the list of hook functions to be called by
+# FUNC_NAME.
 func_remove_hook ()
 {
     $debug_cmd
@@ -1519,10 +1677,28 @@ func_remove_hook ()
 }
 
 
+# func_propagate_result FUNC_NAME_A FUNC_NAME_B
+# ---------------------------------------------
+# If the *_result variable of FUNC_NAME_A _is set_, assign its value to
+# *_result variable of FUNC_NAME_B.
+func_propagate_result ()
+{
+    $debug_cmd
+
+    func_propagate_result_result=:
+    if eval "test \"\${${1}_result+set}\" = set"
+    then
+      eval "${2}_result=\$${1}_result"
+    else
+      func_propagate_result_result=false
+    fi
+}
+
+
 # func_run_hooks FUNC_NAME [ARG]...
 # ---------------------------------
 # Run all hook functions registered to FUNC_NAME.
-# It is assumed that the list of hook functions contains nothing more
+# It's assumed that the list of hook functions contains nothing more
 # than a whitespace-delimited list of legal shell function names, and
 # no effort is wasted trying to catch shell meta-characters or preserve
 # whitespace.
@@ -1534,22 +1710,19 @@ func_run_hooks ()
 
     case " $hookable_fns " in
       *" $1 "*) ;;
-      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+      *) func_fatal_error "'$1' does not support hook functions." ;;
     esac
 
     eval _G_hook_fns=\$$1_hooks; shift
 
     for _G_hook in $_G_hook_fns; do
-      if eval $_G_hook '"$@"'; then
-        # store returned options list back into positional
-        # parameters for next 'cmd' execution.
-        eval _G_hook_result=\$${_G_hook}_result
-        eval set dummy "$_G_hook_result"; shift
-        _G_rc_run_hooks=:
+      func_unset "${_G_hook}_result"
+      eval $_G_hook '${1+"$@"}'
+      func_propagate_result $_G_hook func_run_hooks
+      if $func_propagate_result_result; then
+        eval set dummy "$func_run_hooks_result"; shift
       fi
     done
-
-    $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
 }
 
 
@@ -1559,14 +1732,16 @@ func_run_hooks ()
 ## --------------- ##
 
 # In order to add your own option parsing hooks, you must accept the
-# full positional parameter list in your hook function, you may remove/edit
-# any options that you action, and then pass back the remaining unprocessed
-# options in '<hooked_function_name>_result', escaped suitably for
-# 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
-# hook's caller know that it should pay attention to
-# '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
-# arguments are left untouched by the hook and therefore caller will ignore the
-# result variable.
+# full positional parameter list from your hook function.  You may remove
+# or edit any options that you action, and then pass back the remaining
+# unprocessed options in '<hooked_function_name>_result', escaped
+# suitably for 'eval'.
+#
+# The '<hooked_function_name>_result' variable is automatically unset
+# before your hook gets called; for best performance, only set the
+# *_result variable when necessary (i.e. don't call the 'func_quote'
+# function unnecessarily because it can be an expensive operation on some
+# machines).
 #
 # Like this:
 #
@@ -1578,11 +1753,8 @@ func_run_hooks ()
 #        usage_message=$usage_message'
 #      -s, --silent       don'\''t print informational messages
 #    '
-#        # No change in '$@' (ignored completely by this hook).  There is
-#        # no need to do the equivalent (but slower) action:
-#        # func_quote_for_eval ${1+"$@"}
-#        # my_options_prep_result=$func_quote_for_eval_result
-#        false
+#        # No change in '$@' (ignored completely by this hook).  Leave
+#        # my_options_prep_result variable intact.
 #    }
 #    func_add_hook func_options_prep my_options_prep
 #
@@ -1593,7 +1765,7 @@ func_run_hooks ()
 #
 #        args_changed=false
 #
-#        # Note that for efficiency, we parse as many options as we can
+#        # Note that, for efficiency, we parse as many options as we can
 #        # recognise in a loop before passing the remainder back to the
 #        # caller on the first unrecognised argument we encounter.
 #        while test $# -gt 0; do
@@ -1610,18 +1782,17 @@ func_run_hooks ()
 #                         args_changed=:
 #                         ;;
 #            *)           # Make sure the first unrecognised option "$_G_opt"
-#                         # is added back to "$@", we could need that later
-#                         # if $args_changed is true.
+#                         # is added back to "$@" in case we need it later,
+#                         # if $args_changed was set to 'true'.
 #                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
 #          esac
 #        done
 #
+#        # Only call 'func_quote' here if we processed at least one argument.
 #        if $args_changed; then
-#          func_quote_for_eval ${1+"$@"}
-#          my_silent_option_result=$func_quote_for_eval_result
+#          func_quote eval ${1+"$@"}
+#          my_silent_option_result=$func_quote_result
 #        fi
-#
-#        $args_changed
 #    }
 #    func_add_hook func_parse_options my_silent_option
 #
@@ -1632,8 +1803,6 @@ func_run_hooks ()
 #
 #        $opt_silent && $opt_verbose && func_fatal_help "\
 #    '--silent' and '--verbose' options are mutually exclusive."
-#
-#        false
 #    }
 #    func_add_hook func_validate_options my_option_validation
 #
@@ -1649,13 +1818,8 @@ func_options_finish ()
 {
     $debug_cmd
 
-    _G_func_options_finish_exit=false
-    if func_run_hooks func_options ${1+"$@"}; then
-      func_options_finish_result=$func_run_hooks_result
-      _G_func_options_finish_exit=:
-    fi
-
-    $_G_func_options_finish_exit
+    func_run_hooks func_options ${1+"$@"}
+    func_propagate_result func_run_hooks func_options_finish
 }
 
 
@@ -1668,28 +1832,27 @@ func_options ()
 {
     $debug_cmd
 
-    _G_rc_options=false
+    _G_options_quoted=false
 
     for my_func in options_prep parse_options validate_options options_finish
     do
-      if eval func_$my_func '${1+"$@"}'; then
-        eval _G_res_var='$'"func_${my_func}_result"
-        eval set dummy "$_G_res_var" ; shift
-        _G_rc_options=:
+      func_unset func_${my_func}_result
+      func_unset func_run_hooks_result
+      eval func_$my_func '${1+"$@"}'
+      func_propagate_result func_$my_func func_options
+      if $func_propagate_result_result; then
+        eval set dummy "$func_options_result"; shift
+        _G_options_quoted=:
       fi
     done
 
-    # Save modified positional parameters for caller.  As a top-level
-    # options-parser function we always need to set the 'func_options_result'
-    # variable (regardless the $_G_rc_options value).
-    if $_G_rc_options; then
-      func_options_result=$_G_res_var
-    else
-      func_quote_for_eval ${1+"$@"}
-      func_options_result=$func_quote_for_eval_result
-    fi
-
-    $_G_rc_options
+    $_G_options_quoted || {
+      # As we (func_options) are top-level options-parser function and
+      # nobody quoted "$@" for us yet, we need to do it explicitly for
+      # caller.
+      func_quote eval ${1+"$@"}
+      func_options_result=$func_quote_result
+    }
 }
 
 
@@ -1699,8 +1862,7 @@ func_options ()
 # Note that when calling hook functions, we pass through the list of
 # positional parameters.  If a hook function modifies that list, and
 # needs to propagate that back to rest of this script, then the complete
-# modified list must be put in 'func_run_hooks_result' before
-# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
+# modified list must be put in 'func_run_hooks_result' before returning.
 func_hookable func_options_prep
 func_options_prep ()
 {
@@ -1710,14 +1872,8 @@ func_options_prep ()
     opt_verbose=false
     opt_warning_types=
 
-    _G_rc_options_prep=false
-    if func_run_hooks func_options_prep ${1+"$@"}; then
-      _G_rc_options_prep=:
-      # save modified positional parameters for caller
-      func_options_prep_result=$func_run_hooks_result
-    fi
-
-    $_G_rc_options_prep
+    func_run_hooks func_options_prep ${1+"$@"}
+    func_propagate_result func_run_hooks func_options_prep
 }
 
 
@@ -1729,27 +1885,32 @@ func_parse_options ()
 {
     $debug_cmd
 
-    func_parse_options_result=
-
-    _G_rc_parse_options=false
+    _G_parse_options_requote=false
     # this just eases exit handling
     while test $# -gt 0; do
       # Defer to hook functions for initial option parsing, so they
       # get priority in the event of reusing an option name.
-      if func_run_hooks func_parse_options ${1+"$@"}; then
-        eval set dummy "$func_run_hooks_result"; shift
-        _G_rc_parse_options=:
+      func_run_hooks func_parse_options ${1+"$@"}
+      func_propagate_result func_run_hooks func_parse_options
+      if $func_propagate_result_result; then
+        eval set dummy "$func_parse_options_result"; shift
+        # Even though we may have changed "$@", we passed the "$@" array
+        # down into the hook and it quoted it for us (because we are in
+        # this if-branch).  No need to quote it again.
+        _G_parse_options_requote=false
       fi
 
       # Break out of the loop if we already parsed every option.
       test $# -gt 0 || break
 
+      # We expect that one of the options parsed in this function matches
+      # and thus we remove _G_opt from "$@" and need to re-quote.
       _G_match_parse_options=:
       _G_opt=$1
       shift
       case $_G_opt in
         --debug|-x)   debug_cmd='set -x'
-                      func_echo "enabling shell trace mode"
+                      func_echo "enabling shell trace mode" >&2
                       $debug_cmd
                       ;;
 
@@ -1760,7 +1921,7 @@ func_parse_options ()
 
         --warnings|--warning|-W)
                       if test $# = 0 && func_missing_arg $_G_opt; then
-                        _G_rc_parse_options=:
+                        _G_parse_options_requote=:
                         break
                       fi
                       case " $warning_categories $1" in
@@ -1815,7 +1976,7 @@ func_parse_options ()
                       shift
                       ;;
 
-        --)           _G_rc_parse_options=: ; break ;;
+        --)           _G_parse_options_requote=: ; break ;;
         -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
         *)            set dummy "$_G_opt" ${1+"$@"}; shift
                       _G_match_parse_options=false
@@ -1823,17 +1984,16 @@ func_parse_options ()
                       ;;
       esac
 
-      $_G_match_parse_options && _G_rc_parse_options=:
+      if $_G_match_parse_options; then
+        _G_parse_options_requote=:
+      fi
     done
 
-
-    if $_G_rc_parse_options; then
+    if $_G_parse_options_requote; then
       # save modified positional parameters for caller
-      func_quote_for_eval ${1+"$@"}
-      func_parse_options_result=$func_quote_for_eval_result
+      func_quote eval ${1+"$@"}
+      func_parse_options_result=$func_quote_result
     fi
-
-    $_G_rc_parse_options
 }
 
 
@@ -1846,21 +2006,14 @@ func_validate_options ()
 {
     $debug_cmd
 
-    _G_rc_validate_options=false
-
     # Display all warnings if -W was not given.
     test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
 
-    if func_run_hooks func_validate_options ${1+"$@"}; then
-      # save modified positional parameters for caller
-      func_validate_options_result=$func_run_hooks_result
-      _G_rc_validate_options=:
-    fi
+    func_run_hooks func_validate_options ${1+"$@"}
+    func_propagate_result func_run_hooks func_validate_options
 
     # Bail if the options were screwed!
     $exit_cmd $EXIT_FAILURE
-
-    $_G_rc_validate_options
 }
 
 
@@ -1916,8 +2069,8 @@ func_missing_arg ()
 
 # func_split_equals STRING
 # ------------------------
-# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
-# splitting STRING at the '=' sign.
+# Set func_split_equals_lhs and func_split_equals_rhs shell variables
+# after splitting STRING at the '=' sign.
 test -z "$_G_HAVE_XSI_OPS" \
     && (eval 'x=a/b/c;
       test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
@@ -1932,8 +2085,9 @@ then
 
       func_split_equals_lhs=${1%%=*}
       func_split_equals_rhs=${1#*=}
-      test "x$func_split_equals_lhs" = "x$1" \
-        && func_split_equals_rhs=
+      if test "x$func_split_equals_lhs" = "x$1"; then
+        func_split_equals_rhs=
+      fi
   }'
 else
   # ...otherwise fall back to using expr, which is often a shell builtin.
@@ -1943,7 +2097,7 @@ else
 
       func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
       func_split_equals_rhs=
-      test "x$func_split_equals_lhs" = "x$1" \
+      test "x$func_split_equals_lhs=" = "x$1" \
         || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
   }
 fi #func_split_equals
@@ -1969,7 +2123,7 @@ else
   {
       $debug_cmd
 
-      func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
+      func_split_short_opt_name=`expr "x$1" : 'x\(-.\)'`
       func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
   }
 fi #func_split_short_opt
@@ -2011,31 +2165,44 @@ func_usage_message ()
 # func_version
 # ------------
 # Echo version message to standard output and exit.
+# The version message is extracted from the calling file's header
+# comments, with leading '# ' stripped:
+#   1. First display the progname and version
+#   2. Followed by the header comment line matching  /^# Written by /
+#   3. Then a blank line followed by the first following line matching
+#      /^# Copyright /
+#   4. Immediately followed by any lines between the previous matches,
+#      except lines preceding the intervening completely blank line.
+# For example, see the header comments of this file.
 func_version ()
 {
     $debug_cmd
 
     printf '%s\n' "$progname $scriptversion"
     $SED -n '
-        /(C)/!b go
-        :more
-        /\./!{
-          N
-          s|\n# | |
-          b more
-        }
-        :go
-        /^# Written by /,/# warranty; / {
-          s|^# ||
-          s|^# *$||
-          s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
-          p
+        /^# Written by /!b
+        s|^# ||; p; n
+
+        :fwd2blnk
+        /./ {
+          n
+          b fwd2blnk
         }
-        /^# Written by / {
-          s|^# ||
-          p
+        p; n
+
+        :holdwrnt
+        s|^# ||
+        s|^# *$||
+        /^Copyright /!{
+          /./H
+          n
+          b holdwrnt
         }
-        /^warranty; /q' < "$progpath"
+
+        s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
+        G
+        s|\(\n\)\n*|\1|g
+        p; q' < "$progpath"
 
     exit $?
 }
@@ -2045,12 +2212,12 @@ func_version ()
 # mode: shell-script
 # sh-indentation: 2
 # eval: (add-hook 'before-save-hook 'time-stamp)
-# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-pattern: "30/scriptversion=%:y-%02m-%02d.%02H; # UTC"
 # time-stamp-time-zone: "UTC"
 # End:
 
 # Set a version string.
-scriptversion='(GNU libtool) 2.4.6'
+scriptversion='(GNU libtool) 2.4.7'
 
 
 # func_echo ARG...
@@ -2141,7 +2308,7 @@ include the following information:
        compiler:       $LTCC
        compiler flags: $LTCFLAGS
        linker:         $LD (gnu? $with_gnu_ld)
-       version:        $progname $scriptversion Debian-2.4.6-15
+       version:        $progname $scriptversion Debian-2.4.7-5
        automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
        autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
 
@@ -2197,7 +2364,7 @@ fi
 # a configuration failure hint, and exit.
 func_fatal_configuration ()
 {
-    func__fatal_error ${1+"$@"} \
+    func_fatal_error ${1+"$@"} \
       "See the $PACKAGE documentation for more information." \
       "Fatal configuration error."
 }
@@ -2345,6 +2512,8 @@ libtool_options_prep ()
 
     _G_rc_lt_options_prep=:
 
+    _G_rc_lt_options_prep=:
+
     # Shorthand for --mode=foo, only valid as the first argument
     case $1 in
     clean|clea|cle|cl)
@@ -2375,11 +2544,9 @@ libtool_options_prep ()
 
     if $_G_rc_lt_options_prep; then
       # Pass back the list of options.
-      func_quote_for_eval ${1+"$@"}
-      libtool_options_prep_result=$func_quote_for_eval_result
+      func_quote eval ${1+"$@"}
+      libtool_options_prep_result=$func_quote_result
     fi
-
-    $_G_rc_lt_options_prep
 }
 func_add_hook func_options_prep libtool_options_prep
 
@@ -2482,11 +2649,9 @@ libtool_parse_options ()
 
     if $_G_rc_lt_parse_options; then
       # save modified positional parameters for caller
-      func_quote_for_eval ${1+"$@"}
-      libtool_parse_options_result=$func_quote_for_eval_result
+      func_quote eval ${1+"$@"}
+      libtool_parse_options_result=$func_quote_result
     fi
-
-    $_G_rc_lt_parse_options
 }
 func_add_hook func_parse_options libtool_parse_options
 
@@ -2543,8 +2708,8 @@ libtool_validate_options ()
     }
 
     # Pass back the unparsed argument list
-    func_quote_for_eval ${1+"$@"}
-    libtool_validate_options_result=$func_quote_for_eval_result
+    func_quote eval ${1+"$@"}
+    libtool_validate_options_result=$func_quote_result
 }
 func_add_hook func_validate_options libtool_validate_options
 
@@ -3510,8 +3675,8 @@ func_mode_compile ()
       esac
     done
 
-    func_quote_for_eval "$libobj"
-    test "X$libobj" != "X$func_quote_for_eval_result" \
+    func_quote_arg pretty "$libobj"
+    test "X$libobj" != "X$func_quote_arg_result" \
       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
       && func_warning "libobj name '$libobj' may not contain shell special characters."
     func_dirname_and_basename "$obj" "/" ""
@@ -3584,8 +3749,8 @@ compiler."
 
     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
     srcfile=$func_to_tool_file_result
-    func_quote_for_eval "$srcfile"
-    qsrcfile=$func_quote_for_eval_result
+    func_quote_arg pretty "$srcfile"
+    qsrcfile=$func_quote_arg_result
 
     # Only build a PIC object if we are building libtool libraries.
     if test yes = "$build_libtool_libs"; then
@@ -3740,7 +3905,8 @@ This mode accepts the following additional options:
   -prefer-non-pic   try to build non-PIC objects only
   -shared           do not build a '.o' file suitable for static linking
   -static           only build a '.o' file suitable for static linking
-  -Wc,FLAG          pass FLAG directly to the compiler
+  -Wc,FLAG
+  -Xcompiler FLAG   pass FLAG directly to the compiler
 
 COMPILE-COMMAND is a command to be used in creating a 'standard' object file
 from the given SOURCEFILE.
@@ -3846,6 +4012,8 @@ The following components of LINK-COMMAND are treated specially:
   -weak LIBNAME     declare that the target provides the LIBNAME interface
   -Wc,FLAG
   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wa,FLAG
+  -Xassembler FLAG  pass linker-specific FLAG directly to the assembler
   -Wl,FLAG
   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
@@ -4188,8 +4356,8 @@ func_mode_install ()
        case $nonopt in *shtool*) :;; *) false;; esac
     then
       # Aesthetically quote it.
-      func_quote_for_eval "$nonopt"
-      install_prog="$func_quote_for_eval_result "
+      func_quote_arg pretty "$nonopt"
+      install_prog="$func_quote_arg_result "
       arg=$1
       shift
     else
@@ -4199,8 +4367,8 @@ func_mode_install ()
 
     # The real first argument should be the name of the installation program.
     # Aesthetically quote it.
-    func_quote_for_eval "$arg"
-    func_append install_prog "$func_quote_for_eval_result"
+    func_quote_arg pretty "$arg"
+    func_append install_prog "$func_quote_arg_result"
     install_shared_prog=$install_prog
     case " $install_prog " in
       *[\\\ /]cp\ *) install_cp=: ;;
@@ -4257,12 +4425,12 @@ func_mode_install ()
       esac
 
       # Aesthetically quote the argument.
-      func_quote_for_eval "$arg"
-      func_append install_prog " $func_quote_for_eval_result"
+      func_quote_arg pretty "$arg"
+      func_append install_prog " $func_quote_arg_result"
       if test -n "$arg2"; then
-	func_quote_for_eval "$arg2"
+	func_quote_arg pretty "$arg2"
       fi
-      func_append install_shared_prog " $func_quote_for_eval_result"
+      func_append install_shared_prog " $func_quote_arg_result"
     done
 
     test -z "$install_prog" && \
@@ -4273,8 +4441,8 @@ func_mode_install ()
 
     if test -n "$install_override_mode" && $no_mode; then
       if $install_cp; then :; else
-	func_quote_for_eval "$install_override_mode"
-	func_append install_shared_prog " -m $func_quote_for_eval_result"
+	func_quote_arg pretty "$install_override_mode"
+	func_append install_shared_prog " -m $func_quote_arg_result"
       fi
     fi
 
@@ -4570,8 +4738,8 @@ func_mode_install ()
 	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
 
 	        $opt_quiet || {
-	          func_quote_for_expand "$relink_command"
-		  eval "func_echo $func_quote_for_expand_result"
+	          func_quote_arg expand,pretty "$relink_command"
+		  eval "func_echo $func_quote_arg_result"
 	        }
 	        if eval "$relink_command"; then :
 	          else
@@ -5350,7 +5518,8 @@ else
   if test \"\$libtool_execute_magic\" != \"$magic\"; then
     file=\"\$0\""
 
-    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+    func_quote_arg pretty "$ECHO"
+    qECHO=$func_quote_arg_result
     $ECHO "\
 
 # A function that is used when there is no print builtin or printf.
@@ -5360,7 +5529,7 @@ func_fallback_echo ()
 \$1
 _LTECHO_EOF'
 }
-    ECHO=\"$qECHO\"
+    ECHO=$qECHO
   fi
 
 # Very basic option parsing. These options are (a) specific to
@@ -6703,9 +6872,9 @@ func_mode_link ()
     while test "$#" -gt 0; do
       arg=$1
       shift
-      func_quote_for_eval "$arg"
-      qarg=$func_quote_for_eval_unquoted_result
-      func_append libtool_args " $func_quote_for_eval_result"
+      func_quote_arg pretty,unquoted "$arg"
+      qarg=$func_quote_arg_unquoted_result
+      func_append libtool_args " $func_quote_arg_result"
 
       # If the previous option needs an argument, assign it.
       if test -n "$prev"; then
@@ -6941,6 +7110,13 @@ func_mode_link ()
 	  prev=
 	  continue
 	  ;;
+	xassembler)
+	  func_append compiler_flags " -Xassembler $qarg"
+	  prev=
+	  func_append compile_command " -Xassembler $qarg"
+	  func_append finalize_command " -Xassembler $qarg"
+	  continue
+	  ;;
 	xcclinker)
 	  func_append linker_flags " $qarg"
 	  func_append compiler_flags " $qarg"
@@ -7111,7 +7287,7 @@ func_mode_link ()
 	    # These systems don't actually have a C library (as such)
 	    test X-lc = "X$arg" && continue
 	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
 	    # Do not include libc due to us having libc/libc_r.
 	    test X-lc = "X$arg" && continue
 	    ;;
@@ -7131,7 +7307,7 @@ func_mode_link ()
 	  esac
 	elif test X-lc_r = "X$arg"; then
 	 case $host in
-	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig* | *-*-midnightbsd*)
 	   # Do not include libc_r directly, use -pthread flag.
 	   continue
 	   ;;
@@ -7161,8 +7337,20 @@ func_mode_link ()
 	prev=xcompiler
 	continue
 	;;
-
-      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+     # Solaris ld rejects as of 11.4. Refer to Oracle bug 22985199.
+     -pthread)
+	case $host in
+	  *solaris2*) ;;
+	  *)
+	    case "$new_inherited_linker_flags " in
+	        *" $arg "*) ;;
+	        * ) func_append new_inherited_linker_flags " $arg" ;;
+	    esac
+	  ;;
+	esac
+	continue
+	;;
+      -mt|-mthreads|-kthread|-Kthread|-pthreads|--thread-safe \
       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
 	func_append compiler_flags " $arg"
 	func_append compile_command " $arg"
@@ -7303,9 +7491,9 @@ func_mode_link ()
 	save_ifs=$IFS; IFS=,
 	for flag in $args; do
 	  IFS=$save_ifs
-          func_quote_for_eval "$flag"
-	  func_append arg " $func_quote_for_eval_result"
-	  func_append compiler_flags " $func_quote_for_eval_result"
+          func_quote_arg pretty "$flag"
+	  func_append arg " $func_quote_arg_result"
+	  func_append compiler_flags " $func_quote_arg_result"
 	done
 	IFS=$save_ifs
 	func_stripname ' ' '' "$arg"
@@ -7319,16 +7507,21 @@ func_mode_link ()
 	save_ifs=$IFS; IFS=,
 	for flag in $args; do
 	  IFS=$save_ifs
-          func_quote_for_eval "$flag"
-	  func_append arg " $wl$func_quote_for_eval_result"
-	  func_append compiler_flags " $wl$func_quote_for_eval_result"
-	  func_append linker_flags " $func_quote_for_eval_result"
+          func_quote_arg pretty "$flag"
+	  func_append arg " $wl$func_quote_arg_result"
+	  func_append compiler_flags " $wl$func_quote_arg_result"
+	  func_append linker_flags " $func_quote_arg_result"
 	done
 	IFS=$save_ifs
 	func_stripname ' ' '' "$arg"
 	arg=$func_stripname_result
 	;;
 
+      -Xassembler)
+        prev=xassembler
+        continue
+        ;;
+
       -Xcompiler)
 	prev=xcompiler
 	continue
@@ -7346,8 +7539,8 @@ func_mode_link ()
 
       # -msg_* for osf cc
       -msg_*)
-	func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
+	func_quote_arg pretty "$arg"
+	arg=$func_quote_arg_result
 	;;
 
       # Flags to be passed through unchanged, with rationale:
@@ -7370,12 +7563,13 @@ func_mode_link ()
       # -fuse-ld=*           Linker select flags for GCC
       # -static-*            direct GCC to link specific libraries statically
       # -fcilkplus           Cilk Plus language extension features for C/C++
+      # -Wa,*                Pass flags directly to the assembler
       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
       -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
-      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
-        func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
+      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus|-Wa,*)
+        func_quote_arg pretty "$arg"
+	arg=$func_quote_arg_result
         func_append compile_command " $arg"
         func_append finalize_command " $arg"
         func_append compiler_flags " $arg"
@@ -7396,15 +7590,15 @@ func_mode_link ()
 	  continue
         else
 	  # Otherwise treat like 'Some other compiler flag' below
-	  func_quote_for_eval "$arg"
-	  arg=$func_quote_for_eval_result
+	  func_quote_arg pretty "$arg"
+	  arg=$func_quote_arg_result
         fi
 	;;
 
       # Some other compiler flag.
       -* | +*)
-        func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
+        func_quote_arg pretty "$arg"
+	arg=$func_quote_arg_result
 	;;
 
       *.$objext)
@@ -7524,8 +7718,8 @@ func_mode_link ()
       *)
 	# Unknown arguments in both finalize_command and compile_command need
 	# to be aesthetically quoted because they are evaled later.
-	func_quote_for_eval "$arg"
-	arg=$func_quote_for_eval_result
+	func_quote_arg pretty "$arg"
+	arg=$func_quote_arg_result
 	;;
       esac # arg
 
@@ -8733,7 +8927,7 @@ func_mode_link ()
       test CXX = "$tagname" && {
         case $host_os in
         linux*)
-          case `$CC -V 2>&1 | sed 5q` in
+          case `$CC -V 2>&1 | $SED 5q` in
           *Sun\ C*) # Sun C++ 5.9
             func_suncc_cstd_abi
 
@@ -8906,7 +9100,7 @@ func_mode_link ()
 	  #
 	  case $version_type in
 	  # correct linux to gnu/linux during the next big refactor
-	  darwin|freebsd-elf|linux|osf|windows|none)
+	  darwin|freebsd-elf|linux|midnightbsd-elf|osf|windows|none)
 	    func_arith $number_major + $number_minor
 	    current=$func_arith_result
 	    age=$number_minor
@@ -9000,7 +9194,7 @@ func_mode_link ()
 	  versuffix=.$current.$revision
 	  ;;
 
-	freebsd-elf)
+	freebsd-elf | midnightbsd-elf)
 	  func_arith $current - $age
 	  major=.$func_arith_result
 	  versuffix=$major.$age.$revision
@@ -9226,7 +9420,7 @@ func_mode_link ()
 	  *-*-netbsd*)
 	    # Don't link with libc until the a.out ld.so is fixed.
 	    ;;
-	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-midnightbsd*)
 	    # Do not include libc due to us having libc/libc_r.
 	    ;;
 	  *-*-sco3.2v5* | *-*-sco5v6*)
@@ -10037,8 +10231,8 @@ EOF
 	    for cmd in $concat_cmds; do
 	      IFS=$save_ifs
 	      $opt_quiet || {
-		  func_quote_for_expand "$cmd"
-		  eval "func_echo $func_quote_for_expand_result"
+		  func_quote_arg expand,pretty "$cmd"
+		  eval "func_echo $func_quote_arg_result"
 	      }
 	      $opt_dry_run || eval "$cmd" || {
 		lt_exit=$?
@@ -10131,8 +10325,8 @@ EOF
 	  eval cmd=\"$cmd\"
 	  IFS=$save_ifs
 	  $opt_quiet || {
-	    func_quote_for_expand "$cmd"
-	    eval "func_echo $func_quote_for_expand_result"
+	    func_quote_arg expand,pretty "$cmd"
+	    eval "func_echo $func_quote_arg_result"
 	  }
 	  $opt_dry_run || eval "$cmd" || {
 	    lt_exit=$?
@@ -10606,12 +10800,13 @@ EOF
 	  elif eval var_value=\$$var; test -z "$var_value"; then
 	    relink_command="$var=; export $var; $relink_command"
 	  else
-	    func_quote_for_eval "$var_value"
-	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	    func_quote_arg pretty "$var_value"
+	    relink_command="$var=$func_quote_arg_result; export $var; $relink_command"
 	  fi
 	done
-	relink_command="(cd `pwd`; $relink_command)"
-	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+	func_quote eval cd "`pwd`"
+	func_quote_arg pretty,unquoted "($func_quote_result; $relink_command)"
+	relink_command=$func_quote_arg_unquoted_result
       fi
 
       # Only actually do things if not in dry run mode.
@@ -10851,13 +11046,15 @@ EOF
 	elif eval var_value=\$$var; test -z "$var_value"; then
 	  relink_command="$var=; export $var; $relink_command"
 	else
-	  func_quote_for_eval "$var_value"
-	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	  func_quote_arg pretty,unquoted "$var_value"
+	  relink_command="$var=$func_quote_arg_unquoted_result; export $var; $relink_command"
 	fi
       done
       # Quote the link command for shipping.
-      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
-      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      func_quote eval cd "`pwd`"
+      relink_command="($func_quote_result; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      func_quote_arg pretty,unquoted "$relink_command"
+      relink_command=$func_quote_arg_unquoted_result
       if test yes = "$hardcode_automatic"; then
 	relink_command=
       fi
diff --git a/libssh2/m4/autobuild.m4 b/libssh2/m4/autobuild.m4
deleted file mode 100644
index 2f94844e..00000000
--- a/libssh2/m4/autobuild.m4
+++ /dev/null
@@ -1,44 +0,0 @@
-# autobuild.m4 serial 3
-# Copyright (C) 2004, 2006 Simon Josefsson
-#
-# This file is free software, distributed under the terms of the GNU
-# General Public License.  As a special exception to the GNU General
-# Public License, this file may be distributed as part of a program
-# that contains a configuration script generated by Autoconf, under
-# the same distribution terms as the rest of that program.
-#
-# This file can can be used in projects which are not available under
-# the GNU General Public License or the GNU Library General Public
-# License but which still want to provide support for Autobuild.
-
-# Usage: AB_INIT([MODE]).
-AC_DEFUN([AB_INIT],
-[
-	AC_REQUIRE([AC_CANONICAL_BUILD])
-	AC_REQUIRE([AC_CANONICAL_HOST])
-
-	if test -z "$AB_PACKAGE"; then
-	   AB_PACKAGE=${PACKAGE_NAME:-$PACKAGE}
-	fi
-	AC_MSG_NOTICE([autobuild project... $AB_PACKAGE])
-
-	if test -z "$AB_VERSION"; then
-	   AB_VERSION=${PACKAGE_VERSION:-$VERSION}
-	fi
-	AC_MSG_NOTICE([autobuild revision... $AB_VERSION])
-
-	hostname=`hostname`
-	if test "$hostname"; then
-	   AC_MSG_NOTICE([autobuild hostname... $hostname])
-	fi
-
-	ifelse([$1],[],,[AC_MSG_NOTICE([autobuild mode... $1])])
-
-	date=`date +%Y%m%d-%H%M%S`
-	if test "$?" != 0; then
-	   date=`date`
-	fi
-	if test "$date"; then
-	   AC_MSG_NOTICE([autobuild timestamp... $date])
-	fi
-])
diff --git a/libssh2/m4/lib-ld.m4 b/libssh2/m4/lib-ld.m4
index 96c4e2c3..ea53c41d 100644
--- a/libssh2/m4/lib-ld.m4
+++ b/libssh2/m4/lib-ld.m4
@@ -3,6 +3,8 @@ dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
+dnl
+dnl SPDX-License-Identifier: FSFULLR
 
 dnl Subroutines of libtool.m4,
 dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
@@ -59,7 +61,7 @@ if test "$GCC" = yes; then
       # Canonicalize the path of ld
       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
-	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
+        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
       done
       test -z "$LD" && LD="$ac_prog"
       ;;
@@ -89,9 +91,9 @@ AC_CACHE_VAL(acl_cv_path_LD,
       # Break only if it was the GNU/non-GNU ld that we prefer.
       case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
       *GNU* | *'with BFD'*)
-	test "$with_gnu_ld" != no && break ;;
+        test "$with_gnu_ld" != no && break ;;
       *)
-	test "$with_gnu_ld" != yes && break ;;
+        test "$with_gnu_ld" != yes && break ;;
       esac
     fi
   done
diff --git a/libssh2/m4/lib-link.m4 b/libssh2/m4/lib-link.m4
index f157d983..ee06a613 100644
--- a/libssh2/m4/lib-link.m4
+++ b/libssh2/m4/lib-link.m4
@@ -3,10 +3,12 @@ dnl Copyright (C) 2001-2007 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
+dnl
+dnl SPDX-License-Identifier: FSFULLR
 
 dnl From Bruno Haible.
 
-AC_PREREQ(2.54)
+AC_PREREQ([2.54])
 
 dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
 dnl the libraries corresponding to explicit and implicit dependencies.
@@ -74,7 +76,7 @@ AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
   AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
     ac_save_LIBS="$LIBS"
     LIBS="$LIBS $LIB[]NAME"
-    AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([[$3]], [[$4]])],[ac_cv_lib[]Name=yes],[ac_cv_lib[]Name=no])
     LIBS="$ac_save_LIBS"
   ])
   if test "$ac_cv_lib[]Name" = yes; then
diff --git a/libssh2/m4/lib-prefix.m4 b/libssh2/m4/lib-prefix.m4
index a8684e17..9695f887 100644
--- a/libssh2/m4/lib-prefix.m4
+++ b/libssh2/m4/lib-prefix.m4
@@ -3,6 +3,8 @@ dnl Copyright (C) 2001-2005 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
+dnl
+dnl SPDX-License-Identifier: FSFULLR
 
 dnl From Bruno Haible.
 
diff --git a/libssh2/m4/libtool.m4 b/libssh2/m4/libtool.m4
index c4c02946..e7b68334 100644
--- a/libssh2/m4/libtool.m4
+++ b/libssh2/m4/libtool.m4
@@ -1,6 +1,7 @@
 # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
 #
-#   Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc.
+#   Copyright (C) 1996-2001, 2003-2019, 2021-2022 Free Software
+#   Foundation, Inc.
 #   Written by Gordon Matzigkeit, 1996
 #
 # This file is free software; the Free Software Foundation gives
@@ -31,7 +32,7 @@ m4_define([_LT_COPYING], [dnl
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ])
 
-# serial 58 LT_INIT
+# serial 59 LT_INIT
 
 
 # LT_PREREQ(VERSION)
@@ -181,6 +182,7 @@ m4_require([_LT_FILEUTILS_DEFAULTS])dnl
 m4_require([_LT_CHECK_SHELL_FEATURES])dnl
 m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl
 m4_require([_LT_CMD_RELOAD])dnl
+m4_require([_LT_DECL_FILECMD])dnl
 m4_require([_LT_CHECK_MAGIC_METHOD])dnl
 m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
 m4_require([_LT_CMD_OLD_ARCHIVE])dnl
@@ -219,8 +221,8 @@ esac
 ofile=libtool
 can_build_shared=yes
 
-# All known linkers require a '.a' archive for static linking (except MSVC,
-# which needs '.lib').
+# All known linkers require a '.a' archive for static linking (except MSVC and
+# ICC, which need '.lib').
 libext=a
 
 with_gnu_ld=$lt_cv_prog_gnu_ld
@@ -777,7 +779,7 @@ _LT_EOF
   # if finds mixed CR/LF and LF-only lines.  Since sed operates in
   # text mode, it properly converts lines to CR/LF.  This bash problem
   # is reportedly fixed, but why not run on old versions too?
-  sed '$q' "$ltmain" >> "$cfgfile" \
+  $SED '$q' "$ltmain" >> "$cfgfile" \
      || (rm -f "$cfgfile"; exit 1)
 
    mv -f "$cfgfile" "$ofile" ||
@@ -1041,8 +1043,8 @@ int forced_loaded() { return 2;}
 _LT_EOF
       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
-      echo "$AR cr libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
-      $AR cr libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
+      echo "$AR $AR_FLAGS libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
+      $AR $AR_FLAGS libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
       echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
       $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
       cat > conftest.c << _LT_EOF
@@ -1066,17 +1068,12 @@ _LT_EOF
       _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
     darwin1.*)
       _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-    darwin*) # darwin 5.x on
-      # if running on 10.5 or later, the deployment target defaults
-      # to the OS version, if on x86, and 10.4, the deployment
-      # target defaults to 10.4. Don't you love it?
-      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
-	10.0,*86*-darwin8*|10.0,*-darwin[[912]]*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.[[012]][[,.]]*)
-	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
-	10.*|11.*)
-	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+    darwin*)
+      case $MACOSX_DEPLOYMENT_TARGET,$host in
+        10.[[012]],*|,*powerpc*-darwin[[5-8]]*)
+          _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+        *)
+          _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
       esac
     ;;
   esac
@@ -1125,12 +1122,12 @@ m4_defun([_LT_DARWIN_LINKER_FEATURES],
     output_verbose_link_cmd=func_echo_all
     _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
     _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
-    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
-    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+    _LT_TAGVAR(archive_expsym_cmds, $1)="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    _LT_TAGVAR(module_expsym_cmds, $1)="$SED -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
     m4_if([$1], [CXX],
 [   if test yes != "$lt_cv_apple_cc_single_mod"; then
       _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
-      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+      _LT_TAGVAR(archive_expsym_cmds, $1)="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
     fi
 ],[])
   else
@@ -1244,7 +1241,8 @@ _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
 # _LT_WITH_SYSROOT
 # ----------------
 AC_DEFUN([_LT_WITH_SYSROOT],
-[AC_MSG_CHECKING([for sysroot])
+[m4_require([_LT_DECL_SED])dnl
+AC_MSG_CHECKING([for sysroot])
 AC_ARG_WITH([sysroot],
 [AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@],
   [Search for dependent libraries within DIR (or the compiler's sysroot
@@ -1261,7 +1259,7 @@ case $with_sysroot in #(
    fi
    ;; #(
  /*)
-   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   lt_sysroot=`echo "$with_sysroot" | $SED -e "$sed_quote_subst"`
    ;; #(
  no|'')
    ;; #(
@@ -1291,7 +1289,7 @@ ia64-*-hpux*)
   # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *ELF-32*)
 	HPUX_IA64_MODE=32
 	;;
@@ -1308,7 +1306,7 @@ ia64-*-hpux*)
   echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
     if test yes = "$lt_cv_prog_gnu_ld"; then
-      case `/usr/bin/file conftest.$ac_objext` in
+      case `$FILECMD conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -melf32bsmip"
 	  ;;
@@ -1320,7 +1318,7 @@ ia64-*-hpux*)
 	;;
       esac
     else
-      case `/usr/bin/file conftest.$ac_objext` in
+      case `$FILECMD conftest.$ac_objext` in
 	*32-bit*)
 	  LD="${LD-ld} -32"
 	  ;;
@@ -1342,7 +1340,7 @@ mips64*-*linux*)
   echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
     emul=elf
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *32-bit*)
 	emul="${emul}32"
 	;;
@@ -1350,7 +1348,7 @@ mips64*-*linux*)
 	emul="${emul}64"
 	;;
     esac
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *MSB*)
 	emul="${emul}btsmip"
 	;;
@@ -1358,7 +1356,7 @@ mips64*-*linux*)
 	emul="${emul}ltsmip"
 	;;
     esac
-    case `/usr/bin/file conftest.$ac_objext` in
+    case `$FILECMD conftest.$ac_objext` in
       *N32*)
 	emul="${emul}n32"
 	;;
@@ -1378,14 +1376,14 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
   # not appear in the list.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.o` in
+    case `$FILECMD conftest.o` in
       *32-bit*)
 	case $host in
 	  x86_64-*kfreebsd*-gnu)
 	    LD="${LD-ld} -m elf_i386_fbsd"
 	    ;;
 	  x86_64-*linux*)
-	    case `/usr/bin/file conftest.o` in
+	    case `$FILECMD conftest.o` in
 	      *x86-64*)
 		LD="${LD-ld} -m elf32_x86_64"
 		;;
@@ -1453,7 +1451,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
   # options accordingly.
   echo 'int i;' > conftest.$ac_ext
   if AC_TRY_EVAL(ac_compile); then
-    case `/usr/bin/file conftest.o` in
+    case `$FILECMD conftest.o` in
     *64-bit*)
       case $lt_cv_prog_gnu_ld in
       yes*)
@@ -1492,9 +1490,22 @@ need_locks=$enable_libtool_lock
 m4_defun([_LT_PROG_AR],
 [AC_CHECK_TOOLS(AR, [ar], false)
 : ${AR=ar}
-: ${AR_FLAGS=cr}
 _LT_DECL([], [AR], [1], [The archiver])
-_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])
+
+# Use ARFLAGS variable as AR's operation code to sync the variable naming with
+# Automake.  If both AR_FLAGS and ARFLAGS are specified, AR_FLAGS should have
+# higher priority because thats what people were doing historically (setting
+# ARFLAGS for automake and AR_FLAGS for libtool).  FIXME: Make the AR_FLAGS
+# variable obsoleted/removed.
+
+test ${AR_FLAGS+y} || AR_FLAGS=${ARFLAGS-cr}
+lt_ar_flags=$AR_FLAGS
+_LT_DECL([], [lt_ar_flags], [0], [Flags to create an archive (by configure)])
+
+# Make AR_FLAGS overridable by 'make ARFLAGS='.  Don't try to run-time override
+# by AR_FLAGS because that was never working and AR_FLAGS is about to die.
+_LT_DECL([], [AR_FLAGS], [\@S|@{ARFLAGS-"\@S|@lt_ar_flags"}],
+         [Flags to create an archive])
 
 AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
   [lt_cv_ar_at_file=no
@@ -1713,7 +1724,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
     lt_cv_sys_max_cmd_len=8192;
     ;;
 
-  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
+  bitrig* | darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*)
     # This has been around since 386BSD, at least.  Likely further.
     if test -x /sbin/sysctl; then
       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
@@ -1756,7 +1767,7 @@ AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
   sysv5* | sco5v6* | sysv4.2uw2*)
     kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
     if test -n "$kargmax"; then
-      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[	 ]]//'`
+      lt_cv_sys_max_cmd_len=`echo $kargmax | $SED 's/.*[[	 ]]//'`
     else
       lt_cv_sys_max_cmd_len=32768
     fi
@@ -2206,26 +2217,35 @@ m4_defun([_LT_CMD_STRIPLIB],
 striplib=
 old_striplib=
 AC_MSG_CHECKING([whether stripping libraries is possible])
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
-  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
-  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  AC_MSG_RESULT([yes])
+if test -z "$STRIP"; then
+  AC_MSG_RESULT([no])
 else
-# FIXME - insert some real tests, host_os isn't really good enough
-  case $host_os in
-  darwin*)
-    if test -n "$STRIP"; then
+  if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+    old_striplib="$STRIP --strip-debug"
+    striplib="$STRIP --strip-unneeded"
+    AC_MSG_RESULT([yes])
+  else
+    case $host_os in
+    darwin*)
+      # FIXME - insert some real tests, host_os isn't really good enough
       striplib="$STRIP -x"
       old_striplib="$STRIP -S"
       AC_MSG_RESULT([yes])
-    else
+      ;;
+    freebsd*)
+      if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then
+        old_striplib="$STRIP --strip-debug"
+        striplib="$STRIP --strip-unneeded"
+        AC_MSG_RESULT([yes])
+      else
+        AC_MSG_RESULT([no])
+      fi
+      ;;
+    *)
       AC_MSG_RESULT([no])
-    fi
-    ;;
-  *)
-    AC_MSG_RESULT([no])
-    ;;
-  esac
+      ;;
+    esac
+  fi
 fi
 _LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
 _LT_DECL([], [striplib], [1])
@@ -2548,7 +2568,7 @@ cygwin* | mingw* | pw32* | cegcc*)
     case $host_os in
     cygwin*)
       # Cygwin DLLs use 'cyg' prefix rather than 'lib'
-      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      soname_spec='`echo $libname | $SED -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
 m4_if([$1], [],[
       sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
       ;;
@@ -2558,14 +2578,14 @@ m4_if([$1], [],[
       ;;
     pw32*)
       # pw32 DLLs use 'pw' prefix rather than 'lib'
-      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
+      library_names_spec='`echo $libname | $SED -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
       ;;
     esac
     dynamic_linker='Win32 ld.exe'
     ;;
 
-  *,cl*)
-    # Native MSVC
+  *,cl* | *,icl*)
+    # Native MSVC or ICC
     libname_spec='$name'
     soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
     library_names_spec='$libname.dll.lib'
@@ -2584,7 +2604,7 @@ m4_if([$1], [],[
       done
       IFS=$lt_save_ifs
       # Convert to MSYS style.
-      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
       ;;
     cygwin*)
       # Convert to unix form, then to dos form, then back to unix form
@@ -2621,7 +2641,7 @@ m4_if([$1], [],[
     ;;
 
   *)
-    # Assume MSVC wrapper
+    # Assume MSVC and ICC wrapper
     library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib'
     dynamic_linker='Win32 ld.exe'
     ;;
@@ -2654,7 +2674,7 @@ dgux*)
   shlibpath_var=LD_LIBRARY_PATH
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   # DragonFly does not have aout.  When/if they implement a new
   # versioning mechanism, adjust this.
   if test -x /usr/bin/objformat; then
@@ -3465,7 +3485,7 @@ beos*)
 
 bsdi[[45]]*)
   lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
-  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_cmd='$FILECMD -L'
   lt_cv_file_magic_test_file=/shlib/libc.so
   ;;
 
@@ -3499,14 +3519,14 @@ darwin* | rhapsody*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-freebsd* | dragonfly*)
+freebsd* | dragonfly* | midnightbsd*)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     case $host_cpu in
     i*86 )
       # Not sure whether the presence of OpenBSD here was a mistake.
       # Let's accept both of them until this is cleared up.
       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
-      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_cmd=$FILECMD
       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
       ;;
     esac
@@ -3520,7 +3540,7 @@ haiku*)
   ;;
 
 hpux10.20* | hpux11*)
-  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_cmd=$FILECMD
   case $host_cpu in
   ia64*)
     lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
@@ -3567,7 +3587,7 @@ netbsd* | netbsdelf*-gnu)
 
 newos6*)
   lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
-  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_cmd=$FILECMD
   lt_cv_file_magic_test_file=/usr/lib/libnls.so
   ;;
 
@@ -3694,13 +3714,13 @@ else
 	mingw*) lt_bad_file=conftest.nm/nofile ;;
 	*) lt_bad_file=/dev/null ;;
 	esac
-	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | $SED '1q'` in
 	*$lt_bad_file* | *'Invalid file or object type'*)
 	  lt_cv_path_NM="$tmp_nm -B"
 	  break 2
 	  ;;
 	*)
-	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  case `"$tmp_nm" -p /dev/null 2>&1 | $SED '1q'` in
 	  */dev/null*)
 	    lt_cv_path_NM="$tmp_nm -p"
 	    break 2
@@ -3726,7 +3746,7 @@ else
     # Let the user override the test.
   else
     AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
-    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | $SED '1q'` in
     *COFF*)
       DUMPBIN="$DUMPBIN -symbols -headers"
       ;;
@@ -3966,7 +3986,7 @@ esac
 
 if test "$lt_cv_nm_interface" = "MS dumpbin"; then
   # Gets list of data symbols to import.
-  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'"
+  lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \(.*\)$/\1/p'"
   # Adjust the below global symbol transforms to fixup imported variables.
   lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
   lt_c_name_hook=" -e 's/^I .* \(.*\)$/  {\"\1\", (void *) 0},/p'"
@@ -3984,20 +4004,20 @@ fi
 # Transform an extracted symbol line into a proper C declaration.
 # Some systems (esp. on ia64) link data and code symbols differently,
 # so use this general approach.
-lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+lt_cv_sys_global_symbol_to_cdecl="$SED -n"\
 $lt_cdecl_hook\
 " -e 's/^T .* \(.*\)$/extern int \1();/p'"\
 " -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
 
 # Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+lt_cv_sys_global_symbol_to_c_name_address="$SED -n"\
 $lt_c_name_hook\
 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
 " -e 's/^$symcode$symcode* .* \(.*\)$/  {\"\1\", (void *) \&\1},/p'"
 
 # Transform an extracted symbol line into symbol name with lib prefix and
 # symbol address.
-lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="$SED -n"\
 $lt_c_name_lib_hook\
 " -e 's/^: \(.*\) .*$/  {\"\1\", (void *) 0},/p'"\
 " -e 's/^$symcode$symcode* .* \(lib.*\)$/  {\"\1\", (void *) \&\1},/p'"\
@@ -4021,7 +4041,7 @@ for ac_symprfx in "" "_"; do
   if test "$lt_cv_nm_interface" = "MS dumpbin"; then
     # Fake it for dumpbin and say T for any non-static function,
     # D for any global variable and I for any imported variable.
-    # Also find C++ and __fastcall symbols from MSVC++,
+    # Also find C++ and __fastcall symbols from MSVC++ or ICC,
     # which start with @ or ?.
     lt_cv_sys_global_symbol_pipe="$AWK ['"\
 "     {last_section=section; section=\$ 3};"\
@@ -4039,9 +4059,9 @@ for ac_symprfx in "" "_"; do
 "     s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\
 "     ' prfx=^$ac_symprfx]"
   else
-    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+    lt_cv_sys_global_symbol_pipe="$SED -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
   fi
-  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | $SED '/ __gnu_lto/d'"
 
   # Check to see that the pipe works correctly.
   pipe_works=no
@@ -4329,7 +4349,7 @@ m4_if([$1], [CXX], [
 	    ;;
 	esac
 	;;
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
 	# FreeBSD uses GNU C++
 	;;
       hpux9* | hpux10* | hpux11*)
@@ -4412,7 +4432,7 @@ m4_if([$1], [CXX], [
 	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
 	    ;;
 	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
+	    case `$CC -V 2>&1 | $SED 5q` in
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
@@ -4754,7 +4774,7 @@ m4_if([$1], [CXX], [
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
 	;;
       *)
-	case `$CC -V 2>&1 | sed 5q` in
+	case `$CC -V 2>&1 | $SED 5q` in
 	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)
 	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
 	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
@@ -4937,7 +4957,7 @@ m4_if([$1], [CXX], [
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
       _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
@@ -4945,7 +4965,7 @@ m4_if([$1], [CXX], [
     ;;
   cygwin* | mingw* | cegcc*)
     case $cc_basename in
-    cl*)
+    cl* | icl*)
       _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
       ;;
     *)
@@ -5005,15 +5025,15 @@ dnl Note also adjust exclude_expsyms for C++ above.
 
   case $host_os in
   cygwin* | mingw* | pw32* | cegcc*)
-    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # FIXME: the MSVC++ and ICC port hasn't been tested in a loooong time
     # When not using gcc, we currently assume that we are using
-    # Microsoft Visual C++.
+    # Microsoft Visual C++ or Intel C++ Compiler.
     if test yes != "$GCC"; then
       with_gnu_ld=no
     fi
     ;;
   interix*)
-    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    # we just hope/assume this is gcc and not c89 (= MSVC++ or ICC)
     with_gnu_ld=yes
     ;;
   openbsd* | bitrig*)
@@ -5068,7 +5088,7 @@ dnl Note also adjust exclude_expsyms for C++ above.
       _LT_TAGVAR(whole_archive_flag_spec, $1)=
     fi
     supports_anon_versioning=no
-    case `$LD -v | $SED -e 's/([^)]\+)\s\+//' 2>&1` in
+    case `$LD -v | $SED -e 's/([[^)]]\+)\s\+//' 2>&1` in
       *GNU\ gold*) supports_anon_versioning=yes ;;
       *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
       *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
@@ -5180,6 +5200,7 @@ _LT_EOF
 	emximp -o $lib $output_objdir/$libname.def'
       _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
       _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='@'
       ;;
 
     interix[[3-9]]*)
@@ -5194,7 +5215,7 @@ _LT_EOF
       # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
       # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
       _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
       ;;
 
     gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
@@ -5237,7 +5258,7 @@ _LT_EOF
 	  _LT_TAGVAR(compiler_needs_object, $1)=yes
 	  ;;
 	esac
-	case `$CC -V 2>&1 | sed 5q` in
+	case `$CC -V 2>&1 | $SED 5q` in
 	*Sun\ C*)			# Sun C 5.9
 	  _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
 	  _LT_TAGVAR(compiler_needs_object, $1)=yes
@@ -5249,13 +5270,14 @@ _LT_EOF
 
         if test yes = "$supports_anon_versioning"; then
           _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+            cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
             echo "local: *; };" >> $output_objdir/$libname.ver~
             $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
         fi
 
 	case $cc_basename in
 	tcc*)
+	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
 	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic'
 	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
@@ -5265,7 +5287,7 @@ _LT_EOF
 	  _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
 	  if test yes = "$supports_anon_versioning"; then
 	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-              cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+              cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
               echo "local: *; };" >> $output_objdir/$libname.ver~
               $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
 	  fi
@@ -5397,7 +5419,7 @@ _LT_EOF
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
 	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
@@ -5580,12 +5602,12 @@ _LT_EOF
 
     cygwin* | mingw* | pw32* | cegcc*)
       # When not using gcc, we currently assume that we are using
-      # Microsoft Visual C++.
+      # Microsoft Visual C++ or Intel C++ Compiler.
       # hardcode_libdir_flag_spec is actually meaningless, as there is
       # no search path for DLLs.
       case $cc_basename in
-      cl*)
-	# Native MSVC
+      cl* | icl*)
+	# Native MSVC or ICC
 	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
 	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
 	_LT_TAGVAR(always_export_symbols, $1)=yes
@@ -5626,7 +5648,7 @@ _LT_EOF
           fi'
 	;;
       *)
-	# Assume MSVC wrapper
+	# Assume MSVC and ICC wrapper
 	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
 	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
 	# Tell ltmain to make .lib files, not .a files.
@@ -5674,7 +5696,7 @@ _LT_EOF
       ;;
 
     # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
-    freebsd* | dragonfly*)
+    freebsd* | dragonfly* | midnightbsd*)
       _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
       _LT_TAGVAR(hardcode_direct, $1)=yes
@@ -5815,6 +5837,7 @@ _LT_EOF
 	# Fabrice Bellard et al's Tiny C Compiler
 	_LT_TAGVAR(ld_shlibs, $1)=yes
 	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
 	;;
       esac
       ;;
@@ -5886,6 +5909,7 @@ _LT_EOF
 	emximp -o $lib $output_objdir/$libname.def'
       _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
       _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_TAGVAR(file_list_spec, $1)='@'
       ;;
 
     osf3*)
@@ -6656,8 +6680,8 @@ if test yes != "$_lt_caught_CXX_error"; then
 
       cygwin* | mingw* | pw32* | cegcc*)
 	case $GXX,$cc_basename in
-	,cl* | no,cl*)
-	  # Native MSVC
+	,cl* | no,cl* | ,icl* | no,icl*)
+	  # Native MSVC or ICC
 	  # hardcode_libdir_flag_spec is actually meaningless, as there is
 	  # no search path for DLLs.
 	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
@@ -6755,6 +6779,7 @@ if test yes != "$_lt_caught_CXX_error"; then
 	  emximp -o $lib $output_objdir/$libname.def'
 	_LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
 	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	_LT_TAGVAR(file_list_spec, $1)='@'
 	;;
 
       dgux*)
@@ -6785,7 +6810,7 @@ if test yes != "$_lt_caught_CXX_error"; then
         _LT_TAGVAR(archive_cmds_need_lc, $1)=no
         ;;
 
-      freebsd* | dragonfly*)
+      freebsd* | dragonfly* | midnightbsd*)
         # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
         # conventions
         _LT_TAGVAR(ld_shlibs, $1)=yes
@@ -6922,7 +6947,7 @@ if test yes != "$_lt_caught_CXX_error"; then
 	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
 	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
-	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 	;;
       irix5* | irix6*)
         case $cc_basename in
@@ -7062,13 +7087,13 @@ if test yes != "$_lt_caught_CXX_error"; then
 	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
 	    if test yes = "$supports_anon_versioning"; then
 	      _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
-                cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+                cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
                 echo "local: *; };" >> $output_objdir/$libname.ver~
                 $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
 	    fi
 	    ;;
 	  *)
-	    case `$CC -V 2>&1 | sed 5q` in
+	    case `$CC -V 2>&1 | $SED 5q` in
 	    *Sun\ C*)
 	      # Sun C++ 5.9
 	      _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
@@ -8214,6 +8239,14 @@ _LT_DECL([], [DLLTOOL], [1], [DLL creation program])
 AC_SUBST([DLLTOOL])
 ])
 
+# _LT_DECL_FILECMD
+# ----------------
+# Check for a file(cmd) program that can be used to detect file type and magic
+m4_defun([_LT_DECL_FILECMD],
+[AC_CHECK_TOOL([FILECMD], [file], [:])
+_LT_DECL([], [FILECMD], [1], [A file(cmd) program that detects file types])
+])# _LD_DECL_FILECMD
+
 # _LT_DECL_SED
 # ------------
 # Check for a fully-functional sed program, that truncates
diff --git a/libssh2/m4/ltoptions.m4 b/libssh2/m4/ltoptions.m4
index 94b08297..b0b5e9c2 100644
--- a/libssh2/m4/ltoptions.m4
+++ b/libssh2/m4/ltoptions.m4
@@ -1,7 +1,7 @@
 # Helper functions for option handling.                    -*- Autoconf -*-
 #
-#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
-#   Foundation, Inc.
+#   Copyright (C) 2004-2005, 2007-2009, 2011-2019, 2021-2022 Free
+#   Software Foundation, Inc.
 #   Written by Gary V. Vaughan, 2004
 #
 # This file is free software; the Free Software Foundation gives
diff --git a/libssh2/m4/ltsugar.m4 b/libssh2/m4/ltsugar.m4
index 48bc9344..902508bd 100644
--- a/libssh2/m4/ltsugar.m4
+++ b/libssh2/m4/ltsugar.m4
@@ -1,6 +1,6 @@
 # ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
 #
-# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software
+# Copyright (C) 2004-2005, 2007-2008, 2011-2019, 2021-2022 Free Software
 # Foundation, Inc.
 # Written by Gary V. Vaughan, 2004
 #
diff --git a/libssh2/m4/ltversion.m4 b/libssh2/m4/ltversion.m4
index fa04b52a..b155d0ac 100644
--- a/libssh2/m4/ltversion.m4
+++ b/libssh2/m4/ltversion.m4
@@ -1,6 +1,7 @@
 # ltversion.m4 -- version numbers			-*- Autoconf -*-
 #
-#   Copyright (C) 2004, 2011-2015 Free Software Foundation, Inc.
+#   Copyright (C) 2004, 2011-2019, 2021-2022 Free Software Foundation,
+#   Inc.
 #   Written by Scott James Remnant, 2004
 #
 # This file is free software; the Free Software Foundation gives
@@ -9,15 +10,15 @@
 
 # @configure_input@
 
-# serial 4179 ltversion.m4
+# serial 4245 ltversion.m4
 # This file is part of GNU Libtool
 
-m4_define([LT_PACKAGE_VERSION], [2.4.6])
-m4_define([LT_PACKAGE_REVISION], [2.4.6])
+m4_define([LT_PACKAGE_VERSION], [2.4.7])
+m4_define([LT_PACKAGE_REVISION], [2.4.7])
 
 AC_DEFUN([LTVERSION_VERSION],
-[macro_version='2.4.6'
-macro_revision='2.4.6'
+[macro_version='2.4.7'
+macro_revision='2.4.7'
 _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
 _LT_DECL(, macro_revision, 0)
 ])
diff --git a/libssh2/m4/lt~obsolete.m4 b/libssh2/m4/lt~obsolete.m4
index c6b26f88..0f7a8759 100644
--- a/libssh2/m4/lt~obsolete.m4
+++ b/libssh2/m4/lt~obsolete.m4
@@ -1,7 +1,7 @@
 # lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
 #
-#   Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software
-#   Foundation, Inc.
+#   Copyright (C) 2004-2005, 2007, 2009, 2011-2019, 2021-2022 Free
+#   Software Foundation, Inc.
 #   Written by Scott James Remnant, 2004.
 #
 # This file is free software; the Free Software Foundation gives
diff --git a/libssh2/maketgz b/libssh2/maketgz
index b88d9608..80f557cd 100755
--- a/libssh2/maketgz
+++ b/libssh2/maketgz
@@ -1,63 +1,77 @@
-#! /bin/sh
-# Script to build release-archives with
+#!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
+# Script to build release-archives with. Note that this requires a checkout
+# from git and you should first run 'autoreconf -fi' and './configure'.
+#
+
+set -eu
+
+export LC_ALL=C
+export TZ=UTC
 
-version=$1
+version="${1:-}"
 
 if [ -z "$version" ]; then
   echo "Specify a version number!"
   exit
 fi
 
-if [ "xonly" = "x$2" ]; then
-    echo "Setup version number only!"
-    only=1
+if [ "only" = "${2:-}" ]; then
+  echo "Setup version number only!"
+  only=1
+else
+  only=
 fi
 
 libversion="$version"
 
-major=`echo $libversion |cut -d. -f1 | sed -e "s/[^0-9]//g"`
-minor=`echo $libversion |cut -d. -f2 | sed -e "s/[^0-9]//g"`
-patch=`echo $libversion |cut -d. -f3 | cut -d- -f1 | sed -e "s/[^0-9]//g"`
+major=$(echo "$libversion" | cut -d. -f1 | sed -e "s/[^0-9]//g")
+minor=$(echo "$libversion" | cut -d. -f2 | sed -e "s/[^0-9]//g")
+patch=$(echo "$libversion" | cut -d. -f3 | cut -d- -f1 | sed -e "s/[^0-9]//g")
 
-numeric=`perl -e 'printf("%02x%02x%02x\n", '"$major, $minor, $patch);"`
+numeric="$(printf "%02x%02x%02x\n" "$major" "$minor" "$patch")"
 
 HEADER=include/libssh2.h
 
 if test -z "$only"; then
-    ext=".dist"
-    # when not setting up version numbers locally
-    for a in $HEADER; do
-        cp $a "$a$ext"
-    done
-    HEADER="$HEADER$ext"
+  ext=".dist"
+  # when not setting up version numbers locally
+  for a in $HEADER; do
+    cp "$a" "$a$ext"
+  done
+  HEADER="$HEADER$ext"
 fi
 
-# requires a date command that knows -u for UTC time zone
-datestamp=`LC_TIME=C date -u`
+# requires a date command that knows + for format and -d for date input
+timestamp=${SOURCE_DATE_EPOCH:-$(date +"%s")}
+datestamp=$(date -d "@$timestamp")
+filestamp=$(date -d "@$timestamp" +"%Y%m%d%H%M.%S")
+
+# Replace version number in header file:
+sed -i.bak \
+  -e "s/^#define LIBSSH2_VERSION .*/#define LIBSSH2_VERSION \"$libversion\"/g" \
+  -e "s/^#define LIBSSH2_VERSION_NUM .*/#define LIBSSH2_VERSION_NUM 0x$numeric/g" \
+  -e "s/^#define LIBSSH2_VERSION_MAJOR .*/#define LIBSSH2_VERSION_MAJOR $major/g" \
+  -e "s/^#define LIBSSH2_VERSION_MINOR .*/#define LIBSSH2_VERSION_MINOR $minor/g" \
+  -e "s/^#define LIBSSH2_VERSION_PATCH .*/#define LIBSSH2_VERSION_PATCH $patch/g" \
+  -e "s/^#define LIBSSH2_TIMESTAMP .*/#define LIBSSH2_TIMESTAMP \"$datestamp\"/g" \
+  "$HEADER"
+rm -f "$HEADER.bak"
 
-# Replace in-place version number in header file:
-sed -i -e 's/^#define LIBSSH2_VERSION .*/#define LIBSSH2_VERSION "'$libversion'"/g' \
-    -e 's/^#define LIBSSH2_VERSION_NUM .*/#define LIBSSH2_VERSION_NUM 0x'$numeric'/g' \
-    -e 's/^#define LIBSSH2_VERSION_MAJOR .*/#define LIBSSH2_VERSION_MAJOR '$major'/g' \
-    -e 's/^#define LIBSSH2_VERSION_MINOR .*/#define LIBSSH2_VERSION_MINOR '$minor'/g' \
-    -e 's/^#define LIBSSH2_VERSION_PATCH .*/#define LIBSSH2_VERSION_PATCH '$patch'/g' \
-    -e "s/^#define LIBSSH2_TIMESTAMP .*/#define LIBSSH2_TIMESTAMP \"$datestamp\"/g" \
- $HEADER
+if test -n "$only"; then
+  # done!
+  exit
+fi
 
 echo "libssh2 version $libversion"
 echo "libssh2 numerical $numeric"
 echo "datestamp $datestamp"
 
-if test -n "$only"; then
-    # done!
-    exit;
-fi
-
-findprog()
-{
+findprog() {
   file="$1"
-  for part in `echo $PATH| tr ':' ' '`; do
+  for part in $(echo "$PATH" | tr ':' ' '); do
     path="$part/$file"
     if [ -x "$path" ]; then
       # there it is!
@@ -76,13 +90,13 @@ findprog()
 #
 
 if { findprog automake >/dev/null 2>/dev/null; } then
-  echo "- Could not find or run automake, I hope you know what you're doing!"
+  echo "- Could not find or run automake, I hope you know what you are doing!"
 else
   echo "Runs automake --include-deps"
   automake --include-deps Makefile >/dev/null
 fi
 
-#######################################################################
+############################################################################
 #
 # Generate the changelog
 #
@@ -96,4 +110,77 @@ git log --pretty=fuller --no-color --date=short --decorate=full -1000 | ./git2ne
 
 echo "make dist"
 targz="libssh2-$version.tar.gz"
-make -s dist VERSION=$version
+make -s dist "VERSION=$version"
+res=$?
+
+if test "$res" != 0; then
+  echo "make dist failed"
+  exit 2
+fi
+
+retar() {
+  tempdir=$1
+  rm -rf "$tempdir"
+  mkdir "$tempdir"
+  cd "$tempdir"
+  gzip -dc "../$targz" | tar -xf -
+  find libssh2-* -depth -exec touch -c -t "$filestamp" '{}' +
+  tar --create --format=ustar --owner=0 --group=0 --numeric-owner --sort=name libssh2-* | gzip --best --no-name > out.tar.gz
+  mv out.tar.gz ../
+  cd ..
+  rm -rf "$tempdir"
+}
+
+retar ".tarbuild"
+echo "replace $targz with out.tar.gz"
+mv out.tar.gz "$targz"
+
+############################################################################
+#
+# Now make a bz2 archive from the tar.gz original
+#
+
+bzip2="libssh2-$version.tar.bz2"
+echo "Generating $bzip2"
+gzip -dc "$targz" | bzip2 --best > "$bzip2"
+
+############################################################################
+#
+# Now make an xz archive from the tar.gz original
+#
+
+xz="libssh2-$version.tar.xz"
+echo "Generating $xz"
+gzip -dc "$targz" | xz -6e - > "$xz"
+
+############################################################################
+#
+# Now make a zip archive from the tar.gz original
+#
+makezip() {
+  rm -rf "$tempdir"
+  mkdir "$tempdir"
+  cd "$tempdir"
+  gzip -dc "../$targz" | tar -xf -
+  find . | sort | zip -9 -X "$zip" -@ >/dev/null
+  mv "$zip" ../
+  cd ..
+  rm -rf "$tempdir"
+}
+
+zip="libssh2-$version.zip"
+echo "Generating $zip"
+tempdir=".builddir"
+makezip
+
+# Set deterministic timestamp
+touch -c -t "$filestamp" "$targz" "$bzip2" "$xz" "$zip"
+
+echo "------------------"
+echo "maketgz report:"
+echo ""
+ls -l "$targz" "$bzip2" "$xz" "$zip"
+sha256sum "$targz" "$bzip2" "$xz" "$zip"
+
+echo "Run this:"
+echo "gpg -b -a '$targz' && gpg -b -a '$bzip2' && gpg -b -a '$xz' && gpg -b -a '$zip'"
diff --git a/libssh2/missing b/libssh2/missing
index 8d0eaad2..1fe1611f 100755
--- a/libssh2/missing
+++ b/libssh2/missing
@@ -3,7 +3,7 @@
 
 scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1996-2020 Free Software Foundation, Inc.
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
 # Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
 
 # This program is free software; you can redistribute it and/or modify
diff --git a/libssh2/nw/GNUmakefile b/libssh2/nw/GNUmakefile
deleted file mode 100644
index 8899fdd8..00000000
--- a/libssh2/nw/GNUmakefile
+++ /dev/null
@@ -1,630 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (NetWare version - gnu make)
-## Use: make [help|all|clean|dev|devclean|dist|distclean|lib|nlm|objclean]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Novell NDK.
-ifndef NDKBASE
-NDKBASE	= c:/novell
-endif
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-0.9.8zc
-endif
-
-# Edit the path below to point to your Distribution folder.
-ifndef DISTDIR
-DISTDIR	= libssh2-$(LIBSSH2_VERSION_STR)-bin-nw
-endif
-DISTARC	= $(DISTDIR).zip
-
-# Edit the path below to point to your Development folder.
-ifndef DEVLDIR
-DEVLDIR	= libssh2-$(LIBSSH2_VERSION_STR)-dev-nw
-endif
-DEVLARC	= $(DEVLDIR).zip
-
-# Edit the vars below to change NLM target settings.
-TARGET	= libssh2
-VERSION	= $(LIBSSH2_VERSION)
-CPRIGHT	= Copyright (c) $(LIBSSH2_COPYRIGHT_STR)
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(LIBSSH2_VERSION_STR) ($(LIBARCH)) - $(WWWURL)
-MTSAFE	= YES
-STACK	= 64000
-SCREEN	= none
-EXPORTS	= @$(TARGET).imp
-
-# Edit the var below to point to your lib architecture.
-ifndef LIBARCH
-LIBARCH = LIBC
-endif
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# The following lines defines your compiler.
-ifdef CWFolder
-	METROWERKS = $(CWFolder)
-endif
-ifdef METROWERKS
-	# MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support
-	MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support/Metrowerks Support
-	CC = mwccnlm
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-# If you want to mark the target as MTSAFE you will need a tool for
-# generating the xdc data for the linker; here's a minimal tool:
-# http://www.gknw.net/development/prgtools/mkxdc.zip
-MPKXDC	= mkxdc
-ZIP	= zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif     
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# LIBARCH_U = $(shell $(AWK) 'BEGIN {print toupper(ARGV[1])}' $(LIBARCH))
-LIBARCH_L = $(shell $(AWK) 'BEGIN {print tolower(ARGV[1])}' $(LIBARCH))
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	+= $(OPT) -D$(DB) -DNETWARE -nostdinc
-#CFLAGS	+= -DHAVE_CONFIG_H
-
-ifeq ($(CC),mwccnlm)
-LD	= mwldnlm
-LDFLAGS	= -nostdlib $(PRELUDE) $(OBJL) -o $@ -commandfile
-AR	= mwldnlm
-ARFLAGS	= -nostdlib -type library -o
-LIBEXT	= lib
-CFLAGS	+= -msgstyle gcc -gccinc -inline on -opt nointrinsics -proc 586
-CFLAGS	+= -relax_pointers
-#CFLAGS	+= -w on
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.o
-	CFLAGS += -align 4
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	PRELUDE = "$(MWCW_PATH)/libraries/runtime/prelude.obj"
-	# CFLAGS += -include "$(MWCW_PATH)/headers/nlm_clib_prefix.h"
-	CFLAGS += -align 1
-endif
-else
-LD	= $(CROSSPREFIX)nlmconv
-LDFLAGS	= -UT
-AR	= $(CROSSPREFIX)ar
-ARFLAGS	= -cq
-LIBEXT	= a
-RANLIB	= $(CROSSPREFIX)ranlib
-CFLAGS	+= -m32
-CFLAGS	+= -fno-builtin -fpcc-struct-return
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-#CFLAGS	+= -Wno-pointer-sign
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	# http://www.gknw.net/development/mk_nlm/gcc_pre.zip
-	PRELUDE = $(NDK_ROOT)/pre/prelude.o
-	CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h
-endif
-endif
-
-LDLIBS	=
-
-NDK_ROOT = $(NDKBASE)/ndk
-SDK_CLIB = $(NDK_ROOT)/nwsdk
-SDK_LIBC = $(NDK_ROOT)/libc
-SNPRINTF = $(NDKBASE)/snprintf
-
-INCLUDES = -I. -I../include
-
-ifdef WITH_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-ifdef LINK_STATIC
-	LDLIBS += $(ZLIB_PATH)/nw/$(LIBARCH)/libz.$(LIBEXT)
-else
-	MODULES += libz.nlm
-	IMPORTS += @$(ZLIB_PATH)/nw/$(LIBARCH)/libz.imp
-endif
-endif
-INCLUDES += -I$(OPENSSL_PATH)/outinc_nw_$(LIBARCH_L)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/ssl.$(LIBEXT)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/crypto.$(LIBEXT)
-IMPORTS += GetProcessSwitchCount RunningProcess
-
-ifeq ($(LIBARCH),LIBC)
-	INCLUDES += -I$(SDK_LIBC)/include
-	# INCLUDES += -I$(SDK_LIBC)/include/nks
-	# INCLUDES += -I$(SDK_LIBC)/include/winsock
-	CFLAGS += -D_POSIX_SOURCE
-else
-	INCLUDES += -I$(SDK_CLIB)/include/nlm
-	# INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete
-	# INCLUDES += -I$(SDK_CLIB)/include
-endif
-CFLAGS	+= $(INCLUDES)
-
-ifeq ($(MTSAFE),YES)
-	XDCOPT = -n
-endif
-ifeq ($(MTSAFE),NO)
-	XDCOPT = -u
-endif
-ifdef XDCOPT
-	XDCDATA = $(OBJDIR)/$(TARGET).xdc
-endif
-
-vpath %.c . ../src
-
-# only OpenSSL is supported with this build system
-CFLAGS += -DLIBSSH2_OPENSSL
-include ../Makefile.OpenSSL.inc
-
-# include Makefile.inc to get CSOURCES define
-include ../Makefile.inc
-
-OBJECTS := $(patsubst %.c,%.o,$(CSOURCES))
-ifeq ($(LIBARCH),CLIB)
-# CLIB lacks of snprint() function - here's a replacement:
-# https://www.ijs.si/software/snprintf/
-OBJECTS += snprintf.o
-vpath %.c $(SNPRINTF)
-endif
-
-OBJS	:= $(addprefix $(OBJDIR)/,$(OBJECTS))
-OBJL	= $(OBJS) $(OBJDIR)/nwlib.o $(LDLIBS)
-
-all: lib nlm
-
-nlm: prebuild $(TARGET).nlm
-
-lib: prebuild $(TARGET).$(LIBEXT)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc libssh2_config.h
-
-test: all
-	$(MAKE) -C test
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: ../get_ver.awk ../include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-dist: all $(DISTDIR) $(DISTDIR)/readme.txt
-	@$(call MKDIR, $(DISTDIR)/bin)
-	@$(call COPY, ../AUTHORS, $(DISTDIR))
-	@$(call COPY, ../COPYING, $(DISTDIR))
-	@$(call COPY, ../INSTALL, $(DISTDIR))
-	@$(call COPY, ../README, $(DISTDIR))
-	@$(call COPY, ../RELEASE-NOTES, $(DISTDIR))
-	@$(call COPY, $(TARGET).nlm, $(DISTDIR)/bin)
-	@echo Creating $(DISTARC)
-	@$(ZIP) $(DISTARC) $(DISTDIR)/* < $(DISTDIR)/readme.txt
-
-dev: all $(DEVLDIR) $(DEVLDIR)/readme.txt
-	@$(call MKDIR, $(DEVLDIR)/bin)
-	@$(call MKDIR, $(DEVLDIR)/include)
-	@$(call MKDIR, $(DEVLDIR)/nw)
-	@$(call COPY, ../AUTHORS, $(DEVLDIR))
-	@$(call COPY, ../COPYING, $(DEVLDIR))
-	@$(call COPY, ../INSTALL, $(DEVLDIR))
-	@$(call COPY, ../README, $(DEVLDIR))
-	@$(call COPY, ../RELEASE-NOTES, $(DEVLDIR))
-	@$(call COPY, ../include/*.h, $(DEVLDIR)/include)
-	@$(call COPY, libssh2_config.h, $(DEVLDIR)/include)
-	@$(call COPY, $(TARGET).nlm, $(DEVLDIR)/bin)
-	@$(call COPY, $(TARGET).imp, $(DEVLDIR)/nw)
-	@$(call COPY, $(TARGET).$(LIBEXT), $(DEVLDIR)/nw)
-	@echo Creating $(DEVLARC)
-	@$(ZIP) $(DEVLARC) $(DEVLDIR)/* < $(DEVLDIR)/readme.txt
-
-distclean: clean
-	$(call RMDIR, $(DISTDIR))
-	$(call DEL, $(DISTARC))
-
-devclean: clean
-	$(call RMDIR, $(DEVLDIR))
-	$(call DEL, $(DEVLARC))
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-testclean: clean
-	$(MAKE) -C test clean
-
-clean: objclean
-	$(call DEL, libssh2_config.h)
-	$(call DEL, $(TARGET).*)
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-$(DISTDIR):
-	@$(call MKDIR, $@)
-
-$(DEVLDIR):
-	@$(call MKDIR, $@)
-
-$(TARGET).$(LIBEXT): $(OBJS)
-	@echo Creating $@
-	@$(call DEL, $@)
-	@$(AR) $(ARFLAGS) $@ $^
-ifdef RANLIB
-	@$(RANLIB) $@
-endif
-
-$(TARGET).nlm: $(OBJDIR)/$(TARGET).def $(TARGET).imp $(OBJL) $(XDCDATA)
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $<
-
-$(OBJDIR)/%.xdc: GNUmakefile
-	@echo Creating $@
-	@$(MPKXDC) $(XDCOPT) $@
-
-$(OBJDIR)/%.def: GNUmakefile
-	@echo $(DL)# DEF file for linking with $(LD)$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)#$(DL) >> $@
-	@echo $(DL)copyright "$(CPRIGHT)"$(DL) >> $@
-	@echo $(DL)description "$(DESCR)"$(DL) >> $@
-	@echo $(DL)version $(VERSION)$(DL) >> $@
-ifdef NLMTYPE
-	@echo $(DL)type $(NLMTYPE)$(DL) >> $@
-endif
-ifdef STACK
-	@echo $(DL)stack $(STACK)$(DL) >> $@
-endif
-ifdef SCREEN
-	@echo $(DL)screenname "$(SCREEN)"$(DL) >> $@
-else
-	@echo $(DL)screenname "DEFAULT"$(DL) >> $@
-endif
-ifeq ($(DB),DEBUG)
-	@echo $(DL)debug$(DL) >> $@
-endif
-	@echo $(DL)threadname "$(TARGET)"$(DL) >> $@
-ifdef XDCDATA
-	@echo $(DL)xdcdata $(XDCDATA)$(DL) >> $@
-endif
-	@echo $(DL)flag_on 64$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)start _Prelude$(DL) >> $@
-	@echo $(DL)exit _Stop$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@
-	@echo $(DL)module clib$(DL) >> $@
-else
-	@echo $(DL)pseudopreemption$(DL) >> $@
-	@echo $(DL)start _LibCPrelude$(DL) >> $@
-	@echo $(DL)exit _LibCPostlude$(DL) >> $@
-	@echo $(DL)check _LibCCheckUnload$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@
-	@echo $(DL)module libc$(DL) >> $@
-endif
-ifdef MODULES
-	@echo $(DL)module $(MODULES)$(DL) >> $@
-endif
-ifdef EXPORTS
-	@echo $(DL)export $(EXPORTS)$(DL) >> $@
-endif
-ifdef IMPORTS
-	@echo $(DL)import $(IMPORTS)$(DL) >> $@
-endif
-ifeq ($(LD),nlmconv)
-	@echo $(DL)input $(OBJL)$(DL) >> $@
-	@echo $(DL)input $(PRELUDE)$(DL) >> $@
-	@echo $(DL)output $(TARGET).nlm$(DL) >> $@
-endif
-
-libssh2_config.h: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)/* $@ for NetWare target.$(DL) > $@
-	@echo $(DL)** Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)** All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)*/$(DL) >> $@
-	@echo $(DL)#define VERSION "$(LIBSSH2_VERSION_STR)"$(DL) >> $@
-	@echo $(DL)#define PACKAGE_BUGREPORT "https://github.com/libssh2/libssh2/issues"$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)#define OS "i586-pc-clib-NetWare"$(DL) >> $@
-	@echo $(DL)#define NETDB_USE_INTERNET 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRICMP 1$(DL) >> $@
-	@echo $(DL)#define socklen_t int$(DL) >> $@
-	@echo $(DL)#define sleep(s) delay(1000 * s)$(DL) >> $@
-	@echo $(DL)#define strcasecmp stricmp$(DL) >> $@
-	@echo $(DL)#define strncasecmp strnicmp$(DL) >> $@
-else
-	@echo $(DL)#define OS "i586-pc-libc-NetWare"$(DL) >> $@
-	@echo $(DL)#define HAVE_DLFCN_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_DLOPEN 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FTRUNCATE 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETTIMEOFDAY 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_PTON 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INTTYPES_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIMITS_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LONGLONG 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STDINT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRCASECMP 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRLCAT 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRLCPY 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRTOLL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_PARAM_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SELECT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_TERMIOS_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_AF_INET6 1$(DL) >> $@
-	@echo $(DL)#define HAVE_PF_INET6 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_IN6_ADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_SOCKADDR_IN6 1$(DL) >> $@
-	@echo $(DL)#define SIZEOF_STRUCT_IN6_ADDR 16$(DL) >> $@
-ifdef ENABLE_IPV6
-	@echo $(DL)#define ENABLE_IPV6 1$(DL) >> $@
-endif
-endif
-	@echo $(DL)#define HAVE_ARPA_INET_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ASSERT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_CTYPE_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ERR_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_ERRNO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FCNTL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_FIONBIO 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETHOSTBYADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETHOSTBYNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GETPROTOBYNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_GMTIME_R 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_ADDR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_INET_NTOA 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LOCALTIME_R 1$(DL) >> $@
-	@echo $(DL)#define HAVE_MALLOC_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_NETINET_IN_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SELECT 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SETJMP_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIGNAL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIGNAL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SIG_ATOMIC_T 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SOCKET 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STDLIB_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRDUP 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRFTIME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRING_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRSTR 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_ADDRINFO 1$(DL) >> $@
-	@echo $(DL)#define HAVE_STRUCT_TIMEVAL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_IOCTL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_STAT_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_TIME_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_TIME_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UNAME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UNISTD_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UTIME 1$(DL) >> $@
-	@echo $(DL)#define HAVE_UTIME_H 1$(DL) >> $@
-	@echo $(DL)#define RETSIGTYPE void$(DL) >> $@
-	@echo $(DL)#define SIZEOF_STRUCT_IN_ADDR 4$(DL) >> $@
-	@echo $(DL)#define STDC_HEADERS 1$(DL) >> $@
-	@echo $(DL)#define TIME_WITH_SYS_TIME 1$(DL) >> $@
-	@echo $(DL)#define USE_SSLEAY 1$(DL) >> $@
-	@echo $(DL)#define USE_OPENSSL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_X509_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_SSL_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_RSA_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_PEM_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_ERR_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_CRYPTO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_OPENSSL_ENGINE_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_O_NONBLOCK 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBSSL 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBCRYPTO 1$(DL) >> $@
-	@echo $(DL)#define OPENSSL_NO_KRB5 1$(DL) >> $@
-ifdef WITH_ZLIB
-	@echo $(DL)#define HAVE_ZLIB_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_LIBZ 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_HAVE_ZLIB 1$(DL) >> $@
-endif
-ifdef NW_WINSOCK
-	@echo $(DL)#define HAVE_CLOSESOCKET 1$(DL) >> $@
-else
-	@echo $(DL)#define HAVE_SYS_TYPES_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SOCKET_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_SYS_SOCKIO_H 1$(DL) >> $@
-	@echo $(DL)#define HAVE_NETDB_H 1$(DL) >> $@
-endif
-ifdef OLD_NOVELLSDK
-	@echo $(DL)#define socklen_t int$(DL) >> $@
-endif
-	@echo $(DL)#define LIBSSH2_DH_GEX_NEW 1$(DL) >> $@
-ifeq ($(DB),DEBUG)
-	@echo $(DL)#define LIBSSH2_DEBUG_CONNECTION 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_ERRORS 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_KEX 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_PUBLICKEY 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_SCP 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_SFTP 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_TRANSPORT 1$(DL) >> $@
-	@echo $(DL)#define LIBSSH2_DEBUG_USERAUTH 1$(DL) >> $@
-endif
-
-libssh2.imp: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)# $@ for NetWare target.$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)  (CLIB_LIBSSH2)$(DL) >> $@
-else
-	@echo $(DL)  (LIBC_LIBSSH2)$(DL) >> $@
-endif
-	@echo $(DL)  libssh2_banner_set,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_close,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_direct_tcpip_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_flush_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_free,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_get_exit_status,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_open_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_process_startup,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_read_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_request_pty_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_send_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_set_blocking,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_setenv_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_wait_closed,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_wait_eof,$(DL) >> $@
-	@echo $(DL)  libssh2_channel_write_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_exit,$(DL) >> $@
-	@echo $(DL)  libssh2_hostkey_hash,$(DL) >> $@
-	@echo $(DL)  libssh2_init,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_add,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_check,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_checkp,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_free,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_init,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_readfile,$(DL) >> $@
-	@echo $(DL)  libssh2_knownhost_writefile,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_recv,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_recv2,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_send64,$(DL) >> $@
-	@echo $(DL)  libssh2_scp_send_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_abstract,$(DL) >> $@
-	@echo $(DL)  libssh2_session_block_directions,$(DL) >> $@
-	@echo $(DL)  libssh2_session_callback_set,$(DL) >> $@
-	@echo $(DL)  libssh2_session_disconnect_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_free,$(DL) >> $@
-	@echo $(DL)  libssh2_session_handshake,$(DL) >> $@
-	@echo $(DL)  libssh2_session_hostkey,$(DL) >> $@
-	@echo $(DL)  libssh2_session_init_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_session_last_errno,$(DL) >> $@
-	@echo $(DL)  libssh2_session_last_error,$(DL) >> $@
-	@echo $(DL)  libssh2_session_method_pref,$(DL) >> $@
-	@echo $(DL)  libssh2_session_methods,$(DL) >> $@
-	@echo $(DL)  libssh2_session_set_blocking,$(DL) >> $@
-	@echo $(DL)  libssh2_session_startup,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_close_handle,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_fstat_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_init,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_last_error,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_mkdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_open_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_read,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_readdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_rename_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_rmdir_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_seek,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_seek64,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_shutdown,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_stat_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_symlink_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_tell,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_unlink_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_sftp_write,$(DL) >> $@
-	@echo $(DL)  libssh2_trace,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_authenticated,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_keyboard_interactive_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_list,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_password_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_userauth_publickey_fromfile_ex,$(DL) >> $@
-	@echo $(DL)  libssh2_version$(DL) >> $@
-
-$(DISTDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a binary distribution for NetWare platform.$(DL) > $@
-	@echo $(DL)libssh2 version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-$(DEVLDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a development distribution for NetWare platform.$(DL) > $@
-	@echo $(DL)libssh2 version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh2 package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-ifeq ($(LIBARCH),LIBC)
-	@echo $(DL)Novell LibC NDK = $(SDK_LIBC)$(DL)
-else
-	@echo $(DL)Novell CLib NDK = $(SDK_CLIB)$(DL)
-endif
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) nlm$(DL)
-	@echo $(DL)$(MAKE) lib$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) dev$(DL)
-	@echo $(DL)$(MAKE) devclean$(DL)
-	@echo $(DL)$(MAKE) dist$(DL)
-	@echo $(DL)$(MAKE) distclean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)$(MAKE) test$(DL)
-	@echo $(DL)===========================================================$(DL)
-
-
diff --git a/libssh2/nw/keepscreen.c b/libssh2/nw/keepscreen.c
deleted file mode 100644
index c3471b3e..00000000
--- a/libssh2/nw/keepscreen.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Simple _NonAppStop() implementation which can be linked to your 
- * NLM in order to keep the screen open when the NLM terminates
- * (the good old clib behaviour).
- * You dont have to call it, its done automatically from LibC.
- *
- * 2004-Aug-11  by Guenter Knauf 
- *
- * URL: http://www.gknw.net/development/mk_nlm/
- */
- 
-#include <stdio.h>
-#include <screen.h>
-
-void _NonAppStop()
-{
-    uint16_t row, col;
-    
-    GetScreenSize(&row, &col);
-    gotorowcol(row-1, 0);
-    /* pressanykey(); */
-    printf("<Press any key to close screen> ");
-    getcharacter();
-}
-
-
diff --git a/libssh2/nw/nwlib.c b/libssh2/nw/nwlib.c
deleted file mode 100644
index 43018e59..00000000
--- a/libssh2/nw/nwlib.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/*********************************************************************
- * Universal NetWare library stub.                                   *
- * written by Ulrich Neuman and given to OpenSource copyright-free.  *
- * Extended for CLIB support by Guenter Knauf.                       *
- *********************************************************************/
-
-#ifdef NETWARE /* Novell NetWare */
-
-#include <stdlib.h>
-
-#ifdef __NOVELL_LIBC__
-/* For native LibC-based NLM we need to register as a real lib. */
-#include <errno.h>
-#include <string.h>
-#include <library.h>
-#include <netware.h>
-#include <screen.h>
-#include <nks/thread.h>
-#include <nks/synch.h>
-
-typedef struct
-{
-  int     _errno;
-  void    *twentybytes;
-} libthreaddata_t;
-
-typedef struct
-{
-  int         x;
-  int         y;
-  int         z;
-  void        *tenbytes;
-  NXKey_t     perthreadkey;   /* if -1, no key obtained... */
-  NXMutex_t   *lock;
-} libdata_t;
-
-int         gLibId      = -1;
-void        *gLibHandle = (void *) NULL;
-rtag_t      gAllocTag   = (rtag_t) NULL;
-NXMutex_t   *gLibLock   = (NXMutex_t *) NULL;
-
-/* internal library function prototypes... */
-int     DisposeLibraryData ( void * );
-void    DisposeThreadData ( void * );
-int     GetOrSetUpData ( int id, libdata_t **data, libthreaddata_t **threaddata );
-
-
-int _NonAppStart( void        *NLMHandle,
-                  void        *errorScreen,
-                  const char  *cmdLine,
-                  const char  *loadDirPath,
-                  size_t      uninitializedDataLength,
-                  void        *NLMFileHandle,
-                  int         (*readRoutineP)( int conn,
-                                               void *fileHandle, size_t offset,
-                                               size_t nbytes,
-                                               size_t *bytesRead,
-                                               void *buffer ),
-                  size_t      customDataOffset,
-                  size_t      customDataSize,
-                  int         messageCount,
-                  const char  **messages )
-{
-  NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);
-
-#ifndef __GNUC__
-#pragma unused(cmdLine)
-#pragma unused(loadDirPath)
-#pragma unused(uninitializedDataLength)
-#pragma unused(NLMFileHandle)
-#pragma unused(readRoutineP)
-#pragma unused(customDataOffset)
-#pragma unused(customDataSize)
-#pragma unused(messageCount)
-#pragma unused(messages)
-#endif
-
-/*
-** Here we process our command line, post errors (to the error screen),
-** perform initializations and anything else we need to do before being able
-** to accept calls into us. If we succeed, we return non-zero and the NetWare
-** Loader will leave us up, otherwise we fail to load and get dumped.
-*/
-  gAllocTag = AllocateResourceTag(NLMHandle,
-                   "<library-name> memory allocations", AllocSignature);
-
-  if (!gAllocTag) {
-    OutputToScreen(errorScreen, "Unable to allocate resource tag for "
-                     "library memory allocations.\n");
-    return -1;
-  }
-
-  gLibId = register_library(DisposeLibraryData);
-
-  if (gLibId < -1) {
-    OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
-    return -1;
-  }
-
-  gLibHandle = NLMHandle;
-
-  gLibLock = NXMutexAlloc(0, 0, &liblock);
-
-  if (!gLibLock) {
-    OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
-    return -1;
-  }
-
-  return 0;
-}
-
-/*
-** Here we clean up any resources we allocated. Resource tags is a big part
-** of what we created, but NetWare doesn't ask us to free those.
-*/
-void _NonAppStop( void )
-{
-  (void) unregister_library(gLibId);
-  NXMutexFree(gLibLock);
-}
-
-/*
-** This function cannot be the first in the file for if the file is linked
-** first, then the check-unload function's offset will be nlmname.nlm+0
-** which is how to tell that there isn't one. When the check function is
-** first in the linked objects, it is ambiguous. For this reason, we will
-** put it inside this file after the stop function.
-**
-** Here we check to see if it's alright to ourselves to be unloaded. If not,
-** we return a non-zero value. Right now, there isn't any reason not to allow
-** it.
-*/
-int _NonAppCheckUnload( void )
-{
-  return 0;
-}
-
-int GetOrSetUpData(int id, libdata_t **appData, libthreaddata_t **threadData)
-{
-  int              err;
-  libdata_t        *app_data;
-  libthreaddata_t  *thread_data;
-  NXKey_t          key;
-  NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);
-
-  err         = 0;
-  thread_data = (libthreaddata_t *) NULL;
-
-/*
-** Attempt to get our data for the application calling us. This is where we
-** store whatever application-specific information we need to carry in support
-** of calling applications.
-*/
-  app_data = (libdata_t *) get_app_data(id);
-
-  if (!app_data) {
-/*
-** This application hasn't called us before; set up application AND per-thread
-** data. Of course, just in case a thread from this same application is calling
-** us simultaneously, we better lock our application data-creation mutex. We
-** also need to recheck for data after we acquire the lock because WE might be
-** that other thread that was too late to create the data and the first thread
-** in will have created it.
-*/
-    NXLock(gLibLock);
-
-    if (!(app_data = (libdata_t *) get_app_data(id))) {
-      app_data = (libdata_t *) malloc(sizeof(libdata_t));
-
-      if (app_data) {
-        memset(app_data, 0, sizeof(libdata_t));
-
-        app_data->tenbytes = malloc(10);
-        app_data->lock     = NXMutexAlloc(0, 0, &liblock);
-
-        if (!app_data->tenbytes || !app_data->lock) {
-          if (app_data->lock)
-            NXMutexFree(app_data->lock);
-
-          free(app_data);
-          app_data = (libdata_t *) NULL;
-          err      = ENOMEM;
-        }
-
-        if (app_data) {
-/*
-** Here we burn in the application data that we were trying to get by calling
-** get_app_data(). Next time we call the first function, we'll get this data
-** we're just now setting. We also go on here to establish the per-thread data
-** for the calling thread, something we'll have to do on each application
-** thread the first time it calls us.
-*/
-          err = set_app_data(gLibId, app_data);
-
-          if (err) {
-            free(app_data);
-            app_data = (libdata_t *) NULL;
-            err      = ENOMEM;
-          }
-          else {
-            /* create key for thread-specific data... */
-            err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);
-
-            if (err)                /* (no more keys left?) */
-              key = -1;
-
-            app_data->perthreadkey = key;
-          }
-        }
-      }
-    }
-
-    NXUnlock(gLibLock);
-  }
-
-  if (app_data) {
-    key = app_data->perthreadkey;
-
-    if (key != -1 /* couldn't create a key? no thread data */
-        && !(err = NXKeyGetValue(key, (void **) &thread_data))
-        && !thread_data) {
-/*
-** Allocate the per-thread data for the calling thread. Regardless of whether
-** there was already application data or not, this may be the first call by a
-** a new thread. The fact that we allocation 20 bytes on a pointer is not very
-** important, this just helps to demonstrate that we can have arbitrarily
-** complex per-thread data.
-*/
-      thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));
-
-      if (thread_data) {
-        thread_data->_errno      = 0;
-        thread_data->twentybytes = malloc(20);
-
-        if (!thread_data->twentybytes) {
-          free(thread_data);
-          thread_data = (libthreaddata_t *) NULL;
-          err         = ENOMEM;
-        }
-
-        if ((err = NXKeySetValue(key, thread_data))) {
-          free(thread_data->twentybytes);
-          free(thread_data);
-          thread_data = (libthreaddata_t *) NULL;
-        }
-      }
-    }
-  }
-
-  if (appData)
-    *appData = app_data;
-
-  if (threadData)
-    *threadData = thread_data;
-
-  return err;
-}
-
-int DisposeLibraryData( void *data )
-{
-  if (data) {
-    void *tenbytes = ((libdata_t *) data)->tenbytes;
-
-    if (tenbytes)
-      free(tenbytes);
-
-    free(data);
-  }
-
-  return 0;
-}
-
-void DisposeThreadData( void *data )
-{
-  if (data) {
-    void *twentybytes = ((libthreaddata_t *) data)->twentybytes;
-
-    if (twentybytes)
-      free(twentybytes);
-
-    free(data);
-  }
-}
-
-#else /* __NOVELL_LIBC__ */
-/* For native CLib-based NLM seems we can do a bit more simple. */
-#include <nwthread.h>
-
-int main ( void )
-{
-  /* initialize any globals here... */
-
-  /* do this if any global initializing was done
-  SynchronizeStart();
-  */
-  ExitThread (TSR_THREAD, 0);
-  return 0;
-}
-
-#endif /* __NOVELL_LIBC__ */
-
-#endif /* NETWARE */
-
-
diff --git a/libssh2/nw/test/GNUmakefile b/libssh2/nw/test/GNUmakefile
deleted file mode 100644
index 86bf6b68..00000000
--- a/libssh2/nw/test/GNUmakefile
+++ /dev/null
@@ -1,311 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (NetWare version - gnu make)
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Novell NDK.
-ifndef NDKBASE
-NDKBASE	= c:/novell
-endif
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8zc
-endif
-
-# Edit the var below to enable static linking of libssh2 and libz
-LINK_STATIC = 1
-
-# Edit the vars below to change NLM target settings.
-SAMPLES	= ../../example
-TARGETS := $(filter-out x11.nlm,$(patsubst $(SAMPLES)/%.c,%.nlm,$(strip $(wildcard $(SAMPLES)/*.c))))
-VERSION	= $(LIBSSH2_VERSION)
-COPYR   = Copyright (c) $(LIBSSH2_COPYRIGHT_STR)
-WWWURL	= http://www.libssh2.org/
-DESCR	= libssh2 $(notdir $(@:.def=)) $(LIBSSH2_VERSION_STR) ($(LIBARCH)) - $(WWWURL)
-MTSAFE	= YES
-STACK	= 64000
-SCREEN	= NONE
-#SCREEN	= libssh2 $(notdir $(@:.def=))
-# Comment the line below if you dont want to load protected automatically.
-#LDRING	= 3
-
-# Edit the var below to point to your lib architecture.
-ifndef LIBARCH
-LIBARCH = LIBC
-endif
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# The following lines defines your compiler.
-ifdef CWFolder
-	METROWERKS = $(CWFolder)
-endif
-ifdef METROWERKS
-	# MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support
-	MWCW_PATH = $(subst \,/,$(METROWERKS))/Novell Support/Metrowerks Support
-	CC = mwccnlm
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-# If you want to mark the target as MTSAFE you will need a tool for
-# generating the xdc data for the linker; here's a minimal tool:
-# http://www.gknw.net/development/prgtools/mkxdc.zip
-MPKXDC	= mkxdc
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif     
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# LIBARCH_U = $(shell $(AWK) 'BEGIN {print toupper(ARGV[1])}' $(LIBARCH))
-LIBARCH_L = $(shell $(AWK) 'BEGIN {print tolower(ARGV[1])}' $(LIBARCH))
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	+= $(OPT) -D$(DB) -DNETWARE -nostdinc
-
-ifeq ($(CC),mwccnlm)
-LD	= mwldnlm
-LDFLAGS	= -nostdlib $(<:.def=.o) $(PRELUDE) $(LDLIBS) -o $@ -commandfile
-AR	= mwldnlm
-ARFLAGS	= -type library -w nocmdline $(OBJS) -o
-LIBEXT	= lib
-CFLAGS	+= -msgstyle gcc -gccinc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -relax_pointers
-#CFLAGS	+= -w on
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.o
-	CFLAGS += -align 4
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.o
-	# to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-	PRELUDE = "$(MWCW_PATH)/libraries/runtime/prelude.obj"
-	# CFLAGS += -include "$(MWCW_PATH)/headers/nlm_clib_prefix.h"
-	CFLAGS += -align 1
-endif
-else
-LD	= nlmconv
-LDFLAGS	= -UT
-AR	= ar
-ARFLAGS	= -cq
-LIBEXT	= a
-CFLAGS	+= -m32
-CFLAGS	+= -fno-builtin -fpcc-struct-return
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-ifeq ($(LIBARCH),LIBC)
-	PRELUDE = $(SDK_LIBC)/imports/libcpre.gcc.o
-else
-	# PRELUDE = $(SDK_CLIB)/imports/clibpre.gcc.o
-        # to avoid the __init_* / __deinit_* whoes dont use prelude from NDK
-        # http://www.gknw.net/development/mk_nlm/gcc_pre.zip
-        PRELUDE = $(NDK_ROOT)/pre/prelude.o
-	CFLAGS += -include $(NDKBASE)/nlmconv/genlm.h
-endif
-endif
-
-NDK_ROOT = $(NDKBASE)/ndk
-SDK_CLIB = $(NDK_ROOT)/nwsdk
-SDK_LIBC = $(NDK_ROOT)/libc
-SNPRINTF = $(NDKBASE)/snprintf
-
-INCLUDES = -I.. -I../../include
-
-LDLIBS =
- 
-ifdef LINK_STATIC
-	LDLIBS += ../libssh2.$(LIBEXT)
-else
-	IMPORTS += @../libssh2.imp
-	MODULES += libssh2.nlm
-endif
-
-INCLUDES += -I$(OPENSSL_PATH)/outinc_nw_$(LIBARCH_L)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/ssl.$(LIBEXT)
-LDLIBS += $(OPENSSL_PATH)/out_nw_$(LIBARCH_L)/crypto.$(LIBEXT)
-IMPORTS += GetProcessSwitchCount RunningProcess
-
-ifdef WITH_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-ifdef LINK_STATIC
-	LDLIBS += $(ZLIB_PATH)/nw/$(LIBARCH)/libz.$(LIBEXT)
-else
-	MODULES += libz.nlm
-	IMPORTS += @$(ZLIB_PATH)/nw/$(LIBARCH)/libz.imp
-endif
-endif
-
-ifeq ($(LIBARCH),LIBC)
-	INCLUDES += -I$(SDK_LIBC)/include
-	# INCLUDES += -I$(SDK_LIBC)/include/nks
-	# INCLUDES += -I$(SDK_LIBC)/include/winsock
-	CFLAGS += -D_POSIX_SOURCE
-else
-	INCLUDES += -I$(SDK_CLIB)/include/nlm
-	# INCLUDES += -I$(SDK_CLIB)/include/nlm/obsolete
-	# INCLUDES += -I$(SDK_CLIB)/include
-	# CFLAGS += -DNETDB_USE_INTERNET
-endif
-CFLAGS	+= $(INCLUDES)
-
-ifeq ($(MTSAFE),YES)
-	XDCOPT = -n
-endif
-ifeq ($(MTSAFE),NO)
-	XDCOPT = -u
-endif
-
-vpath %.c $(SAMPLES)
-
-.PRECIOUS: $(OBJDIR)/%.o $(OBJDIR)/%.def $(OBJDIR)/%.xdc
-
-
-all: prebuild $(TARGETS) 
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: ../../get_ver.awk ../../include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-clean: objclean
-	$(foreach f, $(TARGETS), $(call DEL, $(f)))
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-%.nlm: $(OBJDIR)/%.def $(OBJDIR)/%.o $(OBJDIR)/%.xdc
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $<
-
-$(OBJDIR)/%.xdc: GNUmakefile
-	@echo Creating $@
-	@$(MPKXDC) $(XDCOPT) $@
-
-$(OBJDIR)/%.def: GNUmakefile
-	@echo $(DL)# DEF file for linking with $(LD)$(DL) > $@
-	@echo $(DL)# Do not edit this file - it is created by make!$(DL) >> $@
-	@echo $(DL)# All your changes will be lost!!$(DL) >> $@
-	@echo $(DL)#$(DL) >> $@
-	@echo $(DL)copyright "$(COPYR)"$(DL) >> $@
-	@echo $(DL)description "$(DESCR)"$(DL) >> $@
-	@echo $(DL)version $(VERSION)$(DL) >> $@
-ifdef NLMTYPE
-	@echo $(DL)type $(NLMTYPE)$(DL) >> $@
-endif
-ifdef STACK
-	@echo $(DL)stack $(STACK)$(DL) >> $@
-endif
-ifdef SCREEN
-	@echo $(DL)screenname "$(SCREEN)"$(DL) >> $@
-else
-	@echo $(DL)screenname "DEFAULT"$(DL) >> $@
-endif
-ifeq ($(DB),DEBUG)
-	@echo $(DL)debug$(DL) >> $@
-endif
-	@echo $(DL)threadname "$(notdir $(@:.def=))"$(DL) >> $@
-ifdef XDCOPT
-	@echo $(DL)xdcdata $(@:.def=.xdc)$(DL) >> $@
-endif
-ifeq ($(LDRING),0)
-	@echo $(DL)flag_on 16$(DL) >> $@
-endif
-ifeq ($(LDRING),3)
-	@echo $(DL)flag_on 512$(DL) >> $@
-endif
-ifeq ($(LIBARCH),CLIB)
-	@echo $(DL)start _Prelude$(DL) >> $@
-	@echo $(DL)exit _Stop$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/clib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/threads.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/nlmlib.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_CLIB)/imports/socklib.imp$(DL) >> $@
-	@echo $(DL)module clib$(DL) >> $@
-else
-	@echo $(DL)flag_on 64$(DL) >> $@
-	@echo $(DL)pseudopreemption$(DL) >> $@
-	@echo $(DL)start _LibCPrelude$(DL) >> $@
-	@echo $(DL)exit _LibCPostlude$(DL) >> $@
-	@echo $(DL)check _LibCCheckUnload$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/libc.imp$(DL) >> $@
-	@echo $(DL)import @$(SDK_LIBC)/imports/netware.imp$(DL) >> $@
-	@echo $(DL)module libc$(DL) >> $@
-endif
-ifdef MODULES
-	@echo $(DL)module $(MODULES)$(DL) >> $@
-endif
-ifdef EXPORTS
-	@echo $(DL)export $(EXPORTS)$(DL) >> $@
-endif
-ifdef IMPORTS
-	@echo $(DL)import $(IMPORTS)$(DL) >> $@
-endif
-ifeq ($(LD),nlmconv)
-	@echo $(DL)input $(@:.def=.o)$(DL) >> $@
-	@echo $(DL)input $(PRELUDE)$(DL) >> $@
-ifdef LDLIBS
-	@echo $(DL)input $(LDLIBS)$(DL) >> $@
-endif
-	@echo $(DL)output $(notdir $(@:.def=.nlm))$(DL) >> $@
-endif
-
diff --git a/libssh2/os400/README400 b/libssh2/os400/README400
index fdac7da5..025cec79 100644
--- a/libssh2/os400/README400
+++ b/libssh2/os400/README400
@@ -18,7 +18,8 @@ additional procedures are provided for string transcoding (see below). No
 wrappers to standard procedures are provided: however, nested calls to
 transcoding procedures may be used.
 
-Crypto API is provided by the IBM QC3 API library. It supports RSA, but not DSA.
+Crypto API is provided by the IBM QC3 API library. It supports RSA and EC,
+but not DSA.
 
 
   Standard compilation environment does support neither autotools nor make;
@@ -36,22 +37,31 @@ Compiling on OS/400:
 archive extraction. Do not ask questions about these subjects if you're not
 familiar with.
 
-_ As a prerequisite, QADRT development environment must be installed.
-_ Install the libssh2 sources directory in IFS.
-_ Enter shell (QSH)
+_ As a prerequisite, QADRT development environment >= 20211112 must be
+  installed.
+  For more information on downloading and installing the QADRT development kit,
+  please see https://www.ibm.com/support/pages/node/6258183
+_ If data compression has to be supported, ZLIB development environment must
+  be installed.
+_ Install the libssh2 sources directory in IFS. Do NOT install it in the
+  installation target directory (which defaults to /libssh2).
+_ Enter shell (QSH). You may need to change the LANG environment variable
+  to be in phase with the libssh2 source files CCSID.
 _ Change current directory to the libssh2 sources installation directory
 _ Change current directory to os400
-_ Edit file iniscript.sh. You may want to change tunable configuration
-  parameters, like debug info generation, optimisation level, listing option,
-  target library, zlib availability and location, etc.
+- If you want to change the default configuration parameters like debug info
+  generation, optimization level, listing option, target library, zlib
+  availability and location, etc., copy file config400.default to
+  config400.override and edit the latter. Do not edit the original default file
+  as it might be overwritten by a subsequent source installation.
 _ Copy any file in the current directory to makelog (i.e.:
   cp initscript.sh makelog): this is intended to create the makelog file with
   an ASCII CCSID!
 _ Enter the command "sh make.sh > makelog 2>&1'
 _ Examine the makelog file to check for compilation errors.
 
-  Leaving file initscript.sh unchanged, this will produce the following OS/400
-objects:
+  Without configuration parameters override, this will produce the following
+OS/400 objects:
 _ Library LIBSSH2. All other objects will be stored in this library.
 _ Modules for all libssh2 units.
 _ Binding directory LIBSSH2_A, to be used at calling program link time for
@@ -96,9 +106,9 @@ String transcoding support:
 values from/to the libssh2 API, three non-standard additional procedures are
 provided. They use a session pointer and a "string cache" pointer.
   Each time a string is transcoded, it is cached in the given cache. It is
-the responsibility of the caller to release the cache when its associted strings
-are no longer needed. These procedures and the string cache type are defined
-in a new libssh2_ccsid.h header file.
+the responsibility of the caller to release the cache when its associated
+strings are no longer needed. These procedures and the string cache type are
+defined in a new libssh2_ccsid.h header file.
   To create a string cache, use:
 
 #include <libssh2_ccsid.h>
@@ -122,7 +132,8 @@ char * libssh2_to_ccsid(LIBSSH2_SESSION *session,
                         size_t *outlen);
 
 where:
-    session      is a libssh2 session used for memory allocation.
+    session      is a libssh2 session used for memory allocation or NULL for
+                 global allocation scheme.
     cache        is the address of a string cache.
     ccsid        is the external (i.e.: non libssh2) coded character set id.
                  65535 means no conversion and 0 means the current job's CCSID.
@@ -144,6 +155,8 @@ or NULL if an error occurred. In addition, the variable pointed by outlen
 receives the effective byte length of the (cached) translated string, or -1
 in case of error.
 
+  Please take care to never mix different sessions into the same cache.
+
 
 
 ILE/RPG support:
diff --git a/libssh2/os400/ccsid.c b/libssh2/os400/ccsid.c
index ef02f1d3..0eb9da24 100644
--- a/libssh2/os400/ccsid.c
+++ b/libssh2/os400/ccsid.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /* Character encoding wrappers. */
@@ -46,6 +48,7 @@
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 
 
@@ -56,6 +59,11 @@
 
 #define OFFSET_OF(t, f) ((size_t) ((char *) &((t *) 0)->f - (char *) 0))
 
+#define ALLOC(s, sz)        ((s)? LIBSSH2_ALLOC((s), (sz)): malloc(sz))
+#define REALLOC(s, p, sz)   ((s)? LIBSSH2_REALLOC((s), (p), (sz)):      \
+                                  realloc((p), (sz)))
+#define FREE(s, p)          ((s)? LIBSSH2_FREE((s), (p)): free(p))
+
 
 struct _libssh2_string_cache {
     libssh2_string_cache *  next;
@@ -80,7 +88,7 @@ terminator_size(unsigned short ccsid)
     /* Return the null-terminator size for the given CCSID. */
 
     /* Fast check usual CCSIDs. */
-    switch (ccsid) {
+    switch(ccsid) {
     case CCSID_UTF8:
     case 0:                                 /* Job CCSID is SBCS EBCDIC. */
         return 1;
@@ -90,19 +98,19 @@ terminator_size(unsigned short ccsid)
 
     /* Convert an UTF-8 NUL to the target CCSID: use the converted size as
        result. */
-    memset((void *) &outcode, 0, sizeof outcode);
+    memset((void *) &outcode, 0, sizeof(outcode));
     outcode.CCSID = ccsid;
     cd = QtqIconvOpen(&outcode, (QtqCode_T *) &utf8code);
-    if (cd.return_value == -1)
+    if(cd.return_value == -1)
         return -1;
     inp = "";
     ilen = 1;
     outp = buf;
-    olen = sizeof buf;
+    olen = sizeof(buf);
     iconv(cd, &inp, &ilen, &outp, &olen);
     iconv_close(cd);
-    olen = sizeof buf - olen;
-    return olen? olen: -1;
+    olen = sizeof(buf - olen);
+    return olen ? olen : -1;
 }
 
 static char *
@@ -124,66 +132,66 @@ convert_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
     QtqCode_T outcode;
     iconv_t cd;
 
-    if (!instring) {
-        if (outlen)
+    if(!instring) {
+        if(outlen)
             *outlen = 0;
         return NULL;
     }
-    if (outlen)
+    if(outlen)
         *outlen = -1;
-    if (!session || !cache)
+    if(!cache)
         return NULL;
 
     /* Get terminator size. */
     termsize = terminator_size(outccsid);
-    if (termsize < 0)
+    if(termsize < 0)
         return NULL;
- 
+
     /* Prepare conversion parameters. */
-    memset((void *) &incode, 0, sizeof incode);
-    memset((void *) &outcode, 0, sizeof outcode);
+    memset((void *) &incode, 0, sizeof(incode));
+    memset((void *) &outcode, 0, sizeof(outcode));
     incode.CCSID = inccsid;
     outcode.CCSID = outccsid;
     curlen = OFFSET_OF(libssh2_string_cache, string);
     inp = (char *) instring;
     ilen = inlen;
     buflen = inlen + curlen;
-    if (inlen < 0) {
+    if(inlen < 0) {
         incode.length_option = 1;
         buflen = STRING_GRANULE;
         ilen = 0;
     }
 
     /* Allocate output string buffer and open conversion descriptor. */
-    dst = LIBSSH2_ALLOC(session, buflen + termsize);
-    if (!dst)
+    dst = ALLOC(session, buflen + termsize);
+    if(!dst)
         return NULL;
     cd = QtqIconvOpen(&outcode, &incode);
-    if (cd.return_value == -1) {
-        LIBSSH2_FREE(session, (char *) dst);
+    if(cd.return_value == -1) {
+        FREE(session, dst);
         return NULL;
     }
 
     /* Convert string. */
-    for (;;) {
+    for(;;) {
         outp = dst + curlen;
         olen = buflen - curlen;
         i = iconv(cd, &inp, &ilen, &outp, &olen);
-        if (inlen < 0 && olen == buflen - curlen) {
+        if(inlen < 0 && olen == buflen - curlen) {
             /* Special case: converted 0-length (sub)strings do not store the
                terminator. */
-            if (termsize) {
+            if(termsize) {
                 memset(outp, 0, termsize);
                 olen -= termsize;
             }
         }
         curlen = buflen - olen;
-        if (i >= 0 || errno != E2BIG)
+        if(i >= 0 || errno != E2BIG)
             break;
         /* Must expand buffer. */
         buflen += STRING_GRANULE;
-        outp = LIBSSH2_REALLOC(session, dst, buflen + termsize);
-        if (!outp)
+        outp = REALLOC(session, dst, buflen + termsize);
+        if(!outp)
             break;
         dst = outp;
     }
@@ -191,20 +199,20 @@ convert_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
     iconv_close(cd);
 
     /* Check for error. */
-    if (i < 0 || !outp) {
-        LIBSSH2_FREE(session, dst);
+    if(i < 0 || !outp) {
+        FREE(session, dst);
         return NULL;
     }
 
     /* Process terminator. */
-    if (inlen < 0)
+    if(inlen < 0)
         curlen -= termsize;
-    else if (termsize)
+    else if(termsize)
         memset(dst + curlen, 0, termsize);
 
     /* Shorten buffer if possible. */
-    if (curlen < buflen)
-        dst = LIBSSH2_REALLOC(session, dst, curlen + termsize);
+    if(curlen < buflen)
+        dst = REALLOC(session, dst, curlen + termsize);
 
     /* Link to cache. */
     outstring = (libssh2_string_cache *) dst;
@@ -212,7 +220,7 @@ convert_ccsid(LIBSSH2_SESSION *session, libssh2_string_cache **cache,
     *cache = outstring;
 
     /* Return length if required. */
-    if (outlen)
+    if(outlen)
         *outlen = curlen - OFFSET_OF(libssh2_string_cache, string);
 
     return outstring->string;
@@ -242,10 +250,10 @@ libssh2_release_string_cache(LIBSSH2_SESSION *session,
 {
     libssh2_string_cache *p;
 
-    if (session && cache)
-        while ((p = *cache)) {
+    if(cache)
+        while((p = *cache)) {
             *cache = p->next;
-            LIBSSH2_FREE(session, (char *) p);
+            FREE(session, (char *) p);
         }
 }
 
diff --git a/libssh2/os400/config400.default b/libssh2/os400/config400.default
new file mode 100644
index 00000000..5147cb20
--- /dev/null
+++ b/libssh2/os400/config400.default
@@ -0,0 +1,28 @@
+#!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
+################################################################################
+
+#                       Tunable configuration parameters.
+
+setenv TARGETLIB        'LIBSSH2'               # Target OS/400 program library.
+setenv STATBNDDIR       'LIBSSH2_A'             # Static binding directory.
+setenv DYNBNDDIR        'LIBSSH2'               # Dynamic binding directory.
+setenv SRVPGM           "LIBSSH2.${SONAME}"     # Service program.
+setenv TGTCCSID         '500'                   # Target CCSID of objects.
+setenv DEBUG            '*ALL'                  # Debug level.
+setenv OPTIMIZE         '10'                    # Optimisation level
+setenv OUTPUT           '*NONE'                 # Compilation output option.
+setenv TGTRLS           '*CURRENT'              # Target OS release.
+setenv IFSDIR           '/libssh2'              # Installation IFS directory.
+setenv QADRTDIR         '/QIBM/ProdData/qadrt'  # QADRT IFS directory.
+
+setenv WITH_MD5         'yes'                   # enable MD5 support.
+
+#       Define ZLIB availability and locations.
+
+setenv WITH_ZLIB        0                       # Define to 1 to enable.
+setenv ZLIB_INCLUDE     '/zlib/include'         # ZLIB include IFS directory.
+setenv ZLIB_LIB         'ZLIB'                  # ZLIB library.
+setenv ZLIB_BNDDIR      'ZLIB_A'                # ZLIB binding directory.
diff --git a/libssh2/os400/include/alloca.h b/libssh2/os400/include/alloca.h
index ff0cee4e..050f4422 100644
--- a/libssh2/os400/include/alloca.h
+++ b/libssh2/os400/include/alloca.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_ALLOCA_H
diff --git a/libssh2/libssh2/tests/openssh_fixture.h b/libssh2/os400/include/assert.h
similarity index 74%
rename from libssh2/libssh2/tests/openssh_fixture.h
rename to libssh2/os400/include/assert.h
index 2d2bb0ad..b6197c65 100644
--- a/libssh2/libssh2/tests/openssh_fixture.h
+++ b/libssh2/os400/include/assert.h
@@ -1,4 +1,5 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/*
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,13 +34,27 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef LIBSSH2_TESTS_OPENSSH_FIXTURE_H
-#define LIBSSH2_TESTS_OPENSSH_FIXTURE_H
+#ifndef LIBSSH2_ASSERT_H
+#define LIBSSH2_ASSERT_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Ascii assert() macro. */
 
-int start_openssh_fixture();
-void stop_openssh_fixture();
-int open_socket_to_openssh_server();
+#ifndef NDEBUG
+#pragma convert(819)
 
+#define assert(expr)    ((expr)? ((void) 0): (fprintf(stderr,           \
+                "Assertion failed: %s in file %s line %u. Aborting\n",  \
+                #expr, __FILE__, __LINE__), abort()))
+#else
+#define assert(expr)    ((void) 0)
 #endif
+#endif
+
+/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/os400/include/stdio.h b/libssh2/os400/include/stdio.h
deleted file mode 100644
index 7ac9d993..00000000
--- a/libssh2/os400/include/stdio.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#ifndef LIBSSH2_STDIO_H
-#define LIBSSH2_STDIO_H
-
-/*
- *  <stdio.h> wrapper.
- *  Its goal is to redefine snprintf/vsnprintf which are not supported by QADRT.
- */
-
-#include <qadrt.h>
-
-#if __ILEC400_TGTVRM__ >= 710
-# include_next <stdio.h>
-#elif __ILEC400_TGTVRM__ >= 510
-# ifndef __SRCSTMF__
-#  include <QADRT/h/stdio>
-# else
-#  include </QIBM/ProdData/qadrt/include/stdio.h>
-# endif
-#endif
-
-extern int  _libssh2_os400_vsnprintf(char *dst, size_t len,
-                                     const char *fmt, va_list args);
-extern int  _libssh2_os400_snprintf(char *dst, size_t len,
-                                    const char *fmt, ...);
-
-#ifndef LIBSSH2_DISABLE_QADRT_EXT
-# define vsnprintf(dst, len, fmt, args)                                     \
-                        _libssh2_os400_vsnprintf((dst), (len), (fmt), (args))
-# define snprintf       _libssh2_os400_snprintf
-#endif
-
-#endif
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/os400/include/sys/socket.h b/libssh2/os400/include/sys/socket.h
index 4c771218..7d5adea9 100644
--- a/libssh2/os400/include/sys/socket.h
+++ b/libssh2/os400/include/sys/socket.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_SYS_SOCKET_H
@@ -64,7 +66,7 @@
 #endif
 
 extern int  _libssh2_os400_connect(int sd,
-                                   struct sockaddr * destaddr, int addrlen);
+                                   struct sockaddr *destaddr, int addrlen);
 
 #ifndef LIBSSH2_DISABLE_QADRT_EXT
 #define connect(sd, addr, len)  _libssh2_os400_connect((sd), (addr), (len))
diff --git a/libssh2/os400/initscript.sh b/libssh2/os400/initscript.sh
old mode 100644
new mode 100755
index a18e24cf..bbe78c07
--- a/libssh2/os400/initscript.sh
+++ b/libssh2/os400/initscript.sh
@@ -1,19 +1,20 @@
 #!/bin/sh
-
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 
 setenv()
 
 {
         #       Define and export.
 
-        eval ${1}="${2}"
-        export ${1}
+        eval "${1}=${2}"
+        export "${1?}"
 }
 
 
 case "${SCRIPTDIR}" in
 /*)     ;;
-*)      SCRIPTDIR="`pwd`/${SCRIPTDIR}"
+*)      SCRIPTDIR="$(pwd)/${SCRIPTDIR}"
 esac
 
 while true
@@ -25,63 +26,43 @@ done
 
 #  The script directory is supposed to be in $TOPDIR/os400.
 
-TOPDIR=`dirname "${SCRIPTDIR}"`
+TOPDIR=$(dirname "${SCRIPTDIR}")
 export SCRIPTDIR TOPDIR
 
 #  Extract the SONAME from the library makefile.
 
-SONAME=`sed -e '/^VERSION=/!d' -e 's/^.* \([0-9]*\):.*$/\1/' -e 'q'     \
-                                                < "${TOPDIR}/src/Makefile.am"`
+SONAME=$(sed -e '/^VERSION=/!d'                                         \
+             -e 's/^.* \([0-9]*\):.*$/\1/' -e 'q'                       \
+                                                < "${TOPDIR}/src/Makefile.am")
 export SONAME
 
+#       Get OS/400 configuration parameters.
 
-################################################################################
-#
-#                       Tunable configuration parameters.
-#
-################################################################################
-
-setenv TARGETLIB        'LIBSSH2'               # Target OS/400 program library.
-setenv STATBNDDIR       'LIBSSH2_A'             # Static binding directory.
-setenv DYNBNDDIR        'LIBSSH2'               # Dynamic binding directory.
-setenv SRVPGM           "LIBSSH2.${SONAME}"     # Service program.
-setenv TGTCCSID         '500'                   # Target CCSID of objects.
-setenv DEBUG            '*ALL'                  # Debug level.
-setenv OPTIMIZE         '10'                    # Optimisation level
-setenv OUTPUT           '*NONE'                 # Compilation output option.
-setenv TGTRLS           'V6R1M0'                # Target OS release.
-setenv IFSDIR           '/libssh2'              # Installation IFS directory.
-
-#       Define ZLIB availability and locations.
-
-setenv WITH_ZLIB        0                       # Define to 1 to enable.
-setenv ZLIB_INCLUDE     '/zlib/include'         # ZLIB include IFS directory.
-setenv ZLIB_LIB         'ZLIB'                  # ZLIB library.
-setenv ZLIB_BNDDIR      'ZLIB_A'                # ZLIB binding directory.
-
-
-################################################################################
+. "${SCRIPTDIR}/config400.default"
+if [ -f "${SCRIPTDIR}/config400.override" ]
+then    . "${SCRIPTDIR}/config400.override"
+fi
 
 #       Need to get the version definitions.
 
-LIBSSH2_VERSION=`grep '^#define  *LIBSSH2_VERSION '                     \
+LIBSSH2_VERSION=$(grep '^#define  *LIBSSH2_VERSION '                    \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/.*"\(.*\)".*/\1/'`
-LIBSSH2_VERSION_MAJOR=`grep '^#define  *LIBSSH2_VERSION_MAJOR '         \
+                sed 's/.*"\(.*\)".*/\1/')
+LIBSSH2_VERSION_MAJOR=$(grep '^#define  *LIBSSH2_VERSION_MAJOR '        \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_MAJOR  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_MINOR=`grep '^#define  *LIBSSH2_VERSION_MINOR '         \
+                sed 's/^#define  *LIBSSH2_VERSION_MAJOR  *\([^ ]*\).*/\1/')
+LIBSSH2_VERSION_MINOR=$(grep '^#define  *LIBSSH2_VERSION_MINOR '        \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_MINOR  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_PATCH=`grep '^#define  *LIBSSH2_VERSION_PATCH '         \
+                sed 's/^#define  *LIBSSH2_VERSION_MINOR  *\([^ ]*\).*/\1/')
+LIBSSH2_VERSION_PATCH=$(grep '^#define  *LIBSSH2_VERSION_PATCH '        \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_PATCH  *\([^ ]*\).*/\1/'`
-LIBSSH2_VERSION_NUM=`grep '^#define  *LIBSSH2_VERSION_NUM '             \
+                sed 's/^#define  *LIBSSH2_VERSION_PATCH  *\([^ ]*\).*/\1/')
+LIBSSH2_VERSION_NUM=$(grep '^#define  *LIBSSH2_VERSION_NUM '            \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/^#define  *LIBSSH2_VERSION_NUM  *0x\([^ ]*\).*/\1/'`
-LIBSSH2_TIMESTAMP=`grep '^#define  *LIBSSH2_TIMESTAMP '                 \
+                sed 's/^#define  *LIBSSH2_VERSION_NUM  *0x\([^ ]*\).*/\1/')
+LIBSSH2_TIMESTAMP=$(grep '^#define  *LIBSSH2_TIMESTAMP '                \
                         "${TOPDIR}/include/libssh2.h"                   |
-                sed 's/.*"\(.*\)".*/\1/'`
+                sed 's/.*"\(.*\)".*/\1/')
 export LIBSSH2_VERSION
 export LIBSSH2_VERSION_MAJOR LIBSSH2_VERSION_MINOR LIBSSH2_VERSION_PATCH
 export LIBSSH2_VERSION_NUM LIBSSH2_TIMESTAMP
@@ -112,7 +93,8 @@ action_needed()
 
 {
         [ ! -e "${1}" ] && return 0
-        [ "${2}" ] || return 1
+        [ -n "${2}" ] || return 1
+        # shellcheck disable=SC3013
         [ "${1}" -ot "${2}" ] && return 0
         return 1
 }
@@ -129,7 +111,7 @@ canonicalize_path()
 {
         if expr "${1}" : '^/' > /dev/null
         then    P="${1}"
-        else    P="`pwd`/${1}"
+        else    P="$(pwd)/${1}"
         fi
 
         R=
@@ -140,7 +122,7 @@ canonicalize_path()
         do      IFS="${IFSSAVE}"
                 case "${C}" in
                 .)      ;;
-                ..)     R=`expr "${R}" : '^\(.*/\)..*'`
+                ..)     R="$(expr "${R}" : '^\(.*/\)..*')"
                         ;;
                 ?*)     R="${R}${C}/"
                         ;;
@@ -149,7 +131,7 @@ canonicalize_path()
         done
 
         IFS="${IFSSAVE}"
-        echo "/`expr "${R}" : '^\(.*\)/'`"
+        echo "/$(expr "${R}" : '^\(.*\)/')"
 }
 
 
@@ -165,7 +147,7 @@ make_module()
         MODULES="${MODULES} ${1}"
         MODIFSNAME="${LIBIFSNAME}/${1}.MODULE"
         action_needed "${MODIFSNAME}" "${2}" || return 0;
-        SRCDIR=`dirname \`canonicalize_path "${2}"\``
+        SRCDIR="$(dirname "$(canonicalize_path "${2}")")"
 
         #       #pragma convert has to be in the source file itself, i.e.
         #               putting it in an include file makes it only active
@@ -173,16 +155,18 @@ make_module()
         #       Thus we build a temporary file with the pragma prepended to
         #               the source file and we compile that temporary file.
 
-        echo "#line 1 \"${2}\"" > __tmpsrcf.c
-        echo "#pragma convert(819)" >> __tmpsrcf.c
-        echo "#line 1" >> __tmpsrcf.c
-        cat "${2}" >> __tmpsrcf.c
+        {
+                echo "#line 1 \"${2}\""
+                echo "#pragma convert(819)"
+                echo "#line 1"
+                cat "${2}"
+        } > __tmpsrcf.c
         CMD="CRTCMOD MODULE(${TARGETLIB}/${1}) SRCSTMF('__tmpsrcf.c')"
 #       CMD="${CMD} SYSIFCOPT(*IFS64IO) OPTION(*INCDIRFIRST *SHOWINC *SHOWSYS)"
         CMD="${CMD} SYSIFCOPT(*IFS64IO) OPTION(*INCDIRFIRST)"
         CMD="${CMD} LOCALETYPE(*LOCALE) FLAG(10)"
         CMD="${CMD} INCDIR('${TOPDIR}/os400/include'"
-        CMD="${CMD} '/QIBM/ProdData/qadrt/include' '${TOPDIR}/include'"
+        CMD="${CMD} '${QADRTDIR}/include' '${TOPDIR}/include'"
         CMD="${CMD} '${TOPDIR}/os400' '${SRCDIR}'"
 
         if [ "${WITH_ZLIB}" != "0" ]
@@ -198,15 +182,20 @@ make_module()
         DEFINES="${3}"
 
         if [ "${WITH_ZLIB}" != "0" ]
-        then    DEFINES="${DEFINES} HAVE_LIBZ LIBSSH2_HAVE_ZLIB"
+        then    DEFINES="${DEFINES} LIBSSH2_HAVE_ZLIB"
+        fi
+
+        if [ "${WITH_MD5}" != 'yes' ]
+        then    DEFINES="${DEFINES} LIBSSH2_NO_MD5"
         fi
 
-        if [ "${DEFINES}" ]
+        if [ -n "${DEFINES}" ]
         then    CMD="${CMD} DEFINE(${DEFINES})"
         fi
 
         system "${CMD}"
         rm -f __tmpsrcf.c
+        # shellcheck disable=SC2034
         LINK=YES
 }
 
diff --git a/libssh2/os400/libssh2_ccsid.h b/libssh2/os400/libssh2_ccsid.h
index 632effa3..7bd080c2 100644
--- a/libssh2/os400/libssh2_ccsid.h
+++ b/libssh2/os400/libssh2_ccsid.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /* CCSID conversion support. */
diff --git a/libssh2/os400/libssh2_config.h b/libssh2/os400/libssh2_config.h
index 2e34c4c3..594a23c1 100644
--- a/libssh2/os400/libssh2_config.h
+++ b/libssh2/os400/libssh2_config.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_CONFIG_H
@@ -59,25 +61,6 @@
 /* Define to 1 if you have the <arpa/inet.h> header file. */
 #define HAVE_ARPA_INET_H 1
 
-/* Define to 1 if you have the declaration of `SecureZeroMemory', and to 0 if
-   you don't. */
-#undef HAVE_DECL_SECUREZEROMEMORY
-
-/* disabled non-blocking sockets */
-#undef HAVE_DISABLED_NONBLOCKING
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#define HAVE_ERRNO_H 1
-
-/* Define to 1 if you have the `EVP_aes_128_ctr' function. */
-#undef HAVE_EVP_AES_128_CTR
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
 /* use FIONBIO for non-blocking sockets */
 #undef HAVE_FIONBIO
 
@@ -87,42 +70,15 @@
 /* Define to 1 if you have the <inttypes.h> header file. */
 #define HAVE_INTTYPES_H 1
 
-/* use ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET
-
 /* use Ioctlsocket() for non-blocking sockets */
 #undef HAVE_IOCTLSOCKET_CASE
 
-/* Define if you have the bcrypt library. */
-#undef HAVE_LIBBCRYPT
-
-/* Define if you have the crypt32 library. */
-#undef HAVE_LIBCRYPT32
-
 /* Define if you have the gcrypt library. */
 #undef HAVE_LIBGCRYPT
 
-/* Define if you have the ssl library. */
-#undef HAVE_LIBSSL
-
-/* Define if you have the z library. */
-/* #undef HAVE_LIBZ */
-
-/* Define to 1 if the compiler supports the 'long long' data type. */
-#define HAVE_LONGLONG 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
 /* Define to 1 if you have the <netinet/in.h> header file. */
 #define HAVE_NETINET_IN_H 1
 
-/* Define to 1 if you have the <ntdef.h> header file. */
-#undef HAVE_NTDEF_H
-
-/* Define to 1 if you have the <ntstatus.h> header file. */
-#undef HAVE_NTSTATUS_H
-
 /* use O_NONBLOCK for non-blocking sockets */
 #define HAVE_O_NONBLOCK 1
 
@@ -135,21 +91,9 @@
 /* use SO_NONBLOCK for non-blocking sockets */
 #undef HAVE_SO_NONBLOCK
 
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
 /* Define to 1 if you have the <stdio.h> header file. */
 #define HAVE_STDIO_H 1
 
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
 /* Define to 1 if you have the `strtoll' function. */
 #define HAVE_STRTOLL 1
 
@@ -162,15 +106,9 @@
 /* Define to 1 if you have the <sys/socket.h> header file. */
 #define HAVE_SYS_SOCKET_H 1
 
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
 /* Define to 1 if you have the <sys/time.h> header file. */
 #define HAVE_SYS_TIME_H 1
 
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
 /* Define to 1 if you have the <sys/uio.h> header file. */
 #define HAVE_SYS_UIO_H 1
 
@@ -180,36 +118,15 @@
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1
 
-/* Define to 1 if you have the <windows.h> header file. */
-#undef HAVE_WINDOWS_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to 1 if you have the <ws2tcpip.h> header file. */
-#undef HAVE_WS2TCPIP_H
-
 /* to make a symbol visible */
 #undef LIBSSH2_API
 
-/* Enable clearing of memory before being freed */
-#define LIBSSH2_CLEAR_MEMORY 1
-
-/* Enable "none" cipher -- NOT RECOMMENDED */
-#undef LIBSSH2_CRYPT_NONE
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#define LIBSSH2_DH_GEX_NEW 1
-
 /* Compile in zlib support */
 /* #undef LIBSSH2_HAVE_ZLIB */
 
 /* Use libgcrypt */
 #undef LIBSSH2_LIBGCRYPT
 
-/* Enable "none" MAC -- NOT RECOMMENDED */
-#undef LIBSSH2_MAC_NONE
-
 /* Use OpenSSL */
 #undef LIBSSH2_OPENSSL
 
@@ -219,6 +136,10 @@
 /* Use OS/400 Qc3 */
 #define LIBSSH2_OS400QC3
 
+/* Use our platform-specific local implementation:
+   _libssh2_os400_snprintf */
+#define HAVE_SNPRINTF 1
+
 /* Define to the sub-directory in which libtool stores uninstalled libraries.
 */
 #define LT_OBJDIR ".libs/"
@@ -230,7 +151,7 @@
 #define PACKAGE "libssh2"
 
 /* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "libssh2-devel@cool.haxx.se"
+#define PACKAGE_BUGREPORT "libssh2-devel@lists.haxx.se"
 
 /* Define to the full name of this package. */
 #define PACKAGE_NAME "libssh2"
@@ -250,9 +171,9 @@
 /* If using the C implementation of alloca, define if you know the
    direction of stack growth for your system; otherwise it will be
    automatically deduced at runtime.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown */
+     STACK_DIRECTION > 0 => grows toward higher addresses
+     STACK_DIRECTION < 0 => grows toward lower addresses
+     STACK_DIRECTION = 0 => direction of growth unknown */
 #undef STACK_DIRECTION
 
 /* Define to 1 if you have the ANSI C header files. */
@@ -265,11 +186,6 @@
    significant byte first (like Motorola and SPARC, unlike Intel). */
 #define WORDS_BIGENDIAN 1
 
-/* Enable large inode numbers on Mac OS X 10.5.  */
-#ifndef _DARWIN_USE_64_BIT_INODE
-# define _DARWIN_USE_64_BIT_INODE 1
-#endif
-
 /* Number of bits in a file offset, on hosts where this is settable. */
 #undef _FILE_OFFSET_BITS
 
diff --git a/libssh2/os400/libssh2rpg/libssh2.rpgle.in b/libssh2/os400/libssh2rpg/libssh2.rpgle.in
index 7b7fdd94..e19848eb 100644
--- a/libssh2/os400/libssh2rpg/libssh2.rpgle.in
+++ b/libssh2/os400/libssh2rpg/libssh2.rpgle.in
@@ -1,4 +1,4 @@
-      * Copyright (c) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+      * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
       * All rights reserved.
       *
       * Redistribution and use in source and binary forms,
@@ -33,12 +33,14 @@
       * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
       * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
       * OF SUCH DAMAGE.
+      *
+      * SPDX-License-Identifier: BSD-3-Clause
 
       /if not defined(LIBSSH2_H_)
       /define LIBSSH2_H_
 
      d LIBSSH2_COPYRIGHT...
-     d                 c                   '2004-2015 The libssh2 project and +
+     d                 c                   'The libssh2 project and +
      d                                     its contributors.'
 
       * We use underscore instead of dash when appending DEV in dev versions
@@ -58,7 +60,7 @@
      d                 c                   @LIBSSH2_VERSION_PATCH@
 
       * This is the numeric version of the libssh2 version number, meant for
-      * easier parsing and comparions by programs. The LIBSSH2_VERSION_NUM
+      * easier parsing and comparisons by programs. The LIBSSH2_VERSION_NUM
       * define will always follow this syntax:
       *
       *  X'XXYYZZ'
@@ -110,8 +112,12 @@
 
      d libssh2_uint8_t...
      d                 s              3u 0 based(######typedef######)
+     d libssh2_uint16_t...
+     d                 s              5u 0 based(######typedef######)
      d libssh2_uint32_t...
      d                 s             10u 0 based(######typedef######)
+     d libssh2_int32_t...
+     d                 s             10i 0 based(######typedef######)
      d libssh2_uint64_t...
      d                 s             20u 0 based(######typedef######)
      d libssh2_int64_t...
@@ -121,6 +127,10 @@
      d                 s             10i 0 based(######typedef######)
      d LIBSSH2_INVALID_SOCKET...
      d                 c                   -1
+     d LIBSSH2_SOCKET_CLOSE...
+     d                 pr                  extproc('close')
+     d                                     like(libssh2_Cint)
+     d  s                                  value like(libssh2_socket_t)
 
      d libssh2_mode_t  s             10u 0 based(######typedef######)
      d libssh2_ino_t   s             10u 0 based(######typedef######)
@@ -163,9 +173,9 @@
 
       * Part of every banner, user specified or not.
      d LIBSSH2_SSH_BANNER...
-     d                 c                   'SSH-2.0-libssh2_1.6.1_DEV'
+     d                 c                   'SSH-2.0-libssh2_@LIBSSH2_VERSION@'
      d LIBSSH2_SSH_DEFAULT_BANNER...
-     d                 c                   'SSH-2.0-libssh2_1.6.1_DEV'
+     d                 c                   'SSH-2.0-libssh2_@LIBSSH2_VERSION@'
 
       * Default generate and safe prime sizes for
       * diffie-hellman-group-exchange-sha1.
@@ -211,8 +221,8 @@
      d LIBSSH2_USERAUTH_KBDINT_PROMPT...
      d                 ds                  based(######typedef######)
      d                                     align qualified
-     d  text                           *                                        char *
-     d  length                             like(libssh2_Cuint)
+     d  text                           *                                        unsigned char *
+     d  length                             like(libssh2_Csize_t)
      d  echo                               like(libssh2_Cuchar)
 
      d LIBSSH2_USERAUTH_KBDINT_RESPONSE...
@@ -221,6 +231,22 @@
      d  text                           *                                        char *
      d  length                             like(libssh2_Cuint)
 
+     d LIBSSH2_SK_SIG_INFO...
+     d                 ds                  based(######typedef######)
+     d                                     align qualified
+     d  flags                              like(libssh2_uint8_t)
+     d  counter                            like(libssh2_uint32_t)
+     d  sig_r                          *                                        unsigned char *
+     d  sig_r_len                          like(libssh2_Csize_t)
+     d  sig_s                          *                                        unsigned char *
+     d  sig_s_len                          like(libssh2_Csize_t)
+
+      * Flags for SK authentication
+     d LIBSSH2_SK_PRESENCE_REQUIRED...
+     d                 c                   X'01'
+     d LIBSSH2_SK_VERIFICATION_REQUIRED...
+     d                 c                   X'04'
+
       * libssh2_session_callback_set() constants.
      d LIBSSH2_CALLBACK_IGNORE...
      d                 c                   0
@@ -236,6 +262,12 @@
      d                 c                   5
      d LIBSSH2_CALLBACK_RECV...
      d                 c                   6
+     d LIBSSH2_CALLBACK_AUTHAGENT...
+     d                 c                   7
+     d LIBSSH2_CALLBACK_AUTHAGENT_IDENTITIES...
+     d                 c                   8
+     d LIBSSH2_CALLBACK_AUTHAGENT_SIGN...
+     d                 c                   9
 
       * libssh2_session_method_pref() constants.
      d LIBSSH2_METHOD_KEX...
@@ -258,12 +290,38 @@
      d                 c                   8
      d LIBSSH2_METHOD_LANG_SC...
      d                 c                   9
+     d LIBSSH2_METHOD_SIGN_ALGO...
+     d                 c                   10
 
       * flags.
      d LIBSSH2_FLAG_SIGPIPE...
      d                 c                   X'0001'
      d LIBSSH2_FLAG_COMPRESS...
      d                 c                   X'0002'
+     d LIBSSH2_FLAG_QUOTE_PATHS...
+     d                 c                   X'0003'
+
+      * SK signature callback
+     d LIBSSH2_PRIVKEY_SK...
+     d                 ds                  based(######typedef######)
+     d                                     align qualified
+     d  algorithm                          like(libssh2_Cint)
+     d  flags                              like(libssh2_uint8_t)
+     d  application                    *                                        const char *
+     d  key_handle                     *                                        const uchar *
+     d  handle_len                         like(libssh2_Csize_t)
+     d  sign_callback                  *   procptr
+     d  orig_abstract                  *                                        void **
+
+     d libssh2_sign_sk...
+     d                 pr                  extproc('libssh2_sign_sk')
+     d                                     like(libssh2_Cint)
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  sig                            *                                        unsigned char *[]
+     d  sig_len                            value like(libssh2_Csize_t)
+     d  data                           *   value                                const uchar *
+     d  data_len                           value like(libssh2_Csize_t)
+     d  abstract                       *                                        void *
 
      d LIBSSH2_POLLFD  ds                  based(######typedef######)
      d                                     align qualified
@@ -321,6 +379,8 @@
      d                 c                   1
      d LIBSSH2_HOSTKEY_HASH_SHA1...
      d                 c                   2
+     d LIBSSH2_HOSTKEY_HASH_SHA256...
+     d                 c                   3
 
       * Hostkey Types.
      d LIBSSH2_HOSTKEY_TYPE_UNKNOWN...
@@ -329,6 +389,14 @@
      d                 c                   1
      d LIBSSH2_HOSTKEY_TYPE_DSS...
      d                 c                   2
+     d LIBSSH2_HOSTKEY_TYPE_ECDSA_256...
+     d                 c                   3
+     d LIBSSH2_HOSTKEY_TYPE_ECDSA_384...
+     d                 c                   4
+     d LIBSSH2_HOSTKEY_TYPE_ECDSA_521...
+     d                 c                   5
+     d LIBSSH2_HOSTKEY_TYPE_ED25519...
+     d                 c                   6
 
       * Disconnect Codes (defined by SSH protocol).
      d SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT...
@@ -466,6 +534,20 @@
      d                 c                   -45
      d LIBSSH2_ERROR_KNOWN_HOSTS...
      d                 c                   -46
+     d LIBSSH2_ERROR_CHANNEL_WINDOW_FULL...
+     d                 c                   -47
+     d LIBSSH2_ERROR_KEYFILE_AUTH_FAILED...
+     d                 c                   -48
+     d LIBSSH2_ERROR_RANDGEN...
+     d                 c                   -49
+     d LIBSSH2_ERROR_MISSING_USERAUTH_BANNER...
+     d                 c                   -50
+     d LIBSSH2_ERROR_ALGO_UNSUPPORTED...
+     d                 c                   -51
+     d LIBSSH2_ERROR_MAC_FAILURE...
+     d                 c                   -52
+     d LIBSSH2_ERROR_HASH_INIT...
+     d                 c                   -53
 
       * this is a define to provide the old (<= 1.2.7) name.
      d LIBSSH2_ERROR_BANNER_NONE...
@@ -511,7 +593,7 @@
       *
       * Fills algs with a list of supported cryptographic algorithms. Returns a
       * non-negative number (number of supported algorithms) on success or a
-      * negative number (an eror code) on failure.
+      * negative number (an error code) on failure.
       *
       * NOTE: on success, algs must be deallocated (by calling libssh2_free)
       * when not needed anymore
@@ -540,6 +622,17 @@
      d                 pr              *   extproc('libssh2_session_abstract')  void * *
      d  session                        *   value                                LIBSSH2_SESSION *
 
+     d libssh2_cb_generic_ptr...
+     d                 s               *   based(######typedef######) procptr
+
+     d libssh2_session_callback_set2...
+     d                 pr                  extproc(
+     d                                     'libssh2_session_callback_set2')
+     d                                     like(libssh2_cb_generic_ptr)
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  cbtype                             value like(libssh2_Cint)
+     d  callback                           value like(libssh2_cb_generic_ptr)
+
      d libssh2_session_callback_set...
      d                 pr              *   extproc(                             void *
      d                                     'libssh2_session_callback_set')
@@ -553,6 +646,7 @@
      d  session                        *   value                                LIBSSH2_SESSION *
      d  banner                         *   value options(*string)               const char *
 
+      /if not defined(LIBSSH2_NO_DEPRECATED)
      d libssh2_banner_set...
      d                 pr                  extproc('libssh2_banner_set')
      d                                     like(libssh2_Cint)
@@ -564,6 +658,7 @@
      d                                     like(libssh2_Cint)
      d  session                        *   value                                LIBSSH2_SESSION *
      d  sock                               value like(libssh2_Cint)
+      /endif
 
      d libssh2_session_handshake...
      d                 pr                  extproc('libssh2_session_handshake')
@@ -662,6 +757,12 @@
      d  username                       *   value options(*string)               const char *
      d  username_len                       value like(libssh2_Cuint)
 
+     d libssh2_userauth_banner...
+     d                 pr                  extproc('libssh2_userauth_banner')
+     d                                     like(libssh2_Cint)
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  banner                         *                                        char *
+
      d libssh2_userauth_authenticated...
      d                 pr                  extproc(
      d                                     'libssh2_userauth_authenticated')
@@ -772,7 +873,7 @@
       * response_callback is provided with filled by library prompts array,
       * but client must allocate and fill individual responses. Responses
       * array is already allocated. Responses data will be freed by libssh2
-      * after callback return, but before subsequent callback invokation.
+      * after callback return, but before subsequent callback invocation.
 
      d libssh2_userauth_keyboard_interactive_ex...
      d                 pr                  extproc('libssh2_userauth_keyboard_i-
@@ -794,6 +895,24 @@
      d  response_callback...
      d                                 *   value procptr
 
+     d libssh2_userauth_publickey_sk...
+     d                 pr                  extproc(
+     d                                     'libssh2_userauth_publickey_sk')
+     d                                     like(libssh2_Cint)
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  username                       *   value options(*string)               const char *
+     d  username_len                       value like(libssh2_Csize_t)
+     d  pubkeydata                     *   value                                const uchar *
+     d  pubkeydata_len...
+     d                                     value like(libssh2_Csize_t)
+     d  privatekeydata...
+     d                                 *   value options(*string)               const char *
+     d  privatekeydata_len...
+     d                                     value like(libssh2_Csize_t)
+     d  passphrase                     *   value options(*string)               const char *
+     d  sign_callback                  *   value procptr
+     d  abstract                       *                                        void *
+
      d libssh2_poll    pr                  extproc('libssh2_poll')
      d                                     like(libssh2_Cint)
      d  fds                            *   value                                LIBSSH2_POLLFD *
@@ -858,6 +977,14 @@
      d  host                           *   value options(*string)               const char *
      d  port                               value like(libssh2_Cint)
 
+     d  libssh2_channel_direct_streamlocal_ex...
+     d                 pr              *   extproc('libssh2_channel_direct-     LIBSSH2_CHANNEL *
+     d                                     _streamlocal_ex')
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  socket_path                    *   value options(*string)               const char *
+     d  shost                          *   value options(*string)               const char *
+     d  sport                              value like(libssh2_Cint)
+
      d libssh2_channel_forward_listen_ex...
      d                 pr              *   extproc(                             LIBSSH2_LISTENER *
      d                                     'libssh2_channel_forward_listen_ex')
@@ -902,6 +1029,12 @@
      d  varname                        *   value options(*string)               const char *
      d  value                          *   value options(*string)               const char *
 
+     d libssh2_channel_request_auth_agent...
+     d                 pr                  extproc(
+     d                                     'libssh2_channel_request_auth_agent')
+     d                                     like(libssh2_Cint)
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+
      d libssh2_channel_request_pty_ex...
      d                 pr                  extproc(
      d                                     'libssh2_channel_request_pty_ex')
@@ -961,6 +1094,20 @@
      d  channel                        *   value                                LIBSSH2_CHANNEL *
      d  screen_number                      value like(libssh2_Cint)
 
+     d libssh2_channel_signal_ex...
+     d                 pr                  extproc('libssh2_channel_signal_ex')
+     d                                     like(libssh2_Cint)
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+     d  signame                        *   value options(*string)               const char *
+     d  signame_len                        value like(libssh2_Csize_t)
+
+      * C macro implementation
+     d libssh2_channel_signal...
+     d                 pr                  extproc('libssh2_channel_signal_ex')
+     d                                     like(libssh2_Cint)
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+     d  signame                        *   value options(*string)               const char *
+
      d libssh2_channel_process_startup...
      d                 pr                  extproc(
      d                                     'libssh2_channel_process_startup')
@@ -1038,6 +1185,16 @@
      d                                     like(libssh2_Culong)
      d  channel                        *   value                                LIBSSH2_CHANNEL *
 
+      /if not defined(LIBSSH2_NO_DEPRECATED)
+     d libssh2_channel_receive_window_adjust...
+     d                 pr                  extproc('libssh2_channel_receive_win-
+     d                                     dow_adjust')
+     d                                     like(libssh2_Culong)
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+     d  adjustment                         value like(libssh2_Culong)
+     d  force                              value like(libssh2_Cuchar)
+      /endif
+
      d libssh2_channel_receive_window_adjust2...
      d                 pr                  extproc('libssh2_channel_receive_win-
      d                                     dow_adjust2')
@@ -1117,6 +1274,26 @@
      d                                     like(libssh2_Clong)
      d  session                        *   value                                LIBSSH2_SESSION *
 
+     d libssh2_session_set_read_timeout...
+     d                 pr                  extproc(
+     d                                     'libssh2_session_set_read_timeout')
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  timeout                            value like(libssh2_Clong)
+
+     d libssh2_session_get_read_timeout...
+     d                 pr                  extproc(
+     d                                     'libssh2_session_get_read_timeout')
+     d                                     like(libssh2_Clong)
+     d  session                        *   value                                LIBSSH2_SESSION *
+
+      /if not defined(LIBSSH2_NO_DEPRECATED)
+     d libssh2_channel_handle_extended_data...
+     d                 pr                  extproc('libssh2_channel_handle_exte-
+     d                                     nded_data')
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+     d  ignore_mode                        value like(libssh2_Cint)
+      /endif
+
      d libssh2_channel_handle_extended_data2...
      d                 pr                  extproc('libssh2_channel_handle_exte-
      d                                     nded_data2')
@@ -1124,8 +1301,16 @@
      d  channel                        *   value                                LIBSSH2_CHANNEL *
      d  ignore_mode                        value like(libssh2_Cint)
 
+      /if not defined(LIBSSH2_NO_DEPRECATED)
       * libssh2_channel_ignore_extended_data() is defined below for BC with
       * version 0.1.
+      * C macro implementation.
+     d libssh2_channel_ignore_extended_data...
+     d                 pr                  extproc('libssh2_channel-
+     d                                     _ignore_extended_data')
+     d  channel                        *   value                                LIBSSH2_CHANNEL *
+     d  ignore                             value like(libssh2_Cint)
+      /endif
 
      d LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA...
      d                 c                   -1
@@ -1201,6 +1386,14 @@
      d                                     like(libssh2_Cint)
      d  channel                        *   value                                LIBSSH2_CHANNEL *
 
+      /if not defined(LIBSSH2_NO_DEPRECATED)
+     d libssh2_scp_recv...
+     d                 pr              *   extproc('libssh2_scp_recv')          LIBSSH2_CHANNEL *
+     d  session                        *   value                                LIBSSH2_SESSION *
+     d  path                           *   value options(*string)               const char *
+     d  sb                             *   value                                struct stat *
+      /endif
+
       * Use libssh2_scp_recv2 for large (> 2GB) file support.
      d libssh2_scp_recv2...
      d                 pr              *   extproc('libssh2_scp_recv2')         LIBSSH2_CHANNEL *
@@ -1234,6 +1427,7 @@
      d  mode                               value like(libssh2_Cint)
      d  size                               value like(libssh2_int64_t)
 
+      * DEPRECATED
      d libssh2_base64_decode...
      d                 pr                  extproc('libssh2_base64_decode')
      d                                     like(libssh2_Cint)
@@ -1249,6 +1443,26 @@
      d  req_version_num...
      d                                     value like(libssh2_Cint)
 
+     d libssh2_crypto_engine_t...
+     d                 s                   based(######typedef######)
+     d                                     like(libssh2_Cenum)
+     d  libssh2_no_crypto...
+     d                 c                   0
+     d  libssh2_openssl...
+     d                 c                   1
+     d  libssh2_gcrypt...
+     d                 c                   2
+     d  libssh2_mbedtls...
+     d                 c                   3
+     d  libssh2_wincng...
+     d                 c                   4
+     d  libssh2_os400qc3...
+     d                 c                   5
+
+     d libssh2_crypto_engine...
+     d                 pr                  extproc('libssh2_crypto_engine')
+     d                                     like(libssh2_crypto_engine_t)
+
      d HAVE_LIBSSH2_KNOWNHOST_API...                                            since 1.1.1
      d                 c                   X'010101'
      d HAVE_LIBSSH2_VERSION_API...                                              since 1.1
@@ -1311,9 +1525,9 @@
      d LIBSSH2_KNOWNHOST_KEYENC_BASE64...
      d                 c                   X'00020000'
 
-      * type of key (3 bits).
+      * type of key (4 bits).
      d LIBSSH2_KNOWNHOST_KEY_MASK...
-     d                 c                   X'001C0000'
+     d                 c                   X'003C0000'
      d LIBSSH2_KNOWNHOST_KEY_SHIFT...
      d                 c                   18
      d LIBSSH2_KNOWNHOST_KEY_RSA1...
@@ -1322,8 +1536,16 @@
      d                 c                   X'00080000'
      d LIBSSH2_KNOWNHOST_KEY_SSHDSS...
      d                 c                   X'000C0000'
-     d LIBSSH2_KNOWNHOST_KEY_UNKNOWN...
+     d LIBSSH2_KNOWNHOST_KEY_ECDSA_256...
+     d                 c                   X'00100000'
+     d LIBSSH2_KNOWNHOST_KEY_ECDSA_384...
+     d                 c                   X'00140000'
+     d LIBSSH2_KNOWNHOST_KEY_ECDSA_521...
+     d                 c                   X'00180000'
+     d LIBSSH2_KNOWNHOST_KEY_ED25519...
      d                 c                   X'001C0000'
+     d LIBSSH2_KNOWNHOST_KEY_UNKNOWN...
+     d                 c                   X'003C0000'
 
      d libssh2_knownhost_add...
      d                 pr                  extproc('libssh2_knownhost_add')
@@ -1519,7 +1741,7 @@
       * libssh2_knownhost_get()
       *
       * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
-      * the first one. Or pass a poiner to the previously returned one to
+      * the first one. Or pass a pointer to the previously returned one to
       * get the next.
       *
       * Returns:
@@ -1580,7 +1802,7 @@
       * libssh2_agent_get_identity()
       *
       * Traverse the internal list of public keys. Pass NULL to 'prev' to get
-      * the first one. Or pass a poiner to the previously returned one to
+      * the first one. Or pass a pointer to the previously returned one to
       * get the next.
       *
       * Returns:
@@ -1609,6 +1831,24 @@
      d  username                       *   value options(*string)               const char *
      d  identity                           likeds(libssh2_agent_publickey)
 
+      * libssh2_agent_sign()
+      *
+      * Sign a payload using a system-installed ssh-agent.
+      *
+      * Returns 0 if succeeded, or a negative value for error.
+
+     d libssh2_agent_sign...
+     d                 pr                  extproc('libssh2_agent_sign')
+     d                                     like(libssh2_Cint)
+     d  agent                          *   value                                LIBSSH2_AGENT *
+     d  identity                           likeds(libssh2_agent_publickey)
+     d  sig                            *                                        unsigned char *
+     d  s_len                              like(libssh2_Csize_t)
+     d  data                           *   value                                const uchar *
+     d  d_len                              value like(libssh2_Csize_t)
+     d  method                         *   value options(*string)               const char *
+     d  method_len                         value like(libssh2_Cuint)
+
       * libssh2_agent_disconnect()
       *
       * Close a connection to an ssh-agent.
@@ -1629,6 +1869,24 @@
      d                 pr                  extproc('libssh2_agent_free')
      d  agent                          *   value                                LIBSSH2_AGENT *
 
+      * libssh2_agent_set_identity_path()
+      *
+      * Allows a custom agent identity socket path beyond SSH_AUTH_SOCK env
+
+     d libssh2_agent_set_identity_path...
+     d                 pr                  extproc(
+     d                                     'libssh2_agent_set_identity_path')
+     d  agent                          *   value                                LIBSSH2_AGENT *
+     d  path                           *   value options(*string)               const char *
+
+      * libssh2_agent_get_identity_path()
+      *
+      * Returns the custom agent identity socket path if set
+
+     d libssh2_agent_get_identity_path...
+     d                 pr              *   extproc(                             const char *
+     d                                     'libssh2_agent_get_identity_path')
+     d  agent                          *   value                                LIBSSH2_AGENT *
 
       * libssh2_keepalive_config()
       *
diff --git a/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in b/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in
index 345fa630..11364a7d 100644
--- a/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in
+++ b/libssh2/os400/libssh2rpg/libssh2_ccsid.rpgle.in
@@ -1,4 +1,4 @@
-      * Copyright (c) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+      * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
       * All rights reserved.
       *
       * Redistribution and use in source and binary forms,
@@ -33,6 +33,8 @@
       * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
       * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
       * OF SUCH DAMAGE.
+      *
+      * SPDX-License-Identifier: BSD-3-Clause
 
       /if not defined(LIBSSH2_CCSID_H_)
       /define LIBSSH2_CCSID_H_
diff --git a/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle b/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle
index 4387b0d3..4aabfbab 100644
--- a/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle
+++ b/libssh2/os400/libssh2rpg/libssh2_publickey.rpgle
@@ -1,4 +1,4 @@
-      * Copyright (c) 2015, Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+      * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
       * All rights reserved.
       *
       * Redistribution and use in source and binary forms,
@@ -40,6 +40,8 @@
       *
       * For more information on the publickey subsystem,
       * refer to IETF draft: secsh-publickey
+      *
+      * SPDX-License-Identifier: BSD-3-Clause
 
       /if not defined(LIBSSH2_PUBLICKEY_H_)
       /define LIBSSH2_PUBLICKEY_H_
diff --git a/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle b/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle
index f4068fc8..4ccb81b5 100644
--- a/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle
+++ b/libssh2/os400/libssh2rpg/libssh2_sftp.rpgle
@@ -1,4 +1,4 @@
-      * Copyright (c) 2015, Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+      * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
       * All rights reserved.
       *
       * Redistribution and use in source and binary forms,
@@ -33,6 +33,8 @@
       * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
       * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
       * OF SUCH DAMAGE.
+      *
+      * SPDX-License-Identifier: BSD-3-Clause
 
       /if not defined(LIBSSH2_SFTP_H_)
       /define LIBSSH2_SFTP_H_
@@ -77,6 +79,10 @@
      d LIBSSH2_SFTP_REALPATH...
      d                 c                   2
 
+      * Flags for sftp_mkdir()
+     d LIBSSH2_SFTP_DEFAULT_MODE...
+     d                 c                   -1
+
       * SFTP attribute flag bits.
      d LIBSSH2_SFTP_ATTR_SIZE...
      d                 c                   X'00000001'
@@ -95,7 +101,7 @@
      d LIBSSH2_SFTP_ST_NOSUID...
      d                 c                   X'00000002'
 
-     d #LIBSSH2_SFTP_ATTRIBUTES...
+     d LIBSSH2_SFTP_ATTRIBUTES...
      d                 ds                  based(######typedef######)
      d                                     align qualified
       * If flags & ATTR_* bit is set, then the value in this struct will be
@@ -334,8 +340,7 @@
 
       * C macro implementation.
      d libssh2_sftp_open...
-     d                 pr              *   extproc('libssh2_sftp_open')         LIBSSH2_SFTP_HANDLE
-     d                                                                          *
+     d                 pr              *   extproc('libssh2_sftp_open')         LIBSSH2_SFTP_HANDLE*
      d  sftp                           *   value                                LIBSSH2_SFTP *
      d  filename                       *   value options(*string)               const char *
      d  flags                              value like(libssh2_Culong)
@@ -344,16 +349,34 @@
       * C macro libssh2_sftp_opendir implementation.
       * Renamed to avoid upper/lower case name clash.
      d libssh2_sftp_open_dir...
-     d                 pr              *   extproc('libssh2_sftp_opendir')      LIBSSH2_SFTP_HANDLE
-     d                                                                          *
+     d                 pr              *   extproc('libssh2_sftp_opendir')      LIBSSH2_SFTP_HANDLE*
      d  sftp                           *   value                                LIBSSH2_SFTP *
      d  path                           *   value options(*string)               const char *
 
+     d libssh2_sftp_open_ex_r...
+     d                 pr              *   extproc('libssh2_sftp_open_ex_r')    LIBSSH2_SFTP_HANDLE*
+     d  sftp                           *   value                                LIBSSH2_SFTP *
+     d  filename                       *   value options(*string)               const char *
+     d  filename_len                       value like(libssh2_Csize_t)
+     d  flags                              value like(libssh2_Culong)
+     d  mode                               value like(libssh2_Clong)
+     d  open_type                          value like(libssh2_Cint)
+     d  attrs                              likeds(LIBSSH2_SFTP_ATTRIBUTES)
+
+      * C macro implementation.
+     d libssh2_sftp_open_r...
+     d                 pr              *   extproc('libssh2_sftp_open_r')       LIBSSH2_SFTP_HANDLE*
+     d  sftp                           *   value                                LIBSSH2_SFTP *
+     d  filename                       *   value options(*string)               const char *
+     d  flags                              value like(libssh2_Culong)
+     d  mode                               value like(libssh2_Clong)
+     d  attrs                              likeds(LIBSSH2_SFTP_ATTRIBUTES)
+
      d libssh2_sftp_read...
      d                 pr                  extproc('libssh2_sftp_read')
      d                                     like(libssh2_Cssize_t)
      d  handle                         *   value                                LIBSSH2_SFTP_HANDLE*
-     d  buffer                         *   value options(*string)               char *
+     d  buffer                         *   value                                char *
      d  buffer_maxlen                      value like(libssh2_Csize_t)
 
      d libssh2_sftp_readdir_ex...
diff --git a/libssh2/os400/macros.h b/libssh2/os400/macros.h
index 408b98d0..fa2b22ee 100644
--- a/libssh2/os400/macros.h
+++ b/libssh2/os400/macros.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+* SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_MACROS_H_
@@ -90,6 +92,8 @@ libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel,
 LIBSSH2_API int
 libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);
 LIBSSH2_API int
+libssh2_channel_signal(LIBSSH2_CHANNEL *channel, const char *signame);
+LIBSSH2_API int
 libssh2_channel_shell(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API int
 libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);
@@ -98,16 +102,20 @@ libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);
 LIBSSH2_API ssize_t
 libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
 LIBSSH2_API ssize_t
-libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
+libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel,
+                            char *buf, size_t buflen);
 LIBSSH2_API unsigned long
 libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API ssize_t
-libssh2_channel_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);
+libssh2_channel_write(LIBSSH2_CHANNEL *channel,
+                      const char *buf, size_t buflen);
 LIBSSH2_API ssize_t
 libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel,
                              const char *buf, size_t buflen);
 LIBSSH2_API unsigned long
 libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API void
+libssh2_channel_ignore_extended_data(LIBSSH2_CHANNEL *channel, int ignore);
 LIBSSH2_API int libssh2_channel_flush(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API int libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);
 LIBSSH2_API LIBSSH2_CHANNEL *
@@ -116,9 +124,9 @@ libssh2_scp_send(LIBSSH2_SESSION *session,
 
 LIBSSH2_API int
 libssh2_publickey_add(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
-		      const unsigned char *blob, unsigned long blob_len,
+                      const unsigned char *blob, unsigned long blob_len,
                       char overwrite, unsigned long num_attrs,
-		      const libssh2_publickey_attribute attrs[]);
+                      const libssh2_publickey_attribute attrs[]);
 LIBSSH2_API int
 libssh2_publickey_remove(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
                          const unsigned char *blob, unsigned long blob_len);
@@ -135,6 +143,10 @@ libssh2_sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
                   unsigned long flags, long mode);
 LIBSSH2_API LIBSSH2_SFTP_HANDLE *
 libssh2_sftp_opendir(LIBSSH2_SFTP *sftp, const char *path);
+LIBSSH2_API LIBSSH2_SFTP_HANDLE *
+libssh2_sftp_open_r(LIBSSH2_SFTP *sftp, const char *filename,
+                    unsigned long flags, long mode,
+                    LIBSSH2_SFTP_ATTRIBUTES *attrs);
 LIBSSH2_API int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle,
                                      char *buffer, size_t buffer_maxlen,
                                      LIBSSH2_SFTP_ATTRIBUTES *attrs);
diff --git a/libssh2/os400/make-include.sh b/libssh2/os400/make-include.sh
old mode 100644
new mode 100755
index 2cb7b726..5fa911af
--- a/libssh2/os400/make-include.sh
+++ b/libssh2/os400/make-include.sh
@@ -1,11 +1,13 @@
 #!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
 #       Installation of the header files in the OS/400 library.
 #
 
-SCRIPTDIR=`dirname "${0}"`
+SCRIPTDIR=$(dirname "${0}")
 . "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/include"
+cd "${TOPDIR}/include" || exit 1
 
 
 #       Create the OS/400 source program file for the header files.
@@ -45,11 +47,11 @@ copy_hfile()
 #       Copy the header files.
 
 for HFILE in *.h "${TOPDIR}/os400/libssh2_ccsid.h"
-do      DEST="${SRCPF}/`db2_name \"${HFILE}\"`.MBR"
+do      DEST="${SRCPF}/$(db2_name "${HFILE}").MBR"
 
         if action_needed "${DEST}" "${HFILE}"
         then    copy_hfile "${DEST}" "${HFILE}"
-                IFSDEST="${IFSINCLUDE}/`basename \"${HFILE}\"`"
+                IFSDEST="${IFSINCLUDE}/$(basename "${HFILE}")"
                 rm -f "${IFSDEST}"
                 ln -s "${DEST}" "${IFSDEST}"
         fi
diff --git a/libssh2/os400/make-rpg.sh b/libssh2/os400/make-rpg.sh
old mode 100644
new mode 100755
index c8a26472..68b50009
--- a/libssh2/os400/make-rpg.sh
+++ b/libssh2/os400/make-rpg.sh
@@ -1,11 +1,13 @@
 #!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
 #       Installation of the ILE/RPG header files in the OS/400 library.
 #
 
-SCRIPTDIR=`dirname "${0}"`
+SCRIPTDIR=$(dirname "${0}")
 . "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/os400/libssh2rpg"
+cd "${TOPDIR}/os400/libssh2rpg" || exit 1
 
 
 #       Create the OS/400 source program file for the ILE/RPG header files.
@@ -22,9 +24,9 @@ fi
 #       Map file names to DB2 name syntax.
 
 for HFILE in *.rpgle *.rpgle.in
-do      NAME="`basename \"${HFILE}\" .in`"
-        VAR="`basename \"${NAME}\" .rpgle`"
-        VAL="`db2_name \"${NAME}\"`"
+do      NAME="$(basename "${HFILE}" .in)"
+        VAR="$(basename "${NAME}" .rpgle)"
+        VAL="$(db2_name "${NAME}")"
 
         eval "VAR_${VAR}=\"${VAL}\""
         echo "${VAR} s/${VAR}/${VAL}/g"
@@ -62,7 +64,7 @@ fi
 for HFILE in *.rpgle *.rpgle.in
 do      IFSCMD="cat \"${HFILE}\""
         DB2CMD="change_include < \"${HFILE}\""
-        IFSFILE="`basename \"${HFILE}\" .in`"
+        IFSFILE="$(basename "${HFILE}" .in)"
 
         case "${HFILE}" in
 
@@ -77,7 +79,7 @@ do      IFSCMD="cat \"${HFILE}\""
         then    eval "${IFSCMD}" > "${IFSDEST}"
         fi
 
-        eval DB2MBR="\"\${VAR_`basename \"${IFSDEST}\" .rpgle`}\""
+        eval DB2MBR="\"\${VAR_$(basename "${IFSDEST}" .rpgle)}\""
         DB2DEST="${SRCPF}/${DB2MBR}.MBR"
 
         if action_needed "${DB2DEST}" "${HFILE}"
@@ -85,7 +87,7 @@ do      IFSCMD="cat \"${HFILE}\""
 
                 #       Need to translate to target CCSID.
 
-                CMD="CPY OBJ('`pwd`/tmphdrfile') TOOBJ('${DB2DEST}')"
+                CMD="CPY OBJ('$(pwd)/tmphdrfile') TOOBJ('${DB2DEST}')"
                 CMD="${CMD} TOCCSID(${TGTCCSID}) DTAFMT(*TEXT) REPLACE(*YES)"
                 system "${CMD}"
         fi
diff --git a/libssh2/os400/make-src.sh b/libssh2/os400/make-src.sh
old mode 100644
new mode 100755
index 2e9a3c43..4c399da8
--- a/libssh2/os400/make-src.sh
+++ b/libssh2/os400/make-src.sh
@@ -1,11 +1,13 @@
 #!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
 #       libssh2 compilation script for the OS/400.
 #
 
-SCRIPTDIR=`dirname "${0}"`
+SCRIPTDIR=$(dirname "${0}")
 . "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}/src"
+cd "${TOPDIR}/src" || exit 1
 
 
 #       Function to extract external prototypes from header files.
@@ -46,10 +48,12 @@ fi
 
 #      Create and compile the identification source file.
 
-echo '#pragma comment(user, "libssh2 version '"${LIBSSH2_VERSION}"'")' > os400.c
-echo '#pragma comment(user, __DATE__)' >> os400.c
-echo '#pragma comment(user, __TIME__)' >> os400.c
-echo '#pragma comment(copyright, "See COPYING file. OS/400 version by P. Monnerat")' >> os400.c
+{
+        echo '#pragma comment(user, "libssh2 version '"${LIBSSH2_VERSION}"'")'
+        echo '#pragma comment(user, __DATE__)'
+        echo '#pragma comment(user, __TIME__)'
+        echo '#pragma comment(copyright, "See COPYING file. OS/400 version by P. Monnerat")'
+} > os400.c
 make_module     OS400           os400.c
 LINK=                           # No need to rebuild service program yet.
 MODULES=
@@ -78,28 +82,28 @@ fi
 
 #       Get source list.
 
-cat ../Makefile.inc ../Makefile.os400qc3.inc                            |
-  sed -e ':begin'                                                       \
-    -e '/\\$/{'                                                         \
-    -e 's/\\$/ /'                                                       \
-    -e 'N'                                                              \
-    -e 'bbegin'                                                         \
-    -e '}'                                                              \
-    -e 's/\n//g'                                                        \
-    -e 's/[[:space:]]*$//'                                              \
-    -e 's/^\([A-Za-z][A-Za-z0-9_]*\)[[:space:]]*=[[:space:]]*\(.*\)/\1="\2"/' \
-    -e 's/\$(\([A-Za-z][A-Za-z0-9_]*\))/${\1}/g'                        \
-        > tmpscript.sh
+sed -e ':begin'                                                         \
+  -e '/\\$/{'                                                           \
+  -e 's/\\$/ /'                                                         \
+  -e 'N'                                                                \
+  -e 'bbegin'                                                           \
+  -e '}'                                                                \
+  -e 's/\n//g'                                                          \
+  -e 's/[[:space:]]*$//'                                                \
+  -e 's/^\([A-Za-z][A-Za-z0-9_]*\)[[:space:]]*=[[:space:]]*\(.*\)/\1="\2"/' \
+  -e 's/\$(\([A-Za-z][A-Za-z0-9_]*\))/${\1}/g'                          \
+      < Makefile.inc > tmpscript.sh
 . ./tmpscript.sh
 
 
 #       Compile the sources into modules.
 
-INCLUDES="'`pwd`'"
+# shellcheck disable=SC2034
+INCLUDES="'$(pwd)'"
 
 for SRC in "${TOPDIR}/os400/os400sys.c" "${TOPDIR}/os400/ccsid.c"       \
-           ${CSOURCES} ${CRYPTO_CSOURCES} macros.c
-do      MODULE=`db2_name "${SRC}"`
+           ${CSOURCES} macros.c
+do      MODULE=$(db2_name "${SRC}")
         make_module "${MODULE}" "${SRC}"
 done
 
@@ -110,7 +114,7 @@ if action_needed "${LIBIFSNAME}/${STATBNDDIR}.BNDDIR"
 then    LINK=YES
 fi
 
-if [ "${LINK}" ]
+if [ -n "${LINK}" ]
 then    rm -rf "${LIBIFSNAME}/${STATBNDDIR}.BNDDIR"
         CMD="CRTBNDDIR BNDDIR(${TARGETLIB}/${STATBNDDIR})"
         CMD="${CMD} TEXT('libssh2 API static binding directory')"
@@ -143,10 +147,10 @@ fi
 
 #       Gather the list of symbols to export.
 
-EXPORTS=`cat "${TOPDIR}"/include/*.h "${TOPDIR}/os400/macros.h"         \
+EXPORTS=$(cat "${TOPDIR}"/include/*.h "${TOPDIR}/os400/macros.h"        \
              "${TOPDIR}/os400/libssh2_ccsid.h"                          |
          extproto                                                       |
-         sed -e 's/(.*//;s/[^A-Za-z0-9_]/ /g;s/ *$//;s/^.* //'`
+         sed -e 's/(.*//;s/[^A-Za-z0-9_]/ /g;s/ *$//;s/^.* //')
 
 #       Create the service program exportation file in DB2 member if needed.
 
@@ -156,7 +160,7 @@ if action_needed "${BSF}" Makefile.am
 then    LINK=YES
 fi
 
-if [ "${LINK}" ]
+if [ -n "${LINK}" ]
 then    echo " STRPGMEXP PGMLVL(*CURRENT) SIGNATURE('LIBSSH2_${SONAME}')" \
             > "${BSF}"
         for EXPORT in ${EXPORTS}
@@ -173,7 +177,7 @@ if action_needed "${LIBIFSNAME}/${SRVPGM}.SRVPGM"
 then    LINK=YES
 fi
 
-if [ "${LINK}" ]
+if [ -n "${LINK}" ]
 then    CMD="CRTSRVPGM SRVPGM(${TARGETLIB}/${SRVPGM})"
         CMD="${CMD} SRCFILE(${TARGETLIB}/TOOLS) SRCMBR(BNDSRC)"
         CMD="${CMD} MODULE(${TARGETLIB}/OS400)"
@@ -197,7 +201,7 @@ if action_needed "${LIBIFSNAME}/${DYNBNDDIR}.BNDDIR"
 then    LINK=YES
 fi
 
-if [ "${LINK}" ]
+if [ -n "${LINK}" ]
 then    rm -rf "${LIBIFSNAME}/${DYNBNDDIR}.BNDDIR"
         CMD="CRTBNDDIR BNDDIR(${TARGETLIB}/${DYNBNDDIR})"
         CMD="${CMD} TEXT('libssh2 API dynamic binding directory')"
diff --git a/libssh2/os400/make.sh b/libssh2/os400/make.sh
old mode 100644
new mode 100755
index 0c9e3dec..84640db7
--- a/libssh2/os400/make.sh
+++ b/libssh2/os400/make.sh
@@ -1,13 +1,15 @@
 #!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 #
 #       libssh2 compilation script for the OS/400.
 #
 #
 #       This is a shell script since make is not a standard component of OS/400.
 
-SCRIPTDIR=`dirname "${0}"`
+SCRIPTDIR=$(dirname "${0}")
 . "${SCRIPTDIR}/initscript.sh"
-cd "${TOPDIR}"
+cd "${TOPDIR}" || exit 1
 
 
 #       Create the OS/400 library if it does not exist.
@@ -31,8 +33,8 @@ fi
 
 for TEXT in "${TOPDIR}/COPYING" "${SCRIPTDIR}/README400"                \
     "${TOPDIR}/NEWS" "${TOPDIR}/README" "${TOPDIR}/docs/AUTHORS"        \
-    "${TOPDIR}/docs/BINDINGS"
-do      MEMBER="${LIBIFSNAME}/DOCS.FILE/`db2_name \"${TEXT}\"`.MBR"
+    "${TOPDIR}/docs/BINDINGS.md"
+do      MEMBER="${LIBIFSNAME}/DOCS.FILE/$(db2_name "${TEXT}").MBR"
 
         if action_needed "${MEMBER}" "${TEXT}"
         then    CMD="CPY OBJ('${TEXT}') TOOBJ('${MEMBER}') TOCCSID(${TGTCCSID})"
@@ -42,6 +44,36 @@ do      MEMBER="${LIBIFSNAME}/DOCS.FILE/`db2_name \"${TEXT}\"`.MBR"
 done
 
 
+#       Create the RPGXAMPLES source file if it does not exist.
+
+if action_needed "${LIBIFSNAME}/RPGXAMPLES.FILE"
+then    CMD="CRTSRCPF FILE(${TARGETLIB}/RPGXAMPLES) RCDLEN(240)"
+        CMD="${CMD} CCSID(${TGTCCSID}) TEXT('ILE/RPG examples')"
+        system "${CMD}"
+fi
+
+
+#       Copy RPG examples if needed.
+
+for EXAMPLE in "${SCRIPTDIR}/rpg-examples"/*
+do      MEMBER="$(basename "${EXAMPLE}")"
+        IFSMEMBER="${LIBIFSNAME}/RPGXAMPLES.FILE/$(db2_name "${MEMBER}").MBR"
+
+        [ -e "${EXAMPLE}" ] || continue
+
+        if action_needed "${IFSMEMBER}" "${EXAMPLE}"
+        then    CMD="CPY OBJ('${EXAMPLE}') TOOBJ('${IFSMEMBER}')"
+                CMD="${CMD} TOCCSID(${TGTCCSID}) DTAFMT(*TEXT) REPLACE(*YES)"
+                system "${CMD}"
+                MBRTEXT=$(sed -e '1!d;/^      \*/!d;s/^ *\* *//'        \
+                              -e 's/ *$//;s/'"'"'/&&/g' < "${EXAMPLE}")
+                CMD="CHGPFM FILE(${TARGETLIB}/RPGXAMPLES) MBR(${MEMBER})"
+                CMD="${CMD} SRCTYPE(RPGLE) TEXT('${MBRTEXT}')"
+                system "${CMD}"
+        fi
+done
+
+
 #       Build in each directory.
 
 for SUBDIR in include rpg src
diff --git a/libssh2/os400/os400sys.c b/libssh2/os400/os400sys.c
index db67876b..081a26ef 100644
--- a/libssh2/os400/os400sys.c
+++ b/libssh2/os400/os400sys.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /* OS/400 additional support. */
@@ -75,106 +77,54 @@
 
 
 static int
-convert_sockaddr(struct sockaddr_storage * dstaddr,
-                                const struct sockaddr * srcaddr, int srclen)
-
+convert_sockaddr(struct sockaddr_storage *dstaddr,
+                 const struct sockaddr *srcaddr, int srclen)
 {
-  const struct sockaddr_un * srcu;
-  struct sockaddr_un * dstu;
-  unsigned int i;
-  unsigned int dstsize;
+    const struct sockaddr_un *srcu;
+    struct sockaddr_un *dstu;
+    unsigned int i;
+    unsigned int dstsize;
 
-  /* Convert a socket address into job CCSID, if needed. */
+    /* Convert a socket address into job CCSID, if needed. */
 
-  if(!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
-     sizeof srcaddr->sa_family || srclen > sizeof *dstaddr) {
-    errno = EINVAL;
-    return -1;
+    if(!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
+       sizeof(srcaddr->sa_family) || srclen > sizeof(*dstaddr)) {
+        errno = EINVAL;
+        return -1;
     }
 
-  memcpy((char *) dstaddr, (char *) srcaddr, srclen);
+    memcpy((char *) dstaddr, (char *) srcaddr, srclen);
 
-  switch (srcaddr->sa_family) {
+    switch(srcaddr->sa_family) {
 
-  case AF_UNIX:
-    srcu = (const struct sockaddr_un *) srcaddr;
-    dstu = (struct sockaddr_un *) dstaddr;
-    dstsize = sizeof *dstaddr - offsetof(struct sockaddr_un, sun_path);
-    srclen -= offsetof(struct sockaddr_un, sun_path);
-    i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path, dstsize - 1, srclen);
-    dstu->sun_path[i] = '\0';
-    i += offsetof(struct sockaddr_un, sun_path);
-    srclen = i;
+    case AF_UNIX:
+        srcu = (const struct sockaddr_un *) srcaddr;
+        dstu = (struct sockaddr_un *) dstaddr;
+        dstsize = sizeof(*dstaddr) - offsetof(struct sockaddr_un, sun_path);
+        srclen -= offsetof(struct sockaddr_un, sun_path);
+        i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path,
+                            dstsize - 1, srclen);
+        dstu->sun_path[i] = '\0';
+        i += offsetof(struct sockaddr_un, sun_path);
+        srclen = i;
     }
 
-  return srclen;
-}
-
-
-int
-_libssh2_os400_connect(int sd, struct sockaddr * destaddr, int addrlen)
-
-{
-  int i;
-  struct sockaddr_storage laddr;
-
-  i = convert_sockaddr(&laddr, destaddr, addrlen);
-
-  if(i < 0)
-    return -1;
-
-  return connect(sd, (struct sockaddr *) &laddr, i);
+    return srclen;
 }
 
 
 int
-_libssh2_os400_vsnprintf(char *dst, size_t len, const char *fmt, va_list args)
+_libssh2_os400_connect(int sd, struct sockaddr *destaddr, int addrlen)
 {
-    size_t l = 4096;
     int i;
-    char *buf;
-
-    if (!dst || !len) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    if (l < len)
-        l = len;
+    struct sockaddr_storage laddr;
 
-    buf = alloca(l);
+    i = convert_sockaddr(&laddr, destaddr, addrlen);
 
-    if (!buf) {
-        errno = ENOMEM;
+    if(i < 0)
         return -1;
-    }
-
-    i = vsprintf(buf, fmt, args);
-
-    if (i < 0)
-        return i;
-
-    if (--len > i)
-        len = i;
-
-    if (len)
-        memcpy(dst, buf, len);
-
-    dst[len] = '\0';
-    return len;
-}
-
-/* VARARGS3 */
-int
-_libssh2_os400_snprintf(char *dst, size_t len, const char *fmt, ...)
-{
-    va_list args;
-    int ret;
 
-    va_start(args, fmt);
-    ret = _libssh2_os400_vsnprintf(dst, len, fmt, args);
-    va_end(args);
-    return ret;
+    return connect(sd, (struct sockaddr *) &laddr, i);
 }
 
 
@@ -186,11 +136,11 @@ _libssh2_os400_inflateInit_(z_streamp strm,
     char *ebcversion;
     int i;
 
-    if (!version)
+    if(!version)
         return Z_VERSION_ERROR;
     i = strlen(version);
     ebcversion = alloca(i + 1);
-    if (!ebcversion)
+    if(!ebcversion)
         return Z_VERSION_ERROR;
     i = QadrtConvertA2E(ebcversion, version, i, i - 1);
     ebcversion[i] = '\0';
@@ -204,11 +154,11 @@ _libssh2_os400_deflateInit_(z_streamp strm, int level,
     char *ebcversion;
     int i;
 
-    if (!version)
+    if(!version)
         return Z_VERSION_ERROR;
     i = strlen(version);
     ebcversion = alloca(i + 1);
-    if (!ebcversion)
+    if(!ebcversion)
         return Z_VERSION_ERROR;
     i = QadrtConvertA2E(ebcversion, version, i, i - 1);
     ebcversion[i] = '\0';
diff --git a/libssh2/os400/rpg-examples/SFTPXMPLE b/libssh2/os400/rpg-examples/SFTPXMPLE
new file mode 100644
index 00000000..051ddda2
--- /dev/null
+++ b/libssh2/os400/rpg-examples/SFTPXMPLE
@@ -0,0 +1,326 @@
+      * Example: print a remote ascii file using sftp
+      *
+     h DFTACTGRP(*NO) ACTGRP(*NEW)
+     h OPTION(*NOSHOWCPY)
+     h BNDDIR('LIBSSH2')
+     h BNDDIR('QC2LE')
+      *
+      * Copyright (C) The libssh2 project and its contributors.
+      *
+      * Usage:
+      *
+      * CALL SFTPXMPLE ('<host>' '<port>' '<user>' '<password>' '<filepath>')
+      *
+      * SPDX-License-Identifier: BSD-3-Clause
+      *
+     fQPRINT    o    f  120        printer
+      *
+      /include LIBSSH2RPG,SSH2_SFTP
+      /include LIBSSH2RPG,SSH2_CCSID
+      *
+     d                 pi
+     d host                         120
+     d port                           5
+     d user                          20
+     d password                     120
+     d filepath                     120
+      *
+      **************************************************************************
+      *                          External definitions
+      **************************************************************************
+      *
+     d atoi            pr            10i 0 extproc('atoi')
+     d  numstr                         *   value options(*string)
+      *
+     d inet_addr       pr            10u 0 extproc('inet_addr')
+     d  char_addr                      *   value options(*string)
+      *
+     d socket          pr            10i 0 extproc('socket')
+     d  domain                       10i 0 value
+     d  type                         10i 0 value
+     d  protocol                     10i 0 value
+      *
+     d AF_INET         c                   2
+     d SOCK_STREAM     c                   1
+     d IPPROTO_IP      c                   0
+      *
+     d connect         pr            10i 0 extproc('connect')
+     d  sockfd                       10i 0 value
+     d  addr                           *   value
+     d  addrlen                      10u 0 value
+      *
+     d sockaddr_in     ds                  based(######typedef######)
+     d                                     align qualified
+     d  sin_family                    5i 0
+     d  sin_port                      5i 0
+     d  sin_addr                     10u 0
+     d  sin_zero                      8
+      *
+     d shutdown        pr            10i 0 extproc('shutdown')
+     d  socket                       10i 0 value
+     d  how                          10i 0 value
+      *
+     d SHUT_RDWR       c                   2
+      *
+     d qmhsndpm        pr                  extpgm('QMHSNDPM')
+     d  msgid                         7    const
+     d  qmsgfn                       20    const
+     d  data                     999999    const options(*varsize)
+     d  datalength                   10u 0 const
+     d  msgtype                      10    const
+     d  csentry                  999999    const options(*varsize)
+     d  cscounter                    10u 0 const
+     d  msgkey                        4
+     d  errcode                  999999    options(*varsize)
+     d  csentrylen                   10u 0 const options(*nopass)
+     d  csqual                       20    const options(*nopass)
+     d  waittime                     10u 0 const options(*nopass)
+     d  csentrytype                  10    const options(*nopass)
+     d  ccsid                        10u 0 const options(*nopass)
+      *
+      **************************************************************************
+      *                               Constants
+      **************************************************************************
+      *
+     d EBCDIC_CR       c                   X'0D'
+     d EBCDIC_LF       c                   X'25'
+      *
+      **************************************************************************
+      *                            Global storage
+      **************************************************************************
+      *
+     d sc              s               *   inz(*NULL)                           String cache
+     d session         s               *   inz(*NULL)                           Session
+     d sftp_session    s               *   inz(*NULL)                           LIBSSH2_SFTP *
+     d sftp_handle     s               *   inz(*NULL)                           LIBSSH2_SFTP_HANDLE*
+     d sin             ds                  likeds(sockaddr_in)                  Remote IP address
+     d sock            s             10i 0 inz(LIBSSH2_INVALID_SOCKET)          Socket descriptor
+     d rc              s             10i 0                                      Result code
+     d hostlen         s             10u 0                                      Host name length
+      *
+      **************************************************************************
+      *                            Main program
+      **************************************************************************
+
+        // Initialize ssh lbrary
+        rc = libssh2_init(0);
+        if rc <> 0;
+            error('libssh2 initialization failed (' + %trim(%char(rc)) + ')');
+        else;
+            // Build remote address
+            sin.sin_family = AF_INET;
+            hostlen = trimmed_length(host: %len(host): %addr(port));
+            if hostlen <> 0;
+                 sin.sin_addr = inet_addr(%subst(host: 1: hostlen));
+            else;
+                sin.sin_addr = inet_addr('127.0.0.1');
+            endif;
+            sin.sin_port = atoi(port);
+            if sin.sin_port <= 0;
+                sin.sin_port = 22;
+            endif;
+            sin.sin_zero = *ALLX'00';
+
+            main();
+            cleanout();
+        endif;
+
+        *inlr = *on;
+      /space 3
+        begsr *pssr;
+            cleanout();
+        endsr;
+      /eject
+      **************************************************************************
+      * Main procedure
+      **************************************************************************
+      *
+     p main            b
+      *
+     d buf             s           1024                                         Data buffer
+     d nread           s             10i 0                                      Read bytes count
+
+        // Connect to remote server
+        sock = socket(AF_INET: SOCK_STREAM: IPPROTO_IP);
+        if sock = LIBSSH2_INVALID_SOCKET;
+            error('failed to create socket');
+            return;
+        endif;
+        if connect(sock: %addr(sin): %size(sin)) <> 0;
+            error('failed to connect');
+            return;
+        endif;
+
+        // Create a session instance
+        session = libssh2_session_init();
+        if session = *NULL;
+            error('Could not initialize SSH session');
+            return;
+        endif;
+
+        // Since we have set non-blocking, tell libssh2 we are blocking
+        libssh2_session_set_blocking(session: 1);
+
+        // ... start it up. This will trade welcome banners, exchange keys,
+        // and setup crypto, compression, and MAC layers
+        rc = libssh2_session_handshake(session: sock);
+        if rc <> 0;
+            error('Failure establishing SSH session: ' + %trim(%char(rc)));
+            return;
+        endif;
+
+        // Authenticate
+        if libssh2_userauth_password(session:
+          libssh2_from_ccsid(session: sc: 0: user:
+                             trimmed_length(user: %size(user):
+                                            %addr(password)): *omit):
+          libssh2_from_ccsid(session: sc: 0: password:
+                             trimmed_length(password: %size(password):
+                                            %addr(filepath)): *omit)) <> 0;
+            error('Authentication by password failed');
+            return;
+        endif;
+
+        // Request a file via SFTP
+        sftp_session = libssh2_sftp_init(session);
+
+        if sftp_session = *NULL;
+            error('Unable to init SFTP session');
+            return;
+        endif;
+
+        sftp_handle = libssh2_sftp_open(sftp_session:
+          libssh2_from_ccsid(session: sc: 0: filepath:
+                             trimmed_length(filepath: %size(filepath): *null):
+                                            *omit): LIBSSH2_FXF_READ: 0);
+        if sftp_handle = *NULL;
+            error('Unable to open file with SFTP: ' +
+                  %trim(%char(libssh2_sftp_last_error(sftp_session))));
+            return;
+        endif;
+
+        // Download and display the remote file
+        nread = libssh2_sftp_read(sftp_handle: %addr(buf): %size(buf));
+        dow nread > 0;  // loop until we fail
+            print(libssh2_to_ccsid(session: sc: 0: %addr(buf): nread: *omit):
+                  -1);
+            libssh2_release_string_cache(session: sc);
+            nread = libssh2_sftp_read(sftp_handle: %addr(buf): %size(buf));
+        enddo;
+     p main            e
+      /eject
+      **************************************************************************
+      * Release all allocated resources
+      **************************************************************************
+      *
+     p cleanout        b
+      *
+
+        if sftp_handle <> *NULL;
+            libssh2_sftp_close(sftp_handle);
+        endif;
+
+        if sftp_session <> *NULL;
+            libssh2_sftp_shutdown(sftp_session);
+        endif;
+
+        if session <> *NULL;
+            libssh2_session_disconnect(session: libssh2_from_ccsid(session: sc:
+              0: 'Normal shutdown': -1: *omit));
+            libssh2_release_string_cache(session: sc);
+            libssh2_session_free(session);
+        endif;
+
+        if sock <> LIBSSH2_INVALID_SOCKET;
+                shutdown(sock: SHUT_RDWR);
+                LIBSSH2_SOCKET_CLOSE(sock);
+        endif;
+
+        libssh2_exit();
+     p cleanout        e
+      /eject
+      **************************************************************************
+      * Print data line by line
+      **************************************************************************
+      *
+     p print           b
+     d                 pi
+     d  string                         *   value options(*string)
+     d  len                          10i 0 value
+      *
+     d recout          ds                                                       Output line buffer
+     d  lineout                     120    inz(*blanks)
+      *
+     d i               s             10u 0
+     d j               s             10u 0 inz(0)
+
+        if len < 0;
+            len = %len(%str(string));
+        endif;
+
+        for i = 0 to len - 1;
+            if %str(string + i: 1) <> EBCDIC_CR;
+                if %str(string + i: 1) = EBCDIC_LF;
+                    write QPRINT recout;
+                    lineout = *blanks;
+                    j = 0;
+                else;
+                    if j >= %size(lineout);
+                        write QPRINT recout;
+                        lineout = *blanks;
+                        j = 0;
+                    endif;
+                    j = j + 1;
+                    %subst(lineout: j: 1) = %str(string + i: 1);
+                endif;
+            endif;
+        endfor;
+        if j > 0;
+            write QPRINT recout;
+        endif;
+     p print           e
+      /eject
+      **************************************************************************
+      * Error procedure
+      **************************************************************************
+      *
+     p error           b
+     d                 pi
+     d  message                        *   value options(*string)
+      *
+     d errcode         ds                  qualified
+     d  provided                     10u 0 inz(0)
+     d  available                    10u 0
+      *
+     d msgkey          s              4
+
+        // Send error as an exception to the calling level.
+        qmhsndpm('CPF9898': 'QCPFMSG   QSYS':
+                 %str(message): %len(%str(message)): '*ESCAPE':
+                 '*          ': 1: msgkey: errcode);
+     p error           e
+      /eject
+      **************************************************************************
+      * Get the length of right-trimmed string
+      **************************************************************************
+      *
+     p trimmed_length  b
+     d                 pi            10u 0
+     d  string                   999999    options(*varsize)
+     d  length                       10u 0 value
+     d  nextarg                        *   value
+      *
+     d len             s             10u 0
+
+        if nextarg <> *null;
+            len = nextarg - %addr(string);
+            if length > len;
+                length = len;
+            endif;
+        endif;
+        len = %scan(X'00': string: 1: length); // Maybe zero-terminated
+        if len = 0;
+            len = length + 1;
+        endif;
+        return %checkr(' ': string: len - 1);  // Trim right
+     p trimmed_length  e
diff --git a/libssh2/src/CMakeLists.txt b/libssh2/src/CMakeLists.txt
index eee1a80d..512c64ed 100644
--- a/libssh2/src/CMakeLists.txt
+++ b/libssh2/src/CMakeLists.txt
@@ -1,4 +1,5 @@
-# Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Viktor Szakats
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,402 +33,309 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(_libssh2_soversion 1)
+set(_libssh2_libversion 1.0.1)
 
-include(CheckFunctionExists)
-include(CheckSymbolExists)
-include(CheckFunctionExistsMayNeedLibrary)
-include(CheckIncludeFiles)
-include(CheckTypeSize)
-include(CheckSymbolExists)
-include(CheckNonblockingSocketSupport)
-include(SocketLibraries)
-
-## Cryptography backend choice
-
-set(CRYPTO_BACKEND
-  ""
-  CACHE
-  STRING
-  "The backend to use for cryptography: OpenSSL, Libgcrypt or WinCNG, mbedTLS
-or empty to try any available")
-
-# If the crypto backend was given, rather than searching for the first
-# we are able to find, the find_package commands must abort configuration
-# and report to the user.
 if(CRYPTO_BACKEND)
-  set(SPECIFIC_CRYPTO_REQUIREMENT REQUIRED)
+  list(APPEND PRIVATE_COMPILE_DEFINITIONS ${CRYPTO_BACKEND_DEFINE})
+  list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${CRYPTO_BACKEND_INCLUDE_DIR})
+  add_feature_info("Crypto backend" ON "${CRYPTO_BACKEND}")
+else()
+  message(FATAL_ERROR "No suitable cryptography backend found.")
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "OpenSSL" OR NOT CRYPTO_BACKEND)
-
-  find_package(OpenSSL ${SPECIFIC_CRYPTO_REQUIREMENT})
-
-  if(OPENSSL_FOUND)
-    set(CRYPTO_BACKEND "OpenSSL")
-    set(CRYPTO_SOURCES openssl.c openssl.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_OPENSSL)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${OPENSSL_INCLUDE_DIR})
-    list(APPEND LIBRARIES ${OPENSSL_LIBRARIES})
-    list(APPEND PC_REQUIRES_PRIVATE libssl libcrypto)
-
-    if (WIN32)
-      # Statically linking to OpenSSL requires crypt32 for some Windows APIs.
-      # This should really be handled by FindOpenSSL.cmake.
-      list(APPEND LIBRARIES crypt32)
-      list(APPEND PC_LIBS -lcrypt32)
-
-      find_file(DLL_LIBEAY32
-        NAMES libeay32.dll crypto.dll libcrypto-1_1.dll libcrypto-1_1-x64.dll
-        HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS}
-        PATH_SUFFIXES bin)
-      if (NOT DLL_LIBEAY32)
-        message(WARNING
-          "Unable to find OpenSSL crypto (aka libeay32) DLL, executables may not run")
-      endif()
-
-      find_file(DLL_SSLEAY32
-        NAMES ssleay32.dll ssl.dll libssl-1_1.dll libssl-1_1-x64.dll
-        HINTS ${_OPENSSL_ROOT_HINTS} PATHS ${_OPENSSL_ROOT_PATHS}
-        PATH_SUFFIXES bin)
-      if (NOT DLL_SSLEAY32)
-        message(WARNING
-          "Unable to find OpenSSL ssl (aka ssleay32) DLL, executables may not run")
-      endif()
+## Options
 
-      if(DLL_LIBEAY32 AND DLL_SSLEAY32)
-        list(APPEND _RUNTIME_DEPENDENCIES ${DLL_LIBEAY32} ${DLL_SSLEAY32})
-      endif()
-    endif()
+unset(_libssh2_definitions)
 
-    # Not all OpenSSL have AES-CTR functions.
-    set(SAVE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-    set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
-    check_function_exists(EVP_aes_128_ctr HAVE_EVP_AES_128_CTR)
-    set(CMAKE_REQUIRED_LIBRARIES ${SAVE_CMAKE_REQUIRED_LIBRARIES})
-  endif()
+option(CLEAR_MEMORY "Enable clearing of memory before being freed" ON)
+if(NOT CLEAR_MEMORY)
+  list(APPEND _libssh2_definitions "LIBSSH2_NO_CLEAR_MEMORY")
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "Libgcrypt" OR NOT CRYPTO_BACKEND)
-
-  find_package(Libgcrypt ${SPECIFIC_CRYPTO_REQUIREMENT})
+option(ENABLE_ZLIB_COMPRESSION "Use zlib for compression" OFF)
+add_feature_info(Compression ENABLE_ZLIB_COMPRESSION
+  "using zlib for compression")
+if(ENABLE_ZLIB_COMPRESSION)
+  find_package(ZLIB REQUIRED)
 
-  if(LIBGCRYPT_FOUND)
-    set(CRYPTO_BACKEND "Libgcrypt")
-    set(CRYPTO_SOURCES libgcrypt.c libgcrypt.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_LIBGCRYPT)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${LIBGCRYPT_INCLUDE_DIRS})
-    list(APPEND LIBRARIES ${LIBGCRYPT_LIBRARIES})
-    list(APPEND PC_LIBS -lgcrypt)
+  list(APPEND libssh2_INCLUDE_DIRS ${ZLIB_INCLUDE_DIRS})
+  list(APPEND LIBSSH2_LIBS ${ZLIB_LIBRARIES})
+  list(APPEND LIBSSH2_PC_REQUIRES_PRIVATE "zlib")
+  if(ZLIB_FOUND)
+    list(APPEND _libssh2_definitions "LIBSSH2_HAVE_ZLIB")
   endif()
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "WinCNG" OR NOT CRYPTO_BACKEND)
+list(APPEND LIBSSH2_LIBS ${LIBSSH2_LIBS_SOCKET})
 
-  # The check actually compiles the header.  This requires windows.h.
-  check_include_files("windows.h;bcrypt.h" HAVE_BCRYPT_H)
-
-  if(HAVE_BCRYPT_H)
-    set(CRYPTO_BACKEND "WinCNG")
-    set(CRYPTO_SOURCES wincng.c wincng.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_WINCNG)
+# to find generated header
+list(APPEND libssh2_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
-    set(HAVE_LIBCRYPT32 TRUE)
-    list(APPEND LIBRARIES bcrypt)
-    list(APPEND PC_LIBS -lbcrypt)
+if(MSVC)
+  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Zi /Od")
+  set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /DEBUG")
+endif()
 
-    check_include_files(ntdef.h HAVE_NTDEF_H)
-    check_include_files(ntstatus.h HAVE_NTSTATUS_H)
+## Sources
 
-    # Reading keys from files is optional and depends on Wincrypt
-    check_include_files("windows.h;wincrypt.h" HAVE_WINCRYPT_H)
+include(GNUInstallDirs)
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+# Get 'CSOURCES' and 'HHEADERS' variables
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+set(_sources ${CSOURCES} ${HHEADERS})
 
-    if(HAVE_WINCRYPT_H)
-      list(APPEND LIBRARIES crypt32)
-      list(APPEND PC_LIBS -lcrypt32)
-    endif()
+## Library definition
 
-  elseif(${SPECIFIC_CRYPTO_REQUIREMENT} STREQUAL ${REQUIRED})
-    message(FATAL_ERROR "WinCNG not available")
-  endif()
+# Ensure that the static library and import library filenames are different,
+# when building both static and shared library. On Windows, with certain
+# toolchains (e.g. MSVC) these libraries get the same by default, overwriting
+# each other. MinGW is not affected.
+if(WIN32 AND BUILD_STATIC_LIBS AND BUILD_SHARED_LIBS AND
+   NOT STATIC_LIB_SUFFIX AND NOT IMPORT_LIB_SUFFIX AND
+   CMAKE_STATIC_LIBRARY_SUFFIX STREQUAL CMAKE_IMPORT_LIBRARY_SUFFIX)
+  set(STATIC_LIB_SUFFIX "_static")
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "mbedTLS" OR NOT CRYPTO_BACKEND)
-
-  find_package(mbedTLS ${SPECIFIC_CRYPTO_REQUIREMENT})
+unset(_libssh2_export)
 
-  if(MBEDTLS_FOUND)
-    set(CRYPTO_BACKEND "mbedTLS")
-    set(CRYPTO_SOURCES mbedtls.c mbedtls.h)
-    list(APPEND PRIVATE_COMPILE_DEFINITIONS LIBSSH2_MBEDTLS)
-    list(APPEND PRIVATE_INCLUDE_DIRECTORIES ${MBEDTLS_INCLUDE_DIR})
-    list(APPEND LIBRARIES ${MBEDTLS_LIBRARIES})
-    list(APPEND PC_LIBS -lmbedcrypto)
-    link_directories(${MBEDTLS_LIBRARY_DIR})
+# we want it to be called libssh2 on all platforms
+if(BUILD_STATIC_LIBS)
+  list(APPEND _libssh2_export ${LIB_STATIC})
+  add_library(${LIB_STATIC} STATIC ${_sources})
+  add_library(${PROJECT_NAME}::${LIB_STATIC} ALIAS ${LIB_STATIC})
+  target_compile_definitions(${LIB_STATIC} PRIVATE ${PRIVATE_COMPILE_DEFINITIONS} ${_libssh2_definitions})
+  target_link_libraries(${LIB_STATIC} PRIVATE ${LIBSSH2_LIBS})
+  set_target_properties(${LIB_STATIC} PROPERTIES
+    PREFIX "" OUTPUT_NAME "libssh2" SOVERSION "${_libssh2_soversion}" VERSION "${_libssh2_libversion}"
+    SUFFIX "${STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+  target_include_directories(${LIB_STATIC}
+    PRIVATE
+      "${PROJECT_SOURCE_DIR}/include"
+      ${libssh2_INCLUDE_DIRS}
+      ${PRIVATE_INCLUDE_DIRECTORIES}
+    PUBLIC
+      "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
+      "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+endif()
+if(BUILD_SHARED_LIBS)
+  list(APPEND _libssh2_export ${LIB_SHARED})
+  add_library(${LIB_SHARED} SHARED ${_sources})
+  add_library(${PROJECT_NAME}::${LIB_SHARED} ALIAS ${LIB_SHARED})
+  if(WIN32)
+    set_property(TARGET ${LIB_SHARED} APPEND PROPERTY SOURCES "libssh2.rc")
   endif()
+  target_compile_definitions(${LIB_SHARED} PRIVATE ${PRIVATE_COMPILE_DEFINITIONS} ${_libssh2_definitions} ${LIB_SHARED_DEFINITIONS})
+  target_compile_options(${LIB_SHARED} PRIVATE ${LIB_SHARED_C_FLAGS})
+  target_link_libraries(${LIB_SHARED} PRIVATE ${LIBSSH2_LIBS})
+  set_target_properties(${LIB_SHARED} PROPERTIES
+    PREFIX "" OUTPUT_NAME "libssh2" SOVERSION "${_libssh2_soversion}" VERSION "${_libssh2_libversion}"
+    IMPORT_PREFIX "" IMPORT_SUFFIX "${IMPORT_LIB_SUFFIX}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+    POSITION_INDEPENDENT_CODE ON)
+
+  target_include_directories(${LIB_SHARED}
+    PRIVATE
+      "${PROJECT_SOURCE_DIR}/include"
+      ${libssh2_INCLUDE_DIRS}
+      ${PRIVATE_INCLUDE_DIRECTORIES}
+    PUBLIC
+      "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
+      "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
 endif()
 
-if(NOT CRYPTO_BACKEND)
-  message(FATAL_ERROR "No suitable cryptography backend found.")
-endif()
+add_library(${PROJECT_NAME}::${LIB_NAME} ALIAS ${LIB_SELECTED})
+add_library(${LIB_NAME} ALIAS ${LIB_SELECTED})
 
-## Library definition
+## Installation
 
-include(GNUInstallDirs)
-set(SOURCES
-  ${CRYPTO_SOURCES}
-  agent.c
-  agent_win.c
-  blf.h
-  bcrypt_pbkdf.c
-  blowfish.c
-  channel.c
-  channel.h
-  comp.c
-  comp.h
-  crypt.c
-  crypto.h
-  global.c
-  hostkey.c
-  keepalive.c
-  kex.c
-  knownhost.c
-  libssh2_priv.h
-  mac.c
-  mac.h
-  misc.c
-  misc.h
-  packet.c
-  packet.h
-  pem.c
-  publickey.c
-  scp.c
-  session.c
-  session.h
-  sftp.c
-  sftp.h
-  transport.c
-  transport.h
-  userauth.c
-  userauth.h
-  version.c)
+install(FILES
+  "${PROJECT_SOURCE_DIR}/include/libssh2.h"
+  "${PROJECT_SOURCE_DIR}/include/libssh2_publickey.h"
+  "${PROJECT_SOURCE_DIR}/include/libssh2_sftp.h"
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-if(WIN32)
-  list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/win32/libssh2.rc)
+if(BUILD_STATIC_LIBS)
+  install(TARGETS ${LIB_STATIC}
+    EXPORT "${PROJECT_NAME}-targets"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 endif()
+if(BUILD_SHARED_LIBS)
+  install(TARGETS ${LIB_SHARED}
+    EXPORT "${PROJECT_NAME}-targets"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
-add_library(libssh2 ${SOURCES})
-# we want it to be called libssh2 on all platforms
-set_target_properties(libssh2 PROPERTIES PREFIX "")
+  list(APPEND _RUNTIME_DEPENDENCIES $<TARGET_FILE:${LIB_SHARED}>)
+endif()
 
-target_compile_definitions(libssh2 PRIVATE ${PRIVATE_COMPILE_DEFINITIONS})
-target_include_directories(libssh2
-  PRIVATE "${PROJECT_SOURCE_DIR}/include/" ${PRIVATE_INCLUDE_DIRECTORIES}
-  PUBLIC
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-    $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>)
+set(RUNTIME_DEPENDENCIES ${_RUNTIME_DEPENDENCIES} CACHE INTERNAL
+  "Files that must be in the same directory as the executables at runtime.")
 
-## Options
+# Package config
 
-option(CLEAR_MEMORY "Enable clearing of memory before being freed" ON)
-if(CLEAR_MEMORY)
-    add_definitions(-DLIBSSH2_CLEAR_MEMORY)
-endif(CLEAR_MEMORY)
+## During package installation, install libssh2-targets.cmake
+install(EXPORT "${PROJECT_NAME}-targets"
+  NAMESPACE "${PROJECT_NAME}::"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
 
-add_feature_info("Shared library" BUILD_SHARED_LIBS
-  "creating libssh2 as a shared library (.so/.dll)")
+## During build, register directly from build tree
+# create libssh2-targets.cmake
+export(TARGETS ${_libssh2_export} NAMESPACE "${PROJECT_NAME}::" FILE "${PROJECT_NAME}-targets.cmake")
+export(PACKAGE ${PROJECT_NAME})  # register it
 
-option(ENABLE_ZLIB_COMPRESSION "Use zlib for compression")
-add_feature_info(Compression ENABLE_ZLIB_COMPRESSION
-  "using zlib for compression")
-if(ENABLE_ZLIB_COMPRESSION)
-  find_package(ZLIB REQUIRED)
+# Generate libssh2-config.cmake into build tree and install it with dependencies
+configure_file("${PROJECT_SOURCE_DIR}/cmake/libssh2-config.cmake.in" "${PROJECT_NAME}-config.cmake" @ONLY)
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
+    "${PROJECT_SOURCE_DIR}/cmake/FindLibgcrypt.cmake"
+    "${PROJECT_SOURCE_DIR}/cmake/FindMbedTLS.cmake"
+    "${PROJECT_SOURCE_DIR}/cmake/FindWolfSSL.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
 
-  target_include_directories(libssh2 PRIVATE ${ZLIB_INCLUDE_DIRS})
-  list(APPEND LIBRARIES ${ZLIB_LIBRARIES})
-  list(APPEND PC_REQUIRES_PRIVATE zlib)
-  if(ZLIB_FOUND)
-    target_compile_definitions(libssh2 PRIVATE LIBSSH2_HAVE_ZLIB=1)
-  endif()
-endif()
+# Calculate variables for pkg-config
+set(LIBSSH2_PC_LIBS_PRIVATE "")
 
-option(ENABLE_CRYPT_NONE "Permit \"none\" cipher -- NOT RECOMMENDED")
-add_feature_info("\"none\" cipher" ENABLE_CRYPT_NONE "")
-if(ENABLE_CRYPT_NONE)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_CRYPT_NONE=1)
+if(WIN32)
+  list(APPEND LIBSSH2_PC_LIBS_PRIVATE "-lws2_32")
 endif()
 
-option(ENABLE_MAC_NONE "Permit \"none\" MAC -- NOT RECOMMMENDED")
-add_feature_info("\"none\" MAC" ENABLE_MAC_NONE "")
-if(ENABLE_MAC_NONE)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_MAC_NONE=1)
-endif()
+set(_ldflags "")
 
-option(ENABLE_GEX_NEW
-  "Enable diffie-hellman-group-exchange-sha1 method" ON)
-add_feature_info("diffie-hellman-group-exchange-sha1" ENABLE_GEX_NEW
-  "\"new\" diffie-hellman-group-exchange-sha1 method")
-if(ENABLE_GEX_NEW)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_DH_GEX_NEW=1)
-endif()
+# Avoid getting unnecessary -L options for known system directories.
+unset(_sys_libdirs)
+foreach(_libdir IN LISTS CMAKE_SYSTEM_PREFIX_PATH)
+  if(_libdir MATCHES "/$")
+    set(_libdir "${_libdir}lib")
+  else()
+    set(_libdir "${_libdir}/lib")
+  endif()
+  if(IS_DIRECTORY "${_libdir}")
+    list(APPEND _sys_libdirs "${_libdir}")
+  endif()
+  if(DEFINED CMAKE_LIBRARY_ARCHITECTURE)
+    set(_libdir "${_libdir}/${CMAKE_LIBRARY_ARCHITECTURE}")
+    if(IS_DIRECTORY "${_libdir}")
+      list(APPEND _sys_libdirs "${_libdir}")
+    endif()
+  endif()
+endforeach()
 
-# Enable debugging logging by default if the user configured a debug build
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-  set(DEBUG_LOGGING_DEFAULT ON)
-else()
-  set(DEBUG_LOGGING_DEFAULT OFF)
-endif()
-option(ENABLE_DEBUG_LOGGING "log execution with debug trace"
-  ${DEBUG_LOGGING_DEFAULT})
-add_feature_info(Logging ENABLE_DEBUG_LOGGING
-   "Logging of execution with debug trace")
-if(ENABLE_DEBUG_LOGGING)
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2DEBUG)
-endif()
+foreach(_libdir IN LISTS LIBSSH2_LIBDIRS)
+  list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+  if(_libdir_index LESS 0)
+    list(APPEND _ldflags "-L${_libdir}")
+  endif()
+endforeach()
 
-## Platform checks
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(stdlib.h HAVE_STDLIB_H)
-check_include_files(sys/select.h HAVE_SYS_SELECT_H)
-
-check_include_files(sys/uio.h HAVE_SYS_UIO_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(sys/ioctl.h HAVE_SYS_IOCTL_H)
-check_include_files(sys/time.h HAVE_SYS_TIME_H)
-check_include_files(sys/un.h HAVE_SYS_UN_H)
-check_include_files(windows.h HAVE_WINDOWS_H)
-check_include_files(ws2tcpip.h HAVE_WS2TCPIP_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-
-check_type_size("long long" LONGLONG)
-
-if(HAVE_SYS_TIME_H)
-  check_symbol_exists(gettimeofday sys/time.h HAVE_GETTIMEOFDAY)
-else()
-  check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-endif()
-if(HAVE_STDLIB_H)
-  check_symbol_exists(strtoll stdlib.h HAVE_STRTOLL)
-else()
-  check_function_exists(strtoll HAVE_STRTOLL)
-endif()
-if (NOT HAVE_STRTOLL)
-  # Try _strtoi64 if strtoll isn't available
-  check_symbol_exists(_strtoi64 stdlib.h HAVE_STRTOI64)
+unset(_implicit_libs)
+if(NOT MINGW AND NOT UNIX)
+  set(_implicit_libs ${CMAKE_C_IMPLICIT_LINK_LIBRARIES})
 endif()
-check_symbol_exists(snprintf stdio.h HAVE_SNPRINTF)
-check_symbol_exists(memset_s string.h HAVE_MEMSET_S)
-
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" OR
-   ${CMAKE_SYSTEM_NAME} STREQUAL "Interix")
-  # poll() does not work on these platforms
-  #
-  # Interix: "does provide poll(), but the implementing developer must
-  # have been in a bad mood, because poll() only works on the /proc
-  # filesystem here"
-  #
-  # Mac OS X's poll has funny behaviors, like:
-  # not being able to do poll on no filedescriptors (10.3?)
-  # not being able to poll on some files (like anything in /dev)
-  # not having reliable timeout support
-  # inconsistent return of POLLHUP where other implementations give POLLIN
-  message("poll use is disabled on this platform")
-else()
-  check_function_exists(poll HAVE_POLL)
-endif()
-
-append_needed_socket_libraries(LIBRARIES)
 
-# Non-blocking socket support tests.  Must be after library tests to
-# link correctly
-set(SAVE_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-set(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})
-check_nonblocking_socket_support()
-set(CMAKE_REQUIRED_LIBRARIES ${SAVE_CMAKE_REQUIRED_LIBRARIES})
+foreach(_lib IN LISTS _implicit_libs LIBSSH2_LIBS)
+  if(TARGET "${_lib}")
+    set(_libname "${_lib}")
+    get_target_property(_imported "${_libname}" IMPORTED)
+    if(NOT _imported)
+      # Reading the LOCATION property on non-imported target will error out.
+      # Assume the user will not need this information in the .pc file.
+      continue()
+    endif()
+    get_target_property(_lib "${_libname}" LOCATION)
+    if(NOT _lib)
+      message(WARNING "Bad lib in library list: ${_libname}")
+      continue()
+    endif()
+  endif()
+  if(_lib MATCHES "^-")
+    list(APPEND _ldflags "${_lib}")
+  elseif(_lib MATCHES ".*/.*")
+    # This gets a bit more complex, because we want to specify the
+    # directory separately, and only once per directory
+    get_filename_component(_libdir ${_lib} DIRECTORY)
+    get_filename_component(_libname ${_lib} NAME_WE)
+    if(_libname MATCHES "^lib")
+      list(FIND _sys_libdirs "${_libdir}" _libdir_index)
+      if(_libdir_index LESS 0)
+        list(APPEND _ldflags "-L${_libdir}")
+      endif()
+      string(REGEX REPLACE "^lib" "" _libname "${_libname}")
+      list(APPEND LIBSSH2_PC_LIBS_PRIVATE "-l${_libname}")
+    else()
+      list(APPEND LIBSSH2_PC_LIBS_PRIVATE "${_lib}")
+    endif()
+  else()
+    list(APPEND LIBSSH2_PC_LIBS_PRIVATE "-l${_lib}")
+  endif()
+endforeach()
 
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h)
-# to find generated header
-target_include_directories(libssh2 PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
-
-# Check for the OS.
-# Daniel's note: this should not be necessary and we need to work to
-# get this removed.
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_WIN32)
-elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-  target_compile_definitions(libssh2 PRIVATE LIBSSH2_DARWIN)
+if(LIBSSH2_PC_REQUIRES_PRIVATE)
+  string(REPLACE ";" "," LIBSSH2_PC_REQUIRES_PRIVATE "${LIBSSH2_PC_REQUIRES_PRIVATE}")
 endif()
-
-if(MSVC)
-  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Zi /Od")
-  set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /DEBUG")
+if(LIBSSH2_PC_LIBS_PRIVATE)
+  list(REMOVE_DUPLICATES LIBSSH2_PC_LIBS_PRIVATE)
+  string(REPLACE ";" " " LIBSSH2_PC_LIBS_PRIVATE "${LIBSSH2_PC_LIBS_PRIVATE}")
 endif()
-
-if(CMAKE_VERSION VERSION_LESS "2.8.12")
-  # Fall back to over-linking dependencies
-  target_link_libraries(libssh2 ${LIBRARIES})
-else()
-  target_link_libraries(libssh2 PRIVATE ${LIBRARIES})
+if(_ldflags)
+  list(REMOVE_DUPLICATES _ldflags)
+  string(REPLACE ";" " " _ldflags "${_ldflags}")
+  set(LIBSSH2_PC_LIBS_PRIVATE "${_ldflags} ${LIBSSH2_PC_LIBS_PRIVATE}")
+  string(STRIP "${LIBSSH2_PC_LIBS_PRIVATE}" LIBSSH2_PC_LIBS_PRIVATE)
 endif()
 
-## Installation
-
-install(FILES
-  ${PROJECT_SOURCE_DIR}/include/libssh2.h
-  ${PROJECT_SOURCE_DIR}/include/libssh2_publickey.h
-  ${PROJECT_SOURCE_DIR}/include/libssh2_sftp.h
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-install(TARGETS libssh2
-  EXPORT Libssh2Config
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
+# Merge pkg-config private fields into public ones when static-only
 if(BUILD_SHARED_LIBS)
-  list(APPEND _RUNTIME_DEPENDENCIES $<TARGET_FILE:libssh2>)
+  set(LIBSSH2_PC_REQUIRES "")
+  set(LIBSSH2_PC_LIBS "")
+else()
+  set(LIBSSH2_PC_REQUIRES "${LIBSSH2_PC_REQUIRES_PRIVATE}")
+  set(LIBSSH2_PC_LIBS "${LIBSSH2_PC_LIBS_PRIVATE}")
 endif()
 
-set(RUNTIME_DEPENDENCIES ${_RUNTIME_DEPENDENCIES} CACHE INTERNAL
-    "Files that must be in the same directory as the executables at runtime.")
-
-# Package config
-
-## During package installation, install Libssh2Config.cmake
-install(EXPORT Libssh2Config
-  NAMESPACE Libssh2::
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libssh2)
-
-## During build, register directly from build tree
-# create Libssh2Config.cmake
-export(TARGETS libssh2 NAMESPACE Libssh2:: FILE Libssh2Config.cmake)
-export(PACKAGE Libssh2) # register it
-
-## Export a .pc file for client projects not using CMaek
-if(PC_REQUIRES_PRIVATE)
-  string(REPLACE ";" "," PC_REQUIRES_PRIVATE "${PC_REQUIRES_PRIVATE}")
+set(prefix       "${CMAKE_INSTALL_PREFIX}")
+set(exec_prefix  "\${prefix}")
+if(IS_ABSOLUTE ${CMAKE_INSTALL_INCLUDEDIR})
+  set(includedir "${CMAKE_INSTALL_INCLUDEDIR}")
+else()
+  set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
 endif()
-if(PC_LIBS)
-  string(REPLACE ";" " " PC_LIBS "${PC_LIBS}")
+if(IS_ABSOLUTE ${CMAKE_INSTALL_LIBDIR})
+  set(libdir     "${CMAKE_INSTALL_LIBDIR}")
+else()
+  set(libdir     "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
 endif()
-configure_file(libssh2.pc.in libssh2.pc @ONLY)
-install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/libssh2.pc
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 
-## Versioning
+# Generate a pkg-config file for client projects not using CMake.
+# Consumed variables:
+#   exec_prefix
+#   includedir
+#   LIBSSH2_PC_LIBS
+#   LIBSSH2_PC_LIBS_PRIVATE
+#   LIBSSH2_PC_REQUIRES
+#   LIBSSH2_PC_REQUIRES_PRIVATE
+#   LIBSSH2_VERSION
+#   libdir
+#   prefix
+configure_file("${PROJECT_SOURCE_DIR}/libssh2.pc.in" "libssh2.pc" @ONLY)
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/libssh2.pc"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
 
-set_target_properties(libssh2 PROPERTIES
-  SOVERSION 1
-  VERSION 1.0.1)
+#
 
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file(
-  ${CMAKE_CURRENT_BINARY_DIR}/Libssh2ConfigVersion.cmake
+  "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
   VERSION "${LIBSSH2_VERSION_MAJOR}.${LIBSSH2_VERSION_MINOR}.${LIBSSH2_VERSION_PATCH}"
   COMPATIBILITY SameMajorVersion)
 install(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/Libssh2ConfigVersion.cmake
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libssh2)
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
diff --git a/libssh2/src/Libssh2ConfigVersion.cmake b/libssh2/src/Libssh2ConfigVersion.cmake
deleted file mode 100644
index f50fe1bf..00000000
--- a/libssh2/src/Libssh2ConfigVersion.cmake
+++ /dev/null
@@ -1,70 +0,0 @@
-# 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 "1.10.0")
-
-if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
-  set(PACKAGE_VERSION_COMPATIBLE FALSE)
-else()
-
-  if("1.10.0" 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 "1.10.0")
-  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 project requested no architecture check, don't perform the check
-if("FALSE")
-  return()
-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/libssh2/src/Makefile.am b/libssh2/src/Makefile.am
index 31d58ed5..9f148823 100644
--- a/libssh2/src/Makefile.am
+++ b/libssh2/src/Makefile.am
@@ -1,34 +1,26 @@
-# $Id: Makefile.am,v 1.21 2009/05/07 17:21:56 bagder Exp $
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
 
-# Get the CRYPTO_CSOURCES, CRYPTO_HHEADERS and CRYPTO_LTLIBS defines
-if OPENSSL
-include ../Makefile.OpenSSL.inc
-endif
-if LIBGCRYPT
-include ../Makefile.libgcrypt.inc
-endif
-if WINCNG
-include ../Makefile.WinCNG.inc
-endif
-if MBEDTLS
-include ../Makefile.mbedTLS.inc
-endif
-
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-include ../Makefile.inc
+# Get the CSOURCES, HHEADERS and EXTRA_DIST defines
+include Makefile.inc
 
 libssh2_la_SOURCES = $(CSOURCES) $(HHEADERS)
+if HAVE_WINDRES
+libssh2_la_SOURCES += libssh2.rc
+endif
 
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in libssh2.pc.in
-EXTRA_DIST += CMakeLists.txt NMakefile
+EXTRA_DIST += libssh2_config.h.in libssh2_config_cmake.h.in CMakeLists.txt
 
 lib_LTLIBRARIES = libssh2.la
 
 # srcdir/include for the shipped headers
 # builddir/src for the generated config header when building out of the source
 # tree
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/src
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/include
+
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
 
 VERSION=-version-info 1:1:0
 
@@ -61,5 +53,9 @@ VERSION=-version-info 1:1:0
 #
 
 libssh2_la_LDFLAGS = $(VERSION) -no-undefined \
-	-export-symbols-regex '^libssh2_.*' \
-	$(CRYPTO_LTLIBS) $(LTLIBZ)
+  -export-symbols-regex '^libssh2_.*'
+
+if HAVE_WINDRES
+.rc.lo:
+	$(LIBTOOL) --tag=RC --mode=compile $(RC) -I$(top_srcdir)/include $(RCFLAGS) -i $< -o $@
+endif
diff --git a/libssh2/libssh2/src/Makefile.in b/libssh2/src/Makefile.in
similarity index 82%
rename from libssh2/libssh2/src/Makefile.in
rename to libssh2/src/Makefile.in
index d76490ab..cdc88275 100644
--- a/libssh2/libssh2/src/Makefile.in
+++ b/libssh2/src/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -88,14 +88,15 @@ PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
+@HAVE_WINDRES_TRUE@am__append_1 = libssh2.rc
 subdir = src
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
@@ -133,27 +134,25 @@ am__uninstall_files_from_dir = { \
 am__installdirs = "$(DESTDIR)$(libdir)"
 LTLIBRARIES = $(lib_LTLIBRARIES)
 libssh2_la_LIBADD =
-am__libssh2_la_SOURCES_DIST = channel.c comp.c crypt.c hostkey.c kex.c \
-	mac.c misc.c packet.c publickey.c scp.c session.c sftp.c \
-	userauth.c transport.c version.c knownhost.c agent.c \
-	libgcrypt.c mbedtls.c openssl.c wincng.c pem.c keepalive.c \
-	global.c blowfish.c bcrypt_pbkdf.c agent_win.c libssh2_priv.h \
-	libgcrypt.h mbedtls.h openssl.h wincng.h transport.h channel.h \
-	comp.h mac.h misc.h packet.h userauth.h session.h sftp.h \
-	crypto.h blf.h agent.h
-@LIBGCRYPT_FALSE@@MBEDTLS_FALSE@@OPENSSL_FALSE@@WINCNG_TRUE@am__objects_1 = wincng.lo
-@LIBGCRYPT_FALSE@@MBEDTLS_FALSE@@OPENSSL_TRUE@am__objects_1 =  \
-@LIBGCRYPT_FALSE@@MBEDTLS_FALSE@@OPENSSL_TRUE@	openssl.lo
-@LIBGCRYPT_FALSE@@MBEDTLS_TRUE@am__objects_1 = mbedtls.lo
-@LIBGCRYPT_TRUE@am__objects_1 = libgcrypt.lo
-am__objects_2 = channel.lo comp.lo crypt.lo hostkey.lo kex.lo mac.lo \
-	misc.lo packet.lo publickey.lo scp.lo session.lo sftp.lo \
-	userauth.lo transport.lo version.lo knownhost.lo agent.lo \
-	$(am__objects_1) pem.lo keepalive.lo global.lo blowfish.lo \
-	bcrypt_pbkdf.lo agent_win.lo
-am__objects_3 =
-am__objects_4 = $(am__objects_3)
-am_libssh2_la_OBJECTS = $(am__objects_2) $(am__objects_4)
+am__libssh2_la_SOURCES_DIST = agent.c bcrypt_pbkdf.c channel.c comp.c \
+	chacha.c cipher-chachapoly.c crypt.c crypto.c global.c \
+	hostkey.c keepalive.c kex.c knownhost.c mac.c misc.c packet.c \
+	pem.c poly1305.c publickey.c scp.c session.c sftp.c \
+	transport.c userauth.c userauth_kbd_packet.c version.c \
+	chacha.h channel.h cipher-chachapoly.h comp.h crypto.h \
+	crypto_config.h libgcrypt.h libssh2_priv.h libssh2_setup.h \
+	mac.h mbedtls.h misc.h openssl.h os400qc3.h packet.h \
+	poly1305.h session.h sftp.h transport.h userauth.h \
+	userauth_kbd_packet.h wincng.h libssh2.rc
+am__objects_1 = agent.lo bcrypt_pbkdf.lo channel.lo comp.lo chacha.lo \
+	cipher-chachapoly.lo crypt.lo crypto.lo global.lo hostkey.lo \
+	keepalive.lo kex.lo knownhost.lo mac.lo misc.lo packet.lo \
+	pem.lo poly1305.lo publickey.lo scp.lo session.lo sftp.lo \
+	transport.lo userauth.lo userauth_kbd_packet.lo version.lo
+am__objects_2 =
+@HAVE_WINDRES_TRUE@am__objects_3 = libssh2.lo
+am_libssh2_la_OBJECTS = $(am__objects_1) $(am__objects_2) \
+	$(am__objects_3)
 libssh2_la_OBJECTS = $(am_libssh2_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -177,20 +176,20 @@ am__v_at_1 =
 DEFAULT_INCLUDES = 
 depcomp = $(SHELL) $(top_srcdir)/depcomp
 am__maybe_remake_depfiles = depfiles
-am__depfiles_remade = ./$(DEPDIR)/agent.Plo ./$(DEPDIR)/agent_win.Plo \
-	./$(DEPDIR)/bcrypt_pbkdf.Plo ./$(DEPDIR)/blowfish.Plo \
-	./$(DEPDIR)/channel.Plo ./$(DEPDIR)/comp.Plo \
-	./$(DEPDIR)/crypt.Plo ./$(DEPDIR)/global.Plo \
+am__depfiles_remade = ./$(DEPDIR)/agent.Plo \
+	./$(DEPDIR)/bcrypt_pbkdf.Plo ./$(DEPDIR)/chacha.Plo \
+	./$(DEPDIR)/channel.Plo ./$(DEPDIR)/cipher-chachapoly.Plo \
+	./$(DEPDIR)/comp.Plo ./$(DEPDIR)/crypt.Plo \
+	./$(DEPDIR)/crypto.Plo ./$(DEPDIR)/global.Plo \
 	./$(DEPDIR)/hostkey.Plo ./$(DEPDIR)/keepalive.Plo \
 	./$(DEPDIR)/kex.Plo ./$(DEPDIR)/knownhost.Plo \
-	./$(DEPDIR)/libgcrypt.Plo ./$(DEPDIR)/mac.Plo \
-	./$(DEPDIR)/mbedtls.Plo ./$(DEPDIR)/misc.Plo \
-	./$(DEPDIR)/openssl.Plo ./$(DEPDIR)/packet.Plo \
-	./$(DEPDIR)/pem.Plo ./$(DEPDIR)/publickey.Plo \
+	./$(DEPDIR)/mac.Plo ./$(DEPDIR)/misc.Plo \
+	./$(DEPDIR)/packet.Plo ./$(DEPDIR)/pem.Plo \
+	./$(DEPDIR)/poly1305.Plo ./$(DEPDIR)/publickey.Plo \
 	./$(DEPDIR)/scp.Plo ./$(DEPDIR)/session.Plo \
 	./$(DEPDIR)/sftp.Plo ./$(DEPDIR)/transport.Plo \
-	./$(DEPDIR)/userauth.Plo ./$(DEPDIR)/version.Plo \
-	./$(DEPDIR)/wincng.Plo
+	./$(DEPDIR)/userauth.Plo ./$(DEPDIR)/userauth_kbd_packet.Plo \
+	./$(DEPDIR)/version.Plo
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -235,10 +234,7 @@ am__define_uniq_tagged_files = \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
-am__DIST_COMMON = $(srcdir)/../Makefile.OpenSSL.inc \
-	$(srcdir)/../Makefile.WinCNG.inc $(srcdir)/../Makefile.inc \
-	$(srcdir)/../Makefile.libgcrypt.inc \
-	$(srcdir)/../Makefile.mbedTLS.inc $(srcdir)/Makefile.in \
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
 	$(srcdir)/libssh2_config.h.in $(top_srcdir)/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
@@ -275,12 +271,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -291,30 +288,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -336,6 +337,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -397,41 +399,79 @@ top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 
-# $Id: Makefile.am,v 1.21 2009/05/07 17:21:56 bagder Exp $
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 AUTOMAKE_OPTIONS = foreign nostdinc
-@LIBGCRYPT_TRUE@CRYPTO_CSOURCES = libgcrypt.c
-@MBEDTLS_TRUE@CRYPTO_CSOURCES = mbedtls.c
-@OPENSSL_TRUE@CRYPTO_CSOURCES = openssl.c
-@WINCNG_TRUE@CRYPTO_CSOURCES = wincng.c
-@LIBGCRYPT_TRUE@CRYPTO_HHEADERS = libgcrypt.h
-@MBEDTLS_TRUE@CRYPTO_HHEADERS = mbedtls.h
-@OPENSSL_TRUE@CRYPTO_HHEADERS = openssl.h
-@WINCNG_TRUE@CRYPTO_HHEADERS = wincng.h
-@LIBGCRYPT_TRUE@CRYPTO_LTLIBS = $(LTLIBGCRYPT)
-@MBEDTLS_TRUE@CRYPTO_LTLIBS = $(LTLIBMBEDCRYPTO)
-@OPENSSL_TRUE@CRYPTO_LTLIBS = $(LTLIBSSL)
-@WINCNG_TRUE@CRYPTO_LTLIBS = $(LTLIBBCRYPT) $(LTLIBCRYPT32)
-CSOURCES = channel.c comp.c crypt.c hostkey.c kex.c mac.c misc.c \
- packet.c publickey.c scp.c session.c sftp.c userauth.c transport.c \
- version.c knownhost.c agent.c $(CRYPTO_CSOURCES) pem.c keepalive.c global.c \
- blowfish.c bcrypt_pbkdf.c agent_win.c
-
-HHEADERS = libssh2_priv.h $(CRYPTO_HHEADERS) transport.h channel.h comp.h \
- mac.h misc.h packet.h userauth.h session.h sftp.h crypto.h blf.h agent.h
-
-
-# Get the CRYPTO_CSOURCES, CRYPTO_HHEADERS and CRYPTO_LTLIBS defines
-
-# Makefile.inc provides the CSOURCES and HHEADERS defines
-libssh2_la_SOURCES = $(CSOURCES) $(HHEADERS)
-EXTRA_DIST = libssh2_config.h.in libssh2_config_cmake.h.in \
-	libssh2.pc.in CMakeLists.txt NMakefile
+
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+CSOURCES = \
+  agent.c               \
+  bcrypt_pbkdf.c        \
+  channel.c             \
+  comp.c                \
+  chacha.c              \
+  cipher-chachapoly.c   \
+  crypt.c               \
+  crypto.c              \
+  global.c              \
+  hostkey.c             \
+  keepalive.c           \
+  kex.c                 \
+  knownhost.c           \
+  mac.c                 \
+  misc.c                \
+  packet.c              \
+  pem.c                 \
+  poly1305.c            \
+  publickey.c           \
+  scp.c                 \
+  session.c             \
+  sftp.c                \
+  transport.c           \
+  userauth.c            \
+  userauth_kbd_packet.c \
+  version.c
+
+HHEADERS = \
+  chacha.h              \
+  channel.h             \
+  cipher-chachapoly.h   \
+  comp.h                \
+  crypto.h              \
+  crypto_config.h       \
+  libgcrypt.h           \
+  libssh2_priv.h        \
+  libssh2_setup.h       \
+  mac.h                 \
+  mbedtls.h             \
+  misc.h                \
+  openssl.h             \
+  os400qc3.h            \
+  packet.h              \
+  poly1305.h            \
+  session.h             \
+  sftp.h                \
+  transport.h           \
+  userauth.h            \
+  userauth_kbd_packet.h \
+  wincng.h
+
+EXTRA_DIST = agent_win.c blowfish.c libgcrypt.c mbedtls.c openssl.c \
+	os400qc3.c wincng.c libssh2_config.h.in \
+	libssh2_config_cmake.h.in CMakeLists.txt
+
+# Get the CSOURCES, HHEADERS and EXTRA_DIST defines
+libssh2_la_SOURCES = $(CSOURCES) $(HHEADERS) $(am__append_1)
 lib_LTLIBRARIES = libssh2.la
 
 # srcdir/include for the shipped headers
 # builddir/src for the generated config header when building out of the source
 # tree
-AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/src
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/include
+
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
 
 # This flag accepts an argument of the form current[:revision[:age]]. So,
 # passing -version-info 3:12:1 sets current to 3, revision to 12, and age to
@@ -461,15 +501,14 @@ AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_builddir)/src
 # set age to 0. (c:r:a=0)
 #
 libssh2_la_LDFLAGS = $(VERSION) -no-undefined \
-	-export-symbols-regex '^libssh2_.*' \
-	$(CRYPTO_LTLIBS) $(LTLIBZ)
+  -export-symbols-regex '^libssh2_.*'
 
 all: libssh2_config.h
 	$(MAKE) $(AM_MAKEFLAGS) all-am
 
 .SUFFIXES:
-.SUFFIXES: .c .lo .o .obj
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/../Makefile.OpenSSL.inc $(srcdir)/../Makefile.libgcrypt.inc $(srcdir)/../Makefile.WinCNG.inc $(srcdir)/../Makefile.mbedTLS.inc $(srcdir)/../Makefile.inc $(am__configure_deps)
+.SUFFIXES: .c .lo .o .obj .rc
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
@@ -489,7 +528,7 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
 	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
-$(srcdir)/../Makefile.OpenSSL.inc $(srcdir)/../Makefile.libgcrypt.inc $(srcdir)/../Makefile.WinCNG.inc $(srcdir)/../Makefile.mbedTLS.inc $(srcdir)/../Makefile.inc $(am__empty):
+$(srcdir)/Makefile.inc $(am__empty):
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
@@ -560,32 +599,31 @@ distclean-compile:
 	-rm -f *.tab.c
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/agent.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/agent_win.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bcrypt_pbkdf.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blowfish.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/chacha.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/channel.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cipher-chachapoly.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comp.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/crypt.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/crypto.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/global.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hostkey.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/keepalive.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/kex.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/knownhost.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libgcrypt.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mac.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mbedtls.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/misc.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/openssl.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/packet.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pem.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/poly1305.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/publickey.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scp.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/session.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sftp.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/transport.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/userauth.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/userauth_kbd_packet.Plo@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/version.Plo@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wincng.Plo@am__quote@ # am--include-marker
 
 $(am__depfiles_remade):
 	@$(MKDIR_P) $(@D)
@@ -748,32 +786,31 @@ clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
 
 distclean: distclean-am
 		-rm -f ./$(DEPDIR)/agent.Plo
-	-rm -f ./$(DEPDIR)/agent_win.Plo
 	-rm -f ./$(DEPDIR)/bcrypt_pbkdf.Plo
-	-rm -f ./$(DEPDIR)/blowfish.Plo
+	-rm -f ./$(DEPDIR)/chacha.Plo
 	-rm -f ./$(DEPDIR)/channel.Plo
+	-rm -f ./$(DEPDIR)/cipher-chachapoly.Plo
 	-rm -f ./$(DEPDIR)/comp.Plo
 	-rm -f ./$(DEPDIR)/crypt.Plo
+	-rm -f ./$(DEPDIR)/crypto.Plo
 	-rm -f ./$(DEPDIR)/global.Plo
 	-rm -f ./$(DEPDIR)/hostkey.Plo
 	-rm -f ./$(DEPDIR)/keepalive.Plo
 	-rm -f ./$(DEPDIR)/kex.Plo
 	-rm -f ./$(DEPDIR)/knownhost.Plo
-	-rm -f ./$(DEPDIR)/libgcrypt.Plo
 	-rm -f ./$(DEPDIR)/mac.Plo
-	-rm -f ./$(DEPDIR)/mbedtls.Plo
 	-rm -f ./$(DEPDIR)/misc.Plo
-	-rm -f ./$(DEPDIR)/openssl.Plo
 	-rm -f ./$(DEPDIR)/packet.Plo
 	-rm -f ./$(DEPDIR)/pem.Plo
+	-rm -f ./$(DEPDIR)/poly1305.Plo
 	-rm -f ./$(DEPDIR)/publickey.Plo
 	-rm -f ./$(DEPDIR)/scp.Plo
 	-rm -f ./$(DEPDIR)/session.Plo
 	-rm -f ./$(DEPDIR)/sftp.Plo
 	-rm -f ./$(DEPDIR)/transport.Plo
 	-rm -f ./$(DEPDIR)/userauth.Plo
+	-rm -f ./$(DEPDIR)/userauth_kbd_packet.Plo
 	-rm -f ./$(DEPDIR)/version.Plo
-	-rm -f ./$(DEPDIR)/wincng.Plo
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-hdr distclean-tags
@@ -820,32 +857,31 @@ installcheck-am:
 
 maintainer-clean: maintainer-clean-am
 		-rm -f ./$(DEPDIR)/agent.Plo
-	-rm -f ./$(DEPDIR)/agent_win.Plo
 	-rm -f ./$(DEPDIR)/bcrypt_pbkdf.Plo
-	-rm -f ./$(DEPDIR)/blowfish.Plo
+	-rm -f ./$(DEPDIR)/chacha.Plo
 	-rm -f ./$(DEPDIR)/channel.Plo
+	-rm -f ./$(DEPDIR)/cipher-chachapoly.Plo
 	-rm -f ./$(DEPDIR)/comp.Plo
 	-rm -f ./$(DEPDIR)/crypt.Plo
+	-rm -f ./$(DEPDIR)/crypto.Plo
 	-rm -f ./$(DEPDIR)/global.Plo
 	-rm -f ./$(DEPDIR)/hostkey.Plo
 	-rm -f ./$(DEPDIR)/keepalive.Plo
 	-rm -f ./$(DEPDIR)/kex.Plo
 	-rm -f ./$(DEPDIR)/knownhost.Plo
-	-rm -f ./$(DEPDIR)/libgcrypt.Plo
 	-rm -f ./$(DEPDIR)/mac.Plo
-	-rm -f ./$(DEPDIR)/mbedtls.Plo
 	-rm -f ./$(DEPDIR)/misc.Plo
-	-rm -f ./$(DEPDIR)/openssl.Plo
 	-rm -f ./$(DEPDIR)/packet.Plo
 	-rm -f ./$(DEPDIR)/pem.Plo
+	-rm -f ./$(DEPDIR)/poly1305.Plo
 	-rm -f ./$(DEPDIR)/publickey.Plo
 	-rm -f ./$(DEPDIR)/scp.Plo
 	-rm -f ./$(DEPDIR)/session.Plo
 	-rm -f ./$(DEPDIR)/sftp.Plo
 	-rm -f ./$(DEPDIR)/transport.Plo
 	-rm -f ./$(DEPDIR)/userauth.Plo
+	-rm -f ./$(DEPDIR)/userauth_kbd_packet.Plo
 	-rm -f ./$(DEPDIR)/version.Plo
-	-rm -f ./$(DEPDIR)/wincng.Plo
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -884,6 +920,9 @@ uninstall-am: uninstall-libLTLIBRARIES
 .PRECIOUS: Makefile
 
 
+@HAVE_WINDRES_TRUE@.rc.lo:
+@HAVE_WINDRES_TRUE@	$(LIBTOOL) --tag=RC --mode=compile $(RC) -I$(top_srcdir)/include $(RCFLAGS) -i $< -o $@
+
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
 .NOEXPORT:
diff --git a/libssh2/src/Makefile.inc b/libssh2/src/Makefile.inc
new file mode 100644
index 00000000..5cf070cc
--- /dev/null
+++ b/libssh2/src/Makefile.inc
@@ -0,0 +1,62 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+CSOURCES =              \
+  agent.c               \
+  bcrypt_pbkdf.c        \
+  channel.c             \
+  comp.c                \
+  chacha.c              \
+  cipher-chachapoly.c   \
+  crypt.c               \
+  crypto.c              \
+  global.c              \
+  hostkey.c             \
+  keepalive.c           \
+  kex.c                 \
+  knownhost.c           \
+  mac.c                 \
+  misc.c                \
+  packet.c              \
+  pem.c                 \
+  poly1305.c            \
+  publickey.c           \
+  scp.c                 \
+  session.c             \
+  sftp.c                \
+  transport.c           \
+  userauth.c            \
+  userauth_kbd_packet.c \
+  version.c
+
+HHEADERS =              \
+  chacha.h              \
+  channel.h             \
+  cipher-chachapoly.h   \
+  comp.h                \
+  crypto.h              \
+  crypto_config.h       \
+  libgcrypt.h           \
+  libssh2_priv.h        \
+  libssh2_setup.h       \
+  mac.h                 \
+  mbedtls.h             \
+  misc.h                \
+  openssl.h             \
+  os400qc3.h            \
+  packet.h              \
+  poly1305.h            \
+  session.h             \
+  sftp.h                \
+  transport.h           \
+  userauth.h            \
+  userauth_kbd_packet.h \
+  wincng.h
+
+EXTRA_DIST =            \
+  agent_win.c           \
+  blowfish.c            \
+  libgcrypt.c           \
+  mbedtls.c             \
+  openssl.c             \
+  os400qc3.c            \
+  wincng.c
diff --git a/libssh2/src/NMakefile b/libssh2/src/NMakefile
deleted file mode 100644
index 0c4853f1..00000000
--- a/libssh2/src/NMakefile
+++ /dev/null
@@ -1,30 +0,0 @@
-!include "win32/config.mk"
-
-!include "win32/objects.mk"
-
-CFLAGS=$(CFLAGS)
-
-AR = lib
-ARFLAGS = -nologo /LTCG
-
-RESOURCE=$(INTDIR)\libssh2.res
-DLL=libssh2$(SUFFIX).dll
-STATICLIB=$(INTDIR)\libssh2.lib
-
-!if "$(BUILD_STATIC_LIB)" == ""
-all: $(DLL)
-!else
-all: $(STATICLIB)
-!endif
-
-$(DLL): $(OBJECTS) $(RESOURCE)
-	$(CC) -o $(DLL) $(DLLFLAGS) $(OBJECTS) $(RESOURCE) $(LIBS)
-
-$(STATICLIB): $(OBJECTS)
-	$(AR) $(ARFLAGS) -out:$@ $(OBJECTS)
-
-$(RESOURCE): win32\libssh2.rc
-	$(RC) $(RCFLAGS) /Fo"$@" $?
-
-!include "win32/rules.mk"
-
diff --git a/libssh2/src/agent.c b/libssh2/src/agent.c
index 85c3e34a..dd709eb1 100644
--- a/libssh2/src/agent.c
+++ b/libssh2/src/agent.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2009 by Daiki Ueno
- * Copyright (C) 2010-2014 by Daniel Stenberg
+ * Copyright (C) Daiki Ueno
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,12 +35,15 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include "agent.h"
-#include "misc.h"
+
 #include <errno.h>
+#include <stdlib.h>  /* for getenv() */
+
 #ifdef HAVE_SYS_UN_H
 #include <sys/un.h>
 #else
@@ -49,12 +52,15 @@
    support them. */
 #undef PF_UNIX
 #endif
+
+#if defined(_WIN32) && !defined(LIBSSH2_WINDOWS_UWP)
+#define HAVE_WIN32_AGENTS
+#endif
+
 #include "userauth.h"
 #include "session.h"
-#ifdef WIN32
-#include <stdlib.h>
-#endif
 
+#if 0
 /* Requests from client to agent for protocol 1 key operations */
 #define SSH_AGENTC_REQUEST_RSA_IDENTITIES 1
 #define SSH_AGENTC_RSA_CHALLENGE 3
@@ -62,10 +68,12 @@
 #define SSH_AGENTC_REMOVE_RSA_IDENTITY 8
 #define SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES 9
 #define SSH_AGENTC_ADD_RSA_ID_CONSTRAINED 24
+#endif
 
 /* Requests from client to agent for protocol 2 key operations */
 #define SSH2_AGENTC_REQUEST_IDENTITIES 11
 #define SSH2_AGENTC_SIGN_REQUEST 13
+#if 0
 #define SSH2_AGENTC_ADD_IDENTITY 17
 #define SSH2_AGENTC_REMOVE_IDENTITY 18
 #define SSH2_AGENTC_REMOVE_ALL_IDENTITIES 19
@@ -86,13 +94,79 @@
 #define SSH_AGENT_RSA_IDENTITIES_ANSWER 2
 #define SSH_AGENT_RSA_RESPONSE 4
 
+/* Key constraint identifiers */
+#define SSH_AGENT_CONSTRAIN_LIFETIME 1
+#define SSH_AGENT_CONSTRAIN_CONFIRM 2
+#endif
+
 /* Replies from agent to client for protocol 2 key operations */
 #define SSH2_AGENT_IDENTITIES_ANSWER 12
 #define SSH2_AGENT_SIGN_RESPONSE 14
 
-/* Key constraint identifiers */
-#define SSH_AGENT_CONSTRAIN_LIFETIME 1
-#define SSH_AGENT_CONSTRAIN_CONFIRM 2
+/* Signature request methods */
+#define SSH_AGENT_RSA_SHA2_256 2
+#define SSH_AGENT_RSA_SHA2_512 4
+
+/* non-blocking mode on agent connection is not yet implemented, but
+   for future use. */
+typedef enum {
+    agent_NB_state_init = 0,
+    agent_NB_state_request_created,
+    agent_NB_state_request_length_sent,
+    agent_NB_state_request_sent,
+    agent_NB_state_response_length_received,
+    agent_NB_state_response_received
+} agent_nonblocking_states;
+
+typedef struct agent_transaction_ctx {
+    unsigned char *request;
+    size_t request_len;
+    unsigned char *response;
+    size_t response_len;
+    agent_nonblocking_states state;
+    size_t send_recv_total;
+} *agent_transaction_ctx_t;
+
+typedef int (*agent_connect_func)(LIBSSH2_AGENT *agent);
+typedef int (*agent_transact_func)(LIBSSH2_AGENT *agent,
+                                   agent_transaction_ctx_t transctx);
+typedef int (*agent_disconnect_func)(LIBSSH2_AGENT *agent);
+
+struct agent_publickey {
+    struct list_node node;
+
+    /* this is the struct we expose externally */
+    struct libssh2_agent_publickey external;
+};
+
+struct agent_ops {
+    const agent_connect_func connect;
+    const agent_transact_func transact;
+    const agent_disconnect_func disconnect;
+};
+
+struct _LIBSSH2_AGENT
+{
+    LIBSSH2_SESSION *session;  /* the session this "belongs to" */
+
+    libssh2_socket_t fd;
+
+    struct agent_ops *ops;
+
+    struct agent_transaction_ctx transctx;
+    struct agent_publickey *identity;
+    struct list_head head;              /* list of public keys */
+
+    char *identity_agent_path; /* Path to a custom identity agent socket */
+
+#ifdef HAVE_WIN32_AGENTS
+    OVERLAPPED overlapped;
+    HANDLE pipe;
+    BOOL pending_io;
+#endif
+};
+
+#include "agent_win.c"
 
 #ifdef PF_UNIX
 static int
@@ -115,10 +189,10 @@ agent_connect_unix(LIBSSH2_AGENT *agent)
                               "failed creating socket");
 
     s_un.sun_family = AF_UNIX;
-    strncpy(s_un.sun_path, path, sizeof s_un.sun_path);
+    strncpy(s_un.sun_path, path, sizeof(s_un.sun_path));
     s_un.sun_path[sizeof(s_un.sun_path)-1] = 0; /* make sure there's a trailing
                                                    zero */
-    if(connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
+    if(connect(agent->fd, (struct sockaddr*)(&s_un), sizeof(s_un)) != 0) {
         close(agent->fd);
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed connecting with agent");
@@ -128,20 +202,22 @@ agent_connect_unix(LIBSSH2_AGENT *agent)
 }
 
 #define RECV_SEND_ALL(func, socket, buffer, length, flags, abstract) \
-    int rc;                                                          \
-    size_t finished = 0;                                             \
+    do {                                                             \
+        size_t finished = 0;                                         \
                                                                      \
-    while(finished < length) {                                       \
-        rc = func(socket,                                            \
-                  (char *)buffer + finished, length - finished,      \
-                  flags, abstract);                                  \
-        if(rc < 0)                                                   \
-            return rc;                                               \
+        while(finished < length) {                                   \
+            ssize_t rc;                                              \
+            rc = func(socket,                                        \
+                      (char *)buffer + finished, length - finished,  \
+                      flags, abstract);                              \
+            if(rc < 0)                                               \
+                return rc;                                           \
                                                                      \
-        finished += rc;                                              \
-    }                                                                \
+            finished += rc;                                          \
+        }                                                            \
                                                                      \
-    return finished;
+        return finished;                                             \
+    } while(0)
 
 static ssize_t _send_all(LIBSSH2_SEND_FUNC(func), libssh2_socket_t socket,
                          const void *buffer, size_t length,
@@ -167,9 +243,10 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 
     /* Send the length of the request */
     if(transctx->state == agent_NB_state_request_created) {
-        _libssh2_htonu32(buf, transctx->request_len);
-        rc = _send_all(agent->session->send, agent->fd,
-                       buf, sizeof buf, 0, &agent->session->abstract);
+        _libssh2_htonu32(buf, (uint32_t)transctx->request_len);
+        rc = (int)_send_all(agent->session->send, agent->fd,
+                            buf, sizeof(buf), 0,
+                            &agent->session->abstract);
         if(rc == -EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
         else if(rc < 0)
@@ -180,8 +257,9 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 
     /* Send the request body */
     if(transctx->state == agent_NB_state_request_length_sent) {
-        rc = _send_all(agent->session->send, agent->fd, transctx->request,
-                       transctx->request_len, 0, &agent->session->abstract);
+        rc = (int)_send_all(agent->session->send, agent->fd,
+                            transctx->request, transctx->request_len, 0,
+                            &agent->session->abstract);
         if(rc == -EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
         else if(rc < 0)
@@ -192,8 +270,9 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 
     /* Receive the length of a response */
     if(transctx->state == agent_NB_state_request_sent) {
-        rc = _recv_all(agent->session->recv, agent->fd,
-                       buf, sizeof buf, 0, &agent->session->abstract);
+        rc = (int)_recv_all(agent->session->recv, agent->fd,
+                            buf, sizeof(buf), 0,
+                            &agent->session->abstract);
         if(rc < 0) {
             if(rc == -EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
@@ -211,8 +290,9 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 
     /* Receive the response body */
     if(transctx->state == agent_NB_state_response_length_received) {
-        rc = _recv_all(agent->session->recv, agent->fd, transctx->response,
-                       transctx->response_len, 0, &agent->session->abstract);
+        rc = (int)_recv_all(agent->session->recv, agent->fd,
+                            transctx->response, transctx->response_len, 0,
+                            &agent->session->abstract);
         if(rc < 0) {
             if(rc == -EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
@@ -238,14 +318,14 @@ agent_disconnect_unix(LIBSSH2_AGENT *agent)
     return LIBSSH2_ERROR_NONE;
 }
 
-struct agent_ops agent_ops_unix = {
+static struct agent_ops agent_ops_unix = {
     agent_connect_unix,
     agent_transact_unix,
     agent_disconnect_unix
 };
 #endif  /* PF_UNIX */
 
-#ifdef WIN32
+#ifdef HAVE_WIN32_AGENTS
 /* Code to talk to Pageant was taken from PuTTY.
  *
  * Portions copyright Robert de Bath, Joris van Rantwijk, Delian
@@ -276,7 +356,7 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     HANDLE filemap;
     unsigned char *p;
     unsigned char *p2;
-    int id;
+    LRESULT id;
     COPYDATASTRUCT cds;
 
     if(!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
@@ -289,16 +369,16 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
                               "found no pageant");
 
     snprintf(mapname, sizeof(mapname),
-             "PageantRequest%08x%c", (unsigned)GetCurrentThreadId(), '\0');
+             "PageantRequest%08x", (unsigned)GetCurrentThreadId());
     filemap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
                                  0, PAGEANT_MAX_MSGLEN, mapname);
 
-    if(filemap == NULL || filemap == INVALID_HANDLE_VALUE)
+    if(!filemap || filemap == INVALID_HANDLE_VALUE)
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed setting up pageant filemap");
 
     p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
-    if(p == NULL || p2 == NULL) {
+    if(!p || !p2) {
         CloseHandle(filemap);
         return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                               "failed to open pageant filemap for writing");
@@ -308,7 +388,7 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
                        transctx->request_len);
 
     cds.dwData = PAGEANT_COPYDATA_ID;
-    cds.cbData = 1 + strlen(mapname);
+    cds.cbData = (DWORD)(1 + strlen(mapname));
     cds.lpData = mapname;
 
     id = SendMessage(hwnd, WM_COPYDATA, (WPARAM) NULL, (LPARAM) &cds);
@@ -343,21 +423,21 @@ agent_disconnect_pageant(LIBSSH2_AGENT *agent)
     return 0;
 }
 
-struct agent_ops agent_ops_pageant = {
+static struct agent_ops agent_ops_pageant = {
     agent_connect_pageant,
     agent_transact_pageant,
     agent_disconnect_pageant
 };
-#endif  /* WIN32 */
+#endif /* HAVE_WIN32_AGENTS */
 
 static struct {
     const char *name;
     struct agent_ops *ops;
 } supported_backends[] = {
-#ifdef WIN32
+#ifdef HAVE_WIN32_AGENTS
     {"Pageant", &agent_ops_pageant},
     {"OpenSSH", &agent_ops_openssh},
-#endif  /* WIN32 */
+#endif /* HAVE_WIN32_AGENTS */
 #ifdef PF_UNIX
     {"Unix", &agent_ops_unix},
 #endif  /* PF_UNIX */
@@ -375,6 +455,9 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     ssize_t method_len;
     unsigned char *s;
     int rc;
+    unsigned char *method_name = NULL;
+    uint32_t sign_flags = 0;
+    ssize_t plain_len;
 
     /* Create a request to sign the data */
     if(transctx->state == agent_NB_state_init) {
@@ -391,7 +474,18 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
         _libssh2_store_str(&s, (const char *)data, data_len);
 
         /* flags */
-        _libssh2_store_u32(&s, 0);
+        if(session->userauth_pblc_method_len > 0 &&
+            session->userauth_pblc_method) {
+            if(session->userauth_pblc_method_len == 12 &&
+                !memcmp(session->userauth_pblc_method, "rsa-sha2-512", 12)) {
+                sign_flags = SSH_AGENT_RSA_SHA2_512;
+            }
+            else if(session->userauth_pblc_method_len == 12 &&
+                !memcmp(session->userauth_pblc_method, "rsa-sha2-256", 12)) {
+                sign_flags = SSH_AGENT_RSA_SHA2_256;
+            }
+        }
+        _libssh2_store_u32(&s, sign_flags);
 
         transctx->request_len = s - transctx->request;
         transctx->send_recv_total = 0;
@@ -449,8 +543,32 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
         rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
         goto error;
     }
+
+    /* method name */
+    method_name = LIBSSH2_ALLOC(session, method_len);
+    if(!method_name) {
+        rc = LIBSSH2_ERROR_ALLOC;
+        goto error;
+    }
+    memcpy(method_name, s, method_len);
     s += method_len;
 
+    plain_len = plain_method((char *)session->userauth_pblc_method,
+                             session->userauth_pblc_method_len);
+
+    /* check to see if we match requested */
+    if(((size_t)method_len != session->userauth_pblc_method_len &&
+        method_len != plain_len) ||
+       memcmp(method_name, session->userauth_pblc_method, method_len)) {
+        _libssh2_debug((session,
+                       LIBSSH2_TRACE_KEX,
+                       "Agent sign method %.*s",
+                       (int)method_len, method_name));
+
+        rc = LIBSSH2_ERROR_ALGO_UNSUPPORTED;
+        goto error;
+    }
+
     /* Read the signature */
     len -= 4;
     if(len < 0) {
@@ -472,13 +590,19 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     }
     memcpy(*sig, s, *sig_len);
 
-  error:
+error:
+
+    if(method_name)
+        LIBSSH2_FREE(session, method_name);
+
     LIBSSH2_FREE(session, transctx->request);
     transctx->request = NULL;
 
     LIBSSH2_FREE(session, transctx->response);
     transctx->response = NULL;
 
+    transctx->state = agent_NB_state_init;
+
     return _libssh2_error(session, rc, "agent sign failure");
 }
 
@@ -541,7 +665,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
     while(num_identities--) {
         struct agent_publickey *identity;
-        ssize_t comment_len;
+        size_t comment_len;
 
         /* Read the length of the blob */
         len -= 4;
@@ -549,7 +673,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             goto error;
         }
-        identity = LIBSSH2_ALLOC(agent->session, sizeof *identity);
+        identity = LIBSSH2_ALLOC(agent->session, sizeof(*identity));
         if(!identity) {
             rc = LIBSSH2_ERROR_ALLOC;
             goto error;
@@ -586,14 +710,14 @@ agent_list_identities(LIBSSH2_AGENT *agent)
         comment_len = _libssh2_ntohu32(s);
         s += 4;
 
-        /* Read the comment */
-        len -= comment_len;
-        if(len < 0) {
+        if(comment_len > (size_t)len) {
             rc = LIBSSH2_ERROR_AGENT_PROTOCOL;
             LIBSSH2_FREE(agent->session, identity->external.blob);
             LIBSSH2_FREE(agent->session, identity);
             goto error;
         }
+        /* Read the comment */
+        len -= comment_len;
 
         identity->external.comment = LIBSSH2_ALLOC(agent->session,
                                                    comment_len + 1);
@@ -609,7 +733,7 @@ agent_list_identities(LIBSSH2_AGENT *agent)
 
         _libssh2_list_add(&agent->head, &identity->node);
     }
- error:
+error:
     LIBSSH2_FREE(agent->session, transctx->response);
     transctx->response = NULL;
 
@@ -634,7 +758,7 @@ agent_free_identities(LIBSSH2_AGENT *agent)
 
 #define AGENT_PUBLICKEY_MAGIC 0x3bdefed2
 /*
- * agent_publickey_to_external()
+ * agent_publickey_to_external
  *
  * Copies data from the internal to the external representation struct.
  *
@@ -661,7 +785,7 @@ libssh2_agent_init(LIBSSH2_SESSION *session)
 {
     LIBSSH2_AGENT *agent;
 
-    agent = LIBSSH2_CALLOC(session, sizeof *agent);
+    agent = LIBSSH2_CALLOC(session, sizeof(*agent));
     if(!agent) {
         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                        "Unable to allocate space for agent connection");
@@ -672,7 +796,7 @@ libssh2_agent_init(LIBSSH2_SESSION *session)
     agent->identity_agent_path = NULL;
     _libssh2_list_init(&agent->head);
 
-#ifdef WIN32
+#ifdef HAVE_WIN32_AGENTS
     agent->pipe = INVALID_HANDLE_VALUE;
     memset(&agent->overlapped, 0, sizeof(OVERLAPPED));
     agent->pending_io = FALSE;
@@ -682,7 +806,7 @@ libssh2_agent_init(LIBSSH2_SESSION *session)
 }
 
 /*
- * libssh2_agent_connect()
+ * libssh2_agent_connect
  *
  * Connect to an ssh-agent.
  *
@@ -702,7 +826,7 @@ libssh2_agent_connect(LIBSSH2_AGENT *agent)
 }
 
 /*
- * libssh2_agent_list_identities()
+ * libssh2_agent_list_identities
  *
  * Request ssh-agent to list identities.
  *
@@ -711,14 +835,14 @@ libssh2_agent_connect(LIBSSH2_AGENT *agent)
 LIBSSH2_API int
 libssh2_agent_list_identities(LIBSSH2_AGENT *agent)
 {
-    memset(&agent->transctx, 0, sizeof agent->transctx);
+    memset(&agent->transctx, 0, sizeof(agent->transctx));
     /* Abandon the last fetched identities */
     agent_free_identities(agent);
     return agent_list_identities(agent);
 }
 
 /*
- * libssh2_agent_get_identity()
+ * libssh2_agent_get_identity
  *
  * Traverse the internal list of public keys. Pass NULL to 'prev' to get
  * the first one. Or pass a pointer to the previously returned one to get the
@@ -755,7 +879,7 @@ libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
 }
 
 /*
- * libssh2_agent_userauth()
+ * libssh2_agent_userauth
  *
  * Do publickey user authentication with the help of ssh-agent.
  *
@@ -770,7 +894,7 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
     int rc;
 
     if(agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
-        memset(&agent->transctx, 0, sizeof agent->transctx);
+        memset(&agent->transctx, 0, sizeof(agent->transctx));
         agent->identity = identity->node;
     }
 
@@ -785,7 +909,58 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
 }
 
 /*
- * libssh2_agent_disconnect()
+ * libssh2_agent_sign
+ *
+ * Sign a payload using a system-installed ssh-agent.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_sign(LIBSSH2_AGENT *agent,
+                   struct libssh2_agent_publickey *identity,
+                   unsigned char **sig,
+                   size_t *s_len,
+                   const unsigned char *data,
+                   size_t d_len,
+                   const char *method,
+                   unsigned int method_len)
+{
+    void *abstract = agent;
+    int rc;
+    uint32_t methodLen;
+
+    if(agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
+        memset(&agent->transctx, 0, sizeof(agent->transctx));
+        agent->identity = identity->node;
+    }
+
+    if(identity->blob_len < sizeof(uint32_t)) {
+        return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
+    }
+
+    methodLen = _libssh2_ntohu32(identity->blob);
+
+    if(identity->blob_len < sizeof(uint32_t) + methodLen) {
+        return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
+    }
+
+    agent->session->userauth_pblc_method_len = method_len;
+    agent->session->userauth_pblc_method = LIBSSH2_ALLOC(agent->session,
+                                                         method_len);
+
+    memcpy(agent->session->userauth_pblc_method, method, methodLen);
+
+    rc = agent_sign(agent->session, sig, s_len, data, d_len, &abstract);
+
+    LIBSSH2_FREE(agent->session, agent->session->userauth_pblc_method);
+    agent->session->userauth_pblc_method = NULL;
+    agent->session->userauth_pblc_method_len = 0;
+
+    return rc;
+}
+
+/*
+ * libssh2_agent_disconnect
  *
  * Close a connection to an ssh-agent.
  *
@@ -800,7 +975,7 @@ libssh2_agent_disconnect(LIBSSH2_AGENT *agent)
 }
 
 /*
- * libssh2_agent_free()
+ * libssh2_agent_free
  *
  * Free an ssh-agent handle.  This function also frees the internal
  * collection of public keys.
@@ -813,7 +988,7 @@ libssh2_agent_free(LIBSSH2_AGENT *agent)
         libssh2_agent_disconnect(agent);
     }
 
-    if(agent->identity_agent_path != NULL)
+    if(agent->identity_agent_path)
         LIBSSH2_FREE(agent->session, agent->identity_agent_path);
 
     agent_free_identities(agent);
@@ -821,7 +996,7 @@ libssh2_agent_free(LIBSSH2_AGENT *agent)
 }
 
 /*
- * libssh2_agent_set_identity_path()
+ * libssh2_agent_set_identity_path
  *
  * Allows a custom agent socket path beyond SSH_AUTH_SOCK env
  *
@@ -846,7 +1021,7 @@ libssh2_agent_set_identity_path(LIBSSH2_AGENT *agent, const char *path)
 }
 
 /*
- * libssh2_agent_get_identity_path()
+ * libssh2_agent_get_identity_path
  *
  * Returns the custom agent socket path if set
  *
diff --git a/libssh2/libssh2/src/agent_win.c b/libssh2/src/agent_win.c
similarity index 93%
rename from libssh2/libssh2/src/agent_win.c
rename to libssh2/src/agent_win.c
index a1605a95..3764fe43 100644
--- a/libssh2/libssh2/src/agent_win.c
+++ b/libssh2/src/agent_win.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2009 by Daiki Ueno
- * Copyright (C) 2010-2014 by Daniel Stenberg
+ * Copyright (C) Daiki Ueno
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,32 +35,19 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause AND BSD-2-Clause
  */
 
-#include "libssh2_priv.h"
-#include "agent.h"
-#include "misc.h"
-#include <errno.h>
-#ifdef HAVE_SYS_UN_H
-#include <sys/un.h>
-#else
-/* Use the existence of sys/un.h as a test if Unix domain socket is
-   supported.  winsock*.h define PF_UNIX/AF_UNIX but do not actually
-   support them. */
-#undef PF_UNIX
-#endif
-#include "userauth.h"
-#include "session.h"
-#ifdef WIN32
-#include <stdlib.h>
-#endif
+#ifdef HAVE_WIN32_AGENTS /* Compile this via agent.c */
+
+#include <stdlib.h>  /* for getenv() */
 
-#ifdef WIN32
 /* Code to talk to OpenSSH was taken and modified from the Win32 port of
  * Portable OpenSSH by the PowerShell team. Commit
  * 8ab565c53f3619d6a1f5ac229e212cad8a52852c of
  * https://github.com/PowerShell/openssh-portable.git was used as the base,
- * specificaly the following files:
+ * specifically the following files:
  *
  * - contrib\win32\win32compat\fileio.c
  *   - Structure of agent_connect_openssh from ssh_get_authentication_socket
@@ -74,7 +61,7 @@
  *     - fileio_close replacing close
  *
  * Author: Tatu Ylonen <ylo@cs.hut.fi>
- * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
+ * Copyright (C) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
  *                    All rights reserved
  * Functions for connecting the local authentication agent.
  *
@@ -85,7 +72,7 @@
  * called by a name other than "ssh" or "Secure Shell".
  *
  * SSH2 implementation,
- * Copyright (c) 2000 Markus Friedl.  All rights reserved.
+ * Copyright (C) 2000 Markus Friedl.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -107,7 +94,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Copyright (c) 2015 Microsoft Corp.
+ * Copyright (C) 2015 Microsoft Corp.
  * All rights reserved
  *
  * Microsoft openssh win32 port
@@ -195,7 +182,7 @@ agent_connect_openssh(LIBSSH2_AGENT *agent)
     }
 
     event = CreateEventA(NULL, TRUE, FALSE, NULL);
-    if(event == NULL) {
+    if(!event) {
         ret = _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
                              "unable to create async I/O event");
         goto cleanup;
@@ -208,7 +195,7 @@ agent_connect_openssh(LIBSSH2_AGENT *agent)
     agent->fd = 0; /* Mark as the connection has been established */
 
 cleanup:
-    if(event != NULL)
+    if(event)
         CloseHandle(event);
     if(pipe != INVALID_HANDLE_VALUE)
         CloseHandle(pipe);
@@ -273,7 +260,7 @@ agent_transact_openssh(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     /* Send the length of the request */
     if(transctx->state == agent_NB_state_request_created) {
         _libssh2_htonu32(buf, (uint32_t)transctx->request_len);
-        rc = win32_openssh_send_all(agent, buf, sizeof buf,
+        rc = win32_openssh_send_all(agent, buf, sizeof(buf),
                                     &transctx->send_recv_total);
         if(rc == LIBSSH2_ERROR_EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
@@ -298,7 +285,7 @@ agent_transact_openssh(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 
     /* Receive the length of the body */
     if(transctx->state == agent_NB_state_request_sent) {
-        rc = win32_openssh_recv_all(agent, buf, sizeof buf,
+        rc = win32_openssh_recv_all(agent, buf, sizeof(buf),
                                     &transctx->send_recv_total);
         if(rc == LIBSSH2_ERROR_EAGAIN)
             return LIBSSH2_ERROR_EAGAIN;
@@ -353,9 +340,10 @@ agent_disconnect_openssh(LIBSSH2_AGENT *agent)
     return LIBSSH2_ERROR_NONE;
 }
 
-struct agent_ops agent_ops_openssh = {
+static struct agent_ops agent_ops_openssh = {
     agent_connect_openssh,
     agent_transact_openssh,
     agent_disconnect_openssh
 };
-#endif  /* WIN32 */
+
+#endif /* HAVE_WIN32_AGENTS */
diff --git a/libssh2/src/bcrypt_pbkdf.c b/libssh2/src/bcrypt_pbkdf.c
index f782bcac..73cda435 100644
--- a/libssh2/src/bcrypt_pbkdf.c
+++ b/libssh2/src/bcrypt_pbkdf.c
@@ -1,6 +1,6 @@
 /* $OpenBSD: bcrypt_pbkdf.c,v 1.4 2013/07/29 00:55:53 tedu Exp $ */
 /*
- * Copyright (c) 2013 Ted Unangst <tedu@openbsd.org>
+ * Copyright (C) Ted Unangst <tedu@openbsd.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -13,21 +13,18 @@
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
  */
 
+#include "libssh2_priv.h"
 
 #ifndef HAVE_BCRYPT_PBKDF
 
-#include "libssh2_priv.h"
 #include <stdlib.h>
-#include <sys/types.h>
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
 
-#include "blf.h"
-
-#define MINIMUM(a,b) (((a) < (b)) ? (a) : (b))
+#define LIBSSH2_BCRYPT_PBKDF_C
+#include "blowfish.c"
 
 /*
  * pkcs #5 pbkdf2 implementation using the "bcrypt" hash
@@ -60,12 +57,15 @@ static void
 bcrypt_hash(uint8_t *sha2pass, uint8_t *sha2salt, uint8_t *out)
 {
     blf_ctx state;
-    uint8_t ciphertext[BCRYPT_HASHSIZE] =
-        "OxychromaticBlowfishSwatDynamite";
+    uint8_t ciphertext[BCRYPT_HASHSIZE] = {
+        'O', 'x', 'y', 'c', 'h', 'r', 'o', 'm', 'a', 't', 'i', 'c',
+        'B', 'l', 'o', 'w', 'f', 'i', 's', 'h',
+        'S', 'w', 'a', 't',
+        'D', 'y', 'n', 'a', 'm', 'i', 't', 'e' };
     uint32_t cdata[BCRYPT_BLOCKS];
     int i;
     uint16_t j;
-    size_t shalen = SHA512_DIGEST_LENGTH;
+    uint16_t shalen = SHA512_DIGEST_LENGTH;
 
     /* key expansion */
     Blowfish_initstate(&state);
@@ -85,7 +85,7 @@ bcrypt_hash(uint8_t *sha2pass, uint8_t *sha2salt, uint8_t *out)
 
     /* copy out */
     for(i = 0; i < BCRYPT_BLOCKS; i++) {
-        out[4 * i + 3] = (cdata[i] >> 24) & 0xff;
+        out[4 * i + 3] = (uint8_t)((cdata[i] >> 24) & 0xff);
         out[4 * i + 2] = (cdata[i] >> 16) & 0xff;
         out[4 * i + 1] = (cdata[i] >> 8) & 0xff;
         out[4 * i + 0] = cdata[i] & 0xff;
@@ -97,7 +97,7 @@ bcrypt_hash(uint8_t *sha2pass, uint8_t *sha2salt, uint8_t *out)
     _libssh2_explicit_zero(&state, sizeof(state));
 }
 
-int
+static int
 bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
              size_t saltlen,
              uint8_t *key, size_t keylen, unsigned int rounds)
@@ -116,10 +116,10 @@ bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
     if(rounds < 1)
         return -1;
     if(passlen == 0 || saltlen == 0 || keylen == 0 ||
-       keylen > sizeof(out) * sizeof(out) || saltlen > 1<<20)
+       keylen > sizeof(out) * sizeof(out) || saltlen > 1 << 20)
         return -1;
     countsalt = calloc(1, saltlen + 4);
-    if(countsalt == NULL)
+    if(!countsalt)
         return -1;
     stride = (keylen + sizeof(out) - 1) / sizeof(out);
     amt = (keylen + stride - 1) / stride;
@@ -127,30 +127,41 @@ bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
     memcpy(countsalt, salt, saltlen);
 
     /* collapse password */
-    libssh2_sha512_init(&ctx);
-    libssh2_sha512_update(ctx, pass, passlen);
-    libssh2_sha512_final(ctx, sha2pass);
+    if(!libssh2_sha512_init(&ctx) ||
+       !libssh2_sha512_update(ctx, pass, passlen) ||
+       !libssh2_sha512_final(ctx, sha2pass)) {
+        free(countsalt);
+        return -1;
+    }
 
     /* generate key, sizeof(out) at a time */
     for(count = 1; keylen > 0; count++) {
-        countsalt[saltlen + 0] = (count >> 24) & 0xff;
+        countsalt[saltlen + 0] = (uint8_t)((count >> 24) & 0xff);
         countsalt[saltlen + 1] = (count >> 16) & 0xff;
         countsalt[saltlen + 2] = (count >> 8) & 0xff;
         countsalt[saltlen + 3] = count & 0xff;
 
         /* first round, salt is salt */
-        libssh2_sha512_init(&ctx);
-        libssh2_sha512_update(ctx, countsalt, saltlen + 4);
-        libssh2_sha512_final(ctx, sha2salt);
+        if(!libssh2_sha512_init(&ctx) ||
+           !libssh2_sha512_update(ctx, countsalt, saltlen + 4) ||
+           !libssh2_sha512_final(ctx, sha2salt)) {
+            _libssh2_explicit_zero(out, sizeof(out));
+            free(countsalt);
+            return -1;
+        }
 
         bcrypt_hash(sha2pass, sha2salt, tmpout);
         memcpy(out, tmpout, sizeof(out));
 
         for(i = 1; i < rounds; i++) {
             /* subsequent rounds, salt is previous output */
-            libssh2_sha512_init(&ctx);
-            libssh2_sha512_update(ctx, tmpout, sizeof(tmpout));
-            libssh2_sha512_final(ctx, sha2salt);
+            if(!libssh2_sha512_init(&ctx) ||
+               !libssh2_sha512_update(ctx, tmpout, sizeof(tmpout)) ||
+               !libssh2_sha512_final(ctx, sha2salt)) {
+                _libssh2_explicit_zero(out, sizeof(out));
+                free(countsalt);
+                return -1;
+            }
 
             bcrypt_hash(sha2pass, sha2salt, tmpout);
             for(j = 0; j < sizeof(out); j++)
@@ -160,7 +171,7 @@ bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
         /*
          * pbkdf2 deviation: output the key material non-linearly.
          */
-        amt = MINIMUM(amt, keylen);
+        amt = LIBSSH2_MIN(amt, keylen);
         for(i = 0; i < amt; i++) {
             size_t dest = i * stride + (count - 1);
             if(dest >= origkeylen) {
@@ -178,3 +189,22 @@ bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
     return 0;
 }
 #endif /* HAVE_BCRYPT_PBKDF */
+
+/* Wrapper */
+
+int _libssh2_bcrypt_pbkdf(const char *pass,
+                          size_t passlen,
+                          const uint8_t *salt,
+                          size_t saltlen,
+                          uint8_t *key,
+                          size_t keylen,
+                          unsigned int rounds)
+{
+    return bcrypt_pbkdf(pass,
+                        passlen,
+                        salt,
+                        saltlen,
+                        key,
+                        keylen,
+                        rounds);
+}
diff --git a/libssh2/src/blf.h b/libssh2/src/blf.h
deleted file mode 100644
index 5b7c8aae..00000000
--- a/libssh2/src/blf.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef __LIBSSH2_BLF_H
-#define __LIBSSH2_BLF_H
-/* $OpenBSD: blf.h,v 1.7 2007/03/14 17:59:41 grunk Exp $ */
-/*
- * Blowfish - a fast block cipher designed by Bruce Schneier
- *
- * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
- * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-#if !defined(HAVE_BCRYPT_PBKDF) && !defined(HAVE_BLH_H)
-
-/* Schneier specifies a maximum key length of 56 bytes.
- * This ensures that every key bit affects every cipher
- * bit.  However, the subkeys can hold up to 72 bytes.
- * Warning: For normal blowfish encryption only 56 bytes
- * of the key affect all cipherbits.
- */
-
-#define BLF_N   16                      /* Number of Subkeys */
-#define BLF_MAXKEYLEN ((BLF_N-2)*4)     /* 448 bits */
-#define BLF_MAXUTILIZED ((BLF_N + 2)*4)   /* 576 bits */
-
-/* Blowfish context */
-typedef struct BlowfishContext {
-        uint32_t S[4][256];     /* S-Boxes */
-        uint32_t P[BLF_N + 2];  /* Subkeys */
-} blf_ctx;
-
-/* Raw access to customized Blowfish
- *      blf_key is just:
- *      Blowfish_initstate( state )
- *      Blowfish_expand0state( state, key, keylen )
- */
-
-void Blowfish_encipher(blf_ctx *, uint32_t *, uint32_t *);
-void Blowfish_decipher(blf_ctx *, uint32_t *, uint32_t *);
-void Blowfish_initstate(blf_ctx *);
-void Blowfish_expand0state(blf_ctx *, const uint8_t *, uint16_t);
-void Blowfish_expandstate
-(blf_ctx *, const uint8_t *, uint16_t, const uint8_t *, uint16_t);
-
-/* Standard Blowfish */
-
-void blf_key(blf_ctx *, const uint8_t *, uint16_t);
-void blf_enc(blf_ctx *, uint32_t *, uint16_t);
-void blf_dec(blf_ctx *, uint32_t *, uint16_t);
-
-void blf_ecb_encrypt(blf_ctx *, uint8_t *, uint32_t);
-void blf_ecb_decrypt(blf_ctx *, uint8_t *, uint32_t);
-
-void blf_cbc_encrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
-void blf_cbc_decrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
-
-/* Converts uint8_t to uint32_t */
-uint32_t Blowfish_stream2word(const uint8_t *, uint16_t, uint16_t *);
-
-/* bcrypt with pbkd */
-int bcrypt_pbkdf(const char *pass, size_t passlen, const uint8_t *salt,
-                 size_t saltlen,
-                 uint8_t *key, size_t keylen, unsigned int rounds);
-
-#endif /* !defined(HAVE_BCRYPT_PBKDF) && !defined(HAVE_BLH_H) */
-#endif /* __LIBSSH2_BLF_H */
diff --git a/libssh2/src/blowfish.c b/libssh2/src/blowfish.c
index 4aefc66a..5de54f59 100644
--- a/libssh2/src/blowfish.c
+++ b/libssh2/src/blowfish.c
@@ -1,7 +1,8 @@
 /* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */
 /*
- * Blowfish block cipher for OpenBSD
- * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * Blowfish for OpenBSD - a fast block cipher designed by Bruce Schneier
+ *
+ * Copyright (C) Niels Provos <provos@physnet.uni-hamburg.de>
  * All rights reserved.
  *
  * Implementation advice by David Mazieres <dm@lcs.mit.edu>.
@@ -14,10 +15,7 @@
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Niels Provos.
- * 4. The name of the author may not be used to endorse or promote products
+ * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
@@ -30,6 +28,8 @@
  * 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.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /*
@@ -39,38 +39,81 @@
  * Bruce Schneier.
  */
 
+#if defined(LIBSSH2_BCRYPT_PBKDF_C) || defined(_DEBUG_BLOWFISH)
 
 #if !defined(HAVE_BCRYPT_PBKDF) && (!defined(HAVE_BLOWFISH_INITSTATE) || \
                                     !defined(HAVE_BLOWFISH_EXPAND0STATE) || \
                                     !defined(HAVE_BLF_ENC))
 
-#if 0
-#include <stdio.h>              /* used for debugging */
+#ifdef _DEBUG_BLOWFISH
+#include <stdio.h>
 #include <string.h>
+#include <inttypes.h>
+#endif
+
+/* Schneier specifies a maximum key length of 56 bytes.
+ * This ensures that every key bit affects every cipher
+ * bit.  However, the subkeys can hold up to 72 bytes.
+ * Warning: For normal blowfish encryption only 56 bytes
+ * of the key affect all cipherbits.
+ */
+
+#define BLF_N   16                      /* Number of Subkeys */
+#define BLF_MAXKEYLEN ((BLF_N-2)*4)     /* 448 bits */
+#define BLF_MAXUTILIZED ((BLF_N + 2)*4)   /* 576 bits */
+
+/* Blowfish context */
+typedef struct BlowfishContext {
+    uint32_t S[4][256];     /* S-Boxes */
+    uint32_t P[BLF_N + 2];  /* Subkeys */
+} blf_ctx;
+
+/* Raw access to customized Blowfish
+ *      blf_key is just:
+ *      Blowfish_initstate( state )
+ *      Blowfish_expand0state( state, key, keylen )
+ */
+
+static void Blowfish_encipher(blf_ctx *, uint32_t *, uint32_t *);
+#ifdef _DEBUG_BLOWFISH
+static void Blowfish_decipher(blf_ctx *, uint32_t *, uint32_t *);
+#endif
+static void Blowfish_initstate(blf_ctx *);
+static void Blowfish_expand0state(blf_ctx *, const uint8_t *, uint16_t);
+static void Blowfish_expandstate
+(blf_ctx *, const uint8_t *, uint16_t, const uint8_t *, uint16_t);
+
+/* Standard Blowfish */
+
+#ifdef _DEBUG_BLOWFISH
+static void blf_key(blf_ctx *, const uint8_t *, uint16_t);
+#endif
+static void blf_enc(blf_ctx *, uint32_t *, uint16_t);
+#ifdef _DEBUG_BLOWFISH
+static void blf_dec(blf_ctx *, uint32_t *, uint16_t);
 #endif
 
-#include <sys/types.h>
+#if 0
+static void blf_ecb_encrypt(blf_ctx *, uint8_t *, uint32_t);
+static void blf_ecb_decrypt(blf_ctx *, uint8_t *, uint32_t);
 
-#include "libssh2.h"
-#include "blf.h"
+static void blf_cbc_encrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
+static void blf_cbc_decrypt(blf_ctx *, uint8_t *, uint8_t *, uint32_t);
+#endif
 
-#undef inline
-#ifdef __GNUC__
-#define inline __inline
-#else                           /* !__GNUC__ */
-#define inline
-#endif                          /* !__GNUC__ */
+/* Converts uint8_t to uint32_t */
+static uint32_t Blowfish_stream2word(const uint8_t *, uint16_t, uint16_t *);
 
 /* Function for Feistel Networks */
 
-#define F(s, x) ((((s)[        (((x)>>24)&0xFF)]        \
-                   + (s)[0x100 + (((x)>>16)&0xFF)])     \
-                  ^ (s)[0x200 + (((x)>> 8)&0xFF)])      \
-                 + (s)[0x300 + ( (x)     &0xFF)])
+#define F(s, x) ((((s)[        (((x) >> 24) & 0xFF)]      \
+                 + (s)[0x100 + (((x) >> 16) & 0xFF)])     \
+                 ^ (s)[0x200 + (((x) >>  8) & 0xFF)])     \
+                 + (s)[0x300 + ( (x)        & 0xFF)])
 
 #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
 
-void
+static void
 Blowfish_encipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
 {
     uint32_t Xl;
@@ -95,7 +138,8 @@ Blowfish_encipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
     *xr = Xl;
 }
 
-void
+#ifdef _DEBUG_BLOWFISH
+static void
 Blowfish_decipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
 {
     uint32_t Xl;
@@ -119,8 +163,9 @@ Blowfish_decipher(blf_ctx *c, uint32_t *xl, uint32_t *xr)
     *xl = Xr ^ p[0];
     *xr = Xl;
 }
+#endif
 
-void
+static void
 Blowfish_initstate(blf_ctx *c)
 {
     /* P-box and S-box tables initialized with digits of Pi */
@@ -399,7 +444,7 @@ Blowfish_initstate(blf_ctx *c)
     *c = initstate;
 }
 
-uint32_t
+static uint32_t
 Blowfish_stream2word(const uint8_t *data, uint16_t databytes,
                      uint16_t *current)
 {
@@ -420,12 +465,12 @@ Blowfish_stream2word(const uint8_t *data, uint16_t databytes,
     return temp;
 }
 
-void
+static void
 Blowfish_expand0state(blf_ctx *c, const uint8_t *key, uint16_t keybytes)
 {
-    uint16_t i;
+    int i;
+    int k;
     uint16_t j;
-    uint16_t k;
     uint32_t temp;
     uint32_t datal;
     uint32_t datar;
@@ -457,14 +502,13 @@ Blowfish_expand0state(blf_ctx *c, const uint8_t *key, uint16_t keybytes)
     }
 }
 
-
-void
+static void
 Blowfish_expandstate(blf_ctx *c, const uint8_t *data, uint16_t databytes,
                      const uint8_t *key, uint16_t keybytes)
 {
-    uint16_t i;
+    int i;
+    int k;
     uint16_t j;
-    uint16_t k;
     uint32_t temp;
     uint32_t datal;
     uint32_t datar;
@@ -501,7 +545,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8_t *data, uint16_t databytes,
 
 }
 
-void
+#ifdef _DEBUG_BLOWFISH
+static void
 blf_key(blf_ctx *c, const uint8_t *k, uint16_t len)
 {
     /* Initialize S-boxes and subkeys with Pi */
@@ -510,8 +555,9 @@ blf_key(blf_ctx *c, const uint8_t *k, uint16_t len)
     /* Transform S-boxes and subkeys with key */
     Blowfish_expand0state(c, k, len);
 }
+#endif
 
-void
+static void
 blf_enc(blf_ctx *c, uint32_t *data, uint16_t blocks)
 {
     uint32_t *d;
@@ -524,7 +570,8 @@ blf_enc(blf_ctx *c, uint32_t *data, uint16_t blocks)
     }
 }
 
-void
+#ifdef _DEBUG_BLOWFISH
+static void
 blf_dec(blf_ctx *c, uint32_t *data, uint16_t blocks)
 {
     uint32_t *d;
@@ -536,8 +583,10 @@ blf_dec(blf_ctx *c, uint32_t *data, uint16_t blocks)
         d += 2;
     }
 }
+#endif
 
-void
+#if 0
+static void
 blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
 {
     uint32_t l, r;
@@ -547,11 +596,11 @@ blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
         l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         Blowfish_encipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
+        data[0] = (uint8_t)(l >> 24 & 0xff);
         data[1] = l >> 16 & 0xff;
         data[2] = l >> 8 & 0xff;
         data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
+        data[4] = (uint8_t)(r >> 24 & 0xff);
         data[5] = r >> 16 & 0xff;
         data[6] = r >> 8 & 0xff;
         data[7] = r & 0xff;
@@ -559,7 +608,7 @@ blf_ecb_encrypt(blf_ctx *c, uint8_t *data, uint32_t len)
     }
 }
 
-void
+static void
 blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
 {
     uint32_t l, r;
@@ -569,11 +618,11 @@ blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
         l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         Blowfish_decipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
+        data[0] = (uint8_t)(l >> 24 & 0xff);
         data[1] = l >> 16 & 0xff;
         data[2] = l >> 8 & 0xff;
         data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
+        data[4] = (uint8_t)(r >> 24 & 0xff);
         data[5] = r >> 16 & 0xff;
         data[6] = r >> 8 & 0xff;
         data[7] = r & 0xff;
@@ -581,7 +630,7 @@ blf_ecb_decrypt(blf_ctx *c, uint8_t *data, uint32_t len)
     }
 }
 
-void
+static void
 blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
 {
     uint32_t l, r;
@@ -593,11 +642,11 @@ blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
         l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         Blowfish_encipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
+        data[0] = (uint8_t)(l >> 24 & 0xff);
         data[1] = l >> 16 & 0xff;
         data[2] = l >> 8 & 0xff;
         data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
+        data[4] = (uint8_t)(r >> 24 & 0xff);
         data[5] = r >> 16 & 0xff;
         data[6] = r >> 8 & 0xff;
         data[7] = r & 0xff;
@@ -606,7 +655,7 @@ blf_cbc_encrypt(blf_ctx *c, uint8_t *iv, uint8_t *data, uint32_t len)
     }
 }
 
-void
+static void
 blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
 {
     uint32_t l, r;
@@ -619,11 +668,11 @@ blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
         l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         Blowfish_decipher(c, &l, &r);
-        data[0] = l >> 24 & 0xff;
+        data[0] = (uint8_t)(l >> 24 & 0xff);
         data[1] = l >> 16 & 0xff;
         data[2] = l >> 8 & 0xff;
         data[3] = l & 0xff;
-        data[4] = r >> 24 & 0xff;
+        data[4] = (uint8_t)(r >> 24 & 0xff);
         data[5] = r >> 16 & 0xff;
         data[6] = r >> 8 & 0xff;
         data[7] = r & 0xff;
@@ -635,31 +684,31 @@ blf_cbc_decrypt(blf_ctx *c, uint8_t *iva, uint8_t *data, uint32_t len)
     l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
     r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
     Blowfish_decipher(c, &l, &r);
-    data[0] = l >> 24 & 0xff;
+    data[0] = (uint8_t)(l >> 24 & 0xff);
     data[1] = l >> 16 & 0xff;
     data[2] = l >> 8 & 0xff;
     data[3] = l & 0xff;
-    data[4] = r >> 24 & 0xff;
+    data[4] = (uint8_t)(r >> 24 & 0xff);
     data[5] = r >> 16 & 0xff;
     data[6] = r >> 8 & 0xff;
     data[7] = r & 0xff;
     for(j = 0; j < 8; j++)
         data[j] ^= iva[j];
 }
+#endif
 
-#if 0
-void
+#ifdef _DEBUG_BLOWFISH
+static void
 report(uint32_t data[], uint16_t len)
 {
-    uint16_t i;
+    int i;
     for(i = 0; i < len; i += 2)
-        printf("Block %0hd: %08lx %08lx.\n",
-               i / 2, data[i], data[i + 1]);
+        printf("Block %d: 0x%08lx 0x%08lx.\n",
+               i / 2, (unsigned long)data[i], (unsigned long)data[i + 1]);
 }
-void
+int
 main(void)
 {
-
     blf_ctx c;
     char    key[] = "AAAAA";
     char    key2[] = "abcdefghijklmnopqrstuvwxyz";
@@ -682,12 +731,15 @@ main(void)
     report(data, 10);
 
     /* Second test */
-    blf_key(&c, (uint8_t *) key2, strlen(key2));
+    blf_key(&c, (uint8_t *) key2, (uint16_t)strlen(key2));
     blf_enc(&c, data2, 1);
     printf("\nShould read as: 0x324ed0fe 0xf413a203.\n");
     report(data2, 2);
     blf_dec(&c, data2, 1);
+    printf("\nShould read as: 0x424c4f57 0x46495348.\n");
     report(data2, 2);
+
+    return 0;
 }
 #endif
 
@@ -695,3 +747,5 @@ main(void)
           (!defined(HAVE_BLOWFISH_INITSTATE) ||   \
           !defined(HAVE_BLOWFISH_EXPAND0STATE) || \
           '!defined(HAVE_BLF_ENC)) */
+
+#endif /* defined(LIBSSH2_BCRYPT_PBKDF_C) || defined(_DEBUG_BLOWFISH) */
diff --git a/libssh2/src/chacha.c b/libssh2/src/chacha.c
new file mode 100644
index 00000000..72560f86
--- /dev/null
+++ b/libssh2/src/chacha.c
@@ -0,0 +1,224 @@
+/*
+ * chacha-merged.c version 20080118
+ * D. J. Bernstein
+ * Public domain.
+ * Copyright not intended 2024.
+ *
+ * SPDX-License-Identifier: SAX-PD-2.0
+ */
+
+#include "libssh2_priv.h"
+
+#include "chacha.h"
+
+/* $OpenBSD: chacha.c,v 1.1 2013/11/21 00:45:44 djm Exp $ */
+
+typedef unsigned char u8;
+typedef unsigned int u32;
+
+typedef struct chacha_ctx chacha_ctx;
+
+#define U8C(v) (v##U)
+#define U32C(v) (v##U)
+
+#define U8V(v) ((u8)(v) & U8C(0xFF))
+#define U32V(v) ((u32)(v) & U32C(0xFFFFFFFF))
+
+#define ROTL32(v, n) \
+  (U32V((v) << (n)) | ((v) >> (32 - (n))))
+
+#define U8TO32_LITTLE(p) \
+  (((u32)((p)[0])      ) | \
+   ((u32)((p)[1]) <<  8) | \
+   ((u32)((p)[2]) << 16) | \
+   ((u32)((p)[3]) << 24))
+
+#define U32TO8_LITTLE(p, v) \
+  do { \
+    (p)[0] = U8V((v)      ); \
+    (p)[1] = U8V((v) >>  8); \
+    (p)[2] = U8V((v) >> 16); \
+    (p)[3] = U8V((v) >> 24); \
+  } while (0)
+
+#define ROTATE(v,c) (ROTL32(v,c))
+#define XOR(v,w) ((v) ^ (w))
+#define PLUS(v,w) (U32V((v) + (w)))
+#define PLUSONE(v) (PLUS((v),1))
+
+#define QUARTERROUND(a,b,c,d) \
+  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
+  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
+  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
+  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
+
+static const char sigma[17] = "expand 32-byte k";
+static const char tau[17] = "expand 16-byte k";
+
+void
+chacha_keysetup(chacha_ctx *x, const u8 *k, u32 kbits)
+{
+  const char *constants;
+
+  x->input[4] = U8TO32_LITTLE(k + 0);
+  x->input[5] = U8TO32_LITTLE(k + 4);
+  x->input[6] = U8TO32_LITTLE(k + 8);
+  x->input[7] = U8TO32_LITTLE(k + 12);
+  if(kbits == 256) { /* recommended */
+    k += 16;
+    constants = sigma;
+  }
+  else { /* kbits == 128 */
+    constants = tau;
+  }
+  x->input[8] = U8TO32_LITTLE(k + 0);
+  x->input[9] = U8TO32_LITTLE(k + 4);
+  x->input[10] = U8TO32_LITTLE(k + 8);
+  x->input[11] = U8TO32_LITTLE(k + 12);
+  x->input[0] = U8TO32_LITTLE(constants + 0);
+  x->input[1] = U8TO32_LITTLE(constants + 4);
+  x->input[2] = U8TO32_LITTLE(constants + 8);
+  x->input[3] = U8TO32_LITTLE(constants + 12);
+}
+
+void
+chacha_ivsetup(chacha_ctx *x, const u8 *iv, const u8 *counter)
+{
+  x->input[12] = counter == NULL ? 0 : U8TO32_LITTLE(counter + 0);
+  x->input[13] = counter == NULL ? 0 : U8TO32_LITTLE(counter + 4);
+  x->input[14] = U8TO32_LITTLE(iv + 0);
+  x->input[15] = U8TO32_LITTLE(iv + 4);
+}
+
+void
+chacha_encrypt_bytes(chacha_ctx *x, const u8 *m, u8 *c, u32 bytes)
+{
+  u32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
+  u32 j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
+  u8 *ctarget = NULL;
+  u8 tmp[64];
+  u_int i;
+
+  if(!bytes)
+      return;
+
+  j0 = x->input[0];
+  j1 = x->input[1];
+  j2 = x->input[2];
+  j3 = x->input[3];
+  j4 = x->input[4];
+  j5 = x->input[5];
+  j6 = x->input[6];
+  j7 = x->input[7];
+  j8 = x->input[8];
+  j9 = x->input[9];
+  j10 = x->input[10];
+  j11 = x->input[11];
+  j12 = x->input[12];
+  j13 = x->input[13];
+  j14 = x->input[14];
+  j15 = x->input[15];
+
+    for(;;) {
+        if(bytes < 64) {
+            for(i = 0; i < bytes;++i) tmp[i] = m[i];
+            m = tmp;
+            ctarget = c;
+            c = tmp;
+        }
+        x0 = j0;
+        x1 = j1;
+        x2 = j2;
+        x3 = j3;
+        x4 = j4;
+        x5 = j5;
+        x6 = j6;
+        x7 = j7;
+        x8 = j8;
+        x9 = j9;
+        x10 = j10;
+        x11 = j11;
+        x12 = j12;
+        x13 = j13;
+        x14 = j14;
+        x15 = j15;
+        for(i = 20; i > 0; i -= 2) {
+            QUARTERROUND(x0, x4, x8, x12)
+            QUARTERROUND(x1, x5, x9, x13)
+            QUARTERROUND(x2, x6, x10, x14)
+            QUARTERROUND(x3, x7, x11, x15)
+            QUARTERROUND(x0, x5, x10, x15)
+            QUARTERROUND(x1, x6, x11, x12)
+            QUARTERROUND(x2, x7, x8, x13)
+            QUARTERROUND(x3, x4, x9, x14)
+        }
+        x0 = PLUS(x0, j0);
+        x1 = PLUS(x1, j1);
+        x2 = PLUS(x2, j2);
+        x3 = PLUS(x3, j3);
+        x4 = PLUS(x4, j4);
+        x5 = PLUS(x5, j5);
+        x6 = PLUS(x6, j6);
+        x7 = PLUS(x7, j7);
+        x8 = PLUS(x8, j8);
+        x9 = PLUS(x9, j9);
+        x10 = PLUS(x10, j10);
+        x11 = PLUS(x11, j11);
+        x12 = PLUS(x12, j12);
+        x13 = PLUS(x13, j13);
+        x14 = PLUS(x14, j14);
+        x15 = PLUS(x15, j15);
+
+        x0 = XOR(x0, U8TO32_LITTLE(m + 0));
+        x1 = XOR(x1, U8TO32_LITTLE(m + 4));
+        x2 = XOR(x2, U8TO32_LITTLE(m + 8));
+        x3 = XOR(x3, U8TO32_LITTLE(m + 12));
+        x4 = XOR(x4, U8TO32_LITTLE(m + 16));
+        x5 = XOR(x5, U8TO32_LITTLE(m + 20));
+        x6 = XOR(x6, U8TO32_LITTLE(m + 24));
+        x7 = XOR(x7, U8TO32_LITTLE(m + 28));
+        x8 = XOR(x8, U8TO32_LITTLE(m + 32));
+        x9 = XOR(x9, U8TO32_LITTLE(m + 36));
+        x10 = XOR(x10, U8TO32_LITTLE(m + 40));
+        x11 = XOR(x11, U8TO32_LITTLE(m + 44));
+        x12 = XOR(x12, U8TO32_LITTLE(m + 48));
+        x13 = XOR(x13, U8TO32_LITTLE(m + 52));
+        x14 = XOR(x14, U8TO32_LITTLE(m + 56));
+        x15 = XOR(x15, U8TO32_LITTLE(m + 60));
+
+        j12 = PLUSONE(j12);
+        if(!j12) {
+            j13 = PLUSONE(j13);
+            /* stopping at 2^70 bytes per nonce is user's responsibility */
+        }
+
+        U32TO8_LITTLE(c + 0, x0);
+        U32TO8_LITTLE(c + 4, x1);
+        U32TO8_LITTLE(c + 8, x2);
+        U32TO8_LITTLE(c + 12, x3);
+        U32TO8_LITTLE(c + 16, x4);
+        U32TO8_LITTLE(c + 20, x5);
+        U32TO8_LITTLE(c + 24, x6);
+        U32TO8_LITTLE(c + 28, x7);
+        U32TO8_LITTLE(c + 32, x8);
+        U32TO8_LITTLE(c + 36, x9);
+        U32TO8_LITTLE(c + 40, x10);
+        U32TO8_LITTLE(c + 44, x11);
+        U32TO8_LITTLE(c + 48, x12);
+        U32TO8_LITTLE(c + 52, x13);
+        U32TO8_LITTLE(c + 56, x14);
+        U32TO8_LITTLE(c + 60, x15);
+
+        if(bytes <= 64) {
+            if(bytes < 64) {
+                for(i = 0; i < bytes;++i) ctarget[i] = c[i];
+            }
+            x->input[12] = j12;
+            x->input[13] = j13;
+            return;
+        }
+        bytes -= 64;
+        c += 64;
+        m += 64;
+    }
+}
diff --git a/libssh2/src/chacha.h b/libssh2/src/chacha.h
new file mode 100644
index 00000000..b17ecd5c
--- /dev/null
+++ b/libssh2/src/chacha.h
@@ -0,0 +1,33 @@
+/* $OpenBSD: chacha.h,v 1.4 2016/08/27 04:04:56 guenther Exp $ */
+
+/*
+ * chacha-merged.c version 20080118
+ * D. J. Bernstein
+ * Public domain.
+ * Copyright not intended 2024.
+ *
+ * SPDX-License-Identifier: SAX-PD-2.0
+ */
+
+#ifndef CHACHA_H
+#define CHACHA_H
+
+#include <stdlib.h>
+
+struct chacha_ctx {
+    u_int input[16];
+};
+
+#define CHACHA_MINKEYLEN    16
+#define CHACHA_NONCELEN     8
+#define CHACHA_CTRLEN       8
+#define CHACHA_STATELEN     (CHACHA_NONCELEN+CHACHA_CTRLEN)
+#define CHACHA_BLOCKLEN     64
+
+void chacha_keysetup(struct chacha_ctx *x, const u_char *k, u_int kbits);
+void chacha_ivsetup(struct chacha_ctx *x, const u_char *iv, const u_char *ctr);
+void chacha_encrypt_bytes(struct chacha_ctx *x, const u_char *m,
+                          u_char *c, u_int bytes);
+
+#endif /* CHACHA_H */
+
diff --git a/libssh2/src/channel.c b/libssh2/src/channel.c
index 78ed40e8..529c2ef8 100644
--- a/libssh2/src/channel.c
+++ b/libssh2/src/channel.c
@@ -1,7 +1,6 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2008-2019 by Daniel Stenberg
- *
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Mikhail Gusarov <dottedmag@dottedmag.net>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -36,16 +35,19 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
+
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#include <fcntl.h>
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
+
 #include <assert.h>
 
 #include "channel.h"
@@ -81,8 +83,8 @@ _libssh2_channel_nextid(LIBSSH2_SESSION * session)
      * told...
      */
     session->next_channel = id + 1;
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Allocated new channel ID#%lu",
-                   id);
+    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                   "Allocated new channel ID#%u", id));
     return id;
 }
 
@@ -154,9 +156,9 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         memset(&session->open_packet_requirev_state, 0,
                sizeof(session->open_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                        "Opening Channel - win %d pack %d", window_size,
-                       packet_size);
+                       packet_size));
         session->open_channel =
             LIBSSH2_CALLOC(session, sizeof(LIBSSH2_CHANNEL));
         if(!session->open_channel) {
@@ -262,15 +264,15 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
                 _libssh2_ntohu32(session->open_data + 9);
             session->open_channel->local.packet_size =
                 _libssh2_ntohu32(session->open_data + 13);
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Connection Established - ID: %lu/%lu win: %lu/%lu"
-                           " pack: %lu/%lu",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "Connection Established - ID: %u/%u win: %u/%u"
+                           " pack: %u/%u",
                            session->open_channel->local.id,
                            session->open_channel->remote.id,
                            session->open_channel->local.window_size,
                            session->open_channel->remote.window_size,
                            session->open_channel->local.packet_size,
-                           session->open_channel->remote.packet_size);
+                           session->open_channel->remote.packet_size));
             LIBSSH2_FREE(session, session->open_packet);
             session->open_packet = NULL;
             LIBSSH2_FREE(session, session->open_data);
@@ -308,7 +310,7 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         }
     }
 
-  channel_error:
+channel_error:
 
     if(session->open_data) {
         LIBSSH2_FREE(session, session->open_data);
@@ -327,14 +329,14 @@ _libssh2_channel_open(LIBSSH2_SESSION * session, const char *channel_type,
         /* Clear out packets meant for this channel */
         _libssh2_htonu32(channel_id, session->open_channel->local.id);
         while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA,
-                                    &session->open_data,
-                                    &session->open_data_len, 1,
-                                    channel_id, 4) >= 0)
-               ||
-               (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA,
-                                    &session->open_data,
-                                    &session->open_data_len, 1,
-                                    channel_id, 4) >= 0)) {
+                                   &session->open_data,
+                                   &session->open_data_len, 1,
+                                   channel_id, 4) >= 0)
+              ||
+              (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA,
+                                   &session->open_data,
+                                   &session->open_data_len, 1,
+                                   channel_id, 4) >= 0)) {
             LIBSSH2_FREE(session, session->open_data);
             session->open_data = NULL;
         }
@@ -390,9 +392,9 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
         session->direct_message_len =
             session->direct_host_len + session->direct_shost_len + 16;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                        "Requesting direct-tcpip session from %s:%d to %s:%d",
-                       shost, sport, host, port);
+                       shost, sport, host, port));
 
         s = session->direct_message =
             LIBSSH2_ALLOC(session, session->direct_message_len);
@@ -452,6 +454,85 @@ libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
     return ptr;
 }
 
+/*
+ * libssh2_channel_direct_streamlocal_ex
+ *
+ * Tunnel TCP/IP connect through the SSH session to direct UNIX socket
+ */
+static LIBSSH2_CHANNEL *
+channel_direct_streamlocal(LIBSSH2_SESSION * session, const char *socket_path,
+                           const char *shost, int sport)
+{
+    LIBSSH2_CHANNEL *channel;
+    unsigned char *s;
+
+    if(session->direct_state == libssh2_NB_state_idle) {
+        session->direct_host_len = strlen(socket_path);
+        session->direct_shost_len = strlen(shost);
+        session->direct_message_len =
+            session->direct_host_len + session->direct_shost_len + 12;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Requesting direct-streamlocal session to %s",
+                       socket_path));
+
+        s = session->direct_message =
+            LIBSSH2_ALLOC(session, session->direct_message_len);
+        if(!session->direct_message) {
+            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                "Unable to allocate memory for direct-streamlocal connection");
+            return NULL;
+        }
+        _libssh2_store_str(&s, socket_path, session->direct_host_len);
+        _libssh2_store_str(&s, shost, session->direct_shost_len);
+        _libssh2_store_u32(&s, sport);
+    }
+
+    channel =
+        _libssh2_channel_open(session, "direct-streamlocal@openssh.com",
+                              sizeof("direct-streamlocal@openssh.com") - 1,
+                              LIBSSH2_CHANNEL_WINDOW_DEFAULT,
+                              LIBSSH2_CHANNEL_PACKET_DEFAULT,
+                              session->direct_message,
+                              session->direct_message_len);
+
+    if(!channel &&
+        libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
+        /* The error code is still set to LIBSSH2_ERROR_EAGAIN, set our state
+           to created to avoid re-creating the package on next invoke */
+        session->direct_state = libssh2_NB_state_created;
+        return NULL;
+    }
+    /* by default we set (keep?) idle state... */
+    session->direct_state = libssh2_NB_state_idle;
+
+    LIBSSH2_FREE(session, session->direct_message);
+    session->direct_message = NULL;
+
+    return channel;
+}
+
+/*
+ * libssh2_channel_direct_streamlocal_ex
+ *
+ * Tunnel TCP/IP connect through the SSH session to direct UNIX socket
+ */
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_channel_direct_streamlocal_ex(LIBSSH2_SESSION * session,
+                                      const char *socket_path,
+                                      const char *shost, int sport)
+{
+    LIBSSH2_CHANNEL *ptr;
+
+    if(!session)
+        return NULL;
+
+    BLOCK_ADJUST_ERRNO(ptr, session,
+                       channel_direct_streamlocal(session,
+                       socket_path, shost, sport));
+    return ptr;
+}
+
 /*
  * channel_forward_listen
  *
@@ -470,19 +551,20 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
         host = "0.0.0.0";
 
     if(session->fwdLstn_state == libssh2_NB_state_idle) {
-        session->fwdLstn_host_len = strlen(host);
+        session->fwdLstn_host_len = (uint32_t)strlen(host);
         /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4)
            + port(4) */
         session->fwdLstn_packet_len =
-            session->fwdLstn_host_len + (sizeof("tcpip-forward") - 1) + 14;
+            session->fwdLstn_host_len +
+            (uint32_t)(sizeof("tcpip-forward") - 1) + 14;
 
         /* Zero the whole thing out */
         memset(&session->fwdLstn_packet_requirev_state, 0,
                sizeof(session->fwdLstn_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                        "Requesting tcpip-forward session for %s:%d", host,
-                       port);
+                       port));
 
         s = session->fwdLstn_packet =
             LIBSSH2_ALLOC(session, session->fwdLstn_packet_len);
@@ -567,10 +649,10 @@ channel_forward_listen(LIBSSH2_SESSION * session, const char *host,
                     listener->host[session->fwdLstn_host_len] = 0;
                     if(data_len >= 5 && !port) {
                         listener->port = _libssh2_ntohu32(data + 1);
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+                        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                                        "Dynamic tcpip-forward port "
                                        "allocated: %d",
-                                       listener->port);
+                                       listener->port));
                     }
                     else
                         listener->port = port;
@@ -647,9 +729,9 @@ int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
     int retcode = 0;
 
     if(listener->chanFwdCncl_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                        "Cancelling tcpip-forward session for %s:%d",
-                       listener->host, listener->port);
+                       listener->host, listener->port));
 
         s = packet = LIBSSH2_ALLOC(session, packet_len);
         if(!packet) {
@@ -818,10 +900,10 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
         memset(&channel->setenv_packet_requirev_state, 0,
                sizeof(channel->setenv_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                        "Setting remote environment variable: %s=%s on "
-                       "channel %lu/%lu",
-                       varname, value, channel->local.id, channel->remote.id);
+                       "channel %u/%u",
+                       varname, value, channel->local.id, channel->remote.id));
 
         s = channel->setenv_packet =
             LIBSSH2_ALLOC(session, channel->setenv_packet_len);
@@ -877,7 +959,9 @@ static int channel_setenv(LIBSSH2_CHANNEL *channel,
         }
         if(rc) {
             channel->setenv_state = libssh2_NB_state_idle;
-            return rc;
+            return _libssh2_error(session, rc,
+                                  "Failed getting response for "
+                                  "channel-setenv");
         }
         else if(data_len < 1) {
             channel->setenv_state = libssh2_NB_state_idle;
@@ -951,9 +1035,9 @@ static int channel_request_pty(LIBSSH2_CHANNEL *channel,
         memset(&channel->reqPTY_packet_requirev_state, 0,
                sizeof(channel->reqPTY_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Allocating tty on channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Allocating tty on channel %u/%u", channel->local.id,
+                       channel->remote.id));
 
         s = channel->reqPTY_packet;
 
@@ -1054,9 +1138,9 @@ static int channel_request_auth_agent(LIBSSH2_CHANNEL *channel,
         memset(&channel->req_auth_agent_requirev_state, 0,
                sizeof(channel->req_auth_agent_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting auth agent on channel %lu/%lu",
-                       channel->local.id, channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Requesting auth agent on channel %u/%u",
+                       channel->local.id, channel->remote.id));
 
         /*
          *  byte      SSH_MSG_CHANNEL_REQUEST
@@ -1083,6 +1167,7 @@ static int channel_request_auth_agent(LIBSSH2_CHANNEL *channel,
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, rc,
                            "Would block sending auth-agent request");
+            return rc;
         }
         else if(rc) {
             channel->req_auth_agent_state = libssh2_NB_state_idle;
@@ -1099,10 +1184,10 @@ static int channel_request_auth_agent(LIBSSH2_CHANNEL *channel,
         size_t data_len;
         unsigned char code;
 
-        rc = _libssh2_packet_requirev(
-            session, reply_codes, &data, &data_len, 1,
-            channel->req_auth_agent_local_channel,
-            4, &channel->req_auth_agent_requirev_state);
+        rc = _libssh2_packet_requirev(session, reply_codes, &data, &data_len,
+                                      1, channel->req_auth_agent_local_channel,
+                                      4,
+                                      &channel->req_auth_agent_requirev_state);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
         }
@@ -1125,13 +1210,14 @@ static int channel_request_auth_agent(LIBSSH2_CHANNEL *channel,
                           "Unable to complete request for auth-agent");
 }
 
-/**
+/*
  * libssh2_channel_request_auth_agent
+ *
  * Requests that agent forwarding be enabled for the session. The
  * request must be sent over a specific channel, which starts the agent
  * listener on the remote side. Once the channel is closed, the agent
  * listener continues to exist.
- * */
+ */
 LIBSSH2_API int
 libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel)
 {
@@ -1140,6 +1226,8 @@ libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel)
     if(!channel)
         return LIBSSH2_ERROR_BAD_USE;
 
+    rc = LIBSSH2_ERROR_CHANNEL_UNKNOWN;
+
     /* The current RFC draft for agent forwarding says you're supposed to
      * send "auth-agent-req," but most SSH servers out there right now
      * actually expect "auth-agent-req@openssh.com", so we try that
@@ -1152,7 +1240,8 @@ libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel)
 
         /* If we failed (but not with EAGAIN), then we move onto
          * the next step to try another request type. */
-        if(rc != 0 && rc != LIBSSH2_ERROR_EAGAIN)
+        if(rc != LIBSSH2_ERROR_NONE &&
+           rc != LIBSSH2_ERROR_EAGAIN)
             channel->req_auth_agent_try_state = libssh2_NB_state_sent;
     }
 
@@ -1163,12 +1252,13 @@ libssh2_channel_request_auth_agent(LIBSSH2_CHANNEL *channel)
 
         /* If we failed without an EAGAIN, then move on with this
          * state machine. */
-        if(rc != 0 && rc != LIBSSH2_ERROR_EAGAIN)
+        if(rc != LIBSSH2_ERROR_NONE &&
+           rc != LIBSSH2_ERROR_EAGAIN)
             channel->req_auth_agent_try_state = libssh2_NB_state_sent1;
     }
 
     /* If things are good, reset the try state. */
-    if(rc == 0)
+    if(rc == LIBSSH2_ERROR_NONE)
         channel->req_auth_agent_try_state = libssh2_NB_state_idle;
 
     return rc;
@@ -1212,10 +1302,10 @@ channel_request_pty_size(LIBSSH2_CHANNEL * channel, int width,
         memset(&channel->reqPTY_packet_requirev_state, 0,
                sizeof(channel->reqPTY_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-            "changing tty size on channel %lu/%lu",
-            channel->local.id,
-            channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "changing tty size on channel %u/%u",
+                       channel->local.id,
+                       channel->remote.id));
 
         s = channel->reqPTY_packet;
 
@@ -1301,13 +1391,13 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         memset(&channel->reqX11_packet_requirev_state, 0,
                sizeof(channel->reqX11_packet_requirev_state));
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Requesting x11-req for channel %lu/%lu: single=%d "
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Requesting x11-req for channel %u/%u: single=%d "
                        "proto=%s cookie=%s screen=%d",
                        channel->local.id, channel->remote.id,
                        single_connection,
                        auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
-                       auth_cookie ? auth_cookie : "<random>", screen_number);
+                       auth_cookie ? auth_cookie : "<random>", screen_number));
 
         s = channel->reqX11_packet =
             LIBSSH2_ALLOC(session, channel->reqX11_packet_len);
@@ -1326,7 +1416,7 @@ channel_x11_req(LIBSSH2_CHANNEL *channel, int single_connection,
         _libssh2_store_str(&s, auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
                            proto_len);
 
-        _libssh2_store_u32(&s, cookie_len);
+        _libssh2_store_u32(&s, (uint32_t)cookie_len);
         if(auth_cookie) {
             memcpy(s, auth_cookie, cookie_len);
         }
@@ -1459,10 +1549,10 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         if(message)
             channel->process_packet_len += + 4;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "starting request(%s) on channel %lu/%lu, message=%s",
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "starting request(%s) on channel %u/%u, message=%s",
                        request, channel->local.id, channel->remote.id,
-                       message ? message : "<null>");
+                       message ? message : "<null>"));
         s = channel->process_packet =
             LIBSSH2_ALLOC(session, channel->process_packet_len);
         if(!channel->process_packet)
@@ -1476,7 +1566,7 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         *(s++) = 0x01;
 
         if(message)
-            _libssh2_store_u32(&s, message_len);
+            _libssh2_store_u32(&s, (uint32_t)message_len);
 
         channel->process_state = libssh2_NB_state_created;
     }
@@ -1567,7 +1657,7 @@ LIBSSH2_API void
 libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking)
 {
     if(channel)
-        (void) _libssh2_session_set_blocking(channel->session, blocking);
+        (void)_libssh2_session_set_blocking(channel->session, blocking);
 }
 
 /*
@@ -1591,8 +1681,8 @@ _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
 
             if(packet->data_len < 1) {
                 packet = next;
-                _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                               "Unexpected packet length");
+                _libssh2_debug((channel->session, LIBSSH2_TRACE_ERROR,
+                               "Unexpected packet length"));
                 continue;
             }
 
@@ -1628,11 +1718,11 @@ _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
                     size_t bytes_to_flush = packet->data_len -
                         packet->data_head;
 
-                    _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                                   "Flushing %d bytes of data from stream "
-                                   "%lu on channel %lu/%lu",
-                                   bytes_to_flush, packet_stream_id,
-                                   channel->local.id, channel->remote.id);
+                    _libssh2_debug((channel->session, LIBSSH2_TRACE_CONN,
+                                   "Flushing %ld bytes of data from stream "
+                                   "%d on channel %u/%u",
+                                   (long)bytes_to_flush, packet_stream_id,
+                                   channel->local.id, channel->remote.id));
 
                     /* It's one of the streams we wanted to flush */
                     channel->flush_refund_bytes += packet->data_len - 13;
@@ -1652,20 +1742,20 @@ _libssh2_channel_flush(LIBSSH2_CHANNEL *channel, int streamid)
     }
 
     channel->read_avail -= channel->flush_flush_bytes;
-    channel->remote.window_size -= channel->flush_flush_bytes;
+    channel->remote.window_size -= (uint32_t)channel->flush_flush_bytes;
 
     if(channel->flush_refund_bytes) {
         int rc =
             _libssh2_channel_receive_window_adjust(channel,
-                                                   channel->flush_refund_bytes,
-                                                   1, NULL);
+                                         (uint32_t)channel->flush_refund_bytes,
+                                         1, NULL);
         if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
     }
 
     channel->flush_state = libssh2_NB_state_idle;
 
-    return channel->flush_flush_bytes;
+    return (int)channel->flush_flush_bytes;
 }
 
 /*
@@ -1734,7 +1824,7 @@ libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel,
                 *exitsignal = LIBSSH2_ALLOC(session, namelen + 1);
                 if(!*exitsignal) {
                     return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                        "Unable to allocate memory for signal name");
+                                  "Unable to allocate memory for signal name");
                 }
                 memcpy(*exitsignal, channel->exit_signal, namelen);
                 (*exitsignal)[namelen] = '\0';
@@ -1791,10 +1881,10 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
         if(!force
             && (adjustment + channel->adjust_queue <
                 LIBSSH2_CHANNEL_MINADJUST)) {
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                           "Queueing %lu bytes for receive window adjustment "
-                           "for channel %lu/%lu",
-                           adjustment, channel->local.id, channel->remote.id);
+            _libssh2_debug((channel->session, LIBSSH2_TRACE_CONN,
+                           "Queueing %u bytes for receive window adjustment "
+                           "for channel %u/%u",
+                           adjustment, channel->local.id, channel->remote.id));
             channel->adjust_queue += adjustment;
             return 0;
         }
@@ -1810,10 +1900,10 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
         channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
         _libssh2_htonu32(&channel->adjust_adjust[1], channel->remote.id);
         _libssh2_htonu32(&channel->adjust_adjust[5], adjustment);
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Adjusting window %lu bytes for data on "
-                       "channel %lu/%lu",
-                       adjustment, channel->local.id, channel->remote.id);
+        _libssh2_debug((channel->session, LIBSSH2_TRACE_CONN,
+                       "Adjusting window %u bytes for data on "
+                       "channel %u/%u",
+                       adjustment, channel->local.id, channel->remote.id));
 
         channel->adjust_state = libssh2_NB_state_created;
     }
@@ -1840,10 +1930,9 @@ _libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
     return 0;
 }
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /*
- * libssh2_channel_receive_window_adjust
- *
- * DEPRECATED
+ * libssh2_channel_receive_window_adjust (DEPRECATED, DO NOT USE!)
  *
  * Adjust the receive window for a channel by adjustment bytes. If the amount
  * to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and force is 0 the
@@ -1865,13 +1954,15 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
         return (unsigned long)LIBSSH2_ERROR_BAD_USE;
 
     BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_receive_window_adjust(channel, adj,
+                 _libssh2_channel_receive_window_adjust(channel,
+                                                        (uint32_t)adj,
                                                         force, &window));
 
     /* stupid - but this is how it was made to work before and this is just
        kept for backwards compatibility */
     return rc ? (unsigned long)rc : window;
 }
+#endif
 
 /*
  * libssh2_channel_receive_window_adjust2
@@ -1896,8 +1987,9 @@ libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
         return LIBSSH2_ERROR_BAD_USE;
 
     BLOCK_ADJUST(rc, channel->session,
-                 _libssh2_channel_receive_window_adjust(channel, adj, force,
-                                                        window));
+                 _libssh2_channel_receive_window_adjust(channel,
+                                                        (uint32_t)adj,
+                                                        force, window));
     return rc;
 }
 
@@ -1905,10 +1997,10 @@ int
 _libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
 {
     if(channel->extData2_state == libssh2_NB_state_idle) {
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Setting channel %lu/%lu handle_extended_data"
+        _libssh2_debug((channel->session, LIBSSH2_TRACE_CONN,
+                       "Setting channel %u/%u handle_extended_data"
                        " mode to %d",
-                       channel->local.id, channel->remote.id, ignore_mode);
+                       channel->local.id, channel->remote.id, ignore_mode));
         channel->remote.extended_data_ignore_mode = (char)ignore_mode;
 
         channel->extData2_state = libssh2_NB_state_created;
@@ -1929,7 +2021,7 @@ _libssh2_channel_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
 }
 
 /*
- * libssh2_channel_handle_extended_data2()
+ * libssh2_channel_handle_extended_data2
  *
  */
 LIBSSH2_API int
@@ -1946,10 +2038,9 @@ libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
     return rc;
 }
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /*
- * libssh2_channel_handle_extended_data
- *
- * DEPRECATED DO NOTE USE!
+ * libssh2_channel_handle_extended_data (DEPRECATED, DO NOT USE!)
  *
  * How should extended data look to the calling app?  Keep it in separate
  * channels[_read() _read_stdder()]? (NORMAL) Merge the extended data to the
@@ -1962,7 +2053,7 @@ libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
 {
     (void)libssh2_channel_handle_extended_data2(channel, ignore_mode);
 }
-
+#endif
 
 
 /*
@@ -1988,19 +2079,19 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
     LIBSSH2_PACKET *read_packet;
     LIBSSH2_PACKET *read_next;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "channel_read() wants %d bytes from channel %lu/%lu "
+    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                   "channel_read() wants %ld bytes from channel %u/%u "
                    "stream #%d",
-                   (int) buflen, channel->local.id, channel->remote.id,
-                   stream_id);
+                   (long)buflen, channel->local.id, channel->remote.id,
+                   stream_id));
 
     /* expand the receiving window first if it has become too narrow */
     if((channel->read_state == libssh2_NB_state_jump1) ||
        (channel->remote.window_size <
-        channel->remote.window_size_initial / 4 * 3 + buflen) ) {
+        channel->remote.window_size_initial / 4 * 3 + buflen)) {
 
-        uint32_t adjustment = channel->remote.window_size_initial + buflen -
-            channel->remote.window_size;
+        uint32_t adjustment = (uint32_t)(channel->remote.window_size_initial +
+            buflen - channel->remote.window_size);
         if(adjustment < LIBSSH2_CHANNEL_MINADJUST)
             adjustment = LIBSSH2_CHANNEL_MINADJUST;
 
@@ -2041,8 +2132,13 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
 
         if(readpkt->data_len < 5) {
             read_packet = read_next;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
+
+            if(readpkt->data_len != 1 ||
+                readpkt->data[0] != SSH_MSG_REQUEST_FAILURE) {
+                _libssh2_debug((channel->session, LIBSSH2_TRACE_ERROR,
+                               "Unexpected packet length"));
+            }
+
             continue;
         }
 
@@ -2080,11 +2176,11 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
                 unlink_packet = TRUE;
             }
 
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "channel_read() got %d of data from %lu/%lu/%d%s",
-                           bytes_want, channel->local.id,
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "channel_read() got %ld of data from %u/%u/%d%s",
+                           (long)bytes_want, channel->local.id,
                            channel->remote.id, stream_id,
-                           unlink_packet?" [ul]":"");
+                           unlink_packet ? " [ul]" : ""));
 
             /* copy data from this struct to the target buffer */
             memcpy(&buf[bytes_read],
@@ -2123,7 +2219,7 @@ ssize_t _libssh2_channel_read(LIBSSH2_CHANNEL *channel, int stream_id,
     }
 
     channel->read_avail -= bytes_read;
-    channel->remote.window_size -= bytes_read;
+    channel->remote.window_size -= (uint32_t)bytes_read;
 
     return bytes_read;
 }
@@ -2146,7 +2242,7 @@ LIBSSH2_API ssize_t
 libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf,
                         size_t buflen)
 {
-    int rc;
+    ssize_t rc;
     unsigned long recv_window;
 
     if(!channel)
@@ -2156,8 +2252,8 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf,
 
     if(buflen > recv_window) {
         BLOCK_ADJUST(rc, channel->session,
-                     _libssh2_channel_receive_window_adjust(channel, buflen,
-                                                            1, NULL));
+                     _libssh2_channel_receive_window_adjust(channel,
+                                                   (uint32_t)buflen, 1, NULL));
     }
 
     BLOCK_ADJUST(rc, channel->session,
@@ -2180,7 +2276,7 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
     uint32_t read_local_id;
 
     read_packet = _libssh2_list_first(&session->packets);
-    if(read_packet == NULL)
+    if(!read_packet)
         return 0;
 
     while(read_packet) {
@@ -2189,8 +2285,8 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
 
         if(read_packet->data_len < 5) {
             read_packet = next_packet;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
+            _libssh2_debug((channel->session, LIBSSH2_TRACE_ERROR,
+                           "Unexpected packet length"));
             continue;
         }
 
@@ -2218,7 +2314,7 @@ _libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
              && (channel->local.id == read_local_id)
              && (channel->remote.extended_data_ignore_mode
                  == LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
-            return (read_packet->data_len - read_packet->data_head);
+            return read_packet->data_len - read_packet->data_head;
         }
 
         read_packet = next_packet;
@@ -2258,15 +2354,15 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
     if(channel->write_state == libssh2_NB_state_idle) {
         unsigned char *s = channel->write_packet;
 
-        _libssh2_debug(channel->session, LIBSSH2_TRACE_CONN,
-                       "Writing %d bytes on channel %lu/%lu, stream #%d",
-                       (int) buflen, channel->local.id, channel->remote.id,
-                       stream_id);
+        _libssh2_debug((channel->session, LIBSSH2_TRACE_CONN,
+                       "Writing %ld bytes on channel %u/%u, stream #%d",
+                       (long)buflen, channel->local.id, channel->remote.id,
+                       stream_id));
 
         if(channel->local.close)
             return _libssh2_error(channel->session,
                                   LIBSSH2_ERROR_CHANNEL_CLOSED,
-                                  "We've already closed this channel");
+                                  "We have already closed this channel");
         else if(channel->local.eof)
             return _libssh2_error(channel->session,
                                   LIBSSH2_ERROR_CHANNEL_EOF_SENT,
@@ -2293,7 +2389,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
              */
             session->socket_block_directions = LIBSSH2_SESSION_BLOCK_INBOUND;
 
-            return (rc == LIBSSH2_ERROR_EAGAIN?rc:0);
+            return rc == LIBSSH2_ERROR_EAGAIN ? rc : 0;
         }
 
         channel->write_bufwrite = buflen;
@@ -2307,30 +2403,30 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
         /* Don't exceed the remote end's limits */
         /* REMEMBER local means local as the SOURCE of the data */
         if(channel->write_bufwrite > channel->local.window_size) {
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Splitting write block due to %lu byte "
-                           "window_size on %lu/%lu/%d",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "Splitting write block due to %u byte "
+                           "window_size on %u/%u/%d",
                            channel->local.window_size, channel->local.id,
-                           channel->remote.id, stream_id);
+                           channel->remote.id, stream_id));
             channel->write_bufwrite = channel->local.window_size;
         }
         if(channel->write_bufwrite > channel->local.packet_size) {
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Splitting write block due to %lu byte "
-                           "packet_size on %lu/%lu/%d",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "Splitting write block due to %u byte "
+                           "packet_size on %u/%u/%d",
                            channel->local.packet_size, channel->local.id,
-                           channel->remote.id, stream_id);
+                           channel->remote.id, stream_id));
             channel->write_bufwrite = channel->local.packet_size;
         }
         /* store the size here only, the buffer is passed in as-is to
            _libssh2_transport_send() */
-        _libssh2_store_u32(&s, channel->write_bufwrite);
+        _libssh2_store_u32(&s, (uint32_t)channel->write_bufwrite);
         channel->write_packet_len = s - channel->write_packet;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Sending %d bytes on channel %lu/%lu, stream_id=%d",
-                       (int) channel->write_bufwrite, channel->local.id,
-                       channel->remote.id, stream_id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Sending %ld bytes on channel %u/%u, stream_id=%d",
+                       (long)channel->write_bufwrite, channel->local.id,
+                       channel->remote.id, stream_id));
 
         channel->write_state = libssh2_NB_state_created;
     }
@@ -2349,7 +2445,7 @@ _libssh2_channel_write(LIBSSH2_CHANNEL *channel, int stream_id,
                                   "Unable to send channel data");
         }
         /* Shrink local window size */
-        channel->local.window_size -= channel->write_bufwrite;
+        channel->local.window_size -= (uint32_t)channel->write_bufwrite;
 
         wrote += channel->write_bufwrite;
 
@@ -2402,9 +2498,9 @@ static int channel_send_eof(LIBSSH2_CHANNEL *channel)
     unsigned char packet[5];    /* packet_type(1) + channelno(4) */
     int rc;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "Sending EOF on channel %lu/%lu",
-                   channel->local.id, channel->remote.id);
+    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                   "Sending EOF on channel %u/%u",
+                   channel->local.id, channel->remote.id));
     packet[0] = SSH_MSG_CHANNEL_EOF;
     _libssh2_htonu32(packet + 1, channel->remote.id);
     rc = _libssh2_transport_send(session, packet, 5, NULL, 0);
@@ -2463,8 +2559,8 @@ libssh2_channel_eof(LIBSSH2_CHANNEL * channel)
 
         if(packet->data_len < 1) {
             packet = next_packet;
-            _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                           "Unexpected packet length");
+            _libssh2_debug((channel->session, LIBSSH2_TRACE_ERROR,
+                           "Unexpected packet length"));
             continue;
         }
 
@@ -2492,9 +2588,9 @@ static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
     int rc;
 
     if(channel->wait_eof_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Awaiting EOF for channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Awaiting EOF for channel %u/%u", channel->local.id,
+                       channel->remote.id));
 
         channel->wait_eof_state = libssh2_NB_state_created;
     }
@@ -2521,7 +2617,7 @@ static int channel_wait_eof(LIBSSH2_CHANNEL *channel)
         else if(rc < 0) {
             channel->wait_eof_state = libssh2_NB_state_idle;
             return _libssh2_error(session, rc,
-                                  "_libssh2_transport_read() bailed out!");
+                                  "_libssh2_transport_read() bailed out");
         }
     } while(1);
 
@@ -2566,7 +2662,7 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
                 return rc;
             }
             _libssh2_error(session, rc,
-                "Unable to send EOF, but closing channel anyway");
+                           "Unable to send EOF, but closing channel anyway");
         }
     }
 
@@ -2574,8 +2670,8 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel)
        late for us to wait for it. Continue closing! */
 
     if(channel->close_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN, "Closing channel %lu/%lu",
-                       channel->local.id, channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN, "Closing channel %u/%u",
+                       channel->local.id, channel->remote.id));
 
         channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE;
         _libssh2_htonu32(channel->close_packet + 1, channel->remote.id);
@@ -2643,7 +2739,7 @@ libssh2_channel_close(LIBSSH2_CHANNEL *channel)
     if(!channel)
         return LIBSSH2_ERROR_BAD_USE;
 
-    BLOCK_ADJUST(rc, channel->session, _libssh2_channel_close(channel) );
+    BLOCK_ADJUST(rc, channel->session, _libssh2_channel_close(channel));
     return rc;
 }
 
@@ -2664,9 +2760,9 @@ static int channel_wait_closed(LIBSSH2_CHANNEL *channel)
     }
 
     if(channel->wait_closed_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Awaiting close of channel %lu/%lu", channel->local.id,
-                       channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Awaiting close of channel %u/%u", channel->local.id,
+                       channel->remote.id));
 
         channel->wait_closed_state = libssh2_NB_state_created;
     }
@@ -2727,9 +2823,9 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
     assert(session);
 
     if(channel->free_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Freeing channel %lu/%lu resources", channel->local.id,
-                       channel->remote.id);
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Freeing channel %u/%u resources", channel->local.id,
+                       channel->remote.id));
 
         channel->free_state = libssh2_NB_state_created;
     }
@@ -2761,10 +2857,10 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
     /* Clear out packets meant for this channel */
     _libssh2_htonu32(channel_id, channel->local.id);
     while((_libssh2_packet_ask(session, SSH_MSG_CHANNEL_DATA, &data,
-                                &data_len, 1, channel_id, 4) >= 0)
-           ||
-           (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data,
-                                &data_len, 1, channel_id, 4) >= 0)) {
+                               &data_len, 1, channel_id, 4) >= 0)
+          ||
+          (_libssh2_packet_ask(session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data,
+                               &data_len, 1, channel_id, 4) >= 0)) {
         LIBSSH2_FREE(session, data);
     }
 
@@ -2824,7 +2920,7 @@ libssh2_channel_free(LIBSSH2_CHANNEL *channel)
  */
 LIBSSH2_API unsigned long
 libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
-                               unsigned long *read_avail,
+        /* FIXME: -> size_t */ unsigned long *read_avail,
                                unsigned long *window_size_initial)
 {
     if(!channel)
@@ -2846,8 +2942,8 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
 
             if(packet->data_len < 1) {
                 packet = next_packet;
-                _libssh2_debug(channel->session, LIBSSH2_TRACE_ERROR,
-                               "Unexpected packet length");
+                _libssh2_debug((channel->session, LIBSSH2_TRACE_ERROR,
+                               "Unexpected packet length"));
                 continue;
             }
 
@@ -2864,7 +2960,7 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
             packet = next_packet;
         }
 
-        *read_avail = bytes_queued;
+        *read_avail = (unsigned long)bytes_queued;
     }
 
     return channel->remote.window_size;
@@ -2893,3 +2989,87 @@ libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
 
     return channel->local.window_size;
 }
+
+/* A signal can be delivered to the remote process/service using the
+   following message.  Some systems may not implement signals, in which
+   case they SHOULD ignore this message.
+
+      byte      SSH_MSG_CHANNEL_REQUEST
+      uint32    recipient channel
+      string    "signal"
+      boolean   FALSE
+      string    signal name (without the "SIG" prefix)
+
+   'signal name' values will be encoded as discussed in the passage
+   describing SSH_MSG_CHANNEL_REQUEST messages using "exit-signal" in
+   this section.
+ */
+static int channel_signal(LIBSSH2_CHANNEL *channel,
+                          const char *signame,
+                          size_t signame_len)
+{
+    LIBSSH2_SESSION *session = channel->session;
+    int retcode = LIBSSH2_ERROR_PROTO;
+
+    if(channel->sendsignal_state == libssh2_NB_state_idle) {
+        unsigned char *s;
+
+        /* 20 = packet_type(1) + channel(4) +
+                signal_len + sizeof(signal) - 1 + want_reply(1) +
+                signame_len_len(4) */
+        channel->sendsignal_packet_len = 20 + signame_len;
+
+        s = channel->sendsignal_packet =
+            LIBSSH2_ALLOC(session, channel->sendsignal_packet_len);
+        if(!channel->sendsignal_packet)
+            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                  "Unable to allocate memory for "
+                                  "signal request");
+
+        *(s++) = SSH_MSG_CHANNEL_REQUEST;
+        _libssh2_store_u32(&s, channel->remote.id);
+        _libssh2_store_str(&s, "signal", sizeof("signal") - 1);
+        *(s++) = 0x00;  /* Don't reply */
+        _libssh2_store_str(&s, signame, signame_len);
+
+        channel->sendsignal_state = libssh2_NB_state_created;
+    }
+
+    if(channel->sendsignal_state == libssh2_NB_state_created) {
+        int rc;
+
+        rc = _libssh2_transport_send(session, channel->sendsignal_packet,
+                                     channel->sendsignal_packet_len,
+                                     NULL, 0);
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
+            _libssh2_error(session, rc, "Would block sending signal request");
+            return rc;
+        }
+        else if(rc) {
+            LIBSSH2_FREE(session, channel->sendsignal_packet);
+            channel->sendsignal_state = libssh2_NB_state_idle;
+            return _libssh2_error(session, rc, "Unable to send signal packet");
+        }
+        LIBSSH2_FREE(session, channel->sendsignal_packet);
+        retcode = LIBSSH2_ERROR_NONE;
+    }
+
+    channel->sendsignal_state = libssh2_NB_state_idle;
+
+    return retcode;
+}
+
+LIBSSH2_API int
+libssh2_channel_signal_ex(LIBSSH2_CHANNEL *channel,
+                          const char *signame,
+                          size_t signame_len)
+{
+    int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    BLOCK_ADJUST(rc, channel->session,
+                 channel_signal(channel, signame, signame_len));
+    return rc;
+}
diff --git a/libssh2/src/channel.h b/libssh2/src/channel.h
index dc0ee376..709ec061 100644
--- a/libssh2/src/channel.h
+++ b/libssh2/src/channel.h
@@ -1,6 +1,6 @@
-#ifndef __LIBSSH2_CHANNEL_H
-#define __LIBSSH2_CHANNEL_H
-/* Copyright (c) 2008-2010 by Daniel Stenberg
+#ifndef LIBSSH2_CHANNEL_H
+#define LIBSSH2_CHANNEL_H
+/* Copyright (C) Daniel Stenberg
  *
  * All rights reserved.
  *
@@ -36,6 +36,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /*
@@ -137,5 +139,4 @@ int _libssh2_channel_close(LIBSSH2_CHANNEL * channel);
  */
 int _libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
 
-#endif /* __LIBSSH2_CHANNEL_H */
-
+#endif /* LIBSSH2_CHANNEL_H */
diff --git a/libssh2/src/cipher-chachapoly.c b/libssh2/src/cipher-chachapoly.c
new file mode 100644
index 00000000..9e4b1170
--- /dev/null
+++ b/libssh2/src/cipher-chachapoly.c
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2013 Damien Miller <djm@mindrot.org>
+ *
+ * Adapted by Will Cosgrove <will@panic.com> for libssh2
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+/* $OpenBSD: cipher-chachapoly.c,v 1.8 2016/08/03 05:41:57 djm Exp $ */
+
+#include "libssh2_priv.h"
+#include "misc.h"
+#include "cipher-chachapoly.h"
+
+int
+chachapoly_timingsafe_bcmp(const void *b1, const void *b2, size_t n);
+
+int
+chachapoly_init(struct chachapoly_ctx *ctx, const u_char *key, u_int keylen)
+{
+    if(keylen != (32 + 32)) /* 2 x 256 bit keys */
+        return LIBSSH2_ERROR_INVAL;
+    chacha_keysetup(&ctx->main_ctx, key, 256);
+    chacha_keysetup(&ctx->header_ctx, key + 32, 256);
+    return 0;
+}
+
+/*
+ * chachapoly_crypt() operates as following:
+ * En/decrypt with header key 'aadlen' bytes from 'src', storing result
+ * to 'dest'. The ciphertext here is treated as additional authenticated
+ * data for MAC calculation.
+ * En/decrypt 'len' bytes at offset 'aadlen' from 'src' to 'dest'. Use
+ * POLY1305_TAGLEN bytes at offset 'len'+'aadlen' as the authentication
+ * tag. This tag is written on encryption and verified on decryption.
+ */
+int
+chachapoly_crypt(struct chachapoly_ctx *ctx, u_int seqnr, u_char *dest,
+                 const u_char *src, u_int len, u_int aadlen, int do_encrypt)
+{
+    u_char seqbuf[8];
+    const u_char one[8] = { 1, 0, 0, 0, 0, 0, 0, 0 }; /* NB little-endian */
+    u_char expected_tag[POLY1305_TAGLEN], poly_key[POLY1305_KEYLEN];
+    int r = LIBSSH2_ERROR_INVAL;
+    unsigned char *ptr = NULL;
+
+    /*
+     * Run ChaCha20 once to generate the Poly1305 key. The IV is the
+     * packet sequence number.
+     */
+    memset(poly_key, 0, sizeof(poly_key));
+    ptr = &seqbuf[0];
+    _libssh2_store_u64(&ptr, seqnr);
+    chacha_ivsetup(&ctx->main_ctx, seqbuf, NULL);
+    chacha_encrypt_bytes(&ctx->main_ctx,
+                         poly_key, poly_key, sizeof(poly_key));
+
+    /* If decrypting, check tag before anything else */
+    if(!do_encrypt) {
+        const u_char *tag = src + aadlen + len;
+
+        poly1305_auth(expected_tag, src, aadlen + len, poly_key);
+        if(chachapoly_timingsafe_bcmp(expected_tag, tag, POLY1305_TAGLEN)
+           != 0) {
+            r = LIBSSH2_ERROR_DECRYPT;
+            goto out;
+        }
+    }
+
+    /* Crypt additional data */
+    if(aadlen) {
+        chacha_ivsetup(&ctx->header_ctx, seqbuf, NULL);
+        chacha_encrypt_bytes(&ctx->header_ctx, src, dest, aadlen);
+    }
+
+    /* Set Chacha's block counter to 1 */
+    chacha_ivsetup(&ctx->main_ctx, seqbuf, one);
+    chacha_encrypt_bytes(&ctx->main_ctx, src + aadlen,
+                         dest + aadlen, len);
+
+    /* If encrypting, calculate and append tag */
+    if(do_encrypt) {
+        poly1305_auth(dest + aadlen + len, dest, aadlen + len,
+                      poly_key);
+    }
+    r = 0;
+out:
+    memset(expected_tag, 0, sizeof(expected_tag));
+    memset(seqbuf, 0, sizeof(seqbuf));
+    memset(poly_key, 0, sizeof(poly_key));
+    return r;
+}
+
+/* Decrypt and extract the encrypted packet length */
+int
+chachapoly_get_length(struct chachapoly_ctx *ctx, unsigned int *plenp,
+                      unsigned int seqnr, const unsigned char *cp,
+                      unsigned int len)
+{
+    u_char buf[4], seqbuf[8];
+    unsigned char *ptr = NULL;
+
+    if(len < 4)
+        return -1;
+    ptr = &seqbuf[0];
+    _libssh2_store_u64(&ptr, seqnr);
+    chacha_ivsetup(&ctx->header_ctx, seqbuf, NULL);
+    chacha_encrypt_bytes(&ctx->header_ctx, cp, buf, 4);
+    *plenp = _libssh2_ntohu32(buf);
+    return 0;
+}
+
+int
+chachapoly_timingsafe_bcmp(const void *b1, const void *b2, size_t n)
+{
+    const unsigned char *p1 = b1, *p2 = b2;
+    int ret = 0;
+
+    for(; n > 0; n--)
+        ret |= *p1++ ^ *p2++;
+    return (ret != 0);
+}
diff --git a/libssh2/src/cipher-chachapoly.h b/libssh2/src/cipher-chachapoly.h
new file mode 100644
index 00000000..4d0015cb
--- /dev/null
+++ b/libssh2/src/cipher-chachapoly.h
@@ -0,0 +1,41 @@
+/* $OpenBSD: cipher-chachapoly.h,v 1.4 2014/06/24 01:13:21 djm Exp $ */
+
+/*
+ * Copyright (c) Damien Miller 2013 <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+#ifndef CHACHA_POLY_AEAD_H
+#define CHACHA_POLY_AEAD_H
+
+#include "chacha.h"
+#include "poly1305.h"
+
+#define CHACHA_KEYLEN   32 /* Only 256 bit keys used here */
+
+struct chachapoly_ctx {
+    struct chacha_ctx main_ctx, header_ctx;
+};
+
+int chachapoly_init(struct chachapoly_ctx *cpctx,
+                    const u_char *key, u_int keylen);
+int chachapoly_crypt(struct chachapoly_ctx *cpctx, u_int seqnr,
+                     u_char *dest, const u_char *src, u_int len, u_int aadlen,
+                     int do_encrypt);
+int chachapoly_get_length(struct chachapoly_ctx *cpctx,
+                          u_int *plenp, u_int seqnr, const u_char *cp,
+                          u_int len);
+
+#endif /* CHACHA_POLY_AEAD_H */
diff --git a/libssh2/src/comp.c b/libssh2/src/comp.c
index 90ab30c8..ecfb28a3 100644
--- a/libssh2/src/comp.c
+++ b/libssh2/src/comp.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2004-2007, 2019, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2014, Daniel Stenberg <daniel@haxx.se>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg <daniel@haxx.se>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,9 +34,12 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
+
 #ifdef LIBSSH2_HAVE_ZLIB
 #include <zlib.h>
 #undef compress /* dodge name clash with ZLIB macro */
@@ -61,12 +64,12 @@ comp_method_none_comp(LIBSSH2_SESSION *session,
                       size_t src_len,
                       void **abstract)
 {
-    (void) session;
-    (void) abstract;
-    (void) dest;
-    (void) dest_len;
-    (void) src;
-    (void) src_len;
+    (void)session;
+    (void)abstract;
+    (void)dest;
+    (void)dest_len;
+    (void)src;
+    (void)src_len;
 
     return 0;
 }
@@ -84,9 +87,9 @@ comp_method_none_decomp(LIBSSH2_SESSION * session,
                         const unsigned char *src,
                         size_t src_len, void **abstract)
 {
-    (void) session;
-    (void) payload_limit;
-    (void) abstract;
+    (void)session;
+    (void)payload_limit;
+    (void)abstract;
     *dest = (unsigned char *) src;
     *dest_len = src_len;
     return 0;
@@ -163,8 +166,8 @@ comp_method_zlib_init(LIBSSH2_SESSION * session, int compr,
 
     if(status != Z_OK) {
         LIBSSH2_FREE(session, strm);
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "unhandled zlib error %d", status);
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "unhandled zlib error %d", status));
         return LIBSSH2_ERROR_COMPRESS;
     }
     *abstract = strm;
@@ -189,11 +192,11 @@ comp_method_zlib_comp(LIBSSH2_SESSION *session,
                       void **abstract)
 {
     z_stream *strm = *abstract;
-    int out_maxlen = *dest_len;
+    uInt out_maxlen = (uInt)*dest_len;
     int status;
 
     strm->next_in = (unsigned char *) src;
-    strm->avail_in = src_len;
+    strm->avail_in = (uInt)src_len;
     strm->next_out = dest;
     strm->avail_out = out_maxlen;
 
@@ -204,9 +207,9 @@ comp_method_zlib_comp(LIBSSH2_SESSION *session,
         return 0;
     }
 
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                   "unhandled zlib compression error %d, avail_out",
-                   status, strm->avail_out);
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                   "unhandled zlib compression error %d, avail_out %u",
+                   status, strm->avail_out));
     return _libssh2_error(session, LIBSSH2_ERROR_ZLIB, "compression failure");
 }
 
@@ -227,17 +230,17 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
     /* A short-term alloc of a full data chunk is better than a series of
        reallocs */
     char *out;
-    size_t out_maxlen = src_len;
+    size_t out_maxlen;
 
     if(src_len <= SIZE_MAX / 4)
-        out_maxlen = src_len * 4;
+        out_maxlen = (uInt)src_len * 4;
     else
         out_maxlen = payload_limit;
 
     /* If strm is null, then we have not yet been initialized. */
-    if(strm == NULL)
+    if(!strm)
         return _libssh2_error(session, LIBSSH2_ERROR_COMPRESS,
-                              "decompression uninitialized");;
+                              "decompression uninitialized");
 
     /* In practice they never come smaller than this */
     if(out_maxlen < 25)
@@ -247,10 +250,11 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
         out_maxlen = payload_limit;
 
     strm->next_in = (unsigned char *) src;
-    strm->avail_in = src_len;
-    strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen);
+    strm->avail_in = (uInt)src_len;
+    strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session,
+                                                     (uInt)out_maxlen);
     out = (char *) strm->next_out;
-    strm->avail_out = out_maxlen;
+    strm->avail_out = (uInt)out_maxlen;
     if(!strm->next_out)
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate decompression buffer");
@@ -276,8 +280,8 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
         else {
             /* error state */
             LIBSSH2_FREE(session, out);
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                           "unhandled zlib error %d", status);
+            _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                           "unhandled zlib error %d", status));
             return _libssh2_error(session, LIBSSH2_ERROR_ZLIB,
                                   "decompression failure");
         }
@@ -299,7 +303,7 @@ comp_method_zlib_decomp(LIBSSH2_SESSION * session,
         }
         out = newout;
         strm->next_out = (unsigned char *) out + out_ofs;
-        strm->avail_out = out_maxlen - out_ofs;
+        strm->avail_out = (uInt)(out_maxlen - out_ofs);
     }
 
     *dest = (unsigned char *) out;
diff --git a/libssh2/src/comp.h b/libssh2/src/comp.h
index 82ac2dc9..6a35d694 100644
--- a/libssh2/src/comp.h
+++ b/libssh2/src/comp.h
@@ -1,6 +1,6 @@
-#ifndef __LIBSSH2_COMP_H
-#define __LIBSSH2_COMP_H
-/* Copyright (C) 2009-2010 by Daniel Stenberg
+#ifndef LIBSSH2_COMP_H
+#define LIBSSH2_COMP_H
+/* Copyright (C) Daniel Stenberg
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -35,10 +35,11 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
 
 const LIBSSH2_COMP_METHOD **_libssh2_comp_methods(LIBSSH2_SESSION *session);
 
-#endif /* __LIBSSH2_COMP_H */
+#endif /* LIBSSH2_COMP_H */
diff --git a/libssh2/src/crypt.c b/libssh2/src/crypt.c
index 8d493b48..6c816eb4 100644
--- a/libssh2/src/crypt.c
+++ b/libssh2/src/crypt.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2009, 2010 Simon Josefsson <simon@josefsson.org>
- * Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
+/* Copyright (C) Simon Josefsson <simon@josefsson.org>
+ * Copyright (C) Sara Golemon <sarag@libssh2.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,18 +34,36 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
+#include "cipher-chachapoly.h"
 
-#ifdef LIBSSH2_CRYPT_NONE
+#include <assert.h>
 
+#if defined(LIBSSH2DEBUG) && defined(LIBSSH2_CRYPT_NONE_INSECURE)
 /* crypt_none_crypt
- * Minimalist cipher: VERY secure *wink*
+ * Minimalist cipher: no encryption. DO NOT USE.
+ *
+ * The SSH2 Transport allows for unencrypted data transmission using
+ * the "none" cipher.  Because this is such a huge security hole, it is
+ * typically disabled on SSH2 implementations and is disabled in libssh2
+ * by default as well.
+ *
+ * Enabling this option will allow for "none" as a negotiable method,
+ * however it still requires that the method be advertised by the remote
+ * end and that no more-preferable methods are available.
+ *
  */
 static int
-crypt_none_crypt(LIBSSH2_SESSION * session, unsigned char *buf,
-                         void **abstract)
+crypt_none_crypt(LIBSSH2_SESSION * session,
+                 unsigned int seqno,
+                 unsigned char *buf,
+                 size_t buf_len,
+                 void **abstract,
+                 int firstlast)
 {
     /* Do nothing to the data! */
     return 0;
@@ -62,13 +80,14 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = {
     crypt_none_crypt,
     NULL
 };
-#endif /* LIBSSH2_CRYPT_NONE */
+#endif /* defined(LIBSSH2DEBUG) && defined(LIBSSH2_CRYPT_NONE_INSECURE) */
 
 struct crypt_ctx
 {
     int encrypt;
     _libssh2_cipher_type(algo);
     _libssh2_cipher_ctx h;
+    struct chachapoly_ctx chachapoly_ctx;
 };
 
 static int
@@ -96,13 +115,18 @@ crypt_init(LIBSSH2_SESSION * session,
 }
 
 static int
-crypt_encrypt(LIBSSH2_SESSION * session, unsigned char *block,
-              size_t blocksize, void **abstract)
+crypt_encrypt(LIBSSH2_SESSION * session,
+              unsigned int seqno,
+              unsigned char *buf,
+              size_t buf_len,
+              void **abstract,
+              int firstlast)
 {
     struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
     (void) session;
-    return _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
-                                 blocksize);
+    (void) seqno;
+    return _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, buf,
+                                 buf_len, firstlast);
 }
 
 static int
@@ -117,6 +141,38 @@ crypt_dtor(LIBSSH2_SESSION * session, void **abstract)
     return 0;
 }
 
+#if LIBSSH2_AES_GCM
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_gcm = {
+    "aes256-gcm@openssh.com",
+    "",
+    16,                         /* blocksize */
+    12,                         /* initial value length */
+    32,                         /* secret length -- 32*8 == 256bit */
+    16,                         /* length of the authentication tag */
+    LIBSSH2_CRYPT_FLAG_INTEGRATED_MAC | LIBSSH2_CRYPT_FLAG_PKTLEN_AAD,
+    &crypt_init,
+    NULL,
+    &crypt_encrypt,
+    &crypt_dtor,
+    _libssh2_cipher_aes256gcm
+};
+
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_gcm = {
+    "aes128-gcm@openssh.com",
+    "",
+    16,                         /* blocksize */
+    12,                         /* initial value length */
+    16,                         /* secret length -- 16*8 == 128bit */
+    16,                         /* length of the authentication tag */
+    LIBSSH2_CRYPT_FLAG_INTEGRATED_MAC | LIBSSH2_CRYPT_FLAG_PKTLEN_AAD,
+    &crypt_init,
+    NULL,
+    &crypt_encrypt,
+    &crypt_dtor,
+    _libssh2_cipher_aes128gcm
+};
+#endif
+
 #if LIBSSH2_AES_CTR
 static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_ctr = {
     "aes128-ctr",
@@ -124,8 +180,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_ctr = {
     16,                         /* blocksize */
     16,                         /* initial value length */
     16,                         /* secret length -- 16*8 == 128bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes128ctr
@@ -137,8 +195,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_ctr = {
     16,                         /* blocksize */
     16,                         /* initial value length */
     24,                         /* secret length -- 24*8 == 192bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes192ctr
@@ -150,23 +210,27 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_ctr = {
     16,                         /* blocksize */
     16,                         /* initial value length */
     32,                         /* secret length -- 32*8 == 256bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes256ctr
 };
 #endif
 
-#if LIBSSH2_AES
+#if LIBSSH2_AES_CBC
 static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
     "aes128-cbc",
     "DEK-Info: AES-128-CBC",
     16,                         /* blocksize */
     16,                         /* initial value length */
     16,                         /* secret length -- 16*8 == 128bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes128
@@ -178,8 +242,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
     16,                         /* blocksize */
     16,                         /* initial value length */
     24,                         /* secret length -- 24*8 == 192bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes192
@@ -191,8 +257,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
     16,                         /* blocksize */
     16,                         /* initial value length */
     32,                         /* secret length -- 32*8 == 256bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes256
@@ -206,13 +274,15 @@ static const LIBSSH2_CRYPT_METHOD
     16,                         /* blocksize */
     16,                         /* initial value length */
     32,                         /* secret length -- 32*8 == 256bit */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_aes256
 };
-#endif /* LIBSSH2_AES */
+#endif /* LIBSSH2_AES_CBC */
 
 #if LIBSSH2_BLOWFISH
 static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
@@ -221,8 +291,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
     8,                          /* blocksize */
     8,                          /* initial value length */
     16,                         /* secret length */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_blowfish
@@ -236,8 +308,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
     8,                          /* blocksize */
     8,                          /* initial value length */
     16,                         /* secret length */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_arcfour
@@ -260,7 +334,8 @@ crypt_init_arcfour128(LIBSSH2_SESSION * session,
         size_t discard = 1536;
         for(; discard; discard -= 8)
             _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block,
-                                  method->blocksize);
+                                  method->blocksize, MIDDLE_BLOCK);
+                               /* Not all middle, but here it doesn't matter */
     }
 
     return rc;
@@ -272,8 +347,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour128 = {
     8,                          /* blocksize */
     8,                          /* initial value length */
     16,                         /* secret length */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init_arcfour128,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_arcfour
@@ -287,8 +364,10 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
     8,                          /* blocksize */
     8,                          /* initial value length */
     16,                         /* secret length */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_cast5
@@ -302,26 +381,147 @@ static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
     8,                          /* blocksize */
     8,                          /* initial value length */
     24,                         /* secret length */
+    0,                          /* length of the authentication tag */
     0,                          /* flags */
     &crypt_init,
+    NULL,
     &crypt_encrypt,
     &crypt_dtor,
     _libssh2_cipher_3des
 };
 #endif
 
+static int
+crypt_init_chacha20_poly(LIBSSH2_SESSION * session,
+           const LIBSSH2_CRYPT_METHOD * method,
+           unsigned char *iv, int *free_iv,
+           unsigned char *secret, int *free_secret,
+           int encrypt, void **abstract)
+{
+    struct crypt_ctx *ctx = LIBSSH2_ALLOC(session,
+                                          sizeof(struct crypt_ctx));
+
+    (void)iv;
+
+    if(!ctx)
+        return LIBSSH2_ERROR_ALLOC;
+
+    ctx->encrypt = encrypt;
+    ctx->algo = method->algo;
+
+    if(chachapoly_init(&ctx->chachapoly_ctx, secret, method->secret_len)) {
+        LIBSSH2_FREE(session, ctx);
+        return -1;
+    }
+
+    *abstract = ctx;
+    *free_iv = 1;
+    *free_secret = 1;
+    return 0;
+}
+
+
+static int
+crypt_encrypt_chacha20_poly_buffer(LIBSSH2_SESSION * session,
+                                   unsigned int seqno,
+                                   unsigned char *buf,
+                                   size_t buf_len,
+                                   void **abstract,
+                                   int firstlast)
+{
+    int ret = 1;
+    struct crypt_ctx *ctx = *(struct crypt_ctx **) abstract;
+
+    (void)session;
+    (void)firstlast;
+
+    if(ctx) {
+        if(ctx->encrypt) {
+            /* requires out_buf to be large enough to hold encrypted output
+               plus auth tag (auth len)
+
+               buf is a full packet so we need to subtract packet length from
+               length
+             */
+            ret = chachapoly_crypt(&ctx->chachapoly_ctx, seqno, buf, buf,
+                                   ((u_int)buf_len) - 4, 4, ctx->encrypt);
+        }
+        else {
+            /* buf is full packet including size and auth tag but buf_len
+               doesn't include size */
+            ret = chachapoly_crypt(&ctx->chachapoly_ctx, seqno, buf, buf,
+                                   ((u_int)buf_len), 4, ctx->encrypt);
+
+            /* the api expects the size field to already be removed
+               from the decrypted packet so we'll help it out */
+            if(ret == 0) {
+                memmove(buf, buf + 4, buf_len - 4);
+            }
+        }
+    }
+
+    return (ret == 0 ? 0 : 1);
+}
+
+static int
+crypt_get_length_chacha20_poly(LIBSSH2_SESSION * session, unsigned int seqno,
+                               unsigned char *data, size_t data_size,
+                               unsigned int *len, void **abstract)
+{
+    struct crypt_ctx *ctx = *(struct crypt_ctx **) abstract;
+
+    (void)session;
+
+    return chachapoly_get_length(&ctx->chachapoly_ctx, len, seqno, data,
+                                 (u_int)data_size);
+}
+
+static int
+crypt_dtor_chacha20_poly(LIBSSH2_SESSION * session, void **abstract)
+{
+    struct crypt_ctx **cctx = (struct crypt_ctx **) abstract;
+    if(cctx && *cctx) {
+        LIBSSH2_FREE(session, *cctx);
+        *abstract = NULL;
+    }
+    return 0;
+}
+
+static const LIBSSH2_CRYPT_METHOD
+    libssh2_crypt_method_chacha20_poly1305_openssh = {
+    "chacha20-poly1305@openssh.com",
+    "",
+    8,                                          /* blocksize */
+    0,                                          /* initial value length */
+    64,                                         /* secret length */
+    16,                                         /* length of the auth_tag */
+    LIBSSH2_CRYPT_FLAG_REQUIRES_FULL_PACKET,    /* flags */
+    &crypt_init_chacha20_poly,
+    &crypt_get_length_chacha20_poly,
+    &crypt_encrypt_chacha20_poly_buffer,
+    &crypt_dtor_chacha20_poly,
+    _libssh2_cipher_chacha20                    /* not actually used */
+};
+
+/* These are the crypt methods that are available to be negotiated. Methods
+   towards the start are chosen in preference to ones further down the list. */
 static const LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
+    &libssh2_crypt_method_chacha20_poly1305_openssh,
+#if LIBSSH2_AES_GCM
+    &libssh2_crypt_method_aes256_gcm,
+    &libssh2_crypt_method_aes128_gcm,
+#endif /* LIBSSH2_AES_GCM */
 #if LIBSSH2_AES_CTR
-  &libssh2_crypt_method_aes128_ctr,
-  &libssh2_crypt_method_aes192_ctr,
-  &libssh2_crypt_method_aes256_ctr,
-#endif /* LIBSSH2_AES */
-#if LIBSSH2_AES
+    &libssh2_crypt_method_aes256_ctr,
+    &libssh2_crypt_method_aes192_ctr,
+    &libssh2_crypt_method_aes128_ctr,
+#endif /* LIBSSH2_AES_CTR */
+#if LIBSSH2_AES_CBC
     &libssh2_crypt_method_aes256_cbc,
     &libssh2_crypt_method_rijndael_cbc_lysator_liu_se,  /* == aes256-cbc */
     &libssh2_crypt_method_aes192_cbc,
     &libssh2_crypt_method_aes128_cbc,
-#endif /* LIBSSH2_AES */
+#endif /* LIBSSH2_AES_CBC */
 #if LIBSSH2_BLOWFISH
     &libssh2_crypt_method_blowfish_cbc,
 #endif /* LIBSSH2_BLOWFISH */
@@ -335,7 +535,7 @@ static const LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
 #if LIBSSH2_3DES
     &libssh2_crypt_method_3des_cbc,
 #endif /*  LIBSSH2_DES */
-#ifdef LIBSSH2_CRYPT_NONE
+#if defined(LIBSSH2DEBUG) && defined(LIBSSH2_CRYPT_NONE_INSECURE)
     &libssh2_crypt_method_none,
 #endif
     NULL
diff --git a/libssh2/src/crypto.c b/libssh2/src/crypto.c
new file mode 100644
index 00000000..b3b1afcb
--- /dev/null
+++ b/libssh2/src/crypto.c
@@ -0,0 +1,19 @@
+/* Copyright (C) Viktor Szakats
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#define LIBSSH2_CRYPTO_C
+#include "libssh2_priv.h"
+
+#if defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL)
+#include "openssl.c"
+#elif defined(LIBSSH2_LIBGCRYPT)
+#include "libgcrypt.c"
+#elif defined(LIBSSH2_MBEDTLS)
+#include "mbedtls.c"
+#elif defined(LIBSSH2_OS400QC3)
+#include "os400qc3.c"
+#elif defined(LIBSSH2_WINCNG)
+#include "wincng.c"
+#endif
diff --git a/libssh2/src/crypto.h b/libssh2/src/crypto.h
index f512d603..48744414 100644
--- a/libssh2/src/crypto.h
+++ b/libssh2/src/crypto.h
@@ -1,8 +1,9 @@
-#ifndef __LIBSSH2_CRYPTO_H
-#define __LIBSSH2_CRYPTO_H
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2010-2019 Daniel Stenberg
+#ifndef LIBSSH2_CRYPTO_H
+#define LIBSSH2_CRYPTO_H
+/* Copyright (C) Simon Josefsson
+ * Copyright (C) The Written Word, Inc.
+ * Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -36,27 +37,44 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifdef LIBSSH2_OPENSSL
+#if defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL)
 #include "openssl.h"
-#endif
-
-#ifdef LIBSSH2_LIBGCRYPT
+#elif defined(LIBSSH2_LIBGCRYPT)
 #include "libgcrypt.h"
-#endif
-
-#ifdef LIBSSH2_WINCNG
+#elif defined(LIBSSH2_MBEDTLS)
+#include "mbedtls.h"
+#elif defined(LIBSSH2_OS400QC3)
+#include "os400qc3.h"
+#elif defined(LIBSSH2_WINCNG)
 #include "wincng.h"
+#else
+#error "no cryptography backend selected"
 #endif
 
-#ifdef LIBSSH2_OS400QC3
-#include "os400qc3.h"
+/* return: success = 1, error = 0 */
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx);
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen);
 #endif
-
-#ifdef LIBSSH2_MBEDTLS
-#include "mbedtls.h"
+#if LIBSSH2_HMAC_RIPEMD
+int _libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
+                                 void *key, size_t keylen);
 #endif
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen);
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen);
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen);
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen);
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data);
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx);
 
 #define LIBSSH2_ED25519_KEY_LEN 32
 #define LIBSSH2_ED25519_PRIVATE_KEY_LEN 64
@@ -83,16 +101,31 @@ int _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
                              LIBSSH2_SESSION * session,
                              const char *filename,
                              unsigned const char *passphrase);
+#if LIBSSH2_RSA_SHA1
+int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
+                           libssh2_rsa_ctx * rsactx,
+                           const unsigned char *hash,
+                           size_t hash_len,
+                           unsigned char **signature,
+                           size_t *signature_len);
 int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
                              const unsigned char *sig,
-                             unsigned long sig_len,
-                             const unsigned char *m, unsigned long m_len);
-int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
+                             size_t sig_len,
+                             const unsigned char *m, size_t m_len);
+#endif
+#if LIBSSH2_RSA_SHA2
+int _libssh2_rsa_sha2_sign(LIBSSH2_SESSION * session,
                            libssh2_rsa_ctx * rsactx,
                            const unsigned char *hash,
                            size_t hash_len,
                            unsigned char **signature,
                            size_t *signature_len);
+int _libssh2_rsa_sha2_verify(libssh2_rsa_ctx * rsa,
+                             size_t hash_len,
+                             const unsigned char *sig,
+                             size_t sig_len,
+                             const unsigned char *m, size_t m_len);
+#endif
 int _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
                                         LIBSSH2_SESSION * session,
                                         const char *filedata,
@@ -117,10 +150,10 @@ int _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
                              unsigned const char *passphrase);
 int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
                              const unsigned char *sig,
-                             const unsigned char *m, unsigned long m_len);
+                             const unsigned char *m, size_t m_len);
 int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
                            const unsigned char *hash,
-                           unsigned long hash_len, unsigned char *sig);
+                           size_t hash_len, unsigned char *sig);
 int _libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
                                         LIBSSH2_SESSION * session,
                                         const char *filedata,
@@ -134,12 +167,23 @@ _libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ecdsactx,
                                          const unsigned char *k,
                                          size_t k_len,
                                          libssh2_curve_type type);
+
 int
 _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
                            LIBSSH2_SESSION * session,
                            const char *filename,
                            unsigned const char *passphrase);
 
+int
+_libssh2_ecdsa_new_private_sk(libssh2_ecdsa_ctx ** ec_ctx,
+                              unsigned char *flags,
+                              const char **application,
+                              const unsigned char **key_handle,
+                              size_t *handle_len,
+                              LIBSSH2_SESSION * session,
+                              const char *filename,
+                              unsigned const char *passphrase);
+
 int
 _libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
                       const unsigned char *r, size_t r_len,
@@ -160,7 +204,7 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
 
 int
 _libssh2_ecdsa_sign(LIBSSH2_SESSION *session, libssh2_ecdsa_ctx *ec_ctx,
-                    const unsigned char *hash, unsigned long hash_len,
+                    const unsigned char *hash, size_t hash_len,
                     unsigned char **signature, size_t *signature_len);
 
 int _libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
@@ -169,6 +213,16 @@ int _libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
                                           size_t filedata_len,
                                           unsigned const char *passphrase);
 
+int _libssh2_ecdsa_new_private_frommemory_sk(libssh2_ecdsa_ctx ** ec_ctx,
+                                             unsigned char *flags,
+                                             const char **application,
+                                             const unsigned char **key_handle,
+                                             size_t *handle_len,
+                                             LIBSSH2_SESSION * session,
+                                             const char *filedata,
+                                             size_t filedata_len,
+                                             unsigned const char *passphrase);
+
 libssh2_curve_type
 _libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx);
 
@@ -198,11 +252,21 @@ _libssh2_ed25519_new_private(libssh2_ed25519_ctx **ed_ctx,
                             LIBSSH2_SESSION *session,
                             const char *filename, const uint8_t *passphrase);
 
+int
+_libssh2_ed25519_new_private_sk(libssh2_ed25519_ctx **ed_ctx,
+                                unsigned char *flags,
+                                const char **application,
+                                const unsigned char **key_handle,
+                                size_t *handle_len,
+                                LIBSSH2_SESSION *session,
+                                const char *filename,
+                                const uint8_t *passphrase);
+
 int
 _libssh2_ed25519_new_public(libssh2_ed25519_ctx **ed_ctx,
                             LIBSSH2_SESSION *session,
                             const unsigned char *raw_pub_key,
-                            const uint8_t key_len);
+                            const size_t key_len);
 
 int
 _libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
@@ -216,6 +280,17 @@ _libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx **ed_ctx,
                                         size_t filedata_len,
                                         unsigned const char *passphrase);
 
+int
+_libssh2_ed25519_new_private_frommemory_sk(libssh2_ed25519_ctx **ed_ctx,
+                                           unsigned char *flags,
+                                           const char **application,
+                                           const unsigned char **key_handle,
+                                           size_t *handle_len,
+                                           LIBSSH2_SESSION *session,
+                                           const char *filedata,
+                                           size_t filedata_len,
+                                           unsigned const char *passphrase);
+
 #endif /* LIBSSH2_ED25519 */
 
 
@@ -226,7 +301,8 @@ int _libssh2_cipher_init(_libssh2_cipher_ctx * h,
 
 int _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
                           _libssh2_cipher_type(algo),
-                          int encrypt, unsigned char *block, size_t blocksize);
+                          int encrypt, unsigned char *block, size_t blocksize,
+                          int firstlast);
 
 int _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
                               unsigned char **method,
@@ -245,4 +321,37 @@ int _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
                                     size_t privatekeydata_len,
                                     const char *passphrase);
 
-#endif /* __LIBSSH2_CRYPTO_H */
+
+int _libssh2_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                                  unsigned char **method,
+                                  size_t *method_len,
+                                  unsigned char **pubkeydata,
+                                  size_t *pubkeydata_len,
+                                  int *algorithm,
+                                  unsigned char *flags,
+                                  const char **application,
+                                  const unsigned char **key_handle,
+                                  size_t *handle_len,
+                                  const char *privatekeydata,
+                                  size_t privatekeydata_len,
+                                  const char *passphrase);
+
+/**
+ * @function _libssh2_supported_key_sign_algorithms
+ * @abstract Returns supported algorithms used for upgrading public
+ * key signing RFC 8332
+ * @discussion Based on the incoming key_method value, this function
+ * will return supported algorithms that can upgrade the key method
+ * @related _libssh2_key_sign_algorithm()
+ * @param key_method current key method, usually the default key sig method
+ * @param key_method_len length of the key method buffer
+ * @result comma separated list of supported upgrade options per RFC 8332, if
+ * there is no upgrade option return NULL
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len);
+
+#endif /* LIBSSH2_CRYPTO_H */
diff --git a/libssh2/src/crypto_config.h b/libssh2/src/crypto_config.h
new file mode 100644
index 00000000..885a6a91
--- /dev/null
+++ b/libssh2/src/crypto_config.h
@@ -0,0 +1,76 @@
+/* Copyright (C) Viktor Szakats
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#define LIBSSH2_MD5_PEM LIBSSH2_MD5
+
+#ifdef LIBSSH2_NO_MD5
+#undef LIBSSH2_MD5
+#define LIBSSH2_MD5 0
+#endif
+
+#ifdef LIBSSH2_NO_MD5_PEM
+#undef LIBSSH2_MD5_PEM
+#define LIBSSH2_MD5_PEM 0
+#endif
+
+#ifdef LIBSSH2_NO_HMAC_RIPEMD
+#undef LIBSSH2_HMAC_RIPEMD
+#define LIBSSH2_HMAC_RIPEMD 0
+#endif
+
+#if !defined(LIBSSH2_DSA_ENABLE)
+#undef LIBSSH2_DSA
+#define LIBSSH2_DSA 0
+#endif
+
+#ifdef LIBSSH2_NO_RSA
+#undef LIBSSH2_RSA
+#define LIBSSH2_RSA 0
+#endif
+
+#ifdef LIBSSH2_NO_RSA_SHA1
+#undef LIBSSH2_RSA_SHA1
+#define LIBSSH2_RSA_SHA1 0
+#endif
+
+#ifdef LIBSSH2_NO_ECDSA
+#undef LIBSSH2_ECDSA
+#define LIBSSH2_ECDSA 0
+#endif
+
+#ifdef LIBSSH2_NO_ED25519
+#undef LIBSSH2_ED25519
+#define LIBSSH2_ED25519 0
+#endif
+
+#ifdef LIBSSH2_NO_AES_CTR
+#undef LIBSSH2_AES_CTR
+#define LIBSSH2_AES_CTR 0
+#endif
+
+#ifdef LIBSSH2_NO_AES_CBC
+#undef LIBSSH2_AES_CBC
+#define LIBSSH2_AES_CBC 0
+#endif
+
+#ifdef LIBSSH2_NO_BLOWFISH
+#undef LIBSSH2_BLOWFISH
+#define LIBSSH2_BLOWFISH 0
+#endif
+
+#ifdef LIBSSH2_NO_RC4
+#undef LIBSSH2_RC4
+#define LIBSSH2_RC4 0
+#endif
+
+#ifdef LIBSSH2_NO_CAST
+#undef LIBSSH2_CAST
+#define LIBSSH2_CAST 0
+#endif
+
+#ifdef LIBSSH2_NO_3DES
+#undef LIBSSH2_3DES
+#define LIBSSH2_3DES 0
+#endif
diff --git a/libssh2/src/global.c b/libssh2/src/global.c
index 68289845..a8bc3807 100644
--- a/libssh2/src/global.c
+++ b/libssh2/src/global.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2010 Lars Nordin <Lars.Nordin@SDlabs.se>
- * Copyright (C) 2010 Simon Josefsson <simon@josefsson.org>
+/* Copyright (C) Lars Nordin <Lars.Nordin@SDlabs.se>
+ * Copyright (C) Simon Josefsson <simon@josefsson.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -74,5 +76,5 @@ void
 _libssh2_init_if_needed(void)
 {
     if(_libssh2_initialized == 0)
-        (void)libssh2_init (0);
+        (void)libssh2_init(0);
 }
diff --git a/libssh2/src/hostkey.c b/libssh2/src/hostkey.c
index d87a4c74..99eaf3e0 100644
--- a/libssh2/src/hostkey.c
+++ b/libssh2/src/hostkey.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2019 by Daniel Stenberg
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,10 +34,11 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include "misc.h"
 
 /* Needed for struct iovec on some platforms */
 #ifdef HAVE_SYS_UIO_H
@@ -64,8 +65,8 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
                             void **abstract)
 {
     libssh2_rsa_ctx *rsactx;
-    unsigned char *e, *n;
-    size_t e_len, n_len;
+    unsigned char *e, *n, *type;
+    size_t e_len, n_len, type_len;
     struct string_buf buf;
 
     if(*abstract) {
@@ -74,8 +75,8 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
     }
 
     if(hostkey_data_len < 19) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
+        _libssh2_debug((session, LIBSSH2_TRACE_ERROR,
+                       "host key length too short"));
         return -1;
     }
 
@@ -83,8 +84,31 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
     buf.dataptr = buf.data;
     buf.len = hostkey_data_len;
 
-    if(_libssh2_match_string(&buf, "ssh-rsa"))
+    if(_libssh2_get_string(&buf, &type, &type_len)) {
+        return -1;
+    }
+
+    /* we accept one of 3 header types */
+#if LIBSSH2_RSA_SHA1
+    if(type_len == 7 && strncmp("ssh-rsa", (char *)type, 7) == 0) {
+        /* ssh-rsa */
+    }
+    else
+#endif
+#if LIBSSH2_RSA_SHA2
+    if(type_len == 12 && strncmp("rsa-sha2-256", (char *)type, 12) == 0) {
+        /* rsa-sha2-256 */
+    }
+    else if(type_len == 12 && strncmp("rsa-sha2-512", (char *)type, 12) == 0) {
+        /* rsa-sha2-512 */
+    }
+    else
+#endif
+    {
+        _libssh2_debug((session, LIBSSH2_TRACE_ERROR,
+                       "unexpected rsa type: %.*s", (int)type_len, type));
         return -1;
+    }
 
     if(_libssh2_get_string(&buf, &e, &e_len))
         return -1;
@@ -92,8 +116,14 @@ hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
     if(_libssh2_get_string(&buf, &n, &n_len))
         return -1;
 
-    if(_libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0,
-                        NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0)) {
+    if(!_libssh2_eob(&buf))
+        return -1;
+
+    if(_libssh2_rsa_new(&rsactx,
+                        e, (unsigned long)e_len,
+                        n, (unsigned long)n_len,
+                        NULL, 0, NULL, 0, NULL, 0,
+                        NULL, 0, NULL, 0, NULL, 0)) {
         return -1;
     }
 
@@ -163,6 +193,7 @@ hostkey_method_ssh_rsa_initPEMFromMemory(LIBSSH2_SESSION * session,
     return 0;
 }
 
+#if LIBSSH2_RSA_SHA1
 /*
  * hostkey_method_ssh_rsa_sign
  *
@@ -176,7 +207,7 @@ hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session,
                                   size_t m_len, void **abstract)
 {
     libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
-    (void) session;
+    (void)session;
 
     /* Skip past keyname_len(4) + keyname(7){"ssh-rsa"} + signature_len(4) */
     if(sig_len < 15)
@@ -211,11 +242,18 @@ hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
     unsigned char hash[SHA_DIGEST_LENGTH];
     libssh2_sha1_ctx ctx;
 
-    libssh2_sha1_init(&ctx);
+    if(!libssh2_sha1_init(&ctx)) {
+        return -1;
+    }
     for(i = 0; i < veccount; i++) {
-        libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
+        if(!libssh2_sha1_update(ctx,
+                                datavec[i].iov_base, datavec[i].iov_len)) {
+            return -1;
+        }
+    }
+    if(!libssh2_sha1_final(ctx, hash)) {
+        return -1;
     }
-    libssh2_sha1_final(ctx, hash);
 
     ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH,
                                  signature, signature_len);
@@ -226,6 +264,161 @@ hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
     return 0;
 #endif
 }
+#endif
+
+/*
+ * hostkey_method_ssh_rsa_sha2_256_sig_verify
+ *
+ * Verify signature created by remote
+ */
+#if LIBSSH2_RSA_SHA2
+
+static int
+hostkey_method_ssh_rsa_sha2_256_sig_verify(LIBSSH2_SESSION * session,
+                                           const unsigned char *sig,
+                                           size_t sig_len,
+                                           const unsigned char *m,
+                                           size_t m_len, void **abstract)
+{
+    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
+    (void)session;
+
+    /* Skip past keyname_len(4) + keyname(12){"rsa-sha2-256"} +
+       signature_len(4) */
+    if(sig_len < 20)
+        return -1;
+
+    sig += 20;
+    sig_len -= 20;
+    return _libssh2_rsa_sha2_verify(rsactx, SHA256_DIGEST_LENGTH, sig, sig_len,
+                                    m, m_len);
+}
+
+/*
+ * hostkey_method_ssh_rsa_sha2_256_signv
+ *
+ * Construct a signature from an array of vectors
+ */
+
+static int
+hostkey_method_ssh_rsa_sha2_256_signv(LIBSSH2_SESSION * session,
+                                      unsigned char **signature,
+                                      size_t *signature_len,
+                                      int veccount,
+                                      const struct iovec datavec[],
+                                      void **abstract)
+{
+    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
+
+#ifdef _libssh2_rsa_sha2_256_signv
+    return _libssh2_rsa_sha2_256_signv(session, signature, signature_len,
+                                       veccount, datavec, rsactx);
+#else
+    int ret;
+    int i;
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    libssh2_sha256_ctx ctx;
+
+    if(!libssh2_sha256_init(&ctx)) {
+        return -1;
+    }
+    for(i = 0; i < veccount; i++) {
+        if(!libssh2_sha256_update(ctx,
+                                  datavec[i].iov_base, datavec[i].iov_len)) {
+            return -1;
+        }
+    }
+    if(!libssh2_sha256_final(ctx, hash)) {
+        return -1;
+    }
+
+    ret = _libssh2_rsa_sha2_sign(session, rsactx, hash, SHA256_DIGEST_LENGTH,
+                                 signature, signature_len);
+    if(ret) {
+        return -1;
+    }
+
+    return 0;
+#endif
+}
+
+/*
+ * hostkey_method_ssh_rsa_sha2_512_sig_verify
+ *
+ * Verify signature created by remote
+ */
+
+static int
+hostkey_method_ssh_rsa_sha2_512_sig_verify(LIBSSH2_SESSION * session,
+                                           const unsigned char *sig,
+                                           size_t sig_len,
+                                           const unsigned char *m,
+                                           size_t m_len, void **abstract)
+{
+    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
+    (void)session;
+
+    /* Skip past keyname_len(4) + keyname(12){"rsa-sha2-512"} +
+       signature_len(4) */
+    if(sig_len < 20)
+        return -1;
+
+    sig += 20;
+    sig_len -= 20;
+    return _libssh2_rsa_sha2_verify(rsactx, SHA512_DIGEST_LENGTH, sig,
+                                    sig_len, m, m_len);
+}
+
+
+/*
+ * hostkey_method_ssh_rsa_sha2_512_signv
+ *
+ * Construct a signature from an array of vectors
+ */
+static int
+hostkey_method_ssh_rsa_sha2_512_signv(LIBSSH2_SESSION * session,
+                                      unsigned char **signature,
+                                      size_t *signature_len,
+                                      int veccount,
+                                      const struct iovec datavec[],
+                                      void **abstract)
+{
+    libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
+
+#ifdef _libssh2_rsa_sha2_512_signv
+    return _libssh2_rsa_sha2_512_signv(session, signature, signature_len,
+                                       veccount, datavec, rsactx);
+#else
+    int ret;
+    int i;
+    unsigned char hash[SHA512_DIGEST_LENGTH];
+    libssh2_sha512_ctx ctx;
+
+    if(!libssh2_sha512_init(&ctx)) {
+        return -1;
+    }
+    for(i = 0; i < veccount; i++) {
+        if(!libssh2_sha512_update(ctx,
+                                  datavec[i].iov_base, datavec[i].iov_len)) {
+            return -1;
+        }
+    }
+    if(!libssh2_sha512_final(ctx, hash)) {
+        return -1;
+    }
+
+    ret = _libssh2_rsa_sha2_sign(session, rsactx, hash, SHA512_DIGEST_LENGTH,
+                                 signature, signature_len);
+    if(ret) {
+        return -1;
+    }
+
+    return 0;
+#endif
+}
+
+#endif /* LIBSSH2_RSA_SHA2 */
+
 
 /*
  * hostkey_method_ssh_rsa_dtor
@@ -236,7 +429,7 @@ static int
 hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
     libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
-    (void) session;
+    (void)session;
 
     _libssh2_rsa_free(rsactx);
 
@@ -245,13 +438,11 @@ hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract)
     return 0;
 }
 
-#ifdef OPENSSL_NO_MD5
-#define MD5_DIGEST_LENGTH 16
-#endif
+#if LIBSSH2_RSA_SHA1
 
 static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa = {
     "ssh-rsa",
-    MD5_DIGEST_LENGTH,
+    SHA_DIGEST_LENGTH,
     hostkey_method_ssh_rsa_init,
     hostkey_method_ssh_rsa_initPEM,
     hostkey_method_ssh_rsa_initPEMFromMemory,
@@ -260,6 +451,81 @@ static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa = {
     NULL,                       /* encrypt */
     hostkey_method_ssh_rsa_dtor,
 };
+
+#endif /* LIBSSH2_RSA_SHA1 */
+
+#if LIBSSH2_RSA_SHA2
+
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa_sha2_256 = {
+    "rsa-sha2-256",
+    SHA256_DIGEST_LENGTH,
+    hostkey_method_ssh_rsa_init,
+    hostkey_method_ssh_rsa_initPEM,
+    hostkey_method_ssh_rsa_initPEMFromMemory,
+    hostkey_method_ssh_rsa_sha2_256_sig_verify,
+    hostkey_method_ssh_rsa_sha2_256_signv,
+    NULL,                       /* encrypt */
+    hostkey_method_ssh_rsa_dtor,
+};
+
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa_sha2_512 = {
+    "rsa-sha2-512",
+    SHA512_DIGEST_LENGTH,
+    hostkey_method_ssh_rsa_init,
+    hostkey_method_ssh_rsa_initPEM,
+    hostkey_method_ssh_rsa_initPEMFromMemory,
+    hostkey_method_ssh_rsa_sha2_512_sig_verify,
+    hostkey_method_ssh_rsa_sha2_512_signv,
+    NULL,                       /* encrypt */
+    hostkey_method_ssh_rsa_dtor,
+};
+
+#endif /* LIBSSH2_RSA_SHA2 */
+
+#if LIBSSH2_RSA_SHA1
+
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa_cert = {
+    "ssh-rsa-cert-v01@openssh.com",
+    SHA_DIGEST_LENGTH,
+    NULL,
+    hostkey_method_ssh_rsa_initPEM,
+    hostkey_method_ssh_rsa_initPEMFromMemory,
+    NULL,
+    hostkey_method_ssh_rsa_signv,
+    NULL,                       /* encrypt */
+    hostkey_method_ssh_rsa_dtor,
+};
+
+#endif /* LIBSSH2_RSA_SHA1 */
+
+#if LIBSSH2_RSA_SHA2
+
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa_sha2_256_cert = {
+     "rsa-sha2-256-cert-v01@openssh.com",
+     SHA256_DIGEST_LENGTH,
+     NULL,
+     hostkey_method_ssh_rsa_initPEM,
+     hostkey_method_ssh_rsa_initPEMFromMemory,
+     NULL,
+     hostkey_method_ssh_rsa_sha2_256_signv,
+     NULL,                       /* encrypt */
+     hostkey_method_ssh_rsa_dtor,
+};
+
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_rsa_sha2_512_cert = {
+     "rsa-sha2-512-cert-v01@openssh.com",
+     SHA512_DIGEST_LENGTH,
+     NULL,
+     hostkey_method_ssh_rsa_initPEM,
+     hostkey_method_ssh_rsa_initPEMFromMemory,
+     NULL,
+     hostkey_method_ssh_rsa_sha2_512_signv,
+     NULL,                       /* encrypt */
+     hostkey_method_ssh_rsa_dtor,
+};
+
+#endif /* LIBSSH2_RSA_SHA2 */
+
 #endif /* LIBSSH2_RSA */
 
 #if LIBSSH2_DSA
@@ -292,8 +558,8 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
     }
 
     if(hostkey_data_len < 27) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
+        _libssh2_debug((session, LIBSSH2_TRACE_ERROR,
+                       "host key length too short"));
         return -1;
     }
 
@@ -305,7 +571,7 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
         return -1;
 
     if(_libssh2_get_string(&buf, &p, &p_len))
-       return -1;
+        return -1;
 
     if(_libssh2_get_string(&buf, &q, &q_len))
         return -1;
@@ -316,8 +582,15 @@ hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
     if(_libssh2_get_string(&buf, &y, &y_len))
         return -1;
 
-    if(_libssh2_dsa_new(&dsactx, p, p_len, q, q_len,
-                        g, g_len, y, y_len, NULL, 0)) {
+    if(!_libssh2_eob(&buf))
+        return -1;
+
+    if(_libssh2_dsa_new(&dsactx,
+                        p, (unsigned long)p_len,
+                        q, (unsigned long)q_len,
+                        g, (unsigned long)g_len,
+                        y, (unsigned long)y_len,
+                        NULL, 0)) {
         return -1;
     }
 
@@ -431,6 +704,12 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
     libssh2_sha1_ctx ctx;
     int i;
 
+    if(!libssh2_sha1_init(&ctx)) {
+        *signature = NULL;
+        *signature_len = 0;
+        return -1;
+    }
+
     *signature = LIBSSH2_CALLOC(session, 2 * SHA_DIGEST_LENGTH);
     if(!*signature) {
         return -1;
@@ -438,11 +717,15 @@ hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
 
     *signature_len = 2 * SHA_DIGEST_LENGTH;
 
-    libssh2_sha1_init(&ctx);
     for(i = 0; i < veccount; i++) {
-        libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
+        if(!libssh2_sha1_update(ctx,
+                                datavec[i].iov_base, datavec[i].iov_len)) {
+            return -1;
+        }
+    }
+    if(!libssh2_sha1_final(ctx, hash)) {
+        return -1;
     }
-    libssh2_sha1_final(ctx, hash);
 
     if(_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
         LIBSSH2_FREE(session, *signature);
@@ -461,7 +744,7 @@ static int
 hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
     libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
-    (void) session;
+    (void)session;
 
     _libssh2_dsa_free(dsactx);
 
@@ -472,7 +755,7 @@ hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract)
 
 static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_dss = {
     "ssh-dss",
-    MD5_DIGEST_LENGTH,
+    SHA_DIGEST_LENGTH,
     hostkey_method_ssh_dss_init,
     hostkey_method_ssh_dss_initPEM,
     hostkey_method_ssh_dss_initPEMFromMemory,
@@ -500,9 +783,9 @@ hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session,
  */
 static int
 hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
-                          const unsigned char *hostkey_data,
-                          size_t hostkey_data_len,
-                          void **abstract)
+                              const unsigned char *hostkey_data,
+                              size_t hostkey_data_len,
+                              void **abstract)
 {
     libssh2_ecdsa_ctx *ecdsactx = NULL;
     unsigned char *type_str, *domain, *public_key;
@@ -510,14 +793,14 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
     libssh2_curve_type type;
     struct string_buf buf;
 
-    if(abstract != NULL && *abstract) {
+    if(abstract && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
 
     if(hostkey_data_len < 39) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
+        _libssh2_debug((session, LIBSSH2_TRACE_ERROR,
+                       "host key length too short"));
         return -1;
     }
 
@@ -561,11 +844,14 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
     if(_libssh2_get_string(&buf, &public_key, &key_len))
         return -1;
 
+    if(!_libssh2_eob(&buf))
+        return -1;
+
     if(_libssh2_ecdsa_curve_name_with_octal_new(&ecdsactx, public_key,
                                                 key_len, type))
         return -1;
 
-    if(abstract != NULL)
+    if(abstract)
         *abstract = ecdsactx;
 
     return 0;
@@ -578,14 +864,14 @@ hostkey_method_ssh_ecdsa_init(LIBSSH2_SESSION * session,
  */
 static int
 hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
-                             const char *privkeyfile,
-                             unsigned const char *passphrase,
-                             void **abstract)
+                                 const char *privkeyfile,
+                                 unsigned const char *passphrase,
+                                 void **abstract)
 {
     libssh2_ecdsa_ctx *ec_ctx = NULL;
     int ret;
 
-    if(abstract != NULL && *abstract) {
+    if(abstract && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -593,7 +879,7 @@ hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
     ret = _libssh2_ecdsa_new_private(&ec_ctx, session,
                                      privkeyfile, passphrase);
 
-    if(abstract != NULL)
+    if(abstract)
         *abstract = ec_ctx;
 
     return ret;
@@ -606,15 +892,15 @@ hostkey_method_ssh_ecdsa_initPEM(LIBSSH2_SESSION * session,
  */
 static int
 hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
-                                         const char *privkeyfiledata,
-                                         size_t privkeyfiledata_len,
-                                         unsigned const char *passphrase,
-                                         void **abstract)
+                                           const char *privkeyfiledata,
+                                           size_t privkeyfiledata_len,
+                                           unsigned const char *passphrase,
+                                           void **abstract)
 {
     libssh2_ecdsa_ctx *ec_ctx = NULL;
     int ret;
 
-    if(abstract != NULL && *abstract) {
+    if(abstract && *abstract) {
         hostkey_method_ssh_ecdsa_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -627,7 +913,7 @@ hostkey_method_ssh_ecdsa_initPEMFromMemory(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    if(abstract != NULL)
+    if(abstract)
         *abstract = ec_ctx;
 
     return 0;
@@ -651,7 +937,7 @@ hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
     struct string_buf buf;
     libssh2_ecdsa_ctx *ctx = (libssh2_ecdsa_ctx *) (*abstract);
 
-    (void) session;
+    (void)session;
 
     if(sig_len < 35)
         return -1;
@@ -662,14 +948,14 @@ hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
     buf.dataptr = buf.data;
     buf.len = sig_len;
 
-   if(_libssh2_get_string(&buf, &name, &name_len) || name_len != 19)
+    if(_libssh2_get_string(&buf, &name, &name_len) || name_len != 19)
         return -1;
 
     if(_libssh2_get_u32(&buf, &len) != 0 || len < 8)
         return -1;
 
     if(_libssh2_get_string(&buf, &r, &r_len))
-       return -1;
+        return -1;
 
     if(_libssh2_get_string(&buf, &s, &s_len))
         return -1;
@@ -678,21 +964,34 @@ hostkey_method_ssh_ecdsa_sig_verify(LIBSSH2_SESSION * session,
 }
 
 
-#define LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(digest_type)               \
-    {                                                                   \
-        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
-        libssh2_sha##digest_type##_ctx ctx;                             \
-        int i;                                                          \
-        libssh2_sha##digest_type##_init(&ctx);                          \
-        for(i = 0; i < veccount; i++) {                                 \
-            libssh2_sha##digest_type##_update(ctx, datavec[i].iov_base, \
-                                              datavec[i].iov_len);      \
-        }                                                               \
-        libssh2_sha##digest_type##_final(ctx, hash);                    \
-        ret = _libssh2_ecdsa_sign(session, ec_ctx, hash,                \
-                                  SHA##digest_type##_DIGEST_LENGTH,     \
-                                  signature, signature_len);            \
-    }
+#define LIBSSH2_HOSTKEY_METHOD_EC_SIGNV_HASH(digest_type)                \
+    do {                                                                 \
+        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];            \
+        libssh2_sha##digest_type##_ctx ctx;                              \
+        int i;                                                           \
+        if(!libssh2_sha##digest_type##_init(&ctx)) {                     \
+            ret = -1;                                                    \
+            break;                                                       \
+        }                                                                \
+        for(i = 0; i < veccount; i++) {                                  \
+            if(!libssh2_sha##digest_type##_update(ctx,                   \
+                                                  datavec[i].iov_base,   \
+                                                  datavec[i].iov_len)) { \
+                ret = -1;                                                \
+                break;                                                   \
+            }                                                            \
+        }                                                                \
+        if(ret == -1) {                                                  \
+            break;                                                       \
+        }                                                                \
+        if(!libssh2_sha##digest_type##_final(ctx, hash)) {               \
+            ret = -1;                                                    \
+            break;                                                       \
+        }                                                                \
+        ret = _libssh2_ecdsa_sign(session, ec_ctx, hash,                 \
+                                  SHA##digest_type##_DIGEST_LENGTH,      \
+                                  signature, signature_len);             \
+    } while(0)
 
 
 /*
@@ -737,9 +1036,9 @@ static int
 hostkey_method_ssh_ecdsa_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
     libssh2_ecdsa_ctx *keyctx = (libssh2_ecdsa_ctx *) (*abstract);
-    (void) session;
+    (void)session;
 
-    if(keyctx != NULL)
+    if(keyctx)
         _libssh2_ecdsa_free(keyctx);
 
     *abstract = NULL;
@@ -841,9 +1140,10 @@ hostkey_method_ssh_ed25519_init(LIBSSH2_SESSION * session,
                                 size_t hostkey_data_len,
                                 void **abstract)
 {
-    const unsigned char *s;
-    unsigned long len, key_len;
+    size_t key_len;
+    unsigned char *key;
     libssh2_ed25519_ctx *ctx = NULL;
+    struct string_buf buf;
 
     if(*abstract) {
         hostkey_method_ssh_ed25519_dtor(session, abstract);
@@ -851,26 +1151,26 @@ hostkey_method_ssh_ed25519_init(LIBSSH2_SESSION * session,
     }
 
     if(hostkey_data_len < 19) {
-        _libssh2_debug(session, LIBSSH2_TRACE_ERROR,
-                       "host key length too short");
+        _libssh2_debug((session, LIBSSH2_TRACE_ERROR,
+                       "host key length too short"));
         return -1;
     }
 
-    s = hostkey_data;
-    len = _libssh2_ntohu32(s);
-    s += 4;
+    buf.data = (unsigned char *)hostkey_data;
+    buf.dataptr = buf.data;
+    buf.len = hostkey_data_len;
 
-    if(len != 11 || strncmp((char *) s, "ssh-ed25519", 11) != 0) {
+    if(_libssh2_match_string(&buf, "ssh-ed25519"))
         return -1;
-    }
-
-    s += 11;
 
     /* public key */
-    key_len = _libssh2_ntohu32(s);
-    s += 4;
+    if(_libssh2_get_string(&buf, &key, &key_len))
+        return -1;
 
-    if(_libssh2_ed25519_new_public(&ctx, session, s, key_len) != 0) {
+    if(!_libssh2_eob(&buf))
+        return -1;
+
+    if(_libssh2_ed25519_new_public(&ctx, session, key, key_len) != 0) {
         return -1;
     }
 
@@ -886,9 +1186,9 @@ hostkey_method_ssh_ed25519_init(LIBSSH2_SESSION * session,
  */
 static int
 hostkey_method_ssh_ed25519_initPEM(LIBSSH2_SESSION * session,
-                             const char *privkeyfile,
-                             unsigned const char *passphrase,
-                             void **abstract)
+                                   const char *privkeyfile,
+                                   unsigned const char *passphrase,
+                                   void **abstract)
 {
     libssh2_ed25519_ctx *ec_ctx = NULL;
     int ret;
@@ -924,7 +1224,7 @@ hostkey_method_ssh_ed25519_initPEMFromMemory(LIBSSH2_SESSION * session,
     libssh2_ed25519_ctx *ed_ctx = NULL;
     int ret;
 
-    if(abstract != NULL && *abstract) {
+    if(abstract && *abstract) {
         hostkey_method_ssh_ed25519_dtor(session, abstract);
         *abstract = NULL;
     }
@@ -937,7 +1237,7 @@ hostkey_method_ssh_ed25519_initPEMFromMemory(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    if(abstract != NULL)
+    if(abstract)
         *abstract = ed_ctx;
 
     return 0;
@@ -956,7 +1256,7 @@ hostkey_method_ssh_ed25519_sig_verify(LIBSSH2_SESSION * session,
                                       size_t m_len, void **abstract)
 {
     libssh2_ed25519_ctx *ctx = (libssh2_ed25519_ctx *) (*abstract);
-    (void) session;
+    (void)session;
 
     if(sig_len < 19)
         return -1;
@@ -979,11 +1279,11 @@ hostkey_method_ssh_ed25519_sig_verify(LIBSSH2_SESSION * session,
  */
 static int
 hostkey_method_ssh_ed25519_signv(LIBSSH2_SESSION * session,
-                           unsigned char **signature,
-                           size_t *signature_len,
-                           int veccount,
-                           const struct iovec datavec[],
-                           void **abstract)
+                                 unsigned char **signature,
+                                 size_t *signature_len,
+                                 int veccount,
+                                 const struct iovec datavec[],
+                                 void **abstract)
 {
     libssh2_ed25519_ctx *ctx = (libssh2_ed25519_ctx *) (*abstract);
 
@@ -992,7 +1292,8 @@ hostkey_method_ssh_ed25519_signv(LIBSSH2_SESSION * session,
     }
 
     return _libssh2_ed25519_sign(ctx, session, signature, signature_len,
-                                 datavec[0].iov_base, datavec[0].iov_len);
+                                 (const uint8_t *)datavec[0].iov_base,
+                                 datavec[0].iov_len);
 }
 
 
@@ -1005,7 +1306,7 @@ static int
 hostkey_method_ssh_ed25519_dtor(LIBSSH2_SESSION * session, void **abstract)
 {
     libssh2_ed25519_ctx *keyctx = (libssh2_ed25519_ctx*) (*abstract);
-    (void) session;
+    (void)session;
 
     if(keyctx)
         _libssh2_ed25519_free(keyctx);
@@ -1027,7 +1328,19 @@ static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_ed25519 = {
     hostkey_method_ssh_ed25519_dtor,
 };
 
-#endif /*LIBSSH2_ED25519*/
+static const LIBSSH2_HOSTKEY_METHOD hostkey_method_ssh_ed25519_cert = {
+    "ssh-ed25519-cert-v01@openssh.com",
+    SHA256_DIGEST_LENGTH,
+    hostkey_method_ssh_ed25519_init,
+    hostkey_method_ssh_ed25519_initPEM,
+    hostkey_method_ssh_ed25519_initPEMFromMemory,
+    hostkey_method_ssh_ed25519_sig_verify,
+    hostkey_method_ssh_ed25519_signv,
+    NULL,                       /* encrypt */
+    hostkey_method_ssh_ed25519_dtor,
+};
+
+#endif /* LIBSSH2_ED25519 */
 
 
 static const LIBSSH2_HOSTKEY_METHOD *hostkey_methods[] = {
@@ -1041,9 +1354,19 @@ static const LIBSSH2_HOSTKEY_METHOD *hostkey_methods[] = {
 #endif
 #if LIBSSH2_ED25519
     &hostkey_method_ssh_ed25519,
+    &hostkey_method_ssh_ed25519_cert,
 #endif
 #if LIBSSH2_RSA
+#if LIBSSH2_RSA_SHA2
+    &hostkey_method_ssh_rsa_sha2_512,
+    &hostkey_method_ssh_rsa_sha2_256,
+    &hostkey_method_ssh_rsa_sha2_512_cert,
+    &hostkey_method_ssh_rsa_sha2_256_cert,
+#endif /* LIBSSH2_RSA_SHA2 */
+#if LIBSSH2_RSA_SHA1
     &hostkey_method_ssh_rsa,
+    &hostkey_method_ssh_rsa_cert,
+#endif /* LIBSSH2_RSA_SHA1 */
 #endif /* LIBSSH2_RSA */
 #if LIBSSH2_DSA
     &hostkey_method_ssh_dss,
@@ -1074,18 +1397,15 @@ libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type)
         return (session->server_hostkey_md5_valid)
           ? (char *) session->server_hostkey_md5
           : NULL;
-        break;
 #endif /* LIBSSH2_MD5 */
     case LIBSSH2_HOSTKEY_HASH_SHA1:
         return (session->server_hostkey_sha1_valid)
           ? (char *) session->server_hostkey_sha1
           : NULL;
-        break;
     case LIBSSH2_HOSTKEY_HASH_SHA256:
         return (session->server_hostkey_sha256_valid)
           ? (char *) session->server_hostkey_sha256
           : NULL;
-        break;
     default:
         return NULL;
     }
@@ -1096,9 +1416,11 @@ static int hostkey_type(const unsigned char *hostkey, size_t len)
     static const unsigned char rsa[] = {
         0, 0, 0, 0x07, 's', 's', 'h', '-', 'r', 's', 'a'
     };
+#if LIBSSH2_DSA
     static const unsigned char dss[] = {
         0, 0, 0, 0x07, 's', 's', 'h', '-', 'd', 's', 's'
     };
+#endif
     static const unsigned char ecdsa_256[] = {
         0, 0, 0, 0x13, 'e', 'c', 'd', 's', 'a', '-', 's', 'h', 'a', '2', '-',
         'n', 'i', 's', 't', 'p', '2', '5', '6'
@@ -1121,8 +1443,10 @@ static int hostkey_type(const unsigned char *hostkey, size_t len)
     if(!memcmp(rsa, hostkey, 11))
         return LIBSSH2_HOSTKEY_TYPE_RSA;
 
+#if LIBSSH2_DSA
     if(!memcmp(dss, hostkey, 11))
         return LIBSSH2_HOSTKEY_TYPE_DSS;
+#endif
 
     if(len < 15)
         return LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
@@ -1146,7 +1470,7 @@ static int hostkey_type(const unsigned char *hostkey, size_t len)
 }
 
 /*
- * libssh2_session_hostkey()
+ * libssh2_session_hostkey
  *
  * Returns the server key and length.
  *
diff --git a/libssh2/src/keepalive.c b/libssh2/src/keepalive.c
index 2151b171..489a1daa 100644
--- a/libssh2/src/keepalive.c
+++ b/libssh2/src/keepalive.c
@@ -1,5 +1,5 @@
-/* Copyright (C) 2010  Simon Josefsson
- * Author: Simon Josefsson
+/* Copyright (C) Simon Josefsson
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -34,6 +34,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -42,9 +43,9 @@
 /* Keep-alive stuff. */
 
 LIBSSH2_API void
-libssh2_keepalive_config (LIBSSH2_SESSION *session,
-                          int want_reply,
-                          unsigned interval)
+libssh2_keepalive_config(LIBSSH2_SESSION *session,
+                         int want_reply,
+                         unsigned int interval)
 {
     if(interval == 1)
         session->keepalive_interval = 2;
@@ -54,8 +55,8 @@ libssh2_keepalive_config (LIBSSH2_SESSION *session,
 }
 
 LIBSSH2_API int
-libssh2_keepalive_send (LIBSSH2_SESSION *session,
-                        int *seconds_to_next)
+libssh2_keepalive_send(LIBSSH2_SESSION *session,
+                       int *seconds_to_next)
 {
     time_t now;
 
diff --git a/libssh2/src/kex.c b/libssh2/src/kex.c
index 9f3ef799..4ca9c34c 100644
--- a/libssh2/src/kex.c
+++ b/libssh2/src/kex.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2019, Daniel Stenberg <daniel@haxx.se>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg <daniel@haxx.se>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -53,8 +55,9 @@
 /* Helper macro called from
    kex_method_diffie_hellman_group1_sha1_key_exchange */
 
+#if LIBSSH2_ECDSA
 #define LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(value, reqlen, version)        \
-    {                                                                       \
+    do {                                                                    \
         if(type == LIBSSH2_EC_CURVE_NISTP256) {                             \
             LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(256, value, reqlen, version); \
         }                                                                   \
@@ -64,39 +67,57 @@
         else if(type == LIBSSH2_EC_CURVE_NISTP521) {                        \
             LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(512, value, reqlen, version); \
         }                                                                   \
-    }                                                                       \
-
+    } while(0)
+#endif
 
 #define LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(digest_type, value,               \
                                           reqlen, version)                  \
-{                                                                           \
+do {                                                                        \
     libssh2_sha##digest_type##_ctx hash;                                    \
-    unsigned long len = 0;                                                  \
+    size_t len = 0;                                                         \
     if(!(value)) {                                                          \
         value = LIBSSH2_ALLOC(session,                                      \
                               reqlen + SHA##digest_type##_DIGEST_LENGTH);   \
     }                                                                       \
     if(value)                                                               \
-        while(len < (unsigned long)reqlen) {                                \
-            libssh2_sha##digest_type##_init(&hash);                         \
-            libssh2_sha##digest_type##_update(hash,                         \
-                                              exchange_state->k_value,      \
-                                              exchange_state->k_value_len); \
-            libssh2_sha##digest_type##_update(hash,                         \
-                                              exchange_state->h_sig_comp,   \
-                                         SHA##digest_type##_DIGEST_LENGTH); \
+        while(len < (size_t)reqlen) {                                       \
+            if(!libssh2_sha##digest_type##_init(&hash) ||                   \
+               !libssh2_sha##digest_type##_update(hash,                     \
+                                       exchange_state->k_value,             \
+                                       exchange_state->k_value_len) ||      \
+               !libssh2_sha##digest_type##_update(hash,                     \
+                                       exchange_state->h_sig_comp,          \
+                                       SHA##digest_type##_DIGEST_LENGTH)) { \
+                LIBSSH2_FREE(session, value);                               \
+                value = NULL;                                               \
+                break;                                                      \
+            }                                                               \
             if(len > 0) {                                                   \
-                libssh2_sha##digest_type##_update(hash, value, len);        \
+                if(!libssh2_sha##digest_type##_update(hash, value, len)) {  \
+                    LIBSSH2_FREE(session, value);                           \
+                    value = NULL;                                           \
+                    break;                                                  \
+                }                                                           \
             }                                                               \
             else {                                                          \
-                libssh2_sha##digest_type##_update(hash, (version), 1);      \
-                libssh2_sha##digest_type##_update(hash, session->session_id,\
-                                                  session->session_id_len); \
+                if(!libssh2_sha##digest_type##_update(hash,                 \
+                                                      (version), 1) ||      \
+                   !libssh2_sha##digest_type##_update(hash,                 \
+                                                session->session_id,        \
+                                                session->session_id_len)) { \
+                    LIBSSH2_FREE(session, value);                           \
+                    value = NULL;                                           \
+                    break;                                                  \
+                }                                                           \
+            }                                                               \
+            if(!libssh2_sha##digest_type##_final(hash, (value) + len)) {    \
+                LIBSSH2_FREE(session, value);                               \
+                value = NULL;                                               \
+                break;                                                      \
             }                                                               \
-            libssh2_sha##digest_type##_final(hash, (value) + len);          \
             len += SHA##digest_type##_DIGEST_LENGTH;                        \
         }                                                                   \
-}
+} while(0)
 
 /*!
  * @note The following are wrapper functions used by diffie_hellman_sha_algo().
@@ -105,82 +126,87 @@
  * don't allow it so we have to wrap them up in helper functions
  */
 
-static void _libssh2_sha_algo_ctx_init(int sha_algo, void *ctx)
+static int _libssh2_sha_algo_ctx_init(int sha_algo, void *ctx)
 {
     if(sha_algo == 512) {
-        libssh2_sha512_init((libssh2_sha512_ctx*)ctx);
+        return libssh2_sha512_init((libssh2_sha512_ctx*)ctx);
     }
     else if(sha_algo == 384) {
-        libssh2_sha384_init((libssh2_sha384_ctx*)ctx);
+        return libssh2_sha384_init((libssh2_sha384_ctx*)ctx);
     }
     else if(sha_algo == 256) {
-        libssh2_sha256_init((libssh2_sha256_ctx*)ctx);
+        return libssh2_sha256_init((libssh2_sha256_ctx*)ctx);
     }
     else if(sha_algo == 1) {
-        libssh2_sha1_init((libssh2_sha1_ctx*)ctx);
+        return libssh2_sha1_init((libssh2_sha1_ctx*)ctx);
     }
     else {
+#ifdef LIBSSH2DEBUG
         assert(0);
+#endif
     }
+    return 0;
 }
 
-static void _libssh2_sha_algo_ctx_update(int sha_algo, void *ctx,
-                                         void *data, size_t len)
+static int _libssh2_sha_algo_ctx_update(int sha_algo, void *ctx,
+                                        void *data, size_t len)
 {
     if(sha_algo == 512) {
         libssh2_sha512_ctx *_ctx = (libssh2_sha512_ctx*)ctx;
-        libssh2_sha512_update(*_ctx, data, len);
+        return libssh2_sha512_update(*_ctx, data, len);
     }
     else if(sha_algo == 384) {
         libssh2_sha384_ctx *_ctx = (libssh2_sha384_ctx*)ctx;
-        libssh2_sha384_update(*_ctx, data, len);
+        return libssh2_sha384_update(*_ctx, data, len);
     }
     else if(sha_algo == 256) {
         libssh2_sha256_ctx *_ctx = (libssh2_sha256_ctx*)ctx;
-        libssh2_sha256_update(*_ctx, data, len);
+        return libssh2_sha256_update(*_ctx, data, len);
     }
     else if(sha_algo == 1) {
         libssh2_sha1_ctx *_ctx = (libssh2_sha1_ctx*)ctx;
-        libssh2_sha1_update(*_ctx, data, len);
+        return libssh2_sha1_update(*_ctx, data, len);
     }
     else {
-#if LIBSSH2DEBUG
+#ifdef LIBSSH2DEBUG
         assert(0);
 #endif
     }
+    return 0;
 }
 
-static void _libssh2_sha_algo_ctx_final(int sha_algo, void *ctx,
-                                        void *hash)
+static int _libssh2_sha_algo_ctx_final(int sha_algo, void *ctx,
+                                       void *hash)
 {
     if(sha_algo == 512) {
         libssh2_sha512_ctx *_ctx = (libssh2_sha512_ctx*)ctx;
-        libssh2_sha512_final(*_ctx, hash);
+        return libssh2_sha512_final(*_ctx, hash);
     }
     else if(sha_algo == 384) {
         libssh2_sha384_ctx *_ctx = (libssh2_sha384_ctx*)ctx;
-        libssh2_sha384_final(*_ctx, hash);
+        return libssh2_sha384_final(*_ctx, hash);
     }
     else if(sha_algo == 256) {
         libssh2_sha256_ctx *_ctx = (libssh2_sha256_ctx*)ctx;
-        libssh2_sha256_final(*_ctx, hash);
+        return libssh2_sha256_final(*_ctx, hash);
     }
     else if(sha_algo == 1) {
         libssh2_sha1_ctx *_ctx = (libssh2_sha1_ctx*)ctx;
-        libssh2_sha1_final(*_ctx, hash);
+        return libssh2_sha1_final(*_ctx, hash);
     }
     else {
-#if LIBSSH2DEBUG
+#ifdef LIBSSH2DEBUG
         assert(0);
 #endif
     }
+    return 0;
 }
 
 static void _libssh2_sha_algo_value_hash(int sha_algo,
-                                      LIBSSH2_SESSION *session,
-                                      kmdhgGPshakex_state_t *exchange_state,
-                                      unsigned char **data, size_t data_len,
-                                      const unsigned char *version)
+                                         LIBSSH2_SESSION *session,
+                                         kmdhgGPshakex_state_t *exchange_state,
+                                         unsigned char **data, size_t data_len,
+                                         const unsigned char *version)
 {
     if(sha_algo == 512) {
         LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(512, *data, data_len, version);
@@ -195,13 +221,67 @@ static void _libssh2_sha_algo_value_hash(int sha_algo,
         LIBSSH2_KEX_METHOD_SHA_VALUE_HASH(1, *data, data_len, version);
     }
     else {
-#if LIBSSH2DEBUG
+#ifdef LIBSSH2DEBUG
         assert(0);
 #endif
     }
 }
 
 
+static void
+diffie_hellman_state_cleanup(LIBSSH2_SESSION * session,
+                             kmdhgGPshakex_state_t *exchange_state)
+{
+    libssh2_dh_dtor(&exchange_state->x);
+    _libssh2_bn_free(exchange_state->e);
+    exchange_state->e = NULL;
+    _libssh2_bn_free(exchange_state->f);
+    exchange_state->f = NULL;
+    _libssh2_bn_free(exchange_state->k);
+    exchange_state->k = NULL;
+    _libssh2_bn_ctx_free(exchange_state->ctx);
+    exchange_state->ctx = NULL;
+
+    if(exchange_state->e_packet) {
+        LIBSSH2_FREE(session, exchange_state->e_packet);
+        exchange_state->e_packet = NULL;
+    }
+
+    if(exchange_state->s_packet) {
+        LIBSSH2_FREE(session, exchange_state->s_packet);
+        exchange_state->s_packet = NULL;
+    }
+
+    if(exchange_state->k_value) {
+        LIBSSH2_FREE(session, exchange_state->k_value);
+        exchange_state->k_value = NULL;
+    }
+
+    exchange_state->state = libssh2_NB_state_idle;
+}
+
+static void
+kex_diffie_hellman_cleanup(LIBSSH2_SESSION * session,
+                           key_exchange_state_low_t * key_state) {
+    if(key_state->state != libssh2_NB_state_idle) {
+        _libssh2_bn_free(key_state->p);
+        key_state->p = NULL;
+        _libssh2_bn_free(key_state->g);
+        key_state->g = NULL;
+
+        if(key_state->data) {
+            LIBSSH2_FREE(session, key_state->data);
+            key_state->data = NULL;
+        }
+        key_state->state = libssh2_NB_state_idle;
+    }
+
+    if(key_state->exchange_state.state != libssh2_NB_state_idle) {
+        diffie_hellman_state_cleanup(session, &key_state->exchange_state);
+    }
+}
+
+
 /*!
  * @function diffie_hellman_sha_algo
  * @abstract Diffie Hellman Key Exchange, Group Agnostic,
@@ -217,7 +297,7 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                                    unsigned char packet_type_init,
                                    unsigned char packet_type_reply,
                                    unsigned char *midhash,
-                                   unsigned long midhash_len,
+                                   size_t midhash_len,
                                    kmdhgGPshakex_state_t *exchange_state)
 {
     int ret = 0;
@@ -235,7 +315,7 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         digest_len = SHA1_DIGEST_LENGTH;
     else {
         ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                            "sha algo value is unimplemented");
+                             "sha algo value is unimplemented");
         goto clean_exit;
     }
 
@@ -264,8 +344,11 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
 
         rc = libssh2_dh_key_pair(&exchange_state->x, exchange_state->e, g, p,
                                  group_order, exchange_state->ctx);
-        if(rc)
+        if(rc) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
+                                 "dh key pair generation failed");
             goto clean_exit;
+        }
 
         /* Send KEX init */
         /* packet_type(1) + String Length(4) + leading 0(1) */
@@ -285,19 +368,27 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         }
         exchange_state->e_packet[0] = packet_type_init;
         _libssh2_htonu32(exchange_state->e_packet + 1,
-                         exchange_state->e_packet_len - 5);
+                         (uint32_t)(exchange_state->e_packet_len - 5));
         if(_libssh2_bn_bits(exchange_state->e) % 8) {
-            _libssh2_bn_to_bin(exchange_state->e,
-                               exchange_state->e_packet + 5);
+            if(_libssh2_bn_to_bin(exchange_state->e,
+                                  exchange_state->e_packet + 5)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->e");
+                goto clean_exit;
+            }
         }
         else {
             exchange_state->e_packet[5] = 0;
-            _libssh2_bn_to_bin(exchange_state->e,
-                               exchange_state->e_packet + 6);
+            if(_libssh2_bn_to_bin(exchange_state->e,
+                                  exchange_state->e_packet + 6)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->e");
+                goto clean_exit;
+            }
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending KEX packet %d",
-                       (int) packet_type_init);
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX, "Sending KEX packet %u",
+                       (unsigned int) packet_type_init));
         exchange_state->state = libssh2_NB_state_created;
     }
 
@@ -323,9 +414,9 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
              * need to silently ignore it */
             int burn_type;
 
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
                            "Waiting for badly guessed KEX packet "
-                           "(to be ignored)");
+                           "(to be ignored)"));
             burn_type =
                 _libssh2_packet_burn(session, &exchange_state->burn_state);
             if(burn_type == LIBSSH2_ERROR_EAGAIN) {
@@ -338,9 +429,9 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
             }
             session->burn_optimistic_kexinit = 0;
 
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
                            "Burnt packet of type: %02x",
-                           (unsigned int) burn_type);
+                           (unsigned int) burn_type));
         }
 
         exchange_state->state = libssh2_NB_state_sent1;
@@ -350,6 +441,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         /* Wait for KEX reply */
         struct string_buf buf;
         size_t host_key_len;
+        int err;
+        int hok;
 
         rc = _libssh2_packet_require(session, packet_type_reply,
                                      &exchange_state->s_packet,
@@ -367,7 +460,7 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         /* Parse KEXDH_REPLY */
         if(exchange_state->s_packet_len < 5) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected packet length");
+                                 "Unexpected packet length DH-SHA");
             goto clean_exit;
         }
 
@@ -376,8 +469,11 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         buf.dataptr = buf.data;
         buf.dataptr++; /* advance past type */
 
-        if(session->server_hostkey)
+        if(session->server_hostkey) {
             LIBSSH2_FREE(session, session->server_hostkey);
+            session->server_hostkey = NULL;
+            session->server_hostkey_len = 0;
+        }
 
         if(_libssh2_copy_string(session, &buf, &(session->server_hostkey),
                                 &host_key_len)) {
@@ -392,11 +488,11 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
+            if(libssh2_md5_init(&fingerprint_ctx) &&
+               libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
+                                  session->server_hostkey_len) &&
+               libssh2_md5_final(fingerprint_ctx,
+                                 session->server_hostkey_md5)) {
                 session->server_hostkey_md5_valid = TRUE;
             }
             else {
@@ -411,8 +507,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's MD5 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's MD5 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 #endif /* ! LIBSSH2_MD5 */
@@ -420,11 +516,11 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
+            if(libssh2_sha1_init(&fingerprint_ctx) &&
+               libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
+                                   session->server_hostkey_len) &&
+               libssh2_sha1_final(fingerprint_ctx,
+                                  session->server_hostkey_sha1)) {
                 session->server_hostkey_sha1_valid = TRUE;
             }
             else {
@@ -435,24 +531,23 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         {
             char fingerprint[64], *fprint = fingerprint;
             int i;
-
             for(i = 0; i < 20; i++, fprint += 3) {
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's SHA1 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's SHA1 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
+            if(libssh2_sha256_init(&fingerprint_ctx) &&
+               libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
+                                     session->server_hostkey_len) &&
+               libssh2_sha256_final(fingerprint_ctx,
+                                    session->server_hostkey_sha256)) {
                 session->server_hostkey_sha256_valid = TRUE;
             }
             else {
@@ -466,10 +561,10 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                                    (const char *)
                                    session->server_hostkey_sha256,
                                    SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+            if(base64Fingerprint) {
+                _libssh2_debug((session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
+                               base64Fingerprint));
                 LIBSSH2_FREE(session, base64Fingerprint);
             }
         }
@@ -477,27 +572,33 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
 
 
         if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
+                                  session->server_hostkey_len,
+                                  &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
+                                 "Unable to initialize hostkey importer "
+                                 "DH-SHA");
             goto clean_exit;
         }
 
         if(_libssh2_get_string(&buf, &(exchange_state->f_value),
                                &(exchange_state->f_value_len))) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to get f value");
+                                 "Unable to get DH-SHA f value");
             goto clean_exit;
         }
 
-        _libssh2_bn_from_bin(exchange_state->f, exchange_state->f_value_len,
-                             exchange_state->f_value);
+        if(_libssh2_bn_from_bin(exchange_state->f,
+                                exchange_state->f_value_len,
+                                exchange_state->f_value)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
+                                 "Invalid DH-SHA f value");
+            goto clean_exit;
+        }
 
         if(_libssh2_get_string(&buf, &(exchange_state->h_sig),
                                &(exchange_state->h_sig_len))) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to get h sig");
+                                 "Unable to get DH-SHA h sig");
             goto clean_exit;
         }
 
@@ -513,127 +614,154 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
             LIBSSH2_ALLOC(session, exchange_state->k_value_len);
         if(!exchange_state->k_value) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate buffer for K");
+                                 "Unable to allocate buffer for DH-SHA K");
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
+                         (uint32_t)(exchange_state->k_value_len - 4));
         if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 4)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->k");
+                goto clean_exit;
+            }
         }
         else {
             exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 5)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->k");
+                goto clean_exit;
+            }
         }
 
         exchange_state->exchange_hash = (void *)&exchange_hash_ctx;
-        _libssh2_sha_algo_ctx_init(sha_algo_value, exchange_hash_ctx);
-
+        if(!_libssh2_sha_algo_ctx_init(sha_algo_value, exchange_hash_ctx)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_HASH_INIT,
+                                 "Unable to initialize hash context");
+            goto clean_exit;
+        }
+        hok = 1;
         if(session->local.banner) {
             _libssh2_htonu32(exchange_state->h_sig_comp,
-                             strlen((char *) session->local.banner) - 2);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                session->local.banner,
-                                strlen((char *) session->local.banner) - 2);
+                (uint32_t)(strlen((char *) session->local.banner) - 2));
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                                exchange_state->h_sig_comp, 4);
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                                session->local.banner,
+                                   strlen((char *) session->local.banner) - 2);
         }
         else {
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                    (unsigned char *)
-                                    LIBSSH2_SSH_DEFAULT_BANNER,
-                                    sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                                exchange_state->h_sig_comp, 4);
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                   (unsigned char *)LIBSSH2_SSH_DEFAULT_BANNER,
+                                       sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
         }
 
         _libssh2_htonu32(exchange_state->h_sig_comp,
-                         strlen((char *) session->remote.banner));
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->remote.banner,
-                                     strlen((char *) session->remote.banner));
+                         (uint32_t)strlen((char *) session->remote.banner));
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->h_sig_comp, 4);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            session->remote.banner,
+                                       strlen((char *)session->remote.banner));
 
         _libssh2_htonu32(exchange_state->h_sig_comp,
-                         session->local.kexinit_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->local.kexinit,
-                                     session->local.kexinit_len);
+                         (uint32_t)session->local.kexinit_len);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->h_sig_comp, 4);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            session->local.kexinit,
+                                            session->local.kexinit_len);
 
         _libssh2_htonu32(exchange_state->h_sig_comp,
-                         session->remote.kexinit_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->remote.kexinit,
-                                     session->remote.kexinit_len);
+                         (uint32_t)session->remote.kexinit_len);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->h_sig_comp, 4);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            session->remote.kexinit,
+                                            session->remote.kexinit_len);
 
         _libssh2_htonu32(exchange_state->h_sig_comp,
                          session->server_hostkey_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     session->server_hostkey,
-                                     session->server_hostkey_len);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->h_sig_comp, 4);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            session->server_hostkey,
+                                            session->server_hostkey_len);
 
         if(packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
             /* diffie-hellman-group-exchange hashes additional fields */
-#ifdef LIBSSH2_DH_GEX_NEW
             _libssh2_htonu32(exchange_state->h_sig_comp,
                              LIBSSH2_DH_GEX_MINGROUP);
             _libssh2_htonu32(exchange_state->h_sig_comp + 4,
                              LIBSSH2_DH_GEX_OPTGROUP);
             _libssh2_htonu32(exchange_state->h_sig_comp + 8,
                              LIBSSH2_DH_GEX_MAXGROUP);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 12);
-#else
-            _libssh2_htonu32(exchange_state->h_sig_comp,
-                             LIBSSH2_DH_GEX_OPTGROUP);
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         exchange_state->h_sig_comp, 4);
-#endif
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                                exchange_state->h_sig_comp,
+                                                12);
         }
 
         if(midhash) {
-            _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                         midhash, midhash_len);
+            hok &= _libssh2_sha_algo_ctx_update(sha_algo_value,
+                                                exchange_hash_ctx,
+                                                midhash, midhash_len);
         }
 
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->e_packet + 1,
-                                     exchange_state->e_packet_len - 1);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->e_packet + 1,
+                                            exchange_state->e_packet_len - 1);
 
         _libssh2_htonu32(exchange_state->h_sig_comp,
-                         exchange_state->f_value_len);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->h_sig_comp, 4);
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->f_value,
-                                     exchange_state->f_value_len);
-
-        _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
-                                     exchange_state->k_value,
-                                     exchange_state->k_value_len);
-
-        _libssh2_sha_algo_ctx_final(sha_algo_value, exchange_hash_ctx,
-                                    exchange_state->h_sig_comp);
-
-        if(session->hostkey->
-           sig_verify(session, exchange_state->h_sig,
-                      exchange_state->h_sig_len, exchange_state->h_sig_comp,
-                      digest_len, &session->server_hostkey_abstract)) {
+                         (uint32_t)exchange_state->f_value_len);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->h_sig_comp, 4);
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->f_value,
+                                            exchange_state->f_value_len);
+
+        hok &= _libssh2_sha_algo_ctx_update(sha_algo_value, exchange_hash_ctx,
+                                            exchange_state->k_value,
+                                            exchange_state->k_value_len);
+
+        if(!hok ||
+           !_libssh2_sha_algo_ctx_final(sha_algo_value, exchange_hash_ctx,
+                                        exchange_state->h_sig_comp)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_HASH_CALC,
+                                 "kex: failed to calculate hash");
+            goto clean_exit;
+        }
+
+        err = session->hostkey->sig_verify(session,
+                                           exchange_state->h_sig,
+                                           exchange_state->h_sig_len,
+                                           exchange_state->h_sig_comp,
+                                           digest_len,
+                                           &session->server_hostkey_abstract);
+
+        if(err) {
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Failed hostkey sig_verify(): %s: %d",
+                           session->hostkey->name, err));
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
+                                 "Unable to verify hostkey signature "
+                                 "DH-SHA");
             goto clean_exit;
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sending NEWKEYS message");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Sending NEWKEYS message"));
         exchange_state->c = SSH_MSG_NEWKEYS;
 
         exchange_state->state = libssh2_NB_state_sent2;
@@ -646,7 +774,7 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
         }
         else if(rc) {
             ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
+                                 "Unable to send NEWKEYS message DH-SHA");
             goto clean_exit;
         }
 
@@ -662,13 +790,16 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
             return rc;
         }
         else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
+            ret = _libssh2_error(session, rc,
+                                 "Timed out waiting for NEWKEYS DH-SHA");
             goto clean_exit;
         }
+
         /* The first key exchange has been performed,
            switch to active crypt/comp/mac mode */
         session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Received NEWKEYS message DH-SHA"));
 
         /* This will actually end up being just packet_type(1)
            for this packet type anyway */
@@ -685,8 +816,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
             memcpy(session->session_id, exchange_state->h_sig_comp,
                    digest_len);
             session->session_id_len = digest_len;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "session_id calculated"));
         }
 
         /* Cleanup any existing cipher */
@@ -739,8 +870,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server IV and Key calculated"));
 
         if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
@@ -789,8 +920,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client IV and Key calculated"));
 
         if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
@@ -816,8 +947,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server HMAC Key calculated"));
 
         if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
@@ -843,8 +974,8 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client HMAC Key calculated"));
 
         /* Initialize compression for each direction */
 
@@ -856,13 +987,13 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
 
         if(session->local.comp && session->local.comp->init) {
             if(session->local.comp->init(session, 1,
-                                          &session->local.comp_abstract)) {
+                                         &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server compression initialized");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server compression initialized"));
 
         if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
@@ -871,43 +1002,18 @@ static int diffie_hellman_sha_algo(LIBSSH2_SESSION *session,
 
         if(session->remote.comp && session->remote.comp->init) {
             if(session->remote.comp->init(session, 0,
-                                           &session->remote.comp_abstract)) {
+                                          &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client compression initialized");
-
-    }
-
-  clean_exit:
-    libssh2_dh_dtor(&exchange_state->x);
-    _libssh2_bn_free(exchange_state->e);
-    exchange_state->e = NULL;
-    _libssh2_bn_free(exchange_state->f);
-    exchange_state->f = NULL;
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-    _libssh2_bn_ctx_free(exchange_state->ctx);
-    exchange_state->ctx = NULL;
-
-    if(exchange_state->e_packet) {
-        LIBSSH2_FREE(session, exchange_state->e_packet);
-        exchange_state->e_packet = NULL;
-    }
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client compression initialized"));
 
-    if(exchange_state->s_packet) {
-        LIBSSH2_FREE(session, exchange_state->s_packet);
-        exchange_state->s_packet = NULL;
-    }
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
     }
 
-    exchange_state->state = libssh2_NB_state_idle;
+clean_exit:
+    diffie_hellman_state_cleanup(session, exchange_state);
 
     return ret;
 }
@@ -951,11 +1057,19 @@ kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
         key_state->g = _libssh2_bn_init();      /* SSH2 defined value (2) */
 
         /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 128, p_value);
+        if(!key_state->g || _libssh2_bn_set_word(key_state->g, 2)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state g.");
+            goto clean_exit;
+        }
+        if(!key_state->p || _libssh2_bn_from_bin(key_state->p, 128, p_value)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state p.");
+            goto clean_exit;
+        }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group1 Key Exchange");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group1 Key Exchange"));
 
         key_state->state = libssh2_NB_state_created;
     }
@@ -968,11 +1082,8 @@ kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session,
         return ret;
     }
 
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    key_state->state = libssh2_NB_state_idle;
+clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
@@ -990,7 +1101,7 @@ typedef int (*diffie_hellman_hash_func_t)(LIBSSH2_SESSION *,
                                           unsigned char,
                                           unsigned char,
                                           unsigned char *,
-                                          unsigned long,
+                                          size_t,
                                           kmdhgGPshakex_state_t *);
 static int
 kex_method_diffie_hellman_group14_key_exchange(LIBSSH2_SESSION *session,
@@ -1044,26 +1155,32 @@ kex_method_diffie_hellman_group14_key_exchange(LIBSSH2_SESSION *session,
 
         /* g == 2 */
         /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 256, p_value);
+        if(!key_state->g || _libssh2_bn_set_word(key_state->g, 2)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state g.");
+            goto clean_exit;
+        }
+        else if(!key_state->p ||
+                _libssh2_bn_from_bin(key_state->p, 256, p_value)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state p.");
+            goto clean_exit;
+        }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group14 Key Exchange");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group14 Key Exchange"));
 
         key_state->state = libssh2_NB_state_created;
     }
     ret = hashfunc(session, key_state->g, key_state->p,
-                256, sha_algo_value, exchange_hash_ctx, SSH_MSG_KEXDH_INIT,
-                SSH_MSG_KEXDH_REPLY, NULL, 0, &key_state->exchange_state);
+                   256, sha_algo_value, exchange_hash_ctx, SSH_MSG_KEXDH_INIT,
+                   SSH_MSG_KEXDH_REPLY, NULL, 0, &key_state->exchange_state);
     if(ret == LIBSSH2_ERROR_EAGAIN) {
         return ret;
     }
 
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
+clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
@@ -1080,9 +1197,9 @@ kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session,
 {
     libssh2_sha1_ctx ctx;
     return kex_method_diffie_hellman_group14_key_exchange(session,
-                                                    key_state, 1,
-                                                    &ctx,
-                                                    diffie_hellman_sha_algo);
+                                                      key_state, 1,
+                                                      &ctx,
+                                                      diffie_hellman_sha_algo);
 }
 
 
@@ -1097,9 +1214,9 @@ kex_method_diffie_hellman_group14_sha256_key_exchange(LIBSSH2_SESSION *session,
 {
     libssh2_sha256_ctx ctx;
     return kex_method_diffie_hellman_group14_key_exchange(session,
-                                                    key_state, 256,
-                                                    &ctx,
-                                                    diffie_hellman_sha_algo);
+                                                      key_state, 256,
+                                                      &ctx,
+                                                      diffie_hellman_sha_algo);
 }
 
 /* kex_method_diffie_hellman_group16_sha512_key_exchange
@@ -1109,7 +1226,6 @@ static int
 kex_method_diffie_hellman_group16_sha512_key_exchange(LIBSSH2_SESSION *session,
                                                       key_exchange_state_low_t
                                                       * key_state)
-
 {
     static const unsigned char p_value[512] = {
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
@@ -1166,11 +1282,19 @@ kex_method_diffie_hellman_group16_sha512_key_exchange(LIBSSH2_SESSION *session,
 
         /* g == 2 */
         /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 512, p_value);
+        if(!key_state->g || _libssh2_bn_set_word(key_state->g, 2)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state g.");
+            goto clean_exit;
+        }
+        if(!key_state->p || _libssh2_bn_from_bin(key_state->p, 512, p_value)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state p.");
+            goto clean_exit;
+        }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group16 Key Exchange");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group16 Key Exchange"));
 
         key_state->state = libssh2_NB_state_created;
     }
@@ -1183,11 +1307,8 @@ kex_method_diffie_hellman_group16_sha512_key_exchange(LIBSSH2_SESSION *session,
         return ret;
     }
 
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
+clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
@@ -1199,7 +1320,6 @@ static int
 kex_method_diffie_hellman_group18_sha512_key_exchange(LIBSSH2_SESSION *session,
                                                       key_exchange_state_low_t
                                                       * key_state)
-
 {
     static const unsigned char p_value[1024] = {
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
@@ -1299,11 +1419,20 @@ kex_method_diffie_hellman_group18_sha512_key_exchange(LIBSSH2_SESSION *session,
 
         /* g == 2 */
         /* Initialize P and G */
-        _libssh2_bn_set_word(key_state->g, 2);
-        _libssh2_bn_from_bin(key_state->p, 1024, p_value);
+        if(!key_state->g || _libssh2_bn_set_word(key_state->g, 2)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state g.");
+            goto clean_exit;
+        }
+        else if(!key_state->p ||
+                _libssh2_bn_from_bin(key_state->p, 1024, p_value)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Failed to allocate key state p.");
+            goto clean_exit;
+        }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group18 Key Exchange");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group18 Key Exchange"));
 
         key_state->state = libssh2_NB_state_created;
     }
@@ -1316,11 +1445,8 @@ kex_method_diffie_hellman_group18_sha512_key_exchange(LIBSSH2_SESSION *session,
         return ret;
     }
 
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
+clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
@@ -1330,8 +1456,9 @@ kex_method_diffie_hellman_group18_sha512_key_exchange(LIBSSH2_SESSION *session,
  * Negotiates random(ish) group for secret derivation
  */
 static int
-kex_method_diffie_hellman_group_exchange_sha1_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
+kex_method_diffie_hellman_group_exchange_sha1_key_exchange(
+                                          LIBSSH2_SESSION * session,
+                                          key_exchange_state_low_t * key_state)
 {
     int ret = 0;
     int rc;
@@ -1340,23 +1467,13 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
         key_state->p = _libssh2_bn_init_from_bin();
         key_state->g = _libssh2_bn_init_from_bin();
         /* Ask for a P and G pair */
-#ifdef LIBSSH2_DH_GEX_NEW
         key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST;
         _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP);
         _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
         _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
         key_state->request_len = 13;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(New Method)");
-#else
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
-        key_state->request_len = 5;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(Old Method)");
-#endif
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group-Exchange SHA1"));
 
         key_state->state = libssh2_NB_state_created;
     }
@@ -1400,7 +1517,7 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
 
         if(key_state->data_len < 9) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
+                                 "Unexpected key length DH-SHA1");
             goto dh_gex_clean_exit;
         }
 
@@ -1412,21 +1529,30 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
 
         if(_libssh2_get_bignum_bytes(&buf, &p, &p_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
+                                 "Unexpected value DH-SHA1 p");
             goto dh_gex_clean_exit;
         }
 
         if(_libssh2_get_bignum_bytes(&buf, &g, &g_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
+                                 "Unexpected value DH-SHA1 g");
+            goto dh_gex_clean_exit;
+        }
+
+        if(_libssh2_bn_from_bin(key_state->p, p_len, p)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                 "Invalid DH-SHA1 p");
             goto dh_gex_clean_exit;
         }
 
-        _libssh2_bn_from_bin(key_state->p, p_len, p);
-        _libssh2_bn_from_bin(key_state->g, g_len, g);
+        if(_libssh2_bn_from_bin(key_state->g, g_len, g)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                 "Invalid DH-SHA1 g");
+            goto dh_gex_clean_exit;
+        }
 
         ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p,
-                                      p_len, 1,
+                                      (int)p_len, 1,
                                       (void *)&exchange_hash_ctx,
                                       SSH_MSG_KEX_DH_GEX_INIT,
                                       SSH_MSG_KEX_DH_GEX_REPLY,
@@ -1436,16 +1562,10 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
         if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
-
-        LIBSSH2_FREE(session, key_state->data);
     }
 
-  dh_gex_clean_exit:
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
+dh_gex_clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
@@ -1457,8 +1577,9 @@ kex_method_diffie_hellman_group_exchange_sha1_key_exchange
  * Negotiates random(ish) group for secret derivation
  */
 static int
-kex_method_diffie_hellman_group_exchange_sha256_key_exchange
-(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
+kex_method_diffie_hellman_group_exchange_sha256_key_exchange(
+                                          LIBSSH2_SESSION * session,
+                                          key_exchange_state_low_t * key_state)
 {
     int ret = 0;
     int rc;
@@ -1467,23 +1588,13 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
         key_state->p = _libssh2_bn_init();
         key_state->g = _libssh2_bn_init();
         /* Ask for a P and G pair */
-#ifdef LIBSSH2_DH_GEX_NEW
         key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST;
         _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP);
         _libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
         _libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
         key_state->request_len = 13;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(New Method SHA256)");
-#else
-        key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
-        _libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
-        key_state->request_len = 5;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating Diffie-Hellman Group-Exchange "
-                       "(Old Method SHA256)");
-#endif
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating Diffie-Hellman Group-Exchange SHA256"));
 
         key_state->state = libssh2_NB_state_created;
     }
@@ -1528,7 +1639,7 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
 
         if(key_state->data_len < 9) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
+                                 "Unexpected key length DH-SHA256");
             goto dh_gex_clean_exit;
         }
 
@@ -1540,21 +1651,30 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
 
         if(_libssh2_get_bignum_bytes(&buf, &p, &p_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
+                                 "Unexpected value DH-SHA256 p");
             goto dh_gex_clean_exit;
         }
 
         if(_libssh2_get_bignum_bytes(&buf, &g, &g_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected value");
+                                 "Unexpected value DH-SHA256 g");
+            goto dh_gex_clean_exit;
+        }
+
+        if(_libssh2_bn_from_bin(key_state->p, p_len, p)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                 "Invalid DH-SHA256 p");
             goto dh_gex_clean_exit;
         }
 
-        _libssh2_bn_from_bin(key_state->p, p_len, p);
-        _libssh2_bn_from_bin(key_state->g, g_len, g);
+        if(_libssh2_bn_from_bin(key_state->g, g_len, g)) {
+            ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                 "Invalid DH-SHA256 g");
+            goto dh_gex_clean_exit;
+        }
 
         ret = diffie_hellman_sha_algo(session, key_state->g, key_state->p,
-                                      p_len, 256,
+                                      (int)p_len, 256,
                                       (void *)&exchange_hash_ctx,
                                       SSH_MSG_KEX_DH_GEX_INIT,
                                       SSH_MSG_KEX_DH_GEX_REPLY,
@@ -1564,20 +1684,15 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
         if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
-
-        LIBSSH2_FREE(session, key_state->data);
     }
 
-  dh_gex_clean_exit:
-    key_state->state = libssh2_NB_state_idle;
-    _libssh2_bn_free(key_state->g);
-    key_state->g = NULL;
-    _libssh2_bn_free(key_state->p);
-    key_state->p = NULL;
+dh_gex_clean_exit:
+    kex_diffie_hellman_cleanup(session, key_state);
 
     return ret;
 }
 
+#if LIBSSH2_ECDSA
 
 /* LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY
  *
@@ -1595,100 +1710,103 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
  * mpint    K,   shared secret
  *
  */
-
-#define LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(digest_type)       \
-{                                                                       \
-    libssh2_sha##digest_type##_ctx ctx;                                 \
-    exchange_state->exchange_hash = (void *)&ctx;                       \
-    libssh2_sha##digest_type##_init(&ctx);                              \
-    if(session->local.banner) {                                         \
-        _libssh2_htonu32(exchange_state->h_sig_comp,                    \
-                         strlen((char *) session->local.banner) - 2);   \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          exchange_state->h_sig_comp, 4); \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          (char *) session->local.banner, \
-                                          strlen((char *)               \
-                                                 session->local.banner) \
-                                          - 2);                         \
-    }                                                                   \
-    else {                                                              \
-        _libssh2_htonu32(exchange_state->h_sig_comp,                    \
-                         sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);       \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          exchange_state->h_sig_comp, 4); \
-        libssh2_sha##digest_type##_update(ctx,                          \
-                                          LIBSSH2_SSH_DEFAULT_BANNER,   \
+#define LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(digest_type)            \
+do {                                                                         \
+    libssh2_sha##digest_type##_ctx ctx;                                      \
+    int hok;                                                                 \
+    if(!libssh2_sha##digest_type##_init(&ctx)) {                             \
+        rc = -1;                                                             \
+        break;                                                               \
+    }                                                                        \
+    exchange_state->exchange_hash = (void *)&ctx;                            \
+    hok = 1;                                                                 \
+    if(session->local.banner) {                                              \
+        _libssh2_htonu32(exchange_state->h_sig_comp,                         \
+            (uint32_t)(strlen((char *) session->local.banner) - 2));         \
+        hok &= libssh2_sha##digest_type##_update(ctx,                        \
+                                                 exchange_state->h_sig_comp, \
+                                                 4);                         \
+        hok &= libssh2_sha##digest_type##_update(ctx,                        \
+                                              (char *)session->local.banner, \
+                                       strlen((char *)session->local.banner) \
+                                       - 2);                                 \
+    }                                                                        \
+    else {                                                                   \
+        _libssh2_htonu32(exchange_state->h_sig_comp,                         \
+                         sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);            \
+        hok &= libssh2_sha##digest_type##_update(ctx,                        \
+                                          exchange_state->h_sig_comp, 4);    \
+        hok &= libssh2_sha##digest_type##_update(ctx,                        \
+                                                 LIBSSH2_SSH_DEFAULT_BANNER, \
                                           sizeof(LIBSSH2_SSH_DEFAULT_BANNER) \
-                                          - 1);                         \
-    }                                                                   \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     strlen((char *) session->remote.banner));          \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->remote.banner,           \
-                                      strlen((char *)                   \
-                                             session->remote.banner));  \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->local.kexinit_len);                       \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->local.kexinit,           \
-                                      session->local.kexinit_len);      \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->remote.kexinit_len);                      \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->remote.kexinit,          \
-                                      session->remote.kexinit_len);     \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     session->server_hostkey_len);                      \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      session->server_hostkey,          \
-                                      session->server_hostkey_len);     \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     public_key_len);                                   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      public_key,                       \
-                                      public_key_len);                  \
-                                                                        \
-    _libssh2_htonu32(exchange_state->h_sig_comp,                        \
-                     server_public_key_len);                            \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->h_sig_comp, 4);   \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      server_public_key,                \
-                                      server_public_key_len);           \
-                                                                        \
-    libssh2_sha##digest_type##_update(ctx,                              \
-                                      exchange_state->k_value,          \
-                                      exchange_state->k_value_len);     \
-                                                                        \
-    libssh2_sha##digest_type##_final(ctx, exchange_state->h_sig_comp);  \
-                                                                        \
-    if(session->hostkey->                                               \
-       sig_verify(session, exchange_state->h_sig,                       \
-                  exchange_state->h_sig_len, exchange_state->h_sig_comp, \
-                  SHA##digest_type##_DIGEST_LENGTH,                     \
-                  &session->server_hostkey_abstract)) {                 \
-        rc = -1;                                                        \
-    }                                                                   \
-}                                                                       \
-
-
-#if LIBSSH2_ECDSA
+                                          - 1);                              \
+    }                                                                        \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+        (uint32_t)strlen((char *) session->remote.banner));                  \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx, session->remote.banner,    \
+                                   strlen((char *)session->remote.banner));  \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+                     (uint32_t)session->local.kexinit_len);                  \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             session->local.kexinit,         \
+                                             session->local.kexinit_len);    \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+                     (uint32_t)session->remote.kexinit_len);                 \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             session->remote.kexinit,        \
+                                             session->remote.kexinit_len);   \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+                     session->server_hostkey_len);                           \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             session->server_hostkey,        \
+                                             session->server_hostkey_len);   \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+                     (uint32_t)public_key_len);                              \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             public_key,                     \
+                                             public_key_len);                \
+                                                                             \
+    _libssh2_htonu32(exchange_state->h_sig_comp,                             \
+                     (uint32_t)server_public_key_len);                       \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->h_sig_comp, 4); \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             server_public_key,              \
+                                             server_public_key_len);         \
+                                                                             \
+    hok &= libssh2_sha##digest_type##_update(ctx,                            \
+                                             exchange_state->k_value,        \
+                                             exchange_state->k_value_len);   \
+                                                                             \
+    if(!hok ||                                                               \
+       !libssh2_sha##digest_type##_final(ctx, exchange_state->h_sig_comp)) { \
+        rc = -1;                                                             \
+        break;                                                               \
+    }                                                                        \
+                                                                             \
+    if(session->hostkey->                                                    \
+        sig_verify(session, exchange_state->h_sig,                           \
+                   exchange_state->h_sig_len, exchange_state->h_sig_comp,    \
+                   SHA##digest_type##_DIGEST_LENGTH,                         \
+                   &session->server_hostkey_abstract)) {                     \
+        rc = -1;                                                             \
+    }                                                                        \
+} while(0)
 
 /* kex_session_ecdh_curve_type
  * returns the EC curve type by name used in key exchange
@@ -1697,10 +1815,9 @@ kex_method_diffie_hellman_group_exchange_sha256_key_exchange
 static int
 kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
 {
-    int ret = 0;
     libssh2_curve_type type;
 
-    if(name == NULL)
+    if(!name)
         return -1;
 
     if(strcmp(name, "ecdh-sha2-nistp256") == 0)
@@ -1710,14 +1827,57 @@ kex_session_ecdh_curve_type(const char *name, libssh2_curve_type *out_type)
     else if(strcmp(name, "ecdh-sha2-nistp521") == 0)
         type = LIBSSH2_EC_CURVE_NISTP521;
     else {
-        ret = -1;
+        return -1;
     }
 
-    if(ret == 0 && out_type) {
+    if(out_type) {
         *out_type = type;
     }
 
-    return ret;
+    return 0;
+}
+
+
+static void
+ecdh_exchange_state_cleanup(LIBSSH2_SESSION * session,
+                            kmdhgGPshakex_state_t *exchange_state)
+{
+    _libssh2_bn_free(exchange_state->k);
+    exchange_state->k = NULL;
+
+    if(exchange_state->k_value) {
+        LIBSSH2_FREE(session, exchange_state->k_value);
+        exchange_state->k_value = NULL;
+    }
+
+    exchange_state->state = libssh2_NB_state_idle;
+}
+
+
+static void
+kex_method_ecdh_cleanup
+(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
+{
+    if(key_state->public_key_oct) {
+        LIBSSH2_FREE(session, key_state->public_key_oct);
+        key_state->public_key_oct = NULL;
+    }
+
+    if(key_state->private_key) {
+        _libssh2_ecdsa_free(key_state->private_key);
+        key_state->private_key = NULL;
+    }
+
+    if(key_state->data) {
+        LIBSSH2_FREE(session, key_state->data);
+        key_state->data = NULL;
+    }
+
+    key_state->state = libssh2_NB_state_idle;
+
+    if(key_state->exchange_state.state != libssh2_NB_state_idle) {
+        ecdh_exchange_state_cleanup(session, &key_state->exchange_state);
+    }
 }
 
 
@@ -1736,7 +1896,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 
     if(data_len < 5) {
         ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                            "Host key data is too short");
+                             "Host key data is too short");
         return ret;
     }
 
@@ -1761,11 +1921,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         buf.dataptr = buf.data;
         buf.dataptr++; /* Advance past packet type */
 
-         if(_libssh2_copy_string(session, &buf, &(session->server_hostkey),
+        if(_libssh2_copy_string(session, &buf, &(session->server_hostkey),
                                 &server_public_key_len)) {
-             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                  "Unable to allocate memory for a copy "
-                                  "of the host key");
+            ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                 "Unable to allocate memory for a copy "
+                                 "of the host ECDH key");
             goto clean_exit;
         }
 
@@ -1775,11 +1935,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
+            if(libssh2_md5_init(&fingerprint_ctx) &&
+               libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
+                                  session->server_hostkey_len) &&
+               libssh2_md5_final(fingerprint_ctx,
+                                 session->server_hostkey_md5)) {
                 session->server_hostkey_md5_valid = TRUE;
             }
             else {
@@ -1794,8 +1954,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's MD5 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's MD5 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 #endif /* ! LIBSSH2_MD5 */
@@ -1803,11 +1963,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
+            if(libssh2_sha1_init(&fingerprint_ctx) &&
+               libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
+                                   session->server_hostkey_len) &&
+               libssh2_sha1_final(fingerprint_ctx,
+                                  session->server_hostkey_sha1)) {
                 session->server_hostkey_sha1_valid = TRUE;
             }
             else {
@@ -1818,13 +1978,12 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             char fingerprint[64], *fprint = fingerprint;
             int i;
-
             for(i = 0; i < 20; i++, fprint += 3) {
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "Server's SHA1 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's SHA1 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 
@@ -1832,11 +1991,11 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
+            if(libssh2_sha256_init(&fingerprint_ctx) &&
+               libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
+                                     session->server_hostkey_len) &&
+               libssh2_sha256_final(fingerprint_ctx,
+                                    session->server_hostkey_sha256)) {
                 session->server_hostkey_sha256_valid = TRUE;
             }
             else {
@@ -1850,20 +2009,21 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                                    (const char *)
                                    session->server_hostkey_sha256,
                                    SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+            if(base64Fingerprint) {
+                _libssh2_debug((session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
+                               base64Fingerprint));
                 LIBSSH2_FREE(session, base64Fingerprint);
             }
         }
 #endif /* LIBSSH2DEBUG */
 
         if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
+                                  session->server_hostkey_len,
+                                  &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
+                                 "Unable to initialize hostkey importer "
+                                 "ECDH");
             goto clean_exit;
         }
 
@@ -1871,7 +2031,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         if(_libssh2_get_string(&buf, &server_public_key,
                                &server_public_key_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                     "Unexpected key length");
+                                 "Unexpected key length ECDH");
             goto clean_exit;
         }
 
@@ -1879,14 +2039,14 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         if(_libssh2_get_string(&buf, &exchange_state->h_sig,
            &(exchange_state->h_sig_len))) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unexpected ecdh server sig length");
+                                 "Unexpected ECDH server sig length");
             goto clean_exit;
         }
 
         /* Compute the shared secret K */
         rc = _libssh2_ecdh_gen_k(&exchange_state->k, private_key,
                                  server_public_key, server_public_key_len);
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
                                  "Unable to create ECDH shared secret");
             goto clean_exit;
@@ -1901,17 +2061,27 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         LIBSSH2_ALLOC(session, exchange_state->k_value_len);
         if(!exchange_state->k_value) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                 "Unable to allocate buffer for K");
+                                 "Unable to allocate buffer for ECDH K");
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
+                         (uint32_t)(exchange_state->k_value_len - 4));
         if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 4)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->k");
+                goto clean_exit;
+            }
         }
         else {
             exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 5)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->e");
+                goto clean_exit;
+            }
         }
 
         /* verify hash */
@@ -1920,7 +2090,6 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
             case LIBSSH2_EC_CURVE_NISTP256:
                 LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(256);
                 break;
-
             case LIBSSH2_EC_CURVE_NISTP384:
                 LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(384);
                 break;
@@ -1929,9 +2098,10 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 break;
         }
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
+                                 "Unable to verify hostkey signature "
+                                 "ECDH");
             goto clean_exit;
         }
 
@@ -1946,7 +2116,7 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
         }
         else if(rc) {
             ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
+                                 "Unable to send NEWKEYS message ECDH");
             goto clean_exit;
         }
 
@@ -1962,17 +2132,19 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
             return rc;
         }
         else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
+            ret = _libssh2_error(session, rc,
+                                 "Timed out waiting for NEWKEYS ECDH");
             goto clean_exit;
         }
 
         /* The first key exchange has been performed,
-         switch to active crypt/comp/mac mode */
+           switch to active crypt/comp/mac mode */
         session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Received NEWKEYS message ECDH"));
 
         /* This will actually end up being just packet_type(1)
-         for this packet type anyway */
+           for this packet type anyway */
         LIBSSH2_FREE(session, exchange_state->tmp);
 
         if(!session->session_id) {
@@ -2000,9 +2172,9 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
             }
             memcpy(session->session_id, exchange_state->h_sig_comp,
                    digest_length);
-             session->session_id_len = digest_length;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
+             session->session_id_len = (uint32_t)digest_length;
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "session_id calculated"));
         }
 
         /* Cleanup any existing cipher */
@@ -2025,8 +2197,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
             }
 
             LIBSSH2_KEX_METHOD_EC_SHA_VALUE_HASH(secret,
-                                                session->local.crypt->
-                                                secret_len, "C");
+                                                 session->local.crypt->
+                                                 secret_len, "C");
 
             if(!secret) {
                 LIBSSH2_FREE(session, iv);
@@ -2053,8 +2225,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server IV and Key calculated"));
 
         if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
@@ -2103,8 +2275,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client IV and Key calculated"));
 
         if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
@@ -2130,8 +2302,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server HMAC Key calculated"));
 
         if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
@@ -2157,8 +2329,8 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client HMAC Key calculated"));
 
         /* Initialize compression for each direction */
 
@@ -2170,13 +2342,13 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 
         if(session->local.comp && session->local.comp->init) {
             if(session->local.comp->init(session, 1,
-                                          &session->local.comp_abstract)) {
+                                         &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Client to Server compression initialized");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server compression initialized"));
 
         if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
@@ -2185,26 +2357,17 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 
         if(session->remote.comp && session->remote.comp->init) {
             if(session->remote.comp->init(session, 0,
-                                           &session->remote.comp_abstract)) {
+                                          &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Server to Client compression initialized");
-
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client compression initialized"));
     }
 
 clean_exit:
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
-    }
-
-    exchange_state->state = libssh2_NB_state_idle;
+    ecdh_exchange_state_cleanup(session, exchange_state);
 
     return ret;
 }
@@ -2212,10 +2375,9 @@ static int ecdh_sha2_nistp(LIBSSH2_SESSION *session, libssh2_curve_type type,
 /* kex_method_ecdh_key_exchange
  *
  * Elliptic Curve Diffie Hellman Key Exchange
- * supports SHA256/384/512 hashes based on negotated ecdh method
+ * supports SHA256/384/512 hashes based on negotiated ecdh method
  *
  */
-
 static int
 kex_method_ecdh_key_exchange
 (LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
@@ -2234,7 +2396,7 @@ kex_method_ecdh_key_exchange
     if(key_state->state == libssh2_NB_state_created) {
         rc = kex_session_ecdh_curve_type(session->kex->name, &type);
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, -1,
                                  "Unknown KEX nistp curve type");
             goto ecdh_clean_exit;
@@ -2244,7 +2406,7 @@ kex_method_ecdh_key_exchange
                                        &key_state->public_key_oct,
                                        &key_state->public_key_oct_len, type);
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to create private key");
             goto ecdh_clean_exit;
@@ -2256,8 +2418,8 @@ kex_method_ecdh_key_exchange
                            key_state->public_key_oct_len);
         key_state->request_len = key_state->public_key_oct_len + 5;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                       "Initiating ECDH SHA2 NISTP256");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating ECDH SHA2 NISTP256"));
 
         key_state->state = libssh2_NB_state_sent;
     }
@@ -2295,7 +2457,13 @@ kex_method_ecdh_key_exchange
 
     if(key_state->state == libssh2_NB_state_sent2) {
 
-        (void)kex_session_ecdh_curve_type(session->kex->name, &type);
+        rc = kex_session_ecdh_curve_type(session->kex->name, &type);
+
+        if(rc) {
+            ret = _libssh2_error(session, -1,
+                                 "Unknown KEX nistp curve type");
+            goto ecdh_clean_exit;
+        }
 
         ret = ecdh_sha2_nistp(session, type, key_state->data,
                               key_state->data_len,
@@ -2307,36 +2475,68 @@ kex_method_ecdh_key_exchange
         if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
-
-        LIBSSH2_FREE(session, key_state->data);
     }
 
 ecdh_clean_exit:
 
-    if(key_state->public_key_oct) {
-        LIBSSH2_FREE(session, key_state->public_key_oct);
-        key_state->public_key_oct = NULL;
-    }
-
-    if(key_state->private_key) {
-        _libssh2_ecdsa_free(key_state->private_key);
-        key_state->private_key = NULL;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
+    kex_method_ecdh_cleanup(session, key_state);
 
     return ret;
 }
 
-#endif /*LIBSSH2_ECDSA*/
+#endif /* LIBSSH2_ECDSA */
 
 
 #if LIBSSH2_ED25519
 
+static void
+curve25519_exchange_state_cleanup(LIBSSH2_SESSION * session,
+                                  kmdhgGPshakex_state_t *exchange_state)
+{
+    _libssh2_bn_free(exchange_state->k);
+    exchange_state->k = NULL;
+
+    if(exchange_state->k_value) {
+        LIBSSH2_FREE(session, exchange_state->k_value);
+        exchange_state->k_value = NULL;
+    }
+
+    exchange_state->state = libssh2_NB_state_idle;
+}
+
+static void
+kex_method_curve25519_cleanup
+(LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
+{
+    if(key_state->curve25519_public_key) {
+        _libssh2_explicit_zero(key_state->curve25519_public_key,
+                               LIBSSH2_ED25519_KEY_LEN);
+        LIBSSH2_FREE(session, key_state->curve25519_public_key);
+        key_state->curve25519_public_key = NULL;
+    }
+
+    if(key_state->curve25519_private_key) {
+        _libssh2_explicit_zero(key_state->curve25519_private_key,
+                               LIBSSH2_ED25519_KEY_LEN);
+        LIBSSH2_FREE(session, key_state->curve25519_private_key);
+        key_state->curve25519_private_key = NULL;
+    }
+
+    if(key_state->data) {
+        LIBSSH2_FREE(session, key_state->data);
+        key_state->data = NULL;
+    }
+
+    key_state->state = libssh2_NB_state_idle;
+
+    if(key_state->exchange_state.state != libssh2_NB_state_idle) {
+        curve25519_exchange_state_cleanup(session, &key_state->exchange_state);
+    }
+}
+
 /* curve25519_sha256
  * Elliptic Curve Key Exchange
  */
-
 static int
 curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                   size_t data_len,
@@ -2369,7 +2569,7 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
 
         if(data_len < 5) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
+                                 "Unexpected curve25519 key length 1");
             goto clean_exit;
         }
 
@@ -2380,7 +2580,7 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
 
         if(_libssh2_get_string(&buf, &server_host_key, &hostkey_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                 "Unexpected key length");
+                                 "Unexpected curve25519 key length 2");
             goto clean_exit;
         }
 
@@ -2390,7 +2590,7 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         if(!session->server_hostkey) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate memory for a copy "
-                                 "of the host key");
+                                 "of the host curve25519 key");
             goto clean_exit;
         }
 
@@ -2401,11 +2601,11 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         {
             libssh2_md5_ctx fingerprint_ctx;
 
-            if(libssh2_md5_init(&fingerprint_ctx)) {
-                libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
-                                   session->server_hostkey_len);
-                libssh2_md5_final(fingerprint_ctx,
-                                  session->server_hostkey_md5);
+            if(libssh2_md5_init(&fingerprint_ctx) &&
+               libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
+                                  session->server_hostkey_len) &&
+               libssh2_md5_final(fingerprint_ctx,
+                                 session->server_hostkey_md5)) {
                 session->server_hostkey_md5_valid = TRUE;
             }
             else {
@@ -2420,8 +2620,8 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                             "Server's MD5 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's MD5 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 #endif /* ! LIBSSH2_MD5 */
@@ -2429,11 +2629,11 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         {
             libssh2_sha1_ctx fingerprint_ctx;
 
-            if(libssh2_sha1_init(&fingerprint_ctx)) {
-                libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
-                                    session->server_hostkey_len);
-                libssh2_sha1_final(fingerprint_ctx,
-                                   session->server_hostkey_sha1);
+            if(libssh2_sha1_init(&fingerprint_ctx) &&
+               libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
+                                   session->server_hostkey_len) &&
+               libssh2_sha1_final(fingerprint_ctx,
+                                  session->server_hostkey_sha1)) {
                 session->server_hostkey_sha1_valid = TRUE;
             }
             else {
@@ -2444,13 +2644,12 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         {
             char fingerprint[64], *fprint = fingerprint;
             int i;
-
             for(i = 0; i < 20; i++, fprint += 3) {
                 snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
             }
             *(--fprint) = '\0';
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                             "Server's SHA1 Fingerprint: %s", fingerprint);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Server's SHA1 Fingerprint: %s", fingerprint));
         }
 #endif /* LIBSSH2DEBUG */
 
@@ -2458,11 +2657,11 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         {
             libssh2_sha256_ctx fingerprint_ctx;
 
-            if(libssh2_sha256_init(&fingerprint_ctx)) {
-                libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
-                                      session->server_hostkey_len);
-                libssh2_sha256_final(fingerprint_ctx,
-                                     session->server_hostkey_sha256);
+            if(libssh2_sha256_init(&fingerprint_ctx) &&
+               libssh2_sha256_update(fingerprint_ctx, session->server_hostkey,
+                                     session->server_hostkey_len) &&
+               libssh2_sha256_final(fingerprint_ctx,
+                                    session->server_hostkey_sha256)) {
                 session->server_hostkey_sha256_valid = TRUE;
             }
             else {
@@ -2476,20 +2675,21 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                                    (const char *)
                                    session->server_hostkey_sha256,
                                    SHA256_DIGEST_LENGTH, &base64Fingerprint);
-            if(base64Fingerprint != NULL) {
-                _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+            if(base64Fingerprint) {
+                _libssh2_debug((session, LIBSSH2_TRACE_KEX,
                                "Server's SHA256 Fingerprint: %s",
-                               base64Fingerprint);
+                               base64Fingerprint));
                 LIBSSH2_FREE(session, base64Fingerprint);
             }
         }
 #endif /* LIBSSH2DEBUG */
 
         if(session->hostkey->init(session, session->server_hostkey,
-                                   session->server_hostkey_len,
-                                   &session->server_hostkey_abstract)) {
+                                  session->server_hostkey_len,
+                                  &session->server_hostkey_abstract)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
-                                 "Unable to initialize hostkey importer");
+                                 "Unable to initialize hostkey importer "
+                                 "curve25519");
             goto clean_exit;
         }
 
@@ -2497,7 +2697,7 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         if(_libssh2_get_string(&buf, &server_public_key,
                                &server_public_key_len)) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                     "Unexpected key length");
+                                 "Unexpected curve25519 key length");
             goto clean_exit;
         }
 
@@ -2519,9 +2719,9 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         /* Compute the shared secret K */
         rc = _libssh2_curve25519_gen_k(&exchange_state->k, private_key,
                                        server_public_key);
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
-                                 "Unable to create ECDH shared secret");
+                                 "Unable to create curve25519 shared secret");
             goto clean_exit;
         }
 
@@ -2538,21 +2738,32 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
             goto clean_exit;
         }
         _libssh2_htonu32(exchange_state->k_value,
-                         exchange_state->k_value_len - 4);
+                         (uint32_t)(exchange_state->k_value_len - 4));
         if(_libssh2_bn_bits(exchange_state->k) % 8) {
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 4)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->e");
+                goto clean_exit;
+            }
         }
         else {
             exchange_state->k_value[4] = 0;
-            _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
+            if(_libssh2_bn_to_bin(exchange_state->k,
+                                  exchange_state->k_value + 5)) {
+                ret = _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                                     "Can't write exchange_state->e");
+                goto clean_exit;
+            }
         }
 
         /*/ verify hash */
         LIBSSH2_KEX_METHOD_EC_SHA_HASH_CREATE_VERIFY(256);
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
-                                 "Unable to verify hostkey signature");
+                                 "Unable to verify hostkey signature "
+                                 "curve25519");
             goto clean_exit;
         }
 
@@ -2567,7 +2778,7 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
         }
         else if(rc) {
             ret = _libssh2_error(session, rc,
-                                 "Unable to send NEWKEYS message");
+                                 "Unable to send NEWKEYS message curve25519");
             goto clean_exit;
         }
 
@@ -2583,18 +2794,19 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
             return rc;
         }
         else if(rc) {
-            ret = _libssh2_error(session, rc, "Timed out waiting for NEWKEYS");
+            ret = _libssh2_error(session, rc,
+                                 "Timed out waiting for NEWKEYS curve25519");
             goto clean_exit;
         }
 
-        /* The first key exchange has been performed, switch to active
-           crypt/comp/mac mode */
-
+        /* The first key exchange has been performed,
+           switch to active crypt/comp/mac mode */
         session->state |= LIBSSH2_STATE_NEWKEYS;
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Received NEWKEYS message");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Received NEWKEYS message curve25519"));
 
-        /* This will actually end up being just packet_type(1) for this packet
-           type anyway */
+        /* This will actually end up being just packet_type(1)
+           for this packet type anyway */
         LIBSSH2_FREE(session, exchange_state->tmp);
 
         if(!session->session_id) {
@@ -2603,21 +2815,21 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
             session->session_id = LIBSSH2_ALLOC(session, digest_length);
             if(!session->session_id) {
                 ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                     "Unable to allxcocate buffer for "
+                                     "Unable to allocate buffer for "
                                      "SHA digest");
                 goto clean_exit;
             }
             memcpy(session->session_id, exchange_state->h_sig_comp,
                    digest_length);
-            session->session_id_len = digest_length;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                           "session_id calculated");
+            session->session_id_len = (uint32_t)digest_length;
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "session_id calculated"));
         }
 
         /* Cleanup any existing cipher */
         if(session->local.crypt->dtor) {
             session->local.crypt->dtor(session,
-                                        &session->local.crypt_abstract);
+                                       &session->local.crypt_abstract);
         }
 
         /* Calculate IV/Secret/Key for each direction */
@@ -2662,8 +2874,8 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server IV and Key calculated"));
 
         if(session->remote.crypt->dtor) {
             /* Cleanup any existing cipher */
@@ -2712,8 +2924,8 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                 LIBSSH2_FREE(session, secret);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client IV and Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client IV and Key calculated"));
 
         if(session->local.mac->dtor) {
             session->local.mac->dtor(session, &session->local.mac_abstract);
@@ -2739,8 +2951,8 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server HMAC Key calculated"));
 
         if(session->remote.mac->dtor) {
             session->remote.mac->dtor(session, &session->remote.mac_abstract);
@@ -2766,8 +2978,8 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
                 LIBSSH2_FREE(session, key);
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client HMAC Key calculated");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client HMAC Key calculated"));
 
         /* Initialize compression for each direction */
 
@@ -2779,40 +2991,32 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
 
         if(session->local.comp && session->local.comp->init) {
             if(session->local.comp->init(session, 1,
-                                            &session->local.comp_abstract)) {
+                                         &session->local.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Client to Server compression initialized");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Client to Server compression initialized"));
 
         if(session->remote.comp && session->remote.comp->dtor) {
             session->remote.comp->dtor(session, 0,
-                                        &session->remote.comp_abstract);
+                                       &session->remote.comp_abstract);
         }
 
         if(session->remote.comp && session->remote.comp->init) {
             if(session->remote.comp->init(session, 0,
-                                             &session->remote.comp_abstract)) {
+                                          &session->remote.comp_abstract)) {
                 ret = LIBSSH2_ERROR_KEX_FAILURE;
                 goto clean_exit;
             }
         }
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Server to Client compression initialized");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Server to Client compression initialized"));
     }
 
 clean_exit:
-    _libssh2_bn_free(exchange_state->k);
-    exchange_state->k = NULL;
-
-    if(exchange_state->k_value) {
-        LIBSSH2_FREE(session, exchange_state->k_value);
-        exchange_state->k_value = NULL;
-    }
-
-    exchange_state->state = libssh2_NB_state_idle;
+    curve25519_exchange_state_cleanup(session, exchange_state);
 
     return ret;
 }
@@ -2822,7 +3026,6 @@ curve25519_sha256(LIBSSH2_SESSION *session, unsigned char *data,
  * Elliptic Curve X25519 Key Exchange with SHA256 hash
  *
  */
-
 static int
 kex_method_curve25519_key_exchange
 (LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
@@ -2840,10 +3043,10 @@ kex_method_curve25519_key_exchange
         unsigned char *s = NULL;
 
         rc = strcmp(session->kex->name, "curve25519-sha256@libssh.org");
-        if(rc != 0)
+        if(rc)
             rc = strcmp(session->kex->name, "curve25519-sha256");
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, -1,
                                  "Unknown KEX curve25519 curve type");
             goto clean_exit;
@@ -2853,7 +3056,7 @@ kex_method_curve25519_key_exchange
                                      &key_state->curve25519_public_key,
                                      &key_state->curve25519_private_key);
 
-        if(rc != 0) {
+        if(rc) {
             ret = _libssh2_error(session, rc,
                                  "Unable to create private key");
             goto clean_exit;
@@ -2865,8 +3068,8 @@ kex_method_curve25519_key_exchange
                            LIBSSH2_ED25519_KEY_LEN);
         key_state->request_len = LIBSSH2_ED25519_KEY_LEN + 5;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
-                        "Initiating curve25519 SHA2");
+        _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                       "Initiating curve25519 SHA2"));
 
         key_state->state = libssh2_NB_state_sent;
     }
@@ -2912,33 +3115,17 @@ kex_method_curve25519_key_exchange
         if(ret == LIBSSH2_ERROR_EAGAIN) {
             return ret;
         }
-
-        LIBSSH2_FREE(session, key_state->data);
     }
 
 clean_exit:
 
-    if(key_state->curve25519_public_key) {
-        _libssh2_explicit_zero(key_state->curve25519_public_key,
-                               LIBSSH2_ED25519_KEY_LEN);
-        LIBSSH2_FREE(session, key_state->curve25519_public_key);
-        key_state->curve25519_public_key = NULL;
-    }
-
-    if(key_state->curve25519_private_key) {
-        _libssh2_explicit_zero(key_state->curve25519_private_key,
-                               LIBSSH2_ED25519_KEY_LEN);
-        LIBSSH2_FREE(session, key_state->curve25519_private_key);
-        key_state->curve25519_private_key = NULL;
-    }
-
-    key_state->state = libssh2_NB_state_idle;
+    kex_method_curve25519_cleanup(session, key_state);
 
     return ret;
 }
 
 
-#endif /*LIBSSH2_ED25519*/
+#endif /* LIBSSH2_ED25519 */
 
 
 #define LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY     0x0001
@@ -2947,30 +3134,35 @@ kex_method_curve25519_key_exchange
 static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group1_sha1 = {
     "diffie-hellman-group1-sha1",
     kex_method_diffie_hellman_group1_sha1_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
 static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group14_sha1 = {
     "diffie-hellman-group14-sha1",
     kex_method_diffie_hellman_group14_sha1_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
 static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group14_sha256 = {
     "diffie-hellman-group14-sha256",
     kex_method_diffie_hellman_group14_sha256_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
 static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group16_sha512 = {
     "diffie-hellman-group16-sha512",
     kex_method_diffie_hellman_group16_sha512_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
 static const LIBSSH2_KEX_METHOD kex_method_diffie_helman_group18_sha512 = {
     "diffie-hellman-group18-sha512",
     kex_method_diffie_hellman_group18_sha512_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
@@ -2978,6 +3170,7 @@ static const LIBSSH2_KEX_METHOD
 kex_method_diffie_helman_group_exchange_sha1 = {
     "diffie-hellman-group-exchange-sha1",
     kex_method_diffie_hellman_group_exchange_sha1_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
@@ -2985,6 +3178,7 @@ static const LIBSSH2_KEX_METHOD
 kex_method_diffie_helman_group_exchange_sha256 = {
     "diffie-hellman-group-exchange-sha256",
     kex_method_diffie_hellman_group_exchange_sha256_key_exchange,
+    kex_diffie_hellman_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
@@ -2993,6 +3187,7 @@ static const LIBSSH2_KEX_METHOD
 kex_method_ecdh_sha2_nistp256 = {
     "ecdh-sha2-nistp256",
     kex_method_ecdh_key_exchange,
+    kex_method_ecdh_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
@@ -3000,6 +3195,7 @@ static const LIBSSH2_KEX_METHOD
 kex_method_ecdh_sha2_nistp384 = {
     "ecdh-sha2-nistp384",
     kex_method_ecdh_key_exchange,
+    kex_method_ecdh_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
@@ -3007,6 +3203,7 @@ static const LIBSSH2_KEX_METHOD
 kex_method_ecdh_sha2_nistp521 = {
     "ecdh-sha2-nistp521",
     kex_method_ecdh_key_exchange,
+    kex_method_ecdh_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 #endif
@@ -3016,16 +3213,38 @@ static const LIBSSH2_KEX_METHOD
 kex_method_ssh_curve25519_sha256_libssh = {
     "curve25519-sha256@libssh.org",
     kex_method_curve25519_key_exchange,
+    kex_method_curve25519_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 static const LIBSSH2_KEX_METHOD
 kex_method_ssh_curve25519_sha256 = {
     "curve25519-sha256",
     kex_method_curve25519_key_exchange,
+    kex_method_curve25519_cleanup,
     LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 #endif
 
+/* this kex method signals that client can receive extensions
+ * as described in https://datatracker.ietf.org/doc/html/rfc8308
+*/
+
+static const LIBSSH2_KEX_METHOD
+kex_method_extension_negotiation = {
+    "ext-info-c",
+    NULL,
+    NULL,
+    0,
+};
+
+static const LIBSSH2_KEX_METHOD
+kex_method_strict_client_extension = {
+    "kex-strict-c-v00@openssh.com",
+    NULL,
+    NULL,
+    0,
+};
+
 static const LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
 #if LIBSSH2_ED25519
     &kex_method_ssh_curve25519_sha256,
@@ -3043,7 +3262,9 @@ static const LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
     &kex_method_diffie_helman_group14_sha1,
     &kex_method_diffie_helman_group1_sha1,
     &kex_method_diffie_helman_group_exchange_sha1,
-  NULL
+    &kex_method_extension_negotiation,
+    &kex_method_strict_client_extension,
+    NULL
 };
 
 typedef struct _LIBSSH2_COMMON_METHOD
@@ -3052,6 +3273,7 @@ typedef struct _LIBSSH2_COMMON_METHOD
 } LIBSSH2_COMMON_METHOD;
 
 /* kex_method_strlen
+ *
  * Calculate the length of a particular method list's resulting string
  * Includes SUM(strlen() of each individual method plus 1 (for coma)) - 1
  * (because the last coma isn't used)
@@ -3079,8 +3301,8 @@ kex_method_strlen(LIBSSH2_COMMON_METHOD ** method)
 /* kex_method_list
  * Generate formatted preference list in buf
  */
-static size_t
-kex_method_list(unsigned char *buf, size_t list_strlen,
+static uint32_t
+kex_method_list(unsigned char *buf, uint32_t list_strlen,
                 LIBSSH2_COMMON_METHOD ** method)
 {
     _libssh2_htonu32(buf, list_strlen);
@@ -3091,7 +3313,7 @@ kex_method_list(unsigned char *buf, size_t list_strlen,
     }
 
     while(*method && (*method)->name) {
-        int mlen = strlen((*method)->name);
+        uint32_t mlen = (uint32_t)strlen((*method)->name);
         memcpy(buf, (*method)->name, mlen);
         buf += mlen;
         *(buf++) = ',';
@@ -3104,20 +3326,22 @@ kex_method_list(unsigned char *buf, size_t list_strlen,
 
 
 #define LIBSSH2_METHOD_PREFS_LEN(prefvar, defaultvar)           \
-    ((prefvar) ? strlen(prefvar) :                              \
-     kex_method_strlen((LIBSSH2_COMMON_METHOD**)(defaultvar)))
-
-#define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar)  \
-    if(prefvar) {                                                       \
-        _libssh2_htonu32((buf), (prefvarlen));                          \
-        buf += 4;                                                       \
-        memcpy((buf), (prefvar), (prefvarlen));                         \
-        buf += (prefvarlen);                                            \
-    }                                                                   \
-    else {                                                              \
-        buf += kex_method_list((buf), (prefvarlen),                     \
-                               (LIBSSH2_COMMON_METHOD**)(defaultvar));  \
-    }
+    (uint32_t)((prefvar) ? strlen(prefvar) :                    \
+        kex_method_strlen((LIBSSH2_COMMON_METHOD**)(defaultvar)))
+
+#define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar)     \
+    do {                                                                   \
+        if(prefvar) {                                                      \
+            _libssh2_htonu32((buf), (prefvarlen));                         \
+            buf += 4;                                                      \
+            memcpy((buf), (prefvar), (prefvarlen));                        \
+            buf += (prefvarlen);                                           \
+        }                                                                  \
+        else {                                                             \
+            buf += kex_method_list((buf), (prefvarlen),                    \
+                                   (LIBSSH2_COMMON_METHOD**)(defaultvar)); \
+        }                                                                  \
+    } while(0)
 
 /* kexinit
  * Send SSH_MSG_KEXINIT packet
@@ -3127,15 +3351,16 @@ static int kexinit(LIBSSH2_SESSION * session)
     /* 62 = packet_type(1) + cookie(16) + first_packet_follows(1) +
        reserved(4) + length longs(40) */
     size_t data_len = 62;
-    size_t kex_len, hostkey_len = 0;
-    size_t crypt_cs_len, crypt_sc_len;
-    size_t comp_cs_len, comp_sc_len;
-    size_t mac_cs_len, mac_sc_len;
-    size_t lang_cs_len, lang_sc_len;
     unsigned char *data, *s;
     int rc;
 
     if(session->kexinit_state == libssh2_NB_state_idle) {
+        uint32_t kex_len, hostkey_len;
+        uint32_t crypt_cs_len, crypt_sc_len;
+        uint32_t comp_cs_len, comp_sc_len;
+        uint32_t mac_cs_len, mac_sc_len;
+        uint32_t lang_cs_len, lang_sc_len;
+
         kex_len =
             LIBSSH2_METHOD_PREFS_LEN(session->kex_prefs, libssh2_kex_methods);
         hostkey_len =
@@ -3165,8 +3390,8 @@ static int kexinit(LIBSSH2_SESSION * session)
             LIBSSH2_METHOD_PREFS_LEN(session->remote.lang_prefs, NULL);
 
         data_len += kex_len + hostkey_len + crypt_cs_len + crypt_sc_len +
-            comp_cs_len + comp_sc_len + mac_cs_len + mac_sc_len +
-            lang_cs_len + lang_sc_len;
+                    comp_cs_len + comp_sc_len + mac_cs_len + mac_sc_len +
+                    lang_cs_len + lang_sc_len;
 
         s = data = LIBSSH2_ALLOC(session, data_len);
         if(!data) {
@@ -3222,25 +3447,35 @@ static int kexinit(LIBSSH2_SESSION * session)
             /* Funnily enough, they'll all "appear" to be '\0' terminated */
             unsigned char *p = data + 21;   /* type(1) + cookie(16) + len(4) */
 
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent KEX: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent KEX: %s", p));
             p += kex_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent HOSTKEY: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent HOSTKEY: %s", p));
             p += hostkey_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_CS: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent CRYPT_CS: %s", p));
             p += crypt_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent CRYPT_SC: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent CRYPT_SC: %s", p));
             p += crypt_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_CS: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent MAC_CS: %s", p));
             p += mac_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent MAC_SC: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent MAC_SC: %s", p));
             p += mac_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_CS: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent COMP_CS: %s", p));
             p += comp_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent COMP_SC: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent COMP_SC: %s", p));
             p += comp_sc_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_CS: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent LANG_CS: %s", p));
             p += lang_cs_len + 4;
-            _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Sent LANG_SC: %s", p);
+            _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                           "Sent LANG_SC: %s", p));
             p += lang_sc_len + 4;
         }
 #endif /* LIBSSH2DEBUG */
@@ -3281,19 +3516,19 @@ static int kexinit(LIBSSH2_SESSION * session)
     return 0;
 }
 
-/* kex_agree_instr
+/* _libssh2_kex_agree_instr
  * Kex specific variant of strstr()
- * Needle must be precede by BOL or ',', and followed by ',' or EOL
+ * Needle must be preceded by BOL or ',', and followed by ',' or EOL
  */
-static unsigned char *
-kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
-                const unsigned char *needle, unsigned long needle_len)
+unsigned char *
+_libssh2_kex_agree_instr(unsigned char *haystack, size_t haystack_len,
+                         const unsigned char *needle, size_t needle_len)
 {
     unsigned char *s;
     unsigned char *end_haystack;
-    unsigned long left;
+    size_t left;
 
-    if(haystack == NULL || needle == NULL) {
+    if(!haystack || !needle) {
         return NULL;
     }
 
@@ -3314,11 +3549,13 @@ kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
 
     /* Search until we run out of comas or we run out of haystack,
        whichever comes first */
-    while((s = (unsigned char *) memchr((char *) s, ',', left))) {
+    /* !checksrc! disable EQUALSNULL 1 */
+    while((s = (unsigned char *) memchr((char *) s, ',', left)) != NULL) {
         /* Advance buffer past coma if we can */
         left = end_haystack - s;
         if((left >= 1) && (left <= haystack_len) && (left > needle_len)) {
             s++;
+            left--;
         }
         else {
             return NULL;
@@ -3359,8 +3596,8 @@ kex_get_method_by_name(const char *name, size_t name_len,
  * Agree on a Hostkey which works with this kex
  */
 static int kex_agree_hostkey(LIBSSH2_SESSION * session,
-                             unsigned long kex_flags,
-                             unsigned char *hostkey, unsigned long hostkey_len)
+                             size_t kex_flags,
+                             unsigned char *hostkey, size_t hostkey_len)
 {
     const LIBSSH2_HOSTKEY_METHOD **hostkeyp = libssh2_hostkey_methods();
     unsigned char *s;
@@ -3371,7 +3608,7 @@ static int kex_agree_hostkey(LIBSSH2_SESSION * session,
         while(s && *s) {
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            if(kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
+            if(_libssh2_kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
                 const LIBSSH2_HOSTKEY_METHOD *method =
                     (const LIBSSH2_HOSTKEY_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
@@ -3405,9 +3642,9 @@ static int kex_agree_hostkey(LIBSSH2_SESSION * session,
     }
 
     while(hostkeyp && (*hostkeyp) && (*hostkeyp)->name) {
-        s = kex_agree_instr(hostkey, hostkey_len,
-                            (unsigned char *) (*hostkeyp)->name,
-                            strlen((*hostkeyp)->name));
+        s = _libssh2_kex_agree_instr(hostkey, hostkey_len,
+                                     (unsigned char *) (*hostkeyp)->name,
+                                     strlen((*hostkeyp)->name));
         if(s) {
             /* So far so good, but does it suit our purposes? (Encrypting vs
                Signing) */
@@ -3436,11 +3673,17 @@ static int kex_agree_hostkey(LIBSSH2_SESSION * session,
  * Agree on a Key Exchange method and a hostkey encoding type
  */
 static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
-                                 unsigned long kex_len, unsigned char *hostkey,
-                                 unsigned long hostkey_len)
+                                 size_t kex_len, unsigned char *hostkey,
+                                 size_t hostkey_len)
 {
     const LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
     unsigned char *s;
+    const unsigned char *strict =
+        (unsigned char *)"kex-strict-s-v00@openssh.com";
+
+    if(_libssh2_kex_agree_instr(kex, kex_len, strict, 28)) {
+        session->kex_strict = 1;
+    }
 
     if(session->kex_prefs) {
         s = (unsigned char *) session->kex_prefs;
@@ -3448,7 +3691,7 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
         while(s && *s) {
             unsigned char *q, *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
-            q = kex_agree_instr(kex, kex_len, s, method_len);
+            q = _libssh2_kex_agree_instr(kex, kex_len, s, method_len);
             if(q) {
                 const LIBSSH2_KEX_METHOD *method = (const LIBSSH2_KEX_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
@@ -3464,7 +3707,7 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
                  * Can we agree on a hostkey that works with this kex?
                  */
                 if(kex_agree_hostkey(session, method->flags, hostkey,
-                                      hostkey_len) == 0) {
+                                     hostkey_len) == 0) {
                     session->kex = method;
                     if(session->burn_optimistic_kexinit && (kex == q)) {
                         /* Server sent an optimistic packet, and client agrees
@@ -3482,15 +3725,15 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
     }
 
     while(*kexp && (*kexp)->name) {
-        s = kex_agree_instr(kex, kex_len,
-                            (unsigned char *) (*kexp)->name,
-                            strlen((*kexp)->name));
+        s = _libssh2_kex_agree_instr(kex, kex_len,
+                                     (unsigned char *) (*kexp)->name,
+                                     strlen((*kexp)->name));
         if(s) {
             /* We've agreed on a key exchange method,
              * Can we agree on a hostkey that works with this kex?
              */
             if(kex_agree_hostkey(session, (*kexp)->flags, hostkey,
-                                  hostkey_len) == 0) {
+                                 hostkey_len) == 0) {
                 session->kex = *kexp;
                 if(session->burn_optimistic_kexinit && (kex == s)) {
                     /* Server sent an optimistic packet, and client agrees
@@ -3514,12 +3757,12 @@ static int kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
 static int kex_agree_crypt(LIBSSH2_SESSION * session,
                            libssh2_endpoint_data *endpoint,
                            unsigned char *crypt,
-                           unsigned long crypt_len)
+                           size_t crypt_len)
 {
     const LIBSSH2_CRYPT_METHOD **cryptp = libssh2_crypt_methods();
     unsigned char *s;
 
-    (void) session;
+    (void)session;
 
     if(endpoint->crypt_prefs) {
         s = (unsigned char *) endpoint->crypt_prefs;
@@ -3528,7 +3771,7 @@ static int kex_agree_crypt(LIBSSH2_SESSION * session,
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if(kex_agree_instr(crypt, crypt_len, s, method_len)) {
+            if(_libssh2_kex_agree_instr(crypt, crypt_len, s, method_len)) {
                 const LIBSSH2_CRYPT_METHOD *method =
                     (const LIBSSH2_CRYPT_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
@@ -3550,9 +3793,9 @@ static int kex_agree_crypt(LIBSSH2_SESSION * session,
     }
 
     while(*cryptp && (*cryptp)->name) {
-        s = kex_agree_instr(crypt, crypt_len,
-                            (unsigned char *) (*cryptp)->name,
-                            strlen((*cryptp)->name));
+        s = _libssh2_kex_agree_instr(crypt, crypt_len,
+                                     (unsigned char *) (*cryptp)->name,
+                                     strlen((*cryptp)->name));
         if(s) {
             endpoint->crypt = *cryptp;
             return 0;
@@ -3570,11 +3813,20 @@ static int kex_agree_crypt(LIBSSH2_SESSION * session,
  */
 static int kex_agree_mac(LIBSSH2_SESSION * session,
                          libssh2_endpoint_data * endpoint, unsigned char *mac,
-                         unsigned long mac_len)
+                         size_t mac_len)
 {
     const LIBSSH2_MAC_METHOD **macp = _libssh2_mac_methods();
+    const LIBSSH2_MAC_METHOD *override;
     unsigned char *s;
-    (void) session;
+    (void)session;
+
+    override = _libssh2_mac_override(endpoint->crypt);
+    if(override) {
+        /* This crypto method has its own hmac method built-in, so a separate
+         * negotiation (and use) of a separate hmac method is unnecessary */
+        endpoint->mac = override;
+        return 0;
+    }
 
     if(endpoint->mac_prefs) {
         s = (unsigned char *) endpoint->mac_prefs;
@@ -3583,7 +3835,7 @@ static int kex_agree_mac(LIBSSH2_SESSION * session,
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if(kex_agree_instr(mac, mac_len, s, method_len)) {
+            if(_libssh2_kex_agree_instr(mac, mac_len, s, method_len)) {
                 const LIBSSH2_MAC_METHOD *method = (const LIBSSH2_MAC_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
                                            (const LIBSSH2_COMMON_METHOD **)
@@ -3604,8 +3856,9 @@ static int kex_agree_mac(LIBSSH2_SESSION * session,
     }
 
     while(*macp && (*macp)->name) {
-        s = kex_agree_instr(mac, mac_len, (unsigned char *) (*macp)->name,
-                            strlen((*macp)->name));
+        s = _libssh2_kex_agree_instr(mac, mac_len,
+                                     (unsigned char *) (*macp)->name,
+                                     strlen((*macp)->name));
         if(s) {
             endpoint->mac = *macp;
             return 0;
@@ -3623,11 +3876,11 @@ static int kex_agree_mac(LIBSSH2_SESSION * session,
  */
 static int kex_agree_comp(LIBSSH2_SESSION *session,
                           libssh2_endpoint_data *endpoint, unsigned char *comp,
-                          unsigned long comp_len)
+                          size_t comp_len)
 {
     const LIBSSH2_COMP_METHOD **compp = _libssh2_comp_methods(session);
     unsigned char *s;
-    (void) session;
+    (void)session;
 
     if(endpoint->comp_prefs) {
         s = (unsigned char *) endpoint->comp_prefs;
@@ -3636,7 +3889,7 @@ static int kex_agree_comp(LIBSSH2_SESSION *session,
             unsigned char *p = (unsigned char *) strchr((char *) s, ',');
             size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
 
-            if(kex_agree_instr(comp, comp_len, s, method_len)) {
+            if(_libssh2_kex_agree_instr(comp, comp_len, s, method_len)) {
                 const LIBSSH2_COMP_METHOD *method =
                     (const LIBSSH2_COMP_METHOD *)
                     kex_get_method_by_name((char *) s, method_len,
@@ -3658,8 +3911,9 @@ static int kex_agree_comp(LIBSSH2_SESSION *session,
     }
 
     while(*compp && (*compp)->name) {
-        s = kex_agree_instr(comp, comp_len, (unsigned char *) (*compp)->name,
-                            strlen((*compp)->name));
+        s = _libssh2_kex_agree_instr(comp, comp_len,
+                                     (unsigned char *) (*compp)->name,
+                                     strlen((*compp)->name));
         if(s) {
             endpoint->comp = *compp;
             return 0;
@@ -3679,7 +3933,7 @@ static int kex_agree_comp(LIBSSH2_SESSION *session,
  * Decide which specific method to use of the methods offered by each party
  */
 static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
-                             unsigned data_len)
+                             size_t data_len)
 {
     unsigned char *kex, *hostkey, *crypt_cs, *crypt_sc, *comp_cs, *comp_sc,
         *mac_cs, *mac_sc;
@@ -3733,45 +3987,54 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
     }
 
     if(kex_agree_crypt(session, &session->local, crypt_cs, crypt_cs_len)
-       || kex_agree_crypt(session, &session->remote, crypt_sc,
-                          crypt_sc_len)) {
+       || kex_agree_crypt(session, &session->remote, crypt_sc, crypt_sc_len)) {
         return -1;
     }
 
-    if(kex_agree_mac(session, &session->local, mac_cs, mac_cs_len) ||
-        kex_agree_mac(session, &session->remote, mac_sc, mac_sc_len)) {
+    /* This must happen after kex_agree_crypt since some MACs depend on the
+       negotiated crypto method */
+    if(kex_agree_mac(session, &session->local, mac_cs, mac_cs_len)
+       || kex_agree_mac(session, &session->remote, mac_sc, mac_sc_len)) {
         return -1;
     }
 
-    if(kex_agree_comp(session, &session->local, comp_cs, comp_cs_len) ||
-        kex_agree_comp(session, &session->remote, comp_sc, comp_sc_len)) {
+    if(kex_agree_comp(session, &session->local, comp_cs, comp_cs_len)
+       || kex_agree_comp(session, &session->remote, comp_sc, comp_sc_len)) {
         return -1;
     }
 
 #if 0
     if(libssh2_kex_agree_lang(session, &session->local, lang_cs, lang_cs_len)
-        || libssh2_kex_agree_lang(session, &session->remote, lang_sc,
-                                  lang_sc_len)) {
+       || libssh2_kex_agree_lang(session, &session->remote, lang_sc,
+                                 lang_sc_len)) {
         return -1;
     }
 #endif
 
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on KEX method: %s",
-                   session->kex->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on HOSTKEY method: %s",
-                   session->hostkey->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_CS method: %s",
-                   session->local.crypt->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on CRYPT_SC method: %s",
-                   session->remote.crypt->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_CS method: %s",
-                   session->local.mac->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on MAC_SC method: %s",
-                   session->remote.mac->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_CS method: %s",
-                   session->local.comp->name);
-    _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_SC method: %s",
-                   session->remote.comp->name);
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on KEX method: %s",
+                   session->kex->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on HOSTKEY method: %s",
+                   session->hostkey->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on CRYPT_CS method: %s",
+                   session->local.crypt->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on CRYPT_SC method: %s",
+                   session->remote.crypt->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on MAC_CS method: %s",
+                   session->local.mac->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on MAC_SC method: %s",
+                   session->remote.mac->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on COMP_CS method: %s",
+                   session->local.comp->name));
+    _libssh2_debug((session, LIBSSH2_TRACE_KEX,
+                   "Agreed on COMP_SC method: %s",
+                   session->remote.comp->name));
 
     return 0;
 }
@@ -3798,6 +4061,10 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
         session->state |= LIBSSH2_STATE_EXCHANGING_KEYS;
 
         if(reexchange) {
+            if(session->kex && session->kex->cleanup) {
+                session->kex->cleanup(session, &key_state->key_state_low);
+            }
+
             session->kex = NULL;
 
             if(session->hostkey && session->hostkey->dtor) {
@@ -3831,6 +4098,7 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
                 session->local.kexinit = key_state->oldlocal;
                 session->local.kexinit_len = key_state->oldlocal_len;
                 key_state->state = libssh2_NB_state_idle;
+                session->state &= ~LIBSSH2_STATE_INITIAL_KEX;
                 session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
                 session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
                 return -1;
@@ -3856,6 +4124,7 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
                 session->local.kexinit = key_state->oldlocal;
                 session->local.kexinit_len = key_state->oldlocal_len;
                 key_state->state = libssh2_NB_state_idle;
+                session->state &= ~LIBSSH2_STATE_INITIAL_KEX;
                 session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
                 session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
                 return -1;
@@ -3866,9 +4135,10 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
             }
             session->remote.kexinit = key_state->data;
             session->remote.kexinit_len = key_state->data_len;
+            key_state->data = NULL;
 
-            if(kex_agree_methods(session, key_state->data,
-                                  key_state->data_len))
+            if(kex_agree_methods(session, session->remote.kexinit,
+                                 session->remote.kexinit_len))
                 rc = LIBSSH2_ERROR_KEX_FAILURE;
 
             key_state->state = libssh2_NB_state_sent2;
@@ -3904,6 +4174,7 @@ _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
         session->remote.kexinit = NULL;
     }
 
+    session->state &= ~LIBSSH2_STATE_INITIAL_KEX;
     session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
     session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
 
@@ -3922,50 +4193,61 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
                             const char *prefs)
 {
     char **prefvar, *s, *newprefs;
-    int prefs_len = strlen(prefs);
+    char *tmpprefs = NULL;
+    size_t prefs_len = strlen(prefs);
     const LIBSSH2_COMMON_METHOD **mlist;
+    const char *kex_extensions = "ext-info-c,kex-strict-c-v00@openssh.com,";
+    size_t kex_extensions_len = strlen(kex_extensions);
 
     switch(method_type) {
     case LIBSSH2_METHOD_KEX:
         prefvar = &session->kex_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_kex_methods;
+        tmpprefs = LIBSSH2_ALLOC(session, kex_extensions_len + prefs_len + 1);
+        if(!tmpprefs) {
+            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                  "Error allocated space for kex method"
+                                  " preferences");
+        }
+        memcpy(tmpprefs, kex_extensions, kex_extensions_len);
+        memcpy(tmpprefs + kex_extensions_len, prefs, prefs_len + 1);
+        prefs = tmpprefs;
+        prefs_len = strlen(prefs);
         break;
 
     case LIBSSH2_METHOD_HOSTKEY:
         prefvar = &session->hostkey_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_hostkey_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_hostkey_methods();
         break;
 
     case LIBSSH2_METHOD_CRYPT_CS:
         prefvar = &session->local.crypt_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_crypt_methods();
         break;
 
     case LIBSSH2_METHOD_CRYPT_SC:
         prefvar = &session->remote.crypt_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_crypt_methods();
         break;
 
     case LIBSSH2_METHOD_MAC_CS:
         prefvar = &session->local.mac_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_mac_methods();
         break;
 
     case LIBSSH2_METHOD_MAC_SC:
         prefvar = &session->remote.mac_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_mac_methods();
         break;
 
     case LIBSSH2_METHOD_COMP_CS:
         prefvar = &session->local.comp_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_comp_methods(session);
         break;
 
     case LIBSSH2_METHOD_COMP_SC:
         prefvar = &session->remote.comp_prefs;
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_comp_methods(session);
         break;
 
     case LIBSSH2_METHOD_LANG_CS:
@@ -3978,6 +4260,11 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
         mlist = NULL;
         break;
 
+    case LIBSSH2_METHOD_SIGN_ALGO:
+        prefvar = &session->sign_algo_prefs;
+        mlist = NULL;
+        break;
+
     default:
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "Invalid parameter specified for method_type");
@@ -3985,6 +4272,9 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
 
     s = newprefs = LIBSSH2_ALLOC(session, prefs_len + 1);
     if(!newprefs) {
+        if(tmpprefs) {
+            LIBSSH2_FREE(session, tmpprefs);
+        }
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Error allocated space for method preferences");
     }
@@ -3992,12 +4282,12 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
 
     while(s && *s && mlist) {
         char *p = strchr(s, ',');
-        int method_len = p ? (p - s) : (int) strlen(s);
+        size_t method_len = (p ? (size_t)(p - s) : strlen(s));
 
         if(!kex_get_method_by_name(s, method_len, mlist)) {
             /* Strip out unsupported method */
             if(p) {
-                memcpy(s, p + 1, strlen(s) - method_len);
+                memmove(s, p + 1, strlen(s) - method_len);
             }
             else {
                 if(s > newprefs) {
@@ -4013,6 +4303,10 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
         }
     }
 
+    if(tmpprefs) {
+        LIBSSH2_FREE(session, tmpprefs);
+    }
+
     if(!*newprefs) {
         LIBSSH2_FREE(session, newprefs);
         return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
@@ -4029,7 +4323,7 @@ libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
 }
 
 /*
- * libssh2_session_supported_algs()
+ * libssh2_session_supported_algs
  * returns a number of returned algorithms (a positive number) on success,
  * a negative number on failure
  */
@@ -4044,33 +4338,37 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     const LIBSSH2_COMMON_METHOD **mlist;
 
     /* to prevent coredumps due to dereferencing of NULL */
-    if(NULL == algs)
+    if(!algs)
         return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
                               "algs must not be NULL");
 
     switch(method_type) {
     case LIBSSH2_METHOD_KEX:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_kex_methods;
         break;
 
     case LIBSSH2_METHOD_HOSTKEY:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_hostkey_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_hostkey_methods();
         break;
 
     case LIBSSH2_METHOD_CRYPT_CS:
     case LIBSSH2_METHOD_CRYPT_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)libssh2_crypt_methods();
         break;
 
     case LIBSSH2_METHOD_MAC_CS:
     case LIBSSH2_METHOD_MAC_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **) _libssh2_mac_methods();
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_mac_methods();
         break;
 
     case LIBSSH2_METHOD_COMP_CS:
     case LIBSSH2_METHOD_COMP_SC:
-        mlist = (const LIBSSH2_COMMON_METHOD **)
-            _libssh2_comp_methods(session);
+        mlist = (const LIBSSH2_COMMON_METHOD **)_libssh2_comp_methods(session);
+        break;
+
+    case LIBSSH2_METHOD_SIGN_ALGO:
+        /* no built-in supported list due to backend support */
+        mlist = NULL;
         break;
 
     default:
@@ -4079,7 +4377,7 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     }  /* switch */
 
     /* weird situation */
-    if(NULL == mlist)
+    if(!mlist)
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "No algorithm found");
 
@@ -4096,28 +4394,28 @@ LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
     */
 
     /* count the number of supported algorithms */
-    for(i = 0, ialg = 0; NULL != mlist[i]; i++) {
+    for(i = 0, ialg = 0; mlist[i]; i++) {
         /* do not count fields with NULL name */
         if(mlist[i]->name)
             ialg++;
     }
 
     /* weird situation, no algorithm found */
-    if(0 == ialg)
+    if(ialg == 0)
         return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                               "No algorithm found");
 
     /* allocate buffer */
     *algs = (const char **) LIBSSH2_ALLOC(session, ialg*sizeof(const char *));
-    if(NULL == *algs) {
+    if(!*algs) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Memory allocation failed");
     }
-    /* Past this point *algs must be deallocated in case of an error!! */
+    /* Past this point *algs must be deallocated in case of an error! */
 
     /* copy non-NULL pointers only */
-    for(i = 0, j = 0; NULL != mlist[i] && j < ialg; i++) {
-        if(NULL == mlist[i]->name) {
+    for(i = 0, j = 0; mlist[i] && j < ialg; i++) {
+        if(!mlist[i]->name) {
             /* maybe a weird situation but if it occurs, do not include NULL
                pointers */
             continue;
diff --git a/libssh2/src/knownhost.c b/libssh2/src/knownhost.c
index 77798fbf..79500ec5 100644
--- a/libssh2/src/knownhost.c
+++ b/libssh2/src/knownhost.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2019 by Daniel Stenberg
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,10 +34,11 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include "misc.h"
 
 struct known_host {
     struct list_node node;
@@ -111,7 +112,7 @@ libssh2_knownhost_init(LIBSSH2_SESSION *session)
 
 #define KNOWNHOST_MAGIC 0xdeadcafe
 /*
- * knownhost_to_external()
+ * knownhost_to_external
  *
  * Copies data from the internal to the external representation struct.
  *
@@ -123,7 +124,7 @@ static struct libssh2_knownhost *knownhost_to_external(struct known_host *node)
     ext->magic = KNOWNHOST_MAGIC;
     ext->node = node;
     ext->name = ((node->typemask & LIBSSH2_KNOWNHOST_TYPE_MASK) ==
-                 LIBSSH2_KNOWNHOST_TYPE_PLAIN)? node->name:NULL;
+                 LIBSSH2_KNOWNHOST_TYPE_PLAIN) ? node->name : NULL;
     ext->key = node->key;
     ext->typemask = node->typemask;
 
@@ -142,7 +143,7 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
     size_t hostlen = strlen(host);
     int rc;
     char *ptr;
-    unsigned int ptrlen;
+    size_t ptrlen;
 
     /* make sure we have a key type set */
     if(!(typemask & LIBSSH2_KNOWNHOST_KEY_MASK))
@@ -170,15 +171,15 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
         entry->name_len = hostlen;
         break;
     case LIBSSH2_KNOWNHOST_TYPE_SHA1:
-        rc = libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
-                                   host, hostlen);
+        rc = _libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
+                                    host, hostlen);
         if(rc)
             goto error;
         entry->name = ptr;
         entry->name_len = ptrlen;
 
-        rc = libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
-                                   salt, strlen(salt));
+        rc = _libssh2_base64_decode(hosts->session, &ptr, &ptrlen,
+                                    salt, strlen(salt));
         if(rc)
             goto error;
         entry->salt = ptr;
@@ -252,7 +253,7 @@ knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
         *store = knownhost_to_external(entry);
 
     return LIBSSH2_ERROR_NONE;
-  error:
+error:
     free_host(hosts->session, entry);
     return rc;
 }
@@ -420,19 +421,23 @@ knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
                     */
                     unsigned char hash[SHA_DIGEST_LENGTH];
                     libssh2_hmac_ctx ctx;
-                    libssh2_hmac_ctx_init(ctx);
+                    if(!_libssh2_hmac_ctx_init(&ctx))
+                        break;
 
                     if(SHA_DIGEST_LENGTH != node->name_len) {
                         /* the name hash length must be the sha1 size or
                            we can't match it */
                         break;
                     }
-                    libssh2_hmac_sha1_init(&ctx, (unsigned char *)node->salt,
-                                           node->salt_len);
-                    libssh2_hmac_update(ctx, (unsigned char *)host,
-                                        strlen(host));
-                    libssh2_hmac_final(ctx, hash);
-                    libssh2_hmac_cleanup(&ctx);
+                    if(!_libssh2_hmac_sha1_init(&ctx,
+                                                node->salt, node->salt_len))
+                        break;
+                    if(!_libssh2_hmac_update(&ctx, host, strlen(host)) ||
+                       !_libssh2_hmac_final(&ctx, hash)) {
+                        _libssh2_hmac_cleanup(&ctx);
+                        break;
+                    }
+                    _libssh2_hmac_cleanup(&ctx);
 
                     if(!memcmp(hash, node->name, SHA_DIGEST_LENGTH))
                         /* this is a node we're interested in */
@@ -727,7 +732,7 @@ static int hashed_hostline(LIBSSH2_KNOWNHOSTS *hosts,
 }
 
 /*
- * hostline()
+ * hostline
  *
  * Parse a single known_host line pre-split into host and key.
  *
@@ -774,18 +779,20 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
         }
         key_type_len = key - key_type_name;
 
-        if(!strncmp(key_type_name, "ssh-dss", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
-        else if(!strncmp(key_type_name, "ssh-rsa", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
+        if(!strncmp(key_type_name, "ssh-ed25519", key_type_len))
+            key_type = LIBSSH2_KNOWNHOST_KEY_ED25519;
         else if(!strncmp(key_type_name, "ecdsa-sha2-nistp256", key_type_len))
             key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
         else if(!strncmp(key_type_name, "ecdsa-sha2-nistp384", key_type_len))
             key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
         else if(!strncmp(key_type_name, "ecdsa-sha2-nistp521", key_type_len))
             key_type = LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
-        else if(!strncmp(key_type_name, "ssh-ed25519", key_type_len))
-            key_type = LIBSSH2_KNOWNHOST_KEY_ED25519;
+        else if(!strncmp(key_type_name, "ssh-rsa", key_type_len))
+            key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
+#if LIBSSH2_DSA
+        else if(!strncmp(key_type_name, "ssh-dss", key_type_len))
+            key_type = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
+#endif
         else
             key_type = LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
 
@@ -822,7 +829,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
     }
 
     /* Figure out host format */
-    if((hostlen >2) && memcmp(host, "|1|", 3)) {
+    if((hostlen > 2) && memcmp(host, "|1|", 3)) {
         /* old style plain text: [name]([,][name])*
 
            for the sake of simplicity, we add them as separate hosts with the
@@ -841,7 +848,7 @@ static int hostline(LIBSSH2_KNOWNHOSTS *hosts,
 }
 
 /*
- * libssh2_knownhost_readline()
+ * libssh2_knownhost_readline
  *
  * Pass in a line of a file of 'type'.
  *
@@ -983,7 +990,7 @@ libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
 }
 
 /*
- * knownhost_writeline()
+ * knownhost_writeline
  *
  * Ask libssh2 to convert a known host to an output line for storage.
  *
@@ -1021,10 +1028,12 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
         key_type_name = "ssh-rsa";
         key_type_len = 7;
         break;
+#if LIBSSH2_DSA
     case LIBSSH2_KNOWNHOST_KEY_SSHDSS:
         key_type_name = "ssh-dss";
         key_type_len = 7;
         break;
+#endif
     case LIBSSH2_KNOWNHOST_KEY_ECDSA_256:
         key_type_name = "ecdsa-sha2-nistp256";
         key_type_len = 19;
@@ -1048,7 +1057,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
             break;
         }
         /* otherwise fallback to default and error */
-        /* FALL-THROUGH */
+        LIBSSH2_FALLTHROUGH();
     default:
         return _libssh2_error(hosts->session,
                               LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
@@ -1157,7 +1166,7 @@ knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
 }
 
 /*
- * libssh2_knownhost_writeline()
+ * libssh2_knownhost_writeline
  *
  * Ask libssh2 to convert a known host to an output line for storage.
  *
@@ -1183,7 +1192,7 @@ libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
 }
 
 /*
- * libssh2_knownhost_writefile()
+ * libssh2_knownhost_writefile
  *
  * Write hosts+key pairs to the given file.
  */
@@ -1234,7 +1243,7 @@ libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
 
 
 /*
- * libssh2_knownhost_get()
+ * libssh2_knownhost_get
  *
  * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
  * the first one.
diff --git a/libssh2/src/libgcrypt.c b/libssh2/src/libgcrypt.c
index 0aff176a..b92ec7c9 100644
--- a/libssh2/src/libgcrypt.c
+++ b/libssh2/src/libgcrypt.c
@@ -1,5 +1,5 @@
-/* Copyright (C) 2008, 2009, Simon Josefsson
- * Copyright (C) 2006, 2007, The Written Word, Inc.
+/* Copyright (C) Simon Josefsson
+ * Copyright (C) The Written Word, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,14 +34,112 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_priv.h"
+#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */
+
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
+{
+    *ctx = NULL;
+    return 1;
+}
+
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen)
+{
+    gcry_error_t err;
+    err = gcry_md_open(ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    err = gcry_md_setkey(*ctx, key, keylen);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    return 1;
+}
+#endif
+
+#if LIBSSH2_HMAC_RIPEMD
+int _libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
+                                 void *key, size_t keylen)
+{
+    gcry_error_t err;
+    err = gcry_md_open(ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    err = gcry_md_setkey(*ctx, key, keylen);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    return 1;
+}
+#endif
+
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen)
+{
+    gcry_error_t err;
+    err = gcry_md_open(ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    err = gcry_md_setkey(*ctx, key, keylen);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    return 1;
+}
+
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    gcry_error_t err;
+    err = gcry_md_open(ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    err = gcry_md_setkey(*ctx, key, keylen);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    return 1;
+}
+
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    gcry_error_t err;
+    err = gcry_md_open(ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    err = gcry_md_setkey(*ctx, key, keylen);
+    if(gcry_err_code(err) != GPG_ERR_NO_ERROR)
+        return 0;
+    return 1;
+}
+
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen)
+{
+    gcry_md_write(*ctx, data, datalen);
+    return 1;
+}
+
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data)
+{
+    unsigned char *res = gcry_md_read(*ctx, 0);
+
+    if(!res)
+        return 0;
+
+    memcpy(data, res, gcry_md_get_algo_dlen(gcry_md_get_algo(*ctx)));
 
-#ifdef LIBSSH2_LIBGCRYPT /* compile only if we build with libgcrypt */
+    return 1;
+}
 
-#include <string.h>
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
+{
+    gcry_md_close(*ctx);
+}
 
+#if LIBSSH2_RSA
 int
 _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
                  const unsigned char *edata,
@@ -61,17 +159,17 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
                  const unsigned char *coeffdata, unsigned long coefflen)
 {
     int rc;
-    (void) e1data;
-    (void) e1len;
-    (void) e2data;
-    (void) e2len;
+
+    (void)e1data;
+    (void)e1len;
+    (void)e2data;
+    (void)e2len;
 
     if(ddata) {
-        rc = gcry_sexp_build
-            (rsa, NULL,
-             "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
-             nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
-             qlen, qdata, coefflen, coeffdata);
+        rc = gcry_sexp_build(rsa, NULL,
+                 "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
+                 nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
+                 qlen, qdata, coefflen, coeffdata);
     }
     else {
         rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
@@ -85,27 +183,30 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
     return 0;
 }
 
+#if LIBSSH2_RSA_SHA1
 int
 _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
                          const unsigned char *sig,
-                         unsigned long sig_len,
-                         const unsigned char *m, unsigned long m_len)
+                         size_t sig_len,
+                         const unsigned char *m, size_t m_len)
 {
     unsigned char hash[SHA_DIGEST_LENGTH];
     gcry_sexp_t s_sig, s_hash;
     int rc = -1;
 
-    libssh2_sha1(m, m_len, hash);
+    if(libssh2_sha1(m, m_len, hash)) {
+        return -1;
+    }
 
     rc = gcry_sexp_build(&s_hash, NULL,
                          "(data (flags pkcs1) (hash sha1 %b))",
                          SHA_DIGEST_LENGTH, hash);
-    if(rc != 0) {
+    if(rc) {
         return -1;
     }
 
     rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig);
-    if(rc != 0) {
+    if(rc) {
         gcry_sexp_release(s_hash);
         return -1;
     }
@@ -116,7 +217,10 @@ _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
 
     return (rc == 0) ? 0 : -1;
 }
+#endif
+#endif
 
+#if LIBSSH2_DSA
 int
 _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
                  const unsigned char *p,
@@ -132,10 +236,9 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
     int rc;
 
     if(x_len) {
-        rc = gcry_sexp_build
-            (dsactx, NULL,
-             "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
-             p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
+        rc = gcry_sexp_build(dsactx, NULL,
+                 "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
+                  p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
     }
     else {
         rc = gcry_sexp_build(dsactx, NULL,
@@ -150,16 +253,23 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
 
     return 0;
 }
+#endif
 
+#if LIBSSH2_RSA
 int
 _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
                                     LIBSSH2_SESSION * session,
                                     const char *filedata, size_t filedata_len,
                                     unsigned const char *passphrase)
 {
+    (void)rsa;
+    (void)filedata;
+    (void)filedata_len;
+    (void)passphrase;
+
     return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                         "Unable to extract private key from memory: "
-                         "Method unimplemented in libgcrypt backend");
+                          "Unable to extract private key from memory: "
+                          "Method unimplemented in libgcrypt backend");
 }
 
 int
@@ -169,7 +279,7 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
 {
     FILE *fp;
     unsigned char *data, *save_data;
-    unsigned int datalen;
+    size_t datalen;
     int ret;
     unsigned char *n, *e, *d, *p, *q, *e1, *e2, *coeff;
     unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;
@@ -195,83 +305,91 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
         ret = -1;
         goto fail;
     }
-/* First read Version field (should be 0). */
+
+    /* First read Version field (should be 0). */
     ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if(ret != 0 || (nlen != 1 && *n != '\0')) {
+    if(ret || (nlen != 1 && *n != '\0')) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     if(_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
-                         q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
+                        q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
         ret = -1;
         goto fail;
     }
 
     ret = 0;
 
-  fail:
+fail:
     LIBSSH2_FREE(session, save_data);
     return ret;
 }
+#endif
 
+#if LIBSSH2_DSA
 int
 _libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
                                     LIBSSH2_SESSION * session,
                                     const char *filedata, size_t filedata_len,
                                     unsigned const char *passphrase)
 {
+    (void)dsa;
+    (void)filedata;
+    (void)filedata_len;
+    (void)passphrase;
+
     return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-                         "Unable to extract private key from memory: "
-                         "Method unimplemented in libgcrypt backend");
+                          "Unable to extract private key from memory: "
+                          "Method unimplemented in libgcrypt backend");
 }
 
 int
@@ -281,7 +399,7 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
 {
     FILE *fp;
     unsigned char *data, *save_data;
-    unsigned int datalen;
+    size_t datalen;
     int ret;
     unsigned char *p, *q, *g, *y, *x;
     unsigned int plen, qlen, glen, ylen, xlen;
@@ -308,44 +426,44 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
         goto fail;
     }
 
-/* First read Version field (should be 0). */
+    /* First read Version field (should be 0). */
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0 || (plen != 1 && *p != '\0')) {
+    if(ret || (plen != 1 && *p != '\0')) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
     ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen);
-    if(ret != 0) {
+    if(ret) {
         ret = -1;
         goto fail;
     }
 
-    if(datalen != 0) {
+    if(datalen) {
         ret = -1;
         goto fail;
     }
@@ -357,11 +475,14 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
 
     ret = 0;
 
-  fail:
+fail:
     LIBSSH2_FREE(session, save_data);
     return ret;
 }
+#endif
 
+#if LIBSSH2_RSA
+#if LIBSSH2_RSA_SHA1
 int
 _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
                        libssh2_rsa_ctx * rsactx,
@@ -380,8 +501,8 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
     }
 
     if(gcry_sexp_build(&data, NULL,
-                        "(data (flags pkcs1) (hash sha1 %b))",
-                        hash_len, hash)) {
+                       "(data (flags pkcs1) (hash sha1 %b))",
+                       hash_len, hash)) {
         return -1;
     }
 
@@ -389,7 +510,7 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
 
     gcry_sexp_release(data);
 
-    if(rc != 0) {
+    if(rc) {
         return -1;
     }
 
@@ -421,11 +542,14 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
 
     return rc;
 }
+#endif
+#endif
 
+#if LIBSSH2_DSA
 int
 _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
                        const unsigned char *hash,
-                       unsigned long hash_len, unsigned char *sig)
+                       size_t hash_len, unsigned char *sig)
 {
     unsigned char zhash[SHA_DIGEST_LENGTH + 1];
     gcry_sexp_t sig_sexp;
@@ -442,7 +566,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     zhash[0] = 0;
 
     if(gcry_sexp_build(&data, NULL, "(data (value %b))",
-                       hash_len + 1, zhash)) {
+                       (int)(hash_len + 1), zhash)) {
         return -1;
     }
 
@@ -450,13 +574,13 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 
     gcry_sexp_release(data);
 
-    if(ret != 0) {
+    if(ret) {
         return -1;
     }
 
     memset(sig, 0, 40);
 
-/* Extract R. */
+    /* Extract R. */
 
     data = gcry_sexp_find_token(sig_sexp, "r", 0);
     if(!data)
@@ -478,7 +602,7 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 
     gcry_sexp_release(data);
 
-/* Extract S. */
+    /* Extract S. */
 
     data = gcry_sexp_find_token(sig_sexp, "s", 0);
     if(!data)
@@ -499,10 +623,10 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     memcpy(sig + 20 + (20 - size), tmp, size);
     goto out;
 
-  err:
+err:
     ret = -1;
 
-  out:
+out:
     if(sig_sexp) {
         gcry_sexp_release(sig_sexp);
     }
@@ -515,22 +639,24 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 int
 _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
                          const unsigned char *sig,
-                         const unsigned char *m, unsigned long m_len)
+                         const unsigned char *m, size_t m_len)
 {
     unsigned char hash[SHA_DIGEST_LENGTH + 1];
     gcry_sexp_t s_sig, s_hash;
     int rc = -1;
 
-    libssh2_sha1(m, m_len, hash + 1);
+    if(libssh2_sha1(m, m_len, hash + 1)) {
+        return -1;
+    }
     hash[0] = 0;
 
     if(gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
-                        SHA_DIGEST_LENGTH + 1, hash)) {
+                       SHA_DIGEST_LENGTH + 1, hash)) {
         return -1;
     }
 
     if(gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
-                        20, sig, 20, sig + 20)) {
+                       20, sig, 20, sig + 20)) {
         gcry_sexp_release(s_hash);
         return -1;
     }
@@ -541,6 +667,7 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
 
     return (rc == 0) ? 0 : -1;
 }
+#endif
 
 int
 _libssh2_cipher_init(_libssh2_cipher_ctx * h,
@@ -550,9 +677,9 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
     int ret;
     int cipher = _libssh2_gcry_cipher(algo);
     int mode = _libssh2_gcry_mode(algo);
-    int keylen = gcry_cipher_get_algo_keylen(cipher);
+    size_t keylen = gcry_cipher_get_algo_keylen(cipher);
 
-    (void) encrypt;
+    (void)encrypt;
 
     ret = gcry_cipher_open(h, cipher, mode, 0);
     if(ret) {
@@ -566,7 +693,7 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
     }
 
     if(mode != GCRY_CIPHER_MODE_STREAM) {
-        int blklen = gcry_cipher_get_algo_blklen(cipher);
+        size_t blklen = gcry_cipher_get_algo_blklen(cipher);
         if(mode == GCRY_CIPHER_MODE_CTR)
             ret = gcry_cipher_setctr(*h, iv, blklen);
         else
@@ -583,11 +710,14 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
 int
 _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
                       _libssh2_cipher_type(algo),
-                      int encrypt, unsigned char *block, size_t blklen)
+                      int encrypt, unsigned char *block, size_t blklen,
+                      int firstlast)
 {
-    int cipher = _libssh2_gcry_cipher(algo);
     int ret;
 
+    (void)algo;
+    (void)firstlast;
+
     if(encrypt) {
         ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen);
     }
@@ -607,6 +737,14 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
                                 size_t privatekeydata_len,
                                 const char *passphrase)
 {
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)privatekeydata;
+    (void)privatekeydata_len;
+    (void)passphrase;
+
     return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
                           "Unable to extract public key from private "
                           "key in memory: "
@@ -622,9 +760,49 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
                           const char *privatekey,
                           const char *passphrase)
 {
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)privatekey;
+    (void)passphrase;
+
+    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                    "Unable to extract public key from private key file: "
+                    "Method unimplemented in libgcrypt backend");
+}
+
+int
+_libssh2_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                              unsigned char **method,
+                              size_t *method_len,
+                              unsigned char **pubkeydata,
+                              size_t *pubkeydata_len,
+                              int *algorithm,
+                              unsigned char *flags,
+                              const char **application,
+                              const unsigned char **key_handle,
+                              size_t *handle_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase)
+{
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)algorithm;
+    (void)flags;
+    (void)application;
+    (void)key_handle;
+    (void)handle_len;
+    (void)privatekeydata;
+    (void)privatekeydata_len;
+    (void)passphrase;
+
     return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                         "Unable to extract public key from private key file: "
-                         "Method unimplemented in libgcrypt backend");
+                    "Unable to extract public SK key from private key file: "
+                    "Method unimplemented in libgcrypt backend");
 }
 
 void _libssh2_init_aes_ctr(void)
@@ -664,4 +842,22 @@ _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
     *dhctx = NULL;
 }
 
-#endif /* LIBSSH2_LIBGCRYPT */
+/* _libssh2_supported_key_sign_algorithms
+ *
+ * Return supported key hash algo upgrades, see crypto.h
+ *
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len)
+{
+    (void)session;
+    (void)key_method;
+    (void)key_method_len;
+
+    return NULL;
+}
+
+#endif /* LIBSSH2_CRYPTO_C */
diff --git a/libssh2/src/libgcrypt.h b/libssh2/src/libgcrypt.h
index 298c65ed..e8efc4be 100644
--- a/libssh2/src/libgcrypt.h
+++ b/libssh2/src/libgcrypt.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_LIBGCRYPT_H
-#define __LIBSSH2_LIBGCRYPT_H
+#ifndef LIBSSH2_LIBGCRYPT_H
+#define LIBSSH2_LIBGCRYPT_H
 /*
- * Copyright (C) 2008, 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007, The Written Word, Inc.
+ * Copyright (C) Simon Josefsson
+ * Copyright (C) The Written Word, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -37,8 +37,12 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#define LIBSSH2_CRYPTO_ENGINE libssh2_gcrypt
+
 #include <gcrypt.h>
 
 #define LIBSSH2_MD5 1
@@ -47,19 +51,26 @@
 #define LIBSSH2_HMAC_SHA256 1
 #define LIBSSH2_HMAC_SHA512 1
 
-#define LIBSSH2_AES 1
+#define LIBSSH2_AES_CBC 1
 #define LIBSSH2_AES_CTR 1
+#define LIBSSH2_AES_GCM 0
 #define LIBSSH2_BLOWFISH 1
 #define LIBSSH2_RC4 1
 #define LIBSSH2_CAST 1
 #define LIBSSH2_3DES 1
 
 #define LIBSSH2_RSA 1
+#define LIBSSH2_RSA_SHA1 1
+#define LIBSSH2_RSA_SHA2 0
 #define LIBSSH2_DSA 1
 #define LIBSSH2_ECDSA 0
 #define LIBSSH2_ED25519 0
 
+#include "crypto_config.h"
+
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define MD5_DIGEST_LENGTH 16
+#endif
 #define SHA_DIGEST_LENGTH 20
 #define SHA256_DIGEST_LENGTH 32
 #define SHA384_DIGEST_LENGTH 48
@@ -67,103 +78,79 @@
 
 #define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
 
-#define _libssh2_random(buf, len)                \
-  (gcry_randomize ((buf), (len), GCRY_STRONG_RANDOM), 0)
+#define _libssh2_random(buf, len) \
+    (gcry_randomize((buf), (len), GCRY_STRONG_RANDOM), 0)
 
 #define libssh2_prepare_iovec(vec, len)  /* Empty. */
 
 #define libssh2_sha1_ctx gcry_md_hd_t
-
 /* returns 0 in case of failure */
 #define libssh2_sha1_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA1, 0))
+    (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA1, 0))
 #define libssh2_sha1_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
+    (gcry_md_write(ctx, (unsigned char *) data, len), 1)
 #define libssh2_sha1_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close(ctx)
+    (memcpy(out, gcry_md_read(ctx, 0), SHA_DIGEST_LENGTH), \
+    gcry_md_close(ctx), 1)
 #define libssh2_sha1(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA1, out, message, len)
+    (gcry_md_hash_buffer(GCRY_MD_SHA1, out, message, len), 0)
 
 #define libssh2_sha256_ctx gcry_md_hd_t
-
 #define libssh2_sha256_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA256, 0))
+    (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA256, 0))
 #define libssh2_sha256_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
+    (gcry_md_write(ctx, (unsigned char *) data, len), 1)
 #define libssh2_sha256_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA256_DIGEST_LENGTH), gcry_md_close(ctx)
+    (memcpy(out, gcry_md_read(ctx, 0), SHA256_DIGEST_LENGTH), \
+    gcry_md_close(ctx), 1)
 #define libssh2_sha256(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA256, out, message, len)
+    (gcry_md_hash_buffer(GCRY_MD_SHA256, out, message, len), 0)
 
 #define libssh2_sha384_ctx gcry_md_hd_t
-
 #define libssh2_sha384_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA384, 0))
+    (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA384, 0))
 #define libssh2_sha384_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
+    (gcry_md_write(ctx, (unsigned char *) data, len), 1)
 #define libssh2_sha384_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA384_DIGEST_LENGTH), gcry_md_close(ctx)
+    (memcpy(out, gcry_md_read(ctx, 0), SHA384_DIGEST_LENGTH), \
+    gcry_md_close(ctx), 1)
 #define libssh2_sha384(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA384, out, message, len)
+    (gcry_md_hash_buffer(GCRY_MD_SHA384, out, message, len), 0)
 
 #define libssh2_sha512_ctx gcry_md_hd_t
-
 #define libssh2_sha512_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_SHA512, 0))
+    (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_SHA512, 0))
 #define libssh2_sha512_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
+    (gcry_md_write(ctx, (unsigned char *) data, len), 1)
 #define libssh2_sha512_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), SHA512_DIGEST_LENGTH), gcry_md_close(ctx)
+    (memcpy(out, gcry_md_read(ctx, 0), SHA512_DIGEST_LENGTH), \
+    gcry_md_close(ctx), 1)
 #define libssh2_sha512(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_SHA512, out, message, len)
+    (gcry_md_hash_buffer(GCRY_MD_SHA512, out, message, len), 0)
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define libssh2_md5_ctx gcry_md_hd_t
-
-/* returns 0 in case of failure */
 #define libssh2_md5_init(ctx) \
-  (GPG_ERR_NO_ERROR == gcry_md_open(ctx,  GCRY_MD_MD5, 0))
-
+    (GPG_ERR_NO_ERROR == gcry_md_open(ctx, GCRY_MD_MD5, 0))
 #define libssh2_md5_update(ctx, data, len) \
-  gcry_md_write(ctx, (unsigned char *) data, len)
+    (gcry_md_write(ctx, (unsigned char *) data, len), 1)
 #define libssh2_md5_final(ctx, out) \
-  memcpy(out, gcry_md_read(ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close(ctx)
-#define libssh2_md5(message, len, out) \
-  gcry_md_hash_buffer(GCRY_MD_MD5, out, message, len)
+    (memcpy(out, gcry_md_read(ctx, 0), MD5_DIGEST_LENGTH), \
+    gcry_md_close(ctx), 1)
+#endif
 
 #define libssh2_hmac_ctx gcry_md_hd_t
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  gcry_md_open(ctx, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC), \
-    gcry_md_setkey(*ctx, key, keylen)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  gcry_md_write(ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, data) \
-  memcpy(data, gcry_md_read(ctx, 0), \
-      gcry_md_get_algo_dlen(gcry_md_get_algo(ctx)))
-#define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx);
-
-#define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM)
+
+#define libssh2_crypto_init() gcry_control(GCRYCTL_DISABLE_SECMEM)
 #define libssh2_crypto_exit()
 
 #define libssh2_rsa_ctx struct gcry_sexp
 
-#define _libssh2_rsa_free(rsactx)  gcry_sexp_release (rsactx)
+#define _libssh2_rsa_free(rsactx)  gcry_sexp_release(rsactx)
 
 #define libssh2_dsa_ctx struct gcry_sexp
 
-#define _libssh2_dsa_free(dsactx)  gcry_sexp_release (dsactx)
+#define _libssh2_dsa_free(dsactx)  gcry_sexp_release(dsactx)
 
 #if LIBSSH2_ECDSA
 #else
@@ -178,25 +165,27 @@
 #define _libssh2_gcry_mode(m) (m & 0xFF)
 
 #define _libssh2_cipher_aes256ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CTR)
 #define _libssh2_cipher_aes192ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CTR)
 #define _libssh2_cipher_aes128ctr \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR)
 #define _libssh2_cipher_aes256 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC)
 #define _libssh2_cipher_aes192 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC)
 #define _libssh2_cipher_aes128 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC)
 #define _libssh2_cipher_blowfish \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC)
 #define _libssh2_cipher_arcfour \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM)
 #define _libssh2_cipher_cast5 \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC)
 #define _libssh2_cipher_3des \
-  _libssh2_gcry_ciphermode(GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC)
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC)
+#define _libssh2_cipher_chacha20 \
+    _libssh2_gcry_ciphermode(GCRY_CIPHER_CHACHA20, GCRY_CIPHER_MODE_STREAM)
 
 
 #define _libssh2_cipher_dtor(ctx) gcry_cipher_close(*(ctx))
@@ -206,26 +195,35 @@
 #define _libssh2_bn_ctx_new() 0
 #define _libssh2_bn_ctx_free(bnctx) ((void)0)
 #define _libssh2_bn_init() gcry_mpi_new(0)
-#define _libssh2_bn_init_from_bin() NULL /* because gcry_mpi_scan() creates a
-                                            new bignum */
+#define _libssh2_bn_init_from_bin() NULL  /* because gcry_mpi_scan() creates a
+                                             new bignum */
 #define _libssh2_bn_set_word(bn, val) gcry_mpi_set_ui(bn, val)
-#define _libssh2_bn_from_bin(bn, len, val)                      \
+#define _libssh2_bn_from_bin(bn, len, val) \
     gcry_mpi_scan(&((bn)), GCRYMPI_FMT_USG, val, len, NULL)
-#define _libssh2_bn_to_bin(bn, val)                                     \
+#define _libssh2_bn_to_bin(bn, val) \
     gcry_mpi_print(GCRYMPI_FMT_USG, val, _libssh2_bn_bytes(bn), NULL, bn)
-#define _libssh2_bn_bytes(bn)                                           \
-    (gcry_mpi_get_nbits (bn) / 8 +                                      \
-     ((gcry_mpi_get_nbits (bn) % 8 == 0) ? 0 : 1))
-#define _libssh2_bn_bits(bn) gcry_mpi_get_nbits (bn)
+#define _libssh2_bn_bytes(bn) \
+    (gcry_mpi_get_nbits(bn) / 8 + \
+         ((gcry_mpi_get_nbits(bn) % 8 == 0) ? 0 : 1))
+#define _libssh2_bn_bits(bn) gcry_mpi_get_nbits(bn)
 #define _libssh2_bn_free(bn) gcry_mpi_release(bn)
 
+/* Default generate and safe prime sizes for
+   diffie-hellman-group-exchange-sha1 */
+#define LIBSSH2_DH_GEX_MINGROUP     2048
+#define LIBSSH2_DH_GEX_OPTGROUP     4096
+#define LIBSSH2_DH_GEX_MAXGROUP     8192
+
+#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
+
 #define _libssh2_dh_ctx struct gcry_mpi *
 #define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
 #define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
+    _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
 #define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
+    _libssh2_dh_secret(dhctx, secret, f, p)
 #define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
+extern void _libssh2_init_aes_ctr(void);
 extern void _libssh2_dh_init(_libssh2_dh_ctx *dhctx);
 extern int _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
                                 _libssh2_bn *g, _libssh2_bn *p,
@@ -234,4 +232,4 @@ extern int _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
                               _libssh2_bn *f, _libssh2_bn *p);
 extern void _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
 
-#endif /* __LIBSSH2_LIBGCRYPT_H */
+#endif /* LIBSSH2_LIBGCRYPT_H */
diff --git a/libssh2/src/libssh2.pc b/libssh2/src/libssh2.pc
deleted file mode 100644
index 006642ef..00000000
--- a/libssh2/src/libssh2.pc
+++ /dev/null
@@ -1,17 +0,0 @@
-###########################################################################
-# libssh2 installation details
-###########################################################################
-
-prefix=/usr/local
-exec_prefix=${prefix}
-libdir=${prefix}/lib64
-includedir=${prefix}/include
-
-Name: libssh2
-URL: https://www.libssh2.org/
-Description: The SSH library
-Version: 1.10.0
-Requires.private: libssl,libcrypto,zlib
-Libs: -L${libdir} -lssh2 
-Libs.private: 
-Cflags: -I${includedir}
diff --git a/libssh2/src/libssh2.pc.in b/libssh2/src/libssh2.pc.in
deleted file mode 100644
index c070988b..00000000
--- a/libssh2/src/libssh2.pc.in
+++ /dev/null
@@ -1,17 +0,0 @@
-###########################################################################
-# libssh2 installation details
-###########################################################################
-
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
-includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
-
-Name: @PROJECT_NAME@
-URL: @PROJECT_URL@
-Description: @PROJECT_DESCRIPTION@
-Version: @LIBSSH2_VERSION@
-Requires.private: @PC_REQUIRES_PRIVATE@
-Libs: -L${libdir} -lssh2 @PC_LIBS@
-Libs.private: @PC_LIBS@
-Cflags: -I${includedir}
\ No newline at end of file
diff --git a/libssh2/win32/libssh2.rc b/libssh2/src/libssh2.rc
similarity index 56%
rename from libssh2/win32/libssh2.rc
rename to libssh2/src/libssh2.rc
index f5d607a7..3021d8e6 100644
--- a/libssh2/win32/libssh2.rc
+++ b/libssh2/src/libssh2.rc
@@ -1,45 +1,48 @@
 /***************************************************************************
-* libssh2 Win32 resource file                                              *
+* libssh2 Windows resource file
+* Copyright (C) The libssh2 project and its contributors.
+*
+* SPDX-License-Identifier: BSD-3-Clause
 ***************************************************************************/
 #include <winver.h>
-#include "../include/libssh2.h"
+#include "libssh2.h"
 
-LANGUAGE  0x09,0x01
+LANGUAGE 0, 0
 
 #define RC_VERSION  LIBSSH2_VERSION_MAJOR, LIBSSH2_VERSION_MINOR, LIBSSH2_VERSION_PATCH, 0
 
 VS_VERSION_INFO VERSIONINFO
   FILEVERSION     RC_VERSION
   PRODUCTVERSION  RC_VERSION
-  FILEFLAGSMASK   0x3fL
-#if defined(DEBUGBUILD) || defined(_DEBUG)
-  FILEFLAGS 1
+  FILEFLAGSMASK   VS_FFI_FILEFLAGSMASK
+#if defined(LIBSSH2DEBUG) || defined(_DEBUG)
+  FILEFLAGS VS_FF_DEBUG
 #else
   FILEFLAGS 0
 #endif
   FILEOS      VOS__WINDOWS32
   FILETYPE    VFT_DLL
-  FILESUBTYPE 0x0L
+  FILESUBTYPE 0
 
 BEGIN
   BLOCK "StringFileInfo"
   BEGIN
-    BLOCK "040904b0"
+    BLOCK "040904b0"  /* 0x0409: en-US, 1200/0x04b0: UTF-16LE */
     BEGIN
-      VALUE "CompanyName",      "The libssh2 library, https://www.libssh2.org/\0"
+      VALUE "CompanyName",      "The libssh2 library, https://libssh2.org/\0"
       VALUE "FileDescription",  "libssh2 Shared Library\0"
       VALUE "FileVersion",      LIBSSH2_VERSION "\0"
       VALUE "InternalName",     "libssh2\0"
       VALUE "OriginalFilename", "libssh2.dll\0"
       VALUE "ProductName",      "The libssh2 library\0"
       VALUE "ProductVersion",   LIBSSH2_VERSION "\0"
-      VALUE "LegalCopyright",   "© " LIBSSH2_COPYRIGHT "\0"
-      VALUE "License",          "https://www.libssh2.org/license.html\0"
+      VALUE "LegalCopyright",   "Copyright (C) " LIBSSH2_COPYRIGHT "\0"
+      VALUE "License",          "https://libssh2.org/license.html\0"
     END
   END
 
   BLOCK "VarFileInfo"
   BEGIN
-    VALUE "Translation", 0x409, 1200
+    VALUE "Translation", 0x0409, 0x04b0  /* 0x0409: en-US, 1200/0x04b0: UTF-16LE */
   END
 END
diff --git a/libssh2/src/libssh2_config.h b/libssh2/src/libssh2_config.h
deleted file mode 100644
index 2ff68430..00000000
--- a/libssh2/src/libssh2_config.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- * Copyright (c) 1999-2011 Douglas Gilbert. 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#define HAVE_UNISTD_H
-#define HAVE_INTTYPES_H
-#define HAVE_STDLIB_H
-#define HAVE_SYS_SELECT_H
-#define HAVE_SYS_UIO_H
-#define HAVE_SYS_SOCKET_H
-#define HAVE_SYS_IOCTL_H
-#define HAVE_SYS_TIME_H
-#define HAVE_SYS_UN_H
-/* #undef HAVE_WINDOWS_H */
-/* #undef HAVE_WS2TCPIP_H */
-/* #undef HAVE_WINSOCK2_H */
-/* #undef HAVE_NTDEF_H */
-/* #undef HAVE_NTSTATUS_H */
-
-/* Libraries */
-/* #undef HAVE_LIBCRYPT32 */
-
-/* Types */
-#define HAVE_LONGLONG
-
-/* Functions */
-#define HAVE_GETTIMEOFDAY
-#define HAVE_INET_ADDR
-#define HAVE_POLL
-#define HAVE_SELECT
-#define HAVE_SOCKET
-#define HAVE_STRTOLL
-/* #undef HAVE_STRTOI64 */
-#define HAVE_SNPRINTF
-
-/* OpenSSL functions */
-#define HAVE_EVP_AES_128_CTR
-
-/* Socket non-blocking support */
-#define HAVE_O_NONBLOCK
-/* #undef HAVE_FIONBIO */
-/* #undef HAVE_IOCTLSOCKET */
-/* #undef HAVE_IOCTLSOCKET_CASE */
-/* #undef HAVE_SO_NONBLOCK */
-/* #undef HAVE_DISABLED_NONBLOCKING */
-
-/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
-   We provide a safe wrapper if snprintf not found */
-#ifndef HAVE_SNPRINTF
-#include <stdio.h>
-#include <stdarg.h>
-/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
-* then assume cp is pointing to a null char and do nothing. Returns number
-* number of chars placed in cp excluding the trailing null char. So for
-* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
-* <= 0 the return value is 0 (and no chars are written to cp). */
-static int snprintf(char * cp, int cp_max_len, const char * fmt, ...)
-{
-    va_list args;
-    int n;
-
-    if (cp_max_len < 2)
-        return 0;
-    va_start(args, fmt);
-    n = vsnprintf(cp, cp_max_len, fmt, args);
-    va_end(args);
-    return (n < cp_max_len) ? n : (cp_max_len - 1);
-}
-
-#define HAVE_SNPRINTF
-#endif
diff --git a/libssh2/libssh2/src/libssh2_config.h.in b/libssh2/src/libssh2_config.h.in
similarity index 75%
rename from libssh2/libssh2/src/libssh2_config.h.in
rename to libssh2/src/libssh2_config.h.in
index 94adf428..e7dbf0ac 100644
--- a/libssh2/libssh2/src/libssh2_config.h.in
+++ b/libssh2/src/libssh2_config.h.in
@@ -15,21 +15,17 @@
 /* Define to 1 if you have the <arpa/inet.h> header file. */
 #undef HAVE_ARPA_INET_H
 
-/* Define to 1 if you have the declaration of `SecureZeroMemory', and to 0 if
-   you don't. */
-#undef HAVE_DECL_SECUREZEROMEMORY
-
-/* disabled non-blocking sockets */
-#undef HAVE_DISABLED_NONBLOCKING
-
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #undef HAVE_DLFCN_H
 
 /* Define to 1 if you have the <errno.h> header file. */
 #undef HAVE_ERRNO_H
 
-/* Define to 1 if you have the `EVP_aes_128_ctr' function. */
-#undef HAVE_EVP_AES_128_CTR
+/* Define to 1 if you have the 'explicit_bzero' function. */
+#undef HAVE_EXPLICIT_BZERO
+
+/* Define to 1 if you have the 'explicit_memset' function. */
+#undef HAVE_EXPLICIT_MEMSET
 
 /* Define to 1 if you have the <fcntl.h> header file. */
 #undef HAVE_FCNTL_H
@@ -37,24 +33,18 @@
 /* use FIONBIO for non-blocking sockets */
 #undef HAVE_FIONBIO
 
-/* Define to 1 if you have the `gettimeofday' function. */
+/* Define to 1 if you have the 'gettimeofday' function. */
 #undef HAVE_GETTIMEOFDAY
 
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
-/* use ioctlsocket() for non-blocking sockets */
-#undef HAVE_IOCTLSOCKET
-
 /* use Ioctlsocket() for non-blocking sockets */
 #undef HAVE_IOCTLSOCKET_CASE
 
 /* Define if you have the bcrypt library. */
 #undef HAVE_LIBBCRYPT
 
-/* Define if you have the crypt32 library. */
-#undef HAVE_LIBCRYPT32
-
 /* Define if you have the gcrypt library. */
 #undef HAVE_LIBGCRYPT
 
@@ -64,33 +54,30 @@
 /* Define if you have the ssl library. */
 #undef HAVE_LIBSSL
 
+/* Define if you have the wolfssl library. */
+#undef HAVE_LIBWOLFSSL
+
 /* Define if you have the z library. */
 #undef HAVE_LIBZ
 
-/* Define to 1 if the compiler supports the 'long long' data type. */
-#undef HAVE_LONGLONG
-
-/* Define to 1 if you have the `memset_s' function. */
+/* Define to 1 if you have the 'memset_s' function. */
 #undef HAVE_MEMSET_S
 
 /* Define to 1 if you have the <netinet/in.h> header file. */
 #undef HAVE_NETINET_IN_H
 
-/* Define to 1 if you have the <ntdef.h> header file. */
-#undef HAVE_NTDEF_H
-
-/* Define to 1 if you have the <ntstatus.h> header file. */
-#undef HAVE_NTSTATUS_H
-
 /* use O_NONBLOCK for non-blocking sockets */
 #undef HAVE_O_NONBLOCK
 
-/* Define to 1 if you have the `poll' function. */
+/* Define to 1 if you have the 'poll' function. */
 #undef HAVE_POLL
 
 /* Define to 1 if you have the select function. */
 #undef HAVE_SELECT
 
+/* Define to 1 if you have the 'snprintf' function. */
+#undef HAVE_SNPRINTF
+
 /* use SO_NONBLOCK for non-blocking sockets */
 #undef HAVE_SO_NONBLOCK
 
@@ -109,7 +96,7 @@
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
 
-/* Define to 1 if you have the `strtoll' function. */
+/* Define to 1 if you have the 'strtoll' function. */
 #undef HAVE_STRTOLL
 
 /* Define to 1 if you have the <sys/ioctl.h> header file. */
@@ -142,23 +129,11 @@
 /* Define to 1 if you have the <windows.h> header file. */
 #undef HAVE_WINDOWS_H
 
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to 1 if you have the <ws2tcpip.h> header file. */
-#undef HAVE_WS2TCPIP_H
-
 /* to make a symbol visible */
 #undef LIBSSH2_API
 
-/* Enable clearing of memory before being freed */
-#undef LIBSSH2_CLEAR_MEMORY
-
-/* Enable "none" cipher -- NOT RECOMMENDED */
-#undef LIBSSH2_CRYPT_NONE
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#undef LIBSSH2_DH_GEX_NEW
+/* Enable WinCNG ECDSA support */
+#undef LIBSSH2_ECDSA_WINCNG
 
 /* Compile in zlib support */
 #undef LIBSSH2_HAVE_ZLIB
@@ -166,18 +141,21 @@
 /* Use libgcrypt */
 #undef LIBSSH2_LIBGCRYPT
 
-/* Enable "none" MAC -- NOT RECOMMENDED */
-#undef LIBSSH2_MAC_NONE
-
 /* Use mbedtls */
 #undef LIBSSH2_MBEDTLS
 
+/* Disable clearing of memory before being freed */
+#undef LIBSSH2_NO_CLEAR_MEMORY
+
 /* Use openssl */
 #undef LIBSSH2_OPENSSL
 
 /* Use wincng */
 #undef LIBSSH2_WINCNG
 
+/* Use wolfssl */
+#undef LIBSSH2_WOLFSSL
+
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #undef LT_OBJDIR
 
@@ -213,7 +191,7 @@
 	STACK_DIRECTION = 0 => direction of growth unknown */
 #undef STACK_DIRECTION
 
-/* Define to 1 if all of the C90 standard headers exist (not just the ones
+/* Define to 1 if all of the C89 standard headers exist (not just the ones
    required in a freestanding environment). This macro is provided for
    backward compatibility; new code need not use it. */
 #undef STDC_HEADERS
@@ -236,17 +214,23 @@
 /* Number of bits in a file offset, on hosts where this is settable. */
 #undef _FILE_OFFSET_BITS
 
-/* Define for large files, on AIX-style hosts. */
+/* Define to 1 on platforms where this makes off_t a 64-bit type. */
 #undef _LARGE_FILES
 
-/* Define to empty if `const' does not conform to ANSI C. */
+/* Number of bits in time_t, on hosts where this is settable. */
+#undef _TIME_BITS
+
+/* Define to 1 on platforms where this makes time_t a 64-bit type. */
+#undef __MINGW_USE_VC2005_COMPAT
+
+/* Define to empty if 'const' does not conform to ANSI C. */
 #undef const
 
-/* Define to `__inline__' or `__inline' if that's what the C compiler
+/* Define to '__inline__' or '__inline' if that's what the C compiler
    calls it, or to nothing if 'inline' is not supported under any name.  */
 #ifndef __cplusplus
 #undef inline
 #endif
 
-/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* Define as 'unsigned int' if <stddef.h> doesn't define. */
 #undef size_t
diff --git a/libssh2/src/libssh2_config_cmake.h.in b/libssh2/src/libssh2_config_cmake.h.in
index 62723ede..3f0bc138 100644
--- a/libssh2/src/libssh2_config_cmake.h.in
+++ b/libssh2/src/libssh2_config_cmake.h.in
@@ -1,5 +1,6 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- * Copyright (c) 1999-2011 Douglas Gilbert. All rights reserved.
+/* Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+ * Copyright (C) Douglas Gilbert
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -33,73 +34,43 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /* Headers */
 #cmakedefine HAVE_UNISTD_H
 #cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_STDLIB_H
 #cmakedefine HAVE_SYS_SELECT_H
 #cmakedefine HAVE_SYS_UIO_H
 #cmakedefine HAVE_SYS_SOCKET_H
 #cmakedefine HAVE_SYS_IOCTL_H
 #cmakedefine HAVE_SYS_TIME_H
 #cmakedefine HAVE_SYS_UN_H
-#cmakedefine HAVE_WINDOWS_H
-#cmakedefine HAVE_WS2TCPIP_H
-#cmakedefine HAVE_WINSOCK2_H
-#cmakedefine HAVE_NTDEF_H
-#cmakedefine HAVE_NTSTATUS_H
-
-/* Libraries */
-#cmakedefine HAVE_LIBCRYPT32
 
-/* Types */
-#cmakedefine HAVE_LONGLONG
+/* for example and tests */
+#cmakedefine HAVE_ARPA_INET_H
+#cmakedefine HAVE_NETINET_IN_H
 
 /* Functions */
 #cmakedefine HAVE_GETTIMEOFDAY
-#cmakedefine HAVE_INET_ADDR
-#cmakedefine HAVE_POLL
-#cmakedefine HAVE_SELECT
-#cmakedefine HAVE_SOCKET
 #cmakedefine HAVE_STRTOLL
 #cmakedefine HAVE_STRTOI64
 #cmakedefine HAVE_SNPRINTF
+#cmakedefine HAVE_EXPLICIT_BZERO
+#cmakedefine HAVE_EXPLICIT_MEMSET
+#cmakedefine HAVE_MEMSET_S
 
-/* OpenSSL functions */
-#cmakedefine HAVE_EVP_AES_128_CTR
+#cmakedefine HAVE_POLL
+#cmakedefine HAVE_SELECT
 
 /* Socket non-blocking support */
 #cmakedefine HAVE_O_NONBLOCK
 #cmakedefine HAVE_FIONBIO
-#cmakedefine HAVE_IOCTLSOCKET
 #cmakedefine HAVE_IOCTLSOCKET_CASE
 #cmakedefine HAVE_SO_NONBLOCK
-#cmakedefine HAVE_DISABLED_NONBLOCKING
-
-/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
-   We provide a safe wrapper if snprintf not found */
-#ifndef HAVE_SNPRINTF
-#include <stdio.h>
-#include <stdarg.h>
-/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
-* then assume cp is pointing to a null char and do nothing. Returns number
-* number of chars placed in cp excluding the trailing null char. So for
-* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
-* <= 0 the return value is 0 (and no chars are written to cp). */
-static int snprintf(char * cp, int cp_max_len, const char * fmt, ...)
-{
-    va_list args;
-    int n;
-
-    if (cp_max_len < 2)
-        return 0;
-    va_start(args, fmt);
-    n = vsnprintf(cp, cp_max_len, fmt, args);
-    va_end(args);
-    return (n < cp_max_len) ? n : (cp_max_len - 1);
-}
 
-#define HAVE_SNPRINTF
+/* attribute to export symbol */
+#if defined(LIBSSH2_EXPORTS) && defined(LIBSSH2_LIBRARY)
+#cmakedefine LIBSSH2_API ${LIBSSH2_API}
 #endif
diff --git a/libssh2/src/libssh2_priv.h b/libssh2/src/libssh2_priv.h
index da488b74..9b8866dc 100644
--- a/libssh2/src/libssh2_priv.h
+++ b/libssh2/src/libssh2_priv.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_PRIV_H
-#define __LIBSSH2_PRIV_H
-/* Copyright (c) 2004-2008, 2010, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2014 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson
+#ifndef LIBSSH2_PRIV_H
+#define LIBSSH2_PRIV_H
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -37,25 +37,28 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#define LIBSSH2_LIBRARY
-#include "libssh2_config.h"
+/* Header used by 'src' and 'tests' */
 
-#ifdef HAVE_WINDOWS_H
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
+/* FIXME: Disable warnings for 'src' */
+#if !defined(LIBSSH2_TESTS) && !defined(LIBSSH2_WARN_SIGN_CONVERSION)
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
 #endif
 
-#ifdef HAVE_WS2TCPIP_H
-#include <ws2tcpip.h>
-#endif
+#define LIBSSH2_LIBRARY
+
+/* platform/compiler-specific setup */
+#include "libssh2_setup.h"
 
 #include <stdio.h>
+#include <string.h>
 #include <time.h>
+#include <limits.h>
 
 /* The following CPP block should really only be in session.c and packet.c.
    However, AIX have #define's for 'events' and 'revents' and we are using
@@ -66,15 +69,8 @@
 */
 #ifdef HAVE_POLL
 # include <poll.h>
-#else
-# if defined(HAVE_SELECT) && !defined(WIN32)
-# ifdef HAVE_SYS_SELECT_H
+#elif defined(HAVE_SELECT) && defined(HAVE_SYS_SELECT_H)
 # include <sys/select.h>
-# else
-# include <sys/time.h>
-# include <sys/types.h>
-# endif
-# endif
 #endif
 
 /* Needed for struct iovec on some platforms */
@@ -83,10 +79,10 @@
 #endif
 
 #ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
+#include <sys/socket.h>
 #endif
 #ifdef HAVE_SYS_IOCTL_H
-# include <sys/ioctl.h>
+#include <sys/ioctl.h>
 #endif
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
@@ -95,7 +91,20 @@
 #include "libssh2.h"
 #include "libssh2_publickey.h"
 #include "libssh2_sftp.h"
-#include "misc.h" /* for the linked list stuff */
+#include "misc.h"
+
+#ifdef _WIN32
+/* Detect Windows App environment which has a restricted access
+   to the Win32 APIs. */
+# if (defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0602)) || \
+  defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
+     !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#    define LIBSSH2_WINDOWS_UWP
+#  endif
+# endif
+#endif
 
 #ifndef FALSE
 #define FALSE 0
@@ -104,13 +113,64 @@
 #define TRUE 1
 #endif
 
-#ifdef _MSC_VER
+#ifndef UINT32_MAX
+#define UINT32_MAX 0xffffffffU
+#endif
+
+#if (defined(__GNUC__) || defined(__clang__)) && \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(LIBSSH2_NO_FMT_CHECKS)
+#ifdef __MINGW_PRINTF_FORMAT
+#define LIBSSH2_PRINTF(fmt, arg) \
+    __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, arg)))
+#elif !defined(__MINGW32__)
+#define LIBSSH2_PRINTF(fmt, arg) \
+    __attribute__((format(printf, fmt, arg)))
+#endif
+#endif
+#ifndef LIBSSH2_PRINTF
+#define LIBSSH2_PRINTF(fmt, arg)
+#endif
+
+/* Use local implementation when not available */
+#if !defined(HAVE_SNPRINTF)
+#undef snprintf
+#define snprintf _libssh2_snprintf
+#define LIBSSH2_SNPRINTF
+int _libssh2_snprintf(char *cp, size_t cp_max_len, const char *fmt, ...)
+    LIBSSH2_PRINTF(3, 4);
+#endif
+
+#if !defined(HAVE_GETTIMEOFDAY)
+#define HAVE_GETTIMEOFDAY
+#undef gettimeofday
+#define gettimeofday _libssh2_gettimeofday
+#define LIBSSH2_GETTIMEOFDAY
+int _libssh2_gettimeofday(struct timeval *tp, void *tzp);
+#elif defined(HAVE_SYS_TIME_H)
+#include <sys/time.h>
+#endif
+
+#if !defined(LIBSSH2_FALLTHROUGH)
+#if (defined(__GNUC__) && __GNUC__ >= 7) || \
+    (defined(__clang__) && __clang_major__ >= 10)
+#  define LIBSSH2_FALLTHROUGH()  __attribute__((fallthrough))
+#else
+#  define LIBSSH2_FALLTHROUGH()  do {} while (0)
+#endif
+#endif
+
 /* "inline" keyword is valid only with C++ engine! */
+#ifdef __GNUC__
+#undef inline
+#define inline __inline__
+#elif defined(_MSC_VER)
+#undef inline
 #define inline __inline
 #endif
 
 /* 3DS doesn't seem to have iovec */
-#if defined(WIN32) || defined(_3DS)
+#if defined(_WIN32) || defined(_3DS)
 
 struct iovec {
     size_t iov_len;
@@ -119,20 +179,6 @@ struct iovec {
 
 #endif
 
-/* Provide iovec / writev on WIN32 platform. */
-#ifdef WIN32
-
-static inline int writev(int sock, struct iovec *iov, int nvecs)
-{
-    DWORD ret;
-    if(WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
-        return ret;
-    }
-    return -1;
-}
-
-#endif /* WIN32 */
-
 #ifdef __OS400__
 /* Force parameter type. */
 #define send(s, b, l, f)    send((s), (unsigned char *) (b), (l), (f))
@@ -140,13 +186,6 @@ static inline int writev(int sock, struct iovec *iov, int nvecs)
 
 #include "crypto.h"
 
-#ifdef HAVE_WINSOCK2_H
-
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#endif
-
 #ifndef SIZE_MAX
 #if _WIN64
 #define SIZE_MAX 0xFFFFFFFFFFFFFFFF
@@ -159,6 +198,12 @@ static inline int writev(int sock, struct iovec *iov, int nvecs)
 #define UINT_MAX 0xFFFFFFFF
 #endif
 
+#define LIBSSH2_MAX(x, y)  ((x) > (y) ? (x) : (y))
+#define LIBSSH2_MIN(x, y)  ((x) < (y) ? (x) : (y))
+
+#define MAX_BLOCKSIZE 32    /* MUST fit biggest crypto block size we use/get */
+#define MAX_MACSIZE 64      /* MUST fit biggest MAC length we support */
+
 /* RFC4253 section 6.1 Maximum Packet Length says:
  *
  * "All implementations MUST be able to process packets with
@@ -170,33 +215,51 @@ static inline int writev(int sock, struct iovec *iov, int nvecs)
 #define MAX_SHA_DIGEST_LEN SHA512_DIGEST_LENGTH
 
 #define LIBSSH2_ALLOC(session, count) \
-  session->alloc((count), &(session)->abstract)
+    session->alloc((count), &(session)->abstract)
 #define LIBSSH2_CALLOC(session, count) _libssh2_calloc(session, count)
 #define LIBSSH2_REALLOC(session, ptr, count) \
- ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : \
- session->alloc((count), &(session)->abstract))
+    ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : \
+             session->alloc((count), &(session)->abstract))
 #define LIBSSH2_FREE(session, ptr) \
- session->free((ptr), &(session)->abstract)
+    session->free((ptr), &(session)->abstract)
 #define LIBSSH2_IGNORE(session, data, datalen) \
- session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract)
+    session->ssh_msg_ignore((session), (data), (int)(datalen), \
+                            &(session)->abstract)
 #define LIBSSH2_DEBUG(session, always_display, message, message_len, \
-                      language, language_len)    \
-    session->ssh_msg_debug((session), (always_display), (message), \
-                           (message_len), (language), (language_len), \
+                      language, language_len) \
+    session->ssh_msg_debug((session), (always_display), \
+                           (message), (int)(message_len), \
+                           (language), (int)(language_len), \
                            &(session)->abstract)
 #define LIBSSH2_DISCONNECT(session, reason, message, message_len, \
-                           language, language_len)                \
-    session->ssh_msg_disconnect((session), (reason), (message),   \
-                                (message_len), (language), (language_len), \
+                           language, language_len) \
+    session->ssh_msg_disconnect((session), (reason), \
+                                (message), (int)(message_len), \
+                                (language), (int)(language_len), \
                                 &(session)->abstract)
 
-#define LIBSSH2_MACERROR(session, data, datalen)         \
-    session->macerror((session), (data), (datalen), &(session)->abstract)
-#define LIBSSH2_X11_OPEN(channel, shost, sport)          \
+#define LIBSSH2_MACERROR(session, data, datalen) \
+    session->macerror((session), (data), (int)(datalen), &(session)->abstract)
+#define LIBSSH2_X11_OPEN(channel, shost, sport) \
     channel->session->x11(((channel)->session), (channel), \
                           (shost), (sport), (&(channel)->session->abstract))
 
-#define LIBSSH2_CHANNEL_CLOSE(session, channel)          \
+#define LIBSSH2_AUTHAGENT(channel) \
+    channel->session->authagent(((channel)->session), (channel), \
+                                (&(channel)->session->abstract))
+
+#define LIBSSH2_ADD_IDENTITIES(session, buffer, agentPath) \
+    session->addLocalIdentities((session), (buffer), \
+                                (agentPath), (&(session->abstract)))
+
+#define LIBSSH2_AUTHAGENT_SIGN(session, blob, blen, \
+                               data, dlen, sig, sigLen, \
+                               agentPath) \
+    session->agentSignCallback((session), (blob), (blen), \
+                               (data), (dlen), (sig), (sigLen), \
+                               (agentPath), (&(session->abstract)))
+
+#define LIBSSH2_CHANNEL_CLOSE(session, channel) \
     channel->close_cb((session), &(session)->abstract, \
                       (channel), &(channel)->abstract)
 
@@ -205,9 +268,9 @@ static inline int writev(int sock, struct iovec *iov, int nvecs)
 #define LIBSSH2_RECV_FD(session, fd, buffer, length, flags) \
     (session->recv)(fd, buffer, length, flags, &session->abstract)
 
-#define LIBSSH2_SEND(session, buffer, length, flags)  \
+#define LIBSSH2_SEND(session, buffer, length, flags) \
     LIBSSH2_SEND_FD(session, session->socket_fd, buffer, length, flags)
-#define LIBSSH2_RECV(session, buffer, length, flags)                    \
+#define LIBSSH2_RECV(session, buffer, length, flags) \
     LIBSSH2_RECV_FD(session, session->socket_fd, buffer, length, flags)
 
 typedef struct _LIBSSH2_KEX_METHOD LIBSSH2_KEX_METHOD;
@@ -235,7 +298,9 @@ typedef enum
     libssh2_NB_state_jump3,
     libssh2_NB_state_jump4,
     libssh2_NB_state_jump5,
-    libssh2_NB_state_end
+    libssh2_NB_state_error_closing,
+    libssh2_NB_state_end,
+    libssh2_NB_state_jumpauthagent
 } libssh2_nonblocking_states;
 
 typedef struct packet_require_state_t
@@ -341,6 +406,18 @@ typedef struct packet_x11_open_state_t
     LIBSSH2_CHANNEL *channel;
 } packet_x11_open_state_t;
 
+#define AuthAgentUnavail "Auth Agent unavailable"
+
+typedef struct packet_authagent_state_t
+{
+    libssh2_nonblocking_states state;
+    unsigned char packet[17 + (sizeof(AuthAgentUnavail) - 1)];
+    uint32_t sender_channel;
+    uint32_t initial_window_size;
+    uint32_t packet_size;
+    LIBSSH2_CHANNEL *channel;
+} packet_authagent_state_t;
+
 struct _LIBSSH2_PACKET
 {
     struct list_node node; /* linked list header */
@@ -371,7 +448,7 @@ struct _LIBSSH2_CHANNEL
     struct list_node node;
 
     unsigned char *channel_type;
-    unsigned channel_type_len;
+    size_t channel_type_len;
 
     /* channel's program exit status */
     int exit_status;
@@ -383,7 +460,7 @@ struct _LIBSSH2_CHANNEL
     /* Amount of bytes to be refunded to receive window (but not yet sent) */
     uint32_t adjust_queue;
     /* Data immediately available for reading */
-    uint32_t read_avail;
+    size_t read_avail;
 
     LIBSSH2_SESSION *session;
 
@@ -424,7 +501,7 @@ struct _LIBSSH2_CHANNEL
     size_t flush_refund_bytes;
     size_t flush_flush_bytes;
 
-    /* State variables used in libssh2_channel_receive_window_adjust() */
+    /* State variables used in libssh2_channel_receive_window_adjust2() */
     libssh2_nonblocking_states adjust_state;
     unsigned char adjust_adjust[9];     /* packet_type(1) + channel(4) +
                                            adjustment(4) */
@@ -463,6 +540,11 @@ struct _LIBSSH2_CHANNEL
     size_t req_auth_agent_packet_len;
     unsigned char req_auth_agent_local_channel[4];
     packet_requirev_state_t req_auth_agent_requirev_state;
+
+    /* State variables used in libssh2_channel_signal_ex() */
+    libssh2_nonblocking_states sendsignal_state;
+    unsigned char *sendsignal_packet;
+    size_t sendsignal_packet_len;
 };
 
 struct _LIBSSH2_LISTENER
@@ -510,7 +592,7 @@ typedef struct _libssh2_endpoint_data
     char *lang_prefs;
 } libssh2_endpoint_data;
 
-#define PACKETBUFSIZE (1024*16)
+#define PACKETBUFSIZE MAX_SSH_PACKET_LEN
 
 struct transportpacket
 {
@@ -533,14 +615,15 @@ struct transportpacket
                                packet_length + padding_length + 4 +
                                mac_length. */
     unsigned char *payload; /* this is a pointer to a LIBSSH2_ALLOC()
-                               area to which we write decrypted data */
+                               area to which we write incoming packet data
+                               which is not yet decrypted in etm mode. */
     unsigned char *wptr;    /* write pointer into the payload to where we
                                are currently writing decrypted data */
 
     /* ------------- for outgoing data --------------- */
     unsigned char outbuf[MAX_SSH_PACKET_LEN]; /* area for the outgoing data */
 
-    int ototal_num;         /* size of outbuf in number of bytes */
+    ssize_t ototal_num;     /* size of outbuf in number of bytes */
     const unsigned char *odata; /* original pointer to the data */
     size_t olen;            /* original size of the data we stored in
                                outbuf */
@@ -578,26 +661,31 @@ struct _LIBSSH2_PUBLICKEY
 #define LIBSSH2_SCP_RESPONSE_BUFLEN     256
 
 struct flags {
-    int sigpipe;  /* LIBSSH2_FLAG_SIGPIPE */
-    int compress; /* LIBSSH2_FLAG_COMPRESS */
+    int sigpipe;     /* LIBSSH2_FLAG_SIGPIPE */
+    int compress;    /* LIBSSH2_FLAG_COMPRESS */
+    int quote_paths; /* LIBSSH2_FLAG_QUOTE_PATHS */
 };
 
 struct _LIBSSH2_SESSION
 {
     /* Memory management callbacks */
     void *abstract;
-      LIBSSH2_ALLOC_FUNC((*alloc));
-      LIBSSH2_REALLOC_FUNC((*realloc));
-      LIBSSH2_FREE_FUNC((*free));
+
+    LIBSSH2_ALLOC_FUNC((*alloc));
+    LIBSSH2_REALLOC_FUNC((*realloc));
+    LIBSSH2_FREE_FUNC((*free));
 
     /* Other callbacks */
-      LIBSSH2_IGNORE_FUNC((*ssh_msg_ignore));
-      LIBSSH2_DEBUG_FUNC((*ssh_msg_debug));
-      LIBSSH2_DISCONNECT_FUNC((*ssh_msg_disconnect));
-      LIBSSH2_MACERROR_FUNC((*macerror));
-      LIBSSH2_X11_OPEN_FUNC((*x11));
-      LIBSSH2_SEND_FUNC((*send));
-      LIBSSH2_RECV_FUNC((*recv));
+    LIBSSH2_IGNORE_FUNC((*ssh_msg_ignore));
+    LIBSSH2_DEBUG_FUNC((*ssh_msg_debug));
+    LIBSSH2_DISCONNECT_FUNC((*ssh_msg_disconnect));
+    LIBSSH2_MACERROR_FUNC((*macerror));
+    LIBSSH2_X11_OPEN_FUNC((*x11));
+    LIBSSH2_AUTHAGENT_FUNC((*authagent));
+    LIBSSH2_ADD_IDENTITIES_FUNC((*addLocalIdentities));
+    LIBSSH2_AUTHAGENT_SIGN_FUNC((*agentSignCallback));
+    LIBSSH2_SEND_FUNC((*send));
+    LIBSSH2_RECV_FUNC((*recv));
 
     /* Method preferences -- NULL yields "load order" */
     char *kex_prefs;
@@ -610,7 +698,7 @@ struct _LIBSSH2_SESSION
 
     /* Agreed Key Exchange Method */
     const LIBSSH2_KEX_METHOD *kex;
-    unsigned int burn_optimistic_kexinit:1;
+    unsigned int burn_optimistic_kexinit;
 
     unsigned char *session_id;
     uint32_t session_id_len;
@@ -633,13 +721,22 @@ struct _LIBSSH2_SESSION
 #if LIBSSH2_MD5
     unsigned char server_hostkey_md5[MD5_DIGEST_LENGTH];
     int server_hostkey_md5_valid;
-#endif                          /* ! LIBSSH2_MD5 */
+#endif /* ! LIBSSH2_MD5 */
     unsigned char server_hostkey_sha1[SHA_DIGEST_LENGTH];
     int server_hostkey_sha1_valid;
 
     unsigned char server_hostkey_sha256[SHA256_DIGEST_LENGTH];
     int server_hostkey_sha256_valid;
 
+    /* public key algorithms accepted as comma separated list */
+    char *server_sign_algorithms;
+
+    /* key signing algorithm preferences -- NULL yields server order */
+    char *sign_algo_prefs;
+
+    /* Whether to use the OpenSSH Strict KEX extension */
+    int kex_strict;
+
     /* (remote as source of data -- packet_read ) */
     libssh2_endpoint_data remote;
 
@@ -662,7 +759,8 @@ struct _LIBSSH2_SESSION
     int socket_state;
     int socket_block_directions;
     int socket_prev_blockstate; /* stores the state of the socket blockiness
-                                   when libssh2_session_startup() is called */
+                                   when libssh2_session_handshake()
+                                   is called */
 
     /* Error tracking */
     const char *err_msg;
@@ -680,7 +778,7 @@ struct _LIBSSH2_SESSION
 
     /* State variables used in libssh2_banner_send() */
     libssh2_nonblocking_states banner_TxRx_state;
-    char banner_TxRx_banner[256];
+    char banner_TxRx_banner[8192];
     ssize_t banner_TxRx_total_send;
 
     /* State variables used in libssh2_kexinit() */
@@ -688,7 +786,7 @@ struct _LIBSSH2_SESSION
     unsigned char *kexinit_data;
     size_t kexinit_data_len;
 
-    /* State variables used in libssh2_session_startup() */
+    /* State variables used in libssh2_session_handshake() */
     libssh2_nonblocking_states startup_state;
     unsigned char *startup_data;
     size_t startup_data_len;
@@ -713,6 +811,7 @@ struct _LIBSSH2_SESSION
     libssh2_nonblocking_states userauth_list_state;
     unsigned char *userauth_list_data;
     size_t userauth_list_data_len;
+    char *userauth_banner;
     packet_requirev_state_t userauth_list_packet_requirev_state;
 
     /* State variables used in libssh2_userauth_password_ex() */
@@ -753,10 +852,10 @@ struct _LIBSSH2_SESSION
     size_t userauth_kybd_data_len;
     unsigned char *userauth_kybd_packet;
     size_t userauth_kybd_packet_len;
-    unsigned int userauth_kybd_auth_name_len;
-    char *userauth_kybd_auth_name;
-    unsigned userauth_kybd_auth_instruction_len;
-    char *userauth_kybd_auth_instruction;
+    size_t userauth_kybd_auth_name_len;
+    unsigned char *userauth_kybd_auth_name;
+    size_t userauth_kybd_auth_instruction_len;
+    unsigned char *userauth_kybd_auth_instruction;
     unsigned int userauth_kybd_num_prompts;
     int userauth_kybd_auth_failure;
     LIBSSH2_USERAUTH_KBDINT_PROMPT *userauth_kybd_prompts;
@@ -803,12 +902,14 @@ struct _LIBSSH2_SESSION
                                           states */
     packet_queue_listener_state_t packAdd_Qlstn_state;
     packet_x11_open_state_t packAdd_x11open_state;
+    packet_authagent_state_t packAdd_authagent_state;
 
     /* State variables used in fullpacket() */
     libssh2_nonblocking_states fullpacket_state;
     int fullpacket_macstate;
     size_t fullpacket_payload_len;
     int fullpacket_packet_type;
+    uint32_t fullpacket_required_type;
 
     /* State variables used in libssh2_sftp_init() */
     libssh2_nonblocking_states sftpInit_state;
@@ -816,27 +917,17 @@ struct _LIBSSH2_SESSION
     LIBSSH2_CHANNEL *sftpInit_channel;
     unsigned char sftpInit_buffer[9];   /* sftp_header(5){excludes request_id}
                                            + version_id(4) */
-    int sftpInit_sent; /* number of bytes from the buffer that have been
-                          sent */
+    size_t sftpInit_sent; /* number of bytes from the buffer that have been
+                             sent */
 
-    /* State variables used in libssh2_scp_recv() / libssh_scp_recv2() */
+    /* State variables used in libssh2_scp_recv2() */
     libssh2_nonblocking_states scpRecv_state;
     unsigned char *scpRecv_command;
     size_t scpRecv_command_len;
     unsigned char scpRecv_response[LIBSSH2_SCP_RESPONSE_BUFLEN];
     size_t scpRecv_response_len;
     long scpRecv_mode;
-#if defined(HAVE_LONGLONG) && defined(HAVE_STRTOLL)
-    /* we have the type and we can parse such numbers */
-    long long scpRecv_size;
-#define scpsize_strtol strtoll
-#elif defined(HAVE_STRTOI64)
-    __int64 scpRecv_size;
-#define scpsize_strtol _strtoi64
-#else
-    long scpRecv_size;
-#define scpsize_strtol strtol
-#endif
+    libssh2_int64_t scpRecv_size;
     long scpRecv_mtime;
     long scpRecv_atime;
     LIBSSH2_CHANNEL *scpRecv_channel;
@@ -853,19 +944,23 @@ struct _LIBSSH2_SESSION
     int keepalive_interval;
     int keepalive_want_reply;
     time_t keepalive_last_sent;
+
+    /* Configurable timeout for packets. Replaces LIBSSH2_READ_TIMEOUT */
+    long packet_read_timeout;
 };
 
 /* session.state bits */
-#define LIBSSH2_STATE_EXCHANGING_KEYS   0x00000001
-#define LIBSSH2_STATE_NEWKEYS           0x00000002
-#define LIBSSH2_STATE_AUTHENTICATED     0x00000004
-#define LIBSSH2_STATE_KEX_ACTIVE        0x00000008
+#define LIBSSH2_STATE_INITIAL_KEX       0x00000001
+#define LIBSSH2_STATE_EXCHANGING_KEYS   0x00000002
+#define LIBSSH2_STATE_NEWKEYS           0x00000004
+#define LIBSSH2_STATE_AUTHENTICATED     0x00000008
+#define LIBSSH2_STATE_KEX_ACTIVE        0x00000010
 
 /* session.flag helpers */
 #ifdef MSG_NOSIGNAL
-#define LIBSSH2_SOCKET_SEND_FLAGS(session)              \
+#define LIBSSH2_SOCKET_SEND_FLAGS(session) \
     (((session)->flag.sigpipe) ? 0 : MSG_NOSIGNAL)
-#define LIBSSH2_SOCKET_RECV_FLAGS(session)              \
+#define LIBSSH2_SOCKET_RECV_FLAGS(session) \
     (((session)->flag.sigpipe) ? 0 : MSG_NOSIGNAL)
 #else
 /* If MSG_NOSIGNAL isn't defined we're SOL on blocking SIGPIPE */
@@ -887,13 +982,16 @@ struct _LIBSSH2_KEX_METHOD
     int (*exchange_keys) (LIBSSH2_SESSION * session,
                           key_exchange_state_low_t * key_state);
 
+    void (*cleanup) (LIBSSH2_SESSION * session,
+                     key_exchange_state_low_t * key_state);
+
     long flags;
 };
 
 struct _LIBSSH2_HOSTKEY_METHOD
 {
     const char *name;
-    unsigned long hash_len;
+    size_t hash_len;
 
     int (*init) (LIBSSH2_SESSION * session, const unsigned char *hostkey_data,
                  size_t hostkey_data_len, void **abstract);
@@ -927,19 +1025,52 @@ struct _LIBSSH2_CRYPT_METHOD
     int iv_len;
     int secret_len;
 
+    /* length of the authentication tag */
+    int auth_len;
+
     long flags;
 
     int (*init) (LIBSSH2_SESSION * session,
                  const LIBSSH2_CRYPT_METHOD * method, unsigned char *iv,
                  int *free_iv, unsigned char *secret, int *free_secret,
                  int encrypt, void **abstract);
-    int (*crypt) (LIBSSH2_SESSION * session, unsigned char *block,
-                  size_t blocksize, void **abstract);
+    int (*get_len) (LIBSSH2_SESSION * session, unsigned int seqno,
+                    unsigned char *data, size_t data_size, unsigned int *len,
+                    void **abstract);
+    int (*crypt) (LIBSSH2_SESSION * session, unsigned int seqno,
+                  unsigned char *block, size_t blocksize, void **abstract,
+                  int firstlast);
     int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
 
-      _libssh2_cipher_type(algo);
+    _libssh2_cipher_type(algo);
 };
 
+/* Bit flags for _LIBSSH2_CRYPT_METHOD */
+
+/* Crypto method has integrated message authentication */
+#define LIBSSH2_CRYPT_FLAG_INTEGRATED_MAC            1
+/* Crypto method does not encrypt the packet length */
+#define LIBSSH2_CRYPT_FLAG_PKTLEN_AAD                2
+/* Crypto method must encrypt and decrypt entire messages */
+#define LIBSSH2_CRYPT_FLAG_REQUIRES_FULL_PACKET      4
+
+/* Convenience macros for accessing crypt flags */
+/* Local crypto flags */
+#define CRYPT_FLAG_L(session, flag) ((session)->local.crypt && \
+    ((session)->local.crypt->flags & LIBSSH2_CRYPT_FLAG_##flag))
+/* Remote crypto flags */
+#define CRYPT_FLAG_R(session, flag) ((session)->remote.crypt && \
+    ((session)->remote.crypt->flags & LIBSSH2_CRYPT_FLAG_##flag))
+
+/* Values for firstlast */
+#define FIRST_BLOCK 1
+#define MIDDLE_BLOCK 0
+#define LAST_BLOCK 2
+
+/* Convenience macros for accessing firstlast */
+#define IS_FIRST(firstlast) (firstlast & FIRST_BLOCK)
+#define IS_LAST(firstlast) (firstlast & LAST_BLOCK)
+
 struct _LIBSSH2_COMP_METHOD
 {
     const char *name;
@@ -963,23 +1094,12 @@ struct _LIBSSH2_COMP_METHOD
 };
 
 #ifdef LIBSSH2DEBUG
-void _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format,
-                    ...);
+void
+_libssh2_debug_low(LIBSSH2_SESSION * session, int context, const char *format,
+                   ...) LIBSSH2_PRINTF(3, 4);
+#define _libssh2_debug(x) _libssh2_debug_low x
 #else
-#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) ||     \
-    defined(__GNUC__)
-/* C99 supported and also by older GCC */
-#define _libssh2_debug(x,y,z,...) do {} while (0)
-#else
-/* no gcc and not C99, do static and hopefully inline */
-static inline void
-_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
-{
-    (void)session;
-    (void)context;
-    (void)format;
-}
-#endif
+#define _libssh2_debug(x) do {} while(0)
 #endif
 
 #define LIBSSH2_SOCKET_UNKNOWN                   1
@@ -1006,6 +1126,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
 #define SSH_MSG_DEBUG                               4
 #define SSH_MSG_SERVICE_REQUEST                     5
 #define SSH_MSG_SERVICE_ACCEPT                      6
+#define SSH_MSG_EXT_INFO                            7
 
 #define SSH_MSG_KEXINIT                             20
 #define SSH_MSG_NEWKEYS                             21
@@ -1069,18 +1190,22 @@ ssize_t _libssh2_recv(libssh2_socket_t socket, void *buffer,
 ssize_t _libssh2_send(libssh2_socket_t socket, const void *buffer,
                       size_t length, int flags, void **abstract);
 
-#define LIBSSH2_READ_TIMEOUT 60 /* generic timeout in seconds used when
-                                   waiting for more data to arrive */
+#define LIBSSH2_DEFAULT_READ_TIMEOUT 60 /* generic timeout in seconds used when
+                                           waiting for more data to arrive */
 
 
 int _libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
                           key_exchange_state_t * state);
 
+unsigned char *_libssh2_kex_agree_instr(unsigned char *haystack,
+                                        size_t haystack_len,
+                                        const unsigned char *needle,
+                                        size_t needle_len);
+
 /* Let crypt.c/hostkey.c expose their method structs */
 const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void);
 const LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void);
 
-/* misc.c */
 int _libssh2_bcrypt_pbkdf(const char *pass,
                           size_t passlen,
                           const uint8_t *salt,
@@ -1094,12 +1219,12 @@ int _libssh2_pem_parse(LIBSSH2_SESSION * session,
                        const char *headerbegin,
                        const char *headerend,
                        const unsigned char *passphrase,
-                       FILE * fp, unsigned char **data, unsigned int *datalen);
+                       FILE * fp, unsigned char **data, size_t *datalen);
 int _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
                               const char *headerbegin,
                               const char *headerend,
                               const char *filedata, size_t filedata_len,
-                              unsigned char **data, unsigned int *datalen);
+                              unsigned char **data, size_t *datalen);
  /* OpenSSL keys */
 int
 _libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
@@ -1111,37 +1236,41 @@ _libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
                                   const char *filedata, size_t filedata_len,
                                   struct string_buf **decrypted_buf);
 
-int _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen);
-int _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
+int _libssh2_pem_decode_sequence(unsigned char **data, size_t *datalen);
+int _libssh2_pem_decode_integer(unsigned char **data, size_t *datalen,
                                 unsigned char **i, unsigned int *ilen);
 
 /* global.c */
 void _libssh2_init_if_needed(void);
 
+/* Utility function for certificate auth */
+size_t plain_method(char *method, size_t method_len);
 
 #define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0]))
 
 /* define to output the libssh2_int64_t type in a *printf() */
-#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__MINGW32__)
+#if defined(__BORLANDC__) || defined(_MSC_VER)
 #define LIBSSH2_INT64_T_FORMAT "I64d"
+#elif defined(__MINGW32__)
+#define LIBSSH2_INT64_T_FORMAT PRId64
 #else
 #define LIBSSH2_INT64_T_FORMAT "lld"
 #endif
 
 /* In Windows the default file mode is text but an application can override it.
-Therefore we specify it explicitly. https://github.com/curl/curl/pull/258
-*/
-#if defined(WIN32) || defined(MSDOS)
+   Therefore we specify it explicitly. https://github.com/curl/curl/pull/258
+ */
+#if defined(_WIN32) || defined(MSDOS)
 #define FOPEN_READTEXT "rt"
 #define FOPEN_WRITETEXT "wt"
 #define FOPEN_APPENDTEXT "at"
 #elif defined(__CYGWIN__)
-/* Cygwin has specific behavior we need to address when WIN32 is not defined.
-https://cygwin.com/cygwin-ug-net/using-textbinary.html
-For write we want our output to have line endings of LF and be compatible with
-other Cygwin utilities. For read we want to handle input that may have line
-endings either CRLF or LF so 't' is appropriate.
-*/
+/* Cygwin has specific behavior we need to address when _WIN32 is not defined.
+     https://cygwin.com/cygwin-ug-net/using-textbinary.html
+   For write we want our output to have line endings of LF and be compatible
+   with other Cygwin utilities. For read we want to handle input that may have
+   line endings either CRLF or LF so 't' is appropriate.
+ */
 #define FOPEN_READTEXT "rt"
 #define FOPEN_WRITETEXT "w"
 #define FOPEN_APPENDTEXT "a"
@@ -1151,4 +1280,4 @@ endings either CRLF or LF so 't' is appropriate.
 #define FOPEN_APPENDTEXT "a"
 #endif
 
-#endif /* __LIBSSH2_PRIV_H */
+#endif /* LIBSSH2_PRIV_H */
diff --git a/libssh2/src/libssh2_setup.h b/libssh2/src/libssh2_setup.h
new file mode 100644
index 00000000..0f17a188
--- /dev/null
+++ b/libssh2/src/libssh2_setup.h
@@ -0,0 +1,103 @@
+/* Copyright (C) Viktor Szakats
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef LIBSSH2_SETUP_H
+#define LIBSSH2_SETUP_H
+
+/* Header for platform/compiler-specific initialization.
+   Used by 'src', 'example', 'tests' */
+
+/* Define mingw-w64 version macros, eg __MINGW{32,64}_{MINOR,MAJOR}_VERSION */
+#ifdef __MINGW32__
+#include <_mingw.h>
+#endif
+
+/* Configuration provided by build tools (autotools and CMake),
+   and via platform-specific directories for os400 and vms */
+#if defined(HAVE_CONFIG_H) || defined(__OS400__) || defined(__VMS)
+
+#include "libssh2_config.h"
+
+/* Hand-crafted configuration for platforms which lack config tool.
+   Keep this synced with root CMakeLists.txt */
+#elif defined(_WIN32)
+
+#define HAVE_SELECT
+#define HAVE_SNPRINTF
+
+#ifdef __MINGW32__
+# define HAVE_UNISTD_H
+# define HAVE_INTTYPES_H
+# define HAVE_SYS_TIME_H
+# define HAVE_GETTIMEOFDAY
+# define HAVE_STRTOLL
+#elif defined(_MSC_VER)
+# if _MSC_VER >= 1800
+#  define HAVE_INTTYPES_H
+#  define HAVE_STRTOLL
+# else
+#  define HAVE_STRTOI64
+# endif
+# if _MSC_VER < 1900
+#  undef HAVE_SNPRINTF
+# endif
+#endif
+
+#endif /* defined(HAVE_CONFIG_H) */
+
+/* Below applies to both auto-detected and hand-crafted configs */
+
+#ifdef _WIN32
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOGDI
+#define NOGDI
+#endif
+#ifndef NONLS
+#define NONLS
+#endif
+
+#ifdef __MINGW32__
+# ifdef __MINGW64_VERSION_MAJOR
+/* Number of bits in a file offset, on hosts where this is settable. */
+#  ifndef _FILE_OFFSET_BITS
+#  define _FILE_OFFSET_BITS 64
+#  endif
+# endif
+#elif defined(_MSC_VER)
+# ifndef _CRT_SECURE_NO_WARNINGS
+# define _CRT_SECURE_NO_WARNINGS  /* for fopen(), getenv() */
+# endif
+# if !defined(LIBSSH2_LIBRARY) || defined(LIBSSH2_TESTS)
+   /* apply to examples and tests only */
+#  ifndef _CRT_NONSTDC_NO_DEPRECATE
+#  define _CRT_NONSTDC_NO_DEPRECATE  /* for strdup(), write() */
+#  endif
+#  ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
+#  define _WINSOCK_DEPRECATED_NO_WARNINGS  /* for inet_addr() */
+#  endif
+   /* we cannot access our internal snprintf() implementation in examples and
+      tests when linking to a shared libssh2. */
+#  if _MSC_VER < 1900
+#   undef HAVE_SNPRINTF
+#   define HAVE_SNPRINTF
+#   define snprintf _snprintf
+#  endif
+# endif
+# if _MSC_VER < 1500
+#  define vsnprintf _vsnprintf
+# endif
+# if _MSC_VER < 1900
+#  define strdup _strdup
+/* Silence bogus warning C4127: conditional expression is constant */
+#  pragma warning(disable:4127)
+# endif
+#endif
+
+#endif /* _WIN32 */
+
+#endif /* LIBSSH2_SETUP_H */
diff --git a/libssh2/src/mac.c b/libssh2/src/mac.c
index 5ac71df4..00d3c21f 100644
--- a/libssh2/src/mac.c
+++ b/libssh2/src/mac.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,20 +33,33 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
 #include "mac.h"
 
-#ifdef LIBSSH2_MAC_NONE
+#if defined(LIBSSH2DEBUG) && defined(LIBSSH2_MAC_NONE_INSECURE)
 /* mac_none_MAC
- * Minimalist MAC: No MAC
+ *
+ * Minimalist MAC: No MAC. DO NOT USE.
+ *
+ * The SSH2 Transport allows implementations to forego a message
+ * authentication code.  While this is less of a security risk than using
+ * a "none" cipher, it is still not recommended as disabling MAC hashes
+ * removes a layer of security.
+ *
+ * Enabling this option will allow for "none" as a negotiable method,
+ * however it still requires that the method be advertised by the remote
+ * end and that no more-preferable methods are available.
+ *
  */
 static int
 mac_none_MAC(LIBSSH2_SESSION * session, unsigned char *buf,
              uint32_t seqno, const unsigned char *packet,
-             uint32_t packet_len, const unsigned char *addtl,
-             uint32_t addtl_len, void **abstract)
+             size_t packet_len, const unsigned char *addtl,
+             size_t addtl_len, void **abstract)
 {
     return 0;
 }
@@ -60,9 +73,10 @@ static LIBSSH2_MAC_METHOD mac_method_none = {
     0,
     NULL,
     mac_none_MAC,
-    NULL
+    NULL,
+    0
 };
-#endif /* LIBSSH2_MAC_NONE */
+#endif /* defined(LIBSSH2DEBUG) && defined(LIBSSH2_MAC_NONE_INSECURE) */
 
 /* mac_method_common_init
  * Initialize simple mac methods
@@ -73,7 +87,7 @@ mac_method_common_init(LIBSSH2_SESSION * session, unsigned char *key,
 {
     *abstract = key;
     *free_key = 0;
-    (void) session;
+    (void)session;
 
     return 0;
 }
@@ -102,29 +116,31 @@ mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract)
  */
 static int
 mac_method_hmac_sha2_512_hash(LIBSSH2_SESSION * session,
-                          unsigned char *buf, uint32_t seqno,
-                          const unsigned char *packet,
-                          uint32_t packet_len,
-                          const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
+                              unsigned char *buf, uint32_t seqno,
+                              const unsigned char *packet,
+                              size_t packet_len,
+                              const unsigned char *addtl,
+                              size_t addtl_len, void **abstract)
 {
     libssh2_hmac_ctx ctx;
     unsigned char seqno_buf[4];
-    (void) session;
+    int res;
+    (void)session;
 
     _libssh2_htonu32(seqno_buf, seqno);
 
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha512_init(&ctx, *abstract, 64);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
+    if(!_libssh2_hmac_ctx_init(&ctx))
+        return 1;
+    res = _libssh2_hmac_sha512_init(&ctx, *abstract, 64) &&
+          _libssh2_hmac_update(&ctx, seqno_buf, 4) &&
+          _libssh2_hmac_update(&ctx, packet, packet_len);
+    if(res && addtl && addtl_len)
+        res = _libssh2_hmac_update(&ctx, addtl, addtl_len);
+    if(res)
+        res = _libssh2_hmac_final(&ctx, buf);
+    _libssh2_hmac_cleanup(&ctx);
+
+    return !res;
 }
 
 
@@ -136,7 +152,19 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_512 = {
     mac_method_common_init,
     mac_method_hmac_sha2_512_hash,
     mac_method_common_dtor,
+    0
+};
+
+static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_512_etm = {
+    "hmac-sha2-512-etm@openssh.com",
+    64,
+    64,
+    mac_method_common_init,
+    mac_method_hmac_sha2_512_hash,
+    mac_method_common_dtor,
+    1
 };
+
 #endif
 
 
@@ -147,29 +175,31 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_512 = {
  */
 static int
 mac_method_hmac_sha2_256_hash(LIBSSH2_SESSION * session,
-                          unsigned char *buf, uint32_t seqno,
-                          const unsigned char *packet,
-                          uint32_t packet_len,
-                          const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
+                              unsigned char *buf, uint32_t seqno,
+                              const unsigned char *packet,
+                              size_t packet_len,
+                              const unsigned char *addtl,
+                              size_t addtl_len, void **abstract)
 {
     libssh2_hmac_ctx ctx;
     unsigned char seqno_buf[4];
-    (void) session;
+    int res;
+    (void)session;
 
     _libssh2_htonu32(seqno_buf, seqno);
 
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha256_init(&ctx, *abstract, 32);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
+    if(!_libssh2_hmac_ctx_init(&ctx))
+        return 1;
+    res = _libssh2_hmac_sha256_init(&ctx, *abstract, 32) &&
+          _libssh2_hmac_update(&ctx, seqno_buf, 4) &&
+          _libssh2_hmac_update(&ctx, packet, packet_len);
+    if(res && addtl && addtl_len)
+        res = _libssh2_hmac_update(&ctx, addtl, addtl_len);
+    if(res)
+        res = _libssh2_hmac_final(&ctx, buf);
+    _libssh2_hmac_cleanup(&ctx);
+
+    return !res;
 }
 
 
@@ -181,7 +211,19 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_256 = {
     mac_method_common_init,
     mac_method_hmac_sha2_256_hash,
     mac_method_common_dtor,
+    0
+};
+
+static const LIBSSH2_MAC_METHOD mac_method_hmac_sha2_256_etm = {
+    "hmac-sha2-256-etm@openssh.com",
+    32,
+    32,
+    mac_method_common_init,
+    mac_method_hmac_sha2_256_hash,
+    mac_method_common_dtor,
+    1
 };
+
 #endif
 
 
@@ -194,27 +236,29 @@ static int
 mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session,
                           unsigned char *buf, uint32_t seqno,
                           const unsigned char *packet,
-                          uint32_t packet_len,
+                          size_t packet_len,
                           const unsigned char *addtl,
-                          uint32_t addtl_len, void **abstract)
+                          size_t addtl_len, void **abstract)
 {
     libssh2_hmac_ctx ctx;
     unsigned char seqno_buf[4];
-    (void) session;
+    int res;
+    (void)session;
 
     _libssh2_htonu32(seqno_buf, seqno);
 
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_sha1_init(&ctx, *abstract, 20);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
+    if(!_libssh2_hmac_ctx_init(&ctx))
+        return 1;
+    res = _libssh2_hmac_sha1_init(&ctx, *abstract, 20) &&
+          _libssh2_hmac_update(&ctx, seqno_buf, 4) &&
+          _libssh2_hmac_update(&ctx, packet, packet_len);
+    if(res && addtl && addtl_len)
+        res = _libssh2_hmac_update(&ctx, addtl, addtl_len);
+    if(res)
+        res = _libssh2_hmac_final(&ctx, buf);
+    _libssh2_hmac_cleanup(&ctx);
+
+    return !res;
 }
 
 
@@ -226,6 +270,17 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_sha1 = {
     mac_method_common_init,
     mac_method_hmac_sha1_hash,
     mac_method_common_dtor,
+    0
+};
+
+static const LIBSSH2_MAC_METHOD mac_method_hmac_sha1_etm = {
+    "hmac-sha1-etm@openssh.com",
+    20,
+    20,
+    mac_method_common_init,
+    mac_method_hmac_sha1_hash,
+    mac_method_common_dtor,
+    1
 };
 
 /* mac_method_hmac_sha1_96_hash
@@ -235,16 +290,17 @@ static int
 mac_method_hmac_sha1_96_hash(LIBSSH2_SESSION * session,
                              unsigned char *buf, uint32_t seqno,
                              const unsigned char *packet,
-                             uint32_t packet_len,
+                             size_t packet_len,
                              const unsigned char *addtl,
-                             uint32_t addtl_len, void **abstract)
+                             size_t addtl_len, void **abstract)
 {
     unsigned char temp[SHA_DIGEST_LENGTH];
 
-    mac_method_hmac_sha1_hash(session, temp, seqno, packet, packet_len,
-                              addtl, addtl_len, abstract);
-    memcpy(buf, (char *) temp, 96 / 8);
+    if(mac_method_hmac_sha1_hash(session, temp, seqno, packet, packet_len,
+                                 addtl, addtl_len, abstract))
+        return 1;
 
+    memcpy(buf, (char *) temp, 96 / 8);
     return 0;
 }
 
@@ -257,6 +313,7 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_sha1_96 = {
     mac_method_common_init,
     mac_method_hmac_sha1_96_hash,
     mac_method_common_dtor,
+    0
 };
 
 #if LIBSSH2_MD5
@@ -267,27 +324,29 @@ static int
 mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf,
                          uint32_t seqno,
                          const unsigned char *packet,
-                         uint32_t packet_len,
+                         size_t packet_len,
                          const unsigned char *addtl,
-                         uint32_t addtl_len, void **abstract)
+                         size_t addtl_len, void **abstract)
 {
     libssh2_hmac_ctx ctx;
     unsigned char seqno_buf[4];
-    (void) session;
+    int res;
+    (void)session;
 
     _libssh2_htonu32(seqno_buf, seqno);
 
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_md5_init(&ctx, *abstract, 16);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
+    if(!_libssh2_hmac_ctx_init(&ctx))
+        return 1;
+    res = _libssh2_hmac_md5_init(&ctx, *abstract, 16) &&
+          _libssh2_hmac_update(&ctx, seqno_buf, 4) &&
+          _libssh2_hmac_update(&ctx, packet, packet_len);
+    if(res && addtl && addtl_len)
+        res = _libssh2_hmac_update(&ctx, addtl, addtl_len);
+    if(res)
+        res = _libssh2_hmac_final(&ctx, buf);
+    _libssh2_hmac_cleanup(&ctx);
+
+    return !res;
 }
 
 
@@ -299,6 +358,7 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_md5 = {
     mac_method_common_init,
     mac_method_hmac_md5_hash,
     mac_method_common_dtor,
+    0
 };
 
 /* mac_method_hmac_md5_96_hash
@@ -308,13 +368,16 @@ static int
 mac_method_hmac_md5_96_hash(LIBSSH2_SESSION * session,
                             unsigned char *buf, uint32_t seqno,
                             const unsigned char *packet,
-                            uint32_t packet_len,
+                            size_t packet_len,
                             const unsigned char *addtl,
-                            uint32_t addtl_len, void **abstract)
+                            size_t addtl_len, void **abstract)
 {
     unsigned char temp[MD5_DIGEST_LENGTH];
-    mac_method_hmac_md5_hash(session, temp, seqno, packet, packet_len,
-                             addtl, addtl_len, abstract);
+
+    if(mac_method_hmac_md5_hash(session, temp, seqno, packet, packet_len,
+                                addtl, addtl_len, abstract))
+        return 1;
+
     memcpy(buf, (char *) temp, 96 / 8);
     return 0;
 }
@@ -328,6 +391,7 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_md5_96 = {
     mac_method_common_init,
     mac_method_hmac_md5_96_hash,
     mac_method_common_dtor,
+    0
 };
 #endif /* LIBSSH2_MD5 */
 
@@ -339,28 +403,30 @@ static int
 mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session,
                                unsigned char *buf, uint32_t seqno,
                                const unsigned char *packet,
-                               uint32_t packet_len,
+                               size_t packet_len,
                                const unsigned char *addtl,
-                               uint32_t addtl_len,
+                               size_t addtl_len,
                                void **abstract)
 {
     libssh2_hmac_ctx ctx;
     unsigned char seqno_buf[4];
-    (void) session;
+    int res;
+    (void)session;
 
     _libssh2_htonu32(seqno_buf, seqno);
 
-    libssh2_hmac_ctx_init(ctx);
-    libssh2_hmac_ripemd160_init(&ctx, *abstract, 20);
-    libssh2_hmac_update(ctx, seqno_buf, 4);
-    libssh2_hmac_update(ctx, packet, packet_len);
-    if(addtl && addtl_len) {
-        libssh2_hmac_update(ctx, addtl, addtl_len);
-    }
-    libssh2_hmac_final(ctx, buf);
-    libssh2_hmac_cleanup(&ctx);
-
-    return 0;
+    if(!_libssh2_hmac_ctx_init(&ctx))
+        return 1;
+    res = _libssh2_hmac_ripemd160_init(&ctx, *abstract, 20) &&
+          _libssh2_hmac_update(&ctx, seqno_buf, 4) &&
+          _libssh2_hmac_update(&ctx, packet, packet_len);
+    if(res && addtl && addtl_len)
+        res = _libssh2_hmac_update(&ctx, addtl, addtl_len);
+    if(res)
+        res = _libssh2_hmac_final(&ctx, buf);
+    _libssh2_hmac_cleanup(&ctx);
+
+    return !res;
 }
 
 
@@ -372,6 +438,7 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_ripemd160 = {
     mac_method_common_init,
     mac_method_hmac_ripemd160_hash,
     mac_method_common_dtor,
+    0
 };
 
 static const LIBSSH2_MAC_METHOD mac_method_hmac_ripemd160_openssh_com = {
@@ -381,17 +448,21 @@ static const LIBSSH2_MAC_METHOD mac_method_hmac_ripemd160_openssh_com = {
     mac_method_common_init,
     mac_method_hmac_ripemd160_hash,
     mac_method_common_dtor,
+    0
 };
 #endif /* LIBSSH2_HMAC_RIPEMD */
 
 static const LIBSSH2_MAC_METHOD *mac_methods[] = {
 #if LIBSSH2_HMAC_SHA256
     &mac_method_hmac_sha2_256,
+    &mac_method_hmac_sha2_256_etm,
 #endif
 #if LIBSSH2_HMAC_SHA512
     &mac_method_hmac_sha2_512,
+    &mac_method_hmac_sha2_512_etm,
 #endif
     &mac_method_hmac_sha1,
+    &mac_method_hmac_sha1_etm,
     &mac_method_hmac_sha1_96,
 #if LIBSSH2_MD5
     &mac_method_hmac_md5,
@@ -401,9 +472,9 @@ static const LIBSSH2_MAC_METHOD *mac_methods[] = {
     &mac_method_hmac_ripemd160,
     &mac_method_hmac_ripemd160_openssh_com,
 #endif /* LIBSSH2_HMAC_RIPEMD */
-#ifdef LIBSSH2_MAC_NONE
+#if defined(LIBSSH2DEBUG) && defined(LIBSSH2_MAC_NONE_INSECURE)
     &mac_method_none,
-#endif /* LIBSSH2_MAC_NONE */
+#endif
     NULL
 };
 
@@ -412,3 +483,71 @@ _libssh2_mac_methods(void)
 {
     return mac_methods;
 }
+
+#if LIBSSH2_AES_GCM
+static int
+mac_method_none_init(LIBSSH2_SESSION * session, unsigned char *key,
+                     int *free_key, void **abstract)
+{
+    (void)session;
+    (void)key;
+    (void)free_key;
+    (void)abstract;
+    return 0;
+}
+
+static int
+mac_method_hmac_none_hash(LIBSSH2_SESSION * session,
+                          unsigned char *buf, uint32_t seqno,
+                          const unsigned char *packet,
+                          size_t packet_len,
+                          const unsigned char *addtl,
+                          size_t addtl_len, void **abstract)
+{
+    (void)session;
+    (void)buf;
+    (void)seqno;
+    (void)packet;
+    (void)packet_len;
+    (void)addtl;
+    (void)addtl_len;
+    (void)abstract;
+    return 0;
+}
+
+static int
+mac_method_none_dtor(LIBSSH2_SESSION * session, void **abstract)
+{
+    (void)session;
+    (void)abstract;
+    return 0;
+}
+
+/* Stub for aes256-gcm@openssh.com crypto type, which has an integrated
+   HMAC method. This must not be added to mac_methods[] since it cannot be
+   negotiated separately. */
+static const LIBSSH2_MAC_METHOD mac_method_hmac_aesgcm = {
+    "INTEGRATED-AES-GCM",  /* made up name for display only */
+    16,
+    16,
+    mac_method_none_init,
+    mac_method_hmac_none_hash,
+    mac_method_none_dtor,
+    0
+};
+#endif /* LIBSSH2_AES_GCM */
+
+/* See if the negotiated crypto method has its own authentication scheme that
+ * obviates the need for a separate negotiated hmac method */
+const LIBSSH2_MAC_METHOD *
+_libssh2_mac_override(const LIBSSH2_CRYPT_METHOD *crypt)
+{
+#if LIBSSH2_AES_GCM
+    if(!strcmp(crypt->name, "aes256-gcm@openssh.com") ||
+       !strcmp(crypt->name, "aes128-gcm@openssh.com"))
+        return &mac_method_hmac_aesgcm;
+#else
+    (void) crypt;
+#endif /* LIBSSH2_AES_GCM */
+    return NULL;
+}
diff --git a/libssh2/src/mac.h b/libssh2/src/mac.h
index 46fce542..8e5b8c28 100644
--- a/libssh2/src/mac.h
+++ b/libssh2/src/mac.h
@@ -1,6 +1,7 @@
-#ifndef __LIBSSH2_MAC_H
-#define __LIBSSH2_MAC_H
-/* Copyright (C) 2009-2010 by Daniel Stenberg
+#ifndef LIBSSH2_MAC_H
+#define LIBSSH2_MAC_H
+/* Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -35,6 +36,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -54,13 +56,17 @@ struct _LIBSSH2_MAC_METHOD
                  void **abstract);
     int (*hash) (LIBSSH2_SESSION * session, unsigned char *buf,
                  uint32_t seqno, const unsigned char *packet,
-                 uint32_t packet_len, const unsigned char *addtl,
-                 uint32_t addtl_len, void **abstract);
+                 size_t packet_len, const unsigned char *addtl,
+                 size_t addtl_len, void **abstract);
     int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
+
+    int etm; /* encrypt-then-mac */
 };
 
 typedef struct _LIBSSH2_MAC_METHOD LIBSSH2_MAC_METHOD;
 
 const LIBSSH2_MAC_METHOD **_libssh2_mac_methods(void);
+const LIBSSH2_MAC_METHOD *_libssh2_mac_override(
+        const LIBSSH2_CRYPT_METHOD *crypt);
 
-#endif /* __LIBSSH2_MAC_H */
+#endif /* LIBSSH2_MAC_H */
diff --git a/libssh2/src/mbedtls.c b/libssh2/src/mbedtls.c
index 4629ce4a..a66e36c5 100644
--- a/libssh2/src/mbedtls.c
+++ b/libssh2/src/mbedtls.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2016, Art <https://github.com/wildart>
+/* Copyright (C) Art <https://github.com/wildart>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,11 +33,21 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_priv.h"
+#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */
+
+#include <stdlib.h>
 
-#ifdef LIBSSH2_MBEDTLS /* compile only if we build with mbedtls */
+#if MBEDTLS_VERSION_NUMBER < 0x03000000
+#define mbedtls_cipher_info_get_key_bitlen(c) (c->key_bitlen)
+#define mbedtls_cipher_info_get_iv_size(c)    (c->iv_size)
+#define mbedtls_rsa_get_len(rsa)              (rsa->len)
+
+#define MBEDTLS_PRIVATE(m) m
+#endif
 
 /*******************************************************************/
 /*
@@ -63,7 +73,7 @@ _libssh2_mbedtls_init(void)
     ret = mbedtls_ctr_drbg_seed(&_libssh2_mbedtls_ctr_drbg,
                                 mbedtls_entropy_func,
                                 &_libssh2_mbedtls_entropy, NULL, 0);
-    if(ret != 0)
+    if(ret)
         mbedtls_ctr_drbg_free(&_libssh2_mbedtls_ctr_drbg);
 }
 
@@ -75,7 +85,7 @@ _libssh2_mbedtls_free(void)
 }
 
 int
-_libssh2_mbedtls_random(unsigned char *buf, int len)
+_libssh2_mbedtls_random(unsigned char *buf, size_t len)
 {
     int ret;
     ret = mbedtls_ctr_drbg_random(&_libssh2_mbedtls_ctr_drbg, buf, len);
@@ -83,19 +93,13 @@ _libssh2_mbedtls_random(unsigned char *buf, int len)
 }
 
 static void
-_libssh2_mbedtls_safe_free(void *buf, int len)
+_libssh2_mbedtls_safe_free(void *buf, size_t len)
 {
-#ifndef LIBSSH2_CLEAR_MEMORY
-    (void)len;
-#endif
-
     if(!buf)
         return;
 
-#ifdef LIBSSH2_CLEAR_MEMORY
     if(len > 0)
         _libssh2_explicit_zero(buf, len);
-#endif
 
     mbedtls_free(buf);
 }
@@ -122,10 +126,14 @@ _libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
     mbedtls_cipher_init(ctx);
     ret = mbedtls_cipher_setup(ctx, cipher_info);
     if(!ret)
-        ret = mbedtls_cipher_setkey(ctx, secret, cipher_info->key_bitlen, op);
+        ret = mbedtls_cipher_setkey(ctx,
+                  secret,
+                  (int)mbedtls_cipher_info_get_key_bitlen(cipher_info),
+                  op);
 
     if(!ret)
-        ret = mbedtls_cipher_set_iv(ctx, iv, cipher_info->iv_size);
+        ret = mbedtls_cipher_set_iv(ctx, iv,
+                  mbedtls_cipher_info_get_iv_size(cipher_info));
 
     return ret == 0 ? 0 : -1;
 }
@@ -135,14 +143,15 @@ _libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
                               _libssh2_cipher_type(algo),
                               int encrypt,
                               unsigned char *block,
-                              size_t blocklen)
+                              size_t blocklen, int firstlast)
 {
     int ret;
     unsigned char *output;
     size_t osize, olen, finish_olen;
 
-    (void) encrypt;
-    (void) algo;
+    (void)encrypt;
+    (void)algo;
+    (void)firstlast;
 
     osize = blocklen + mbedtls_cipher_get_block_size(ctx);
 
@@ -178,8 +187,8 @@ _libssh2_mbedtls_cipher_dtor(_libssh2_cipher_ctx *ctx)
 
 int
 _libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
-                          mbedtls_md_type_t mdtype,
-                          const unsigned char *key, unsigned long keylen)
+                           mbedtls_md_type_t mdtype,
+                           const unsigned char *key, size_t keylen)
 {
     const mbedtls_md_info_t *md_info;
     int ret, hmac;
@@ -188,7 +197,7 @@ _libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
     if(!md_info)
         return 0;
 
-    hmac = key == NULL ? 0 : 1;
+    hmac = key ? 1 : 0;
 
     mbedtls_md_init(ctx);
     ret = mbedtls_md_setup(ctx, md_info, hmac);
@@ -210,11 +219,11 @@ _libssh2_mbedtls_hash_final(mbedtls_md_context_t *ctx, unsigned char *hash)
     ret = mbedtls_md_finish(ctx, hash);
     mbedtls_md_free(ctx);
 
-    return ret == 0 ? 0 : -1;
+    return ret == 0 ? 1 : 0;
 }
 
 int
-_libssh2_mbedtls_hash(const unsigned char *data, unsigned long datalen,
+_libssh2_mbedtls_hash(const unsigned char *data, size_t datalen,
                       mbedtls_md_type_t mdtype, unsigned char *hash)
 {
     const mbedtls_md_info_t *md_info;
@@ -229,6 +238,66 @@ _libssh2_mbedtls_hash(const unsigned char *data, unsigned long datalen,
     return ret == 0 ? 0 : -1;
 }
 
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
+{
+    memset(ctx, 0, sizeof(*ctx));
+    return 1;
+}
+
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen)
+{
+    return _libssh2_mbedtls_hash_init(ctx, MBEDTLS_MD_MD5, key, keylen);
+}
+#endif
+
+#if LIBSSH2_HMAC_RIPEMD
+int _libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
+                                 void *key, size_t keylen)
+{
+    return _libssh2_mbedtls_hash_init(ctx, MBEDTLS_MD_RIPEMD160, key, keylen);
+}
+#endif
+
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen)
+{
+    return _libssh2_mbedtls_hash_init(ctx, MBEDTLS_MD_SHA1, key, keylen);
+}
+
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    return _libssh2_mbedtls_hash_init(ctx, MBEDTLS_MD_SHA256, key, keylen);
+}
+
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    return _libssh2_mbedtls_hash_init(ctx, MBEDTLS_MD_SHA512, key, keylen);
+}
+
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen)
+{
+    int ret = mbedtls_md_hmac_update(ctx, data, datalen);
+
+    return ret == 0 ? 1 : 0;
+}
+
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data)
+{
+    int ret = mbedtls_md_hmac_finish(ctx, data);
+
+    return ret == 0 ? 1 : 0;
+}
+
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
+{
+    mbedtls_md_free(ctx);
+}
+
 /*******************************************************************/
 /*
  * mbedTLS backend: BigNumber functions
@@ -261,7 +330,7 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
 {
     size_t len;
     int err;
-    int i;
+    size_t i;
 
     if(!bn || bits <= 0)
         return -1;
@@ -272,8 +341,8 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
     if(err)
         return -1;
 
-    /* Zero unused bits above the most significant bit*/
-    for(i = len*8 - 1; bits <= i; --i) {
+    /* Zero unused bits above the most significant bit */
+    for(i = len*8 - 1; (size_t)bits <= i; --i) {
         err = mbedtls_mpi_set_bit(bn, i, 0);
         if(err)
             return -1;
@@ -285,10 +354,12 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
        will be set to 1, so that the product of two such random numbers will
        always have 2*bits length.
     */
-    for(i = 0; i <= top; ++i) {
-        err = mbedtls_mpi_set_bit(bn, bits-i-1, 1);
-        if(err)
-            return -1;
+    if(top >= 0) {
+        for(i = 0; i <= (size_t)top; ++i) {
+            err = mbedtls_mpi_set_bit(bn, bits-i-1, 1);
+            if(err)
+                return -1;
+        }
     }
 
     /* make odd by setting first bit in least significant byte */
@@ -309,52 +380,64 @@ _libssh2_mbedtls_bignum_random(_libssh2_bn *bn, int bits, int top, int bottom)
 
 int
 _libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen)
+                         const unsigned char *edata,
+                         unsigned long elen,
+                         const unsigned char *ndata,
+                         unsigned long nlen,
+                         const unsigned char *ddata,
+                         unsigned long dlen,
+                         const unsigned char *pdata,
+                         unsigned long plen,
+                         const unsigned char *qdata,
+                         unsigned long qlen,
+                         const unsigned char *e1data,
+                         unsigned long e1len,
+                         const unsigned char *e2data,
+                         unsigned long e2len,
+                         const unsigned char *coeffdata,
+                         unsigned long coefflen)
 {
     int ret;
     libssh2_rsa_ctx *ctx;
 
     ctx = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
-    if(ctx != NULL) {
+    if(ctx) {
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+        mbedtls_rsa_init(ctx);
+#else
         mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V15, 0);
+#endif
     }
     else
         return -1;
 
     /* !checksrc! disable ASSIGNWITHINCONDITION 1 */
-    if((ret = mbedtls_mpi_read_binary(&(ctx->E), edata, elen) ) != 0 ||
-       (ret = mbedtls_mpi_read_binary(&(ctx->N), ndata, nlen) ) != 0) {
+    if((ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(E)),
+                                      edata, elen)) ||
+       (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(N)),
+                                      ndata, nlen))) {
         ret = -1;
     }
 
     if(!ret) {
-        ctx->len = mbedtls_mpi_size(&(ctx->N));
+        ctx->MBEDTLS_PRIVATE(len) =
+            mbedtls_mpi_size(&(ctx->MBEDTLS_PRIVATE(N)));
     }
 
     if(!ret && ddata) {
         /* !checksrc! disable ASSIGNWITHINCONDITION 1 */
-        if((ret = mbedtls_mpi_read_binary(&(ctx->D), ddata, dlen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->P), pdata, plen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->Q), qdata, qlen) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->DP), e1data, e1len) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->DQ), e2data, e2len) ) != 0 ||
-           (ret = mbedtls_mpi_read_binary(&(ctx->QP), coeffdata, coefflen) )
-           != 0) {
+        if((ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(D)),
+                                          ddata, dlen)) ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(P)),
+                                          pdata, plen)) ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(Q)),
+                                          qdata, qlen)) ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(DP)),
+                                          e1data, e1len)) ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(DQ)),
+                                          e2data, e2len)) ||
+           (ret = mbedtls_mpi_read_binary(&(ctx->MBEDTLS_PRIVATE(QP)),
+                                          coeffdata, coefflen))) {
             ret = -1;
         }
         ret = mbedtls_rsa_check_privkey(ctx);
@@ -373,23 +456,33 @@ _libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
 
 int
 _libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase)
+                                 LIBSSH2_SESSION *session,
+                                 const char *filename,
+                                 const unsigned char *passphrase)
 {
     int ret;
     mbedtls_pk_context pkey;
     mbedtls_rsa_context *pk_rsa;
 
     *rsa = (libssh2_rsa_ctx *) LIBSSH2_ALLOC(session, sizeof(libssh2_rsa_ctx));
-    if(*rsa == NULL)
+    if(!*rsa)
         return -1;
 
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    mbedtls_rsa_init(*rsa);
+#else
     mbedtls_rsa_init(*rsa, MBEDTLS_RSA_PKCS_V15, 0);
+#endif
     mbedtls_pk_init(&pkey);
 
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase,
+                                   mbedtls_ctr_drbg_random,
+                                   &_libssh2_mbedtls_ctr_drbg);
+#else
     ret = mbedtls_pk_parse_keyfile(&pkey, filename, (char *)passphrase);
-    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
+#endif
+    if(ret || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
         mbedtls_pk_free(&pkey);
         mbedtls_rsa_free(*rsa);
         LIBSSH2_FREE(session, *rsa);
@@ -406,10 +499,10 @@ _libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
 
 int
 _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase)
+                                            LIBSSH2_SESSION *session,
+                                            const char *filedata,
+                                            size_t filedata_len,
+                                            unsigned const char *passphrase)
 {
     int ret;
     mbedtls_pk_context pkey;
@@ -418,7 +511,7 @@ _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
     size_t pwd_len;
 
     *rsa = (libssh2_rsa_ctx *) mbedtls_calloc(1, sizeof(libssh2_rsa_ctx));
-    if(*rsa == NULL)
+    if(!*rsa)
         return -1;
 
     /*
@@ -426,20 +519,28 @@ _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
     private-key from memory will fail if the last byte is not a null byte
     */
     filedata_nullterm = mbedtls_calloc(filedata_len + 1, 1);
-    if(filedata_nullterm == NULL) {
+    if(!filedata_nullterm) {
         return -1;
     }
     memcpy(filedata_nullterm, filedata, filedata_len);
 
     mbedtls_pk_init(&pkey);
 
-    pwd_len = passphrase != NULL ? strlen((const char *)passphrase) : 0;
+    pwd_len = passphrase ? strlen((const char *)passphrase) : 0;
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata_nullterm,
+                               filedata_len + 1,
+                               passphrase, pwd_len,
+                               mbedtls_ctr_drbg_random,
+                               &_libssh2_mbedtls_ctr_drbg);
+#else
     ret = mbedtls_pk_parse_key(&pkey, (unsigned char *)filedata_nullterm,
                                filedata_len + 1,
                                passphrase, pwd_len);
+#endif
     _libssh2_mbedtls_safe_free(filedata_nullterm, filedata_len);
 
-    if(ret != 0 || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
+    if(ret || mbedtls_pk_get_type(&pkey) != MBEDTLS_PK_RSA) {
         mbedtls_pk_free(&pkey);
         mbedtls_rsa_free(*rsa);
         LIBSSH2_FREE(session, *rsa);
@@ -455,49 +556,115 @@ _libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
 }
 
 int
-_libssh2_mbedtls_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len)
+_libssh2_mbedtls_rsa_sha2_verify(libssh2_rsa_ctx * rsactx,
+                                 size_t hash_len,
+                                 const unsigned char *sig,
+                                 size_t sig_len,
+                                 const unsigned char *m,
+                                 size_t m_len)
 {
-    unsigned char hash[SHA_DIGEST_LENGTH];
     int ret;
+    int md_type;
+    unsigned char *hash;
 
-    ret = _libssh2_mbedtls_hash(m, m_len, MBEDTLS_MD_SHA1, hash);
-    if(ret)
+    if(sig_len < mbedtls_rsa_get_len(rsactx))
+        return -1;
+
+    hash = malloc(hash_len);
+    if(!hash)
+        return -1;
+
+    if(hash_len == SHA_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA1;
+    }
+    else if(hash_len == SHA256_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA256;
+    }
+    else if(hash_len == SHA512_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA512;
+    }
+    else{
+        free(hash);
+        return -1; /* unsupported digest */
+    }
+    ret = _libssh2_mbedtls_hash(m, m_len, md_type, hash);
+
+    if(ret) {
+        free(hash);
         return -1; /* failure */
+    }
 
-    ret = mbedtls_rsa_pkcs1_verify(rsa, NULL, NULL, MBEDTLS_RSA_PUBLIC,
-                                   MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    ret = mbedtls_rsa_pkcs1_verify(rsactx,
+                                   md_type, (unsigned int)hash_len,
+                                   hash, sig);
+#else
+    ret = mbedtls_rsa_pkcs1_verify(rsactx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
+                                   md_type, (unsigned int)hash_len,
                                    hash, sig);
+#endif
+    free(hash);
 
     return (ret == 0) ? 0 : -1;
 }
 
 int
-_libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len)
+_libssh2_mbedtls_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
+                                 const unsigned char *sig,
+                                 size_t sig_len,
+                                 const unsigned char *m,
+                                 size_t m_len)
+{
+    return _libssh2_mbedtls_rsa_sha2_verify(rsactx, SHA_DIGEST_LENGTH,
+                                            sig, sig_len, m, m_len);
+}
+
+int
+_libssh2_mbedtls_rsa_sha2_sign(LIBSSH2_SESSION *session,
+                               libssh2_rsa_ctx *rsa,
+                               const unsigned char *hash,
+                               size_t hash_len,
+                               unsigned char **signature,
+                               size_t *signature_len)
 {
     int ret;
     unsigned char *sig;
-    unsigned int sig_len;
-
-    (void)hash_len;
+    size_t sig_len;
+    int md_type;
 
-    sig_len = rsa->len;
+    sig_len = mbedtls_rsa_get_len(rsa);
     sig = LIBSSH2_ALLOC(session, sig_len);
     if(!sig) {
         return -1;
     }
-
-    ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
-                                 MBEDTLS_MD_SHA1, SHA_DIGEST_LENGTH,
-                                 hash, sig);
+    ret = 0;
+    if(hash_len == SHA_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA1;
+    }
+    else if(hash_len == SHA256_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA256;
+    }
+    else if(hash_len == SHA512_DIGEST_LENGTH) {
+        md_type = MBEDTLS_MD_SHA512;
+    }
+    else {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Unsupported hash digest length");
+        ret = -1;
+    }
+    if(ret == 0) {
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+        ret = mbedtls_rsa_pkcs1_sign(rsa,
+                                     mbedtls_ctr_drbg_random,
+                                     &_libssh2_mbedtls_ctr_drbg,
+                                     md_type, (unsigned int)hash_len,
+                                     hash, sig);
+#else
+        ret = mbedtls_rsa_pkcs1_sign(rsa, NULL, NULL, MBEDTLS_RSA_PRIVATE,
+                                     md_type, (unsigned int)hash_len,
+                                     hash, sig);
+#endif
+    }
     if(ret) {
         LIBSSH2_FREE(session, sig);
         return -1;
@@ -509,6 +676,18 @@ _libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
     return (ret == 0) ? 0 : -1;
 }
 
+int
+_libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION * session,
+                               libssh2_rsa_ctx * rsactx,
+                               const unsigned char *hash,
+                               size_t hash_len,
+                               unsigned char **signature,
+                               size_t *signature_len)
+{
+    return _libssh2_mbedtls_rsa_sha2_sign(session, rsactx, hash, hash_len,
+                                          signature, signature_len);
+}
+
 void
 _libssh2_mbedtls_rsa_free(libssh2_rsa_ctx *ctx)
 {
@@ -518,16 +697,16 @@ _libssh2_mbedtls_rsa_free(libssh2_rsa_ctx *ctx)
 
 static unsigned char *
 gen_publickey_from_rsa(LIBSSH2_SESSION *session,
-                      mbedtls_rsa_context *rsa,
-                      size_t *keylen)
+                       mbedtls_rsa_context *rsa,
+                       size_t *keylen)
 {
-    int            e_bytes, n_bytes;
-    unsigned long  len;
+    uint32_t e_bytes, n_bytes;
+    uint32_t len;
     unsigned char *key;
     unsigned char *p;
 
-    e_bytes = mbedtls_mpi_size(&rsa->E);
-    n_bytes = mbedtls_mpi_size(&rsa->N);
+    e_bytes = (uint32_t)mbedtls_mpi_size(&rsa->MBEDTLS_PRIVATE(E));
+    n_bytes = (uint32_t)mbedtls_mpi_size(&rsa->MBEDTLS_PRIVATE(N));
 
     /* Key form is "ssh-rsa" + e + n. */
     len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
@@ -547,11 +726,11 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
 
     _libssh2_htonu32(p, e_bytes);
     p += 4;
-    mbedtls_mpi_write_binary(&rsa->E, p, e_bytes);
+    mbedtls_mpi_write_binary(&rsa->MBEDTLS_PRIVATE(E), p, e_bytes);
 
     _libssh2_htonu32(p, n_bytes);
     p += 4;
-    mbedtls_mpi_write_binary(&rsa->N, p, n_bytes);
+    mbedtls_mpi_write_binary(&rsa->MBEDTLS_PRIVATE(N), p, n_bytes);
 
     *keylen = (size_t)(p - key);
     return key;
@@ -559,11 +738,11 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session,
 
 static int
 _libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
-                               unsigned char **method,
-                               size_t *method_len,
-                               unsigned char **pubkeydata,
-                               size_t *pubkeydata_len,
-                               mbedtls_pk_context *pkey)
+                              unsigned char **method,
+                              size_t *method_len,
+                              unsigned char **pubkeydata,
+                              size_t *pubkeydata_len,
+                              mbedtls_pk_context *pkey)
 {
     unsigned char *key = NULL, *mth = NULL;
     size_t keylen = 0, mthlen = 0;
@@ -588,7 +767,7 @@ _libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
 
     rsa = mbedtls_pk_rsa(*pkey);
     key = gen_publickey_from_rsa(session, rsa, &keylen);
-    if(key == NULL) {
+    if(!key) {
         ret = -1;
     }
 
@@ -611,27 +790,33 @@ _libssh2_mbedtls_pub_priv_key(LIBSSH2_SESSION *session,
 
 int
 _libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase)
+                                  unsigned char **method,
+                                  size_t *method_len,
+                                  unsigned char **pubkeydata,
+                                  size_t *pubkeydata_len,
+                                  const char *privatekey,
+                                  const char *passphrase)
 {
     mbedtls_pk_context pkey;
     char buf[1024];
     int ret;
 
     mbedtls_pk_init(&pkey);
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase,
+                                   mbedtls_ctr_drbg_random,
+                                   &_libssh2_mbedtls_ctr_drbg);
+#else
     ret = mbedtls_pk_parse_keyfile(&pkey, privatekey, passphrase);
-    if(ret != 0) {
+#endif
+    if(ret) {
         mbedtls_strerror(ret, (char *)buf, sizeof(buf));
         mbedtls_pk_free(&pkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
     }
 
     ret = _libssh2_mbedtls_pub_priv_key(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, &pkey);
+                                        pubkeydata, pubkeydata_len, &pkey);
 
     mbedtls_pk_free(&pkey);
 
@@ -640,13 +825,13 @@ _libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
 
 int
 _libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase)
+                                        unsigned char **method,
+                                        size_t *method_len,
+                                        unsigned char **pubkeydata,
+                                        size_t *pubkeydata_len,
+                                        const char *privatekeydata,
+                                        size_t privatekeydata_len,
+                                        const char *passphrase)
 {
     mbedtls_pk_context pkey;
     char buf[1024];
@@ -659,34 +844,76 @@ _libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     private-key from memory will fail if the last byte is not a null byte
     */
     privatekeydata_nullterm = mbedtls_calloc(privatekeydata_len + 1, 1);
-    if(privatekeydata_nullterm == NULL) {
+    if(!privatekeydata_nullterm) {
         return -1;
     }
     memcpy(privatekeydata_nullterm, privatekeydata, privatekeydata_len);
 
     mbedtls_pk_init(&pkey);
 
-    pwd_len = passphrase != NULL ? strlen((const char *)passphrase) : 0;
+    pwd_len = passphrase ? strlen((const char *)passphrase) : 0;
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    ret = mbedtls_pk_parse_key(&pkey,
+                               (unsigned char *)privatekeydata_nullterm,
+                               privatekeydata_len + 1,
+                               (const unsigned char *)passphrase, pwd_len,
+                               mbedtls_ctr_drbg_random,
+                               &_libssh2_mbedtls_ctr_drbg);
+#else
     ret = mbedtls_pk_parse_key(&pkey,
                                (unsigned char *)privatekeydata_nullterm,
                                privatekeydata_len + 1,
                                (const unsigned char *)passphrase, pwd_len);
+#endif
     _libssh2_mbedtls_safe_free(privatekeydata_nullterm, privatekeydata_len);
 
-    if(ret != 0) {
+    if(ret) {
         mbedtls_strerror(ret, (char *)buf, sizeof(buf));
         mbedtls_pk_free(&pkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);
     }
 
     ret = _libssh2_mbedtls_pub_priv_key(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, &pkey);
+                                        pubkeydata, pubkeydata_len, &pkey);
 
     mbedtls_pk_free(&pkey);
 
     return ret;
 }
 
+int
+_libssh2_mbedtls_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                                      unsigned char **method,
+                                      size_t *method_len,
+                                      unsigned char **pubkeydata,
+                                      size_t *pubkeydata_len,
+                                      int *algorithm,
+                                      unsigned char *flags,
+                                      const char **application,
+                                      const unsigned char **key_handle,
+                                      size_t *handle_len,
+                                      const char *privatekeydata,
+                                      size_t privatekeydata_len,
+                                      const char *passphrase)
+{
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)algorithm;
+    (void)flags;
+    (void)application;
+    (void)key_handle;
+    (void)handle_len;
+    (void)privatekeydata;
+    (void)privatekeydata_len;
+    (void)passphrase;
+
+    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                    "Unable to extract public SK key from private key file: "
+                    "Method unimplemented in mbedTLS backend");
+}
+
 void _libssh2_init_aes_ctr(void)
 {
     /* no implementation */
@@ -756,23 +983,24 @@ _libssh2_mbedtls_ecdsa_create_key(LIBSSH2_SESSION *session,
 
     *privkey = LIBSSH2_ALLOC(session, sizeof(mbedtls_ecp_keypair));
 
-    if(*privkey == NULL)
+    if(!*privkey)
         goto failed;
 
     mbedtls_ecdsa_init(*privkey);
 
     if(mbedtls_ecdsa_genkey(*privkey, (mbedtls_ecp_group_id)curve,
                             mbedtls_ctr_drbg_random,
-                            &_libssh2_mbedtls_ctr_drbg) != 0)
+                            &_libssh2_mbedtls_ctr_drbg))
         goto failed;
 
-    plen = 2 * mbedtls_mpi_size(&(*privkey)->grp.P) + 1;
+    plen = 2 * mbedtls_mpi_size(&(*privkey)->MBEDTLS_PRIVATE(grp).P) + 1;
     *pubkey_oct = LIBSSH2_ALLOC(session, plen);
 
-    if(*pubkey_oct == NULL)
+    if(!*pubkey_oct)
         goto failed;
 
-    if(mbedtls_ecp_point_write_binary(&(*privkey)->grp, &(*privkey)->Q,
+    if(mbedtls_ecp_point_write_binary(&(*privkey)->MBEDTLS_PRIVATE(grp),
+                                      &(*privkey)->MBEDTLS_PRIVATE(Q),
                                       MBEDTLS_ECP_PF_UNCOMPRESSED,
                                       pubkey_oct_len, *pubkey_oct, plen) == 0)
         return 0;
@@ -800,18 +1028,22 @@ _libssh2_mbedtls_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx **ctx,
 {
     *ctx = mbedtls_calloc(1, sizeof(mbedtls_ecp_keypair));
 
-    if(*ctx == NULL)
+    if(!*ctx)
         goto failed;
 
     mbedtls_ecdsa_init(*ctx);
 
-    if(mbedtls_ecp_group_load(&(*ctx)->grp, (mbedtls_ecp_group_id)curve) != 0)
+    if(mbedtls_ecp_group_load(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                              (mbedtls_ecp_group_id)curve))
         goto failed;
 
-    if(mbedtls_ecp_point_read_binary(&(*ctx)->grp, &(*ctx)->Q, k, k_len) != 0)
+    if(mbedtls_ecp_point_read_binary(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                                     &(*ctx)->MBEDTLS_PRIVATE(Q),
+                                     k, k_len))
         goto failed;
 
-    if(mbedtls_ecp_check_pubkey(&(*ctx)->grp, &(*ctx)->Q) == 0)
+    if(mbedtls_ecp_check_pubkey(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                                &(*ctx)->MBEDTLS_PRIVATE(Q)) == 0)
         return 0;
 
 failed:
@@ -837,26 +1069,28 @@ _libssh2_mbedtls_ecdh_gen_k(_libssh2_bn **k,
     mbedtls_ecp_point pubkey;
     int rc = 0;
 
-    if(*k == NULL)
+    if(!*k)
         return -1;
 
     mbedtls_ecp_point_init(&pubkey);
 
-    if(mbedtls_ecp_point_read_binary(&privkey->grp, &pubkey,
-                                     server_pubkey, server_pubkey_len) != 0) {
+    if(mbedtls_ecp_point_read_binary(&privkey->MBEDTLS_PRIVATE(grp),
+                                     &pubkey,
+                                     server_pubkey, server_pubkey_len)) {
         rc = -1;
         goto cleanup;
     }
 
-    if(mbedtls_ecdh_compute_shared(&privkey->grp, *k,
-                                   &pubkey, &privkey->d,
+    if(mbedtls_ecdh_compute_shared(&privkey->MBEDTLS_PRIVATE(grp), *k,
+                                   &pubkey,
+                                   &privkey->MBEDTLS_PRIVATE(d),
                                    mbedtls_ctr_drbg_random,
-                                   &_libssh2_mbedtls_ctr_drbg) != 0) {
+                                   &_libssh2_mbedtls_ctr_drbg)) {
         rc = -1;
         goto cleanup;
     }
 
-    if(mbedtls_ecp_check_privkey(&privkey->grp, *k) != 0)
+    if(mbedtls_ecp_check_privkey(&privkey->MBEDTLS_PRIVATE(grp), *k))
         rc = -1;
 
 cleanup:
@@ -866,19 +1100,18 @@ _libssh2_mbedtls_ecdh_gen_k(_libssh2_bn **k,
     return rc;
 }
 
-#define LIBSSH2_MBEDTLS_ECDSA_VERIFY(digest_type)                   \
-{                                                                   \
-    unsigned char hsh[SHA##digest_type##_DIGEST_LENGTH];            \
-                                                                    \
-    if(libssh2_sha##digest_type(m, m_len, hsh) == 0) {              \
-        rc = mbedtls_ecdsa_verify(&ctx->grp, hsh,                   \
-                                  SHA##digest_type##_DIGEST_LENGTH, \
-                                  &ctx->Q, &pr, &ps);               \
-    }                                                               \
-                                                                    \
-}
-
-/* _libssh2_ecdsa_sign
+#define LIBSSH2_MBEDTLS_ECDSA_VERIFY(digest_type)                           \
+    do {                                                                    \
+        unsigned char hsh[SHA##digest_type##_DIGEST_LENGTH];                \
+                                                                            \
+        if(libssh2_sha##digest_type(m, m_len, hsh) == 0) {                  \
+            rc = mbedtls_ecdsa_verify(&ctx->MBEDTLS_PRIVATE(grp), hsh,      \
+                                      SHA##digest_type##_DIGEST_LENGTH,     \
+                                      &ctx->MBEDTLS_PRIVATE(Q), &pr, &ps);  \
+        }                                                                   \
+    } while(0)
+
+/* _libssh2_ecdsa_verify
  *
  * Verifies the ECDSA signature of a hashed message
  *
@@ -896,10 +1129,10 @@ _libssh2_mbedtls_ecdsa_verify(libssh2_ecdsa_ctx *ctx,
     mbedtls_mpi_init(&pr);
     mbedtls_mpi_init(&ps);
 
-    if(mbedtls_mpi_read_binary(&pr, r, r_len) != 0)
+    if(mbedtls_mpi_read_binary(&pr, r, r_len))
         goto cleanup;
 
-    if(mbedtls_mpi_read_binary(&ps, s, s_len) != 0)
+    if(mbedtls_mpi_read_binary(&ps, s, s_len))
         goto cleanup;
 
     switch(_libssh2_ecdsa_get_curve_type(ctx)) {
@@ -936,15 +1169,23 @@ _libssh2_mbedtls_parse_eckey(libssh2_ecdsa_ctx **ctx,
 
     pwd_len = pwd ? strlen((const char *) pwd) : 0;
 
-    if(mbedtls_pk_parse_key(pkey, data, data_len, pwd, pwd_len) != 0)
+#if MBEDTLS_VERSION_NUMBER >= 0x03000000
+    if(mbedtls_pk_parse_key(pkey, data, data_len, pwd, pwd_len,
+                            mbedtls_ctr_drbg_random,
+                            &_libssh2_mbedtls_ctr_drbg))
+
+        goto failed;
+#else
+    if(mbedtls_pk_parse_key(pkey, data, data_len, pwd, pwd_len))
         goto failed;
+#endif
 
     if(mbedtls_pk_get_type(pkey) != MBEDTLS_PK_ECKEY)
         goto failed;
 
     *ctx = LIBSSH2_ALLOC(session, sizeof(libssh2_ecdsa_ctx));
 
-    if(*ctx == NULL)
+    if(!*ctx)
         goto failed;
 
     mbedtls_ecdsa_init(*ctx);
@@ -975,45 +1216,50 @@ _libssh2_mbedtls_parse_openssh_key(libssh2_ecdsa_ctx **ctx,
 
     if(_libssh2_openssh_pem_parse_memory(session, pwd,
                                          (const char *)data, data_len,
-                                         &decrypted) != 0)
+                                         &decrypted))
         goto failed;
 
-    if(_libssh2_get_string(decrypted, &name, NULL) != 0)
+    if(_libssh2_get_string(decrypted, &name, NULL))
         goto failed;
 
     if(_libssh2_mbedtls_ecdsa_curve_type_from_name((const char *)name,
-                                                   &type) != 0)
+                                                   &type))
         goto failed;
 
-    if(_libssh2_get_string(decrypted, &curve, &curvelen) != 0)
+    if(_libssh2_get_string(decrypted, &curve, &curvelen))
         goto failed;
 
-    if(_libssh2_get_string(decrypted, &point_buf, &pointlen) != 0)
+    if(_libssh2_get_string(decrypted, &point_buf, &pointlen))
         goto failed;
 
-    if(_libssh2_get_bignum_bytes(decrypted, &exponent, &exponentlen) != 0)
+    if(_libssh2_get_bignum_bytes(decrypted, &exponent, &exponentlen))
         goto failed;
 
     *ctx = LIBSSH2_ALLOC(session, sizeof(libssh2_ecdsa_ctx));
 
-    if(*ctx == NULL)
+    if(!*ctx)
         goto failed;
 
     mbedtls_ecdsa_init(*ctx);
 
-    if(mbedtls_ecp_group_load(&(*ctx)->grp, (mbedtls_ecp_group_id)type) != 0)
+    if(mbedtls_ecp_group_load(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                              (mbedtls_ecp_group_id)type))
         goto failed;
 
-    if(mbedtls_mpi_read_binary(&(*ctx)->d, exponent, exponentlen) != 0)
+    if(mbedtls_mpi_read_binary(&(*ctx)->MBEDTLS_PRIVATE(d),
+                               exponent, exponentlen))
         goto failed;
 
-    if(mbedtls_ecp_mul(&(*ctx)->grp, &(*ctx)->Q,
-                       &(*ctx)->d, &(*ctx)->grp.G,
+    if(mbedtls_ecp_mul(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                       &(*ctx)->MBEDTLS_PRIVATE(Q),
+                       &(*ctx)->MBEDTLS_PRIVATE(d),
+                       &(*ctx)->MBEDTLS_PRIVATE(grp).G,
                        mbedtls_ctr_drbg_random,
-                       &_libssh2_mbedtls_ctr_drbg) != 0)
+                       &_libssh2_mbedtls_ctr_drbg))
         goto failed;
 
-    if(mbedtls_ecp_check_privkey(&(*ctx)->grp, &(*ctx)->d) == 0)
+    if(mbedtls_ecp_check_privkey(&(*ctx)->MBEDTLS_PRIVATE(grp),
+                                 &(*ctx)->MBEDTLS_PRIVATE(d)) == 0)
         goto cleanup;
 
 failed:
@@ -1027,9 +1273,14 @@ _libssh2_mbedtls_parse_openssh_key(libssh2_ecdsa_ctx **ctx,
         _libssh2_string_buf_free(session, decrypted);
     }
 
-    return (*ctx == NULL) ? -1 : 0;
+    return *ctx ? 0 : -1;
 }
 
+/* Force-expose internal mbedTLS function */
+#if MBEDTLS_VERSION_NUMBER >= 0x03060000
+int mbedtls_pk_load_file(const char *path, unsigned char **buf, size_t *n);
+#endif
+
 /* _libssh2_ecdsa_new_private
  *
  * Creates a new private key given a file path and password
@@ -1043,14 +1294,15 @@ _libssh2_mbedtls_ecdsa_new_private(libssh2_ecdsa_ctx **ctx,
                                    const unsigned char *pwd)
 {
     mbedtls_pk_context pkey;
-    unsigned char *data;
-    size_t data_len;
-
-    if(mbedtls_pk_load_file(filename, &data, &data_len) != 0)
-        goto cleanup;
+    unsigned char *data = NULL;
+    size_t data_len = 0;
 
     mbedtls_pk_init(&pkey);
 
+    /* FIXME: Reimplement this functionality via a public API. */
+    if(mbedtls_pk_load_file(filename, &data, &data_len))
+        goto cleanup;
+
     if(_libssh2_mbedtls_parse_eckey(ctx, &pkey, session,
                                     data, data_len, pwd) == 0)
         goto cleanup;
@@ -1063,7 +1315,7 @@ _libssh2_mbedtls_ecdsa_new_private(libssh2_ecdsa_ctx **ctx,
 
     _libssh2_mbedtls_safe_free(data, data_len);
 
-    return (*ctx == NULL) ? -1 : 0;
+    return *ctx ? 0 : -1;
 }
 
 /* _libssh2_ecdsa_new_private
@@ -1086,7 +1338,7 @@ _libssh2_mbedtls_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx **ctx,
 
     ntdata = LIBSSH2_ALLOC(session, data_len + 1);
 
-    if(ntdata == NULL)
+    if(!ntdata)
         goto cleanup;
 
     memcpy(ntdata, data, data_len);
@@ -1104,7 +1356,7 @@ _libssh2_mbedtls_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx **ctx,
 
     _libssh2_mbedtls_safe_free(ntdata, data_len);
 
-    return (*ctx == NULL) ? -1 : 0;
+    return *ctx ? 0 : -1;
 }
 
 static unsigned char *
@@ -1113,6 +1365,7 @@ _libssh2_mbedtls_mpi_write_binary(unsigned char *buf,
                                   size_t bytes)
 {
     unsigned char *p = buf;
+    uint32_t size = (uint32_t)bytes;
 
     if(sizeof(&p) / sizeof(p[0]) < 4) {
         goto done;
@@ -1121,19 +1374,19 @@ _libssh2_mbedtls_mpi_write_binary(unsigned char *buf,
     p += 4;
     *p = 0;
 
-    if(bytes > 0) {
-        mbedtls_mpi_write_binary(mpi, p + 1, bytes - 1);
+    if(size > 0) {
+        mbedtls_mpi_write_binary(mpi, p + 1, size - 1);
     }
 
-    if(bytes > 0 && !(*(p + 1) & 0x80)) {
-        memmove(p, p + 1, --bytes);
+    if(size > 0 && !(*(p + 1) & 0x80)) {
+        memmove(p, p + 1, --size);
     }
 
-    _libssh2_htonu32(p - 4, bytes);
+    _libssh2_htonu32(p - 4, size);
 
 done:
 
-    return p + bytes;
+    return p + size;
 }
 
 /* _libssh2_ecdsa_sign
@@ -1146,7 +1399,7 @@ int
 _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
                             libssh2_ecdsa_ctx *ctx,
                             const unsigned char *hash,
-                            unsigned long hash_len,
+                            size_t hash_len,
                             unsigned char **sign,
                             size_t *sign_len)
 {
@@ -1157,10 +1410,11 @@ _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
     mbedtls_mpi_init(&pr);
     mbedtls_mpi_init(&ps);
 
-    if(mbedtls_ecdsa_sign(&ctx->grp, &pr, &ps, &ctx->d,
+    if(mbedtls_ecdsa_sign(&ctx->MBEDTLS_PRIVATE(grp), &pr, &ps,
+                          &ctx->MBEDTLS_PRIVATE(d),
                           hash, hash_len,
                           mbedtls_ctr_drbg_random,
-                          &_libssh2_mbedtls_ctr_drbg) != 0)
+                          &_libssh2_mbedtls_ctr_drbg))
         goto cleanup;
 
     r_len = mbedtls_mpi_size(&pr) + 1;
@@ -1169,7 +1423,7 @@ _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
 
     tmp_sign = LIBSSH2_CALLOC(session, tmp_sign_len);
 
-    if(tmp_sign == NULL)
+    if(!tmp_sign)
         goto cleanup;
 
     sp = tmp_sign;
@@ -1180,7 +1434,7 @@ _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
 
     *sign = LIBSSH2_CALLOC(session, *sign_len);
 
-    if(*sign == NULL)
+    if(!*sign)
         goto cleanup;
 
     memcpy(*sign, tmp_sign, *sign_len);
@@ -1192,7 +1446,7 @@ _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
 
     _libssh2_mbedtls_safe_free(tmp_sign, tmp_sign_len);
 
-    return (*sign == NULL) ? -1 : 0;
+    return *sign ? 0 : -1;
 }
 
 /* _libssh2_ecdsa_get_curve_type
@@ -1204,7 +1458,7 @@ _libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
 libssh2_curve_type
 _libssh2_mbedtls_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ctx)
 {
-    return (libssh2_curve_type) ctx->grp.id;
+    return (libssh2_curve_type) ctx->MBEDTLS_PRIVATE(grp).id;
 }
 
 /* _libssh2_ecdsa_curve_type_from_name
@@ -1220,7 +1474,7 @@ _libssh2_mbedtls_ecdsa_curve_type_from_name(const char *name,
     int ret = 0;
     libssh2_curve_type type;
 
-    if(name == NULL || strlen(name) != 19)
+    if(!name || strlen(name) != 19)
         return -1;
 
     if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
@@ -1246,6 +1500,34 @@ _libssh2_mbedtls_ecdsa_free(libssh2_ecdsa_ctx *ctx)
     mbedtls_ecdsa_free(ctx);
     mbedtls_free(ctx);
 }
-
 #endif /* LIBSSH2_ECDSA */
-#endif /* LIBSSH2_MBEDTLS */
+
+
+/* _libssh2_supported_key_sign_algorithms
+ *
+ * Return supported key hash algo upgrades, see crypto.h
+ *
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len)
+{
+    (void)session;
+
+#if LIBSSH2_RSA_SHA2
+    if(key_method_len == 7 &&
+       memcmp(key_method, "ssh-rsa", key_method_len) == 0) {
+        return "rsa-sha2-512,rsa-sha2-256"
+#if LIBSSH2_RSA_SHA1
+            ",ssh-rsa"
+#endif
+            ;
+    }
+#endif
+
+    return NULL;
+}
+
+#endif /* LIBSSH2_CRYPTO_C */
diff --git a/libssh2/src/mbedtls.h b/libssh2/src/mbedtls.h
index 671932c5..b1e6726e 100644
--- a/libssh2/src/mbedtls.h
+++ b/libssh2/src/mbedtls.h
@@ -1,6 +1,6 @@
-#ifndef __LIBSSH2_MBEDTLS_H
-#define __LIBSSH2_MBEDTLS_H
-/* Copyright (c) 2016, Art <https://github.com/wildart>
+#ifndef LIBSSH2_MBEDTLS_H
+#define LIBSSH2_MBEDTLS_H
+/* Copyright (C) Art <https://github.com/wildart>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,11 +35,28 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include <stdlib.h>
-#include <string.h>
+#define LIBSSH2_CRYPTO_ENGINE libssh2_mbedtls
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+/* mbedTLS (as of v3.5.1) has a `[-Werror=arith-conversion]`
+   warning in its public headers. */
+#if !defined(__clang__) && __GNUC__ >= 10
+#pragma GCC diagnostic ignored "-Warith-conversion"
+#endif
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+/* mbedTLS (as of v3.5.1) has a duplicate function declaration
+   in its public headers. Disable the warning that detects it. */
+#pragma GCC diagnostic ignored "-Wredundant-decls"
+#endif
 
+#include <mbedtls/version.h>
 #include <mbedtls/platform.h>
 #include <mbedtls/md.h>
 #include <mbedtls/rsa.h>
@@ -56,6 +73,10 @@
 #include <mbedtls/pk.h>
 #include <mbedtls/error.h>
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 /* Define which features are supported. */
 #define LIBSSH2_MD5             1
 
@@ -63,14 +84,25 @@
 #define LIBSSH2_HMAC_SHA256     1
 #define LIBSSH2_HMAC_SHA512     1
 
-#define LIBSSH2_AES             1
+#define LIBSSH2_AES_CBC         1
 #define LIBSSH2_AES_CTR         1
-#define LIBSSH2_BLOWFISH        1
-#define LIBSSH2_RC4             1
+#define LIBSSH2_AES_GCM         0
+#ifdef MBEDTLS_CIPHER_BLOWFISH_CBC
+# define LIBSSH2_BLOWFISH       1
+#else
+# define LIBSSH2_BLOWFISH       0
+#endif
+#ifdef MBEDTLS_CIPHER_ARC4_128
+# define LIBSSH2_RC4            1
+#else
+# define LIBSSH2_RC4            0
+#endif
 #define LIBSSH2_CAST            0
 #define LIBSSH2_3DES            1
 
 #define LIBSSH2_RSA             1
+#define LIBSSH2_RSA_SHA1        1
+#define LIBSSH2_RSA_SHA2        1
 #define LIBSSH2_DSA             0
 #ifdef MBEDTLS_ECDSA_C
 # define LIBSSH2_ECDSA          1
@@ -79,7 +111,11 @@
 #endif
 #define LIBSSH2_ED25519         0
 
+#include "crypto_config.h"
+
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define MD5_DIGEST_LENGTH      16
+#endif
 #define SHA_DIGEST_LENGTH      20
 #define SHA256_DIGEST_LENGTH   32
 #define SHA384_DIGEST_LENGTH   48
@@ -94,12 +130,12 @@
  */
 
 #define libssh2_crypto_init() \
-  _libssh2_mbedtls_init()
+    _libssh2_mbedtls_init()
 #define libssh2_crypto_exit() \
-  _libssh2_mbedtls_free()
+    _libssh2_mbedtls_free()
 
 #define _libssh2_random(buf, len) \
-  _libssh2_mbedtls_random(buf, len)
+    _libssh2_mbedtls_random(buf, len)
 
 #define libssh2_prepare_iovec(vec, len)  /* Empty. */
 
@@ -111,27 +147,6 @@
 
 #define libssh2_hmac_ctx    mbedtls_md_context_t
 
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_cleanup(pctx) \
-  mbedtls_md_free(pctx)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  mbedtls_md_hmac_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, hash) \
-  mbedtls_md_hmac_finish(&ctx, hash)
-
-#define libssh2_hmac_sha1_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA1, key, keylen)
-#define libssh2_hmac_md5_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_MD5, key, keylen)
-#define libssh2_hmac_ripemd160_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_RIPEMD160, key, keylen)
-#define libssh2_hmac_sha256_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA256, key, keylen)
-#define libssh2_hmac_sha384_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA384, key, keylen)
-#define libssh2_hmac_sha512_init(pctx, key, keylen) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA512, key, keylen)
-
 
 /*******************************************************************/
 /*
@@ -141,13 +156,14 @@
 #define libssh2_sha1_ctx      mbedtls_md_context_t
 
 #define libssh2_sha1_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA1, NULL, 0)
+    _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA1, NULL, 0)
 #define libssh2_sha1_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
+    (mbedtls_md_update(&ctx, (const unsigned char *) data, datalen) == 0)
 #define libssh2_sha1_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
+    _libssh2_mbedtls_hash_final(&ctx, hash)
 #define libssh2_sha1(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA1, hash)
+    _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA1, hash)
+
 
 /*******************************************************************/
 /*
@@ -157,13 +173,13 @@
 #define libssh2_sha256_ctx      mbedtls_md_context_t
 
 #define libssh2_sha256_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA256, NULL, 0)
+    _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA256, NULL, 0)
 #define libssh2_sha256_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
+    (mbedtls_md_update(&ctx, (const unsigned char *) data, datalen) == 0)
 #define libssh2_sha256_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
+    _libssh2_mbedtls_hash_final(&ctx, hash)
 #define libssh2_sha256(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA256, hash)
+    _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA256, hash)
 
 
 /*******************************************************************/
@@ -174,13 +190,13 @@
 #define libssh2_sha384_ctx      mbedtls_md_context_t
 
 #define libssh2_sha384_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA384, NULL, 0)
+    _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA384, NULL, 0)
 #define libssh2_sha384_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
+    (mbedtls_md_update(&ctx, (const unsigned char *) data, datalen) == 0)
 #define libssh2_sha384_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
+    _libssh2_mbedtls_hash_final(&ctx, hash)
 #define libssh2_sha384(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA384, hash)
+    _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA384, hash)
 
 
 /*******************************************************************/
@@ -191,13 +207,13 @@
 #define libssh2_sha512_ctx      mbedtls_md_context_t
 
 #define libssh2_sha512_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA512, NULL, 0)
+    _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_SHA512, NULL, 0)
 #define libssh2_sha512_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
+    (mbedtls_md_update(&ctx, (const unsigned char *) data, datalen) == 0)
 #define libssh2_sha512_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
+    _libssh2_mbedtls_hash_final(&ctx, hash)
 #define libssh2_sha512(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA512, hash)
+    _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_SHA512, hash)
 
 
 /*******************************************************************/
@@ -205,17 +221,16 @@
  * mbedTLS backend: MD5 functions
  */
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define libssh2_md5_ctx      mbedtls_md_context_t
 
 #define libssh2_md5_init(pctx) \
-  _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_MD5, NULL, 0)
+    _libssh2_mbedtls_hash_init(pctx, MBEDTLS_MD_MD5, NULL, 0)
 #define libssh2_md5_update(ctx, data, datalen) \
-  mbedtls_md_update(&ctx, (unsigned char *) data, datalen)
+    (mbedtls_md_update(&ctx, (const unsigned char *) data, datalen) == 0)
 #define libssh2_md5_final(ctx, hash) \
-  _libssh2_mbedtls_hash_final(&ctx, hash)
-#define libssh2_md5(data, datalen, hash) \
-  _libssh2_mbedtls_hash(data, datalen, MBEDTLS_MD_MD5, hash)
-
+    _libssh2_mbedtls_hash_final(&ctx, hash)
+#endif
 
 /*******************************************************************/
 /*
@@ -227,26 +242,33 @@
 #define _libssh2_rsa_new(rsactx, e, e_len, n, n_len, \
                          d, d_len, p, p_len, q, q_len, \
                          e1, e1_len, e2, e2_len, c, c_len) \
-  _libssh2_mbedtls_rsa_new(rsactx, e, e_len, n, n_len, \
-                          d, d_len, p, p_len, q, q_len, \
-                          e1, e1_len, e2, e2_len, c, c_len)
+    _libssh2_mbedtls_rsa_new(rsactx, e, e_len, n, n_len, \
+                             d, d_len, p, p_len, q, q_len, \
+                             e1, e1_len, e2, e2_len, c, c_len)
 
 #define _libssh2_rsa_new_private(rsactx, s, filename, passphrase) \
-  _libssh2_mbedtls_rsa_new_private(rsactx, s, filename, passphrase)
+    _libssh2_mbedtls_rsa_new_private(rsactx, s, filename, passphrase)
 
 #define _libssh2_rsa_new_private_frommemory(rsactx, s, filedata, \
                                             filedata_len, passphrase) \
-  _libssh2_mbedtls_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                             filedata_len, passphrase)
+    _libssh2_mbedtls_rsa_new_private_frommemory(rsactx, s, filedata, \
+                                                filedata_len, passphrase)
 
 #define _libssh2_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len) \
-  _libssh2_mbedtls_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
+    _libssh2_mbedtls_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
+
+#define _libssh2_rsa_sha2_sign(s, rsactx, hash, hash_len, sig, sig_len) \
+    _libssh2_mbedtls_rsa_sha2_sign(s, rsactx, hash, hash_len, sig, sig_len)
+
 
 #define _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len) \
-  _libssh2_mbedtls_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
+    _libssh2_mbedtls_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
+
+#define _libssh2_rsa_sha2_verify(rsactx, hash_len, sig, sig_len, m, m_len) \
+    _libssh2_mbedtls_rsa_sha2_verify(rsactx, hash_len, sig, sig_len, m, m_len)
 
 #define _libssh2_rsa_free(rsactx) \
-  _libssh2_mbedtls_rsa_free(rsactx)
+    _libssh2_mbedtls_rsa_free(rsactx)
 
 
 /*******************************************************************/
@@ -291,34 +313,34 @@ typedef enum {
 
 #define _libssh2_ecdsa_create_key(session, privkey, pubkey_octal, \
                                   pubkey_octal_len, curve) \
-  _libssh2_mbedtls_ecdsa_create_key(session, privkey, pubkey_octal, \
-                                    pubkey_octal_len, curve)
+    _libssh2_mbedtls_ecdsa_create_key(session, privkey, pubkey_octal, \
+                                      pubkey_octal_len, curve)
 
 #define _libssh2_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve) \
-  _libssh2_mbedtls_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve)
+    _libssh2_mbedtls_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve)
 
 #define _libssh2_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len) \
-  _libssh2_mbedtls_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len)
+    _libssh2_mbedtls_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len)
 
 #define _libssh2_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len) \
-  _libssh2_mbedtls_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len)
+    _libssh2_mbedtls_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len)
 
 #define _libssh2_ecdsa_new_private(ctx, session, filename, passphrase) \
-  _libssh2_mbedtls_ecdsa_new_private(ctx, session, filename, passphrase)
+    _libssh2_mbedtls_ecdsa_new_private(ctx, session, filename, passphrase)
 
 #define _libssh2_ecdsa_new_private_frommemory(ctx, session, filedata, \
                                               filedata_len, passphrase) \
-  _libssh2_mbedtls_ecdsa_new_private_frommemory(ctx, session, filedata, \
-                                                filedata_len, passphrase)
+    _libssh2_mbedtls_ecdsa_new_private_frommemory(ctx, session, filedata, \
+                                                  filedata_len, passphrase)
 
 #define _libssh2_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len) \
-  _libssh2_mbedtls_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len)
+    _libssh2_mbedtls_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len)
 
 #define _libssh2_ecdsa_get_curve_type(ctx) \
-  _libssh2_mbedtls_ecdsa_get_curve_type(ctx)
+    _libssh2_mbedtls_ecdsa_get_curve_type(ctx)
 
 #define _libssh2_ecdsa_free(ctx) \
-  _libssh2_mbedtls_ecdsa_free(ctx)
+    _libssh2_mbedtls_ecdsa_free(ctx)
 
 #endif /* LIBSSH2_ECDSA */
 
@@ -329,11 +351,15 @@ typedef enum {
  */
 
 #define _libssh2_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw) \
-  _libssh2_mbedtls_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
+    _libssh2_mbedtls_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
 #define _libssh2_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                     pk, pk_len, pw) \
-  _libssh2_mbedtls_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                      pk, pk_len, pw)
+                                        pk, pk_len, pw) \
+    _libssh2_mbedtls_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
+                                            pk, pk_len, pw)
+#define _libssh2_sk_pub_keyfilememory(s, m, m_len, p, p_len, alg, app, \
+                                      f, kh, kh_len, pk, pk_len, pw) \
+    _libssh2_mbedtls_sk_pub_keyfilememory(s, m, m_len, p, p_len, alg, app, \
+                                          f, kh, kh_len, pk, pk_len, pw)
 
 
 /*******************************************************************/
@@ -351,10 +377,14 @@ typedef enum {
 #define _libssh2_cipher_aes256    MBEDTLS_CIPHER_AES_256_CBC
 #define _libssh2_cipher_aes192    MBEDTLS_CIPHER_AES_192_CBC
 #define _libssh2_cipher_aes128    MBEDTLS_CIPHER_AES_128_CBC
+#ifdef MBEDTLS_CIPHER_BLOWFISH_CBC
 #define _libssh2_cipher_blowfish  MBEDTLS_CIPHER_BLOWFISH_CBC
+#endif
+#ifdef MBEDTLS_CIPHER_ARC4_128
 #define _libssh2_cipher_arcfour   MBEDTLS_CIPHER_ARC4_128
-#define _libssh2_cipher_cast5     MBEDTLS_CIPHER_NULL
+#endif
 #define _libssh2_cipher_3des      MBEDTLS_CIPHER_DES_EDE3_CBC
+#define _libssh2_cipher_chacha20  MBEDTLS_CIPHER_CHACHA20_POLY1305
 
 
 /*******************************************************************/
@@ -363,11 +393,11 @@ typedef enum {
  */
 
 #define _libssh2_cipher_init(ctx, type, iv, secret, encrypt) \
-  _libssh2_mbedtls_cipher_init(ctx, type, iv, secret, encrypt)
-#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen) \
-  _libssh2_mbedtls_cipher_crypt(ctx, type, encrypt, block, blocklen)
+    _libssh2_mbedtls_cipher_init(ctx, type, iv, secret, encrypt)
+#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen, fl) \
+    _libssh2_mbedtls_cipher_crypt(ctx, type, encrypt, block, blocklen, fl)
 #define _libssh2_cipher_dtor(ctx) \
-  _libssh2_mbedtls_cipher_dtor(ctx)
+    _libssh2_mbedtls_cipher_dtor(ctx)
 
 
 /*******************************************************************/
@@ -382,21 +412,21 @@ typedef enum {
 #define _libssh2_bn mbedtls_mpi
 
 #define _libssh2_bn_init() \
-  _libssh2_mbedtls_bignum_init()
+    _libssh2_mbedtls_bignum_init()
 #define _libssh2_bn_init_from_bin() \
-  _libssh2_mbedtls_bignum_init()
+    _libssh2_mbedtls_bignum_init()
 #define _libssh2_bn_set_word(bn, word) \
-  mbedtls_mpi_lset(bn, word)
+    mbedtls_mpi_lset(bn, word)
 #define _libssh2_bn_from_bin(bn, len, bin) \
-  mbedtls_mpi_read_binary(bn, bin, len)
+    mbedtls_mpi_read_binary(bn, bin, len)
 #define _libssh2_bn_to_bin(bn, bin) \
-  mbedtls_mpi_write_binary(bn, bin, mbedtls_mpi_size(bn))
+    mbedtls_mpi_write_binary(bn, bin, mbedtls_mpi_size(bn))
 #define _libssh2_bn_bytes(bn) \
-  mbedtls_mpi_size(bn)
+    mbedtls_mpi_size(bn)
 #define _libssh2_bn_bits(bn) \
-  mbedtls_mpi_bitlen(bn)
+    mbedtls_mpi_bitlen(bn)
 #define _libssh2_bn_free(bn) \
-  _libssh2_mbedtls_bignum_free(bn)
+    _libssh2_mbedtls_bignum_free(bn)
 
 
 /*******************************************************************/
@@ -404,12 +434,20 @@ typedef enum {
  * mbedTLS backend: Diffie-Hellman support.
  */
 
+/* Default generate and safe prime sizes for
+   diffie-hellman-group-exchange-sha1 */
+#define LIBSSH2_DH_GEX_MINGROUP     2048
+#define LIBSSH2_DH_GEX_OPTGROUP     4096
+#define LIBSSH2_DH_GEX_MAXGROUP     8192
+
+#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
+
 #define _libssh2_dh_ctx mbedtls_mpi *
 #define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
 #define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
+    _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
 #define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
+    _libssh2_dh_secret(dhctx, secret, f, p)
 #define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
 
 
@@ -425,32 +463,20 @@ void
 _libssh2_mbedtls_free(void);
 
 int
-_libssh2_mbedtls_random(unsigned char *buf, int len);
+_libssh2_mbedtls_random(unsigned char *buf, size_t len);
 
-int
-_libssh2_mbedtls_cipher_init(_libssh2_cipher_ctx *ctx,
-                            _libssh2_cipher_type(type),
-                            unsigned char *iv,
-                            unsigned char *secret,
-                            int encrypt);
-int
-_libssh2_mbedtls_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(type),
-                             int encrypt,
-                             unsigned char *block,
-                             size_t blocklen);
 void
 _libssh2_mbedtls_cipher_dtor(_libssh2_cipher_ctx *ctx);
 
 int
 _libssh2_mbedtls_hash_init(mbedtls_md_context_t *ctx,
-                          mbedtls_md_type_t mdtype,
-                          const unsigned char *key, unsigned long keylen);
+                           mbedtls_md_type_t mdtype,
+                           const unsigned char *key, size_t keylen);
 
 int
 _libssh2_mbedtls_hash_final(mbedtls_md_context_t *ctx, unsigned char *hash);
 int
-_libssh2_mbedtls_hash(const unsigned char *data, unsigned long datalen,
+_libssh2_mbedtls_hash(const unsigned char *data, size_t datalen,
                       mbedtls_md_type_t mdtype, unsigned char *hash);
 
 _libssh2_bn *
@@ -459,110 +485,10 @@ _libssh2_mbedtls_bignum_init(void);
 void
 _libssh2_mbedtls_bignum_free(_libssh2_bn *bn);
 
-int
-_libssh2_mbedtls_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen);
-
-int
-_libssh2_mbedtls_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-
-int
-_libssh2_mbedtls_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_mbedtls_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_mbedtls_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len);
 void
 _libssh2_mbedtls_rsa_free(libssh2_rsa_ctx *rsa);
 
-int
-_libssh2_mbedtls_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase);
-int
-_libssh2_mbedtls_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase);
 #if LIBSSH2_ECDSA
-int
-_libssh2_mbedtls_ecdsa_create_key(LIBSSH2_SESSION *session,
-                                  _libssh2_ec_key **privkey,
-                                  unsigned char **pubkey_octal,
-                                  size_t *pubkey_octal_len,
-                                  libssh2_curve_type curve);
-int
-_libssh2_mbedtls_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx **ctx,
-                                                 const unsigned char *k,
-                                                 size_t k_len,
-                                                 libssh2_curve_type curve);
-int
-_libssh2_mbedtls_ecdh_gen_k(_libssh2_bn **k,
-                            _libssh2_ec_key *privkey,
-                            const unsigned char *server_pubkey,
-                            size_t server_pubkey_len);
-int
-_libssh2_mbedtls_ecdsa_verify(libssh2_ecdsa_ctx *ctx,
-                              const unsigned char *r, size_t r_len,
-                              const unsigned char *s, size_t s_len,
-                              const unsigned char *m, size_t m_len);
-int
-_libssh2_mbedtls_ecdsa_new_private(libssh2_ecdsa_ctx **ctx,
-                                  LIBSSH2_SESSION *session,
-                                  const char *filename,
-                                  const unsigned char *passphrase);
-int
-_libssh2_mbedtls_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx **ctx,
-                                              LIBSSH2_SESSION *session,
-                                              const char *filedata,
-                                              size_t filedata_len,
-                                              const unsigned char *passphrase);
-int
-_libssh2_mbedtls_ecdsa_sign(LIBSSH2_SESSION *session,
-                            libssh2_ecdsa_ctx *ctx,
-                            const unsigned char *hash,
-                            unsigned long hash_len,
-                            unsigned char **signature,
-                            size_t *signature_len);
 libssh2_curve_type
 _libssh2_mbedtls_ecdsa_key_get_curve_type(libssh2_ecdsa_ctx *ctx);
 int
@@ -572,15 +498,17 @@ void
 _libssh2_mbedtls_ecdsa_free(libssh2_ecdsa_ctx *ctx);
 #endif /* LIBSSH2_ECDSA */
 
+extern void
+_libssh2_init_aes_ctr(void);
 extern void
 _libssh2_dh_init(_libssh2_dh_ctx *dhctx);
 extern int
 _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
-                    _libssh2_bn *g, _libssh2_bn *p, int group_order);
+                     _libssh2_bn *g, _libssh2_bn *p, int group_order);
 extern int
 _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
-                  _libssh2_bn *f, _libssh2_bn *p);
+                   _libssh2_bn *f, _libssh2_bn *p);
 extern void
 _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
 
-#endif /* __LIBSSH2_MBEDTLS_H */
+#endif /* LIBSSH2_MBEDTLS_H */
diff --git a/libssh2/src/misc.c b/libssh2/src/misc.c
index 594b2d1f..6c28327c 100644
--- a/libssh2/src/misc.c
+++ b/libssh2/src/misc.c
@@ -1,6 +1,6 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2019 by Daniel Stenberg
- * Copyright (c) 2010  Simon Josefsson
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,43 +35,65 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include "misc.h"
-#include "blf.h"
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
+#include <errno.h>
+#include <assert.h>
 
-#if defined(HAVE_DECL_SECUREZEROMEMORY) && HAVE_DECL_SECUREZEROMEMORY
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
+#ifdef _WIN32
+/* Force parameter type. */
+#define recv(s, b, l, f)  recv((s), (b), (int)(l), (f))
+#define send(s, b, l, f)  send((s), (b), (int)(l), (f))
 #endif
 
-#include <stdio.h>
-#include <errno.h>
+/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
+   We provide a safe wrapper if snprintf not found */
+#ifdef LIBSSH2_SNPRINTF
+#include <stdarg.h>
+
+/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
+* then assume cp is pointing to a null char and do nothing. Returns number
+* number of chars placed in cp excluding the trailing null char. So for
+* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
+* <= 0 the return value is 0 (and no chars are written to cp). */
+int _libssh2_snprintf(char *cp, size_t cp_max_len, const char *fmt, ...)
+{
+    va_list args;
+    int n;
+
+    if(cp_max_len < 2)
+        return 0;
+    va_start(args, fmt);
+    n = vsnprintf(cp, cp_max_len, fmt, args);
+    va_end(args);
+    return (n < (int)cp_max_len) ? n : (int)(cp_max_len - 1);
+}
+#endif
 
 int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode,
                          const char *errmsg, int errflags)
 {
+    if(!session) {
+        if(errmsg)
+            fprintf(stderr, "Session is NULL, error: %s\n", errmsg);
+        return errcode;
+    }
+
     if(session->err_flags & LIBSSH2_ERR_FLAG_DUP)
         LIBSSH2_FREE(session, (char *)session->err_msg);
 
     session->err_code = errcode;
     session->err_flags = 0;
 
-    if((errmsg != NULL) && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
+    if(errmsg && ((errflags & LIBSSH2_ERR_FLAG_DUP) != 0)) {
         size_t len = strlen(errmsg);
         char *copy = LIBSSH2_ALLOC(session, len + 1);
         if(copy) {
@@ -91,8 +113,8 @@ int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode,
         /* if this is EAGAIN and we're in non-blocking mode, don't generate
            a debug output for this */
         return errcode;
-    _libssh2_debug(session, LIBSSH2_TRACE_ERROR, "%d - %s", session->err_code,
-                   session->err_msg);
+    _libssh2_debug((session, LIBSSH2_TRACE_ERROR, "%d - %s", session->err_code,
+                   session->err_msg));
 #endif
 
     return errcode;
@@ -103,8 +125,8 @@ int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg)
     return _libssh2_error_flags(session, errcode, errmsg, 0);
 }
 
-#ifdef WIN32
-static int wsa2errno(void)
+#ifdef _WIN32
+int _libssh2_wsa2errno(void)
 {
     switch(WSAGetLastError()) {
     case WSAEWOULDBLOCK:
@@ -135,26 +157,32 @@ _libssh2_recv(libssh2_socket_t sock, void *buffer, size_t length,
 {
     ssize_t rc;
 
-    (void) abstract;
+    (void)abstract;
 
     rc = recv(sock, buffer, length, flags);
-#ifdef WIN32
-    if(rc < 0)
-        return -wsa2errno();
-#else
     if(rc < 0) {
+        int err;
+#ifdef _WIN32
+        err = _libssh2_wsa2errno();
+#else
+        err = errno;
+#endif
+        /* Profiling tools that use SIGPROF can cause EINTR responses.
+           recv() does not modify its arguments when it returns EINTR,
+           but there may be data waiting, so the caller should try again */
+        if(err == EINTR)
+            return -EAGAIN;
         /* Sometimes the first recv() function call sets errno to ENOENT on
            Solaris and HP-UX */
-        if(errno == ENOENT)
+        if(err == ENOENT)
             return -EAGAIN;
 #ifdef EWOULDBLOCK /* For VMS and other special unixes */
-        else if(errno == EWOULDBLOCK)
-          return -EAGAIN;
+        else if(err == EWOULDBLOCK)
+            return -EAGAIN;
 #endif
         else
-            return -errno;
+            return -err;
     }
-#endif
     return rc;
 }
 
@@ -168,33 +196,39 @@ _libssh2_send(libssh2_socket_t sock, const void *buffer, size_t length,
 {
     ssize_t rc;
 
-    (void) abstract;
+    (void)abstract;
 
     rc = send(sock, buffer, length, flags);
-#ifdef WIN32
-    if(rc < 0)
-        return -wsa2errno();
-#else
     if(rc < 0) {
+        int err;
+#ifdef _WIN32
+        err = _libssh2_wsa2errno();
+#else
+        err = errno;
+#endif
+        /* Profiling tools that use SIGPROF can cause EINTR responses.
+           send() is defined as not yet sending any data when it returns EINTR,
+           so the caller should try again */
+        if(err == EINTR)
+            return -EAGAIN;
 #ifdef EWOULDBLOCK /* For VMS and other special unixes */
-      if(errno == EWOULDBLOCK)
-        return -EAGAIN;
+        if(err == EWOULDBLOCK)
+            return -EAGAIN;
 #endif
-      return -errno;
+        return -err;
     }
-#endif
     return rc;
 }
 
 /* libssh2_ntohu32
  */
-unsigned int
+uint32_t
 _libssh2_ntohu32(const unsigned char *buf)
 {
-    return (((unsigned int)buf[0] << 24)
-           | ((unsigned int)buf[1] << 16)
-           | ((unsigned int)buf[2] << 8)
-           | ((unsigned int)buf[3]));
+    return ((uint32_t)buf[0] << 24)
+         | ((uint32_t)buf[1] << 16)
+         | ((uint32_t)buf[2] << 8)
+         | ((uint32_t)buf[3]);
 }
 
 
@@ -203,14 +237,14 @@ _libssh2_ntohu32(const unsigned char *buf)
 libssh2_uint64_t
 _libssh2_ntohu64(const unsigned char *buf)
 {
-    unsigned long msl, lsl;
-
-    msl = ((libssh2_uint64_t)buf[0] << 24) | ((libssh2_uint64_t)buf[1] << 16)
-        | ((libssh2_uint64_t)buf[2] << 8) | (libssh2_uint64_t)buf[3];
-    lsl = ((libssh2_uint64_t)buf[4] << 24) | ((libssh2_uint64_t)buf[5] << 16)
-        | ((libssh2_uint64_t)buf[6] << 8) | (libssh2_uint64_t)buf[7];
-
-    return ((libssh2_uint64_t)msl <<32) | lsl;
+    return ((libssh2_uint64_t)buf[0] << 56)
+         | ((libssh2_uint64_t)buf[1] << 48)
+         | ((libssh2_uint64_t)buf[2] << 40)
+         | ((libssh2_uint64_t)buf[3] << 32)
+         | ((libssh2_uint64_t)buf[4] << 24)
+         | ((libssh2_uint64_t)buf[5] << 16)
+         | ((libssh2_uint64_t)buf[6] <<  8)
+         | ((libssh2_uint64_t)buf[7]);
 }
 
 /* _libssh2_htonu32
@@ -218,7 +252,7 @@ _libssh2_ntohu64(const unsigned char *buf)
 void
 _libssh2_htonu32(unsigned char *buf, uint32_t value)
 {
-    buf[0] = (value >> 24) & 0xFF;
+    buf[0] = (unsigned char)((value >> 24) & 0xFF);
     buf[1] = (value >> 16) & 0xFF;
     buf[2] = (value >> 8) & 0xFF;
     buf[3] = value & 0xFF;
@@ -232,15 +266,70 @@ void _libssh2_store_u32(unsigned char **buf, uint32_t value)
     *buf += sizeof(uint32_t);
 }
 
+/* _libssh2_store_u64
+ */
+void _libssh2_store_u64(unsigned char **buf, libssh2_uint64_t value)
+{
+    unsigned char *ptr = *buf;
+
+    ptr[0] = (unsigned char)((value >> 56) & 0xFF);
+    ptr[1] = (unsigned char)((value >> 48) & 0xFF);
+    ptr[2] = (unsigned char)((value >> 40) & 0xFF);
+    ptr[3] = (unsigned char)((value >> 32) & 0xFF);
+    ptr[4] = (unsigned char)((value >> 24) & 0xFF);
+    ptr[5] = (unsigned char)((value >> 16) & 0xFF);
+    ptr[6] = (unsigned char)((value >> 8) & 0xFF);
+    ptr[7] = (unsigned char)(value & 0xFF);
+
+    *buf += sizeof(libssh2_uint64_t);
+}
+
 /* _libssh2_store_str
  */
-void _libssh2_store_str(unsigned char **buf, const char *str, size_t len)
+int _libssh2_store_str(unsigned char **buf, const char *str, size_t len)
 {
-    _libssh2_store_u32(buf, (uint32_t)len);
-    if(len) {
-        memcpy(*buf, str, len);
-        *buf += len;
+    uint32_t len_stored = (uint32_t)len;
+
+    _libssh2_store_u32(buf, len_stored);
+    if(len_stored) {
+        memcpy(*buf, str, len_stored);
+        *buf += len_stored;
     }
+
+    assert(len_stored == len);
+    return len_stored == len;
+}
+
+/* _libssh2_store_bignum2_bytes
+ */
+int _libssh2_store_bignum2_bytes(unsigned char **buf,
+                                 const unsigned char *bytes,
+                                 size_t len)
+{
+    uint32_t len_stored;
+    uint32_t extraByte;
+    const unsigned char *p;
+
+    for(p = bytes; len > 0 && *p == 0; --len, ++p) {}
+
+    extraByte = (len > 0 && (p[0] & 0x80) != 0);
+    len_stored = (uint32_t)len;
+    if(extraByte && len_stored == UINT32_MAX)
+        len_stored--;
+    _libssh2_store_u32(buf, len_stored + extraByte);
+
+    if(extraByte) {
+        *buf[0] = 0;
+        *buf += 1;
+    }
+
+    if(len_stored) {
+        memcpy(*buf, p, len_stored);
+        *buf += len_stored;
+    }
+
+    assert(len_stored == len);
+    return len_stored == len;
 }
 
 /* Base64 Conversion */
@@ -266,26 +355,46 @@ static const short base64_reverse_table[256] = {
 
 /* libssh2_base64_decode
  *
- * Decode a base64 chunk and store it into a newly alloc'd buffer
+ * Legacy public function. DEPRECATED.
  */
 LIBSSH2_API int
 libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
                       unsigned int *datalen, const char *src,
                       unsigned int src_len)
 {
-    unsigned char *s, *d;
+    int rc;
+    size_t dlen;
+
+    rc = _libssh2_base64_decode(session, data, &dlen, src, src_len);
+
+    if(datalen)
+        *datalen = (unsigned int)dlen;
+
+    return rc;
+}
+
+/* _libssh2_base64_decode
+ *
+ * Decode a base64 chunk and store it into a newly alloc'd buffer
+ */
+int _libssh2_base64_decode(LIBSSH2_SESSION *session,
+                           char **data, size_t *datalen,
+                           const char *src, size_t src_len)
+{
+    unsigned char *d;
+    const char *s;
     short v;
-    int i = 0, len = 0;
+    ssize_t i = 0, len = 0;
 
-    *data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1);
+    *data = LIBSSH2_ALLOC(session, ((src_len / 4) * 3) + 1);
     d = (unsigned char *) *data;
     if(!d) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory for base64 decoding");
     }
 
-    for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) {
-        v = base64_reverse_table[*s];
+    for(s = src; s < (src + src_len); s++) {
+        v = base64_reverse_table[(unsigned char)*s];
         if(v < 0)
             continue;
         switch(i % 4) {
@@ -293,15 +402,15 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
             d[len] = (unsigned char)(v << 2);
             break;
         case 1:
-            d[len++] |= v >> 4;
+            d[len++] |= (unsigned char)(v >> 4);
             d[len] = (unsigned char)(v << 4);
             break;
         case 2:
-            d[len++] |= v >> 2;
+            d[len++] |= (unsigned char)(v >> 2);
             d[len] = (unsigned char)(v << 6);
             break;
         case 3:
-            d[len++] |= v;
+            d[len++] |= (unsigned char)v;
             break;
         }
         i++;
@@ -320,10 +429,10 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
 
 /* ---- Base64 Encoding/Decoding Table --- */
 static const char table64[]=
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /*
- * _libssh2_base64_encode()
+ * _libssh2_base64_encode
  *
  * Returns the length of the newly created base64 string. The third argument
  * is a pointer to an allocated area holding the base64 data. If something
@@ -344,11 +453,11 @@ size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
     *outptr = NULL; /* set to NULL in case of failure before we reach the
                        end */
 
-    if(0 == insize)
+    if(insize == 0)
         insize = strlen(indata);
 
     base64data = output = LIBSSH2_ALLOC(session, insize * 4 / 3 + 4);
-    if(NULL == output)
+    if(!output)
         return 0;
 
     while(insize > 0) {
@@ -372,22 +481,22 @@ size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
 
         switch(inputparts) {
         case 1: /* only one byte read */
-            snprintf(output, 5, "%c%c==",
-                     table64[obuf[0]],
-                     table64[obuf[1]]);
+            output[0] = table64[obuf[0]];
+            output[1] = table64[obuf[1]];
+            output[2] = '=';
+            output[3] = '=';
             break;
         case 2: /* two bytes read */
-            snprintf(output, 5, "%c%c%c=",
-                     table64[obuf[0]],
-                     table64[obuf[1]],
-                     table64[obuf[2]]);
+            output[0] = table64[obuf[0]];
+            output[1] = table64[obuf[1]];
+            output[2] = table64[obuf[2]];
+            output[3] = '=';
             break;
         default:
-            snprintf(output, 5, "%c%c%c%c",
-                     table64[obuf[0]],
-                     table64[obuf[1]],
-                     table64[obuf[2]],
-                     table64[obuf[3]]);
+            output[0] = table64[obuf[0]];
+            output[1] = table64[obuf[1]];
+            output[2] = table64[obuf[2]];
+            output[3] = table64[obuf[3]];
             break;
         }
         output += 4;
@@ -425,13 +534,14 @@ libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
 }
 
 void
-_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
+_libssh2_debug_low(LIBSSH2_SESSION * session, int context, const char *format,
+                   ...)
 {
     char buffer[1536];
     int len, msglen, buflen = sizeof(buffer);
     va_list vargs;
     struct timeval now;
-    static int firstsec;
+    static long firstsec;
     static const char *const contexts[] = {
         "Unknown",
         "Transport",
@@ -461,7 +571,7 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
         }
     }
 
-    _libssh2_gettimeofday(&now, NULL);
+    gettimeofday(&now, NULL);
     if(!firstsec) {
         firstsec = now.tv_sec;
     }
@@ -492,8 +602,8 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
 LIBSSH2_API int
 libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
 {
-    (void) session;
-    (void) bitmask;
+    (void)session;
+    (void)bitmask;
     return 0;
 }
 
@@ -501,9 +611,9 @@ LIBSSH2_API int
 libssh2_trace_sethandler(LIBSSH2_SESSION *session, void *handler_context,
                          libssh2_trace_handler_func callback)
 {
-    (void) session;
-    (void) handler_context;
-    (void) callback;
+    (void)session;
+    (void)handler_context;
+    (void)callback;
     return 0;
 }
 #endif
@@ -600,10 +710,10 @@ void _libssh2_list_insert(struct list_node *after, /* insert before this */
 
 #endif
 
-/* this define is defined in misc.h for the correct platforms */
-#ifdef LIBSSH2_GETTIMEOFDAY_WIN32
+/* Defined in libssh2_priv.h for the correct platforms */
+#ifdef LIBSSH2_GETTIMEOFDAY
 /*
- * gettimeofday
+ * _libssh2_gettimeofday
  * Implementation according to:
  * The Open Group Base Specifications Issue 6
  * IEEE Std 1003.1, 2004 Edition
@@ -624,27 +734,31 @@ void _libssh2_list_insert(struct list_node *after, /* insert before this */
  *  Danny Smith <dannysmith@users.sourceforge.net>
  */
 
-/* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
-#define _W32_FT_OFFSET (116444736000000000)
-
-int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp)
+int _libssh2_gettimeofday(struct timeval *tp, void *tzp)
 {
-    union {
-        unsigned __int64 ns100; /*time since 1 Jan 1601 in 100ns units */
-        FILETIME ft;
-    } _now;
     (void)tzp;
     if(tp) {
+#ifdef _WIN32
+        /* Offset between 1601-01-01 and 1970-01-01 in 100 nanosec units */
+        #define _WIN32_FT_OFFSET (116444736000000000)
+
+        union {
+            libssh2_uint64_t ns100; /* time since 1 Jan 1601 in 100ns units */
+            FILETIME ft;
+        } _now;
         GetSystemTimeAsFileTime(&_now.ft);
         tp->tv_usec = (long)((_now.ns100 / 10) % 1000000);
-        tp->tv_sec = (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000);
+        tp->tv_sec = (long)((_now.ns100 - _WIN32_FT_OFFSET) / 10000000);
+#else
+        /* Platforms without a native implementation or local replacement */
+        tp->tv_usec = 0;
+        tp->tv_sec = 0;
+#endif
     }
     /* Always return 0 as per Open Group Base Specifications Issue 6.
        Do not set errno on error.  */
     return 0;
 }
-
-
 #endif
 
 void *_libssh2_calloc(LIBSSH2_SESSION* session, size_t size)
@@ -687,34 +801,23 @@ void _libssh2_aes_ctr_increment(unsigned char *ctr,
     }
 }
 
-#ifdef WIN32
-static void * (__cdecl * const volatile memset_libssh)(void *, int, size_t) =
-    memset;
-#else
+#ifdef LIBSSH2_MEMZERO
 static void * (* const volatile memset_libssh)(void *, int, size_t) = memset;
-#endif
 
-void _libssh2_explicit_zero(void *buf, size_t size)
+void _libssh2_memzero(void *buf, size_t size)
 {
-#if defined(HAVE_DECL_SECUREZEROMEMORY) && HAVE_DECL_SECUREZEROMEMORY
-    SecureZeroMemory(buf, size);
-    (void)memset_libssh; /* Silence unused variable warning */
-#elif defined(HAVE_MEMSET_S)
-    (void)memset_s(buf, size, 0, size);
-    (void)memset_libssh; /* Silence unused variable warning */
-#else
     memset_libssh(buf, 0, size);
-#endif
 }
+#endif
 
 /* String buffer */
 
-struct string_buf* _libssh2_string_buf_new(LIBSSH2_SESSION *session)
+struct string_buf *_libssh2_string_buf_new(LIBSSH2_SESSION *session)
 {
     struct string_buf *ret;
 
     ret = _libssh2_calloc(session, sizeof(*ret));
-    if(ret == NULL)
+    if(!ret)
         return NULL;
 
     return ret;
@@ -722,16 +825,39 @@ struct string_buf* _libssh2_string_buf_new(LIBSSH2_SESSION *session)
 
 void _libssh2_string_buf_free(LIBSSH2_SESSION *session, struct string_buf *buf)
 {
-    if(buf == NULL)
+    if(!buf)
         return;
 
-    if(buf->data != NULL)
+    if(buf->data)
         LIBSSH2_FREE(session, buf->data);
 
     LIBSSH2_FREE(session, buf);
     buf = NULL;
 }
 
+int _libssh2_get_byte(struct string_buf *buf, unsigned char *out)
+{
+    if(!_libssh2_check_length(buf, 1)) {
+        return -1;
+    }
+
+    *out = buf->dataptr[0];
+    buf->dataptr += 1;
+    return 0;
+}
+
+int _libssh2_get_boolean(struct string_buf *buf, unsigned char *out)
+{
+    if(!_libssh2_check_length(buf, 1)) {
+        return -1;
+    }
+
+
+    *out = buf->dataptr[0] == 0 ? 0 : 1;
+    buf->dataptr += 1;
+    return 0;
+}
+
 int _libssh2_get_u32(struct string_buf *buf, uint32_t *out)
 {
     if(!_libssh2_check_length(buf, 4)) {
@@ -769,7 +895,7 @@ int _libssh2_get_string(struct string_buf *buf, unsigned char **outbuf,
                         size_t *outlen)
 {
     uint32_t data_len;
-    if(_libssh2_get_u32(buf, &data_len) != 0) {
+    if(!buf || _libssh2_get_u32(buf, &data_len) != 0) {
         return -1;
     }
     if(!_libssh2_check_length(buf, data_len)) {
@@ -794,12 +920,17 @@ int _libssh2_copy_string(LIBSSH2_SESSION *session, struct string_buf *buf,
         return -1;
     }
 
-    *outbuf = LIBSSH2_ALLOC(session, str_len);
-    if(*outbuf) {
-        memcpy(*outbuf, str, str_len);
+    if(str_len) {
+        *outbuf = LIBSSH2_ALLOC(session, str_len);
+        if(*outbuf) {
+            memcpy(*outbuf, str, str_len);
+        }
+        else {
+            return -1;
+        }
     }
     else {
-        return -1;
+        *outbuf = NULL;
     }
 
     if(outlen)
@@ -848,25 +979,11 @@ int _libssh2_check_length(struct string_buf *buf, size_t len)
 {
     unsigned char *endp = &buf->data[buf->len];
     size_t left = endp - buf->dataptr;
-    return ((len <= left) && (left <= buf->len));
-}
-
-/* Wrappers */
-
-int _libssh2_bcrypt_pbkdf(const char *pass,
-                          size_t passlen,
-                          const uint8_t *salt,
-                          size_t saltlen,
-                          uint8_t *key,
-                          size_t keylen,
-                          unsigned int rounds)
-{
-    /* defined in bcrypt_pbkdf.c */
-    return bcrypt_pbkdf(pass,
-                        passlen,
-                        salt,
-                        saltlen,
-                        key,
-                        keylen,
-                        rounds);
+    return (len <= left) && (left <= buf->len);
+}
+
+int _libssh2_eob(struct string_buf *buf)
+{
+    unsigned char *endp = &buf->data[buf->len];
+    return buf->dataptr >= endp;
 }
diff --git a/libssh2/src/misc.h b/libssh2/src/misc.h
index 5481e666..eac2e064 100644
--- a/libssh2/src/misc.h
+++ b/libssh2/src/misc.h
@@ -1,7 +1,6 @@
-#ifndef __LIBSSH2_MISC_H
-#define __LIBSSH2_MISC_H
-/* Copyright (c) 2009-2019 by Daniel Stenberg
- *
+#ifndef LIBSSH2_MISC_H
+#define LIBSSH2_MISC_H
+/* Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -36,8 +35,29 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#ifdef LIBSSH2_NO_CLEAR_MEMORY
+#define _libssh2_explicit_zero(buf, size) do { \
+                                              (void)(buf); \
+                                              (void)(size); \
+                                          } while(0)
+#elif defined(_WIN32)
+#define _libssh2_explicit_zero(buf, size) SecureZeroMemory(buf, size)
+#elif defined(HAVE_EXPLICIT_BZERO)
+#define _libssh2_explicit_zero(buf, size) explicit_bzero(buf, size)
+#elif defined(HAVE_EXPLICIT_MEMSET)
+#define _libssh2_explicit_zero(buf, size) (void)explicit_memset(buf, 0, size)
+#elif defined(HAVE_MEMSET_S)
+#define _libssh2_explicit_zero(buf, size) (void)memset_s(buf, size, 0, size)
+#else
+#define LIBSSH2_MEMZERO
+void _libssh2_memzero(void *buf, size_t size);
+#define _libssh2_explicit_zero(buf, size) _libssh2_memzero(buf, size)
+#endif
+
 struct list_head {
     struct list_node *last;
     struct list_node *first;
@@ -59,6 +79,11 @@ int _libssh2_error_flags(LIBSSH2_SESSION* session, int errcode,
                          const char *errmsg, int errflags);
 int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char *errmsg);
 
+#ifdef _WIN32
+/* Convert Win32 WSAGetLastError to errno equivalent */
+int _libssh2_wsa2errno(void);
+#endif
+
 void _libssh2_list_init(struct list_head *head);
 
 /* add a node last in the list */
@@ -77,20 +102,28 @@ void *_libssh2_list_prev(struct list_node *node);
 /* remove this node from the list */
 void _libssh2_list_remove(struct list_node *entry);
 
+int _libssh2_base64_decode(LIBSSH2_SESSION *session,
+                           char **data, size_t *datalen,
+                           const char *src, size_t src_len);
 size_t _libssh2_base64_encode(LIBSSH2_SESSION *session,
                               const char *inp, size_t insize, char **outptr);
 
-unsigned int _libssh2_ntohu32(const unsigned char *buf);
+uint32_t _libssh2_ntohu32(const unsigned char *buf);
 libssh2_uint64_t _libssh2_ntohu64(const unsigned char *buf);
 void _libssh2_htonu32(unsigned char *buf, uint32_t val);
 void _libssh2_store_u32(unsigned char **buf, uint32_t value);
-void _libssh2_store_str(unsigned char **buf, const char *str, size_t len);
+void _libssh2_store_u64(unsigned char **buf, libssh2_uint64_t value);
+int _libssh2_store_str(unsigned char **buf, const char *str, size_t len);
+int _libssh2_store_bignum2_bytes(unsigned char **buf,
+                                 const unsigned char *bytes,
+                                 size_t len);
 void *_libssh2_calloc(LIBSSH2_SESSION *session, size_t size);
-void _libssh2_explicit_zero(void *buf, size_t size);
 
-struct string_buf* _libssh2_string_buf_new(LIBSSH2_SESSION *session);
+struct string_buf *_libssh2_string_buf_new(LIBSSH2_SESSION *session);
 void _libssh2_string_buf_free(LIBSSH2_SESSION *session,
                               struct string_buf *buf);
+int _libssh2_get_boolean(struct string_buf *buf, unsigned char *out);
+int _libssh2_get_byte(struct string_buf *buf, unsigned char *out);
 int _libssh2_get_u32(struct string_buf *buf, uint32_t *out);
 int _libssh2_get_u64(struct string_buf *buf, libssh2_uint64_t *out);
 int _libssh2_match_string(struct string_buf *buf, const char *match);
@@ -101,19 +134,7 @@ int _libssh2_copy_string(LIBSSH2_SESSION* session, struct string_buf *buf,
 int _libssh2_get_bignum_bytes(struct string_buf *buf, unsigned char **outbuf,
                               size_t *outlen);
 int _libssh2_check_length(struct string_buf *buf, size_t requested_len);
-
-#if defined(LIBSSH2_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-/* provide a private one */
-#undef HAVE_GETTIMEOFDAY
-int __cdecl _libssh2_gettimeofday(struct timeval *tp, void *tzp);
-#define HAVE_LIBSSH2_GETTIMEOFDAY
-#define LIBSSH2_GETTIMEOFDAY_WIN32 /* enable the win32 implementation */
-#else
-#ifdef HAVE_GETTIMEOFDAY
-#define _libssh2_gettimeofday(x,y) gettimeofday(x,y)
-#define HAVE_LIBSSH2_GETTIMEOFDAY
-#endif
-#endif
+int _libssh2_eob(struct string_buf *buf);
 
 void _libssh2_xor_data(unsigned char *output,
                        const unsigned char *input1,
@@ -122,4 +143,4 @@ void _libssh2_xor_data(unsigned char *output,
 
 void _libssh2_aes_ctr_increment(unsigned char *ctr, size_t length);
 
-#endif /* _LIBSSH2_MISC_H */
+#endif /* LIBSSH2_MISC_H */
diff --git a/libssh2/src/openssl.c b/libssh2/src/openssl.c
index 7a6810f1..eba05031 100644
--- a/libssh2/src/openssl.c
+++ b/libssh2/src/openssl.c
@@ -1,8 +1,7 @@
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
- *
- * Author: Simon Josefsson
+/* Copyright (C) Simon Josefsson
+ * Copyright (C) The Written Word, Inc.
+ * Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -36,26 +35,189 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_priv.h"
+#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */
 
-#ifdef LIBSSH2_OPENSSL /* compile only if we build with openssl */
+#include <stdlib.h>
+#include <assert.h>
 
-#include <string.h>
-#include "misc.h"
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
+{
+#ifdef USE_OPENSSL_3
+    *ctx = NULL;
+    return 1;
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    *ctx = HMAC_CTX_new();
+    return *ctx ? 1 : 0;
+#else
+    HMAC_CTX_init(ctx);
+    return 1;
+#endif
+}
 
-#ifndef EVP_MAX_BLOCK_LENGTH
-#define EVP_MAX_BLOCK_LENGTH 32
+#ifdef USE_OPENSSL_3
+static int _libssh2_hmac_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen,
+                              const char *digest_name)
+{
+    EVP_MAC* mac;
+    OSSL_PARAM params[3];
+
+    mac = EVP_MAC_fetch(NULL, OSSL_MAC_NAME_HMAC, NULL);
+    if(!mac)
+        return 0;
+
+    *ctx = EVP_MAC_CTX_new(mac);
+    EVP_MAC_free(mac);
+    if(!*ctx)
+        return 0;
+
+    params[0] = OSSL_PARAM_construct_octet_string(
+        OSSL_MAC_PARAM_KEY, (void *)key, keylen);
+    params[1] = OSSL_PARAM_construct_utf8_string(
+        OSSL_MAC_PARAM_DIGEST, (char *)digest_name, 0);
+    params[2] = OSSL_PARAM_construct_end();
+
+    return EVP_MAC_init(*ctx, NULL, 0, params);
+}
 #endif
 
-int
-read_openssh_private_key_from_memory(void **key_ctx, LIBSSH2_SESSION *session,
-                                     const char *key_type,
-                                     const char *filedata,
-                                     size_t filedata_len,
-                                     unsigned const char *passphrase);
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen)
+{
+#ifdef USE_OPENSSL_3
+    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_MD5);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_md5(), NULL);
+#else
+    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_md5(), NULL);
+#endif
+}
+#endif
+
+#if LIBSSH2_HMAC_RIPEMD
+int _libssh2_hmac_ripemd160_init(libssh2_hmac_ctx *ctx,
+                                 void *key, size_t keylen)
+{
+#ifdef USE_OPENSSL_3
+    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_RIPEMD160);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_ripemd160(), NULL);
+#else
+    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_ripemd160(), NULL);
+#endif
+}
+#endif
+
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen)
+{
+#ifdef USE_OPENSSL_3
+    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA1);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha1(), NULL);
+#else
+    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha1(), NULL);
+#endif
+}
 
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+#ifdef USE_OPENSSL_3
+    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA2_256);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha256(), NULL);
+#else
+    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha256(), NULL);
+#endif
+}
+
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+#ifdef USE_OPENSSL_3
+    return _libssh2_hmac_init(ctx, key, keylen, OSSL_DIGEST_NAME_SHA2_512);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Init_ex(*ctx, key, (int)keylen, EVP_sha512(), NULL);
+#else
+    return HMAC_Init_ex(ctx, key, (int)keylen, EVP_sha512(), NULL);
+#endif
+}
+
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen)
+{
+#ifdef USE_OPENSSL_3
+    return EVP_MAC_update(*ctx, data, datalen);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+/* FIXME: upstream bug as of v5.7.0: datalen is int instead of size_t */
+#if defined(LIBSSH2_WOLFSSL)
+    return HMAC_Update(*ctx, data, (int)datalen);
+#else /* !LIBSSH2_WOLFSSL */
+    return HMAC_Update(*ctx, data, datalen);
+#endif /* LIBSSH2_WOLFSSL */
+#else
+    return HMAC_Update(ctx, data, datalen);
+#endif
+}
+
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data)
+{
+#ifdef USE_OPENSSL_3
+    return EVP_MAC_final(*ctx, data, NULL, MAX_MACSIZE);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    return HMAC_Final(*ctx, data, NULL);
+#else
+    return HMAC_Final(ctx, data, NULL);
+#endif
+}
+
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
+{
+#ifdef USE_OPENSSL_3
+    EVP_MAC_CTX_free(*ctx);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+    HMAC_CTX_free(*ctx);
+#else
+    HMAC_cleanup(ctx);
+#endif
+}
+
+static int
+_libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
+                                        void **key_ctx,
+                                        const char *key_type,
+                                        unsigned char **method,
+                                        size_t *method_len,
+                                        unsigned char **pubkeydata,
+                                        size_t *pubkeydata_len,
+                                        const char *privatekeydata,
+                                        size_t privatekeydata_len,
+                                        unsigned const char *passphrase);
+
+static int
+_libssh2_sk_pub_openssh_keyfilememory(LIBSSH2_SESSION *session,
+                                      void **key_ctx,
+                                      const char *key_type,
+                                      unsigned char **method,
+                                      size_t *method_len,
+                                      unsigned char **pubkeydata,
+                                      size_t *pubkeydata_len,
+                                      int *algorithm,
+                                      unsigned char *flags,
+                                      const char **application,
+                                      const unsigned char **key_handle,
+                                      size_t *handle_len,
+                                      const char *privatekeydata,
+                                      size_t privatekeydata_len,
+                                      unsigned const char *passphrase);
+
+#if LIBSSH2_RSA || LIBSSH2_DSA || LIBSSH2_ECDSA
 static unsigned char *
 write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
 {
@@ -73,7 +235,33 @@ write_bn(unsigned char *buf, const BIGNUM *bn, int bn_bytes)
 
     return p + bn_bytes;
 }
+#endif
 
+static inline void
+_libssh2_swap_bytes(unsigned char *buf, unsigned long len)
+{
+#if !defined(WORDS_BIGENDIAN) || !WORDS_BIGENDIAN
+    unsigned long i, j;
+    unsigned char temp;
+    for(i = 0, j = len - 1; i < j; i++, j--) {
+        temp = buf[i];
+        buf[i] = buf[j];
+        buf[j] = temp;
+    }
+#endif
+}
+
+int
+_libssh2_openssl_random(void *buf, size_t len)
+{
+    if(len > INT_MAX) {
+        return -1;
+    }
+
+    return RAND_bytes(buf, (int)len) == 1 ? 0 : -1;
+}
+
+#if LIBSSH2_RSA
 int
 _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
                  const unsigned char *edata,
@@ -92,6 +280,78 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
                  unsigned long e2len,
                  const unsigned char *coeffdata, unsigned long coefflen)
 {
+#ifdef USE_OPENSSL_3
+    int ret = 0;
+    EVP_PKEY_CTX *ctx;
+    OSSL_PARAM params[4];
+    int param_num = 0;
+    unsigned char *nbuf = NULL;
+    unsigned char *ebuf = NULL;
+    unsigned char *dbuf = NULL;
+
+    (void)pdata;
+    (void)plen;
+    (void)qdata;
+    (void)qlen;
+    (void)e1data;
+    (void)e1len;
+    (void)e2data;
+    (void)e2len;
+    (void)coeffdata;
+    (void)coefflen;
+
+    if(ndata && nlen > 0) {
+        nbuf = OPENSSL_malloc(nlen);
+
+        if(nbuf) {
+            memcpy(nbuf, ndata, nlen);
+            _libssh2_swap_bytes(nbuf, nlen);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_N, nbuf, nlen);
+        }
+    }
+
+    if(edata && elen > 0) {
+        ebuf = OPENSSL_malloc(elen);
+        if(ebuf) {
+            memcpy(ebuf, edata, elen);
+            _libssh2_swap_bytes(ebuf, elen);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_E, ebuf, elen);
+        }
+    }
+
+    if(ddata && dlen > 0) {
+        dbuf = OPENSSL_malloc(dlen);
+        if(dbuf) {
+            memcpy(dbuf, ddata, dlen);
+            _libssh2_swap_bytes(dbuf, dlen);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_RSA_D, dbuf, dlen);
+        }
+    }
+
+    params[param_num] = OSSL_PARAM_construct_end();
+
+    *rsa = NULL;
+    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
+
+    if(EVP_PKEY_fromdata_init(ctx) > 0) {
+        ret = EVP_PKEY_fromdata(ctx, rsa, EVP_PKEY_KEYPAIR, params);
+    }
+    if(nbuf)
+        OPENSSL_clear_free(nbuf, nlen);
+
+    if(ebuf)
+        OPENSSL_clear_free(ebuf, elen);
+
+    if(dbuf)
+        OPENSSL_clear_free(dbuf, dlen);
+
+    EVP_PKEY_CTX_free(ctx);
+
+    return (ret == 1) ? 0 : -1;
+#else
     BIGNUM * e;
     BIGNUM * n;
     BIGNUM * d = 0;
@@ -102,29 +362,29 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
     BIGNUM * iqmp = 0;
 
     e = BN_new();
-    BN_bin2bn(edata, elen, e);
+    BN_bin2bn(edata, (int) elen, e);
 
     n = BN_new();
-    BN_bin2bn(ndata, nlen, n);
+    BN_bin2bn(ndata, (int) nlen, n);
 
     if(ddata) {
         d = BN_new();
-        BN_bin2bn(ddata, dlen, d);
+        BN_bin2bn(ddata, (int) dlen, d);
 
         p = BN_new();
-        BN_bin2bn(pdata, plen, p);
+        BN_bin2bn(pdata, (int) plen, p);
 
         q = BN_new();
-        BN_bin2bn(qdata, qlen, q);
+        BN_bin2bn(qdata, (int) qlen, q);
 
         dmp1 = BN_new();
-        BN_bin2bn(e1data, e1len, dmp1);
+        BN_bin2bn(e1data, (int) e1len, dmp1);
 
         dmq1 = BN_new();
-        BN_bin2bn(e2data, e2len, dmq1);
+        BN_bin2bn(e2data, (int) e2len, dmq1);
 
         iqmp = BN_new();
-        BN_bin2bn(coeffdata, coefflen, iqmp);
+        BN_bin2bn(coeffdata, (int) coefflen, iqmp);
     }
 
     *rsa = RSA_new();
@@ -151,24 +411,104 @@ _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
     (*rsa)->iqmp = iqmp;
 #endif
     return 0;
+
+#endif /* USE_OPENSSL_3 */
 }
 
 int
-_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
+_libssh2_rsa_sha2_verify(libssh2_rsa_ctx * rsactx,
+                         size_t hash_len,
                          const unsigned char *sig,
-                         unsigned long sig_len,
-                         const unsigned char *m, unsigned long m_len)
+                         size_t sig_len,
+                         const unsigned char *m, size_t m_len)
 {
-    unsigned char hash[SHA_DIGEST_LENGTH];
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = NULL;
+    const EVP_MD *md = NULL;
+#endif
+
     int ret;
+    int nid_type;
+    unsigned char *hash = malloc(hash_len);
+    if(!hash)
+        return -1;
 
-    if(_libssh2_sha1(m, m_len, hash))
+    if(hash_len == SHA_DIGEST_LENGTH) {
+        nid_type = NID_sha1;
+        ret = _libssh2_sha1(m, m_len, hash);
+    }
+    else if(hash_len == SHA256_DIGEST_LENGTH) {
+        nid_type = NID_sha256;
+        ret = _libssh2_sha256(m, m_len, hash);
+    }
+    else if(hash_len == SHA512_DIGEST_LENGTH) {
+        nid_type = NID_sha512;
+        ret = _libssh2_sha512(m, m_len, hash);
+    }
+    else {
+/* silence:
+   warning C4701: potentially uninitialized local variable 'nid_type' used */
+#if defined(_MSC_VER)
+        nid_type = 0;
+#endif
+        ret = -1; /* unsupported digest */
+    }
+
+    if(ret) {
+        free(hash);
         return -1; /* failure */
-    ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,
-                     (unsigned char *) sig, sig_len, rsactx);
+    }
+
+#ifdef USE_OPENSSL_3
+    ctx = EVP_PKEY_CTX_new(rsactx, NULL);
+
+    if(nid_type == NID_sha1) {
+        md = EVP_sha1();
+    }
+    else if(nid_type == NID_sha256) {
+        md = EVP_sha256();
+    }
+    else if(nid_type == NID_sha512) {
+        md = EVP_sha512();
+    }
+
+    if(ctx && md) {
+        if(EVP_PKEY_verify_init(ctx) > 0 &&
+           EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) > 0 &&
+           EVP_PKEY_CTX_set_signature_md(ctx, md) > 0) {
+            ret = EVP_PKEY_verify(ctx, sig, sig_len, hash, hash_len);
+        }
+    }
+
+    if(ctx) {
+        EVP_PKEY_CTX_free(ctx);
+    }
+
+#else
+
+    ret = RSA_verify(nid_type, hash, (unsigned int) hash_len,
+                     (unsigned char *) sig,
+                     (unsigned int) sig_len, rsactx);
+#endif
+
+    free(hash);
+
     return (ret == 1) ? 0 : -1;
 }
 
+#if LIBSSH2_RSA_SHA1
+int
+_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
+                         const unsigned char *sig,
+                         size_t sig_len,
+                         const unsigned char *m, size_t m_len)
+{
+    return _libssh2_rsa_sha2_verify(rsactx, SHA_DIGEST_LENGTH, sig, sig_len, m,
+                                    m_len);
+}
+#endif
+#endif
+
 #if LIBSSH2_DSA
 int
 _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
@@ -182,6 +522,97 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
                  unsigned long y_len,
                  const unsigned char *x, unsigned long x_len)
 {
+#ifdef USE_OPENSSL_3
+    int ret = 0;
+    EVP_PKEY_CTX *ctx = NULL;
+    OSSL_PARAM params[6];
+    int param_num = 0;
+    unsigned char *p_buf = NULL;
+    unsigned char *q_buf = NULL;
+    unsigned char *g_buf = NULL;
+    unsigned char *y_buf = NULL;
+    unsigned char *x_buf = NULL;
+
+    if(p && p_len > 0) {
+        p_buf = OPENSSL_malloc(p_len);
+
+        if(p_buf) {
+            memcpy(p_buf, p, p_len);
+            _libssh2_swap_bytes(p_buf, p_len);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_P, p_buf, p_len);
+        }
+    }
+
+    if(q && q_len > 0) {
+        q_buf = OPENSSL_malloc(q_len);
+
+        if(q_buf) {
+            memcpy(q_buf, q, q_len);
+            _libssh2_swap_bytes(q_buf, q_len);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_Q, q_buf, q_len);
+        }
+    }
+
+    if(g && g_len > 0) {
+        g_buf = OPENSSL_malloc(g_len);
+
+        if(g_buf) {
+            memcpy(g_buf, g, g_len);
+            _libssh2_swap_bytes(g_buf, g_len);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_FFC_G, g_buf, g_len);
+        }
+    }
+
+    if(y && y_len > 0) {
+        y_buf = OPENSSL_malloc(y_len);
+
+        if(y_buf) {
+            memcpy(y_buf, y, y_len);
+            _libssh2_swap_bytes(y_buf, y_len);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_PUB_KEY, y_buf, y_len);
+        }
+    }
+
+    if(x && x_len > 0) {
+        x_buf = OPENSSL_malloc(x_len);
+
+        if(x_buf) {
+            memcpy(x_buf, x, x_len);
+            _libssh2_swap_bytes(x_buf, x_len);
+            params[param_num++] =
+                OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_PRIV_KEY,
+                                        x_buf, x_len);
+        }
+    }
+
+    params[param_num] = OSSL_PARAM_construct_end();
+
+    *dsactx = NULL;
+    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_DSA, NULL);
+
+    if(EVP_PKEY_fromdata_init(ctx) > 0) {
+        ret = EVP_PKEY_fromdata(ctx, dsactx, EVP_PKEY_KEYPAIR, params);
+    }
+
+    if(p_buf)
+        OPENSSL_clear_free(p_buf, p_len);
+    if(q_buf)
+        OPENSSL_clear_free(q_buf, q_len);
+    if(g_buf)
+        OPENSSL_clear_free(g_buf, g_len);
+    if(x_buf)
+        OPENSSL_clear_free(x_buf, x_len);
+    if(y_buf)
+        OPENSSL_clear_free(y_buf, y_len);
+
+    return (ret == 1) ? 0 : -1;
+
+#else
+
     BIGNUM * p_bn;
     BIGNUM * q_bn;
     BIGNUM * g_bn;
@@ -189,20 +620,20 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
     BIGNUM * priv_key = NULL;
 
     p_bn = BN_new();
-    BN_bin2bn(p, p_len, p_bn);
+    BN_bin2bn(p, (int) p_len, p_bn);
 
     q_bn = BN_new();
-    BN_bin2bn(q, q_len, q_bn);
+    BN_bin2bn(q, (int) q_len, q_bn);
 
     g_bn = BN_new();
-    BN_bin2bn(g, g_len, g_bn);
+    BN_bin2bn(g, (int) g_len, g_bn);
 
     pub_key = BN_new();
-    BN_bin2bn(y, y_len, pub_key);
+    BN_bin2bn(y, (int) y_len, pub_key);
 
     if(x_len) {
         priv_key = BN_new();
-        BN_bin2bn(x, x_len, priv_key);
+        BN_bin2bn(x, (int) x_len, priv_key);
     }
 
     *dsactx = DSA_new();
@@ -222,13 +653,21 @@ _libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
     (*dsactx)->priv_key = priv_key;
 #endif
     return 0;
+
+#endif /* USE_OPENSSL_3 */
 }
 
 int
 _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
                          const unsigned char *sig,
-                         const unsigned char *m, unsigned long m_len)
+                         const unsigned char *m, size_t m_len)
 {
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = NULL;
+    unsigned char *der = NULL;
+    int der_len = 0;
+#endif
+
     unsigned char hash[SHA_DIGEST_LENGTH];
     DSA_SIG * dsasig;
     BIGNUM * r;
@@ -247,9 +686,30 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
     dsasig->r = r;
     dsasig->s = s;
 #endif
+
+#ifdef USE_OPENSSL_3
+    ctx = EVP_PKEY_CTX_new(dsactx, NULL);
+    der_len = i2d_DSA_SIG(dsasig, &der);
+
+    if(ctx && !_libssh2_sha1(m, m_len, hash)) {
+        /* _libssh2_sha1() succeeded */
+        if(EVP_PKEY_verify_init(ctx) > 0) {
+            ret = EVP_PKEY_verify(ctx, der, der_len, hash, SHA_DIGEST_LENGTH);
+        }
+    }
+
+    if(ctx) {
+        EVP_PKEY_CTX_free(ctx);
+    }
+
+    if(der) {
+        OPENSSL_clear_free(der, der_len);
+    }
+#else
     if(!_libssh2_sha1(m, m_len, hash))
         /* _libssh2_sha1() succeeded */
         ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, dsasig, dsactx);
+#endif
 
     DSA_SIG_free(dsasig);
 
@@ -268,8 +728,25 @@ _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
 libssh2_curve_type
 _libssh2_ecdsa_get_curve_type(libssh2_ecdsa_ctx *ec_ctx)
 {
+#ifdef USE_OPENSSL_3
+    int bits = 0;
+    EVP_PKEY_get_int_param(ec_ctx, OSSL_PKEY_PARAM_BITS, &bits);
+
+    if(bits == 256) {
+        return LIBSSH2_EC_CURVE_NISTP256;
+    }
+    else if(bits == 384) {
+        return LIBSSH2_EC_CURVE_NISTP384;
+    }
+    else if(bits == 521) {
+        return LIBSSH2_EC_CURVE_NISTP521;
+    }
+
+    return LIBSSH2_EC_CURVE_NISTP256;
+#else
     const EC_GROUP *group = EC_KEY_get0_group(ec_ctx);
     return EC_GROUP_get_curve_name(group);
+#endif
 }
 
 /* _libssh2_ecdsa_curve_type_from_name
@@ -282,10 +759,9 @@ int
 _libssh2_ecdsa_curve_type_from_name(const char *name,
                                     libssh2_curve_type *out_type)
 {
-    int ret = 0;
     libssh2_curve_type type;
 
-    if(name == NULL || strlen(name) != 19)
+    if(!name || strlen(name) != 19)
         return -1;
 
     if(strcmp(name, "ecdsa-sha2-nistp256") == 0)
@@ -295,14 +771,14 @@ _libssh2_ecdsa_curve_type_from_name(const char *name,
     else if(strcmp(name, "ecdsa-sha2-nistp521") == 0)
         type = LIBSSH2_EC_CURVE_NISTP521;
     else {
-        ret = -1;
+        return -1;
     }
 
-    if(ret == 0 && out_type) {
+    if(out_type) {
         *out_type = type;
     }
 
-    return ret;
+    return 0;
 }
 
 /* _libssh2_ecdsa_curve_name_with_octal_new
@@ -316,63 +792,161 @@ _libssh2_ecdsa_curve_name_with_octal_new(libssh2_ecdsa_ctx ** ec_ctx,
      const unsigned char *k,
      size_t k_len, libssh2_curve_type curve)
 {
-
     int ret = 0;
-    const EC_GROUP *ec_group = NULL;
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
+    const char *n = EC_curve_nid2nist(curve);
+    char *group_name = NULL;
+    unsigned char *data = NULL;
+
+    if(!ctx)
+        return -1;
+
+    if(n) {
+        group_name = OPENSSL_zalloc(strlen(n) + 1);
+    }
+
+    if(k_len > 0) {
+        data = OPENSSL_malloc(k_len);
+    }
+
+    if(group_name && data) {
+        OSSL_PARAM params[3] = { 0 };
+
+        memcpy(group_name, n, strlen(n));
+        memcpy(data, k, k_len);
+
+        params[0] =
+        OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
+                                         group_name, 0);
+
+        params[1] =
+        OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
+                                          data, k_len);
+
+        params[2] = OSSL_PARAM_construct_end();
+
+        if(EVP_PKEY_fromdata_init(ctx) > 0)
+            ret = EVP_PKEY_fromdata(ctx, ec_ctx, EVP_PKEY_PUBLIC_KEY,
+                                    params);
+        else
+            ret = -1;
+    }
+    else
+        ret = -1;
+
+    if(group_name)
+        OPENSSL_clear_free(group_name, strlen(n));
+
+    if(data)
+        OPENSSL_clear_free(data, k_len);
+
+    EVP_PKEY_CTX_free(ctx);
+#else
     EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);
-    EC_POINT *point = NULL;
 
     if(ec_key) {
+        const EC_GROUP *ec_group = NULL;
+        EC_POINT *point = NULL;
+
         ec_group = EC_KEY_get0_group(ec_key);
         point = EC_POINT_new(ec_group);
-        ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
-        ret = EC_KEY_set_public_key(ec_key, point);
 
-        if(point != NULL)
+        if(point) {
+            ret = EC_POINT_oct2point(ec_group, point, k, k_len, NULL);
+            if(ret == 1)
+                ret = EC_KEY_set_public_key(ec_key, point);
+
             EC_POINT_free(point);
+        }
+        else
+            ret = -1;
 
-        if(ec_ctx != NULL)
+        if(ret == 1 && ec_ctx)
             *ec_ctx = ec_key;
+        else {
+            EC_KEY_free(ec_key);
+            ret = -1;
+        }
     }
+    else
+        ret = -1;
+#endif
 
     return (ret == 1) ? 0 : -1;
 }
 
-#define LIBSSH2_ECDSA_VERIFY(digest_type)                           \
-{                                                                   \
-    unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
-    libssh2_sha##digest_type(m, m_len, hash);                       \
-    ret = ECDSA_do_verify(hash, SHA##digest_type##_DIGEST_LENGTH,   \
-      ecdsa_sig, ec_key);                                           \
-                                                                    \
-}
+#ifdef USE_OPENSSL_3
+#define LIBSSH2_ECDSA_VERIFY(digest_type)                               \
+    do {                                                                \
+        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
+        if(libssh2_sha##digest_type(m, m_len, hash) == 0) {             \
+            ret = EVP_PKEY_verify_init(ctx);                            \
+            if(ret > 0) {                                               \
+                ret = EVP_PKEY_verify(ctx, der, der_len, hash,          \
+                                     SHA##digest_type##_DIGEST_LENGTH); \
+            }                                                           \
+        }                                                               \
+    } while(0)
+#else
+#define LIBSSH2_ECDSA_VERIFY(digest_type)                               \
+    do {                                                                \
+        unsigned char hash[SHA##digest_type##_DIGEST_LENGTH];           \
+        if(libssh2_sha##digest_type(m, m_len, hash) == 0) {             \
+            ret = ECDSA_do_verify(hash,                                 \
+                                  SHA##digest_type##_DIGEST_LENGTH,     \
+                                  ecdsa_sig, ec_key);                   \
+        }                                                               \
+    } while(0)
+#endif
 
 int
-_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
-      const unsigned char *r, size_t r_len,
-      const unsigned char *s, size_t s_len,
-      const unsigned char *m, size_t m_len)
+_libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ecdsa_ctx,
+                      const unsigned char *r, size_t r_len,
+                      const unsigned char *s, size_t s_len,
+                      const unsigned char *m, size_t m_len)
 {
     int ret = 0;
-    EC_KEY *ec_key = (EC_KEY*)ctx;
-    libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ec_key);
+    libssh2_curve_type type = _libssh2_ecdsa_get_curve_type(ecdsa_ctx);
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = NULL;
+    unsigned char *der = NULL;
+    int der_len = 0;
+#else
+    EC_KEY *ec_key = (EC_KEY*)ecdsa_ctx;
+#endif
 
 #ifdef HAVE_OPAQUE_STRUCTS
     ECDSA_SIG *ecdsa_sig = ECDSA_SIG_new();
     BIGNUM *pr = BN_new();
     BIGNUM *ps = BN_new();
 
-    BN_bin2bn(r, r_len, pr);
-    BN_bin2bn(s, s_len, ps);
+    BN_bin2bn(r, (int) r_len, pr);
+    BN_bin2bn(s, (int) s_len, ps);
     ECDSA_SIG_set0(ecdsa_sig, pr, ps);
-
 #else
     ECDSA_SIG ecdsa_sig_;
     ECDSA_SIG *ecdsa_sig = &ecdsa_sig_;
     ecdsa_sig_.r = BN_new();
-    BN_bin2bn(r, r_len, ecdsa_sig_.r);
+    BN_bin2bn(r, (int) r_len, ecdsa_sig_.r);
     ecdsa_sig_.s = BN_new();
-    BN_bin2bn(s, s_len, ecdsa_sig_.s);
+    BN_bin2bn(s, (int) s_len, ecdsa_sig_.s);
+#endif
+
+#ifdef USE_OPENSSL_3
+    ctx = EVP_PKEY_CTX_new(ecdsa_ctx, NULL);
+    if(!ctx) {
+        ret = -1;
+        goto cleanup;
+    }
+
+    der_len = i2d_ECDSA_SIG(ecdsa_sig, &der);
+    if(der_len <= 0) {
+        ret = -1;
+        goto cleanup;
+    }
 #endif
 
     if(type == LIBSSH2_EC_CURVE_NISTP256) {
@@ -385,12 +959,24 @@ _libssh2_ecdsa_verify(libssh2_ecdsa_ctx * ctx,
         LIBSSH2_ECDSA_VERIFY(512);
     }
 
+#ifdef USE_OPENSSL_3
+cleanup:
+
+    if(ctx)
+        EVP_PKEY_CTX_free(ctx);
+
+    if(der)
+        OPENSSL_free(der);
+#endif
+
 #ifdef HAVE_OPAQUE_STRUCTS
     if(ecdsa_sig)
         ECDSA_SIG_free(ecdsa_sig);
 #else
-    BN_clear_free(ecdsa_sig_.s);
-    BN_clear_free(ecdsa_sig_.r);
+    if(ecdsa_sig_.s)
+        BN_clear_free(ecdsa_sig_.s);
+    if(ecdsa_sig_.r)
+        BN_clear_free(ecdsa_sig_.r);
 #endif
 
     return (ret == 1) ? 0 : -1;
@@ -404,262 +990,157 @@ _libssh2_cipher_init(_libssh2_cipher_ctx * h,
                      unsigned char *iv, unsigned char *secret, int encrypt)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
+#if LIBSSH2_AES_GCM
+    const int is_aesgcm = (algo == EVP_aes_128_gcm) ||
+                          (algo == EVP_aes_256_gcm);
+#endif /* LIBSSH2_AES_GCM */
+    int rc;
+
     *h = EVP_CIPHER_CTX_new();
-    return !EVP_CipherInit(*h, algo(), secret, iv, encrypt);
+    rc = !EVP_CipherInit(*h, algo(), secret, iv, encrypt);
+#if LIBSSH2_AES_GCM
+    if(is_aesgcm) {
+        /* Sets both fixed and invocation_counter parts of IV */
+        rc |= !EVP_CIPHER_CTX_ctrl(*h, EVP_CTRL_AEAD_SET_IV_FIXED, -1, iv);
+    }
+#endif /* LIBSSH2_AES_GCM */
+
+    return rc;
 #else
+# if LIBSSH2_AES_GCM
+#  error AES-GCM is only supported with opaque structs in use
+# endif /* LIBSSH2_AES_GCM */
     EVP_CIPHER_CTX_init(h);
     return !EVP_CipherInit(h, algo(), secret, iv, encrypt);
 #endif
 }
 
+#ifndef EVP_MAX_BLOCK_LENGTH
+#define EVP_MAX_BLOCK_LENGTH 32
+#endif
+
 int
 _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
                       _libssh2_cipher_type(algo),
-                      int encrypt, unsigned char *block, size_t blocksize)
+                      int encrypt, unsigned char *block, size_t blocksize,
+                      int firstlast)
 {
     unsigned char buf[EVP_MAX_BLOCK_LENGTH];
-    int ret;
-    (void) algo;
-    (void) encrypt;
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    ret = EVP_Cipher(*ctx, buf, block, blocksize);
-#else
-    ret = EVP_Cipher(ctx, buf, block, blocksize);
-#endif
-#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3
-    if(ret != -1) {
-#else
-    if(ret == 1) {
-#endif
-        memcpy(block, buf, blocksize);
-    }
-
-#if defined(OPENSSL_VERSION_MAJOR) && OPENSSL_VERSION_MAJOR >= 3
-    return ret != -1 ? 0 : 1;
-#else
-    return ret == 1 ? 0 : 1;
-#endif
-}
-
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-
-#include <openssl/aes.h>
-#include <openssl/evp.h>
-
-typedef struct
-{
-    AES_KEY       key;
-    EVP_CIPHER_CTX *aes_ctx;
-    unsigned char ctr[AES_BLOCK_SIZE];
-} aes_ctr_ctx;
-
-static EVP_CIPHER * aes_128_ctr_cipher = NULL;
-static EVP_CIPHER * aes_192_ctr_cipher = NULL;
-static EVP_CIPHER * aes_256_ctr_cipher = NULL;
-
-static int
-aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
-             const unsigned char *iv, int enc) /* init key */
-{
-    /*
-     * variable "c" is leaked from this scope, but is later freed
-     * in aes_ctr_cleanup
-     */
-    aes_ctr_ctx *c;
-    const EVP_CIPHER *aes_cipher;
-    (void) enc;
-
-    switch(EVP_CIPHER_CTX_key_length(ctx)) {
-    case 16:
-        aes_cipher = EVP_aes_128_ecb();
-        break;
-    case 24:
-        aes_cipher = EVP_aes_192_ecb();
-        break;
-    case 32:
-        aes_cipher = EVP_aes_256_ecb();
-        break;
-    default:
-        return 0;
-    }
-
-    c = malloc(sizeof(*c));
-    if(c == NULL)
-        return 0;
-
-#ifdef HAVE_OPAQUE_STRUCTS
-    c->aes_ctx = EVP_CIPHER_CTX_new();
-#else
-    c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));
-#endif
-    if(c->aes_ctx == NULL) {
-        free(c);
-        return 0;
-    }
+    int ret = 1;
+    int rc = 1;
 
-    if(EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
-#ifdef HAVE_OPAQUE_STRUCTS
-        EVP_CIPHER_CTX_free(c->aes_ctx);
+#if LIBSSH2_AES_GCM
+    const int is_aesgcm = (algo == EVP_aes_128_gcm) ||
+                          (algo == EVP_aes_256_gcm);
+    char lastiv[1];
 #else
-        free(c->aes_ctx);
-#endif
-        free(c);
-        return 0;
-    }
-
-    EVP_CIPHER_CTX_set_padding(c->aes_ctx, 0);
-
-    memcpy(c->ctr, iv, AES_BLOCK_SIZE);
-
-    EVP_CIPHER_CTX_set_app_data(ctx, c);
-
-    return 1;
-}
-
-static int
-aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                  const unsigned char *in,
-                  size_t inl) /* encrypt/decrypt data */
-{
-    aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
-    unsigned char b1[AES_BLOCK_SIZE];
-    int outlen = 0;
-
-    if(inl != 16) /* libssh2 only ever encrypt one block */
-        return 0;
-
-    if(c == NULL) {
-        return 0;
-    }
-
-/*
-  To encrypt a packet P=P1||P2||...||Pn (where P1, P2, ..., Pn are each
-  blocks of length L), the encryptor first encrypts <X> with <cipher>
-  to obtain a block B1.  The block B1 is then XORed with P1 to generate
-  the ciphertext block C1.  The counter X is then incremented
-*/
-
-    if(EVP_EncryptUpdate(c->aes_ctx, b1, &outlen,
-                         c->ctr, AES_BLOCK_SIZE) != 1) {
-        return 0;
-    }
-
-    _libssh2_xor_data(out, in, b1, AES_BLOCK_SIZE);
-    _libssh2_aes_ctr_increment(c->ctr, AES_BLOCK_SIZE);
-
-    return 1;
-}
-
-static int
-aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */
-{
-    aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
-
-    if(c == NULL) {
-        return 1;
-    }
+    const int is_aesgcm = 0;
+#endif /* LIBSSH2_AES_GCM */
+    /* length of AES-GCM Authentication Tag */
+    const int authlen = is_aesgcm ? 16 : 0;
+    /* length of AAD, only on the first block */
+    const int aadlen = (is_aesgcm && IS_FIRST(firstlast)) ? 4 : 0;
+    /* size of AT, if present */
+    const int authenticationtag = IS_LAST(firstlast) ? authlen : 0;
+    /* length to encrypt */
+    const int cryptlen = (unsigned int)blocksize - aadlen - authenticationtag;
+
+    (void)algo;
+
+    assert(blocksize <= sizeof(buf));
+    assert(cryptlen >= 0);
+
+#if LIBSSH2_AES_GCM
+    /* First block */
+    if(IS_FIRST(firstlast)) {
+        /* Increments invocation_counter portion of IV */
+        if(is_aesgcm) {
+            ret = EVP_CIPHER_CTX_ctrl(*ctx, EVP_CTRL_GCM_IV_GEN, 1, lastiv);
+        }
 
-    if(c->aes_ctx != NULL) {
-#ifdef HAVE_OPAQUE_STRUCTS
-        EVP_CIPHER_CTX_free(c->aes_ctx);
-#else
-        _libssh2_cipher_dtor(c->aes_ctx);
-        free(c->aes_ctx);
-#endif
+        if(aadlen) {
+            /* Include the 4 byte packet length as AAD */
+            ret = EVP_Cipher(*ctx, NULL, block, aadlen);
+        }
     }
 
-    free(c);
-
-    return 1;
-}
-
-static const EVP_CIPHER *
-make_ctr_evp (size_t keylen, EVP_CIPHER **aes_ctr_cipher, int type)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    *aes_ctr_cipher = EVP_CIPHER_meth_new(type, 16, keylen);
-    if(*aes_ctr_cipher) {
-        EVP_CIPHER_meth_set_iv_length(*aes_ctr_cipher, 16);
-        EVP_CIPHER_meth_set_init(*aes_ctr_cipher, aes_ctr_init);
-        EVP_CIPHER_meth_set_do_cipher(*aes_ctr_cipher, aes_ctr_do_cipher);
-        EVP_CIPHER_meth_set_cleanup(*aes_ctr_cipher, aes_ctr_cleanup);
+    /* Last portion of block to encrypt/decrypt */
+    if(IS_LAST(firstlast)) {
+        if(is_aesgcm && !encrypt) {
+            /* set tag on decryption */
+            ret = EVP_CIPHER_CTX_ctrl(*ctx, EVP_CTRL_GCM_SET_TAG, authlen,
+                                      block + blocksize - authlen);
+        }
     }
 #else
-    (*aes_ctr_cipher)->nid = type;
-    (*aes_ctr_cipher)->block_size = 16;
-    (*aes_ctr_cipher)->key_len = keylen;
-    (*aes_ctr_cipher)->iv_len = 16;
-    (*aes_ctr_cipher)->init = aes_ctr_init;
-    (*aes_ctr_cipher)->do_cipher = aes_ctr_do_cipher;
-    (*aes_ctr_cipher)->cleanup = aes_ctr_cleanup;
-#endif
+    (void)encrypt;
+    (void)firstlast;
+#endif /* LIBSSH2_AES_GCM */
 
-    return *aes_ctr_cipher;
-}
-
-const EVP_CIPHER *
-_libssh2_EVP_aes_128_ctr(void)
-{
+    if(cryptlen > 0) {
 #ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_128_ctr_cipher ?
-        make_ctr_evp(16, &aes_128_ctr_cipher, NID_aes_128_ctr) :
-        aes_128_ctr_cipher;
+        ret = EVP_Cipher(*ctx, buf + aadlen, block + aadlen, cryptlen);
 #else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_128_ctr_cipher) {
-        aes_128_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(16, &aes_128_ctr_cipher, 0);
-    }
-    return aes_128_ctr_cipher;
+        ret = EVP_Cipher(ctx, buf + aadlen, block + aadlen, cryptlen);
 #endif
-}
+    }
 
-const EVP_CIPHER *
-_libssh2_EVP_aes_192_ctr(void)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_192_ctr_cipher ?
-        make_ctr_evp(24, &aes_192_ctr_cipher, NID_aes_192_ctr) :
-        aes_192_ctr_cipher;
+#if defined(USE_OPENSSL_3) || defined(LIBSSH2_WOLFSSL)
+    if(ret != -1)
 #else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_192_ctr_cipher) {
-        aes_192_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(24, &aes_192_ctr_cipher, 0);
-    }
-    return aes_192_ctr_cipher;
+    if(ret >= 1)
 #endif
-}
-
-const EVP_CIPHER *
-_libssh2_EVP_aes_256_ctr(void)
-{
-#ifdef HAVE_OPAQUE_STRUCTS
-    return !aes_256_ctr_cipher ?
-        make_ctr_evp(32, &aes_256_ctr_cipher, NID_aes_256_ctr) :
-        aes_256_ctr_cipher;
+    {
+        rc = 0;
+        if(IS_LAST(firstlast)) {
+            /* This is the last block.
+               encrypt: compute tag, if applicable
+               decrypt: verify tag, if applicable
+               in!=NULL is equivalent to EVP_CipherUpdate
+               in==NULL is equivalent to EVP_CipherFinal */
+#if defined(LIBSSH2_WOLFSSL) && LIBWOLFSSL_VERSION_HEX < 0x05007000
+            /* Workaround for wolfSSL bug fixed in v5.7.0:
+               https://github.com/wolfSSL/wolfssl/pull/7143 */
+            unsigned char buf2[EVP_MAX_BLOCK_LENGTH];
+            int outb;
+            ret = EVP_CipherFinal(*ctx, buf2, &outb);
+#elif defined(HAVE_OPAQUE_STRUCTS)
+            ret = EVP_Cipher(*ctx, NULL, NULL, 0); /* final */
 #else
-    static EVP_CIPHER aes_ctr_cipher;
-    if(!aes_256_ctr_cipher) {
-        aes_256_ctr_cipher = &aes_ctr_cipher;
-        make_ctr_evp(32, &aes_256_ctr_cipher, 0);
-    }
-    return aes_256_ctr_cipher;
+            ret = EVP_Cipher(ctx, NULL, NULL, 0); /* final */
 #endif
-}
+            if(ret < 0) {
+                ret = 0;
+            }
+            else {
+                ret = 1;
+#if LIBSSH2_AES_GCM
+                if(is_aesgcm && encrypt) {
+                    /* write the Authentication Tag a.k.a. MAC at the end
+                       of the block */
+                    assert(authenticationtag == authlen);
+                    ret = EVP_CIPHER_CTX_ctrl(*ctx, EVP_CTRL_GCM_GET_TAG,
+                            authlen, block + blocksize - authenticationtag);
+                }
+#endif /* LIBSSH2_AES_GCM */
+            }
+        }
+        /* Copy en/decrypted data back to the caller.
+           The first aadlen should not be touched because they weren't
+           encrypted and are unmodified. */
+        memcpy(block + aadlen, buf + aadlen, cryptlen);
+        rc = !ret;
+    }
 
-#endif /* LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR) */
+    /* TODO: the return code should distinguish between decryption errors and
+       invalid MACs */
+    return rc;
+}
 
 void _libssh2_openssl_crypto_init(void)
 {
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
-    !defined(LIBRESSL_VERSION_NUMBER)
-#ifndef OPENSSL_NO_ENGINE
-    ENGINE_load_builtin_engines();
-    ENGINE_register_all_complete();
-#endif
-#else
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x2070000fL)
     OpenSSL_add_all_algorithms();
     OpenSSL_add_all_ciphers();
     OpenSSL_add_all_digests();
@@ -668,44 +1149,25 @@ void _libssh2_openssl_crypto_init(void)
     ENGINE_register_all_complete();
 #endif
 #endif
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-    aes_128_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_128_ctr();
-    aes_192_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_192_ctr();
-    aes_256_ctr_cipher = (EVP_CIPHER *) _libssh2_EVP_aes_256_ctr();
+#if defined(LIBSSH2_WOLFSSL) && defined(DEBUG_WOLFSSL)
+    wolfSSL_Debugging_ON();
 #endif
 }
 
 void _libssh2_openssl_crypto_exit(void)
 {
-#if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
-#ifdef HAVE_OPAQUE_STRUCTS
-    if(aes_128_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_128_ctr_cipher);
-    }
-
-    if(aes_192_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_192_ctr_cipher);
-    }
-
-    if(aes_256_ctr_cipher) {
-        EVP_CIPHER_meth_free(aes_256_ctr_cipher);
-    }
-#endif
-
-    aes_128_ctr_cipher = NULL;
-    aes_192_ctr_cipher = NULL;
-    aes_256_ctr_cipher = NULL;
-#endif
 }
 
+#if LIBSSH2_RSA || LIBSSH2_DSA || LIBSSH2_ECDSA || LIBSSH2_ED25519
 /* TODO: Optionally call a passphrase callback specified by the
  * calling program
  */
 static int
 passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
 {
-    int passphrase_len = strlen(passphrase);
-    (void) rwflag;
+    int passphrase_len = (int) strlen(passphrase);
+
+    (void)rwflag;
 
     if(passphrase_len > (size - 1)) {
         passphrase_len = size - 1;
@@ -730,19 +1192,24 @@ read_private_key_from_memory(void **key_ctx,
 
     *key_ctx = NULL;
 
-    bp = BIO_new_mem_buf((char *)filedata, filedata_len);
+#if OPENSSL_VERSION_NUMBER >= 0x1000200fL
+    bp = BIO_new_mem_buf(filedata, (int)filedata_len);
+#else
+    bp = BIO_new_mem_buf((char *)filedata, (int)filedata_len);
+#endif
     if(!bp) {
         return -1;
     }
+
     *key_ctx = read_private_key(bp, NULL, (pem_password_cb *) passphrase_cb,
                                 (void *) passphrase);
 
     BIO_free(bp);
     return (*key_ctx) ? 0 : -1;
 }
+#endif
 
-
-
+#if LIBSSH2_RSA || LIBSSH2_DSA || LIBSSH2_ECDSA
 static int
 read_private_key_from_file(void **key_ctx,
                            pem_read_bio_func read_private_key,
@@ -764,47 +1231,75 @@ read_private_key_from_file(void **key_ctx,
     BIO_free(bp);
     return (*key_ctx) ? 0 : -1;
 }
+#endif
 
+#if LIBSSH2_RSA
 int
 _libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx ** rsa,
                                     LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
+                                    const char *filedata,
+                                    size_t filedata_len,
                                     unsigned const char *passphrase)
 {
     int rc;
 
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_rsa =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
     pem_read_bio_func read_rsa =
         (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
-    rc = read_private_key_from_memory((void **) rsa, read_rsa,
-                                      filedata, filedata_len, passphrase);
+    rc = read_private_key_from_memory((void **)rsa, read_rsa,
+                                      filedata, filedata_len,
+                                      passphrase);
 
     if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)rsa, session,
-                        "ssh-rsa", filedata, filedata_len, passphrase);
+        rc = _libssh2_pub_priv_openssh_keyfilememory(session, (void **)rsa,
+                                                     "ssh-rsa",
+                                                     NULL, NULL, NULL, NULL,
+                                                     filedata, filedata_len,
+                                                     passphrase);
     }
 
-return rc;
+    return rc;
 }
 
 static unsigned char *
-gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
+gen_publickey_from_rsa(LIBSSH2_SESSION *session, libssh2_rsa_ctx *rsa,
                        size_t *key_len)
 {
     int            e_bytes, n_bytes;
     unsigned long  len;
-    unsigned char *key;
+    unsigned char *key = NULL;
     unsigned char *p;
+
+#ifdef USE_OPENSSL_3
+    BIGNUM * e = NULL;
+    BIGNUM * n = NULL;
+
+    EVP_PKEY_get_bn_param(rsa, OSSL_PKEY_PARAM_RSA_E, &e);
+    EVP_PKEY_get_bn_param(rsa, OSSL_PKEY_PARAM_RSA_N, &n);
+#else
     const BIGNUM * e;
     const BIGNUM * n;
-#ifdef HAVE_OPAQUE_STRUCTS
+#if defined(HAVE_OPAQUE_STRUCTS)
+    e = NULL;
+    n = NULL;
+
     RSA_get0_key(rsa, &n, &e, NULL);
 #else
     e = rsa->e;
     n = rsa->n;
 #endif
+#endif
+    if(!e || !n) {
+        goto fail;
+    }
+
     e_bytes = BN_num_bytes(e) + 1;
     n_bytes = BN_num_bytes(n) + 1;
 
@@ -812,8 +1307,8 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
     len = 4 + 7 + 4 + e_bytes + 4 + n_bytes;
 
     key = LIBSSH2_ALLOC(session, len);
-    if(key == NULL) {
-        return NULL;
+    if(!key) {
+        goto fail;
     }
 
     /* Process key encoding. */
@@ -828,6 +1323,11 @@ gen_publickey_from_rsa(LIBSSH2_SESSION *session, RSA *rsa,
     p = write_bn(p, n, n_bytes);
 
     *key_len = (size_t)(p - key);
+fail:
+#ifdef USE_OPENSSL_3
+    BN_clear_free(e);
+    BN_clear_free(n);
+#endif
     return key;
 }
 
@@ -839,44 +1339,56 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
                            size_t *pubkeydata_len,
                            EVP_PKEY *pk)
 {
-    RSA*           rsa = NULL;
+    libssh2_rsa_ctx* rsa = NULL;
     unsigned char *key;
     unsigned char *method_buf = NULL;
     size_t  key_len;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing public key from RSA private key envelope");
+                   "Computing public key from RSA private key envelope"));
 
+#ifdef USE_OPENSSL_3
+    rsa = pk;
+#else
     rsa = EVP_PKEY_get1_RSA(pk);
-    if(rsa == NULL) {
+#endif
+    if(!rsa) {
         /* Assume memory allocation error... what else could it be ? */
         goto __alloc_error;
     }
 
     method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-rsa. */
-    if(method_buf == NULL) {
+    if(!method_buf) {
         goto __alloc_error;
     }
 
     key = gen_publickey_from_rsa(session, rsa, &key_len);
-    if(key == NULL) {
+    if(!key) {
         goto __alloc_error;
     }
+#ifndef USE_OPENSSL_3
     RSA_free(rsa);
+#endif
 
     memcpy(method_buf, "ssh-rsa", 7);
-    *method         = method_buf;
-    *method_len     = 7;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
+    *method = method_buf;
+    if(method_len) {
+        *method_len = 7;
+    }
+    *pubkeydata = key;
+    if(pubkeydata_len) {
+        *pubkeydata_len = key_len;
+    }
     return 0;
 
-  __alloc_error:
-    if(rsa != NULL) {
+__alloc_error:
+#ifndef USE_OPENSSL_3
+    if(rsa) {
         RSA_free(rsa);
     }
-    if(method_buf != NULL) {
+#endif
+    if(method_buf) {
         LIBSSH2_FREE(session, method_buf);
     }
 
@@ -885,7 +1397,8 @@ gen_publickey_from_rsa_evp(LIBSSH2_SESSION *session,
                           "Unable to allocate memory for private key data");
 }
 
-static int _libssh2_rsa_new_additional_parameters(RSA *rsa)
+#ifndef USE_OPENSSL_3
+static int _libssh2_rsa_new_additional_parameters(libssh2_rsa_ctx *rsa)
 {
     BN_CTX *ctx = NULL;
     BIGNUM *aux = NULL;
@@ -906,23 +1419,23 @@ static int _libssh2_rsa_new_additional_parameters(RSA *rsa)
 #endif
 
     ctx = BN_CTX_new();
-    if(ctx == NULL)
+    if(!ctx)
         return -1;
 
     aux = BN_new();
-    if(aux == NULL) {
+    if(!aux) {
         rc = -1;
         goto out;
     }
 
     dmp1 = BN_new();
-    if(dmp1 == NULL) {
+    if(!dmp1) {
         rc = -1;
         goto out;
     }
 
     dmq1 = BN_new();
-    if(dmq1 == NULL) {
+    if(!dmq1) {
         rc = -1;
         goto out;
     }
@@ -947,7 +1460,7 @@ static int _libssh2_rsa_new_additional_parameters(RSA *rsa)
         BN_clear_free(aux);
     BN_CTX_free(ctx);
 
-    if(rc != 0) {
+    if(rc) {
         if(dmp1)
             BN_clear_free(dmp1);
         if(dmq1)
@@ -956,6 +1469,7 @@ static int _libssh2_rsa_new_additional_parameters(RSA *rsa)
 
     return rc;
 }
+#endif /* ndef USE_OPENSSL_3 */
 
 static int
 gen_publickey_from_rsa_openssh_priv_data(LIBSSH2_SESSION *session,
@@ -969,11 +1483,11 @@ gen_publickey_from_rsa_openssh_priv_data(LIBSSH2_SESSION *session,
     int rc = 0;
     size_t nlen, elen, dlen, plen, qlen, coefflen, commentlen;
     unsigned char *n, *e, *d, *p, *q, *coeff, *comment;
-    RSA *rsa = NULL;
+    libssh2_rsa_ctx *rsa = NULL;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing RSA keys from private key data");
+                   "Computing RSA keys from private key data"));
 
     /* public key data */
     if(_libssh2_get_bignum_bytes(decrypted, &n, &nlen)) {
@@ -1019,41 +1533,55 @@ gen_publickey_from_rsa_openssh_priv_data(LIBSSH2_SESSION *session,
         return -1;
     }
 
-    if((rc = _libssh2_rsa_new(&rsa, e, elen, n, nlen, d, dlen, p, plen,
-                              q, qlen, NULL, 0, NULL, 0,
-                              coeff, coefflen)) != 0) {
-        _libssh2_debug(session,
+    rc = _libssh2_rsa_new(&rsa,
+                          e, (unsigned long)elen,
+                          n, (unsigned long)nlen,
+                          d, (unsigned long)dlen,
+                          p, (unsigned long)plen,
+                          q, (unsigned long)qlen,
+                          NULL, 0, NULL, 0,
+                          coeff, (unsigned long)coefflen);
+    if(rc) {
+        _libssh2_debug((session,
                        LIBSSH2_TRACE_AUTH,
-                       "Could not create RSA private key");
+                       "Could not create RSA private key"));
         goto fail;
     }
 
-    if(rsa != NULL)
+#ifndef USE_OPENSSL_3
+    if(rsa)
         rc = _libssh2_rsa_new_additional_parameters(rsa);
+#endif
 
-    if(rsa != NULL && pubkeydata != NULL && method != NULL) {
+    if(rsa && pubkeydata && method) {
+#ifdef USE_OPENSSL_3
+        EVP_PKEY *pk = rsa;
+#else
         EVP_PKEY *pk = EVP_PKEY_new();
         EVP_PKEY_set1_RSA(pk, rsa);
+#endif
 
         rc = gen_publickey_from_rsa_evp(session, method, method_len,
                                         pubkeydata, pubkeydata_len,
                                         pk);
 
+#ifndef USE_OPENSSL_3
         if(pk)
             EVP_PKEY_free(pk);
+#endif
     }
 
-    if(rsa_ctx != NULL)
+    if(rsa_ctx)
         *rsa_ctx = rsa;
     else
-        RSA_free(rsa);
+        _libssh2_rsa_free(rsa);
 
     return rc;
 
 fail:
 
-    if(rsa != NULL)
-        RSA_free(rsa);
+    if(rsa)
+        _libssh2_rsa_free(rsa);
 
     return _libssh2_error(session,
                           LIBSSH2_ERROR_ALLOC,
@@ -1071,7 +1599,7 @@ _libssh2_rsa_new_openssh_private(libssh2_rsa_ctx ** rsa,
     unsigned char *buf = NULL;
     struct string_buf *decrypted = NULL;
 
-    if(session == NULL) {
+    if(!session) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Session is required");
         return -1;
@@ -1095,7 +1623,7 @@ _libssh2_rsa_new_openssh_private(libssh2_rsa_ctx ** rsa,
     /* We have a new key file, now try and parse it using supported types  */
     rc = _libssh2_get_string(decrypted, &buf, NULL);
 
-    if(rc != 0 || buf == NULL) {
+    if(rc || !buf) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Public key type in decrypted key data not found");
         return -1;
@@ -1103,8 +1631,8 @@ _libssh2_rsa_new_openssh_private(libssh2_rsa_ctx ** rsa,
 
     if(strcmp("ssh-rsa", (const char *)buf) == 0) {
         rc = gen_publickey_from_rsa_openssh_priv_data(session, decrypted,
-                                                      NULL, 0,
-                                                      NULL, 0, rsa);
+                                                      NULL, NULL,
+                                                      NULL, NULL, rsa);
     }
     else {
         rc = -1;
@@ -1123,8 +1651,13 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
 {
     int rc;
 
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_rsa =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
     pem_read_bio_func read_rsa =
         (pem_read_bio_func) &PEM_read_bio_RSAPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
@@ -1138,41 +1671,63 @@ _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
 
     return rc;
 }
+#endif
 
 #if LIBSSH2_DSA
 int
 _libssh2_dsa_new_private_frommemory(libssh2_dsa_ctx ** dsa,
                                     LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
+                                    const char *filedata,
+                                    size_t filedata_len,
                                     unsigned const char *passphrase)
 {
     int rc;
 
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_dsa =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
     pem_read_bio_func read_dsa =
         (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
     rc = read_private_key_from_memory((void **)dsa, read_dsa,
-                                      filedata, filedata_len, passphrase);
+                                      filedata, filedata_len,
+                                      passphrase);
 
     if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)dsa, session,
-                            "ssh-dsa", filedata, filedata_len, passphrase);
+        rc = _libssh2_pub_priv_openssh_keyfilememory(session, (void **)dsa,
+                                                     "ssh-dsa",
+                                                     NULL, NULL, NULL, NULL,
+                                                     filedata, filedata_len,
+                                                     passphrase);
     }
 
     return rc;
 }
 
 static unsigned char *
-gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
+gen_publickey_from_dsa(LIBSSH2_SESSION* session, libssh2_dsa_ctx *dsa,
                        size_t *key_len)
 {
     int            p_bytes, q_bytes, g_bytes, k_bytes;
     unsigned long  len;
-    unsigned char *key;
+    unsigned char *key = NULL;
     unsigned char *p;
 
+#ifdef USE_OPENSSL_3
+    BIGNUM * p_bn = NULL;
+    BIGNUM * q = NULL;
+    BIGNUM * g = NULL;
+    BIGNUM * pub_key = NULL;
+
+    EVP_PKEY_get_bn_param(dsa, OSSL_PKEY_PARAM_FFC_P, &p_bn);
+    EVP_PKEY_get_bn_param(dsa, OSSL_PKEY_PARAM_FFC_Q, &q);
+    EVP_PKEY_get_bn_param(dsa, OSSL_PKEY_PARAM_FFC_G, &g);
+    EVP_PKEY_get_bn_param(dsa, OSSL_PKEY_PARAM_PUB_KEY, &pub_key);
+#else
     const BIGNUM * p_bn;
     const BIGNUM * q;
     const BIGNUM * g;
@@ -1189,6 +1744,7 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
     DSA_get0_key(dsa, &pub_key, NULL);
 #else
     pub_key = dsa->pub_key;
+#endif
 #endif
     p_bytes = BN_num_bytes(p_bn) + 1;
     q_bytes = BN_num_bytes(q) + 1;
@@ -1199,8 +1755,8 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
     len = 4 + 7 + 4 + p_bytes + 4 + q_bytes + 4 + g_bytes + 4 + k_bytes;
 
     key = LIBSSH2_ALLOC(session, len);
-    if(key == NULL) {
-        return NULL;
+    if(!key) {
+        goto fail;
     }
 
     /* Process key encoding. */
@@ -1217,6 +1773,13 @@ gen_publickey_from_dsa(LIBSSH2_SESSION* session, DSA *dsa,
     p = write_bn(p, pub_key, k_bytes);
 
     *key_len = (size_t)(p - key);
+fail:
+#ifdef USE_OPENSSL_3
+    BN_clear_free(p_bn);
+    BN_clear_free(q);
+    BN_clear_free(g);
+    BN_clear_free(pub_key);
+#endif
     return key;
 }
 
@@ -1228,44 +1791,56 @@ gen_publickey_from_dsa_evp(LIBSSH2_SESSION *session,
                            size_t *pubkeydata_len,
                            EVP_PKEY *pk)
 {
-    DSA*           dsa = NULL;
+    libssh2_dsa_ctx *dsa = NULL;
     unsigned char *key;
     unsigned char *method_buf = NULL;
     size_t  key_len;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing public key from DSA private key envelope");
+                   "Computing public key from DSA private key envelope"));
 
+#ifdef USE_OPENSSL_3
+    dsa = pk;
+#else
     dsa = EVP_PKEY_get1_DSA(pk);
-    if(dsa == NULL) {
+#endif
+    if(!dsa) {
         /* Assume memory allocation error... what else could it be ? */
         goto __alloc_error;
     }
 
     method_buf = LIBSSH2_ALLOC(session, 7);  /* ssh-dss. */
-    if(method_buf == NULL) {
+    if(!method_buf) {
         goto __alloc_error;
     }
 
     key = gen_publickey_from_dsa(session, dsa, &key_len);
-    if(key == NULL) {
+    if(!key) {
         goto __alloc_error;
     }
+#ifndef USE_OPENSSL_3
     DSA_free(dsa);
+#endif
 
     memcpy(method_buf, "ssh-dss", 7);
-    *method         = method_buf;
-    *method_len     = 7;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
+    *method = method_buf;
+    if(method_len) {
+        *method_len = 7;
+    }
+    *pubkeydata = key;
+    if(pubkeydata_len) {
+        *pubkeydata_len = key_len;
+    }
     return 0;
 
-  __alloc_error:
-    if(dsa != NULL) {
+__alloc_error:
+#ifndef USE_OPENSSL_3
+    if(dsa) {
         DSA_free(dsa);
     }
-    if(method_buf != NULL) {
+#endif
+    if(method_buf) {
         LIBSSH2_FREE(session, method_buf);
     }
 
@@ -1286,11 +1861,11 @@ gen_publickey_from_dsa_openssh_priv_data(LIBSSH2_SESSION *session,
     int rc = 0;
     size_t plen, qlen, glen, pub_len, priv_len;
     unsigned char *p, *q, *g, *pub_key, *priv_key;
-    DSA *dsa = NULL;
+    libssh2_dsa_ctx *dsa = NULL;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing DSA keys from private key data");
+                   "Computing DSA keys from private key data"));
 
     if(_libssh2_get_bignum_bytes(decrypted, &p, &plen)) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
@@ -1322,38 +1897,48 @@ gen_publickey_from_dsa_openssh_priv_data(LIBSSH2_SESSION *session,
         return -1;
     }
 
-    rc = _libssh2_dsa_new(&dsa, p, plen, q, qlen, g, glen, pub_key, pub_len,
-                          priv_key, priv_len);
-    if(rc != 0) {
-        _libssh2_debug(session,
+    rc = _libssh2_dsa_new(&dsa,
+                          p, (unsigned long)plen,
+                          q, (unsigned long)qlen,
+                          g, (unsigned long)glen,
+                          pub_key, (unsigned long)pub_len,
+                          priv_key, (unsigned long)priv_len);
+    if(rc) {
+        _libssh2_debug((session,
                        LIBSSH2_ERROR_PROTO,
-                       "Could not create DSA private key");
+                       "Could not create DSA private key"));
         goto fail;
     }
 
-    if(dsa != NULL && pubkeydata != NULL && method != NULL) {
+    if(dsa && pubkeydata && method) {
+#ifdef USE_OPENSSL_3
+        EVP_PKEY *pk = dsa;
+#else
         EVP_PKEY *pk = EVP_PKEY_new();
         EVP_PKEY_set1_DSA(pk, dsa);
+#endif
 
         rc = gen_publickey_from_dsa_evp(session, method, method_len,
                                         pubkeydata, pubkeydata_len,
                                         pk);
 
+#ifndef USE_OPENSSL_3
         if(pk)
             EVP_PKEY_free(pk);
+#endif
     }
 
-    if(dsa_ctx != NULL)
+    if(dsa_ctx)
         *dsa_ctx = dsa;
     else
-        DSA_free(dsa);
+        _libssh2_dsa_free(dsa);
 
     return rc;
 
 fail:
 
-    if(dsa != NULL)
-        DSA_free(dsa);
+    if(dsa)
+        _libssh2_dsa_free(dsa);
 
     return _libssh2_error(session,
                           LIBSSH2_ERROR_ALLOC,
@@ -1371,7 +1956,7 @@ _libssh2_dsa_new_openssh_private(libssh2_dsa_ctx ** dsa,
     unsigned char *buf = NULL;
     struct string_buf *decrypted = NULL;
 
-    if(session == NULL) {
+    if(!session) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Session is required");
         return -1;
@@ -1395,7 +1980,7 @@ _libssh2_dsa_new_openssh_private(libssh2_dsa_ctx ** dsa,
     /* We have a new key file, now try and parse it using supported types  */
     rc = _libssh2_get_string(decrypted, &buf, NULL);
 
-    if(rc != 0 || buf == NULL) {
+    if(rc || !buf) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Public key type in decrypted key data not found");
         return -1;
@@ -1403,8 +1988,8 @@ _libssh2_dsa_new_openssh_private(libssh2_dsa_ctx ** dsa,
 
     if(strcmp("ssh-dss", (const char *)buf) == 0) {
         rc = gen_publickey_from_dsa_openssh_priv_data(session, decrypted,
-                                                      NULL, 0,
-                                                      NULL, 0, dsa);
+                                                      NULL, NULL,
+                                                      NULL, NULL, dsa);
     }
     else {
         rc = -1;
@@ -1423,8 +2008,13 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
 {
     int rc;
 
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_dsa =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
     pem_read_bio_func read_dsa =
         (pem_read_bio_func) &PEM_read_bio_DSAPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
@@ -1438,36 +2028,71 @@ _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
 
     return rc;
 }
-
 #endif /* LIBSSH_DSA */
 
 #if LIBSSH2_ECDSA
-
 int
 _libssh2_ecdsa_new_private_frommemory(libssh2_ecdsa_ctx ** ec_ctx,
-                                    LIBSSH2_SESSION * session,
-                                    const char *filedata, size_t filedata_len,
-                                    unsigned const char *passphrase)
+                                      LIBSSH2_SESSION * session,
+                                      const char *filedata,
+                                      size_t filedata_len,
+                                      unsigned const char *passphrase)
 {
     int rc;
 
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_ec =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
     pem_read_bio_func read_ec =
         (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
-    rc = read_private_key_from_memory((void **) ec_ctx, read_ec,
-                                      filedata, filedata_len, passphrase);
+    rc = read_private_key_from_memory((void **)ec_ctx, read_ec,
+                                      filedata, filedata_len,
+                                      passphrase);
 
     if(rc) {
-        rc = read_openssh_private_key_from_memory((void **)ec_ctx, session,
-                                                  "ssh-ecdsa", filedata,
-                                                  filedata_len, passphrase);
+        rc = _libssh2_pub_priv_openssh_keyfilememory(session, (void **)ec_ctx,
+                                                     "ssh-ecdsa",
+                                                     NULL, NULL, NULL, NULL,
+                                                     filedata, filedata_len,
+                                                     passphrase);
     }
 
     return rc;
 }
 
+int _libssh2_ecdsa_new_private_frommemory_sk(libssh2_ecdsa_ctx ** ec_ctx,
+                                             unsigned char *flags,
+                                             const char **application,
+                                             const unsigned char **key_handle,
+                                             size_t *handle_len,
+                                             LIBSSH2_SESSION * session,
+                                             const char *filedata,
+                                             size_t filedata_len,
+                                             unsigned const char *passphrase)
+{
+    int algorithm;
+    return _libssh2_sk_pub_openssh_keyfilememory(session,
+                                                 (void **)ec_ctx,
+                                          "sk-ecdsa-sha2-nistp256@openssh.com",
+                                                 NULL,
+                                                 NULL,
+                                                 NULL,
+                                                 NULL,
+                                                 &algorithm,
+                                                 flags,
+                                                 application,
+                                                 key_handle,
+                                                 handle_len,
+                                                 filedata,
+                                                 filedata_len,
+                                                 passphrase);
+}
+
 #endif /* LIBSSH2_ECDSA */
 
 
@@ -1485,38 +2110,38 @@ _libssh2_curve25519_new(LIBSSH2_SESSION *session,
     int rc = -1;
 
     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_X25519, NULL);
-    if(pctx == NULL)
+    if(!pctx)
         return -1;
 
     if(EVP_PKEY_keygen_init(pctx) != 1 ||
        EVP_PKEY_keygen(pctx, &key) != 1) {
-        goto cleanExit;
+        goto clean_exit;
     }
 
-    if(out_private_key != NULL) {
+    if(out_private_key) {
         privLen = LIBSSH2_ED25519_KEY_LEN;
         priv = LIBSSH2_ALLOC(session, privLen);
-        if(priv == NULL)
-            goto cleanExit;
+        if(!priv)
+            goto clean_exit;
 
         if(EVP_PKEY_get_raw_private_key(key, priv, &privLen) != 1 ||
            privLen != LIBSSH2_ED25519_KEY_LEN) {
-            goto cleanExit;
+            goto clean_exit;
         }
 
         *out_private_key = priv;
         priv = NULL;
     }
 
-    if(out_public_key != NULL) {
+    if(out_public_key) {
         pubLen = LIBSSH2_ED25519_KEY_LEN;
         pub = LIBSSH2_ALLOC(session, pubLen);
-        if(pub == NULL)
-            goto cleanExit;
+        if(!pub)
+            goto clean_exit;
 
         if(EVP_PKEY_get_raw_public_key(key, pub, &pubLen) != 1 ||
            pubLen != LIBSSH2_ED25519_KEY_LEN) {
-            goto cleanExit;
+            goto clean_exit;
         }
 
         *out_public_key = pub;
@@ -1526,7 +2151,7 @@ _libssh2_curve25519_new(LIBSSH2_SESSION *session,
     /* success */
     rc = 0;
 
-cleanExit:
+clean_exit:
 
     if(pctx)
         EVP_PKEY_CTX_free(pctx);
@@ -1556,8 +2181,8 @@ gen_publickey_from_ed_evp(LIBSSH2_SESSION *session,
     size_t bufLen = 0;
     unsigned char *bufPos = NULL;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                   "Computing public key from ED private key envelope");
+    _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                   "Computing public key from ED private key envelope"));
 
     methodBuf = LIBSSH2_ALLOC(session, sizeof(methodName) - 1);
     if(!methodBuf) {
@@ -1583,7 +2208,7 @@ gen_publickey_from_ed_evp(LIBSSH2_SESSION *session,
     }
 
     _libssh2_store_str(&bufPos, methodName, sizeof(methodName) - 1);
-    _libssh2_store_u32(&bufPos, rawKeyLen);
+    _libssh2_store_u32(&bufPos, (uint32_t) rawKeyLen);
 
     if(EVP_PKEY_get_raw_public_key(pk, bufPos, &rawKeyLen) != 1) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
@@ -1591,41 +2216,195 @@ gen_publickey_from_ed_evp(LIBSSH2_SESSION *session,
         goto fail;
     }
 
-    *method         = methodBuf;
-    *method_len     = sizeof(methodName) - 1;
-    *pubkeydata     = keyBuf;
-    *pubkeydata_len = bufLen;
+    *method = methodBuf;
+    if(method_len) {
+        *method_len = sizeof(methodName) - 1;
+    }
+    *pubkeydata = keyBuf;
+    if(pubkeydata_len) {
+        *pubkeydata_len = bufLen;
+    }
     return 0;
 
-fail:
-    if(methodBuf)
-        LIBSSH2_FREE(session, methodBuf);
-    if(keyBuf)
-        LIBSSH2_FREE(session, keyBuf);
+fail:
+    if(methodBuf)
+        LIBSSH2_FREE(session, methodBuf);
+    if(keyBuf)
+        LIBSSH2_FREE(session, keyBuf);
+    return -1;
+}
+
+
+static int
+gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
+                                             struct string_buf *decrypted,
+                                             unsigned char **method,
+                                             size_t *method_len,
+                                             unsigned char **pubkeydata,
+                                             size_t *pubkeydata_len,
+                                             libssh2_ed25519_ctx **out_ctx)
+{
+    libssh2_ed25519_ctx *ctx = NULL;
+    unsigned char *method_buf = NULL;
+    unsigned char *key = NULL;
+    int i, ret = 0;
+    unsigned char *pub_key, *priv_key, *buf;
+    size_t key_len = 0, tmp_len = 0;
+    unsigned char *p;
+
+    _libssh2_debug((session,
+                   LIBSSH2_TRACE_AUTH,
+                   "Computing ED25519 keys from private key data"));
+
+    if(_libssh2_get_string(decrypted, &pub_key, &tmp_len) ||
+       tmp_len != LIBSSH2_ED25519_KEY_LEN) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Wrong public key length");
+        return -1;
+    }
+
+    if(_libssh2_get_string(decrypted, &priv_key, &tmp_len) ||
+       tmp_len != LIBSSH2_ED25519_PRIVATE_KEY_LEN) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Wrong private key length");
+        ret = -1;
+        goto clean_exit;
+    }
+
+    /* first 32 bytes of priv_key is the private key, the last 32 bytes are
+       the public key */
+    ctx = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL,
+                                       (const unsigned char *)priv_key,
+                                       LIBSSH2_ED25519_KEY_LEN);
+
+    /* comment */
+    if(_libssh2_get_string(decrypted, &buf, &tmp_len)) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Unable to read comment");
+        ret = -1;
+        goto clean_exit;
+    }
+
+    if(tmp_len > 0) {
+        unsigned char *comment = LIBSSH2_CALLOC(session, tmp_len + 1);
+        if(comment) {
+            memcpy(comment, buf, tmp_len);
+            memcpy(comment + tmp_len, "\0", 1);
+
+            _libssh2_debug((session, LIBSSH2_TRACE_AUTH, "Key comment: %s",
+                           comment));
+
+            LIBSSH2_FREE(session, comment);
+        }
+    }
+
+    /* Padding */
+    i = 1;
+    while(decrypted->dataptr < decrypted->data + decrypted->len) {
+        if(*decrypted->dataptr != i) {
+            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                           "Wrong padding");
+            ret = -1;
+            goto clean_exit;
+        }
+        i++;
+        decrypted->dataptr++;
+    }
+
+    if(ret == 0) {
+        _libssh2_debug((session,
+                       LIBSSH2_TRACE_AUTH,
+                       "Computing public key from ED25519 "
+                       "private key envelope"));
+
+        method_buf = LIBSSH2_ALLOC(session, 11);  /* ssh-ed25519. */
+        if(!method_buf) {
+            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                           "Unable to allocate memory for ED25519 key");
+            goto clean_exit;
+        }
+
+        /* Key form is: type_len(4) + type(11) + pub_key_len(4) +
+           pub_key(32). */
+        key_len = LIBSSH2_ED25519_KEY_LEN + 19;
+        key = LIBSSH2_CALLOC(session, key_len);
+        if(!key) {
+            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                           "Unable to allocate memory for ED25519 key");
+            goto clean_exit;
+        }
+
+        p = key;
+
+        _libssh2_store_str(&p, "ssh-ed25519", 11);
+        _libssh2_store_str(&p, (const char *)pub_key, LIBSSH2_ED25519_KEY_LEN);
+
+        memcpy(method_buf, "ssh-ed25519", 11);
+
+        if(method)
+            *method = method_buf;
+        else
+            LIBSSH2_FREE(session, method_buf);
+
+        if(method_len)
+            *method_len = 11;
+
+        if(pubkeydata)
+            *pubkeydata = key;
+        else
+            LIBSSH2_FREE(session, key);
+
+        if(pubkeydata_len)
+            *pubkeydata_len = key_len;
+
+        if(out_ctx)
+            *out_ctx = ctx;
+        else if(ctx)
+            _libssh2_ed25519_free(ctx);
+
+        return 0;
+    }
+
+clean_exit:
+
+    if(ctx)
+        _libssh2_ed25519_free(ctx);
+
+    if(method_buf)
+        LIBSSH2_FREE(session, method_buf);
+
+    if(key)
+        LIBSSH2_FREE(session, key);
+
     return -1;
 }
 
-
 static int
-gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
-                                             struct string_buf *decrypted,
-                                             unsigned char **method,
-                                             size_t *method_len,
-                                             unsigned char **pubkeydata,
-                                             size_t *pubkeydata_len,
-                                             libssh2_ed25519_ctx **out_ctx)
+gen_publickey_from_sk_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
+                                                struct string_buf *decrypted,
+                                                unsigned char **method,
+                                                size_t *method_len,
+                                                unsigned char **pubkeydata,
+                                                size_t *pubkeydata_len,
+                                                unsigned char *flags,
+                                                const char **application,
+                                              const unsigned char **key_handle,
+                                                size_t *handle_len,
+                                                libssh2_ed25519_ctx **out_ctx)
 {
+    const char *key_type = "sk-ssh-ed25519@openssh.com";
+
     libssh2_ed25519_ctx *ctx = NULL;
     unsigned char *method_buf = NULL;
     unsigned char *key = NULL;
-    int i, ret = 0;
-    unsigned char *pub_key, *priv_key, *buf;
-    size_t key_len = 0, tmp_len = 0;
+    int ret = 0;
+    unsigned char *pub_key, *app;
+    size_t key_len = 0, app_len = 0, tmp_len = 0;
     unsigned char *p;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing ED25519 keys from private key data");
+                   "Computing sk-ED25519 keys from private key data"));
 
     if(_libssh2_get_string(decrypted, &pub_key, &tmp_len) ||
        tmp_len != LIBSSH2_ED25519_KEY_LEN) {
@@ -1634,72 +2413,58 @@ gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
         return -1;
     }
 
-    if(_libssh2_get_string(decrypted, &priv_key, &tmp_len) ||
-       tmp_len != LIBSSH2_ED25519_PRIVATE_KEY_LEN) {
+    if(_libssh2_get_string(decrypted, &app, &app_len)) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Wrong private key length");
-        ret = -1;
-        goto clean_exit;
+                       "No SK application.");
+        return -1;
     }
 
-    /* first 32 bytes of priv_key is the private key, the last 32 bytes are
-       the public key */
-    ctx = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, NULL,
-                                       (const unsigned char *)priv_key,
-                                       LIBSSH2_ED25519_KEY_LEN);
-
-    /* comment */
-    if(_libssh2_get_string(decrypted, &buf, &tmp_len)) {
+    if(flags && _libssh2_get_byte(decrypted, flags)) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Unable to read comment");
-        ret = -1;
-        goto clean_exit;
+                       "No SK flags.");
+        return -1;
     }
 
-    if(tmp_len > 0) {
-        unsigned char *comment = LIBSSH2_CALLOC(session, tmp_len + 1);
-        if(comment != NULL) {
-            memcpy(comment, buf, tmp_len);
-            memcpy(comment + tmp_len, "\0", 1);
+    if(key_handle && handle_len) {
+        unsigned char *handle = NULL;
+        if(_libssh2_get_string(decrypted, &handle, handle_len)) {
+            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                           "No SK key_handle.");
+            return -1;
+        }
 
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Key comment: %s",
-                           comment);
+        if(*handle_len > 0) {
+            *key_handle = LIBSSH2_ALLOC(session, *handle_len);
 
-            LIBSSH2_FREE(session, comment);
+            if(key_handle) {
+                memcpy((void *)*key_handle, handle, *handle_len);
+            }
         }
     }
 
-    /* Padding */
-    i = 1;
-    while(decrypted->dataptr < decrypted->data + decrypted->len) {
-        if(*decrypted->dataptr != i) {
-            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Wrong padding");
-            ret = -1;
-            goto clean_exit;
-        }
-        i++;
-        decrypted->dataptr++;
-    }
+    ctx = EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL,
+                                      (const unsigned char *)pub_key,
+                                      LIBSSH2_ED25519_KEY_LEN);
 
     if(ret == 0) {
-        _libssh2_debug(session,
+        _libssh2_debug((session,
                        LIBSSH2_TRACE_AUTH,
                        "Computing public key from ED25519 "
-                       "private key envelope");
+                       "private key envelope"));
 
-        method_buf = LIBSSH2_ALLOC(session, 11);  /* ssh-ed25519. */
-        if(method_buf == NULL) {
+        /* sk-ssh-ed25519@openssh.com. */
+        method_buf = LIBSSH2_ALLOC(session, strlen(key_type));
+        if(!method_buf) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for ED25519 key");
             goto clean_exit;
         }
 
-        /* Key form is: type_len(4) + type(11) + pub_key_len(4) +
-           pub_key(32). */
-        key_len = LIBSSH2_ED25519_KEY_LEN + 19;
+        /* Key form is: type_len(4) + type(26) + pub_key_len(4) +
+           pub_key(32) + application_len(4) + application(X). */
+        key_len = LIBSSH2_ED25519_KEY_LEN + 38 + app_len;
         key = LIBSSH2_CALLOC(session, key_len);
-        if(key == NULL) {
+        if(!key) {
             _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                            "Unable to allocate memory for ED25519 key");
             goto clean_exit;
@@ -1707,30 +2472,37 @@ gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
 
         p = key;
 
-        _libssh2_store_str(&p, "ssh-ed25519", 11);
+        _libssh2_store_str(&p, key_type, strlen(key_type));
         _libssh2_store_str(&p, (const char *)pub_key, LIBSSH2_ED25519_KEY_LEN);
+        _libssh2_store_str(&p, (const char *)app, app_len);
 
-        memcpy(method_buf, "ssh-ed25519", 11);
+        if(application && app_len > 0) {
+            *application = (const char *)LIBSSH2_ALLOC(session, app_len + 1);
+            _libssh2_explicit_zero((void *)*application, app_len + 1);
+            memcpy((void *)*application, app, app_len);
+        }
 
-        if(method != NULL)
+        memcpy(method_buf, key_type, strlen(key_type));
+
+        if(method)
             *method = method_buf;
         else
             LIBSSH2_FREE(session, method_buf);
 
-        if(method_len != NULL)
-            *method_len = 11;
+        if(method_len)
+            *method_len = strlen(key_type);
 
-        if(pubkeydata != NULL)
+        if(pubkeydata)
             *pubkeydata = key;
-        else
+        else if(key)
             LIBSSH2_FREE(session, key);
 
-        if(pubkeydata_len != NULL)
+        if(pubkeydata_len)
             *pubkeydata_len = key_len;
 
-        if(out_ctx != NULL)
+        if(out_ctx)
             *out_ctx = ctx;
-        else if(ctx != NULL)
+        else if(ctx)
             _libssh2_ed25519_free(ctx);
 
         return 0;
@@ -1747,6 +2519,16 @@ gen_publickey_from_ed25519_openssh_priv_data(LIBSSH2_SESSION *session,
     if(key)
         LIBSSH2_FREE(session, key);
 
+    if(application && *application) {
+        LIBSSH2_FREE(session, (void *)application);
+        *application = NULL;
+    }
+
+    if(key_handle && *key_handle) {
+        LIBSSH2_FREE(session, (void *)key_handle);
+        *key_handle = NULL;
+    }
+
     return -1;
 }
 
@@ -1761,7 +2543,7 @@ _libssh2_ed25519_new_private(libssh2_ed25519_ctx ** ed_ctx,
     struct string_buf *decrypted = NULL;
     libssh2_ed25519_ctx *ctx = NULL;
 
-    if(session == NULL) {
+    if(!session) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Session is required");
         return -1;
@@ -1785,19 +2567,16 @@ _libssh2_ed25519_new_private(libssh2_ed25519_ctx ** ed_ctx,
     /* We have a new key file, now try and parse it using supported types  */
     rc = _libssh2_get_string(decrypted, &buf, NULL);
 
-    if(rc != 0 || buf == NULL) {
+    if(rc || !buf) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Public key type in decrypted key data not found");
         return -1;
     }
 
     if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
-        rc = gen_publickey_from_ed25519_openssh_priv_data(session,
-                                                          decrypted,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
-                                                          NULL,
+        rc = gen_publickey_from_ed25519_openssh_priv_data(session, decrypted,
+                                                          NULL, NULL,
+                                                          NULL, NULL,
                                                           &ctx);
     }
     else {
@@ -1808,9 +2587,83 @@ _libssh2_ed25519_new_private(libssh2_ed25519_ctx ** ed_ctx,
         _libssh2_string_buf_free(session, decrypted);
 
     if(rc == 0) {
-        if(ed_ctx != NULL)
+        if(ed_ctx)
+            *ed_ctx = ctx;
+        else if(ctx)
+            _libssh2_ed25519_free(ctx);
+    }
+
+    return rc;
+}
+
+int
+_libssh2_ed25519_new_private_sk(libssh2_ed25519_ctx **ed_ctx,
+                                unsigned char *flags,
+                                const char **application,
+                                const unsigned char **key_handle,
+                                size_t *handle_len,
+                                LIBSSH2_SESSION *session,
+                                const char *filename,
+                                const uint8_t *passphrase)
+{
+    int rc;
+    FILE *fp;
+    unsigned char *buf;
+    struct string_buf *decrypted = NULL;
+    libssh2_ed25519_ctx *ctx = NULL;
+
+    if(!session) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Session is required");
+        return -1;
+    }
+
+    _libssh2_init_if_needed();
+
+    fp = fopen(filename, "r");
+    if(!fp) {
+        _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                       "Unable to open ED25519 SK private key file");
+        return -1;
+    }
+
+    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
+    fclose(fp);
+    if(rc) {
+        return rc;
+    }
+
+    /* We have a new key file, now try and parse it using supported types  */
+    rc = _libssh2_get_string(decrypted, &buf, NULL);
+
+    if(rc || !buf) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Public key type in decrypted key data not found");
+        return -1;
+    }
+
+    if(strcmp("sk-ssh-ed25519@openssh.com", (const char *)buf) == 0) {
+        rc = gen_publickey_from_sk_ed25519_openssh_priv_data(session,
+                                                             decrypted,
+                                                             NULL, NULL,
+                                                             NULL, NULL,
+                                                             flags,
+                                                             application,
+                                                             key_handle,
+                                                             handle_len,
+                                                             &ctx);
+    }
+    else {
+        rc = -1;
+    }
+
+    if(decrypted)
+        _libssh2_string_buf_free(session, decrypted);
+
+    if(rc == 0) {
+        if(ed_ctx)
             *ed_ctx = ctx;
-        else if(ctx != NULL)
+        else if(ctx)
             _libssh2_ed25519_free(ctx);
     }
 
@@ -1831,7 +2684,8 @@ _libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx ** ed_ctx,
     if(read_private_key_from_memory((void **)&ctx,
                                     (pem_read_bio_func)
                                     &PEM_read_bio_PrivateKey,
-                                    filedata, filedata_len, passphrase) == 0) {
+                                    filedata, filedata_len,
+                                    passphrase) == 0) {
         if(EVP_PKEY_id(ctx) != EVP_PKEY_ED25519) {
             _libssh2_ed25519_free(ctx);
             return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
@@ -1842,21 +2696,51 @@ _libssh2_ed25519_new_private_frommemory(libssh2_ed25519_ctx ** ed_ctx,
         return 0;
     }
 
-    return read_openssh_private_key_from_memory((void **)ed_ctx, session,
-                                                "ssh-ed25519",
-                                                filedata, filedata_len,
-                                                passphrase);
+    return _libssh2_pub_priv_openssh_keyfilememory(session, (void **)ed_ctx,
+                                                   "ssh-ed25519",
+                                                   NULL, NULL, NULL, NULL,
+                                                   filedata, filedata_len,
+                                                   passphrase);
+}
+
+int
+_libssh2_ed25519_new_private_frommemory_sk(libssh2_ed25519_ctx **ed_ctx,
+                                           unsigned char *flags,
+                                           const char **application,
+                                           const unsigned char **key_handle,
+                                           size_t *handle_len,
+                                           LIBSSH2_SESSION *session,
+                                           const char *filedata,
+                                           size_t filedata_len,
+                                           unsigned const char *passphrase)
+{
+    int algorithm;
+    return _libssh2_sk_pub_openssh_keyfilememory(session,
+                                                 (void **)ed_ctx,
+                                                 "sk-ssh-ed25519@openssh.com",
+                                                 NULL,
+                                                 NULL,
+                                                 NULL,
+                                                 NULL,
+                                                 &algorithm,
+                                                 flags,
+                                                 application,
+                                                 key_handle,
+                                                 handle_len,
+                                                 filedata,
+                                                 filedata_len,
+                                                 passphrase);
 }
 
 int
 _libssh2_ed25519_new_public(libssh2_ed25519_ctx ** ed_ctx,
                             LIBSSH2_SESSION * session,
                             const unsigned char *raw_pub_key,
-                            const uint8_t key_len)
+                            const size_t key_len)
 {
     libssh2_ed25519_ctx *ctx = NULL;
 
-    if(ed_ctx == NULL)
+    if(!ed_ctx)
         return -1;
 
     ctx = EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL,
@@ -1865,7 +2749,7 @@ _libssh2_ed25519_new_public(libssh2_ed25519_ctx ** ed_ctx,
         return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                               "could not create ED25519 public key");
 
-    if(ed_ctx != NULL)
+    if(ed_ctx)
         *ed_ctx = ctx;
     else if(ctx)
         _libssh2_ed25519_free(ctx);
@@ -1875,25 +2759,81 @@ _libssh2_ed25519_new_public(libssh2_ed25519_ctx ** ed_ctx,
 #endif /* LIBSSH2_ED25519 */
 
 
+#if LIBSSH2_RSA
 int
-_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
+_libssh2_rsa_sha2_sign(LIBSSH2_SESSION * session,
                        libssh2_rsa_ctx * rsactx,
                        const unsigned char *hash,
                        size_t hash_len,
                        unsigned char **signature, size_t *signature_len)
 {
-    int ret;
-    unsigned char *sig;
-    unsigned int sig_len;
+    int ret = -1;
+    unsigned char *sig = NULL;
+
+#ifdef USE_OPENSSL_3
+    size_t sig_len = 0;
+    BIGNUM *n = NULL;
+    const EVP_MD *md = NULL;
+
+    if(EVP_PKEY_get_bn_param(rsactx, OSSL_PKEY_PARAM_RSA_N, &n) > 0) {
+        sig_len = BN_num_bytes(n);
+        BN_clear_free(n);
+    }
+
+    if(sig_len > 0)
+        sig = LIBSSH2_ALLOC(session, sig_len);
+#else
+    unsigned int sig_len = 0;
 
     sig_len = RSA_size(rsactx);
     sig = LIBSSH2_ALLOC(session, sig_len);
+#endif
 
     if(!sig) {
         return -1;
     }
 
-    ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
+#ifdef USE_OPENSSL_3
+    if(hash_len == SHA_DIGEST_LENGTH)
+        md = EVP_sha1();
+    else if(hash_len == SHA256_DIGEST_LENGTH)
+        md = EVP_sha256();
+    else if(hash_len == SHA512_DIGEST_LENGTH)
+        md = EVP_sha512();
+    else {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Unsupported hash digest length");
+    }
+
+    if(md) {
+        EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsactx, NULL);
+        if(ctx &&
+           EVP_PKEY_sign_init(ctx) > 0 &&
+           EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) > 0 &&
+           EVP_PKEY_CTX_set_signature_md(ctx, md) > 0) {
+            ret = EVP_PKEY_sign(ctx, sig, &sig_len, hash, hash_len);
+        }
+
+        if(ctx) {
+            EVP_PKEY_CTX_free(ctx);
+        }
+    }
+#else
+    if(hash_len == SHA_DIGEST_LENGTH)
+        ret = RSA_sign(NID_sha1,
+                       hash, (unsigned int) hash_len, sig, &sig_len, rsactx);
+    else if(hash_len == SHA256_DIGEST_LENGTH)
+        ret = RSA_sign(NID_sha256,
+                       hash, (unsigned int) hash_len, sig, &sig_len, rsactx);
+    else if(hash_len == SHA512_DIGEST_LENGTH)
+        ret = RSA_sign(NID_sha512,
+                       hash, (unsigned int) hash_len, sig, &sig_len, rsactx);
+    else {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Unsupported hash digest length");
+        ret = -1;
+    }
+#endif
 
     if(!ret) {
         LIBSSH2_FREE(session, sig);
@@ -1906,19 +2846,61 @@ _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
     return 0;
 }
 
+#if LIBSSH2_RSA_SHA1
+int
+_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
+                       libssh2_rsa_ctx * rsactx,
+                       const unsigned char *hash,
+                       size_t hash_len,
+                       unsigned char **signature, size_t *signature_len)
+{
+    return _libssh2_rsa_sha2_sign(session, rsactx, hash, hash_len,
+                                  signature, signature_len);
+}
+#endif
+#endif
+
 #if LIBSSH2_DSA
 int
 _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
                        const unsigned char *hash,
-                       unsigned long hash_len, unsigned char *signature)
+                       size_t hash_len, unsigned char *signature)
 {
-    DSA_SIG *sig;
+    DSA_SIG *sig = NULL;
     const BIGNUM * r;
     const BIGNUM * s;
     int r_len, s_len;
-    (void) hash_len;
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(dsactx, NULL);
+    unsigned char *buf = NULL;
+    size_t sig_len = 0;
+    int size = 0;
+
+    if(EVP_PKEY_get_int_param(dsactx, OSSL_PKEY_PARAM_MAX_SIZE, &size) > 0) {
+        sig_len = size;
+        buf = OPENSSL_malloc(size);
+    }
+
+    if(buf && ctx && EVP_PKEY_sign_init(ctx) > 0) {
+        EVP_PKEY_sign(ctx, buf, &sig_len, hash, hash_len);
+    }
+
+    if(ctx) {
+        EVP_PKEY_CTX_free(ctx);
+    }
+
+    if(buf) {
+        const unsigned char *in = buf;
+        d2i_DSA_SIG(&sig, &in, (long)sig_len);
+        OPENSSL_clear_free(buf, size);
+    }
+#else
+    (void)hash_len;
 
     sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx);
+#endif
+
     if(!sig) {
         return -1;
     }
@@ -1930,20 +2912,20 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
     s = sig->s;
 #endif
     r_len = BN_num_bytes(r);
-    if(r_len < 1 || r_len > 20) {
+    if(r_len < 1 || r_len > SHA_DIGEST_LENGTH) {
         DSA_SIG_free(sig);
         return -1;
     }
     s_len = BN_num_bytes(s);
-    if(s_len < 1 || s_len > 20) {
+    if(s_len < 1 || s_len > SHA_DIGEST_LENGTH) {
         DSA_SIG_free(sig);
         return -1;
     }
 
-    memset(signature, 0, 40);
+    memset(signature, 0, SHA_DIGEST_LENGTH * 2);
 
-    BN_bn2bin(r, signature + (20 - r_len));
-    BN_bn2bin(s, signature + 20 + (20 - s_len));
+    BN_bn2bin(r, signature + (SHA_DIGEST_LENGTH - r_len));
+    BN_bn2bin(s, signature + SHA_DIGEST_LENGTH + (SHA_DIGEST_LENGTH - s_len));
 
     DSA_SIG_free(sig);
 
@@ -1955,8 +2937,8 @@ _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
 
 int
 _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
-    const unsigned char *hash, unsigned long hash_len,
-    unsigned char **signature, size_t *signature_len)
+                    const unsigned char *hash, size_t hash_len,
+                    unsigned char **signature, size_t *signature_len)
 {
     int r_len, s_len;
     int rc = 0;
@@ -1965,10 +2947,47 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     const BIGNUM *pr = NULL, *ps = NULL;
     unsigned char *temp_buffer = NULL;
     unsigned char *out_buffer = NULL;
+    ECDSA_SIG *sig = NULL;
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(ec_ctx, NULL);
+    const unsigned char *p = NULL;
+    rc = -1;
+
+    if(!ctx) {
+        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                              "out of memory");
+    }
+
+    out_buffer_len = EVP_PKEY_get_size(ec_ctx);
+    temp_buffer = LIBSSH2_ALLOC(session, out_buffer_len);
+    if(!temp_buffer) {
+        goto clean_exit;
+    }
+
+    rc = EVP_PKEY_sign_init(ctx);
+    if(rc <= 0) {
+        rc = -1;
+        goto clean_exit;
+    }
+
+    rc = EVP_PKEY_sign(ctx, temp_buffer, &out_buffer_len, hash, hash_len);
+    if(rc <= 0) {
+        rc = -1;
+        goto clean_exit;
+    }
+
+    rc = 0;
 
-    ECDSA_SIG *sig = ECDSA_do_sign(hash, hash_len, ec_ctx);
-    if(sig == NULL)
+    p = temp_buffer;
+    sig = d2i_ECDSA_SIG(NULL, &p, (long)out_buffer_len);
+    OPENSSL_clear_free(temp_buffer, out_buffer_len);
+#else
+    sig = ECDSA_do_sign(hash, (int)hash_len, ec_ctx);
+    if(!sig)
         return -1;
+#endif
+
 #ifdef HAVE_OPAQUE_STRUCTS
     ECDSA_SIG_get0(sig, &pr, &ps);
 #else
@@ -1980,7 +2999,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     s_len = BN_num_bytes(ps) + 1;
 
     temp_buffer = malloc(r_len + s_len + 8);
-    if(temp_buffer == NULL) {
+    if(!temp_buffer) {
         rc = -1;
         goto clean_exit;
     }
@@ -1992,7 +3011,7 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
     out_buffer_len = (size_t)(sp - temp_buffer);
 
     out_buffer = LIBSSH2_CALLOC(session, out_buffer_len);
-    if(out_buffer == NULL) {
+    if(!out_buffer) {
         rc = -1;
         goto clean_exit;
     }
@@ -2004,12 +3023,17 @@ _libssh2_ecdsa_sign(LIBSSH2_SESSION * session, libssh2_ecdsa_ctx * ec_ctx,
 
 clean_exit:
 
-    if(temp_buffer != NULL)
+    if(temp_buffer)
         free(temp_buffer);
 
     if(sig)
         ECDSA_SIG_free(sig);
 
+#ifdef USE_OPENSSL_3
+    if(ctx)
+        EVP_PKEY_CTX_free(ctx);
+#endif
+
     return rc;
 }
 #endif /* LIBSSH2_ECDSA */
@@ -2020,7 +3044,7 @@ _libssh2_sha1_init(libssh2_sha1_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if(*ctx == NULL)
+    if(!*ctx)
         return 0;
 
     if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha1")))
@@ -2037,13 +3061,37 @@ _libssh2_sha1_init(libssh2_sha1_ctx *ctx)
 }
 
 int
-_libssh2_sha1(const unsigned char *message, unsigned long len,
+_libssh2_sha1_update(libssh2_sha1_ctx *ctx,
+                     const void *data, size_t len)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    return EVP_DigestUpdate(*ctx, data, len);
+#else
+    return EVP_DigestUpdate(ctx, data, len);
+#endif
+}
+
+int
+_libssh2_sha1_final(libssh2_sha1_ctx *ctx,
+                    unsigned char *out)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    int ret = EVP_DigestFinal(*ctx, out, NULL);
+    EVP_MD_CTX_free(*ctx);
+    return ret;
+#else
+    return EVP_DigestFinal(ctx, out, NULL);
+#endif
+}
+
+int
+_libssh2_sha1(const unsigned char *message, size_t len,
               unsigned char *out)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if(ctx == NULL)
+    if(!ctx)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha1"))) {
@@ -2072,7 +3120,7 @@ _libssh2_sha256_init(libssh2_sha256_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if(*ctx == NULL)
+    if(!*ctx)
         return 0;
 
     if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha256")))
@@ -2089,13 +3137,37 @@ _libssh2_sha256_init(libssh2_sha256_ctx *ctx)
 }
 
 int
-_libssh2_sha256(const unsigned char *message, unsigned long len,
+_libssh2_sha256_update(libssh2_sha256_ctx *ctx,
+                       const void *data, size_t len)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    return EVP_DigestUpdate(*ctx, data, len);
+#else
+    return EVP_DigestUpdate(ctx, data, len);
+#endif
+}
+
+int
+_libssh2_sha256_final(libssh2_sha256_ctx *ctx,
+                      unsigned char *out)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    int ret = EVP_DigestFinal(*ctx, out, NULL);
+    EVP_MD_CTX_free(*ctx);
+    return ret;
+#else
+    return EVP_DigestFinal(ctx, out, NULL);
+#endif
+}
+
+int
+_libssh2_sha256(const unsigned char *message, size_t len,
                 unsigned char *out)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if(ctx == NULL)
+    if(!ctx)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha256"))) {
@@ -2124,7 +3196,7 @@ _libssh2_sha384_init(libssh2_sha384_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if(*ctx == NULL)
+    if(!*ctx)
         return 0;
 
     if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha384")))
@@ -2141,13 +3213,37 @@ _libssh2_sha384_init(libssh2_sha384_ctx *ctx)
 }
 
 int
-_libssh2_sha384(const unsigned char *message, unsigned long len,
-    unsigned char *out)
+_libssh2_sha384_update(libssh2_sha384_ctx *ctx,
+                       const void *data, size_t len)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    return EVP_DigestUpdate(*ctx, data, len);
+#else
+    return EVP_DigestUpdate(ctx, data, len);
+#endif
+}
+
+int
+_libssh2_sha384_final(libssh2_sha384_ctx *ctx,
+                      unsigned char *out)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    int ret = EVP_DigestFinal(*ctx, out, NULL);
+    EVP_MD_CTX_free(*ctx);
+    return ret;
+#else
+    return EVP_DigestFinal(ctx, out, NULL);
+#endif
+}
+
+int
+_libssh2_sha384(const unsigned char *message, size_t len,
+                unsigned char *out)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if(ctx == NULL)
+    if(!ctx)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha384"))) {
@@ -2176,7 +3272,7 @@ _libssh2_sha512_init(libssh2_sha512_ctx *ctx)
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if(*ctx == NULL)
+    if(!*ctx)
         return 0;
 
     if(EVP_DigestInit(*ctx, EVP_get_digestbyname("sha512")))
@@ -2193,13 +3289,37 @@ _libssh2_sha512_init(libssh2_sha512_ctx *ctx)
 }
 
 int
-_libssh2_sha512(const unsigned char *message, unsigned long len,
-    unsigned char *out)
+_libssh2_sha512_update(libssh2_sha512_ctx *ctx,
+                       const void *data, size_t len)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    return EVP_DigestUpdate(*ctx, data, len);
+#else
+    return EVP_DigestUpdate(ctx, data, len);
+#endif
+}
+
+int
+_libssh2_sha512_final(libssh2_sha512_ctx *ctx,
+                      unsigned char *out)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    int ret = EVP_DigestFinal(*ctx, out, NULL);
+    EVP_MD_CTX_free(*ctx);
+    return ret;
+#else
+    return EVP_DigestFinal(ctx, out, NULL);
+#endif
+}
+
+int
+_libssh2_sha512(const unsigned char *message, size_t len,
+                unsigned char *out)
 {
 #ifdef HAVE_OPAQUE_STRUCTS
     EVP_MD_CTX * ctx = EVP_MD_CTX_new();
 
-    if(ctx == NULL)
+    if(!ctx)
         return 1; /* error */
 
     if(EVP_DigestInit(ctx, EVP_get_digestbyname("sha512"))) {
@@ -2222,6 +3342,7 @@ _libssh2_sha512(const unsigned char *message, unsigned long len,
     return 1; /* error */
 }
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 int
 _libssh2_md5_init(libssh2_md5_ctx *ctx)
 {
@@ -2231,17 +3352,17 @@ _libssh2_md5_init(libssh2_md5_ctx *ctx)
      * So, just return 0 in FIPS mode
      */
 #if OPENSSL_VERSION_NUMBER >= 0x000907000L && \
-    defined(OPENSSL_VERSION_MAJOR) && \
-    OPENSSL_VERSION_MAJOR < 3 && \
+    !defined(USE_OPENSSL_3) && \
     !defined(LIBRESSL_VERSION_NUMBER)
-     if(FIPS_mode() != 0)
-         return 0;
+
+    if(FIPS_mode())
+        return 0;
 #endif
 
 #ifdef HAVE_OPAQUE_STRUCTS
     *ctx = EVP_MD_CTX_new();
 
-    if(*ctx == NULL)
+    if(!*ctx)
         return 0;
 
     if(EVP_DigestInit(*ctx, EVP_get_digestbyname("md5")))
@@ -2257,6 +3378,31 @@ _libssh2_md5_init(libssh2_md5_ctx *ctx)
 #endif
 }
 
+int
+_libssh2_md5_update(libssh2_md5_ctx *ctx,
+                    const void *data, size_t len)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    return EVP_DigestUpdate(*ctx, data, len);
+#else
+    return EVP_DigestUpdate(ctx, data, len);
+#endif
+}
+
+int
+_libssh2_md5_final(libssh2_md5_ctx *ctx,
+                   unsigned char *out)
+{
+#ifdef HAVE_OPAQUE_STRUCTS
+    int ret = EVP_DigestFinal(*ctx, out, NULL);
+    EVP_MD_CTX_free(*ctx);
+    return ret;
+#else
+    return EVP_DigestFinal(ctx, out, NULL);
+#endif
+}
+#endif
+
 #if LIBSSH2_ECDSA
 
 static int
@@ -2265,31 +3411,41 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
                           size_t *method_len,
                           unsigned char **pubkeydata,
                           size_t *pubkeydata_len,
+                          int is_sk,
                           EVP_PKEY *pk)
 {
     int rc = 0;
-    EC_KEY *ec = NULL;
     unsigned char *p;
     unsigned char *method_buf = NULL;
     unsigned char *key;
+    size_t  method_buf_len = 0;
     size_t  key_len = 0;
     unsigned char *octal_value = NULL;
     size_t octal_len;
-    const EC_POINT *public_key;
-    const EC_GROUP *group;
-    BN_CTX *bn_ctx;
     libssh2_curve_type type;
 
-    _libssh2_debug(session,
+#ifdef USE_OPENSSL_3
+    _libssh2_debug((session,
        LIBSSH2_TRACE_AUTH,
-       "Computing public key from EC private key envelope");
+       "Computing public key from EC private key envelope"));
+
+    type = _libssh2_ecdsa_get_curve_type(pk);
+#else
+    EC_KEY *ec = NULL;
+    const EC_POINT *public_key;
+    const EC_GROUP *group;
+    BN_CTX *bn_ctx = NULL;
+
+    _libssh2_debug((session,
+                   LIBSSH2_TRACE_AUTH,
+                   "Computing public key from EC private key envelope"));
 
     bn_ctx = BN_CTX_new();
-    if(bn_ctx == NULL)
+    if(!bn_ctx)
         return -1;
 
     ec = EVP_PKEY_get1_EC_KEY(pk);
-    if(ec == NULL) {
+    if(!ec) {
         rc = -1;
         goto clean_exit;
     }
@@ -2297,27 +3453,46 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     public_key = EC_KEY_get0_public_key(ec);
     group = EC_KEY_get0_group(ec);
     type = _libssh2_ecdsa_get_curve_type(ec);
+#endif
+
+    if(is_sk)
+        method_buf_len = 34;
+    else
+        method_buf_len = 19;
 
-    method_buf = LIBSSH2_ALLOC(session, 19);
-    if(method_buf == NULL) {
+    method_buf = LIBSSH2_ALLOC(session, method_buf_len);
+    if(!method_buf) {
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-            "out of memory");
+                              "out of memory");
     }
 
-    if(type == LIBSSH2_EC_CURVE_NISTP256)
-        memcpy(method_buf, "ecdsa-sha2-nistp256", 19);
-    else if(type == LIBSSH2_EC_CURVE_NISTP384)
-        memcpy(method_buf, "ecdsa-sha2-nistp384", 19);
-    else if(type == LIBSSH2_EC_CURVE_NISTP521)
-        memcpy(method_buf, "ecdsa-sha2-nistp521", 19);
+    if(is_sk) {
+        memcpy(method_buf, "sk-ecdsa-sha2-nistp256@openssh.com",
+               method_buf_len);
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP256) {
+        memcpy(method_buf, "ecdsa-sha2-nistp256", method_buf_len);
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP384) {
+        memcpy(method_buf, "ecdsa-sha2-nistp384", method_buf_len);
+    }
+    else if(type == LIBSSH2_EC_CURVE_NISTP521) {
+        memcpy(method_buf, "ecdsa-sha2-nistp521", method_buf_len);
+    }
     else {
-        _libssh2_debug(session,
-            LIBSSH2_TRACE_ERROR,
-            "Unsupported EC private key type");
+        _libssh2_debug((session,
+                       LIBSSH2_TRACE_ERROR,
+                       "Unsupported EC private key type"));
         rc = -1;
         goto clean_exit;
     }
 
+#ifdef USE_OPENSSL_3
+    octal_len = EC_MAX_POINT_LEN;
+    octal_value = LIBSSH2_ALLOC(session, octal_len);
+    EVP_PKEY_get_octet_string_param(pk, OSSL_PKEY_PARAM_PUB_KEY,
+                                    octal_value, octal_len, &octal_len);
+#else
     /* get length */
     octal_len = EC_POINT_point2oct(group, public_key,
                                    POINT_CONVERSION_UNCOMPRESSED,
@@ -2328,7 +3503,7 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     }
 
     octal_value = malloc(octal_len);
-    if(octal_value == NULL) {
+    if(!octal_value) {
         rc = -1;
         goto clean_exit;
     }
@@ -2336,52 +3511,64 @@ gen_publickey_from_ec_evp(LIBSSH2_SESSION *session,
     /* convert to octal */
     if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
        octal_value, octal_len, bn_ctx) != octal_len) {
-           rc = -1;
-           goto clean_exit;
+        rc = -1;
+        goto clean_exit;
     }
+#endif
 
-    /* Key form is: type_len(4) + type(19) + domain_len(4) + domain(8) +
-       pub_key_len(4) + pub_key(~65). */
-    key_len = 4 + 19 + 4 + 8 + 4 + octal_len;
+    /* Key form is: type_len(4) + type(method_buf_len) + domain_len(4)
+       + domain(8) + pub_key_len(4) + pub_key(~65). */
+    key_len = 4 + method_buf_len + 4 + 8 + 4 + octal_len;
     key = LIBSSH2_ALLOC(session, key_len);
-    if(key == NULL) {
+    if(!key) {
         rc = -1;
-        goto  clean_exit;
+        goto clean_exit;
     }
 
     /* Process key encoding. */
     p = key;
 
     /* Key type */
-    _libssh2_store_str(&p, (const char *)method_buf, 19);
+    _libssh2_store_str(&p, (const char *)method_buf, method_buf_len);
 
     /* Name domain */
-    _libssh2_store_str(&p, (const char *)method_buf + 11, 8);
+    if(is_sk) {
+        _libssh2_store_str(&p, "nistp256", 8);
+    }
+    else {
+        _libssh2_store_str(&p, (const char *)method_buf + 11, 8);
+    }
 
     /* Public key */
     _libssh2_store_str(&p, (const char *)octal_value, octal_len);
 
-    *method         = method_buf;
-    *method_len     = 19;
-    *pubkeydata     = key;
-    *pubkeydata_len = key_len;
+    *method = method_buf;
+    if(method_len) {
+        *method_len = method_buf_len;
+    }
+    *pubkeydata = key;
+    if(pubkeydata_len) {
+        *pubkeydata_len = key_len;
+    }
 
 clean_exit:
 
-    if(ec != NULL)
+#ifndef USE_OPENSSL_3
+    if(ec)
         EC_KEY_free(ec);
 
-    if(bn_ctx != NULL) {
+    if(bn_ctx) {
         BN_CTX_free(bn_ctx);
     }
+#endif
 
-    if(octal_value != NULL)
+    if(octal_value)
         free(octal_value);
 
     if(rc == 0)
         return 0;
 
-    if(method_buf != NULL)
+    if(method_buf)
         LIBSSH2_FREE(session, method_buf);
 
     return -1;
@@ -2400,12 +3587,20 @@ gen_publickey_from_ecdsa_openssh_priv_data(LIBSSH2_SESSION *session,
     int rc = 0;
     size_t curvelen, exponentlen, pointlen;
     unsigned char *curve, *exponent, *point_buf;
-    EC_KEY *ec_key = NULL;
+    libssh2_ecdsa_ctx *ec_key = NULL;
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *fromdata_ctx = NULL;
+    OSSL_PARAM params[4];
+    const char *n = EC_curve_nid2nist(curve_type);
+    char *group_name = NULL;
+#else
     BIGNUM *bn_exponent;
+#endif
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing ECDSA keys from private key data");
+                   "Computing ECDSA keys from private key data"));
 
     if(_libssh2_get_string(decrypted, &curve, &curvelen) ||
         curvelen == 0) {
@@ -2426,8 +3621,47 @@ gen_publickey_from_ecdsa_openssh_priv_data(LIBSSH2_SESSION *session,
         return -1;
     }
 
-    if((rc = _libssh2_ecdsa_curve_name_with_octal_new(&ec_key, point_buf,
-        pointlen, curve_type)) != 0) {
+#ifdef USE_OPENSSL_3
+    if(!n)
+        return -1;
+
+    fromdata_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
+
+    if(!fromdata_ctx)
+        goto fail;
+
+    group_name = OPENSSL_zalloc(strlen(n) + 1);
+
+    if(!group_name)
+        goto fail;
+
+    memcpy(group_name, n, strlen(n));
+    _libssh2_swap_bytes(exponent, (unsigned long)exponentlen);
+
+    params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
+                                                 group_name, 0);
+
+    params[1] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
+                                                  point_buf, pointlen);
+
+    params[2] = OSSL_PARAM_construct_BN(OSSL_PKEY_PARAM_PRIV_KEY, exponent,
+                                        exponentlen);
+
+    params[3] = OSSL_PARAM_construct_end();
+
+    if(EVP_PKEY_fromdata_init(fromdata_ctx) <= 0)
+        goto fail;
+
+    rc = EVP_PKEY_fromdata(fromdata_ctx, &ec_key, EVP_PKEY_KEYPAIR, params);
+    rc = rc != 1;
+
+    if(group_name)
+        OPENSSL_clear_free(group_name, strlen(n));
+#else
+    rc = _libssh2_ecdsa_curve_name_with_octal_new(&ec_key,
+                                                  point_buf, pointlen,
+                                                  curve_type);
+    if(rc) {
         rc = -1;
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "ECDSA could not create key");
@@ -2435,42 +3669,205 @@ gen_publickey_from_ecdsa_openssh_priv_data(LIBSSH2_SESSION *session,
     }
 
     bn_exponent = BN_new();
-    if(bn_exponent == NULL) {
+    if(!bn_exponent) {
         rc = -1;
         _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                        "Unable to allocate memory for private key data");
         goto fail;
     }
 
-    BN_bin2bn(exponent, exponentlen, bn_exponent);
+    BN_bin2bn(exponent, (int) exponentlen, bn_exponent);
     rc = (EC_KEY_set_private_key(ec_key, bn_exponent) != 1);
+#endif
+
+    if(rc == 0 && ec_key && pubkeydata && method) {
+#ifdef USE_OPENSSL_3
+        EVP_PKEY *pk = ec_key;
+#else
+        EVP_PKEY *pk = EVP_PKEY_new();
+        EVP_PKEY_set1_EC_KEY(pk, ec_key);
+#endif
+
+        rc = gen_publickey_from_ec_evp(session, method, method_len,
+                                       pubkeydata, pubkeydata_len,
+                                       0, pk);
+
+#ifndef USE_OPENSSL_3
+        if(pk)
+            EVP_PKEY_free(pk);
+#endif
+    }
+
+#ifdef USE_OPENSSL_3
+    if(fromdata_ctx)
+        EVP_PKEY_CTX_free(fromdata_ctx);
+#endif
+
+    if(ec_ctx)
+        *ec_ctx = ec_key;
+    else
+        _libssh2_ecdsa_free(ec_key);
+
+    return rc;
+
+fail:
+#ifdef USE_OPENSSL_3
+    if(fromdata_ctx)
+        EVP_PKEY_CTX_free(fromdata_ctx);
+#endif
+
+    if(ec_key)
+        _libssh2_ecdsa_free(ec_key);
+
+    return rc;
+}
+
+static int
+gen_publickey_from_sk_ecdsa_openssh_priv_data(LIBSSH2_SESSION *session,
+                                              struct string_buf *decrypted,
+                                              unsigned char **method,
+                                              size_t *method_len,
+                                              unsigned char **pubkeydata,
+                                              size_t *pubkeydata_len,
+                                              uint8_t *flags,
+                                              const char **application,
+                                              const unsigned char **key_handle,
+                                              size_t *handle_len,
+                                              libssh2_ecdsa_ctx **ec_ctx)
+{
+    int rc = 0;
+    size_t curvelen, pointlen, key_len, app_len;
+    unsigned char *curve, *point_buf, *p, *key, *app;
+    libssh2_ecdsa_ctx *ec_key = NULL;
+
+    _libssh2_debug((session,
+                   LIBSSH2_TRACE_AUTH,
+                   "Extracting ECDSA-SK public key"));
+
+    if(_libssh2_get_string(decrypted, &curve, &curvelen) ||
+        curvelen == 0) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "ECDSA no curve");
+        return -1;
+    }
+
+    if(_libssh2_get_string(decrypted, &point_buf, &pointlen)) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "ECDSA no point");
+        return -1;
+    }
+
+    rc = _libssh2_ecdsa_curve_name_with_octal_new(&ec_key,
+                                                  point_buf, pointlen,
+                                                  LIBSSH2_EC_CURVE_NISTP256);
+    if(rc) {
+        rc = -1;
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "ECDSA could not create key");
+        goto fail;
+    }
+
+    if(_libssh2_get_string(decrypted, &app, &app_len)) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "No SK application.");
+        goto fail;
+    }
+
+    if(flags && _libssh2_get_byte(decrypted, flags)) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "No SK flags.");
+        goto fail;
+    }
+
+    if(key_handle && handle_len) {
+        unsigned char *handle = NULL;
+        if(_libssh2_get_string(decrypted, &handle, handle_len)) {
+            _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                           "No SK key_handle.");
+            goto fail;
+        }
+
+        if(*handle_len > 0) {
+            *key_handle = LIBSSH2_ALLOC(session, *handle_len);
+
+            if(*key_handle) {
+                memcpy((void *)*key_handle, handle, *handle_len);
+            }
+        }
+    }
 
-    if(rc == 0 && ec_key != NULL && pubkeydata != NULL && method != NULL) {
+    if(rc == 0 && ec_key && pubkeydata && method) {
+#ifdef USE_OPENSSL_3
+        EVP_PKEY *pk = ec_key;
+#else
         EVP_PKEY *pk = EVP_PKEY_new();
         EVP_PKEY_set1_EC_KEY(pk, ec_key);
+#endif
 
         rc = gen_publickey_from_ec_evp(session, method, method_len,
                                        pubkeydata, pubkeydata_len,
-                                       pk);
+                                       1, pk);
 
+#ifndef USE_OPENSSL_3
         if(pk)
             EVP_PKEY_free(pk);
+#endif
+    }
+
+    if(rc == 0 && pubkeydata) {
+        key_len = *pubkeydata_len + app_len + 4;
+        key = LIBSSH2_ALLOC(session, key_len);
+
+        if(!key) {
+            rc = -1;
+            goto fail;
+        }
+
+        p = key + *pubkeydata_len;
+
+        memcpy(key, *pubkeydata, *pubkeydata_len);
+        _libssh2_store_str(&p, (const char *)app, app_len);
+
+        if(application && app_len > 0) {
+            *application = (const char *)LIBSSH2_ALLOC(session, app_len + 1);
+            _libssh2_explicit_zero((void *)*application, app_len + 1);
+            memcpy((void *)*application, app, app_len);
+        }
+
+        LIBSSH2_FREE(session, *pubkeydata);
+        *pubkeydata_len = key_len;
+
+        if(pubkeydata)
+            *pubkeydata = key;
+        else if(key)
+            LIBSSH2_FREE(session, key);
     }
 
-    if(ec_ctx != NULL)
+    if(ec_ctx)
         *ec_ctx = ec_key;
     else
-        EC_KEY_free(ec_key);
+        _libssh2_ecdsa_free(ec_key);
 
     return rc;
 
 fail:
-    if(ec_key != NULL)
-        EC_KEY_free(ec_key);
+    if(ec_key)
+        _libssh2_ecdsa_free(ec_key);
+
+    if(application && *application) {
+        LIBSSH2_FREE(session, (void *)application);
+        *application = NULL;
+    }
+
+    if(key_handle && *key_handle) {
+        LIBSSH2_FREE(session, (void *)key_handle);
+        *key_handle = NULL;
+    }
 
     return rc;
 }
 
+
 static int
 _libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx ** ec_ctx,
                                    LIBSSH2_SESSION * session,
@@ -2483,9 +3880,9 @@ _libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx ** ec_ctx,
     libssh2_curve_type type;
     struct string_buf *decrypted = NULL;
 
-    if(session == NULL) {
+    if(!session) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Session is required");
+                       "Session is required");
         return -1;
     }
 
@@ -2507,7 +3904,7 @@ _libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx ** ec_ctx,
     /* We have a new key file, now try and parse it using supported types  */
     rc = _libssh2_get_string(decrypted, &buf, NULL);
 
-    if(rc != 0 || buf == NULL) {
+    if(rc || !buf) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Public key type in decrypted key data not found");
         return -1;
@@ -2517,8 +3914,75 @@ _libssh2_ecdsa_new_openssh_private(libssh2_ecdsa_ctx ** ec_ctx,
 
     if(rc == 0) {
         rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
-                                                        decrypted, NULL, 0,
-                                                        NULL, 0, ec_ctx);
+                                                        decrypted,
+                                                        NULL, NULL,
+                                                        NULL, NULL, ec_ctx);
+    }
+    else {
+        rc = -1;
+    }
+
+    if(decrypted)
+        _libssh2_string_buf_free(session, decrypted);
+
+    return rc;
+}
+
+static int
+_libssh2_ecdsa_new_openssh_private_sk(libssh2_ecdsa_ctx ** ec_ctx,
+                                      uint8_t *flags,
+                                      const char **application,
+                                      const unsigned char **key_handle,
+                                      size_t *handle_len,
+                                      LIBSSH2_SESSION * session,
+                                      const char *filename,
+                                      unsigned const char *passphrase)
+{
+    FILE *fp;
+    int rc;
+    unsigned char *buf = NULL;
+    struct string_buf *decrypted = NULL;
+
+    if(!session) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Session is required");
+        return -1;
+    }
+
+    _libssh2_init_if_needed();
+
+    fp = fopen(filename, "r");
+    if(!fp) {
+        _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                       "Unable to open OpenSSH ECDSA private key file");
+        return -1;
+    }
+
+    rc = _libssh2_openssh_pem_parse(session, passphrase, fp, &decrypted);
+    fclose(fp);
+    if(rc) {
+        return rc;
+    }
+
+    /* We have a new key file, now try and parse it using supported types  */
+    rc = _libssh2_get_string(decrypted, &buf, NULL);
+
+    if(rc || !buf) {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Public key type in decrypted key data not found");
+        return -1;
+    }
+
+    if(strcmp("sk-ecdsa-sha2-nistp256@openssh.com", (const char *)buf) == 0) {
+        rc = gen_publickey_from_sk_ecdsa_openssh_priv_data(session,
+                                                           decrypted,
+                                                           NULL, NULL,
+                                                           NULL, NULL,
+                                                           flags,
+                                                           application,
+                                                           key_handle,
+                                                           handle_len,
+                                                           ec_ctx);
     }
     else {
         rc = -1;
@@ -2537,12 +4001,18 @@ _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
 {
     int rc;
 
-    pem_read_bio_func read_ec = (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_ec =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
+    pem_read_bio_func read_ec =
+        (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
+#endif
 
     _libssh2_init_if_needed();
 
     rc = read_private_key_from_file((void **) ec_ctx, read_ec,
-      filename, passphrase);
+                                    filename, passphrase);
 
     if(rc) {
         return _libssh2_ecdsa_new_openssh_private(ec_ctx, session,
@@ -2552,6 +4022,46 @@ _libssh2_ecdsa_new_private(libssh2_ecdsa_ctx ** ec_ctx,
     return rc;
 }
 
+int
+_libssh2_ecdsa_new_private_sk(libssh2_ecdsa_ctx ** ec_ctx,
+                              unsigned char *flags,
+                              const char **application,
+                              const unsigned char **key_handle,
+                              size_t *handle_len,
+                              LIBSSH2_SESSION * session,
+                              const char *filename,
+                              unsigned const char *passphrase)
+{
+    int rc;
+
+#if defined(USE_OPENSSL_3)
+    pem_read_bio_func read_ec =
+        (pem_read_bio_func) &PEM_read_bio_PrivateKey;
+#else
+    pem_read_bio_func read_ec =
+        (pem_read_bio_func) &PEM_read_bio_ECPrivateKey;
+#endif
+
+    _libssh2_init_if_needed();
+
+    rc = read_private_key_from_file((void **) ec_ctx, read_ec,
+                                    filename, passphrase);
+
+    if(rc) {
+        return _libssh2_ecdsa_new_openssh_private_sk(ec_ctx,
+                                                     flags,
+                                                     application,
+                                                     key_handle,
+                                                     handle_len,
+                                                     session,
+                                                     filename,
+                                                     passphrase);
+    }
+
+    return rc;
+}
+
+
 /*
  * _libssh2_ecdsa_create_key
  *
@@ -2570,8 +4080,51 @@ _libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
     int ret = 1;
     size_t octal_len = 0;
     unsigned char octal_value[EC_MAX_POINT_LEN];
+    _libssh2_ec_key *private_key = NULL;
+
+#ifdef USE_OPENSSL_3
+    EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
+
+    if(ctx &&
+       EVP_PKEY_keygen_init(ctx) > 0 &&
+       EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, curve_type) > 0) {
+        ret = EVP_PKEY_keygen(ctx, &private_key);
+    }
+
+    if(ret <= 0) {
+        goto clean_exit;
+    }
+
+    if(out_private_key)
+        *out_private_key = private_key;
+
+    ret = EVP_PKEY_get_octet_string_param(private_key, OSSL_PKEY_PARAM_PUB_KEY,
+                                          NULL, 0, &octal_len);
+
+    if(ret <= 0) {
+        goto clean_exit;
+    }
+
+    *out_public_key_octal = LIBSSH2_ALLOC(session, octal_len);
+
+    if(!(*out_public_key_octal)) {
+        ret = -1;
+        goto clean_exit;
+    }
+
+    ret = EVP_PKEY_get_octet_string_param(private_key, OSSL_PKEY_PARAM_PUB_KEY,
+                                          octal_value, octal_len, &octal_len);
+
+    if(ret <= 0) {
+        goto clean_exit;
+    }
+
+    memcpy(*out_public_key_octal, octal_value, octal_len);
+
+    if(out_public_key_octal_len)
+        *out_public_key_octal_len = octal_len;
+#else
     const EC_POINT *public_key = NULL;
-    EC_KEY *private_key = NULL;
     const EC_GROUP *group = NULL;
 
     /* create key */
@@ -2597,16 +4150,16 @@ _libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
     /* convert to octal */
     if(EC_POINT_point2oct(group, public_key, POINT_CONVERSION_UNCOMPRESSED,
        octal_value, octal_len, bn_ctx) != octal_len) {
-           ret = -1;
-           goto clean_exit;
+        ret = -1;
+        goto clean_exit;
     }
 
-    if(out_private_key != NULL)
+    if(out_private_key)
         *out_private_key = private_key;
 
     if(out_public_key_octal) {
         *out_public_key_octal = LIBSSH2_ALLOC(session, octal_len);
-        if(*out_public_key_octal == NULL) {
+        if(!*out_public_key_octal) {
             ret = -1;
             goto clean_exit;
         }
@@ -2614,13 +4167,18 @@ _libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
         memcpy(*out_public_key_octal, octal_value, octal_len);
     }
 
-    if(out_public_key_octal_len != NULL)
+    if(out_public_key_octal_len)
         *out_public_key_octal_len = octal_len;
+#endif /* USE_OPENSSL_3 */
 
 clean_exit:
-
+#ifdef USE_OPENSSL_3
+    if(ctx)
+        EVP_PKEY_CTX_free(ctx);
+#else
     if(bn_ctx)
         BN_CTX_free(bn_ctx);
+#endif
 
     return (ret == 1) ? 0 : -1;
 }
@@ -2633,27 +4191,131 @@ _libssh2_ecdsa_create_key(LIBSSH2_SESSION *session,
 
 int
 _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
-    const unsigned char *server_public_key, size_t server_public_key_len)
+                    const unsigned char *server_public_key,
+                    size_t server_public_key_len)
 {
     int ret = 0;
-    int rc;
+    BN_CTX *bn_ctx = NULL;
+
+#ifdef USE_OPENSSL_3
+    char *group_name = NULL;
+    size_t group_name_len = 0;
+    unsigned char *out_shared_key = NULL;
+    EVP_PKEY *peer_key = NULL, *server_key = NULL;
+    EVP_PKEY_CTX *key_fromdata_ctx = NULL;
+    EVP_PKEY_CTX *server_key_ctx = NULL;
+    OSSL_PARAM params[3];
+
+    size_t out_len = 0;
+
+    if(!k || !(*k) || server_public_key_len <= 0)
+        return -1;
+
+    bn_ctx = BN_CTX_new();
+    if(!bn_ctx)
+        goto clean_exit;
+
+    key_fromdata_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
+    if(!key_fromdata_ctx)
+        goto clean_exit;
+
+    ret = EVP_PKEY_get_utf8_string_param(private_key,
+                                         OSSL_PKEY_PARAM_GROUP_NAME,
+                                         NULL, 0, &group_name_len);
+
+    if(ret <= 0)
+        goto clean_exit;
+
+    group_name_len += 1;
+    group_name = OPENSSL_zalloc(group_name_len);
+
+    if(!group_name)
+        goto clean_exit;
+
+    ret = EVP_PKEY_get_utf8_string_param(private_key,
+                                         OSSL_PKEY_PARAM_GROUP_NAME,
+                                         group_name, group_name_len,
+                                         &group_name_len);
+
+    if(ret <= 0)
+        goto clean_exit;
+
+    out_shared_key = OPENSSL_malloc(server_public_key_len);
+
+    if(!out_shared_key)
+        goto clean_exit;
+
+    memcpy(out_shared_key, server_public_key, server_public_key_len);
+
+    params[0] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME,
+                                                 group_name, 0);
+
+    params[1] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
+                                                  out_shared_key,
+                                                  server_public_key_len);
+
+    params[2] = OSSL_PARAM_construct_end();
+
+    ret = EVP_PKEY_fromdata_init(key_fromdata_ctx);
+    if(ret <= 0)
+        goto clean_exit;
+
+    ret = EVP_PKEY_fromdata(key_fromdata_ctx, &peer_key,
+                            EVP_PKEY_PUBLIC_KEY, params);
+
+    if(ret <= 0)
+        goto clean_exit;
+
+    server_key = private_key;
+
+    if(!peer_key || !server_key) {
+        goto clean_exit;
+    }
+
+    server_key_ctx = EVP_PKEY_CTX_new(server_key, NULL);
+    if(!server_key_ctx) {
+        goto clean_exit;
+    }
+
+    ret = EVP_PKEY_derive_init(server_key_ctx);
+    if(ret <= 0)
+        goto clean_exit;
+
+    ret = EVP_PKEY_derive_set_peer(server_key_ctx, peer_key);
+    if(ret <= 0)
+        goto clean_exit;
+
+    ret = EVP_PKEY_derive(server_key_ctx, NULL, &out_len);
+    if(ret <= 0)
+        goto clean_exit;
+
+    ret = EVP_PKEY_derive(server_key_ctx, out_shared_key, &out_len);
+
+    if(ret == 1) {
+        BN_bin2bn(out_shared_key, (int)out_len, *k);
+    }
+    else {
+        ret = -1;
+    }
+#else
+    int rc = -1;
     size_t secret_len;
     unsigned char *secret = NULL;
     const EC_GROUP *private_key_group;
     EC_POINT *server_public_key_point;
 
-    BN_CTX *bn_ctx = BN_CTX_new();
+    bn_ctx = BN_CTX_new();
 
     if(!bn_ctx)
         return -1;
 
-    if(k == NULL)
+    if(!k)
         return -1;
 
     private_key_group = EC_KEY_get0_group(private_key);
 
     server_public_key_point = EC_POINT_new(private_key_group);
-    if(server_public_key_point == NULL)
+    if(!server_public_key_point)
         return -1;
 
     rc = EC_POINT_oct2point(private_key_group, server_public_key_point,
@@ -2678,20 +4340,35 @@ _libssh2_ecdh_gen_k(_libssh2_bn **k, _libssh2_ec_key *private_key,
         goto clean_exit;
     }
 
-    BN_bin2bn(secret, secret_len, *k);
+    BN_bin2bn(secret, (int) secret_len, *k);
+#endif
 
 clean_exit:
+#ifdef USE_OPENSSL_3
+    if(group_name)
+        OPENSSL_clear_free(group_name, group_name_len);
 
-    if(server_public_key_point != NULL)
+    if(out_shared_key)
+        OPENSSL_clear_free(out_shared_key, server_public_key_len);
+
+    if(server_key_ctx)
+        EVP_PKEY_CTX_free(server_key_ctx);
+#else
+    if(server_public_key_point)
         EC_POINT_free(server_public_key_point);
 
-    if(bn_ctx != NULL)
+    if(bn_ctx)
         BN_CTX_free(bn_ctx);
 
-    if(secret != NULL)
+    if(secret)
         free(secret);
+#endif
 
+#ifdef USE_OPENSSL_3
+    return ret == 1 ? 0 : -1;
+#else
     return ret;
+#endif
 }
 
 
@@ -2709,7 +4386,7 @@ _libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
     size_t sig_len = 0;
     unsigned char *sig = NULL;
 
-    if(md_ctx != NULL) {
+    if(md_ctx) {
         if(EVP_DigestSignInit(md_ctx, NULL, NULL, NULL, ctx) != 1)
             goto clean_exit;
         if(EVP_DigestSign(md_ctx, NULL, &sig_len, message, message_len) != 1)
@@ -2719,7 +4396,7 @@ _libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
             goto clean_exit;
 
         sig = LIBSSH2_CALLOC(session, sig_len);
-        if(sig == NULL)
+        if(!sig)
             goto clean_exit;
 
         rc = EVP_DigestSign(md_ctx, sig, &sig_len, message, message_len);
@@ -2740,7 +4417,7 @@ _libssh2_ed25519_sign(libssh2_ed25519_ctx *ctx, LIBSSH2_SESSION *session,
     if(md_ctx)
         EVP_MD_CTX_free(md_ctx);
 
-    return (rc == 1 ? 0 : -1);
+    return (rc == 1) ? 0 : -1;
 }
 
 int
@@ -2755,11 +4432,11 @@ _libssh2_curve25519_gen_k(_libssh2_bn **k,
     BN_CTX *bn_ctx = NULL;
     size_t out_len = 0;
 
-    if(k == NULL || *k == NULL)
+    if(!k || !*k)
         return -1;
 
     bn_ctx = BN_CTX_new();
-    if(bn_ctx == NULL)
+    if(!bn_ctx)
         return -1;
 
     peer_key = EVP_PKEY_new_raw_public_key(EVP_PKEY_X25519, NULL,
@@ -2770,27 +4447,33 @@ _libssh2_curve25519_gen_k(_libssh2_bn **k,
                                               private_key,
                                               LIBSSH2_ED25519_KEY_LEN);
 
-    if(peer_key == NULL || server_key == NULL) {
-        goto cleanExit;
+    if(!peer_key || !server_key) {
+        goto clean_exit;
     }
 
     server_key_ctx = EVP_PKEY_CTX_new(server_key, NULL);
-    if(server_key_ctx == NULL) {
-        goto cleanExit;
+    if(!server_key_ctx) {
+        goto clean_exit;
     }
 
     rc = EVP_PKEY_derive_init(server_key_ctx);
-    if(rc <= 0) goto cleanExit;
+    if(rc <= 0) {
+        goto clean_exit;
+    }
 
     rc = EVP_PKEY_derive_set_peer(server_key_ctx, peer_key);
-    if(rc <= 0) goto cleanExit;
+    if(rc <= 0) {
+        goto clean_exit;
+    }
 
     rc = EVP_PKEY_derive(server_key_ctx, NULL, &out_len);
-    if(rc <= 0) goto cleanExit;
+    if(rc <= 0) {
+        goto clean_exit;
+    }
 
     if(out_len != LIBSSH2_ED25519_KEY_LEN) {
         rc = -1;
-        goto cleanExit;
+        goto clean_exit;
     }
 
     rc = EVP_PKEY_derive(server_key_ctx, out_shared_key, &out_len);
@@ -2802,7 +4485,7 @@ _libssh2_curve25519_gen_k(_libssh2_bn **k,
         rc = -1;
     }
 
-cleanExit:
+clean_exit:
 
     if(server_key_ctx)
         EVP_PKEY_CTX_free(server_key_ctx);
@@ -2810,7 +4493,7 @@ _libssh2_curve25519_gen_k(_libssh2_bn **k,
         EVP_PKEY_free(peer_key);
     if(server_key)
         EVP_PKEY_free(server_key);
-    if(bn_ctx != NULL)
+    if(bn_ctx)
         BN_CTX_free(bn_ctx);
 
     return (rc == 1) ? 0 : -1;
@@ -2824,7 +4507,7 @@ _libssh2_ed25519_verify(libssh2_ed25519_ctx *ctx, const uint8_t *s,
     int ret = -1;
 
     EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
-    if(NULL == md_ctx)
+    if(!md_ctx)
         return -1;
 
     ret = EVP_DigestVerifyInit(md_ctx, NULL, NULL, NULL, ctx);
@@ -2833,7 +4516,7 @@ _libssh2_ed25519_verify(libssh2_ed25519_ctx *ctx, const uint8_t *s,
 
     ret = EVP_DigestVerify(md_ctx, s, s_len, m, m_len);
 
-    clean_exit:
+clean_exit:
 
     EVP_MD_CTX_free(md_ctx);
 
@@ -2856,7 +4539,7 @@ _libssh2_pub_priv_openssh_keyfile(LIBSSH2_SESSION *session,
     struct string_buf *decrypted = NULL;
     int rc = 0;
 
-    if(session == NULL) {
+    if(!session) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Session is required");
         return -1;
@@ -2883,7 +4566,7 @@ _libssh2_pub_priv_openssh_keyfile(LIBSSH2_SESSION *session,
     /* We have a new key file, now try and parse it using supported types  */
     rc = _libssh2_get_string(decrypted, &buf, NULL);
 
-    if(rc != 0 || buf == NULL) {
+    if(rc || !buf) {
         _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                        "Public key type in decrypted key data not found");
         return -1;
@@ -2891,6 +4574,12 @@ _libssh2_pub_priv_openssh_keyfile(LIBSSH2_SESSION *session,
 
     rc = -1;
 
+    /* Avoid unused variable warnings when all branches below are disabled */
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+
 #if LIBSSH2_ED25519
     if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
         rc = gen_publickey_from_ed25519_openssh_priv_data(session, decrypted,
@@ -2937,7 +4626,7 @@ _libssh2_pub_priv_openssh_keyfile(LIBSSH2_SESSION *session,
     if(decrypted)
         _libssh2_string_buf_free(session, decrypted);
 
-    if(rc != 0) {
+    if(rc) {
         _libssh2_error(session, LIBSSH2_ERROR_FILE,
                        "Unsupported OpenSSH key type");
     }
@@ -2960,24 +4649,24 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
     int       pktype;
     int       rc;
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
                    "Computing public key from private key file: %s",
-                   privatekey);
+                   privatekey));
 
     bp = BIO_new_file(privatekey, "r");
-    if(bp == NULL) {
+    if(!bp) {
         return _libssh2_error(session,
                               LIBSSH2_ERROR_FILE,
                               "Unable to extract public key from private key "
                               "file: Unable to open private key file");
     }
 
-    BIO_reset(bp);
+    (void)BIO_reset(bp);
     pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
     BIO_free(bp);
 
-    if(pk == NULL) {
+    if(!pk) {
 
         /* Try OpenSSH format */
         rc = _libssh2_pub_priv_openssh_keyfile(session,
@@ -2985,7 +4674,7 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
                                                method_len,
                                                pubkeydata, pubkeydata_len,
                                                privatekey, passphrase);
-        if(rc != 0) {
+        if(rc) {
             return _libssh2_error(session,
                                   LIBSSH2_ERROR_FILE,
                                   "Unable to extract public key "
@@ -3005,31 +4694,30 @@ _libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
 
     switch(pktype) {
 #if LIBSSH2_ED25519
-    case EVP_PKEY_ED25519 :
+    case EVP_PKEY_ED25519:
         st = gen_publickey_from_ed_evp(
             session, method, method_len, pubkeydata, pubkeydata_len, pk);
         break;
 #endif /* LIBSSH2_ED25519 */
-    case EVP_PKEY_RSA :
+#if LIBSSH2_RSA
+    case EVP_PKEY_RSA:
         st = gen_publickey_from_rsa_evp(
             session, method, method_len, pubkeydata, pubkeydata_len, pk);
         break;
-
+#endif /* LIBSSH2_RSA */
 #if LIBSSH2_DSA
-    case EVP_PKEY_DSA :
+    case EVP_PKEY_DSA:
         st = gen_publickey_from_dsa_evp(
             session, method, method_len, pubkeydata, pubkeydata_len, pk);
         break;
-#endif /* LIBSSH_DSA */
-
+#endif /* LIBSSH2_DSA */
 #if LIBSSH2_ECDSA
-    case EVP_PKEY_EC :
+    case EVP_PKEY_EC:
         st = gen_publickey_from_ec_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
+            session, method, method_len, pubkeydata, pubkeydata_len, 0, pk);
     break;
-#endif
-
-    default :
+#endif /* LIBSSH2_ECDSA */
+    default:
         st = _libssh2_error(session,
                             LIBSSH2_ERROR_FILE,
                             "Unable to extract public key "
@@ -3058,14 +4746,14 @@ _libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
     unsigned char *buf = NULL;
     struct string_buf *decrypted = NULL;
 
-    if(key_ctx != NULL)
+    if(key_ctx)
         *key_ctx = NULL;
 
-    if(session == NULL)
+    if(!session)
         return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                               "Session is required");
 
-    if(key_type != NULL && (strlen(key_type) > 11 || strlen(key_type) < 7))
+    if(key_type && (strlen(key_type) > 11 || strlen(key_type) < 7))
         return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                               "type is invalid");
 
@@ -3078,19 +4766,25 @@ _libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
     if(rc)
         return rc;
 
-   /* We have a new key file, now try and parse it using supported types  */
-   rc = _libssh2_get_string(decrypted, &buf, NULL);
+    /* We have a new key file, now try and parse it using supported types  */
+    rc = _libssh2_get_string(decrypted, &buf, NULL);
+
+    if(rc || !buf)
+        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                              "Public key type in decrypted "
+                              "key data not found");
 
-   if(rc != 0 || buf == NULL)
-       return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                             "Public key type in decrypted "
-                             "key data not found");
+    rc = LIBSSH2_ERROR_FILE;
 
-   rc = LIBSSH2_ERROR_FILE;
+    /* Avoid unused variable warnings when all branches below are disabled */
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
 
 #if LIBSSH2_ED25519
     if(strcmp("ssh-ed25519", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-ed25519", key_type) == 0) {
+        if(!key_type || strcmp("ssh-ed25519", key_type) == 0) {
             rc = gen_publickey_from_ed25519_openssh_priv_data(session,
                                                               decrypted,
                                                               method,
@@ -3099,42 +4793,67 @@ _libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
                                                               pubkeydata_len,
                                               (libssh2_ed25519_ctx**)key_ctx);
         }
-   }
+    }
+
+    if(strcmp("sk-ssh-ed25519@openssh.com", (const char *)buf) == 0) {
+        if(!key_type ||
+           strcmp("sk-ssh-ed25519@openssh.com", key_type) == 0) {
+            rc = gen_publickey_from_sk_ed25519_openssh_priv_data(session,
+                                                                 decrypted,
+                                                                 method,
+                                                                 method_len,
+                                                                 pubkeydata,
+                                                                pubkeydata_len,
+                                                                 NULL, NULL,
+                                                                 NULL, NULL,
+                                               (libssh2_ed25519_ctx**)key_ctx);
+        }
+    }
 #endif
 #if LIBSSH2_RSA
     if(strcmp("ssh-rsa", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-rsa", key_type) == 0) {
+        if(!key_type || strcmp("ssh-rsa", key_type) == 0) {
             rc = gen_publickey_from_rsa_openssh_priv_data(session, decrypted,
                                                           method, method_len,
                                                           pubkeydata,
                                                           pubkeydata_len,
-                                                (libssh2_rsa_ctx**)key_ctx);
+                                                   (libssh2_rsa_ctx**)key_ctx);
         }
-   }
+    }
 #endif
 #if LIBSSH2_DSA
     if(strcmp("ssh-dss", (const char *)buf) == 0) {
-        if(key_type == NULL || strcmp("ssh-dss", key_type) == 0) {
+        if(!key_type || strcmp("ssh-dss", key_type) == 0) {
             rc = gen_publickey_from_dsa_openssh_priv_data(session, decrypted,
-                                                         method, method_len,
+                                                          method, method_len,
                                                           pubkeydata,
                                                           pubkeydata_len,
-                                                 (libssh2_dsa_ctx**)key_ctx);
+                                                   (libssh2_dsa_ctx**)key_ctx);
         }
-   }
+    }
 #endif
 #if LIBSSH2_ECDSA
 {
-   libssh2_curve_type type;
+    libssh2_curve_type type;
 
-   if(_libssh2_ecdsa_curve_type_from_name((const char *)buf, &type) == 0) {
-       if(key_type == NULL || strcmp("ssh-ecdsa", key_type) == 0) {
-           rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
-                                                           decrypted,
+    if(strcmp("sk-ecdsa-sha2-nistp256@openssh.com", (const char *)buf) == 0) {
+        rc = gen_publickey_from_sk_ecdsa_openssh_priv_data(session, decrypted,
                                                            method, method_len,
                                                            pubkeydata,
                                                            pubkeydata_len,
-                                               (libssh2_ecdsa_ctx**)key_ctx);
+                                                           NULL, NULL,
+                                                           NULL, NULL,
+                                                 (libssh2_ecdsa_ctx**)key_ctx);
+    }
+    else if(_libssh2_ecdsa_curve_type_from_name((const char *)buf, &type)
+        == 0) {
+        if(!key_type || strcmp("ssh-ecdsa", key_type) == 0) {
+            rc = gen_publickey_from_ecdsa_openssh_priv_data(session, type,
+                                                            decrypted,
+                                                            method, method_len,
+                                                            pubkeydata,
+                                                            pubkeydata_len,
+                                                 (libssh2_ecdsa_ctx**)key_ctx);
         }
     }
 }
@@ -3151,19 +4870,117 @@ _libssh2_pub_priv_openssh_keyfilememory(LIBSSH2_SESSION *session,
     return rc;
 }
 
-int
-read_openssh_private_key_from_memory(void **key_ctx, LIBSSH2_SESSION *session,
-                                     const char *key_type,
-                                     const char *filedata,
-                                     size_t filedata_len,
-                                     unsigned const char *passphrase)
+static int
+_libssh2_sk_pub_openssh_keyfilememory(LIBSSH2_SESSION *session,
+                                      void **key_ctx,
+                                      const char *key_type,
+                                      unsigned char **method,
+                                      size_t *method_len,
+                                      unsigned char **pubkeydata,
+                                      size_t *pubkeydata_len,
+                                      int *algorithm,
+                                      unsigned char *flags,
+                                      const char **application,
+                                      const unsigned char **key_handle,
+                                      size_t *handle_len,
+                                      const char *privatekeydata,
+                                      size_t privatekeydata_len,
+                                      unsigned const char *passphrase)
 {
-    return _libssh2_pub_priv_openssh_keyfilememory(session, key_ctx, key_type,
-                                                   NULL, NULL, NULL, NULL,
-                                                   filedata, filedata_len,
-                                                   passphrase);
+    int rc;
+    unsigned char *buf = NULL;
+    struct string_buf *decrypted = NULL;
+
+    if(key_ctx)
+        *key_ctx = NULL;
+
+    if(!session)
+        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                              "Session is required");
+
+    if(key_type && strlen(key_type) < 7)
+        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                              "type is invalid");
+
+    _libssh2_init_if_needed();
+
+    rc = _libssh2_openssh_pem_parse_memory(session, passphrase,
+                                           privatekeydata,
+                                           privatekeydata_len, &decrypted);
+
+    if(rc)
+        return rc;
+
+    /* We have a new key file, now try and parse it using supported types  */
+    rc = _libssh2_get_string(decrypted, &buf, NULL);
+
+    if(rc || !buf)
+        return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                              "Public key type in decrypted "
+                              "key data not found");
+
+    rc = LIBSSH2_ERROR_FILE;
+
+    /* Avoid unused variable warnings when all branches below are disabled */
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)algorithm;
+    (void)flags;
+    (void)application;
+    (void)key_handle;
+    (void)handle_len;
+
+#if LIBSSH2_ED25519
+    if(strcmp("sk-ssh-ed25519@openssh.com", (const char *)buf) == 0) {
+        *algorithm = LIBSSH2_HOSTKEY_TYPE_ED25519;
+        if(!key_type ||
+           strcmp("sk-ssh-ed25519@openssh.com", key_type) == 0) {
+            rc = gen_publickey_from_sk_ed25519_openssh_priv_data(session,
+                                                                 decrypted,
+                                                                 method,
+                                                                 method_len,
+                                                                 pubkeydata,
+                                                                pubkeydata_len,
+                                                                 flags,
+                                                                 application,
+                                                                 key_handle,
+                                                                 handle_len,
+                                               (libssh2_ed25519_ctx**)key_ctx);
+        }
+    }
+#endif
+#if LIBSSH2_ECDSA
+    if(strcmp("sk-ecdsa-sha2-nistp256@openssh.com", (const char *)buf) == 0) {
+        *algorithm = LIBSSH2_HOSTKEY_TYPE_ECDSA_256;
+        rc = gen_publickey_from_sk_ecdsa_openssh_priv_data(session, decrypted,
+                                                           method, method_len,
+                                                           pubkeydata,
+                                                           pubkeydata_len,
+                                                           flags,
+                                                           application,
+                                                           key_handle,
+                                                           handle_len,
+                                                 (libssh2_ecdsa_ctx**)key_ctx);
+    }
+#endif
+
+    if(rc == LIBSSH2_ERROR_FILE)
+        rc = _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                         "Unable to extract public key from private key file: "
+                         "invalid/unrecognized private key file format");
+
+    if(decrypted)
+        _libssh2_string_buf_free(session, decrypted);
+
+    return rc;
 }
 
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#define HAVE_SSLERROR_BAD_DECRYPT
+#endif
+
 int
 _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
                                 unsigned char **method,
@@ -3178,21 +4995,31 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     BIO*      bp;
     EVP_PKEY* pk;
     int       pktype;
+#ifdef HAVE_SSLERROR_BAD_DECRYPT
+    unsigned long sslError;
+#endif
 
-    _libssh2_debug(session,
+    _libssh2_debug((session,
                    LIBSSH2_TRACE_AUTH,
-                   "Computing public key from private key.");
+                   "Computing public key from private key."));
 
-    bp = BIO_new_mem_buf((char *)privatekeydata, privatekeydata_len);
+#if OPENSSL_VERSION_NUMBER >= 0x1000200fL
+    bp = BIO_new_mem_buf(privatekeydata, (int)privatekeydata_len);
+#else
+    bp = BIO_new_mem_buf((char *)privatekeydata, (int)privatekeydata_len);
+#endif
     if(!bp)
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                               "Unable to allocate memory when"
                               "computing public key");
-    BIO_reset(bp);
+    (void)BIO_reset(bp);
     pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
+#ifdef HAVE_SSLERROR_BAD_DECRYPT
+    sslError = ERR_get_error();
+#endif
     BIO_free(bp);
 
-    if(pk == NULL) {
+    if(!pk) {
         /* Try OpenSSH format */
         st = _libssh2_pub_priv_openssh_keyfilememory(session, NULL, NULL,
                                                      method,
@@ -3201,10 +5028,23 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
                                                      pubkeydata_len,
                                                      privatekeydata,
                                                      privatekeydata_len,
-                                           (unsigned const char *)passphrase);
-        if(st != 0)
-            return st;
-        return 0;
+                                            (unsigned const char *)passphrase);
+        if(st == 0)
+            return 0;
+
+#ifdef HAVE_SSLERROR_BAD_DECRYPT
+        if((ERR_GET_LIB(sslError) == ERR_LIB_PEM &&
+            ERR_GET_REASON(sslError) == PEM_R_BAD_DECRYPT) ||
+           (ERR_GET_LIB(sslError) == ERR_LIB_PROV &&
+            ERR_GET_REASON(sslError) == EVP_R_BAD_DECRYPT))
+            return _libssh2_error(session, LIBSSH2_ERROR_KEYFILE_AUTH_FAILED,
+                                  "Wrong passphrase for private key");
+#endif
+        return _libssh2_error(session,
+                              LIBSSH2_ERROR_FILE,
+                              "Unable to extract public key "
+                              "from private key file: "
+                              "Unsupported private key file format");
     }
 
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -3215,28 +5055,30 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
 
     switch(pktype) {
 #if LIBSSH2_ED25519
-    case EVP_PKEY_ED25519 :
-        st = gen_publickey_from_ed_evp(
-            session, method, method_len, pubkeydata, pubkeydata_len, pk);
+    case EVP_PKEY_ED25519:
+        st = gen_publickey_from_ed_evp(session, method, method_len,
+                                       pubkeydata, pubkeydata_len, pk);
         break;
 #endif /* LIBSSH2_ED25519 */
-    case EVP_PKEY_RSA :
+#if LIBSSH2_RSA
+    case EVP_PKEY_RSA:
         st = gen_publickey_from_rsa_evp(session, method, method_len,
                                         pubkeydata, pubkeydata_len, pk);
         break;
+#endif /* LIBSSH2_RSA */
 #if LIBSSH2_DSA
-    case EVP_PKEY_DSA :
+    case EVP_PKEY_DSA:
         st = gen_publickey_from_dsa_evp(session, method, method_len,
                                         pubkeydata, pubkeydata_len, pk);
         break;
-#endif /* LIBSSH_DSA */
+#endif /* LIBSSH2_DSA */
 #if LIBSSH2_ECDSA
-    case EVP_PKEY_EC :
+    case EVP_PKEY_EC:
         st = gen_publickey_from_ec_evp(session, method, method_len,
-                                       pubkeydata, pubkeydata_len, pk);
+                                       pubkeydata, pubkeydata_len, 0, pk);
         break;
 #endif /* LIBSSH2_ECDSA */
-    default :
+    default:
         st = _libssh2_error(session,
                             LIBSSH2_ERROR_FILE,
                             "Unable to extract public key "
@@ -3249,6 +5091,62 @@ _libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     return st;
 }
 
+int
+_libssh2_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                              unsigned char **method,
+                              size_t *method_len,
+                              unsigned char **pubkeydata,
+                              size_t *pubkeydata_len,
+                              int *algorithm,
+                              unsigned char *flags,
+                              const char **application,
+                              const unsigned char **key_handle,
+                              size_t *handle_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase)
+{
+    int       st = -1;
+    BIO*      bp;
+    EVP_PKEY* pk;
+
+    _libssh2_debug((session,
+                   LIBSSH2_TRACE_AUTH,
+                   "Computing public key from private key."));
+
+#if OPENSSL_VERSION_NUMBER >= 0x1000200fL
+    bp = BIO_new_mem_buf(privatekeydata, (int)privatekeydata_len);
+#else
+    bp = BIO_new_mem_buf((char *)privatekeydata, (int)privatekeydata_len);
+#endif
+    if(!bp)
+        return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                              "Unable to allocate memory when"
+                              "computing public key");
+    (void)BIO_reset(bp);
+    pk = PEM_read_bio_PrivateKey(bp, NULL, NULL, (void *)passphrase);
+    BIO_free(bp);
+
+    if(!pk) {
+        /* Try OpenSSH format */
+        st = _libssh2_sk_pub_openssh_keyfilememory(session, NULL, NULL,
+                                                   method,
+                                                   method_len,
+                                                   pubkeydata,
+                                                   pubkeydata_len,
+                                                   algorithm,
+                                                   flags,
+                                                   application,
+                                                   key_handle,
+                                                   handle_len,
+                                                   privatekeydata,
+                                                   privatekeydata_len,
+                                            (unsigned const char *)passphrase);
+    }
+
+    return st;
+}
+
 void
 _libssh2_dh_init(_libssh2_dh_ctx *dhctx)
 {
@@ -3283,4 +5181,45 @@ _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
     *dhctx = NULL;
 }
 
-#endif /* LIBSSH2_OPENSSL */
+int
+_libssh2_bn_from_bin(_libssh2_bn *bn, size_t len, const unsigned char *val)
+{
+    if(!BN_bin2bn(val, (int)len, bn)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/* _libssh2_supported_key_sign_algorithms
+ *
+ * Return supported key hash algo upgrades, see crypto.h
+ *
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len)
+{
+    (void)session;
+
+#if LIBSSH2_RSA_SHA2
+    if((key_method_len == 7 &&
+        memcmp(key_method, "ssh-rsa", key_method_len) == 0) ||
+       (key_method_len == 28 &&
+        memcmp(key_method, "ssh-rsa-cert-v01@openssh.com",
+               key_method_len) == 0)
+       ) {
+        return "rsa-sha2-512,rsa-sha2-256"
+#if LIBSSH2_RSA_SHA1
+            ",ssh-rsa"
+#endif
+            ;
+    }
+#endif
+
+    return NULL;
+}
+
+#endif /* LIBSSH2_CRYPTO_C */
diff --git a/libssh2/src/openssl.h b/libssh2/src/openssl.h
index 658b040d..e41c1df4 100644
--- a/libssh2/src/openssl.h
+++ b/libssh2/src/openssl.h
@@ -1,9 +1,8 @@
-#ifndef __LIBSSH2_OPENSSL_H
-#define __LIBSSH2_OPENSSL_H
-/* Copyright (C) 2009, 2010 Simon Josefsson
- * Copyright (C) 2006, 2007 The Written Word, Inc.  All rights reserved.
- *
- * Author: Simon Josefsson
+#ifndef LIBSSH2_OPENSSL_H
+#define LIBSSH2_OPENSSL_H
+/* Copyright (C) Simon Josefsson
+ * Copyright (C) The Written Word, Inc.
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -37,8 +36,64 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#define LIBSSH2_CRYPTO_ENGINE libssh2_openssl
+
+/* disable deprecated warnings in OpenSSL 3 */
+#define OPENSSL_SUPPRESS_DEPRECATED
+
+#ifdef LIBSSH2_WOLFSSL
+
+#include <wolfssl/options.h>
+#include <wolfssl/openssl/ecdh.h>
+
+#if defined(NO_DSA) || defined(HAVE_FIPS)
+#define OPENSSL_NO_DSA
+#endif
+
+#if defined(NO_MD5) || defined(HAVE_FIPS)
+#define OPENSSL_NO_MD5
+#endif
+
+#if !defined(WOLFSSL_RIPEMD) || defined(HAVE_FIPS)
+#define OPENSSL_NO_RIPEMD
+#endif
+
+#if defined(NO_RC4) || defined(HAVE_FIPS)
+#define OPENSSL_NO_RC4
+#endif
+
+#ifdef NO_DES3
+#define OPENSSL_NO_DES
+#endif
+
+/* wolfSSL doesn't support Blowfish or CAST. */
+#define OPENSSL_NO_BF
+#define OPENSSL_NO_CAST
+/* wolfSSL has no engine framework. */
+#define OPENSSL_NO_ENGINE
+
+#include <wolfssl/openssl/opensslconf.h>
+#include <wolfssl/openssl/sha.h>
+#include <wolfssl/openssl/rsa.h>
+#ifndef OPENSSL_NO_DSA
+#include <wolfssl/openssl/dsa.h>
+#endif
+#ifndef OPENSSL_NO_MD5
+#include <wolfssl/openssl/md5.h>
+#endif
+#include <wolfssl/openssl/err.h>
+#include <wolfssl/openssl/evp.h>
+#include <wolfssl/openssl/hmac.h>
+#include <wolfssl/openssl/bn.h>
+#include <wolfssl/openssl/pem.h>
+#include <wolfssl/openssl/rand.h>
+
+#else /* !LIBSSH2_WOLFSSL */
+
 #include <openssl/opensslconf.h>
 #include <openssl/sha.h>
 #include <openssl/rsa.h>
@@ -51,21 +106,37 @@
 #ifndef OPENSSL_NO_MD5
 #include <openssl/md5.h>
 #endif
+#include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/bn.h>
 #include <openssl/pem.h>
 #include <openssl/rand.h>
 
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L && \
-    !defined(LIBRESSL_VERSION_NUMBER)
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#define USE_OPENSSL_3 1
+#include <openssl/core_names.h>
+#endif
+
+#endif /* LIBSSH2_WOLFSSL */
+
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L && \
+    !defined(LIBRESSL_VERSION_NUMBER)) || defined(LIBSSH2_WOLFSSL) || \
+    (defined(LIBRESSL_VERSION_NUMBER) && \
+    LIBRESSL_VERSION_NUMBER >= 0x3050000fL)
+/* For wolfSSL, whether the structs are truly opaque or not, it's best to not
+ * rely on their internal data members being exposed publicly. */
 # define HAVE_OPAQUE_STRUCTS 1
 #endif
 
 #ifdef OPENSSL_NO_RSA
 # define LIBSSH2_RSA 0
+# define LIBSSH2_RSA_SHA1 0
+# define LIBSSH2_RSA_SHA2 0
 #else
 # define LIBSSH2_RSA 1
+# define LIBSSH2_RSA_SHA1 1
+# define LIBSSH2_RSA_SHA2 1
 #endif
 
 #ifdef OPENSSL_NO_DSA
@@ -74,14 +145,16 @@
 # define LIBSSH2_DSA 1
 #endif
 
-#ifdef OPENSSL_NO_ECDSA
+#if defined(OPENSSL_NO_ECDSA) || defined(OPENSSL_NO_EC)
 # define LIBSSH2_ECDSA 0
 #else
 # define LIBSSH2_ECDSA 1
 #endif
 
-#if OPENSSL_VERSION_NUMBER >= 0x10101000L && \
-!defined(LIBRESSL_VERSION_NUMBER)
+#if (OPENSSL_VERSION_NUMBER >= 0x10101000L && \
+    !defined(LIBRESSL_VERSION_NUMBER)) || \
+    (defined(LIBRESSL_VERSION_NUMBER) && \
+    LIBRESSL_VERSION_NUMBER >= 0x3070000fL)
 # define LIBSSH2_ED25519 1
 #else
 # define LIBSSH2_ED25519 0
@@ -94,7 +167,7 @@
 # define LIBSSH2_MD5 1
 #endif
 
-#ifdef OPENSSL_NO_RIPEMD
+#if defined(OPENSSL_NO_RIPEMD) || defined(OPENSSL_NO_RMD160)
 # define LIBSSH2_HMAC_RIPEMD 0
 #else
 # define LIBSSH2_HMAC_RIPEMD 1
@@ -103,12 +176,24 @@
 #define LIBSSH2_HMAC_SHA256 1
 #define LIBSSH2_HMAC_SHA512 1
 
-#if OPENSSL_VERSION_NUMBER >= 0x00907000L && !defined(OPENSSL_NO_AES)
+#if (OPENSSL_VERSION_NUMBER >= 0x00907000L && !defined(OPENSSL_NO_AES)) || \
+    (defined(LIBSSH2_WOLFSSL) && defined(WOLFSSL_AES_COUNTER))
 # define LIBSSH2_AES_CTR 1
-# define LIBSSH2_AES 1
+# define LIBSSH2_AES_CBC 1
 #else
 # define LIBSSH2_AES_CTR 0
-# define LIBSSH2_AES 0
+# define LIBSSH2_AES_CBC 0
+#endif
+
+/* wolfSSL v5.4.0 is required due to possibly this bug:
+   https://github.com/wolfSSL/wolfssl/pull/5205
+   Before this release, all libssh2 tests crash with AES-GCM enabled */
+#if (OPENSSL_VERSION_NUMBER >= 0x01010100fL && !defined(OPENSSL_NO_AES)) || \
+    (defined(LIBSSH2_WOLFSSL) && LIBWOLFSSL_VERSION_HEX >= 0x05004000 && \
+    defined(HAVE_AESGCM) && defined(WOLFSSL_AESGCM_STREAM))
+# define LIBSSH2_AES_GCM 1
+#else
+# define LIBSSH2_AES_GCM 0
 #endif
 
 #ifdef OPENSSL_NO_BF
@@ -135,9 +220,12 @@
 # define LIBSSH2_3DES 1
 #endif
 
+#include "crypto_config.h"
+
 #define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
 
-#define _libssh2_random(buf, len) (RAND_bytes((buf), (len)) == 1 ? 0 : -1)
+#define _libssh2_random(buf, len) \
+    _libssh2_openssl_random((buf), (len))
 
 #define libssh2_prepare_iovec(vec, len)  /* Empty. */
 
@@ -149,19 +237,15 @@
 
 /* returns 0 in case of failure */
 int _libssh2_sha1_init(libssh2_sha1_ctx *ctx);
-#define libssh2_sha1_init(x) _libssh2_sha1_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha1_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha1_final(ctx, out) do { \
-                                         EVP_DigestFinal(ctx, out, NULL); \
-                                         EVP_MD_CTX_free(ctx); \
-                                     } while(0)
-#else
-#define libssh2_sha1_update(ctx, data, len) EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha1_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha1(const unsigned char *message, unsigned long len,
+int _libssh2_sha1_update(libssh2_sha1_ctx *ctx,
+                         const void *data, size_t len);
+int _libssh2_sha1_final(libssh2_sha1_ctx *ctx, unsigned char *out);
+int _libssh2_sha1(const unsigned char *message, size_t len,
                   unsigned char *out);
+#define libssh2_sha1_init(x) _libssh2_sha1_init(x)
+#define libssh2_sha1_update(ctx, data, len) \
+    _libssh2_sha1_update(&(ctx), data, len)
+#define libssh2_sha1_final(ctx, out) _libssh2_sha1_final(&(ctx), out)
 #define libssh2_sha1(x,y,z) _libssh2_sha1(x,y,z)
 
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -172,20 +256,15 @@ int _libssh2_sha1(const unsigned char *message, unsigned long len,
 
 /* returns 0 in case of failure */
 int _libssh2_sha256_init(libssh2_sha256_ctx *ctx);
+int _libssh2_sha256_update(libssh2_sha256_ctx *ctx,
+                           const void *data, size_t len);
+int _libssh2_sha256_final(libssh2_sha256_ctx *ctx, unsigned char *out);
+int _libssh2_sha256(const unsigned char *message, size_t len,
+                    unsigned char *out);
 #define libssh2_sha256_init(x) _libssh2_sha256_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha256_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha256_final(ctx, out) do { \
-                                           EVP_DigestFinal(ctx, out, NULL); \
-                                           EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
 #define libssh2_sha256_update(ctx, data, len) \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha256_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha256(const unsigned char *message, unsigned long len,
-                  unsigned char *out);
+    _libssh2_sha256_update(&(ctx), data, len)
+#define libssh2_sha256_final(ctx, out) _libssh2_sha256_final(&(ctx), out)
 #define libssh2_sha256(x,y,z) _libssh2_sha256(x,y,z)
 
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -196,20 +275,15 @@ int _libssh2_sha256(const unsigned char *message, unsigned long len,
 
 /* returns 0 in case of failure */
 int _libssh2_sha384_init(libssh2_sha384_ctx *ctx);
-#define libssh2_sha384_init(x) _libssh2_sha384_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha384_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha384_final(ctx, out) do { \
-                                            EVP_DigestFinal(ctx, out, NULL); \
-                                            EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
-#define libssh2_sha384_update(ctx, data, len)   \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha384_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha384(const unsigned char *message, unsigned long len,
+int _libssh2_sha384_update(libssh2_sha384_ctx *ctx,
+                           const void *data, size_t len);
+int _libssh2_sha384_final(libssh2_sha384_ctx *ctx, unsigned char *out);
+int _libssh2_sha384(const unsigned char *message, size_t len,
                     unsigned char *out);
+#define libssh2_sha384_init(x) _libssh2_sha384_init(x)
+#define libssh2_sha384_update(ctx, data, len) \
+    _libssh2_sha384_update(&(ctx), data, len)
+#define libssh2_sha384_final(ctx, out) _libssh2_sha384_final(&(ctx), out)
 #define libssh2_sha384(x,y,z) _libssh2_sha384(x,y,z)
 
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -220,22 +294,18 @@ int _libssh2_sha384(const unsigned char *message, unsigned long len,
 
 /* returns 0 in case of failure */
 int _libssh2_sha512_init(libssh2_sha512_ctx *ctx);
-#define libssh2_sha512_init(x) _libssh2_sha512_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_sha512_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_sha512_final(ctx, out) do { \
-                                            EVP_DigestFinal(ctx, out, NULL); \
-                                            EVP_MD_CTX_free(ctx); \
-                                       } while(0)
-#else
-#define libssh2_sha512_update(ctx, data, len)   \
-    EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_sha512_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-int _libssh2_sha512(const unsigned char *message, unsigned long len,
+int _libssh2_sha512_update(libssh2_sha512_ctx *ctx,
+                           const void *data, size_t len);
+int _libssh2_sha512_final(libssh2_sha512_ctx *ctx, unsigned char *out);
+int _libssh2_sha512(const unsigned char *message, size_t len,
                     unsigned char *out);
+#define libssh2_sha512_init(x) _libssh2_sha512_init(x)
+#define libssh2_sha512_update(ctx, data, len) \
+    _libssh2_sha512_update(&(ctx), data, len)
+#define libssh2_sha512_final(ctx, out) _libssh2_sha512_final(&(ctx), out)
 #define libssh2_sha512(x,y,z) _libssh2_sha512(x,y,z)
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #ifdef HAVE_OPAQUE_STRUCTS
 #define libssh2_md5_ctx EVP_MD_CTX *
 #else
@@ -244,74 +314,63 @@ int _libssh2_sha512(const unsigned char *message, unsigned long len,
 
 /* returns 0 in case of failure */
 int _libssh2_md5_init(libssh2_md5_ctx *ctx);
+int _libssh2_md5_update(libssh2_md5_ctx *ctx,
+                        const void *data, size_t len);
+int _libssh2_md5_final(libssh2_md5_ctx *ctx, unsigned char *out);
 #define libssh2_md5_init(x) _libssh2_md5_init(x)
-#ifdef HAVE_OPAQUE_STRUCTS
-#define libssh2_md5_update(ctx, data, len) EVP_DigestUpdate(ctx, data, len)
-#define libssh2_md5_final(ctx, out) do { \
-                                        EVP_DigestFinal(ctx, out, NULL); \
-                                        EVP_MD_CTX_free(ctx); \
-                                    } while(0)
-#else
-#define libssh2_md5_update(ctx, data, len) EVP_DigestUpdate(&(ctx), data, len)
-#define libssh2_md5_final(ctx, out) EVP_DigestFinal(&(ctx), out, NULL)
-#endif
-
-#ifdef HAVE_OPAQUE_STRUCTS
+#define libssh2_md5_update(ctx, data, len) \
+    _libssh2_md5_update(&(ctx), data, len)
+#define libssh2_md5_final(ctx, out) _libssh2_md5_final(&(ctx), out)
+#endif /* LIBSSH2_MD5 || LIBSSH2_MD5_PEM */
+
+#ifdef USE_OPENSSL_3
+#define libssh2_hmac_ctx EVP_MAC_CTX *
+#elif defined(HAVE_OPAQUE_STRUCTS)
 #define libssh2_hmac_ctx HMAC_CTX *
-#define libssh2_hmac_ctx_init(ctx) ctx = HMAC_CTX_new()
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha1(), NULL)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_md5(), NULL)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_ripemd160(), NULL)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha256(), NULL)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  HMAC_Init_ex(*(ctx), key, keylen, EVP_sha512(), NULL)
-
-#define libssh2_hmac_update(ctx, data, datalen) \
-  HMAC_Update(ctx, data, datalen)
-#define libssh2_hmac_final(ctx, data) HMAC_Final(ctx, data, NULL)
-#define libssh2_hmac_cleanup(ctx) HMAC_CTX_free(*(ctx))
-#else
+#else /* !HAVE_OPAQUE_STRUCTS */
 #define libssh2_hmac_ctx HMAC_CTX
-#define libssh2_hmac_ctx_init(ctx) \
-  HMAC_CTX_init(&ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha1(), NULL)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_md5(), NULL)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_ripemd160(), NULL)
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha256(), NULL)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  HMAC_Init_ex(ctx, key, keylen, EVP_sha512(), NULL)
-
-#define libssh2_hmac_update(ctx, data, datalen) \
-  HMAC_Update(&(ctx), data, datalen)
-#define libssh2_hmac_final(ctx, data) HMAC_Final(&(ctx), data, NULL)
-#define libssh2_hmac_cleanup(ctx) HMAC_cleanup(ctx)
-#endif
+#endif /* USE_OPENSSL_3 */
 
 extern void _libssh2_openssl_crypto_init(void);
 extern void _libssh2_openssl_crypto_exit(void);
 #define libssh2_crypto_init() _libssh2_openssl_crypto_init()
 #define libssh2_crypto_exit() _libssh2_openssl_crypto_exit()
 
-#define libssh2_rsa_ctx RSA
+#if LIBSSH2_RSA
 
+#ifdef USE_OPENSSL_3
+#define libssh2_rsa_ctx EVP_PKEY
+#define _libssh2_rsa_free(rsactx) EVP_PKEY_free(rsactx)
+#else
+#define libssh2_rsa_ctx RSA
 #define _libssh2_rsa_free(rsactx) RSA_free(rsactx)
+#endif
 
-#define libssh2_dsa_ctx DSA
+#endif /* LIBSSH2_RSA */
 
+#if LIBSSH2_DSA
+
+#ifdef USE_OPENSSL_3
+#define libssh2_dsa_ctx EVP_PKEY
+#define _libssh2_dsa_free(rsactx) EVP_PKEY_free(rsactx)
+#else
+#define libssh2_dsa_ctx DSA
 #define _libssh2_dsa_free(dsactx) DSA_free(dsactx)
+#endif
+
+#endif /* LIBSSH2_DSA */
 
 #if LIBSSH2_ECDSA
+
+#ifdef USE_OPENSSL_3
+#define libssh2_ecdsa_ctx EVP_PKEY
+#define _libssh2_ecdsa_free(ecdsactx) EVP_PKEY_free(ecdsactx)
+#define _libssh2_ec_key EVP_PKEY
+#else
 #define libssh2_ecdsa_ctx EC_KEY
 #define _libssh2_ecdsa_free(ecdsactx) EC_KEY_free(ecdsactx)
 #define _libssh2_ec_key EC_KEY
+#endif
 
 typedef enum {
     LIBSSH2_EC_CURVE_NISTP256 = NID_X9_62_prime256v1,
@@ -319,15 +378,14 @@ typedef enum {
     LIBSSH2_EC_CURVE_NISTP521 = NID_secp521r1
 }
 libssh2_curve_type;
-#else
+#else /* !LIBSSH2_ECDSA */
 #define _libssh2_ec_key void
 #endif /* LIBSSH2_ECDSA */
 
 #if LIBSSH2_ED25519
 #define libssh2_ed25519_ctx EVP_PKEY
-
 #define _libssh2_ed25519_free(ctx) EVP_PKEY_free(ctx)
-#endif /* ED25519 */
+#endif /* LIBSSH2_ED25519 */
 
 #define _libssh2_cipher_type(name) const EVP_CIPHER *(*name)(void)
 #ifdef HAVE_OPAQUE_STRUCTS
@@ -336,22 +394,20 @@ libssh2_curve_type;
 #define _libssh2_cipher_ctx EVP_CIPHER_CTX
 #endif
 
+#define _libssh2_cipher_aes256gcm EVP_aes_256_gcm
+#define _libssh2_cipher_aes128gcm EVP_aes_128_gcm
+
 #define _libssh2_cipher_aes256 EVP_aes_256_cbc
 #define _libssh2_cipher_aes192 EVP_aes_192_cbc
 #define _libssh2_cipher_aes128 EVP_aes_128_cbc
-#ifdef HAVE_EVP_AES_128_CTR
 #define _libssh2_cipher_aes128ctr EVP_aes_128_ctr
 #define _libssh2_cipher_aes192ctr EVP_aes_192_ctr
 #define _libssh2_cipher_aes256ctr EVP_aes_256_ctr
-#else
-#define _libssh2_cipher_aes128ctr _libssh2_EVP_aes_128_ctr
-#define _libssh2_cipher_aes192ctr _libssh2_EVP_aes_192_ctr
-#define _libssh2_cipher_aes256ctr _libssh2_EVP_aes_256_ctr
-#endif
 #define _libssh2_cipher_blowfish EVP_bf_cbc
 #define _libssh2_cipher_arcfour EVP_rc4
 #define _libssh2_cipher_cast5 EVP_cast5_cbc
 #define _libssh2_cipher_3des EVP_des_ede3_cbc
+#define _libssh2_cipher_chacha20 NULL
 
 #ifdef HAVE_OPAQUE_STRUCTS
 #define _libssh2_cipher_dtor(ctx) EVP_CIPHER_CTX_free(*(ctx))
@@ -365,19 +421,28 @@ libssh2_curve_type;
 #define _libssh2_bn_ctx_free(bnctx) BN_CTX_free(bnctx)
 #define _libssh2_bn_init() BN_new()
 #define _libssh2_bn_init_from_bin() _libssh2_bn_init()
-#define _libssh2_bn_set_word(bn, val) BN_set_word(bn, val)
-#define _libssh2_bn_from_bin(bn, len, val) BN_bin2bn(val, len, bn)
-#define _libssh2_bn_to_bin(bn, val) BN_bn2bin(bn, val)
+#define _libssh2_bn_set_word(bn, val) !BN_set_word(bn, val)
+extern int _libssh2_bn_from_bin(_libssh2_bn *bn, size_t len,
+                                const unsigned char *v);
+#define _libssh2_bn_to_bin(bn, val) (BN_bn2bin(bn, val) <= 0)
 #define _libssh2_bn_bytes(bn) BN_num_bytes(bn)
 #define _libssh2_bn_bits(bn) BN_num_bits(bn)
 #define _libssh2_bn_free(bn) BN_clear_free(bn)
 
+/* Default generate and safe prime sizes for
+   diffie-hellman-group-exchange-sha1 */
+#define LIBSSH2_DH_GEX_MINGROUP     2048
+#define LIBSSH2_DH_GEX_OPTGROUP     4096
+#define LIBSSH2_DH_GEX_MAXGROUP     8192
+
+#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
+
 #define _libssh2_dh_ctx BIGNUM *
 #define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
 #define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx)
+    _libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx)
 #define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p, bnctx)
+    _libssh2_dh_secret(dhctx, secret, f, p, bnctx)
 #define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
 extern void _libssh2_dh_init(_libssh2_dh_ctx *dhctx);
 extern int _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
@@ -389,8 +454,10 @@ extern int _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
                               _libssh2_bn_ctx *bnctx);
 extern void _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
 
+extern int _libssh2_openssl_random(void *buf, size_t len);
+
 const EVP_CIPHER *_libssh2_EVP_aes_128_ctr(void);
 const EVP_CIPHER *_libssh2_EVP_aes_192_ctr(void);
 const EVP_CIPHER *_libssh2_EVP_aes_256_ctr(void);
 
-#endif /* __LIBSSH2_OPENSSL_H */
+#endif /* LIBSSH2_OPENSSL_H */
diff --git a/libssh2/src/os400qc3.c b/libssh2/src/os400qc3.c
new file mode 100644
index 00000000..9ec9b036
--- /dev/null
+++ b/libssh2/src/os400qc3.c
@@ -0,0 +1,2535 @@
+/*
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
+ * 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 any other contributors may be used to endorse or
+ *   promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */
+
+#include <stdlib.h>
+
+#include <stdarg.h>
+#include <alloca.h>
+#include <sys/uio.h>
+
+#include <arpa/inet.h>
+
+
+#ifdef OS400_DEBUG
+/* In debug mode, all system library errors cause an exception. */
+#define set_EC_length(ec, length)   ((ec).Bytes_Provided =                  \
+                                     (ec).Bytes_Available = 0)
+#else
+#define set_EC_length(ec, length)   ((ec).Bytes_Provided = (length))
+#endif
+
+
+/* Ensure va_list operations are not on an array. */
+typedef struct {
+    va_list     list;
+}       valiststr;
+
+
+typedef int (*loadkeyproc)(LIBSSH2_SESSION *session,
+                           const unsigned char *data, unsigned int datalen,
+                           const unsigned char *passphrase, void *loadkeydata);
+
+/* Public key extraction data. */
+typedef struct {
+    const char *            method;
+    const unsigned char *   data;
+    unsigned int            length;
+}       loadpubkeydata;
+
+
+/* Support for ASN.1 elements. */
+
+typedef struct {
+    char *          header;         /* Pointer to header byte. */
+    char *          beg;            /* Pointer to element data. */
+    char *          end;            /* Pointer to 1st byte after element. */
+    unsigned char   class;          /* ASN.1 element class. */
+    unsigned char   tag;            /* ASN.1 element tag. */
+    unsigned char   constructed;    /* Element is constructed. */
+}       asn1Element;
+
+#define ASN1_INTEGER        2
+#define ASN1_BIT_STRING     3
+#define ASN1_OCTET_STRING   4
+#define ASN1_NULL           5
+#define ASN1_OBJ_ID         6
+#define ASN1_SEQ            16
+
+#define ASN1_CONSTRUCTED    0x20
+
+/* rsaEncryption OID: 1.2.840.113549.1.1.1 */
+static unsigned char    OID_rsaEncryption[] =
+                            {9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 1, 1, 1};
+static int  sshrsapubkey(LIBSSH2_SESSION *session, char **sshpubkey,
+                         asn1Element *params, asn1Element *key,
+                         const char *method);
+
+#if LIBSSH2_DSA != 0
+/* dsaEncryption OID: 1.2.840.10040.4.1 */
+static unsigned char    OID_dsaEncryption[] =
+                            {7, 40 + 2, 0x86, 0x48, 0xCE, 0x38, 4, 1};
+static int  sshdsapubkey(LIBSSH2_SESSION *session, char **sshpubkey,
+                         asn1Element *params, asn1Element *key,
+                         const char *method);
+#endif
+
+static unsigned char    OID_dhKeyAgreement[] =
+                            {9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 1, 3, 1};
+
+
+/* PKCS#5 support. */
+
+typedef struct pkcs5params  pkcs5params;
+struct pkcs5params {
+    int         cipher;         /* Encryption cipher. */
+    int         blocksize;      /* Cipher block size. */
+    char        mode;           /* Block encryption mode. */
+    char        padopt;         /* Pad option. */
+    char        padchar;        /* Pad character. */
+    int         (*kdf)(LIBSSH2_SESSION *session, char **dk,
+                       const unsigned char *passphrase, pkcs5params *pkcs5);
+    int         hash;           /* KDF hash algorithm. */
+    size_t      hashlen;        /* KDF hash digest length. */
+    char *      salt;           /* Salt. */
+    size_t      saltlen;        /* Salt length. */
+    char *      iv;             /* Initialization vector. */
+    size_t      ivlen;          /* Initialization vector length. */
+    int         itercount;      /* KDF iteration count. */
+    int         dklen;          /* Derived key length (#bytes). */
+    int         effkeysize;     /* RC2 effective key size (#bits) or 0. */
+};
+
+typedef struct pkcs5algo    pkcs5algo;
+struct pkcs5algo {
+    const unsigned char *   oid;
+    int         (*parse)(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                         pkcs5algo *algo, asn1Element *param);
+    int         cipher;         /* Encryption cipher. */
+    size_t      blocksize;      /* Cipher block size. */
+    char        mode;           /* Block encryption mode. */
+    char        padopt;         /* Pad option. */
+    char        padchar;        /* Pad character. */
+    size_t      keylen;         /* Key length (#bytes). */
+    int         hash;           /* Hash algorithm. */
+    size_t      hashlen;        /* Hash digest length. */
+    size_t      saltlen;        /* Salt length. */
+    size_t      ivlen;          /* Initialisation vector length. */
+    int         effkeysize;     /* RC2 effective key size (#bits) or 0. */
+};
+
+/* id-PBES2 OID: 1.2.840.113549.1.5.13 */
+static const unsigned char  OID_id_PBES2[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x0D
+};
+static int  parse_pbes2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                        pkcs5algo *algo, asn1Element *param);
+static const pkcs5algo  PBES2 = {
+    OID_id_PBES2,   parse_pbes2,    0,  0,  '\0',   '\0',   '\0',   0,
+    0,  0,  0,  0,  0
+};
+
+/* id-PBKDF2 OID: 1.2.840.113549.1.5.12 */
+static const unsigned char  OID_id_PBKDF2[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x0C
+};
+static int  parse_pbkdf2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                         pkcs5algo *algo, asn1Element *param);
+static const pkcs5algo  PBKDF2 = {
+    OID_id_PBKDF2,  parse_pbkdf2,   0,  0,  '\0',   '\0',   '\0',
+    SHA_DIGEST_LENGTH,  Qc3_SHA1,   SHA_DIGEST_LENGTH,  8,  8,  0
+};
+
+/* id-hmacWithSHA1 OID: 1.2.840.113549.2.7 */
+static const unsigned char  OID_id_hmacWithSHA1[] = {
+    8, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x07
+};
+static int  parse_hmacWithSHA1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                               pkcs5algo *algo, asn1Element *param);
+static const pkcs5algo  hmacWithSHA1 = {
+    OID_id_hmacWithSHA1,    parse_hmacWithSHA1, 0,  0,  '\0',   '\0',   '\0',
+    SHA_DIGEST_LENGTH,  Qc3_SHA1,   SHA_DIGEST_LENGTH,  8,  8,  0
+};
+
+/* desCBC OID: 1.3.14.3.2.7 */
+static const unsigned char  OID_desCBC[] = {5, 40 + 3, 0x0E, 0x03, 0x02, 0x07};
+static int  parse_iv(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                     pkcs5algo *algo, asn1Element *param);
+static const pkcs5algo  desCBC = {
+    OID_desCBC, parse_iv,   Qc3_DES,    8,  Qc3_CBC,    Qc3_Pad_Counter,
+   '\0',   8,   0,  0,  8,  8,  0
+};
+
+/* des-EDE3-CBC OID: 1.2.840.113549.3.7 */
+static const unsigned char  OID_des_EDE3_CBC[] = {
+    8, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x03, 0x07
+};
+static const pkcs5algo  des_EDE3_CBC = {
+    OID_des_EDE3_CBC,   parse_iv,   Qc3_TDES,   8,  Qc3_CBC, Qc3_Pad_Counter,
+    '\0',   24, 0,  0,  8,  8,  0
+};
+
+/* rc2CBC OID: 1.2.840.113549.3.2 */
+static const unsigned char  OID_rc2CBC[] = {
+    8, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x03, 0x02
+};
+static int  parse_rc2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                      pkcs5algo *algo, asn1Element *param);
+static const pkcs5algo  rc2CBC = {
+    OID_rc2CBC, parse_rc2,  Qc3_RC2,    8,  Qc3_CBC,    Qc3_Pad_Counter,
+    '\0',   0,  0,  0,  8,  0,  32
+};
+
+static int  parse_pbes1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                        pkcs5algo *algo, asn1Element *param);
+
+#if LIBSSH2_MD5
+/* pbeWithMD5AndDES-CBC OID: 1.2.840.113549.1.5.3 */
+static const unsigned char  OID_pbeWithMD5AndDES_CBC[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x03
+};
+static const pkcs5algo  pbeWithMD5AndDES_CBC = {
+    OID_pbeWithMD5AndDES_CBC,   parse_pbes1,    Qc3_DES,    8,  Qc3_CBC,
+    Qc3_Pad_Counter,    '\0',   8,  Qc3_MD5,    MD5_DIGEST_LENGTH,  8,  0,  0
+};
+
+/* pbeWithMD5AndRC2-CBC OID: 1.2.840.113549.1.5.6 */
+static const unsigned char  OID_pbeWithMD5AndRC2_CBC[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x06
+};
+static const pkcs5algo  pbeWithMD5AndRC2_CBC = {
+    OID_pbeWithMD5AndRC2_CBC,   parse_pbes1,    Qc3_RC2,    8,  Qc3_CBC,
+    Qc3_Pad_Counter,    '\0',   0,  Qc3_MD5,    MD5_DIGEST_LENGTH,  8,  0,  64
+};
+#endif
+
+/* pbeWithSHA1AndDES-CBC OID: 1.2.840.113549.1.5.10 */
+static const unsigned char  OID_pbeWithSHA1AndDES_CBC[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x0A
+};
+static const pkcs5algo  pbeWithSHA1AndDES_CBC = {
+    OID_pbeWithSHA1AndDES_CBC,   parse_pbes1,    Qc3_DES,    8,  Qc3_CBC,
+    Qc3_Pad_Counter,    '\0',   8,  Qc3_SHA1,   SHA_DIGEST_LENGTH,  8,  0, 0
+};
+
+/* pbeWithSHA1AndRC2-CBC OID: 1.2.840.113549.1.5.11 */
+static const unsigned char  OID_pbeWithSHA1AndRC2_CBC[] = {
+    9, 40 + 2, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x05, 0x0B
+};
+static const pkcs5algo  pbeWithSHA1AndRC2_CBC = {
+    OID_pbeWithSHA1AndRC2_CBC,   parse_pbes1,    Qc3_RC2,    8,  Qc3_CBC,
+    Qc3_Pad_Counter,    '\0',   0,  Qc3_SHA1,   SHA_DIGEST_LENGTH,  8,  0,  64
+};
+
+/* rc5-CBC-PAD OID: 1.2.840.113549.3.9: RC5 not implemented in Qc3. */
+/* pbeWithMD2AndDES-CBC OID: 1.2.840.113549.1.5.1: MD2 not implemented. */
+/* pbeWithMD2AndRC2-CBC OID: 1.2.840.113549.1.5.4: MD2 not implemented. */
+
+static const pkcs5algo *    pbestable[] = {
+#if LIBSSH2_MD5
+    &pbeWithMD5AndDES_CBC,
+    &pbeWithMD5AndRC2_CBC,
+#endif
+    &pbeWithSHA1AndDES_CBC,
+    &pbeWithSHA1AndRC2_CBC,
+    &PBES2,
+    NULL
+};
+
+static const pkcs5algo *    pbkdf2table[] = {
+    &PBKDF2,
+    NULL
+};
+
+static const pkcs5algo *    pbes2enctable[] = {
+    &desCBC,
+    &des_EDE3_CBC,
+    &rc2CBC,
+    NULL
+};
+
+static const pkcs5algo *    kdf2prftable[] = {
+    &hmacWithSHA1,
+    NULL
+};
+
+
+/* Public key extraction support. */
+static struct {
+    unsigned char *oid;
+    int             (*sshpubkey)(LIBSSH2_SESSION *session, char **pubkey,
+                                 asn1Element *params, asn1Element *key,
+                                 const char *method);
+    const char *    method;
+}       pka[] = {
+#if LIBSSH2_RSA != 0
+    {   OID_rsaEncryption,  sshrsapubkey,   "ssh-rsa"   },
+#endif
+#if LIBSSH2_DSA != 0
+    {   OID_dsaEncryption,  sshdsapubkey,   "ssh-dss"   },
+#endif
+    {   NULL,               NULL,           NULL        }
+};
+
+/* Define ASCII strings. */
+static const char   beginencprivkeyhdr[] =
+                                    "-----BEGIN ENCRYPTED PRIVATE KEY-----";
+static const char   endencprivkeyhdr[] = "-----END ENCRYPTED PRIVATE KEY-----";
+static const char   beginprivkeyhdr[] = "-----BEGIN PRIVATE KEY-----";
+static const char   endprivkeyhdr[] = "-----END PRIVATE KEY-----";
+static const char   beginrsaprivkeyhdr[] = "-----BEGIN RSA PRIVATE KEY-----";
+static const char   endrsaprivkeyhdr[] = "-----END RSA PRIVATE KEY-----";
+static const char   fopenrmode[] = "r";
+static const char   fopenrbmode[] = "rb";
+
+
+/* The rest of character literals in this module are in EBCDIC. */
+#pragma convert(37)
+
+#include <qusec.h>
+#include <qc3prng.h>
+#include <qc3dtaen.h>
+#include <qc3dtade.h>
+#include <qc3ctx.h>
+#include <qc3hash.h>
+#include <qc3hmac.h>
+#include <qc3pbext.h>
+#include <qc3sigvr.h>
+#include <qc3sigcl.h>
+#include <qc3pbext.h>
+#include <qc3dh.h>
+
+static Qc3_Format_KEYD0100_T    nulltoken = {""};
+
+static int      zero = 0;
+static int      rsaprivate[] = { Qc3_RSA_Private };
+static char     anycsp[] = { Qc3_Any_CSP };
+static char     binstring[] = { Qc3_Bin_String };
+static char     berstring[] = { Qc3_BER_String };
+static char     qc3clear[] = { Qc3_Clear };
+
+static const Qus_EC_t ecnull = {0};     /* Error causes an exception. */
+
+static asn1Element  lastbytebitcount = {
+    (char *) &zero, NULL, (char *) &zero + 1
+};
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: big numbers support.
+ *
+ *******************************************************************/
+
+int
+_libssh2_random(unsigned char *buf, size_t len)
+{
+    Qus_EC_t errcode;
+
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3GenPRNs(buf, len,
+        Qc3PRN_TYPE_NORMAL, Qc3PRN_NO_PARITY, (char *) &errcode);
+    return errcode.Bytes_Available ? -1 : 0;
+}
+
+_libssh2_bn *
+_libssh2_bn_init(void)
+{
+    _libssh2_bn *bignum;
+
+    bignum = (_libssh2_bn *) malloc(sizeof(*bignum));
+    if(bignum) {
+        bignum->bignum = NULL;
+        bignum->length = 0;
+    }
+
+    return bignum;
+}
+
+void
+_libssh2_bn_free(_libssh2_bn *bn)
+{
+    if(bn) {
+        if(bn->bignum) {
+            if(bn->length)
+                _libssh2_explicit_zero(bn->bignum, bn->length);
+
+            free(bn->bignum);
+        }
+
+        free((char *) bn);
+    }
+}
+
+static int
+_libssh2_bn_resize(_libssh2_bn *bn, size_t newlen)
+{
+    unsigned char *bignum;
+
+    if(!bn)
+        return -1;
+    if(newlen == bn->length)
+        return 0;
+
+    if(!bn->bignum)
+        bignum = (unsigned char *) malloc(newlen);
+    else {
+        if(newlen < bn->length)
+            _libssh2_explicit_zero(bn->bignum + newlen, bn->length - newlen);
+
+        if(!newlen) {
+            free((char *) bn->bignum);
+            bn->bignum = NULL;
+            bn->length = 0;
+            return 0;
+        }
+        bignum = (unsigned char *) realloc((char *) bn->bignum, newlen);
+    }
+
+    if(!bignum)
+        return -1;
+
+    if(newlen > bn->length)
+        memset((char *) bignum + bn->length, 0, newlen - bn->length);
+
+    bn->bignum = bignum;
+    bn->length = newlen;
+    return 0;
+}
+
+unsigned long
+_libssh2_bn_bits(_libssh2_bn *bn)
+{
+    unsigned int i;
+    unsigned char b;
+
+    if(bn && bn->bignum) {
+        for(i = bn->length; i--;) {
+            b = bn->bignum[i];
+            if(b) {
+                i *= 8;
+                do {
+                    i++;
+                } while(b >>= 1);
+                return i;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int
+_libssh2_bn_from_bin(_libssh2_bn *bn, size_t len, const unsigned char *val)
+{
+    size_t i;
+
+    if(!bn || (len && !val))
+        return -1;
+
+    for(; len && !*val; len--)
+        val++;
+
+    if(_libssh2_bn_resize(bn, len))
+        return -1;
+
+    for(i = len; i--;)
+        bn->bignum[i] = *val++;
+
+    return 0;
+}
+
+int
+_libssh2_bn_set_word(_libssh2_bn *bn, unsigned long val)
+{
+    val = htonl(val);
+    return _libssh2_bn_from_bin(bn, sizeof(val), (unsigned char *) &val);
+}
+
+int
+_libssh2_bn_to_bin(_libssh2_bn *bn, unsigned char *val)
+{
+    int i;
+
+    if(!bn || !val)
+        return -1;
+
+    for(i = bn->length; i--;)
+        *val++ = bn->bignum[i];
+
+    return 0;
+}
+
+static int
+_libssh2_bn_from_bn(_libssh2_bn *to, _libssh2_bn *from)
+{
+    int i;
+
+    if(!to || !from)
+        return -1;
+
+    if(_libssh2_bn_resize(to, from->length))
+        return -1;
+
+    for(i = to->length; i--;)
+        to->bignum[i] = from->bignum[i];
+
+    return 0;
+}
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: ASN.1 support.
+ *
+ *******************************************************************/
+
+static char *
+getASN1Element(asn1Element *elem, char *beg, char *end)
+{
+    unsigned char b;
+    unsigned long len;
+    asn1Element lelem;
+
+    /* Get a single ASN.1 element into `elem', parse ASN.1 string at `beg'
+     * ending at `end'.
+     * Returns a pointer in source string after the parsed element, or NULL
+     * if an error occurs.
+     */
+
+    if(beg >= end || !*beg)
+        return NULL;
+
+    /* Process header byte. */
+    elem->header = beg;
+    b = (unsigned char) *beg++;
+    elem->constructed = (b & 0x20) != 0;
+    elem->class = (b >> 6) & 3;
+    b &= 0x1F;
+    if(b == 0x1F)
+        return NULL;            /* Long tag values not supported here. */
+    elem->tag = b;
+
+    /* Process length. */
+    if(beg >= end)
+        return NULL;
+    b = (unsigned char) *beg++;
+    if(!(b & 0x80))
+        len = b;
+    else if(!(b &= 0x7F)) {
+        /* Unspecified length. Since we have all the data, we can determine the
+         * effective length by skipping element until an end element is
+         * found.
+         */
+        if(!elem->constructed)
+            return NULL;
+        elem->beg = beg;
+        while(beg < end && *beg) {
+            beg = getASN1Element(&lelem, beg, end);
+        if(!beg)
+            return NULL;
+        }
+        if(beg >= end)
+            return NULL;
+        elem->end = beg;
+        return beg + 1;
+    }
+    else if(beg + b > end)
+        return NULL;                        /* Does not fit in source. */
+    else {
+        /* Get long length. */
+        len = 0;
+        do {
+            if(len & 0xFF000000L)
+                return NULL;    /* Lengths > 32 bits are not supported. */
+            len = (len << 8) | (unsigned char) *beg++;
+        } while(--b);
+    }
+    if((unsigned long) (end - beg) < len)
+        return NULL;            /* Element data does not fit in source. */
+    elem->beg = beg;
+    elem->end = beg + len;
+    return elem->end;
+}
+
+static asn1Element *
+asn1_new(unsigned int type, unsigned int length)
+{
+    asn1Element *e;
+    unsigned int hdrl = 2;
+    unsigned int i;
+    unsigned char *buf;
+
+    e = (asn1Element *) malloc(sizeof(*e));
+
+    if(e) {
+        if(length >= 0x80)
+            for(i = length; i; i >>= 8)
+                hdrl++;
+
+        buf = (unsigned char *) malloc(hdrl + length);
+
+        if(buf) {
+            e->header = buf;
+            e->beg = buf + hdrl;
+            e->end = e->beg + length;
+            e->class = (type >> 6) & 0x03;
+            e->tag = type & 0x1F;
+            e->constructed = (type >> 5) & 0x01;
+            e->header[0] = type;
+
+            if(length < 0x80)
+                e->header[1] = length;
+            else {
+                e->header[1] = (hdrl - 2) | 0x80;
+                do {
+                    e->header[--hdrl] = length;
+                    length >>= 8;
+                } while(length);
+            }
+        }
+        else {
+            free((char *) e);
+            e = NULL;
+        }
+    }
+
+    return e;
+}
+
+static asn1Element *
+asn1_new_from_bytes(const unsigned char *data, unsigned int length)
+{
+    asn1Element *e;
+    asn1Element et;
+
+    getASN1Element(&et,
+                   (unsigned char *) data, (unsigned char *) data + length);
+    e = asn1_new(et.tag, et.end - et.beg);
+
+    if(e)
+        memcpy(e->header, data, e->end - e->header);
+
+    return e;
+}
+
+static void
+asn1delete(asn1Element *e)
+{
+    if(e) {
+        if(e->header)
+            free((char *) e->header);
+        free((char *) e);
+    }
+}
+
+static asn1Element *
+asn1uint(_libssh2_bn *bn)
+{
+    asn1Element *e;
+    int bits;
+    int length;
+    unsigned char *p;
+
+    if(!bn)
+        return NULL;
+
+    bits = _libssh2_bn_bits(bn);
+    length = (bits + 8) >> 3;
+    e = asn1_new(ASN1_INTEGER, length);
+
+    if(e) {
+        p = e->beg;
+        if(!(bits & 0x07))
+            *p++ = 0;
+        _libssh2_bn_to_bin(bn, p);
+    }
+
+    return e;
+}
+
+static asn1Element *
+asn1containerv(unsigned int type, valiststr args)
+{
+    valiststr va;
+    asn1Element *e;
+    asn1Element *p;
+    unsigned char *bp;
+    unsigned int length = 0;
+
+    memcpy((char *) &va, (char *) &args, sizeof(args));
+    while((p = va_arg(va.list, asn1Element *)))
+        length += p->end - p->header;
+    va_end(va.list);
+    e = asn1_new(type, length);
+    if(e) {
+        bp = e->beg;
+        while((p = va_arg(args.list, asn1Element *))) {
+            memcpy(bp, p->header, p->end - p->header);
+            bp += p->end - p->header;
+        }
+    }
+    return e;
+}
+
+/* VARARGS1 */
+static asn1Element *
+asn1container(unsigned int type, ...)
+{
+    valiststr va;
+    asn1Element *e;
+
+    va_start(va.list, type);
+    e = asn1containerv(type, va);
+    va_end(va.list);
+    return e;
+}
+
+static asn1Element *
+asn1bytes(unsigned int type, const unsigned char *bytes, unsigned int length)
+{
+    asn1Element *e;
+
+    e = asn1_new(type, length);
+    if(e && length)
+        memcpy(e->beg, bytes, length);
+    return e;
+}
+
+static asn1Element *
+rsapublickey(_libssh2_bn *e, _libssh2_bn *m)
+{
+    asn1Element *publicexponent;
+    asn1Element *modulus;
+    asn1Element *rsapubkey;
+
+    /* Build a PKCS#1 RSAPublicKey. */
+
+    modulus = asn1uint(m);
+    publicexponent = asn1uint(e);
+    rsapubkey = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                              modulus, publicexponent, NULL);
+    asn1delete(modulus);
+    asn1delete(publicexponent);
+
+    if(!modulus || !publicexponent) {
+        asn1delete(rsapubkey);
+        rsapubkey = NULL;
+    }
+
+    return rsapubkey;
+}
+
+static asn1Element *
+rsaprivatekey(_libssh2_bn *e, _libssh2_bn *m, _libssh2_bn *d,
+              _libssh2_bn *p, _libssh2_bn *q,
+              _libssh2_bn *exp1, _libssh2_bn *exp2, _libssh2_bn *coeff)
+{
+    asn1Element *version;
+    asn1Element *modulus;
+    asn1Element *publicexponent;
+    asn1Element *privateexponent;
+    asn1Element *prime1;
+    asn1Element *prime2;
+    asn1Element *exponent1;
+    asn1Element *exponent2;
+    asn1Element *coefficient;
+    asn1Element *rsaprivkey;
+
+    /* Build a PKCS#1 RSAPrivateKey. */
+    version = asn1bytes(ASN1_INTEGER, "\0", 1);
+    modulus = asn1uint(m);
+    publicexponent = asn1uint(e);
+    privateexponent = asn1uint(d);
+    prime1 = asn1uint(p);
+    prime2 = asn1uint(q);
+    exponent1 = asn1uint(exp1);
+    exponent2 = asn1uint(exp2);
+    coefficient = asn1uint(coeff);
+    rsaprivkey = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED, version, modulus,
+                               publicexponent, privateexponent, prime1, prime2,
+                               exponent1, exponent2, coefficient, NULL);
+    asn1delete(version);
+    asn1delete(modulus);
+    asn1delete(publicexponent);
+    asn1delete(privateexponent);
+    asn1delete(prime1);
+    asn1delete(prime2);
+    asn1delete(exponent1);
+    asn1delete(exponent2);
+    asn1delete(coefficient);
+
+    if(!version || !modulus || !publicexponent || !privateexponent ||
+        !prime1 || !prime2 || !exponent1 || !exponent2 || !coefficient) {
+        asn1delete(rsaprivkey);
+        rsaprivkey = NULL;
+    }
+
+    return rsaprivkey;
+}
+
+static asn1Element *
+subjectpublickeyinfo(asn1Element *pubkey, const unsigned char *algo,
+                     asn1Element *parameters)
+{
+    asn1Element *subjpubkey;
+    asn1Element *algorithm;
+    asn1Element *algorithmid;
+    asn1Element *subjpubkeyinfo;
+    unsigned int algosize = *algo++;
+
+    algorithm = asn1bytes(ASN1_OBJ_ID, algo, algosize);
+    algorithmid = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                                algorithm, parameters, NULL);
+    subjpubkey = asn1container(ASN1_BIT_STRING, &lastbytebitcount,
+                               pubkey, NULL);
+    subjpubkeyinfo = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                                   algorithmid, subjpubkey, NULL);
+    asn1delete(algorithm);
+    asn1delete(algorithmid);
+    asn1delete(subjpubkey);
+    if(!algorithm || !algorithmid || !subjpubkey) {
+        asn1delete(subjpubkeyinfo);
+        subjpubkeyinfo = NULL;
+    }
+    return subjpubkeyinfo;
+}
+
+static asn1Element *
+rsasubjectpublickeyinfo(asn1Element *pubkey)
+{
+    asn1Element *parameters;
+    asn1Element *subjpubkeyinfo;
+
+    parameters = asn1bytes(ASN1_NULL, NULL, 0);
+    subjpubkeyinfo = subjectpublickeyinfo(pubkey,
+                                          OID_rsaEncryption, parameters);
+    asn1delete(parameters);
+    if(!parameters) {
+        asn1delete(subjpubkeyinfo);
+        subjpubkeyinfo = NULL;
+    }
+    return subjpubkeyinfo;
+}
+
+static asn1Element *
+privatekeyinfo(asn1Element *privkey, const unsigned char *algo,
+               asn1Element *parameters)
+{
+    asn1Element *version;
+    asn1Element *privatekey;
+    asn1Element *algorithm;
+    asn1Element *privatekeyalgorithm;
+    asn1Element *privkeyinfo;
+    unsigned int algosize = *algo++;
+
+    /* Build a PKCS#8 PrivateKeyInfo. */
+    version = asn1bytes(ASN1_INTEGER, "\0", 1);
+    algorithm = asn1bytes(ASN1_OBJ_ID, algo, algosize);
+    privatekeyalgorithm = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                                        algorithm, parameters, NULL);
+    privatekey = asn1container(ASN1_OCTET_STRING, privkey, NULL);
+    privkeyinfo = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED, version,
+                                privatekeyalgorithm, privatekey, NULL);
+    asn1delete(version);
+    asn1delete(algorithm);
+    asn1delete(privatekeyalgorithm);
+    if(!version || !algorithm || !privatekeyalgorithm) {
+        asn1delete(privkeyinfo);
+        privkeyinfo = NULL;
+    }
+    return privkeyinfo;
+}
+
+static asn1Element *
+rsaprivatekeyinfo(asn1Element *privkey)
+{
+    asn1Element *parameters;
+    asn1Element *privkeyinfo;
+
+    parameters = asn1bytes(ASN1_NULL, NULL, 0);
+    privkeyinfo = privatekeyinfo(privkey, OID_rsaEncryption, parameters);
+    asn1delete(parameters);
+    if(!parameters) {
+        asn1delete(privkeyinfo);
+        privkeyinfo = NULL;
+    }
+    return privkeyinfo;
+}
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: crypto context support.
+ *
+ *******************************************************************/
+
+static _libssh2_os400qc3_crypto_ctx *
+libssh2_init_crypto_ctx(_libssh2_os400qc3_crypto_ctx *ctx)
+{
+    if(!ctx)
+        ctx = (_libssh2_os400qc3_crypto_ctx *) malloc(sizeof(*ctx));
+
+    if(ctx) {
+        memset((char *) ctx, 0, sizeof(*ctx));
+        ctx->hash.Final_Op_Flag = Qc3_Continue;
+    }
+
+    return ctx;
+}
+
+static int
+null_token(const char *token)
+{
+    return !memcmp(token, nulltoken.Key_Context_Token,
+                   sizeof(nulltoken.Key_Context_Token));
+}
+
+void
+_libssh2_os400qc3_crypto_dtor(_libssh2_os400qc3_crypto_ctx *x)
+{
+    if(!x)
+        return;
+    if(!null_token(x->hash.Alg_Context_Token)) {
+        Qc3DestroyAlgorithmContext(x->hash.Alg_Context_Token,
+                                   (char *) &ecnull);
+        memset(x->hash.Alg_Context_Token, 0,
+               sizeof(x->hash.Alg_Context_Token));
+    }
+    if(!null_token(x->key.Key_Context_Token)) {
+        Qc3DestroyKeyContext(x->key.Key_Context_Token, (char *) &ecnull);
+        memset(x->key.Key_Context_Token, 0,
+               sizeof(x->key.Key_Context_Token));
+    }
+    if(x->kek) {
+        _libssh2_os400qc3_crypto_dtor(x->kek);
+        free((char *) x->kek);
+        x->kek = NULL;
+    }
+}
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: hash algorithms support.
+ *
+ *******************************************************************/
+
+int
+_libssh2_os400qc3_hash_init(Qc3_Format_ALGD0100_T *x, unsigned int algorithm)
+{
+    Qc3_Format_ALGD0500_T algd;
+    Qus_EC_t errcode;
+
+    if(!x)
+        return 0;
+
+    memset((char *) x, 0, sizeof(*x));
+    x->Final_Op_Flag = Qc3_Continue;
+    algd.Hash_Alg = algorithm;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Hash,
+                              x->Alg_Context_Token, &errcode);
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+int
+_libssh2_os400qc3_hash_update(Qc3_Format_ALGD0100_T *ctx,
+                              const unsigned char *data, int len)
+{
+    char dummy[64];
+    Qus_EC_t errcode;
+
+    ctx->Final_Op_Flag = Qc3_Continue;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateHash((char *) data, &len, Qc3_Data, (char *) ctx,
+                     Qc3_Alg_Token, anycsp, NULL, dummy, &errcode);
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+int
+_libssh2_os400qc3_hash_final(Qc3_Format_ALGD0100_T *ctx, unsigned char *out)
+{
+    char data;
+    Qus_EC_t errcode;
+
+    ctx->Final_Op_Flag = Qc3_Final;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateHash(&data, &zero, Qc3_Data, (char *) ctx, Qc3_Alg_Token,
+                     anycsp, NULL, (char *) out, &errcode);
+    Qc3DestroyAlgorithmContext(ctx->Alg_Context_Token, (char *) &ecnull);
+    memset(ctx->Alg_Context_Token, 0, sizeof(ctx->Alg_Context_Token));
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+int
+_libssh2_os400qc3_hash(const unsigned char *message, unsigned long len,
+                       unsigned char *out, unsigned int algo)
+{
+    Qc3_Format_ALGD0100_T ctx;
+
+    if(!_libssh2_os400qc3_hash_init(&ctx, algo) ||
+       !_libssh2_os400qc3_hash_update(&ctx, message, len) ||
+       !_libssh2_os400qc3_hash_final(&ctx, out))
+        return 1;
+
+    return 0;
+}
+
+static int
+libssh2_os400qc3_hmac_init(_libssh2_os400qc3_crypto_ctx *ctx,
+                           int algo, size_t minkeylen, void *key, int keylen)
+{
+    Qus_EC_t errcode;
+
+    if(keylen < minkeylen) {
+        char *lkey = alloca(minkeylen);
+
+        /* Pad key with zeroes if too short. */
+        if(!lkey)
+            return 0;
+        memcpy(lkey, (char *) key, keylen);
+        memset(lkey + keylen, 0, minkeylen - keylen);
+        key = (void *) lkey;
+        keylen = minkeylen;
+    }
+    if(!_libssh2_os400qc3_hash_init(&ctx->hash, algo))
+        return 0;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CreateKeyContext((char *) key, &keylen, binstring, &algo, qc3clear,
+                        NULL, NULL, ctx->key.Key_Context_Token,
+                        (char *) &errcode);
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
+{
+    memset((char *) ctx, 0, sizeof(libssh2_hmac_ctx));
+    return 1;
+}
+
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen)
+{
+    return libssh2_os400qc3_hmac_init(ctx, Qc3_MD5,                     \
+                                      MD5_DIGEST_LENGTH,                \
+                                      key, keylen);
+}
+#endif
+
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen)
+{
+    return libssh2_os400qc3_hmac_init(ctx, Qc3_SHA1,                    \
+                                      SHA_DIGEST_LENGTH,                \
+                                      key, keylen);
+}
+
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    return libssh2_os400qc3_hmac_init(ctx, Qc3_SHA256,                  \
+                                      SHA256_DIGEST_LENGTH,             \
+                                      key, keylen);
+}
+
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    return libssh2_os400qc3_hmac_init(ctx, Qc3_SHA512,                  \
+                                      SHA512_DIGEST_LENGTH,             \
+                                      key, keylen);
+}
+
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen)
+{
+    char dummy[64];
+    int len = (int) datalen;
+    Qus_EC_t errcode;
+
+    ctx->hash.Final_Op_Flag = Qc3_Continue;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateHMAC((char *) data, &len, Qc3_Data, (char *) &ctx->hash,
+                     Qc3_Alg_Token, ctx->key.Key_Context_Token, Qc3_Key_Token,
+                     anycsp, NULL, dummy, (char *) &errcode);
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *out)
+{
+    char data;
+    Qus_EC_t errcode;
+
+    ctx->hash.Final_Op_Flag = Qc3_Final;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateHMAC((char *) data, &zero, Qc3_Data, (char *) &ctx->hash,
+                     Qc3_Alg_Token, ctx->key.Key_Context_Token, Qc3_Key_Token,
+                     anycsp, NULL, (char *) out, (char *) &errcode);
+    return errcode.Bytes_Available ? 0 : 1;
+}
+
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
+{
+    _libssh2_os400qc3_crypto_dtor(ctx);
+}
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: cipher algorithms support.
+ *
+ *******************************************************************/
+
+int
+_libssh2_cipher_init(_libssh2_cipher_ctx *h, _libssh2_cipher_type(algo),
+                     unsigned char *iv, unsigned char *secret, int encrypt)
+{
+    Qc3_Format_ALGD0200_T algd;
+    Qus_EC_t errcode;
+
+    (void) encrypt;
+
+    if(!h)
+        return -1;
+
+    libssh2_init_crypto_ctx(h);
+    algd.Block_Cipher_Alg = algo.algo;
+    algd.Block_Length = algo.size;
+    algd.Mode = algo.mode;
+    algd.Pad_Option = Qc3_No_Pad;
+    algd.Pad_Character = 0;
+    algd.Reserved = 0;
+    algd.MAC_Length = 0;
+    algd.Effective_Key_Size = 0;
+    memset(algd.Init_Vector, 0, sizeof(algd.Init_Vector));
+    if(algo.mode != Qc3_ECB && algo.size)
+        memcpy(algd.Init_Vector, iv, algo.size);
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CreateAlgorithmContext((char *) &algd, algo.fmt,
+                              h->hash.Alg_Context_Token, &errcode);
+    if(errcode.Bytes_Available)
+        return -1;
+    Qc3CreateKeyContext((char *) secret, &algo.keylen, binstring,
+                        &algo.algo, qc3clear, NULL, NULL,
+                        h->key.Key_Context_Token, (char *) &errcode);
+    if(errcode.Bytes_Available) {
+        _libssh2_os400qc3_crypto_dtor(h);
+        return -1;
+    }
+
+    return 0;
+}
+
+int
+_libssh2_cipher_crypt(_libssh2_cipher_ctx *ctx,
+                      _libssh2_cipher_type(algo),
+                      int encrypt, unsigned char *block, size_t blocksize,
+                      int firstlast)
+{
+    Qus_EC_t errcode;
+    int outlen;
+    int blksize = blocksize;
+
+    (void) algo;
+
+    set_EC_length(errcode, sizeof(errcode));
+    if(encrypt)
+        Qc3EncryptData((char *) block, &blksize, Qc3_Data,
+                       ctx->hash.Alg_Context_Token, Qc3_Alg_Token,
+                       ctx->key.Key_Context_Token, Qc3_Key_Token, anycsp, NULL,
+                       (char *) block, &blksize, &outlen, (char *) &errcode);
+    else
+        Qc3DecryptData((char *) block, &blksize,
+                       ctx->hash.Alg_Context_Token, Qc3_Alg_Token,
+                       ctx->key.Key_Context_Token, Qc3_Key_Token, anycsp, NULL,
+                       (char *) block, &blksize, &outlen, (char *) &errcode);
+
+    return errcode.Bytes_Available ? -1 : 0;
+}
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: RSA support.
+ *
+ *******************************************************************/
+
+int
+_libssh2_rsa_new(libssh2_rsa_ctx **rsa,
+                 const unsigned char *edata, unsigned long elen,
+                 const unsigned char *ndata, unsigned long nlen,
+                 const unsigned char *ddata, unsigned long dlen,
+                 const unsigned char *pdata, unsigned long plen,
+                 const unsigned char *qdata, unsigned long qlen,
+                 const unsigned char *e1data, unsigned long e1len,
+                 const unsigned char *e2data, unsigned long e2len,
+                 const unsigned char *coeffdata, unsigned long coefflen)
+{
+    libssh2_rsa_ctx *ctx;
+    _libssh2_bn *e = _libssh2_bn_init_from_bin();
+    _libssh2_bn *n = _libssh2_bn_init_from_bin();
+    _libssh2_bn *d = NULL;
+    _libssh2_bn *p = NULL;
+    _libssh2_bn *q = NULL;
+    _libssh2_bn *e1 = NULL;
+    _libssh2_bn *e2 = NULL;
+    _libssh2_bn *coeff = NULL;
+    asn1Element *key = NULL;
+    asn1Element *structkey = NULL;
+    int keytype;
+    int ret = 0;
+    int i;
+
+    ctx = libssh2_init_crypto_ctx(NULL);
+    if(!ctx)
+        ret = -1;
+    if(!ret) {
+        _libssh2_bn_from_bin(e, elen, edata);
+        _libssh2_bn_from_bin(n, nlen, ndata);
+        if(!e || !n)
+            ret = -1;
+    }
+    if(!ret && ddata) {
+        /* Private key. */
+        d = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(d, dlen, ddata);
+        p = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(p, plen, pdata);
+        q = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(q, qlen, qdata);
+        e1 = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(e1, e1len, e1data);
+        e2 = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(e2, e2len, e2data);
+        coeff = _libssh2_bn_init_from_bin();
+        _libssh2_bn_from_bin(coeff, coefflen, coeffdata);
+        if(!d || !p || !q ||!e1 || !e2 || !coeff)
+            ret = -1;
+
+        if(!ret) {
+            /* Build a PKCS#8 private key. */
+            key = rsaprivatekey(e, n, d, p, q, e1, e2, coeff);
+            structkey = rsaprivatekeyinfo(key);
+        }
+        keytype = Qc3_RSA_Private;
+    }
+    else if(!ret) {
+        key = rsapublickey(e, n);
+        structkey = rsasubjectpublickeyinfo(key);
+        keytype = Qc3_RSA_Public;
+    }
+    if(!key || !structkey)
+        ret = -1;
+
+    /* Create the key context. */
+    if(!ret) {
+        Qus_EC_t errcode;
+
+        set_EC_length(errcode, sizeof(errcode));
+        i = structkey->end - structkey->header;
+        Qc3CreateKeyContext(structkey->header, &i, berstring, &keytype,
+                            qc3clear, NULL, NULL, ctx->key.Key_Context_Token,
+                            (char *) &errcode);
+        if(errcode.Bytes_Available)
+            ret = -1;
+    }
+
+    _libssh2_bn_free(e);
+    _libssh2_bn_free(n);
+    _libssh2_bn_free(d);
+    _libssh2_bn_free(p);
+    _libssh2_bn_free(q);
+    _libssh2_bn_free(e1);
+    _libssh2_bn_free(e2);
+    _libssh2_bn_free(coeff);
+    asn1delete(key);
+    asn1delete(structkey);
+    if(ret && ctx) {
+        _libssh2_rsa_free(ctx);
+        ctx = NULL;
+    }
+    *rsa = ctx;
+    return ret;
+}
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: Diffie-Hellman support.
+ *
+ *******************************************************************/
+
+void
+_libssh2_os400qc3_dh_init(_libssh2_dh_ctx *dhctx)
+{
+    memset((char *) dhctx, 0, sizeof(*dhctx));
+}
+
+int
+_libssh2_os400qc3_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
+                              _libssh2_bn *g, _libssh2_bn *p, int group_order)
+{
+    asn1Element *prime;
+    asn1Element *base;
+    asn1Element *dhparameter;
+    asn1Element *dhkeyagreement;
+    asn1Element *pkcs3;
+    int pkcs3len;
+    char *pubkey;
+    int pubkeysize;
+    int pubkeylen;
+    Qus_EC_t errcode;
+
+    (void) group_order;
+
+    /* Build the PKCS#3 structure. */
+
+    base = asn1uint(g);
+    prime = asn1uint(p);
+    dhparameter = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                                prime, base, NULL);
+    asn1delete(base);
+    asn1delete(prime);
+    dhkeyagreement = asn1bytes(ASN1_OBJ_ID,
+                               OID_dhKeyAgreement + 1, OID_dhKeyAgreement[0]);
+    pkcs3 = asn1container(ASN1_SEQ | ASN1_CONSTRUCTED,
+                          dhkeyagreement, dhparameter, NULL);
+    asn1delete(dhkeyagreement);
+    asn1delete(dhparameter);
+    if(!base || !prime || !dhparameter ||
+        !dhkeyagreement || !dhparameter || !pkcs3) {
+        asn1delete(pkcs3);
+        return -1;
+    }
+    pkcs3len = pkcs3->end - pkcs3->header;
+    pubkeysize = (_libssh2_bn_bits(p) + 7) >> 3;
+    pubkey = alloca(pubkeysize);
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3GenDHKeyPair((char *) pkcs3->header, &pkcs3len, anycsp, NULL,
+                    dhctx->token, pubkey, &pubkeysize, &pubkeylen, &errcode);
+    asn1delete(pkcs3);
+    if(errcode.Bytes_Available)
+        return -1;
+    return _libssh2_bn_from_bin(public, pubkeylen, (unsigned char *) pubkey);
+}
+
+int
+_libssh2_os400qc3_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
+                            _libssh2_bn *f, _libssh2_bn *p)
+{
+    char *pubkey;
+    int pubkeysize;
+    char *secretbuf;
+    int secretbufsize;
+    int secretbuflen;
+    Qus_EC_t errcode;
+
+    pubkeysize = (_libssh2_bn_bits(f) + 7) >> 3;
+    pubkey = alloca(pubkeysize);
+    _libssh2_bn_to_bin(f, pubkey);
+    secretbufsize = (_libssh2_bn_bits(p) + 7) >> 3;
+    secretbuf = alloca(pubkeysize);
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateDHSecretKey(dhctx->token, pubkey, &pubkeysize,
+                            secretbuf, &secretbufsize, &secretbuflen,
+                            &errcode);
+    if(errcode.Bytes_Available)
+        return -1;
+    return _libssh2_bn_from_bin(secret,
+                                secretbuflen, (unsigned char *) secretbuf);
+}
+
+void
+_libssh2_os400qc3_dh_dtor(_libssh2_dh_ctx *dhctx)
+{
+    if(!null_token(dhctx->token)) {
+        Qc3DestroyAlgorithmContext(dhctx->token, (char *) &ecnull);
+        memset((char *) dhctx, 0, sizeof(*dhctx));
+    }
+}
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: PKCS#5 supplement.
+ *
+ *******************************************************************/
+
+static int
+oidcmp(const asn1Element *e, const unsigned char *oid)
+{
+    int i = e->end - e->beg - *oid++;
+
+    if(*e->header != ASN1_OBJ_ID)
+        return -2;
+    if(!i)
+        i = memcmp(e->beg, oid, oid[-1]);
+    return i;
+}
+
+static int
+asn1getword(asn1Element *e, unsigned long *v)
+{
+    unsigned long a;
+    const unsigned char *cp;
+
+    if(*e->header != ASN1_INTEGER)
+        return -1;
+    for(cp = e->beg; cp < e->end && !*cp; cp++)
+        ;
+    if(e->end - cp > sizeof(a))
+        return -1;
+    for(a = 0; cp < e->end; cp++)
+        a = (a << 8) | *cp;
+    *v = a;
+    return 0;
+}
+
+static int
+pbkdf1(LIBSSH2_SESSION *session, char **dk, const unsigned char *passphrase,
+       pkcs5params *pkcs5)
+{
+    int i;
+    Qc3_Format_ALGD0100_T hctx;
+    int len = pkcs5->saltlen;
+    char *data = (char *) pkcs5->salt;
+    Qus_EC_t errcode;
+
+    *dk = NULL;
+    if(pkcs5->dklen > pkcs5->hashlen)
+        return -1;
+
+    /* Allocate the derived key buffer. */
+    *dk = LIBSSH2_ALLOC(session, pkcs5->hashlen);
+    if(!*dk)
+        return -1;
+
+    set_EC_length(errcode, sizeof(errcode));
+    errcode.Bytes_Available = 1;   /* Defaults to error flagging. */
+
+    /* Initial hash. */
+    if(_libssh2_os400qc3_hash_init(&hctx, pkcs5->hash)) {
+        if(_libssh2_os400qc3_hash_update(&hctx,
+                                         passphrase, strlen(passphrase))) {
+            hctx.Final_Op_Flag = Qc3_Final;
+            Qc3CalculateHash((char *) pkcs5->salt, &len, Qc3_Data,
+                             (char *) &hctx, Qc3_Alg_Token, anycsp, NULL, *dk,
+                             (char *) &errcode);
+
+            /* Iterate. */
+            len = pkcs5->hashlen;
+            for(i = 1; !errcode.Bytes_Available && i < pkcs5->itercount; i++)
+                Qc3CalculateHash((char *) *dk, &len, Qc3_Data, (char *) &hctx,
+                                 Qc3_Alg_Token, anycsp, NULL, *dk,
+                                 (char *) &errcode);
+        }
+
+        Qc3DestroyAlgorithmContext(hctx.Alg_Context_Token, (char *) &ecnull);
+    }
+
+    if(errcode.Bytes_Available) {
+        LIBSSH2_FREE(session, *dk);
+        *dk = NULL;
+        return -1;
+    }
+
+    /* Special stuff for PBES1: split derived key into 8-byte key and 8-byte
+       initialization vector. */
+    pkcs5->dklen = 8;
+    pkcs5->ivlen = 8;
+    pkcs5->iv = *dk + 8;
+
+    return 0;
+}
+
+static int
+pbkdf2(LIBSSH2_SESSION *session, char **dk, const unsigned char *passphrase,
+       pkcs5params *pkcs5)
+{
+    size_t i;
+    size_t k;
+    int j;
+    int l;
+    uint32_t ni;
+    unsigned long long t;
+    char *mac;
+    char *buf;
+    _libssh2_os400qc3_crypto_ctx hctx;
+
+    *dk = NULL;
+    t = ((unsigned long long) pkcs5->dklen + pkcs5->hashlen - 1) /
+        pkcs5->hashlen;
+    if(t > 0xFFFFFFFF)
+        return -1;
+    mac = alloca(pkcs5->hashlen);
+    if(!mac)
+        return -1;
+
+    /* Create an HMAC context for our computations. */
+    if(!libssh2_os400qc3_hmac_init(&hctx, pkcs5->hash, pkcs5->hashlen,
+                                   (void *) passphrase, strlen(passphrase)))
+        return -1;
+
+    /* Allocate the derived key buffer. */
+    l = t;
+    buf = LIBSSH2_ALLOC(session, l * pkcs5->hashlen);
+    if(!buf)
+        return -1;
+    *dk = buf;
+
+    /* Process each hLen-size blocks. */
+    for(i = 1; i <= l; i++) {
+        ni = htonl(i);
+        if(!_libssh2_hmac_update(&hctx, pkcs5->salt, pkcs5->saltlen) ||
+           !_libssh2_hmac_update(&hctx, &ni, sizeof(ni)) ||
+           !_libssh2_hmac_final(&hctx, mac)) {
+            LIBSSH2_FREE(session, buf);
+            *dk = NULL;
+            _libssh2_os400qc3_crypto_dtor(&hctx);
+            return -1;
+        }
+        memcpy(buf, mac, pkcs5->hashlen);
+        for(j = 1; j < pkcs5->itercount; j++) {
+            if(!_libssh2_hmac_update(&hctx, mac, pkcs5->hashlen) ||
+               !_libssh2_hmac_final(&hctx, mac)) {
+                LIBSSH2_FREE(session, buf);
+                *dk = NULL;
+                _libssh2_os400qc3_crypto_dtor(&hctx);
+                return -1;
+            }
+            for(k = 0; k < pkcs5->hashlen; k++)
+                buf[k] ^= mac[k];
+        }
+        buf += pkcs5->hashlen;
+    }
+
+    /* Computation done. Release HMAC context. */
+    _libssh2_os400qc3_crypto_dtor(&hctx);
+    return 0;
+}
+
+static int
+parse_pkcs5_algorithm(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                      asn1Element *algid, pkcs5algo **algotable)
+{
+    asn1Element oid;
+    asn1Element param;
+    char *cp;
+
+    cp = getASN1Element(&oid, algid->beg, algid->end);
+    if(!cp || *oid.header != ASN1_OBJ_ID)
+        return -1;
+    param.header = NULL;
+    if(cp < algid->end)
+        cp = getASN1Element(&param, cp, algid->end);
+    if(cp != algid->end)
+        return -1;
+    for(; *algotable; algotable++)
+        if(!oidcmp(&oid, (*algotable)->oid))
+            return (*(*algotable)->parse)(session, pkcs5, *algotable,
+                                          param.header ? &param : NULL);
+    return -1;
+}
+
+static int
+parse_pbes2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+            pkcs5algo *algo, asn1Element *param)
+{
+    asn1Element keyDerivationFunc;
+    asn1Element encryptionScheme;
+    char *cp;
+
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    cp = getASN1Element(&keyDerivationFunc, param->beg, param->end);
+    if(!cp || *keyDerivationFunc.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    if(getASN1Element(&encryptionScheme, cp, param->end) != param->end ||
+        *encryptionScheme.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    if(parse_pkcs5_algorithm(session, pkcs5, &encryptionScheme, pbes2enctable))
+        return -1;
+    if(parse_pkcs5_algorithm(session, pkcs5, &keyDerivationFunc, pbkdf2table))
+        return -1;
+    return 0;
+}
+
+static int
+parse_pbkdf2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+             pkcs5algo *algo, asn1Element *param)
+{
+    asn1Element salt;
+    asn1Element iterationCount;
+    asn1Element keyLength;
+    asn1Element prf;
+    unsigned long itercount;
+    char *cp;
+
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    cp = getASN1Element(&salt, param->beg, param->end);
+    /* otherSource not supported. */
+    if(!cp || *salt.header != ASN1_OCTET_STRING)
+        return -1;
+    cp = getASN1Element(&iterationCount, cp, param->end);
+    if(!cp || *iterationCount.header != ASN1_INTEGER)
+        return -1;
+    keyLength.header = prf.header = NULL;
+    if(cp < param->end) {
+        cp = getASN1Element(&prf, cp, param->end);
+        if(!cp)
+            return -1;
+        if(*prf.header == ASN1_INTEGER) {
+            keyLength = prf;
+            prf.header = NULL;
+            if(cp < param->end)
+                cp = getASN1Element(&prf, cp, param->end);
+        }
+        if(cp != param->end)
+            return -1;
+    }
+    pkcs5->hash = algo->hash;
+    pkcs5->hashlen = algo->hashlen;
+    if(prf.header) {
+        if(*prf.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+            return -1;
+        if(parse_pkcs5_algorithm(session, pkcs5, &prf, kdf2prftable))
+            return -1;
+    }
+    pkcs5->saltlen = salt.end - salt.beg;
+    pkcs5->salt = salt.beg;
+    if(asn1getword(&iterationCount, &itercount) ||
+        !itercount || itercount > 100000)
+        return -1;
+    pkcs5->itercount = itercount;
+    pkcs5->kdf = pbkdf2;
+    return 0;
+}
+
+static int
+parse_hmacWithSHA1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+                   pkcs5algo *algo, asn1Element *param)
+{
+    if(!param || *param->header != ASN1_NULL)
+        return -1;
+    pkcs5->hash = algo->hash;
+    pkcs5->hashlen = algo->hashlen;
+    return 0;
+}
+
+static int
+parse_iv(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+         pkcs5algo *algo, asn1Element *param)
+{
+    if(!param || *param->header != ASN1_OCTET_STRING ||
+        param->end - param->beg != algo->ivlen)
+        return -1;
+    pkcs5->cipher = algo->cipher;
+    pkcs5->blocksize = algo->blocksize;
+    pkcs5->mode = algo->mode;
+    pkcs5->padopt = algo->padopt;
+    pkcs5->padchar = algo->padchar;
+    pkcs5->dklen = algo->keylen;
+    pkcs5->ivlen = algo->ivlen;
+    pkcs5->iv = param->beg;
+    return 0;
+}
+
+static int
+parse_rc2(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+          pkcs5algo *algo, asn1Element *param)
+{
+    asn1Element iv;
+    unsigned long effkeysize;
+    char *cp;
+
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    cp = getASN1Element(&iv, param->beg, param->end);
+    if(!cp)
+        return -1;
+    effkeysize = algo->effkeysize;
+    if(*iv.header == ASN1_INTEGER) {
+        if(asn1getword(&iv, &effkeysize) || effkeysize > 1024)
+            return -1;
+
+        cp = getASN1Element(&iv, cp, param->end);
+        if(effkeysize < 256)
+            switch(effkeysize) {
+            case 160:
+                effkeysize = 40;
+            case 120:
+                effkeysize = 64;
+            case 58:
+                effkeysize = 128;
+                break;
+            default:
+                return -1;
+            }
+    }
+    if(effkeysize > 1024 || cp != param->end ||
+        *iv.header != ASN1_OCTET_STRING || iv.end - iv.beg != algo->ivlen)
+        return -1;
+    pkcs5->cipher = algo->cipher;
+    pkcs5->blocksize = algo->blocksize;
+    pkcs5->mode = algo->mode;
+    pkcs5->padopt = algo->padopt;
+    pkcs5->padchar = algo->padchar;
+    pkcs5->ivlen = algo->ivlen;
+    pkcs5->iv = iv.beg;
+    pkcs5->effkeysize = effkeysize;
+    pkcs5->dklen = (effkeysize + 8 - 1) / 8;
+    return 0;
+}
+
+static int
+parse_pbes1(LIBSSH2_SESSION *session, pkcs5params *pkcs5,
+            pkcs5algo *algo, asn1Element *param)
+{
+    asn1Element salt;
+    asn1Element iterationCount;
+    unsigned long itercount;
+    char *cp;
+
+    if(!param || *param->header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+
+    cp = getASN1Element(&salt, param->beg, param->end);
+    if(!cp || *salt.header != ASN1_OCTET_STRING ||
+        salt.end - salt.beg != algo->saltlen)
+        return -1;
+    if(getASN1Element(&iterationCount, cp, param->end) != param->end ||
+        *iterationCount.header != ASN1_INTEGER)
+        return -1;
+    if(asn1getword(&iterationCount, &itercount) ||
+        !itercount || itercount > 100000)
+        return -1;
+    pkcs5->cipher = algo->cipher;
+    pkcs5->blocksize = algo->blocksize;
+    pkcs5->mode = algo->mode;
+    pkcs5->padopt = algo->padopt;
+    pkcs5->padchar = algo->padchar;
+    pkcs5->hash = algo->hash;
+    pkcs5->hashlen = algo->hashlen;
+    pkcs5->dklen = 16;
+    pkcs5->saltlen = algo->saltlen;
+    pkcs5->effkeysize = algo->effkeysize;
+    pkcs5->salt = salt.beg;
+    pkcs5->kdf = pbkdf1;
+    pkcs5->itercount = itercount;
+    return 0;
+}
+
+static int
+pkcs8kek(LIBSSH2_SESSION *session, _libssh2_os400qc3_crypto_ctx **ctx,
+         const unsigned char *data, unsigned int datalen,
+         const unsigned char *passphrase, asn1Element *privkeyinfo)
+{
+    asn1Element encprivkeyinfo;
+    asn1Element pkcs5alg;
+    pkcs5params pkcs5;
+    size_t pplen;
+    char *cp;
+    unsigned long t;
+    int i;
+    char *dk = NULL;
+    Qc3_Format_ALGD0200_T algd;
+    Qus_EC_t errcode;
+
+    /* Determine if the PKCS#8 data is encrypted and, if so, set-up a
+       key encryption key and algorithm in context.
+       Return 1 if encrypted, 0, if not, -1 if error. */
+
+    *ctx = NULL;
+    privkeyinfo->beg = (char *) data;
+    privkeyinfo->end = privkeyinfo->beg + datalen;
+
+    /* If no passphrase is given, it cannot be an encrypted key. */
+    if(!passphrase || !*passphrase)
+        return 0;
+
+    /* Parse PKCS#8 data, checking if ASN.1 format is PrivateKeyInfo or
+       EncryptedPrivateKeyInfo. */
+    if(getASN1Element(&encprivkeyinfo, privkeyinfo->beg, privkeyinfo->end) !=
+        (char *) data + datalen ||
+        *encprivkeyinfo.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    cp = getASN1Element(&pkcs5alg, encprivkeyinfo.beg, encprivkeyinfo.end);
+    if(!cp)
+        return -1;
+
+    switch(*pkcs5alg.header) {
+    case ASN1_INTEGER:                          /* Version. */
+        return 0;       /* This is a PrivateKeyInfo --> not encrypted. */
+    case ASN1_SEQ | ASN1_CONSTRUCTED:           /* AlgorithIdentifier. */
+        break;          /* This is an EncryptedPrivateKeyInfo --> encrypted. */
+    default:
+        return -1;      /* Unrecognized: error. */
+    }
+
+    /* Get the encrypted key data. */
+    if(getASN1Element(privkeyinfo, cp, encprivkeyinfo.end) !=
+        encprivkeyinfo.end || *privkeyinfo->header != ASN1_OCTET_STRING)
+        return -1;
+
+    /* PKCS#5: parse the PBES AlgorithmIdentifier and recursively get all
+       encryption parameters. */
+    memset((char *) &pkcs5, 0, sizeof(pkcs5));
+    if(parse_pkcs5_algorithm(session, &pkcs5, &pkcs5alg, pbestable))
+        return -1;
+
+    /* Compute the derived key. */
+    if((*pkcs5.kdf)(session, &dk, passphrase, &pkcs5))
+        return -1;
+
+    /* Prepare the algorithm descriptor. */
+    memset((char *) &algd, 0, sizeof(algd));
+    algd.Block_Cipher_Alg = pkcs5.cipher;
+    algd.Block_Length = pkcs5.blocksize;
+    algd.Mode = pkcs5.mode;
+    algd.Pad_Option = pkcs5.padopt;
+    algd.Pad_Character = pkcs5.padchar;
+    algd.Effective_Key_Size = pkcs5.effkeysize;
+    memcpy(algd.Init_Vector, pkcs5.iv, pkcs5.ivlen);
+
+    /* Create the key and algorithm context tokens. */
+    *ctx = libssh2_init_crypto_ctx(NULL);
+    if(!*ctx) {
+        LIBSSH2_FREE(session, dk);
+        return -1;
+    }
+    libssh2_init_crypto_ctx(*ctx);
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CreateKeyContext(dk, &pkcs5.dklen, binstring, &algd.Block_Cipher_Alg,
+                        qc3clear, NULL, NULL, (*ctx)->key.Key_Context_Token,
+                        (char *) &errcode);
+    LIBSSH2_FREE(session, dk);
+    if(errcode.Bytes_Available) {
+        free((char *) *ctx);
+        *ctx = NULL;
+        return -1;
+    }
+
+    Qc3CreateAlgorithmContext((char *) &algd, Qc3_Alg_Block_Cipher,
+                              (*ctx)->hash.Alg_Context_Token, &errcode);
+    if(errcode.Bytes_Available) {
+        Qc3DestroyKeyContext((*ctx)->key.Key_Context_Token, (char *) &ecnull);
+        free((char *) *ctx);
+        *ctx = NULL;
+        return -1;
+    }
+    return 1;       /* Tell it's encrypted. */
+}
+
+static int
+rsapkcs8privkey(LIBSSH2_SESSION *session,
+                const unsigned char *data, unsigned int datalen,
+                const unsigned char *passphrase, void *loadkeydata)
+{
+    libssh2_rsa_ctx *ctx = (libssh2_rsa_ctx *) loadkeydata;
+    char keyform = Qc3_Clear;
+    char *kek = NULL;
+    char *kea = NULL;
+    _libssh2_os400qc3_crypto_ctx *kekctx;
+    asn1Element pki;
+    int pkilen;
+    Qus_EC_t errcode;
+
+    switch(pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
+    case 1:
+        keyform = Qc3_Encrypted;
+        kek = kekctx->key.Key_Context_Token;
+        kea = kekctx->hash.Alg_Context_Token;
+    case 0:
+        break;
+    default:
+        return -1;
+    }
+
+    set_EC_length(errcode, sizeof(errcode));
+    pkilen = pki.end - pki.beg;
+    Qc3CreateKeyContext((unsigned char *) pki.beg, &pkilen, berstring,
+                        rsaprivate, &keyform, kek, kea,
+                        ctx->key.Key_Context_Token, (char *) &errcode);
+    if(errcode.Bytes_Available) {
+        if(kekctx)
+            _libssh2_os400qc3_crypto_dtor(kekctx);
+        return -1;
+    }
+    ctx->kek = kekctx;
+    return 0;
+}
+
+static char *
+storewithlength(char *p, const char *data, int length)
+{
+    _libssh2_htonu32(p, length);
+    if(length)
+        memcpy(p + 4, data, length);
+    return p + 4 + length;
+}
+
+static int
+sshrsapubkey(LIBSSH2_SESSION *session, char **sshpubkey,
+             asn1Element *params, asn1Element *key, const char *method)
+{
+    int methlen = strlen(method);
+    asn1Element keyseq;
+    asn1Element m;
+    asn1Element e;
+    int len;
+    char *cp;
+
+    if(getASN1Element(&keyseq, key->beg + 1, key->end) != key->end ||
+        *keyseq.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    if(!getASN1Element(&m, keyseq.beg, keyseq.end) ||
+        *m.header != ASN1_INTEGER)
+        return -1;
+    if(getASN1Element(&e, m.end, keyseq.end) != keyseq.end ||
+        *e.header != ASN1_INTEGER)
+        return -1;
+    len = 4 + methlen + 4 + (e.end - e.beg) + 4 + (m.end - m.beg);
+    cp = LIBSSH2_ALLOC(session, len);
+    if(!cp)
+        return -1;
+    *sshpubkey = cp;
+    cp = storewithlength(cp, method, methlen);
+    cp = storewithlength(cp, e.beg, e.end - e.beg);
+    cp = storewithlength(cp, m.beg, m.end - m.beg);
+    return len;
+}
+
+static int
+rsapkcs8pubkey(LIBSSH2_SESSION *session,
+               const unsigned char *data, unsigned int datalen,
+               const unsigned char *passphrase, void *loadkeydata)
+{
+    loadpubkeydata *p = (loadpubkeydata *) loadkeydata;
+    char *buf;
+    int len;
+    char *cp;
+    int i;
+    char keyform = Qc3_Clear;
+    char *kek = NULL;
+    char *kea = NULL;
+    _libssh2_os400qc3_crypto_ctx *kekctx;
+    asn1Element subjpubkeyinfo;
+    asn1Element algorithmid;
+    asn1Element algorithm;
+    asn1Element subjpubkey;
+    asn1Element parameters;
+    asn1Element pki;
+    int pkilen;
+    Qus_EC_t errcode;
+
+    buf = alloca(datalen);
+    if(!buf)
+        return -1;
+
+    switch(pkcs8kek(session, &kekctx, data, datalen, passphrase, &pki)) {
+    case 1:
+        keyform = Qc3_Encrypted;
+        kek = kekctx->key.Key_Context_Token;
+        kea = kekctx->hash.Alg_Context_Token;
+    case 0:
+        break;
+    default:
+        return -1;
+    }
+
+    set_EC_length(errcode, sizeof(errcode));
+    pkilen = pki.end - pki.beg;
+    Qc3ExtractPublicKey(pki.beg, &pkilen, berstring, &keyform,
+                        kek, kea, buf, (int *) &datalen, &len, &errcode);
+    _libssh2_os400qc3_crypto_dtor(kekctx);
+    if(errcode.Bytes_Available)
+        return -1;
+    /* Get the algorithm OID and key data from SubjectPublicKeyInfo. */
+    if(getASN1Element(&subjpubkeyinfo, buf, buf + len) != buf + len ||
+        *subjpubkeyinfo.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    cp = getASN1Element(&algorithmid, subjpubkeyinfo.beg, subjpubkeyinfo.end);
+    if(!cp || *algorithmid.header != (ASN1_SEQ | ASN1_CONSTRUCTED))
+        return -1;
+    if(!getASN1Element(&algorithm, algorithmid.beg, algorithmid.end) ||
+        *algorithm.header != ASN1_OBJ_ID)
+        return -1;
+    if(getASN1Element(&subjpubkey, cp, subjpubkeyinfo.end) !=
+        subjpubkeyinfo.end || *subjpubkey.header != ASN1_BIT_STRING)
+        return -1;
+    /* Check for supported algorithm. */
+    for(i = 0; pka[i].oid; i++)
+        if(!oidcmp(&algorithm, pka[i].oid)) {
+            len = (*pka[i].sshpubkey)(session, &p->data, &algorithmid,
+                                      &subjpubkey, pka[i].method);
+            if(len < 0)
+                return -1;
+            p->length = len;
+            p->method = pka[i].method;
+            return 0;
+        }
+    return -1;                              /* Algorithm not supported. */
+}
+
+static int
+pkcs1topkcs8(LIBSSH2_SESSION *session,
+             const unsigned char **data8, unsigned int *datalen8,
+             const unsigned char *data1, unsigned int datalen1)
+{
+    asn1Element *prvk;
+    asn1Element *pkcs8;
+    unsigned char *data;
+
+    *data8 = NULL;
+    *datalen8 = 0;
+    if(datalen1 < 2)
+        return -1;
+    prvk = asn1_new_from_bytes(data1, datalen1);
+    if(!prvk)
+        return -1;
+    pkcs8 = rsaprivatekeyinfo(prvk);
+    asn1delete(prvk);
+    if(!prvk) {
+        asn1delete(pkcs8);
+        pkcs8 = NULL;
+    }
+    if(!pkcs8)
+        return -1;
+    data = (unsigned char *) LIBSSH2_ALLOC(session,
+                                           pkcs8->end - pkcs8->header);
+    if(!data) {
+        asn1delete(pkcs8);
+        return -1;
+    }
+    *data8 = data;
+    *datalen8 = pkcs8->end - pkcs8->header;
+    memcpy((char *) data, (char *) pkcs8->header, *datalen8);
+    asn1delete(pkcs8);
+    return 0;
+}
+
+static int
+rsapkcs1privkey(LIBSSH2_SESSION *session,
+                const unsigned char *data, unsigned int datalen,
+                const unsigned char *passphrase, void *loadkeydata)
+{
+    const unsigned char *data8;
+    unsigned int datalen8;
+    int ret;
+
+    if(pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
+        return -1;
+    ret = rsapkcs8privkey(session, data8, datalen8, passphrase, loadkeydata);
+    LIBSSH2_FREE(session, (char *) data8);
+    return ret;
+}
+
+static int
+rsapkcs1pubkey(LIBSSH2_SESSION *session,
+               const unsigned char *data, unsigned int datalen,
+               const unsigned char *passphrase, void *loadkeydata)
+{
+    const unsigned char *data8;
+    unsigned int datalen8;
+    int ret;
+
+    if(pkcs1topkcs8(session, &data8, &datalen8, data, datalen))
+        return -1;
+    ret = rsapkcs8pubkey(session, data8, datalen8, passphrase, loadkeydata);
+    LIBSSH2_FREE(session, (char *) data8);
+    return ret;
+}
+
+static int
+try_pem_load(LIBSSH2_SESSION *session, FILE *fp,
+             const unsigned char *passphrase,
+             const char *header, const char *trailer,
+             loadkeyproc proc, void *loadkeydata)
+{
+    unsigned char *data = NULL;
+    size_t datalen = 0;
+    int c;
+    int ret;
+
+    fseek(fp, 0L, SEEK_SET);
+    for(;;) {
+        ret = _libssh2_pem_parse(session, header, trailer,
+                                 passphrase,
+                                 fp, &data, &datalen);
+
+        if(!ret) {
+            ret = (*proc)(session, data, datalen, passphrase, loadkeydata);
+            if(!ret)
+                return 0;
+        }
+
+        if(data) {
+            LIBSSH2_FREE(session, data);
+            data = NULL;
+        }
+        c = getc(fp);
+
+        if(c == EOF)
+            break;
+
+        ungetc(c, fp);
+    }
+
+    return -1;
+}
+
+static int
+load_rsa_private_file(LIBSSH2_SESSION *session, const char *filename,
+                      unsigned const char *passphrase,
+                      loadkeyproc proc1, loadkeyproc proc8, void *loadkeydata)
+{
+    FILE *fp = fopen(filename, fopenrmode);
+    unsigned char *data = NULL;
+    size_t datalen = 0;
+    int ret;
+    long filesize;
+
+    if(!fp)
+        return -1;
+
+    /* Try with "ENCRYPTED PRIVATE KEY" PEM armor.
+       --> PKCS#8 EncryptedPrivateKeyInfo */
+    ret = try_pem_load(session, fp, passphrase, beginencprivkeyhdr,
+                       endencprivkeyhdr, proc8, loadkeydata);
+
+    /* Try with "PRIVATE KEY" PEM armor.
+       --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+    if(ret)
+        ret = try_pem_load(session, fp, passphrase, beginprivkeyhdr,
+                           endprivkeyhdr, proc8, loadkeydata);
+
+    /* Try with "RSA PRIVATE KEY" PEM armor.
+       --> PKCS#1 RSAPrivateKey */
+    if(ret)
+        ret = try_pem_load(session, fp, passphrase, beginrsaprivkeyhdr,
+                           endrsaprivkeyhdr, proc1, loadkeydata);
+    fclose(fp);
+
+    if(ret) {
+        /* Try DER encoding. */
+        fp = fopen(filename, fopenrbmode);
+        fseek(fp, 0L, SEEK_END);
+        filesize = ftell(fp);
+
+        if(filesize <= 32768) {        /* Limit to a reasonable size. */
+            datalen = filesize;
+            data = (unsigned char *) alloca(datalen);
+            if(data) {
+                fseek(fp, 0L, SEEK_SET);
+                fread(data, datalen, 1, fp);
+
+                /* Try as PKCS#8 DER data.
+                   --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+                ret = (*proc8)(session, data, datalen, passphrase,
+                               loadkeydata);
+
+                /* Try as PKCS#1 DER data.
+                   --> PKCS#1 RSAPrivateKey */
+                if(ret)
+                    ret = (*proc1)(session, data, datalen, passphrase,
+                                   loadkeydata);
+            }
+        }
+        fclose(fp);
+    }
+
+    return ret;
+}
+
+int
+_libssh2_rsa_new_private(libssh2_rsa_ctx **rsa, LIBSSH2_SESSION *session,
+                         const char *filename, unsigned const char *passphrase)
+{
+    libssh2_rsa_ctx *ctx = libssh2_init_crypto_ctx(NULL);
+    int ret;
+
+    if(!ctx)
+        return -1;
+    ret = load_rsa_private_file(session, filename, passphrase,
+                                rsapkcs1privkey, rsapkcs8privkey,
+                                (void *) ctx);
+    if(ret) {
+        _libssh2_os400qc3_crypto_dtor(ctx);
+        ctx = NULL;
+    }
+    *rsa = ctx;
+    return ret;
+}
+
+int
+_libssh2_pub_priv_keyfile(LIBSSH2_SESSION *session,
+                          unsigned char **method, size_t *method_len,
+                          unsigned char **pubkeydata, size_t *pubkeydata_len,
+                          const char *privatekey, const char *passphrase)
+{
+    loadpubkeydata p;
+    int ret;
+
+    *method = NULL;
+    *method_len = 0;
+    *pubkeydata = NULL;
+    *pubkeydata_len = 0;
+
+    ret = load_rsa_private_file(session, privatekey, passphrase,
+                                rsapkcs1pubkey, rsapkcs8pubkey, (void *) &p);
+    if(!ret) {
+        *method_len = strlen(p.method);
+        *method = LIBSSH2_ALLOC(session, *method_len);
+        if(*method)
+            memcpy((char *) *method, p.method, *method_len);
+        else
+            ret = -1;
+    }
+
+    if(ret) {
+        if(*method)
+            LIBSSH2_FREE(session, *method);
+        if(p.data)
+            LIBSSH2_FREE(session, (void *) p.data);
+        *method = NULL;
+        *method_len = 0;
+    }
+    else {
+        *pubkeydata = (unsigned char *) p.data;
+        *pubkeydata_len = p.length;
+    }
+
+    return ret;
+}
+
+int
+_libssh2_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
+                                    LIBSSH2_SESSION *session,
+                                    const char *filedata,
+                                    size_t filedata_len,
+                                    unsigned const char *passphrase)
+{
+    libssh2_rsa_ctx *ctx = libssh2_init_crypto_ctx(NULL);
+    unsigned char *data = NULL;
+    size_t datalen = 0;
+    int ret;
+
+    if(!ctx)
+        return -1;
+
+    /* Try with "ENCRYPTED PRIVATE KEY" PEM armor.
+       --> PKCS#8 EncryptedPrivateKeyInfo */
+    ret = _libssh2_pem_parse_memory(session,
+                                    beginencprivkeyhdr, endencprivkeyhdr,
+                                    filedata, filedata_len, &data, &datalen);
+
+    /* Try with "PRIVATE KEY" PEM armor.
+       --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+    if(ret)
+        ret = _libssh2_pem_parse_memory(session,
+                                        beginprivkeyhdr, endprivkeyhdr,
+                                        filedata, filedata_len,
+                                        &data, &datalen);
+
+    if(!ret) {
+        /* Process PKCS#8. */
+        ret = rsapkcs8privkey(session,
+                              data, datalen, passphrase, (void *) &ctx);
+    }
+    else {
+        /* Try with "RSA PRIVATE KEY" PEM armor.
+           --> PKCS#1 RSAPrivateKey */
+        ret = _libssh2_pem_parse_memory(session,
+                                        beginrsaprivkeyhdr, endrsaprivkeyhdr,
+                                        filedata, filedata_len,
+                                        &data, &datalen);
+        if(!ret)
+            ret = rsapkcs1privkey(session,
+                                  data, datalen, passphrase, (void *) &ctx);
+    }
+
+    if(ret) {
+        /* Try as PKCS#8 DER data.
+           --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+        ret = rsapkcs8privkey(session, filedata, filedata_len,
+                              passphrase, (void *) &ctx);
+
+        /* Try as PKCS#1 DER data.
+           --> PKCS#1 RSAPrivateKey */
+        if(ret)
+            ret = rsapkcs1privkey(session, filedata, filedata_len,
+                                  passphrase, (void *) &ctx);
+    }
+
+    if(data)
+        LIBSSH2_FREE(session, data);
+
+    if(ret) {
+        _libssh2_os400qc3_crypto_dtor(ctx);
+        ctx = NULL;
+    }
+
+    *rsa = ctx;
+    return ret;
+}
+
+int
+_libssh2_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
+                                unsigned char **method, size_t *method_len,
+                                unsigned char **pubkeydata,
+                                size_t *pubkeydata_len,
+                                const char *privatekeydata,
+                                size_t privatekeydata_len,
+                                const char *passphrase)
+{
+    loadpubkeydata p;
+    unsigned char *data = NULL;
+    size_t datalen = 0;
+    const char *meth;
+    int ret;
+
+    *method = NULL;
+    *method_len = 0;
+    *pubkeydata = NULL;
+    *pubkeydata_len = 0;
+
+    /* Try with "ENCRYPTED PRIVATE KEY" PEM armor.
+       --> PKCS#8 EncryptedPrivateKeyInfo */
+    ret = _libssh2_pem_parse_memory(session,
+                                    beginencprivkeyhdr, endencprivkeyhdr,
+                                    privatekeydata, privatekeydata_len,
+                                    &data, &datalen);
+
+    /* Try with "PRIVATE KEY" PEM armor.
+       --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+    if(ret)
+        ret = _libssh2_pem_parse_memory(session,
+                                        beginprivkeyhdr, endprivkeyhdr,
+                                        privatekeydata, privatekeydata_len,
+                                        &data, &datalen);
+
+    if(!ret) {
+        /* Process PKCS#8. */
+        ret = rsapkcs8pubkey(session,
+                             data, datalen, passphrase, (void *) &p);
+    }
+    else {
+        /* Try with "RSA PRIVATE KEY" PEM armor.
+           --> PKCS#1 RSAPrivateKey */
+        ret = _libssh2_pem_parse_memory(session,
+                                        beginrsaprivkeyhdr, endrsaprivkeyhdr,
+                                        privatekeydata, privatekeydata_len,
+                                        &data, &datalen);
+        if(!ret)
+            ret = rsapkcs1pubkey(session,
+                                 data, datalen, passphrase, (void *) &p);
+    }
+
+    if(ret) {
+        /* Try as PKCS#8 DER data.
+           --> PKCS#8 PrivateKeyInfo or EncryptedPrivateKeyInfo */
+        ret = rsapkcs8pubkey(session, privatekeydata, privatekeydata_len,
+                             passphrase, (void *) &p);
+
+        /* Try as PKCS#1 DER data.
+           --> PKCS#1 RSAPrivateKey */
+        if(ret)
+            ret = rsapkcs1pubkey(session, privatekeydata, privatekeydata_len,
+                                 passphrase, (void *) &p);
+    }
+
+    if(data)
+        LIBSSH2_FREE(session, data);
+
+    if(!ret) {
+        *method_len = strlen(p.method);
+        *method = LIBSSH2_ALLOC(session, *method_len);
+        if(*method)
+            memcpy((char *) *method, p.method, *method_len);
+        else
+            ret = -1;
+    }
+    if(ret) {
+        if(*method)
+            LIBSSH2_FREE(session, *method);
+        if(p.data)
+            LIBSSH2_FREE(session, (void *) p.data);
+        *method = NULL;
+        *method_len = 0;
+    }
+    else {
+        *pubkeydata = (unsigned char *) p.data;
+        *pubkeydata_len = p.length;
+    }
+
+    return ret;
+}
+
+int
+_libssh2_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                              unsigned char **method,
+                              size_t *method_len,
+                              unsigned char **pubkeydata,
+                              size_t *pubkeydata_len,
+                              int *algorithm,
+                              unsigned char *flags,
+                              const char **application,
+                              const unsigned char **key_handle,
+                              size_t *handle_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase)
+{
+    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                    "Unable to extract public SK key from private key file: "
+                    "Method unimplemented in OS/400 QC3 backend");
+}
+
+int
+_libssh2_rsa_sha2_verify(libssh2_rsa_ctx *rsa, size_t hash_len,
+                         const unsigned char *sig, size_t sig_len,
+                         const unsigned char *m, size_t m_len)
+{
+    Qus_EC_t errcode;
+    Qc3_Format_ALGD0400_T algd;
+    int slen = (int)sig_len;
+    int mlen = (int)m_len;
+
+    memset(&algd, 0, sizeof(algd));
+    algd.Public_Key_Alg = Qc3_RSA;
+    algd.PKA_Block_Format = Qc3_PKCS1_01;
+    switch(hash_len) {
+    case SHA_DIGEST_LENGTH:
+        algd.Signing_Hash_Alg = Qc3_SHA1;
+        break;
+    case SHA256_DIGEST_LENGTH:
+        algd.Signing_Hash_Alg = Qc3_SHA256;
+        break;
+    case SHA512_DIGEST_LENGTH:
+        algd.Signing_Hash_Alg = Qc3_SHA512;
+        break;
+    default:
+        return -1;
+    }
+
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3VerifySignature((char *) sig, &slen, (char *) m, &mlen, Qc3_Data,
+                       (char *) &algd, Qc3_Alg_Public_Key,
+                       (char *) &rsa->key, Qc3_Key_Token, anycsp,
+                       NULL, (char *) &errcode);
+    return errcode.Bytes_Available ? -1 : 0;
+}
+
+int
+_libssh2_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
+                         const unsigned char *sig, size_t sig_len,
+                         const unsigned char *m, size_t m_len)
+{
+    return _libssh2_rsa_sha2_verify(rsa, SHA_DIGEST_LENGTH,
+                                    sig, sig_len, m, m_len);
+}
+
+int
+_libssh2_os400qc3_rsa_signv(LIBSSH2_SESSION *session,
+                            int algo,
+                            unsigned char **signature,
+                            size_t *signature_len,
+                            int veccount,
+                            const struct iovec vector[],
+                            libssh2_rsa_ctx *ctx)
+{
+    Qus_EC_t errcode;
+    Qc3_Format_ALGD0400_T algd;
+    int siglen;
+    unsigned char *sig;
+    char sigbuf[8192];
+    int sigbufsize = sizeof(sigbuf);
+
+    algd.Public_Key_Alg = Qc3_RSA;
+    algd.PKA_Block_Format = Qc3_PKCS1_01;
+    memset(algd.Reserved, 0, sizeof(algd.Reserved));
+    algd.Signing_Hash_Alg = algo;
+    set_EC_length(errcode, sizeof(errcode));
+    Qc3CalculateSignature((char *) vector, &veccount, Qc3_Array,
+                          (char *) &algd, Qc3_Alg_Public_Key,
+                          (char *) &ctx->key, Qc3_Key_Token,
+                          anycsp, NULL, sigbuf, &sigbufsize, &siglen,
+                          (char *) &errcode);
+    if(errcode.Bytes_Available)
+        return -1;
+    sig = LIBSSH2_ALLOC(session, siglen);
+    if(!sig)
+        return -1;
+    memcpy((char *) sig, sigbuf, siglen);
+    *signature = sig;
+    *signature_len = siglen;
+    return 0;
+}
+
+/* _libssh2_supported_key_sign_algorithms
+ *
+ * Return supported key hash algo upgrades, see crypto.h
+ *
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len)
+{
+    (void)session;
+
+    if(key_method_len == 7 &&
+       memcmp(key_method, "ssh-rsa", key_method_len) == 0) {
+        return "rsa-sha2-512,rsa-sha2-256"
+#if LIBSSH2_RSA_SHA1
+            ",ssh-rsa"
+#endif
+            ;
+    }
+
+    return NULL;
+}
+
+#endif /* LIBSSH2_CRYPTO_C */
+
+/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/src/os400qc3.h b/libssh2/src/os400qc3.h
new file mode 100644
index 00000000..8c4096b5
--- /dev/null
+++ b/libssh2/src/os400qc3.h
@@ -0,0 +1,397 @@
+#ifndef LIBSSH2_OS400QC3_H
+#define LIBSSH2_OS400QC3_H
+/*
+ * Copyright (C) Patrick Monnerat <patrick@monnerat.net>
+ * 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 any other contributors may be used to endorse or
+ *   promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#define LIBSSH2_CRYPTO_ENGINE libssh2_os400qc3
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <qc3cci.h>
+
+
+/* Redefine character/string literals as always EBCDIC. */
+#undef Qc3_Alg_Token
+#define Qc3_Alg_Token       "\xC1\xD3\xC7\xC4\xF0\xF1\xF0\xF0"  /* ALGD0100 */
+#undef Qc3_Alg_Block_Cipher
+#define Qc3_Alg_Block_Cipher "\xC1\xD3\xC7\xC4\xF0\xF2\xF0\xF0" /* ALGD0200 */
+#undef Qc3_Alg_Block_CipherAuth
+#define Qc3_Alg_Block_CipherAuth                                            \
+                            "\xC1\xD3\xC7\xC4\xF0\xF2\xF1\xF0"  /* ALGD0210 */
+#undef Qc3_Alg_Stream_Cipher
+#define Qc3_Alg_Stream_Cipher                                               \
+                            "\xC1\xD3\xC7\xC4\xF0\xF3\xF0\xF0"  /* ALGD0300 */
+#undef Qc3_Alg_Public_Key
+#define Qc3_Alg_Public_Key  "\xC1\xD3\xC7\xC4\xF0\xF4\xF0\xF0"  /* ALGD0400 */
+#undef Qc3_Alg_Hash
+#define Qc3_Alg_Hash        "\xC1\xD3\xC7\xC4\xF0\xF5\xF0\xF0"  /* ALGD0500 */
+#undef Qc3_Data
+#define Qc3_Data            "\xC4\xC1\xE3\xC1\xF0\xF1\xF0\xF0"  /* DATA0100 */
+#undef Qc3_Array
+#define Qc3_Array           "\xC4\xC1\xE3\xC1\xF0\xF2\xF0\xF0"  /* DATA0200 */
+#undef Qc3_Key_Token
+#define Qc3_Key_Token       "\xD2\xC5\xE8\xC4\xF0\xF1\xF0\xF0"  /* KEYD0100 */
+#undef Qc3_Key_Parms
+#define Qc3_Key_Parms       "\xD2\xC5\xE8\xC4\xF0\xF2\xF0\xF0"  /* KEYD0200 */
+#undef Qc3_Key_KSLabel
+#define Qc3_Key_KSLabel     "\xD2\xC5\xE8\xC4\xF0\xF4\xF0\xF0"  /* KEYD0400 */
+#undef Qc3_Key_PKCS5
+#define Qc3_Key_PKCS5       "\xD2\xC5\xE8\xC4\xF0\xF5\xF0\xF0"  /* KEYD0500 */
+#undef Qc3_Key_PEMCert
+#define Qc3_Key_PEMCert     "\xD2\xC5\xE8\xC4\xF0\xF6\xF0\xF0"  /* KEYD0600 */
+#undef Qc3_Key_CSLabel
+#define Qc3_Key_CSLabel     "\xD2\xC5\xE8\xC4\xF0\xF7\xF0\xF0"  /* KEYD0700 */
+#undef Qc3_Key_CSDN
+#define Qc3_Key_CSDN        "\xD2\xC5\xE8\xC4\xF0\xF8\xF0\xF0"  /* KEYD0800 */
+#undef Qc3_Key_AppID
+#define Qc3_Key_AppID       "\xD2\xC5\xE8\xC4\xF0\xF9\xF0\xF0"  /* KEYD0900 */
+
+#undef Qc3_ECB
+#define Qc3_ECB             '\xF0'      /* '0' */
+#undef Qc3_CBC
+#define Qc3_CBC             '\xF1'      /* '1' */
+#undef Qc3_OFB
+#define Qc3_OFB             '\xF2'      /* '2' */
+#undef Qc3_CFB1Bit
+#define Qc3_CFB1Bit         '\xF3'      /* '3' */
+#undef Qc3_CFB8Bit
+#define Qc3_CFB8Bit         '\xF4'      /* '4' */
+#undef Qc3_CFB64Bit
+#define Qc3_CFB64Bit        '\xF5'      /* '5' */
+#undef Qc3_CUSP
+#define Qc3_CUSP            '\xF6'      /* '6' */
+#undef Qc3_CTR
+#define Qc3_CTR             '\xF7'      /* '7' */
+#undef Qc3_CCM
+#define Qc3_CCM             '\xF8'      /* '8' */
+#undef Qc3_No_Pad
+#define Qc3_No_Pad          '\xF0'      /* '0' */
+#undef Qc3_Pad_Char
+#define Qc3_Pad_Char        '\xF1'      /* '1' */
+#undef Qc3_Pad_Counter
+#define Qc3_Pad_Counter     '\xF2'      /* '2' */
+#undef Qc3_PKCS1_00
+#define Qc3_PKCS1_00        '\xF0'      /* '0' */
+#undef Qc3_PKCS1_01
+#define Qc3_PKCS1_01        '\xF1'      /* '1' */
+#undef Qc3_PKCS1_02
+#define Qc3_PKCS1_02        '\xF2'      /* '2' */
+#undef Qc3_ISO9796
+#define Qc3_ISO9796         '\xF3'      /* '3' */
+#undef Qc3_Zero_Pad
+#define Qc3_Zero_Pad        '\xF4'      /* '4' */
+#undef Qc3_ANSI_X931
+#define Qc3_ANSI_X931       '\xF5'      /* '5' */
+#undef Qc3_OAEP
+#define Qc3_OAEP            '\xF6'      /* '6' */
+#undef Qc3_Bin_String
+#define Qc3_Bin_String      '\xF0'      /* '0' */
+#undef Qc3_BER_String
+#define Qc3_BER_String      '\xF1'      /* '1' */
+#undef Qc3_MK_Struct
+#define Qc3_MK_Struct       '\xF3'      /* '3' */
+#undef Qc3_KSLabel_Struct
+#define Qc3_KSLabel_Struct  '\xF4'      /* '4' */
+#undef Qc3_PKCS5_Struct
+#define Qc3_PKCS5_Struct    '\xF5'      /* '5' */
+#undef Qc3_PEMCert_String
+#define Qc3_PEMCert_String  '\xF6'      /* '6' */
+#undef Qc3_CSLabel_String
+#define Qc3_CSLabel_String  '\xF7'      /* '7' */
+#undef Qc3_CSDN_String
+#define Qc3_CSDN_String     '\xF8'      /* '8' */
+#undef Qc3_Clear
+#define Qc3_Clear           '\xF0'      /* '0' */
+#undef Qc3_Encrypted
+#define Qc3_Encrypted       '\xF1'      /* '1' */
+#undef Qc3_MK_Encrypted
+#define Qc3_MK_Encrypted    '\xF2'      /* '2' */
+#undef Qc3_Any_CSP
+#define Qc3_Any_CSP         '\xF0'      /* '0' */
+#undef Qc3_Sfw_CSP
+#define Qc3_Sfw_CSP         '\xF1'      /* '1' */
+#undef Qc3_Hdw_CSP
+#define Qc3_Hdw_CSP         '\xF2'      /* '2' */
+#undef Qc3_Continue
+#define Qc3_Continue        '\xF0'      /* '0' */
+#undef Qc3_Final
+#define Qc3_Final           '\xF1'      /* '1' */
+#undef Qc3_MK_New
+#define Qc3_MK_New          '\xF0'      /* '0' */
+#undef Qc3_MK_Current
+#define Qc3_MK_Current      '\xF1'      /* '1' */
+#undef Qc3_MK_Old
+#define Qc3_MK_Old          '\xF2'      /* '2' */
+#undef Qc3_MK_Pending
+#define Qc3_MK_Pending      '\xF3'      /* '3' */
+
+/* Define which features are supported. */
+#ifdef OPENSSL_NO_MD5
+# define LIBSSH2_MD5            0
+#else
+# define LIBSSH2_MD5            1
+#endif
+
+#define LIBSSH2_HMAC_RIPEMD     0
+#define LIBSSH2_HMAC_SHA256     1
+#define LIBSSH2_HMAC_SHA512     1
+
+#define LIBSSH2_AES_CBC         1
+#define LIBSSH2_AES_CTR         1
+#define LIBSSH2_AES_GCM         0
+#define LIBSSH2_BLOWFISH        0
+#define LIBSSH2_RC4             1
+#define LIBSSH2_CAST            0
+#define LIBSSH2_3DES            1
+
+#define LIBSSH2_RSA             1
+#define LIBSSH2_RSA_SHA1        1
+#define LIBSSH2_RSA_SHA2        1
+#define LIBSSH2_DSA             0
+#define LIBSSH2_ECDSA           0
+#define LIBSSH2_ED25519         0
+
+#include "crypto_config.h"
+
+#define SHA_DIGEST_LENGTH       20
+#define SHA256_DIGEST_LENGTH    32
+#define SHA384_DIGEST_LENGTH    48
+#define SHA512_DIGEST_LENGTH    64
+
+#define EC_MAX_POINT_LEN ((528 * 2 / 8) + 1)
+
+#if LIBSSH2_ECDSA
+#else
+#define _libssh2_ec_key void
+#endif
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: global handles structures.
+ *
+ *******************************************************************/
+
+/* HMAC & private key algorithms support structure. */
+typedef struct _libssh2_os400qc3_crypto_ctx _libssh2_os400qc3_crypto_ctx;
+struct _libssh2_os400qc3_crypto_ctx {
+    Qc3_Format_ALGD0100_T           hash;           /* Hash algorithm. */
+    Qc3_Format_KEYD0100_T           key;            /* Key. */
+    _libssh2_os400qc3_crypto_ctx *  kek;            /* Key encryption. */
+};
+
+typedef struct {        /* Big number. */
+    unsigned char *         bignum;         /* Number bits, little-endian. */
+    unsigned int            length;         /* Length of bignum (# bytes). */
+}       _libssh2_bn;
+
+typedef struct {        /* Algorithm description. */
+    char *                  fmt;            /* Format of Qc3 structure. */
+    int                     algo;           /* Algorithm identifier. */
+    unsigned char           size;           /* Block length. */
+    unsigned char           mode;           /* Block mode. */
+    int                     keylen;         /* Key length. */
+}       _libssh2_os400qc3_cipher_t;
+
+typedef struct {        /* Diffie-Hellman context. */
+    char                    token[8];       /* Context token. */
+}       _libssh2_os400qc3_dh_ctx;
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: Define global types/codes.
+ *
+ *******************************************************************/
+
+#define libssh2_crypto_init()
+#define libssh2_crypto_exit()
+
+#define libssh2_sha1_ctx        Qc3_Format_ALGD0100_T
+#define libssh2_sha256_ctx      Qc3_Format_ALGD0100_T
+#define libssh2_sha384_ctx      Qc3_Format_ALGD0100_T
+#define libssh2_sha512_ctx      Qc3_Format_ALGD0100_T
+#define libssh2_hmac_ctx        _libssh2_os400qc3_crypto_ctx
+#define _libssh2_cipher_ctx     _libssh2_os400qc3_crypto_ctx
+
+#define libssh2_sha1_init(x)    _libssh2_os400qc3_hash_init(x, Qc3_SHA1)
+#define libssh2_sha1_update(ctx, data, len)                                 \
+                               _libssh2_os400qc3_hash_update(&(ctx), data, len)
+#define libssh2_sha1_final(ctx, out)                                        \
+                                _libssh2_os400qc3_hash_final(&(ctx), out)
+#define libssh2_sha256_init(x)  _libssh2_os400qc3_hash_init(x, Qc3_SHA256)
+#define libssh2_sha256_update(ctx, data, len)                               \
+                               _libssh2_os400qc3_hash_update(&(ctx), data, len)
+#define libssh2_sha256_final(ctx, out)                                      \
+                                _libssh2_os400qc3_hash_final(&(ctx), out)
+#define libssh2_sha256(message, len, out)                                   \
+                                _libssh2_os400qc3_hash(message, len, out,   \
+                                                       Qc3_SHA256)
+#define libssh2_sha384_init(x)  _libssh2_os400qc3_hash_init(x, Qc3_SHA384)
+#define libssh2_sha384_update(ctx, data, len)                               \
+                               _libssh2_os400qc3_hash_update(&(ctx), data, len)
+#define libssh2_sha384_final(ctx, out)                                      \
+                                _libssh2_os400qc3_hash_final(&(ctx), out)
+#define libssh2_sha384(message, len, out)                                   \
+                                _libssh2_os400qc3_hash(message, len, out,   \
+                                                       Qc3_SHA384)
+#define libssh2_sha512_init(x)  _libssh2_os400qc3_hash_init(x, Qc3_SHA512)
+#define libssh2_sha512_update(ctx, data, len)                               \
+                               _libssh2_os400qc3_hash_update(&(ctx), data, len)
+#define libssh2_sha512_final(ctx, out)                                      \
+                                _libssh2_os400qc3_hash_final(&(ctx), out)
+#define libssh2_sha512(message, len, out)                                   \
+                                _libssh2_os400qc3_hash(message, len, out,   \
+                                                       Qc3_SHA512)
+
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
+#define MD5_DIGEST_LENGTH       16
+#define libssh2_md5_ctx         Qc3_Format_ALGD0100_T
+#define libssh2_md5_init(x)     _libssh2_os400qc3_hash_init(x, Qc3_MD5)
+#define libssh2_md5_update(ctx, data, len)                                  \
+                               _libssh2_os400qc3_hash_update(&(ctx), data, len)
+#define libssh2_md5_final(ctx, out)                                         \
+                                _libssh2_os400qc3_hash_final(&(ctx), out)
+#endif
+
+#define _libssh2_bn_ctx         int                 /* Not used. */
+
+#define _libssh2_bn_ctx_new()           0
+#define _libssh2_bn_ctx_free(bnctx)     ((void) 0)
+
+#define _libssh2_bn_init_from_bin() _libssh2_bn_init()
+#define _libssh2_bn_bytes(bn)   ((bn)->length)
+
+#define _libssh2_cipher_type(name)  _libssh2_os400qc3_cipher_t name
+#define _libssh2_cipher_aes128 {Qc3_Alg_Block_Cipher, Qc3_AES, 16,          \
+                                Qc3_CBC, 16}
+#define _libssh2_cipher_aes192 {Qc3_Alg_Block_Cipher, Qc3_AES, 16,          \
+                                Qc3_CBC, 24}
+#define _libssh2_cipher_aes256 {Qc3_Alg_Block_Cipher, Qc3_AES, 16,          \
+                                Qc3_CBC, 32}
+#define _libssh2_cipher_aes128ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 16,       \
+                                   Qc3_CTR, 16}
+#define _libssh2_cipher_aes192ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 16,       \
+                                   Qc3_CTR, 24}
+#define _libssh2_cipher_aes256ctr {Qc3_Alg_Block_Cipher, Qc3_AES, 16,       \
+                                   Qc3_CTR, 32}
+#define _libssh2_cipher_3des {Qc3_Alg_Block_Cipher, Qc3_TDES, 8,            \
+                              Qc3_CBC, 24}
+/* Nonsense values for chacha20-poly1305 */
+#define _libssh2_cipher_chacha20 {Qc3_Alg_Stream_Cipher, Qc3_RC4, 8, 0, 16}
+#define _libssh2_cipher_arcfour {Qc3_Alg_Stream_Cipher, Qc3_RC4, 8, 0, 16}
+
+#define _libssh2_cipher_dtor(ctx) _libssh2_os400qc3_crypto_dtor(ctx)
+
+#define libssh2_rsa_ctx         _libssh2_os400qc3_crypto_ctx
+#define _libssh2_rsa_free(ctx)  (_libssh2_os400qc3_crypto_dtor(ctx),        \
+                                 free((char *) ctx))
+#define libssh2_prepare_iovec(vec, len) memset((char *) (vec), 0,           \
+                                               (len) * sizeof(struct iovec))
+#define _libssh2_rsa_sha1_signv(session, sig, siglen, count, vector, ctx)   \
+            _libssh2_os400qc3_rsa_signv(session, Qc3_SHA1, sig, siglen,     \
+                                             count, vector, ctx)
+#define _libssh2_rsa_sha2_256_signv(session, sig, siglen, cnt, vector, ctx) \
+            _libssh2_os400qc3_rsa_signv(session, Qc3_SHA256, sig, siglen,   \
+                                             cnt, vector, ctx)
+#define _libssh2_rsa_sha2_512_signv(session, sig, siglen, cnt, vector, ctx) \
+            _libssh2_os400qc3_rsa_signv(session, Qc3_SHA512, sig, siglen,   \
+                                             cnt, vector, ctx)
+
+/* Default generate and safe prime sizes for diffie-hellman-group-exchange-sha1
+   Qc3 is limited to a maximum 2048-bit modulus/key size. */
+#define LIBSSH2_DH_GEX_MINGROUP     1024
+#define LIBSSH2_DH_GEX_OPTGROUP     1536
+#define LIBSSH2_DH_GEX_MAXGROUP     2048
+
+#define LIBSSH2_DH_MAX_MODULUS_BITS 2048
+
+#define _libssh2_dh_ctx         _libssh2_os400qc3_dh_ctx
+#define libssh2_dh_init(dhctx)  _libssh2_os400qc3_dh_init(dhctx)
+#define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx)        \
+            _libssh2_os400qc3_dh_key_pair(dhctx, public, g, p, group_order)
+#define libssh2_dh_secret(dhctx, secret, f, p, bnctx)                       \
+            _libssh2_os400qc3_dh_secret(dhctx, secret, f, p)
+#define libssh2_dh_dtor(dhctx)  _libssh2_os400qc3_dh_dtor(dhctx)
+
+
+/*******************************************************************
+ *
+ * OS/400 QC3 crypto-library backend: Support procedure prototypes.
+ *
+ *******************************************************************/
+
+extern _libssh2_bn *    _libssh2_bn_init(void);
+extern void     _libssh2_bn_free(_libssh2_bn *bn);
+extern unsigned long    _libssh2_bn_bits(_libssh2_bn *bn);
+extern int      _libssh2_bn_from_bin(_libssh2_bn *bn, size_t len,
+                                     const unsigned char *v);
+extern int      _libssh2_bn_set_word(_libssh2_bn *bn, unsigned long val);
+extern int      _libssh2_bn_to_bin(_libssh2_bn *bn, unsigned char *val);
+extern int      _libssh2_random(unsigned char *buf, size_t len);
+extern void     _libssh2_os400qc3_crypto_dtor(_libssh2_os400qc3_crypto_ctx *x);
+extern int      _libssh2_os400qc3_hash_init(Qc3_Format_ALGD0100_T *x,
+                                            unsigned int algo);
+extern int      _libssh2_os400qc3_hash_update(Qc3_Format_ALGD0100_T *ctx,
+                                              const unsigned char *data,
+                                              int len);
+extern int      _libssh2_os400qc3_hash_final(Qc3_Format_ALGD0100_T *ctx,
+                                             unsigned char *out);
+extern int      _libssh2_os400qc3_hash(const unsigned char *message,
+                                       unsigned long len, unsigned char *out,
+                                       unsigned int algo);
+extern int      _libssh2_os400qc3_rsa_signv(LIBSSH2_SESSION *session, int algo,
+                                            unsigned char **signature,
+                                            size_t *signature_len,
+                                            int veccount,
+                                            const struct iovec vector[],
+                                            libssh2_rsa_ctx *ctx);
+extern void     _libssh2_os400qc3_dh_init(_libssh2_dh_ctx *dhctx);
+extern int      _libssh2_os400qc3_dh_key_pair(_libssh2_dh_ctx *dhctx,
+                                              _libssh2_bn *public,
+                                              _libssh2_bn *g,
+                                              _libssh2_bn *p, int group_order);
+extern int      _libssh2_os400qc3_dh_secret(_libssh2_dh_ctx *dhctx,
+                                            _libssh2_bn *secret,
+                                            _libssh2_bn *f, _libssh2_bn *p);
+extern void     _libssh2_os400qc3_dh_dtor(_libssh2_dh_ctx *dhctx);
+
+#endif /* LIBSSH2_OS400QC3_H */
+
+/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/src/packet.c b/libssh2/src/packet.c
index 04937d62..6da14e9f 100644
--- a/libssh2/src/packet.c
+++ b/libssh2/src/packet.c
@@ -1,7 +1,7 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005,2006 Mikhail Gusarov
- * Copyright (c) 2009-2014 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Mikhail Gusarov
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -36,31 +36,23 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include <errno.h>
-#include <fcntl.h>
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
-
 /* Needed for struct iovec on some platforms */
 #ifdef HAVE_SYS_UIO_H
 #include <sys/uio.h>
 #endif
 
-#include <sys/types.h>
-
 #include "transport.h"
 #include "channel.h"
 #include "packet.h"
@@ -72,21 +64,21 @@
  */
 static inline int
 packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
-                      unsigned long datalen,
+                      size_t datalen,
                       packet_queue_listener_state_t *listen_state)
 {
     /*
      * Look for a matching listener
      */
     /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
-    unsigned long packet_len = 17 + (sizeof(FwdNotReq) - 1);
+    size_t packet_len = 17 + strlen(FwdNotReq);
     unsigned char *p;
     LIBSSH2_LISTENER *listn = _libssh2_list_first(&session->listeners);
     char failure_code = SSH_OPEN_ADMINISTRATIVELY_PROHIBITED;
     int rc;
 
     if(listen_state->state == libssh2_NB_state_idle) {
-        unsigned long offset = (sizeof("forwarded-tcpip") - 1) + 5;
+        size_t offset = strlen("forwarded-tcpip") + 5;
         size_t temp_len = 0;
         struct string_buf buf;
         buf.data = data;
@@ -133,10 +125,10 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                                   "Data too short extracting sport");
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "Remote received connection from %s:%ld to %s:%ld",
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Remote received connection from %s:%u to %s:%u",
                        listen_state->shost, listen_state->sport,
-                       listen_state->host, listen_state->port);
+                       listen_state->host, listen_state->port));
 
         listen_state->state = libssh2_NB_state_allocated;
     }
@@ -145,8 +137,8 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
         while(listn) {
             if((listn->port == (int) listen_state->port) &&
                 (strlen(listn->host) == listen_state->host_len) &&
-                (memcmp (listn->host, listen_state->host,
-                         listen_state->host_len) == 0)) {
+                (memcmp(listn->host, listen_state->host,
+                        listen_state->host_len) == 0)) {
                 /* This is our listener */
                 LIBSSH2_CHANNEL *channel = NULL;
                 listen_state->channel = NULL;
@@ -156,8 +148,8 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                         (listn->queue_maxsize <= listn->queue_size)) {
                         /* Queue is full */
                         failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                       "Listener queue full, ignoring");
+                        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                                       "Listener queue full, ignoring"));
                         listen_state->state = libssh2_NB_state_sent;
                         break;
                     }
@@ -174,7 +166,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                     listen_state->channel = channel;
 
                     channel->session = session;
-                    channel->channel_type_len = sizeof("forwarded-tcpip") - 1;
+                    channel->channel_type_len = strlen("forwarded-tcpip");
                     channel->channel_type = LIBSSH2_ALLOC(session,
                                                           channel->
                                                           channel_type_len +
@@ -206,14 +198,14 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
                         listen_state->initial_window_size;
                     channel->local.packet_size = listen_state->packet_size;
 
-                    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                   "Connection queued: channel %lu/%lu "
-                                   "win %lu/%lu packet %lu/%lu",
+                    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                                   "Connection queued: channel %u/%u "
+                                   "win %u/%u packet %u/%u",
                                    channel->local.id, channel->remote.id,
                                    channel->local.window_size,
                                    channel->remote.window_size,
                                    channel->local.packet_size,
-                                   channel->remote.packet_size);
+                                   channel->remote.packet_size));
 
                     p = listen_state->packet;
                     *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
@@ -261,7 +253,7 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
     *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
     _libssh2_store_u32(&p, listen_state->sender_channel);
     _libssh2_store_u32(&p, failure_code);
-    _libssh2_store_str(&p, FwdNotReq, sizeof(FwdNotReq) - 1);
+    _libssh2_store_str(&p, FwdNotReq, strlen(FwdNotReq));
     _libssh2_htonu32(p, 0);
 
     rc = _libssh2_transport_send(session, listen_state->packet,
@@ -285,19 +277,19 @@ packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
  */
 static inline int
 packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
-                unsigned long datalen,
+                size_t datalen,
                 packet_x11_open_state_t *x11open_state)
 {
     int failure_code = SSH_OPEN_CONNECT_FAILED;
     /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
-    unsigned long packet_len = 17 + (sizeof(X11FwdUnAvil) - 1);
+    size_t packet_len = 17 + strlen(X11FwdUnAvil);
     unsigned char *p;
     LIBSSH2_CHANNEL *channel = x11open_state->channel;
     int rc;
 
     if(x11open_state->state == libssh2_NB_state_idle) {
 
-        unsigned long offset = (sizeof("x11") - 1) + 5;
+        size_t offset = strlen("x11") + 5;
         size_t temp_len = 0;
         struct string_buf buf;
         buf.data = data;
@@ -346,10 +338,10 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
             goto x11_exit;
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                       "X11 Connection Received from %s:%ld on channel %lu",
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "X11 Connection Received from %s:%u on channel %u",
                        x11open_state->shost, x11open_state->sport,
-                       x11open_state->sender_channel);
+                       x11open_state->sender_channel));
 
         x11open_state->state = libssh2_NB_state_allocated;
     }
@@ -365,7 +357,7 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
             }
 
             channel->session = session;
-            channel->channel_type_len = sizeof("x11") - 1;
+            channel->channel_type_len = strlen("x11");
             channel->channel_type = LIBSSH2_ALLOC(session,
                                                   channel->channel_type_len +
                                                   1);
@@ -391,14 +383,14 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
             channel->local.window_size = x11open_state->initial_window_size;
             channel->local.packet_size = x11open_state->packet_size;
 
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "X11 Connection established: channel %lu/%lu "
-                           "win %lu/%lu packet %lu/%lu",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "X11 Connection established: channel %u/%u "
+                           "win %u/%u packet %u/%u",
                            channel->local.id, channel->remote.id,
                            channel->local.window_size,
                            channel->remote.window_size,
                            channel->local.packet_size,
-                           channel->remote.packet_size);
+                           channel->remote.packet_size));
             p = x11open_state->packet;
             *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
             _libssh2_store_u32(&p, channel->remote.id);
@@ -439,12 +431,12 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
     else
         failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
     /* fall-trough */
-  x11_exit:
+x11_exit:
     p = x11open_state->packet;
     *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
     _libssh2_store_u32(&p, x11open_state->sender_channel);
     _libssh2_store_u32(&p, failure_code);
-    _libssh2_store_str(&p, X11FwdUnAvil, sizeof(X11FwdUnAvil) - 1);
+    _libssh2_store_str(&p, X11FwdUnAvil, strlen(X11FwdUnAvil));
     _libssh2_htonu32(p, 0);
 
     rc = _libssh2_transport_send(session, x11open_state->packet, packet_len,
@@ -460,6 +452,171 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
     return 0;
 }
 
+/*
+ * packet_authagent_open
+ *
+ * Open a connection to authentication agent
+ */
+static inline int
+packet_authagent_open(LIBSSH2_SESSION * session,
+                      unsigned char *data, size_t datalen,
+                      packet_authagent_state_t *authagent_state)
+{
+    int failure_code = SSH_OPEN_CONNECT_FAILED;
+    /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
+    size_t packet_len = 17 + strlen(X11FwdUnAvil);
+    unsigned char *p;
+    LIBSSH2_CHANNEL *channel = authagent_state->channel;
+    int rc;
+    struct string_buf buf;
+    size_t offset = strlen("auth-agent@openssh.org") + 5;
+
+    buf.data = data;
+    buf.dataptr = buf.data;
+    buf.len = datalen;
+
+    buf.dataptr += offset;
+
+    if(datalen < offset) {
+        return _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                              "Unexpected packet size");
+    }
+
+    if(authagent_state->state == libssh2_NB_state_idle) {
+        if(_libssh2_get_u32(&buf, &(authagent_state->sender_channel))) {
+            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                                  "Data too short extracting channel");
+        }
+        if(_libssh2_get_u32(&buf, &(authagent_state->initial_window_size))) {
+            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                                  "Data too short extracting window size");
+        }
+        if(_libssh2_get_u32(&buf, &(authagent_state->packet_size))) {
+            return _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                                  "Data too short extracting packet");
+        }
+
+        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                       "Auth Agent Connection Received on channel %u",
+                       authagent_state->sender_channel));
+
+        authagent_state->state = libssh2_NB_state_allocated;
+    }
+
+    if(session->authagent) {
+        if(authagent_state->state == libssh2_NB_state_allocated) {
+            channel = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
+            authagent_state->channel = channel;
+
+            if(!channel) {
+                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                               "allocate a channel for new connection");
+                failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
+                goto authagent_exit;
+            }
+            memset(channel, 0, sizeof(LIBSSH2_CHANNEL));
+
+            channel->session = session;
+            channel->channel_type_len = strlen("auth agent");
+            channel->channel_type = LIBSSH2_ALLOC(session,
+                                                  channel->channel_type_len +
+                                                  1);
+            if(!channel->channel_type) {
+                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                               "allocate a channel for new connection");
+                LIBSSH2_FREE(session, channel);
+                failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
+                goto authagent_exit;
+            }
+            memcpy(channel->channel_type, "auth agent",
+                   channel->channel_type_len + 1);
+
+            channel->remote.id = authagent_state->sender_channel;
+            channel->remote.window_size_initial =
+                LIBSSH2_CHANNEL_WINDOW_DEFAULT;
+            channel->remote.window_size = LIBSSH2_CHANNEL_WINDOW_DEFAULT;
+            channel->remote.packet_size = LIBSSH2_CHANNEL_PACKET_DEFAULT;
+
+            channel->local.id = _libssh2_channel_nextid(session);
+            channel->local.window_size_initial =
+                authagent_state->initial_window_size;
+            channel->local.window_size = authagent_state->initial_window_size;
+            channel->local.packet_size = authagent_state->packet_size;
+
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "Auth Agent Connection established: channel "
+                           "%u/%u win %u/%u packet %u/%u",
+                           channel->local.id, channel->remote.id,
+                           channel->local.window_size,
+                           channel->remote.window_size,
+                           channel->local.packet_size,
+                           channel->remote.packet_size));
+
+            p = authagent_state->packet;
+            *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
+            _libssh2_store_u32(&p, channel->remote.id);
+            _libssh2_store_u32(&p, channel->local.id);
+            _libssh2_store_u32(&p, channel->remote.window_size_initial);
+            _libssh2_store_u32(&p, channel->remote.packet_size);
+
+            authagent_state->state = libssh2_NB_state_created;
+        }
+
+        if(authagent_state->state == libssh2_NB_state_created) {
+            rc = _libssh2_transport_send(session, authagent_state->packet, 17,
+                                         NULL, 0);
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
+                return rc;
+            }
+            else if(rc) {
+                authagent_state->state = libssh2_NB_state_idle;
+                return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
+                                      "Unable to send channel open "
+                                      "confirmation");
+            }
+
+            /* Link the channel into the session */
+            _libssh2_list_add(&session->channels, &channel->node);
+
+            /* mess with stuff so we don't keep reading the same packet
+               over and over */
+            session->packet.total_num = 0;
+            session->fullpacket_state = libssh2_NB_state_idle;
+
+            /* Pass control to the callback, they may turn right around and
+               and free the channel, or actually use it */
+
+            LIBSSH2_AUTHAGENT(channel);
+
+            authagent_state->state = libssh2_NB_state_idle;
+            return 0;
+        }
+    }
+    else
+        failure_code = SSH_OPEN_RESOURCE_SHORTAGE;
+
+    /* fall-through */
+authagent_exit:
+    p = authagent_state->packet;
+    *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
+    _libssh2_store_u32(&p, authagent_state->sender_channel);
+    _libssh2_store_u32(&p, failure_code);
+    _libssh2_store_str(&p, AuthAgentUnavail, strlen(AuthAgentUnavail));
+    _libssh2_htonu32(p, 0);
+
+    rc = _libssh2_transport_send(session, authagent_state->packet, packet_len,
+                                 NULL, 0);
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
+        return rc;
+    }
+    else if(rc) {
+        authagent_state->state = libssh2_NB_state_idle;
+        return _libssh2_error(session, rc, "Unable to send open failure");
+    }
+    authagent_state->state = libssh2_NB_state_idle;
+    return 0;
+}
+
 /*
  * _libssh2_packet_add
  *
@@ -467,14 +624,13 @@ packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
  * layer when it has received a packet.
  *
  * The input pointer 'data' is pointing to allocated data that this function
- * is asked to deal with so on failure OR success, it must be freed fine.
- * The only exception is when the return code is LIBSSH2_ERROR_EAGAIN.
+ * will be freed unless return the code is LIBSSH2_ERROR_EAGAIN.
  *
  * This function will always be called with 'datalen' greater than zero.
  */
 int
 _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
-                    size_t datalen, int macstate)
+                    size_t datalen, int macstate, uint32_t seq)
 {
     int rc = 0;
     unsigned char *message = NULL;
@@ -487,9 +643,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 
     switch(session->packAdd_state) {
     case libssh2_NB_state_idle:
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Packet type %d received, length=%d",
-                       (int) msg, (int) datalen);
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "Packet type %u received, length=%ld",
+                       (unsigned int) msg, (long) datalen));
 
         if((macstate == LIBSSH2_MAC_INVALID) &&
             (!session->macerror ||
@@ -513,10 +669,76 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         goto libssh2_packet_add_jump_point4;
     case libssh2_NB_state_jump5:
         goto libssh2_packet_add_jump_point5;
+    case libssh2_NB_state_jumpauthagent:
+        goto libssh2_packet_add_jump_authagent;
     default: /* nothing to do */
         break;
     }
 
+    if(session->state & LIBSSH2_STATE_INITIAL_KEX) {
+        if(msg == SSH_MSG_KEXINIT) {
+            if(!session->kex_strict) {
+                if(datalen < 17) {
+                    LIBSSH2_FREE(session, data);
+                    session->packAdd_state = libssh2_NB_state_idle;
+                    return _libssh2_error(session,
+                                          LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                                          "Data too short extracting kex");
+                }
+                else {
+                    const unsigned char *strict =
+                    (unsigned char *)"kex-strict-s-v00@openssh.com";
+                    struct string_buf buf;
+                    unsigned char *algs = NULL;
+                    size_t algs_len = 0;
+
+                    buf.data = (unsigned char *)data;
+                    buf.dataptr = buf.data;
+                    buf.len = datalen;
+                    buf.dataptr += 17; /* advance past type and cookie */
+
+                    if(_libssh2_get_string(&buf, &algs, &algs_len)) {
+                        LIBSSH2_FREE(session, data);
+                        session->packAdd_state = libssh2_NB_state_idle;
+                        return _libssh2_error(session,
+                                              LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                                              "Algs too short");
+                    }
+
+                    if(algs_len == 0 ||
+                       _libssh2_kex_agree_instr(algs, algs_len, strict, 28)) {
+                        session->kex_strict = 1;
+                    }
+                }
+            }
+
+            if(session->kex_strict && seq) {
+                LIBSSH2_FREE(session, data);
+                session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
+                session->packAdd_state = libssh2_NB_state_idle;
+                libssh2_session_disconnect(session, "strict KEX violation: "
+                                           "KEXINIT was not the first packet");
+
+                return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
+                                      "strict KEX violation: "
+                                      "KEXINIT was not the first packet");
+            }
+        }
+
+        if(session->kex_strict && session->fullpacket_required_type &&
+            session->fullpacket_required_type != msg) {
+            LIBSSH2_FREE(session, data);
+            session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
+            session->packAdd_state = libssh2_NB_state_idle;
+            libssh2_session_disconnect(session, "strict KEX violation: "
+                                       "unexpected packet type");
+
+            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
+                                  "strict KEX violation: "
+                                  "unexpected packet type");
+        }
+    }
+
     if(session->packAdd_state == libssh2_NB_state_allocated) {
         /* A couple exceptions to the packet adding rule: */
         switch(msg) {
@@ -547,9 +769,9 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                                        language_len);
                 }
 
-                _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
+                _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
                                "Disconnect(%d): %s(%s)", reason,
-                               message, language);
+                               message, language));
             }
 
             LIBSSH2_FREE(session, data);
@@ -606,15 +828,85 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
             }
 
             /*
-             * _libssh2_debug will actually truncate this for us so
+             * _libssh2_debug() will actually truncate this for us so
              * that it's not an inordinate about of data
              */
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                           "Debug Packet: %s", message);
+            _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                           "Debug Packet: %s", message));
             LIBSSH2_FREE(session, data);
             session->packAdd_state = libssh2_NB_state_idle;
             return 0;
 
+            /*
+              byte      SSH_MSG_EXT_INFO
+              uint32    nr-extensions
+              [repeat   "nr-extensions" times]
+              string    extension-name  [RFC8308]
+              string    extension-value (binary)
+            */
+
+        case SSH_MSG_EXT_INFO:
+            if(datalen >= 5) {
+                uint32_t nr_extensions = 0;
+                struct string_buf buf;
+                buf.data = (unsigned char *)data;
+                buf.dataptr = buf.data;
+                buf.len = datalen;
+                buf.dataptr += 1; /* advance past type */
+
+                if(_libssh2_get_u32(&buf, &nr_extensions) != 0) {
+                    rc = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                        "Invalid extension info received");
+                }
+
+                while(rc == 0 && nr_extensions > 0) {
+
+                    size_t name_len = 0;
+                    size_t value_len = 0;
+                    unsigned char *name = NULL;
+                    unsigned char *value = NULL;
+
+                    nr_extensions -= 1;
+
+                    _libssh2_get_string(&buf, &name, &name_len);
+                    _libssh2_get_string(&buf, &value, &value_len);
+
+                    if(name && value) {
+                        _libssh2_debug((session,
+                                       LIBSSH2_TRACE_KEX,
+                                       "Server to Client extension %.*s: %.*s",
+                                       (int)name_len, name,
+                                       (int)value_len, value));
+                    }
+
+                    if(name_len == 15 &&
+                        memcmp(name, "server-sig-algs", 15) == 0) {
+                        if(session->server_sign_algorithms) {
+                            LIBSSH2_FREE(session,
+                                         session->server_sign_algorithms);
+                        }
+
+                        session->server_sign_algorithms =
+                                                LIBSSH2_ALLOC(session,
+                                                              value_len + 1);
+
+                        if(session->server_sign_algorithms) {
+                            memcpy(session->server_sign_algorithms,
+                                   value, value_len);
+                            session->server_sign_algorithms[value_len] = '\0';
+                        }
+                        else {
+                            rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                                "memory for server sign algo");
+                        }
+                    }
+                }
+            }
+
+            LIBSSH2_FREE(session, data);
+            session->packAdd_state = libssh2_NB_state_idle;
+            return rc;
+
             /*
               byte      SSH_MSG_GLOBAL_REQUEST
               string    request name in US-ASCII only
@@ -629,17 +921,17 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 len = _libssh2_ntohu32(data + 1);
                 if((len <= (UINT_MAX - 6)) && (datalen >= (6 + len))) {
                     want_reply = data[5 + len];
-                    _libssh2_debug(session,
+                    _libssh2_debug((session,
                                    LIBSSH2_TRACE_CONN,
                                    "Received global request type %.*s (wr %X)",
-                                   len, data + 5, want_reply);
+                                   (int)len, data + 5, want_reply));
                 }
 
 
                 if(want_reply) {
                     static const unsigned char packet =
                         SSH_MSG_REQUEST_FAILURE;
-                  libssh2_packet_add_jump_point5:
+libssh2_packet_add_jump_point5:
                     session->packAdd_state = libssh2_NB_state_jump5;
                     rc = _libssh2_transport_send(session, &packet, 1, NULL, 0);
                     if(rc == LIBSSH2_ERROR_EAGAIN)
@@ -661,7 +953,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
             /* streamid(4) */
             data_head += 4;
 
-            /* fall-through */
+            LIBSSH2_FALLTHROUGH();
 
             /*
               byte      SSH_MSG_CHANNEL_DATA
@@ -691,12 +983,12 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 if(msg == SSH_MSG_CHANNEL_EXTENDED_DATA)
                     stream_id = _libssh2_ntohu32(data + 5);
 
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "%d bytes packet_add() for %lu/%lu/%lu",
-                               (int) (datalen - data_head),
+                _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                               "%ld bytes packet_add() for %u/%u/%u",
+                               (long) (datalen - data_head),
                                channelp->local.id,
                                channelp->remote.id,
-                               stream_id);
+                               stream_id));
             }
 #endif
             if((channelp->remote.extended_data_ignore_mode ==
@@ -705,30 +997,31 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 /* Pretend we didn't receive this */
                 LIBSSH2_FREE(session, data);
 
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "Ignoring extended data and refunding %d bytes",
-                               (int) (datalen - 13));
+                _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                              "Ignoring extended data and refunding %ld bytes",
+                               (long) (datalen - 13)));
                 if(channelp->read_avail + datalen - data_head >=
                     channelp->remote.window_size)
                     datalen = channelp->remote.window_size -
                         channelp->read_avail + data_head;
 
-                channelp->remote.window_size -= datalen - data_head;
-                _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                               "shrinking window size by %lu bytes to %lu, "
-                               "read_avail %lu",
-                               datalen - data_head,
+                channelp->remote.window_size -= (uint32_t)(datalen -
+                                                           data_head);
+                _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                               "shrinking window size by %ld bytes to %u, "
+                               "read_avail %ld",
+                               (long) (datalen - data_head),
                                channelp->remote.window_size,
-                               channelp->read_avail);
+                               (long) channelp->read_avail));
 
                 session->packAdd_channelp = channelp;
 
                 /* Adjust the window based on the block we just freed */
-              libssh2_packet_add_jump_point1:
+libssh2_packet_add_jump_point1:
                 session->packAdd_state = libssh2_NB_state_jump1;
                 rc = _libssh2_channel_receive_window_adjust(session->
                                                             packAdd_channelp,
-                                                            datalen - 13,
+                                                    (uint32_t)(datalen - 13),
                                                             1, NULL);
                 if(rc == LIBSSH2_ERROR_EAGAIN)
                     return rc;
@@ -746,8 +1039,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                  * Spec says we MAY ignore bytes sent beyond
                  * packet_size
                  */
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
+                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
                                "Packet contains more data than we offered"
                                " to receive, truncating");
                 datalen = channelp->remote.packet_size + data_head;
@@ -757,8 +1049,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                  * Spec says we MAY ignore bytes sent beyond
                  * window_size
                  */
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
+                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
                                "The current receive window is full,"
                                " data ignored");
                 LIBSSH2_FREE(session, data);
@@ -770,8 +1061,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 
             if(channelp->read_avail + datalen - data_head >
                 channelp->remote.window_size) {
-                _libssh2_error(session,
-                               LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
+                _libssh2_error(session, LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
                                "Remote sent more data than current "
                                "window allows, truncating");
                 datalen = channelp->remote.window_size -
@@ -783,11 +1073,11 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
              * from an upper layer */
             channelp->read_avail += datalen - data_head;
 
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "increasing read_avail by %lu bytes to %lu/%lu",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "increasing read_avail by %ld bytes to %ld/%u",
                            (long)(datalen - data_head),
                            (long)channelp->read_avail,
-                           (long)channelp->remote.window_size);
+                           channelp->remote.window_size));
 
             break;
 
@@ -805,11 +1095,11 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 /* We may have freed already, just quietly ignore this... */
                 ;
             else {
-                _libssh2_debug(session,
+                _libssh2_debug((session,
                                LIBSSH2_TRACE_CONN,
-                               "EOF received for channel %lu/%lu",
+                               "EOF received for channel %u/%u",
                                channelp->local.id,
-                               channelp->remote.id);
+                               channelp->remote.id));
                 channelp->remote.eof = 1;
             }
             LIBSSH2_FREE(session, data);
@@ -833,45 +1123,47 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 if((len + 9) < datalen)
                     want_reply = data[len + 9];
 
-                _libssh2_debug(session,
+                _libssh2_debug((session,
                                LIBSSH2_TRACE_CONN,
-                               "Channel %d received request type %.*s (wr %X)",
-                               channel, len, data + 9, want_reply);
+                               "Channel %u received request type %.*s (wr %X)",
+                               channel, (int)len, data + 9, want_reply));
 
-                if(len == sizeof("exit-status") - 1
-                    && (sizeof("exit-status") - 1 + 9) <= datalen
+                if(len == strlen("exit-status")
+                    && (strlen("exit-status") + 9) <= datalen
                     && !memcmp("exit-status", data + 9,
-                               sizeof("exit-status") - 1)) {
+                               strlen("exit-status"))) {
 
                     /* we've got "exit-status" packet. Set the session value */
                     if(datalen >= 20)
                         channelp =
                             _libssh2_channel_locate(session, channel);
 
-                    if(channelp && (sizeof("exit-status") + 13) <= datalen) {
+                    if(channelp && (strlen("exit-status") + 14) <= datalen) {
                         channelp->exit_status =
-                            _libssh2_ntohu32(data + 9 + sizeof("exit-status"));
-                        _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                       "Exit status %lu received for "
-                                       "channel %lu/%lu",
+                            _libssh2_ntohu32(data + 10 +
+                                             strlen("exit-status"));
+                        _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                                       "Exit status %d received for "
+                                       "channel %u/%u",
                                        channelp->exit_status,
                                        channelp->local.id,
-                                       channelp->remote.id);
+                                       channelp->remote.id));
                     }
 
                 }
-                else if(len == sizeof("exit-signal") - 1
-                         && (sizeof("exit-signal") - 1 + 9) <= datalen
+                else if(len == strlen("exit-signal")
+                         && (strlen("exit-signal") + 9) <= datalen
                          && !memcmp("exit-signal", data + 9,
-                                    sizeof("exit-signal") - 1)) {
+                                    strlen("exit-signal"))) {
                     /* command terminated due to signal */
                     if(datalen >= 20)
                         channelp = _libssh2_channel_locate(session, channel);
 
-                    if(channelp && (sizeof("exit-signal") + 13) <= datalen) {
+                    if(channelp && (strlen("exit-signal") + 14) <= datalen) {
                         /* set signal name (without SIG prefix) */
                         uint32_t namelen =
-                            _libssh2_ntohu32(data + 9 + sizeof("exit-signal"));
+                            _libssh2_ntohu32(data + 10 +
+                                             strlen("exit-signal"));
 
                         if(namelen <= UINT_MAX - 1) {
                             channelp->exit_signal =
@@ -884,18 +1176,18 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                         if(!channelp->exit_signal)
                             rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                                 "memory for signal name");
-                        else if((sizeof("exit-signal") + 13 + namelen <=
+                        else if((strlen("exit-signal") + 14 + namelen <=
                                  datalen)) {
                             memcpy(channelp->exit_signal,
-                                   data + 13 + sizeof("exit-signal"), namelen);
+                                   data + 14 + strlen("exit-signal"), namelen);
                             channelp->exit_signal[namelen] = '\0';
                             /* TODO: save error message and language tag */
-                            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
+                            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
                                            "Exit signal %s received for "
-                                           "channel %lu/%lu",
+                                           "channel %u/%u",
                                            channelp->exit_signal,
                                            channelp->local.id,
-                                           channelp->remote.id);
+                                           channelp->remote.id));
                         }
                     }
                 }
@@ -903,7 +1195,7 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
 
                 if(want_reply) {
                     unsigned char packet[5];
-                  libssh2_packet_add_jump_point4:
+libssh2_packet_add_jump_point4:
                     session->packAdd_state = libssh2_NB_state_jump4;
                     packet[0] = SSH_MSG_CHANNEL_FAILURE;
                     memcpy(&packet[1], data + 1, 4);
@@ -932,10 +1224,10 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 session->packAdd_state = libssh2_NB_state_idle;
                 return 0;
             }
-            _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                           "Close received for channel %lu/%lu",
+            _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                           "Close received for channel %u/%u",
                            channelp->local.id,
-                           channelp->remote.id);
+                           channelp->remote.id));
 
             channelp->remote.close = 1;
             channelp->remote.eof = 1;
@@ -955,35 +1247,50 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         case SSH_MSG_CHANNEL_OPEN:
             if(datalen < 17)
                 ;
-            else if((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
-                     ((sizeof("forwarded-tcpip") - 1) ==
+            else if((datalen >= (strlen("forwarded-tcpip") + 5)) &&
+                     (strlen("forwarded-tcpip") ==
                       _libssh2_ntohu32(data + 1))
                      &&
                      (memcmp(data + 5, "forwarded-tcpip",
-                             sizeof("forwarded-tcpip") - 1) == 0)) {
+                             strlen("forwarded-tcpip")) == 0)) {
 
                 /* init the state struct */
                 memset(&session->packAdd_Qlstn_state, 0,
                        sizeof(session->packAdd_Qlstn_state));
 
-              libssh2_packet_add_jump_point2:
+libssh2_packet_add_jump_point2:
                 session->packAdd_state = libssh2_NB_state_jump2;
                 rc = packet_queue_listener(session, data, datalen,
                                            &session->packAdd_Qlstn_state);
             }
-            else if((datalen >= (sizeof("x11") + 4)) &&
-                     ((sizeof("x11") - 1) == _libssh2_ntohu32(data + 1)) &&
-                     (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) {
+            else if((datalen >= (strlen("x11") + 5)) &&
+                     ((strlen("x11")) == _libssh2_ntohu32(data + 1)) &&
+                     (memcmp(data + 5, "x11", strlen("x11")) == 0)) {
 
                 /* init the state struct */
                 memset(&session->packAdd_x11open_state, 0,
                        sizeof(session->packAdd_x11open_state));
 
-              libssh2_packet_add_jump_point3:
+libssh2_packet_add_jump_point3:
                 session->packAdd_state = libssh2_NB_state_jump3;
                 rc = packet_x11_open(session, data, datalen,
                                      &session->packAdd_x11open_state);
             }
+            else if((datalen >= (strlen("auth-agent@openssh.com") + 5)) &&
+                    (strlen("auth-agent@openssh.com") ==
+                      _libssh2_ntohu32(data + 1)) &&
+                    (memcmp(data + 5, "auth-agent@openssh.com",
+                            strlen("auth-agent@openssh.com")) == 0)) {
+
+                /* init the state struct */
+                memset(&session->packAdd_authagent_state, 0,
+                       sizeof(session->packAdd_authagent_state));
+
+libssh2_packet_add_jump_authagent:
+                session->packAdd_state = libssh2_NB_state_jumpauthagent;
+                rc = packet_authagent_open(session, data, datalen,
+                                           &session->packAdd_authagent_state);
+            }
             if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
 
@@ -1007,13 +1314,13 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
                 if(channelp) {
                     channelp->local.window_size += bytestoadd;
 
-                    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                                   "Window adjust for channel %lu/%lu, "
-                                   "adding %lu bytes, new window_size=%lu",
+                    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                                   "Window adjust for channel %u/%u, "
+                                   "adding %u bytes, new window_size=%u",
                                    channelp->local.id,
                                    channelp->remote.id,
                                    bytestoadd,
-                                   channelp->local.window_size);
+                                   channelp->local.window_size));
                 }
             }
             LIBSSH2_FREE(session, data);
@@ -1030,8 +1337,8 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
         LIBSSH2_PACKET *packetp =
             LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
         if(!packetp) {
-            _libssh2_debug(session, LIBSSH2_ERROR_ALLOC,
-                           "memory for packet");
+            _libssh2_debug((session, LIBSSH2_ERROR_ALLOC,
+                           "memory for packet"));
             LIBSSH2_FREE(session, data);
             session->packAdd_state = libssh2_NB_state_idle;
             return LIBSSH2_ERROR_ALLOC;
@@ -1054,7 +1361,8 @@ _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
              * Well, it's already in the brigade,
              * let's just call back into ourselves
              */
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Renegotiating Keys");
+            _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                           "Renegotiating Keys"));
 
             session->packAdd_state = libssh2_NB_state_sent2;
         }
@@ -1099,8 +1407,9 @@ _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
 {
     LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets);
 
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                   "Looking for packet of type: %d", (int) packet_type);
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                   "Looking for packet of type: %u",
+                   (unsigned int)packet_type));
 
     while(packet) {
         if(packet->data[0] == packet_type
@@ -1118,6 +1427,15 @@ _libssh2_packet_ask(LIBSSH2_SESSION * session, unsigned char packet_type,
 
             return 0;
         }
+        else if(session->kex_strict &&
+                (session->state & LIBSSH2_STATE_INITIAL_KEX)) {
+            libssh2_session_disconnect(session, "strict KEX violation: "
+                                       "unexpected packet type");
+
+            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
+                                  "strict KEX violation: "
+                                  "unexpected packet type");
+        }
         packet = _libssh2_list_next(&packet->node);
     }
     return -1;
@@ -1137,12 +1455,12 @@ _libssh2_packet_askv(LIBSSH2_SESSION * session,
                      const unsigned char *match_buf,
                      size_t match_len)
 {
-    int i, packet_types_len = strlen((char *) packet_types);
+    size_t i, packet_types_len = strlen((const char *) packet_types);
 
     for(i = 0; i < packet_types_len; i++) {
-        if(0 == _libssh2_packet_ask(session, packet_types[i], data,
-                                     data_len, match_ofs,
-                                     match_buf, match_len)) {
+        if(_libssh2_packet_ask(session, packet_types[i], data,
+                               data_len, match_ofs,
+                               match_buf, match_len) == 0) {
             return 0;
         }
     }
@@ -1169,8 +1487,8 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
 {
     if(state->start == 0) {
         if(_libssh2_packet_ask(session, packet_type, data, data_len,
-                                match_ofs, match_buf,
-                                match_len) == 0) {
+                               match_ofs, match_buf,
+                               match_len) == 0) {
             /* A packet was available in the packet brigade */
             return 0;
         }
@@ -1179,7 +1497,10 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
     }
 
     while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-        int ret = _libssh2_transport_read(session);
+        int ret;
+        session->fullpacket_required_type = packet_type;
+        ret = _libssh2_transport_read(session);
+        session->fullpacket_required_type = 0;
         if(ret == LIBSSH2_ERROR_EAGAIN)
             return ret;
         else if(ret < 0) {
@@ -1196,8 +1517,8 @@ _libssh2_packet_require(LIBSSH2_SESSION * session, unsigned char packet_type,
         }
         else if(ret == 0) {
             /* nothing available, wait until data arrives or we time out */
-            long left = LIBSSH2_READ_TIMEOUT - (long)(time(NULL) -
-                                                      state->start);
+            long left = session->packet_read_timeout - (long)(time(NULL) -
+                                                              state->start);
 
             if(left <= 0) {
                 state->start = 0;
@@ -1234,15 +1555,15 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
         all_packets[254] = 0;
 
         if(_libssh2_packet_askv(session, all_packets, &data, &data_len, 0,
-                                 NULL, 0) == 0) {
+                                NULL, 0) == 0) {
             i = data[0];
             /* A packet was available in the packet brigade, burn it */
             LIBSSH2_FREE(session, data);
             return i;
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Blocking until packet becomes available to burn");
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "Blocking until packet becomes available to burn"));
         *state = libssh2_NB_state_created;
     }
 
@@ -1263,7 +1584,7 @@ _libssh2_packet_burn(LIBSSH2_SESSION * session,
         /* Be lazy, let packet_ask pull it out of the brigade */
         if(0 ==
             _libssh2_packet_ask(session, (unsigned char)ret,
-                                         &data, &data_len, 0, NULL, 0)) {
+                                &data, &data_len, 0, NULL, 0)) {
             /* Smoke 'em if you got 'em */
             LIBSSH2_FREE(session, data);
             *state = libssh2_NB_state_idle;
@@ -1292,7 +1613,7 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
                          packet_requirev_state_t * state)
 {
     if(_libssh2_packet_askv(session, packet_types, data, data_len, match_ofs,
-                             match_buf, match_len) == 0) {
+                            match_buf, match_len) == 0) {
         /* One of the packets listed was available in the packet brigade */
         state->start = 0;
         return 0;
@@ -1309,7 +1630,7 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
             return ret;
         }
         if(ret <= 0) {
-            long left = LIBSSH2_READ_TIMEOUT -
+            long left = session->packet_read_timeout -
                 (long)(time(NULL) - state->start);
 
             if(left <= 0) {
@@ -1323,9 +1644,9 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
 
         if(strchr((char *) packet_types, ret)) {
             /* Be lazy, let packet_ask pull it out of the brigade */
-            int ret = _libssh2_packet_askv(session, packet_types, data,
-                                        data_len, match_ofs, match_buf,
-                                        match_len);
+            ret = _libssh2_packet_askv(session, packet_types, data,
+                                       data_len, match_ofs, match_buf,
+                                       match_len);
             state->start = 0;
             return ret;
         }
@@ -1335,4 +1656,3 @@ _libssh2_packet_requirev(LIBSSH2_SESSION *session,
     state->start = 0;
     return LIBSSH2_ERROR_SOCKET_DISCONNECT;
 }
-
diff --git a/libssh2/src/packet.h b/libssh2/src/packet.h
index 79018bcf..955351e5 100644
--- a/libssh2/src/packet.h
+++ b/libssh2/src/packet.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_PACKET_H
-#define __LIBSSH2_PACKET_H
+#ifndef LIBSSH2_PACKET_H
+#define LIBSSH2_PACKET_H
 /*
- * Copyright (C) 2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
+ * Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -37,6 +37,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 int _libssh2_packet_read(LIBSSH2_SESSION * session);
@@ -71,6 +72,6 @@ int _libssh2_packet_burn(LIBSSH2_SESSION * session,
 int _libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data,
                           unsigned long data_len);
 int _libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
-                        size_t datalen, int macstate);
+                        size_t datalen, int macstate, uint32_t seq);
 
-#endif /* __LIBSSH2_PACKET_H */
+#endif /* LIBSSH2_PACKET_H */
diff --git a/libssh2/src/pem.c b/libssh2/src/pem.c
index 3416bd52..c9ab7746 100644
--- a/libssh2/src/pem.c
+++ b/libssh2/src/pem.c
@@ -1,5 +1,5 @@
-/* Copyright (C) 2007 The Written Word, Inc.
- * Copyright (C) 2008, Simon Josefsson
+/* Copyright (C) The Written Word, Inc.
+ * Copyright (C) Simon Josefsson
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -100,7 +102,8 @@ static const char *crypt_annotation = "Proc-Type: 4,ENCRYPTED";
 
 static unsigned char hex_decode(char digit)
 {
-    return (digit >= 'A') ? 0xA + (digit - 'A') : (digit - '0');
+    return (unsigned char)
+        ((digit >= 'A') ? (0xA + (digit - 'A')) : (digit - '0'));
 }
 
 int
@@ -108,12 +111,12 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
                    const char *headerbegin,
                    const char *headerend,
                    const unsigned char *passphrase,
-                   FILE * fp, unsigned char **data, unsigned int *datalen)
+                   FILE * fp, unsigned char **data, size_t *datalen)
 {
     char line[LINE_SIZE];
     unsigned char iv[LINE_SIZE];
     char *b64data = NULL;
-    unsigned int b64datalen = 0;
+    size_t b64datalen = 0;
     int ret;
     const LIBSSH2_CRYPT_METHOD *method = NULL;
 
@@ -123,8 +126,7 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         if(readline(line, LINE_SIZE, fp)) {
             return -1;
         }
-    }
-    while(strcmp(line, headerbegin) != 0);
+    } while(strcmp(line, headerbegin) != 0);
 
     if(readline(line, LINE_SIZE, fp)) {
         return -1;
@@ -141,7 +143,8 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         }
 
         all_methods = libssh2_crypt_methods();
-        while((cur_method = *all_methods++)) {
+        /* !checksrc! disable EQUALSNULL 1 */
+        while((cur_method = *all_methods++) != NULL) {
             if(*cur_method->pem_annotation &&
                     memcmp(line, cur_method->pem_annotation,
                            strlen(cur_method->pem_annotation)) == 0) {
@@ -152,12 +155,12 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         }
 
         /* None of the available crypt methods were able to decrypt the key */
-        if(method == NULL)
+        if(!method)
             return -1;
 
         /* Decode IV from hex */
         for(i = 0; i < method->iv_len; ++i) {
-            iv[i]  = hex_decode(iv[2*i]) << 4;
+            iv[i]  = (unsigned char)(hex_decode(iv[2*i]) << 4);
             iv[i] |= hex_decode(iv[2*i + 1]);
         }
 
@@ -198,13 +201,14 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    if(libssh2_base64_decode(session, (char **) data, datalen,
+    if(_libssh2_base64_decode(session, (char **) data, datalen,
                               b64data, b64datalen)) {
         ret = -1;
         goto out;
     }
 
     if(method) {
+#if LIBSSH2_MD5_PEM
         /* Set up decryption */
         int free_iv = 0, free_secret = 0, len_decrypted = 0, padding = 0;
         int blocksize = method->blocksize;
@@ -213,24 +217,26 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         libssh2_md5_ctx fingerprint_ctx;
 
         /* Perform key derivation (PBKDF1/MD5) */
-        if(!libssh2_md5_init(&fingerprint_ctx)) {
+        if(!libssh2_md5_init(&fingerprint_ctx) ||
+           !libssh2_md5_update(fingerprint_ctx, passphrase,
+                               strlen((char *)passphrase)) ||
+           !libssh2_md5_update(fingerprint_ctx, iv, 8) ||
+           !libssh2_md5_final(fingerprint_ctx, secret)) {
             ret = -1;
             goto out;
         }
-        libssh2_md5_update(fingerprint_ctx, passphrase,
-                           strlen((char *)passphrase));
-        libssh2_md5_update(fingerprint_ctx, iv, 8);
-        libssh2_md5_final(fingerprint_ctx, secret);
         if(method->secret_len > MD5_DIGEST_LENGTH) {
-            if(!libssh2_md5_init(&fingerprint_ctx)) {
+            if(!libssh2_md5_init(&fingerprint_ctx) ||
+               !libssh2_md5_update(fingerprint_ctx,
+                                   secret, MD5_DIGEST_LENGTH) ||
+               !libssh2_md5_update(fingerprint_ctx,
+                                   passphrase, strlen((char *)passphrase)) ||
+               !libssh2_md5_update(fingerprint_ctx, iv, 8) ||
+               !libssh2_md5_final(fingerprint_ctx,
+                                  secret + MD5_DIGEST_LENGTH)) {
                 ret = -1;
                 goto out;
             }
-            libssh2_md5_update(fingerprint_ctx, secret, MD5_DIGEST_LENGTH);
-            libssh2_md5_update(fingerprint_ctx, passphrase,
-                               strlen((char *)passphrase));
-            libssh2_md5_update(fingerprint_ctx, iv, 8);
-            libssh2_md5_final(fingerprint_ctx, secret + MD5_DIGEST_LENGTH);
         }
 
         /* Initialize the decryption */
@@ -256,9 +262,8 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
             goto out;
         }
 
-        while(len_decrypted <= (int)*datalen - blocksize) {
-            if(method->crypt(session, *data + len_decrypted, blocksize,
-                              &abstract)) {
+        if(method->flags & LIBSSH2_CRYPT_FLAG_REQUIRES_FULL_PACKET) {
+            if(method->crypt(session, 0, *data, *datalen, &abstract, 0)) {
                 ret = LIBSSH2_ERROR_DECRYPT;
                 _libssh2_explicit_zero((char *)secret, sizeof(secret));
                 method->dtor(session, &abstract);
@@ -266,8 +271,25 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
                 LIBSSH2_FREE(session, *data);
                 goto out;
             }
+        }
+        else {
+            while(len_decrypted <= (int)*datalen - blocksize) {
+                if(method->crypt(session, 0, *data + len_decrypted, blocksize,
+                                &abstract,
+                                len_decrypted == 0 ? FIRST_BLOCK :
+                                ((len_decrypted == (int)*datalen - blocksize) ?
+                                 LAST_BLOCK : MIDDLE_BLOCK)
+                                )) {
+                    ret = LIBSSH2_ERROR_DECRYPT;
+                    _libssh2_explicit_zero((char *)secret, sizeof(secret));
+                    method->dtor(session, &abstract);
+                    _libssh2_explicit_zero(*data, *datalen);
+                    LIBSSH2_FREE(session, *data);
+                    goto out;
+                }
 
-            len_decrypted += blocksize;
+                len_decrypted += blocksize;
+            }
         }
 
         /* Account for padding */
@@ -278,10 +300,14 @@ _libssh2_pem_parse(LIBSSH2_SESSION * session,
         /* Clean up */
         _libssh2_explicit_zero((char *)secret, sizeof(secret));
         method->dtor(session, &abstract);
+#else
+        ret = -1;
+        goto out;
+#endif
     }
 
     ret = 0;
-  out:
+out:
     if(b64data) {
         _libssh2_explicit_zero(b64data, b64datalen);
         LIBSSH2_FREE(session, b64data);
@@ -294,11 +320,11 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
                           const char *headerbegin,
                           const char *headerend,
                           const char *filedata, size_t filedata_len,
-                          unsigned char **data, unsigned int *datalen)
+                          unsigned char **data, size_t *datalen)
 {
     char line[LINE_SIZE];
     char *b64data = NULL;
-    unsigned int b64datalen = 0;
+    size_t b64datalen = 0;
     size_t off = 0;
     int ret;
 
@@ -308,8 +334,7 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
         if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
             return -1;
         }
-    }
-    while(strcmp(line, headerbegin) != 0);
+    } while(strcmp(line, headerbegin) != 0);
 
     *line = '\0';
 
@@ -343,14 +368,14 @@ _libssh2_pem_parse_memory(LIBSSH2_SESSION * session,
         return -1;
     }
 
-    if(libssh2_base64_decode(session, (char **) data, datalen,
+    if(_libssh2_base64_decode(session, (char **) data, datalen,
                               b64data, b64datalen)) {
         ret = -1;
         goto out;
     }
 
     ret = 0;
-  out:
+out:
     if(b64data) {
         _libssh2_explicit_zero(b64data, b64datalen);
         LIBSSH2_FREE(session, b64data);
@@ -382,7 +407,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
     unsigned char *key_part = NULL;
     unsigned char *iv_part = NULL;
     unsigned char *f = NULL;
-    unsigned int f_len = 0;
+    size_t f_len = 0;
     int ret = 0, keylen = 0, ivlen = 0, total_len = 0;
     size_t kdf_len = 0, tmp_len = 0, salt_len = 0;
 
@@ -390,10 +415,10 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         *decrypted_buf = NULL;
 
     /* decode file */
-    if(libssh2_base64_decode(session, (char **)&f, &f_len,
-                             b64data, b64datalen)) {
-       ret = -1;
-       goto out;
+    if(_libssh2_base64_decode(session, (char **)&f, &f_len,
+                              b64data, b64datalen)) {
+        ret = -1;
+        goto out;
     }
 
     /* Parse the file */
@@ -425,7 +450,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
     if(_libssh2_get_string(&decoded, &kdfname, &tmp_len) ||
        tmp_len == 0) {
         ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "kdfname is missing");
+                             "kdfname is missing");
         goto out;
     }
 
@@ -440,7 +465,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         kdf_buf.len = kdf_len;
     }
 
-    if((passphrase == NULL || strlen((const char *)passphrase) == 0) &&
+    if((!passphrase || strlen((const char *)passphrase) == 0) &&
         strcmp((const char *)ciphername, "none") != 0) {
         /* passphrase required */
         ret = LIBSSH2_ERROR_KEYFILE_AUTH_FAILED;
@@ -456,8 +481,8 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
 
     if(!strcmp((const char *)kdfname, "none") &&
        strcmp((const char *)ciphername, "none") != 0) {
-        ret =_libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                            "invalid format");
+        ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                             "invalid format");
         goto out;
     }
 
@@ -478,7 +503,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
 
     if(_libssh2_get_string(&decoded, &buf, &tmp_len) || tmp_len == 0) {
         ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                       "Private key data not found");
+                             "Private key data not found");
         goto out;
     }
 
@@ -490,7 +515,8 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         const LIBSSH2_CRYPT_METHOD **all_methods, *cur_method;
 
         all_methods = libssh2_crypt_methods();
-        while((cur_method = *all_methods++)) {
+        /* !checksrc! disable EQUALSNULL 1 */
+        while((cur_method = *all_methods++) != NULL) {
             if(*cur_method->name &&
                 memcmp(ciphername, cur_method->name,
                        strlen(cur_method->name)) == 0) {
@@ -500,9 +526,9 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
 
         /* None of the available crypt methods were able to decrypt the key */
 
-        if(method == NULL) {
+        if(!method) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                "No supported cipher found");
+                                 "No supported cipher found");
             goto out;
         }
     }
@@ -517,16 +543,15 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         total_len = keylen + ivlen;
 
         key = LIBSSH2_CALLOC(session, total_len);
-        if(key == NULL) {
+        if(!key) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                           "Could not alloc key");
+                                 "Could not alloc key");
             goto out;
         }
 
-        if(strcmp((const char *)kdfname, "bcrypt") == 0 &&
-           passphrase != NULL) {
+        if(strcmp((const char *)kdfname, "bcrypt") == 0 && passphrase) {
             if((_libssh2_get_string(&kdf_buf, &salt, &salt_len)) ||
-                (_libssh2_get_u32(&kdf_buf, &rounds) != 0) ) {
+                (_libssh2_get_u32(&kdf_buf, &rounds) != 0)) {
                 ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                                      "kdf contains unexpected values");
                 LIBSSH2_FREE(session, key);
@@ -545,7 +570,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         }
         else {
             ret = _libssh2_error(session, LIBSSH2_ERROR_KEYFILE_AUTH_FAILED,
-                                            "bcrypted without passphrase");
+                                 "bcrypted without passphrase");
             LIBSSH2_FREE(session, key);
             goto out;
         }
@@ -554,14 +579,14 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         blocksize = method->blocksize;
 
         key_part = LIBSSH2_CALLOC(session, keylen);
-        if(key_part == NULL) {
+        if(!key_part) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                                  "Could not alloc key part");
             goto out;
         }
 
         iv_part = LIBSSH2_CALLOC(session, ivlen);
-        if(iv_part == NULL) {
+        if(!iv_part) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                                  "Could not alloc iv part");
             goto out;
@@ -572,7 +597,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
 
         /* Initialize the decryption */
         if(method->init(session, method, iv_part, &free_iv, key_part,
-                         &free_secret, 0, &abstract)) {
+                        &free_secret, 0, &abstract)) {
             ret = LIBSSH2_ERROR_DECRYPT;
             goto out;
         }
@@ -584,19 +609,59 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
             goto out;
         }
 
-        while((size_t)len_decrypted <= decrypted.len - blocksize) {
-            if(method->crypt(session, decrypted.data + len_decrypted,
-                             blocksize,
-                             &abstract)) {
+        if(method->flags & LIBSSH2_CRYPT_FLAG_REQUIRES_FULL_PACKET) {
+            if(method->crypt(session, 0, decrypted.data,
+                             decrypted.len,
+                             &abstract,
+                             MIDDLE_BLOCK)) {
                 ret = LIBSSH2_ERROR_DECRYPT;
                 method->dtor(session, &abstract);
                 goto out;
             }
-
-            len_decrypted += blocksize;
         }
+        else {
+            while((size_t)len_decrypted <= decrypted.len - blocksize) {
+                /* We always pass MIDDLE_BLOCK here because OpenSSH Key Files
+                 * do not use AAD to authenticate the length.
+                 * Furthermore, the authentication tag is appended after the
+                 * encrypted key, and the length of the authentication tag is
+                 * not included in the key length, so we check it after the
+                 * loop.
+                 */
+                if(method->crypt(session, 0, decrypted.data + len_decrypted,
+                                 blocksize,
+                                 &abstract,
+                                 MIDDLE_BLOCK)) {
+                    ret = LIBSSH2_ERROR_DECRYPT;
+                    method->dtor(session, &abstract);
+                    goto out;
+                }
+
+                len_decrypted += blocksize;
+            }
 
-        /* No padding */
+            /* No padding */
+
+            /* for the AES GCM methods, the 16 byte authentication tag is
+             * appended to the encrypted key */
+            if(strcmp(method->name, "aes256-gcm@openssh.com") == 0 ||
+               strcmp(method->name, "aes128-gcm@openssh.com") == 0) {
+                if(!_libssh2_check_length(&decoded, 16)) {
+                    ret = _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                                         "GCM auth tag missing");
+                    method->dtor(session, &abstract);
+                    goto out;
+                }
+                if(method->crypt(session, 0, decoded.dataptr, 16, &abstract,
+                                 LAST_BLOCK)) {
+                    ret = _libssh2_error(session, LIBSSH2_ERROR_DECRYPT,
+                                         "GCM auth tag invalid");
+                    method->dtor(session, &abstract);
+                    goto out;
+                }
+                decoded.dataptr += 16;
+            }
+        }
 
         method->dtor(session, &abstract);
     }
@@ -606,13 +671,13 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
     if(_libssh2_get_u32(&decrypted, &check1) != 0 ||
        _libssh2_get_u32(&decrypted, &check2) != 0 ||
        check1 != check2) {
-       _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                      "Private key unpack failed (correct password?)");
-       ret = LIBSSH2_ERROR_KEYFILE_AUTH_FAILED;
-       goto out;
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Private key unpack failed (correct password?)");
+        ret = LIBSSH2_ERROR_KEYFILE_AUTH_FAILED;
+        goto out;
     }
 
-    if(decrypted_buf != NULL) {
+    if(decrypted_buf) {
         /* copy data to out-going buffer */
         struct string_buf *out_buf = _libssh2_string_buf_new(session);
         if(!out_buf) {
@@ -623,7 +688,7 @@ _libssh2_openssh_pem_parse_data(LIBSSH2_SESSION * session,
         }
 
         out_buf->data = LIBSSH2_CALLOC(session, decrypted.len);
-        if(out_buf->data == NULL) {
+        if(!out_buf->data) {
             ret = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                  "Unable to allocate memory for "
                                  "decrypted struct");
@@ -668,7 +733,7 @@ _libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
 {
     char line[LINE_SIZE];
     char *b64data = NULL;
-    unsigned int b64datalen = 0;
+    size_t b64datalen = 0;
     int ret = 0;
 
     /* read file */
@@ -679,8 +744,7 @@ _libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
         if(readline(line, LINE_SIZE, fp)) {
             return -1;
         }
-    }
-    while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
+    } while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
 
     if(readline(line, LINE_SIZE, fp)) {
         return -1;
@@ -719,7 +783,7 @@ _libssh2_openssh_pem_parse(LIBSSH2_SESSION * session,
     ret = _libssh2_openssh_pem_parse_data(session,
                                           passphrase,
                                           (const char *)b64data,
-                                          (size_t)b64datalen,
+                                          b64datalen,
                                           decrypted_buf);
 
     if(b64data) {
@@ -740,11 +804,11 @@ _libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
 {
     char line[LINE_SIZE];
     char *b64data = NULL;
-    unsigned int b64datalen = 0;
+    size_t b64datalen = 0;
     size_t off = 0;
     int ret;
 
-    if(filedata == NULL || filedata_len <= 0)
+    if(!filedata || filedata_len <= 0)
         return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
                               "Error parsing PEM: filedata missing");
 
@@ -754,18 +818,18 @@ _libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
 
         if(off >= filedata_len)
             return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
-                                  "Error parsing PEM: offset out of bounds");
+                                  "Error parsing PEM: "
+                                  "OpenSSH header not found");
 
         if(readline_memory(line, LINE_SIZE, filedata, filedata_len, &off)) {
             return -1;
         }
-    }
-    while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
+    } while(strcmp(line, OPENSSH_HEADER_BEGIN) != 0);
 
     *line = '\0';
 
     do {
-        if (*line) {
+        if(*line) {
             char *tmp;
             size_t linelen;
 
@@ -814,7 +878,7 @@ _libssh2_openssh_pem_parse_memory(LIBSSH2_SESSION * session,
 
 static int
 read_asn1_length(const unsigned char *data,
-                 unsigned int datalen, unsigned int *len)
+                 size_t datalen, size_t *len)
 {
     unsigned int lenlen;
     int nextpos;
@@ -848,9 +912,9 @@ read_asn1_length(const unsigned char *data,
 }
 
 int
-_libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
+_libssh2_pem_decode_sequence(unsigned char **data, size_t *datalen)
 {
-    unsigned int len;
+    size_t len;
     int lenlen;
 
     if(*datalen < 1) {
@@ -876,10 +940,10 @@ _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
 }
 
 int
-_libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
+_libssh2_pem_decode_integer(unsigned char **data, size_t *datalen,
                             unsigned char **i, unsigned int *ilen)
 {
-    unsigned int len;
+    size_t len;
     int lenlen;
 
     if(*datalen < 1) {
@@ -902,7 +966,7 @@ _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
     *datalen -= lenlen;
 
     *i = *data;
-    *ilen = len;
+    *ilen = (unsigned int)len;
 
     *data += len;
     *datalen -= len;
diff --git a/libssh2/src/poly1305.c b/libssh2/src/poly1305.c
new file mode 100644
index 00000000..2d7b2324
--- /dev/null
+++ b/libssh2/src/poly1305.c
@@ -0,0 +1,206 @@
+/*
+ * Public Domain poly1305 from Andrew Moon
+ * poly1305-donna-unrolled.c from https://github.com/floodyberry/poly1305-donna
+ * Copyright not intended 2024.
+ *
+ * SPDX-License-Identifier: SAX-PD-2.0
+ */
+
+/* $OpenBSD: poly1305.c,v 1.3 2013/12/19 22:57:13 djm Exp $ */
+
+#include "libssh2_priv.h"
+
+#include "poly1305.h"
+
+#define mul32x32_64(a,b) ((uint64_t)(a) * (b))
+
+#define U8TO32_LE(p) \
+    (((uint32_t)((p)[0])) | \
+     ((uint32_t)((p)[1]) <<  8) | \
+     ((uint32_t)((p)[2]) << 16) | \
+     ((uint32_t)((p)[3]) << 24))
+
+#define U32TO8_LE(p, v) \
+    do { \
+        (p)[0] = (uint8_t)((v)); \
+        (p)[1] = (uint8_t)((v) >>  8); \
+        (p)[2] = (uint8_t)((v) >> 16); \
+        (p)[3] = (uint8_t)((v) >> 24); \
+    } while (0)
+
+void
+poly1305_auth(unsigned char out[POLY1305_TAGLEN], const unsigned char *m,
+              size_t inlen, const unsigned char key[POLY1305_KEYLEN]) {
+    uint32_t t0;
+    uint32_t t1;
+    uint32_t t2;
+    uint32_t t3;
+    uint32_t h0;
+    uint32_t h1;
+    uint32_t h2;
+    uint32_t h3;
+    uint32_t h4;
+    uint32_t r0;
+    uint32_t r1;
+    uint32_t r2;
+    uint32_t r3;
+    uint32_t r4;
+    uint32_t s1;
+    uint32_t s2;
+    uint32_t s3;
+    uint32_t s4;
+    uint32_t b;
+    uint32_t nb;
+    size_t j;
+    uint64_t t[5];
+    uint64_t f0;
+    uint64_t f1;
+    uint64_t f2;
+    uint64_t f3;
+    uint32_t g0;
+    uint32_t g1;
+    uint32_t g2;
+    uint32_t g3;
+    uint32_t g4;
+    uint64_t c;
+    unsigned char mp[16];
+
+    /* clamp key */
+    t0 = U8TO32_LE(key + 0);
+    t1 = U8TO32_LE(key + 4);
+    t2 = U8TO32_LE(key + 8);
+    t3 = U8TO32_LE(key + 12);
+
+    /* precompute multipliers */
+    r0 = t0 & 0x3ffffff; t0 >>= 26; t0 |= t1 << 6;
+    r1 = t0 & 0x3ffff03; t1 >>= 20; t1 |= t2 << 12;
+    r2 = t1 & 0x3ffc0ff; t2 >>= 14; t2 |= t3 << 18;
+    r3 = t2 & 0x3f03fff; t3 >>= 8;
+    r4 = t3 & 0x00fffff;
+
+    s1 = r1 * 5;
+    s2 = r2 * 5;
+    s3 = r3 * 5;
+    s4 = r4 * 5;
+
+    /* init state */
+    h0 = 0;
+    h1 = 0;
+    h2 = 0;
+    h3 = 0;
+    h4 = 0;
+
+    /* full blocks */
+    if(inlen < 16)
+        goto poly1305_donna_atmost15bytes;
+
+poly1305_donna_16bytes:
+    m += 16;
+    inlen -= 16;
+
+    t0 = U8TO32_LE(m-16);
+    t1 = U8TO32_LE(m-12);
+    t2 = U8TO32_LE(m-8);
+    t3 = U8TO32_LE(m-4);
+
+    h0 += t0 & 0x3ffffff;
+    h1 += ((uint32_t)((((uint64_t)t1 << 32) | t0) >> 26) & 0x3ffffff);
+    h2 += ((uint32_t)((((uint64_t)t2 << 32) | t1) >> 20) & 0x3ffffff);
+    h3 += ((uint32_t)((((uint64_t)t3 << 32) | t2) >> 14) & 0x3ffffff);
+    h4 += (t3 >> 8) | (1 << 24);
+
+
+poly1305_donna_mul:
+    t[0] = mul32x32_64(h0, r0) + mul32x32_64(h1, s4) + mul32x32_64(h2, s3) +
+        mul32x32_64(h3, s2) + mul32x32_64(h4, s1);
+    t[1] = mul32x32_64(h0, r1) + mul32x32_64(h1, r0) + mul32x32_64(h2, s4) +
+        mul32x32_64(h3, s3) + mul32x32_64(h4, s2);
+    t[2] = mul32x32_64(h0, r2) + mul32x32_64(h1, r1) + mul32x32_64(h2, r0) +
+        mul32x32_64(h3, s4) + mul32x32_64(h4, s3);
+    t[3] = mul32x32_64(h0, r3) + mul32x32_64(h1, r2) + mul32x32_64(h2, r1) +
+        mul32x32_64(h3, r0) + mul32x32_64(h4, s4);
+    t[4] = mul32x32_64(h0, r4) + mul32x32_64(h1, r3) + mul32x32_64(h2, r2) +
+        mul32x32_64(h3, r1) + mul32x32_64(h4, r0);
+
+    h0 = (uint32_t)t[0] & 0x3ffffff;
+    c = (t[0] >> 26);
+
+    t[1] += c;
+    h1 = (uint32_t)t[1] & 0x3ffffff;
+    b = (uint32_t)(t[1] >> 26);
+
+    t[2] += b;
+    h2 = (uint32_t)t[2] & 0x3ffffff;
+    b = (uint32_t)(t[2] >> 26);
+
+    t[3] += b;
+    h3 = (uint32_t)t[3] & 0x3ffffff;
+    b = (uint32_t)(t[3] >> 26);
+
+    t[4] += b;
+    h4 = (uint32_t)t[4] & 0x3ffffff;
+    b = (uint32_t)(t[4] >> 26);
+
+    h0 += b * 5;
+
+    if(inlen >= 16)
+        goto poly1305_donna_16bytes;
+
+    /* final bytes */
+poly1305_donna_atmost15bytes:
+    if(!inlen)
+        goto poly1305_donna_finish;
+
+    for(j = 0; j < inlen; j++) mp[j] = m[j];
+    mp[j++] = 1;
+    for(; j < 16; j++)
+        mp[j] = 0;
+
+    inlen = 0;
+
+    t0 = U8TO32_LE(mp + 0);
+    t1 = U8TO32_LE(mp + 4);
+    t2 = U8TO32_LE(mp + 8);
+    t3 = U8TO32_LE(mp + 12);
+
+    h0 += t0 & 0x3ffffff;
+    h1 += ((uint32_t)((((uint64_t)t1 << 32) | t0) >> 26) & 0x3ffffff);
+    h2 += ((uint32_t)((((uint64_t)t2 << 32) | t1) >> 20) & 0x3ffffff);
+    h3 += ((uint32_t)((((uint64_t)t3 << 32) | t2) >> 14) & 0x3ffffff);
+    h4 += (t3 >> 8);
+
+    goto poly1305_donna_mul;
+
+poly1305_donna_finish:
+    b = h0 >> 26; h0 = h0 & 0x3ffffff;
+    h1 +=     b; b = h1 >> 26; h1 = h1 & 0x3ffffff;
+    h2 +=     b; b = h2 >> 26; h2 = h2 & 0x3ffffff;
+    h3 +=     b; b = h3 >> 26; h3 = h3 & 0x3ffffff;
+    h4 +=     b; b = h4 >> 26; h4 = h4 & 0x3ffffff;
+    h0 += b * 5; b = h0 >> 26; h0 = h0 & 0x3ffffff;
+    h1 +=     b;
+
+    g0 = h0 + 5; b = g0 >> 26; g0 &= 0x3ffffff;
+    g1 = h1 + b; b = g1 >> 26; g1 &= 0x3ffffff;
+    g2 = h2 + b; b = g2 >> 26; g2 &= 0x3ffffff;
+    g3 = h3 + b; b = g3 >> 26; g3 &= 0x3ffffff;
+    g4 = h4 + b - (1 << 26);
+
+    b = (g4 >> 31) - 1;
+    nb = ~b;
+    h0 = (h0 & nb) | (g0 & b);
+    h1 = (h1 & nb) | (g1 & b);
+    h2 = (h2 & nb) | (g2 & b);
+    h3 = (h3 & nb) | (g3 & b);
+    h4 = (h4 & nb) | (g4 & b);
+
+    f0 = ((h0      ) | (h1 << 26)) + (uint64_t)U8TO32_LE(&key[16]);
+    f1 = ((h1 >>  6) | (h2 << 20)) + (uint64_t)U8TO32_LE(&key[20]);
+    f2 = ((h2 >> 12) | (h3 << 14)) + (uint64_t)U8TO32_LE(&key[24]);
+    f3 = ((h3 >> 18) | (h4 <<  8)) + (uint64_t)U8TO32_LE(&key[28]);
+
+    U32TO8_LE(&out[ 0], f0); f1 += (f0 >> 32);
+    U32TO8_LE(&out[ 4], f1); f2 += (f1 >> 32);
+    U32TO8_LE(&out[ 8], f2); f3 += (f2 >> 32);
+    U32TO8_LE(&out[12], f3);
+}
diff --git a/libssh2/src/poly1305.h b/libssh2/src/poly1305.h
new file mode 100644
index 00000000..21efca93
--- /dev/null
+++ b/libssh2/src/poly1305.h
@@ -0,0 +1,20 @@
+/* $OpenBSD: poly1305.h,v 1.4 2014/05/02 03:27:54 djm Exp $ */
+
+/*
+ * Public Domain poly1305 from Andrew Moon
+ * poly1305-donna-unrolled.c from https://github.com/floodyberry/poly1305-donna
+ * Copyright not intended 2024.
+ *
+ * SPDX-License-Identifier: SAX-PD-2.0
+ */
+
+#ifndef POLY1305_H
+#define POLY1305_H
+
+#define POLY1305_KEYLEN 32
+#define POLY1305_TAGLEN 16
+
+void poly1305_auth(u_char out[POLY1305_TAGLEN], const u_char *m, size_t inlen,
+                   const u_char key[POLY1305_KEYLEN]);
+
+#endif /* POLY1305_H */
diff --git a/libssh2/src/publickey.c b/libssh2/src/publickey.c
index f26c6327..9c9fa618 100644
--- a/libssh2/src/publickey.c
+++ b/libssh2/src/publickey.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2010-2014 by Daniel Stenberg
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,6 +34,8 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
@@ -105,7 +107,7 @@ static const LIBSSH2_PUBLICKEY_CODE_LIST publickey_status_codes[] = {
  */
 static void
 publickey_status_error(const LIBSSH2_PUBLICKEY *pkey,
-                       LIBSSH2_SESSION *session, int status)
+                       LIBSSH2_SESSION *session, unsigned long status)
 {
     const char *msg;
 
@@ -114,7 +116,7 @@ publickey_status_error(const LIBSSH2_PUBLICKEY *pkey,
         status = 7;
     }
 
-    if(status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
+    if(status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
         msg = "unknown";
     }
     else {
@@ -136,14 +138,14 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
     LIBSSH2_CHANNEL *channel = pkey->channel;
     LIBSSH2_SESSION *session = channel->session;
     unsigned char buffer[4];
-    int rc;
+    ssize_t rc;
     *data = NULL; /* default to nothing returned */
     *data_len = 0;
 
     if(pkey->receive_state == libssh2_NB_state_idle) {
         rc = _libssh2_channel_read(channel, 0, (char *) buffer, 4);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+            return (int)rc;
         }
         else if(rc != 4) {
             return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
@@ -166,9 +168,9 @@ publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
         rc = _libssh2_channel_read(channel, 0, (char *) pkey->receive_packet,
                                    pkey->receive_packet_len);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+            return (int)rc;
         }
-        else if(rc != (int)pkey->receive_packet_len) {
+        else if(rc != (ssize_t)pkey->receive_packet_len) {
             LIBSSH2_FREE(session, pkey->receive_packet);
             pkey->receive_packet = NULL;
             pkey->receive_state = libssh2_NB_state_idle;
@@ -234,7 +236,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
     size_t data_len;
     int response;
 
-    while(1) {
+    for(;;) {
         int rc = publickey_packet_receive(pkey, &data, &data_len);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             return rc;
@@ -272,7 +274,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
                 return 0;
 
             publickey_status_error(pkey, session, status);
-            return -1;
+            goto err_exit;
         }
         default:
             LIBSSH2_FREE(session, data);
@@ -287,7 +289,7 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
             data = NULL;
         }
     }
-    /* never reached, but include `return` to silence compiler warnings */
+err_exit:
     return -1;
 }
 
@@ -310,8 +312,8 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_pkey = NULL;
         session->pkeyInit_channel = NULL;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Initializing publickey subsystem");
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
+                       "Initializing publickey subsystem"));
 
         session->pkeyInit_state = libssh2_NB_state_allocated;
     }
@@ -387,28 +389,29 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
 
         session->pkeyInit_buffer_sent = 0;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
                        "Sending publickey advertising version %d support",
-                       (int) LIBSSH2_PUBLICKEY_VERSION);
+                       (int) LIBSSH2_PUBLICKEY_VERSION));
 
         session->pkeyInit_state = libssh2_NB_state_sent2;
     }
 
     if(session->pkeyInit_state == libssh2_NB_state_sent2) {
-        rc = _libssh2_channel_write(session->pkeyInit_channel, 0,
-                                    session->pkeyInit_buffer,
-                                    19 - session->pkeyInit_buffer_sent);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(session->pkeyInit_channel, 0,
+                                          session->pkeyInit_buffer,
+                                          19 - session->pkeyInit_buffer_sent);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending publickey version packet");
             return NULL;
         }
-        else if(rc < 0) {
-            _libssh2_error(session, rc,
+        else if(nwritten < 0) {
+            _libssh2_error(session, (int)nwritten,
                            "Unable to send publickey version packet");
             goto err_exit;
         }
-        session->pkeyInit_buffer_sent += rc;
+        session->pkeyInit_buffer_sent += nwritten;
         if(session->pkeyInit_buffer_sent < 19) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Need to be called again to complete this");
@@ -419,7 +422,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
     }
 
     if(session->pkeyInit_state == libssh2_NB_state_sent3) {
-        while(1) {
+        for(;;) {
             unsigned char *s;
             rc = publickey_packet_receive(session->pkeyInit_pkey,
                                           &session->pkeyInit_data,
@@ -511,16 +514,16 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
                 session->pkeyInit_pkey->version = _libssh2_ntohu32(s);
                 if(session->pkeyInit_pkey->version >
                     LIBSSH2_PUBLICKEY_VERSION) {
-                    _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
+                    _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
                                    "Truncate remote publickey version "
-                                   "from %lu",
-                                   session->pkeyInit_pkey->version);
+                                   "from %u",
+                                   session->pkeyInit_pkey->version));
                     session->pkeyInit_pkey->version =
                         LIBSSH2_PUBLICKEY_VERSION;
                 }
-                _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                               "Enabling publickey subsystem version %lu",
-                               session->pkeyInit_pkey->version);
+                _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
+                               "Enabling publickey subsystem version %u",
+                               session->pkeyInit_pkey->version));
                 LIBSSH2_FREE(session, session->pkeyInit_data);
                 session->pkeyInit_data = NULL;
                 session->pkeyInit_state = libssh2_NB_state_idle;
@@ -538,7 +541,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
     }
 
     /* Never reached except by direct goto */
-  err_exit:
+err_exit:
     session->pkeyInit_state = libssh2_NB_state_sent4;
     if(session->pkeyInit_channel) {
         rc = _libssh2_channel_close(session->pkeyInit_channel);
@@ -607,8 +610,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
     if(pkey->add_state == libssh2_NB_state_idle) {
         pkey->add_packet = NULL;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY, "Adding %s publickey",
-                       name);
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
+                       "Adding %s publickey", name));
 
         if(pkey->version == 1) {
             for(i = 0; i < num_attrs; i++) {
@@ -639,25 +642,25 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
         }
 
         pkey->add_s = pkey->add_packet;
-        _libssh2_htonu32(pkey->add_s, packet_len - 4);
+        _libssh2_htonu32(pkey->add_s, (uint32_t)(packet_len - 4));
         pkey->add_s += 4;
         _libssh2_htonu32(pkey->add_s, sizeof("add") - 1);
         pkey->add_s += 4;
         memcpy(pkey->add_s, "add", sizeof("add") - 1);
         pkey->add_s += sizeof("add") - 1;
         if(pkey->version == 1) {
-            _libssh2_htonu32(pkey->add_s, comment_len);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)comment_len);
             pkey->add_s += 4;
             if(comment) {
                 memcpy(pkey->add_s, comment, comment_len);
                 pkey->add_s += comment_len;
             }
 
-            _libssh2_htonu32(pkey->add_s, name_len);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)name_len);
             pkey->add_s += 4;
             memcpy(pkey->add_s, name, name_len);
             pkey->add_s += name_len;
-            _libssh2_htonu32(pkey->add_s, blob_len);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)blob_len);
             pkey->add_s += 4;
             memcpy(pkey->add_s, blob, blob_len);
             pkey->add_s += blob_len;
@@ -665,23 +668,23 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
         else {
             /* Version == 2 */
 
-            _libssh2_htonu32(pkey->add_s, name_len);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)name_len);
             pkey->add_s += 4;
             memcpy(pkey->add_s, name, name_len);
             pkey->add_s += name_len;
-            _libssh2_htonu32(pkey->add_s, blob_len);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)blob_len);
             pkey->add_s += 4;
             memcpy(pkey->add_s, blob, blob_len);
             pkey->add_s += blob_len;
             *(pkey->add_s++) = overwrite ? 0x01 : 0;
-            _libssh2_htonu32(pkey->add_s, num_attrs);
+            _libssh2_htonu32(pkey->add_s, (uint32_t)num_attrs);
             pkey->add_s += 4;
             for(i = 0; i < num_attrs; i++) {
-                _libssh2_htonu32(pkey->add_s, attrs[i].name_len);
+                _libssh2_htonu32(pkey->add_s, (uint32_t)attrs[i].name_len);
                 pkey->add_s += 4;
                 memcpy(pkey->add_s, attrs[i].name, attrs[i].name_len);
                 pkey->add_s += attrs[i].name_len;
-                _libssh2_htonu32(pkey->add_s, attrs[i].value_len);
+                _libssh2_htonu32(pkey->add_s, (uint32_t)attrs[i].value_len);
                 pkey->add_s += 4;
                 memcpy(pkey->add_s, attrs[i].value, attrs[i].value_len);
                 pkey->add_s += attrs[i].value_len;
@@ -689,21 +692,22 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
             }
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
                        "Sending publickey \"add\" packet: "
                        "type=%s blob_len=%ld num_attrs=%ld",
-                       name, blob_len, num_attrs);
+                       name, blob_len, num_attrs));
 
         pkey->add_state = libssh2_NB_state_created;
     }
 
     if(pkey->add_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, pkey->add_packet,
-                                    (pkey->add_s - pkey->add_packet));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, pkey->add_packet,
+                                          (pkey->add_s - pkey->add_packet));
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if((pkey->add_s - pkey->add_packet) != rc) {
+        else if((pkey->add_s - pkey->add_packet) != nwritten) {
             LIBSSH2_FREE(session, pkey->add_packet);
             pkey->add_packet = NULL;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
@@ -758,36 +762,37 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
         }
 
         pkey->remove_s = pkey->remove_packet;
-        _libssh2_htonu32(pkey->remove_s, packet_len - 4);
+        _libssh2_htonu32(pkey->remove_s, (uint32_t)(packet_len - 4));
         pkey->remove_s += 4;
         _libssh2_htonu32(pkey->remove_s, sizeof("remove") - 1);
         pkey->remove_s += 4;
         memcpy(pkey->remove_s, "remove", sizeof("remove") - 1);
         pkey->remove_s += sizeof("remove") - 1;
-        _libssh2_htonu32(pkey->remove_s, name_len);
+        _libssh2_htonu32(pkey->remove_s, (uint32_t)name_len);
         pkey->remove_s += 4;
         memcpy(pkey->remove_s, name, name_len);
         pkey->remove_s += name_len;
-        _libssh2_htonu32(pkey->remove_s, blob_len);
+        _libssh2_htonu32(pkey->remove_s, (uint32_t)blob_len);
         pkey->remove_s += 4;
         memcpy(pkey->remove_s, blob, blob_len);
         pkey->remove_s += blob_len;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
                        "Sending publickey \"remove\" packet: "
                        "type=%s blob_len=%ld",
-                       name, blob_len);
+                       name, blob_len));
 
         pkey->remove_state = libssh2_NB_state_created;
     }
 
     if(pkey->remove_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, pkey->remove_packet,
-                                    (pkey->remove_s - pkey->remove_packet));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, pkey->remove_packet,
+                                       (pkey->remove_s - pkey->remove_packet));
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if((pkey->remove_s - pkey->remove_packet) != rc) {
+        else if((pkey->remove_s - pkey->remove_packet) != nwritten) {
             LIBSSH2_FREE(session, pkey->remove_packet);
             pkey->remove_packet = NULL;
             pkey->remove_state = libssh2_NB_state_idle;
@@ -835,28 +840,29 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         pkey->listFetch_data = NULL;
 
         pkey->listFetch_s = pkey->listFetch_buffer;
-        _libssh2_htonu32(pkey->listFetch_s, buffer_len - 4);
+        _libssh2_htonu32(pkey->listFetch_s, (uint32_t)(buffer_len - 4));
         pkey->listFetch_s += 4;
         _libssh2_htonu32(pkey->listFetch_s, sizeof("list") - 1);
         pkey->listFetch_s += 4;
         memcpy(pkey->listFetch_s, "list", sizeof("list") - 1);
         pkey->listFetch_s += sizeof("list") - 1;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"list\" packet");
+        _libssh2_debug((session, LIBSSH2_TRACE_PUBLICKEY,
+                       "Sending publickey \"list\" packet"));
 
         pkey->listFetch_state = libssh2_NB_state_created;
     }
 
     if(pkey->listFetch_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0,
-                                    pkey->listFetch_buffer,
-                                    (pkey->listFetch_s -
-                                     pkey->listFetch_buffer));
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0,
+                                          pkey->listFetch_buffer,
+                                          (pkey->listFetch_s -
+                                           pkey->listFetch_buffer));
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
+        else if((pkey->listFetch_s - pkey->listFetch_buffer) != nwritten) {
             pkey->listFetch_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                   "Unable to send publickey list packet");
@@ -865,7 +871,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         pkey->listFetch_state = libssh2_NB_state_sent;
     }
 
-    while(1) {
+    for(;;) {
         rc = publickey_packet_receive(pkey, &pkey->listFetch_data,
                                       &pkey->listFetch_data_len);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
@@ -1197,7 +1203,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
     }
 
     /* Only reached via explicit goto */
-  err_exit:
+err_exit:
     if(pkey->listFetch_data) {
         LIBSSH2_FREE(session, pkey->listFetch_data);
         pkey->listFetch_data = NULL;
diff --git a/libssh2/src/scp.c b/libssh2/src/scp.c
index 8cb3d65c..8a8e7d9e 100644
--- a/libssh2/src/scp.c
+++ b/libssh2/src/scp.c
@@ -1,5 +1,5 @@
-/* Copyright (c) 2009-2019 by Daniel Stenberg
- * Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
+/* Copyright (C) Daniel Stenberg
+ * Copyright (C) Sara Golemon <sarag@libssh2.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,15 +34,24 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include <errno.h>
-#include <stdlib.h>
 
 #include "channel.h"
 #include "session.h"
 
+#include <stdlib.h>  /* strtoll(), _strtoi64(), strtol() */
+
+#if defined(HAVE_STRTOLL)
+#define scpsize_strtol strtoll
+#elif defined(HAVE_STRTOI64)
+#define scpsize_strtol _strtoi64
+#else
+#define scpsize_strtol strtol
+#endif
 
 /* Max. length of a quoted string after libssh2_shell_quotearg() processing */
 #define _libssh2_shell_quotedsize(s)     (3 * strlen(s) + 2)
@@ -112,7 +121,7 @@
 
   References:
   o  csh-compatible quotation (special handling for '!' etc.), see
-  http://www.grymoire.com/Unix/Csh.html#toc-uh-10
+  https://www.grymoire.com/Unix/Csh.html#toc-uh-10
 
   Return value:
   Length of the resulting string (not counting the terminating '\0'),
@@ -122,9 +131,9 @@
   until then it is kept static and in this source file.
 */
 
-static unsigned
+static size_t
 shell_quotearg(const char *path, unsigned char *buf,
-               unsigned bufsize)
+               size_t bufsize)
 {
     const char *src;
     unsigned char *dst, *endp;
@@ -270,7 +279,7 @@ shell_quotearg(const char *path, unsigned char *buf,
 static LIBSSH2_CHANNEL *
 scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 {
-    int cmd_len;
+    size_t cmd_len;
     int rc;
     int tmp_err_code;
     const char *tmp_err_msg;
@@ -282,7 +291,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         session->scpRecv_atime = 0;
 
         session->scpRecv_command_len =
-            _libssh2_shell_quotedsize(path) + sizeof("scp -f ") + (sb?1:0);
+            _libssh2_shell_quotedsize(path) + sizeof("scp -f ") + (sb ? 1 : 0);
 
         session->scpRecv_command =
             LIBSSH2_ALLOC(session, session->scpRecv_command_len);
@@ -296,18 +305,30 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
         snprintf((char *)session->scpRecv_command,
                  session->scpRecv_command_len,
-                 "scp -%sf ", sb?"p":"");
+                 "scp -%sf ", sb ? "p" : "");
 
         cmd_len = strlen((char *)session->scpRecv_command);
-        cmd_len += shell_quotearg(path,
-                                  &session->scpRecv_command[cmd_len],
-                                  session->scpRecv_command_len - cmd_len);
+
+        if(!session->flag.quote_paths) {
+            size_t path_len;
+
+            path_len = strlen(path);
+
+            /* no NUL-termination needed, so memcpy will do */
+            memcpy(&session->scpRecv_command[cmd_len], path, path_len);
+            cmd_len += path_len;
+        }
+        else {
+            cmd_len += shell_quotearg(path,
+                                      &session->scpRecv_command[cmd_len],
+                                      session->scpRecv_command_len - cmd_len);
+        }
 
         /* the command to exec should _not_ be NUL-terminated */
         session->scpRecv_command_len = cmd_len;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                       "Opening channel for SCP receive");
+        _libssh2_debug((session, LIBSSH2_TRACE_SCP,
+                       "Opening channel for SCP receive"));
 
         session->scpRecv_state = libssh2_NB_state_created;
     }
@@ -356,7 +377,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
         LIBSSH2_FREE(session, session->scpRecv_command);
         session->scpRecv_command = NULL;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sending initial wakeup");
+        _libssh2_debug((session, LIBSSH2_TRACE_SCP, "Sending initial wakeup"));
         /* SCP ACK */
         session->scpRecv_response[0] = '\0';
 
@@ -364,8 +385,8 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
     }
 
     if(session->scpRecv_state == libssh2_NB_state_sent1) {
-        rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                    session->scpRecv_response, 1);
+        rc = (int)_libssh2_channel_write(session->scpRecv_channel, 0,
+                                         session->scpRecv_response, 1);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block sending initial wakeup");
@@ -384,14 +405,15 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
     if((session->scpRecv_state == libssh2_NB_state_sent2)
         || (session->scpRecv_state == libssh2_NB_state_sent3)) {
         while(sb && (session->scpRecv_response_len <
-                      LIBSSH2_SCP_RESPONSE_BUFLEN)) {
+                     LIBSSH2_SCP_RESPONSE_BUFLEN)) {
             unsigned char *s, *p;
 
             if(session->scpRecv_state == libssh2_NB_state_sent2) {
-                rc = _libssh2_channel_read(session->scpRecv_channel, 0,
-                                           (char *) session->
-                                           scpRecv_response +
-                                           session->scpRecv_response_len, 1);
+                rc = (int)_libssh2_channel_read(session->scpRecv_channel, 0,
+                                                (char *) session->
+                                                scpRecv_response +
+                                                session->scpRecv_response_len,
+                                                1);
                 if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting for SCP response");
@@ -435,9 +457,9 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     /* zero terminate the error */
                     err_msg[err_len] = 0;
 
-                    _libssh2_debug(session, LIBSSH2_TRACE_SCP,
+                    _libssh2_debug((session, LIBSSH2_TRACE_SCP,
                                    "got %02x %s", session->scpRecv_response[0],
-                                   err_msg);
+                                   err_msg));
 
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                    "Failed to recv file");
@@ -550,8 +572,8 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
             }
 
             if(session->scpRecv_state == libssh2_NB_state_sent3) {
-                rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                            session->scpRecv_response, 1);
+                rc = (int)_libssh2_channel_write(session->scpRecv_channel, 0,
+                                                 session->scpRecv_response, 1);
                 if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting to send SCP ACK");
@@ -561,9 +583,10 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                     goto scp_recv_error;
                 }
 
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
+                _libssh2_debug((session, LIBSSH2_TRACE_SCP,
                                "mtime = %ld, atime = %ld",
-                               session->scpRecv_mtime, session->scpRecv_atime);
+                               session->scpRecv_mtime,
+                               session->scpRecv_atime));
 
                 /* We *should* check that atime.usec is valid, but why let
                    that stop use? */
@@ -586,17 +609,18 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
             char *s, *p, *e = NULL;
 
             if(session->scpRecv_state == libssh2_NB_state_sent5) {
-                rc = _libssh2_channel_read(session->scpRecv_channel, 0,
-                                           (char *) session->
-                                           scpRecv_response +
-                                           session->scpRecv_response_len, 1);
+                rc = (int)_libssh2_channel_read(session->scpRecv_channel, 0,
+                                                (char *) session->
+                                                scpRecv_response +
+                                                session->scpRecv_response_len,
+                                                1);
                 if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block waiting for SCP response");
                     return NULL;
                 }
                 else if(rc < 0) {
-                    /* error, bail out*/
+                    /* error, bail out */
                     _libssh2_error(session, rc, "Failed reading SCP response");
                     goto scp_recv_error;
                 }
@@ -678,7 +702,6 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
                 *(p++) = '\0';
                 /* Make sure we don't get fooled by leftover values */
-
                 session->scpRecv_mode = strtol(s, &e, 8);
                 if(e && *e) {
                     _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -713,8 +736,8 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
             }
 
             if(session->scpRecv_state == libssh2_NB_state_sent6) {
-                rc = _libssh2_channel_write(session->scpRecv_channel, 0,
-                                            session->scpRecv_response, 1);
+                rc = (int)_libssh2_channel_write(session->scpRecv_channel, 0,
+                                                 session->scpRecv_response, 1);
                 if(rc == LIBSSH2_ERROR_EAGAIN) {
                     _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                    "Would block sending SCP ACK");
@@ -723,9 +746,9 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
                 else if(rc != 1) {
                     goto scp_recv_error;
                 }
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
+                _libssh2_debug((session, LIBSSH2_TRACE_SCP,
                                "mode = 0%lo size = %ld", session->scpRecv_mode,
-                               session->scpRecv_size);
+                               (long)session->scpRecv_size));
 
                 /* We *should* check that basename is valid, but why let that
                    stop us? */
@@ -741,14 +764,14 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
 
         sb->st_mtime = session->scpRecv_mtime;
         sb->st_atime = session->scpRecv_atime;
-        sb->st_size = session->scpRecv_size;
+        sb->st_size = (libssh2_struct_stat_size)session->scpRecv_size;
         sb->st_mode = (unsigned short)session->scpRecv_mode;
     }
 
     session->scpRecv_state = libssh2_NB_state_idle;
     return session->scpRecv_channel;
 
-  scp_recv_empty_channel:
+scp_recv_empty_channel:
     /* the code only jumps here as a result of a zero read from channel_read()
        so we check EOF status to avoid getting stuck in a loop */
     if(libssh2_channel_eof(session->scpRecv_channel))
@@ -757,11 +780,11 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
     else
         return session->scpRecv_channel;
     /* fall-through */
-  scp_recv_error:
+scp_recv_error:
     tmp_err_code = session->err_code;
     tmp_err_msg = session->err_msg;
     while(libssh2_channel_free(session->scpRecv_channel) ==
-           LIBSSH2_ERROR_EAGAIN);
+          LIBSSH2_ERROR_EAGAIN);
     session->err_code = tmp_err_code;
     session->err_msg = tmp_err_msg;
     session->scpRecv_channel = NULL;
@@ -769,6 +792,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
     return NULL;
 }
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /*
  * libssh2_scp_recv
  *
@@ -780,7 +804,7 @@ scp_recv(LIBSSH2_SESSION * session, const char *path, libssh2_struct_stat * sb)
  *
  */
 LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat * sb)
+libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat *sb)
 {
     LIBSSH2_CHANNEL *ptr;
 
@@ -805,6 +829,7 @@ libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat * sb)
 
     return ptr;
 }
+#endif
 
 /*
  * libssh2_scp_recv2
@@ -823,7 +848,7 @@ libssh2_scp_recv2(LIBSSH2_SESSION *session, const char *path,
 }
 
 /*
- * scp_send()
+ * scp_send
  *
  * Send a file using SCP
  *
@@ -832,7 +857,7 @@ static LIBSSH2_CHANNEL *
 scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
          libssh2_int64_t size, time_t mtime, time_t atime)
 {
-    int cmd_len;
+    size_t cmd_len;
     int rc;
     int tmp_err_code;
     const char *tmp_err_msg;
@@ -840,7 +865,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     if(session->scpSend_state == libssh2_NB_state_idle) {
         session->scpSend_command_len =
             _libssh2_shell_quotedsize(path) + sizeof("scp -t ") +
-            ((mtime || atime)?1:0);
+            ((mtime || atime) ? 1 : 0);
 
         session->scpSend_command =
             LIBSSH2_ALLOC(session, session->scpSend_command_len);
@@ -854,18 +879,31 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
         snprintf((char *)session->scpSend_command,
                  session->scpSend_command_len,
-                 "scp -%st ", (mtime || atime)?"p":"");
+                 "scp -%st ", (mtime || atime) ? "p" : "");
 
         cmd_len = strlen((char *)session->scpSend_command);
-        cmd_len += shell_quotearg(path,
-                                  &session->scpSend_command[cmd_len],
-                                  session->scpSend_command_len - cmd_len);
+
+        if(!session->flag.quote_paths) {
+            size_t path_len;
+
+            path_len = strlen(path);
+
+            /* no NUL-termination needed, so memcpy will do */
+            memcpy(&session->scpSend_command[cmd_len], path, path_len);
+            cmd_len += path_len;
+
+        }
+        else {
+            cmd_len += shell_quotearg(path,
+                                      &session->scpSend_command[cmd_len],
+                                      session->scpSend_command_len - cmd_len);
+        }
 
         /* the command to exec should _not_ be NUL-terminated */
         session->scpSend_command_len = cmd_len;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP,
-                       "Opening channel for SCP send");
+        _libssh2_debug((session, LIBSSH2_TRACE_SCP,
+                       "Opening channel for SCP send"));
         /* Allocate a channel */
 
         session->scpSend_state = libssh2_NB_state_created;
@@ -922,8 +960,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
     if(session->scpSend_state == libssh2_NB_state_sent1) {
         /* Wait for ACK */
-        rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                   (char *) session->scpSend_response, 1);
+        rc = (int)_libssh2_channel_read(session->scpSend_channel, 0,
+                                        (char *) session->scpSend_response, 1);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block waiting for response from remote");
@@ -936,7 +974,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         else if(!rc)
             /* remain in the same state */
             goto scp_send_empty_channel;
-        else if(session->scpSend_response[0] != 0) {
+        else if(session->scpSend_response[0]) {
             _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                            "Invalid ACK response from remote");
             goto scp_send_error;
@@ -947,8 +985,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
                 snprintf((char *) session->scpSend_response,
                          LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n",
                          (long)mtime, (long)atime);
-            _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
-                           session->scpSend_response);
+            _libssh2_debug((session, LIBSSH2_TRACE_SCP, "Sent %s",
+                           session->scpSend_response));
         }
 
         session->scpSend_state = libssh2_NB_state_sent2;
@@ -957,9 +995,9 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     /* Send mtime and atime to be used for file */
     if(mtime || atime) {
         if(session->scpSend_state == libssh2_NB_state_sent2) {
-            rc = _libssh2_channel_write(session->scpSend_channel, 0,
-                                        session->scpSend_response,
-                                        session->scpSend_response_len);
+            rc = (int)_libssh2_channel_write(session->scpSend_channel, 0,
+                                             session->scpSend_response,
+                                             session->scpSend_response_len);
             if(rc == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block sending time data for SCP file");
@@ -976,8 +1014,9 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
         if(session->scpSend_state == libssh2_NB_state_sent3) {
             /* Wait for ACK */
-            rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                       (char *) session->scpSend_response, 1);
+            rc = (int)_libssh2_channel_read(session->scpSend_channel, 0,
+                                            (char *) session->scpSend_response,
+                                            1);
             if(rc == LIBSSH2_ERROR_EAGAIN) {
                 _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                "Would block waiting for response");
@@ -990,7 +1029,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
             else if(!rc)
                 /* remain in the same state */
                 goto scp_send_empty_channel;
-            else if(session->scpSend_response[0] != 0) {
+            else if(session->scpSend_response[0]) {
                 _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
                                "Invalid SCP ACK response");
                 goto scp_send_error;
@@ -1018,16 +1057,16 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
                      LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %"
                      LIBSSH2_INT64_T_FORMAT " %s\n", mode,
                      size, base);
-        _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
-                       session->scpSend_response);
+        _libssh2_debug((session, LIBSSH2_TRACE_SCP, "Sent %s",
+                       session->scpSend_response));
 
         session->scpSend_state = libssh2_NB_state_sent5;
     }
 
     if(session->scpSend_state == libssh2_NB_state_sent5) {
-        rc = _libssh2_channel_write(session->scpSend_channel, 0,
-                                    session->scpSend_response,
-                                    session->scpSend_response_len);
+        rc = (int)_libssh2_channel_write(session->scpSend_channel, 0,
+                                         session->scpSend_response,
+                                         session->scpSend_response_len);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block send core file data for SCP file");
@@ -1044,8 +1083,9 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
     if(session->scpSend_state == libssh2_NB_state_sent6) {
         /* Wait for ACK */
-        rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                   (char *) session->scpSend_response, 1);
+        rc = (int)_libssh2_channel_read(session->scpSend_channel, 0,
+                                        (char *) session->scpSend_response,
+                                        1);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block waiting for response");
@@ -1059,7 +1099,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
         else if(rc == 0)
             goto scp_send_empty_channel;
 
-        else if(session->scpSend_response[0] != 0) {
+        else if(session->scpSend_response[0]) {
             size_t err_len;
             char *err_msg;
 
@@ -1073,13 +1113,13 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
             }
 
             /* Read the remote error message */
-            rc = _libssh2_channel_read(session->scpSend_channel, 0,
-                                       err_msg, err_len);
+            rc = (int)_libssh2_channel_read(session->scpSend_channel, 0,
+                                            err_msg, err_len);
             if(rc > 0) {
                 err_msg[err_len] = 0;
-                _libssh2_debug(session, LIBSSH2_TRACE_SCP,
+                _libssh2_debug((session, LIBSSH2_TRACE_SCP,
                                "got %02x %s", session->scpSend_response[0],
-                               err_msg);
+                               err_msg));
             }
             LIBSSH2_FREE(session, err_msg);
             _libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
@@ -1091,7 +1131,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     session->scpSend_state = libssh2_NB_state_idle;
     return session->scpSend_channel;
 
-  scp_send_empty_channel:
+scp_send_empty_channel:
     /* the code only jumps here as a result of a zero read from channel_read()
        so we check EOF status to avoid getting stuck in a loop */
     if(libssh2_channel_eof(session->scpSend_channel)) {
@@ -1101,7 +1141,7 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
     else
         return session->scpSend_channel;
     /* fall-through */
-  scp_send_error:
+scp_send_error:
     tmp_err_code = session->err_code;
     tmp_err_msg = session->err_msg;
     while(libssh2_channel_free(session->scpSend_channel) ==
diff --git a/libssh2/src/session.c b/libssh2/src/session.c
index 212560b8..2d77b05e 100644
--- a/libssh2/src/session.c
+++ b/libssh2/src/session.c
@@ -1,6 +1,6 @@
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2015 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson <simon@josefsson.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,35 +35,45 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
-#include <errno.h>
+
+#ifdef _WIN32
+#include <ws2tcpip.h>  /* for socklen_t */
+#endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#include <stdlib.h>
-#include <fcntl.h>
-
-#ifdef HAVE_GETTIMEOFDAY
-#include <sys/time.h>
-#endif
 #ifdef HAVE_ALLOCA_H
 #include <alloca.h>
 #endif
 
+#include <errno.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
 #include "transport.h"
 #include "session.h"
 #include "channel.h"
 #include "mac.h"
-#include "misc.h"
+
+#if defined(_WIN32)
+#define libssh2_usec_t long
+#elif defined(__APPLE__)
+#define libssh2_usec_t suseconds_t
+#else
+#undef libssh2_usec_t
+#endif
 
 /* libssh2_default_alloc
  */
 static
 LIBSSH2_ALLOC_FUNC(libssh2_default_alloc)
 {
-    (void) abstract;
+    (void)abstract;
     return malloc(count);
 }
 
@@ -72,7 +82,7 @@ LIBSSH2_ALLOC_FUNC(libssh2_default_alloc)
 static
 LIBSSH2_FREE_FUNC(libssh2_default_free)
 {
-    (void) abstract;
+    (void)abstract;
     free(ptr);
 }
 
@@ -81,7 +91,7 @@ LIBSSH2_FREE_FUNC(libssh2_default_free)
 static
 LIBSSH2_REALLOC_FUNC(libssh2_default_realloc)
 {
-    (void) abstract;
+    (void)abstract;
     return realloc(ptr, count);
 }
 
@@ -96,8 +106,8 @@ LIBSSH2_REALLOC_FUNC(libssh2_default_realloc)
 static int
 banner_receive(LIBSSH2_SESSION * session)
 {
-    int ret;
-    int banner_len;
+    ssize_t ret;
+    size_t banner_len;
 
     if(session->banner_TxRx_state == libssh2_NB_state_idle) {
         banner_len = 0;
@@ -108,25 +118,25 @@ banner_receive(LIBSSH2_SESSION * session)
         banner_len = session->banner_TxRx_total_send;
     }
 
-    while((banner_len < (int) sizeof(session->banner_TxRx_banner)) &&
-           ((banner_len == 0)
-            || (session->banner_TxRx_banner[banner_len - 1] != '\n'))) {
+    while((banner_len < sizeof(session->banner_TxRx_banner)) &&
+          ((banner_len == 0)
+           || (session->banner_TxRx_banner[banner_len - 1] != '\n'))) {
         char c = '\0';
 
         /* no incoming block yet! */
         session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_INBOUND;
 
         ret = LIBSSH2_RECV(session, &c, 1,
-                            LIBSSH2_SOCKET_RECV_FLAGS(session));
+                           LIBSSH2_SOCKET_RECV_FLAGS(session));
         if(ret < 0) {
             if(session->api_block_mode || (ret != -EAGAIN))
                 /* ignore EAGAIN when non-blocking */
-                _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                               "Error recving %d bytes: %d", 1, -ret);
+                _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                               "Error recving %d bytes: %ld", 1, (long)-ret));
         }
         else
-            _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                           "Recved %d bytes banner", ret);
+            _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                           "Recved %ld bytes banner", (long)ret));
 
         if(ret < 0) {
             if(ret == -EAGAIN) {
@@ -147,6 +157,10 @@ banner_receive(LIBSSH2_SESSION * session)
             return LIBSSH2_ERROR_SOCKET_DISCONNECT;
         }
 
+        if((c == '\r' || c == '\n') && banner_len == 0) {
+            continue;
+        }
+
         if(c == '\0') {
             /* NULLs are not allowed in SSH banners */
             session->banner_TxRx_state = libssh2_NB_state_idle;
@@ -158,8 +172,8 @@ banner_receive(LIBSSH2_SESSION * session)
     }
 
     while(banner_len &&
-           ((session->banner_TxRx_banner[banner_len - 1] == '\n') ||
-            (session->banner_TxRx_banner[banner_len - 1] == '\r'))) {
+          ((session->banner_TxRx_banner[banner_len - 1] == '\n') ||
+           (session->banner_TxRx_banner[banner_len - 1] == '\r'))) {
         banner_len--;
     }
 
@@ -180,8 +194,8 @@ banner_receive(LIBSSH2_SESSION * session)
     }
     memcpy(session->remote.banner, session->banner_TxRx_banner, banner_len);
     session->remote.banner[banner_len] = '\0';
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Received Banner: %s",
-                   session->remote.banner);
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS, "Received Banner: %s",
+                   session->remote.banner));
     return LIBSSH2_ERROR_NONE;
 }
 
@@ -199,11 +213,8 @@ static int
 banner_send(LIBSSH2_SESSION * session)
 {
     char *banner = (char *) LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF;
-    int banner_len = sizeof(LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF) - 1;
+    size_t banner_len = sizeof(LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF) - 1;
     ssize_t ret;
-#ifdef LIBSSH2DEBUG
-    char banner_dup[256];
-#endif
 
     if(session->banner_TxRx_state == libssh2_NB_state_idle) {
         if(session->local.banner) {
@@ -212,18 +223,22 @@ banner_send(LIBSSH2_SESSION * session)
             banner = (char *) session->local.banner;
         }
 #ifdef LIBSSH2DEBUG
-        /* Hack and slash to avoid sending CRLF in debug output */
-        if(banner_len < 256) {
-            memcpy(banner_dup, banner, banner_len - 2);
-            banner_dup[banner_len - 2] = '\0';
-        }
-        else {
-            memcpy(banner_dup, banner, 255);
-            banner_dup[255] = '\0';
-        }
+        {
+            char banner_dup[256];
 
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Sending Banner: %s",
-                       banner_dup);
+            /* Hack and slash to avoid sending CRLF in debug output */
+            if(banner_len < 256) {
+                memcpy(banner_dup, banner, banner_len - 2);
+                banner_dup[banner_len - 2] = '\0';
+            }
+            else {
+                memcpy(banner_dup, banner, 255);
+                banner_dup[255] = '\0';
+            }
+
+            _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                           "Sending Banner: %s", banner_dup));
+        }
 #endif
 
         session->banner_TxRx_state = libssh2_NB_state_created;
@@ -233,20 +248,21 @@ banner_send(LIBSSH2_SESSION * session)
     session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_OUTBOUND;
 
     ret = LIBSSH2_SEND(session,
-                        banner + session->banner_TxRx_total_send,
-                        banner_len - session->banner_TxRx_total_send,
-                        LIBSSH2_SOCKET_SEND_FLAGS(session));
+                       banner + session->banner_TxRx_total_send,
+                       banner_len - session->banner_TxRx_total_send,
+                       LIBSSH2_SOCKET_SEND_FLAGS(session));
     if(ret < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d",
-                       banner_len - session->banner_TxRx_total_send, -ret);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Error sending %ld bytes: %ld",
+                       (long)(banner_len - session->banner_TxRx_total_send),
+                       (long)-ret));
     else
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Sent %d/%d bytes at %p+%d", ret,
-                       banner_len - session->banner_TxRx_total_send,
-                       banner, session->banner_TxRx_total_send);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Sent %ld/%ld bytes at %p+%ld", (long)ret,
+                       (long)(banner_len - session->banner_TxRx_total_send),
+                       (void *)banner, (long)session->banner_TxRx_total_send));
 
-    if(ret != (banner_len - session->banner_TxRx_total_send)) {
+    if(ret != (ssize_t)(banner_len - session->banner_TxRx_total_send)) {
         if(ret >= 0 || ret == -EAGAIN) {
             /* the whole packet could not be sent, save the what was */
             session->socket_block_directions =
@@ -276,8 +292,6 @@ static int
 session_nonblock(libssh2_socket_t sockfd,   /* operate on this */
                  int nonblock /* TRUE or FALSE */ )
 {
-#undef SETBLOCK
-#define SETBLOCK 0
 #ifdef HAVE_O_NONBLOCK
     /* most recent unix versions */
     int flags;
@@ -287,66 +301,39 @@ session_nonblock(libssh2_socket_t sockfd,   /* operate on this */
         return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
     else
         return fcntl(sockfd, F_SETFL, flags & (~O_NONBLOCK));
-#undef SETBLOCK
-#define SETBLOCK 1
-#endif
-
-#if defined(HAVE_FIONBIO) && (SETBLOCK == 0)
-    /* older unix versions and VMS*/
+#elif defined(HAVE_FIONBIO)
+    /* older unix versions and VMS */
     int flags;
 
     flags = nonblock;
     return ioctl(sockfd, FIONBIO, &flags);
-#undef SETBLOCK
-#define SETBLOCK 2
-#endif
-
-#if defined(HAVE_IOCTLSOCKET) && (SETBLOCK == 0)
-    /* Windows? */
-    unsigned long flags;
-    flags = nonblock;
-
-    return ioctlsocket(sockfd, FIONBIO, &flags);
-#undef SETBLOCK
-#define SETBLOCK 3
-#endif
-
-#if defined(HAVE_IOCTLSOCKET_CASE) && (SETBLOCK == 0)
+#elif defined(HAVE_IOCTLSOCKET_CASE)
     /* presumably for Amiga */
     return IoctlSocket(sockfd, FIONBIO, (long) nonblock);
-#undef SETBLOCK
-#define SETBLOCK 4
-#endif
-
-#if defined(HAVE_SO_NONBLOCK) && (SETBLOCK == 0)
+#elif defined(HAVE_SO_NONBLOCK)
     /* BeOS */
     long b = nonblock ? 1 : 0;
     return setsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
-#undef SETBLOCK
-#define SETBLOCK 5
-#endif
+#elif defined(_WIN32)
+    unsigned long flags;
 
-#ifdef HAVE_DISABLED_NONBLOCKING
+    flags = nonblock;
+    return ioctlsocket(sockfd, FIONBIO, &flags);
+#else
+    (void)sockfd;
+    (void)nonblock;
     return 0;                   /* returns success */
-#undef SETBLOCK
-#define SETBLOCK 6
-#endif
-
-#if(SETBLOCK == 0)
-#error "no non-blocking method was found/used/set"
 #endif
 }
 
 /*
- * get_socket_nonblocking()
+ * get_socket_nonblocking
  *
  * gets the given blocking or non-blocking state of the socket.
  */
 static int
-get_socket_nonblocking(int sockfd)
+get_socket_nonblocking(libssh2_socket_t sockfd)
 {                               /* operate on this */
-#undef GETBLOCK
-#define GETBLOCK 0
 #ifdef HAVE_O_NONBLOCK
     /* most recent unix versions */
     int flags = fcntl(sockfd, F_GETFL, 0);
@@ -356,26 +343,7 @@ get_socket_nonblocking(int sockfd)
         return 1;
     }
     return (flags & O_NONBLOCK);
-#undef GETBLOCK
-#define GETBLOCK 1
-#endif
-
-#if defined(WSAEWOULDBLOCK) && (GETBLOCK == 0)
-    /* Windows? */
-    unsigned int option_value;
-    socklen_t option_len = sizeof(option_value);
-
-    if(getsockopt
-        (sockfd, SOL_SOCKET, SO_ERROR, (void *) &option_value, &option_len)) {
-        /* Assume blocking on error */
-        return 1;
-    }
-    return (int) option_value;
-#undef GETBLOCK
-#define GETBLOCK 2
-#endif
-
-#if defined(HAVE_SO_NONBLOCK) && (GETBLOCK == 0)
+#elif defined(HAVE_SO_NONBLOCK)
     /* BeOS */
     long b;
     if(getsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b))) {
@@ -383,12 +351,7 @@ get_socket_nonblocking(int sockfd)
         return 1;
     }
     return (int) b;
-#undef GETBLOCK
-#define GETBLOCK 5
-#endif
-
-#if defined(SO_STATE) && defined(__VMS) && (GETBLOCK == 0)
-
+#elif defined(SO_STATE) && defined(__VMS)
     /* VMS TCP/IP Services */
 
     size_t sockstat = 0;
@@ -396,23 +359,27 @@ get_socket_nonblocking(int sockfd)
     size_t size = sizeof(int);
 
     callstat = getsockopt(sockfd, SOL_SOCKET, SO_STATE,
-                                  (char *)&sockstat, &size);
-    if(callstat == -1) return 0;
-    if((sockstat&SS_NBIO) != 0) return 1;
+                          (char *)&sockstat, &size);
+    if(callstat == -1) {
+        return 0;
+    }
+    if((sockstat&SS_NBIO) != 0) {
+        return 1;
+    }
     return 0;
+#elif defined(_WIN32)
+    unsigned int option_value;
+    socklen_t option_len = sizeof(option_value);
 
-#undef GETBLOCK
-#define GETBLOCK 6
-#endif
-
-#ifdef HAVE_DISABLED_NONBLOCKING
+    if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR,
+                  (void *) &option_value, &option_len)) {
+        /* Assume blocking on error */
+        return 1;
+    }
+    return (int) option_value;
+#else
+    (void)sockfd;
     return 1;                   /* returns blocking */
-#undef GETBLOCK
-#define GETBLOCK 7
-#endif
-
-#if(GETBLOCK == 0)
-#error "no non-blocking method was found/used/get"
 #endif
 }
 
@@ -442,8 +409,8 @@ libssh2_session_banner_set(LIBSSH2_SESSION * session, const char *banner)
 
     /* first zero terminate like this so that the debug output is nice */
     session->local.banner[banner_len] = '\0';
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting local Banner: %s",
-                   session->local.banner);
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS, "Setting local Banner: %s",
+                   session->local.banner));
     session->local.banner[banner_len++] = '\r';
     session->local.banner[banner_len++] = '\n';
     session->local.banner[banner_len] = '\0';
@@ -451,6 +418,7 @@ libssh2_session_banner_set(LIBSSH2_SESSION * session, const char *banner)
     return 0;
 }
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /* libssh2_banner_set
  * Set the local banner. DEPRECATED VERSION
  */
@@ -459,6 +427,7 @@ libssh2_banner_set(LIBSSH2_SESSION * session, const char *banner)
 {
     return libssh2_session_banner_set(session, banner);
 }
+#endif
 
 /*
  * libssh2_session_init_ex
@@ -500,75 +469,124 @@ libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
         session->abstract = abstract;
         session->api_timeout = 0; /* timeout-free API by default */
         session->api_block_mode = 1; /* blocking API by default */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "New session resource allocated");
+        session->state = LIBSSH2_STATE_INITIAL_KEX;
+        session->fullpacket_required_type = 0;
+        session->packet_read_timeout = LIBSSH2_DEFAULT_READ_TIMEOUT;
+        session->flag.quote_paths = 1; /* default behavior is to quote paths
+                                          for the scp subsystem */
+        session->kex = NULL;
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "New session resource allocated"));
         _libssh2_init_if_needed();
     }
     return session;
 }
 
 /*
- * libssh2_session_callback_set
+ * libssh2_session_callback_set2
  *
  * Set (or reset) a callback function
  * Returns the prior address
- *
- * ALERT: this function relies on that we can typecast function pointers
- * to void pointers, which isn't allowed in ISO C!
  */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-LIBSSH2_API void *
-libssh2_session_callback_set(LIBSSH2_SESSION * session,
-                             int cbtype, void *callback)
+LIBSSH2_API libssh2_cb_generic *
+libssh2_session_callback_set2(LIBSSH2_SESSION *session, int cbtype,
+                              libssh2_cb_generic *callback)
 {
-    void *oldcb;
+    libssh2_cb_generic *oldcb;
 
     switch(cbtype) {
     case LIBSSH2_CALLBACK_IGNORE:
-        oldcb = session->ssh_msg_ignore;
-        session->ssh_msg_ignore = callback;
+        oldcb = (libssh2_cb_generic *)session->ssh_msg_ignore;
+        session->ssh_msg_ignore = (LIBSSH2_IGNORE_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_DEBUG:
-        oldcb = session->ssh_msg_debug;
-        session->ssh_msg_debug = callback;
+        oldcb = (libssh2_cb_generic *)session->ssh_msg_debug;
+        session->ssh_msg_debug = (LIBSSH2_DEBUG_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_DISCONNECT:
-        oldcb = session->ssh_msg_disconnect;
-        session->ssh_msg_disconnect = callback;
+        oldcb = (libssh2_cb_generic *)session->ssh_msg_disconnect;
+        session->ssh_msg_disconnect = (LIBSSH2_DISCONNECT_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_MACERROR:
-        oldcb = session->macerror;
-        session->macerror = callback;
+        oldcb = (libssh2_cb_generic *)session->macerror;
+        session->macerror = (LIBSSH2_MACERROR_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_X11:
-        oldcb = session->x11;
-        session->x11 = callback;
+        oldcb = (libssh2_cb_generic *)session->x11;
+        session->x11 = (LIBSSH2_X11_OPEN_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_SEND:
-        oldcb = session->send;
-        session->send = callback;
+        oldcb = (libssh2_cb_generic *)session->send;
+        session->send = (LIBSSH2_SEND_FUNC((*)))callback;
         return oldcb;
 
     case LIBSSH2_CALLBACK_RECV:
-        oldcb = session->recv;
-        session->recv = callback;
+        oldcb = (libssh2_cb_generic *)session->recv;
+        session->recv = (LIBSSH2_RECV_FUNC((*)))callback;
+        return oldcb;
+
+    case LIBSSH2_CALLBACK_AUTHAGENT:
+        oldcb = (libssh2_cb_generic *)session->authagent;
+        session->authagent = (LIBSSH2_AUTHAGENT_FUNC((*)))callback;
+        return oldcb;
+
+    case LIBSSH2_CALLBACK_AUTHAGENT_IDENTITIES:
+        oldcb = (libssh2_cb_generic *)session->addLocalIdentities;
+        session->addLocalIdentities =
+            (LIBSSH2_ADD_IDENTITIES_FUNC((*)))callback;
+        return oldcb;
+
+    case LIBSSH2_CALLBACK_AUTHAGENT_SIGN:
+        oldcb = (libssh2_cb_generic *)session->agentSignCallback;
+        session->agentSignCallback =
+            (LIBSSH2_AUTHAGENT_SIGN_FUNC((*)))callback;
         return oldcb;
     }
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Setting Callback %d",
-                   cbtype);
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS, "Setting Callback %d",
+                   cbtype));
 
     return NULL;
 }
+
+/*
+ * libssh2_session_callback_set (DEPRECATED, DO NOT USE!)
+ *
+ * Set (or reset) a callback function
+ * Returns the prior address
+ *
+ * ALERT: this function relies on that we can typecast function pointers
+ * to void pointers, which isn't allowed in ISO C!
+ */
+#ifdef _MSC_VER
+#pragma warning(push)
+/* 'type cast': from data pointer to function pointer */
+#pragma warning(disable:4054)
+/* 'type cast': from function pointer to data pointer */
+#pragma warning(disable:4055)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+LIBSSH2_API void *
+libssh2_session_callback_set(LIBSSH2_SESSION * session,
+                             int cbtype, void *callback)
+{
+    return (void *)libssh2_session_callback_set2(session, cbtype,
+                                               (libssh2_cb_generic *)callback);
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#else
 #pragma GCC diagnostic pop
+#endif
 
 /*
- * _libssh2_wait_socket()
+ * _libssh2_wait_socket
  *
  * Utility function that waits for action on the socket. Returns 0 when ready
  * to run again or error on timeout.
@@ -598,8 +616,8 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
     dir = libssh2_session_block_directions(session);
 
     if(!dir) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Nothing to wait for in wait_socket");
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Nothing to wait for in wait_socket"));
         /* To avoid that we hang below just because there's nothing set to
            wait for, we timeout on 1 second to also avoid busy-looping
            during this condition */
@@ -638,7 +656,7 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
         if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
             sockets[0].events |= POLLOUT;
 
-        rc = poll(sockets, 1, has_timeout?ms_to_next: -1);
+        rc = poll(sockets, 1, has_timeout ? (int)ms_to_next : -1);
     }
 #else
     {
@@ -649,21 +667,39 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
         struct timeval tv;
 
         tv.tv_sec = ms_to_next / 1000;
+#ifdef libssh2_usec_t
+        tv.tv_usec = (libssh2_usec_t)((ms_to_next - tv.tv_sec*1000) * 1000);
+#else
         tv.tv_usec = (ms_to_next - tv.tv_sec*1000) * 1000;
+#endif
 
         if(dir & LIBSSH2_SESSION_BLOCK_INBOUND) {
             FD_ZERO(&rfd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
             FD_SET(session->socket_fd, &rfd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
             readfd = &rfd;
         }
 
         if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
             FD_ZERO(&wfd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
             FD_SET(session->socket_fd, &wfd);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
             writefd = &wfd;
         }
 
-        rc = select(session->socket_fd + 1, readfd, writefd, NULL,
+        rc = select((int)(session->socket_fd + 1), readfd, writefd, NULL,
                     has_timeout ? &tv : NULL);
     }
 #endif
@@ -672,6 +708,18 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t start_time)
                               "Timed out waiting on socket");
     }
     if(rc < 0) {
+        int err;
+#ifdef _WIN32
+        err = _libssh2_wsa2errno();
+#else
+        err = errno;
+#endif
+        /* Profiling tools that use SIGPROF can cause EINTR responses.
+           poll() / select() do not set any descriptor states on EINTR,
+           but some fds may be ready, so the caller should try again */
+        if(err == EINTR)
+            return 0;
+
         return _libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
                               "Error waiting on socket");
     }
@@ -685,8 +733,8 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
     int rc;
 
     if(session->startup_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "session_startup for socket %d", sock);
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "session_startup for socket %ld", (long)sock));
         if(LIBSSH2_INVALID_SOCKET == sock) {
             /* Did we forget something? */
             return _libssh2_error(session, LIBSSH2_ERROR_BAD_SOCKET,
@@ -730,7 +778,7 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
             else if(rc)
                 return _libssh2_error(session, rc,
                                       "Failed getting banner");
-        } while(strncmp("SSH-", (char *)session->remote.banner, 4));
+        } while(strncmp("SSH-", (const char *)session->remote.banner, 4));
 
         session->startup_state = libssh2_NB_state_sent1;
     }
@@ -747,8 +795,8 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
     }
 
     if(session->startup_state == libssh2_NB_state_sent2) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Requesting userauth service");
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "Requesting userauth service"));
 
         /* Request the userauth service */
         session->startup_service[0] = SSH_MSG_SERVICE_REQUEST;
@@ -780,7 +828,9 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
                                      &session->startup_data_len, 0, NULL, 0,
                                      &session->startup_req_state);
         if(rc)
-            return rc;
+            return _libssh2_error(session, rc,
+                                  "Failed to get response to "
+                                  "ssh-userauth request");
 
         if(session->startup_data_len < 5) {
             return _libssh2_error(session, LIBSSH2_ERROR_PROTO,
@@ -792,7 +842,8 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
 
 
         if((session->startup_service_length != (sizeof("ssh-userauth") - 1))
-            || strncmp("ssh-userauth", (char *) session->startup_data + 5,
+            || strncmp("ssh-userauth",
+                       (const char *) session->startup_data + 5,
                        session->startup_service_length)) {
             LIBSSH2_FREE(session, session->startup_data);
             session->startup_data = NULL;
@@ -812,7 +863,7 @@ session_startup(LIBSSH2_SESSION *session, libssh2_socket_t sock)
 }
 
 /*
- * libssh2_session_handshake()
+ * libssh2_session_handshake
  *
  * session: LIBSSH2_SESSION struct allocated and owned by the calling program
  * sock:    *must* be populated with an opened and connected socket.
@@ -824,13 +875,14 @@ libssh2_session_handshake(LIBSSH2_SESSION *session, libssh2_socket_t sock)
 {
     int rc;
 
-    BLOCK_ADJUST(rc, session, session_startup(session, sock) );
+    BLOCK_ADJUST(rc, session, session_startup(session, sock));
 
     return rc;
 }
 
+#ifndef LIBSSH2_NO_DEPRECATED
 /*
- * libssh2_session_startup()
+ * libssh2_session_startup
  *
  * DEPRECATED. Use libssh2_session_handshake() instead! This function is not
  * portable enough.
@@ -845,9 +897,10 @@ libssh2_session_startup(LIBSSH2_SESSION *session, int sock)
 {
     return libssh2_session_handshake(session, (libssh2_socket_t) sock);
 }
+#endif
 
 /*
- * libssh2_session_free
+ * session_free
  *
  * Frees the memory allocated to the session
  * Also closes and frees any channels attached to this session
@@ -862,16 +915,16 @@ session_free(LIBSSH2_SESSION *session)
     int packets_left = 0;
 
     if(session->free_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-                       "Freeing session resource",
-                       session->remote.banner);
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "Freeing session resource %p",
+                       (void *)session->remote.banner));
 
         session->free_state = libssh2_NB_state_created;
     }
 
     if(session->free_state == libssh2_NB_state_created) {
-        while((ch = _libssh2_list_first(&session->channels))) {
-
+        /* !checksrc! disable EQUALSNULL 1 */
+        while((ch = _libssh2_list_first(&session->channels)) != NULL) {
             rc = _libssh2_channel_free(ch);
             if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
@@ -881,7 +934,8 @@ session_free(LIBSSH2_SESSION *session)
     }
 
     if(session->free_state == libssh2_NB_state_sent) {
-        while((l = _libssh2_list_first(&session->listeners))) {
+        /* !checksrc! disable EQUALSNULL 1 */
+        while((l = _libssh2_list_first(&session->listeners)) != NULL) {
             rc = _libssh2_channel_forward_cancel(l);
             if(rc == LIBSSH2_ERROR_EAGAIN)
                 return rc;
@@ -890,6 +944,11 @@ session_free(LIBSSH2_SESSION *session)
         session->free_state = libssh2_NB_state_sent1;
     }
 
+    if(session->kex && session->kex->cleanup) {
+        session->kex->cleanup(session,
+                              &session->startup_key_state.key_state_low);
+    }
+
     if(session->state & LIBSSH2_STATE_NEWKEYS) {
         /* hostkey */
         if(session->hostkey && session->hostkey->dtor) {
@@ -981,6 +1040,12 @@ session_free(LIBSSH2_SESSION *session)
     if(session->remote.lang_prefs) {
         LIBSSH2_FREE(session, session->remote.lang_prefs);
     }
+    if(session->server_sign_algorithms) {
+        LIBSSH2_FREE(session, session->server_sign_algorithms);
+    }
+    if(session->sign_algo_prefs) {
+        LIBSSH2_FREE(session, session->sign_algo_prefs);
+    }
 
     /*
      * Make sure all memory used in the state variables are free
@@ -994,6 +1059,9 @@ session_free(LIBSSH2_SESSION *session)
     if(session->userauth_list_data) {
         LIBSSH2_FREE(session, session->userauth_list_data);
     }
+    if(session->userauth_banner) {
+        LIBSSH2_FREE(session, session->userauth_banner);
+    }
     if(session->userauth_pswd_data) {
         LIBSSH2_FREE(session, session->userauth_pswd_data);
     }
@@ -1058,10 +1126,11 @@ session_free(LIBSSH2_SESSION *session)
     }
 
     /* Cleanup all remaining packets */
-    while((pkg = _libssh2_list_first(&session->packets))) {
+    /* !checksrc! disable EQUALSNULL 1 */
+    while((pkg = _libssh2_list_first(&session->packets)) != NULL) {
         packets_left++;
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-            "packet left with id %d", pkg->data[0]);
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                       "packet left with id %d", pkg->data[0]));
         /* unlink the node */
         _libssh2_list_remove(&pkg->node);
 
@@ -1069,15 +1138,16 @@ session_free(LIBSSH2_SESSION *session)
         LIBSSH2_FREE(session, pkg->data);
         LIBSSH2_FREE(session, pkg);
     }
-    _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-         "Extra packets left %d", packets_left);
+    (void)packets_left;
+    _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                   "Extra packets left %d", packets_left));
 
     if(session->socket_prev_blockstate) {
         /* if the socket was previously blocking, put it back so */
         rc = session_nonblock(session->socket_fd, 0);
         if(rc) {
-            _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
-             "unable to reset socket's blocking state");
+            _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
+                           "unable to reset socket's blocking state"));
         }
     }
 
@@ -1107,13 +1177,13 @@ libssh2_session_free(LIBSSH2_SESSION * session)
 {
     int rc;
 
-    BLOCK_ADJUST(rc, session, session_free(session) );
+    BLOCK_ADJUST(rc, session, session_free(session));
 
     return rc;
 }
 
 /*
- * libssh2_session_disconnect_ex
+ * session_disconnect
  */
 static int
 session_disconnect(LIBSSH2_SESSION *session, int reason,
@@ -1121,13 +1191,13 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
                    const char *lang)
 {
     unsigned char *s;
-    unsigned long descr_len = 0, lang_len = 0;
+    size_t descr_len = 0, lang_len = 0;
     int rc;
 
     if(session->disconnect_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS,
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS,
                        "Disconnecting: reason=%d, desc=%s, lang=%s", reason,
-                       description, lang);
+                       description, lang));
         if(description)
             descr_len = strlen(description);
 
@@ -1138,6 +1208,10 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
             return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                                   "too long description");
 
+        if(lang_len > 256)
+            return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
+                                  "too long language string");
+
         /* 13 = packet_type(1) + reason code(4) + descr_len(4) + lang_len(4) */
         session->disconnect_data_len = descr_len + lang_len + 13;
 
@@ -1147,14 +1221,14 @@ session_disconnect(LIBSSH2_SESSION *session, int reason,
         _libssh2_store_u32(&s, reason);
         _libssh2_store_str(&s, description, descr_len);
         /* store length only, lang is sent separately */
-        _libssh2_store_u32(&s, lang_len);
+        _libssh2_store_u32(&s, (uint32_t)lang_len);
 
         session->disconnect_state = libssh2_NB_state_created;
     }
 
     rc = _libssh2_transport_send(session, session->disconnect_data,
                                  session->disconnect_data_len,
-                                 (unsigned char *)lang, lang_len);
+                                 (const unsigned char *)lang, lang_len);
     if(rc == LIBSSH2_ERROR_EAGAIN)
         return rc;
 
@@ -1171,6 +1245,7 @@ libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason,
                               const char *desc, const char *lang)
 {
     int rc;
+    session->state &= ~LIBSSH2_STATE_INITIAL_KEX;
     session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
     BLOCK_ADJUST(rc, session,
                  session_disconnect(session, reason, desc, lang));
@@ -1303,7 +1378,7 @@ libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg,
     }
 
     if(errmsg_len) {
-        *errmsg_len = msglen;
+        *errmsg_len = (int)msglen;
     }
 
     return session->err_code;
@@ -1336,7 +1411,7 @@ libssh2_session_set_last_error(LIBSSH2_SESSION* session,
                                 LIBSSH2_ERR_FLAG_DUP);
 }
 
-/* Libssh2_session_flag
+/* libssh2_session_flag
  *
  * Set/Get session flags
  *
@@ -1352,6 +1427,9 @@ libssh2_session_flag(LIBSSH2_SESSION * session, int flag, int value)
     case LIBSSH2_FLAG_COMPRESS:
         session->flag.compress = value;
         break;
+    case LIBSSH2_FLAG_QUOTE_PATHS:
+        session->flag.quote_paths = value;
+        break;
     default:
         /* unknown flag */
         return LIBSSH2_ERROR_INVAL;
@@ -1370,8 +1448,8 @@ int
 _libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking)
 {
     int bl = session->api_block_mode;
-    _libssh2_debug(session, LIBSSH2_TRACE_CONN,
-                   "Setting blocking mode %s", blocking?"ON":"OFF");
+    _libssh2_debug((session, LIBSSH2_TRACE_CONN,
+                   "Setting blocking mode %s", blocking ? "ON" : "OFF"));
     session->api_block_mode = blocking;
 
     return bl;
@@ -1385,7 +1463,7 @@ _libssh2_session_set_blocking(LIBSSH2_SESSION *session, int blocking)
 LIBSSH2_API void
 libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking)
 {
-    (void) _libssh2_session_set_blocking(session, blocking);
+    (void)_libssh2_session_set_blocking(session, blocking);
 }
 
 /* libssh2_session_get_blocking
@@ -1420,6 +1498,30 @@ libssh2_session_get_timeout(LIBSSH2_SESSION * session)
     return session->api_timeout;
 }
 
+/* libssh2_session_set_read_timeout
+ *
+ * Set a session's timeout (in sec) when reading packets,
+ * or 0 to use default of 60 seconds.
+ */
+LIBSSH2_API void
+libssh2_session_set_read_timeout(LIBSSH2_SESSION * session, long timeout)
+{
+    if(timeout <= 0) {
+        timeout = LIBSSH2_DEFAULT_READ_TIMEOUT;
+    }
+    session->packet_read_timeout = timeout;
+}
+
+/* libssh2_session_get_read_timeout
+ *
+ * Returns a session's timeout. Default is 60 seconds.
+ */
+LIBSSH2_API long
+libssh2_session_get_read_timeout(LIBSSH2_SESSION * session)
+{
+    return session->packet_read_timeout;
+}
+
 /*
  * libssh2_poll_channel_read
  *
@@ -1513,7 +1615,7 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         switch(fds[i].type) {
         case LIBSSH2_POLLFD_SOCKET:
             sockets[i].fd = fds[i].fd.socket;
-            sockets[i].events = fds[i].events;
+            sockets[i].events = (short)fds[i].events;
             sockets[i].revents = 0;
             break;
 
@@ -1553,19 +1655,40 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         switch(fds[i].type) {
         case LIBSSH2_POLLFD_SOCKET:
             if(fds[i].events & LIBSSH2_POLLFD_POLLIN) {
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
                 FD_SET(fds[i].fd.socket, &rfds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
                 if(fds[i].fd.socket > maxfd)
                     maxfd = fds[i].fd.socket;
             }
             if(fds[i].events & LIBSSH2_POLLFD_POLLOUT) {
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
                 FD_SET(fds[i].fd.socket, &wfds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
                 if(fds[i].fd.socket > maxfd)
                     maxfd = fds[i].fd.socket;
             }
             break;
 
         case LIBSSH2_POLLFD_CHANNEL:
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
             FD_SET(fds[i].fd.channel->session->socket_fd, &rfds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
             if(fds[i].fd.channel->session->socket_fd > maxfd)
                 maxfd = fds[i].fd.channel->session->socket_fd;
             if(!session)
@@ -1573,7 +1696,14 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
             break;
 
         case LIBSSH2_POLLFD_LISTENER:
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
             FD_SET(fds[i].fd.listener->session->socket_fd, &rfds);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
             if(fds[i].fd.listener->session->socket_fd > maxfd)
                 maxfd = fds[i].fd.listener->session->socket_fd;
             if(!session)
@@ -1675,23 +1805,15 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         }
 #ifdef HAVE_POLL
 
-#ifdef HAVE_LIBSSH2_GETTIMEOFDAY
         {
             struct timeval tv_begin, tv_end;
 
-            _libssh2_gettimeofday((struct timeval *) &tv_begin, NULL);
-            sysret = poll(sockets, nfds, timeout_remaining);
-            _libssh2_gettimeofday((struct timeval *) &tv_end, NULL);
+            gettimeofday(&tv_begin, NULL);
+            sysret = poll(sockets, nfds, (int)timeout_remaining);
+            gettimeofday(&tv_end, NULL);
             timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
             timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
         }
-#else
-        /* If the platform doesn't support gettimeofday,
-         * then just make the call non-blocking and walk away
-         */
-        sysret = poll(sockets, nfds, timeout_remaining);
-        timeout_remaining = 0;
-#endif /* HAVE_GETTIMEOFDAY */
 
         if(sysret > 0) {
             for(i = 0; i < nfds; i++) {
@@ -1737,30 +1859,31 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
         }
 #elif defined(HAVE_SELECT)
         tv.tv_sec = timeout_remaining / 1000;
+#ifdef libssh2_usec_t
+        tv.tv_usec = (libssh2_usec_t)((timeout_remaining % 1000) * 1000);
+#else
         tv.tv_usec = (timeout_remaining % 1000) * 1000;
-#ifdef HAVE_LIBSSH2_GETTIMEOFDAY
+#endif
+
         {
             struct timeval tv_begin, tv_end;
 
-            _libssh2_gettimeofday((struct timeval *) &tv_begin, NULL);
-            sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
-            _libssh2_gettimeofday((struct timeval *) &tv_end, NULL);
+            gettimeofday(&tv_begin, NULL);
+            sysret = select((int)(maxfd + 1), &rfds, &wfds, NULL, &tv);
+            gettimeofday(&tv_end, NULL);
 
             timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
             timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
         }
-#else
-        /* If the platform doesn't support gettimeofday,
-         * then just make the call non-blocking and walk away
-         */
-        sysret = select(maxfd + 1, &rfds, &wfds, NULL, &tv);
-        timeout_remaining = 0;
-#endif
 
         if(sysret > 0) {
             for(i = 0; i < nfds; i++) {
                 switch(fds[i].type) {
                 case LIBSSH2_POLLFD_SOCKET:
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
                     if(FD_ISSET(fds[i].fd.socket, &rfds)) {
                         fds[i].revents |= LIBSSH2_POLLFD_POLLIN;
                     }
@@ -1770,6 +1893,9 @@ libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
                     if(fds[i].revents) {
                         active_fds++;
                     }
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
                     break;
 
                 case LIBSSH2_POLLFD_CHANNEL:
@@ -1822,10 +1948,10 @@ LIBSSH2_API const char *
 libssh2_session_banner_get(LIBSSH2_SESSION *session)
 {
     /* to avoid a coredump when session is NULL */
-    if(NULL == session)
+    if(!session)
         return NULL;
 
-    if(NULL == session->remote.banner)
+    if(!session->remote.banner)
         return NULL;
 
     return (const char *) session->remote.banner;
diff --git a/libssh2/src/session.h b/libssh2/src/session.h
index 9f8f2c70..d4fc5755 100644
--- a/libssh2/src/session.h
+++ b/libssh2/src/session.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_SESSION_H
-#define __LIBSSH2_SESSION_H
-/* Copyright (c) 2004-2007 Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2010 by Daniel Stenberg
- * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
+#ifndef LIBSSH2_SESSION_H
+#define LIBSSH2_SESSION_H
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
+ * Copyright (C) Simon Josefsson <simon@josefsson.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -37,31 +37,32 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /* Conveniance-macros to allow code like this;
 
-   int rc = BLOCK_ADJUST(rc, session, session_startup(session, sock) );
+   int rc = BLOCK_ADJUST(rc, session, session_startup(session, sock));
 
-   int rc = BLOCK_ADJUST_ERRNO(ptr, session, session_startup(session, sock) );
+   int rc = BLOCK_ADJUST_ERRNO(ptr, session, session_startup(session, sock));
 
-   The point of course being to make sure that while in non-blocking mode
-   these always return no matter what the return code is, but in blocking mode
-   it blocks if EAGAIN is the reason for the return from the underlying
-   function.
+   The point being to make sure that while in non-blocking mode these always
+   return no matter what the return code is, but in blocking mode it blocks
+   if EAGAIN is the reason for the return from the underlying function.
 
 */
 #define BLOCK_ADJUST(rc, sess, x) \
     do { \
-       time_t entry_time = time(NULL); \
-       do { \
-          rc = x; \
-          /* the order of the check below is important to properly deal with \
-             the case when the 'sess' is freed */ \
-          if((rc != LIBSSH2_ERROR_EAGAIN) || !sess->api_block_mode) \
-              break; \
-          rc = _libssh2_wait_socket(sess, entry_time);  \
-       } while(!rc);   \
+        time_t entry_time = time(NULL); \
+        do { \
+            rc = x; \
+            /* the order of the check below is important to properly \
+               deal with the case when the 'sess' is freed */ \
+            if((rc != LIBSSH2_ERROR_EAGAIN) || !sess->api_block_mode) \
+                break; \
+            rc = _libssh2_wait_socket(sess, entry_time);  \
+        } while(!rc);   \
     } while(0)
 
 /*
@@ -72,15 +73,15 @@
  */
 #define BLOCK_ADJUST_ERRNO(ptr, sess, x) \
     do { \
-       time_t entry_time = time(NULL); \
-       int rc; \
-       do { \
-           ptr = x; \
-           if(!sess->api_block_mode || \
-              (ptr != NULL) || \
-              (libssh2_session_last_errno(sess) != LIBSSH2_ERROR_EAGAIN) ) \
-               break; \
-           rc = _libssh2_wait_socket(sess, entry_time); \
+        time_t entry_time = time(NULL); \
+        int rc; \
+        do { \
+            ptr = x; \
+            if(!sess->api_block_mode || \
+               (ptr != NULL) || \
+               (libssh2_session_last_errno(sess) != LIBSSH2_ERROR_EAGAIN)) \
+                break; \
+            rc = _libssh2_wait_socket(sess, entry_time); \
         } while(!rc); \
     } while(0)
 
@@ -90,4 +91,4 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session, time_t entry_time);
 /* this is the lib-internal set blocking function */
 int _libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking);
 
-#endif /* __LIBSSH2_SESSION_H */
+#endif /* LIBSSH2_SESSION_H */
diff --git a/libssh2/src/sftp.c b/libssh2/src/sftp.c
index ac7ee016..6ede3111 100644
--- a/libssh2/src/sftp.c
+++ b/libssh2/src/sftp.c
@@ -1,6 +1,6 @@
-/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2007 Eli Fant <elifantu@mail.ru>
- * Copyright (c) 2009-2019 by Daniel Stenberg
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Eli Fant <elifantu@mail.ru>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,21 +35,26 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include <assert.h>
-
 #include "libssh2_priv.h"
 #include "libssh2_sftp.h"
+
 #include "channel.h"
 #include "session.h"
 #include "sftp.h"
 
-/* Note: Version 6 was documented at the time of writing
- * However it was marked as "DO NOT IMPLEMENT" due to pending changes
- *
- * This release of libssh2 implements Version 5 with automatic downgrade
+#include <assert.h>
+#include <stdlib.h>  /* strtol() */
+
+/* This release of libssh2 implements Version 5 with automatic downgrade
  * based on server's declaration
+ *   https://www.ietf.org/archive/id/draft-ietf-secsh-filexfer-05.txt
+ *
+ * Version 6:
+ *   https://www.ietf.org/archive/id/draft-ietf-secsh-filexfer-13.txt
  */
 
 /* SFTP packet types */
@@ -98,39 +103,6 @@ static int sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,
                            size_t *data_len);
 static void sftp_packet_flush(LIBSSH2_SFTP *sftp);
 
-/* sftp_attrsize
- * Size that attr with this flagset will occupy when turned into a bin struct
- */
-static int sftp_attrsize(unsigned long flags)
-{
-    return (4 +                                 /* flags(4) */
-            ((flags & LIBSSH2_SFTP_ATTR_SIZE) ? 8 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_UIDGID) ? 8 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) ? 4 : 0) +
-            ((flags & LIBSSH2_SFTP_ATTR_ACMODTIME) ? 8 : 0));
-    /* atime + mtime as u32 */
-}
-
-/* _libssh2_store_u64
- */
-static void _libssh2_store_u64(unsigned char **ptr, libssh2_uint64_t value)
-{
-    uint32_t msl = (uint32_t)(value >> 32);
-    unsigned char *buf = *ptr;
-
-    buf[0] = (unsigned char)((msl >> 24) & 0xFF);
-    buf[1] = (unsigned char)((msl >> 16) & 0xFF);
-    buf[2] = (unsigned char)((msl >> 8)  & 0xFF);
-    buf[3] = (unsigned char)( msl        & 0xFF);
-
-    buf[4] = (unsigned char)((value >> 24) & 0xFF);
-    buf[5] = (unsigned char)((value >> 16) & 0xFF);
-    buf[6] = (unsigned char)((value >> 8)  & 0xFF);
-    buf[7] = (unsigned char)( value        & 0xFF);
-
-    *ptr += 8;
-}
-
 /*
  * Search list of zombied FXP_READ request IDs.
  *
@@ -160,10 +132,10 @@ remove_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
     struct sftp_zombie_requests *zombie = find_zombie_request(sftp,
                                                               request_id);
     if(zombie) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Removing request ID %ld from the list of "
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Removing request ID %u from the list of "
                        "zombie requests",
-                       request_id);
+                       request_id));
 
         _libssh2_list_remove(&zombie->node);
         LIBSSH2_FREE(session, zombie);
@@ -177,14 +149,14 @@ add_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
 
     struct sftp_zombie_requests *zombie;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Marking request ID %ld as a zombie request", request_id);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                   "Marking request ID %u as a zombie request", request_id));
 
     zombie = LIBSSH2_ALLOC(sftp->channel->session,
                            sizeof(struct sftp_zombie_requests));
     if(!zombie)
         return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                              "malloc fail for zombie request  ID");
+                              "malloc fail for zombie request ID");
     else {
         zombie->request_id = request_id;
         _libssh2_list_add(&sftp->zombie_requests, &zombie->node);
@@ -192,9 +164,7 @@ add_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)
     }
 }
 
-/*
- * sftp_packet_add
- *
+/* sftp_packet_add
  * Add a packet to the SFTP packet brigade
  */
 static int
@@ -209,9 +179,9 @@ sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
         return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
     }
 
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Received packet type %d (len %d)",
-                   (int) data[0], data_len);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                   "Received packet type %u (len %lu)",
+                   (unsigned int)data[0], (unsigned long)data_len));
 
     /*
      * Experience shows that if we mess up EAGAIN handling somewhere or
@@ -250,14 +220,15 @@ sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
     case SSH_FXP_EXTENDED_REPLY:
         break;
     default:
+        sftp->last_errno = LIBSSH2_FX_OK;
         return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                               "Out of sync with the world");
     }
 
     request_id = _libssh2_ntohu32(&data[1]);
 
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Received packet id %d",
-                   request_id);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Received packet id %d",
+                   request_id));
 
     /* Don't add the packet if it answers a request we've given up on. */
     if((data[0] == SSH_FXP_STATUS || data[0] == SSH_FXP_DATA)
@@ -287,9 +258,7 @@ sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,
     return LIBSSH2_ERROR_NONE;
 }
 
-/*
- * sftp_packet_read
- *
+/* sftp_packet_read
  * Frame an SFTP packet off the channel
  */
 static int
@@ -301,8 +270,9 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
     ssize_t rc;
     unsigned long recv_window;
     int packet_type;
+    uint32_t request_id;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "recv packet");
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "recv packet"));
 
     switch(sftp->packet_state) {
     case libssh2_NB_state_sent: /* EAGAIN from window adjusting */
@@ -316,12 +286,12 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
 
         packet = sftp->partial_packet;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "partial read cont, len: %lu", sftp->partial_len);
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "partial read cont, len: %u", sftp->partial_len));
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
                        "partial read cont, already recvd: %lu",
-                       sftp->partial_received);
-        /* fall-through */
+                       (unsigned long)sftp->partial_received));
+        LIBSSH2_FALLTHROUGH();
     default:
         if(!packet) {
             /* only do this if there's not already a packet buffer allocated
@@ -329,49 +299,59 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
 
             /* each packet starts with a 32 bit length field */
             rc = _libssh2_channel_read(channel, 0,
-                                       (char *)&sftp->partial_size[
-                                           sftp->partial_size_len],
-                                       4 - sftp->partial_size_len);
+                                       (char *)&sftp->packet_header[
+                                           sftp->packet_header_len],
+                                       sizeof(sftp->packet_header) -
+                                       sftp->packet_header_len);
             if(rc == LIBSSH2_ERROR_EAGAIN)
-                return rc;
+                return (int)rc;
             else if(rc < 0)
-                return _libssh2_error(session, rc, "channel read");
+                return _libssh2_error(session, (int)rc, "channel read");
 
-            sftp->partial_size_len += rc;
+            sftp->packet_header_len += rc;
 
-            if(4 != sftp->partial_size_len)
-                /* we got a short read for the length part */
+            if(sftp->packet_header_len != sizeof(sftp->packet_header))
+                /* we got a short read for the header part */
                 return LIBSSH2_ERROR_EAGAIN;
 
-            sftp->partial_len = _libssh2_ntohu32(sftp->partial_size);
+            /* parse SFTP packet header */
+            sftp->partial_len = _libssh2_ntohu32(sftp->packet_header);
+            packet_type = sftp->packet_header[4];
+            request_id = _libssh2_ntohu32(sftp->packet_header + 5);
+
             /* make sure we don't proceed if the packet size is unreasonably
                large */
-            if(sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN) {
+            if(sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN &&
+               /* exception: response to SSH_FXP_READDIR request */
+               !(sftp->readdir_state != libssh2_NB_state_idle &&
+                 sftp->readdir_request_id == request_id &&
+                 packet_type == SSH_FXP_NAME)) {
                 libssh2_channel_flush(channel);
-                sftp->partial_size_len = 0;
+                sftp->packet_header_len = 0;
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
                                       "SFTP packet too large");
             }
 
-            if(sftp->partial_len == 0)
+            if(sftp->partial_len < 5)
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_ALLOC,
-                                      "Unable to allocate empty SFTP packet");
+                                      "Invalid SFTP packet size");
 
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
+            _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
                            "Data begin - Packet Length: %lu",
-                           sftp->partial_len);
+                           (unsigned long)sftp->partial_len));
             packet = LIBSSH2_ALLOC(session, sftp->partial_len);
             if(!packet)
                 return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                       "Unable to allocate SFTP packet");
-            sftp->partial_size_len = 0;
-            sftp->partial_received = 0; /* how much of the packet already
-                                           received */
+            sftp->packet_header_len = 0;
             sftp->partial_packet = packet;
+            /* copy over packet type(4) and request id(1) */
+            sftp->partial_received = 5;
+            memcpy(packet, sftp->packet_header + 4, 5);
 
-          window_adjust:
+window_adjust:
             recv_window = libssh2_channel_window_read_ex(channel, NULL, NULL);
 
             if(sftp->partial_len > recv_window) {
@@ -382,12 +362,12 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
                                                             1, NULL);
                 /* store the state so that we continue with the correct
                    operation at next invoke */
-                sftp->packet_state = (rc == LIBSSH2_ERROR_EAGAIN)?
-                    libssh2_NB_state_sent:
+                sftp->packet_state = (rc == LIBSSH2_ERROR_EAGAIN) ?
+                    libssh2_NB_state_sent :
                     libssh2_NB_state_idle;
 
                 if(rc == LIBSSH2_ERROR_EAGAIN)
-                    return rc;
+                    return (int)rc;
             }
         }
 
@@ -405,12 +385,12 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
                  * knows how to continue on the next invoke.
                  */
                 sftp->packet_state = libssh2_NB_state_sent1;
-                return rc;
+                return (int)rc;
             }
             else if(rc < 0) {
                 LIBSSH2_FREE(session, packet);
                 sftp->partial_packet = NULL;
-                return _libssh2_error(session, rc,
+                return _libssh2_error(session, (int)rc,
                                       "Error waiting for SFTP packet");
             }
             sftp->partial_received += rc;
@@ -424,7 +404,7 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
         rc = sftp_packet_add(sftp, packet, sftp->partial_len);
         if(rc) {
             LIBSSH2_FREE(session, packet);
-            return rc;
+            return (int)rc;
         }
         else {
             return packet_type;
@@ -432,8 +412,8 @@ sftp_packet_read(LIBSSH2_SFTP *sftp)
     }
     /* WON'T REACH */
 }
-/*
- * sftp_packetlist_flush
+
+/* sftp_packetlist_flush
  *
  * Remove all pending packets in the packet_list and the corresponding one(s)
  * in the SFTP packet brigade.
@@ -474,7 +454,7 @@ static void sftp_packetlist_flush(LIBSSH2_SFTP_HANDLE *handle)
 
 
 /*
- * sftp_packet_ask()
+ * sftp_packet_ask
  *
  * Checks if there's a matching SFTP packet available.
  */
@@ -523,19 +503,19 @@ sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
     LIBSSH2_SESSION *session = sftp->channel->session;
     int rc;
 
-    if(data == NULL || data_len == NULL || required_size == 0) {
+    if(!data || !data_len || required_size == 0) {
         return LIBSSH2_ERROR_BAD_USE;
     }
 
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Requiring packet %d id %ld",
-                   (int) packet_type, request_id);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Requiring packet %u id %u",
+                   (unsigned int) packet_type, request_id));
 
     if(sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {
         /* The right packet was available in the packet brigade */
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
-                       (int) packet_type);
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Got %u",
+                       (unsigned int) packet_type));
 
-        if (*data_len < required_size) {
+        if(*data_len < required_size) {
             return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         }
 
@@ -550,10 +530,10 @@ sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,
         /* data was read, check the queue again */
         if(!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {
             /* The right packet was available in the packet brigade */
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Got %d",
-                           (int) packet_type);
+            _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Got %d",
+                           (unsigned int) packet_type));
 
-            if (*data_len < required_size) {
+            if(*data_len < required_size) {
                 return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
             }
 
@@ -577,7 +557,7 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
     int i;
     int rc;
 
-    if(data == NULL || data_len == NULL || required_size == 0) {
+    if(!data || !data_len || required_size == 0) {
         return LIBSSH2_ERROR_BAD_USE;
     }
 
@@ -588,14 +568,14 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
     while(sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
         for(i = 0; i < num_valid_responses; i++) {
             if(sftp_packet_ask(sftp, valid_responses[i], request_id,
-                                data, data_len) == 0) {
+                               data, data_len) == 0) {
                 /*
                  * Set to zero before all returns to say
                  * the timeout is not active
                  */
                 sftp->requirev_start = 0;
 
-                if (*data_len < required_size) {
+                if(*data_len < required_size) {
                     return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
                 }
 
@@ -611,7 +591,7 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
         else if(rc <= 0) {
             /* prevent busy-looping */
             long left =
-                LIBSSH2_READ_TIMEOUT -
+                sftp->channel->session->packet_read_timeout -
                 (long)(time(NULL) - sftp->requirev_start);
 
             if(left <= 0) {
@@ -630,6 +610,19 @@ sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,
     return LIBSSH2_ERROR_SOCKET_DISCONNECT;
 }
 
+/* sftp_attrsize
+ * Size that attr with this flagset will occupy when turned into a bin struct
+ */
+static int sftp_attrsize(unsigned long flags)
+{
+    return 4 +                                 /* flags(4) */
+           ((flags & LIBSSH2_SFTP_ATTR_SIZE) ? 8 : 0) +
+           ((flags & LIBSSH2_SFTP_ATTR_UIDGID) ? 8 : 0) +
+           ((flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) ? 4 : 0) +
+           ((flags & LIBSSH2_SFTP_ATTR_ACMODTIME) ? 8 : 0);
+    /* atime + mtime as u32 */
+}
+
 /* sftp_attr2bin
  * Populate attributes into an SFTP block
  */
@@ -638,8 +631,10 @@ sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs)
 {
     unsigned char *s = p;
     uint32_t flag_mask =
-        LIBSSH2_SFTP_ATTR_SIZE | LIBSSH2_SFTP_ATTR_UIDGID |
-        LIBSSH2_SFTP_ATTR_PERMISSIONS | LIBSSH2_SFTP_ATTR_ACMODTIME;
+        LIBSSH2_SFTP_ATTR_SIZE |
+        LIBSSH2_SFTP_ATTR_UIDGID |
+        LIBSSH2_SFTP_ATTR_PERMISSIONS |
+        LIBSSH2_SFTP_ATTR_ACMODTIME;
 
     /* TODO: When we add SFTP4+ functionality flag_mask can get additional
        bits */
@@ -649,32 +644,32 @@ sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs)
         return 4;
     }
 
-    _libssh2_store_u32(&s, attrs->flags & flag_mask);
+    _libssh2_store_u32(&s, (uint32_t)(attrs->flags & flag_mask));
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
         _libssh2_store_u64(&s, attrs->filesize);
     }
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
-        _libssh2_store_u32(&s, attrs->uid);
-        _libssh2_store_u32(&s, attrs->gid);
+        _libssh2_store_u32(&s, (uint32_t)attrs->uid);
+        _libssh2_store_u32(&s, (uint32_t)attrs->gid);
     }
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
-        _libssh2_store_u32(&s, attrs->permissions);
+        _libssh2_store_u32(&s, (uint32_t)attrs->permissions);
     }
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
-        _libssh2_store_u32(&s, attrs->atime);
-        _libssh2_store_u32(&s, attrs->mtime);
+        _libssh2_store_u32(&s, (uint32_t)attrs->atime);
+        _libssh2_store_u32(&s, (uint32_t)attrs->mtime);
     }
 
-    return (s - p);
+    return s - p;
 }
 
 /* sftp_bin2attr
  */
-static int
+static ssize_t
 sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
               size_t data_len)
 {
@@ -684,13 +679,13 @@ sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
     buf.dataptr = buf.data;
     buf.len = data_len;
 
-    if(_libssh2_get_u32(&buf, &flags) != 0) {
+    if(_libssh2_get_u32(&buf, &flags)) {
         return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
     }
     attrs->flags = flags;
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {
-        if(_libssh2_get_u64(&buf, &(attrs->filesize)) != 0) {
+        if(_libssh2_get_u64(&buf, &(attrs->filesize))) {
             return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         }
     }
@@ -698,8 +693,8 @@ sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
     if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {
         uint32_t uid = 0;
         uint32_t gid = 0;
-        if(_libssh2_get_u32(&buf, &uid) != 0 ||
-           _libssh2_get_u32(&buf, &gid) != 0) {
+        if(_libssh2_get_u32(&buf, &uid) ||
+           _libssh2_get_u32(&buf, &gid)) {
             return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         }
         attrs->uid = uid;
@@ -708,7 +703,7 @@ sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
 
     if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
         uint32_t permissions;
-        if(_libssh2_get_u32(&buf, &permissions) != 0) {
+        if(_libssh2_get_u32(&buf, &permissions)) {
             return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         }
         attrs->permissions = permissions;
@@ -717,15 +712,36 @@ sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,
     if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
         uint32_t atime;
         uint32_t mtime;
-        if(_libssh2_get_u32(&buf, &atime) != 0 ||
-           _libssh2_get_u32(&buf, &mtime) != 0) {
+        if(_libssh2_get_u32(&buf, &atime) ||
+           _libssh2_get_u32(&buf, &mtime)) {
             return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         }
         attrs->atime = atime;
         attrs->mtime = mtime;
     }
 
-    return (buf.dataptr - buf.data);
+    /* Parse extended data, if present, to avoid stream parsing errors */
+    if(attrs->flags & LIBSSH2_SFTP_ATTR_EXTENDED) {
+        uint32_t extended_count;
+        uint32_t i;
+        size_t etype_len;
+        unsigned char *etype;
+        size_t edata_len;
+        unsigned char *edata;
+
+        if(_libssh2_get_u32(&buf, &extended_count)) {
+            return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
+        }
+
+        for(i = 0; i < extended_count; ++i) {
+            if(_libssh2_get_string(&buf, &etype, &etype_len) ||
+               _libssh2_get_string(&buf, &edata, &edata_len)) {
+                return LIBSSH2_ERROR_BUFFER_TOO_SMALL;
+            }
+        }
+    }
+
+    return buf.dataptr - buf.data;
 }
 
 /* ************
@@ -741,8 +757,8 @@ LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor)
 {
     LIBSSH2_SFTP *sftp = (LIBSSH2_SFTP *) (*channel_abstract);
 
-    (void) session_abstract;
-    (void) channel;
+    (void)session_abstract;
+    (void)channel;
 
     /* Free the partial packet storage for sftp_packet_read */
     if(sftp->partial_packet) {
@@ -757,23 +773,21 @@ LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor)
     LIBSSH2_FREE(session, sftp);
 }
 
-/*
- * sftp_init
- *
+/* sftp_init
  * Startup an SFTP session
  */
 static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
 {
     unsigned char *data;
-    size_t data_len;
+    size_t data_len = 0;
     ssize_t rc;
     LIBSSH2_SFTP *sftp_handle;
     struct string_buf buf;
     unsigned char *endp;
 
     if(session->sftpInit_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Initializing SFTP subsystem");
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Initializing SFTP subsystem"));
 
         /*
          * The 'sftpInit_sftp' and 'sftpInit_channel' struct fields within the
@@ -787,7 +801,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
          * including *EAGAIN).
          */
 
-        assert(session->sftpInit_sftp == NULL);
+        assert(!session->sftpInit_sftp);
         session->sftpInit_sftp = NULL;
         session->sftpInit_state = libssh2_NB_state_created;
     }
@@ -860,10 +874,10 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         _libssh2_htonu32(session->sftpInit_buffer + 5, LIBSSH2_SFTP_VERSION);
         session->sftpInit_sent = 0; /* nothing's sent yet */
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
                        "Sending FXP_INIT packet advertising "
                        "version %d support",
-                       (int) LIBSSH2_SFTP_VERSION);
+                       (int) LIBSSH2_SFTP_VERSION));
 
         session->sftpInit_state = libssh2_NB_state_sent2;
     }
@@ -896,6 +910,22 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         }
     }
 
+    if(session->sftpInit_state == libssh2_NB_state_error_closing) {
+        rc = _libssh2_channel_free(session->sftpInit_channel);
+        if(rc == LIBSSH2_ERROR_EAGAIN) {
+            _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
+                           "Would block closing channel");
+            return NULL;
+        }
+        session->sftpInit_channel = NULL;
+        if(session->sftpInit_sftp) {
+            LIBSSH2_FREE(session, session->sftpInit_sftp);
+            session->sftpInit_sftp = NULL;
+        }
+        session->sftpInit_state = libssh2_NB_state_idle;
+        return NULL;
+    }
+
     rc = sftp_packet_require(sftp_handle, SSH_FXP_VERSION,
                              0, &data, &data_len, 5);
     if(rc == LIBSSH2_ERROR_EAGAIN) {
@@ -912,7 +942,7 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
         goto sftp_init_error;
     }
     else if(rc) {
-        _libssh2_error(session, rc,
+        _libssh2_error(session, (int)rc,
                        "Timeout waiting for response from SFTP subsystem");
         goto sftp_init_error;
     }
@@ -922,37 +952,59 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     buf.len = data_len;
     endp = &buf.data[data_len];
 
-    if(_libssh2_get_u32(&buf, &(sftp_handle->version)) != 0) {
+    if(_libssh2_get_u32(&buf, &(sftp_handle->version))) {
         LIBSSH2_FREE(session, data);
         rc = LIBSSH2_ERROR_BUFFER_TOO_SMALL;
         goto sftp_init_error;
     }
 
     if(sftp_handle->version > LIBSSH2_SFTP_VERSION) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Truncating remote SFTP version from %lu",
-                       sftp_handle->version);
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Truncating remote SFTP version from %u",
+                       sftp_handle->version));
         sftp_handle->version = LIBSSH2_SFTP_VERSION;
     }
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                   "Enabling SFTP version %lu compatibility",
-                   sftp_handle->version);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                   "Enabling SFTP version %u compatibility",
+                   sftp_handle->version));
     while(buf.dataptr < endp) {
         unsigned char *extname, *extdata;
+        size_t extname_len, extdata_len;
+        uint32_t extversion = 0;
 
-        if(_libssh2_get_string(&buf, &extname, NULL)) {
+        if(_libssh2_get_string(&buf, &extname, &extname_len)) {
             LIBSSH2_FREE(session, data);
             _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
                            "Data too short when extracting extname");
             goto sftp_init_error;
         }
 
-        if(_libssh2_get_string(&buf, &extdata, NULL)) {
+        if(_libssh2_get_string(&buf, &extdata, &extdata_len)) {
             LIBSSH2_FREE(session, data);
             _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
                            "Data too short when extracting extdata");
             goto sftp_init_error;
         }
+
+        if(extdata_len > 0) {
+            char *extversion_str;
+            extversion_str = (char *)LIBSSH2_ALLOC(session, extdata_len + 1);
+            if(!extversion_str) {
+                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                               "Unable to allocate memory for SSH_FXP_VERSION "
+                               "packet");
+                goto sftp_init_error;
+            }
+            memcpy(extversion_str, extdata, extdata_len);
+            extversion_str[extdata_len] = '\0';
+            extversion = (uint32_t)strtol(extversion_str, NULL, 10);
+            LIBSSH2_FREE(session, extversion_str);
+        }
+        if(extname_len == 24
+           && strncmp("posix-rename@openssh.com", (char *)extname, 24) == 0) {
+            sftp_handle->posix_rename_version = extversion;
+        }
+
     }
     LIBSSH2_FREE(session, data);
 
@@ -971,21 +1023,12 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
 
     return sftp_handle;
 
-  sftp_init_error:
-    while(_libssh2_channel_free(session->sftpInit_channel) ==
-           LIBSSH2_ERROR_EAGAIN);
-    session->sftpInit_channel = NULL;
-    if(session->sftpInit_sftp) {
-        LIBSSH2_FREE(session, session->sftpInit_sftp);
-        session->sftpInit_sftp = NULL;
-    }
-    session->sftpInit_state = libssh2_NB_state_idle;
+sftp_init_error:
+    session->sftpInit_state = libssh2_NB_state_error_closing;
     return NULL;
 }
 
-/*
- * libssh2_sftp_init
- *
+/* libssh2_sftp_init
  * Startup an SFTP session
  */
 LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
@@ -1005,9 +1048,7 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
     return ptr;
 }
 
-/*
- * sftp_shutdown
- *
+/* sftp_shutdown
  * Shuts down the SFTP subsystem
  */
 static int
@@ -1103,7 +1144,7 @@ libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp)
 static LIBSSH2_SFTP_HANDLE *
 sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
           size_t filename_len, uint32_t flags, long mode,
-          int open_type)
+          int open_type, LIBSSH2_SFTP_ATTRIBUTES *attrs_in)
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
@@ -1113,14 +1154,19 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
     };
     unsigned char *s;
     ssize_t rc;
-    int open_file = (open_type == LIBSSH2_SFTP_OPENFILE)?1:0;
+    int open_file = (open_type == LIBSSH2_SFTP_OPENFILE) ? 1 : 0;
 
     if(sftp->open_state == libssh2_NB_state_idle) {
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        if(attrs_in) {
+            memcpy(&attrs, attrs_in, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
+        }
+
         /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) +
            flags(4) */
-        sftp->open_packet_len = filename_len + 13 +
-            (open_file? (4 +
-                         sftp_attrsize(LIBSSH2_SFTP_ATTR_PERMISSIONS)) : 0);
+        sftp->open_packet_len = (uint32_t)(filename_len + 13 +
+            (open_file ? (4 + sftp_attrsize(attrs.flags)) : 0));
 
         /* surprise! this starts out with nothing sent */
         sftp->open_packet_sent = 0;
@@ -1137,7 +1183,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
              LIBSSH2_SFTP_ATTR_PFILETYPE_DIR);
 
         _libssh2_store_u32(&s, sftp->open_packet_len - 4);
-        *(s++) = open_file? SSH_FXP_OPEN : SSH_FXP_OPENDIR;
+        *(s++) = open_file ? SSH_FXP_OPEN : SSH_FXP_OPENDIR;
         sftp->open_request_id = sftp->request_id++;
         _libssh2_store_u32(&s, sftp->open_request_id);
         _libssh2_store_str(&s, filename, filename_len);
@@ -1147,8 +1193,8 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
             s += sftp_attr2bin(s, &attrs);
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Sending %s open request",
-                       open_file? "file" : "directory");
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Sending %s open request",
+                       open_file ? "file" : "directory"));
 
         sftp->open_state = libssh2_NB_state_created;
     }
@@ -1165,7 +1211,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
             return NULL;
         }
         else if(rc < 0) {
-            _libssh2_error(session, rc, "Unable to send FXP_OPEN*");
+            _libssh2_error(session, (int)rc, "Unable to send FXP_OPEN*");
             LIBSSH2_FREE(session, sftp->open_packet);
             sftp->open_packet = NULL;
             sftp->open_state = libssh2_NB_state_idle;
@@ -1185,7 +1231,7 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
     }
 
     if(sftp->open_state == libssh2_NB_state_sent) {
-        size_t data_len;
+        size_t data_len = 0;
         unsigned char *data;
         static const unsigned char fopen_responses[2] =
             { SSH_FXP_HANDLE, SSH_FXP_STATUS };
@@ -1207,7 +1253,8 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         }
         sftp->open_state = libssh2_NB_state_idle;
         if(rc) {
-            _libssh2_error(session, rc, "Timeout waiting for status message");
+            _libssh2_error(session, (int)rc,
+                           "Timeout waiting for status message");
             return NULL;
         }
 
@@ -1228,8 +1275,8 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
             sftp->last_errno = _libssh2_ntohu32(data + 5);
 
             if(LIBSSH2_FX_OK == sftp->last_errno) {
-                _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                               "got HANDLE FXOK!");
+                _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                               "got HANDLE FXOK"));
 
                 LIBSSH2_FREE(session, data);
 
@@ -1258,9 +1305,9 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
             if(badness) {
                 _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                "Failed opening remote file");
-                _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
+                _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
                                "got FXP_STATUS %d",
-                               sftp->last_errno);
+                               sftp->last_errno));
                 LIBSSH2_FREE(session, data);
                 return NULL;
             }
@@ -1304,7 +1351,8 @@ sftp_open(LIBSSH2_SFTP *sftp, const char *filename,
         fp->u.file.offset = 0;
         fp->u.file.offset_sent = 0;
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Open command successful");
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Open command successful"));
         return fp;
     }
     return NULL;
@@ -1323,16 +1371,31 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, const char *filename,
         return NULL;
 
     BLOCK_ADJUST_ERRNO(hnd, sftp->channel->session,
-                       sftp_open(sftp, filename, filename_len, flags, mode,
-                                 open_type));
+                       sftp_open(sftp, filename, filename_len, (uint32_t)flags,
+                                 mode, open_type, NULL));
     return hnd;
 }
 
-/*
- * sftp_read
- *
+/* libssh2_sftp_open_ex_r
+ */
+LIBSSH2_API LIBSSH2_SFTP_HANDLE *
+libssh2_sftp_open_ex_r(LIBSSH2_SFTP *sftp, const char *filename,
+                       size_t filename_len, unsigned long flags, long mode,
+                       int open_type, LIBSSH2_SFTP_ATTRIBUTES *attrs)
+{
+    LIBSSH2_SFTP_HANDLE *hnd;
+
+    if(!sftp)
+        return NULL;
+
+    BLOCK_ADJUST_ERRNO(hnd, sftp->channel->session,
+                       sftp_open(sftp, filename, filename_len, (uint32_t)flags,
+                                 mode, open_type, attrs));
+    return hnd;
+}
+
+/* sftp_read
  * Read from an SFTP file handle
- *
  */
 static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                          size_t buffer_size)
@@ -1382,13 +1445,14 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
     switch(sftp->read_state) {
     case libssh2_NB_state_idle:
+        sftp->last_errno = LIBSSH2_FX_OK;
 
         /* Some data may already have been read from the server in the
            previous call but didn't fit in the buffer at the time.  If so, we
            return that now as we can't risk being interrupted later with data
            partially written to the buffer. */
         if(filep->data_left) {
-            size_t copy = MIN(buffer_size, filep->data_left);
+            size_t copy = LIBSSH2_MIN(buffer_size, filep->data_left);
 
             memcpy(buffer, &filep->data[ filep->data_len - filep->data_left],
                    copy);
@@ -1452,8 +1516,8 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                    allows, expand it! */
 
                 rc = _libssh2_channel_receive_window_adjust(sftp->channel,
-                                                            max_read_ahead*8,
-                                                            1, NULL);
+                                               (uint32_t)(max_read_ahead * 8),
+                                               1, NULL);
                 /* if this returns EAGAIN, we will get back to this function
                    at next call */
                 assert(rc != LIBSSH2_ERROR_EAGAIN || !filep->data_left);
@@ -1468,12 +1532,12 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
             /* 25 = packet_len(4) + packet_type(1) + request_id(4) +
                handle_len(4) + offset(8) + count(4) */
-            uint32_t packet_len = (uint32_t)handle->handle_len + 25;
+            uint32_t packet_len = (uint32_t)(handle->handle_len + 25);
             uint32_t request_id;
 
-            uint32_t size = count;
+            uint32_t size = (uint32_t)count;
             if(size < buffer_size)
-                size = buffer_size;
+                size = (uint32_t)buffer_size;
             if(size > MAX_SFTP_READ_SIZE)
                 size = MAX_SFTP_READ_SIZE;
 
@@ -1502,13 +1566,15 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
             /* add this new entry LAST in the list */
             _libssh2_list_add(&handle->packet_list, &chunk->node);
-            count -= MIN(size, count); /* deduct the size we used, as we might
-                                        * have to create more packets */
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                           "read request id %d sent (offset: %d, size: %d)",
-                           request_id, (int)chunk->offset, (int)chunk->len);
-        }
-        /* FALL-THROUGH */
+            /* deduct the size we used, as we might have to create
+               more packets */
+            count -= LIBSSH2_MIN(size, count);
+            _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                           "read request id %d sent (offset: %lu, size: %lu)",
+                           request_id, (unsigned long)chunk->offset,
+                           (unsigned long)chunk->len));
+        }
+        LIBSSH2_FALLTHROUGH();
     case libssh2_NB_state_sent:
 
         sftp->read_state = libssh2_NB_state_idle;
@@ -1548,7 +1614,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
             /* move on to the next chunk with data to send */
             chunk = _libssh2_list_next(&chunk->node);
         }
-        /* FALL-THROUGH */
+        LIBSSH2_FALLTHROUGH();
 
     case libssh2_NB_state_sent2:
 
@@ -1561,7 +1627,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
         while(chunk) {
             unsigned char *data;
-            size_t data_len;
+            size_t data_len = 0;
             uint32_t rc32;
             static const unsigned char read_responses[2] = {
                 SSH_FXP_DATA, SSH_FXP_STATUS
@@ -1582,7 +1648,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
             rc = sftp_packet_requirev(sftp, 2, read_responses,
                                       chunk->request_id, &data, &data_len, 9);
-            if(rc == LIBSSH2_ERROR_EAGAIN && bytes_in_buffer != 0) {
+            if(rc == LIBSSH2_ERROR_EAGAIN && bytes_in_buffer) {
                 /* do not return EAGAIN if we have already
                  * written data into the buffer */
                 return bytes_in_buffer;
@@ -1628,7 +1694,6 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                     return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                           "SFTP READ error");
                 }
-                break;
 
             case SSH_FXP_DATA:
                 if(chunk->offset != filep->offset) {
@@ -1636,7 +1701,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
                        requested, which shouldn't happen for normal files. See:
                        https://tools.ietf.org/html/draft-ietf-secsh-filexfer-02
                        #section-6.4
-                    */
+                     */
                     return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                           "Read Packet At Unexpected Offset");
                 }
@@ -1667,7 +1732,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
 
                     /* getting the full packet would overflow the buffer, so
                        only get the correct amount and keep the remainder */
-                    rc32 = (uint32_t)buffer_size - bytes_in_buffer;
+                    rc32 = (uint32_t)(buffer_size - bytes_in_buffer);
 
                     /* store data to keep for next call */
                     filep->data = data;
@@ -1717,7 +1782,7 @@ static ssize_t sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer,
         break;
 
     default:
-        assert(!"State machine error; unrecognised read state");
+        assert(0);  /* State machine error; unrecognised read state */
     }
 
     /* we should never reach this point */
@@ -1751,16 +1816,18 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     LIBSSH2_SFTP *sftp = handle->sftp;
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     uint32_t num_names;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 13;
+    uint32_t packet_len = (uint32_t)(handle->handle_len + 13);
     unsigned char *s, *data;
     static const unsigned char read_responses[2] = {
         SSH_FXP_NAME, SSH_FXP_STATUS };
     ssize_t retcode;
 
     if(sftp->readdir_state == libssh2_NB_state_idle) {
+        sftp->last_errno = LIBSSH2_FX_OK;
+
         if(handle->u.dir.names_left) {
             /*
              * A prior request returned more than one directory entry,
@@ -1772,7 +1839,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
             size_t filename_len;
             size_t longentry_len;
             size_t names_packet_len = handle->u.dir.names_packet_len;
-            int attr_len = 0;
+            ssize_t attr_len = 0;
 
             if(names_packet_len >= 4) {
                 s = (unsigned char *) handle->u.dir.next_name;
@@ -1813,7 +1880,7 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
                 goto end;
             }
 
-            if(longentry && (longentry_maxlen>1)) {
+            if(longentry && (longentry_maxlen > 1)) {
                 longentry_len = real_longentry_len;
 
                 if(longentry_len >= longentry_maxlen ||
@@ -1852,14 +1919,14 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
 
             handle->u.dir.next_name = (char *) s;
             handle->u.dir.names_packet_len = names_packet_len;
-          end:
 
             if((--handle->u.dir.names_left) == 0)
                 LIBSSH2_FREE(session, handle->u.dir.names_packet);
 
-            _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                           "libssh2_sftp_readdir_ex() return %d",
-                           filename_len);
+end:
+            _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                           "libssh2_sftp_readdir_ex() return %lu",
+                           (unsigned long)filename_len));
             return (ssize_t)filename_len;
         }
 
@@ -1881,8 +1948,8 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     }
 
     if(sftp->readdir_state == libssh2_NB_state_created) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Reading entries from directory handle");
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Reading entries from directory handle"));
         retcode = _libssh2_channel_write(channel, 0, sftp->readdir_packet,
                                          packet_len);
         if(retcode == LIBSSH2_ERROR_EAGAIN) {
@@ -1916,19 +1983,20 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     }
     else if(retcode) {
         sftp->readdir_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, retcode,
+        return _libssh2_error(session, (int)retcode,
                               "Timeout waiting for status message");
     }
 
     if(data[0] == SSH_FXP_STATUS) {
-        retcode = _libssh2_ntohu32(data + 5);
+        unsigned int rerrno;
+        rerrno = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
-        if(retcode == LIBSSH2_FX_EOF) {
+        if(rerrno == LIBSSH2_FX_EOF) {
             sftp->readdir_state = libssh2_NB_state_idle;
             return 0;
         }
         else {
-            sftp->last_errno = retcode;
+            sftp->last_errno = rerrno;
             sftp->readdir_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
                                   "SFTP Protocol Error");
@@ -1938,8 +2006,8 @@ static ssize_t sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
     sftp->readdir_state = libssh2_NB_state_idle;
 
     num_names = _libssh2_ntohu32(data + 5);
-    _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%lu entries returned",
-                   num_names);
+    _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "%u entries returned",
+                   num_names));
     if(!num_names) {
         LIBSSH2_FREE(session, data);
         return 0;
@@ -1964,17 +2032,16 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *hnd, char *buffer,
                         size_t longentry_maxlen,
                         LIBSSH2_SFTP_ATTRIBUTES *attrs)
 {
-    int rc;
+    ssize_t rc;
     if(!hnd)
         return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session,
                  sftp_readdir(hnd, buffer, buffer_maxlen, longentry,
                               longentry_maxlen, attrs));
-    return rc;
+    return (int)rc;  /* FIXME: -> ssize_t */
 }
 
-/*
- * sftp_write
+/* sftp_write
  *
  * Write data to an SFTP handle. Returns the number of bytes written, or
  * a negative error code.
@@ -2017,10 +2084,10 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
     LIBSSH2_SFTP *sftp = handle->sftp;
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     uint32_t retcode;
     uint32_t packet_len;
-    unsigned char *s, *data;
+    unsigned char *s, *data = NULL;
     ssize_t rc;
     struct sftp_pipeline_chunk *chunk;
     struct sftp_pipeline_chunk *next;
@@ -2031,6 +2098,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
     switch(sftp->write_state) {
     default:
     case libssh2_NB_state_idle:
+        sftp->last_errno = LIBSSH2_FX_OK;
 
         /* Number of bytes sent off that haven't been acked and therefore we
            will get passed in here again.
@@ -2039,8 +2107,8 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
            acked but we haven't been able to return as such yet, so we will
            get that data as well passed in here again.
         */
-        already = (size_t) (handle->u.file.offset_sent -
-                            handle->u.file.offset)+
+        already = (size_t)(handle->u.file.offset_sent -
+                           handle->u.file.offset)+
             handle->u.file.acked;
 
         if(count >= already) {
@@ -2056,12 +2124,13 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
         while(count) {
             /* TODO: Possibly this should have some logic to prevent a very
                very small fraction to be left but lets ignore that for now */
-            uint32_t size = MIN(MAX_SFTP_OUTGOING_SIZE, count);
+            uint32_t size =
+                (uint32_t)(LIBSSH2_MIN(MAX_SFTP_OUTGOING_SIZE, count));
             uint32_t request_id;
 
             /* 25 = packet_len(4) + packet_type(1) + request_id(4) +
                handle_len(4) + offset(8) + count(4) */
-            packet_len = handle->handle_len + size + 25;
+            packet_len = (uint32_t)(handle->handle_len + size + 25);
 
             chunk = LIBSSH2_ALLOC(session, packet_len +
                                   sizeof(struct sftp_pipeline_chunk));
@@ -2119,7 +2188,8 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
             chunk = _libssh2_list_next(&chunk->node);
         }
 
-        /* fall-through */
+        LIBSSH2_FALLTHROUGH();
+
     case libssh2_NB_state_sent:
 
         sftp->write_state = libssh2_NB_state_idle;
@@ -2206,7 +2276,7 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
     acked += handle->u.file.acked;
 
     if(acked) {
-        ssize_t ret = MIN(acked, org_count);
+        ssize_t ret = LIBSSH2_MIN(acked, org_count);
         /* we got data acked so return that amount, but no more than what
            was asked to get sent! */
 
@@ -2244,15 +2314,17 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
     LIBSSH2_SESSION *session = channel->session;
     /* 34 = packet_len(4) + packet_type(1) + request_id(4) +
        string_len(4) + strlen("fsync@openssh.com")(17) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 34;
-    size_t data_len;
-    unsigned char *packet, *s, *data;
+    uint32_t packet_len = (uint32_t)(handle->handle_len + 34);
+    size_t data_len = 0;
+    unsigned char *packet, *s, *data = NULL;
     ssize_t rc;
     uint32_t retcode;
 
     if(sftp->fsync_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Issuing fsync command");
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Issuing fsync command"));
         s = packet = LIBSSH2_ALLOC(session, packet_len);
         if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -2295,7 +2367,7 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
     rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
                              sftp->fsync_request_id, &data, &data_len, 9);
     if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
+        return (int)rc;
     }
     else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
         if(data_len > 0) {
@@ -2306,7 +2378,7 @@ static int sftp_fsync(LIBSSH2_SFTP_HANDLE *handle)
     }
     else if(rc) {
         sftp->fsync_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
+        return _libssh2_error(session, (int)rc,
                               "Error waiting for FXP EXTENDED REPLY");
     }
 
@@ -2339,9 +2411,7 @@ libssh2_sftp_fsync(LIBSSH2_SFTP_HANDLE *hnd)
 }
 
 
-/*
- * sftp_fstat
- *
+/* sftp_fstat
  * Get or Set stat on a file
  */
 static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
@@ -2350,18 +2420,20 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
     LIBSSH2_SFTP *sftp = handle->sftp;
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len =
-        handle->handle_len + 13 + (setstat ? sftp_attrsize(attrs->flags) : 0);
-    unsigned char *s, *data;
+    uint32_t packet_len = (uint32_t)(handle->handle_len + 13 +
+                                 (setstat ? sftp_attrsize(attrs->flags) : 0));
+    unsigned char *s, *data = NULL;
     static const unsigned char fstat_responses[2] =
         { SSH_FXP_ATTRS, SSH_FXP_STATUS };
     ssize_t rc;
 
     if(sftp->fstat_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Issuing %s command",
-                       setstat ? "set-stat" : "stat");
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Issuing %s command",
+                       setstat ? "set-stat" : "stat"));
         s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->fstat_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -2386,7 +2458,7 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
         rc = _libssh2_channel_write(channel, 0, sftp->fstat_packet,
                                     packet_len);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+            return (int)rc;
         }
         else if((ssize_t)packet_len != rc) {
             LIBSSH2_FREE(session, sftp->fstat_packet);
@@ -2406,7 +2478,7 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
                               sftp->fstat_request_id, &data,
                               &data_len, 9);
     if(rc == LIBSSH2_ERROR_EAGAIN)
-        return rc;
+        return (int)rc;
     else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
         if(data_len > 0) {
             LIBSSH2_FREE(session, data);
@@ -2416,7 +2488,7 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
     }
     else if(rc) {
         sftp->fstat_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
+        return _libssh2_error(session, (int)rc,
                               "Timeout waiting for status message");
     }
 
@@ -2575,14 +2647,16 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
     LIBSSH2_SFTP *sftp = handle->sftp;
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
-    uint32_t packet_len = handle->handle_len + 13;
+    uint32_t packet_len = (uint32_t)(handle->handle_len + 13);
     unsigned char *s, *data = NULL;
     int rc = 0;
 
     if(handle->close_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Closing handle");
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Closing handle"));
         s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!handle->close_packet) {
             handle->close_state = libssh2_NB_state_idle;
@@ -2602,12 +2676,13 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
     }
 
     if(handle->close_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, handle->close_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, handle->close_packet,
+                                          packet_len);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if((ssize_t)packet_len != rc) {
+        else if((ssize_t)packet_len != nwritten) {
             handle->close_state = libssh2_NB_state_idle;
             rc = _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
                                 "Unable to send FXP_CLOSE command");
@@ -2649,7 +2724,7 @@ sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
 
     }
     else {
-        int retcode = _libssh2_ntohu32(data + 5);
+        uint32_t retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
 
         if(retcode != LIBSSH2_FX_OK) {
@@ -2705,15 +2780,18 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    int retcode;
+    size_t data_len = 0;
+    uint32_t retcode;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) */
-    uint32_t packet_len = filename_len + 13;
-    unsigned char *s, *data;
+    uint32_t packet_len = (uint32_t)(filename_len + 13);
+    unsigned char *s, *data = NULL;
     int rc;
 
     if(sftp->unlink_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Unlinking %s", filename);
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Unlinking %s", filename));
         s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->unlink_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -2730,12 +2808,13 @@ static int sftp_unlink(LIBSSH2_SFTP *sftp, const char *filename,
     }
 
     if(sftp->unlink_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->unlink_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, sftp->unlink_packet,
+                                          packet_len);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if((ssize_t)packet_len != rc) {
+        else if((ssize_t)packet_len != nwritten) {
             LIBSSH2_FREE(session, sftp->unlink_packet);
             sftp->unlink_packet = NULL;
             sftp->unlink_state = libssh2_NB_state_idle;
@@ -2797,9 +2876,7 @@ libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename,
     return rc;
 }
 
-/*
- * sftp_rename
- *
+/* sftp_rename
  * Rename a file on the remote server
  */
 static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
@@ -2809,24 +2886,26 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     int retcode;
     uint32_t packet_len =
-        source_filename_len + dest_filename_len + 17 + (sftp->version >=
-                                                        5 ? 4 : 0);
+        source_filename_len + dest_filename_len + 17 +
+        (sftp->version >= 5 ? 4 : 0);
     /* packet_len(4) + packet_type(1) + request_id(4) +
        source_filename_len(4) + dest_filename_len(4) + flags(4){SFTP5+) */
-    unsigned char *data;
+    unsigned char *data = NULL;
     ssize_t rc;
 
-    if(sftp->version < 2) {
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Server does not support RENAME");
-    }
-
     if(sftp->rename_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Renaming %s to %s",
-                       source_filename, dest_filename);
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        if(sftp->version < 2) {
+            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
+                                  "Server does not support RENAME");
+        }
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Renaming %s to %s",
+                       source_filename, dest_filename));
         sftp->rename_s = sftp->rename_packet =
             LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->rename_packet) {
@@ -2844,7 +2923,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
         _libssh2_store_str(&sftp->rename_s, dest_filename, dest_filename_len);
 
         if(sftp->version >= 5)
-            _libssh2_store_u32(&sftp->rename_s, flags);
+            _libssh2_store_u32(&sftp->rename_s, (uint32_t)flags);
 
         sftp->rename_state = libssh2_NB_state_created;
     }
@@ -2853,7 +2932,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
         rc = _libssh2_channel_write(channel, 0, sftp->rename_packet,
                                     sftp->rename_s - sftp->rename_packet);
         if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+            return (int)rc;
         }
         else if((ssize_t)packet_len != rc) {
             LIBSSH2_FREE(session, sftp->rename_packet);
@@ -2872,7 +2951,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
                              sftp->rename_request_id, &data,
                              &data_len, 9);
     if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
+        return (int)rc;
     }
     else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
         if(data_len > 0) {
@@ -2883,7 +2962,7 @@ static int sftp_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
     }
     else if(rc) {
         sftp->rename_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
+        return _libssh2_error(session, (int)rc,
                               "Error waiting for FXP STATUS");
     }
 
@@ -2939,9 +3018,137 @@ libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename,
     return rc;
 }
 
-/*
- * sftp_fstatvfs
- *
+static int
+sftp_posix_rename(LIBSSH2_SFTP *sftp, const char *source_filename,
+                  size_t source_filename_len,
+                  const char *dest_filename,
+                  size_t dest_filename_len)
+{
+    LIBSSH2_CHANNEL *channel = sftp->channel;
+    LIBSSH2_SESSION *session = channel->session;
+    uint32_t packet_len;
+    size_t data_len = 0;
+    unsigned char *packet, *s, *data = NULL;
+    ssize_t rc;
+    uint32_t retcode;
+
+    if(sftp->posix_rename_version != 1) {
+        return _libssh2_error(session, LIBSSH2_FX_OP_UNSUPPORTED,
+                              "Server does not support"
+                              "posix-rename@openssh.com");
+    }
+
+    if(source_filename_len > UINT32_MAX ||
+       dest_filename_len > UINT32_MAX ||
+       45 + source_filename_len + dest_filename_len > UINT32_MAX) {
+        return _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                              "Input too large"
+                              "posix-rename@openssh.com");
+    }
+
+    packet_len = (uint32_t)(45 + source_filename_len + dest_filename_len);
+
+    /* 45 = packet_len(4) + packet_type(1) + request_id(4) +
+       string_len(4) + strlen("posix-rename@openssh.com")(24) +
+       oldpath_len(4) + source_filename_len +
+       newpath_len(4) + dest_filename_len */
+
+    if(sftp->posix_rename_state == libssh2_NB_state_idle) {
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Issuing posix_rename command"));
+        s = packet = LIBSSH2_ALLOC(session, packet_len);
+        if(!packet) {
+            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                  "Unable to allocate memory for FXP_EXTENDED "
+                                  "packet");
+        }
+
+        _libssh2_store_u32(&s, packet_len - 4);
+        *(s++) = SSH_FXP_EXTENDED;
+        sftp->posix_rename_request_id = sftp->request_id++;
+        _libssh2_store_u32(&s, sftp->posix_rename_request_id);
+        _libssh2_store_str(&s, "posix-rename@openssh.com", 24);
+        _libssh2_store_str(&s, source_filename, source_filename_len);
+        _libssh2_store_str(&s, dest_filename, dest_filename_len);
+
+        sftp->posix_rename_state = libssh2_NB_state_created;
+    }
+    else {
+        packet = sftp->posix_rename_packet;
+    }
+
+    if(sftp->posix_rename_state == libssh2_NB_state_created) {
+        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
+        if(rc == LIBSSH2_ERROR_EAGAIN ||
+            (0 <= rc && rc < (ssize_t)packet_len)) {
+            sftp->posix_rename_packet = packet;
+            return LIBSSH2_ERROR_EAGAIN;
+        }
+
+        LIBSSH2_FREE(session, packet);
+        sftp->posix_rename_packet = NULL;
+
+        if(rc < 0) {
+            sftp->posix_rename_state = libssh2_NB_state_idle;
+            return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
+                                  "_libssh2_channel_write() failed");
+        }
+        sftp->posix_rename_state = libssh2_NB_state_sent;
+    }
+
+    rc = sftp_packet_require(sftp, SSH_FXP_STATUS,
+                             sftp->posix_rename_request_id,
+                             &data, &data_len, 9);
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
+        return (int)rc;
+    }
+    else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
+        if(data_len > 0) {
+            LIBSSH2_FREE(session, data);
+        }
+        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
+                              "SFTP posix_rename packet too short");
+    }
+    else if(rc) {
+        sftp->posix_rename_state = libssh2_NB_state_idle;
+        return (int)_libssh2_error(session, (int)rc,
+                                   "Error waiting for FXP EXTENDED REPLY");
+    }
+
+    sftp->posix_rename_state = libssh2_NB_state_idle;
+
+    retcode = _libssh2_ntohu32(data + 5);
+    LIBSSH2_FREE(session, data);
+
+    if(retcode != LIBSSH2_FX_OK) {
+        sftp->last_errno = retcode;
+        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
+                              "posix_rename failed");
+    }
+
+    return 0;
+}
+
+/* libssh2_sftp_posix_rename_ex
+ * Rename a file on the remote server using the posix-rename@openssh.com
+ * extension.
+ */
+LIBSSH2_API int
+libssh2_sftp_posix_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename,
+                             size_t source_filename_len,
+                             const char *dest_filename,
+                             size_t dest_filename_len)
+{
+    int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
+    BLOCK_ADJUST(rc, sftp->channel->session,
+                 sftp_posix_rename(sftp, source_filename, source_filename_len,
+                                   dest_filename, dest_filename_len));
+    return rc;
+}
+
+/* sftp_fstatvfs
  * Get file system statistics
  */
 static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
@@ -2949,20 +3156,22 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
     LIBSSH2_SFTP *sftp = handle->sftp;
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     /* 17 = packet_len(4) + packet_type(1) + request_id(4) + ext_len(4)
        + handle_len (4) */
     /* 20 = strlen ("fstatvfs@openssh.com") */
-    uint32_t packet_len = handle->handle_len + 20 + 17;
-    unsigned char *packet, *s, *data;
+    uint32_t packet_len = (uint32_t)(handle->handle_len + 20 + 17);
+    unsigned char *packet, *s, *data = NULL;
     ssize_t rc;
     unsigned int flag;
     static const unsigned char responses[2] =
         { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
 
     if(sftp->fstatvfs_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Getting file system statistics");
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Getting file system statistics"));
         s = packet = LIBSSH2_ALLOC(session, packet_len);
         if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3006,7 +3215,7 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
                               &data, &data_len, 9);
 
     if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
+        return (int)rc;
     }
     else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
         if(data_len > 0) {
@@ -3017,12 +3226,12 @@ static int sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
     }
     else if(rc) {
         sftp->fstatvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
+        return _libssh2_error(session, (int)rc,
                               "Error waiting for FXP EXTENDED REPLY");
     }
 
     if(data[0] == SSH_FXP_STATUS) {
-        int retcode = _libssh2_ntohu32(data + 5);
+        uint32_t retcode = _libssh2_ntohu32(data + 5);
         sftp->fstatvfs_state = libssh2_NB_state_idle;
         LIBSSH2_FREE(session, data);
         sftp->last_errno = retcode;
@@ -3075,9 +3284,7 @@ libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
     return rc;
 }
 
-/*
- * sftp_statvfs
- *
+/* sftp_statvfs
  * Get file system statistics
  */
 static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
@@ -3085,20 +3292,22 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     /* 17 = packet_len(4) + packet_type(1) + request_id(4) + ext_len(4)
        + path_len (4) */
     /* 19 = strlen ("statvfs@openssh.com") */
     uint32_t packet_len = path_len + 19 + 17;
-    unsigned char *packet, *s, *data;
+    unsigned char *packet, *s, *data = NULL;
     ssize_t rc;
     unsigned int flag;
     static const unsigned char responses[2] =
         { SSH_FXP_EXTENDED_REPLY, SSH_FXP_STATUS };
 
     if(sftp->statvfs_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Getting file system statistics of %s", path);
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Getting file system statistics of %s", path));
         s = packet = LIBSSH2_ALLOC(session, packet_len);
         if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3141,7 +3350,7 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
     rc = sftp_packet_requirev(sftp, 2, responses, sftp->statvfs_request_id,
                               &data, &data_len, 9);
     if(rc == LIBSSH2_ERROR_EAGAIN) {
-        return rc;
+        return (int)rc;
     }
     else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {
         if(data_len > 0) {
@@ -3152,12 +3361,12 @@ static int sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
     }
     else if(rc) {
         sftp->statvfs_state = libssh2_NB_state_idle;
-        return _libssh2_error(session, rc,
+        return _libssh2_error(session, (int)rc,
                               "Error waiting for FXP EXTENDED REPLY");
     }
 
     if(data[0] == SSH_FXP_STATUS) {
-        int retcode = _libssh2_ntohu32(data + 5);
+        uint32_t retcode = _libssh2_ntohu32(data + 5);
         sftp->statvfs_state = libssh2_NB_state_idle;
         LIBSSH2_FREE(session, data);
         sftp->last_errno = retcode;
@@ -3206,15 +3415,13 @@ libssh2_sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
     int rc;
     if(!sftp || !st)
         return LIBSSH2_ERROR_BAD_USE;
-    BLOCK_ADJUST(rc, sftp->channel->session, sftp_statvfs(sftp, path, path_len,
-                                                          st));
+    BLOCK_ADJUST(rc, sftp->channel->session,
+                 sftp_statvfs(sftp, path, (unsigned int)path_len, st));
     return rc;
 }
 
 
-/*
- * sftp_mkdir
- *
+/* sftp_mkdir
  * Create an SFTP directory
  */
 static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
@@ -3225,10 +3432,10 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     LIBSSH2_SFTP_ATTRIBUTES attrs = {
         0, 0, 0, 0, 0, 0, 0
     };
-    size_t data_len;
-    int retcode;
+    size_t data_len = 0;
+    uint32_t retcode;
     ssize_t packet_len;
-    unsigned char *packet, *s, *data;
+    unsigned char *packet, *s, *data = NULL;
     int rc;
 
     if(mode != LIBSSH2_SFTP_DEFAULT_MODE) {
@@ -3241,8 +3448,10 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     packet_len = path_len + 13 + sftp_attrsize(attrs.flags);
 
     if(sftp->mkdir_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP,
-                       "Creating directory %s with mode 0%lo", path, mode);
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP,
+                       "Creating directory %s with mode 0%lo", path, mode));
         s = packet = LIBSSH2_ALLOC(session, packet_len);
         if(!packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3250,7 +3459,7 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
                                   "packet");
         }
 
-        _libssh2_store_u32(&s, packet_len - 4);
+        _libssh2_store_u32(&s, (uint32_t)(packet_len - 4));
         *(s++) = SSH_FXP_MKDIR;
         sftp->mkdir_request_id = sftp->request_id++;
         _libssh2_store_u32(&s, sftp->mkdir_request_id);
@@ -3265,12 +3474,13 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     }
 
     if(sftp->mkdir_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, packet, packet_len);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
             sftp->mkdir_packet = packet;
-            return rc;
+            return (int)nwritten;
         }
-        if(packet_len != rc) {
+        if(packet_len != nwritten) {
             LIBSSH2_FREE(session, packet);
             sftp->mkdir_state = libssh2_NB_state_idle;
             return _libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
@@ -3305,7 +3515,7 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     LIBSSH2_FREE(session, data);
 
     if(retcode == LIBSSH2_FX_OK) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "OK!");
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "OK"));
         return 0;
     }
     else {
@@ -3315,9 +3525,7 @@ static int sftp_mkdir(LIBSSH2_SFTP *sftp, const char *path,
     }
 }
 
-/*
- * libssh2_sftp_mkdir_ex
- *
+/* libssh2_sftp_mkdir_ex
  * Create an SFTP directory
  */
 LIBSSH2_API int
@@ -3340,16 +3548,18 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
-    int retcode;
+    size_t data_len = 0;
+    uint32_t retcode;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
     ssize_t packet_len = path_len + 13;
-    unsigned char *s, *data;
+    unsigned char *s, *data = NULL;
     int rc;
 
     if(sftp->rmdir_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "Removing directory: %s",
-                       path);
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Removing directory: %s",
+                       path));
         s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->rmdir_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3357,7 +3567,7 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
                                   "packet");
         }
 
-        _libssh2_store_u32(&s, packet_len - 4);
+        _libssh2_store_u32(&s, (uint32_t)(packet_len - 4));
         *(s++) = SSH_FXP_RMDIR;
         sftp->rmdir_request_id = sftp->request_id++;
         _libssh2_store_u32(&s, sftp->rmdir_request_id);
@@ -3367,12 +3577,13 @@ static int sftp_rmdir(LIBSSH2_SFTP *sftp, const char *path,
     }
 
     if(sftp->rmdir_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->rmdir_packet,
-                                    packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0, sftp->rmdir_packet,
+                                          packet_len);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if(packet_len != rc) {
+        else if(packet_len != nwritten) {
             LIBSSH2_FREE(session, sftp->rmdir_packet);
             sftp->rmdir_packet = NULL;
             sftp->rmdir_state = libssh2_NB_state_idle;
@@ -3442,22 +3653,24 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len;
+    size_t data_len = 0;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
     ssize_t packet_len =
         path_len + 13 +
         ((stat_type ==
           LIBSSH2_SFTP_SETSTAT) ? sftp_attrsize(attrs->flags) : 0);
-    unsigned char *s, *data;
+    unsigned char *s, *data = NULL;
     static const unsigned char stat_responses[2] =
         { SSH_FXP_ATTRS, SSH_FXP_STATUS };
     int rc;
 
     if(sftp->stat_state == libssh2_NB_state_idle) {
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s",
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "%s %s",
                        (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" :
                        (stat_type ==
-                        LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
+                        LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path));
         s = sftp->stat_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->stat_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3465,7 +3678,7 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
                                   "packet");
         }
 
-        _libssh2_store_u32(&s, packet_len - 4);
+        _libssh2_store_u32(&s, (uint32_t)(packet_len - 4));
 
         switch(stat_type) {
         case LIBSSH2_SFTP_SETSTAT:
@@ -3491,11 +3704,13 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
     }
 
     if(sftp->stat_state == libssh2_NB_state_created) {
-        rc = _libssh2_channel_write(channel, 0, sftp->stat_packet, packet_len);
-        if(rc == LIBSSH2_ERROR_EAGAIN) {
-            return rc;
+        ssize_t nwritten;
+        nwritten = _libssh2_channel_write(channel, 0,
+                                          sftp->stat_packet, packet_len);
+        if(nwritten == LIBSSH2_ERROR_EAGAIN) {
+            return (int)nwritten;
         }
-        else if(packet_len != rc) {
+        else if(packet_len != nwritten) {
             LIBSSH2_FREE(session, sftp->stat_packet);
             sftp->stat_packet = NULL;
             sftp->stat_state = libssh2_NB_state_idle;
@@ -3528,7 +3743,7 @@ static int sftp_stat(LIBSSH2_SFTP *sftp, const char *path,
     sftp->stat_state = libssh2_NB_state_idle;
 
     if(data[0] == SSH_FXP_STATUS) {
-        int retcode;
+        uint32_t retcode;
 
         retcode = _libssh2_ntohu32(data + 5);
         LIBSSH2_FREE(session, data);
@@ -3580,22 +3795,25 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
 {
     LIBSSH2_CHANNEL *channel = sftp->channel;
     LIBSSH2_SESSION *session = channel->session;
-    size_t data_len, link_len;
+    size_t data_len = 0, link_len;
     /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
     ssize_t packet_len =
         path_len + 13 +
         ((link_type == LIBSSH2_SFTP_SYMLINK) ? (4 + target_len) : 0);
-    unsigned char *s, *data;
+    unsigned char *s, *data = NULL;
     static const unsigned char link_responses[2] =
         { SSH_FXP_NAME, SSH_FXP_STATUS };
     int retcode;
 
-    if((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) {
-        return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
-                              "Server does not support SYMLINK or READLINK");
-    }
-
     if(sftp->symlink_state == libssh2_NB_state_idle) {
+        sftp->last_errno = LIBSSH2_FX_OK;
+
+        if((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) {
+            return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
+                                  "Server does not support SYMLINK or"
+                                  " READLINK");
+        }
+
         s = sftp->symlink_packet = LIBSSH2_ALLOC(session, packet_len);
         if(!sftp->symlink_packet) {
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -3603,13 +3821,14 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
                                   "SYMLINK/READLINK/REALPATH packet");
         }
 
-        _libssh2_debug(session, LIBSSH2_TRACE_SFTP, "%s %s on %s",
+        _libssh2_debug((session, LIBSSH2_TRACE_SFTP, "%s %s on %s",
                        (link_type ==
                         LIBSSH2_SFTP_SYMLINK) ? "Creating" : "Reading",
                        (link_type ==
-                        LIBSSH2_SFTP_REALPATH) ? "realpath" : "symlink", path);
+                        LIBSSH2_SFTP_REALPATH) ? "realpath" : "symlink",
+                       path));
 
-        _libssh2_store_u32(&s, packet_len - 4);
+        _libssh2_store_u32(&s, (uint32_t)(packet_len - 4));
 
         switch(link_type) {
         case LIBSSH2_SFTP_REALPATH:
@@ -3638,7 +3857,7 @@ static int sftp_symlink(LIBSSH2_SFTP *sftp, const char *path,
         ssize_t rc = _libssh2_channel_write(channel, 0, sftp->symlink_packet,
                                             packet_len);
         if(rc == LIBSSH2_ERROR_EAGAIN)
-            return rc;
+            return (int)rc;
         else if(packet_len != rc) {
             LIBSSH2_FREE(session, sftp->symlink_packet);
             sftp->symlink_packet = NULL;
diff --git a/libssh2/src/sftp.h b/libssh2/src/sftp.h
index 129b8f08..264f823b 100644
--- a/libssh2/src/sftp.h
+++ b/libssh2/src/sftp.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_SFTP_H
-#define __LIBSSH2_SFTP_H
+#ifndef LIBSSH2_SFTP_PRIV_H
+#define LIBSSH2_SFTP_PRIV_H
 /*
- * Copyright (C) 2010 - 2012 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
+ * Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -37,6 +37,7 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 /*
@@ -67,10 +68,6 @@ struct sftp_zombie_requests {
     uint32_t request_id;
 };
 
-#ifndef MIN
-#define MIN(x,y) ((x)<(y)?(x):(y))
-#endif
-
 struct _LIBSSH2_SFTP_PACKET
 {
     struct list_node node;   /* linked list header */
@@ -81,7 +78,8 @@ struct _LIBSSH2_SFTP_PACKET
 
 typedef struct _LIBSSH2_SFTP_PACKET LIBSSH2_SFTP_PACKET;
 
-#define SFTP_HANDLE_MAXLEN 256 /* according to spec! */
+/* Increasing from 256 to 4092 since OpenSSH doesn't honor it. */
+#define SFTP_HANDLE_MAXLEN 4092 /* according to spec, this should be 256! */
 
 struct _LIBSSH2_SFTP_HANDLE
 {
@@ -140,7 +138,7 @@ struct _LIBSSH2_SFTP
 {
     LIBSSH2_CHANNEL *channel;
 
-    uint32_t request_id, version;
+    uint32_t request_id, version, posix_rename_version;
 
     struct list_head packets;
 
@@ -153,9 +151,10 @@ struct _LIBSSH2_SFTP
     uint32_t last_errno;
 
     /* Holder for partial packet, use in libssh2_sftp_packet_read() */
-    unsigned char partial_size[4];      /* buffer for size field   */
-    size_t partial_size_len;            /* size field length       */
-    unsigned char *partial_packet;      /* The data                */
+    unsigned char packet_header[9];
+    /* packet size (4) packet type (1) request id (4) */
+    size_t packet_header_len;           /* packet_header length    */
+    unsigned char *partial_packet;      /* The data, with header   */
     uint32_t partial_len;               /* Desired number of bytes */
     size_t partial_received;            /* Bytes received so far   */
 
@@ -204,6 +203,11 @@ struct _LIBSSH2_SFTP
     unsigned char *rename_s;
     uint32_t rename_request_id;
 
+    /* State variables used in libssh2_sftp_posix_rename_ex() */
+    libssh2_nonblocking_states posix_rename_state;
+    unsigned char *posix_rename_packet;
+    uint32_t posix_rename_request_id;
+
     /* State variables used in libssh2_sftp_fstatvfs() */
     libssh2_nonblocking_states fstatvfs_state;
     unsigned char *fstatvfs_packet;
@@ -235,4 +239,4 @@ struct _LIBSSH2_SFTP
     uint32_t symlink_request_id;
 };
 
-#endif /* __LIBSSH2_SFTP_H */
+#endif /* LIBSSH2_SFTP_PRIV_H */
diff --git a/libssh2/src/transport.c b/libssh2/src/transport.c
index 17af3e4d..e1120656 100644
--- a/libssh2/src/transport.c
+++ b/libssh2/src/transport.c
@@ -1,6 +1,6 @@
-/* Copyright (C) 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2009-2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
+/* Copyright (C) The Written Word, Inc.
+ * Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -35,25 +35,22 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/*
  * This file handles reading and writing to the SECSH transport layer. RFC4253.
  */
 
 #include "libssh2_priv.h"
+
 #include <errno.h>
-#include <fcntl.h>
 #include <ctype.h>
-#ifdef LIBSSH2DEBUG
-#include <stdio.h>
-#endif
-
 #include <assert.h>
 
 #include "transport.h"
 #include "mac.h"
 
-#define MAX_BLOCKSIZE 32    /* MUST fit biggest crypto block size we use/get */
-#define MAX_MACSIZE 64      /* MUST fit biggest MAC length we support */
-
 #ifdef LIBSSH2DEBUG
 #define UNPRINTABLE_CHAR '.'
 static void
@@ -72,8 +69,8 @@ debugdump(LIBSSH2_SESSION * session,
         return;
     }
 
-    used = snprintf(buffer, sizeof(buffer), "=> %s (%d bytes)\n",
-                    desc, (int) size);
+    used = snprintf(buffer, sizeof(buffer), "=> %s (%lu bytes)\n",
+                    desc, (unsigned long) size);
     if(session->tracehandler)
         (session->tracehandler)(session, session->tracehandler_context,
                                 buffer, used);
@@ -118,29 +115,50 @@ debugdump(LIBSSH2_SESSION * session,
     }
 }
 #else
-#define debugdump(a,x,y,z)
+#define debugdump(a,x,y,z) do {} while(0)
 #endif
 
 
-/* decrypt() decrypts 'len' bytes from 'source' to 'dest'.
+/* decrypt() decrypts 'len' bytes from 'source' to 'dest' in units of
+ * blocksize.
  *
  * returns 0 on success and negative on failure
  */
 
 static int
 decrypt(LIBSSH2_SESSION * session, unsigned char *source,
-        unsigned char *dest, int len)
+        unsigned char *dest, ssize_t len, int firstlast)
 {
     struct transportpacket *p = &session->packet;
     int blocksize = session->remote.crypt->blocksize;
 
     /* if we get called with a len that isn't an even number of blocksizes
-       we risk losing those extra bytes */
-    assert((len % blocksize) == 0);
+       we risk losing those extra bytes. AAD is an exception, since those first
+       few bytes aren't encrypted so it throws off the rest of the count. */
+    if(!CRYPT_FLAG_L(session, PKTLEN_AAD))
+        assert((len % blocksize) == 0);
+
+    while(len > 0) {
+        /* normally decrypt up to blocksize bytes at a time */
+        ssize_t decryptlen = LIBSSH2_MIN(blocksize, len);
+        /* The first block is special (since it needs to be decoded to get the
+           length of the remainder of the block) and takes priority. When the
+           length finally gets to the last blocksize bytes, and there's no
+           more data to come, it's the end. */
+        int lowerfirstlast = IS_FIRST(firstlast) ? FIRST_BLOCK :
+            ((len <= blocksize) ? firstlast : MIDDLE_BLOCK);
+        /* If the last block would be less than a whole blocksize, combine it
+           with the previous block to make it larger. This ensures that the
+           whole MAC is included in a single decrypt call. */
+        if(CRYPT_FLAG_L(session, PKTLEN_AAD) && IS_LAST(firstlast)
+           && (len < blocksize*2)) {
+            decryptlen = len;
+            lowerfirstlast = LAST_BLOCK;
+        }
 
-    while(len >= blocksize) {
-        if(session->remote.crypt->crypt(session, source, blocksize,
-                                         &session->remote.crypt_abstract)) {
+        if(session->remote.crypt->crypt(session, 0, source, decryptlen,
+                                        &session->remote.crypt_abstract,
+                                        lowerfirstlast)) {
             LIBSSH2_FREE(session, p->payload);
             return LIBSSH2_ERROR_DECRYPT;
         }
@@ -148,11 +166,11 @@ decrypt(LIBSSH2_SESSION * session, unsigned char *source,
         /* if the crypt() function would write to a given address it
            wouldn't have to memcpy() and we could avoid this memcpy()
            too */
-        memcpy(dest, source, blocksize);
+        memcpy(dest, source, decryptlen);
 
-        len -= blocksize;       /* less bytes left */
-        dest += blocksize;      /* advance write pointer */
-        source += blocksize;    /* advance read pointer */
+        len -= decryptlen;       /* less bytes left */
+        dest += decryptlen;      /* advance write pointer */
+        source += decryptlen;    /* advance read pointer */
     }
     return LIBSSH2_ERROR_NONE;         /* all is fine */
 }
@@ -168,30 +186,101 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
     struct transportpacket *p = &session->packet;
     int rc;
     int compressed;
+    const LIBSSH2_MAC_METHOD *remote_mac = NULL;
+    uint32_t seq = session->remote.seqno;
+
+    if(!encrypted || (!CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET) &&
+                      !CRYPT_FLAG_R(session, INTEGRATED_MAC))) {
+        remote_mac = session->remote.mac;
+    }
 
     if(session->fullpacket_state == libssh2_NB_state_idle) {
         session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED;
         session->fullpacket_payload_len = p->packet_length - 1;
 
-        if(encrypted) {
+        if(encrypted && remote_mac) {
 
             /* Calculate MAC hash */
-            session->remote.mac->hash(session, macbuf,  /* store hash here */
-                                      session->remote.seqno,
-                                      p->init, 5,
-                                      p->payload,
-                                      session->fullpacket_payload_len,
-                                      &session->remote.mac_abstract);
+            int etm = remote_mac->etm;
+            size_t mac_len = remote_mac->mac_len;
+            if(etm) {
+                /* store hash here */
+                remote_mac->hash(session, macbuf,
+                                 session->remote.seqno,
+                                 p->payload, p->total_num - mac_len,
+                                 NULL, 0,
+                                 &session->remote.mac_abstract);
+            }
+            else {
+                /* store hash here */
+                remote_mac->hash(session, macbuf,
+                                 session->remote.seqno,
+                                 p->init, 5,
+                                 p->payload,
+                                 session->fullpacket_payload_len,
+                                 &session->remote.mac_abstract);
+            }
 
             /* Compare the calculated hash with the MAC we just read from
              * the network. The read one is at the very end of the payload
              * buffer. Note that 'payload_len' here is the packet_length
              * field which includes the padding but not the MAC.
              */
-            if(memcmp(macbuf, p->payload + session->fullpacket_payload_len,
-                       session->remote.mac->mac_len)) {
+            if(memcmp(macbuf, p->payload + p->total_num - mac_len, mac_len)) {
+                _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                               "Failed MAC check"));
                 session->fullpacket_macstate = LIBSSH2_MAC_INVALID;
+
             }
+            else if(etm) {
+                /* MAC was ok and we start by decrypting the first block that
+                   contains padding length since this allows us to decrypt
+                   all other blocks to the right location in memory
+                   avoiding moving a larger block of memory one byte. */
+                unsigned char first_block[MAX_BLOCKSIZE];
+                ssize_t decrypt_size;
+                unsigned char *decrypt_buffer;
+                int blocksize = session->remote.crypt->blocksize;
+
+                rc = decrypt(session, p->payload + 4,
+                             first_block, blocksize, FIRST_BLOCK);
+                if(rc) {
+                    return rc;
+                }
+
+                /* we need buffer for decrypt */
+                decrypt_size = p->total_num - mac_len - 4;
+                decrypt_buffer = LIBSSH2_ALLOC(session, decrypt_size);
+                if(!decrypt_buffer) {
+                    return LIBSSH2_ERROR_ALLOC;
+                }
+
+                /* grab padding length and copy anything else
+                   into target buffer */
+                p->padding_length = first_block[0];
+                if(blocksize > 1) {
+                    memcpy(decrypt_buffer, first_block + 1, blocksize - 1);
+                }
+
+                /* decrypt all other blocks packet */
+                if(blocksize < decrypt_size) {
+                    rc = decrypt(session, p->payload + blocksize + 4,
+                                 decrypt_buffer + blocksize - 1,
+                                 decrypt_size - blocksize, LAST_BLOCK);
+                    if(rc) {
+                        LIBSSH2_FREE(session, decrypt_buffer);
+                        return rc;
+                    }
+                }
+
+                /* replace encrypted payload with plain text payload */
+                LIBSSH2_FREE(session, p->payload);
+                p->payload = decrypt_buffer;
+            }
+        }
+        else if(encrypted && CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+            /* etm trim off padding byte from payload */
+            memmove(p->payload, &p->payload[1], p->packet_length - 1);
         }
 
         session->remote.seqno++;
@@ -200,11 +289,10 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
         session->fullpacket_payload_len -= p->padding_length;
 
         /* Check for and deal with decompression */
-        compressed =
-            session->local.comp != NULL &&
-            session->local.comp->compress &&
-            ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
-             session->local.comp->use_in_auth);
+        compressed = session->local.comp &&
+                     session->local.comp->compress &&
+                     ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
+                      session->local.comp->use_in_auth);
 
         if(compressed && session->remote.comp_abstract) {
             /*
@@ -240,7 +328,7 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
     if(session->fullpacket_state == libssh2_NB_state_created) {
         rc = _libssh2_packet_add(session, p->payload,
                                  session->fullpacket_payload_len,
-                                 session->fullpacket_macstate);
+                                 session->fullpacket_macstate, seq);
         if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
         if(rc) {
@@ -251,6 +339,11 @@ fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
 
     session->fullpacket_state = libssh2_NB_state_idle;
 
+    if(session->kex_strict &&
+        session->fullpacket_packet_type == SSH_MSG_NEWKEYS) {
+        session->remote.seqno = 0;
+    }
+
     return session->fullpacket_packet_type;
 }
 
@@ -274,13 +367,21 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
 {
     int rc;
     struct transportpacket *p = &session->packet;
-    int remainbuf;
-    int remainpack;
-    int numbytes;
-    int numdecrypt;
-    unsigned char block[MAX_BLOCKSIZE];
-    int blocksize;
-    int encrypted = 1;
+    ssize_t remainpack; /* how much there is left to add to the current payload
+                           package */
+    ssize_t remainbuf;  /* how much data there is remaining in the buffer to
+                           deal with before we should read more from the
+                           network */
+    ssize_t numbytes;   /* how much data to deal with from the buffer on this
+                           iteration through the loop */
+    ssize_t numdecrypt; /* number of bytes to decrypt this iteration */
+    unsigned char block[MAX_BLOCKSIZE]; /* working block buffer */
+    int blocksize;  /* minimum number of bytes we need before we can
+                       use them */
+    int encrypted = 1; /* whether the packet is encrypted or not */
+    int firstlast = FIRST_BLOCK; /* if the first or last block to decrypt */
+    unsigned int auth_len = 0; /* length of the authentication tag */
+    const LIBSSH2_MAC_METHOD *remote_mac = NULL; /* The remote MAC, if used */
 
     /* default clear the bit */
     session->socket_block_directions &= ~LIBSSH2_SESSION_BLOCK_INBOUND;
@@ -303,8 +404,8 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         /* Whoever wants a packet won't get anything until the key re-exchange
          * is done!
          */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
-                       " key re-exchange from _libssh2_transport_read");
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
+                       " key re-exchange from _libssh2_transport_read"));
         rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
         if(rc)
             return rc;
@@ -322,6 +423,7 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
     }
 
     do {
+        int etm;
         if(session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
             return LIBSSH2_ERROR_SOCKET_DISCONNECT;
         }
@@ -335,6 +437,17 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                                    make the checks below work fine still */
         }
 
+        if(encrypted) {
+            if(CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+                auth_len = session->remote.crypt->auth_len;
+            }
+            else {
+                remote_mac = session->remote.mac;
+            }
+        }
+
+        etm = encrypted && remote_mac ? remote_mac->etm : 0;
+
         /* read/use a whole big chunk into a temporary area stored in
            the LIBSSH2_SESSION struct. We will decrypt data from that
            buffer into the packet buffer so this temp one doesn't have
@@ -348,7 +461,9 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         /* if remainbuf turns negative we have a bad internal error */
         assert(remainbuf >= 0);
 
-        if(remainbuf < blocksize) {
+        if(remainbuf < blocksize ||
+           (CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)
+            && ((ssize_t)p->total_num) > remainbuf)) {
             /* If we have less than a blocksize left, it is too
                little data to deal with, read more */
             ssize_t nread;
@@ -366,10 +481,9 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
             }
 
             /* now read a big chunk from the network into the temp buffer */
-            nread =
-                LIBSSH2_RECV(session, &p->buf[remainbuf],
-                              PACKETBUFSIZE - remainbuf,
-                              LIBSSH2_SOCKET_RECV_FLAGS(session));
+            nread = LIBSSH2_RECV(session, &p->buf[remainbuf],
+                                 PACKETBUFSIZE - remainbuf,
+                                 LIBSSH2_SOCKET_RECV_FLAGS(session));
             if(nread <= 0) {
                 /* check if this is due to EAGAIN and return the special
                    return code if so, error out normally otherwise */
@@ -378,14 +492,16 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                         LIBSSH2_SESSION_BLOCK_INBOUND;
                     return LIBSSH2_ERROR_EAGAIN;
                 }
-                _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                               "Error recving %d bytes (got %d)",
-                               PACKETBUFSIZE - remainbuf, -nread);
+                _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                               "Error recving %ld bytes (got %ld)",
+                               (long)(PACKETBUFSIZE - remainbuf),
+                               (long)-nread));
                 return LIBSSH2_ERROR_SOCKET_RECV;
             }
-            _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                           "Recved %d/%d bytes to %p+%d", nread,
-                           PACKETBUFSIZE - remainbuf, p->buf, remainbuf);
+            _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                           "Recved %ld/%ld bytes to %p+%ld", (long)nread,
+                           (long)(PACKETBUFSIZE - remainbuf), (void *)p->buf,
+                           (long)remainbuf));
 
             debugdump(session, "libssh2_transport_read() raw",
                       &p->buf[remainbuf], nread);
@@ -400,13 +516,19 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
         numbytes = remainbuf;
 
         if(!p->total_num) {
-            size_t total_num;
+            size_t total_num; /* the number of bytes following the initial
+                                 (5 bytes) packet length and padding length
+                                 fields */
+
+            /* packet length is not encrypted in encode-then-mac mode
+               and we donøt need to decrypt first block */
+            ssize_t required_size = etm ? 4 : blocksize;
 
             /* No payload package area allocated yet. To know the
-               size of this payload, we need to decrypt the first
+               size of this payload, we need enough to decrypt the first
                blocksize data. */
 
-            if(numbytes < blocksize) {
+            if(numbytes < required_size) {
                 /* we can't act on anything less than blocksize, but this
                    check is only done for the initial block since once we have
                    got the start of a block we can in fact deal with fractions
@@ -416,46 +538,121 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
                 return LIBSSH2_ERROR_EAGAIN;
             }
 
-            if(encrypted) {
-                rc = decrypt(session, &p->buf[p->readidx], block, blocksize);
+            if(etm) {
+                /* etm size field is not encrypted */
+                memcpy(block, &p->buf[p->readidx], 4);
+                memcpy(p->init, &p->buf[p->readidx], 4);
+            }
+            else if(encrypted && session->remote.crypt->get_len) {
+                unsigned int len = 0;
+                unsigned char *ptr = NULL;
+
+                rc = session->remote.crypt->get_len(session,
+                                            session->remote.seqno,
+                                            &p->buf[p->readidx],
+                                            numbytes,
+                                            &len,
+                                            &session->remote.crypt_abstract);
+
                 if(rc != LIBSSH2_ERROR_NONE) {
+                    p->total_num = 0;   /* no packet buffer available */
+                    if(p->payload)
+                        LIBSSH2_FREE(session, p->payload);
+                    p->payload = NULL;
                     return rc;
                 }
-                /* save the first 5 bytes of the decrypted package, to be
-                   used in the hash calculation later down. */
-                memcpy(p->init, block, 5);
+
+                /* store size in buffers for use below */
+                ptr = &block[0];
+                _libssh2_store_u32(&ptr, len);
+
+                ptr = &p->init[0];
+                _libssh2_store_u32(&ptr, len);
             }
             else {
-                /* the data is plain, just copy it verbatim to
-                   the working block buffer */
-                memcpy(block, &p->buf[p->readidx], blocksize);
-            }
+                if(encrypted) {
+                    /* first decrypted block */
+                    rc = decrypt(session, &p->buf[p->readidx],
+                                 block, blocksize, FIRST_BLOCK);
+                    if(rc != LIBSSH2_ERROR_NONE) {
+                        return rc;
+                    }
+                    /* Save the first 5 bytes of the decrypted package, to be
+                       used in the hash calculation later down.
+                       This is ignored in the INTEGRATED_MAC case. */
+                    memcpy(p->init, block, 5);
+                }
+                else {
+                    /* the data is plain, just copy it verbatim to
+                       the working block buffer */
+                    memcpy(block, &p->buf[p->readidx], blocksize);
+                }
 
-            /* advance the read pointer */
-            p->readidx += blocksize;
+                /* advance the read pointer */
+                p->readidx += blocksize;
 
-            /* we now have the initial blocksize bytes decrypted,
-             * and we can extract packet and padding length from it
-             */
-            p->packet_length = _libssh2_ntohu32(block);
-            if(p->packet_length < 1) {
-                return LIBSSH2_ERROR_DECRYPT;
-            }
-            else if(p->packet_length > LIBSSH2_PACKET_MAXPAYLOAD) {
-                return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
+                /* we now have the initial blocksize bytes decrypted,
+                 * and we can extract packet and padding length from it
+                 */
+                p->packet_length = _libssh2_ntohu32(block);
             }
 
-            p->padding_length = block[4];
-            if(p->padding_length > p->packet_length - 1) {
-                return LIBSSH2_ERROR_DECRYPT;
+            if(!encrypted || !CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+                if(p->packet_length < 1) {
+                    return LIBSSH2_ERROR_DECRYPT;
+                }
+                else if(p->packet_length > LIBSSH2_PACKET_MAXPAYLOAD) {
+                    return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
+                }
+
+                if(etm) {
+                    /* we collect entire undecrypted packet including the
+                     packet length field that we run MAC over */
+                    p->packet_length = _libssh2_ntohu32(block);
+                    total_num = 4 + p->packet_length +
+                    remote_mac->mac_len;
+                }
+                else {
+                    /* padding_length has not been authenticated yet, but it
+                     won't actually be used (except for the sanity check
+                     immediately following) until after the entire packet is
+                     authenticated, so this is safe. */
+                    p->padding_length = block[4];
+                    if(p->padding_length > p->packet_length - 1) {
+                        return LIBSSH2_ERROR_DECRYPT;
+                    }
+
+                    /* total_num is the number of bytes following the initial
+                     (5 bytes) packet length and padding length fields */
+                    total_num = p->packet_length - 1 +
+                    (encrypted ? remote_mac->mac_len : 0);
+                }
             }
+            else {
+                /* advance the read pointer past size field if the packet
+                 length is not required for decryption */
+
+                /* add size field to be included in total packet size
+                 * calculation so it doesn't get dropped off on subsequent
+                 * partial reads
+                 */
+                total_num = 4;
 
+                p->packet_length = _libssh2_ntohu32(block);
+                if(p->packet_length < 1)
+                    return LIBSSH2_ERROR_DECRYPT;
 
-            /* total_num is the number of bytes following the initial
-               (5 bytes) packet length and padding length fields */
-            total_num =
-                p->packet_length - 1 +
-                (encrypted ? session->remote.mac->mac_len : 0);
+                /* total_num may include size field, however due to existing
+                 * logic it needs to be removed after the entire packet is read
+                 */
+
+                total_num += p->packet_length +
+                    (remote_mac ? remote_mac->mac_len : 0) + auth_len;
+
+                /* don't know what padding is until we decrypt the full
+                   packet */
+                p->padding_length = 0;
+            }
 
             /* RFC4253 section 6.1 Maximum Packet Length says:
              *
@@ -479,27 +676,42 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
             /* init write pointer to start of payload buffer */
             p->wptr = p->payload;
 
-            if(blocksize > 5) {
-                /* copy the data from index 5 to the end of
-                   the blocksize from the temporary buffer to
-                   the start of the decrypted buffer */
-                if(blocksize - 5 <= (int) total_num) {
-                    memcpy(p->wptr, &block[5], blocksize - 5);
-                    p->wptr += blocksize - 5;       /* advance write pointer */
-                }
-                else {
-                    if(p->payload)
-                        LIBSSH2_FREE(session, p->payload);
-                    return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
+            if(!encrypted || !CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+                if(!etm && blocksize > 5) {
+                    /* copy the data from index 5 to the end of
+                     the blocksize from the temporary buffer to
+                     the start of the decrypted buffer */
+                    if(blocksize - 5 <= (int) total_num) {
+                        memcpy(p->wptr, &block[5], blocksize - 5);
+                        p->wptr += blocksize - 5; /* advance write pointer */
+                        if(etm) {
+                            /* advance past unencrypted packet length */
+                            p->wptr += 4;
+                        }
+                    }
+                    else {
+                        if(p->payload)
+                            LIBSSH2_FREE(session, p->payload);
+                        return LIBSSH2_ERROR_OUT_OF_BOUNDARY;
+                    }
                 }
-            }
 
-            /* init the data_num field to the number of bytes of
-               the package read so far */
-            p->data_num = p->wptr - p->payload;
+                /* init the data_num field to the number of bytes of
+                 the package read so far */
+                p->data_num = p->wptr - p->payload;
+
+                /* we already dealt with a blocksize worth of data */
+                if(!etm)
+                    numbytes -= blocksize;
+            }
+            else {
+                /* haven't started reading payload yet */
+                p->data_num = 0;
 
-            /* we already dealt with a blocksize worth of data */
-            numbytes -= blocksize;
+                /* we already dealt with packet size worth of data */
+                if(!encrypted)
+                    numbytes -= 4;
+            }
         }
 
         /* how much there is left to add to the current payload
@@ -512,45 +724,110 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
             numbytes = remainpack;
         }
 
-        if(encrypted) {
+        if(encrypted && CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+            if(numbytes < remainpack) {
+                /* need a full packet before checking MAC */
+                session->socket_block_directions |=
+                LIBSSH2_SESSION_BLOCK_INBOUND;
+                return LIBSSH2_ERROR_EAGAIN;
+            }
+
+            /* we have a full packet, now remove the size field from numbytes
+               and total_num to process only the packet data */
+            numbytes -= 4;
+            p->total_num -= 4;
+        }
+
+        if(encrypted && !etm) {
             /* At the end of the incoming stream, there is a MAC,
                and we don't want to decrypt that since we need it
                "raw". We MUST however decrypt the padding data
                since it is used for the hash later on. */
-            int skip = session->remote.mac->mac_len;
+            int skip = (remote_mac ? remote_mac->mac_len : 0) + auth_len;
+
+            if(CRYPT_FLAG_R(session, INTEGRATED_MAC))
+                /* This crypto method DOES need the MAC to go through
+                   decryption so it can be authenticated. */
+                skip = 0;
 
             /* if what we have plus numbytes is bigger than the
                total minus the skip margin, we should lower the
                amount to decrypt even more */
-            if((p->data_num + numbytes) > (p->total_num - skip)) {
-                numdecrypt = (p->total_num - skip) - p->data_num;
+            if((p->data_num + numbytes) >= (p->total_num - skip)) {
+                /* decrypt the entire rest of the package */
+                numdecrypt = LIBSSH2_MAX(0,
+                    (int)(p->total_num - skip) - (int)p->data_num);
+                firstlast = LAST_BLOCK;
             }
             else {
-                int frac;
+                ssize_t frac;
                 numdecrypt = numbytes;
                 frac = numdecrypt % blocksize;
                 if(frac) {
-                    /* not an aligned amount of blocks,
-                       align it */
+                    /* not an aligned amount of blocks, align it by reducing
+                       the number of bytes processed this loop */
                     numdecrypt -= frac;
                     /* and make it no unencrypted data
                        after it */
                     numbytes = 0;
                 }
+                if(CRYPT_FLAG_R(session, INTEGRATED_MAC)) {
+                    /* Make sure that we save enough bytes to make the last
+                     * block large enough to hold the entire integrated MAC */
+                    numdecrypt = LIBSSH2_MIN(numdecrypt,
+                        (int)(p->total_num - skip - blocksize - p->data_num));
+                    numbytes = 0;
+                }
+                firstlast = MIDDLE_BLOCK;
             }
         }
         else {
             /* unencrypted data should not be decrypted at all */
             numdecrypt = 0;
         }
+        assert(numdecrypt >= 0);
 
         /* if there are bytes to decrypt, do that */
         if(numdecrypt > 0) {
             /* now decrypt the lot */
-            rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt);
-            if(rc != LIBSSH2_ERROR_NONE) {
-                p->total_num = 0;   /* no packet buffer available */
-                return rc;
+            if(CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+                rc = session->remote.crypt->crypt(session,
+                                               session->remote.seqno,
+                                               &p->buf[p->readidx],
+                                               numdecrypt,
+                                               &session->remote.crypt_abstract,
+                                               0);
+
+                if(rc != LIBSSH2_ERROR_NONE) {
+                    p->total_num = 0;   /* no packet buffer available */
+                    return rc;
+                }
+
+                memcpy(p->wptr, &p->buf[p->readidx], numbytes);
+
+                /* advance read index past size field now that we've decrypted
+                   full packet */
+                p->readidx += 4;
+
+                /* include auth tag in bytes decrypted */
+                numdecrypt += auth_len;
+
+                /* set padding now that the packet has been verified and
+                   decrypted */
+                p->padding_length = p->wptr[0];
+
+                if(p->padding_length > p->packet_length - 1) {
+                    return LIBSSH2_ERROR_DECRYPT;
+                }
+            }
+            else {
+                rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt,
+                             firstlast);
+
+                if(rc != LIBSSH2_ERROR_NONE) {
+                    p->total_num = 0;   /* no packet buffer available */
+                    return rc;
+                }
             }
 
             /* advance the read pointer */
@@ -564,11 +841,11 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
             numbytes -= numdecrypt;
         }
 
-        /* if there are bytes to copy that aren't decrypted, simply
+        /* if there are bytes to copy that aren't decrypted,
            copy them as-is to the target buffer */
         if(numbytes > 0) {
 
-            if(numbytes <= (int)(p->total_num - (p->wptr - p->payload))) {
+            if((size_t)numbytes <= (p->total_num - (p->wptr - p->payload))) {
                 memcpy(p->wptr, &p->buf[p->readidx], numbytes);
             }
             else {
@@ -591,13 +868,13 @@ int _libssh2_transport_read(LIBSSH2_SESSION * session)
 
         if(!remainpack) {
             /* we have a full packet */
-          libssh2_transport_read_point1:
+libssh2_transport_read_point1:
             rc = fullpacket(session, encrypted);
             if(rc == LIBSSH2_ERROR_EAGAIN) {
 
                 if(session->packAdd_state != libssh2_NB_state_idle) {
                     /* fullpacket only returns LIBSSH2_ERROR_EAGAIN if
-                     * libssh2_packet_add returns LIBSSH2_ERROR_EAGAIN. If
+                     * libssh2_packet_add() returns LIBSSH2_ERROR_EAGAIN. If
                      * that returns LIBSSH2_ERROR_EAGAIN but the packAdd_state
                      * is idle, then the packet has been added to the brigade,
                      * but some immediate action that was taken based on the
@@ -641,7 +918,9 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
            we don't add this one up until the previous one has been sent. To
            make the caller really notice his/hers flaw, we return error for
            this case */
-        return LIBSSH2_ERROR_BAD_USE;
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Address is different, returning EAGAIN"));
+        return LIBSSH2_ERROR_EAGAIN;
     }
 
     *ret = 1;                   /* set to make our parent return */
@@ -650,14 +929,15 @@ send_existing(LIBSSH2_SESSION *session, const unsigned char *data,
     length = p->ototal_num - p->osent;
 
     rc = LIBSSH2_SEND(session, &p->outbuf[p->osent], length,
-                       LIBSSH2_SOCKET_SEND_FLAGS(session));
+                      LIBSSH2_SOCKET_SEND_FLAGS(session));
     if(rc < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d", length, -rc);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Error sending %ld bytes: %ld",
+                       (long)length, (long)-rc));
     else {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Sent %d/%d bytes at %p+%d", rc, length, p->outbuf,
-                       p->osent);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Sent %ld/%ld bytes at %p+%lu", (long)rc, (long)length,
+                       (void *)p->outbuf, (unsigned long)p->osent));
         debugdump(session, "libssh2_transport_write send()",
                   &p->outbuf[p->osent], rc);
     }
@@ -712,20 +992,24 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
     int blocksize =
         (session->state & LIBSSH2_STATE_NEWKEYS) ?
         session->local.crypt->blocksize : 8;
-    int padding_length;
+    ssize_t padding_length;
     size_t packet_length;
-    int total_length;
-#ifdef RANDOM_PADDING
+    ssize_t total_length;
+#ifdef LIBSSH2_RANDOM_PADDING
     int rand_max;
     int seed = data[0];         /* FIXME: make this random */
 #endif
     struct transportpacket *p = &session->packet;
     int encrypted;
     int compressed;
+    int etm;
     ssize_t ret;
     int rc;
     const unsigned char *orgdata = data;
+    const LIBSSH2_MAC_METHOD *local_mac = NULL;
+    unsigned int auth_len = 0;
     size_t orgdata_len = data_len;
+    size_t crypt_offset, etm_crypt_offset;
 
     /*
      * If the last read operation was interrupted in the middle of a key
@@ -738,8 +1022,8 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
         /* Don't write any new packets if we're still in the middle of a key
          * exchange. */
-        _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
-                       " key re-exchange from _libssh2_transport_send");
+        _libssh2_debug((session, LIBSSH2_TRACE_TRANS, "Redirecting into the"
+                       " key re-exchange from _libssh2_transport_send"));
         rc = _libssh2_kex_exchange(session, 1, &session->startup_key_state);
         if(rc)
             return rc;
@@ -750,7 +1034,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         debugdump(session, "libssh2_transport_write plain2", data2, data2_len);
 
     /* FIRST, check if we have a pending write to complete. send_existing
-       only sanity-check data and data_len and not data2 and data2_len!! */
+       only sanity-check data and data_len and not data2 and data2_len! */
     rc = send_existing(session, data, data_len, &ret);
     if(rc)
         return rc;
@@ -763,11 +1047,20 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
 
     encrypted = (session->state & LIBSSH2_STATE_NEWKEYS) ? 1 : 0;
 
-    compressed =
-        session->local.comp != NULL &&
-        session->local.comp->compress &&
-        ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
-         session->local.comp->use_in_auth);
+    if(encrypted && session->local.crypt &&
+        CRYPT_FLAG_R(session, REQUIRES_FULL_PACKET)) {
+        auth_len = session->local.crypt->auth_len;
+    }
+    else {
+        local_mac = session->local.mac;
+    }
+
+    etm = encrypted && local_mac ? local_mac->etm : 0;
+
+    compressed = session->local.comp &&
+                 session->local.comp->compress &&
+                 ((session->state & LIBSSH2_STATE_AUTHENTICATED) ||
+                  session->local.comp->use_in_auth);
 
     if(encrypted && compressed && session->local.comp_abstract) {
         /* the idea here is that these function must fail if the output gets
@@ -825,12 +1118,18 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
 
     packet_length = data_len + 1 + 4;   /* 1 is for padding_length field
                                            4 for the packet_length field */
+    /* subtract 4 bytes of the packet_length field when padding AES-GCM
+       or with ETM */
+    crypt_offset = (etm || auth_len ||
+                    (encrypted && CRYPT_FLAG_R(session, PKTLEN_AAD)))
+                   ? 4 : 0;
+    etm_crypt_offset = etm ? 4 : 0;
 
     /* at this point we have it all except the padding */
 
     /* first figure out our minimum padding amount to make it an even
        block size */
-    padding_length = blocksize - (packet_length % blocksize);
+    padding_length = blocksize - ((packet_length - crypt_offset) % blocksize);
 
     /* if the padding becomes too small we add another blocksize worth
        of it (taken from the original libssh2 where it didn't have any
@@ -838,7 +1137,7 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
     if(padding_length < 4) {
         padding_length += blocksize;
     }
-#ifdef RANDOM_PADDING
+#ifdef LIBSSH2_RANDOM_PADDING
     /* FIXME: we can add padding here, but that also makes the packets
        bigger etc */
 
@@ -853,11 +1152,13 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
 
     /* append the MAC length to the total_length size */
     total_length =
-        packet_length + (encrypted ? session->local.mac->mac_len : 0);
+        packet_length + (encrypted && local_mac ? local_mac->mac_len : 0);
+
+    total_length += auth_len;
 
     /* store packet_length, which is the size of the whole packet except
        the MAC and the packet_length field itself */
-    _libssh2_htonu32(p->outbuf, packet_length - 4);
+    _libssh2_htonu32(p->outbuf, (uint32_t)(packet_length - 4));
     /* store padding_length */
     p->outbuf[4] = (unsigned char)padding_length;
 
@@ -873,33 +1174,114 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
         /* Calculate MAC hash. Put the output at index packet_length,
            since that size includes the whole packet. The MAC is
            calculated on the entire unencrypted packet, including all
-           fields except the MAC field itself. */
-        session->local.mac->hash(session, p->outbuf + packet_length,
-                                 session->local.seqno, p->outbuf,
-                                 packet_length, NULL, 0,
-                                 &session->local.mac_abstract);
-
-        /* Encrypt the whole packet data, one block size at a time.
-           The MAC field is not encrypted. */
-        for(i = 0; i < packet_length; i += session->local.crypt->blocksize) {
-            unsigned char *ptr = &p->outbuf[i];
-            if(session->local.crypt->crypt(session, ptr,
-                                            session->local.crypt->blocksize,
-                                            &session->local.crypt_abstract))
-                return LIBSSH2_ERROR_ENCRYPT;     /* encryption failure */
+           fields except the MAC field itself. This is skipped in the
+           INTEGRATED_MAC case, where the crypto algorithm also does its
+           own hash. */
+        if(!etm && local_mac && !CRYPT_FLAG_L(session, INTEGRATED_MAC)) {
+            if(local_mac->hash(session, p->outbuf + packet_length,
+                               session->local.seqno, p->outbuf,
+                               packet_length, NULL, 0,
+                               &session->local.mac_abstract))
+                return _libssh2_error(session, LIBSSH2_ERROR_MAC_FAILURE,
+                                      "Failed to calculate MAC");
+        }
+
+        if(CRYPT_FLAG_L(session, REQUIRES_FULL_PACKET)) {
+            if(session->local.crypt->crypt(session,
+                                           session->local.seqno,
+                                           p->outbuf,
+                                           packet_length,
+                                           &session->local.crypt_abstract,
+                                           0)) {
+                return LIBSSH2_ERROR_ENCRYPT;
+            }
+        }
+        else {
+            /* Encrypt the whole packet data, one block size at a time.
+             The MAC field is not encrypted unless INTEGRATED_MAC. */
+            /* Some crypto back-ends could handle a single crypt() call for
+             encryption, but (presumably) others cannot, so break it up
+             into blocksize-sized chunks to satisfy them all. */
+            for(i = etm_crypt_offset; i < packet_length;
+                i += session->local.crypt->blocksize) {
+                unsigned char *ptr = &p->outbuf[i];
+                size_t bsize = LIBSSH2_MIN(session->local.crypt->blocksize,
+                                           (int)(packet_length-i));
+                /* The INTEGRATED_MAC case always has an extra call below, so
+                 it will never be LAST_BLOCK up here. */
+                int firstlast = i == 0 ? FIRST_BLOCK :
+                (!CRYPT_FLAG_L(session, INTEGRATED_MAC)
+                 && (i == packet_length - session->local.crypt->blocksize)
+                 ? LAST_BLOCK : MIDDLE_BLOCK);
+                /* In the AAD case, the last block would be only 4 bytes
+                 because everything is offset by 4 since the initial
+                 packet_length isn't encrypted. In this case, combine that last
+                 short packet with the previous one since AES-GCM crypt()
+                 assumes that the entire MAC is available in that packet so it
+                 can set that to the authentication tag. */
+                if(!CRYPT_FLAG_L(session, INTEGRATED_MAC))
+                    if(i > packet_length - 2*bsize) {
+                        /* increase the final block size */
+                        bsize = packet_length - i;
+                        /* advance the loop counter by the extra amount */
+                        i += bsize - session->local.crypt->blocksize;
+                    }
+                _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                                "crypting bytes %lu-%lu", (unsigned long)i,
+                                (unsigned long)(i + bsize - 1)));
+                if(session->local.crypt->crypt(session, 0, ptr,
+                                               bsize,
+                                               &session->local.crypt_abstract,
+                                               firstlast))
+                    return LIBSSH2_ERROR_ENCRYPT;     /* encryption failure */
+            }
+
+            /* Call crypt one last time so it can be filled in with the MAC */
+            if(CRYPT_FLAG_L(session, INTEGRATED_MAC)) {
+                int authlen = local_mac->mac_len;
+                assert((size_t)total_length <=
+                       packet_length + session->local.crypt->blocksize);
+                if(session->local.crypt->crypt(session,
+                                               0,
+                                               &p->outbuf[packet_length],
+                                               authlen,
+                                               &session->local.crypt_abstract,
+                                               LAST_BLOCK))
+                    return LIBSSH2_ERROR_ENCRYPT;     /* encryption failure */
+            }
+        }
+
+        if(etm) {
+            /* Calculate MAC hash. Put the output at index packet_length,
+               since that size includes the whole packet. The MAC is
+               calculated on the entire packet (length plain the rest
+               encrypted), including all fields except the MAC field
+               itself. */
+            if(local_mac->hash(session, p->outbuf + packet_length,
+                               session->local.seqno, p->outbuf,
+                               packet_length, NULL, 0,
+                               &session->local.mac_abstract))
+                return _libssh2_error(session, LIBSSH2_ERROR_MAC_FAILURE,
+                                      "Failed to calculate MAC");
         }
     }
 
     session->local.seqno++;
 
+    if(session->kex_strict && data[0] == SSH_MSG_NEWKEYS) {
+        session->local.seqno = 0;
+    }
+
     ret = LIBSSH2_SEND(session, p->outbuf, total_length,
-                        LIBSSH2_SOCKET_SEND_FLAGS(session));
+                       LIBSSH2_SOCKET_SEND_FLAGS(session));
     if(ret < 0)
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET,
-                       "Error sending %d bytes: %d", total_length, -ret);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Error sending %ld bytes: %ld",
+                       (long)total_length, (long)-ret));
     else {
-        _libssh2_debug(session, LIBSSH2_TRACE_SOCKET, "Sent %d/%d bytes at %p",
-                       ret, total_length, p->outbuf);
+        _libssh2_debug((session, LIBSSH2_TRACE_SOCKET,
+                       "Sent %ld/%ld bytes at %p",
+                       (long)ret, (long)total_length, (void *)p->outbuf));
         debugdump(session, "libssh2_transport_write send()", p->outbuf, ret);
     }
 
diff --git a/libssh2/src/transport.h b/libssh2/src/transport.h
index 7d395d0e..4b824e20 100644
--- a/libssh2/src/transport.h
+++ b/libssh2/src/transport.h
@@ -1,8 +1,8 @@
-#ifndef __LIBSSH2_TRANSPORT_H
-#define __LIBSSH2_TRANSPORT_H
-/* Copyright (C) 2007 The Written Word, Inc.  All rights reserved.
- * Copyright (C) 2009-2010 by Daniel Stenberg
- * Author: Daniel Stenberg <daniel@haxx.se>
+#ifndef LIBSSH2_TRANSPORT_H
+#define LIBSSH2_TRANSPORT_H
+/* Copyright (C) The Written Word, Inc.
+ * Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -38,12 +38,13 @@
  * OF SUCH DAMAGE.
  *
  * This file handles reading and writing to the SECSH transport layer. RFC4253.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
 #include "packet.h"
 
-
 /*
  * libssh2_transport_send
  *
@@ -83,4 +84,4 @@ int _libssh2_transport_send(LIBSSH2_SESSION *session,
  */
 int _libssh2_transport_read(LIBSSH2_SESSION * session);
 
-#endif /* __LIBSSH2_TRANSPORT_H */
+#endif /* LIBSSH2_TRANSPORT_H */
diff --git a/libssh2/src/userauth.c b/libssh2/src/userauth.c
index 40ef9153..0040c3fa 100644
--- a/libssh2/src/userauth.c
+++ b/libssh2/src/userauth.c
@@ -1,6 +1,6 @@
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2005 Mikhail Gusarov <dottedmag@dottedmag.net>
- * Copyright (c) 2009-2014 by Daniel Stenberg
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Mikhail Gusarov <dottedmag@dottedmag.net>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -35,14 +35,13 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
 
 #include <ctype.h>
-#include <stdio.h>
-
-#include <assert.h>
 
 /* Needed for struct iovec on some platforms */
 #ifdef HAVE_SYS_UIO_H
@@ -52,8 +51,11 @@
 #include "transport.h"
 #include "session.h"
 #include "userauth.h"
+#include "userauth_kbd_packet.h"
 
-/* libssh2_userauth_list
+#include <stdlib.h>  /* strtol() */
+
+/* userauth_list
  *
  * List authentication methods
  * Will yield successful login if "none" happens to be allowable for this user
@@ -63,11 +65,13 @@
 static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
                            unsigned int username_len)
 {
-    static const unsigned char reply_codes[3] =
-        { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
+    unsigned char reply_codes[4] =
+        { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE,
+          SSH_MSG_USERAUTH_BANNER, 0 };
     /* packet_type(1) + username_len(4) + service_len(4) +
        service(14)"ssh-connection" + method_len(4) = 27 */
     unsigned long methods_len;
+    unsigned int banner_len;
     unsigned char *s;
     int rc;
 
@@ -134,6 +138,57 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
             return NULL;
         }
 
+        if(session->userauth_list_data[0] == SSH_MSG_USERAUTH_BANNER) {
+            if(session->userauth_list_data_len < 5) {
+                LIBSSH2_FREE(session, session->userauth_list_data);
+                session->userauth_list_data = NULL;
+                _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                               "Unexpected packet size");
+                return NULL;
+            }
+            banner_len = _libssh2_ntohu32(session->userauth_list_data + 1);
+            if(banner_len > session->userauth_list_data_len - 5) {
+                LIBSSH2_FREE(session, session->userauth_list_data);
+                session->userauth_list_data = NULL;
+                _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                               "Unexpected userauth banner size");
+                return NULL;
+            }
+            session->userauth_banner = LIBSSH2_ALLOC(session, banner_len + 1);
+            if(!session->userauth_banner) {
+                LIBSSH2_FREE(session, session->userauth_list_data);
+                session->userauth_list_data = NULL;
+                _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                              "Unable to allocate memory for userauth_banner");
+                return NULL;
+            }
+            memcpy(session->userauth_banner, session->userauth_list_data + 5,
+                    banner_len);
+            session->userauth_banner[banner_len] = '\0';
+            _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                           "Banner: %s",
+                           session->userauth_banner));
+            LIBSSH2_FREE(session, session->userauth_list_data);
+            session->userauth_list_data = NULL;
+            /* SSH_MSG_USERAUTH_BANNER has been handled */
+            reply_codes[2] = 0;
+            rc = _libssh2_packet_requirev(session, reply_codes,
+                                          &session->userauth_list_data,
+                                          &session->userauth_list_data_len, 0,
+                                          NULL, 0,
+                                &session->userauth_list_packet_requirev_state);
+            if(rc == LIBSSH2_ERROR_EAGAIN) {
+                _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
+                               "Would block requesting userauth list");
+                return NULL;
+            }
+            else if(rc || (session->userauth_list_data_len < 1)) {
+                _libssh2_error(session, rc, "Failed getting response");
+                session->userauth_list_state = libssh2_NB_state_idle;
+                return NULL;
+            }
+        }
+
         if(session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
             /* Wow, who'dve thought... */
             _libssh2_error(session, LIBSSH2_ERROR_NONE, "No error");
@@ -163,13 +218,13 @@ static char *userauth_list(LIBSSH2_SESSION *session, const char *username,
         memmove(session->userauth_list_data, session->userauth_list_data + 5,
                 methods_len);
         session->userauth_list_data[methods_len] = '\0';
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
                        "Permitted auth methods: %s",
-                       session->userauth_list_data);
+                       session->userauth_list_data));
     }
 
     session->userauth_list_state = libssh2_NB_state_idle;
-    return (char *) session->userauth_list_data;
+    return (char *)session->userauth_list_data;
 }
 
 /* libssh2_userauth_list
@@ -189,6 +244,30 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *user,
     return ptr;
 }
 
+/* libssh2_userauth_banner
+ *
+ * Retrieve banner message from server, if available.
+ * When no such message is sent by server or if no authentication attempt has
+ * been made, this function returns LIBSSH2_ERROR_MISSING_AUTH_BANNER.
+ */
+LIBSSH2_API int
+libssh2_userauth_banner(LIBSSH2_SESSION *session, char **banner)
+{
+    if(!session)
+        return LIBSSH2_ERROR_MISSING_USERAUTH_BANNER;
+
+    if(!session->userauth_banner) {
+        return _libssh2_error(session,
+                              LIBSSH2_ERROR_MISSING_USERAUTH_BANNER,
+                              "Missing userauth banner");
+    }
+
+    if(banner)
+        *banner = session->userauth_banner;
+
+    return LIBSSH2_ERROR_NONE;
+}
+
 /*
  * libssh2_userauth_authenticated
  *
@@ -198,7 +277,7 @@ libssh2_userauth_list(LIBSSH2_SESSION * session, const char *user,
 LIBSSH2_API int
 libssh2_userauth_authenticated(LIBSSH2_SESSION * session)
 {
-    return (session->state & LIBSSH2_STATE_AUTHENTICATED)?1:0;
+    return (session->state & LIBSSH2_STATE_AUTHENTICATED) ? 1 : 0;
 }
 
 
@@ -251,8 +330,8 @@ userauth_password(LIBSSH2_SESSION *session,
         _libssh2_store_u32(&s, password_len);
         /* 'password' is sent separately */
 
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting to login using password authentication");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Attempting to login using password authentication"));
 
         session->userauth_pswd_state = libssh2_NB_state_created;
     }
@@ -279,7 +358,7 @@ userauth_password(LIBSSH2_SESSION *session,
         session->userauth_pswd_state = libssh2_NB_state_sent;
     }
 
-  password_response:
+password_response:
 
     if((session->userauth_pswd_state == libssh2_NB_state_sent)
         || (session->userauth_pswd_state == libssh2_NB_state_sent1)
@@ -306,8 +385,8 @@ userauth_password(LIBSSH2_SESSION *session,
             }
 
             if(session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Password authentication successful");
+                _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                               "Password authentication successful"));
                 LIBSSH2_FREE(session, session->userauth_pswd_data);
                 session->userauth_pswd_data = NULL;
                 session->state |= LIBSSH2_STATE_AUTHENTICATED;
@@ -316,8 +395,8 @@ userauth_password(LIBSSH2_SESSION *session,
             }
             else if(session->userauth_pswd_data[0] ==
                     SSH_MSG_USERAUTH_FAILURE) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Password authentication failed");
+                _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                               "Password authentication failed"));
                 LIBSSH2_FREE(session, session->userauth_pswd_data);
                 session->userauth_pswd_data = NULL;
                 session->userauth_pswd_state = libssh2_NB_state_idle;
@@ -348,8 +427,8 @@ userauth_password(LIBSSH2_SESSION *session,
             if((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
                 (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
                 if(session->userauth_pswd_state == libssh2_NB_state_sent1) {
-                    _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                                   "Password change required");
+                    _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                                   "Password change required"));
                     LIBSSH2_FREE(session, session->userauth_pswd_data);
                     session->userauth_pswd_data = NULL;
                 }
@@ -490,7 +569,7 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
 {
     unsigned char *pubkey = NULL, *sp1, *sp2, *tmp;
     size_t pubkey_len = pubkeyfiledata_len;
-    unsigned int tmp_len;
+    size_t tmp_len;
 
     if(pubkeyfiledata_len <= 1) {
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
@@ -518,7 +597,7 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     }
 
     sp1 = memchr(pubkey, ' ', pubkey_len);
-    if(sp1 == NULL) {
+    if(!sp1) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid public key data");
@@ -527,16 +606,17 @@ memory_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     sp1++;
 
     sp2 = memchr(sp1, ' ', pubkey_len - (sp1 - pubkey));
-    if(sp2 == NULL) {
+    if(!sp2) {
         /* Assume that the id string is missing, but that it's okay */
         sp2 = pubkey + pubkey_len;
     }
 
-    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
-                              (char *) sp1, sp2 - sp1)) {
+    if(_libssh2_base64_decode(session, (char **)&tmp, &tmp_len,
+                              (const char *)sp1,
+                              sp2 - sp1)) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                                  "Invalid key data, not base64 encoded");
+                              "Invalid key data, not base64 encoded");
     }
 
     /* Wasting some bytes here (okay, more than some), but since it's likely
@@ -573,10 +653,10 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     char c;
     unsigned char *pubkey = NULL, *sp1, *sp2, *tmp;
     size_t pubkey_len = 0, sp_len;
-    unsigned int tmp_len;
+    size_t tmp_len;
 
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading public key file: %s",
-                   pubkeyfile);
+    _libssh2_debug((session, LIBSSH2_TRACE_AUTH, "Loading public key file: %s",
+                   pubkeyfile));
     /* Read Public Key */
     fd = fopen(pubkeyfile, FOPEN_READTEXT);
     if(!fd) {
@@ -621,7 +701,7 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
     }
 
     sp1 = memchr(pubkey, ' ', pubkey_len);
-    if(sp1 == NULL) {
+    if(!sp1) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid public key data");
@@ -631,13 +711,14 @@ file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
 
     sp_len = sp1 > pubkey ? (sp1 - pubkey) : 0;
     sp2 = memchr(sp1, ' ', pubkey_len - sp_len);
-    if(sp2 == NULL) {
+    if(!sp2) {
         /* Assume that the id string is missing, but that it's okay */
         sp2 = pubkey + pubkey_len;
     }
 
-    if(libssh2_base64_decode(session, (char **) &tmp, &tmp_len,
-                              (char *) sp1, sp2 - sp1)) {
+    if(_libssh2_base64_decode(session, (char **)&tmp, &tmp_len,
+                              (const char *)sp1,
+                              sp2 - sp1)) {
         LIBSSH2_FREE(session, pubkey);
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
                               "Invalid key data, not base64 encoded");
@@ -659,7 +740,7 @@ static int
 memory_read_privatekey(LIBSSH2_SESSION * session,
                        const LIBSSH2_HOSTKEY_METHOD ** hostkey_method,
                        void **hostkey_abstract,
-                       const unsigned char *method, int method_len,
+                       const unsigned char *method, size_t method_len,
                        const char *privkeyfiledata, size_t privkeyfiledata_len,
                        const char *passphrase)
 {
@@ -687,7 +768,7 @@ memory_read_privatekey(LIBSSH2_SESSION * session,
                           (unsigned char *) passphrase,
                           hostkey_abstract)) {
         return _libssh2_error(session, LIBSSH2_ERROR_FILE,
-                              "Unable to initialize private key from file");
+                              "Unable to initialize private key from memory");
     }
 
     return 0;
@@ -700,14 +781,14 @@ static int
 file_read_privatekey(LIBSSH2_SESSION * session,
                      const LIBSSH2_HOSTKEY_METHOD ** hostkey_method,
                      void **hostkey_abstract,
-                     const unsigned char *method, int method_len,
+                     const unsigned char *method, size_t method_len,
                      const char *privkeyfile, const char *passphrase)
 {
     const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail =
         libssh2_hostkey_methods();
 
-    _libssh2_debug(session, LIBSSH2_TRACE_AUTH, "Loading private key file: %s",
-                   privkeyfile);
+    _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                   "Loading private key file: %s", privkeyfile));
     *hostkey_method = NULL;
     *hostkey_abstract = NULL;
     while(*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
@@ -739,11 +820,17 @@ struct privkey_file {
     const char *passphrase;
 };
 
+struct privkey_mem {
+    const char *passphrase;
+    const char *data;
+    size_t data_len;
+};
+
 static int
 sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
                 const unsigned char *data, size_t data_len, void **abstract)
 {
-    struct privkey_file *pk_file = (struct privkey_file *) (*abstract);
+    struct privkey_mem *pk_mem = (struct privkey_mem *) (*abstract);
     const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
     void *hostkey_abstract;
     struct iovec datavec;
@@ -752,9 +839,9 @@ sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     rc = memory_read_privatekey(session, &privkeyobj, &hostkey_abstract,
                                 session->userauth_pblc_method,
                                 session->userauth_pblc_method_len,
-                                pk_file->filename,
-                                strlen(pk_file->filename),
-                                pk_file->passphrase);
+                                pk_mem->data,
+                                pk_mem->data_len,
+                                pk_mem->passphrase);
     if(rc)
         return rc;
 
@@ -763,7 +850,7 @@ sign_frommemory(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     datavec.iov_len  = data_len;
 
     if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
-                          &hostkey_abstract)) {
+                         &hostkey_abstract)) {
         if(privkeyobj->dtor) {
             privkeyobj->dtor(session, &hostkey_abstract);
         }
@@ -799,7 +886,7 @@ sign_fromfile(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     datavec.iov_len  = data_len;
 
     if(privkeyobj->signv(session, sig, sig_len, 1, &datavec,
-                          &hostkey_abstract)) {
+                         &hostkey_abstract)) {
         if(privkeyobj->dtor) {
             privkeyobj->dtor(session, &hostkey_abstract);
         }
@@ -812,7 +899,106 @@ sign_fromfile(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     return 0;
 }
 
+int
+libssh2_sign_sk(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
+                const unsigned char *data, size_t data_len, void **abstract)
+{
+    int rc = LIBSSH2_ERROR_DECRYPT;
+    LIBSSH2_PRIVKEY_SK *sk_info = (LIBSSH2_PRIVKEY_SK *) (*abstract);
+    LIBSSH2_SK_SIG_INFO sig_info = { 0 };
+
+    if(sk_info->handle_len <= 0) {
+        return LIBSSH2_ERROR_DECRYPT;
+    }
+
+    rc = sk_info->sign_callback(session,
+                                &sig_info,
+                                data,
+                                data_len,
+                                sk_info->algorithm,
+                                sk_info->flags,
+                                sk_info->application,
+                                sk_info->key_handle,
+                                sk_info->handle_len,
+                                sk_info->orig_abstract);
+
+    if(rc == 0 && sig_info.sig_r_len > 0 && sig_info.sig_r) {
+        unsigned char *p = NULL;
+
+        if(sig_info.sig_s_len > 0 && sig_info.sig_s) {
+            /* sig length, sig_r, sig_s, flags, counter, plus 4 bytes for each
+               component's length, and up to 1 extra byte for each component */
+            *sig_len = 4 + 5 + sig_info.sig_r_len + 5 + sig_info.sig_s_len + 5;
+            *sig = LIBSSH2_ALLOC(session, *sig_len);
+
+            if(*sig) {
+                unsigned char *x = *sig;
+                p = *sig;
+
+                _libssh2_store_u32(&p, 0);
+
+                _libssh2_store_bignum2_bytes(&p,
+                                             sig_info.sig_r,
+                                             sig_info.sig_r_len);
+
+                _libssh2_store_bignum2_bytes(&p,
+                                             sig_info.sig_s,
+                                             sig_info.sig_s_len);
+
+                *sig_len = p - *sig;
+
+                _libssh2_store_u32(&x, (uint32_t)(*sig_len - 4));
+            }
+            else {
+                _libssh2_debug((session,
+                               LIBSSH2_ERROR_ALLOC,
+                               "Unable to allocate ecdsa-sk signature."));
+                rc = LIBSSH2_ERROR_ALLOC;
+            }
+        }
+        else {
+            /* sig, flags, counter, plus 4 bytes for sig length. */
+            *sig_len = 4 + sig_info.sig_r_len + 1 + 4;
+            *sig = LIBSSH2_ALLOC(session, *sig_len);
+
+            if(*sig) {
+                p = *sig;
+
+                _libssh2_store_str(&p,
+                                   (const char *)sig_info.sig_r,
+                                   sig_info.sig_r_len);
+            }
+            else {
+                _libssh2_debug((session,
+                               LIBSSH2_ERROR_ALLOC,
+                               "Unable to allocate ed25519-sk signature."));
+                rc = LIBSSH2_ERROR_ALLOC;
+            }
+        }
+
+        if(p) {
+            *p = sig_info.flags;
+            ++p;
+            _libssh2_store_u32(&p, sig_info.counter);
+
+            *sig_len = p - *sig;
+        }
+
+        LIBSSH2_FREE(session, sig_info.sig_r);
 
+        if(sig_info.sig_s) {
+            LIBSSH2_FREE(session, sig_info.sig_s);
+        }
+    }
+    else {
+        _libssh2_debug((session,
+                       LIBSSH2_ERROR_DECRYPT,
+                       "sign_callback failed or returned invalid signature."));
+        *sig_len = 0;
+    }
+
+    return rc;
+}
 
 /* userauth_hostbased_fromfile
  * Authenticate using a keypair found in the named files
@@ -858,7 +1044,7 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                                            &pubkeydata, &pubkeydata_len,
                                            privatekey, passphrase);
             if(rc)
-                /* libssh2_pub_priv_keyfile calls _libssh2_error() */
+                /* libssh2_pub_priv_keyfile() calls _libssh2_error() */
                 return rc;
         }
 
@@ -927,8 +1113,8 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         datavec[2].iov_len = session->userauth_host_packet_len;
 
         if(privkeyobj && privkeyobj->signv &&
-                          privkeyobj->signv(session, &sig, &sig_len, 3,
-                                            datavec, &abstract)) {
+                         privkeyobj->signv(session, &sig, &sig_len, 3,
+                                           datavec, &abstract)) {
             LIBSSH2_FREE(session, session->userauth_host_method);
             session->userauth_host_method = NULL;
             LIBSSH2_FREE(session, session->userauth_host_packet);
@@ -967,8 +1153,8 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
             session->userauth_host_packet + session->userauth_host_packet_len;
 
         _libssh2_store_u32(&session->userauth_host_s,
-                           4 + session->userauth_host_method_len +
-                           4 + sig_len);
+                           (uint32_t)(4 + session->userauth_host_method_len +
+                                      4 + sig_len));
         _libssh2_store_str(&session->userauth_host_s,
                            (const char *)session->userauth_host_method,
                            session->userauth_host_method_len);
@@ -979,8 +1165,8 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
                            sig_len);
         LIBSSH2_FREE(session, sig);
 
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting hostbased authentication");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Attempting hostbased authentication"));
 
         session->userauth_host_state = libssh2_NB_state_created;
     }
@@ -1028,8 +1214,8 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
         }
 
         if(session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                           "Hostbased authentication successful");
+            _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                           "Hostbased authentication successful"));
             /* We are us and we've proved it. */
             LIBSSH2_FREE(session, session->userauth_host_data);
             session->userauth_host_data = NULL;
@@ -1070,8 +1256,23 @@ libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
     return rc;
 }
 
-static int plain_method_len(const char *method, size_t method_len)
+size_t plain_method(char *method, size_t method_len)
 {
+    if(!strncmp("ssh-rsa-cert-v01@openssh.com",
+                method,
+                method_len)) {
+        return 7;
+    }
+
+    if(!strncmp("rsa-sha2-256-cert-v01@openssh.com",
+                method,
+                method_len) ||
+       !strncmp("rsa-sha2-512-cert-v01@openssh.com",
+                method,
+                method_len)) {
+       return 12;
+    }
+
     if(!strncmp("ecdsa-sha2-nistp256-cert-v01@openssh.com",
                 method,
                 method_len) ||
@@ -1083,15 +1284,240 @@ static int plain_method_len(const char *method, size_t method_len)
                 method_len)) {
         return 19;
     }
+
+    if(!strncmp("ssh-ed25519-cert-v01@openssh.com",
+                method,
+                method_len)) {
+        return 11;
+    }
+
+    if(!strncmp("sk-ecdsa-sha2-nistp256-cert-v01@openssh.com",
+                method,
+                method_len)) {
+        const char *new_method = "sk-ecdsa-sha2-nistp256@openssh.com";
+        memcpy(method, new_method, strlen(new_method));
+        return strlen(new_method);
+    }
+
+    if(!strncmp("sk-ssh-ed25519-cert-v01@openssh.com",
+                method,
+                method_len)) {
+        const char *new_method = "sk-ssh-ed25519@openssh.com";
+        memcpy(method, new_method, strlen(new_method));
+        return strlen(new_method);
+    }
+
     return method_len;
 }
 
+/* Function to check if the given version is less than pattern (OpenSSH 7.8)
+ * This function expects the input version in x.y* format
+ * (x being openssh major and y being openssh minor version)
+ * Returns 1 if the version is less than OpenSSH_7.8, 0 otherwise
+ */
+static int is_version_less_than_78(const char *version)
+{
+    char *endptr = NULL;
+    long major = 0;
+    int minor = 0;
+
+    if(!version)
+        return 0;
+
+    major = strtol(version, &endptr, 10);
+    if(!endptr || *endptr != '.')
+        return 0; /* Not a valid number */
+    minor = (endptr + 1)[0] - '0';
+    if((major >= 1 && major <= 6) ||
+       (major == 7 && minor >= 0 && minor <= 7)) {
+        return 1; /* Version is in the specified range */
+    }
+    return 0;
+}
+
+/**
+ * @function _libssh2_key_sign_algorithm
+ * @abstract Upgrades the algorithm used for public key signing RFC 8332
+ * @discussion Based on the incoming key_method value, this function
+ * will upgrade the key method input based on user preferences,
+ * server support algos and crypto backend support
+ * @related _libssh2_supported_key_sign_algorithms()
+ * @param key_method current key method, usually the default key sig method
+ * @param key_method_len length of the key method buffer
+ * @result error code or zero on success
+ */
+
+static int
+_libssh2_key_sign_algorithm(LIBSSH2_SESSION *session,
+                            unsigned char **key_method,
+                            size_t *key_method_len)
+{
+    const char *s = NULL;
+    const char *a = NULL;
+    const char *match = NULL;
+    const char *p = NULL;
+    const char *f = NULL;
+    char *i = NULL;
+    size_t p_len = 0;
+    size_t f_len = 0;
+    int rc = 0;
+    size_t match_len = 0;
+    const size_t suffix_len = 21;
+    char *filtered_algs = NULL;
+    const char * const certSuffix = "-cert-v01@openssh.com";
+    const char *remote_banner = NULL;
+    const char * const remote_ver_pre = "OpenSSH_";
+    const char *remote_ver_start = NULL;
+    const char *remote_ver = NULL;
+    int SSH_BUG_SIGTYPE = 0;
+
+    const char *supported_algs =
+    _libssh2_supported_key_sign_algorithms(session,
+                                           *key_method,
+                                           *key_method_len);
+
+    if(!supported_algs || !session->server_sign_algorithms) {
+        /* no upgrading key algorithm supported, do nothing */
+        return LIBSSH2_ERROR_NONE;
+    }
+
+    filtered_algs = LIBSSH2_ALLOC(session, strlen(supported_algs) + 1);
+    if(!filtered_algs) {
+        rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                            "Unable to allocate filtered algs");
+        return rc;
+    }
+
+    /* Set "SSH_BUG_SIGTYPE" flag when the remote server version is OpenSSH 7.7
+       or lower and when the RSA key in question is a certificate to ignore
+       "server-sig-algs" and only offer ssh-rsa signature algorithm for
+       RSA certs */
+    remote_banner = libssh2_session_banner_get(session);
+    /* Extract version information from the banner */
+    if(remote_banner) {
+        remote_ver_start = strstr(remote_banner, remote_ver_pre);
+        if(remote_ver_start) {
+            remote_ver = remote_ver_start + strlen(remote_ver_pre);
+            SSH_BUG_SIGTYPE = is_version_less_than_78(remote_ver);
+            if(SSH_BUG_SIGTYPE && *key_method_len == 28 &&
+               memcmp(key_method, "ssh-rsa-cert-v01@openssh.com",
+                      *key_method_len)) {
+                return LIBSSH2_ERROR_NONE;
+            }
+        }
+    }
+
+    s = session->server_sign_algorithms;
+    i = filtered_algs;
+
+    /* this walks the server algo list and the supported algo list and creates
+       a filtered list that includes matches */
+
+    while(s && *s) {
+        p = strchr(s, ',');
+        p_len = (p ? (size_t)(p - s) : strlen(s));
+        a = supported_algs;
+
+        while(a && *a) {
+            f = strchr(a, ',');
+            f_len = (f ? (size_t)(f - a) : strlen(a));
+
+            if(f_len == p_len && memcmp(a, s, p_len) == 0) {
+
+                if(i != filtered_algs) {
+                    memcpy(i, ",", 1);
+                    i += 1;
+                }
+
+                memcpy(i, s, p_len);
+                i += p_len;
+            }
+
+            a = f ? (f + 1) : NULL;
+        }
+
+        s = p ? (p + 1) : NULL;
+    }
+
+    filtered_algs[i - filtered_algs] = '\0';
+
+    if(session->sign_algo_prefs) {
+        s = session->sign_algo_prefs;
+    }
+    else {
+        s = supported_algs;
+    }
+
+    /* now that we have the possible supported algos, match based on the prefs
+       or what is supported by the crypto backend, look for a match */
+
+    while(s && *s && !match) {
+        p = strchr(s, ',');
+        p_len = (p ? (size_t)(p - s) : strlen(s));
+        a = filtered_algs;
+
+        while(a && *a && !match) {
+            f = strchr(a, ',');
+            f_len = (f ? (size_t)(f - a) : strlen(a));
+
+            if(f_len == p_len && memcmp(a, s, p_len) == 0) {
+                /* found a match, upgrade key method */
+                match = s;
+                match_len = p_len;
+            }
+            else {
+                a = f ? (f + 1) : NULL;
+            }
+        }
+
+        s = p ? (p + 1) : NULL;
+    }
+
+    if(match) {
+        if(*key_method_len == 28 &&
+        memcmp(key_method, "ssh-rsa-cert-v01@openssh.com", *key_method_len)) {
+            if(*key_method)
+                LIBSSH2_FREE(session, *key_method);
+            *key_method = LIBSSH2_ALLOC(session, match_len + suffix_len);
+            if(*key_method) {
+                memcpy(*key_method, match, match_len);
+                memcpy(*key_method + match_len, certSuffix, suffix_len);
+                *key_method_len = match_len + suffix_len;
+            }
+        }
+        else {
+            if(*key_method)
+                LIBSSH2_FREE(session, *key_method);
+            *key_method = LIBSSH2_ALLOC(session, match_len);
+            if(*key_method) {
+                memcpy(*key_method, match, match_len);
+                *key_method_len = match_len;
+            }
+        }
+        if(!key_method) {
+            *key_method_len = 0;
+            rc = _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                                "Unable to allocate key method upgrade");
+        }
+    }
+    else {
+        /* no match was found */
+        rc = _libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
+                            "No signing signature matched");
+    }
+
+    if(filtered_algs)
+        LIBSSH2_FREE(session, filtered_algs);
+
+    return rc;
+}
+
 int
 _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                             const char *username,
-                            unsigned int username_len,
+                            size_t username_len,
                             const unsigned char *pubkeydata,
-                            unsigned long pubkeydata_len,
+                            size_t pubkeydata_len,
                             LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
                             ((*sign_callback)),
                             void *abstract)
@@ -1102,6 +1528,10 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         };
     int rc;
     unsigned char *s;
+    int auth_attempts = 0;
+
+retry_auth:
+    auth_attempts++;
 
     if(session->userauth_pblc_state == libssh2_NB_state_idle) {
 
@@ -1127,9 +1557,8 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
             session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata);
 
             if(session->userauth_pblc_method_len > pubkeydata_len - 4)
-                /* the method length simply cannot be longer than the entire
-                   passed in data, so we use this to detect crazy input
-                   data */
+                /* the method length cannot be longer than the entire passed
+                   in data, so we use this to detect crazy input data */
                 return _libssh2_error(session,
                                       LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
                                       "Invalid public key");
@@ -1144,15 +1573,27 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
             memcpy(session->userauth_pblc_method, pubkeydata + 4,
                    session->userauth_pblc_method_len);
         }
-        /*
-         * The length of the method name read from plaintext prefix in the
-         * file must match length embedded in the key.
-         * TODO: The data should match too but we don't check that. Should we?
-         */
-        else if(session->userauth_pblc_method_len !=
-                 _libssh2_ntohu32(pubkeydata))
-            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
-                                  "Invalid public key");
+
+        /* upgrade key signing algo if it is supported and
+         * it is our first auth attempt, otherwise fallback to
+         * the key default algo */
+        if(auth_attempts == 1) {
+            rc = _libssh2_key_sign_algorithm(session,
+                                           &session->userauth_pblc_method,
+                                           &session->userauth_pblc_method_len);
+
+            if(rc)
+                return rc;
+        }
+
+        if(session->userauth_pblc_method_len &&
+           session->userauth_pblc_method) {
+            _libssh2_debug((session,
+                           LIBSSH2_TRACE_KEX,
+                           "Signing using %.*s",
+                           (int)session->userauth_pblc_method_len,
+                           session->userauth_pblc_method));
+        }
 
         /*
          * 45 = packet_type(1) + username_len(4) + servicename_len(4) +
@@ -1198,8 +1639,8 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                            session->userauth_pblc_method_len);
         _libssh2_store_str(&s, (const char *)pubkeydata, pubkeydata_len);
 
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting publickey authentication");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Attempting publickey authentication"));
 
         session->userauth_pblc_state = libssh2_NB_state_created;
     }
@@ -1246,8 +1687,8 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         }
 
         if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                           "Pubkey authentication prematurely successful");
+            _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                           "Pubkey authentication prematurely successful"));
             /*
              * God help any SSH server that allows an UNVERIFIED
              * public key to validate the user
@@ -1310,6 +1751,17 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
             return _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                                   "Would block");
         }
+        else if(rc == LIBSSH2_ERROR_ALGO_UNSUPPORTED && auth_attempts == 1) {
+            /* try again with the default key algo */
+            LIBSSH2_FREE(session, session->userauth_pblc_method);
+            session->userauth_pblc_method = NULL;
+            LIBSSH2_FREE(session, session->userauth_pblc_packet);
+            session->userauth_pblc_packet = NULL;
+            session->userauth_pblc_state = libssh2_NB_state_idle;
+
+            rc = LIBSSH2_ERROR_NONE;
+            goto retry_auth;
+        }
         else if(rc) {
             LIBSSH2_FREE(session, session->userauth_pblc_method);
             session->userauth_pblc_method = NULL;
@@ -1350,23 +1802,39 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
         session->userauth_pblc_b = NULL;
 
         session->userauth_pblc_method_len =
-           plain_method_len((const char *)session->userauth_pblc_method,
-                            session->userauth_pblc_method_len);
-
-        _libssh2_store_u32(&s,
-                           4 + session->userauth_pblc_method_len + 4 +
-                           sig_len);
-        _libssh2_store_str(&s, (const char *)session->userauth_pblc_method,
-                           session->userauth_pblc_method_len);
+            plain_method((char *)session->userauth_pblc_method,
+                         session->userauth_pblc_method_len);
+
+        if(strncmp((const char *)session->userauth_pblc_method,
+                   "sk-ecdsa-sha2-nistp256@openssh.com",
+                   session->userauth_pblc_method_len) == 0 ||
+           strncmp((const char *)session->userauth_pblc_method,
+                   "sk-ssh-ed25519@openssh.com",
+                   session->userauth_pblc_method_len) == 0) {
+            _libssh2_store_u32(&s,
+                             (uint32_t)(4 + session->userauth_pblc_method_len +
+                                        sig_len));
+            _libssh2_store_str(&s, (const char *)session->userauth_pblc_method,
+                               session->userauth_pblc_method_len);
+            memcpy(s, sig, sig_len);
+            s += sig_len;
+        }
+        else {
+            _libssh2_store_u32(&s,
+                             (uint32_t)(4 + session->userauth_pblc_method_len +
+                                        4 + sig_len));
+            _libssh2_store_str(&s, (const char *)session->userauth_pblc_method,
+                               session->userauth_pblc_method_len);
+            _libssh2_store_str(&s, (const char *)sig, sig_len);
+        }
 
         LIBSSH2_FREE(session, session->userauth_pblc_method);
         session->userauth_pblc_method = NULL;
 
-        _libssh2_store_str(&s, (const char *)sig, sig_len);
         LIBSSH2_FREE(session, sig);
 
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting publickey authentication -- phase 2");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Attempting publickey authentication -- phase 2"));
 
         session->userauth_pblc_s = s;
         session->userauth_pblc_state = libssh2_NB_state_sent2;
@@ -1412,8 +1880,8 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
     }
 
     if(session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Publickey authentication successful");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Publickey authentication successful"));
         /* We are us and we've proved it. */
         LIBSSH2_FREE(session, session->userauth_pblc_data);
         session->userauth_pblc_data = NULL;
@@ -1431,10 +1899,10 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                           "username/public key combination");
 }
 
- /*
-  * userauth_publickey_frommemory
-  * Authenticate using a keypair from memory
-  */
+/*
+ * userauth_publickey_frommemory
+ * Authenticate using a keypair from memory
+ */
 static int
 userauth_publickey_frommemory(LIBSSH2_SESSION *session,
                               const char *username,
@@ -1447,12 +1915,13 @@ userauth_publickey_frommemory(LIBSSH2_SESSION *session,
 {
     unsigned char *pubkeydata = NULL;
     size_t pubkeydata_len = 0;
-    struct privkey_file privkey_file;
-    void *abstract = &privkey_file;
+    struct privkey_mem privkey_mem;
+    void *abstract = &privkey_mem;
     int rc;
 
-    privkey_file.filename = privatekeydata;
-    privkey_file.passphrase = passphrase;
+    privkey_mem.data = privatekeydata;
+    privkey_mem.data_len = privatekeydata_len;
+    privkey_mem.passphrase = passphrase;
 
     if(session->userauth_pblc_state == libssh2_NB_state_idle) {
         if(publickeydata_len && publickeydata) {
@@ -1556,7 +2025,7 @@ libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
 {
     int rc;
 
-    if(NULL == passphrase)
+    if(!passphrase)
         /* if given a NULL pointer, make it point to a zero-length
            string to save us from having to check this all over */
         passphrase = "";
@@ -1584,7 +2053,7 @@ libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 {
     int rc;
 
-    if(NULL == passphrase)
+    if(!passphrase)
         /* if given a NULL pointer, make it point to a zero-length
            string to save us from having to check this all over */
         passphrase = "";
@@ -1605,7 +2074,7 @@ libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                            const unsigned char *pubkeydata,
                            size_t pubkeydata_len,
                            LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                           ((*sign_callback)),
+                               ((*sign_callback)),
                            void **abstract)
 {
     int rc;
@@ -1632,16 +2101,16 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
                               const char *username,
                               unsigned int username_len,
                               LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC
-                              ((*response_callback)))
+                                  ((*response_callback)))
 {
     unsigned char *s;
+
     int rc;
 
     static const unsigned char reply_codes[4] = {
         SSH_MSG_USERAUTH_SUCCESS,
         SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_INFO_REQUEST, 0
     };
-    unsigned int language_tag_len;
     unsigned int i;
 
     if(session->userauth_kybd_state == libssh2_NB_state_idle) {
@@ -1692,8 +2161,8 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
         /* submethods */
         _libssh2_store_u32(&s, 0);
 
-        _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                       "Attempting keyboard-interactive authentication");
+        _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                       "Attempting keyboard-interactive authentication"));
 
         session->userauth_kybd_state = libssh2_NB_state_created;
     }
@@ -1741,9 +2210,9 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             }
 
             if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
+                _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
                                "Keyboard-interactive "
-                               "authentication successful");
+                               "authentication successful"));
                 LIBSSH2_FREE(session, session->userauth_kybd_data);
                 session->userauth_kybd_data = NULL;
                 session->state |= LIBSSH2_STATE_AUTHENTICATED;
@@ -1752,8 +2221,8 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             }
 
             if(session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
-                _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
-                               "Keyboard-interactive authentication failed");
+                _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
+                               "Keyboard-interactive authentication failed"));
                 LIBSSH2_FREE(session, session->userauth_kybd_data);
                 session->userauth_kybd_data = NULL;
                 session->userauth_kybd_state = libssh2_NB_state_idle;
@@ -1764,232 +2233,36 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             }
 
             /* server requested PAM-like conversation */
-            s = session->userauth_kybd_data + 1;
-
-            if(session->userauth_kybd_data_len >= 5) {
-                /* string    name (ISO-10646 UTF-8) */
-                session->userauth_kybd_auth_name_len = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "to get length");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_auth_name_len) {
-                session->userauth_kybd_auth_name =
-                    LIBSSH2_ALLOC(session,
-                                  session->userauth_kybd_auth_name_len);
-                if(!session->userauth_kybd_auth_name) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive 'name' "
-                                   "request field");
-                    goto cleanup;
-                }
-                if(s + session->userauth_list_data_len <=
-                   session->userauth_kybd_data +
-                   session->userauth_kybd_data_len) {
-                    memcpy(session->userauth_kybd_auth_name, s,
-                           session->userauth_kybd_auth_name_len);
-                    s += session->userauth_kybd_auth_name_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "userauth keyboard data buffer too small"
-                                   "for auth name");
-                    goto cleanup;
-                }
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* string    instruction (ISO-10646 UTF-8) */
-                session->userauth_kybd_auth_instruction_len =
-                    _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth instruction length");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_auth_instruction_len) {
-                session->userauth_kybd_auth_instruction =
-                    LIBSSH2_ALLOC(session,
-                                  session->userauth_kybd_auth_instruction_len);
-                if(!session->userauth_kybd_auth_instruction) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive 'instruction' "
-                                   "request field");
-                    goto cleanup;
-                }
-                if(s + session->userauth_kybd_auth_instruction_len <=
-                   session->userauth_kybd_data +
-                   session->userauth_kybd_data_len) {
-                    memcpy(session->userauth_kybd_auth_instruction, s,
-                           session->userauth_kybd_auth_instruction_len);
-                    s += session->userauth_kybd_auth_instruction_len;
-                }
-                else {
-                    _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                   "userauth keyboard data buffer too small"
-                                   "for auth instruction");
-                    goto cleanup;
-                }
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* string    language tag (as defined in [RFC-3066]) */
-                language_tag_len = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth language tag length");
-                goto cleanup;
-            }
-
-            if(s + language_tag_len <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* ignoring this field as deprecated */
-                s += language_tag_len;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth language tag");
-                goto cleanup;
-            }
-
-            if(s + 4 <= session->userauth_kybd_data +
-               session->userauth_kybd_data_len) {
-                /* int       num-prompts */
-                session->userauth_kybd_num_prompts = _libssh2_ntohu32(s);
-                s += 4;
-            }
-            else {
-                _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                               "userauth keyboard data buffer too small"
-                               "for auth num keyboard prompts");
-                goto cleanup;
-            }
-
-            if(session->userauth_kybd_num_prompts > 100) {
-                _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
-                               "Too many replies for "
-                               "keyboard-interactive prompts");
+            if(userauth_keyboard_interactive_decode_info_request(session)
+               < 0) {
                 goto cleanup;
             }
 
-            if(session->userauth_kybd_num_prompts) {
-                session->userauth_kybd_prompts =
-                    LIBSSH2_CALLOC(session,
-                                   sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
-                                   session->userauth_kybd_num_prompts);
-                if(!session->userauth_kybd_prompts) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive prompts array");
-                    goto cleanup;
-                }
-
-                session->userauth_kybd_responses =
-                    LIBSSH2_CALLOC(session,
-                                   sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
-                                   session->userauth_kybd_num_prompts);
-                if(!session->userauth_kybd_responses) {
-                    _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                   "Unable to allocate memory for "
-                                   "keyboard-interactive responses array");
-                    goto cleanup;
-                }
-
-                for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
-                    if(s + 4 <= session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        /* string    prompt[1] (ISO-10646 UTF-8) */
-                        session->userauth_kybd_prompts[i].length =
-                            _libssh2_ntohu32(s);
-                        s += 4;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard "
-                                       "prompt length");
-                        goto cleanup;
-                    }
-
-                    session->userauth_kybd_prompts[i].text =
-                        LIBSSH2_CALLOC(session,
-                                       session->userauth_kybd_prompts[i].
-                                       length);
-                    if(!session->userauth_kybd_prompts[i].text) {
-                        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-                                       "Unable to allocate memory for "
-                                       "keyboard-interactive prompt message");
-                        goto cleanup;
-                    }
-
-                    if(s + session->userauth_kybd_prompts[i].length <=
-                       session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        memcpy(session->userauth_kybd_prompts[i].text, s,
-                               session->userauth_kybd_prompts[i].length);
-                        s += session->userauth_kybd_prompts[i].length;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard prompt");
-                        goto cleanup;
-                    }
-                    if(s < session->userauth_kybd_data +
-                       session->userauth_kybd_data_len) {
-                        /* boolean   echo[1] */
-                        session->userauth_kybd_prompts[i].echo = *s++;
-                    }
-                    else {
-                        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
-                                       "userauth keyboard data buffer too "
-                                       "small for auth keyboard prompt echo");
-                        goto cleanup;
-                    }
-                }
-            }
-
-            response_callback(session->userauth_kybd_auth_name,
-                              session->userauth_kybd_auth_name_len,
+            response_callback((const char *)session->userauth_kybd_auth_name,
+                              (int)session->userauth_kybd_auth_name_len,
+                              (const char *)
                               session->userauth_kybd_auth_instruction,
-                              session->userauth_kybd_auth_instruction_len,
+                              (int)session->userauth_kybd_auth_instruction_len,
                               session->userauth_kybd_num_prompts,
                               session->userauth_kybd_prompts,
                               session->userauth_kybd_responses,
                               &session->abstract);
 
-            _libssh2_debug(session, LIBSSH2_TRACE_AUTH,
+            _libssh2_debug((session, LIBSSH2_TRACE_AUTH,
                            "Keyboard-interactive response callback function"
-                           " invoked");
+                           " invoked"));
 
             session->userauth_kybd_packet_len =
-                1 /* byte      SSH_MSG_USERAUTH_INFO_RESPONSE */
-                + 4             /* int       num-responses */
+                1    /* byte      SSH_MSG_USERAUTH_INFO_RESPONSE */
+                + 4  /* int       num-responses */
                 ;
 
             for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
                 /* string    response[1] (ISO-10646 UTF-8) */
                 if(session->userauth_kybd_responses[i].length <=
-                   (SIZE_MAX - 4 - session->userauth_kybd_packet_len) ) {
+                   (SIZE_MAX - 4 - session->userauth_kybd_packet_len)) {
                     session->userauth_kybd_packet_len +=
-                        4 + session->userauth_kybd_responses[i].length;
+                        4 + (size_t)session->userauth_kybd_responses[i].length;
                 }
                 else {
                     _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
@@ -2042,7 +2315,7 @@ userauth_keyboard_interactive(LIBSSH2_SESSION * session,
             session->userauth_kybd_auth_failure = 0;
         }
 
-      cleanup:
+cleanup:
         /*
          * It's safe to clean all the data here, because unallocated pointers
          * are filled by zeroes
@@ -2102,7 +2375,7 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *session,
                                          const char *user,
                                          unsigned int user_len,
                                          LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC
-                                         ((*response_callback)))
+                                             ((*response_callback)))
 {
     int rc;
     BLOCK_ADJUST(rc, session,
@@ -2110,3 +2383,124 @@ libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *session,
                                                response_callback));
     return rc;
 }
+
+/*
+ * libssh2_userauth_publickey_sk
+ *
+ * Authenticate using an external callback function
+ */
+LIBSSH2_API int
+libssh2_userauth_publickey_sk(LIBSSH2_SESSION *session,
+                              const char *username,
+                              size_t username_len,
+                              const unsigned char *publickeydata,
+                              size_t publickeydata_len,
+                              const char *privatekeydata,
+                              size_t privatekeydata_len,
+                              const char *passphrase,
+                              LIBSSH2_USERAUTH_SK_SIGN_FUNC
+                                  ((*sign_callback)),
+                              void **abstract)
+{
+    int rc = LIBSSH2_ERROR_NONE;
+
+    unsigned char *tmp_method = NULL;
+    size_t tmp_method_len = 0;
+
+    unsigned char *tmp_publickeydata = NULL;
+    size_t tmp_publickeydata_len = 0;
+
+    unsigned char *pubkeydata = NULL;
+    size_t pubkeydata_len = 0;
+
+    LIBSSH2_PRIVKEY_SK sk_info = { 0 };
+    void *sign_abstract = &sk_info;
+
+    sk_info.sign_callback = sign_callback;
+    sk_info.orig_abstract = abstract;
+
+    if(privatekeydata_len && privatekeydata) {
+
+        if(_libssh2_sk_pub_keyfilememory(session,
+                                         &tmp_method,
+                                         &tmp_method_len,
+                                         &tmp_publickeydata,
+                                         &tmp_publickeydata_len,
+                                         &(sk_info.algorithm),
+                                         &(sk_info.flags),
+                                         &(sk_info.application),
+                                         &(sk_info.key_handle),
+                                         &(sk_info.handle_len),
+                                         privatekeydata, privatekeydata_len,
+                                         passphrase)) {
+            return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                                  "Unable to extract public key "
+                                  "from private key.");
+        }
+        else if(publickeydata_len == 0 || !publickeydata) {
+            session->userauth_pblc_method = tmp_method;
+            session->userauth_pblc_method_len = tmp_method_len;
+
+            pubkeydata_len = tmp_publickeydata_len;
+            pubkeydata = tmp_publickeydata;
+        }
+        else {
+            const char *ecdsa = "sk-ecdsa-sha2-nistp256-cert-v01@openssh.com";
+            const char *ed25519 = "sk-ssh-ed25519-cert-v01@openssh.com";
+
+            if(tmp_method) {
+                LIBSSH2_FREE(session, tmp_method);
+            }
+
+            if(!strncmp((char *)publickeydata, ecdsa, strlen(ecdsa))) {
+                session->userauth_pblc_method_len = strlen(ecdsa);
+                session->userauth_pblc_method =
+                    LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
+
+                memcpy(session->userauth_pblc_method, ecdsa,
+                       session->userauth_pblc_method_len);
+            }
+            else if(!strncmp((char *)publickeydata, ed25519,
+                             strlen(ed25519))) {
+                session->userauth_pblc_method_len = strlen(ed25519);
+                session->userauth_pblc_method =
+                    LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
+
+                memcpy(session->userauth_pblc_method, ed25519,
+                       session->userauth_pblc_method_len);
+            }
+
+            rc = memory_read_publickey(session,
+                                       &session->userauth_pblc_method,
+                                       &session->userauth_pblc_method_len,
+                                       &pubkeydata, &pubkeydata_len,
+                                       (char *)publickeydata,
+                                       publickeydata_len);
+        }
+    }
+    else {
+        return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                              "Invalid data in public and private key.");
+    }
+
+    if(rc == LIBSSH2_ERROR_NONE) {
+        rc = _libssh2_userauth_publickey(session, username, username_len,
+                                         pubkeydata, pubkeydata_len,
+                                         libssh2_sign_sk, &sign_abstract);
+
+        while(rc == LIBSSH2_ERROR_EAGAIN) {
+            rc = _libssh2_userauth_publickey(session, username, username_len,
+                                             pubkeydata, pubkeydata_len,
+                                             libssh2_sign_sk, &sign_abstract);
+        }
+    }
+
+    if(tmp_publickeydata)
+        LIBSSH2_FREE(session, tmp_publickeydata);
+
+    if(sk_info.application) {
+        LIBSSH2_FREE(session, (void *)sk_info.application);
+    }
+
+    return rc;
+}
diff --git a/libssh2/src/userauth.h b/libssh2/src/userauth.h
index 6b402ddb..2f53ac5b 100644
--- a/libssh2/src/userauth.h
+++ b/libssh2/src/userauth.h
@@ -1,7 +1,7 @@
-#ifndef __LIBSSH2_USERAUTH_H
-#define __LIBSSH2_USERAUTH_H
-/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
- * Copyright (c) 2009-2010 by Daniel Stenberg
+#ifndef LIBSSH2_USERAUTH_H
+#define LIBSSH2_USERAUTH_H
+/* Copyright (C) Sara Golemon <sarag@libssh2.org>
+ * Copyright (C) Daniel Stenberg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -36,16 +36,18 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 int
 _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                             const char *username,
-                            unsigned int username_len,
+                            size_t username_len,
                             const unsigned char *pubkeydata,
-                            unsigned long pubkeydata_len,
+                            size_t pubkeydata_len,
                             LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC
-                            ((*sign_callback)),
+                                ((*sign_callback)),
                             void *abstract);
 
-#endif /* __LIBSSH2_USERAUTH_H */
+#endif /* LIBSSH2_USERAUTH_H */
diff --git a/libssh2/src/userauth_kbd_packet.c b/libssh2/src/userauth_kbd_packet.c
new file mode 100644
index 00000000..216048e2
--- /dev/null
+++ b/libssh2/src/userauth_kbd_packet.c
@@ -0,0 +1,166 @@
+/* Copyright (C) Xaver Loppenstedt <xaver@loppenstedt.de>
+ * 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 any other contributors may be used to endorse or
+ *   promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "libssh2_priv.h"
+#include "userauth_kbd_packet.h"
+
+int userauth_keyboard_interactive_decode_info_request(LIBSSH2_SESSION *session)
+{
+    unsigned char *language_tag;
+    size_t language_tag_len;
+    unsigned int i;
+    unsigned char packet_type;
+    uint32_t tmp_u32;
+
+    struct string_buf decoded;
+
+    decoded.data = session->userauth_kybd_data;
+    decoded.dataptr = session->userauth_kybd_data;
+    decoded.len = session->userauth_kybd_data_len;
+
+    if(session->userauth_kybd_data_len < 17) {
+        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                       "userauth keyboard data buffer too small "
+                       "to get length");
+        return -1;
+    }
+
+    /* byte      SSH_MSG_USERAUTH_INFO_REQUEST */
+    _libssh2_get_byte(&decoded, &packet_type);
+
+    /* string    name (ISO-10646 UTF-8) */
+    if(_libssh2_copy_string(session, &decoded,
+                            &session->userauth_kybd_auth_name,
+                            &session->userauth_kybd_auth_name_len) == -1) {
+        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                       "Unable to decode "
+                       "keyboard-interactive 'name' "
+                       "request field");
+        return -1;
+    }
+
+    /* string    instruction (ISO-10646 UTF-8) */
+    if(_libssh2_copy_string(session, &decoded,
+                            &session->userauth_kybd_auth_instruction,
+                            &session->userauth_kybd_auth_instruction_len)
+       == -1) {
+        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                       "Unable to decode "
+                       "keyboard-interactive 'instruction' "
+                       "request field");
+        return -1;
+    }
+
+    /* string    language tag (as defined in [RFC-3066]) */
+    if(_libssh2_get_string(&decoded, &language_tag,
+                           &language_tag_len) == -1) {
+        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                       "Unable to decode "
+                       "keyboard-interactive 'language tag' "
+                       "request field");
+        return -1;
+    }
+
+    /* int       num-prompts */
+    if(_libssh2_get_u32(&decoded, &tmp_u32) == -1 ||
+       (session->userauth_kybd_num_prompts = tmp_u32) != tmp_u32) {
+        _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                       "Unable to decode "
+                       "keyboard-interactive number of keyboard prompts");
+        return -1;
+    }
+
+    if(session->userauth_kybd_num_prompts > 100) {
+        _libssh2_error(session, LIBSSH2_ERROR_OUT_OF_BOUNDARY,
+                       "Too many replies for "
+                       "keyboard-interactive prompts");
+        return -1;
+    }
+
+    if(session->userauth_kybd_num_prompts == 0) {
+        return 0;
+    }
+
+    session->userauth_kybd_prompts =
+        LIBSSH2_CALLOC(session,
+                       sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
+                       session->userauth_kybd_num_prompts);
+    if(!session->userauth_kybd_prompts) {
+        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                       "Unable to allocate memory for "
+                       "keyboard-interactive prompts array");
+        return -1;
+    }
+
+    session->userauth_kybd_responses =
+        LIBSSH2_CALLOC(session,
+                       sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
+                       session->userauth_kybd_num_prompts);
+    if(!session->userauth_kybd_responses) {
+        _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                       "Unable to allocate memory for "
+                       "keyboard-interactive responses array");
+        return -1;
+    }
+
+    for(i = 0; i < session->userauth_kybd_num_prompts; i++) {
+        /* string    prompt[1] (ISO-10646 UTF-8) */
+        if(_libssh2_copy_string(session, &decoded,
+                                &session->userauth_kybd_prompts[i].text,
+                                &session->userauth_kybd_prompts[i].length)
+           == -1) {
+            _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
+                           "Unable to decode "
+                           "keyboard-interactive prompt message");
+            return -1;
+        }
+
+        /* boolean   echo[1] */
+        if(_libssh2_get_boolean(&decoded,
+                                &session->userauth_kybd_prompts[i].echo)
+           == -1) {
+            _libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,
+                           "Unable to decode "
+                           "user auth keyboard prompt echo");
+            return -1;
+        }
+    }
+
+    return 0;
+}
diff --git a/libssh2/libssh2/tests/session_fixture.h b/libssh2/src/userauth_kbd_packet.h
similarity index 84%
rename from libssh2/libssh2/tests/session_fixture.h
rename to libssh2/src/userauth_kbd_packet.h
index d3824b79..56e88b3f 100644
--- a/libssh2/libssh2/tests/session_fixture.h
+++ b/libssh2/src/userauth_kbd_packet.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Xaver Loppenstedt <xaver@loppenstedt.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,15 +33,13 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef LIBSSH2_TESTS_SESSION_FIXTURE_H
-#define LIBSSH2_TESTS_SESSION_FIXTURE_H
-
-#include <libssh2.h>
+#ifndef LIBSSH2_USERAUTH_KBD_PACKET_H
+#define LIBSSH2_USERAUTH_KBD_PACKET_H
 
-LIBSSH2_SESSION *start_session_fixture();
-void stop_session_fixture();
-void print_last_session_error(const char *function);
+int userauth_keyboard_interactive_decode_info_request(LIBSSH2_SESSION *);
 
-#endif
+#endif /* LIBSSH2_USERAUTH_KBD_PACKET_H */
diff --git a/libssh2/src/version.c b/libssh2/src/version.c
index 408f83a3..d32ae64a 100644
--- a/libssh2/src/version.c
+++ b/libssh2/src/version.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 2009 Daniel Stenberg.  All rights reserved.
+/* Copyright (C) Daniel Stenberg
+ * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
  * with or without modification, are permitted provided
@@ -33,18 +34,11 @@
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "libssh2_priv.h"
 
-/*
-  libssh2_version() can be used like this:
-
-  if (!libssh2_version(LIBSSH2_VERSION_NUM)) {
-    fprintf (stderr, "Runtime libssh2 version too old!\n");
-    exit(1);
-  }
-*/
 LIBSSH2_API
 const char *libssh2_version(int req_version_num)
 {
@@ -52,3 +46,9 @@ const char *libssh2_version(int req_version_num)
         return LIBSSH2_VERSION;
     return NULL; /* this is not a suitable library! */
 }
+
+LIBSSH2_API
+libssh2_crypto_engine_t libssh2_crypto_engine(void)
+{
+    return LIBSSH2_CRYPTO_ENGINE;
+}
diff --git a/libssh2/src/wincng.c b/libssh2/src/wincng.c
index cbb2b61c..5d4b36b7 100644
--- a/libssh2/src/wincng.c
+++ b/libssh2/src/wincng.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2020 Marc Hoersken <info@marc-hoersken.de>
+ * Copyright (C) Marc Hoersken <info@marc-hoersken.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,11 +34,11 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "libssh2_priv.h"
-
-#ifdef LIBSSH2_WINCNG /* compile only if we build with wincng */
+#ifdef LIBSSH2_CRYPTO_C /* Compile this via crypto.c */
 
 /* required for cross-compilation against the w64 mingw-runtime package */
 #if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
@@ -48,6 +48,10 @@
 #define _WIN32_WINNT 0x0600
 #endif
 
+#if !defined(LIBSSH2_WINCNG_DISABLE_WINCRYPT) && !defined(HAVE_LIBCRYPT32)
+#define HAVE_LIBCRYPT32
+#endif
+
 /* specify the required libraries for dependencies using MSVC */
 #ifdef _MSC_VER
 #pragma comment(lib, "bcrypt.lib")
@@ -58,22 +62,32 @@
 
 #include <windows.h>
 #include <bcrypt.h>
-#include <ntstatus.h>
 #include <math.h>
-#include "misc.h"
 
-#ifdef HAVE_STDLIB_H
 #include <stdlib.h>
-#endif
+
 #ifdef HAVE_LIBCRYPT32
-#include <wincrypt.h>
+#include <wincrypt.h>  /* for CryptDecodeObjectEx() */
 #endif
 
 #define PEM_RSA_HEADER "-----BEGIN RSA PRIVATE KEY-----"
 #define PEM_RSA_FOOTER "-----END RSA PRIVATE KEY-----"
 #define PEM_DSA_HEADER "-----BEGIN DSA PRIVATE KEY-----"
 #define PEM_DSA_FOOTER "-----END DSA PRIVATE KEY-----"
+#define PEM_ECDSA_HEADER "-----BEGIN OPENSSH PRIVATE KEY-----"
+#define PEM_ECDSA_FOOTER "-----END OPENSSH PRIVATE KEY-----"
+
+#define OPENSSL_PRIVATEKEY_AUTH_MAGIC "openssh-key-v1"
+
+/* Define these manually to avoid including <ntstatus.h> and thus
+   clashing with <windows.h> symbols. */
+#ifndef STATUS_NOT_SUPPORTED
+#define STATUS_NOT_SUPPORTED ((NTSTATUS)0xC00000BB)
+#endif
 
+#ifndef STATUS_INVALID_SIGNATURE
+#define STATUS_INVALID_SIGNATURE ((NTSTATUS)0xC000A000)
+#endif
 
 /*******************************************************************/
 /*
@@ -87,9 +101,11 @@
 #define BCRYPT_RNG_ALGORITHM L"RNG"
 #endif
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #ifndef BCRYPT_MD5_ALGORITHM
 #define BCRYPT_MD5_ALGORITHM L"MD5"
 #endif
+#endif
 
 #ifndef BCRYPT_SHA1_ALGORITHM
 #define BCRYPT_SHA1_ALGORITHM L"SHA1"
@@ -216,6 +232,103 @@
 #define PKCS_RSA_PRIVATE_KEY (LPCSTR)43
 #endif
 
+#if defined(_MSC_VER) && _MSC_VER < 1700
+/* Workaround for warning C4306:
+   'type cast' : conversion from 'int' to 'LPCSTR' of greater size */
+#undef X509_SEQUENCE_OF_ANY
+#undef X509_MULTI_BYTE_UINT
+#undef PKCS_RSA_PRIVATE_KEY
+#define X509_SEQUENCE_OF_ANY ((LPCSTR)(size_t)34)
+#define X509_MULTI_BYTE_UINT ((LPCSTR)(size_t)38)
+#define PKCS_RSA_PRIVATE_KEY ((LPCSTR)(size_t)43)
+#endif
+
+static int
+_libssh2_wincng_bignum_resize(_libssh2_bn* bn, ULONG length);
+
+/*******************************************************************/
+/*
+ * Windows CNG backend: ECDSA-specific declarations.
+ */
+#if LIBSSH2_ECDSA
+
+typedef enum {
+    WINCNG_ECC_KEYTYPE_ECDSA = 0,
+    WINCNG_ECC_KEYTYPE_ECDH = 1,
+} _libssh2_wincng_ecc_keytype;
+
+typedef struct __libssh2_wincng_ecdsa_algorithm {
+    /* Algorithm name */
+    const char *name;
+
+    /* Key length, in bits */
+    ULONG key_length;
+
+    /* Length of each point, in bytes */
+    ULONG point_length;
+
+    /* Name of CNG algorithm provider, */
+    /* indexed by _libssh2_wincng_ecc_keytype */
+    LPCWSTR provider[2];
+
+    /* Magic for public key import, indexed by _libssh2_wincng_ecc_keytype */
+    ULONG public_import_magic[2];
+
+    /* Magic for private key import, indexed by _libssh2_wincng_ecc_keytype */
+    ULONG private_import_magic[2];
+} _libssh2_wincng_ecdsa_algorithm;
+
+/* Supported algorithms, indexed by libssh2_curve_type */
+static _libssh2_wincng_ecdsa_algorithm _wincng_ecdsa_algorithms[] = {
+    {
+        "ecdsa-sha2-nistp256",
+        256,
+        256 / 8,
+        { BCRYPT_ECDSA_P256_ALGORITHM, BCRYPT_ECDH_P256_ALGORITHM },
+        { BCRYPT_ECDSA_PUBLIC_P256_MAGIC, BCRYPT_ECDH_PUBLIC_P256_MAGIC },
+        { BCRYPT_ECDSA_PRIVATE_P256_MAGIC, BCRYPT_ECDH_PRIVATE_P256_MAGIC }
+    },
+    {
+        "ecdsa-sha2-nistp384",
+        384,
+        384 / 8,
+        { BCRYPT_ECDSA_P384_ALGORITHM, BCRYPT_ECDH_P384_ALGORITHM },
+        { BCRYPT_ECDSA_PUBLIC_P384_MAGIC, BCRYPT_ECDH_PUBLIC_P384_MAGIC },
+        { BCRYPT_ECDSA_PRIVATE_P384_MAGIC, BCRYPT_ECDH_PRIVATE_P384_MAGIC }
+    },
+    {
+        "ecdsa-sha2-nistp521",
+        521,
+        ((521 + 7) & ~7) / 8,
+        { BCRYPT_ECDSA_P521_ALGORITHM, BCRYPT_ECDH_P521_ALGORITHM },
+        { BCRYPT_ECDSA_PUBLIC_P521_MAGIC, BCRYPT_ECDH_PUBLIC_P521_MAGIC },
+        { BCRYPT_ECDSA_PRIVATE_P521_MAGIC, BCRYPT_ECDH_PRIVATE_P521_MAGIC }
+    },
+};
+
+/* An encoded point */
+typedef struct __libssh2_ecdsa_point {
+    libssh2_curve_type curve;
+
+    const unsigned char *x;
+    ULONG x_len;
+
+    const unsigned char *y;
+    ULONG y_len;
+} _libssh2_ecdsa_point;
+
+/* Lookup libssh2_curve_type by name */
+static int
+_libssh2_wincng_ecdsa_curve_type_from_name(IN const char *name,
+                                           OUT libssh2_curve_type *out_curve);
+
+/* Parse an OpenSSL-formatted ECDSA private key */
+static int
+_libssh2_wincng_parse_ecdsa_privatekey(OUT _libssh2_wincng_ecdsa_key **key,
+                                       IN unsigned char *privatekey,
+                                       IN size_t privatekey_len);
+
+#endif
 
 /*******************************************************************/
 /*
@@ -229,6 +342,10 @@ _libssh2_wincng_init(void)
 {
     int ret;
 
+#if LIBSSH2_ECDSA
+    unsigned int curve;
+#endif
+
     memset(&_libssh2_wincng, 0, sizeof(_libssh2_wincng));
 
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgRNG,
@@ -237,11 +354,13 @@ _libssh2_wincng_init(void)
         _libssh2_wincng.hAlgRNG = NULL;
     }
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashMD5,
                                       BCRYPT_MD5_ALGORITHM, NULL, 0);
     if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng.hAlgHashMD5 = NULL;
     }
+#endif
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHashSHA1,
                                       BCRYPT_SHA1_ALGORITHM, NULL, 0);
     if(!BCRYPT_SUCCESS(ret)) {
@@ -263,12 +382,14 @@ _libssh2_wincng_init(void)
         _libssh2_wincng.hAlgHashSHA512 = NULL;
     }
 
+#if LIBSSH2_MD5
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacMD5,
                                       BCRYPT_MD5_ALGORITHM, NULL,
                                       BCRYPT_ALG_HANDLE_HMAC_FLAG);
     if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng.hAlgHmacMD5 = NULL;
     }
+#endif
     ret = BCryptOpenAlgorithmProvider(&_libssh2_wincng.hAlgHmacSHA1,
                                       BCRYPT_SHA1_ALGORITHM, NULL,
                                       BCRYPT_ALG_HANDLE_HMAC_FLAG);
@@ -371,15 +492,46 @@ _libssh2_wincng_init(void)
     if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng.hAlgDH = NULL;
     }
+
+#if LIBSSH2_ECDSA
+    for(curve = 0; curve < ARRAY_SIZE(_wincng_ecdsa_algorithms); curve++) {
+        BCRYPT_ALG_HANDLE alg_handle_ecdsa;
+        BCRYPT_ALG_HANDLE alg_handle_ecdh;
+
+        ret = BCryptOpenAlgorithmProvider(
+            &alg_handle_ecdsa,
+            _wincng_ecdsa_algorithms[curve].provider[WINCNG_ECC_KEYTYPE_ECDSA],
+            NULL,
+            0);
+        if(BCRYPT_SUCCESS(ret)) {
+            _libssh2_wincng.hAlgECDSA[curve] = alg_handle_ecdsa;
+        }
+
+        ret = BCryptOpenAlgorithmProvider(
+            &alg_handle_ecdh,
+            _wincng_ecdsa_algorithms[curve].provider[WINCNG_ECC_KEYTYPE_ECDH],
+            NULL,
+            0);
+        if(BCRYPT_SUCCESS(ret)) {
+            _libssh2_wincng.hAlgECDH[curve] = alg_handle_ecdh;
+        }
+    }
+#endif
 }
 
 void
 _libssh2_wincng_free(void)
 {
+#if LIBSSH2_ECDSA
+    unsigned int curve;
+#endif
+
     if(_libssh2_wincng.hAlgRNG)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgRNG, 0);
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
     if(_libssh2_wincng.hAlgHashMD5)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashMD5, 0);
+#endif
     if(_libssh2_wincng.hAlgHashSHA1)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA1, 0);
     if(_libssh2_wincng.hAlgHashSHA256)
@@ -388,8 +540,10 @@ _libssh2_wincng_free(void)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA384, 0);
     if(_libssh2_wincng.hAlgHashSHA512)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHashSHA512, 0);
+#if LIBSSH2_MD5
     if(_libssh2_wincng.hAlgHmacMD5)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacMD5, 0);
+#endif
     if(_libssh2_wincng.hAlgHmacSHA1)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgHmacSHA1, 0);
     if(_libssh2_wincng.hAlgHmacSHA256)
@@ -411,33 +565,40 @@ _libssh2_wincng_free(void)
     if(_libssh2_wincng.hAlgDH)
         (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgDH, 0);
 
+#if LIBSSH2_ECDSA
+    for(curve = 0; curve < ARRAY_SIZE(_wincng_ecdsa_algorithms); curve++) {
+        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgECDSA[curve],
+                                           0);
+        (void)BCryptCloseAlgorithmProvider(_libssh2_wincng.hAlgECDH[curve],
+                                           0);
+    }
+#endif
+
     memset(&_libssh2_wincng, 0, sizeof(_libssh2_wincng));
 }
 
 int
-_libssh2_wincng_random(void *buf, int len)
+_libssh2_wincng_random(void *buf, size_t len)
 {
     int ret;
 
-    ret = BCryptGenRandom(_libssh2_wincng.hAlgRNG, buf, len, 0);
+    if(len > ULONG_MAX) {
+        return -1;
+    }
+
+    ret = BCryptGenRandom(_libssh2_wincng.hAlgRNG, buf, (ULONG)len, 0);
 
     return BCRYPT_SUCCESS(ret) ? 0 : -1;
 }
 
 static void
-_libssh2_wincng_safe_free(void *buf, int len)
+_libssh2_wincng_safe_free(void *buf, size_t len)
 {
-#ifndef LIBSSH2_CLEAR_MEMORY
-    (void)len;
-#endif
-
     if(!buf)
         return;
 
-#ifdef LIBSSH2_CLEAR_MEMORY
     if(len > 0)
-        SecureZeroMemory(buf, len);
-#endif
+        _libssh2_explicit_zero(buf, len);
 
     free(buf);
 }
@@ -446,8 +607,8 @@ _libssh2_wincng_safe_free(void *buf, int len)
  * if the size of src is smaller than dest then pad the "left" (MSB)
  * end with zeroes and copy the bits into the "right" (LSB) end. */
 static void
-memcpy_with_be_padding(unsigned char *dest, unsigned long dest_len,
-                       unsigned char *src, unsigned long src_len)
+memcpy_with_be_padding(unsigned char *dest, ULONG dest_len,
+                       unsigned char *src, ULONG src_len)
 {
     if(dest_len > src_len) {
         memset(dest, 0, dest_len - src_len);
@@ -455,12 +616,6 @@ memcpy_with_be_padding(unsigned char *dest, unsigned long dest_len,
     memcpy((dest + dest_len) - src_len, src, src_len);
 }
 
-static int
-round_down(int number, int multiple)
-{
-    return (number / multiple) * multiple;
-}
-
 /*******************************************************************/
 /*
  * Windows CNG backend: Hash functions
@@ -468,12 +623,12 @@ round_down(int number, int multiple)
 
 int
 _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
-                          BCRYPT_ALG_HANDLE hAlg, unsigned long hashlen,
-                          unsigned char *key, unsigned long keylen)
+                          BCRYPT_ALG_HANDLE hAlg, ULONG hashlen,
+                          unsigned char *key, ULONG keylen)
 {
     BCRYPT_HASH_HANDLE hHash;
     unsigned char *pbHashObject;
-    unsigned long dwHashObject, dwHash, cbData;
+    ULONG dwHashObject, dwHash, cbData;
     int ret;
 
     ret = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH,
@@ -517,11 +672,11 @@ _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
 
 int
 _libssh2_wincng_hash_update(_libssh2_wincng_hash_ctx *ctx,
-                            const unsigned char *data, unsigned long datalen)
+                            const void *data, ULONG datalen)
 {
     int ret;
 
-    ret = BCryptHashData(ctx->hHash, (unsigned char *)data, datalen, 0);
+    ret = BCryptHashData(ctx->hHash, (PUCHAR)data, datalen, 0);
 
     return BCRYPT_SUCCESS(ret) ? 0 : -1;
 }
@@ -545,9 +700,9 @@ _libssh2_wincng_hash_final(_libssh2_wincng_hash_ctx *ctx,
 }
 
 int
-_libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
+_libssh2_wincng_hash(const unsigned char *data, ULONG datalen,
                      BCRYPT_ALG_HANDLE hAlg,
-                     unsigned char *hash, unsigned long hashlen)
+                     unsigned char *hash, ULONG hashlen)
 {
     _libssh2_wincng_hash_ctx ctx;
     int ret;
@@ -567,19 +722,70 @@ _libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
  * Windows CNG backend: HMAC functions
  */
 
-int
-_libssh2_wincng_hmac_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash)
+int _libssh2_hmac_ctx_init(libssh2_hmac_ctx *ctx)
 {
-    int ret;
+    memset(ctx, 0, sizeof(*ctx));
+    return 1;
+}
 
-    ret = BCryptFinishHash(ctx->hHash, hash, ctx->cbHash, 0);
+#if LIBSSH2_MD5
+int _libssh2_hmac_md5_init(libssh2_hmac_ctx *ctx,
+                           void *key, size_t keylen)
+{
+    int ret = _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacMD5,
+                                        MD5_DIGEST_LENGTH,
+                                        key, (ULONG) keylen);
 
-    return BCRYPT_SUCCESS(ret) ? 0 : -1;
+    return ret == 0 ? 1 : 0;
 }
+#endif
 
-void
-_libssh2_wincng_hmac_cleanup(_libssh2_wincng_hash_ctx *ctx)
+int _libssh2_hmac_sha1_init(libssh2_hmac_ctx *ctx,
+                            void *key, size_t keylen)
+{
+    int ret = _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA1,
+                                        SHA_DIGEST_LENGTH,
+                                        key, (ULONG) keylen);
+
+    return ret == 0 ? 1 : 0;
+}
+
+int _libssh2_hmac_sha256_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    int ret = _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA256,
+                                        SHA256_DIGEST_LENGTH,
+                                        key, (ULONG) keylen);
+
+    return ret == 0 ? 1 : 0;
+}
+
+int _libssh2_hmac_sha512_init(libssh2_hmac_ctx *ctx,
+                              void *key, size_t keylen)
+{
+    int ret = _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA512,
+                                        SHA512_DIGEST_LENGTH,
+                                        key, (ULONG) keylen);
+
+    return ret == 0 ? 1 : 0;
+}
+
+int _libssh2_hmac_update(libssh2_hmac_ctx *ctx,
+                         const void *data, size_t datalen)
+{
+    int ret = _libssh2_wincng_hash_update(ctx, data, (ULONG) datalen);
+
+    return ret == 0 ? 1 : 0;
+}
+
+int _libssh2_hmac_final(libssh2_hmac_ctx *ctx, void *data)
+{
+    int ret = BCryptFinishHash(ctx->hHash, data, ctx->cbHash, 0);
+
+    return BCRYPT_SUCCESS(ret) ? 1 : 0;
+}
+
+void _libssh2_hmac_cleanup(libssh2_hmac_ctx *ctx)
 {
     BCryptDestroyHash(ctx->hHash);
     ctx->hHash = NULL;
@@ -595,39 +801,58 @@ _libssh2_wincng_hmac_cleanup(_libssh2_wincng_hash_ctx *ctx)
  * Windows CNG backend: Key functions
  */
 
-int
-_libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len,
-                                unsigned long flags)
+static int
+_libssh2_wincng_key_sha_verify(_libssh2_wincng_key_ctx *ctx,
+                               ULONG hashlen,
+                               const unsigned char *sig,
+                               ULONG sig_len,
+                               const unsigned char *m,
+                               ULONG m_len,
+                               ULONG flags)
 {
     BCRYPT_PKCS1_PADDING_INFO paddingInfoPKCS1;
+    BCRYPT_ALG_HANDLE hAlgHash;
     void *pPaddingInfo;
     unsigned char *data, *hash;
-    unsigned long datalen, hashlen;
+    ULONG datalen;
     int ret;
 
+    if(hashlen == SHA_DIGEST_LENGTH) {
+        hAlgHash = _libssh2_wincng.hAlgHashSHA1;
+        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA1_ALGORITHM;
+    }
+    else if(hashlen == SHA256_DIGEST_LENGTH) {
+        hAlgHash = _libssh2_wincng.hAlgHashSHA256;
+        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA256_ALGORITHM;
+    }
+    else if(hashlen == SHA384_DIGEST_LENGTH) {
+        hAlgHash = _libssh2_wincng.hAlgHashSHA384;
+        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA384_ALGORITHM;
+    }
+    else if(hashlen == SHA512_DIGEST_LENGTH) {
+        hAlgHash = _libssh2_wincng.hAlgHashSHA512;
+        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA512_ALGORITHM;
+    }
+    else {
+        return -1;
+    }
+
     datalen = m_len;
     data = malloc(datalen);
     if(!data) {
         return -1;
     }
 
-    hashlen = SHA_DIGEST_LENGTH;
     hash = malloc(hashlen);
     if(!hash) {
         free(data);
         return -1;
     }
-
     memcpy(data, m, datalen);
 
     ret = _libssh2_wincng_hash(data, datalen,
-                               _libssh2_wincng.hAlgHashSHA1,
+                               hAlgHash,
                                hash, hashlen);
-
     _libssh2_wincng_safe_free(data, datalen);
 
     if(ret) {
@@ -643,7 +868,6 @@ _libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
     }
 
     if(flags & BCRYPT_PAD_PKCS1) {
-        paddingInfoPKCS1.pszAlgId = BCRYPT_SHA1_ALGORITHM;
         pPaddingInfo = &paddingInfoPKCS1;
     }
     else
@@ -664,11 +888,11 @@ _libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
 static int
 _libssh2_wincng_load_pem(LIBSSH2_SESSION *session,
                          const char *filename,
-                         const char *passphrase,
+                         const unsigned char *passphrase,
                          const char *headerbegin,
                          const char *headerend,
                          unsigned char **data,
-                         unsigned int *datalen)
+                         size_t *datalen)
 {
     FILE *fp;
     int ret;
@@ -690,13 +914,13 @@ _libssh2_wincng_load_pem(LIBSSH2_SESSION *session,
 static int
 _libssh2_wincng_load_private(LIBSSH2_SESSION *session,
                              const char *filename,
-                             const char *passphrase,
+                             const unsigned char *passphrase,
                              unsigned char **ppbEncoded,
-                             unsigned long *pcbEncoded,
+                             size_t *pcbEncoded,
                              int tryLoadRSA, int tryLoadDSA)
 {
     unsigned char *data = NULL;
-    unsigned int datalen = 0;
+    size_t datalen = 0;
     int ret = -1;
 
     if(ret && tryLoadRSA) {
@@ -723,13 +947,13 @@ static int
 _libssh2_wincng_load_private_memory(LIBSSH2_SESSION *session,
                                     const char *privatekeydata,
                                     size_t privatekeydata_len,
-                                    const char *passphrase,
+                                    const unsigned char *passphrase,
                                     unsigned char **ppbEncoded,
-                                    unsigned long *pcbEncoded,
+                                    size_t *pcbEncoded,
                                     int tryLoadRSA, int tryLoadDSA)
 {
     unsigned char *data = NULL;
-    unsigned int datalen = 0;
+    size_t datalen = 0;
     int ret = -1;
 
     (void)passphrase;
@@ -758,13 +982,13 @@ _libssh2_wincng_load_private_memory(LIBSSH2_SESSION *session,
 
 static int
 _libssh2_wincng_asn_decode(unsigned char *pbEncoded,
-                           unsigned long cbEncoded,
+                           DWORD cbEncoded,
                            LPCSTR lpszStructType,
                            unsigned char **ppbDecoded,
-                           unsigned long *pcbDecoded)
+                           DWORD *pcbDecoded)
 {
     unsigned char *pbDecoded = NULL;
-    unsigned long cbDecoded = 0;
+    DWORD cbDecoded = 0;
     int ret;
 
     ret = CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
@@ -798,12 +1022,12 @@ _libssh2_wincng_asn_decode(unsigned char *pbEncoded,
 
 static int
 _libssh2_wincng_bn_ltob(unsigned char *pbInput,
-                        unsigned long cbInput,
+                        DWORD cbInput,
                         unsigned char **ppbOutput,
-                        unsigned long *pcbOutput)
+                        DWORD *pcbOutput)
 {
     unsigned char *pbOutput;
-    unsigned long cbOutput, index, offset, length;
+    DWORD cbOutput, index, offset, length;
 
     if(cbInput < 1) {
         return 0;
@@ -837,20 +1061,21 @@ _libssh2_wincng_bn_ltob(unsigned char *pbInput,
 
 static int
 _libssh2_wincng_asn_decode_bn(unsigned char *pbEncoded,
-                              unsigned long cbEncoded,
+                              DWORD cbEncoded,
                               unsigned char **ppbDecoded,
-                              unsigned long *pcbDecoded)
+                              DWORD *pcbDecoded)
 {
-    unsigned char *pbDecoded = NULL, *pbInteger;
-    unsigned long cbDecoded = 0, cbInteger;
+    unsigned char *pbDecoded = NULL;
+    PCRYPT_DATA_BLOB pbInteger;
+    DWORD cbDecoded = 0, cbInteger;
     int ret;
 
     ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
                                      X509_MULTI_BYTE_UINT,
-                                     &pbInteger, &cbInteger);
+                                     (void *)&pbInteger, &cbInteger);
     if(!ret) {
-        ret = _libssh2_wincng_bn_ltob(((PCRYPT_DATA_BLOB)pbInteger)->pbData,
-                                      ((PCRYPT_DATA_BLOB)pbInteger)->cbData,
+        ret = _libssh2_wincng_bn_ltob(pbInteger->pbData,
+                                      pbInteger->cbData,
                                       &pbDecoded, &cbDecoded);
         if(!ret) {
             *ppbDecoded = pbDecoded;
@@ -864,29 +1089,29 @@ _libssh2_wincng_asn_decode_bn(unsigned char *pbEncoded,
 
 static int
 _libssh2_wincng_asn_decode_bns(unsigned char *pbEncoded,
-                               unsigned long cbEncoded,
+                               DWORD cbEncoded,
                                unsigned char ***prpbDecoded,
-                               unsigned long **prcbDecoded,
-                               unsigned long *pcbCount)
+                               DWORD **prcbDecoded,
+                               DWORD *pcbCount)
 {
     PCRYPT_DER_BLOB pBlob;
-    unsigned char *pbDecoded, **rpbDecoded;
-    unsigned long cbDecoded, *rcbDecoded, index, length;
+    unsigned char **rpbDecoded;
+    PCRYPT_SEQUENCE_OF_ANY pbDecoded;
+    DWORD cbDecoded, *rcbDecoded, index, length;
     int ret;
 
     ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
                                      X509_SEQUENCE_OF_ANY,
-                                     &pbDecoded, &cbDecoded);
+                                     (void *)&pbDecoded, &cbDecoded);
     if(!ret) {
-        length = ((PCRYPT_DATA_BLOB)pbDecoded)->cbData;
+        length = pbDecoded->cValue;
 
         rpbDecoded = malloc(sizeof(PBYTE) * length);
         if(rpbDecoded) {
             rcbDecoded = malloc(sizeof(DWORD) * length);
             if(rcbDecoded) {
                 for(index = 0; index < length; index++) {
-                    pBlob = &((PCRYPT_DER_BLOB)
-                              ((PCRYPT_DATA_BLOB)pbDecoded)->pbData)[index];
+                    pBlob = &pbDecoded->rgValue[index];
                     ret = _libssh2_wincng_asn_decode_bn(pBlob->pbData,
                                                         pBlob->cbData,
                                                         &rpbDecoded[index],
@@ -927,11 +1152,11 @@ _libssh2_wincng_asn_decode_bns(unsigned char *pbEncoded,
 }
 #endif /* HAVE_LIBCRYPT32 */
 
-static unsigned long
-_libssh2_wincng_bn_size(const unsigned char *bignum,
-                        unsigned long length)
+#if LIBSSH2_RSA || LIBSSH2_DSA
+static ULONG
+_libssh2_wincng_bn_size(const unsigned char *bignum, ULONG length)
 {
-    unsigned long offset;
+    ULONG offset;
 
     if(!bignum)
         return 0;
@@ -946,8 +1171,10 @@ _libssh2_wincng_bn_size(const unsigned char *bignum,
 
     return length - offset;
 }
+#endif
 
 
+#if LIBSSH2_RSA
 /*******************************************************************/
 /*
  * Windows CNG backend: RSA functions
@@ -975,8 +1202,7 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
     BCRYPT_KEY_HANDLE hKey;
     BCRYPT_RSAKEY_BLOB *rsakey;
     LPCWSTR lpszBlobType;
-    unsigned char *key;
-    unsigned long keylen, offset, mlen, p1len = 0, p2len = 0;
+    ULONG keylen, offset, mlen, p1len = 0, p2len = 0;
     int ret;
 
     mlen = max(_libssh2_wincng_bn_size(ndata, nlen),
@@ -991,65 +1217,76 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
         keylen += p1len * 3 + p2len * 2 + mlen;
     }
 
-    key = malloc(keylen);
-    if(!key) {
+    rsakey = (BCRYPT_RSAKEY_BLOB *)malloc(keylen);
+    if(!rsakey) {
         return -1;
     }
 
-    memset(key, 0, keylen);
+    memset(rsakey, 0, keylen);
 
 
     /* https://msdn.microsoft.com/library/windows/desktop/aa375531.aspx */
-    rsakey = (BCRYPT_RSAKEY_BLOB *)key;
     rsakey->BitLength = mlen * 8;
     rsakey->cbPublicExp = elen;
     rsakey->cbModulus = mlen;
 
-    memcpy(key + offset, edata, elen);
+    memcpy((unsigned char *)rsakey + offset, edata, elen);
     offset += elen;
 
     if(nlen < mlen)
-        memcpy(key + offset + mlen - nlen, ndata, nlen);
+        memcpy((unsigned char *)rsakey + offset + mlen - nlen, ndata, nlen);
     else
-        memcpy(key + offset, ndata + nlen - mlen, mlen);
+        memcpy((unsigned char *)rsakey + offset, ndata + nlen - mlen, mlen);
 
     if(ddata && dlen > 0) {
         offset += mlen;
 
         if(plen < p1len)
-            memcpy(key + offset + p1len - plen, pdata, plen);
+            memcpy((unsigned char *)rsakey + offset + p1len - plen,
+                   pdata, plen);
         else
-            memcpy(key + offset, pdata + plen - p1len, p1len);
+            memcpy((unsigned char *)rsakey + offset,
+                   pdata + plen - p1len, p1len);
         offset += p1len;
 
         if(qlen < p2len)
-            memcpy(key + offset + p2len - qlen, qdata, qlen);
+            memcpy((unsigned char *)rsakey + offset + p2len - qlen,
+                   qdata, qlen);
         else
-            memcpy(key + offset, qdata + qlen - p2len, p2len);
+            memcpy((unsigned char *)rsakey + offset,
+                   qdata + qlen - p2len, p2len);
         offset += p2len;
 
         if(e1len < p1len)
-            memcpy(key + offset + p1len - e1len, e1data, e1len);
+            memcpy((unsigned char *)rsakey + offset + p1len - e1len,
+                   e1data, e1len);
         else
-            memcpy(key + offset, e1data + e1len - p1len, p1len);
+            memcpy((unsigned char *)rsakey + offset,
+                   e1data + e1len - p1len, p1len);
         offset += p1len;
 
         if(e2len < p2len)
-            memcpy(key + offset + p2len - e2len, e2data, e2len);
+            memcpy((unsigned char *)rsakey + offset + p2len - e2len,
+                   e2data, e2len);
         else
-            memcpy(key + offset, e2data + e2len - p2len, p2len);
+            memcpy((unsigned char *)rsakey + offset,
+                   e2data + e2len - p2len, p2len);
         offset += p2len;
 
         if(coefflen < p1len)
-            memcpy(key + offset + p1len - coefflen, coeffdata, coefflen);
+            memcpy((unsigned char *)rsakey + offset + p1len - coefflen,
+                   coeffdata, coefflen);
         else
-            memcpy(key + offset, coeffdata + coefflen - p1len, p1len);
+            memcpy((unsigned char *)rsakey + offset,
+                   coeffdata + coefflen - p1len, p1len);
         offset += p1len;
 
         if(dlen < mlen)
-            memcpy(key + offset + mlen - dlen, ddata, dlen);
+            memcpy((unsigned char *)rsakey + offset + mlen - dlen,
+                   ddata, dlen);
         else
-            memcpy(key + offset, ddata + dlen - mlen, mlen);
+            memcpy((unsigned char *)rsakey + offset,
+                   ddata + dlen - mlen, mlen);
 
         lpszBlobType = BCRYPT_RSAFULLPRIVATE_BLOB;
         rsakey->Magic = BCRYPT_RSAFULLPRIVATE_MAGIC;
@@ -1065,9 +1302,9 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
 
 
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL, lpszBlobType,
-                              &hKey, key, keylen, 0);
+                              &hKey, (PUCHAR)rsakey, keylen, 0);
     if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(key, keylen);
+        _libssh2_wincng_safe_free(rsakey, keylen);
         return -1;
     }
 
@@ -1075,12 +1312,12 @@ _libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
     *rsa = malloc(sizeof(libssh2_rsa_ctx));
     if(!(*rsa)) {
         BCryptDestroyKey(hKey);
-        _libssh2_wincng_safe_free(key, keylen);
+        _libssh2_wincng_safe_free(rsakey, keylen);
         return -1;
     }
 
     (*rsa)->hKey = hKey;
-    (*rsa)->pbKeyObject = key;
+    (*rsa)->pbKeyObject = rsakey;
     (*rsa)->cbKeyObject = keylen;
 
     return 0;
@@ -1091,16 +1328,16 @@ static int
 _libssh2_wincng_rsa_new_private_parse(libssh2_rsa_ctx **rsa,
                                       LIBSSH2_SESSION *session,
                                       unsigned char *pbEncoded,
-                                      unsigned long cbEncoded)
+                                      size_t cbEncoded)
 {
     BCRYPT_KEY_HANDLE hKey;
     unsigned char *pbStructInfo;
-    unsigned long cbStructInfo;
+    DWORD cbStructInfo;
     int ret;
 
     (void)session;
 
-    ret = _libssh2_wincng_asn_decode(pbEncoded, cbEncoded,
+    ret = _libssh2_wincng_asn_decode(pbEncoded, (DWORD)cbEncoded,
                                      PKCS_RSA_PRIVATE_KEY,
                                      &pbStructInfo, &cbStructInfo);
 
@@ -1143,13 +1380,12 @@ _libssh2_wincng_rsa_new_private(libssh2_rsa_ctx **rsa,
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
     (void)session;
 
-    ret = _libssh2_wincng_load_private(session, filename,
-                                       (const char *)passphrase,
+    ret = _libssh2_wincng_load_private(session, filename, passphrase,
                                        &pbEncoded, &cbEncoded, 1, 0);
     if(ret) {
         return -1;
@@ -1173,17 +1409,17 @@ _libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
                                            LIBSSH2_SESSION *session,
                                            const char *filedata,
                                            size_t filedata_len,
-                                           unsigned const char *passphrase)
+                                           const unsigned char *passphrase)
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
     (void)session;
 
     ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
-                                              (const char *)passphrase,
+                                              passphrase,
                                               &pbEncoded, &cbEncoded, 1, 0);
     if(ret) {
         return -1;
@@ -1203,38 +1439,69 @@ _libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
 #endif /* HAVE_LIBCRYPT32 */
 }
 
+#if LIBSSH2_RSA_SHA1
 int
 _libssh2_wincng_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
                                 const unsigned char *sig,
-                                unsigned long sig_len,
+                                size_t sig_len,
                                 const unsigned char *m,
-                                unsigned long m_len)
+                                size_t m_len)
 {
-    return _libssh2_wincng_key_sha1_verify(rsa, sig, sig_len, m, m_len,
-                                           BCRYPT_PAD_PKCS1);
+    return _libssh2_wincng_key_sha_verify(rsa, SHA_DIGEST_LENGTH,
+                                          sig, (ULONG)sig_len,
+                                          m, (ULONG)m_len,
+                                          BCRYPT_PAD_PKCS1);
 }
+#endif
 
+#if LIBSSH2_RSA_SHA2
 int
-_libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len)
+_libssh2_wincng_rsa_sha2_verify(libssh2_rsa_ctx *rsa,
+                                size_t hash_len,
+                                const unsigned char *sig,
+                                size_t sig_len,
+                                const unsigned char *m,
+                                size_t m_len)
+{
+    return _libssh2_wincng_key_sha_verify(rsa, (ULONG)hash_len,
+                                          sig, (ULONG)sig_len,
+                                          m, (ULONG)m_len,
+                                          BCRYPT_PAD_PKCS1);
+}
+#endif
+
+static int
+_libssh2_wincng_rsa_sha_sign(LIBSSH2_SESSION *session,
+                             libssh2_rsa_ctx *rsa,
+                             const unsigned char *hash,
+                             size_t hash_len,
+                             unsigned char **signature,
+                             size_t *signature_len)
 {
     BCRYPT_PKCS1_PADDING_INFO paddingInfo;
     unsigned char *data, *sig;
-    unsigned long cbData, datalen, siglen;
-    int ret;
+    ULONG cbData, datalen, siglen;
+    NTSTATUS ret;
+
+    if(hash_len == SHA_DIGEST_LENGTH)
+        paddingInfo.pszAlgId = BCRYPT_SHA1_ALGORITHM;
+    else if(hash_len == SHA256_DIGEST_LENGTH)
+        paddingInfo.pszAlgId = BCRYPT_SHA256_ALGORITHM;
+    else if(hash_len == SHA384_DIGEST_LENGTH)
+        paddingInfo.pszAlgId = BCRYPT_SHA384_ALGORITHM;
+    else if(hash_len == SHA512_DIGEST_LENGTH)
+        paddingInfo.pszAlgId = BCRYPT_SHA512_ALGORITHM;
+    else {
+        _libssh2_error(session, LIBSSH2_ERROR_PROTO,
+                       "Unsupported hash digest length");
+        return -1;
+    }
 
-    datalen = (unsigned long)hash_len;
+    datalen = (ULONG)hash_len;
     data = malloc(datalen);
     if(!data) {
         return -1;
     }
-
-    paddingInfo.pszAlgId = BCRYPT_SHA1_ALGORITHM;
-
     memcpy(data, hash, datalen);
 
     ret = BCryptSignHash(rsa->hKey, &paddingInfo,
@@ -1256,7 +1523,7 @@ _libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
             }
         }
         else
-            ret = STATUS_NO_MEMORY;
+            ret = (NTSTATUS)STATUS_NO_MEMORY;
     }
 
     _libssh2_wincng_safe_free(data, datalen);
@@ -1264,6 +1531,32 @@ _libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
     return BCRYPT_SUCCESS(ret) ? 0 : -1;
 }
 
+int
+_libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
+                              libssh2_rsa_ctx *rsa,
+                              const unsigned char *hash,
+                              size_t hash_len,
+                              unsigned char **signature,
+                              size_t *signature_len)
+{
+    return _libssh2_wincng_rsa_sha_sign(session, rsa,
+                                        hash, hash_len,
+                                        signature, signature_len);
+}
+
+int
+_libssh2_wincng_rsa_sha2_sign(LIBSSH2_SESSION *session,
+                              libssh2_rsa_ctx *rsa,
+                              const unsigned char *hash,
+                              size_t hash_len,
+                              unsigned char **signature,
+                              size_t *signature_len)
+{
+    return _libssh2_wincng_rsa_sha_sign(session, rsa,
+                                        hash, hash_len,
+                                        signature, signature_len);
+}
+
 void
 _libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa)
 {
@@ -1276,7 +1569,7 @@ _libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa)
     _libssh2_wincng_safe_free(rsa->pbKeyObject, rsa->cbKeyObject);
     _libssh2_wincng_safe_free(rsa, sizeof(libssh2_rsa_ctx));
 }
-
+#endif
 
 /*******************************************************************/
 /*
@@ -1300,8 +1593,7 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
     BCRYPT_KEY_HANDLE hKey;
     BCRYPT_DSA_KEY_BLOB *dsakey;
     LPCWSTR lpszBlobType;
-    unsigned char *key;
-    unsigned long keylen, offset, length;
+    ULONG keylen, offset, length;
     int ret;
 
     length = max(max(_libssh2_wincng_bn_size(pdata, plen),
@@ -1312,16 +1604,15 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
     if(xdata && xlen > 0)
         keylen += 20;
 
-    key = malloc(keylen);
-    if(!key) {
+    dsakey = (BCRYPT_DSA_KEY_BLOB *)malloc(keylen);
+    if(!dsakey) {
         return -1;
     }
 
-    memset(key, 0, keylen);
+    memset(dsakey, 0, keylen);
 
 
     /* https://msdn.microsoft.com/library/windows/desktop/aa833126.aspx */
-    dsakey = (BCRYPT_DSA_KEY_BLOB *)key;
     dsakey->cbKey = length;
 
     memset(dsakey->Count, -1, sizeof(dsakey->Count));
@@ -1333,29 +1624,35 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
         memcpy(dsakey->q, qdata + qlen - 20, 20);
 
     if(plen < length)
-        memcpy(key + offset + length - plen, pdata, plen);
+        memcpy((unsigned char *)dsakey + offset + length - plen,
+               pdata, plen);
     else
-        memcpy(key + offset, pdata + plen - length, length);
+        memcpy((unsigned char *)dsakey + offset,
+               pdata + plen - length, length);
     offset += length;
 
     if(glen < length)
-        memcpy(key + offset + length - glen, gdata, glen);
+        memcpy((unsigned char *)dsakey + offset + length - glen,
+               gdata, glen);
     else
-        memcpy(key + offset, gdata + glen - length, length);
+        memcpy((unsigned char *)dsakey + offset,
+               gdata + glen - length, length);
     offset += length;
 
     if(ylen < length)
-        memcpy(key + offset + length - ylen, ydata, ylen);
+        memcpy((unsigned char *)dsakey + offset + length - ylen,
+               ydata, ylen);
     else
-        memcpy(key + offset, ydata + ylen - length, length);
+        memcpy((unsigned char *)dsakey + offset,
+               ydata + ylen - length, length);
 
     if(xdata && xlen > 0) {
         offset += length;
 
         if(xlen < 20)
-            memcpy(key + offset + 20 - xlen, xdata, xlen);
+            memcpy((unsigned char *)dsakey + offset + 20 - xlen, xdata, xlen);
         else
-            memcpy(key + offset, xdata + xlen - 20, 20);
+            memcpy((unsigned char *)dsakey + offset, xdata + xlen - 20, 20);
 
         lpszBlobType = BCRYPT_DSA_PRIVATE_BLOB;
         dsakey->dwMagic = BCRYPT_DSA_PRIVATE_MAGIC;
@@ -1367,9 +1664,9 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
 
 
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgDSA, NULL, lpszBlobType,
-                              &hKey, key, keylen, 0);
+                              &hKey, (PUCHAR)dsakey, keylen, 0);
     if(!BCRYPT_SUCCESS(ret)) {
-        _libssh2_wincng_safe_free(key, keylen);
+        _libssh2_wincng_safe_free(dsakey, keylen);
         return -1;
     }
 
@@ -1377,12 +1674,12 @@ _libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
     *dsa = malloc(sizeof(libssh2_dsa_ctx));
     if(!(*dsa)) {
         BCryptDestroyKey(hKey);
-        _libssh2_wincng_safe_free(key, keylen);
+        _libssh2_wincng_safe_free(dsakey, keylen);
         return -1;
     }
 
     (*dsa)->hKey = hKey;
-    (*dsa)->pbKeyObject = key;
+    (*dsa)->pbKeyObject = dsakey;
     (*dsa)->cbKeyObject = keylen;
 
     return 0;
@@ -1393,15 +1690,15 @@ static int
 _libssh2_wincng_dsa_new_private_parse(libssh2_dsa_ctx **dsa,
                                       LIBSSH2_SESSION *session,
                                       unsigned char *pbEncoded,
-                                      unsigned long cbEncoded)
+                                      size_t cbEncoded)
 {
     unsigned char **rpbDecoded;
-    unsigned long *rcbDecoded, index, length;
+    DWORD *rcbDecoded, index, length;
     int ret;
 
     (void)session;
 
-    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, cbEncoded,
+    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, (DWORD)cbEncoded,
                                          &rpbDecoded, &rcbDecoded, &length);
 
     _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
@@ -1444,11 +1741,10 @@ _libssh2_wincng_dsa_new_private(libssh2_dsa_ctx **dsa,
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
-    ret = _libssh2_wincng_load_private(session, filename,
-                                       (const char *)passphrase,
+    ret = _libssh2_wincng_load_private(session, filename, passphrase,
                                        &pbEncoded, &cbEncoded, 0, 1);
     if(ret) {
         return -1;
@@ -1472,15 +1768,15 @@ _libssh2_wincng_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
                                            LIBSSH2_SESSION *session,
                                            const char *filedata,
                                            size_t filedata_len,
-                                           unsigned const char *passphrase)
+                                           const unsigned char *passphrase)
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
     ret = _libssh2_wincng_load_private_memory(session, filedata, filedata_len,
-                                              (const char *)passphrase,
+                                              passphrase,
                                               &pbEncoded, &cbEncoded, 0, 1);
     if(ret) {
         return -1;
@@ -1504,22 +1800,23 @@ int
 _libssh2_wincng_dsa_sha1_verify(libssh2_dsa_ctx *dsa,
                                 const unsigned char *sig_fixed,
                                 const unsigned char *m,
-                                unsigned long m_len)
+                                size_t m_len)
 {
-    return _libssh2_wincng_key_sha1_verify(dsa, sig_fixed, 40, m, m_len, 0);
+    return _libssh2_wincng_key_sha_verify(dsa, SHA_DIGEST_LENGTH, sig_fixed,
+                                          40, m, (ULONG)m_len, 0);
 }
 
 int
 _libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
                               const unsigned char *hash,
-                              unsigned long hash_len,
+                              size_t hash_len,
                               unsigned char *sig_fixed)
 {
     unsigned char *data, *sig;
-    unsigned long cbData, datalen, siglen;
-    int ret;
+    ULONG cbData, datalen, siglen;
+    NTSTATUS ret;
 
-    datalen = hash_len;
+    datalen = (ULONG)hash_len;
     data = malloc(datalen);
     if(!data) {
         return -1;
@@ -1543,10 +1840,10 @@ _libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
                 _libssh2_wincng_safe_free(sig, siglen);
             }
             else
-                ret = STATUS_NO_MEMORY;
+                ret = (NTSTATUS)STATUS_NO_MEMORY;
         }
         else
-            ret = STATUS_NO_MEMORY;
+            ret = (NTSTATUS)STATUS_NO_MEMORY;
     }
 
     _libssh2_wincng_safe_free(data, datalen);
@@ -1571,124 +1868,1334 @@ _libssh2_wincng_dsa_free(libssh2_dsa_ctx *dsa)
 
 /*******************************************************************/
 /*
- * Windows CNG backend: Key functions
+ * Windows CNG backend: ECDSA helper functions
  */
 
-#ifdef HAVE_LIBCRYPT32
-static unsigned long
-_libssh2_wincng_pub_priv_write(unsigned char *key,
-                               unsigned long offset,
-                               const unsigned char *bignum,
-                               const unsigned long length)
-{
-    _libssh2_htonu32(key + offset, length);
-    offset += 4;
-
-    memcpy(key + offset, bignum, length);
-    offset += length;
-
-    return offset;
-}
+#if LIBSSH2_ECDSA
 
+/*
+ * Decode an uncompressed point.
+ */
 static int
-_libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       unsigned char *pbEncoded,
-                                       unsigned long cbEncoded)
+_libssh2_wincng_ecdsa_decode_uncompressed_point(
+    IN const unsigned char *encoded_point,
+    IN size_t encoded_point_len,
+    OUT _libssh2_ecdsa_point *point)
 {
-    unsigned char **rpbDecoded;
-    unsigned long *rcbDecoded;
-    unsigned char *key = NULL, *mth = NULL;
-    unsigned long keylen = 0, mthlen = 0;
-    unsigned long index, offset, length;
-    int ret;
-
-    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, cbEncoded,
-                                         &rpbDecoded, &rcbDecoded, &length);
+    unsigned int curve;
 
-    _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
+    if(!point) {
+        return LIBSSH2_ERROR_INVAL;
+    }
 
-    if(ret) {
-        return -1;
+    /* Verify that the point uses uncompressed format */
+    if(encoded_point_len == 0 || encoded_point[0] != 4) {
+        return LIBSSH2_ERROR_INVAL;
     }
 
+    for(curve = 0; curve < ARRAY_SIZE(_wincng_ecdsa_algorithms); curve++) {
+        if(_wincng_ecdsa_algorithms[curve].point_length ==
+            (encoded_point_len - 1) / 2) {
 
-    if(length == 9) { /* private RSA key */
-        mthlen = 7;
-        mth = LIBSSH2_ALLOC(session, mthlen);
-        if(mth) {
-            memcpy(mth, "ssh-rsa", mthlen);
-        }
-        else {
-            ret = -1;
+            point->curve = curve;
+
+            point->x = encoded_point + 1;
+            point->x_len = _wincng_ecdsa_algorithms[curve].point_length;
+
+            point->y = point->x + point->x_len;
+            point->y_len = _wincng_ecdsa_algorithms[curve].point_length;
+
+            return LIBSSH2_ERROR_NONE;
         }
+    }
+
+    return LIBSSH2_ERROR_INVAL;
+}
 
+/*
+ * Create a IEEE P-1363 signature from a point.
+ *
+ * The IEEE P-1363 format is defined as r || s,
+ * where r and s are of the same length.
+ */
+static int
+_libssh2_wincng_p1363signature_from_point(IN const unsigned char *r,
+                                          IN size_t r_len,
+                                          IN const unsigned char *s,
+                                          IN size_t s_len,
+                                          IN libssh2_curve_type curve,
+                                          OUT PUCHAR *signature,
+                                          OUT size_t *signature_length)
+{
+    const unsigned char *r_trimmed;
+    const unsigned char *s_trimmed;
+    size_t r_trimmed_len;
+    size_t s_trimmed_len;
+
+    /* Validate parameters */
+    if(curve >= ARRAY_SIZE(_wincng_ecdsa_algorithms)) {
+        return LIBSSH2_ERROR_INVAL;
+    }
 
-        keylen = 4 + mthlen + 4 + rcbDecoded[2] + 4 + rcbDecoded[1];
-        key = LIBSSH2_ALLOC(session, keylen);
-        if(key) {
-            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
+    *signature = NULL;
+    *signature_length = (size_t)
+        _wincng_ecdsa_algorithms[curve].point_length * 2;
 
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[2],
-                                                    rcbDecoded[2]);
+    /* Trim leading zero, if any */
+    r_trimmed = r;
+    r_trimmed_len = r_len;
+    if(r_len > 0 && r[0] == '\0') {
+        r_trimmed++;
+        r_trimmed_len--;
+    }
 
-            _libssh2_wincng_pub_priv_write(key, offset,
-                                           rpbDecoded[1],
-                                           rcbDecoded[1]);
-        }
-        else {
-            ret = -1;
-        }
+    s_trimmed = s;
+    s_trimmed_len = s_len;
+    if(s_len > 0 && s[0] == '\0') {
+        s_trimmed++;
+        s_trimmed_len--;
+    }
 
+    /* Concatenate into zero-filled buffer and zero-pad if necessary */
+    *signature = calloc(1, *signature_length);
+    if(!*signature) {
+        return LIBSSH2_ERROR_ALLOC;
     }
-    else if(length == 6) { /* private DSA key */
-        mthlen = 7;
-        mth = LIBSSH2_ALLOC(session, mthlen);
-        if(mth) {
-            memcpy(mth, "ssh-dss", mthlen);
-        }
-        else {
-            ret = -1;
-        }
 
-        keylen = 4 + mthlen + 4 + rcbDecoded[1] + 4 + rcbDecoded[2]
-                            + 4 + rcbDecoded[3] + 4 + rcbDecoded[4];
-        key = LIBSSH2_ALLOC(session, keylen);
-        if(key) {
-            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
+    memcpy(
+        *signature + (*signature_length / 2) - r_trimmed_len,
+        r_trimmed,
+        r_trimmed_len);
+    memcpy(
+        *signature + (*signature_length) - s_trimmed_len,
+        s_trimmed,
+        s_trimmed_len);
 
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[1],
-                                                    rcbDecoded[1]);
+    return LIBSSH2_ERROR_NONE;
+}
 
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[2],
-                                                    rcbDecoded[2]);
+/*
+ * Create a CNG public key from an ECC point.
+ */
+static int
+_libssh2_wincng_publickey_from_point(IN _libssh2_wincng_ecc_keytype keytype,
+                                     IN _libssh2_ecdsa_point *point,
+                                     OUT BCRYPT_KEY_HANDLE *key)
+{
 
-            offset = _libssh2_wincng_pub_priv_write(key, offset,
-                                                    rpbDecoded[3],
-                                                    rcbDecoded[3]);
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
 
-            _libssh2_wincng_pub_priv_write(key, offset,
-                                           rpbDecoded[4],
-                                           rcbDecoded[4]);
-        }
-        else {
-            ret = -1;
-        }
+    PBCRYPT_ECCKEY_BLOB ecc_blob;
+    size_t ecc_blob_len;
 
+    /* Validate parameters */
+    if(!key) {
+        return LIBSSH2_ERROR_INVAL;
     }
-    else {
-        ret = -1;
+
+    if(point->x_len != point->y_len) {
+        return LIBSSH2_ERROR_INVAL;
     }
 
+    *key = NULL;
 
-    for(index = 0; index < length; index++) {
-        _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
+    /* Initialize a blob to import */
+    ecc_blob_len = sizeof(BCRYPT_ECCKEY_BLOB) + point->x_len + point->y_len;
+    ecc_blob = malloc(ecc_blob_len);
+    if(!ecc_blob) {
+        return LIBSSH2_ERROR_ALLOC;
+    }
+
+    ecc_blob->cbKey = point->x_len;
+    ecc_blob->dwMagic =
+        _wincng_ecdsa_algorithms[point->curve].public_import_magic[keytype];
+
+    /** Copy x, y */
+    memcpy(
+        (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB),
+        point->x,
+        point->x_len);
+    memcpy(
+        (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB) + point->x_len,
+        point->y,
+        point->y_len);
+
+    status = BCryptImportKeyPair(
+        keytype == WINCNG_ECC_KEYTYPE_ECDSA
+            ? _libssh2_wincng.hAlgECDSA[point->curve]
+            : _libssh2_wincng.hAlgECDH[point->curve],
+        NULL,
+        BCRYPT_ECCPUBLIC_BLOB,
+        key,
+        (PUCHAR)ecc_blob,
+        (ULONG)ecc_blob_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    result = LIBSSH2_ERROR_NONE;
+
+cleanup:
+    free(ecc_blob);
+    return result;
+}
+
+/*
+ * Create a CNG private key from an ECC point.
+ */
+static int
+_libssh2_wincng_privatekey_from_point(IN _libssh2_wincng_ecc_keytype keytype,
+                                      IN _libssh2_ecdsa_point *q,
+                                      IN unsigned char *d,
+                                      IN size_t d_len,
+                                      OUT BCRYPT_KEY_HANDLE *key)
+{
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
+
+    PBCRYPT_ECCKEY_BLOB ecc_blob;
+    size_t ecc_blob_len;
+
+    /* Validate parameters */
+    if(!key) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    if(q->x_len != q->y_len) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *key = NULL;
+
+    /* Initialize a blob to import */
+    ecc_blob_len =
+        sizeof(BCRYPT_ECCPRIVATE_BLOB) + q->x_len + q->y_len + d_len;
+    ecc_blob = malloc(ecc_blob_len);
+    if(!ecc_blob) {
+        return LIBSSH2_ERROR_ALLOC;
+    }
+
+    ecc_blob->cbKey = q->x_len;
+    ecc_blob->dwMagic =
+        _wincng_ecdsa_algorithms[q->curve].private_import_magic[keytype];
+
+    /* Copy x, y, d */
+    memcpy(
+        (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB),
+        q->x,
+        q->x_len);
+    memcpy(
+        (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB) + q->x_len,
+        q->y,
+        q->y_len);
+    memcpy(
+        (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB) + q->x_len + q->y_len,
+        d,
+        d_len);
+
+    status = BCryptImportKeyPair(
+        keytype == WINCNG_ECC_KEYTYPE_ECDSA
+            ? _libssh2_wincng.hAlgECDSA[q->curve]
+            : _libssh2_wincng.hAlgECDH[q->curve],
+        NULL,
+        BCRYPT_ECCPRIVATE_BLOB,
+        key,
+        (PUCHAR)ecc_blob,
+        (ULONG)ecc_blob_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    result = LIBSSH2_ERROR_NONE;
+
+cleanup:
+    free(ecc_blob);
+    return result;
+}
+
+/*
+ * Get the uncompressed point encoding for a CNG key.
+ */
+static int
+_libssh2_wincng_uncompressed_point_from_publickey(
+    IN LIBSSH2_SESSION *session,
+    IN libssh2_curve_type curve,
+    IN BCRYPT_KEY_HANDLE key,
+    OUT PUCHAR *encoded_point,
+    OUT size_t *encoded_point_len)
+{
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
+
+    PBCRYPT_ECCKEY_BLOB ecc_blob = NULL;
+    ULONG ecc_blob_len;
+    PUCHAR point_x;
+    PUCHAR point_y;
+
+    /* Validate parameters */
+    if(curve >= ARRAY_SIZE(_wincng_ecdsa_algorithms)) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    if(!encoded_point || !encoded_point_len) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *encoded_point = NULL;
+    *encoded_point_len = 0;
+
+    /*
+     * Export point as BCRYPT_ECCKEY_BLOB, a dynamically-sized structure.
+     */
+    status = BCryptExportKey(key,
+        NULL,
+        BCRYPT_ECCPUBLIC_BLOB,
+        NULL,
+        0,
+        &ecc_blob_len,
+        0);
+    if(BCRYPT_SUCCESS(status) && ecc_blob_len > 0) {
+        ecc_blob = LIBSSH2_ALLOC(session, ecc_blob_len);
+        if(!ecc_blob) {
+            result = LIBSSH2_ERROR_ALLOC;
+            goto cleanup;
+        }
+
+        status = BCryptExportKey(key,
+            NULL,
+            BCRYPT_ECCPUBLIC_BLOB,
+            (PUCHAR)ecc_blob,
+            ecc_blob_len,
+            &ecc_blob_len,
+            0);
+    }
+
+    if(!BCRYPT_SUCCESS(status)) {
+        result = _libssh2_error(session,
+            LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+            "Decoding the ECC public key failed");
+        goto cleanup;
+    }
+
+    point_x = (PUCHAR)ecc_blob + sizeof(BCRYPT_ECCKEY_BLOB);
+    point_y = (PUCHAR)ecc_blob + ecc_blob->cbKey + sizeof(BCRYPT_ECCKEY_BLOB);
+
+    /*
+     * Create uncompressed point, which needs to look like the following:
+     *
+     * struct uncompressed_point {
+     *     UCHAR tag = 4; // uncompressed
+     *     PUCHAR[size] x;
+     *     PUCHAR[size] y;
+     * }
+     */
+
+    *encoded_point_len = (size_t)ecc_blob->cbKey * 2 + 1;
+    *encoded_point = LIBSSH2_ALLOC(session, *encoded_point_len);
+    if(!*encoded_point) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    **encoded_point = 4;  /* Uncompressed tag */
+    memcpy((*encoded_point) + 1, point_x, ecc_blob->cbKey);
+    memcpy((*encoded_point) + 1 + ecc_blob->cbKey, point_y, ecc_blob->cbKey);
+
+cleanup:
+    if(ecc_blob) {
+        LIBSSH2_FREE(session, ecc_blob);
+    }
+
+    return result;
+}
+
+static void
+_libssh_wincng_reverse_bytes(IN PUCHAR buffer,
+                             IN size_t buffer_len)
+{
+    PUCHAR start = buffer;
+    PUCHAR end = buffer + buffer_len - 1;
+    while(start < end) {
+        unsigned char tmp = *end;
+        *end = *start;
+        *start = tmp;
+        start++;
+        end--;
+    }
+}
+
+/*******************************************************************/
+/*
+ * Windows CNG backend: ECDSA functions
+ */
+
+void
+_libssh2_wincng_ecdsa_free(IN _libssh2_wincng_ecdsa_key *key)
+{
+    if(!key) {
+        return;
+    }
+
+    (void)BCryptDestroyKey(key->handle);
+    free(key);
+}
+
+
+/*
+ * _libssh2_ecdsa_create_key
+ *
+ * Creates a local private ECDH key based on input curve
+ * and returns the public key in uncompressed point encoding.
+ */
+
+int
+_libssh2_wincng_ecdh_create_key(IN LIBSSH2_SESSION *session,
+                                OUT _libssh2_wincng_ecdsa_key **privatekey,
+                                OUT unsigned char **encoded_publickey,
+                                OUT size_t *encoded_publickey_len,
+                                IN libssh2_curve_type curve)
+{
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
+
+    BCRYPT_KEY_HANDLE key_handle = NULL;
+
+    /* Validate parameters */
+    if(curve >= ARRAY_SIZE(_wincng_ecdsa_algorithms)) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    if(!_libssh2_wincng.hAlgECDH[curve]) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    if(!privatekey || !encoded_publickey || !encoded_publickey_len) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *privatekey = NULL;
+    *encoded_publickey = NULL;
+    *encoded_publickey_len = 0;
+
+    /* Create an ECDH key pair using the requested curve */
+    status = BCryptGenerateKeyPair(
+        _libssh2_wincng.hAlgECDH[curve],
+        &key_handle,
+        _wincng_ecdsa_algorithms[curve].key_length,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = _libssh2_error(
+            session,
+            LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+            "Creating ECC key pair failed");
+        goto cleanup;
+    }
+
+    status = BCryptFinalizeKeyPair(key_handle, 0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = _libssh2_error(
+            session,
+            LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+            "Creating ECDH key pair failed");
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_uncompressed_point_from_publickey(
+        session,
+        curve,
+        key_handle,
+        encoded_publickey,
+        encoded_publickey_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        result = _libssh2_error(
+            session,
+            LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+            "Exporting ECDH key pair failed");
+    }
+
+    *privatekey = malloc(sizeof(_libssh2_wincng_ecdsa_key));
+    if(!*privatekey) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    (*privatekey)->curve = curve;
+    (*privatekey)->handle = key_handle;
+
+cleanup:
+    if(result != LIBSSH2_ERROR_NONE && key_handle) {
+        (void)BCryptDestroyKey(key_handle);
+    }
+
+    if(result != LIBSSH2_ERROR_NONE && *privatekey) {
+        free(*privatekey);
+    }
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdsa_curve_name_with_octal_new
+ *
+ * Creates an ECDSA public key from an uncompressed point.
+ */
+
+int
+_libssh2_wincng_ecdsa_curve_name_with_octal_new(
+    OUT _libssh2_wincng_ecdsa_key **key,
+    IN const unsigned char *publickey_encoded,
+    IN size_t publickey_encoded_len,
+    IN libssh2_curve_type curve)
+{
+    int result = LIBSSH2_ERROR_NONE;
+
+    BCRYPT_KEY_HANDLE publickey_handle;
+    _libssh2_ecdsa_point publickey;
+
+    /* Validate parameters */
+    if(curve >= ARRAY_SIZE(_wincng_ecdsa_algorithms)) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    if(!key) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *key = NULL;
+
+    result = _libssh2_wincng_ecdsa_decode_uncompressed_point(
+        publickey_encoded,
+        publickey_encoded_len,
+        &publickey);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_publickey_from_point(
+        WINCNG_ECC_KEYTYPE_ECDSA,
+        &publickey,
+        &publickey_handle);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    *key = malloc(sizeof(_libssh2_wincng_ecdsa_key));
+    if(!*key) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    (*key)->handle = publickey_handle;
+    (*key)->curve = curve;
+
+cleanup:
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdh_gen_k
+ *
+ * Computes the shared secret K given a local private key,
+ * remote public key and length
+ */
+
+int
+_libssh2_wincng_ecdh_gen_k(OUT _libssh2_bn **secret,
+                           IN _libssh2_wincng_ecdsa_key *privatekey,
+                           IN const unsigned char *server_publickey_encoded,
+                           IN size_t server_publickey_encoded_len)
+{
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
+
+    BCRYPT_KEY_HANDLE publickey_handle;
+    BCRYPT_SECRET_HANDLE agreed_secret_handle = NULL;
+    ULONG secret_len;
+    _libssh2_ecdsa_point server_publickey;
+
+    /* Validate parameters */
+    if(!secret) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *secret = NULL;
+
+    /* Decode the public key */
+    result = _libssh2_wincng_ecdsa_decode_uncompressed_point(
+        server_publickey_encoded,
+        server_publickey_encoded_len,
+        &server_publickey);
+    if(result != LIBSSH2_ERROR_NONE) {
+        return result;
+    }
+
+    result = _libssh2_wincng_publickey_from_point(
+        WINCNG_ECC_KEYTYPE_ECDH,
+        &server_publickey,
+        &publickey_handle);
+    if(result != LIBSSH2_ERROR_NONE) {
+        return result;
+    }
+
+    /* Establish the shared secret between ourselves and the peer */
+    status = BCryptSecretAgreement(
+        privatekey->handle,
+        publickey_handle,
+        &agreed_secret_handle,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    /* Compute the size of the buffer that is needed to hold the derived
+     * shared secret.
+     *
+     * NB. The use of BCRYPT_KDF_RAW_SECRET requires Windows 10 or newer.
+     * On older versions, the BCryptDeriveKey returns STATUS_NOT_SUPPORTED.
+     */
+    status = BCryptDeriveKey(
+        agreed_secret_handle,
+        BCRYPT_KDF_RAW_SECRET,
+        NULL,
+        NULL,
+        0,
+        &secret_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    /* Allocate a secret bignum to be ready to receive the derived secret */
+    *secret = _libssh2_wincng_bignum_init();
+    if(!*secret) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    if(_libssh2_wincng_bignum_resize(*secret, secret_len)) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    /* And populate the secret bignum */
+    status = BCryptDeriveKey(
+        agreed_secret_handle,
+        BCRYPT_KDF_RAW_SECRET,
+        NULL,
+        (*secret)->bignum,
+        secret_len,
+        &secret_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    /* BCRYPT_KDF_RAW_SECRET returns the little-endian representation of the
+     * raw secret, so we need to swap it to big endian order.
+     */
+
+    _libssh_wincng_reverse_bytes((*secret)->bignum, secret_len);
+
+    result = LIBSSH2_ERROR_NONE;
+
+cleanup:
+    if(result != LIBSSH2_ERROR_NONE && agreed_secret_handle) {
+        _libssh2_wincng_bignum_free(*secret);
+    }
+
+    if(result != LIBSSH2_ERROR_NONE && agreed_secret_handle) {
+        BCryptDestroySecret(agreed_secret_handle);
+    }
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdsa_curve_type_from_name
+ *
+ */
+int
+_libssh2_wincng_ecdsa_curve_type_from_name(IN const char *name,
+                                           OUT libssh2_curve_type *out_curve)
+{
+    unsigned int curve;
+
+    /* Validate parameters */
+    if(!out_curve) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    for(curve = 0; curve < ARRAY_SIZE(_wincng_ecdsa_algorithms); curve++) {
+        if(strcmp(name, _wincng_ecdsa_algorithms[curve].name) == 0) {
+            *out_curve = curve;
+            return LIBSSH2_ERROR_NONE;
+        }
+    }
+
+    return LIBSSH2_ERROR_INVAL;
+}
+
+/*
+ * _libssh2_ecdsa_verify
+ *
+ * Verifies the ECDSA signature of a hashed message
+ *
+ */
+
+int
+_libssh2_wincng_ecdsa_verify(IN _libssh2_wincng_ecdsa_key *key,
+                             IN const unsigned char *r,
+                             IN size_t r_len,
+                             IN const unsigned char *s,
+                             IN size_t s_len,
+                             IN const unsigned char *m,
+                             IN size_t m_len)
+{
+    int result = LIBSSH2_ERROR_NONE;
+    NTSTATUS status;
+
+    PUCHAR signature_p1363 = NULL;
+    size_t signature_p1363_len;
+    ULONG hash_len;
+    PUCHAR hash = NULL;
+    BCRYPT_ALG_HANDLE hash_alg;
+
+    /* CNG expects signatures in IEEE P-1363 format. */
+    result = _libssh2_wincng_p1363signature_from_point(
+        r,
+        r_len,
+        s,
+        s_len,
+        _libssh2_wincng_ecdsa_get_curve_type(key),
+        &signature_p1363,
+        &signature_p1363_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Create hash over m */
+    switch(_libssh2_wincng_ecdsa_get_curve_type(key)) {
+    case LIBSSH2_EC_CURVE_NISTP256:
+        hash_len = 256/8;
+        hash_alg = _libssh2_wincng.hAlgHashSHA256;
+        break;
+
+    case LIBSSH2_EC_CURVE_NISTP384:
+        hash_len = 384/8;
+        hash_alg = _libssh2_wincng.hAlgHashSHA384;
+        break;
+
+    case LIBSSH2_EC_CURVE_NISTP521:
+        hash_len = 512/8;
+        hash_alg = _libssh2_wincng.hAlgHashSHA512;
+        break;
+
+    default:
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    hash = malloc(hash_len);
+    result = _libssh2_wincng_hash(
+        m,
+        (ULONG)m_len,
+        hash_alg,
+        hash,
+        hash_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Verify signature over hash */
+    status = BCryptVerifySignature(
+        key->handle,
+        NULL,
+        hash,
+        hash_len,
+        signature_p1363,
+        (ULONG)signature_p1363_len,
+        0);
+
+    if(status == STATUS_INVALID_SIGNATURE) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+    else if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    result = LIBSSH2_ERROR_NONE;
+
+cleanup:
+    if(hash) {
+        free(hash);
+    }
+
+    if(signature_p1363) {
+        free(signature_p1363);
+    }
+
+    return result;
+}
+
+/*
+ *_libssh2_ecdsa_new_private
+ *
+ * Creates a new private key given a file path and password
+ *
+ */
+
+int
+_libssh2_wincng_ecdsa_new_private(OUT _libssh2_wincng_ecdsa_key **key,
+                                  IN LIBSSH2_SESSION *session,
+                                  IN const char *filename,
+                                  IN const unsigned char *passphrase)
+{
+    int result;
+
+    FILE *file_handle = NULL;
+    unsigned char *data = NULL;
+    size_t datalen = 0;
+
+    /* Validate parameters */
+    if(!key || !session || !filename) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *key = NULL;
+
+    if(passphrase && strlen((const char *)passphrase) > 0) {
+        return _libssh2_error(
+            session,
+            LIBSSH2_ERROR_INVAL,
+            "Passphrase-protected ECDSA private key files are unsupported");
+    }
+
+    file_handle = fopen(filename, FOPEN_READTEXT);
+    if(!file_handle) {
+        result = _libssh2_error(
+            session,
+            LIBSSH2_ERROR_INVAL,
+            "Opening the private key file failed");
+        goto cleanup;
+    }
+
+    result = _libssh2_pem_parse(session,
+        PEM_ECDSA_HEADER,
+        PEM_ECDSA_FOOTER,
+        passphrase,
+        file_handle,
+        &data,
+        &datalen);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_ecdsa_new_private_frommemory(
+        key,
+        session,
+        (const char *)data,
+        datalen,
+        passphrase);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+cleanup:
+    if(file_handle) {
+        fclose(file_handle);
+    }
+
+    if(data) {
+        LIBSSH2_FREE(session, data);
+    }
+
+    return result;
+}
+
+int
+_libssh2_wincng_parse_ecdsa_privatekey(OUT _libssh2_wincng_ecdsa_key **key,
+                                       IN unsigned char *privatekey,
+                                       IN size_t privatekey_len)
+{
+    char *keytype = NULL;
+    size_t keytype_len;
+
+    unsigned char *ignore;
+    size_t ignore_len;
+
+    unsigned char *publickey;
+    size_t publickey_len;
+
+    libssh2_curve_type curve_type;
+    int result;
+    uint32_t check1, check2;
+    struct string_buf data_buffer;
+
+    _libssh2_ecdsa_point q;
+    unsigned char *d;
+    size_t d_len;
+
+    BCRYPT_KEY_HANDLE key_handle = NULL;
+
+    *key = NULL;
+
+    data_buffer.data = privatekey;
+    data_buffer.dataptr = privatekey;
+    data_buffer.len = privatekey_len;
+
+    /* Read the 2 checkints and check that they match */
+    result = _libssh2_get_u32(&data_buffer, &check1);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_get_u32(&data_buffer, &check2);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    if(check1 != check2) {
+        result = LIBSSH2_ERROR_FILE;
+        goto cleanup;
+    }
+
+    /* What follows is a key as defined in */
+    /* draft-miller-ssh-agent, section-3.2.2 */
+
+    /* Read the key type */
+    result = _libssh2_get_string(&data_buffer,
+                                 (unsigned char **)&keytype,
+                                 &keytype_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_ecdsa_curve_type_from_name(keytype, &curve_type);
+    if(result < 0) {
+        goto cleanup;
+    }
+
+    /* Read the curve */
+    result = _libssh2_get_string(&data_buffer, &ignore, &ignore_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Read Q */
+    result = _libssh2_get_string(&data_buffer, &publickey, &publickey_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_ecdsa_decode_uncompressed_point(
+        publickey,
+        publickey_len,
+        &q);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Read d */
+    result = _libssh2_get_bignum_bytes(&data_buffer, &d, &d_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Ignore the rest (comment, etc) */
+
+    /* Use Q and d to create a key handle */
+    result = _libssh2_wincng_privatekey_from_point(
+        WINCNG_ECC_KEYTYPE_ECDSA,
+        &q,
+        d,
+        d_len,
+        &key_handle);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    *key = malloc(sizeof(_libssh2_wincng_ecdsa_key));
+    if(!*key) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    (*key)->curve = q.curve;
+    (*key)->handle = key_handle;
+
+    result = LIBSSH2_ERROR_NONE;
+
+cleanup:
+    if(result != LIBSSH2_ERROR_NONE && key_handle) {
+        (void)BCryptDestroyKey(key_handle);
+    }
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdsa_new_private
+ *
+ * Creates a new private key given a file data and password.
+ * ECDSA private key files use the decoding defined in PROTOCOL.key
+ * in the OpenSSL source tree.
+ */
+int
+_libssh2_wincng_ecdsa_new_private_frommemory(
+    OUT _libssh2_wincng_ecdsa_key **key,
+    IN LIBSSH2_SESSION *session,
+    IN const char *data,
+    IN size_t data_len,
+    IN const unsigned char *passphrase)
+{
+    int result;
+
+    struct string_buf data_buffer;
+    uint32_t index;
+    uint32_t key_count;
+    unsigned char *privatekey;
+    size_t privatekey_len;
+
+    /* Validate parameters */
+    if(!key || !session || !data) {
+        return LIBSSH2_ERROR_INVAL;
+    }
+
+    *key = NULL;
+
+    if(passphrase && strlen((const char *)passphrase) > 0) {
+        return _libssh2_error(
+            session,
+            LIBSSH2_ERROR_INVAL,
+            "Passphrase-protected ECDSA private key files are unsupported");
+    }
+
+    /* Read OPENSSL_PRIVATEKEY_AUTH_MAGIC */
+    if(strncmp(data, OPENSSL_PRIVATEKEY_AUTH_MAGIC, data_len) != 0) {
+        result = -1;
+        goto cleanup;
+    }
+
+    data_buffer.len = data_len;
+    data_buffer.data = (unsigned char *)data;
+    data_buffer.dataptr =
+        (unsigned char *)data + strlen(OPENSSL_PRIVATEKEY_AUTH_MAGIC) + 1;
+
+    /* Read ciphername, should be 'none' as we don't support passphrases */
+    result = _libssh2_match_string(&data_buffer, "none");
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Read kdfname, should be 'none' as we don't support passphrases */
+    result = _libssh2_match_string(&data_buffer, "none");
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Read kdfoptions, should be empty */
+    result = _libssh2_match_string(&data_buffer, "");
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    /* Read number of keys N */
+    result = _libssh2_get_u32(&data_buffer, &key_count);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    if(key_count == 0) {
+        result = LIBSSH2_ERROR_FILE;
+        goto cleanup;
+    }
+
+    /* Skip all public keys */
+    for(index = 0; index < key_count; index++) {
+        unsigned char *publickey;
+        size_t publickey_len;
+
+        result = _libssh2_get_string(&data_buffer, &publickey, &publickey_len);
+        if(result != LIBSSH2_ERROR_NONE) {
+            goto cleanup;
+        }
+    }
+
+    /* Read first private key */
+    result = _libssh2_get_string(&data_buffer, &privatekey, &privatekey_len);
+    if(result != LIBSSH2_ERROR_NONE) {
+        goto cleanup;
+    }
+
+    result = _libssh2_wincng_parse_ecdsa_privatekey(
+        key,
+        privatekey,
+        privatekey_len);
+
+cleanup:
+    if(result != LIBSSH2_ERROR_NONE) {
+        return _libssh2_error(
+            session,
+            result,
+            "The key is malformed");
+    }
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdsa_sign
+ *
+ * Computes the ECDSA signature of a previously-hashed message
+ *
+ */
+
+int
+_libssh2_wincng_ecdsa_sign(IN LIBSSH2_SESSION *session,
+                           IN _libssh2_wincng_ecdsa_key *key,
+                           IN const unsigned char *hash,
+                           IN size_t hash_len,
+                           OUT unsigned char **signature,
+                           OUT size_t *signature_len)
+{
+    NTSTATUS status;
+    int result = LIBSSH2_ERROR_NONE;
+
+    unsigned char *hash_buffer;
+
+    unsigned char *cng_signature = NULL;
+    ULONG cng_signature_len;
+
+    ULONG signature_maxlen;
+    unsigned char *signature_ptr;
+
+    *signature = NULL;
+    *signature_len = 0;
+
+    /* CNG expects a mutable buffer */
+    hash_buffer = malloc(hash_len);
+    if(!hash_buffer) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    memcpy(hash_buffer, hash, hash_len);
+
+    status = BCryptSignHash(
+        key->handle,
+        NULL,
+        hash_buffer,
+        (ULONG)hash_len,
+        NULL,
+        0,
+        &cng_signature_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    cng_signature = malloc(cng_signature_len);
+    if(!cng_signature) {
+        result = LIBSSH2_ERROR_ALLOC;
+        goto cleanup;
+    }
+
+    status = BCryptSignHash(
+        key->handle,
+        NULL,
+        hash_buffer,
+        (ULONG)hash_len,
+        cng_signature,
+        cng_signature_len,
+        &cng_signature_len,
+        0);
+    if(!BCRYPT_SUCCESS(status)) {
+        result = LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+        goto cleanup;
+    }
+
+    /*
+        cng_signature is in IEEE P-1163 format: r || s.
+        Convert to ecdsa_signature_blob: mpint(r) || mpint(s)
+    */
+
+    signature_maxlen =
+        cng_signature_len / 2 + 5 + /* mpint(r) */
+        cng_signature_len / 2 + 5;  /* mpint(s) */
+
+    *signature = LIBSSH2_ALLOC(session, signature_maxlen);
+    signature_ptr = *signature;
+
+    _libssh2_store_bignum2_bytes(
+        &signature_ptr,
+        cng_signature,
+        cng_signature_len / 2);
+
+    _libssh2_store_bignum2_bytes(
+        &signature_ptr,
+        cng_signature + (cng_signature_len / 2),
+        cng_signature_len / 2);
+
+    *signature_len = signature_ptr - *signature;
+
+cleanup:
+    if(cng_signature) {
+        free(cng_signature);
+    }
+
+    if(hash_buffer) {
+        free(hash_buffer);
+    }
+
+    return result;
+}
+
+/*
+ * _libssh2_ecdsa_get_curve_type
+ *
+ * returns key curve type that maps to libssh2_curve_type
+ *
+ */
+
+libssh2_curve_type
+_libssh2_wincng_ecdsa_get_curve_type(IN _libssh2_wincng_ecdsa_key *key)
+{
+    return key->curve;
+}
+
+#endif
+
+/*******************************************************************/
+/*
+ * Windows CNG backend: Key functions
+ */
+
+#ifdef HAVE_LIBCRYPT32
+static DWORD
+_libssh2_wincng_pub_priv_write(unsigned char *key,
+                               DWORD offset,
+                               const unsigned char *bignum,
+                               const DWORD length)
+{
+    _libssh2_htonu32(key + offset, length);
+    offset += 4;
+
+    memcpy(key + offset, bignum, length);
+    offset += length;
+
+    return offset;
+}
+
+static int
+_libssh2_wincng_pub_priv_keyfile_parse(LIBSSH2_SESSION *session,
+                                       unsigned char **method,
+                                       size_t *method_len,
+                                       unsigned char **pubkeydata,
+                                       size_t *pubkeydata_len,
+                                       unsigned char *pbEncoded,
+                                       size_t cbEncoded)
+{
+    unsigned char **rpbDecoded = NULL;
+    DWORD *rcbDecoded = NULL;
+    unsigned char *key = NULL, *mth = NULL;
+    DWORD keylen = 0, mthlen = 0;
+    DWORD index, offset, length = 0;
+    int ret;
+
+    ret = _libssh2_wincng_asn_decode_bns(pbEncoded, (DWORD)cbEncoded,
+                                         &rpbDecoded, &rcbDecoded, &length);
+
+    _libssh2_wincng_safe_free(pbEncoded, cbEncoded);
+
+    if(ret) {
+        return -1;
+    }
+
+
+    if(length == 9) { /* private RSA key */
+        mthlen = 7;
+        mth = LIBSSH2_ALLOC(session, mthlen);
+        if(mth) {
+            memcpy(mth, "ssh-rsa", mthlen);
+        }
+        else {
+            ret = -1;
+        }
+
+
+        keylen = 4 + mthlen + 4 + rcbDecoded[2] + 4 + rcbDecoded[1];
+        key = LIBSSH2_ALLOC(session, keylen);
+        if(key) {
+            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
+
+            offset = _libssh2_wincng_pub_priv_write(key, offset,
+                                                    rpbDecoded[2],
+                                                    rcbDecoded[2]);
+
+            _libssh2_wincng_pub_priv_write(key, offset,
+                                           rpbDecoded[1],
+                                           rcbDecoded[1]);
+        }
+        else {
+            ret = -1;
+        }
+
+    }
+    else if(length == 6) { /* private DSA key */
+        mthlen = 7;
+        mth = LIBSSH2_ALLOC(session, mthlen);
+        if(mth) {
+            memcpy(mth, "ssh-dss", mthlen);
+        }
+        else {
+            ret = -1;
+        }
+
+        keylen = 4 + mthlen + 4 + rcbDecoded[1] + 4 + rcbDecoded[2]
+                            + 4 + rcbDecoded[3] + 4 + rcbDecoded[4];
+        key = LIBSSH2_ALLOC(session, keylen);
+        if(key) {
+            offset = _libssh2_wincng_pub_priv_write(key, 0, mth, mthlen);
+
+            offset = _libssh2_wincng_pub_priv_write(key, offset,
+                                                    rpbDecoded[1],
+                                                    rcbDecoded[1]);
+
+            offset = _libssh2_wincng_pub_priv_write(key, offset,
+                                                    rpbDecoded[2],
+                                                    rcbDecoded[2]);
+
+            offset = _libssh2_wincng_pub_priv_write(key, offset,
+                                                    rpbDecoded[3],
+                                                    rcbDecoded[3]);
+
+            _libssh2_wincng_pub_priv_write(key, offset,
+                                           rpbDecoded[4],
+                                           rcbDecoded[4]);
+        }
+        else {
+            ret = -1;
+        }
+
+    }
+    else {
+        ret = -1;
+    }
+
+
+    for(index = 0; index < length; index++) {
+        _libssh2_wincng_safe_free(rpbDecoded[index], rcbDecoded[index]);
         rpbDecoded[index] = NULL;
         rcbDecoded[index] = 0;
     }
@@ -1725,10 +3232,11 @@ _libssh2_wincng_pub_priv_keyfile(LIBSSH2_SESSION *session,
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
-    ret = _libssh2_wincng_load_private(session, privatekey, passphrase,
+    ret = _libssh2_wincng_load_private(session, privatekey,
+                                       (const unsigned char *)passphrase,
                                        &pbEncoded, &cbEncoded, 1, 1);
     if(ret) {
         return -1;
@@ -1763,11 +3271,13 @@ _libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
 {
 #ifdef HAVE_LIBCRYPT32
     unsigned char *pbEncoded;
-    unsigned long cbEncoded;
+    size_t cbEncoded;
     int ret;
 
     ret = _libssh2_wincng_load_private_memory(session, privatekeydata,
-                                              privatekeydata_len, passphrase,
+                                              privatekeydata_len,
+                                              (const unsigned char *)
+                                                  passphrase,
                                               &pbEncoded, &cbEncoded, 1, 1);
     if(ret) {
         return -1;
@@ -1786,11 +3296,44 @@ _libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
     (void)passphrase;
 
     return _libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
-               "Unable to extract public key from private key in memory: "
-               "Method unsupported in Windows CNG backend");
+                    "Unable to extract public key from private key in memory: "
+                    "Method unsupported in Windows CNG backend");
 #endif /* HAVE_LIBCRYPT32 */
 }
 
+int
+_libssh2_wincng_sk_pub_keyfilememory(LIBSSH2_SESSION *session,
+                                     unsigned char **method,
+                                     size_t *method_len,
+                                     unsigned char **pubkeydata,
+                                     size_t *pubkeydata_len,
+                                     int *algorithm,
+                                     unsigned char *flags,
+                                     const char **application,
+                                     const unsigned char **key_handle,
+                                     size_t *handle_len,
+                                     const char *privatekeydata,
+                                     size_t privatekeydata_len,
+                                     const char *passphrase)
+{
+    (void)method;
+    (void)method_len;
+    (void)pubkeydata;
+    (void)pubkeydata_len;
+    (void)algorithm;
+    (void)flags;
+    (void)application;
+    (void)key_handle;
+    (void)handle_len;
+    (void)privatekeydata;
+    (void)privatekeydata_len;
+    (void)passphrase;
+
+    return _libssh2_error(session, LIBSSH2_ERROR_FILE,
+                    "Unable to extract public SK key from private key file: "
+                    "Method unimplemented in Windows CNG backend");
+}
+
 /*******************************************************************/
 /*
  * Windows CNG backend: Cipher functions
@@ -1805,9 +3348,8 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
 {
     BCRYPT_KEY_HANDLE hKey;
     BCRYPT_KEY_DATA_BLOB_HEADER *header;
-    unsigned char *pbKeyObject, *pbIV, *key, *pbCtr, *pbIVCopy;
-    unsigned long dwKeyObject, dwIV, dwCtrLength, dwBlockLength,
-                  cbData, keylen;
+    unsigned char *pbKeyObject, *pbIV, *pbCtr, *pbIVCopy;
+    ULONG dwKeyObject, dwIV, dwCtrLength, dwBlockLength, cbData, keylen;
     int ret;
 
     (void)encrypt;
@@ -1834,26 +3376,27 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
     }
 
 
-    keylen = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + type.dwKeyLength;
-    key = malloc(keylen);
-    if(!key) {
+    keylen = (ULONG)sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) +
+             type.dwKeyLength;
+    header = (BCRYPT_KEY_DATA_BLOB_HEADER *)malloc(keylen);
+    if(!header) {
         free(pbKeyObject);
         return -1;
     }
 
 
-    header = (BCRYPT_KEY_DATA_BLOB_HEADER *)key;
     header->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
     header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
     header->cbKeyData = type.dwKeyLength;
 
-    memcpy(key + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER),
+    memcpy((unsigned char *)header + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER),
            secret, type.dwKeyLength);
 
     ret = BCryptImportKey(*type.phAlg, NULL, BCRYPT_KEY_DATA_BLOB, &hKey,
-                          pbKeyObject, dwKeyObject, key, keylen, 0);
+                          pbKeyObject, dwKeyObject,
+                          (PUCHAR)header, keylen, 0);
 
-    _libssh2_wincng_safe_free(key, keylen);
+    _libssh2_wincng_safe_free(header, keylen);
 
     if(!BCRYPT_SUCCESS(ret)) {
         _libssh2_wincng_safe_free(pbKeyObject, dwKeyObject);
@@ -1895,20 +3438,22 @@ _libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
 
     return 0;
 }
+
 int
 _libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
                              _libssh2_cipher_type(type),
                              int encrypt,
                              unsigned char *block,
-                             size_t blocklen)
+                             size_t blocklen, int firstlast)
 {
     unsigned char *pbOutput, *pbInput;
-    unsigned long cbOutput, cbInput;
-    int ret;
+    ULONG cbOutput, cbInput;
+    NTSTATUS ret;
 
     (void)type;
+    (void)firstlast;
 
-    cbInput = (unsigned long)blocklen;
+    cbInput = (ULONG)blocklen;
 
     if(type.ctrMode) {
         pbInput = ctx->pbCtr;
@@ -1951,7 +3496,7 @@ _libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
             _libssh2_wincng_safe_free(pbOutput, cbOutput);
         }
         else
-            ret = STATUS_NO_MEMORY;
+            ret = (NTSTATUS)STATUS_NO_MEMORY;
     }
 
     return BCRYPT_SUCCESS(ret) ? 0 : -1;
@@ -1997,7 +3542,7 @@ _libssh2_wincng_bignum_init(void)
 }
 
 static int
-_libssh2_wincng_bignum_resize(_libssh2_bn *bn, unsigned long length)
+_libssh2_wincng_bignum_resize(_libssh2_bn *bn, ULONG length)
 {
     unsigned char *bignum;
 
@@ -2007,11 +3552,9 @@ _libssh2_wincng_bignum_resize(_libssh2_bn *bn, unsigned long length)
     if(length == bn->length)
         return 0;
 
-#ifdef LIBSSH2_CLEAR_MEMORY
     if(bn->bignum && bn->length > 0 && length < bn->length) {
-        SecureZeroMemory(bn->bignum + length, bn->length - length);
+        _libssh2_explicit_zero(bn->bignum + length, bn->length - length);
     }
-#endif
 
     bignum = realloc(bn->bignum, length);
     if(!bignum)
@@ -2027,13 +3570,12 @@ static int
 _libssh2_wincng_bignum_rand(_libssh2_bn *rnd, int bits, int top, int bottom)
 {
     unsigned char *bignum;
-    unsigned long length;
+    ULONG length;
 
     if(!rnd)
         return -1;
 
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
+    length = (ULONG) (ceil(((double)bits) / 8.0) * sizeof(unsigned char));
     if(_libssh2_wincng_bignum_resize(rnd, length))
         return -1;
 
@@ -2048,13 +3590,13 @@ _libssh2_wincng_bignum_rand(_libssh2_bn *rnd, int bits, int top, int bottom)
         bits = 8;
 
     /* fill most significant byte with zero padding */
-    bignum[0] &= ((1 << bits) - 1);
+    bignum[0] &= (unsigned char)((1 << bits) - 1);
 
     /* set most significant bits in most significant byte */
     if(top == 0)
-        bignum[0] |= (1 << (bits - 1));
+        bignum[0] |= (unsigned char)(1 << (bits - 1));
     else if(top == 1)
-        bignum[0] |= (3 << (bits - 2));
+        bignum[0] |= (unsigned char)(3 << (bits - 2));
 
     /* make odd by setting first bit in least significant byte */
     if(bottom)
@@ -2071,9 +3613,9 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
 {
     BCRYPT_KEY_HANDLE hKey;
     BCRYPT_RSAKEY_BLOB *rsakey;
-    unsigned char *key, *bignum;
-    unsigned long keylen, offset, length;
-    int ret;
+    unsigned char *bignum;
+    ULONG keylen, offset, length;
+    NTSTATUS ret;
 
     if(!r || !a || !p || !m)
         return -1;
@@ -2081,13 +3623,12 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
     offset = sizeof(BCRYPT_RSAKEY_BLOB);
     keylen = offset + p->length + m->length;
 
-    key = malloc(keylen);
-    if(!key)
+    rsakey = (BCRYPT_RSAKEY_BLOB *)malloc(keylen);
+    if(!rsakey)
         return -1;
 
 
     /* https://msdn.microsoft.com/library/windows/desktop/aa375531.aspx */
-    rsakey = (BCRYPT_RSAKEY_BLOB *)key;
     rsakey->Magic = BCRYPT_RSAPUBLIC_MAGIC;
     rsakey->BitLength = m->length * 8;
     rsakey->cbPublicExp = p->length;
@@ -2095,14 +3636,15 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
     rsakey->cbPrime1 = 0;
     rsakey->cbPrime2 = 0;
 
-    memcpy(key + offset, p->bignum, p->length);
+    memcpy((unsigned char *)rsakey + offset, p->bignum, p->length);
     offset += p->length;
 
-    memcpy(key + offset, m->bignum, m->length);
+    memcpy((unsigned char *)rsakey + offset, m->bignum, m->length);
     offset = 0;
 
     ret = BCryptImportKeyPair(_libssh2_wincng.hAlgRSA, NULL,
-                              BCRYPT_RSAPUBLIC_BLOB, &hKey, key, keylen, 0);
+                              BCRYPT_RSAPUBLIC_BLOB, &hKey,
+                              (PUCHAR)rsakey, keylen, 0);
     if(BCRYPT_SUCCESS(ret)) {
         ret = BCryptEncrypt(hKey, a->bignum, a->length, NULL, NULL, 0,
                             NULL, 0, &length, BCRYPT_PAD_NONE);
@@ -2125,24 +3667,24 @@ _libssh2_wincng_bignum_mod_exp(_libssh2_bn *r,
                     }
                 }
                 else
-                    ret = STATUS_NO_MEMORY;
+                    ret = (NTSTATUS)STATUS_NO_MEMORY;
             }
             else
-                ret = STATUS_NO_MEMORY;
+                ret = (NTSTATUS)STATUS_NO_MEMORY;
         }
 
         BCryptDestroyKey(hKey);
     }
 
-    _libssh2_wincng_safe_free(key, keylen);
+    _libssh2_wincng_safe_free(rsakey, keylen);
 
     return BCRYPT_SUCCESS(ret) ? 0 : -1;
 }
 
 int
-_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word)
+_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, ULONG word)
 {
-    unsigned long offset, number, bits, length;
+    ULONG offset, number, bits, length;
 
     if(!bn)
         return -1;
@@ -2153,8 +3695,7 @@ _libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word)
         bits++;
     bits++;
 
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
+    length = (ULONG) (ceil(((double)bits) / 8.0) * sizeof(unsigned char));
     if(_libssh2_wincng_bignum_resize(bn, length))
         return -1;
 
@@ -2164,11 +3705,11 @@ _libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word)
     return 0;
 }
 
-unsigned long
+ULONG
 _libssh2_wincng_bignum_bits(const _libssh2_bn *bn)
 {
     unsigned char number;
-    unsigned long offset, length, bits;
+    ULONG offset, length, bits;
 
     if(!bn || !bn->bignum || !bn->length)
         return 0;
@@ -2187,47 +3728,52 @@ _libssh2_wincng_bignum_bits(const _libssh2_bn *bn)
     return bits;
 }
 
-void
-_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
+int
+_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, ULONG len,
                                 const unsigned char *bin)
 {
     unsigned char *bignum;
-    unsigned long offset, length, bits;
+    ULONG offset, length, bits;
 
     if(!bn || !bin || !len)
-        return;
+        return -1;
 
     if(_libssh2_wincng_bignum_resize(bn, len))
-        return;
+        return -1;
 
     memcpy(bn->bignum, bin, len);
 
     bits = _libssh2_wincng_bignum_bits(bn);
-    length = (unsigned long) (ceil(((double)bits) / 8.0) *
-                              sizeof(unsigned char));
+    length = (ULONG) (ceil(((double)bits) / 8.0) * sizeof(unsigned char));
 
     offset = bn->length - length;
     if(offset > 0) {
         memmove(bn->bignum, bn->bignum + offset, length);
 
-#ifdef LIBSSH2_CLEAR_MEMORY
-        SecureZeroMemory(bn->bignum + length, offset);
-#endif
+        _libssh2_explicit_zero(bn->bignum + length, offset);
 
         bignum = realloc(bn->bignum, length);
         if(bignum) {
             bn->bignum = bignum;
             bn->length = length;
         }
+        else {
+            return -1;
+        }
     }
+
+    return 0;
 }
 
-void
+int
 _libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin)
 {
     if(bin && bn && bn->bignum && bn->length > 0) {
         memcpy(bin, bn->bignum, bn->length);
+        return 0;
     }
+
+    return -1;
 }
 
 void
@@ -2253,9 +3799,9 @@ void
 _libssh2_dh_init(_libssh2_dh_ctx *dhctx)
 {
     /* Random from client */
-    dhctx->bn = NULL;
     dhctx->dh_handle = NULL;
     dhctx->dh_params = NULL;
+    dhctx->dh_privbn = NULL;
 }
 
 void
@@ -2271,12 +3817,18 @@ _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx)
         free(dhctx->dh_params);
         dhctx->dh_params = NULL;
     }
-    if(dhctx->bn) {
-        _libssh2_wincng_bignum_free(dhctx->bn);
-        dhctx->bn = NULL;
+    if(dhctx->dh_privbn) {
+        _libssh2_wincng_bignum_free(dhctx->dh_privbn);
+        dhctx->dh_privbn = NULL;
     }
 }
 
+static int
+round_down(int number, int multiple)
+{
+    return (number / multiple) * multiple;
+}
+
 /* Generates a Diffie-Hellman key pair using base `g', prime `p' and the given
  * `group_order'. Can use the given big number context `bnctx' if needed.  The
  * private key is stored as opaque in the Diffie-Hellman context `*dhctx' and
@@ -2287,16 +3839,19 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
                      _libssh2_bn *g, _libssh2_bn *p, int group_order)
 {
     const int hasAlgDHwithKDF = _libssh2_wincng.hasAlgDHwithKDF;
+
+    if(group_order < 0)
+        return -1;
+
     while(_libssh2_wincng.hAlgDH && hasAlgDHwithKDF != -1) {
-        BCRYPT_DH_PARAMETER_HEADER *dh_params = NULL;
-        unsigned long dh_params_len;
-        unsigned char *blob = NULL;
+        BCRYPT_DH_PARAMETER_HEADER *dh_params;
+        ULONG dh_params_len;
         int status;
         /* Note that the DH provider requires that keys be multiples of 64 bits
          * in length. At the time of writing a practical observed group_order
          * value is 257, so we need to round down to 8 bytes of length (64/8)
          * in order for kex to succeed */
-        DWORD key_length_bytes = max(round_down(group_order, 8),
+        ULONG key_length_bytes = max((ULONG)round_down(group_order, 8),
                                      max(g->length, p->length));
         BCRYPT_DH_KEY_BLOB *dh_key_blob;
         LPCWSTR key_type;
@@ -2310,38 +3865,39 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
             return -1;
         }
 
-        dh_params_len = sizeof(*dh_params) + 2 * key_length_bytes;
-        blob = malloc(dh_params_len);
-        if(!blob) {
+        dh_params_len = (ULONG)sizeof(*dh_params) +
+                        2 * key_length_bytes;
+        dh_params = (BCRYPT_DH_PARAMETER_HEADER *)malloc(dh_params_len);
+        if(!dh_params) {
             return -1;
         }
 
         /* Populate DH parameters blob; after the header follows the `p`
          * value and the `g` value. */
-        dh_params = (BCRYPT_DH_PARAMETER_HEADER*)blob;
         dh_params->cbLength = dh_params_len;
         dh_params->dwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
         dh_params->cbKeyLength = key_length_bytes;
-        memcpy_with_be_padding(blob + sizeof(*dh_params), key_length_bytes,
-                               p->bignum, p->length);
-        memcpy_with_be_padding(blob + sizeof(*dh_params) + key_length_bytes,
+        memcpy_with_be_padding((unsigned char *)dh_params +
+                               sizeof(*dh_params),
+                               key_length_bytes, p->bignum, p->length);
+        memcpy_with_be_padding((unsigned char *)dh_params +
+                               sizeof(*dh_params) + key_length_bytes,
                                key_length_bytes, g->bignum, g->length);
 
         status = BCryptSetProperty(dhctx->dh_handle, BCRYPT_DH_PARAMETERS,
-                                   blob, dh_params_len, 0);
+                                   (PUCHAR)dh_params, dh_params_len, 0);
         if(hasAlgDHwithKDF == -1) {
             /* We know that the raw KDF is not supported, so discard this. */
-            free(blob);
+            free(dh_params);
         }
         else {
             /* Pass ownership to dhctx; these parameters will be freed when
              * the context is destroyed. We need to keep the parameters more
              * easily available so that we have access to the `g` value when
-             * _libssh2_dh_secret is called later. */
+             * _libssh2_dh_secret() is called later. */
             dhctx->dh_params = dh_params;
         }
         dh_params = NULL;
-        blob = NULL;
 
         if(!BCRYPT_SUCCESS(status)) {
             return -1;
@@ -2371,21 +3927,21 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
             return -1;
         }
 
-        blob = malloc(key_length_bytes);
-        if(!blob) {
+        dh_key_blob = (BCRYPT_DH_KEY_BLOB *)malloc(key_length_bytes);
+        if(!dh_key_blob) {
             return -1;
         }
 
         status = BCryptExportKey(dhctx->dh_handle, NULL, key_type,
-                                 blob, key_length_bytes,
+                                 (PUCHAR)dh_key_blob, key_length_bytes,
                                  &key_length_bytes, 0);
         if(!BCRYPT_SUCCESS(status)) {
             if(hasAlgDHwithKDF == 1) {
                 /* We have no private data, because raw KDF is supported */
-                free(blob);
+                free(dh_key_blob);
             }
             else { /* we may have potentially private data, use secure free */
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
+                _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
             }
             return -1;
         }
@@ -2399,45 +3955,47 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
         /* BCRYPT_DH_PUBLIC_BLOB corresponds to a BCRYPT_DH_KEY_BLOB header
          * followed by the Modulus, Generator and Public data. Those components
          * each have equal size, specified by dh_key_blob->cbKey. */
-        dh_key_blob = (BCRYPT_DH_KEY_BLOB*)blob;
         if(_libssh2_wincng_bignum_resize(public, dh_key_blob->cbKey)) {
             if(hasAlgDHwithKDF == 1) {
                 /* We have no private data, because raw KDF is supported */
-                free(blob);
+                free(dh_key_blob);
             }
             else { /* we may have potentially private data, use secure free */
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
+                _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
             }
             return -1;
         }
 
         /* Copy the public key data into the public bignum data buffer */
-        memcpy(public->bignum,
-               blob + sizeof(*dh_key_blob) + 2 * dh_key_blob->cbKey,
+        memcpy(public->bignum, (unsigned char *)dh_key_blob +
+                               sizeof(*dh_key_blob) +
+                               2 * dh_key_blob->cbKey,
                dh_key_blob->cbKey);
 
         if(dh_key_blob->dwMagic == BCRYPT_DH_PRIVATE_MAGIC) {
             /* BCRYPT_DH_PRIVATE_BLOB additionally contains the Private data */
-            dhctx->bn = _libssh2_wincng_bignum_init();
-            if(!dhctx->bn) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
+            dhctx->dh_privbn = _libssh2_wincng_bignum_init();
+            if(!dhctx->dh_privbn) {
+                _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
                 return -1;
             }
-            if(_libssh2_wincng_bignum_resize(dhctx->bn, dh_key_blob->cbKey)) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
+            if(_libssh2_wincng_bignum_resize(dhctx->dh_privbn,
+                                             dh_key_blob->cbKey)) {
+                _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
                 return -1;
             }
 
             /* Copy the private key data into the dhctx bignum data buffer */
-            memcpy(dhctx->bn->bignum,
-                   blob + sizeof(*dh_key_blob) + 3 * dh_key_blob->cbKey,
+            memcpy(dhctx->dh_privbn->bignum, (unsigned char *)dh_key_blob +
+                                             sizeof(*dh_key_blob) +
+                                             3 * dh_key_blob->cbKey,
                    dh_key_blob->cbKey);
 
             /* Make sure the private key is an odd number, because only
              * odd primes can be used with the RSA-based fallback while
              * DH itself does not seem to care about it being odd or not. */
-            if(!(dhctx->bn->bignum[dhctx->bn->length-1] % 2)) {
-                _libssh2_wincng_safe_free(blob, key_length_bytes);
+            if(!(dhctx->dh_privbn->bignum[dhctx->dh_privbn->length-1] % 2)) {
+                _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
                 /* discard everything first, then try again */
                 _libssh2_dh_dtor(dhctx);
                 _libssh2_dh_init(dhctx);
@@ -2445,16 +4003,18 @@ _libssh2_dh_key_pair(_libssh2_dh_ctx *dhctx, _libssh2_bn *public,
             }
         }
 
+        _libssh2_wincng_safe_free(dh_key_blob, key_length_bytes);
+
         return 0;
     }
 
     /* Generate x and e */
-    dhctx->bn = _libssh2_wincng_bignum_init();
-    if(!dhctx->bn)
+    dhctx->dh_privbn = _libssh2_wincng_bignum_init();
+    if(!dhctx->dh_privbn)
         return -1;
-    if(_libssh2_wincng_bignum_rand(dhctx->bn, group_order * 8 - 1, 0, -1))
+    if(_libssh2_wincng_bignum_rand(dhctx->dh_privbn, (group_order*8)-1, 0, -1))
         return -1;
-    if(_libssh2_wincng_bignum_mod_exp(public, g, dhctx->bn, p))
+    if(_libssh2_wincng_bignum_mod_exp(public, g, dhctx->dh_privbn, p))
         return -1;
 
     return 0;
@@ -2473,12 +4033,12 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
         BCRYPT_KEY_HANDLE peer_public = NULL;
         BCRYPT_SECRET_HANDLE agreement = NULL;
         ULONG secret_len_bytes = 0;
-        unsigned char *blob;
-        int status;
+        NTSTATUS status;
         unsigned char *start, *end;
-        BCRYPT_DH_KEY_BLOB *public_blob = NULL;
-        DWORD key_length_bytes = max(f->length, dhctx->dh_params->cbKeyLength);
-        DWORD public_blob_len = sizeof(*public_blob) + 3 * key_length_bytes;
+        BCRYPT_DH_KEY_BLOB *public_blob;
+        ULONG key_length_bytes = max(f->length, dhctx->dh_params->cbKeyLength);
+        ULONG public_blob_len = (ULONG)(sizeof(*public_blob) +
+                                        3 * key_length_bytes);
 
         {
             /* Populate a BCRYPT_DH_KEY_BLOB; after the header follows the
@@ -2487,11 +4047,10 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
             unsigned char *dest;
             unsigned char *src;
 
-            blob = malloc(public_blob_len);
-            if(!blob) {
+            public_blob = (BCRYPT_DH_KEY_BLOB *)malloc(public_blob_len);
+            if(!public_blob) {
                 return -1;
             }
-            public_blob = (BCRYPT_DH_KEY_BLOB*)blob;
             public_blob->dwMagic = BCRYPT_DH_PUBLIC_MAGIC;
             public_blob->cbKey = key_length_bytes;
 
@@ -2512,8 +4071,8 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
 
         /* Import the peer public key information */
         status = BCryptImportKeyPair(_libssh2_wincng.hAlgDH, NULL,
-                                     BCRYPT_DH_PUBLIC_BLOB, &peer_public, blob,
-                                     public_blob_len, 0);
+                                     BCRYPT_DH_PUBLIC_BLOB, &peer_public,
+                                     (PUCHAR)public_blob, public_blob_len, 0);
         if(!BCRYPT_SUCCESS(status)) {
             goto out;
         }
@@ -2540,7 +4099,7 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
         /* Expand the secret bignum to be ready to receive the derived secret
          * */
         if(_libssh2_wincng_bignum_resize(secret, secret_len_bytes)) {
-            status = STATUS_NO_MEMORY;
+            status = (NTSTATUS)STATUS_NO_MEMORY;
             goto out;
         }
 
@@ -2578,6 +4137,9 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
         if(agreement) {
             BCryptDestroySecret(agreement);
         }
+
+        free(public_blob);
+
         if(status == STATUS_NOT_SUPPORTED &&
            _libssh2_wincng.hasAlgDHwithKDF == -1) {
             goto fb; /* fallback to RSA-based implementation */
@@ -2587,7 +4149,37 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
 
 fb:
     /* Compute the shared secret */
-    return _libssh2_wincng_bignum_mod_exp(secret, f, dhctx->bn, p);
+    return _libssh2_wincng_bignum_mod_exp(secret, f, dhctx->dh_privbn, p);
+}
+
+/* _libssh2_supported_key_sign_algorithms
+ *
+ * Return supported key hash algo upgrades, see crypto.h
+ *
+ */
+
+const char *
+_libssh2_supported_key_sign_algorithms(LIBSSH2_SESSION *session,
+                                       unsigned char *key_method,
+                                       size_t key_method_len)
+{
+    (void)session;
+
+#if LIBSSH2_RSA_SHA2
+    if(key_method_len == 7 &&
+        memcmp(key_method, "ssh-rsa", key_method_len) == 0) {
+        return "rsa-sha2-512,rsa-sha2-256"
+#if LIBSSH2_RSA_SHA1
+            ",ssh-rsa"
+#endif
+            ;
+    }
+#else
+    (void)key_method;
+    (void)key_method_len;
+#endif
+
+    return NULL;
 }
 
-#endif /* LIBSSH2_WINCNG */
+#endif /* LIBSSH2_CRYPTO_C */
diff --git a/libssh2/src/wincng.h b/libssh2/src/wincng.h
old mode 100755
new mode 100644
index eaf6f905..a8d0d805
--- a/libssh2/src/wincng.h
+++ b/libssh2/src/wincng.h
@@ -1,7 +1,7 @@
-#ifndef __LIBSSH2_WINCNG_H
-#define __LIBSSH2_WINCNG_H
+#ifndef LIBSSH2_WINCNG_H
+#define LIBSSH2_WINCNG_H
 /*
- * Copyright (C) 2013-2020 Marc Hoersken <info@marc-hoersken.de>
+ * Copyright (C) Marc Hoersken <info@marc-hoersken.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -36,8 +36,12 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#define LIBSSH2_CRYPTO_ENGINE libssh2_wincng
+
 /* required for cross-compilation against the w64 mingw-runtime package */
 #if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
 #undef _WIN32_WINNT
@@ -55,19 +59,43 @@
 #define LIBSSH2_HMAC_SHA256 1
 #define LIBSSH2_HMAC_SHA512 1
 
-#define LIBSSH2_AES 1
+#define LIBSSH2_AES_CBC 1
 #define LIBSSH2_AES_CTR 1
+#define LIBSSH2_AES_GCM 0
 #define LIBSSH2_BLOWFISH 0
 #define LIBSSH2_RC4 1
 #define LIBSSH2_CAST 0
 #define LIBSSH2_3DES 1
 
 #define LIBSSH2_RSA 1
+#define LIBSSH2_RSA_SHA1 1
+#define LIBSSH2_RSA_SHA2 1
 #define LIBSSH2_DSA 1
-#define LIBSSH2_ECDSA 0
 #define LIBSSH2_ED25519 0
 
+/*
+ * Conditionally enable ECDSA support.
+ *
+ * ECDSA support requires the use of
+ *
+ *   BCryptDeriveKey(..., BCRYPT_KDF_RAW_SECRET, ... )
+ *
+ * This functionality is only available as of Windows 10. To maintain
+ * backward compatibility, ECDSA support is therefore disabled
+ * by default and needs to be explicitly enabled using a build
+ * flag.
+ */
+#ifdef LIBSSH2_ECDSA_WINCNG
+#define LIBSSH2_ECDSA 1
+#else
+#define LIBSSH2_ECDSA 0
+#endif
+
+#include "crypto_config.h"
+
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define MD5_DIGEST_LENGTH 16
+#endif
 #define SHA_DIGEST_LENGTH 20
 #define SHA256_DIGEST_LENGTH 32
 #define SHA384_DIGEST_LENGTH 48
@@ -104,6 +132,11 @@ struct _libssh2_wincng_ctx {
     BCRYPT_ALG_HANDLE hAlgRC4_NA;
     BCRYPT_ALG_HANDLE hAlg3DES_CBC;
     BCRYPT_ALG_HANDLE hAlgDH;
+    BCRYPT_ALG_HANDLE hAlgChacha20;
+#if LIBSSH2_ECDSA
+    BCRYPT_ALG_HANDLE hAlgECDH[3];  /* indexed by libssh2_curve_type */
+    BCRYPT_ALG_HANDLE hAlgECDSA[3]; /* indexed by libssh2_curve_type */
+#endif
     volatile int hasAlgDHwithKDF; /* -1=no, 0=maybe, 1=yes */
 };
 
@@ -115,16 +148,13 @@ extern struct _libssh2_wincng_ctx _libssh2_wincng;
  * Windows CNG backend: Generic functions
  */
 
-void _libssh2_wincng_init(void);
-void _libssh2_wincng_free(void);
-
 #define libssh2_crypto_init() \
-  _libssh2_wincng_init()
+    _libssh2_wincng_init()
 #define libssh2_crypto_exit() \
-  _libssh2_wincng_free()
+    _libssh2_wincng_free()
 
 #define _libssh2_random(buf, len) \
-  _libssh2_wincng_random(buf, len)
+    _libssh2_wincng_random(buf, len)
 
 #define libssh2_prepare_iovec(vec, len)  /* Empty. */
 
@@ -137,8 +167,8 @@ void _libssh2_wincng_free(void);
 typedef struct __libssh2_wincng_hash_ctx {
     BCRYPT_HASH_HANDLE hHash;
     unsigned char *pbHashObject;
-    unsigned long dwHashObject;
-    unsigned long cbHash;
+    ULONG dwHashObject;
+    ULONG cbHash;
 } _libssh2_wincng_hash_ctx;
 
 /*
@@ -147,88 +177,68 @@ typedef struct __libssh2_wincng_hash_ctx {
 
 #define libssh2_sha1_ctx _libssh2_wincng_hash_ctx
 #define libssh2_sha1_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA1, \
-                            SHA_DIGEST_LENGTH, NULL, 0) == 0)
+    (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA1, \
+                               SHA_DIGEST_LENGTH, NULL, 0) == 0)
 #define libssh2_sha1_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
+    (_libssh2_wincng_hash_update(&ctx, data, (ULONG) datalen) == 0)
 #define libssh2_sha1_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
+    (_libssh2_wincng_hash_final(&ctx, hash) == 0)
 #define libssh2_sha1(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA1, \
-                       hash, SHA_DIGEST_LENGTH)
+    _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA1, \
+                         hash, SHA_DIGEST_LENGTH)
 
 #define libssh2_sha256_ctx _libssh2_wincng_hash_ctx
 #define libssh2_sha256_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA256, \
-                            SHA256_DIGEST_LENGTH, NULL, 0) == 0)
+    (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA256, \
+                               SHA256_DIGEST_LENGTH, NULL, 0) == 0)
 #define libssh2_sha256_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
+    (_libssh2_wincng_hash_update(&ctx, data, (ULONG) datalen) == 0)
 #define libssh2_sha256_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
+    (_libssh2_wincng_hash_final(&ctx, hash) == 0)
 #define libssh2_sha256(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA256, \
-                       hash, SHA256_DIGEST_LENGTH)
+    _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA256, \
+                         hash, SHA256_DIGEST_LENGTH)
+
 #define libssh2_sha384_ctx _libssh2_wincng_hash_ctx
 #define libssh2_sha384_init(ctx) \
- (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA384, \
-                           SHA384_DIGEST_LENGTH, NULL, 0) == 0)
+    (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA384, \
+                               SHA384_DIGEST_LENGTH, NULL, 0) == 0)
 #define libssh2_sha384_update(ctx, data, datalen) \
- _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
+    (_libssh2_wincng_hash_update(&ctx, data, (ULONG) datalen) == 0)
 #define libssh2_sha384_final(ctx, hash) \
- _libssh2_wincng_hash_final(&ctx, hash)
+    (_libssh2_wincng_hash_final(&ctx, hash) == 0)
 #define libssh2_sha384(data, datalen, hash) \
-_libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA384, \
-                     hash, SHA384_DIGEST_LENGTH)
+    _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA384, \
+                         hash, SHA384_DIGEST_LENGTH)
+
 #define libssh2_sha512_ctx _libssh2_wincng_hash_ctx
 #define libssh2_sha512_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA512, \
-                            SHA512_DIGEST_LENGTH, NULL, 0) == 0)
+    (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashSHA512, \
+                               SHA512_DIGEST_LENGTH, NULL, 0) == 0)
 #define libssh2_sha512_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
+    (_libssh2_wincng_hash_update(&ctx, data, (ULONG) datalen) == 0)
 #define libssh2_sha512_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
+    (_libssh2_wincng_hash_final(&ctx, hash) == 0)
 #define libssh2_sha512(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA512, \
-                       hash, SHA512_DIGEST_LENGTH)
+    _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA512, \
+                         hash, SHA512_DIGEST_LENGTH)
 
+#if LIBSSH2_MD5 || LIBSSH2_MD5_PEM
 #define libssh2_md5_ctx _libssh2_wincng_hash_ctx
 #define libssh2_md5_init(ctx) \
-  (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashMD5, \
-                            MD5_DIGEST_LENGTH, NULL, 0) == 0)
+    (_libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHashMD5, \
+                               MD5_DIGEST_LENGTH, NULL, 0) == 0)
 #define libssh2_md5_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
+    (_libssh2_wincng_hash_update(&ctx, data, (ULONG) datalen) == 0)
 #define libssh2_md5_final(ctx, hash) \
-  _libssh2_wincng_hash_final(&ctx, hash)
-#define libssh2_md5(data, datalen, hash) \
-  _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashMD5, \
-                       hash, MD5_DIGEST_LENGTH)
+    (_libssh2_wincng_hash_final(&ctx, hash) == 0)
+#endif
 
 /*
  * Windows CNG backend: HMAC functions
  */
 
 #define libssh2_hmac_ctx _libssh2_wincng_hash_ctx
-#define libssh2_hmac_ctx_init(ctx)
-#define libssh2_hmac_sha1_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA1, \
-                            SHA_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_md5_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacMD5, \
-                            MD5_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_ripemd160_init(ctx, key, keylen)
-  /* not implemented */
-#define libssh2_hmac_sha256_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA256, \
-                            SHA256_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_sha512_init(ctx, key, keylen) \
-  _libssh2_wincng_hash_init(ctx, _libssh2_wincng.hAlgHmacSHA512, \
-                            SHA512_DIGEST_LENGTH, key, keylen)
-#define libssh2_hmac_update(ctx, data, datalen) \
-  _libssh2_wincng_hash_update(&ctx, (unsigned char *) data, datalen)
-#define libssh2_hmac_final(ctx, hash) \
-  _libssh2_wincng_hmac_final(&ctx, hash)
-#define libssh2_hmac_cleanup(ctx) \
-  _libssh2_wincng_hmac_cleanup(ctx)
 
 
 /*******************************************************************/
@@ -238,8 +248,8 @@ _libssh2_wincng_hash(data, datalen, _libssh2_wincng.hAlgHashSHA384, \
 
 typedef struct __libssh2_wincng_key_ctx {
     BCRYPT_KEY_HANDLE hKey;
-    unsigned char *pbKeyObject;
-    unsigned long cbKeyObject;
+    void *pbKeyObject;
+    DWORD cbKeyObject;
 } _libssh2_wincng_key_ctx;
 
 
@@ -251,21 +261,25 @@ typedef struct __libssh2_wincng_key_ctx {
 #define _libssh2_rsa_new(rsactx, e, e_len, n, n_len, \
                          d, d_len, p, p_len, q, q_len, \
                          e1, e1_len, e2, e2_len, c, c_len) \
-  _libssh2_wincng_rsa_new(rsactx, e, e_len, n, n_len, \
-                          d, d_len, p, p_len, q, q_len, \
-                          e1, e1_len, e2, e2_len, c, c_len)
+    _libssh2_wincng_rsa_new(rsactx, e, e_len, n, n_len, \
+                            d, d_len, p, p_len, q, q_len, \
+                            e1, e1_len, e2, e2_len, c, c_len)
 #define _libssh2_rsa_new_private(rsactx, s, filename, passphrase) \
-  _libssh2_wincng_rsa_new_private(rsactx, s, filename, passphrase)
+    _libssh2_wincng_rsa_new_private(rsactx, s, filename, passphrase)
 #define _libssh2_rsa_new_private_frommemory(rsactx, s, filedata, \
                                             filedata_len, passphrase) \
-  _libssh2_wincng_rsa_new_private_frommemory(rsactx, s, filedata, \
-                                             filedata_len, passphrase)
+    _libssh2_wincng_rsa_new_private_frommemory(rsactx, s, filedata, \
+                                               filedata_len, passphrase)
 #define _libssh2_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len) \
-  _libssh2_wincng_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
+    _libssh2_wincng_rsa_sha1_sign(s, rsactx, hash, hash_len, sig, sig_len)
+#define _libssh2_rsa_sha2_sign(s, rsactx, hash, hash_len, sig, sig_len) \
+    _libssh2_wincng_rsa_sha2_sign(s, rsactx, hash, hash_len, sig, sig_len)
 #define _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len) \
-  _libssh2_wincng_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
+    _libssh2_wincng_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len)
+#define _libssh2_rsa_sha2_verify(rsactx, hash_len, sig, sig_len, m, m_len) \
+    _libssh2_wincng_rsa_sha2_verify(rsactx, hash_len, sig, sig_len, m, m_len)
 #define _libssh2_rsa_free(rsactx) \
-  _libssh2_wincng_rsa_free(rsactx)
+    _libssh2_wincng_rsa_free(rsactx)
 
 /*
  * Windows CNG backend: DSA functions
@@ -274,32 +288,92 @@ typedef struct __libssh2_wincng_key_ctx {
 #define libssh2_dsa_ctx _libssh2_wincng_key_ctx
 #define _libssh2_dsa_new(dsactx, p, p_len, q, q_len, \
                          g, g_len, y, y_len, x, x_len) \
-  _libssh2_wincng_dsa_new(dsactx, p, p_len, q, q_len, \
-                          g, g_len, y, y_len, x, x_len)
+    _libssh2_wincng_dsa_new(dsactx, p, p_len, q, q_len, \
+                            g, g_len, y, y_len, x, x_len)
 #define _libssh2_dsa_new_private(dsactx, s, filename, passphrase) \
-  _libssh2_wincng_dsa_new_private(dsactx, s, filename, passphrase)
+    _libssh2_wincng_dsa_new_private(dsactx, s, filename, passphrase)
 #define _libssh2_dsa_new_private_frommemory(dsactx, s, filedata, \
                                             filedata_len, passphrase) \
-  _libssh2_wincng_dsa_new_private_frommemory(dsactx, s, filedata, \
-                                             filedata_len, passphrase)
+    _libssh2_wincng_dsa_new_private_frommemory(dsactx, s, filedata, \
+                                               filedata_len, passphrase)
 #define _libssh2_dsa_sha1_sign(dsactx, hash, hash_len, sig) \
-  _libssh2_wincng_dsa_sha1_sign(dsactx, hash, hash_len, sig)
+    _libssh2_wincng_dsa_sha1_sign(dsactx, hash, hash_len, sig)
 #define _libssh2_dsa_sha1_verify(dsactx, sig, m, m_len) \
-  _libssh2_wincng_dsa_sha1_verify(dsactx, sig, m, m_len)
+    _libssh2_wincng_dsa_sha1_verify(dsactx, sig, m, m_len)
 #define _libssh2_dsa_free(dsactx) \
-  _libssh2_wincng_dsa_free(dsactx)
+    _libssh2_wincng_dsa_free(dsactx)
+
+
+/*
+ * Windows CNG backend: ECDSA functions
+ */
+
+typedef enum {
+    LIBSSH2_EC_CURVE_NISTP256 = 0,
+    LIBSSH2_EC_CURVE_NISTP384 = 1,
+    LIBSSH2_EC_CURVE_NISTP521 = 2,
+} libssh2_curve_type;
+
+typedef struct __libssh2_wincng_ecdsa_ctx {
+    BCRYPT_KEY_HANDLE handle;
+    libssh2_curve_type curve;
+} _libssh2_wincng_ecdsa_key;
+
+#define libssh2_ecdsa_ctx _libssh2_wincng_ecdsa_key
+
+#if LIBSSH2_ECDSA
+#define _libssh2_ec_key _libssh2_wincng_ecdsa_key
+#endif
+
+void
+_libssh2_wincng_ecdsa_free(libssh2_ecdsa_ctx* ctx);
+
+#define _libssh2_ecdsa_create_key(session, privkey, pubkey_octal, \
+                                  pubkey_octal_len, curve) \
+    _libssh2_wincng_ecdh_create_key(session, privkey, pubkey_octal, \
+                                    pubkey_octal_len, curve)
+
+#define _libssh2_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve) \
+    _libssh2_wincng_ecdsa_curve_name_with_octal_new(ctx, k, k_len, curve)
+
+#define _libssh2_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len) \
+    _libssh2_wincng_ecdh_gen_k(k, privkey, server_pubkey, server_pubkey_len)
+
+#define _libssh2_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len) \
+    _libssh2_wincng_ecdsa_verify(ctx, r, r_len, s, s_len, m, m_len)
+
+#define _libssh2_ecdsa_new_private(ctx, session, filename, passphrase) \
+    _libssh2_wincng_ecdsa_new_private(ctx, session, filename, passphrase)
+
+#define _libssh2_ecdsa_new_private_frommemory(ctx, session, filedata, \
+                                              filedata_len, passphrase) \
+    _libssh2_wincng_ecdsa_new_private_frommemory(ctx, session, filedata, \
+                                                 filedata_len, passphrase)
+
+#define _libssh2_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len) \
+    _libssh2_wincng_ecdsa_sign(session, ctx, hash, hash_len, sign, sign_len)
+
+#define _libssh2_ecdsa_get_curve_type(ctx) \
+    _libssh2_wincng_ecdsa_get_curve_type(ctx)
+
+#define _libssh2_ecdsa_free(ecdsactx) \
+    _libssh2_wincng_ecdsa_free(ecdsactx)
+
 
 /*
  * Windows CNG backend: Key functions
  */
 
 #define _libssh2_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw) \
-  _libssh2_wincng_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
+    _libssh2_wincng_pub_priv_keyfile(s, m, m_len, p, p_len, pk, pw)
 #define _libssh2_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                     pk, pk_len, pw) \
-  _libssh2_wincng_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
-                                                      pk, pk_len, pw)
-
+                                        pk, pk_len, pw) \
+    _libssh2_wincng_pub_priv_keyfilememory(s, m, m_len, p, p_len, \
+                                           pk, pk_len, pw)
+#define _libssh2_sk_pub_keyfilememory(s, m, m_len, p, p_len, alg, app, \
+                                      f, kh, kh_len, pk, pk_len, pw) \
+    _libssh2_wincng_sk_pub_keyfilememory(s, m, m_len, p, p_len, alg, app, \
+                                         f, kh, kh_len, pk, pk_len, pw)
 
 /*******************************************************************/
 /*
@@ -311,10 +385,10 @@ struct _libssh2_wincng_cipher_ctx {
     unsigned char *pbKeyObject;
     unsigned char *pbIV;
     unsigned char *pbCtr;
-    unsigned long dwKeyObject;
-    unsigned long dwIV;
-    unsigned long dwBlockLength;
-    unsigned long dwCtrLength;
+    ULONG dwKeyObject;
+    ULONG dwIV;
+    ULONG dwBlockLength;
+    ULONG dwCtrLength;
 };
 
 #define _libssh2_cipher_ctx struct _libssh2_wincng_cipher_ctx
@@ -325,7 +399,7 @@ struct _libssh2_wincng_cipher_ctx {
 
 struct _libssh2_wincng_cipher_type {
     BCRYPT_ALG_HANDLE *phAlg;
-    unsigned long dwKeyLength;
+    ULONG dwKeyLength;
     int useIV;      /* TODO: Convert to bool when a C89 compatible bool type
                        is defined */
     int ctrMode;
@@ -336,22 +410,23 @@ struct _libssh2_wincng_cipher_type {
 #define _libssh2_cipher_aes256ctr { &_libssh2_wincng.hAlgAES_ECB, 32, 0, 1 }
 #define _libssh2_cipher_aes192ctr { &_libssh2_wincng.hAlgAES_ECB, 24, 0, 1 }
 #define _libssh2_cipher_aes128ctr { &_libssh2_wincng.hAlgAES_ECB, 16, 0, 1 }
-#define _libssh2_cipher_aes256 { &_libssh2_wincng.hAlgAES_CBC, 32, 1, 0 }
-#define _libssh2_cipher_aes192 { &_libssh2_wincng.hAlgAES_CBC, 24, 1, 0 }
-#define _libssh2_cipher_aes128 { &_libssh2_wincng.hAlgAES_CBC, 16, 1, 0 }
-#define _libssh2_cipher_arcfour { &_libssh2_wincng.hAlgRC4_NA, 16, 0, 0 }
-#define _libssh2_cipher_3des { &_libssh2_wincng.hAlg3DES_CBC, 24, 1, 0 }
+#define _libssh2_cipher_aes256    { &_libssh2_wincng.hAlgAES_CBC, 32, 1, 0 }
+#define _libssh2_cipher_aes192    { &_libssh2_wincng.hAlgAES_CBC, 24, 1, 0 }
+#define _libssh2_cipher_aes128    { &_libssh2_wincng.hAlgAES_CBC, 16, 1, 0 }
+#define _libssh2_cipher_arcfour   { &_libssh2_wincng.hAlgRC4_NA, 16, 0, 0 }
+#define _libssh2_cipher_3des      { &_libssh2_wincng.hAlg3DES_CBC, 24, 1, 0 }
+#define _libssh2_cipher_chacha20  { &_libssh2_wincng.hAlgChacha20, 24, 1, 0 }
 
 /*
  * Windows CNG backend: Cipher functions
  */
 
 #define _libssh2_cipher_init(ctx, type, iv, secret, encrypt) \
-  _libssh2_wincng_cipher_init(ctx, type, iv, secret, encrypt)
-#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen) \
-  _libssh2_wincng_cipher_crypt(ctx, type, encrypt, block, blocklen)
+    _libssh2_wincng_cipher_init(ctx, type, iv, secret, encrypt)
+#define _libssh2_cipher_crypt(ctx, type, encrypt, block, blocklen, fl) \
+    _libssh2_wincng_cipher_crypt(ctx, type, encrypt, block, blocklen, fl)
 #define _libssh2_cipher_dtor(ctx) \
-  _libssh2_wincng_cipher_dtor(ctx)
+    _libssh2_wincng_cipher_dtor(ctx)
 
 /*******************************************************************/
 /*
@@ -370,7 +445,7 @@ struct _libssh2_wincng_cipher_type {
 
 struct _libssh2_wincng_bignum {
     unsigned char *bignum;
-    unsigned long length;
+    ULONG length;
 };
 
 #define _libssh2_bn struct _libssh2_wincng_bignum
@@ -379,28 +454,34 @@ struct _libssh2_wincng_bignum {
  * Windows CNG backend: BigNumber functions
  */
 
-_libssh2_bn *_libssh2_wincng_bignum_init(void);
-
 #define _libssh2_bn_init() \
-  _libssh2_wincng_bignum_init()
+    _libssh2_wincng_bignum_init()
 #define _libssh2_bn_init_from_bin() \
-  _libssh2_bn_init()
+    _libssh2_bn_init()
 #define _libssh2_bn_set_word(bn, word) \
-  _libssh2_wincng_bignum_set_word(bn, word)
+    _libssh2_wincng_bignum_set_word(bn, word)
 #define _libssh2_bn_from_bin(bn, len, bin) \
-  _libssh2_wincng_bignum_from_bin(bn, len, bin)
+    _libssh2_wincng_bignum_from_bin(bn, (ULONG) len, bin)
 #define _libssh2_bn_to_bin(bn, bin) \
-  _libssh2_wincng_bignum_to_bin(bn, bin)
+    _libssh2_wincng_bignum_to_bin(bn, bin)
 #define _libssh2_bn_bytes(bn) bn->length
 #define _libssh2_bn_bits(bn) \
-  _libssh2_wincng_bignum_bits(bn)
+    _libssh2_wincng_bignum_bits(bn)
 #define _libssh2_bn_free(bn) \
-  _libssh2_wincng_bignum_free(bn)
+    _libssh2_wincng_bignum_free(bn)
 
 /*
  * Windows CNG backend: Diffie-Hellman support
  */
 
+/* Default generate and safe prime sizes for
+   diffie-hellman-group-exchange-sha1 */
+#define LIBSSH2_DH_GEX_MINGROUP     2048
+#define LIBSSH2_DH_GEX_OPTGROUP     4096
+#define LIBSSH2_DH_GEX_MAXGROUP     4096
+
+#define LIBSSH2_DH_MAX_MODULUS_BITS 16384
+
 typedef struct {
     /* holds our private and public key components */
     BCRYPT_KEY_HANDLE dh_handle;
@@ -409,14 +490,14 @@ typedef struct {
     BCRYPT_DH_PARAMETER_HEADER *dh_params;
     /* records the parsed out private key component for
      * fallback if the DH API raw KDF is not supported */
-    struct _libssh2_wincng_bignum *bn;
+    struct _libssh2_wincng_bignum *dh_privbn;
 } _libssh2_dh_ctx;
 
 #define libssh2_dh_init(dhctx) _libssh2_dh_init(dhctx)
 #define libssh2_dh_key_pair(dhctx, public, g, p, group_order, bnctx) \
-        _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
+    _libssh2_dh_key_pair(dhctx, public, g, p, group_order)
 #define libssh2_dh_secret(dhctx, secret, f, p, bnctx) \
-        _libssh2_dh_secret(dhctx, secret, f, p)
+    _libssh2_dh_secret(dhctx, secret, f, p)
 #define libssh2_dh_dtor(dhctx) _libssh2_dh_dtor(dhctx)
 
 /*******************************************************************/
@@ -425,163 +506,44 @@ typedef struct {
  */
 void _libssh2_wincng_init(void);
 void _libssh2_wincng_free(void);
-int _libssh2_wincng_random(void *buf, int len);
+int _libssh2_wincng_random(void *buf, size_t len);
 
 int
 _libssh2_wincng_hash_init(_libssh2_wincng_hash_ctx *ctx,
-                          BCRYPT_ALG_HANDLE hAlg, unsigned long hashlen,
-                          unsigned char *key, unsigned long keylen);
+                          BCRYPT_ALG_HANDLE hAlg, ULONG hashlen,
+                          unsigned char *key, ULONG keylen);
 int
 _libssh2_wincng_hash_update(_libssh2_wincng_hash_ctx *ctx,
-                            const unsigned char *data, unsigned long datalen);
+                            const void *data, ULONG datalen);
 int
 _libssh2_wincng_hash_final(_libssh2_wincng_hash_ctx *ctx,
                            unsigned char *hash);
 int
-_libssh2_wincng_hash(unsigned char *data, unsigned long datalen,
+_libssh2_wincng_hash(const unsigned char *data, ULONG datalen,
                      BCRYPT_ALG_HANDLE hAlg,
-                     unsigned char *hash, unsigned long hashlen);
+                     unsigned char *hash, ULONG hashlen);
 
-int
-_libssh2_wincng_hmac_final(_libssh2_wincng_hash_ctx *ctx,
-                           unsigned char *hash);
-void
-_libssh2_wincng_hmac_cleanup(_libssh2_wincng_hash_ctx *ctx);
-
-int
-_libssh2_wincng_key_sha1_verify(_libssh2_wincng_key_ctx *ctx,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len,
-                                unsigned long flags);
-
-int
-_libssh2_wincng_rsa_new(libssh2_rsa_ctx **rsa,
-                        const unsigned char *edata,
-                        unsigned long elen,
-                        const unsigned char *ndata,
-                        unsigned long nlen,
-                        const unsigned char *ddata,
-                        unsigned long dlen,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *e1data,
-                        unsigned long e1len,
-                        const unsigned char *e2data,
-                        unsigned long e2len,
-                        const unsigned char *coeffdata,
-                        unsigned long coefflen);
-int
-_libssh2_wincng_rsa_new_private(libssh2_rsa_ctx **rsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-int
-_libssh2_wincng_rsa_new_private_frommemory(libssh2_rsa_ctx **rsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_wincng_rsa_sha1_verify(libssh2_rsa_ctx *rsa,
-                                const unsigned char *sig,
-                                unsigned long sig_len,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_wincng_rsa_sha1_sign(LIBSSH2_SESSION *session,
-                              libssh2_rsa_ctx *rsa,
-                              const unsigned char *hash,
-                              size_t hash_len,
-                              unsigned char **signature,
-                              size_t *signature_len);
 void
 _libssh2_wincng_rsa_free(libssh2_rsa_ctx *rsa);
 
 #if LIBSSH2_DSA
-int
-_libssh2_wincng_dsa_new(libssh2_dsa_ctx **dsa,
-                        const unsigned char *pdata,
-                        unsigned long plen,
-                        const unsigned char *qdata,
-                        unsigned long qlen,
-                        const unsigned char *gdata,
-                        unsigned long glen,
-                        const unsigned char *ydata,
-                        unsigned long ylen,
-                        const unsigned char *xdata,
-                        unsigned long xlen);
-int
-_libssh2_wincng_dsa_new_private(libssh2_dsa_ctx **dsa,
-                                LIBSSH2_SESSION *session,
-                                const char *filename,
-                                const unsigned char *passphrase);
-int
-_libssh2_wincng_dsa_new_private_frommemory(libssh2_dsa_ctx **dsa,
-                                           LIBSSH2_SESSION *session,
-                                           const char *filedata,
-                                           size_t filedata_len,
-                                           unsigned const char *passphrase);
-int
-_libssh2_wincng_dsa_sha1_verify(libssh2_dsa_ctx *dsa,
-                                const unsigned char *sig_fixed,
-                                const unsigned char *m,
-                                unsigned long m_len);
-int
-_libssh2_wincng_dsa_sha1_sign(libssh2_dsa_ctx *dsa,
-                              const unsigned char *hash,
-                              unsigned long hash_len,
-                              unsigned char *sig_fixed);
 void
 _libssh2_wincng_dsa_free(libssh2_dsa_ctx *dsa);
 #endif
 
-int
-_libssh2_wincng_pub_priv_keyfile(LIBSSH2_SESSION *session,
-                                 unsigned char **method,
-                                 size_t *method_len,
-                                 unsigned char **pubkeydata,
-                                 size_t *pubkeydata_len,
-                                 const char *privatekey,
-                                 const char *passphrase);
-int
-_libssh2_wincng_pub_priv_keyfilememory(LIBSSH2_SESSION *session,
-                                       unsigned char **method,
-                                       size_t *method_len,
-                                       unsigned char **pubkeydata,
-                                       size_t *pubkeydata_len,
-                                       const char *privatekeydata,
-                                       size_t privatekeydata_len,
-                                       const char *passphrase);
-
-int
-_libssh2_wincng_cipher_init(_libssh2_cipher_ctx *ctx,
-                            _libssh2_cipher_type(type),
-                            unsigned char *iv,
-                            unsigned char *secret,
-                            int encrypt);
-int
-_libssh2_wincng_cipher_crypt(_libssh2_cipher_ctx *ctx,
-                             _libssh2_cipher_type(type),
-                             int encrypt,
-                             unsigned char *block,
-                             size_t blocklen);
 void
 _libssh2_wincng_cipher_dtor(_libssh2_cipher_ctx *ctx);
 
 _libssh2_bn *
 _libssh2_wincng_bignum_init(void);
 int
-_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, unsigned long word);
-unsigned long
+_libssh2_wincng_bignum_set_word(_libssh2_bn *bn, ULONG word);
+ULONG
 _libssh2_wincng_bignum_bits(const _libssh2_bn *bn);
-void
-_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, unsigned long len,
+int
+_libssh2_wincng_bignum_from_bin(_libssh2_bn *bn, ULONG len,
                                 const unsigned char *bin);
-void
+int
 _libssh2_wincng_bignum_to_bin(const _libssh2_bn *bn, unsigned char *bin);
 void
 _libssh2_wincng_bignum_free(_libssh2_bn *bn);
@@ -596,4 +558,4 @@ _libssh2_dh_secret(_libssh2_dh_ctx *dhctx, _libssh2_bn *secret,
 extern void
 _libssh2_dh_dtor(_libssh2_dh_ctx *dhctx);
 
-#endif /* __LIBSSH2_WINCNG_H */
+#endif /* LIBSSH2_WINCNG_H */
diff --git a/libssh2/tap-driver.sh b/libssh2/tap-driver.sh
new file mode 100755
index 00000000..fea066f5
--- /dev/null
+++ b/libssh2/tap-driver.sh
@@ -0,0 +1,651 @@
+#! /bin/sh
+# Copyright (C) 2011-2021 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+scriptversion=2013-12-23.17; # UTC
+
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+
+me=tap-driver.sh
+
+fatal ()
+{
+  echo "$me: fatal: $*" >&2
+  exit 1
+}
+
+usage_error ()
+{
+  echo "$me: $*" >&2
+  print_usage >&2
+  exit 2
+}
+
+print_usage ()
+{
+  cat <<END
+Usage:
+  tap-driver.sh --test-name=NAME --log-file=PATH --trs-file=PATH
+                [--expect-failure={yes|no}] [--color-tests={yes|no}]
+                [--enable-hard-errors={yes|no}] [--ignore-exit]
+                [--diagnostic-string=STRING] [--merge|--no-merge]
+                [--comments|--no-comments] [--] TEST-COMMAND
+The '--test-name', '-log-file' and '--trs-file' options are mandatory.
+END
+}
+
+# TODO: better error handling in option parsing (in particular, ensure
+# TODO: $log_file, $trs_file and $test_name are defined).
+test_name= # Used for reporting.
+log_file=  # Where to save the result and output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=0
+color_tests=0
+merge=0
+ignore_exit=0
+comments=0
+diag_string='#'
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "$me $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) shift;; # No-op.
+  --merge) merge=1;;
+  --no-merge) merge=0;;
+  --ignore-exit) ignore_exit=1;;
+  --comments) comments=1;;
+  --no-comments) comments=0;;
+  --diagnostic-string) diag_string=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+  esac
+  shift
+done
+
+test $# -gt 0 || usage_error "missing test command"
+
+case $expect_failure in
+  yes) expect_failure=1;;
+    *) expect_failure=0;;
+esac
+
+if test $color_tests = yes; then
+  init_colors='
+    color_map["red"]="" # Red.
+    color_map["grn"]="" # Green.
+    color_map["lgn"]="" # Light green.
+    color_map["blu"]="" # Blue.
+    color_map["mgn"]="" # Magenta.
+    color_map["std"]=""     # No color.
+    color_for_result["ERROR"] = "mgn"
+    color_for_result["PASS"]  = "grn"
+    color_for_result["XPASS"] = "red"
+    color_for_result["FAIL"]  = "red"
+    color_for_result["XFAIL"] = "lgn"
+    color_for_result["SKIP"]  = "blu"'
+else
+  init_colors=''
+fi
+
+# :; is there to work around a bug in bash 3.2 (and earlier) which
+# does not always set '$?' properly on redirection failure.
+# See the Autoconf manual for more details.
+:;{
+  (
+    # Ignore common signals (in this subshell only!), to avoid potential
+    # problems with Korn shells.  Some Korn shells are known to propagate
+    # to themselves signals that have killed a child process they were
+    # waiting for; this is done at least for SIGINT (and usually only for
+    # it, in truth).  Without the `trap' below, such a behaviour could
+    # cause a premature exit in the current subshell, e.g., in case the
+    # test command it runs gets terminated by a SIGINT.  Thus, the awk
+    # script we are piping into would never seen the exit status it
+    # expects on its last input line (which is displayed below by the
+    # last `echo $?' statement), and would thus die reporting an internal
+    # error.
+    # For more information, see the Autoconf manual and the threads:
+    # <https://lists.gnu.org/archive/html/bug-autoconf/2011-09/msg00004.html>
+    # <http://mail.opensolaris.org/pipermail/ksh93-integration-discuss/2009-February/004121.html>
+    trap : 1 3 2 13 15
+    if test $merge -gt 0; then
+      exec 2>&1
+    else
+      exec 2>&3
+    fi
+    "$@"
+    echo $?
+  ) | LC_ALL=C ${AM_TAP_AWK-awk} \
+        -v me="$me" \
+        -v test_script_name="$test_name" \
+        -v log_file="$log_file" \
+        -v trs_file="$trs_file" \
+        -v expect_failure="$expect_failure" \
+        -v merge="$merge" \
+        -v ignore_exit="$ignore_exit" \
+        -v comments="$comments" \
+        -v diag_string="$diag_string" \
+'
+# TODO: the usages of "cat >&3" below could be optimized when using
+#       GNU awk, and/on on systems that supports /dev/fd/.
+
+# Implementation note: in what follows, `result_obj` will be an
+# associative array that (partly) simulates a TAP result object
+# from the `TAP::Parser` perl module.
+
+## ----------- ##
+##  FUNCTIONS  ##
+## ----------- ##
+
+function fatal(msg)
+{
+  print me ": " msg | "cat >&2"
+  exit 1
+}
+
+function abort(where)
+{
+  fatal("internal error " where)
+}
+
+# Convert a boolean to a "yes"/"no" string.
+function yn(bool)
+{
+  return bool ? "yes" : "no";
+}
+
+function add_test_result(result)
+{
+  if (!test_results_index)
+    test_results_index = 0
+  test_results_list[test_results_index] = result
+  test_results_index += 1
+  test_results_seen[result] = 1;
+}
+
+# Whether the test script should be re-run by "make recheck".
+function must_recheck()
+{
+  for (k in test_results_seen)
+    if (k != "XFAIL" && k != "PASS" && k != "SKIP")
+      return 1
+  return 0
+}
+
+# Whether the content of the log file associated to this test should
+# be copied into the "global" test-suite.log.
+function copy_in_global_log()
+{
+  for (k in test_results_seen)
+    if (k != "PASS")
+      return 1
+  return 0
+}
+
+function get_global_test_result()
+{
+    if ("ERROR" in test_results_seen)
+      return "ERROR"
+    if ("FAIL" in test_results_seen || "XPASS" in test_results_seen)
+      return "FAIL"
+    all_skipped = 1
+    for (k in test_results_seen)
+      if (k != "SKIP")
+        all_skipped = 0
+    if (all_skipped)
+      return "SKIP"
+    return "PASS";
+}
+
+function stringify_result_obj(result_obj)
+{
+  if (result_obj["is_unplanned"] || result_obj["number"] != testno)
+    return "ERROR"
+
+  if (plan_seen == LATE_PLAN)
+    return "ERROR"
+
+  if (result_obj["directive"] == "TODO")
+    return result_obj["is_ok"] ? "XPASS" : "XFAIL"
+
+  if (result_obj["directive"] == "SKIP")
+    return result_obj["is_ok"] ? "SKIP" : COOKED_FAIL;
+
+  if (length(result_obj["directive"]))
+      abort("in function stringify_result_obj()")
+
+  return result_obj["is_ok"] ? COOKED_PASS : COOKED_FAIL
+}
+
+function decorate_result(result)
+{
+  color_name = color_for_result[result]
+  if (color_name)
+    return color_map[color_name] "" result "" color_map["std"]
+  # If we are not using colorized output, or if we do not know how
+  # to colorize the given result, we should return it unchanged.
+  return result
+}
+
+function report(result, details)
+{
+  if (result ~ /^(X?(PASS|FAIL)|SKIP|ERROR)/)
+    {
+      msg = ": " test_script_name
+      add_test_result(result)
+    }
+  else if (result == "#")
+    {
+      msg = " " test_script_name ":"
+    }
+  else
+    {
+      abort("in function report()")
+    }
+  if (length(details))
+    msg = msg " " details
+  # Output on console might be colorized.
+  print decorate_result(result) msg
+  # Log the result in the log file too, to help debugging (this is
+  # especially true when said result is a TAP error or "Bail out!").
+  print result msg | "cat >&3";
+}
+
+function testsuite_error(error_message)
+{
+  report("ERROR", "- " error_message)
+}
+
+function handle_tap_result()
+{
+  details = result_obj["number"];
+  if (length(result_obj["description"]))
+    details = details " " result_obj["description"]
+
+  if (plan_seen == LATE_PLAN)
+    {
+      details = details " # AFTER LATE PLAN";
+    }
+  else if (result_obj["is_unplanned"])
+    {
+       details = details " # UNPLANNED";
+    }
+  else if (result_obj["number"] != testno)
+    {
+       details = sprintf("%s # OUT-OF-ORDER (expecting %d)",
+                         details, testno);
+    }
+  else if (result_obj["directive"])
+    {
+      details = details " # " result_obj["directive"];
+      if (length(result_obj["explanation"]))
+        details = details " " result_obj["explanation"]
+    }
+
+  report(stringify_result_obj(result_obj), details)
+}
+
+# `skip_reason` should be empty whenever planned > 0.
+function handle_tap_plan(planned, skip_reason)
+{
+  planned += 0 # Avoid getting confused if, say, `planned` is "00"
+  if (length(skip_reason) && planned > 0)
+    abort("in function handle_tap_plan()")
+  if (plan_seen)
+    {
+      # Error, only one plan per stream is acceptable.
+      testsuite_error("multiple test plans")
+      return;
+    }
+  planned_tests = planned
+  # The TAP plan can come before or after *all* the TAP results; we speak
+  # respectively of an "early" or a "late" plan.  If we see the plan line
+  # after at least one TAP result has been seen, assume we have a late
+  # plan; in this case, any further test result seen after the plan will
+  # be flagged as an error.
+  plan_seen = (testno >= 1 ? LATE_PLAN : EARLY_PLAN)
+  # If testno > 0, we have an error ("too many tests run") that will be
+  # automatically dealt with later, so do not worry about it here.  If
+  # $plan_seen is true, we have an error due to a repeated plan, and that
+  # has already been dealt with above.  Otherwise, we have a valid "plan
+  # with SKIP" specification, and should report it as a particular kind
+  # of SKIP result.
+  if (planned == 0 && testno == 0)
+    {
+      if (length(skip_reason))
+        skip_reason = "- "  skip_reason;
+      report("SKIP", skip_reason);
+    }
+}
+
+function extract_tap_comment(line)
+{
+  if (index(line, diag_string) == 1)
+    {
+      # Strip leading `diag_string` from `line`.
+      line = substr(line, length(diag_string) + 1)
+      # And strip any leading and trailing whitespace left.
+      sub("^[ \t]*", "", line)
+      sub("[ \t]*$", "", line)
+      # Return what is left (if any).
+      return line;
+    }
+  return "";
+}
+
+# When this function is called, we know that line is a TAP result line,
+# so that it matches the (perl) RE "^(not )?ok\b".
+function setup_result_obj(line)
+{
+  # Get the result, and remove it from the line.
+  result_obj["is_ok"] = (substr(line, 1, 2) == "ok" ? 1 : 0)
+  sub("^(not )?ok[ \t]*", "", line)
+
+  # If the result has an explicit number, get it and strip it; otherwise,
+  # automatically assign the next test number to it.
+  if (line ~ /^[0-9]+$/ || line ~ /^[0-9]+[^a-zA-Z0-9_]/)
+    {
+      match(line, "^[0-9]+")
+      # The final `+ 0` is to normalize numbers with leading zeros.
+      result_obj["number"] = substr(line, 1, RLENGTH) + 0
+      line = substr(line, RLENGTH + 1)
+    }
+  else
+    {
+      result_obj["number"] = testno
+    }
+
+  if (plan_seen == LATE_PLAN)
+    # No further test results are acceptable after a "late" TAP plan
+    # has been seen.
+    result_obj["is_unplanned"] = 1
+  else if (plan_seen && testno > planned_tests)
+    result_obj["is_unplanned"] = 1
+  else
+    result_obj["is_unplanned"] = 0
+
+  # Strip trailing and leading whitespace.
+  sub("^[ \t]*", "", line)
+  sub("[ \t]*$", "", line)
+
+  # This will have to be corrected if we have a "TODO"/"SKIP" directive.
+  result_obj["description"] = line
+  result_obj["directive"] = ""
+  result_obj["explanation"] = ""
+
+  if (index(line, "#") == 0)
+    return # No possible directive, nothing more to do.
+
+  # Directives are case-insensitive.
+  rx = "[ \t]*#[ \t]*([tT][oO][dD][oO]|[sS][kK][iI][pP])[ \t]*"
+
+  # See whether we have the directive, and if yes, where.
+  pos = match(line, rx "$")
+  if (!pos)
+    pos = match(line, rx "[^a-zA-Z0-9_]")
+
+  # If there was no TAP directive, we have nothing more to do.
+  if (!pos)
+    return
+
+  # Let`s now see if the TAP directive has been escaped.  For example:
+  #  escaped:     ok \# SKIP
+  #  not escaped: ok \\# SKIP
+  #  escaped:     ok \\\\\# SKIP
+  #  not escaped: ok \ # SKIP
+  if (substr(line, pos, 1) == "#")
+    {
+      bslash_count = 0
+      for (i = pos; i > 1 && substr(line, i - 1, 1) == "\\"; i--)
+        bslash_count += 1
+      if (bslash_count % 2)
+        return # Directive was escaped.
+    }
+
+  # Strip the directive and its explanation (if any) from the test
+  # description.
+  result_obj["description"] = substr(line, 1, pos - 1)
+  # Now remove the test description from the line, that has been dealt
+  # with already.
+  line = substr(line, pos)
+  # Strip the directive, and save its value (normalized to upper case).
+  sub("^[ \t]*#[ \t]*", "", line)
+  result_obj["directive"] = toupper(substr(line, 1, 4))
+  line = substr(line, 5)
+  # Now get the explanation for the directive (if any), with leading
+  # and trailing whitespace removed.
+  sub("^[ \t]*", "", line)
+  sub("[ \t]*$", "", line)
+  result_obj["explanation"] = line
+}
+
+function get_test_exit_message(status)
+{
+  if (status == 0)
+    return ""
+  if (status !~ /^[1-9][0-9]*$/)
+    abort("getting exit status")
+  if (status < 127)
+    exit_details = ""
+  else if (status == 127)
+    exit_details = " (command not found?)"
+  else if (status >= 128 && status <= 255)
+    exit_details = sprintf(" (terminated by signal %d?)", status - 128)
+  else if (status > 256 && status <= 384)
+    # We used to report an "abnormal termination" here, but some Korn
+    # shells, when a child process die due to signal number n, can leave
+    # in $? an exit status of 256+n instead of the more standard 128+n.
+    # Apparently, both behaviours are allowed by POSIX (2008), so be
+    # prepared to handle them both.  See also Austing Group report ID
+    # 0000051 <http://www.austingroupbugs.net/view.php?id=51>
+    exit_details = sprintf(" (terminated by signal %d?)", status - 256)
+  else
+    # Never seen in practice.
+    exit_details = " (abnormal termination)"
+  return sprintf("exited with status %d%s", status, exit_details)
+}
+
+function write_test_results()
+{
+  print ":global-test-result: " get_global_test_result() > trs_file
+  print ":recheck: "  yn(must_recheck()) > trs_file
+  print ":copy-in-global-log: " yn(copy_in_global_log()) > trs_file
+  for (i = 0; i < test_results_index; i += 1)
+    print ":test-result: " test_results_list[i] > trs_file
+  close(trs_file);
+}
+
+BEGIN {
+
+## ------- ##
+##  SETUP  ##
+## ------- ##
+
+'"$init_colors"'
+
+# Properly initialized once the TAP plan is seen.
+planned_tests = 0
+
+COOKED_PASS = expect_failure ? "XPASS": "PASS";
+COOKED_FAIL = expect_failure ? "XFAIL": "FAIL";
+
+# Enumeration-like constants to remember which kind of plan (if any)
+# has been seen.  It is important that NO_PLAN evaluates "false" as
+# a boolean.
+NO_PLAN = 0
+EARLY_PLAN = 1
+LATE_PLAN = 2
+
+testno = 0     # Number of test results seen so far.
+bailed_out = 0 # Whether a "Bail out!" directive has been seen.
+
+# Whether the TAP plan has been seen or not, and if yes, which kind
+# it is ("early" is seen before any test result, "late" otherwise).
+plan_seen = NO_PLAN
+
+## --------- ##
+##  PARSING  ##
+## --------- ##
+
+is_first_read = 1
+
+while (1)
+  {
+    # Involutions required so that we are able to read the exit status
+    # from the last input line.
+    st = getline
+    if (st < 0) # I/O error.
+      fatal("I/O error while reading from input stream")
+    else if (st == 0) # End-of-input
+      {
+        if (is_first_read)
+          abort("in input loop: only one input line")
+        break
+      }
+    if (is_first_read)
+      {
+        is_first_read = 0
+        nextline = $0
+        continue
+      }
+    else
+      {
+        curline = nextline
+        nextline = $0
+        $0 = curline
+      }
+    # Copy any input line verbatim into the log file.
+    print | "cat >&3"
+    # Parsing of TAP input should stop after a "Bail out!" directive.
+    if (bailed_out)
+      continue
+
+    # TAP test result.
+    if ($0 ~ /^(not )?ok$/ || $0 ~ /^(not )?ok[^a-zA-Z0-9_]/)
+      {
+        testno += 1
+        setup_result_obj($0)
+        handle_tap_result()
+      }
+    # TAP plan (normal or "SKIP" without explanation).
+    else if ($0 ~ /^1\.\.[0-9]+[ \t]*$/)
+      {
+        # The next two lines will put the number of planned tests in $0.
+        sub("^1\\.\\.", "")
+        sub("[^0-9]*$", "")
+        handle_tap_plan($0, "")
+        continue
+      }
+    # TAP "SKIP" plan, with an explanation.
+    else if ($0 ~ /^1\.\.0+[ \t]*#/)
+      {
+        # The next lines will put the skip explanation in $0, stripping
+        # any leading and trailing whitespace.  This is a little more
+        # tricky in truth, since we want to also strip a potential leading
+        # "SKIP" string from the message.
+        sub("^[^#]*#[ \t]*(SKIP[: \t][ \t]*)?", "")
+        sub("[ \t]*$", "");
+        handle_tap_plan(0, $0)
+      }
+    # "Bail out!" magic.
+    # Older versions of prove and TAP::Harness (e.g., 3.17) did not
+    # recognize a "Bail out!" directive when preceded by leading
+    # whitespace, but more modern versions (e.g., 3.23) do.  So we
+    # emulate the latter, "more modern" behaviour.
+    else if ($0 ~ /^[ \t]*Bail out!/)
+      {
+        bailed_out = 1
+        # Get the bailout message (if any), with leading and trailing
+        # whitespace stripped.  The message remains stored in `$0`.
+        sub("^[ \t]*Bail out![ \t]*", "");
+        sub("[ \t]*$", "");
+        # Format the error message for the
+        bailout_message = "Bail out!"
+        if (length($0))
+          bailout_message = bailout_message " " $0
+        testsuite_error(bailout_message)
+      }
+    # Maybe we have too look for dianogtic comments too.
+    else if (comments != 0)
+      {
+        comment = extract_tap_comment($0);
+        if (length(comment))
+          report("#", comment);
+      }
+  }
+
+## -------- ##
+##  FINISH  ##
+## -------- ##
+
+# A "Bail out!" directive should cause us to ignore any following TAP
+# error, as well as a non-zero exit status from the TAP producer.
+if (!bailed_out)
+  {
+    if (!plan_seen)
+      {
+        testsuite_error("missing test plan")
+      }
+    else if (planned_tests != testno)
+      {
+        bad_amount = testno > planned_tests ? "many" : "few"
+        testsuite_error(sprintf("too %s tests run (expected %d, got %d)",
+                                bad_amount, planned_tests, testno))
+      }
+    if (!ignore_exit)
+      {
+        # Fetch exit status from the last line.
+        exit_message = get_test_exit_message(nextline)
+        if (exit_message)
+          testsuite_error(exit_message)
+      }
+  }
+
+write_test_results()
+
+exit 0
+
+} # End of "BEGIN" block.
+'
+
+# TODO: document that we consume the file descriptor 3 :-(
+} 3>"$log_file"
+
+test $? -eq 0 || fatal "I/O or internal error"
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:
diff --git a/libssh2/test-driver b/libssh2/test-driver
index 9759384a..be73b80a 100755
--- a/libssh2/test-driver
+++ b/libssh2/test-driver
@@ -3,7 +3,7 @@
 
 scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 2011-2020 Free Software Foundation, Inc.
+# Copyright (C) 2011-2021 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -105,8 +105,11 @@ trap "st=130; $do_exit" 2
 trap "st=141; $do_exit" 13
 trap "st=143; $do_exit" 15
 
-# Test script is run here.
-"$@" >$log_file 2>&1
+# Test script is run here. We create the file first, then append to it,
+# to ameliorate tests themselves also writing to the log file. Our tests
+# don't, but others can (automake bug#35762).
+: >"$log_file"
+"$@" >>"$log_file" 2>&1
 estatus=$?
 
 if test $enable_hard_errors = no && test $estatus -eq 99; then
@@ -128,7 +131,7 @@ esac
 # know whether the test passed or failed simply by looking at the '.log'
 # file, without the need of also peaking into the corresponding '.trs'
 # file (automake bug#11814).
-echo "$res $test_name (exit status: $estatus)" >>$log_file
+echo "$res $test_name (exit status: $estatus)" >>"$log_file"
 
 # Report outcome to console.
 echo "${col}${res}${std}: $test_name"
diff --git a/libssh2/tests/CMakeLists.txt b/libssh2/tests/CMakeLists.txt
index cf4b3f76..07acdee1 100644
--- a/libssh2/tests/CMakeLists.txt
+++ b/libssh2/tests/CMakeLists.txt
@@ -1,4 +1,5 @@
-# Copyright (c) 2014-2016 Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# Copyright (C) Viktor Szakats
 #
 # Redistribution and use in source and binary forms,
 # with or without modification, are permitted provided
@@ -32,155 +33,146 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 # USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 # OF SUCH DAMAGE.
+#
+# SPDX-License-Identifier: BSD-3-Clause
 
-include(CheckIncludeFiles)
-include(CheckFunctionExists)
-include(CheckSymbolExists)
-include(BundleUtilities)
 include(CopyRuntimeDependencies)
-include(SocketLibraries)
-
-## Platform checks
-check_include_files(inttypes.h HAVE_INTTYPES_H)
-check_include_files(unistd.h HAVE_UNISTD_H)
-check_include_files(sys/param.h HAVE_SYS_PARAM_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(arpa/inet.h HAVE_ARPA_INET_H)
-check_include_files(windows.h HAVE_WINDOWS_H)
-check_include_files(winsock2.h HAVE_WINSOCK2_H)
-check_include_files(netinet/in.h HAVE_NETINET_IN_H)
-configure_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/libssh2_config_cmake.h.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/libssh2_config.h")
-append_needed_socket_libraries(LIBRARIES)
-
-## Cryptography backend choice
-
-set(CRYPTO_BACKEND
-  ""
-  CACHE
-  STRING
-  "The backend to use for cryptography: OpenSSL, Libgcrypt or WinCNG, mbedTLS
-or empty to try any available")
-
-# If the crypto backend was given, rather than searching for the first
-# we are able to find, the find_package commands must abort configuration
-# and report to the user.
-if(CRYPTO_BACKEND)
-  set(SPECIFIC_CRYPTO_REQUIREMENT REQUIRED)
-endif()
-
-if(CRYPTO_BACKEND STREQUAL "OpenSSL" OR NOT CRYPTO_BACKEND)
-
-  find_package(OpenSSL ${SPECIFIC_CRYPTO_REQUIREMENT})
 
-  if(OPENSSL_FOUND)
-    set(CRYPTO_BACKEND "OpenSSL")
+list(APPEND LIBSSH2_LIBS ${LIBSSH2_LIBS_SOCKET})
+
+transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+# Get 'DOCKER_TESTS', 'DOCKER_TESTS_STATIC', 'STANDALONE_TESTS', 'STANDALONE_TESTS_STATIC', 'SSHD_TESTS',
+# 'librunner_la_SOURCES' variables
+include("${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
+list(APPEND DOCKER_TESTS ${DOCKER_TESTS_STATIC})
+list(APPEND STANDALONE_TESTS ${STANDALONE_TESTS_STATIC})
+
+if(CMAKE_COMPILER_IS_GNUCC)
+  find_program(GCOV_PATH "gcov")
+  if(GCOV_PATH)
+    set(_gcov_cflags "-g" "--coverage")
+    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
+      set(_gcov_cflags "${_gcov_cflags} -fprofile-abs-path")
+    endif()
   endif()
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "Libgcrypt" OR NOT CRYPTO_BACKEND)
-
-  find_package(Libgcrypt ${SPECIFIC_CRYPTO_REQUIREMENT})
+option(RUN_SSHD_TESTS "Run tests requiring sshd" ON)
 
-  if(LIBGCRYPT_FOUND)
-    set(CRYPTO_BACKEND "Libgcrypt")
+find_program(SH_EXECUTABLE "sh")
+mark_as_advanced(SH_EXECUTABLE)
+if(SH_EXECUTABLE)
+  if(RUN_SSHD_TESTS)
+    find_program(SSHD_EXECUTABLE "sshd")
+    mark_as_advanced(SSHD_EXECUTABLE)
   endif()
+
+  add_test(NAME mansyntax COMMAND ${SH_EXECUTABLE} -c "${CMAKE_CURRENT_SOURCE_DIR}/mansyntax.sh")
 endif()
 
-if(CRYPTO_BACKEND STREQUAL "WinCNG" OR NOT CRYPTO_BACKEND)
+add_library(runner STATIC ${librunner_la_SOURCES})
+target_compile_definitions(runner PRIVATE "${CRYPTO_BACKEND_DEFINE}")
+target_include_directories(runner PRIVATE
+  "${CMAKE_CURRENT_BINARY_DIR}/../src"
+  "../src"
+  "../include"
+  "${CRYPTO_BACKEND_INCLUDE_DIR}")
+target_link_libraries(runner PRIVATE libssh2)
+
+foreach(_test IN LISTS DOCKER_TESTS STANDALONE_TESTS SSHD_TESTS)
+  if(NOT ";${DOCKER_TESTS_STATIC};${STANDALONE_TESTS_STATIC};" MATCHES ";${_test};")
+    set(_lib_for_tests ${LIB_SELECTED})
+  elseif(TARGET ${LIB_STATIC})
+    set(_lib_for_tests ${LIB_STATIC})
+  else()
+    unset(_lib_for_tests)
+    message(STATUS "Skip test requiring static libssh2 lib: ${_test}")
+  endif()
 
-  # The check actually compiles the header.  This requires windows.h.
-  check_include_files("windows.h;bcrypt.h" HAVE_BCRYPT_H)
+  # We support the same target as both Docker and SSHD test. Build those just once.
+  # Skip building tests that require the static lib when the static lib is disabled.
+  if(NOT TARGET ${_test} AND _lib_for_tests)
+    add_executable(${_test} "${_test}.c")
+    target_compile_definitions(${_test} PRIVATE "${CRYPTO_BACKEND_DEFINE}")
+    target_include_directories(${_test} PRIVATE
+      "${CMAKE_CURRENT_BINARY_DIR}/../src"
+      "../src"
+      "../include"
+      "${CRYPTO_BACKEND_INCLUDE_DIR}")
+    set_target_properties(${_test} PROPERTIES UNITY_BUILD OFF)
+
+    # build a single test with gcov
+    if(GCOV_PATH AND _test STREQUAL "test_auth_keyboard_info_request" AND TARGET ${LIB_STATIC})
+      target_compile_options(${_test} BEFORE PRIVATE ${_gcov_cflags})
+      target_link_libraries(${_test} runner ${_lib_for_tests} ${LIBSSH2_LIBS} "gcov")
+    else()
+      target_link_libraries(${_test} runner ${_lib_for_tests} ${LIBSSH2_LIBS})
+    endif()
 
-  if(HAVE_BCRYPT_H)
-    set(CRYPTO_BACKEND "WinCNG")
+    list(APPEND TEST_TARGETS ${_test})
   endif()
-endif()
+endforeach()
 
-if(CRYPTO_BACKEND STREQUAL "mbedTLS" OR NOT CRYPTO_BACKEND)
+option(RUN_DOCKER_TESTS "Run tests requiring Docker" ON)
 
-  find_package(mbedTLS ${SPECIFIC_CRYPTO_REQUIREMENT})
+if(RUN_DOCKER_TESTS)
+  foreach(_test IN LISTS DOCKER_TESTS)
+    if(TARGET ${_test})
+      add_test(NAME ${_test} COMMAND "$<TARGET_FILE:${_test}>")
+      set_property(TEST ${_test} APPEND PROPERTY ENVIRONMENT "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
+    endif()
+  endforeach()
+endif()
 
-  if(MBEDTLS_FOUND)
-    set(CRYPTO_BACKEND "mbedTLS")
+foreach(_test IN LISTS STANDALONE_TESTS)
+  if(TARGET ${_test})
+    add_test(NAME ${_test} COMMAND "$<TARGET_FILE:${_test}>")
+    set_property(TEST ${_test} APPEND PROPERTY ENVIRONMENT "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
   endif()
-endif()
+endforeach()
 
-set(TESTS
-  hostkey
-  hostkey_hash
-  password_auth_succeeds_with_correct_credentials
-  password_auth_fails_with_wrong_password
-  password_auth_fails_with_wrong_username
-  public_key_auth_fails_with_wrong_key
-  public_key_auth_succeeds_with_correct_rsa_key
-  public_key_auth_succeeds_with_correct_encrypted_rsa_key
-  keyboard_interactive_auth_fails_with_wrong_response
-  keyboard_interactive_auth_succeeds_with_correct_response
-  agent_forward_succeeds
-  )
-
-if(CRYPTO_BACKEND STREQUAL "OpenSSL")
-    list(APPEND TESTS
-      public_key_auth_succeeds_with_correct_rsa_openssh_key
-    )
-    if(OPENSSL_VERSION VERSION_GREATER "1.1.0")
-      list(APPEND TESTS
-        public_key_auth_succeeds_with_correct_ed25519_key
-        public_key_auth_succeeds_with_correct_encrypted_ed25519_key
-        public_key_auth_succeeds_with_correct_ed25519_key_from_mem
-        public_key_auth_succeeds_with_correct_ecdsa_key
-        public_key_auth_succeeds_with_correct_signed_ecdsa_key
-       )
+if(RUN_SSHD_TESTS AND SSHD_EXECUTABLE)
+  unset(_sshd_test_targets)
+  foreach(_test IN LISTS SSHD_TESTS)
+    if(TARGET ${_test})
+      set(_sshd_test_targets "${_sshd_test_targets} $<TARGET_FILE:${_test}>")
     endif()
-endif()
+  endforeach()
 
-if(NOT CRYPTO_BACKEND STREQUAL "mbedTLS")
-  list(APPEND TESTS
-    public_key_auth_succeeds_with_correct_dsa_key
-    )
+  if(_sshd_test_targets)
+    add_test(NAME test_sshd COMMAND ${SH_EXECUTABLE} -c "${CMAKE_CURRENT_SOURCE_DIR}/test_sshd.test ${_sshd_test_targets}")
+    set_property(TEST test_sshd APPEND PROPERTY ENVIRONMENT "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
+    set_property(TEST test_sshd APPEND PROPERTY ENVIRONMENT "SSHD=${SSHD_EXECUTABLE}")
+  endif()
 endif()
 
-add_library(openssh_fixture STATIC openssh_fixture.h openssh_fixture.c)
-target_link_libraries(openssh_fixture ${LIBRARIES})
-target_include_directories(openssh_fixture PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-
-add_library(session_fixture STATIC session_fixture.h session_fixture.c)
-target_link_libraries(session_fixture ${LIBRARIES} openssh_fixture libssh2)
-target_include_directories(session_fixture PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-
-add_library(runner STATIC runner.c)
-target_link_libraries(runner session_fixture)
-target_include_directories(runner PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
+if(RUN_DOCKER_TESTS)
+  # CRYPT/MAC algo tests
+  file(READ "test_read_algos.txt" _algo_tests)
+  string(REGEX REPLACE "\\\n" ";" _algo_tests ${_algo_tests})
+  foreach(_test IN LISTS _algo_tests)
+    if(_test)
+      set(_testname "test_read-${_test}")
+      add_test(NAME ${_testname} COMMAND "$<TARGET_FILE:test_read>")
+      set_property(TEST ${_testname} APPEND PROPERTY ENVIRONMENT "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
+      if(_test MATCHES "mac-")
+        set_property(TEST ${_testname} APPEND PROPERTY ENVIRONMENT "FIXTURE_TEST_MAC=${_test}")
+      else()
+        set_property(TEST ${_testname} APPEND PROPERTY ENVIRONMENT "FIXTURE_TEST_CRYPT=${_test}")
+      endif()
+    endif()
+  endforeach()
+endif()
 
-foreach(test ${TESTS})
-  add_executable(test_${test} test_${test}.c)
-  target_link_libraries(test_${test} libssh2 runner ${LIBRARIES})
-  target_include_directories(test_${test} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
-  list(APPEND TEST_TARGETS test_${test})
-  add_definitions(-DFIXTURE_WORKDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+add_custom_target(coverage
+  COMMAND gcovr --root "${PROJECT_SOURCE_DIR}" --exclude tests/*
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/coverage"
+  COMMAND gcovr --root "${PROJECT_SOURCE_DIR}" --exclude tests/* --html-details --output "${CMAKE_CURRENT_BINARY_DIR}/coverage/index.html")
 
-  add_test(
-    NAME test_${test} COMMAND $<TARGET_FILE:test_${test}>
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-endforeach()
+add_custom_target(clean-coverage
+  COMMAND rm -rf "${CMAKE_CURRENT_BINARY_DIR}/coverage")
 
 add_target_to_copy_dependencies(
   TARGET copy_test_dependencies
   DEPENDENCIES ${RUNTIME_DEPENDENCIES}
   BEFORE_TARGETS ${TEST_TARGETS})
-
-
-# TODO convert mansyntax.sh into CMake script.
-# XXX Just because we can find all three programs, doesn't mean sh can
-# find man and grep
-find_program(SH_EXECUTABLE sh)
-find_program(MAN_EXECUTABLE man)
-find_program(GREP_EXECUTABLE grep)
-mark_as_advanced(SH_EXECUTABLE MAN_EXECUTABLE GREP_EXECUTABLE)
-if(SH_EXECUTABLE AND MAN_EXECUTABLE AND GREP_EXECUTABLE)
-  set(cmd "srcdir=${CMAKE_CURRENT_SOURCE_DIR}")
-  set(cmd "${cmd} ${CMAKE_CURRENT_SOURCE_DIR}/mansyntax.sh")
-  add_test(mansyntax ${SH_EXECUTABLE} -c "${cmd}")
-endif()
diff --git a/libssh2/tests/Makefile.am b/libssh2/tests/Makefile.am
index 27ddc2df..f3609a15 100644
--- a/libssh2/tests/Makefile.am
+++ b/libssh2/tests/Makefile.am
@@ -1,78 +1,55 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 SUBDIRS = ossfuzz
 
-AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/include -I$(top_builddir)/src
-LDADD = ../src/libssh2.la
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src -I$(top_srcdir)/include
 
-if SSHD
-noinst_PROGRAMS = ssh2
-ssh2_SOURCES = ssh2.c
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
+
+# Get DOCKER_TESTS, DOCKER_TESTS_STATIC, STANDALONE_TESTS, STANDALONE_TESTS_STATOC, SSHD_TESTS,
+# librunner_la_SOURCES defines and *_LDFLAGS for statically linked tests.
+include Makefile.inc
+
+if HAVE_LIB_STATIC
+DOCKER_TESTS += $(DOCKER_TESTS_STATIC)
+STANDALONE_TESTS += $(STANDALONE_TESTS_STATIC)
+endif
+
+# Some tests rely on the 'srcdir' env. Set by autotools automatically.
+TESTS_ENVIRONMENT =
+
+# Tests to run
+TESTS = mansyntax.sh
+
+if RUN_DOCKER_TESTS
+TESTS += $(DOCKER_TESTS)
 endif
 
-ctests = simple$(EXEEXT)
-TESTS = $(ctests) mansyntax.sh
+TESTS += $(STANDALONE_TESTS)
+
+# TAP tests
+TEST_EXTENSIONS = .test
+# 'TEST' in 'TEST_LOG_DRIVER' is the test extension in uppercase.
+TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/tap-driver.sh
+
+TESTS_ENVIRONMENT += EXEEXT=$(EXEEXT)
+if RUN_SSHD_TESTS
 if SSHD
-TESTS += ssh2.sh
+TESTS += test_sshd.test
+TESTS_ENVIRONMENT += SSHD="$(SSHD)"
 endif
-check_PROGRAMS = $(ctests)
+endif
+if RUN_DOCKER_TESTS
+TESTS += test_read_algos.test
+endif
+
+# Tests to build
+check_PROGRAMS = $(DOCKER_TESTS) $(STANDALONE_TESTS) $(SSHD_TESTS)
 
-TESTS_ENVIRONMENT = SSHD=$(SSHD) EXEEXT=$(EXEEXT)
-TESTS_ENVIRONMENT += srcdir=$(top_srcdir)/tests builddir=$(top_builddir)/tests
+# Internal library used by tests
+LDADD = librunner.la
+check_LTLIBRARIES = librunner.la
 
-EXTRA_DIST =                                                           \
- CMakeLists.txt                                                        \
- etc/host                                                              \
- etc/host.pub                                                          \
- etc/user                                                              \
- etc/user.pub                                                          \
- key_dsa                                                               \
- key_dsa.pub                                                           \
- key_dsa_wrong                                                         \
- key_dsa_wrong.pub                                                     \
- key_ecdsa                                                             \
- key_ecdsa.pub                                                         \
- key_ed25519                                                           \
- key_ed25519.pub                                                       \
- key_ed25519_encrypted                                                 \
- key_ed25519_encrypted.pub                                             \
- key_rsa                                                               \
- key_rsa.pub                                                           \
- key_rsa_encrypted                                                     \
- key_rsa_encrypted.pub                                                 \
- key_rsa_openssh                                                       \
- key_rsa_openssh.pub                                                   \
- libssh2_config_cmake.h.in                                             \
- mansyntax.sh                                                          \
- openssh_fixture.c                                                     \
- openssh_fixture.h                                                     \
- openssh_server/Dockerfile                                             \
- openssh_server/authorized_keys                                        \
- openssh_server/ca_ecdsa                                               \
- openssh_server/ca_ecdsa.pub                                           \
- openssh_server/ssh_host_ecdsa_key                                     \
- openssh_server/ssh_host_ed25519_key                                   \
- openssh_server/ssh_host_rsa_key                                       \
- runner.c                                                              \
- session_fixture.c                                                     \
- session_fixture.h                                                     \
- simple.c                                                              \
- ssh2.c                                                                \
- ssh2.sh                                                               \
- sshd_fixture.sh.in                                                    \
- test_agent_forward_succeeds.c                                         \
- test_hostkey.c                                                        \
- test_hostkey_hash.c                                                   \
- test_keyboard_interactive_auth_fails_with_wrong_response.c            \
- test_keyboard_interactive_auth_succeeds_with_correct_response.c       \
- test_password_auth_fails_with_wrong_password.c                        \
- test_password_auth_fails_with_wrong_username.c                        \
- test_password_auth_succeeds_with_correct_credentials.c                \
- test_public_key_auth_fails_with_wrong_key.c                           \
- test_public_key_auth_succeeds_with_correct_dsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_ed25519_key.c              \
- test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c     \
- test_public_key_auth_succeeds_with_correct_ecdsa_key.c                \
- test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c         \
- test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c    \
- test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c        \
- test_public_key_auth_succeeds_with_correct_rsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
+# This must be last in the list so it resolves symbols in previous libraries
+LDADD += ../src/libssh2.la
diff --git a/libssh2/tests/Makefile.in b/libssh2/tests/Makefile.in
index e5eb881a..5e56ac9c 100644
--- a/libssh2/tests/Makefile.in
+++ b/libssh2/tests/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -14,6 +14,8 @@
 
 @SET_MAKE@
 
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
@@ -88,16 +90,26 @@ PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
-@SSHD_TRUE@noinst_PROGRAMS = ssh2$(EXEEXT)
-@SSHD_TRUE@am__append_1 = ssh2.sh
+
+# Get DOCKER_TESTS, DOCKER_TESTS_STATIC, STANDALONE_TESTS, STANDALONE_TESTS_STATOC, SSHD_TESTS,
+# librunner_la_SOURCES defines and *_LDFLAGS for statically linked tests.
+@HAVE_LIB_STATIC_TRUE@am__append_1 = $(DOCKER_TESTS_STATIC)
+@HAVE_LIB_STATIC_TRUE@am__append_2 = $(STANDALONE_TESTS_STATIC)
+TESTS = mansyntax.sh $(am__EXEEXT_8) $(am__EXEEXT_6) $(am__append_4) \
+	$(am__append_6)
+@RUN_DOCKER_TESTS_TRUE@am__append_3 = $(DOCKER_TESTS)
+@RUN_SSHD_TESTS_TRUE@@SSHD_TRUE@am__append_4 = test_sshd.test
+@RUN_SSHD_TESTS_TRUE@@SSHD_TRUE@am__append_5 = SSHD="$(SSHD)"
+@RUN_DOCKER_TESTS_TRUE@am__append_6 = test_read_algos.test
+check_PROGRAMS = $(am__EXEEXT_3) $(am__EXEEXT_6) $(am__EXEEXT_7)
 subdir = tests
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
@@ -105,20 +117,191 @@ mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/src/libssh2_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
-PROGRAMS = $(noinst_PROGRAMS)
-simple_SOURCES = simple.c
-simple_OBJECTS = simple.$(OBJEXT)
-simple_LDADD = $(LDADD)
-simple_DEPENDENCIES = ../src/libssh2.la
+am__EXEEXT_1 = test_auth_keyboard_info_request$(EXEEXT) \
+	test_hostkey$(EXEEXT)
+@HAVE_LIB_STATIC_TRUE@am__EXEEXT_2 = $(am__EXEEXT_1)
+am__EXEEXT_3 = test_aa_warmup$(EXEEXT) test_agent_forward_ok$(EXEEXT) \
+	test_auth_keyboard_fail$(EXEEXT) \
+	test_auth_keyboard_ok$(EXEEXT) \
+	test_auth_password_fail_password$(EXEEXT) \
+	test_auth_password_fail_username$(EXEEXT) \
+	test_auth_password_ok$(EXEEXT) test_auth_pubkey_fail$(EXEEXT) \
+	test_auth_pubkey_ok_dsa$(EXEEXT) \
+	test_auth_pubkey_ok_ecdsa$(EXEEXT) \
+	test_auth_pubkey_ok_ecdsa_signed$(EXEEXT) \
+	test_auth_pubkey_ok_ed25519$(EXEEXT) \
+	test_auth_pubkey_ok_ed25519_encrypted$(EXEEXT) \
+	test_auth_pubkey_ok_ed25519_mem$(EXEEXT) \
+	test_auth_pubkey_ok_rsa$(EXEEXT) \
+	test_auth_pubkey_ok_rsa_aes256gcm$(EXEEXT) \
+	test_auth_pubkey_ok_rsa_encrypted$(EXEEXT) \
+	test_auth_pubkey_ok_rsa_openssh$(EXEEXT) \
+	test_auth_pubkey_ok_rsa_signed$(EXEEXT) \
+	test_auth_pubkey_ok_rsa_sha2_256_signed$(EXEEXT) \
+	test_hostkey_hash$(EXEEXT) test_read$(EXEEXT) $(am__EXEEXT_2)
+am__EXEEXT_4 = test_simple$(EXEEXT)
+@HAVE_LIB_STATIC_TRUE@am__EXEEXT_5 = $(am__EXEEXT_4)
+am__EXEEXT_6 = $(am__EXEEXT_5)
+am__EXEEXT_7 = test_ssh2$(EXEEXT) test_auth_pubkey_ok_ed25519$(EXEEXT)
+librunner_la_LIBADD =
+am_librunner_la_OBJECTS = runner.lo session_fixture.lo \
+	openssh_fixture.lo
+librunner_la_OBJECTS = $(am_librunner_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
-am__ssh2_SOURCES_DIST = ssh2.c
-@SSHD_TRUE@am_ssh2_OBJECTS = ssh2.$(OBJEXT)
-ssh2_OBJECTS = $(am_ssh2_OBJECTS)
-ssh2_LDADD = $(LDADD)
-ssh2_DEPENDENCIES = ../src/libssh2.la
+test_aa_warmup_SOURCES = test_aa_warmup.c
+test_aa_warmup_OBJECTS = test_aa_warmup.$(OBJEXT)
+test_aa_warmup_LDADD = $(LDADD)
+test_aa_warmup_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_agent_forward_ok_SOURCES = test_agent_forward_ok.c
+test_agent_forward_ok_OBJECTS = test_agent_forward_ok.$(OBJEXT)
+test_agent_forward_ok_LDADD = $(LDADD)
+test_agent_forward_ok_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_keyboard_fail_SOURCES = test_auth_keyboard_fail.c
+test_auth_keyboard_fail_OBJECTS = test_auth_keyboard_fail.$(OBJEXT)
+test_auth_keyboard_fail_LDADD = $(LDADD)
+test_auth_keyboard_fail_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_keyboard_info_request_SOURCES =  \
+	test_auth_keyboard_info_request.c
+test_auth_keyboard_info_request_OBJECTS =  \
+	test_auth_keyboard_info_request.$(OBJEXT)
+test_auth_keyboard_info_request_LDADD = $(LDADD)
+test_auth_keyboard_info_request_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_keyboard_info_request_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+	$(AM_CFLAGS) $(CFLAGS) \
+	$(test_auth_keyboard_info_request_LDFLAGS) $(LDFLAGS) -o $@
+test_auth_keyboard_ok_SOURCES = test_auth_keyboard_ok.c
+test_auth_keyboard_ok_OBJECTS = test_auth_keyboard_ok.$(OBJEXT)
+test_auth_keyboard_ok_LDADD = $(LDADD)
+test_auth_keyboard_ok_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_password_fail_password_SOURCES =  \
+	test_auth_password_fail_password.c
+test_auth_password_fail_password_OBJECTS =  \
+	test_auth_password_fail_password.$(OBJEXT)
+test_auth_password_fail_password_LDADD = $(LDADD)
+test_auth_password_fail_password_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_password_fail_username_SOURCES =  \
+	test_auth_password_fail_username.c
+test_auth_password_fail_username_OBJECTS =  \
+	test_auth_password_fail_username.$(OBJEXT)
+test_auth_password_fail_username_LDADD = $(LDADD)
+test_auth_password_fail_username_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_password_ok_SOURCES = test_auth_password_ok.c
+test_auth_password_ok_OBJECTS = test_auth_password_ok.$(OBJEXT)
+test_auth_password_ok_LDADD = $(LDADD)
+test_auth_password_ok_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_pubkey_fail_SOURCES = test_auth_pubkey_fail.c
+test_auth_pubkey_fail_OBJECTS = test_auth_pubkey_fail.$(OBJEXT)
+test_auth_pubkey_fail_LDADD = $(LDADD)
+test_auth_pubkey_fail_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_pubkey_ok_dsa_SOURCES = test_auth_pubkey_ok_dsa.c
+test_auth_pubkey_ok_dsa_OBJECTS = test_auth_pubkey_ok_dsa.$(OBJEXT)
+test_auth_pubkey_ok_dsa_LDADD = $(LDADD)
+test_auth_pubkey_ok_dsa_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_pubkey_ok_ecdsa_SOURCES = test_auth_pubkey_ok_ecdsa.c
+test_auth_pubkey_ok_ecdsa_OBJECTS =  \
+	test_auth_pubkey_ok_ecdsa.$(OBJEXT)
+test_auth_pubkey_ok_ecdsa_LDADD = $(LDADD)
+test_auth_pubkey_ok_ecdsa_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_ecdsa_signed_SOURCES =  \
+	test_auth_pubkey_ok_ecdsa_signed.c
+test_auth_pubkey_ok_ecdsa_signed_OBJECTS =  \
+	test_auth_pubkey_ok_ecdsa_signed.$(OBJEXT)
+test_auth_pubkey_ok_ecdsa_signed_LDADD = $(LDADD)
+test_auth_pubkey_ok_ecdsa_signed_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_ed25519_SOURCES = test_auth_pubkey_ok_ed25519.c
+test_auth_pubkey_ok_ed25519_OBJECTS =  \
+	test_auth_pubkey_ok_ed25519.$(OBJEXT)
+test_auth_pubkey_ok_ed25519_LDADD = $(LDADD)
+test_auth_pubkey_ok_ed25519_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_ed25519_encrypted_SOURCES =  \
+	test_auth_pubkey_ok_ed25519_encrypted.c
+test_auth_pubkey_ok_ed25519_encrypted_OBJECTS =  \
+	test_auth_pubkey_ok_ed25519_encrypted.$(OBJEXT)
+test_auth_pubkey_ok_ed25519_encrypted_LDADD = $(LDADD)
+test_auth_pubkey_ok_ed25519_encrypted_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_ed25519_mem_SOURCES =  \
+	test_auth_pubkey_ok_ed25519_mem.c
+test_auth_pubkey_ok_ed25519_mem_OBJECTS =  \
+	test_auth_pubkey_ok_ed25519_mem.$(OBJEXT)
+test_auth_pubkey_ok_ed25519_mem_LDADD = $(LDADD)
+test_auth_pubkey_ok_ed25519_mem_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_rsa_SOURCES = test_auth_pubkey_ok_rsa.c
+test_auth_pubkey_ok_rsa_OBJECTS = test_auth_pubkey_ok_rsa.$(OBJEXT)
+test_auth_pubkey_ok_rsa_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_auth_pubkey_ok_rsa_aes256gcm_SOURCES =  \
+	test_auth_pubkey_ok_rsa_aes256gcm.c
+test_auth_pubkey_ok_rsa_aes256gcm_OBJECTS =  \
+	test_auth_pubkey_ok_rsa_aes256gcm.$(OBJEXT)
+test_auth_pubkey_ok_rsa_aes256gcm_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_aes256gcm_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_rsa_encrypted_SOURCES =  \
+	test_auth_pubkey_ok_rsa_encrypted.c
+test_auth_pubkey_ok_rsa_encrypted_OBJECTS =  \
+	test_auth_pubkey_ok_rsa_encrypted.$(OBJEXT)
+test_auth_pubkey_ok_rsa_encrypted_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_encrypted_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_rsa_openssh_SOURCES =  \
+	test_auth_pubkey_ok_rsa_openssh.c
+test_auth_pubkey_ok_rsa_openssh_OBJECTS =  \
+	test_auth_pubkey_ok_rsa_openssh.$(OBJEXT)
+test_auth_pubkey_ok_rsa_openssh_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_openssh_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_rsa_sha2_256_signed_SOURCES =  \
+	test_auth_pubkey_ok_rsa_sha2_256_signed.c
+test_auth_pubkey_ok_rsa_sha2_256_signed_OBJECTS =  \
+	test_auth_pubkey_ok_rsa_sha2_256_signed.$(OBJEXT)
+test_auth_pubkey_ok_rsa_sha2_256_signed_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_sha2_256_signed_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_auth_pubkey_ok_rsa_signed_SOURCES =  \
+	test_auth_pubkey_ok_rsa_signed.c
+test_auth_pubkey_ok_rsa_signed_OBJECTS =  \
+	test_auth_pubkey_ok_rsa_signed.$(OBJEXT)
+test_auth_pubkey_ok_rsa_signed_LDADD = $(LDADD)
+test_auth_pubkey_ok_rsa_signed_DEPENDENCIES = librunner.la \
+	../src/libssh2.la
+test_hostkey_SOURCES = test_hostkey.c
+test_hostkey_OBJECTS = test_hostkey.$(OBJEXT)
+test_hostkey_LDADD = $(LDADD)
+test_hostkey_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_hostkey_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(test_hostkey_LDFLAGS) $(LDFLAGS) -o $@
+test_hostkey_hash_SOURCES = test_hostkey_hash.c
+test_hostkey_hash_OBJECTS = test_hostkey_hash.$(OBJEXT)
+test_hostkey_hash_LDADD = $(LDADD)
+test_hostkey_hash_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_read_SOURCES = test_read.c
+test_read_OBJECTS = test_read.$(OBJEXT)
+test_read_LDADD = $(LDADD)
+test_read_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_simple_SOURCES = test_simple.c
+test_simple_OBJECTS = test_simple.$(OBJEXT)
+test_simple_LDADD = $(LDADD)
+test_simple_DEPENDENCIES = librunner.la ../src/libssh2.la
+test_simple_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(test_simple_LDFLAGS) $(LDFLAGS) -o $@
+test_ssh2_SOURCES = test_ssh2.c
+test_ssh2_OBJECTS = test_ssh2.$(OBJEXT)
+test_ssh2_LDADD = $(LDADD)
+test_ssh2_DEPENDENCIES = librunner.la ../src/libssh2.la
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
@@ -134,7 +317,32 @@ am__v_at_1 =
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/src
 depcomp = $(SHELL) $(top_srcdir)/depcomp
 am__maybe_remake_depfiles = depfiles
-am__depfiles_remade = ./$(DEPDIR)/simple.Po ./$(DEPDIR)/ssh2.Po
+am__depfiles_remade = ./$(DEPDIR)/openssh_fixture.Plo \
+	./$(DEPDIR)/runner.Plo ./$(DEPDIR)/session_fixture.Plo \
+	./$(DEPDIR)/test_aa_warmup.Po \
+	./$(DEPDIR)/test_agent_forward_ok.Po \
+	./$(DEPDIR)/test_auth_keyboard_fail.Po \
+	./$(DEPDIR)/test_auth_keyboard_info_request.Po \
+	./$(DEPDIR)/test_auth_keyboard_ok.Po \
+	./$(DEPDIR)/test_auth_password_fail_password.Po \
+	./$(DEPDIR)/test_auth_password_fail_username.Po \
+	./$(DEPDIR)/test_auth_password_ok.Po \
+	./$(DEPDIR)/test_auth_pubkey_fail.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_dsa.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_ecdsa.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_ecdsa_signed.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_ed25519.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_ed25519_encrypted.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_ed25519_mem.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa_aes256gcm.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa_encrypted.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa_openssh.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa_sha2_256_signed.Po \
+	./$(DEPDIR)/test_auth_pubkey_ok_rsa_signed.Po \
+	./$(DEPDIR)/test_hostkey.Po ./$(DEPDIR)/test_hostkey_hash.Po \
+	./$(DEPDIR)/test_read.Po ./$(DEPDIR)/test_simple.Po \
+	./$(DEPDIR)/test_ssh2.Po
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -154,8 +362,38 @@ AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
-SOURCES = simple.c $(ssh2_SOURCES)
-DIST_SOURCES = simple.c $(am__ssh2_SOURCES_DIST)
+SOURCES = $(librunner_la_SOURCES) test_aa_warmup.c \
+	test_agent_forward_ok.c test_auth_keyboard_fail.c \
+	test_auth_keyboard_info_request.c test_auth_keyboard_ok.c \
+	test_auth_password_fail_password.c \
+	test_auth_password_fail_username.c test_auth_password_ok.c \
+	test_auth_pubkey_fail.c test_auth_pubkey_ok_dsa.c \
+	test_auth_pubkey_ok_ecdsa.c test_auth_pubkey_ok_ecdsa_signed.c \
+	test_auth_pubkey_ok_ed25519.c \
+	test_auth_pubkey_ok_ed25519_encrypted.c \
+	test_auth_pubkey_ok_ed25519_mem.c test_auth_pubkey_ok_rsa.c \
+	test_auth_pubkey_ok_rsa_aes256gcm.c \
+	test_auth_pubkey_ok_rsa_encrypted.c \
+	test_auth_pubkey_ok_rsa_openssh.c \
+	test_auth_pubkey_ok_rsa_sha2_256_signed.c \
+	test_auth_pubkey_ok_rsa_signed.c test_hostkey.c \
+	test_hostkey_hash.c test_read.c test_simple.c test_ssh2.c
+DIST_SOURCES = $(librunner_la_SOURCES) test_aa_warmup.c \
+	test_agent_forward_ok.c test_auth_keyboard_fail.c \
+	test_auth_keyboard_info_request.c test_auth_keyboard_ok.c \
+	test_auth_password_fail_password.c \
+	test_auth_password_fail_username.c test_auth_password_ok.c \
+	test_auth_pubkey_fail.c test_auth_pubkey_ok_dsa.c \
+	test_auth_pubkey_ok_ecdsa.c test_auth_pubkey_ok_ecdsa_signed.c \
+	test_auth_pubkey_ok_ed25519.c \
+	test_auth_pubkey_ok_ed25519_encrypted.c \
+	test_auth_pubkey_ok_ed25519_mem.c test_auth_pubkey_ok_rsa.c \
+	test_auth_pubkey_ok_rsa_aes256gcm.c \
+	test_auth_pubkey_ok_rsa_encrypted.c \
+	test_auth_pubkey_ok_rsa_openssh.c \
+	test_auth_pubkey_ok_rsa_sha2_256_signed.c \
+	test_auth_pubkey_ok_rsa_signed.c test_hostkey.c \
+	test_hostkey_hash.c test_read.c test_simple.c test_ssh2.c
 RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
 	ctags-recursive dvi-recursive html-recursive info-recursive \
 	install-data-recursive install-dvi-recursive \
@@ -378,8 +616,8 @@ am__set_TESTS_bases = \
   bases=`echo $$bases`
 AM_TESTSUITE_SUMMARY_HEADER = ' for $(PACKAGE_STRING)'
 RECHECK_LOGS = $(TEST_LOGS)
+@RUN_DOCKER_TESTS_TRUE@am__EXEEXT_8 = $(am__EXEEXT_3)
 TEST_SUITE_LOG = test-suite.log
-TEST_EXTENSIONS = @EXEEXT@ .test
 LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
 LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
 am__set_b = \
@@ -395,12 +633,11 @@ am__set_b = \
 am__test_logs1 = $(TESTS:=.log)
 am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
 TEST_LOGS = $(am__test_logs2:.test.log=.log)
-TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
 TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
 	$(TEST_LOG_FLAGS)
 DIST_SUBDIRS = $(SUBDIRS)
-am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp \
-	$(top_srcdir)/test-driver
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.inc \
+	$(top_srcdir)/depcomp $(top_srcdir)/test-driver
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 am__relativize = \
   dir0=`pwd`; \
@@ -461,12 +698,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -477,30 +715,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -522,6 +764,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -582,79 +825,124 @@ target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
+
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
 SUBDIRS = ossfuzz
-AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/include -I$(top_builddir)/src
-LDADD = ../src/libssh2.la
-@SSHD_TRUE@ssh2_SOURCES = ssh2.c
-ctests = simple$(EXEEXT)
-TESTS = $(ctests) mansyntax.sh $(am__append_1)
-check_PROGRAMS = $(ctests)
-TESTS_ENVIRONMENT = SSHD=$(SSHD) EXEEXT=$(EXEEXT) \
-	srcdir=$(top_srcdir)/tests builddir=$(top_builddir)/tests
-EXTRA_DIST = \
- CMakeLists.txt                                                        \
- etc/host                                                              \
- etc/host.pub                                                          \
- etc/user                                                              \
- etc/user.pub                                                          \
- key_dsa                                                               \
- key_dsa.pub                                                           \
- key_dsa_wrong                                                         \
- key_dsa_wrong.pub                                                     \
- key_ecdsa                                                             \
- key_ecdsa.pub                                                         \
- key_ed25519                                                           \
- key_ed25519.pub                                                       \
- key_ed25519_encrypted                                                 \
- key_ed25519_encrypted.pub                                             \
- key_rsa                                                               \
- key_rsa.pub                                                           \
- key_rsa_encrypted                                                     \
- key_rsa_encrypted.pub                                                 \
- key_rsa_openssh                                                       \
- key_rsa_openssh.pub                                                   \
- libssh2_config_cmake.h.in                                             \
- mansyntax.sh                                                          \
- openssh_fixture.c                                                     \
- openssh_fixture.h                                                     \
- openssh_server/Dockerfile                                             \
- openssh_server/authorized_keys                                        \
- openssh_server/ca_ecdsa                                               \
- openssh_server/ca_ecdsa.pub                                           \
- openssh_server/ssh_host_ecdsa_key                                     \
- openssh_server/ssh_host_ed25519_key                                   \
- openssh_server/ssh_host_rsa_key                                       \
- runner.c                                                              \
- session_fixture.c                                                     \
- session_fixture.h                                                     \
- simple.c                                                              \
- ssh2.c                                                                \
- ssh2.sh                                                               \
- sshd_fixture.sh.in                                                    \
- test_agent_forward_succeeds.c                                         \
- test_hostkey.c                                                        \
- test_hostkey_hash.c                                                   \
- test_keyboard_interactive_auth_fails_with_wrong_response.c            \
- test_keyboard_interactive_auth_succeeds_with_correct_response.c       \
- test_password_auth_fails_with_wrong_password.c                        \
- test_password_auth_fails_with_wrong_username.c                        \
- test_password_auth_succeeds_with_correct_credentials.c                \
- test_public_key_auth_fails_with_wrong_key.c                           \
- test_public_key_auth_succeeds_with_correct_dsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_ed25519_key.c              \
- test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c     \
- test_public_key_auth_succeeds_with_correct_ecdsa_key.c                \
- test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c         \
- test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c    \
- test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c        \
- test_public_key_auth_succeeds_with_correct_rsa_key.c                  \
- test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src -I$(top_srcdir)/include
+
+# This might hold -Werror
+AM_CFLAGS = @LIBSSH2_CFLAG_EXTRAS@
+
+# Keep this list sorted
+#
+# NOTE: test_auth_keyboard_info_request does not use the network, but when
+#       run as Windows standalone test, it intermittently fails on GHA with:
+#         `Terminate batch job (Y/N)?`
+DOCKER_TESTS = test_aa_warmup test_agent_forward_ok \
+	test_auth_keyboard_fail test_auth_keyboard_ok \
+	test_auth_password_fail_password \
+	test_auth_password_fail_username test_auth_password_ok \
+	test_auth_pubkey_fail test_auth_pubkey_ok_dsa \
+	test_auth_pubkey_ok_ecdsa test_auth_pubkey_ok_ecdsa_signed \
+	test_auth_pubkey_ok_ed25519 \
+	test_auth_pubkey_ok_ed25519_encrypted \
+	test_auth_pubkey_ok_ed25519_mem test_auth_pubkey_ok_rsa \
+	test_auth_pubkey_ok_rsa_aes256gcm \
+	test_auth_pubkey_ok_rsa_encrypted \
+	test_auth_pubkey_ok_rsa_openssh test_auth_pubkey_ok_rsa_signed \
+	test_auth_pubkey_ok_rsa_sha2_256_signed test_hostkey_hash \
+	test_read $(am__append_1)
+STANDALONE_TESTS = $(am__append_2)
+SSHD_TESTS = \
+  test_ssh2 \
+  test_auth_pubkey_ok_ed25519
+
+
+# Programs of the above that use internal libssh2 functions so they need
+# to be statically linked against libssh2
+DOCKER_TESTS_STATIC = \
+  test_auth_keyboard_info_request \
+  test_hostkey
+
+STANDALONE_TESTS_STATIC = \
+  test_simple
+
+
+# Copy of the above for Makefile.am.
+# Is there a way to reuse the lists above?
+test_auth_keyboard_info_request_LDFLAGS = -static
+test_hostkey_LDFLAGS = -static
+test_simple_LDFLAGS = -static
+librunner_la_SOURCES = \
+  runner.c runner.h \
+  session_fixture.c session_fixture.h \
+  openssh_fixture.c openssh_fixture.h
 
+EXTRA_DIST = \
+  CMakeLists.txt \
+  key_dsa \
+  key_dsa.pub \
+  key_dsa_wrong \
+  key_dsa_wrong.pub \
+  key_ecdsa \
+  key_ecdsa.pub \
+  key_ecdsa_signed \
+  key_ecdsa_signed-cert.pub \
+  key_ecdsa_signed.pub \
+  key_ed25519 \
+  key_ed25519.pub \
+  key_ed25519_encrypted \
+  key_ed25519_encrypted.pub \
+  key_rsa \
+  key_rsa.pub \
+  key_rsa_aes256gcm \
+  key_rsa_aes256gcm.pub \
+  key_rsa_encrypted \
+  key_rsa_encrypted.pub \
+  key_rsa_openssh \
+  key_rsa_openssh.pub \
+  key_rsa_signed \
+  key_rsa_signed-cert.pub \
+  key_rsa_signed.pub \
+  key_rsa_sha2_256_signed \
+  key_rsa_sha2_256_signed-cert.pub \
+  key_rsa_sha2_256_signed.pub \
+  mansyntax.sh \
+  openssh_server/Dockerfile \
+  openssh_server/authorized_keys \
+  openssh_server/ca_ecdsa \
+  openssh_server/ca_ecdsa.pub \
+  openssh_server/ca_rsa \
+  openssh_server/ca_rsa.pub \
+  openssh_server/ca_user_keys.pub \
+  openssh_server/ssh_host_ecdsa_key \
+  openssh_server/ssh_host_ed25519_key \
+  openssh_server/ssh_host_rsa_key \
+  openssh_server/sshd_config \
+  test_read_algos.test \
+  test_read_algos.txt \
+  test_sshd.test
+
+
+# Some tests rely on the 'srcdir' env. Set by autotools automatically.
+TESTS_ENVIRONMENT = EXEEXT=$(EXEEXT) $(am__append_5)
+
+# TAP tests
+TEST_EXTENSIONS = .test
+# 'TEST' in 'TEST_LOG_DRIVER' is the test extension in uppercase.
+TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/tap-driver.sh
+
+# Internal library used by tests
+
+# This must be last in the list so it resolves symbols in previous libraries
+LDADD = librunner.la ../src/libssh2.la
+check_LTLIBRARIES = librunner.la
 all: all-recursive
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .log .o .obj .test .test$(EXEEXT) .trs
-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/Makefile.inc $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
@@ -674,6 +962,7 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
 	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
+$(srcdir)/Makefile.inc $(am__empty):
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
@@ -693,22 +982,123 @@ clean-checkPROGRAMS:
 	echo " rm -f" $$list; \
 	rm -f $$list
 
-clean-noinstPROGRAMS:
-	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
+clean-checkLTLIBRARIES:
+	-test -z "$(check_LTLIBRARIES)" || rm -f $(check_LTLIBRARIES)
+	@list='$(check_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+
+librunner.la: $(librunner_la_OBJECTS) $(librunner_la_DEPENDENCIES) $(EXTRA_librunner_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(LINK)  $(librunner_la_OBJECTS) $(librunner_la_LIBADD) $(LIBS)
+
+test_aa_warmup$(EXEEXT): $(test_aa_warmup_OBJECTS) $(test_aa_warmup_DEPENDENCIES) $(EXTRA_test_aa_warmup_DEPENDENCIES) 
+	@rm -f test_aa_warmup$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_aa_warmup_OBJECTS) $(test_aa_warmup_LDADD) $(LIBS)
+
+test_agent_forward_ok$(EXEEXT): $(test_agent_forward_ok_OBJECTS) $(test_agent_forward_ok_DEPENDENCIES) $(EXTRA_test_agent_forward_ok_DEPENDENCIES) 
+	@rm -f test_agent_forward_ok$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_agent_forward_ok_OBJECTS) $(test_agent_forward_ok_LDADD) $(LIBS)
+
+test_auth_keyboard_fail$(EXEEXT): $(test_auth_keyboard_fail_OBJECTS) $(test_auth_keyboard_fail_DEPENDENCIES) $(EXTRA_test_auth_keyboard_fail_DEPENDENCIES) 
+	@rm -f test_auth_keyboard_fail$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_keyboard_fail_OBJECTS) $(test_auth_keyboard_fail_LDADD) $(LIBS)
+
+test_auth_keyboard_info_request$(EXEEXT): $(test_auth_keyboard_info_request_OBJECTS) $(test_auth_keyboard_info_request_DEPENDENCIES) $(EXTRA_test_auth_keyboard_info_request_DEPENDENCIES) 
+	@rm -f test_auth_keyboard_info_request$(EXEEXT)
+	$(AM_V_CCLD)$(test_auth_keyboard_info_request_LINK) $(test_auth_keyboard_info_request_OBJECTS) $(test_auth_keyboard_info_request_LDADD) $(LIBS)
+
+test_auth_keyboard_ok$(EXEEXT): $(test_auth_keyboard_ok_OBJECTS) $(test_auth_keyboard_ok_DEPENDENCIES) $(EXTRA_test_auth_keyboard_ok_DEPENDENCIES) 
+	@rm -f test_auth_keyboard_ok$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_keyboard_ok_OBJECTS) $(test_auth_keyboard_ok_LDADD) $(LIBS)
+
+test_auth_password_fail_password$(EXEEXT): $(test_auth_password_fail_password_OBJECTS) $(test_auth_password_fail_password_DEPENDENCIES) $(EXTRA_test_auth_password_fail_password_DEPENDENCIES) 
+	@rm -f test_auth_password_fail_password$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_password_fail_password_OBJECTS) $(test_auth_password_fail_password_LDADD) $(LIBS)
+
+test_auth_password_fail_username$(EXEEXT): $(test_auth_password_fail_username_OBJECTS) $(test_auth_password_fail_username_DEPENDENCIES) $(EXTRA_test_auth_password_fail_username_DEPENDENCIES) 
+	@rm -f test_auth_password_fail_username$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_password_fail_username_OBJECTS) $(test_auth_password_fail_username_LDADD) $(LIBS)
+
+test_auth_password_ok$(EXEEXT): $(test_auth_password_ok_OBJECTS) $(test_auth_password_ok_DEPENDENCIES) $(EXTRA_test_auth_password_ok_DEPENDENCIES) 
+	@rm -f test_auth_password_ok$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_password_ok_OBJECTS) $(test_auth_password_ok_LDADD) $(LIBS)
+
+test_auth_pubkey_fail$(EXEEXT): $(test_auth_pubkey_fail_OBJECTS) $(test_auth_pubkey_fail_DEPENDENCIES) $(EXTRA_test_auth_pubkey_fail_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_fail$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_fail_OBJECTS) $(test_auth_pubkey_fail_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_dsa$(EXEEXT): $(test_auth_pubkey_ok_dsa_OBJECTS) $(test_auth_pubkey_ok_dsa_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_dsa_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_dsa$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_dsa_OBJECTS) $(test_auth_pubkey_ok_dsa_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_ecdsa$(EXEEXT): $(test_auth_pubkey_ok_ecdsa_OBJECTS) $(test_auth_pubkey_ok_ecdsa_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_ecdsa_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_ecdsa$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_ecdsa_OBJECTS) $(test_auth_pubkey_ok_ecdsa_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_ecdsa_signed$(EXEEXT): $(test_auth_pubkey_ok_ecdsa_signed_OBJECTS) $(test_auth_pubkey_ok_ecdsa_signed_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_ecdsa_signed_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_ecdsa_signed$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_ecdsa_signed_OBJECTS) $(test_auth_pubkey_ok_ecdsa_signed_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_ed25519$(EXEEXT): $(test_auth_pubkey_ok_ed25519_OBJECTS) $(test_auth_pubkey_ok_ed25519_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_ed25519_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_ed25519$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_ed25519_OBJECTS) $(test_auth_pubkey_ok_ed25519_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_ed25519_encrypted$(EXEEXT): $(test_auth_pubkey_ok_ed25519_encrypted_OBJECTS) $(test_auth_pubkey_ok_ed25519_encrypted_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_ed25519_encrypted_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_ed25519_encrypted$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_ed25519_encrypted_OBJECTS) $(test_auth_pubkey_ok_ed25519_encrypted_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_ed25519_mem$(EXEEXT): $(test_auth_pubkey_ok_ed25519_mem_OBJECTS) $(test_auth_pubkey_ok_ed25519_mem_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_ed25519_mem_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_ed25519_mem$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_ed25519_mem_OBJECTS) $(test_auth_pubkey_ok_ed25519_mem_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa$(EXEEXT): $(test_auth_pubkey_ok_rsa_OBJECTS) $(test_auth_pubkey_ok_rsa_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_OBJECTS) $(test_auth_pubkey_ok_rsa_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa_aes256gcm$(EXEEXT): $(test_auth_pubkey_ok_rsa_aes256gcm_OBJECTS) $(test_auth_pubkey_ok_rsa_aes256gcm_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_aes256gcm_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa_aes256gcm$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_aes256gcm_OBJECTS) $(test_auth_pubkey_ok_rsa_aes256gcm_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa_encrypted$(EXEEXT): $(test_auth_pubkey_ok_rsa_encrypted_OBJECTS) $(test_auth_pubkey_ok_rsa_encrypted_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_encrypted_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa_encrypted$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_encrypted_OBJECTS) $(test_auth_pubkey_ok_rsa_encrypted_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa_openssh$(EXEEXT): $(test_auth_pubkey_ok_rsa_openssh_OBJECTS) $(test_auth_pubkey_ok_rsa_openssh_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_openssh_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa_openssh$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_openssh_OBJECTS) $(test_auth_pubkey_ok_rsa_openssh_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa_sha2_256_signed$(EXEEXT): $(test_auth_pubkey_ok_rsa_sha2_256_signed_OBJECTS) $(test_auth_pubkey_ok_rsa_sha2_256_signed_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_sha2_256_signed_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa_sha2_256_signed$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_sha2_256_signed_OBJECTS) $(test_auth_pubkey_ok_rsa_sha2_256_signed_LDADD) $(LIBS)
+
+test_auth_pubkey_ok_rsa_signed$(EXEEXT): $(test_auth_pubkey_ok_rsa_signed_OBJECTS) $(test_auth_pubkey_ok_rsa_signed_DEPENDENCIES) $(EXTRA_test_auth_pubkey_ok_rsa_signed_DEPENDENCIES) 
+	@rm -f test_auth_pubkey_ok_rsa_signed$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_auth_pubkey_ok_rsa_signed_OBJECTS) $(test_auth_pubkey_ok_rsa_signed_LDADD) $(LIBS)
+
+test_hostkey$(EXEEXT): $(test_hostkey_OBJECTS) $(test_hostkey_DEPENDENCIES) $(EXTRA_test_hostkey_DEPENDENCIES) 
+	@rm -f test_hostkey$(EXEEXT)
+	$(AM_V_CCLD)$(test_hostkey_LINK) $(test_hostkey_OBJECTS) $(test_hostkey_LDADD) $(LIBS)
+
+test_hostkey_hash$(EXEEXT): $(test_hostkey_hash_OBJECTS) $(test_hostkey_hash_DEPENDENCIES) $(EXTRA_test_hostkey_hash_DEPENDENCIES) 
+	@rm -f test_hostkey_hash$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_hostkey_hash_OBJECTS) $(test_hostkey_hash_LDADD) $(LIBS)
 
-simple$(EXEEXT): $(simple_OBJECTS) $(simple_DEPENDENCIES) $(EXTRA_simple_DEPENDENCIES) 
-	@rm -f simple$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(simple_OBJECTS) $(simple_LDADD) $(LIBS)
+test_read$(EXEEXT): $(test_read_OBJECTS) $(test_read_DEPENDENCIES) $(EXTRA_test_read_DEPENDENCIES) 
+	@rm -f test_read$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_read_OBJECTS) $(test_read_LDADD) $(LIBS)
 
-ssh2$(EXEEXT): $(ssh2_OBJECTS) $(ssh2_DEPENDENCIES) $(EXTRA_ssh2_DEPENDENCIES) 
-	@rm -f ssh2$(EXEEXT)
-	$(AM_V_CCLD)$(LINK) $(ssh2_OBJECTS) $(ssh2_LDADD) $(LIBS)
+test_simple$(EXEEXT): $(test_simple_OBJECTS) $(test_simple_DEPENDENCIES) $(EXTRA_test_simple_DEPENDENCIES) 
+	@rm -f test_simple$(EXEEXT)
+	$(AM_V_CCLD)$(test_simple_LINK) $(test_simple_OBJECTS) $(test_simple_LDADD) $(LIBS)
+
+test_ssh2$(EXEEXT): $(test_ssh2_OBJECTS) $(test_ssh2_DEPENDENCIES) $(EXTRA_test_ssh2_DEPENDENCIES) 
+	@rm -f test_ssh2$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_ssh2_OBJECTS) $(test_ssh2_LDADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
@@ -716,8 +1106,35 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple.Po@am__quote@ # am--include-marker
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ssh2.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/openssh_fixture.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runner.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/session_fixture.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_aa_warmup.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_agent_forward_ok.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_keyboard_fail.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_keyboard_info_request.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_keyboard_ok.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_password_fail_password.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_password_fail_username.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_password_ok.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_fail.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_dsa.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_ecdsa.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_ecdsa_signed.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_ed25519.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_ed25519_encrypted.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_ed25519_mem.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa_aes256gcm.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa_encrypted.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa_openssh.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa_sha2_256_signed.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_auth_pubkey_ok_rsa_signed.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_hostkey.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_hostkey_hash.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_read.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_simple.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_ssh2.Po@am__quote@ # am--include-marker
 
 $(am__depfiles_remade):
 	@$(MKDIR_P) $(@D)
@@ -971,7 +1388,7 @@ $(TEST_SUITE_LOG): $(TEST_LOGS)
 	fi;								\
 	$$success || exit 1
 
-check-TESTS: $(check_PROGRAMS)
+check-TESTS: $(check_PROGRAMS) $(check_LTLIBRARIES)
 	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
 	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
 	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
@@ -981,7 +1398,7 @@ check-TESTS: $(check_PROGRAMS)
 	log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
 	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
 	exit $$?;
-recheck: all $(check_PROGRAMS)
+recheck: all $(check_PROGRAMS) $(check_LTLIBRARIES)
 	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
 	@set +e; $(am__set_TESTS_bases); \
 	bases=`for i in $$bases; do echo $$i; done \
@@ -992,23 +1409,184 @@ recheck: all $(check_PROGRAMS)
 	        am__force_recheck=am--force-recheck \
 	        TEST_LOGS="$$log_list"; \
 	exit $$?
-simple.log: simple$(EXEEXT)
-	@p='simple$(EXEEXT)'; \
-	b='simple'; \
+mansyntax.sh.log: mansyntax.sh
+	@p='mansyntax.sh'; \
+	b='mansyntax.sh'; \
 	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
-mansyntax.sh.log: mansyntax.sh
-	@p='mansyntax.sh'; \
-	b='mansyntax.sh'; \
+test_aa_warmup.log: test_aa_warmup$(EXEEXT)
+	@p='test_aa_warmup$(EXEEXT)'; \
+	b='test_aa_warmup'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_agent_forward_ok.log: test_agent_forward_ok$(EXEEXT)
+	@p='test_agent_forward_ok$(EXEEXT)'; \
+	b='test_agent_forward_ok'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_keyboard_fail.log: test_auth_keyboard_fail$(EXEEXT)
+	@p='test_auth_keyboard_fail$(EXEEXT)'; \
+	b='test_auth_keyboard_fail'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_keyboard_ok.log: test_auth_keyboard_ok$(EXEEXT)
+	@p='test_auth_keyboard_ok$(EXEEXT)'; \
+	b='test_auth_keyboard_ok'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_password_fail_password.log: test_auth_password_fail_password$(EXEEXT)
+	@p='test_auth_password_fail_password$(EXEEXT)'; \
+	b='test_auth_password_fail_password'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_password_fail_username.log: test_auth_password_fail_username$(EXEEXT)
+	@p='test_auth_password_fail_username$(EXEEXT)'; \
+	b='test_auth_password_fail_username'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_password_ok.log: test_auth_password_ok$(EXEEXT)
+	@p='test_auth_password_ok$(EXEEXT)'; \
+	b='test_auth_password_ok'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_fail.log: test_auth_pubkey_fail$(EXEEXT)
+	@p='test_auth_pubkey_fail$(EXEEXT)'; \
+	b='test_auth_pubkey_fail'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_dsa.log: test_auth_pubkey_ok_dsa$(EXEEXT)
+	@p='test_auth_pubkey_ok_dsa$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_dsa'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_ecdsa.log: test_auth_pubkey_ok_ecdsa$(EXEEXT)
+	@p='test_auth_pubkey_ok_ecdsa$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_ecdsa'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_ecdsa_signed.log: test_auth_pubkey_ok_ecdsa_signed$(EXEEXT)
+	@p='test_auth_pubkey_ok_ecdsa_signed$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_ecdsa_signed'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_ed25519.log: test_auth_pubkey_ok_ed25519$(EXEEXT)
+	@p='test_auth_pubkey_ok_ed25519$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_ed25519'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_ed25519_encrypted.log: test_auth_pubkey_ok_ed25519_encrypted$(EXEEXT)
+	@p='test_auth_pubkey_ok_ed25519_encrypted$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_ed25519_encrypted'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_ed25519_mem.log: test_auth_pubkey_ok_ed25519_mem$(EXEEXT)
+	@p='test_auth_pubkey_ok_ed25519_mem$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_ed25519_mem'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa.log: test_auth_pubkey_ok_rsa$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa_aes256gcm.log: test_auth_pubkey_ok_rsa_aes256gcm$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa_aes256gcm$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa_aes256gcm'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa_encrypted.log: test_auth_pubkey_ok_rsa_encrypted$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa_encrypted$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa_encrypted'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa_openssh.log: test_auth_pubkey_ok_rsa_openssh$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa_openssh$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa_openssh'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa_signed.log: test_auth_pubkey_ok_rsa_signed$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa_signed$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa_signed'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_pubkey_ok_rsa_sha2_256_signed.log: test_auth_pubkey_ok_rsa_sha2_256_signed$(EXEEXT)
+	@p='test_auth_pubkey_ok_rsa_sha2_256_signed$(EXEEXT)'; \
+	b='test_auth_pubkey_ok_rsa_sha2_256_signed'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_hostkey_hash.log: test_hostkey_hash$(EXEEXT)
+	@p='test_hostkey_hash$(EXEEXT)'; \
+	b='test_hostkey_hash'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_read.log: test_read$(EXEEXT)
+	@p='test_read$(EXEEXT)'; \
+	b='test_read'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_auth_keyboard_info_request.log: test_auth_keyboard_info_request$(EXEEXT)
+	@p='test_auth_keyboard_info_request$(EXEEXT)'; \
+	b='test_auth_keyboard_info_request'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+test_hostkey.log: test_hostkey$(EXEEXT)
+	@p='test_hostkey$(EXEEXT)'; \
+	b='test_hostkey'; \
 	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
-ssh2.sh.log: ssh2.sh
-	@p='ssh2.sh'; \
-	b='ssh2.sh'; \
+test_simple.log: test_simple$(EXEEXT)
+	@p='test_simple$(EXEEXT)'; \
+	b='test_simple'; \
 	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
@@ -1086,10 +1664,10 @@ distdir-am: $(DISTFILES)
 	  fi; \
 	done
 check-am: all-am
-	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
+	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) $(check_LTLIBRARIES)
 	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
 check: check-recursive
-all-am: Makefile $(PROGRAMS)
+all-am: Makefile
 installdirs: installdirs-recursive
 installdirs-am:
 install: install-recursive
@@ -1127,12 +1705,39 @@ maintainer-clean-generic:
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-recursive
 
-clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
-	clean-noinstPROGRAMS mostlyclean-am
+clean-am: clean-checkLTLIBRARIES clean-checkPROGRAMS clean-generic \
+	clean-libtool mostlyclean-am
 
 distclean: distclean-recursive
-		-rm -f ./$(DEPDIR)/simple.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
+		-rm -f ./$(DEPDIR)/openssh_fixture.Plo
+	-rm -f ./$(DEPDIR)/runner.Plo
+	-rm -f ./$(DEPDIR)/session_fixture.Plo
+	-rm -f ./$(DEPDIR)/test_aa_warmup.Po
+	-rm -f ./$(DEPDIR)/test_agent_forward_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_fail.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_info_request.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_fail_password.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_fail_username.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_fail.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_dsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ecdsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ecdsa_signed.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519_encrypted.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519_mem.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_aes256gcm.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_encrypted.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_openssh.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_sha2_256_signed.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_signed.Po
+	-rm -f ./$(DEPDIR)/test_hostkey.Po
+	-rm -f ./$(DEPDIR)/test_hostkey_hash.Po
+	-rm -f ./$(DEPDIR)/test_read.Po
+	-rm -f ./$(DEPDIR)/test_simple.Po
+	-rm -f ./$(DEPDIR)/test_ssh2.Po
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -1178,8 +1783,35 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-recursive
-		-rm -f ./$(DEPDIR)/simple.Po
-	-rm -f ./$(DEPDIR)/ssh2.Po
+		-rm -f ./$(DEPDIR)/openssh_fixture.Plo
+	-rm -f ./$(DEPDIR)/runner.Plo
+	-rm -f ./$(DEPDIR)/session_fixture.Plo
+	-rm -f ./$(DEPDIR)/test_aa_warmup.Po
+	-rm -f ./$(DEPDIR)/test_agent_forward_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_fail.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_info_request.Po
+	-rm -f ./$(DEPDIR)/test_auth_keyboard_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_fail_password.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_fail_username.Po
+	-rm -f ./$(DEPDIR)/test_auth_password_ok.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_fail.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_dsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ecdsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ecdsa_signed.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519_encrypted.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_ed25519_mem.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_aes256gcm.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_encrypted.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_openssh.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_sha2_256_signed.Po
+	-rm -f ./$(DEPDIR)/test_auth_pubkey_ok_rsa_signed.Po
+	-rm -f ./$(DEPDIR)/test_hostkey.Po
+	-rm -f ./$(DEPDIR)/test_hostkey_hash.Po
+	-rm -f ./$(DEPDIR)/test_read.Po
+	-rm -f ./$(DEPDIR)/test_simple.Po
+	-rm -f ./$(DEPDIR)/test_ssh2.Po
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -1202,8 +1834,8 @@ uninstall-am:
 
 .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
 	am--depfiles check check-TESTS check-am clean \
-	clean-checkPROGRAMS clean-generic clean-libtool \
-	clean-noinstPROGRAMS cscopelist-am ctags ctags-am distclean \
+	clean-checkLTLIBRARIES clean-checkPROGRAMS clean-generic \
+	clean-libtool cscopelist-am ctags ctags-am distclean \
 	distclean-compile distclean-generic distclean-libtool \
 	distclean-tags distdir dvi dvi-am html html-am info info-am \
 	install install-am install-data install-data-am install-dvi \
diff --git a/libssh2/tests/Makefile.inc b/libssh2/tests/Makefile.inc
new file mode 100644
index 00000000..45f7f475
--- /dev/null
+++ b/libssh2/tests/Makefile.inc
@@ -0,0 +1,102 @@
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Keep this list sorted
+#
+# NOTE: test_auth_keyboard_info_request does not use the network, but when
+#       run as Windows standalone test, it intermittently fails on GHA with:
+#         `Terminate batch job (Y/N)?`
+DOCKER_TESTS = \
+  test_aa_warmup \
+  test_agent_forward_ok \
+  test_auth_keyboard_fail \
+  test_auth_keyboard_ok \
+  test_auth_password_fail_password \
+  test_auth_password_fail_username \
+  test_auth_password_ok \
+  test_auth_pubkey_fail \
+  test_auth_pubkey_ok_dsa \
+  test_auth_pubkey_ok_ecdsa \
+  test_auth_pubkey_ok_ecdsa_signed \
+  test_auth_pubkey_ok_ed25519 \
+  test_auth_pubkey_ok_ed25519_encrypted \
+  test_auth_pubkey_ok_ed25519_mem \
+  test_auth_pubkey_ok_rsa \
+  test_auth_pubkey_ok_rsa_aes256gcm \
+  test_auth_pubkey_ok_rsa_encrypted \
+  test_auth_pubkey_ok_rsa_openssh \
+  test_auth_pubkey_ok_rsa_signed \
+  test_auth_pubkey_ok_rsa_sha2_256_signed \
+  test_hostkey_hash \
+  test_read
+
+STANDALONE_TESTS =
+
+SSHD_TESTS = \
+  test_ssh2 \
+  test_auth_pubkey_ok_ed25519
+
+# Programs of the above that use internal libssh2 functions so they need
+# to be statically linked against libssh2
+DOCKER_TESTS_STATIC = \
+  test_auth_keyboard_info_request \
+  test_hostkey
+
+STANDALONE_TESTS_STATIC = \
+  test_simple
+
+# Copy of the above for Makefile.am.
+# Is there a way to reuse the lists above?
+test_auth_keyboard_info_request_LDFLAGS = -static
+test_hostkey_LDFLAGS = -static
+test_simple_LDFLAGS = -static
+
+librunner_la_SOURCES = \
+  runner.c runner.h \
+  session_fixture.c session_fixture.h \
+  openssh_fixture.c openssh_fixture.h
+
+EXTRA_DIST = \
+  CMakeLists.txt \
+  key_dsa \
+  key_dsa.pub \
+  key_dsa_wrong \
+  key_dsa_wrong.pub \
+  key_ecdsa \
+  key_ecdsa.pub \
+  key_ecdsa_signed \
+  key_ecdsa_signed-cert.pub \
+  key_ecdsa_signed.pub \
+  key_ed25519 \
+  key_ed25519.pub \
+  key_ed25519_encrypted \
+  key_ed25519_encrypted.pub \
+  key_rsa \
+  key_rsa.pub \
+  key_rsa_aes256gcm \
+  key_rsa_aes256gcm.pub \
+  key_rsa_encrypted \
+  key_rsa_encrypted.pub \
+  key_rsa_openssh \
+  key_rsa_openssh.pub \
+  key_rsa_signed \
+  key_rsa_signed-cert.pub \
+  key_rsa_signed.pub \
+  key_rsa_sha2_256_signed \
+  key_rsa_sha2_256_signed-cert.pub \
+  key_rsa_sha2_256_signed.pub \
+  mansyntax.sh \
+  openssh_server/Dockerfile \
+  openssh_server/authorized_keys \
+  openssh_server/ca_ecdsa \
+  openssh_server/ca_ecdsa.pub \
+  openssh_server/ca_rsa \
+  openssh_server/ca_rsa.pub \
+  openssh_server/ca_user_keys.pub \
+  openssh_server/ssh_host_ecdsa_key \
+  openssh_server/ssh_host_ed25519_key \
+  openssh_server/ssh_host_rsa_key \
+  openssh_server/sshd_config \
+  test_read_algos.test \
+  test_read_algos.txt \
+  test_sshd.test
diff --git a/libssh2/tests/etc/host b/libssh2/tests/etc/host
deleted file mode 100644
index c4ead711..00000000
--- a/libssh2/tests/etc/host
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEogIBAAKCAQEAwJaOo3i1X3N401hMd92lRec0tPMBgaF6ZDanovBiQP+PNo6g
-VNtuF15AspbyxrViqtAyjLWQQlKGWgEFb2ga3ukzJll4dKPtNff3mO++W19ia0WQ
-ZFWTAGcYqet4fvSALIpG+t/3u5MZXMNZPyCU8u1l+QXX14f6dEjzgRw7s3fSy/uv
-Qawkgn8TQFvtSBOfvUTJPTAhhZqxZAt3nGH8d6vqD1hBNvdOpsohy6EgFh8V+kxn
-UdQntrYe9WSz0djt0RRrdAvRkM0hq1UY8C9FTQQWni1n168c7FVrf65+GdJOn7NQ
-Du0Whmh/R3flXR0kIBG+F7e8+e9W9OhlionkPwIBIwKCAQEAqpP6rgvT2DMTPtkt
-yUCoU9tpMo4XRu4b8lxLVc2Y2nvz391pb7sJvO0Uu2/BFmYkMORKB5l/xbbOxL8T
-cU2UJIVn0YJyAOj2rCTFW5KEB8mDDo4SLPtWUNBXrHF5WoDJTAVyEWdJInr5NOeJ
-j68k1yoJ3JAlkwNozWUvclrVytZNohPhiYdKkj2DPlWKL//0INGIo9TU31AGJx2R
-ymy105EFCXWDv1GAIWwqBjNNxzlyxDauuGTwWr2iYDyectBYApCkjyJzMpFn4Yiu
-Mq5XomwkQhefK3y32bRasm+HSrQsGswSvSyS8I5YosjSKMmiWdYj4WxrSciT6gG/
-KHanEwKBgQDucA7E/s9aKs6rECypXPaCORxvbLqdqAiwzJ0edufE+g0aQU/Zm3xj
-m6LGovdEcaBog4rfKCSB9NRKi35m4HV9PO4YBw6/lQ0NeO6jrb8OnZp/P97FbomT
-AXBibzUjQ8fhbPCaJF/2TUEoyhNbzJkpl+M0zu2aQ3MUYVd4dZ4y4wKBgQDOxfeA
-RH3ZPvdYI50jxW+/kKcio+APZZJ9xhtqOKzmEuJOPzlngWk5WQgS8B1aicHyFRhw
-UT2vKeJvqqoeLbIE9Fm6qlpN22594S88+LOiMda4wRswxG9wBZ2J4+rrYKpcb1gt
-JXvVKY7h5qLWGCR0x+ovOcNXABWsF8CAnOnb9QKBgA2gANgOj4F+yfslfuUbQUlF
-F5FWq5P6+S6sm0ORxBniZyYSXFWT2zjkUnHAK2L/LbzUURQQ7CSu5487K8tdSIrQ
-SB6hUUzGsEnppzyNleOT+jMoOJ2RSbCg/xuRU35bpQWRMlHzczKlVC43btILsPsP
-/lrJ/vLfSGeQiKfMNOz3AoGAC9DMUHjxP50ytJRSH00cVBbk+qpHUVZC4p2bKqQn
-IxcFnhI9y2Z7CpdfjA24iNSr/zRny+dinEuJSDWjUi5/M3utWx+tY4jhvgzeIL3B
-HzYMRRJZUz5sxJKbSbVAn7xhgZ/2aPrT4EuEge/sDDvk03kjUyffRszOCdV4tuRl
-IoMCgYEAnrexTd5GuxEEBg3qJgN4IMwoBzZlJ1voaI6I/AMuvQ5kVklYvHTPTZOI
-kSIrvaG8xaOdf0f76XNdT7U/dkx0C0vcesy5++hqakmeRCHjfsE1wN7m+hGo5WcR
-Jq8Ph9ZnH5RKjqDsHh7Y4BCewQNrMBqNQEzDebZCDBUTnK9OgOg=
------END RSA PRIVATE KEY-----
diff --git a/libssh2/tests/etc/host.pub b/libssh2/tests/etc/host.pub
deleted file mode 100644
index e1ad7f98..00000000
--- a/libssh2/tests/etc/host.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwJaOo3i1X3N401hMd92lRec0tPMBgaF6ZDanovBiQP+PNo6gVNtuF15AspbyxrViqtAyjLWQQlKGWgEFb2ga3ukzJll4dKPtNff3mO++W19ia0WQZFWTAGcYqet4fvSALIpG+t/3u5MZXMNZPyCU8u1l+QXX14f6dEjzgRw7s3fSy/uvQawkgn8TQFvtSBOfvUTJPTAhhZqxZAt3nGH8d6vqD1hBNvdOpsohy6EgFh8V+kxnUdQntrYe9WSz0djt0RRrdAvRkM0hq1UY8C9FTQQWni1n168c7FVrf65+GdJOn7NQDu0Whmh/R3flXR0kIBG+F7e8+e9W9OhlionkPw== jas@mocca
diff --git a/libssh2/tests/etc/user b/libssh2/tests/etc/user
deleted file mode 100644
index 01bf6ac9..00000000
--- a/libssh2/tests/etc/user
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEoQIBAAKCAQEAxIgBuZS39D4bFnWminE7svGQLdVKx1aWKnEYEa+XtNU4DKZ/
-pxUHg0zbEBya+IkX1yqQYWALoiOwI8XhdemLp8g03BX7o+DLSWisfiHpCDVGAuNq
-RDF7qnFyL/ZBH6e0XKMtsoB51TDuBc4Rxh6p1V2QL/fg8BoHcCrnKkoqN8PSoKUX
-2lPKJ3JIF/P8cDLbKYCvbSTFOdf56eqg0GJe7jFtSwweE9yz3IWZ3kSS1E/9E6sX
-aNCu/hUt1bvQthICQyBNoTtQP/igEUJ7n0GMetsnq9wiUSomLzWqIWNqmvOv62aC
-XRi5sYgpSAR4Zvnm3Cx/Wl0BEPz2rrFkG+G0SQIBIwKCAQEAgSYtBOyzZfztOqUV
-q277WFWZQrC8HJf8R8aparU3zpq+braOZnuImByP9KUVYX6pRECKw6WD/NWfonq4
-uzMSoXTviVBGRx6xeWIK880kG1Y1UlruD447Ur+ULiV7QLAIzylnLCiKk2lL9S+l
-R63AD95mEOS4Y0ROB+Gt2fY5ABHRMqhGLvRKK8qwn35C1Z9qnTGhgiRbeoc373A5
-ZAYyegyLnbvyV47UfPYS/TVzxZ9RCx3D3I/9fI7ZAFafkkIufQX3QPaVxf0zFUwW
-de/f+gTbySTL4RDF185Evunx+tYvzCyIimB0cTE5dfsCWcHDtO6DwehKiOgJsbeW
-IrpeTwKBgQDnEMfv7ORR35Ouj91iNCSfLU/v0TSzAJBfqYovByhXRsopgWAKXUmH
-mWpBBP5vcGu3NvKfiZcMMbBPfllvlxkafQwvCqrdn5mg01MdAHMWP/O9yfvuxMDE
-KycU2G2CT8j85mIPn19WeIgXC/kws+P0RAVNCBNeq89Gvp4IdLN67wKBgQDZvTYh
-TPCYG32jBK+CcWmOna2SLvBloDcNevhzfu3RGjLIXzUHGxLdx7slsP/tpndmXIAL
-CgV6GfrLxix5bO08203S2qnnwP8VrjjNIv1CyZIbbQFAFIeC3QxZMZHnXieLrO0z
-qF5CuUXcL3cMeGmF/0HN/rB+4sF0qfv8wD8kRwKBgFXTCG8O2HYueK6NNPiXBknA
-X4T17wCocCOIHWHstzZcHzP82oeBvDmuAuTzOe7gnQmJcA9e/ZbQoJKOA/Y/b7lh
-pXCO7wHcMb9kb1PqOWAJIASqG78V4TLrdOp8Re6Sqb0FHRu+2kSwbQ/f4DapN2lb
-F+lpZke8KGq71ExImm99AoGAN/10UbSy5UjlytVRs9QFM00eAQTBeTfTpGFzFmJ3
-qsw48bIU8zLY9zNcAmC21rXG7m+Oo8C/lG0UmsyPF+jPSinDjf22qU7iger4qccr
-Lm5YxTlJduC1IaaOJZBnWMBwkaF+0sTlCdfew5ctPbiQKcVLb3wBf7amxjpWvVYB
-m50CgYAT6t2/Suav21J5zpzyrrt+oMZQ3MMzBnPHFRUQ1FdqZnE4eW5a10g0P+E+
-YeTol+fYxL34+cI5PREK3dcnW1E8g8KOsOQqMgWdTfZEDHYRLqEyGIhu20aqfJCY
-qu9tBburQoSlym9aQp41CMxIyHrL4GnwRlJkTTEVhDuab1HmKw==
------END RSA PRIVATE KEY-----
diff --git a/libssh2/tests/etc/user.pub b/libssh2/tests/etc/user.pub
deleted file mode 100644
index c60e90d1..00000000
--- a/libssh2/tests/etc/user.pub
+++ /dev/null
@@ -1 +0,0 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAxIgBuZS39D4bFnWminE7svGQLdVKx1aWKnEYEa+XtNU4DKZ/pxUHg0zbEBya+IkX1yqQYWALoiOwI8XhdemLp8g03BX7o+DLSWisfiHpCDVGAuNqRDF7qnFyL/ZBH6e0XKMtsoB51TDuBc4Rxh6p1V2QL/fg8BoHcCrnKkoqN8PSoKUX2lPKJ3JIF/P8cDLbKYCvbSTFOdf56eqg0GJe7jFtSwweE9yz3IWZ3kSS1E/9E6sXaNCu/hUt1bvQthICQyBNoTtQP/igEUJ7n0GMetsnq9wiUSomLzWqIWNqmvOv62aCXRi5sYgpSAR4Zvnm3Cx/Wl0BEPz2rrFkG+G0SQ== jas@mocca
diff --git a/libssh2/tests/key_ecdsa.pub b/libssh2/tests/key_ecdsa.pub
index 597f63fc..7f50e19f 100644
--- a/libssh2/tests/key_ecdsa.pub
+++ b/libssh2/tests/key_ecdsa.pub
@@ -1 +1 @@
-ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBOiyJJwf+hFJrOkik9IQVxjhhVnI1vKl4BGLj03erLvw4TXXwoZzlPx6J936fU9JvvPw+d8PA4viMEfFbmdbHREKhwi3u1vZrfj0mB8SXw96AcZwX8PAL556wgom+/Qx+Q== 
+ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBOiyJJwf+hFJrOkik9IQVxjhhVnI1vKl4BGLj03erLvw4TXXwoZzlPx6J936fU9JvvPw+d8PA4viMEfFbmdbHREKhwi3u1vZrfj0mB8SXw96AcZwX8PAL556wgom+/Qx+Q==
diff --git a/libssh2/tests/key_ecdsa_signed b/libssh2/tests/key_ecdsa_signed
new file mode 100644
index 00000000..1e08cfd7
--- /dev/null
+++ b/libssh2/tests/key_ecdsa_signed
@@ -0,0 +1,10 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAiAAAABNlY2RzYS
+1zaGEyLW5pc3RwMzg0AAAACG5pc3RwMzg0AAAAYQRv1/fnN1SuIkg222jYnySqIJ88J5M3
+bB6JGeloKhIvnZdPOSVFuFBjuF7NPrGrsm87QstQFbDiLhIlcDNHIq0VhS5itHNMjtC6Ym
+RRx7mlQSXPbRRF5MclxvDJCMyAIagAAADQekojnXpKI50AAAATZWNkc2Etc2hhMi1uaXN0
+cDM4NAAAAAhuaXN0cDM4NAAAAGEEb9f35zdUriJINtto2J8kqiCfPCeTN2weiRnpaCoSL5
+2XTzklRbhQY7hezT6xq7JvO0LLUBWw4i4SJXAzRyKtFYUuYrRzTI7QumJkUce5pUElz20U
+ReTHJcbwyQjMgCGoAAAAMQDmng9vaqXjHAhRssuBHeQylRKRwzOYOaToF8f+O0NmpmfLnc
+/c2wOcXf2f9GBAQdYAAAAAAQIDBAUGBw==
+-----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/key_ecdsa_signed-cert.pub b/libssh2/tests/key_ecdsa_signed-cert.pub
new file mode 100644
index 00000000..3f1db684
--- /dev/null
+++ b/libssh2/tests/key_ecdsa_signed-cert.pub
@@ -0,0 +1 @@
+ecdsa-sha2-nistp384-cert-v01@openssh.com AAAAKGVjZHNhLXNoYTItbmlzdHAzODQtY2VydC12MDFAb3BlbnNzaC5jb20AAAAgQCXc1JaqZ4XzkudbzP/pgEUbkioo7pl9aB09h6sg7KYAAAAIbmlzdHAzODQAAABhBG/X9+c3VK4iSDbbaNifJKognzwnkzdsHokZ6WgqEi+dl085JUW4UGO4Xs0+sauybztCy1AVsOIuEiVwM0cirRWFLmK0c0yO0LpiZFHHuaVBJc9tFEXkxyXG8MkIzIAhqAAAAAAAAAABAAAAAQAAAAhpZGVudGl0eQAAAAsAAAAHbGlic3NoMgAAAAAAAAAA//////////8AAAAAAAAAggAAABVwZXJtaXQtWDExLWZvcndhcmRpbmcAAAAAAAAAF3Blcm1pdC1hZ2VudC1mb3J3YXJkaW5nAAAAAAAAABZwZXJtaXQtcG9ydC1mb3J3YXJkaW5nAAAAAAAAAApwZXJtaXQtcHR5AAAAAAAAAA5wZXJtaXQtdXNlci1yYwAAAAAAAAAAAAAArAAAABNlY2RzYS1zaGEyLW5pc3RwNTIxAAAACG5pc3RwNTIxAAAAhQQAfv15s+G2xg56J+audKAM4G9qOTFrbZRo0CTwvkb/oHrf9/2RSWqYsx/0m5mYCZVlecnZqwRHAOolXbc/Yb4cGjsALUj3UDirsnYR7Ve+SwnunkpvW/H3a98sA3sS+HCpd5RbpfWClSBOI9JEAlPtS1CrEQ7EmO7hmlFOH2cL0qfHCyYAAACnAAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAACMAAAAQgGxnhh8z8LNk5pMw0D9InyEtVRm8OJi23XEhqj/ieT/BsLZXbu65UAcMjrUn6DPdERxF9Dwe9pdIAWOLLjLHYEFBQAAAEIAlxz+XjUKa9Q2vpH0y8IgJMm0H1hTBUM1DQEoL8No1BVtgtIO20mac2fE3I35JxNDmmXoW+FuzmJnyrY9rxY+YXM= key_ecdsa_signed.pub
diff --git a/libssh2/tests/key_ecdsa_signed.pub b/libssh2/tests/key_ecdsa_signed.pub
new file mode 100644
index 00000000..88866545
--- /dev/null
+++ b/libssh2/tests/key_ecdsa_signed.pub
@@ -0,0 +1 @@
+ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBG/X9+c3VK4iSDbbaNifJKognzwnkzdsHokZ6WgqEi+dl085JUW4UGO4Xs0+sauybztCy1AVsOIuEiVwM0cirRWFLmK0c0yO0LpiZFHHuaVBJc9tFEXkxyXG8MkIzIAhqA== key_ecdsa_signed
diff --git a/libssh2/tests/key_ed25519 b/libssh2/tests/key_ed25519
index bfb1ad56..bdf07a8e 100644
--- a/libssh2/tests/key_ed25519
+++ b/libssh2/tests/key_ed25519
@@ -1,7 +1,7 @@
 -----BEGIN OPENSSH PRIVATE KEY-----
 b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6JgAAAJg8nvUxPJ71
-MQAAAAtzc2gtZWQyNTUxOQAAACCMbXcoNmUVxO9FMMj1VB91MnwwVfBl+XDxet+j+oY6Jg
-AAAECnhCuTDYdz3kUn48BXkaCXXdbKdH7wSIQ/CUx1cbnR0Ixtdyg2ZRXE70UwyPVUH3Uy
-fDBV8GX5cPF636P6hjomAAAAEHdpbGxAaUN1YmUubG9jYWwBAgMEBQ==
+QyNTUxOQAAACBRINCCN823NclhoUcyHOSsE0ZZsddEUD9LEut/taDD4gAAAJDgVkFO4FZB
+TgAAAAtzc2gtZWQyNTUxOQAAACBRINCCN823NclhoUcyHOSsE0ZZsddEUD9LEut/taDD4g
+AAAECD4khMmQkiGtn/wwcwqKNRo3oCetwMOOlhli8S8So8OVEg0II3zbc1yWGhRzIc5KwT
+Rlmx10RQP0sS63+1oMPiAAAAC2tleV9lZDI1NTE5AQI=
 -----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/key_ed25519.pub b/libssh2/tests/key_ed25519.pub
index cd592194..ccc3b90f 100644
--- a/libssh2/tests/key_ed25519.pub
+++ b/libssh2/tests/key_ed25519.pub
@@ -1 +1 @@
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom
+ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFEg0II3zbc1yWGhRzIc5KwTRlmx10RQP0sS63+1oMPi key_ed25519
diff --git a/libssh2/tests/key_rsa_aes256gcm b/libssh2/tests/key_rsa_aes256gcm
new file mode 100644
index 00000000..021d7b3a
--- /dev/null
+++ b/libssh2/tests/key_rsa_aes256gcm
@@ -0,0 +1,28 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAAFmFlczI1Ni1nY21Ab3BlbnNzaC5jb20AAAAGYmNyeXB0AA
+AAGAAAABAmOIAmfR0iPtpLznIb9WCyAAAAEAAAAAEAAAEXAAAAB3NzaC1yc2EAAAADAQAB
+AAABAQDD+1l4u2KtpvsP2EpioqgHjfirT7IIQOQfCsjZCppmLUcPE1/qCC7krqjzaQ3nuK
+lVEc/pKJrti2oc0tBDp6zzr8pPkmzdMtpjP84RkJZwu6eVZyZqQrjpmwjw7IWVbGoxkKFp
+WS2ndxCzhoD/F+TW2NcjpwFN53Ktq0SdHVUXU00RlzUiKNTdzanb8vyF3m+PGwIWPX92E2
+t/31WxRVXwybTdpXSzyz9IIjxMkrSRVa8XzX0EyUzETuiAeU94AWJX5Gu/pFJT6E7VEMQu
+deN4iI75WYGxrYU1HCOTnsYk/9LCdM7O6ntJIlzul3CwXsD6+B35hu5AJb91RNbHYWUzAA
+AD0HUCt7WrNYthfkq/kHld0SbsL6Eb6fu3iMWtXrRAi1/9sV5520u3NNjPwdFWSe4rWPGO
+uBUW+zwquU1Ob9JIsgMwBtGSCrx6UOhPEMsJF76HRkkgRow9tLZkFB7YZf6RLUALIg12Sf
+lv0YEAOZZejp2m7866ABYpcju0AsJ9M6p3H8vd5SK2KVyybV0ITKeetUNctCEw/sxQQN6d
+p/pPbDFf5NiC4MPctdjM+PzkXOQ1Aw6kkkmz1TsfN6wyjuCKR1fMzloCc5WVC5LAtMd+sN
+cVJmBKe2tVVHSsN+z0MuU9zb1XLi9cvSl/S2MGQFU1KFr8GTG+WYkS/BUeNUup8oxYKWNZ
+LQYUpqs5dGoLWgxNDTrXnFoT5QaSob9FSANaJdT/bjL7Dtvnmakwd1nR1ZDDENUpWFjUAM
+yEavga1xS2tWhMNqRLzhoszyvAykdYXoKHj7ovWwXA6d6WVrlaP7zLxPScD3ML9qfLp2DY
+IMM7WDFmzPiSyI731dN7xoBroblaGInM8JK8B6gpS+QvLj7UcmNdQldHRgT/2KsK5K2Cn3
+16gHKUG2vnqzASJ6IrqII/H557t0Ded27SB5ZMP2adyMRDwBJNMlCGhJmbYECdzr+1eJU3
+1FQTV7Iz6+XNmEK3QdC5qCrGzem6GPm3j1FpuDYS5Z7AszfVPCeJr031ePcH6JZOMa09A0
+Zfcv2/+lyIpt713m9pTMnbfTEbxa2EVquVnSG+YyknASMnqw/DAT5n3/Zx9sO7RefrrNHx
+MhOG5Pg1TIb1gr0W5R/f+0evqftJTLDvP7z5cbsqBlKpIc5jnWuV/kvDhltN2Ty6FjSRlX
+kdf/Cgig7xKxcgd4iC98ThvcHaGjkAu4vD2G6tCVE/vEhq6rkhTsTS/OwKUC8Wd/Agf02S
+2MRl7cocSqZAJQDiLIWwDIg8hrAV67WqLZi82v4tH+TwjcUnP/JHFI0ZQkcQF203sGml77
+YC2qS/km1AMj4J4E8i6qLWM3gKuo7ZOvigDQfCGY0VLmuPugI0UKBhiVK7yyKdAfO5CM3d
+S6c2dNk7AHXI2AdtoFNe227rutuVV1JFzK9si6ZEo6SrcqigPq7WcKjkzrEIVFXxfnj1c2
+sYQ8gWlzHO3WvSM7/+9vpv0yQEHT1iysjkWscIPEQqkJ7LizXhq8MWp7NRlyIY6/CcqAzX
+mgIHD2WnoZ/4EzR6tgewWdaIoduiGbO3q7E06sw+2VGwFDXYfOIQjFgvm/fJu4BGRB1dbW
+HfPJ4F59jHjnnxse44PkztJ3IydvQ4RvM/zoUPa6RMCZTkYnJ0SsgnRoli5+UNNWbf
+-----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/key_rsa_aes256gcm.pub b/libssh2/tests/key_rsa_aes256gcm.pub
new file mode 100644
index 00000000..19b8dfd3
--- /dev/null
+++ b/libssh2/tests/key_rsa_aes256gcm.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDD+1l4u2KtpvsP2EpioqgHjfirT7IIQOQfCsjZCppmLUcPE1/qCC7krqjzaQ3nuKlVEc/pKJrti2oc0tBDp6zzr8pPkmzdMtpjP84RkJZwu6eVZyZqQrjpmwjw7IWVbGoxkKFpWS2ndxCzhoD/F+TW2NcjpwFN53Ktq0SdHVUXU00RlzUiKNTdzanb8vyF3m+PGwIWPX92E2t/31WxRVXwybTdpXSzyz9IIjxMkrSRVa8XzX0EyUzETuiAeU94AWJX5Gu/pFJT6E7VEMQudeN4iI75WYGxrYU1HCOTnsYk/9LCdM7O6ntJIlzul3CwXsD6+B35hu5AJb91RNbHYWUz key_rsa_aes256gcm
diff --git a/libssh2/tests/key_rsa_openssh.pub b/libssh2/tests/key_rsa_openssh.pub
index 9fc4ac27..ecd00790 100644
--- a/libssh2/tests/key_rsa_openssh.pub
+++ b/libssh2/tests/key_rsa_openssh.pub
@@ -1 +1 @@
-ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTe1lN2L/yet0Ma1JzXkQf3t1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJWuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVPEYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9azgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoR will@iCube.local
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTe1lN2L/yet0Ma1JzXkQf3t1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJWuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVPEYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9azgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoR
diff --git a/libssh2/tests/key_rsa_sha2_256_signed b/libssh2/tests/key_rsa_sha2_256_signed
new file mode 100644
index 00000000..4d1c38b0
--- /dev/null
+++ b/libssh2/tests/key_rsa_sha2_256_signed
@@ -0,0 +1,49 @@
+-----BEGIN OPENSSH PRIVATE KEY-----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+-----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/key_rsa_sha2_256_signed-cert.pub b/libssh2/tests/key_rsa_sha2_256_signed-cert.pub
new file mode 100644
index 00000000..1f8ec62d
--- /dev/null
+++ b/libssh2/tests/key_rsa_sha2_256_signed-cert.pub
@@ -0,0 +1 @@
+ssh-rsa-cert-v01@openssh.com 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 key_rsa_sha2_256_signed
diff --git a/libssh2/tests/key_rsa_sha2_256_signed.pub b/libssh2/tests/key_rsa_sha2_256_signed.pub
new file mode 100644
index 00000000..09f92300
--- /dev/null
+++ b/libssh2/tests/key_rsa_sha2_256_signed.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCp0vxjWDhHiT2u0j7Eor+iLjqfGvx0tGNu//VKW/sLKPnRiR+Ate4adBPSDxrQ6tEkrwQEn48FnUknoXMDum87XRK5hu4b7ukizI9PXHk/dh4J70WAVVB3sTukSKy7/V06EdwDsMtG02l20aVdBcDeGVkMWT4OX/aKhKoxljm4OUsx6/JMVHScQA7BPdVuC+RnN64RQMKLAHPNzIpwR6wdO+lRTZajz9nekcldm+YF7bac7aNUYwEilMriFYgLvvr7QV5W2diZDVRzk2G+6avCYfCCo49P24NJv86ab+S1GsvQkFsTfaTWLKxpAc5A6juRTtvLTBy7ko/XrtRWzJJnhcpSMiYSmyYMqHr6oDR4bnHs2r8nwoUUDfdz9hgnjR2clBkkDjju8MVkcWlD4atZCq2EdHCMPbHsoaRkVrJ4vwYOjuUtzwGxwLzWliBWZTAS4DI1moJX+pCmDshxnIih1TZl+wcUPJgLHIog7cqb7g3GG3AXCrb0eltAI5D7hubuRY6DinUD1moAyjP35QjKwVVPlK0IbF75fCNfIwbTorYZuKh4Fd0bW8DY2/Ev1oH48n1fJvYzI6cywTWl96bzQRYR3kAu1wwYyi2DpyW8qTcPTcfNlw7dRSwIgGSbzOg9XYjCnosN6asmyl9JMVXbC07+PkWtl51kRFDcdRY46w== key_rsa_sha2_256_signed
diff --git a/libssh2/tests/key_rsa_signed b/libssh2/tests/key_rsa_signed
new file mode 100644
index 00000000..6ece64b8
--- /dev/null
+++ b/libssh2/tests/key_rsa_signed
@@ -0,0 +1,49 @@
+-----BEGIN OPENSSH PRIVATE KEY-----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+-----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/key_rsa_signed-cert.pub b/libssh2/tests/key_rsa_signed-cert.pub
new file mode 100644
index 00000000..de7a8301
--- /dev/null
+++ b/libssh2/tests/key_rsa_signed-cert.pub
@@ -0,0 +1 @@
+ssh-rsa-cert-v01@openssh.com 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 key_rsa_signed
diff --git a/libssh2/tests/key_rsa_signed.pub b/libssh2/tests/key_rsa_signed.pub
new file mode 100644
index 00000000..d8ae239f
--- /dev/null
+++ b/libssh2/tests/key_rsa_signed.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCwMtW6rz83hgCKqV1Xf2KPgtWA5pkVA3jY4CosgWsV8rjwSpq+AMmB1wzVdTT/zrEEyy2iLoIwiAXQ7wlpo1QQWklnChIdlbaxg+F0UullsYIYoExrL+9YMwRGwmd00yIe/POHlBCa10qeBWfdMmjt5ZDlakPVYwFjvK5lZ0UW1FM1ucqX5HoIPhVONfReZonCP+jwvin44IMaqtdaSy4k71Qq7RuRbMYeTzpNaxv2CbxubvY5E7wlDrT47e25Dn/XeoV2VEX9T87ZAMnwmeyDbKW2Dv48l4Zze3Y8veUojfH3NlA/F9+1PwdTlqKsf45E/VVLyTTtn1KJy2hLyuav8Qt6Wgew41G2F9alDJab11urcogRiHyI/oPo0c6Km1vieF7IfW72yE5TFTZtbzSNS+W0GCo1xh4TUx8bBNXHO4+mDFt2gNCgX+Hf64FlPqM0kaZSUtBVKrWSupgTbMSXfHbRV5NJvSdGpPUWeFD1ifxYcPhxwJlznTXVQumEglDueIMsnE8yKEYjREtuao8/r9+ORtqf9OPZsT9j+bwROevLFnKZkzfD9xYQyU2aMrRDuo8R6SD7SiI6tXRwlohdflXA6ng9RTNyqVROQDOJ94bGPD5b4Bbnm31s2GhhWjoByQGlkNW4BRDEJmgG9sE8ztAxl7d8CV2V93BOisaPkw== key_rsa_signed
diff --git a/libssh2/tests/libssh2_config_cmake.h.in b/libssh2/tests/libssh2_config_cmake.h.in
deleted file mode 100644
index 4df27ecd..00000000
--- a/libssh2/tests/libssh2_config_cmake.h.in
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (c) 2014 Alexander Lamaison <alexander.lamaison@gmail.com>
- *
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-/* Headers */
-#cmakedefine HAVE_UNISTD_H
-#cmakedefine HAVE_INTTYPES_H
-#cmakedefine HAVE_SYS_PARAM_H
-#cmakedefine HAVE_SYS_SOCKET_H
-#cmakedefine HAVE_ARPA_INET_H
-#cmakedefine HAVE_NETINET_IN_H
-#cmakedefine HAVE_WINDOWS_H
-#cmakedefine HAVE_WINSOCK2_H
-#cmakedefine HAVE_SNPRINTF
-
-/* snprintf not in Visual Studio CRT and _snprintf dangerously incompatible.
-   We provide a safe wrapper if snprintf not found */
-#ifndef HAVE_SNPRINTF
-#include <stdio.h>
-#include <stdarg.h>
-/* Want safe, 'n += snprintf(b + n ...)' like function. If cp_max_len is 1
-* then assume cp is pointing to a null char and do nothing. Returns number
-* number of chars placed in cp excluding the trailing null char. So for
-* cp_max_len > 0 the return value is always < cp_max_len; for cp_max_len
-* <= 0 the return value is 0 (and no chars are written to cp). */
-static int snprintf(char *cp, int cp_max_len, const char *fmt, ...)
-{
-    va_list args;
-    int n;
-
-    if (cp_max_len < 2)
-        return 0;
-    va_start(args, fmt);
-    n = vsnprintf(cp, cp_max_len, fmt, args);
-    va_end(args);
-    return (n < cp_max_len) ? n : (cp_max_len - 1);
-}
-
-#define HAVE_SNPRINTF
-#endif
diff --git a/libssh2/tests/mansyntax.sh b/libssh2/tests/mansyntax.sh
index dd4aa773..73a0b4b3 100755
--- a/libssh2/tests/mansyntax.sh
+++ b/libssh2/tests/mansyntax.sh
@@ -1,37 +1,45 @@
 #!/bin/sh
+# Copyright (C) The libssh2 project and its contributors.
+# SPDX-License-Identifier: BSD-3-Clause
+
 set -e
+set -u
 
 # Written by Mikhail Gusarov
 #
 # Run syntax checks for all manpages in the documentation tree.
 #
+# Requirement on macOS: brew install man-db
+#
+
+command -v gman >/dev/null 2>&1 && man() { gman "$@"; }
 
-srcdir=${srcdir:-$PWD}
-dstdir=${builddir:-$PWD}
-mandir=${srcdir}/../docs
+dstdir="${builddir:-$PWD}"
+mandir="$(dirname "$0")/../docs"
+
+ec=0
 
 #
 # Only test if suitable man is available
 #
-if ! man --help | grep -q warnings; then
-  echo "man version not suitable, skipping tests"
-  exit 0
+if command -v grep >/dev/null 2>&1 && \
+   man --help 2>/dev/null | grep -q warnings; then
+
+  trap 'rm -f "$dstdir/man3"' EXIT HUP INT TERM
+
+  ln -sf "$mandir" "$dstdir/man3"
+
+  for manpage in "$mandir"/libssh2_*.*; do
+    echo "$manpage"
+    warnings=$(LANG=en_US.UTF-8 MANWIDTH=80 man -M "$dstdir" --warnings \
+      -E UTF-8 -l "$manpage" >/dev/null 2>&1)
+    if [ -n "$warnings" ]; then
+      echo "$warnings"
+      ec=1
+    fi
+  done
+else
+  echo 'mansyntax: Required tool not found, skipping tests.'
 fi
 
-ec=0
-
-trap "rm -f $dstdir/man3" EXIT
-
-ln -sf "$mandir" "$dstdir/man3"
-
-for manpage in $mandir/libssh2_*.*; do
-  echo "$manpage"
-  warnings=$(LANG=en_US.UTF-8 MANWIDTH=80 man -M "$dstdir" --warnings \
-    -E UTF-8 -l "$manpage" 2>&1 >/dev/null)
-  if [ -n "$warnings" ]; then
-    echo "$warnings"
-    ec=1
-  fi
-done
-
-exit $ec
+exit "$ec"
diff --git a/libssh2/tests/openssh_fixture.c b/libssh2/tests/openssh_fixture.c
index 0480c5d5..1ec9ef9f 100644
--- a/libssh2/tests/openssh_fixture.c
+++ b/libssh2/tests/openssh_fixture.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,38 +33,62 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#include "session_fixture.h"
 #include "openssh_fixture.h"
-#include "libssh2_config.h"
 
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
 #endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
 #ifdef HAVE_ARPA_INET_H
 #include <arpa/inet.h>
 #endif
 #ifdef HAVE_NETINET_IN_H
 #include <netinet/in.h>
 #endif
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <ctype.h>
+
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <stdarg.h>
+#include <ctype.h>
+
+#if defined(_WIN32) && defined(_WIN64)
+#define LIBSSH2_SOCKET_MASK "%lld"
+#else
+#define LIBSSH2_SOCKET_MASK "%d"
+#endif
+
+#ifdef LIBSSH2_WINDOWS_UWP
+#define popen(x, y) (NULL)
+#define pclose(x) (-1)
+#elif defined(_WIN32)
+#define popen _popen
+#define pclose _pclose
+#endif
+
+static int have_docker = 0;
+
+int openssh_fixture_have_docker(void)
+{
+    return have_docker;
+}
+
+static int run_command_varg(char **output, const char *command, va_list args)
+    LIBSSH2_PRINTF(2, 0);
 
 static int run_command_varg(char **output, const char *command, va_list args)
 {
+    static const char redirect_stderr[] = "%s 2>&1";
+
     FILE *pipe;
-    char redirect_stderr[] = "%s 2>&1";
     char command_buf[BUFSIZ];
-    char buf[BUFSIZ];
+    char buf[BUFSIZ + sizeof(redirect_stderr)];
     int ret;
     size_t buf_len;
 
@@ -91,12 +115,8 @@ static int run_command_varg(char **output, const char *command, va_list args)
         return -1;
     }
 
-    fprintf(stdout, "Command: %s\n", command);
-#ifdef WIN32
-    pipe = _popen(buf, "r");
-#else
+    fprintf(stdout, "Command: %s\n", command_buf);
     pipe = popen(buf, "r");
-#endif
     if(!pipe) {
         fprintf(stderr, "Unable to execute command '%s'\n", command);
         return -1;
@@ -104,16 +124,12 @@ static int run_command_varg(char **output, const char *command, va_list args)
     buf[0] = 0;
     buf_len = 0;
     while(buf_len < (sizeof(buf) - 1) &&
-        fgets(&buf[buf_len], sizeof(buf) - buf_len, pipe) != NULL) {
+        fgets(&buf[buf_len], (int)(sizeof(buf) - buf_len), pipe)) {
         buf_len = strlen(buf);
     }
 
-#ifdef WIN32
-    ret = _pclose(pipe);
-#else
     ret = pclose(pipe);
-#endif
-    if(ret != 0) {
+    if(ret) {
         fprintf(stderr, "Error running command '%s' (exit %d): %s\n",
                 command, ret, buf);
     }
@@ -122,7 +138,7 @@ static int run_command_varg(char **output, const char *command, va_list args)
         /* command output may contain a trailing newline, so we trim
          * whitespace here */
         size_t end = strlen(buf);
-        while(end > 0 && isspace(buf[end - 1])) {
+        while(end > 0 && isspace((int)buf[end - 1])) {
             buf[end - 1] = '\0';
         }
 
@@ -131,6 +147,9 @@ static int run_command_varg(char **output, const char *command, va_list args)
     return ret;
 }
 
+static int run_command(char **output, const char *command, ...)
+    LIBSSH2_PRINTF(2, 3);
+
 static int run_command(char **output, const char *command, ...)
 {
     va_list args;
@@ -143,10 +162,33 @@ static int run_command(char **output, const char *command, ...)
     return ret;
 }
 
+static const char *openssh_server_image(void)
+{
+    return getenv("OPENSSH_SERVER_IMAGE");
+}
+
 static int build_openssh_server_docker_image(void)
 {
-    return run_command(NULL, "docker build -t libssh2/openssh_server "
-                             "openssh_server");
+    if(have_docker) {
+        const char *container_image_name = openssh_server_image();
+        if(container_image_name) {
+            int ret = run_command(NULL, "docker pull %s",
+                                  container_image_name);
+            if(ret == 0) {
+                ret = run_command(NULL, "docker tag %s libssh2/openssh_server",
+                                  container_image_name);
+                if(ret == 0) {
+                    return ret;
+                }
+            }
+        }
+        return run_command(NULL,
+                           "docker build --quiet -t libssh2/openssh_server %s",
+                           srcdir_path("openssh_server"));
+    }
+    else {
+        return 0;
+    }
 }
 
 static const char *openssh_server_port(void)
@@ -156,23 +198,33 @@ static const char *openssh_server_port(void)
 
 static int start_openssh_server(char **container_id_out)
 {
-    const char *container_host_port = openssh_server_port();
-    if(container_host_port != NULL) {
-        return run_command(container_id_out,
-                           "docker run --rm -d -p %s:22 "
-                           "libssh2/openssh_server",
-                           container_host_port);
-    }
-    else {
+    if(have_docker) {
+        const char *container_host_port = openssh_server_port();
+        if(container_host_port) {
+            return run_command(container_id_out,
+                               "docker run --rm -d -p %s:22 "
+                               "libssh2/openssh_server",
+                               container_host_port);
+        }
+
         return run_command(container_id_out,
                            "docker run --rm -d -p 22 "
                            "libssh2/openssh_server");
     }
+    else {
+        *container_id_out = strdup("");
+        return 0;
+    }
 }
 
 static int stop_openssh_server(char *container_id)
 {
-    return run_command(NULL, "docker stop %s", container_id);
+    if(have_docker) {
+        return run_command(NULL, "docker stop %s", container_id);
+    }
+    else {
+        return 0;
+    }
 }
 
 static const char *docker_machine_name(void)
@@ -180,24 +232,24 @@ static const char *docker_machine_name(void)
     return getenv("DOCKER_MACHINE_NAME");
 }
 
-static int is_running_inside_a_container()
+static int is_running_inside_a_container(void)
 {
-#ifdef WIN32
+#ifdef _WIN32
     return 0;
 #else
     const char *cgroup_filename = "/proc/self/cgroup";
-    FILE *f = NULL;
+    FILE *f;
     char *line = NULL;
     size_t len = 0;
-    ssize_t read = 0;
+    ssize_t read;
     int found = 0;
     f = fopen(cgroup_filename, "r");
-    if(f == NULL) {
+    if(!f) {
         /* Don't go further, we are not in a container */
         return 0;
     }
     while((read = getline(&line, &len, f)) != -1) {
-        if(strstr(line, "docker") != NULL) {
+        if(strstr(line, "docker")) {
             found = 1;
             break;
         }
@@ -208,9 +260,9 @@ static int is_running_inside_a_container()
 #endif
 }
 
-static unsigned int portable_sleep(unsigned int seconds)
+static void portable_sleep(unsigned int seconds)
 {
-#ifdef WIN32
+#ifdef _WIN32
     Sleep(seconds);
 #else
     sleep(seconds);
@@ -220,13 +272,13 @@ static unsigned int portable_sleep(unsigned int seconds)
 static int ip_address_from_container(char *container_id, char **ip_address_out)
 {
     const char *active_docker_machine = docker_machine_name();
-    if(active_docker_machine != NULL) {
+    if(active_docker_machine) {
 
         /* This can be flaky when tests run in parallel (see
            https://github.com/docker/machine/issues/2612), so we retry a few
            times with exponential backoff if it fails */
         int attempt_no = 0;
-        int wait_time = 500;
+        unsigned int wait_time = 500;
         for(;;) {
             int ret = run_command(ip_address_out, "docker-machine ip %s",
                                   active_docker_machine);
@@ -281,28 +333,44 @@ static int port_from_container(char *container_id, char **port_out)
     }
 }
 
-static int open_socket_to_container(char *container_id)
+static libssh2_socket_t open_socket_to_container(char *container_id)
 {
     char *ip_address = NULL;
     char *port_string = NULL;
-    unsigned long hostaddr;
-    int sock;
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
     struct sockaddr_in sin;
-    int counter = 0;
+    unsigned int counter;
+    libssh2_socket_t ret = LIBSSH2_INVALID_SOCKET;
+
+    if(have_docker) {
+        int res;
+        res = ip_address_from_container(container_id, &ip_address);
+        if(res) {
+            fprintf(stderr, "Failed to get IP address for container %s\n",
+                    container_id);
+            goto cleanup;
+        }
 
-    int ret = ip_address_from_container(container_id, &ip_address);
-    if(ret != 0) {
-        fprintf(stderr, "Failed to get IP address for container %s\n",
-                container_id);
-        ret = -1;
-        goto cleanup;
+        res = port_from_container(container_id, &port_string);
+        if(res) {
+            fprintf(stderr, "Failed to get port for container %s\n",
+                    container_id);
+            goto cleanup;
+        }
     }
-
-    ret = port_from_container(container_id, &port_string);
-    if(ret != 0) {
-        fprintf(stderr, "Failed to get port for container %s\n",
-                container_id);
-        ret = -1;
+    else {
+        const char *env;
+        env = getenv("OPENSSH_SERVER_HOST");
+        if(!env) {
+            env = "127.0.0.1";
+        }
+        ip_address = strdup(env);
+        env = openssh_server_port();
+        if(!env) {
+            env = "4711";
+        }
+        port_string = strdup(env);
     }
 
     /* 0.0.0.0 is returned by Docker for Windows, because the container
@@ -314,27 +382,25 @@ static int open_socket_to_container(char *container_id)
     }
 
     hostaddr = inet_addr(ip_address);
-    if(hostaddr == (unsigned long)(-1)) {
+    if(hostaddr == (uint32_t)(-1)) {
         fprintf(stderr, "Failed to convert %s host address\n", ip_address);
-        ret = -1;
         goto cleanup;
     }
 
     sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock <= 0) {
-        fprintf(stderr, "Failed to open socket (%d)\n", sock);
-        ret = -1;
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr,
+                "Failed to open socket (" LIBSSH2_SOCKET_MASK ")\n", sock);
         goto cleanup;
     }
 
     sin.sin_family = AF_INET;
-    sin.sin_port = htons((short)strtol(port_string, NULL, 0));
+    sin.sin_port = htons((unsigned short)strtol(port_string, NULL, 0));
     sin.sin_addr.s_addr = hostaddr;
 
     for(counter = 0; counter < 3; ++counter) {
-        if(connect(sock, (struct sockaddr *)(&sin),
-                   sizeof(struct sockaddr_in)) != 0) {
-            ret = -1;
+        if(connect(sock, (struct sockaddr*)(&sin),
+                   sizeof(struct sockaddr_in))) {
             fprintf(stderr,
                     "Connection to %s:%s attempt #%d failed: retrying...\n",
                     ip_address, port_string, counter);
@@ -345,7 +411,7 @@ static int open_socket_to_container(char *container_id)
             break;
         }
     }
-    if(ret == -1) {
+    if(ret == LIBSSH2_INVALID_SOCKET) {
         fprintf(stderr, "Failed to connect to %s:%s\n",
                 ip_address, port_string);
         goto cleanup;
@@ -358,23 +424,37 @@ static int open_socket_to_container(char *container_id)
     return ret;
 }
 
+static void close_socket_to_container(libssh2_socket_t sock)
+{
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2 /* SHUT_RDWR */);
+#ifdef _WIN32
+        closesocket(sock);
+#else
+        close(sock);
+#endif
+    }
+}
+
 static char *running_container_id = NULL;
 
-int start_openssh_fixture()
+int start_openssh_fixture(void)
 {
     int ret;
-#ifdef HAVE_WINSOCK2_H
+#ifdef _WIN32
     WSADATA wsadata;
 
     ret = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(ret != 0) {
+    if(ret) {
         fprintf(stderr, "WSAStartup failed with error: %d\n", ret);
         return 1;
     }
 #endif
 
+    have_docker = !getenv("OPENSSH_NO_DOCKER");
+
     ret = build_openssh_server_docker_image();
-    if(ret == 0) {
+    if(!ret) {
         return start_openssh_server(&running_container_id);
     }
     else {
@@ -383,19 +463,28 @@ int start_openssh_fixture()
     }
 }
 
-void stop_openssh_fixture()
+void stop_openssh_fixture(void)
 {
     if(running_container_id) {
         stop_openssh_server(running_container_id);
         free(running_container_id);
         running_container_id = NULL;
     }
-    else {
-        fprintf(stderr, "Cannot stop container - none started");
+    else if(have_docker) {
+        fprintf(stderr, "Cannot stop container - none started\n");
     }
+
+#ifdef _WIN32
+    WSACleanup();
+#endif
 }
 
-int open_socket_to_openssh_server()
+libssh2_socket_t open_socket_to_openssh_server(void)
 {
     return open_socket_to_container(running_container_id);
 }
+
+void close_socket_to_openssh_server(libssh2_socket_t sock)
+{
+    close_socket_to_container(sock);
+}
diff --git a/libssh2/tests/openssh_fixture.h b/libssh2/tests/openssh_fixture.h
index 2d2bb0ad..eb076a14 100644
--- a/libssh2/tests/openssh_fixture.h
+++ b/libssh2/tests/openssh_fixture.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,13 +33,17 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_TESTS_OPENSSH_FIXTURE_H
 #define LIBSSH2_TESTS_OPENSSH_FIXTURE_H
 
-int start_openssh_fixture();
-void stop_openssh_fixture();
-int open_socket_to_openssh_server();
+int start_openssh_fixture(void);
+void stop_openssh_fixture(void);
+libssh2_socket_t open_socket_to_openssh_server(void);
+void close_socket_to_openssh_server(libssh2_socket_t sock);
+int openssh_fixture_have_docker(void);
 
 #endif
diff --git a/libssh2/tests/openssh_server/Dockerfile b/libssh2/tests/openssh_server/Dockerfile
index c5ce2224..4099501f 100644
--- a/libssh2/tests/openssh_server/Dockerfile
+++ b/libssh2/tests/openssh_server/Dockerfile
@@ -1,79 +1,53 @@
-# Copyright (c) 2016 Alexander Lamaison <alexander.lamaison@gmail.com>
-#
-# 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 any other contributors may be used to endorse or
-#   promote products derived from this software without
-#   specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-# OF SUCH DAMAGE.
-
-FROM debian:jessie
+# Copyright (C) Alexander Lamaison <alexander.lamaison@gmail.com>
+# SPDX-License-Identifier: BSD-3-Clause
+
+FROM debian:testing-slim
 
 RUN apt-get update \
  && apt-get install -y openssh-server \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*
-RUN mkdir /var/run/sshd
+RUN [ -d /var/run/sshd ] || mkdir /var/run/sshd
 
 # Chmodding because, when building on Windows, files are copied in with
 # -rwxr-xr-x permissions.
 #
 # Copying to a temp location, then moving because chmodding the copied file has
 # no effect (Docker AUFS-related bug maybe?)
+
+# Host keys
 COPY ssh_host_rsa_key /tmp/etc/ssh/ssh_host_rsa_key
-RUN mv /tmp/etc/ssh/ssh_host_rsa_key /etc/ssh/ssh_host_rsa_key
-RUN chmod 600 /etc/ssh/ssh_host_rsa_key
+RUN install -m 0600 /tmp/etc/ssh/ssh_host_rsa_key /etc/ssh/ssh_host_rsa_key
 
 COPY ssh_host_ecdsa_key /tmp/etc/ssh/ssh_host_ecdsa_key
-RUN mv /tmp/etc/ssh/ssh_host_ecdsa_key /etc/ssh/ssh_host_ecdsa_key
-RUN chmod 600 /etc/ssh/ssh_host_ecdsa_key
+RUN install -m 0600 /tmp/etc/ssh/ssh_host_ecdsa_key /etc/ssh/ssh_host_ecdsa_key
 
 COPY ssh_host_ed25519_key /tmp/etc/ssh/ssh_host_ed25519_key
-RUN mv /tmp/etc/ssh/ssh_host_ed25519_key /etc/ssh/ssh_host_ed25519_key
-RUN chmod 600 /etc/ssh/ssh_host_ed25519_key
-
-COPY ca_ecdsa.pub /tmp/etc/ssh/ca_ecdsa.pub
-RUN mv /tmp/etc/ssh/ca_ecdsa.pub /etc/ssh/ca_ecdsa.pub
-RUN chmod 600 /etc/ssh/ca_ecdsa.pub
+RUN install -m 0600 /tmp/etc/ssh/ssh_host_ed25519_key /etc/ssh/ssh_host_ed25519_key
 
+# Trusted CA keys
 COPY ca_ecdsa /tmp/etc/ssh/ca_ecdsa
-RUN mv /tmp/etc/ssh/ca_ecdsa /etc/ssh/ca_ecdsa
-RUN chmod 600 /etc/ssh/ca_ecdsa
+RUN install -m 0600 /tmp/etc/ssh/ca_ecdsa /etc/ssh/ca_ecdsa
+
+COPY ca_rsa /tmp/etc/ssh/ca_rsa
+RUN install -m 0600 /tmp/etc/ssh/ca_rsa /etc/ssh/ca_rsa
 
+COPY ca_user_keys.pub /tmp/etc/ssh/ca_user_keys.pub
+RUN install -m 0600 /tmp/etc/ssh/ca_user_keys.pub /etc/ssh/ca_user_keys.pub
+
+# User
 RUN adduser --disabled-password --gecos 'Test user for libssh2 integration tests' libssh2
 RUN echo 'libssh2:my test password' | chpasswd
 
-RUN sed -i 's/ChallengeResponseAuthentication no/ChallengeResponseAuthentication yes/' /etc/ssh/sshd_config
-RUN echo "TrustedUserCAKeys /etc/ssh/ca_ecdsa.pub" >> /etc/ssh/sshd_config
+# Config
+RUN sed -i 's/KbdInteractiveAuthentication no/KbdInteractiveAuthentication yes/' /etc/ssh/sshd_config
+COPY sshd_config /tmp/etc/ssh/sshd_config
+RUN cat /tmp/etc/ssh/sshd_config >> /etc/ssh/sshd_config
+RUN echo 'TrustedUserCAKeys /etc/ssh/ca_user_keys.pub' >> /etc/ssh/sshd_config
+
 
 # SSH login fix. Otherwise user is kicked off after login
-RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
+RUN sed 's/session\s*required\s*pam_loginuid.so/session optional pam_loginuid.so/g' -i /etc/pam.d/sshd
 
 USER libssh2
 
@@ -81,8 +55,7 @@ RUN mkdir -p /home/libssh2/.ssh
 RUN mkdir -p /home/libssh2/sandbox
 
 COPY authorized_keys /tmp/libssh2/.ssh/authorized_keys
-RUN cp /tmp/libssh2/.ssh/authorized_keys /home/libssh2/.ssh/authorized_keys
-RUN chmod 600 /home/libssh2/.ssh/authorized_keys
+RUN install -m 0600 /tmp/libssh2/.ssh/authorized_keys /home/libssh2/.ssh/authorized_keys
 
 USER root
 
diff --git a/libssh2/tests/openssh_server/authorized_keys b/libssh2/tests/openssh_server/authorized_keys
index cdd6eef5..c1146152 100644
--- a/libssh2/tests/openssh_server/authorized_keys
+++ b/libssh2/tests/openssh_server/authorized_keys
@@ -2,6 +2,7 @@ ssh-dss AAAAB3NzaC1kc3MAAACBAK2Jh2Ck+8W1+LsFrjgOIH7XHySiONPSdG+faFTZprinh9cjyR3o
 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAnak1T7zHJ+hVRFBDQ9pf1KVzmd5gaNc7y7NPmL13aOG3sYeJevi1x1WM/R3tb8XnUnzZUX9GJN0MYovvZsw9bknG1mDP72LFbGp/gzPddGIKHBBpvceDaJ85sM/ME3XOtD7uuXQuNAuEHwEzSMMiSIEMcQS+lXIcMLr5xPLEkyNvqsO5RqSjMTLHKHgY8gLWx7oQ1avokhwuDxF7P3Pqtj+rW2Te6vR0i1H6EyFPsBkzkgNXb33cus8M1CnTmYTSgJgmHO2LLcGpjQ5sL8T/PWIWHaSqTnkrFXEMysgoteXnAYILjzyBaqq2WV4KA3TluGdAP2p8gC32QtKmIuis3Q== awl03@bounty
 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC92YlGoc4PJy6DzX916JJZhxkvmkWBLGJdWOL7R9B6iaYEKebBxzTE3P1RcnxnuI06kklVq/KcDP9sLlgawTZcDg7ifM7HncPOi18OON8vvVVzodikHzuupjhpI5YTT9wwV2fDVi2URsBjvX4AFiZ5WM3/NwqdKpYABzWieBikXGJ58Tsnw+zQw2qMmKKESBuzSN538loTAj5iEH/GAKYDbbH9t2a17qhNCNEw4vrtURT9JqwO1cOg7N1OKpmqCPEbK0wuSTljNC230VJ06X/8UqahWWSH6MreGy6gwpPi6i9wFiFLur301R0dTPiKVhz6bguhcC1EAlhSgjfelFJt awl03@bounty
 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDTe1lN2L/yet0Ma1JzXkQf3t1f+pauALec2FsGZy87KRJW1AOxcTTiePjlFwP1yfSK1lWXQ+uf0b61gkKqqR52FDky24HJWuYlfXlEQMn2d/PNDNVDDbO4TXKyNxxUHFJ6qYMNd4kWjOH+6rmYoWKsWV+3mDRbHagbVPEYL8wep8OTqKOqruVLVPzZyYZkBtn4XOFi6UE8WKiSVdK1Am1O5UxvlD95t32eYch6wQ9azgMqja6spe/L5UJgP83QZFknVC3wPZWkjqomVFql0FpaQclENwyY/OZMxr0cT/f7bCL6s4A/1XpbsGmC0xak4/THHbOn+0LdIej2nGV8JFoR
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDD+1l4u2KtpvsP2EpioqgHjfirT7IIQOQfCsjZCppmLUcPE1/qCC7krqjzaQ3nuKlVEc/pKJrti2oc0tBDp6zzr8pPkmzdMtpjP84RkJZwu6eVZyZqQrjpmwjw7IWVbGoxkKFpWS2ndxCzhoD/F+TW2NcjpwFN53Ktq0SdHVUXU00RlzUiKNTdzanb8vyF3m+PGwIWPX92E2t/31WxRVXwybTdpXSzyz9IIjxMkrSRVa8XzX0EyUzETuiAeU94AWJX5Gu/pFJT6E7VEMQudeN4iI75WYGxrYU1HCOTnsYk/9LCdM7O6ntJIlzul3CwXsD6+B35hu5AJb91RNbHYWUz key_rsa_aes256gcm
+ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFEg0II3zbc1yWGhRzIc5KwTRlmx10RQP0sS63+1oMPi
 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICHxEyUTOVHXvdMFARedFQ+H9DW/n8Zy3daKKRqnTDMq
 ecdsa-sha2-nistp384 AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBOiyJJwf+hFJrOkik9IQVxjhhVnI1vKl4BGLj03erLvw4TXXwoZzlPx6J936fU9JvvPw+d8PA4viMEfFbmdbHREKhwi3u1vZrfj0mB8SXw96AcZwX8PAL556wgom+/Qx+Q==
diff --git a/libssh2/tests/openssh_server/ca_rsa b/libssh2/tests/openssh_server/ca_rsa
new file mode 100644
index 00000000..8b5aa57c
--- /dev/null
+++ b/libssh2/tests/openssh_server/ca_rsa
@@ -0,0 +1,38 @@
+-----BEGIN OPENSSH PRIVATE KEY-----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+-----END OPENSSH PRIVATE KEY-----
diff --git a/libssh2/tests/openssh_server/ca_rsa.pub b/libssh2/tests/openssh_server/ca_rsa.pub
new file mode 100644
index 00000000..7c6be996
--- /dev/null
+++ b/libssh2/tests/openssh_server/ca_rsa.pub
@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDEiBsRlsihCg0nJGNqURhszCZw1FwZmDpkD64L6HFf2U/GFXFgDBtYJZ8zdgua+RA9F/QNhq14OUemJX39HggAox/Acwg1vKPm6WPYAb3DMyzXT4ws32SbFd5ld/sQrqJUeMxaFLu1f02eY0UttQe4+nMjoM4Me98Qho7TzgpDIgn9nls42Sjt6KM9muqTBIVv4USwi9IsFn+54e0CEjfgiFyU8/8bH6vp1rtMPA6m4vuidyt2pP7PHFnUnikQGsaG4ldO/D/G0FFtMqPXeC1wQXI5RHnRns9TiI6Ep3r3h64ZI5iBYZeG16Fk+nuGvtp+WLWE5m01vfEHc5o+p09j+Ni1mQ5pmUq3AOM/MZMh+eCkTstnCyng/bHEZTIKQi1nnu694Mcq8W1v34wgMyBN3bvE65NhjIdLubnHvDgzVn127wjPEdeVD9ShtACxNS4a6xJCWg6llHVyzezqnj68umXre02MsXLbFikV/fEvUOXUp/rDeo+LJizk2bHAlyk= ca_rsa
diff --git a/libssh2/tests/openssh_server/ca_user_keys.pub b/libssh2/tests/openssh_server/ca_user_keys.pub
new file mode 100644
index 00000000..19ec03f3
--- /dev/null
+++ b/libssh2/tests/openssh_server/ca_user_keys.pub
@@ -0,0 +1,2 @@
+ecdsa-sha2-nistp521 AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBAB+/Xmz4bbGDnon5q50oAzgb2o5MWttlGjQJPC+Rv+get/3/ZFJapizH/SbmZgJlWV5ydmrBEcA6iVdtz9hvhwaOwAtSPdQOKuydhHtV75LCe6eSm9b8fdr3ywDexL4cKl3lFul9YKVIE4j0kQCU+1LUKsRDsSY7uGaUU4fZwvSp8cLJg== CA
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDEiBsRlsihCg0nJGNqURhszCZw1FwZmDpkD64L6HFf2U/GFXFgDBtYJZ8zdgua+RA9F/QNhq14OUemJX39HggAox/Acwg1vKPm6WPYAb3DMyzXT4ws32SbFd5ld/sQrqJUeMxaFLu1f02eY0UttQe4+nMjoM4Me98Qho7TzgpDIgn9nls42Sjt6KM9muqTBIVv4USwi9IsFn+54e0CEjfgiFyU8/8bH6vp1rtMPA6m4vuidyt2pP7PHFnUnikQGsaG4ldO/D/G0FFtMqPXeC1wQXI5RHnRns9TiI6Ep3r3h64ZI5iBYZeG16Fk+nuGvtp+WLWE5m01vfEHc5o+p09j+Ni1mQ5pmUq3AOM/MZMh+eCkTstnCyng/bHEZTIKQi1nnu694Mcq8W1v34wgMyBN3bvE65NhjIdLubnHvDgzVn127wjPEdeVD9ShtACxNS4a6xJCWg6llHVyzezqnj68umXre02MsXLbFikV/fEvUOXUp/rDeo+LJizk2bHAlyk= ca_rsa
diff --git a/libssh2/tests/openssh_server/sshd_config b/libssh2/tests/openssh_server/sshd_config
new file mode 100644
index 00000000..5cd2b898
--- /dev/null
+++ b/libssh2/tests/openssh_server/sshd_config
@@ -0,0 +1,4 @@
+HostKeyAlgorithms +ssh-rsa
+PubkeyAcceptedKeyTypes +ssh-rsa,ssh-rsa-cert-v01@openssh.com
+MACs +hmac-sha1,hmac-sha1-96,hmac-sha2-256,hmac-sha2-512,hmac-md5,hmac-md5-96,umac-64@openssh.com,umac-128@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha1-96-etm@openssh.com,hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-md5-etm@openssh.com,hmac-md5-96-etm@openssh.com,umac-64-etm@openssh.com,umac-128-etm@openssh.com
+Ciphers +3des-cbc,aes128-cbc,aes192-cbc,aes256-cbc,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com,chacha20-poly1305@openssh.com
diff --git a/libssh2/tests/ossfuzz/Makefile.am b/libssh2/tests/ossfuzz/Makefile.am
index a7e95825..b58c84cf 100644
--- a/libssh2/tests/ossfuzz/Makefile.am
+++ b/libssh2/tests/ossfuzz/Makefile.am
@@ -18,10 +18,10 @@ noinst_LIBRARIES =
 
 if USE_OSSFUZZERS
 noinst_PROGRAMS += \
-	ssh2_client_fuzzer
+  ssh2_client_fuzzer
 
 noinst_LIBRARIES += \
-	libstandaloneengine.a
+  libstandaloneengine.a
 endif
 
 ssh2_client_fuzzer_SOURCES = ssh2_client_fuzzer.cc testinput.h
@@ -30,3 +30,5 @@ ssh2_client_fuzzer_LDFLAGS = $(AM_LDFLAGS) -static
 
 libstandaloneengine_a_SOURCES = standaloneengine.cc
 libstandaloneengine_a_CXXFLAGS = $(AM_CXXFLAGS)
+
+EXTRA_DIST = ossfuzz.sh
diff --git a/libssh2/tests/ossfuzz/Makefile.in b/libssh2/tests/ossfuzz/Makefile.in
index 9fa6d259..8d7ea477 100644
--- a/libssh2/tests/ossfuzz/Makefile.in
+++ b/libssh2/tests/ossfuzz/Makefile.in
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.16.4 from Makefile.am.
+# Makefile.in generated by automake 1.16.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994-2021 Free Software Foundation, Inc.
@@ -93,19 +93,19 @@ host_triplet = @host@
 @USE_OSSFUZZ_FLAG_FALSE@@USE_OSSFUZZ_STATIC_FALSE@am__append_2 = libstandaloneengine.a
 noinst_PROGRAMS = $(am__EXEEXT_1)
 @USE_OSSFUZZERS_TRUE@am__append_3 = \
-@USE_OSSFUZZERS_TRUE@	ssh2_client_fuzzer
+@USE_OSSFUZZERS_TRUE@  ssh2_client_fuzzer
 
 @USE_OSSFUZZERS_TRUE@am__append_4 = \
-@USE_OSSFUZZERS_TRUE@	libstandaloneengine.a
+@USE_OSSFUZZERS_TRUE@  libstandaloneengine.a
 
 subdir = tests/ossfuzz
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/m4/autobuild.m4 \
-	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
-	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \
-	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
-	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/acinclude.m4 $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/m4/lib-ld.m4 \
+	$(top_srcdir)/m4/lib-link.m4 $(top_srcdir)/m4/lib-prefix.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
@@ -259,12 +259,13 @@ EGREP = @EGREP@
 ETAGS = @ETAGS@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
+FILECMD = @FILECMD@
 GREP = @GREP@
 HAVE_LIBBCRYPT = @HAVE_LIBBCRYPT@
-HAVE_LIBCRYPT32 = @HAVE_LIBCRYPT32@
 HAVE_LIBGCRYPT = @HAVE_LIBGCRYPT@
 HAVE_LIBMBEDCRYPTO = @HAVE_LIBMBEDCRYPTO@
 HAVE_LIBSSL = @HAVE_LIBSSL@
+HAVE_LIBWOLFSSL = @HAVE_LIBWOLFSSL@
 HAVE_LIBZ = @HAVE_LIBZ@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
@@ -275,30 +276,34 @@ LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBBCRYPT = @LIBBCRYPT@
 LIBBCRYPT_PREFIX = @LIBBCRYPT_PREFIX@
-LIBCRYPT32 = @LIBCRYPT32@
-LIBCRYPT32_PREFIX = @LIBCRYPT32_PREFIX@
 LIBGCRYPT = @LIBGCRYPT@
 LIBGCRYPT_PREFIX = @LIBGCRYPT_PREFIX@
 LIBMBEDCRYPTO = @LIBMBEDCRYPTO@
 LIBMBEDCRYPTO_PREFIX = @LIBMBEDCRYPTO_PREFIX@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
-LIBSREQUIRED = @LIBSREQUIRED@
-LIBSSH2VER = @LIBSSH2VER@
+LIBSSH2_CFLAG_EXTRAS = @LIBSSH2_CFLAG_EXTRAS@
+LIBSSH2_PC_LIBS = @LIBSSH2_PC_LIBS@
+LIBSSH2_PC_LIBS_PRIVATE = @LIBSSH2_PC_LIBS_PRIVATE@
+LIBSSH2_PC_REQUIRES = @LIBSSH2_PC_REQUIRES@
+LIBSSH2_PC_REQUIRES_PRIVATE = @LIBSSH2_PC_REQUIRES_PRIVATE@
+LIBSSH2_VERSION = @LIBSSH2_VERSION@
 LIBSSL = @LIBSSL@
 LIBSSL_PREFIX = @LIBSSL_PREFIX@
 LIBTOOL = @LIBTOOL@
+LIBWOLFSSL = @LIBWOLFSSL@
+LIBWOLFSSL_PREFIX = @LIBWOLFSSL_PREFIX@
 LIBZ = @LIBZ@
 LIBZ_PREFIX = @LIBZ_PREFIX@
 LIB_FUZZING_ENGINE = @LIB_FUZZING_ENGINE@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBBCRYPT = @LTLIBBCRYPT@
-LTLIBCRYPT32 = @LTLIBCRYPT32@
 LTLIBGCRYPT = @LTLIBGCRYPT@
 LTLIBMBEDCRYPTO = @LTLIBMBEDCRYPTO@
 LTLIBOBJS = @LTLIBOBJS@
 LTLIBSSL = @LTLIBSSL@
+LTLIBWOLFSSL = @LTLIBWOLFSSL@
 LTLIBZ = @LTLIBZ@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAINT = @MAINT@
@@ -320,6 +325,7 @@ PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+RC = @RC@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -391,6 +397,7 @@ ssh2_client_fuzzer_CXXFLAGS = $(AM_CXXFLAGS) $(FUZZ_FLAG)
 ssh2_client_fuzzer_LDFLAGS = $(AM_LDFLAGS) -static
 libstandaloneengine_a_SOURCES = standaloneengine.cc
 libstandaloneengine_a_CXXFLAGS = $(AM_CXXFLAGS)
+EXTRA_DIST = ossfuzz.sh
 all: all-am
 
 .SUFFIXES:
diff --git a/libssh2/tests/ossfuzz/ossfuzz.sh b/libssh2/tests/ossfuzz/ossfuzz.sh
new file mode 100755
index 00000000..032b686e
--- /dev/null
+++ b/libssh2/tests/ossfuzz/ossfuzz.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+set -eu
+
+# This script is called by the oss-fuzz main project when compiling the fuzz
+# targets. This script is regression tested by ci/ossfuzz.sh.
+
+# Save off the current folder as the build root.
+export BUILD_ROOT="$PWD"
+
+echo "CC: $CC"
+echo "CXX: $CXX"
+echo "LIB_FUZZING_ENGINE: $LIB_FUZZING_ENGINE"
+echo "CFLAGS: $CFLAGS"
+echo "CXXFLAGS: $CXXFLAGS"
+echo "OUT: $OUT"
+
+MAKEFLAGS+="-j$(nproc)"
+export MAKEFLAGS
+
+# Install dependencies
+apt-get -y install automake libtool libssl-dev zlib1g-dev
+
+# Compile the fuzzer.
+autoreconf -fi
+./configure --disable-shared \
+            --enable-ossfuzzers \
+            --disable-examples-build \
+            --enable-debug
+make V=1
+
+# Copy the fuzzer to the output directory.
+cp -v tests/ossfuzz/ssh2_client_fuzzer "$OUT/"
diff --git a/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc b/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc
index d9f5ab51..047850ea 100644
--- a/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc
+++ b/libssh2/tests/ossfuzz/ssh2_client_fuzzer.cc
@@ -1,3 +1,7 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 #include <assert.h>
 #include <errno.h>
 #include <stdbool.h>
@@ -10,12 +14,12 @@
 #include "testinput.h"
 
 #define FUZZ_ASSERT(COND)                                                     \
-        if(!(COND))                                                           \
-        {                                                                     \
-          fprintf(stderr, "Assertion failed: " #COND "\n%s",                  \
-                  strerror(errno));                                           \
-          assert((COND));                                                     \
-        }
+    if(!(COND))                                                               \
+    {                                                                         \
+      fprintf(stderr, "Assertion failed: " #COND "\n%s",                      \
+              strerror(errno));                                               \
+      assert((COND));                                                         \
+    }
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
@@ -27,7 +31,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 
   rc = libssh2_init(0);
 
-  if(rc != 0) {
+  if(rc) {
     fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
     goto EXIT_LABEL;
   }
@@ -38,7 +42,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 
   written = send(socket_fds[1], data, size, 0);
 
-  if (written != size)
+  if(written != size)
   {
     // Handle whatever error case we're in.
     fprintf(stderr, "send() of %zu bytes returned %zu (%d)\n",
@@ -49,7 +53,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
   }
 
   rc = shutdown(socket_fds[1], SHUT_WR);
-  if (rc != 0)
+  if(rc)
   {
     fprintf(stderr, "socket shutdown failed (%d)\n", rc);
     goto EXIT_LABEL;
@@ -60,6 +64,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
   if(session) {
     libssh2_session_set_blocking(session, 1);
   }
+  else {
+    goto EXIT_LABEL;
+  }
 
   if(libssh2_session_handshake(session, socket_fds[0])) {
     goto EXIT_LABEL;
@@ -70,9 +77,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 
 EXIT_LABEL:
 
-  if (session != NULL)
+  if(session)
   {
-    if (handshake_completed)
+    if(handshake_completed)
     {
       libssh2_session_disconnect(session,
                                  "Normal Shutdown, Thank you for playing");
diff --git a/libssh2/tests/ossfuzz/standaloneengine.cc b/libssh2/tests/ossfuzz/standaloneengine.cc
index 175360e4..e40cb2b2 100644
--- a/libssh2/tests/ossfuzz/standaloneengine.cc
+++ b/libssh2/tests/ossfuzz/standaloneengine.cc
@@ -1,4 +1,7 @@
-#include <stdint.h>
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -45,7 +48,7 @@ int main(int argc, char **argv)
         /* Call the fuzzer with the data. */
         LLVMFuzzerTestOneInput(buffer, buffer_len);
 
-        printf("complete !!");
+        printf("complete.");
 
         /* Free the buffer as it's no longer needed. */
         free(buffer);
diff --git a/libssh2/tests/ossfuzz/testinput.h b/libssh2/tests/ossfuzz/testinput.h
index 6ab9b515..6f9241be 100644
--- a/libssh2/tests/ossfuzz/testinput.h
+++ b/libssh2/tests/ossfuzz/testinput.h
@@ -1,3 +1,7 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 #include <inttypes.h>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
diff --git a/libssh2/tests/runner.c b/libssh2/tests/runner.c
index b9f9328d..84993979 100644
--- a/libssh2/tests/runner.c
+++ b/libssh2/tests/runner.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,19 +33,47 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include "session_fixture.h"
-
-extern int test(LIBSSH2_SESSION *session);
+#include "runner.h"
 
-int main()
+int main(void)
 {
-    int exit_code = 1;
-    LIBSSH2_SESSION *session = start_session_fixture();
-    if(session != NULL) {
-        exit_code = (test(session) == 0) ? 0 : 1;
-    }
-    stop_session_fixture();
+    int exit_code;
+    int retries = 0, retry = 0;
+
+#ifdef LIBSSH2_WINCNG
+    /* FIXME: Retry tests with WinCNG due to flakiness in hostkey
+       verification: https://github.com/libssh2/libssh2/issues/804 */
+    retries += 2;
+#endif
+
+    do {
+        int skipped, rc;
+        LIBSSH2_SESSION *session = start_session_fixture(&skipped, &rc);
+        if(session) {
+            exit_code = (test(session) == 0) ? 0 : 1;
+        }
+        else if(skipped) {
+            fprintf(stderr, "Test skipped.\n");
+            exit_code = 0;
+        }
+        else {
+            exit_code = 1;
+        }
+        stop_session_fixture();
+        if(exit_code == 0 ||
+#ifdef LIBSSH2_WINCNG
+           rc != LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE ||
+#endif
+           ++retry > retries) {
+            break;
+        }
+        fprintf(stderr, "Test failed (%d). Retrying... %d / %d\n",
+                        rc, retry, retries);
+    } while(1);
+
     return exit_code;
 }
diff --git a/libssh2/libssh2/os400/include/alloca.h b/libssh2/tests/runner.h
similarity index 86%
rename from libssh2/libssh2/os400/include/alloca.h
rename to libssh2/tests/runner.h
index ff0cee4e..926736b7 100644
--- a/libssh2/libssh2/os400/include/alloca.h
+++ b/libssh2/tests/runner.h
@@ -1,5 +1,4 @@
-/*
- * Copyright (C) 2015 Patrick Monnerat, D+H <patrick.monnerat@dh.com>
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,17 +33,17 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef LIBSSH2_ALLOCA_H
-#define LIBSSH2_ALLOCA_H
-
-/* alloca() emulation. */
+#ifndef LIBSSH2_TESTS_RUNNER_H
+#define LIBSSH2_TESTS_RUNNER_H
 
-#include <modasa.mih>
+/* Most tests need these */
+#include "session_fixture.h"
+#include <stdio.h>
 
-#define alloca(n)       _MODASA(n)
+int test(LIBSSH2_SESSION *session);
 
 #endif
-
-/* vim: set expandtab ts=4 sw=4: */
diff --git a/libssh2/tests/session_fixture.c b/libssh2/tests/session_fixture.c
index 5d8fd215..9dc32181 100644
--- a/libssh2/tests/session_fixture.c
+++ b/libssh2/tests/session_fixture.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,100 +33,178 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include "session_fixture.h"
-#include "libssh2_config.h"
 #include "openssh_fixture.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_WINDOWS_H
-#include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-#include <winsock2.h>
-#endif
 #ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
 #endif
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
 #endif
 
-LIBSSH2_SESSION *connected_session = NULL;
-int connected_socket = -1;
+#include <stdio.h>
+#include <stdlib.h>  /* for getenv() */
+#include <assert.h>
+
+static LIBSSH2_SESSION *connected_session = NULL;
+static libssh2_socket_t connected_socket = LIBSSH2_INVALID_SOCKET;
 
-static int connect_to_server()
+static int connect_to_server(void)
 {
     int rc;
     connected_socket = open_socket_to_openssh_server();
-    if(connected_socket <= 0) {
-        return -1;
+    if(connected_socket == LIBSSH2_INVALID_SOCKET) {
+        return LIBSSH2_ERROR_SOCKET_NONE;
     }
 
     rc = libssh2_session_handshake(connected_session, connected_socket);
-    if(rc != 0) {
+    if(rc) {
         print_last_session_error("libssh2_session_handshake");
-        return -1;
+        return libssh2_session_last_errno(connected_session);
     }
 
-    return 0;
+    return LIBSSH2_ERROR_NONE;
 }
 
-void setup_fixture_workdir()
-{
-    char *wd = getenv("FIXTURE_WORKDIR");
-#ifdef FIXTURE_WORKDIR
-    if(!wd) {
-        wd = FIXTURE_WORKDIR;
-    }
+/* List of crypto protocols for which tests are skipped */
+static char const *skip_crypt[] = {
+#ifdef LIBSSH2_MBEDTLS
+    /* Due to a bug with mbedTLS support, these crypt methods fail.
+       Until that bug is fixed, don't run them there to avoid this
+       known issue causing red tests.
+       See: https://github.com/libssh2/libssh2/issues/793
+     */
+    "3des-cbc",
+    "aes128-cbc",
+    "aes192-cbc",
+    "aes256-cbc",
+    "aes128-gcm@openssh.com",
+    "aes256-gcm@openssh.com",
+    "rijndael-cbc@lysator.liu.se",
 #endif
-    if(!wd) {
-#ifdef WIN32
-        char wd_buf[_MAX_PATH];
-#else
-        char wd_buf[MAXPATHLEN];
+
+#if !LIBSSH2_3DES
+    "3des-cbc",
 #endif
-        getcwd(wd_buf, sizeof(wd_buf));
-        wd = wd_buf;
-    }
 
-    chdir(wd);
-}
+#if !LIBSSH2_AES_GCM
+    /* Support for AES-GCM hasn't been added to these back-ends yet */
+    "aes128-gcm@openssh.com",
+    "aes256-gcm@openssh.com",
+#endif
+
+    NULL
+};
+
+/* List of MAC protocols for which tests are skipped */
+static char const *skip_mac[] = {
+#if !LIBSSH2_MD5
+    "hmac-md5",
+    "hmac-md5-96",
+#endif
+    NULL
+};
 
-LIBSSH2_SESSION *start_session_fixture()
+LIBSSH2_SESSION *start_session_fixture(int *skipped, int *err)
 {
     int rc;
 
-    setup_fixture_workdir();
+    const char *crypt = getenv("FIXTURE_TEST_CRYPT");
+    const char *mac = getenv("FIXTURE_TEST_MAC");
+
+    *skipped = 0;
+    *err = LIBSSH2_ERROR_NONE;
+
+    if(crypt) {
+        char const * const *sk;
+        for(sk = skip_crypt; *sk; ++sk) {
+            if(strcmp(*sk, crypt) == 0) {
+                fprintf(stderr, "unsupported crypt algorithm (%s) skipped.\n",
+                                crypt);
+                *skipped = 1;
+                return NULL;
+            }
+        }
+    }
+
+    if(mac) {
+        char const * const *sk;
+        for(sk = skip_mac; *sk; ++sk) {
+            if(strcmp(*sk, mac) == 0) {
+                fprintf(stderr, "unsupported MAC algorithm (%s) skipped.\n",
+                                mac);
+                *skipped = 1;
+                return NULL;
+            }
+        }
+    }
 
     rc = start_openssh_fixture();
-    if(rc != 0) {
+    if(rc) {
         return NULL;
     }
     rc = libssh2_init(0);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2_init failed (%d)\n", rc);
         return NULL;
     }
 
     connected_session = libssh2_session_init_ex(NULL, NULL, NULL, NULL);
-    libssh2_session_set_blocking(connected_session, 1);
-    if(connected_session == NULL) {
+    if(!connected_session) {
         fprintf(stderr, "libssh2_session_init_ex failed\n");
         return NULL;
     }
 
+    if(getenv("FIXTURE_TRACE_ALL_CONNECT")) {
+        libssh2_trace(connected_session, ~0);
+        fprintf(stdout, "Trace all enabled for connect_to_server.\n");
+    }
+    else if(getenv("FIXTURE_TRACE_ALL")) {
+        libssh2_trace(connected_session, ~0);
+        fprintf(stdout, "Trace all enabled.\n");
+    }
+
+    /* Override crypt algorithm for the test */
+    if(crypt) {
+        if(libssh2_session_method_pref(connected_session,
+                                       LIBSSH2_METHOD_CRYPT_CS, crypt) ||
+           libssh2_session_method_pref(connected_session,
+                                       LIBSSH2_METHOD_CRYPT_SC, crypt)) {
+            fprintf(stderr, "libssh2_session_method_pref CRYPT failed "
+                            "(probably disabled in the build): '%s'\n", crypt);
+            return NULL;
+        }
+    }
+
+    /* Override mac algorithm for the test */
+    if(mac) {
+        if(libssh2_session_method_pref(connected_session,
+                                       LIBSSH2_METHOD_MAC_CS, mac) ||
+           libssh2_session_method_pref(connected_session,
+                                       LIBSSH2_METHOD_MAC_SC, mac)) {
+            fprintf(stderr, "libssh2_session_method_pref MAC failed "
+                            "(probably disabled in the build): '%s'\n", mac);
+            return NULL;
+        }
+    }
+
+    libssh2_session_set_blocking(connected_session, 1);
+
     rc = connect_to_server();
-    if(rc != 0) {
+    if(rc != LIBSSH2_ERROR_NONE) {
+        *err = rc;
         return NULL;
     }
 
+    if(getenv("FIXTURE_TRACE_ALL_CONNECT")) {
+        libssh2_trace(connected_session, 0);
+    }
+
     return connected_session;
 }
 
@@ -139,21 +217,322 @@ void print_last_session_error(const char *function)
         fprintf(stderr, "%s failed (%d): %s\n", function, rc, message);
     }
     else {
-        fprintf(stderr, "No session");
+        fprintf(stderr, "No session\n");
     }
 }
 
-void stop_session_fixture()
+void stop_session_fixture(void)
 {
     if(connected_session) {
         libssh2_session_disconnect(connected_session, "test ended");
         libssh2_session_free(connected_session);
-        shutdown(connected_socket, 2);
         connected_session = NULL;
     }
     else {
-        fprintf(stderr, "Cannot stop session - none started");
+        fprintf(stderr, "Cannot stop session - none started\n");
     }
 
+    close_socket_to_openssh_server(connected_socket);
+    connected_socket = LIBSSH2_INVALID_SOCKET;
+
+    srcdir_path(NULL);  /* cleanup allocated filepath */
+
+    libssh2_exit();
+
     stop_openssh_fixture();
 }
+
+
+/* Return a static string that contains a file path relative to the srcdir
+ * variable, if found.
+ */
+#define NUMPATHS 32
+char *srcdir_path(const char *file)
+{
+    static char *filepath[NUMPATHS];
+    static int curpath;
+    char *p = getenv("srcdir");
+    if(file) {
+        int len;
+        if(curpath >= NUMPATHS) {
+            fprintf(stderr, "srcdir_path ran out of filepath slots.\n");
+        }
+        assert(curpath < NUMPATHS);
+        if(p) {
+            len = snprintf(NULL, 0, "%s/%s", p, file);
+            if(len > 2) {
+                filepath[curpath] = calloc(1, (size_t)len + 1);
+                snprintf(filepath[curpath], (size_t)len + 1, "%s/%s", p, file);
+            }
+            else {
+               return NULL;
+            }
+        }
+        else {
+            len = snprintf(NULL, 0, "%s", file);
+            if(len > 0) {
+                filepath[curpath] = calloc(1, (size_t)len + 1);
+                snprintf(filepath[curpath], (size_t)len + 1, "%s", file);
+            }
+            else {
+               return NULL;
+            }
+        }
+        return filepath[curpath++];
+    }
+    else {
+        int i;
+        for(i = 0; i < curpath; ++i) {
+            free(filepath[curpath]);
+        }
+        curpath = 0;
+        return NULL;
+    }
+}
+
+static const char *kbd_password;
+
+static void kbd_callback(const char *name, int name_len,
+                         const char *instruct, int instruct_len,
+                         int num_prompts,
+                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
+                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
+                         void **abstract)
+{
+    int i;
+    (void)abstract;
+
+    fprintf(stdout, "Kb-int name: %.*s\n", name_len, name);
+    fprintf(stdout, "Kb-int instruction: %.*s\n", instruct_len, instruct);
+    for(i = 0; i < num_prompts; ++i) {
+        fprintf(stdout, "Kb-int prompt %d: %.*s\n", i,
+                (int)prompts[i].length, prompts[i].text);
+    }
+
+    if(num_prompts == 1) {
+        responses[0].text = strdup(kbd_password);
+        responses[0].length = (unsigned int)strlen(kbd_password);
+    }
+}
+
+int test_auth_keyboard(LIBSSH2_SESSION *session, int flags,
+                       const char *username,
+                       const char *password)
+{
+    int rc;
+
+    const char *userauth_list =
+        libssh2_userauth_list(session, username,
+                              (unsigned int)strlen(username));
+    if(!userauth_list) {
+        print_last_session_error("libssh2_userauth_list");
+        return 1;
+    }
+
+    if(!strstr(userauth_list, "keyboard-interactive")) {
+        fprintf(stderr,
+                "'keyboard-interactive' was expected in userauth list: %s\n",
+                userauth_list);
+        return 1;
+    }
+
+    kbd_password = password;
+
+    rc = libssh2_userauth_keyboard_interactive_ex(session, username,
+                                                (unsigned int)strlen(username),
+                                                  kbd_callback);
+
+    kbd_password = NULL;
+
+    if((flags & TEST_AUTH_SHOULDFAIL) != 0) {
+        if(rc == 0) {
+            fprintf(stderr, "Keyboard-interactive auth succeeded "
+                            "with wrong response\n");
+            return 1;
+        }
+    }
+    else {
+        if(rc) {
+            print_last_session_error(
+                "libssh2_userauth_keyboard_interactive_ex");
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+int test_auth_password(LIBSSH2_SESSION *session, int flags,
+                       const char *username,
+                       const char *password)
+{
+    int rc;
+
+    const char *userauth_list =
+        libssh2_userauth_list(session, username,
+                              (unsigned int)strlen(username));
+    if(!userauth_list) {
+        print_last_session_error("libssh2_userauth_list");
+        return 1;
+    }
+
+    if(!strstr(userauth_list, "password")) {
+        fprintf(stderr, "'password' was expected in userauth list: %s\n",
+                userauth_list);
+        return 1;
+    }
+
+    rc = libssh2_userauth_password_ex(session, username,
+                                      (unsigned int)strlen(username),
+                                      password,
+                                      (unsigned int)strlen(password),
+                                      NULL);
+
+    if((flags & TEST_AUTH_SHOULDFAIL) != 0) {
+        if(rc == 0) {
+            fprintf(stderr, "Password auth succeeded with wrong password\n");
+            return 1;
+        }
+    }
+    else {
+        if(rc) {
+            print_last_session_error("libssh2_userauth_password_ex");
+            return 1;
+        }
+
+        if(libssh2_userauth_authenticated(session) == 0) {
+            fprintf(stderr, "Password auth appeared to succeed but "
+                            "libssh2_userauth_authenticated returned 0\n");
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static int read_file(const char *path, char **out_buffer, size_t *out_len)
+{
+    FILE *fp;
+    char *buffer;
+    ssize_t len;
+
+    if(!out_buffer || !out_len || !path) {
+        fprintf(stderr, "invalid params.\n");
+        return 1;
+    }
+
+    *out_buffer = NULL;
+    *out_len = 0;
+
+    fp = fopen(path, "r");
+
+    if(!fp) {
+        fprintf(stderr, "File could not be read: %s\n", path);
+        return 1;
+    }
+
+    fseek(fp, 0L, SEEK_END);
+    len = ftell(fp);
+    if(len < 0) {
+        fclose(fp);
+        fprintf(stderr, "Could not determine input size of: %s\n", path);
+        return 1;
+    }
+    rewind(fp);
+
+    buffer = calloc(1, (size_t)len + 1);
+    if(!buffer) {
+        fclose(fp);
+        fprintf(stderr, "Could not alloc memory.\n");
+        return 1;
+    }
+
+    if(1 != fread(buffer, (size_t)len, 1, fp)) {
+        fclose(fp);
+        free(buffer);
+        fprintf(stderr, "Could not read file into memory.\n");
+        return 1;
+    }
+
+    fclose(fp);
+
+    *out_buffer = buffer;
+    *out_len = (size_t)len;
+
+    return 0;
+}
+
+int test_auth_pubkey(LIBSSH2_SESSION *session, int flags,
+                     const char *username,
+                     const char *password,
+                     const char *fn_pub,
+                     const char *fn_priv)
+{
+    int rc;
+    const char *userauth_list;
+
+    /* Ignore our hard-wired Dockerfile user when not running under Docker */
+    if(!openssh_fixture_have_docker() && strcmp(username, "libssh2") == 0) {
+        username = getenv("USER");
+        if(!username) {
+#ifdef _WIN32
+            username = getenv("USERNAME");
+#else
+            username = getenv("LOGNAME");
+#endif
+        }
+    }
+
+    userauth_list = libssh2_userauth_list(session, username,
+                                          (unsigned int)strlen(username));
+    if(!userauth_list) {
+        print_last_session_error("libssh2_userauth_list");
+        return 1;
+    }
+
+    if(!strstr(userauth_list, "publickey")) {
+        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
+                userauth_list);
+        return 1;
+    }
+
+    if((flags & TEST_AUTH_FROMMEM) != 0) {
+        char *buffer = NULL;
+        size_t len = 0;
+
+        if(read_file(srcdir_path(fn_priv), &buffer, &len)) {
+            fprintf(stderr, "Reading key file failed.\n");
+            return 1;
+        }
+
+        rc = libssh2_userauth_publickey_frommemory(session,
+                                                   username, strlen(username),
+                                                   NULL, 0,
+                                                   buffer, len,
+                                                   NULL);
+
+        free(buffer);
+    }
+    else {
+        rc = libssh2_userauth_publickey_fromfile_ex(session, username,
+                                                (unsigned int)strlen(username),
+                                                    srcdir_path(fn_pub),
+                                                    srcdir_path(fn_priv),
+                                                    password);
+    }
+
+    if((flags & TEST_AUTH_SHOULDFAIL) != 0) {
+        if(rc == 0) {
+            fprintf(stderr, "Public-key auth succeeded with wrong key\n");
+            return 1;
+        }
+    }
+    else {
+        if(rc) {
+            print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
+            return 1;
+        }
+    }
+
+    return 0;
+}
diff --git a/libssh2/tests/session_fixture.h b/libssh2/tests/session_fixture.h
index d3824b79..e6992eed 100644
--- a/libssh2/tests/session_fixture.h
+++ b/libssh2/tests/session_fixture.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2016 Alexander Lamaison
+/* Copyright (C) Alexander Lamaison
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -33,15 +33,37 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #ifndef LIBSSH2_TESTS_SESSION_FIXTURE_H
 #define LIBSSH2_TESTS_SESSION_FIXTURE_H
 
-#include <libssh2.h>
+#define LIBSSH2_TESTS
+
+#include "libssh2_priv.h"
 
-LIBSSH2_SESSION *start_session_fixture();
-void stop_session_fixture();
+LIBSSH2_SESSION *start_session_fixture(int *skipped, int *err);
+void stop_session_fixture(void);
 void print_last_session_error(const char *function);
+char *srcdir_path(const char *file);
+
+#define TEST_AUTH_SHOULDFAIL  1
+#define TEST_AUTH_FROMMEM     2
+
+int test_auth_keyboard(LIBSSH2_SESSION *session, int flags,
+                       const char *username,
+                       const char *password);
+
+int test_auth_password(LIBSSH2_SESSION *session, int flags,
+                       const char *username,
+                       const char *password);
+
+int test_auth_pubkey(LIBSSH2_SESSION *session, int flags,
+                     const char *username,
+                     const char *password,
+                     const char *fn_pub,
+                     const char *fn_priv);
 
 #endif
diff --git a/libssh2/tests/simple.c b/libssh2/tests/simple.c
deleted file mode 100644
index e97f7d33..00000000
--- a/libssh2/tests/simple.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/* Copyright (C) 2007 The Written Word, Inc.
- * Copyright (C) 2008, 2010 Simon Josefsson
- * 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 any other contributors may be used to endorse or
- *   promote products derived from this software without
- *   specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "libssh2.h"
-
-static int test_libssh2_base64_decode(LIBSSH2_SESSION *session)
-{
-    char *data;
-    unsigned int datalen;
-    const char *src = "Zm5vcmQ=";
-    unsigned int src_len = strlen(src);
-    int ret;
-
-    ret = libssh2_base64_decode(session, &data, &datalen,
-                                src, src_len);
-    if(ret)
-        return ret;
-
-    if(datalen != 5 || strcmp(data, "fnord") != 0) {
-        fprintf(stderr,
-                "libssh2_base64_decode() failed (%d, %.*s)\n",
-                datalen, datalen, data);
-        return 1;
-    }
-
-    free(data);
-
-    return 0;
-}
-
-int main(int argc, char *argv[])
-{
-    LIBSSH2_SESSION *session;
-    int rc;
-    (void)argv;
-    (void)argc;
-
-    rc = libssh2_init(LIBSSH2_INIT_NO_CRYPTO);
-    if(rc != 0) {
-        fprintf(stderr, "libssh2_init() failed: %d\n", rc);
-        return 1;
-    }
-
-    session = libssh2_session_init();
-    if(!session) {
-        fprintf(stderr, "libssh2_session_init() failed\n");
-        return 1;
-    }
-
-    test_libssh2_base64_decode(session);
-
-    libssh2_session_free(session);
-
-    libssh2_exit();
-
-    return 0;
-}
diff --git a/libssh2/tests/ssh2.c b/libssh2/tests/ssh2.c
deleted file mode 100644
index f903e075..00000000
--- a/libssh2/tests/ssh2.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/* Self test, based on examples/ssh2.c. */
-
-#include "libssh2_config.h"
-#include <libssh2.h>
-#include <libssh2_sftp.h>
-
-#ifdef HAVE_WINDOWS_H
-# include <windows.h>
-#endif
-#ifdef HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-# ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-# ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-
-int main(int argc, char *argv[])
-{
-    unsigned long hostaddr;
-    int sock, i, auth_pw = 0;
-    struct sockaddr_in sin;
-    const char *fingerprint;
-    char *userauthlist;
-    LIBSSH2_SESSION *session;
-    LIBSSH2_CHANNEL *channel;
-    const char *pubkeyfile = "etc/user.pub";
-    const char *privkeyfile = "etc/user";
-    const char *username = "username";
-    const char *password = "password";
-    int ec = 1;
-
-#ifdef WIN32
-    WSADATA wsadata;
-    int err;
-
-    err = WSAStartup(MAKEWORD(2, 0), &wsadata);
-    if(err != 0) {
-        fprintf(stderr, "WSAStartup failed with error: %d\n", err);
-        return -1;
-    }
-#endif
-
-    (void)argc;
-    (void)argv;
-
-    if(getenv("USER"))
-      username = getenv("USER");
-
-    if(getenv ("PRIVKEY"))
-      privkeyfile = getenv("PRIVKEY");
-
-    if(getenv("PUBKEY"))
-      pubkeyfile = getenv("PUBKEY");
-
-    hostaddr = htonl(0x7F000001);
-
-    sock = socket(AF_INET, SOCK_STREAM, 0);
-#ifndef WIN32
-    fcntl(sock, F_SETFL, 0);
-#endif
-    sin.sin_family = AF_INET;
-    sin.sin_port = htons(4711);
-    sin.sin_addr.s_addr = hostaddr;
-    if(connect(sock, (struct sockaddr*)(&sin),
-                sizeof(struct sockaddr_in)) != 0) {
-        fprintf(stderr, "failed to connect!\n");
-        return 1;
-    }
-
-    /* Create a session instance and start it up
-     * This will trade welcome banners, exchange keys,
-     * and setup crypto, compression, and MAC layers
-     */
-    session = libssh2_session_init();
-    if(libssh2_session_startup(session, sock)) {
-        fprintf(stderr, "Failure establishing SSH session\n");
-        return 1;
-    }
-
-    /* At this point we haven't authenticated,
-     * The first thing to do is check the hostkey's
-     * fingerprint against our known hosts
-     * Your app may have it hard coded, may go to a file,
-     * may present it to the user, that's your call
-     */
-    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-    printf("Fingerprint: ");
-    for(i = 0; i < 20; i++) {
-        printf("%02X ", (unsigned char)fingerprint[i]);
-    }
-    printf("\n");
-
-    /* check what authentication methods are available */
-    userauthlist = libssh2_userauth_list(session, username, strlen(username));
-    printf("Authentication methods: %s\n", userauthlist);
-    if(strstr(userauthlist, "password") != NULL) {
-        auth_pw |= 1;
-    }
-    if(strstr(userauthlist, "keyboard-interactive") != NULL) {
-        auth_pw |= 2;
-    }
-    if(strstr(userauthlist, "publickey") != NULL) {
-        auth_pw |= 4;
-    }
-
-    if(auth_pw & 4) {
-        /* Authenticate by public key */
-        if(libssh2_userauth_publickey_fromfile(session, username, pubkeyfile,
-                                               privkeyfile, password)) {
-            printf("\tAuthentication by public key failed!\n");
-            goto shutdown;
-        }
-        else {
-            printf("\tAuthentication by public key succeeded.\n");
-        }
-    }
-    else {
-        printf("No supported authentication methods found!\n");
-        goto shutdown;
-    }
-
-    /* Request a shell */
-    channel = libssh2_channel_open_session(session);
-    if(!channel) {
-        fprintf(stderr, "Unable to open a session\n");
-        goto shutdown;
-    }
-
-    /* Some environment variables may be set,
-     * It's up to the server which ones it'll allow though
-     */
-    libssh2_channel_setenv(channel, "FOO", "bar");
-
-    /* Request a terminal with 'vanilla' terminal emulation
-     * See /etc/termcap for more options
-     */
-    if(libssh2_channel_request_pty(channel, "vanilla")) {
-        fprintf(stderr, "Failed requesting pty\n");
-        goto skip_shell;
-    }
-
-    /* Open a SHELL on that pty */
-    if(libssh2_channel_shell(channel)) {
-        fprintf(stderr, "Unable to request shell on allocated pty\n");
-        goto shutdown;
-    }
-
-    ec = 0;
-
-  skip_shell:
-    if(channel) {
-        libssh2_channel_free(channel);
-        channel = NULL;
-    }
-
-  shutdown:
-
-    libssh2_session_disconnect(session, "Normal Shutdown");
-    libssh2_session_free(session);
-
-#ifdef WIN32
-    Sleep(1000);
-    closesocket(sock);
-#else
-    sleep(1);
-    close(sock);
-#endif
-
-    return ec;
-}
diff --git a/libssh2/tests/ssh2.sh b/libssh2/tests/ssh2.sh
deleted file mode 100755
index 07795bb7..00000000
--- a/libssh2/tests/ssh2.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/bin/sh
-
-# Written by Simon Josefsson.
-
-# Start sshd, invoke parameters, saving exit code, kill sshd, and
-# return exit code.
-
-srcdir=${srcdir:-$PWD}
-SSHD=${SSHD:-/usr/sbin/sshd}
-
-cmd="./ssh2${EXEEXT}"
-srcdir=`cd "$srcdir"; pwd`
-
-PRIVKEY=$srcdir/etc/user
-export PRIVKEY
-PUBKEY=$srcdir/etc/user.pub
-export PUBKEY
-
-if test -n "$DEBUG"; then
-    libssh2_sshd_params="-d -d"
-fi
-
-chmod go-rwx "$srcdir"/etc/host*
-$SSHD -f /dev/null -h "$srcdir"/etc/host \
-    -o 'Port 4711' \
-    -o 'Protocol 2' \
-    -o "AuthorizedKeysFile $srcdir/etc/user.pub" \
-    -o 'UsePrivilegeSeparation no' \
-    -o 'StrictModes no' \
-    -D \
-    $libssh2_sshd_params &
-sshdpid=$!
-
-trap "kill ${sshdpid}; echo signal killing sshd; exit 1;" EXIT
-
-: "started sshd (${sshdpid})"
-
-sleep 3
-
-: Invoking $cmd...
-eval $cmd
-ec=$?
-: Self-test exit code $ec
-
-: "killing sshd (${sshdpid})"
-kill "${sshdpid}" > /dev/null 2>&1
-trap "" EXIT
-exit $ec
diff --git a/libssh2/tests/sshd_fixture.sh.in b/libssh2/tests/sshd_fixture.sh.in
deleted file mode 100644
index a76f4338..00000000
--- a/libssh2/tests/sshd_fixture.sh.in
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/bin/sh
-
-# Written by Simon Josefsson.
-
-# Start sshd, invoke parameters, saving exit code, kill sshd, and
-# return exit code.
-
-srcdir="@SSHD_TEST_CONFIG_DIR@"
-SSHD="@SSHD_EXECUTABLE@"
-
-cmd="\"$1\""
-
-PRIVKEY=$srcdir/etc/user
-export PRIVKEY
-PUBKEY=$srcdir/etc/user.pub
-export PUBKEY
-
-if test -n "$DEBUG"; then
-    libssh2_sshd_params="-d -d"
-fi
-
-chmod go-rwx "$srcdir"/etc/host*
-"$SSHD" -f /dev/null -h "$srcdir/etc/host" \
-    -o 'Port 4711' \
-    -o 'Protocol 2' \
-    -o "AuthorizedKeysFile \"$srcdir/etc/user.pub\"" \
-    -o 'UsePrivilegeSeparation no' \
-    -o 'StrictModes no' \
-    -D \
-    $libssh2_sshd_params &
-sshdpid=$!
-
-trap "kill ${sshdpid}; echo signal killing sshd; exit 1;" EXIT
-
-: "started sshd (${sshdpid})"
-
-sleep 3
-
-if ! kill -0 ${sshdpid}
-then
-    echo "SSHD exited before test started"
-    exit 1
-fi
-
-: Invoking $cmd...
-eval "$cmd"
-ec=$?
-: Self-test exit code $ec
-
-: "killing sshd (${sshdpid})"
-kill "${sshdpid}" > /dev/null 2>&1
-trap "" EXIT
-exit $ec
diff --git a/libssh2/tests/test_aa_warmup.c b/libssh2/tests/test_aa_warmup.c
new file mode 100644
index 00000000..b2e00067
--- /dev/null
+++ b/libssh2/tests/test_aa_warmup.c
@@ -0,0 +1,24 @@
+/* Copyright (C) Viktor Szakats
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/* Warm-up test. Always return success.
+   Workaround for CI/docker/etc flakiness on the first run. */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    size_t len = 0;
+    int type = 0;
+    const char *hostkey = libssh2_session_hostkey(session, &len, &type);
+
+    (void)hostkey;
+
+    fprintf(stdout,
+            "libssh2_session_hostkey returned len, type: %ld, %d\n",
+            (long)len, type);
+
+    return 0;  /* always return success */
+}
diff --git a/libssh2/tests/test_agent_forward_ok.c b/libssh2/tests/test_agent_forward_ok.c
new file mode 100644
index 00000000..cc282c18
--- /dev/null
+++ b/libssh2/tests/test_agent_forward_ok.c
@@ -0,0 +1,57 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+static const char *username = "libssh2"; /* set in Dockerfile */
+static const char *key_file_private = "key_rsa";
+static const char *key_file_public = "key_rsa.pub"; /* set in Dockerfile */
+
+int test(LIBSSH2_SESSION *session)
+{
+    int rc;
+    LIBSSH2_CHANNEL *channel;
+
+    const char *userauth_list =
+        libssh2_userauth_list(session, username,
+                              (unsigned int)strlen(username));
+    if(!userauth_list) {
+        print_last_session_error("libssh2_userauth_list");
+        return 1;
+    }
+
+    if(!strstr(userauth_list, "publickey")) {
+        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
+                userauth_list);
+        return 1;
+    }
+
+    rc = libssh2_userauth_publickey_fromfile_ex(session, username,
+                                                (unsigned int)strlen(username),
+                                                srcdir_path(key_file_public),
+                                                srcdir_path(key_file_private),
+                                                NULL);
+    if(rc) {
+        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
+        return 1;
+    }
+
+    channel = libssh2_channel_open_session(session);
+    #if 0
+    if(!channel) {
+        printf("Error opening channel\n");
+        return 1;
+    }
+    #endif
+
+    rc = libssh2_channel_request_auth_agent(channel);
+    if(rc) {
+        fprintf(stderr, "Auth agent request for agent forwarding failed, "
+            "error code %d\n", rc);
+        return 1;
+    }
+
+    return 0;
+}
diff --git a/libssh2/tests/test_agent_forward_succeeds.c b/libssh2/tests/test_agent_forward_succeeds.c
deleted file mode 100644
index daf7bd5a..00000000
--- a/libssh2/tests/test_agent_forward_succeeds.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-const char *USERNAME = "libssh2"; /* set in Dockerfile */
-const char *KEY_FILE_PRIVATE = "key_rsa";
-const char *KEY_FILE_PUBLIC = "key_rsa.pub"; /* set in Dockerfile */
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    LIBSSH2_CHANNEL *channel;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    channel = libssh2_channel_open_session(session);
-    /* if(channel == NULL) { */
-    /*     printf("Error opening channel\n"); */
-    /*     return 1; */
-    /* } */
-
-    rc = libssh2_channel_request_auth_agent(channel);
-    if(rc != 0) {
-        fprintf(stderr, "Auth agent request for agent forwarding failed, "
-            "error code %d\n", rc);
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_auth_keyboard_fail.c b/libssh2/tests/test_auth_keyboard_fail.c
new file mode 100644
index 00000000..7fc95df2
--- /dev/null
+++ b/libssh2/tests/test_auth_keyboard_fail.c
@@ -0,0 +1,13 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_keyboard(session, TEST_AUTH_SHOULDFAIL,
+                              "libssh2", /* set in Dockerfile */
+                              "I am the wrong password");
+}
diff --git a/libssh2/tests/test_auth_keyboard_info_request.c b/libssh2/tests/test_auth_keyboard_info_request.c
new file mode 100644
index 00000000..d10a89a1
--- /dev/null
+++ b/libssh2/tests/test_auth_keyboard_info_request.c
@@ -0,0 +1,331 @@
+/* Copyright (C) Xaver Loppenstedt
+ * 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 any other contributors may be used to endorse or
+ *   promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "libssh2_priv.h"
+#include "userauth_kbd_packet.h"
+
+#include <stdlib.h>
+
+#define PASS 0
+#define FAIL -1
+
+struct expected {
+    int rc;
+    int last_error_code;
+    const char *last_error_message;
+};
+struct test_case {
+    const char *data;
+    unsigned int data_len;
+    struct expected expected;
+};
+
+#define TEST_CASES_LEN 16
+static const struct test_case
+    test_cases[TEST_CASES_LEN] = {
+    /* too small */
+    {
+        NULL, 0,
+        {FAIL, -38,
+            "userauth keyboard data buffer too small to get length"}},
+    /* too small */
+    {
+        "1234", 4,
+        {FAIL, -38,
+            "userauth keyboard data buffer too small to get length"}},
+    /* smallest valid packet possible */
+    {
+        "<"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0", 17,
+        {PASS, 0, ""}},
+    /* overrun name */
+    {
+        "<"
+        "\0\0\0\x7f"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0", 17,
+        {FAIL, -6,
+            "Unable to decode keyboard-interactive 'name' request field"}},
+    /* overrun instruction */
+    {
+        "<"
+        "\0\0\0\0"
+        "\0\0\0\x7f"
+        "\0\0\0\0"
+        "\0\0\0\0", 17,
+        {FAIL, -6,
+            "Unable to decode keyboard-interactive 'instruction' "
+            "request field"}},
+    /* overrun language */
+    {
+        "<"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\x7f"
+        "\0\0\0\0", 17,
+        {FAIL, -6,
+            "Unable to decode keyboard-interactive 'language tag' "
+            "request field"}},
+    /* underrun prompt number */
+    {
+        "<"
+        "\0\0\0\x01"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0", 17,
+        {FAIL, -38,
+            "Unable to decode keyboard-interactive number of "
+            "keyboard prompts"}},
+    /* too many prompts */
+    {
+        "<"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\x7f", 17,
+        {FAIL, -41, "Too many replies for keyboard-interactive prompts"}},
+    /* empty prompt */
+    {
+        "<"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\0"
+        "\0\0\0\x01"
+        "\0\0\0\0"
+        "\0", 22,
+        {PASS, 0, ""}},
+    /* copied from OpenSSH */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"
+        "\0\0\0\x0aPassword: \0", 32,
+        {PASS, 0, ""}},
+    /* overrun in prompt text */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"
+        "\0\0\0\x7bPassword: \0", 32,
+        {FAIL, -6,
+            "Unable to decode keyboard-interactive "
+            "prompt message"}},
+    /* no echo prompt boolean */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"
+        "\0\0\0\x0bPassword: \0", 32,
+        {FAIL, -38, "Unable to decode user auth keyboard prompt echo"}},
+    /* two prompts */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02"
+        "\0\0\0\x0aPassword: \0"
+        "\0\0\0\x07Token: \1", 44,
+        {PASS, 0, ""}},
+    /* example from RFC 4256 */
+    {
+        "<"
+        "\0\0\0\x19""CRYPTOCard Authentication"
+        "\0\0\0\x1b""The challenge is '14315716'"
+        "\0\0\0\x05""en-US"
+        "\0\0\0\x01"
+        "\0\0\0\x0aResponse: "
+        "\x01"
+        , 89,
+        {PASS, 0, ""}},
+    /* three prompts, 3rd missing */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x03"
+        "\0\0\0\x0aPassword: \0"
+        "\0\0\0\x07Token: \1", 44,
+        {FAIL, -6, "Unable to decode keyboard-interactive prompt message"}},
+    /* overflow language on 32 bit platform */
+    {
+        "<"
+        "\0\0\0\x19"
+            "\0\0\0\x01"
+            "\0\0\0\x05""PWN3D\0\1\2\3\4\5\6\7\1\2\3"
+            "\x01"
+        "\0\0\0\x1b""The challenge is '14315716'"
+        "\xff\xff\xff\xc4""en-US"
+        "\0\0\0\x01"
+        "\0\0\0\x0aResponse: "
+        "\x01",
+        89,
+        {FAIL, -6,
+            "Unable to decode keyboard-interactive 'language tag' "
+            "request field"}},
+};
+
+#define FAILED_MALLOC_TEST_CASES_LEN 2
+static const struct test_case
+    failed_malloc_test_cases[FAILED_MALLOC_TEST_CASES_LEN] = {
+    /* malloc fail */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"
+        "\0\0\0\x0aPassword: \0", 32,
+        {FAIL, -6,
+            "Unable to allocate memory for "
+            "keyboard-interactive prompts array"}},
+    /* malloc fail */
+    {
+        "<"
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01"
+        "\0\0\0\x0aPassword: \0", 32,
+        {FAIL, -6,
+            "Unable to allocate memory for "
+            "keyboard-interactive responses array"
+        }}
+};
+
+static int alloc_count = 0;
+static int free_count = 0;
+
+/* libssh2_default_alloc
+ */
+static
+LIBSSH2_ALLOC_FUNC(test_alloc)
+{
+    int *threshold_int_ptr = *abstract;
+    alloc_count++;
+    if(*abstract && *threshold_int_ptr == alloc_count) {
+        return NULL;
+    }
+
+    return malloc(count);
+}
+
+/* libssh2_default_free
+ */
+static
+LIBSSH2_FREE_FUNC(test_free)
+{
+    (void)abstract;
+    free_count++;
+    free(ptr);
+}
+
+static
+int test_case(int num,
+              const char *data, unsigned int data_len, void *abstract,
+              struct expected expected)
+{
+    int rc;
+    char *message;
+    int error_code;
+    LIBSSH2_SESSION *session;
+
+    alloc_count = 0;
+    free_count = 0;
+
+    session = libssh2_session_init_ex(test_alloc, test_free, NULL, abstract);
+    if(!session) {
+        fprintf(stderr, "libssh2_session_init_ex failed\n");
+        return 1;
+    }
+
+    session->userauth_kybd_data = LIBSSH2_ALLOC(session, data_len);
+    session->userauth_kybd_data_len = data_len;
+    memcpy(session->userauth_kybd_data, data, data_len);
+
+    rc = userauth_keyboard_interactive_decode_info_request(session);
+
+    if(rc != expected.rc) {
+        fprintf(stdout,
+                "Test case %d: expected return code to be %d got %d\n",
+                num, expected.rc, rc);
+        return 1;
+    }
+
+    error_code = libssh2_session_last_error(session, &message, NULL, 0);
+
+    if(expected.last_error_code != error_code) {
+        fprintf(stdout,
+                "Test case %d: expected last error code to be "
+                "\"%d\" got \"%d\"\n",
+                num, expected.last_error_code, error_code);
+        return 1;
+    }
+
+    if(strcmp(expected.last_error_message, message) != 0) {
+        fprintf(stdout,
+                "Test case %d: expected last error message to be "
+                "\"%s\" got \"%s\"\n",
+                num, expected.last_error_message, message);
+        return 1;
+    }
+    libssh2_session_free(session);
+
+    fprintf(stderr, "Test case %d passed\n", num);
+
+    return 0;
+}
+
+int main(void)
+{
+    int ret = 0;
+    int i;
+
+    for(i = 0; i < TEST_CASES_LEN; i++) {
+        if(test_case(i + 1,
+                     test_cases[i].data,
+                     test_cases[i].data_len,
+                     NULL,
+                     test_cases[i].expected))
+            ret = 1;
+    }
+
+    for(i = 0; i < FAILED_MALLOC_TEST_CASES_LEN; i++) {
+        int tc =  i + TEST_CASES_LEN + 1;
+        int malloc_call_num = 3 + i;
+        if(test_case(tc,
+                     failed_malloc_test_cases[i].data,
+                     failed_malloc_test_cases[i].data_len,
+                     &malloc_call_num,
+                     failed_malloc_test_cases[i].expected))
+            ret = 1;
+    }
+
+    return ret;
+}
diff --git a/libssh2/tests/test_auth_keyboard_ok.c b/libssh2/tests/test_auth_keyboard_ok.c
new file mode 100644
index 00000000..517f8bf6
--- /dev/null
+++ b/libssh2/tests/test_auth_keyboard_ok.c
@@ -0,0 +1,13 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_keyboard(session, 0,
+                              "libssh2", /* set in Dockerfile */
+                              "my test password"); /* set in Dockerfile */
+}
diff --git a/libssh2/tests/test_auth_password_fail_password.c b/libssh2/tests/test_auth_password_fail_password.c
new file mode 100644
index 00000000..4e08bb51
--- /dev/null
+++ b/libssh2/tests/test_auth_password_fail_password.c
@@ -0,0 +1,13 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_password(session, TEST_AUTH_SHOULDFAIL,
+                              "libssh2", /* set in Dockerfile */
+                              "I am the wrong password");
+}
diff --git a/libssh2/tests/test_auth_password_fail_username.c b/libssh2/tests/test_auth_password_fail_username.c
new file mode 100644
index 00000000..99f65b53
--- /dev/null
+++ b/libssh2/tests/test_auth_password_fail_username.c
@@ -0,0 +1,13 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_password(session, TEST_AUTH_SHOULDFAIL,
+                              "I am the wrong username",
+                              "my test password"); /* set in Dockerfile */
+}
diff --git a/libssh2/tests/test_auth_password_ok.c b/libssh2/tests/test_auth_password_ok.c
new file mode 100644
index 00000000..2ebc2e3b
--- /dev/null
+++ b/libssh2/tests/test_auth_password_ok.c
@@ -0,0 +1,13 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_password(session, 0,
+                              "libssh2", /* set in Dockerfile */
+                              "my test password"); /* set in Dockerfile */
+}
diff --git a/libssh2/tests/test_auth_pubkey_fail.c b/libssh2/tests/test_auth_pubkey_fail.c
new file mode 100644
index 00000000..c702fb6e
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_fail.c
@@ -0,0 +1,15 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+    return test_auth_pubkey(session, TEST_AUTH_SHOULDFAIL,
+                            "libssh2", /* set in Dockerfile */
+                            NULL,
+                            "key_dsa_wrong.pub", /* Not authorized on server */
+                            "key_dsa_wrong");
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_dsa.c b/libssh2/tests/test_auth_pubkey_ok_dsa.c
new file mode 100644
index 00000000..983eaa88
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_dsa.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_DSA
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_dsa.pub",
+                            "key_dsa");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_ecdsa.c b/libssh2/tests/test_auth_pubkey_ok_ecdsa.c
new file mode 100644
index 00000000..681e0189
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_ecdsa.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_ECDSA
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_ecdsa.pub",
+                            "key_ecdsa");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_ecdsa_signed.c b/libssh2/tests/test_auth_pubkey_ok_ecdsa_signed.c
new file mode 100644
index 00000000..6ac4f671
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_ecdsa_signed.c
@@ -0,0 +1,22 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_ECDSA && \
+    (defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_ecdsa_signed-cert.pub",
+                            "key_ecdsa_signed");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_ed25519.c b/libssh2/tests/test_auth_pubkey_ok_ed25519.c
new file mode 100644
index 00000000..280ed702
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_ed25519.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_ED25519
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_ed25519.pub",
+                            "key_ed25519");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_ed25519_encrypted.c b/libssh2/tests/test_auth_pubkey_ok_ed25519_encrypted.c
new file mode 100644
index 00000000..f6160f37
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_ed25519_encrypted.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_ED25519
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            "libssh2",
+                            "key_ed25519_encrypted.pub",
+                            "key_ed25519_encrypted");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_ed25519_mem.c b/libssh2/tests/test_auth_pubkey_ok_ed25519_mem.c
new file mode 100644
index 00000000..8274b073
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_ed25519_mem.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_ED25519
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, TEST_AUTH_FROMMEM,
+                            "libssh2",
+                            NULL,
+                            NULL,
+                            "key_ed25519");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa.c b/libssh2/tests/test_auth_pubkey_ok_rsa.c
new file mode 100644
index 00000000..25b24920
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA1
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_rsa.pub",
+                            "key_rsa");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa_aes256gcm.c b/libssh2/tests/test_auth_pubkey_ok_rsa_aes256gcm.c
new file mode 100644
index 00000000..c7007d67
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa_aes256gcm.c
@@ -0,0 +1,22 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA1 && LIBSSH2_AES_GCM && \
+    (defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            "libssh2",
+                            "key_rsa_aes256gcm.pub",
+                            "key_rsa_aes256gcm");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa_encrypted.c b/libssh2/tests/test_auth_pubkey_ok_rsa_encrypted.c
new file mode 100644
index 00000000..86ca8429
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa_encrypted.c
@@ -0,0 +1,21 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA1 && LIBSSH2_MD5_PEM
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            "libssh2",
+                            "key_rsa_encrypted.pub",
+                            "key_rsa_encrypted");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa_openssh.c b/libssh2/tests/test_auth_pubkey_ok_rsa_openssh.c
new file mode 100644
index 00000000..2e78df1a
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa_openssh.c
@@ -0,0 +1,22 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA1 && \
+    (defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_rsa_openssh.pub",
+                            "key_rsa_openssh");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa_sha2_256_signed.c b/libssh2/tests/test_auth_pubkey_ok_rsa_sha2_256_signed.c
new file mode 100644
index 00000000..95dc5b37
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa_sha2_256_signed.c
@@ -0,0 +1,22 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA2 && \
+    (defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_rsa_sha2_256_signed-cert.pub",
+                            "key_rsa_sha2_256_signed");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_auth_pubkey_ok_rsa_signed.c b/libssh2/tests/test_auth_pubkey_ok_rsa_signed.c
new file mode 100644
index 00000000..1956dd58
--- /dev/null
+++ b/libssh2/tests/test_auth_pubkey_ok_rsa_signed.c
@@ -0,0 +1,22 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+
+int test(LIBSSH2_SESSION *session)
+{
+#if LIBSSH2_RSA_SHA1 && \
+    (defined(LIBSSH2_OPENSSL) || defined(LIBSSH2_WOLFSSL))
+    /* set in Dockerfile */
+    return test_auth_pubkey(session, 0,
+                            "libssh2",
+                            NULL,
+                            "key_rsa_signed-cert.pub",
+                            "key_rsa_signed");
+#else
+    (void)session;
+    return 0;
+#endif
+}
diff --git a/libssh2/tests/test_hostkey.c b/libssh2/tests/test_hostkey.c
index e33f68f9..f54a275f 100644
--- a/libssh2/tests/test_hostkey.c
+++ b/libssh2/tests/test_hostkey.c
@@ -1,8 +1,9 @@
-#include "session_fixture.h"
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 
-#include <libssh2.h>
-
-#include <stdio.h>
+#include "runner.h"
 
 static const char *EXPECTED_RSA_HOSTKEY =
     "AAAAB3NzaC1yc2EAAAABIwAAAQEArrr/JuJmaZligyfS8vcNur+mWR2ddDQtVdhHzdKU"
@@ -16,43 +17,51 @@ static const char *EXPECTED_ECDSA_HOSTKEY =
     "AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBC+/syyeKJD9dC2ZH"
     "9Q7iJGReR4YM3rUCMsSynkyXojdfSClGCMY7JvWlt30ESjYvxoTfSRGx6WvaqYK/vPoYQ4=";
 
+static const char *EXPECTED_ED25519_HOSTKEY =
+    "AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom";
+
 int test(LIBSSH2_SESSION *session)
 {
     int rc;
     size_t len;
     int type;
-    unsigned int expected_len = 0;
+    size_t expected_len = 0;
     char *expected_hostkey = NULL;
 
     const char *hostkey = libssh2_session_hostkey(session, &len, &type);
-    if(hostkey == NULL) {
+    if(!hostkey) {
         print_last_session_error("libssh2_session_hostkey");
         return 1;
     }
 
-    if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
-        rc = libssh2_base64_decode(session, &expected_hostkey, &expected_len,
-                                   EXPECTED_ECDSA_HOSTKEY,
-                                   strlen(EXPECTED_ECDSA_HOSTKEY));
+    if(type == LIBSSH2_HOSTKEY_TYPE_ED25519) {
+        rc = _libssh2_base64_decode(session, &expected_hostkey, &expected_len,
+                                    EXPECTED_ED25519_HOSTKEY,
+                                    strlen(EXPECTED_ED25519_HOSTKEY));
+    }
+    else if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
+        rc = _libssh2_base64_decode(session, &expected_hostkey, &expected_len,
+                                    EXPECTED_ECDSA_HOSTKEY,
+                                    strlen(EXPECTED_ECDSA_HOSTKEY));
     }
     else if(type == LIBSSH2_HOSTKEY_TYPE_RSA) {
-        rc = libssh2_base64_decode(session, &expected_hostkey, &expected_len,
-                                   EXPECTED_RSA_HOSTKEY,
-                                   strlen(EXPECTED_RSA_HOSTKEY));
+        rc = _libssh2_base64_decode(session, &expected_hostkey, &expected_len,
+                                    EXPECTED_RSA_HOSTKEY,
+                                    strlen(EXPECTED_RSA_HOSTKEY));
     }
     else {
         fprintf(stderr, "Unexpected type of hostkey: %i\n", type);
         return 1;
     }
 
-    if(rc != 0) {
-        print_last_session_error("libssh2_base64_decode");
+    if(rc) {
+        print_last_session_error("_libssh2_base64_decode");
         return 1;
     }
 
     if(len != expected_len) {
-        fprintf(stderr, "Hostkey does not have the expected length %ld!=%d\n",
-                (unsigned long)len, expected_len);
+        fprintf(stderr, "Hostkey does not have the expected length %ld!=%ld\n",
+                (unsigned long)len, (unsigned long)expected_len);
         return 1;
     }
 
diff --git a/libssh2/tests/test_hostkey_hash.c b/libssh2/tests/test_hostkey_hash.c
index 112b491f..9ca3b810 100644
--- a/libssh2/tests/test_hostkey_hash.c
+++ b/libssh2/tests/test_hostkey_hash.c
@@ -1,9 +1,9 @@
-#include "session_fixture.h"
-#include "libssh2_config.h"
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
 
-#include <libssh2.h>
-
-#include <stdio.h>
+#include "runner.h"
 
 static const char *EXPECTED_RSA_HOSTKEY =
     "AAAAB3NzaC1yc2EAAAABIwAAAQEArrr/JuJmaZligyfS8vcNur+mWR2ddDQtVdhHzdKU"
@@ -17,8 +17,13 @@ static const char *EXPECTED_ECDSA_HOSTKEY =
     "AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBC+/syyeKJD9dC2ZH"
     "9Q7iJGReR4YM3rUCMsSynkyXojdfSClGCMY7JvWlt30ESjYvxoTfSRGx6WvaqYK/vPoYQ4=";
 
+static const char *EXPECTED_ED25519_HOSTKEY =
+    "AAAAC3NzaC1lZDI1NTE5AAAAIIxtdyg2ZRXE70UwyPVUH3UyfDBV8GX5cPF636P6hjom";
+
+#if LIBSSH2_MD5
 static const char *EXPECTED_RSA_MD5_HASH_DIGEST =
     "0C0ED1A5BB10275F76924CE187CE5C5E";
+#endif
 
 static const char *EXPECTED_RSA_SHA1_HASH_DIGEST =
     "F3CD59E2913F4422B80F7B0A82B2B89EAE449387";
@@ -26,8 +31,10 @@ static const char *EXPECTED_RSA_SHA1_HASH_DIGEST =
 static const char *EXPECTED_RSA_SHA256_HASH_DIGEST =
     "92E3DA49DF3C7F99A828F505ED8239397A5D1F62914459760F878F7510F563A3";
 
+#if LIBSSH2_MD5
 static const char *EXPECTED_ECDSA_MD5_HASH_DIGEST =
     "0402E4D897580BBC911379CBD88BCD3D";
+#endif
 
 static const char *EXPECTED_ECDSA_SHA1_HASH_DIGEST =
     "12FDAD1E3B31B10BABB00F2A8D1B9A62C326BD2F";
@@ -35,9 +42,14 @@ static const char *EXPECTED_ECDSA_SHA1_HASH_DIGEST =
 static const char *EXPECTED_ECDSA_SHA256_HASH_DIGEST =
     "56FCD975B166C3F0342D0036E44C311A86C0EAE40713B53FC776369BAE7F5264";
 
-static const int MD5_HASH_SIZE = 16;
-static const int SHA1_HASH_SIZE = 20;
-static const int SHA256_HASH_SIZE = 32;
+static const char *EXPECTED_ED25519_SHA256_HASH_DIGEST =
+    "2638B020F6121FA750A7F4754B718419F621814C6E779D68ADF26AA68814ADDF";
+
+#if LIBSSH2_MD5
+static const size_t MD5_HASH_SIZE = 16;
+#endif
+static const size_t SHA1_HASH_SIZE = 20;
+static const size_t SHA256_HASH_SIZE = 32;
 
 static void calculate_digest(const char *hash, size_t hash_len, char *buffer,
                              size_t buffer_len)
@@ -47,7 +59,7 @@ static void calculate_digest(const char *hash, size_t hash_len, char *buffer,
     char *end = buffer + buffer_len;
 
     for(i = 0; i < hash_len && p < end; ++i) {
-        p += snprintf(p, end - p, "%02X", (unsigned char)hash[i]);
+        p += snprintf(p, (size_t)(end - p), "%02X", (unsigned char)hash[i]);
     }
 }
 
@@ -56,7 +68,9 @@ int test(LIBSSH2_SESSION *session)
     char buf[BUFSIZ];
 
     const char *hostkey;
+#if LIBSSH2_MD5
     const char *md5_hash;
+#endif
     const char *sha1_hash;
     const char *sha256_hash;
     int type;
@@ -65,17 +79,38 @@ int test(LIBSSH2_SESSION *session)
     /* these are the host keys under test, they are currently unused */
     (void)EXPECTED_RSA_HOSTKEY;
     (void)EXPECTED_ECDSA_HOSTKEY;
+    (void)EXPECTED_ED25519_HOSTKEY;
 
     hostkey = libssh2_session_hostkey(session, &len, &type);
-    if(hostkey == NULL) {
+    if(!hostkey) {
         print_last_session_error("libssh2_session_hostkey");
         return 1;
     }
 
-    if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
+    if(type == LIBSSH2_HOSTKEY_TYPE_ED25519) {
+
+        sha256_hash = libssh2_hostkey_hash(session,
+                                           LIBSSH2_HOSTKEY_HASH_SHA256);
+        if(!sha256_hash) {
+            print_last_session_error(
+                "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA256)");
+            return 1;
+        }
+
+        calculate_digest(sha256_hash, SHA256_HASH_SIZE, buf, BUFSIZ);
 
+        if(strcmp(buf, EXPECTED_ED25519_SHA256_HASH_DIGEST) != 0) {
+            fprintf(stderr,
+                    "ED25519 SHA256 hash not as expected - digest %s != %s\n",
+                    buf, EXPECTED_ED25519_SHA256_HASH_DIGEST);
+            return 1;
+        }
+    }
+    else if(type == LIBSSH2_HOSTKEY_TYPE_ECDSA_256) {
+
+#if LIBSSH2_MD5
         md5_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
-        if(md5_hash == NULL) {
+        if(!md5_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_MD5)");
             return 1;
@@ -89,9 +124,10 @@ int test(LIBSSH2_SESSION *session)
                     buf, EXPECTED_ECDSA_MD5_HASH_DIGEST);
             return 1;
         }
+#endif
 
         sha1_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-        if(sha1_hash == NULL) {
+        if(!sha1_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA1)");
             return 1;
@@ -108,7 +144,7 @@ int test(LIBSSH2_SESSION *session)
 
         sha256_hash = libssh2_hostkey_hash(session,
                                            LIBSSH2_HOSTKEY_HASH_SHA256);
-        if(sha256_hash == NULL) {
+        if(!sha256_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA256)");
             return 1;
@@ -122,12 +158,12 @@ int test(LIBSSH2_SESSION *session)
                     buf, EXPECTED_ECDSA_SHA256_HASH_DIGEST);
             return 1;
         }
-
     }
     else if(type == LIBSSH2_HOSTKEY_TYPE_RSA) {
 
+#if LIBSSH2_MD5
         md5_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
-        if(md5_hash == NULL) {
+        if(!md5_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_MD5)");
             return 1;
@@ -141,9 +177,10 @@ int test(LIBSSH2_SESSION *session)
                     buf, EXPECTED_RSA_MD5_HASH_DIGEST);
             return 1;
         }
+#endif
 
         sha1_hash = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
-        if(sha1_hash == NULL) {
+        if(!sha1_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA1)");
             return 1;
@@ -160,7 +197,7 @@ int test(LIBSSH2_SESSION *session)
 
         sha256_hash = libssh2_hostkey_hash(session,
                                            LIBSSH2_HOSTKEY_HASH_SHA256);
-        if(sha256_hash == NULL) {
+        if(!sha256_hash) {
             print_last_session_error(
                 "libssh2_hostkey_hash(LIBSSH2_HOSTKEY_HASH_SHA256)");
             return 1;
diff --git a/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c b/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c
deleted file mode 100644
index 56b1ba54..00000000
--- a/libssh2/tests/test_keyboard_interactive_auth_fails_with_wrong_response.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *WRONG_PASSWORD = "i'm not the password";
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruct, int instruct_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    int i;
-    (void)abstract;
-    fprintf(stdout, "Kb-int name: %.*s\n", name_len, name);
-    fprintf(stdout, "Kb-int instruction: %.*s\n", instruct_len, instruct);
-    for(i = 0; i < num_prompts; ++i) {
-        fprintf(stdout, "Kb-int prompt %d: %.*s\n", i, prompts[i].length,
-                prompts[i].text);
-    }
-
-    if(num_prompts == 1) {
-        responses[0].text = strdup(WRONG_PASSWORD);
-        responses[0].length = strlen(WRONG_PASSWORD);
-    }
-}
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "keyboard-interactive") == NULL) {
-        fprintf(stderr,
-                "'keyboard-interactive' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_keyboard_interactive_ex(
-        session, USERNAME, strlen(USERNAME), kbd_callback);
-    if(rc == 0) {
-        fprintf(stderr,
-                "Keyboard-interactive auth succeeded with wrong response\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c b/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c
deleted file mode 100644
index 0ccf5dd9..00000000
--- a/libssh2/tests/test_keyboard_interactive_auth_succeeds_with_correct_response.c
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "my test password";
-
-static void kbd_callback(const char *name, int name_len,
-                         const char *instruct, int instruct_len,
-                         int num_prompts,
-                         const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
-                         LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
-                         void **abstract)
-{
-    int i;
-    (void)abstract;
-
-    fprintf(stdout, "Kb-int name: %.*s\n", name_len, name);
-    fprintf(stdout, "Kb-int instruction: %.*s\n", instruct_len, instruct);
-    for(i = 0; i < num_prompts; ++i) {
-        fprintf(stdout, "Kb-int prompt %d: %.*s\n", i, prompts[i].length,
-                prompts[i].text);
-    }
-
-    if(num_prompts == 1) {
-        responses[0].text = strdup(PASSWORD);
-        responses[0].length = strlen(PASSWORD);
-    }
-}
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "keyboard-interactive") == NULL) {
-        fprintf(stderr,
-                "'keyboard-interactive' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_keyboard_interactive_ex(
-        session, USERNAME, strlen(USERNAME), kbd_callback);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_keyboard_interactive_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_password_auth_fails_with_wrong_password.c b/libssh2/tests/test_password_auth_fails_with_wrong_password.c
deleted file mode 100644
index 2b895d08..00000000
--- a/libssh2/tests/test_password_auth_fails_with_wrong_password.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *WRONG_PASSWORD = "i'm not the password";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, USERNAME, strlen(USERNAME),
-                                      WRONG_PASSWORD, strlen(WRONG_PASSWORD),
-                                      NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Password auth succeeded with wrong password\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_password_auth_fails_with_wrong_username.c b/libssh2/tests/test_password_auth_fails_with_wrong_username.c
deleted file mode 100644
index b78617a4..00000000
--- a/libssh2/tests/test_password_auth_fails_with_wrong_username.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *PASSWORD = "my test password";
-static const char *WRONG_USERNAME = "i dont exist";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, WRONG_USERNAME, strlen(WRONG_USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, WRONG_USERNAME,
-                                      strlen(WRONG_USERNAME), PASSWORD,
-                                      strlen(PASSWORD), NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Password auth succeeded with wrong username\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c b/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c
deleted file mode 100644
index 94b86b87..00000000
--- a/libssh2/tests/test_password_auth_succeeds_with_correct_credentials.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "my test password";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "password") == NULL) {
-        fprintf(stderr, "'password' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_password_ex(session, USERNAME, strlen(USERNAME),
-                                      PASSWORD, strlen(PASSWORD), NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_password_ex");
-        return 1;
-    }
-
-    if(libssh2_userauth_authenticated(session) == 0) {
-        fprintf(stderr, "Password auth appeared to succeed but "
-                        "libssh2_userauth_authenticated returned 0\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c b/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c
deleted file mode 100644
index dd2d254f..00000000
--- a/libssh2/tests/test_public_key_auth_fails_with_wrong_key.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *KEY_FILE_PRIVATE = "key_dsa_wrong";
-static const char *KEY_FILE_PUBLIC = "key_dsa_wrong.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc == 0) {
-        fprintf(stderr, "Public-key auth succeeded with wrong key\n");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c
deleted file mode 100644
index 187c1313..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_dsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_dsa";
-static const char *KEY_FILE_PUBLIC = "key_dsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c
deleted file mode 100644
index 2ea3a369..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ecdsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ecdsa";
-static const char *KEY_FILE_PUBLIC = "key_ecdsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c
deleted file mode 100644
index c52830d9..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ed25519";
-static const char *KEY_FILE_PUBLIC = "key_ed25519.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
deleted file mode 100644
index a79d1b51..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_ed25519_key_from_mem.c
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-
-static const char *USERNAME = "libssh2"; /* set in Dockerfile */
-static const char *KEY_FILE_ED25519_PRIVATE = "key_ed25519";
-
-int read_file(const char *path, char **buf, size_t *len);
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    char *buffer = NULL;
-    size_t len = 0;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    if(read_file(KEY_FILE_ED25519_PRIVATE, &buffer, &len)) {
-        fprintf(stderr, "Reading key file failed.");
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_frommemory(session,
-                                               USERNAME, strlen(USERNAME),
-                                               NULL, 0,
-                                               buffer, len,
-                                               NULL);
-
-    free(buffer);
-
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
-
-int read_file(const char *path, char **out_buffer, size_t *out_len)
-{
-    FILE *fp = NULL;
-    char *buffer = NULL;
-    size_t len = 0;
-
-    if(out_buffer == NULL || out_len == NULL || path == NULL) {
-        fprintf(stderr, "invalid params.");
-        return 1;
-    }
-
-    *out_buffer = NULL;
-    *out_len = 0;
-
-    fp = fopen(path, "r");
-
-    if(!fp) {
-        fprintf(stderr, "File could not be read.");
-        return 1;
-    }
-
-    fseek(fp, 0L, SEEK_END);
-    len = ftell(fp);
-    rewind(fp);
-
-    buffer = calloc(1, len + 1);
-    if(!buffer) {
-        fclose(fp);
-        fprintf(stderr, "Could not alloc memory.");
-        return 1;
-    }
-
-    if(1 != fread(buffer, len, 1, fp)) {
-        fclose(fp);
-        free(buffer);
-        fprintf(stderr, "Could not read file into memory.");
-        return 1;
-    }
-
-    fclose(fp);
-
-    *out_buffer = buffer;
-    *out_len = len;
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c
deleted file mode 100644
index 553023a9..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_ed25519_key.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_ed25519_encrypted";
-static const char *KEY_FILE_PUBLIC = "key_ed25519_encrypted.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        PASSWORD);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c
deleted file mode 100644
index ba98ac7c..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_encrypted_rsa_key.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *PASSWORD = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa_encrypted";
-static const char *KEY_FILE_PUBLIC = "key_rsa_encrypted.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        PASSWORD);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c
deleted file mode 100644
index 0cf2a633..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa";
-static const char *KEY_FILE_PUBLIC = "key_rsa.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
deleted file mode 100644
index a067d729..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_rsa_openssh_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "key_rsa_openssh";
-static const char *KEY_FILE_PUBLIC = "key_rsa_openssh.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-
-    const char *userauth_list =
-        libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c b/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c
deleted file mode 100644
index 10b33cbb..00000000
--- a/libssh2/tests/test_public_key_auth_succeeds_with_correct_signed_ecdsa_key.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "session_fixture.h"
-
-#include <libssh2.h>
-
-#include <stdio.h>
-
-/* configured in Dockerfile */
-static const char *USERNAME = "libssh2";
-static const char *KEY_FILE_PRIVATE = "signed_key_ecdsa";
-static const char *KEY_FILE_PUBLIC = "signed_key_ecdsa-cert.pub";
-
-int test(LIBSSH2_SESSION *session)
-{
-    int rc;
-    const char *userauth_list = NULL;
-
-    userauth_list = libssh2_userauth_list(session, USERNAME, strlen(USERNAME));
-    if(userauth_list == NULL) {
-        print_last_session_error("libssh2_userauth_list");
-        return 1;
-    }
-
-    if(strstr(userauth_list, "publickey") == NULL) {
-        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
-                userauth_list);
-        return 1;
-    }
-
-    rc = libssh2_userauth_publickey_fromfile_ex(
-        session, USERNAME, strlen(USERNAME), KEY_FILE_PUBLIC, KEY_FILE_PRIVATE,
-        NULL);
-    if(rc != 0) {
-        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/libssh2/tests/test_read.c b/libssh2/tests/test_read.c
new file mode 100644
index 00000000..ab94a7d0
--- /dev/null
+++ b/libssh2/tests/test_read.c
@@ -0,0 +1,131 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * libssh2 test receiving large amounts of data through a channel
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "runner.h"
+#include "openssh_fixture.h"
+
+#include <stdlib.h>  /* for getenv() */
+
+/* set in Dockerfile */
+static const char *username = "libssh2";
+static const char *key_file_private = "key_rsa";
+static const char *key_file_public = "key_rsa.pub";
+
+int test(LIBSSH2_SESSION *session)
+{
+    int rc;
+    unsigned long xfer_bytes = 0;
+    LIBSSH2_CHANNEL *channel;
+
+    /* Size and number of blocks to transfer
+     * This needs to be large to increase the chance of timing effects causing
+     * different code paths to be hit in the unframing code, but not so long
+     * that the integration tests take too long. 5 seconds of run time is
+     * probably a reasonable compromise. The block size is an odd number to
+     * increase the chance that various internal buffer and block boundaries
+     * are overlapped. */
+    const unsigned long xfer_bs = 997;
+    unsigned long xfer_count = 140080;
+
+    char remote_command[256];
+    const char *env;
+    const char *userauth_list;
+
+    /* Ignore our hard-wired Dockerfile user when not running under Docker */
+    if(!openssh_fixture_have_docker()) {
+        username = getenv("USER");
+#ifdef _WIN32
+        if(!username)
+            username = getenv("USERNAME");
+#endif
+    }
+
+    userauth_list = libssh2_userauth_list(session, username,
+                                          (unsigned int)strlen(username));
+    if(!userauth_list) {
+        print_last_session_error("libssh2_userauth_list");
+        return 1;
+    }
+
+    if(!strstr(userauth_list, "publickey")) {
+        fprintf(stderr, "'publickey' was expected in userauth list: %s\n",
+                userauth_list);
+        return 1;
+    }
+
+    rc = libssh2_userauth_publickey_fromfile_ex(session, username,
+                                                (unsigned int)strlen(username),
+                                                srcdir_path(key_file_public),
+                                                srcdir_path(key_file_private),
+                                                NULL);
+    if(rc) {
+        print_last_session_error("libssh2_userauth_publickey_fromfile_ex");
+        return 1;
+    }
+
+    /* Request a session channel on which to run a shell */
+    channel = libssh2_channel_open_session(session);
+    if(!channel) {
+        fprintf(stderr, "Unable to open a session\n");
+        goto shutdown;
+    }
+
+    env = getenv("FIXTURE_XFER_COUNT");
+    if(env) {
+        xfer_count = (unsigned long)strtol(env, NULL, 0);
+        fprintf(stderr, "Custom xfer_count: %lu\n", xfer_count);
+    }
+
+    /* command to transfer the desired amount of data */
+    snprintf(remote_command, sizeof(remote_command),
+             "dd if=/dev/zero bs=%lu count=%lu status=none",
+             xfer_bs, xfer_count);
+
+    /* Send the command to transfer data */
+    if(libssh2_channel_exec(channel, remote_command)) {
+        fprintf(stderr, "Unable to request command on channel\n");
+        goto shutdown;
+    }
+
+    /* Read data */
+    while(!libssh2_channel_eof(channel)) {
+        char buf[1024];
+        ssize_t err = libssh2_channel_read(channel, buf, sizeof(buf));
+        if(err < 0)
+            fprintf(stderr, "Unable to read response: %ld\n", (long)err);
+        else {
+            unsigned int i;
+            for(i = 0; i < (unsigned long)err; ++i) {
+                if(buf[i]) {
+                    fprintf(stderr, "Bad data received\n");
+                    /* Test will fail below due to bad data length */
+                    break;
+                }
+            }
+            xfer_bytes += i;
+        }
+    }
+
+    /* Shut down */
+    if(libssh2_channel_close(channel))
+        fprintf(stderr, "Unable to close channel\n");
+
+    if(channel) {
+        libssh2_channel_free(channel);
+        channel = NULL;
+    }
+
+shutdown:
+
+    /* Test check */
+    if(xfer_bytes != xfer_count * xfer_bs) {
+        fprintf(stderr, "Not enough bytes received: %lu not %lu\n",
+                xfer_bytes, xfer_count * xfer_bs);
+        return 1;  /* error */
+    }
+    return 0;
+}
diff --git a/libssh2/tests/test_read_algos.test b/libssh2/tests/test_read_algos.test
new file mode 100755
index 00000000..c283873c
--- /dev/null
+++ b/libssh2/tests/test_read_algos.test
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Copyright (C) Viktor Szakats
+# SPDX-License-Identifier: BSD-3-Clause
+
+set -e
+set -u
+
+# https://testanything.org/tap-specification.html
+
+testbin="./test_read${EXEEXT:-}"
+
+d="$(dirname "$0")"
+algos="$(tr -d $"\r" < "${d}/test_read_algos.txt")"
+
+count=1
+total="$(echo "${algos}" | wc -l | tr -d ' ')"
+
+echo "${count}..${total}"
+
+while read -r test; do
+  if [[ "${test}" = *'mac-'* ]]; then
+    if FIXTURE_TEST_MAC="${test}" "${testbin}"; then
+      res='ok'
+    else
+      res='not ok'
+    fi
+  else
+    if FIXTURE_TEST_CRYPT="${test}" "${testbin}"; then
+      res='ok'
+    else
+      res='not ok'
+    fi
+  fi
+  echo "${res} ${count} - test_read-${test}"
+  ((count++))
+done <<< "${algos}"
diff --git a/libssh2/tests/test_read_algos.txt b/libssh2/tests/test_read_algos.txt
new file mode 100644
index 00000000..a6f61738
--- /dev/null
+++ b/libssh2/tests/test_read_algos.txt
@@ -0,0 +1,18 @@
+3des-cbc
+aes128-cbc
+aes128-ctr
+aes128-gcm@openssh.com
+aes192-cbc
+aes192-ctr
+aes256-cbc
+aes256-ctr
+aes256-gcm@openssh.com
+hmac-md5
+hmac-md5-96
+hmac-sha1
+hmac-sha1-96
+hmac-sha1-etm@openssh.com
+hmac-sha2-256
+hmac-sha2-256-etm@openssh.com
+hmac-sha2-512
+hmac-sha2-512-etm@openssh.com
diff --git a/libssh2/libssh2/tests/simple.c b/libssh2/tests/test_simple.c
similarity index 85%
rename from libssh2/libssh2/tests/simple.c
rename to libssh2/tests/test_simple.c
index e97f7d33..3ba04071 100644
--- a/libssh2/libssh2/tests/simple.c
+++ b/libssh2/tests/test_simple.c
@@ -1,5 +1,5 @@
-/* Copyright (C) 2007 The Written Word, Inc.
- * Copyright (C) 2008, 2010 Simon Josefsson
+/* Copyright (C) The Written Word, Inc.
+ * Copyright (C) Simon Josefsson
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms,
@@ -34,30 +34,31 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#include "libssh2_priv.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "libssh2.h"
-
 static int test_libssh2_base64_decode(LIBSSH2_SESSION *session)
 {
     char *data;
-    unsigned int datalen;
+    size_t datalen;
     const char *src = "Zm5vcmQ=";
-    unsigned int src_len = strlen(src);
     int ret;
 
-    ret = libssh2_base64_decode(session, &data, &datalen,
-                                src, src_len);
+    ret = _libssh2_base64_decode(session, &data, &datalen,
+                                 src, strlen(src));
     if(ret)
         return ret;
 
     if(datalen != 5 || strcmp(data, "fnord") != 0) {
         fprintf(stderr,
-                "libssh2_base64_decode() failed (%d, %.*s)\n",
-                datalen, datalen, data);
+                "_libssh2_base64_decode() failed (%d, %.*s)\n",
+                (unsigned int)datalen, (unsigned int)datalen, data);
         return 1;
     }
 
@@ -74,7 +75,7 @@ int main(int argc, char *argv[])
     (void)argc;
 
     rc = libssh2_init(LIBSSH2_INIT_NO_CRYPTO);
-    if(rc != 0) {
+    if(rc) {
         fprintf(stderr, "libssh2_init() failed: %d\n", rc);
         return 1;
     }
diff --git a/libssh2/tests/test_ssh2.c b/libssh2/tests/test_ssh2.c
new file mode 100644
index 00000000..ca282de5
--- /dev/null
+++ b/libssh2/tests/test_ssh2.c
@@ -0,0 +1,277 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Self test, based on example/ssh2.c.
+ */
+
+#include "libssh2_setup.h"
+#include <libssh2.h>
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>  /* for getenv() */
+
+static const char *hostname = "127.0.0.1";
+static const int port_number = 4711;
+static const char *pubkey = "key_rsa.pub";
+static const char *privkey = "key_rsa";
+static const char *username = "username";
+static const char *password = "password";
+
+static void portable_sleep(unsigned int seconds)
+{
+#ifdef _WIN32
+    Sleep(seconds);
+#else
+    sleep(seconds);
+#endif
+}
+
+int main(int argc, char *argv[])
+{
+    uint32_t hostaddr;
+    libssh2_socket_t sock;
+    int i, auth_pw = 0;
+    struct sockaddr_in sin;
+    const char *fingerprint;
+    char *userauthlist;
+    int rc;
+    LIBSSH2_SESSION *session = NULL;
+    LIBSSH2_CHANNEL *channel;
+    unsigned int counter;
+
+#ifdef _WIN32
+    WSADATA wsadata;
+
+    rc = WSAStartup(MAKEWORD(2, 0), &wsadata);
+    if(rc) {
+        fprintf(stderr, "WSAStartup failed with error: %d\n", rc);
+        return 1;
+    }
+#endif
+
+    (void)argc;
+    (void)argv;
+
+    #ifdef _WIN32
+    #define LIBSSH2_FALLBACK_USER_ENV "USERNAME"
+    #else
+    #define LIBSSH2_FALLBACK_USER_ENV "LOGNAME"
+    #endif
+
+    if(getenv("USER"))
+        username = getenv("USER");
+    else if(getenv(LIBSSH2_FALLBACK_USER_ENV))
+        username = getenv(LIBSSH2_FALLBACK_USER_ENV);
+
+    if(getenv("PRIVKEY"))
+        privkey = getenv("PRIVKEY");
+
+    if(getenv("PUBKEY"))
+        pubkey = getenv("PUBKEY");
+
+    hostaddr = inet_addr(hostname);
+    if(hostaddr == (uint32_t)(-1)) {
+        fprintf(stderr, "Failed to convert %s host address\n", hostname);
+        return 1;
+    }
+
+    rc = libssh2_init(0);
+    if(rc) {
+        fprintf(stderr, "libssh2 initialization failed (%d)\n", rc);
+        return 1;
+    }
+
+    rc = 1;
+
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "failed to create socket.\n");
+        goto shutdown;
+    }
+
+    sin.sin_family = AF_INET;
+    sin.sin_port = htons((unsigned short)port_number);
+    sin.sin_addr.s_addr = hostaddr;
+
+    for(counter = 0; counter < 3; ++counter) {
+        if(connect(sock, (struct sockaddr*)(&sin),
+                   sizeof(struct sockaddr_in))) {
+            fprintf(stderr,
+                    "Connection to %s:%d attempt #%d failed: retrying...\n",
+                    hostname, port_number, counter);
+            portable_sleep(1 + 2*counter);
+        }
+        else {
+            break;
+        }
+    }
+    if(sock == LIBSSH2_INVALID_SOCKET) {
+        fprintf(stderr, "Failed to connect to %s:%d\n",
+                hostname, port_number);
+        goto shutdown;
+    }
+
+    /* Create a session instance and start it up. This will trade welcome
+     * banners, exchange keys, and setup crypto, compression, and MAC layers
+     */
+    session = libssh2_session_init();
+    if(!session) {
+        fprintf(stderr, "Could not initialize SSH session.\n");
+        goto shutdown;
+    }
+
+    if(getenv("FIXTURE_TRACE_ALL_CONNECT") ||
+       getenv("FIXTURE_TRACE_ALL")) {
+        libssh2_trace(session, ~0);
+        fprintf(stdout, "Trace all enabled.\n");
+    }
+
+    libssh2_session_set_blocking(session, 1);
+
+    {
+        int retries = 0, retry = 0;
+#ifdef LIBSSH2_WINCNG
+        /* FIXME: Retry tests with WinCNG due to flakiness in hostkey
+           verification: https://github.com/libssh2/libssh2/issues/804 */
+        retries += 2;
+#endif
+        do {
+            rc = libssh2_session_handshake(session, sock);
+            if(rc == 0) {
+                break;
+            }
+            fprintf(stderr, "Failure establishing SSH session: %d\n", rc);
+            if(
+#ifdef LIBSSH2_WINCNG
+               rc != LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE ||
+#endif
+               ++retry > retries) {
+                break;
+            }
+            fprintf(stderr, "Retrying... %d / %d\n", retry, retries);
+        } while(1);
+    }
+
+    rc = 1;
+
+    /* At this point we have not yet authenticated.  The first thing to do
+     * is check the hostkey's fingerprint against our known hosts Your app
+     * may have it hard coded, may go to a file, may present it to the
+     * user, that's your call
+     */
+    fingerprint = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
+    fprintf(stderr, "Fingerprint: ");
+    for(i = 0; i < 20; i++) {
+        fprintf(stderr, "%02X ", (unsigned char)fingerprint[i]);
+    }
+    fprintf(stderr, "\n");
+
+    /* check what authentication methods are available */
+    userauthlist = libssh2_userauth_list(session, username,
+                                         (unsigned int)strlen(username));
+    if(userauthlist) {
+        fprintf(stderr, "Authentication methods: %s\n", userauthlist);
+        if(strstr(userauthlist, "password")) {
+            auth_pw |= 1;
+        }
+        if(strstr(userauthlist, "keyboard-interactive")) {
+            auth_pw |= 2;
+        }
+        if(strstr(userauthlist, "publickey")) {
+            auth_pw |= 4;
+        }
+
+        if(auth_pw & 4) {
+            /* Authenticate by public key */
+            if(libssh2_userauth_publickey_fromfile(session, username,
+                                                   pubkey, privkey,
+                                                   password)) {
+                fprintf(stderr, "Authentication by public key failed.\n");
+                goto shutdown;
+            }
+            else {
+                fprintf(stderr, "Authentication by public key succeeded.\n");
+            }
+        }
+        else {
+            fprintf(stderr, "No supported authentication methods found.\n");
+            goto shutdown;
+        }
+    }
+
+    /* Request a session channel on which to run a shell */
+    channel = libssh2_channel_open_session(session);
+    if(!channel) {
+        fprintf(stderr, "Unable to open a session\n");
+        goto shutdown;
+    }
+
+    /* Some environment variables may be set,
+     * It's up to the server which ones it'll allow though
+     */
+    libssh2_channel_setenv(channel, "FOO", "bar");
+
+    /* Request a terminal with 'vanilla' terminal emulation
+     * See /etc/termcap for more options. This is useful when opening
+     * an interactive shell.
+     */
+    if(libssh2_channel_request_pty(channel, "vanilla")) {
+        fprintf(stderr, "Failed requesting pty\n");
+        goto skip_shell;
+    }
+
+    /* Open a SHELL on that pty */
+    if(libssh2_channel_shell(channel)) {
+        fprintf(stderr, "Unable to request shell on allocated pty\n");
+        goto shutdown;
+    }
+
+    rc = 0;
+
+skip_shell:
+
+    if(channel) {
+        libssh2_channel_free(channel);
+        channel = NULL;
+    }
+
+shutdown:
+
+    if(session) {
+        libssh2_session_disconnect(session, "Normal Shutdown");
+        libssh2_session_free(session);
+    }
+
+    if(sock != LIBSSH2_INVALID_SOCKET) {
+        shutdown(sock, 2 /* SHUT_RDWR */);
+#ifdef _WIN32
+        closesocket(sock);
+#else
+        close(sock);
+#endif
+    }
+
+    fprintf(stderr, "all done\n");
+
+    libssh2_exit();
+
+#ifdef _WIN32
+    WSACleanup();
+#endif
+
+    return rc;
+}
diff --git a/libssh2/tests/test_sshd.test b/libssh2/tests/test_sshd.test
new file mode 100755
index 00000000..01e8c541
--- /dev/null
+++ b/libssh2/tests/test_sshd.test
@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# Copyright (C) Simon Josefsson
+# Copyright (C) Viktor Szakats
+# SPDX-License-Identifier: BSD-3-Clause
+#
+# Start sshd, invoke test(s), saving exit code, kill sshd, and
+# return exit code.
+
+set -e
+set -u
+
+# https://testanything.org/tap-specification.html
+
+d="$(dirname "$0")"
+uname="$(uname)"
+
+# Load list of tests
+
+if [ -n "${1:-}" ]; then
+  # for CMake or manual
+  tests="$*"
+  via_args=1
+else
+  # for autotools
+  via_args=0
+  # Load list of SSHD tests from Makefile.inc
+  tests=''
+  load=0
+  while read -r l; do
+    if [[ "${l}" = 'SSHD_TESTS ='* ]]; then
+      load=1
+    elif [ "${load}" = '1' ]; then
+      [[ "${l}" =~ [a-z0-9_]+ ]] && tests+="${tests:+ }./${BASH_REMATCH[0]}${EXEEXT:-}"
+      [[ ! "${l}" = *"\\" ]] && break
+    fi
+  done <<< "$(tr -d $"\r" < "${d}/Makefile.inc")"
+fi
+
+if [ -n "${SSHD_TESTS_LIMIT_TO:-}" ]; then
+  tests="$(echo "${tests}" | cut -d ' ' -f -"${SSHD_TESTS_LIMIT_TO}")"
+  echo "# limiting tests to the first ${SSHD_TESTS_LIMIT_TO}."
+fi
+
+# Init and start sshd
+
+d="$(cd "${d}" || exit; pwd)"  # sshd needs absolute paths
+
+SSHD="${SSHD:-/usr/sbin/sshd}"
+[[ "${uname}" = *'_NT'* ]] && SSHD="$(cygpath "${SSHD}")"
+ver="$("${SSHD}" -V 2>&1 || true)"
+if [[ "${ver}" =~ OpenSSH_[a-zA-Z0-9_\ .,]+ ]]; then
+  ver="${BASH_REMATCH[0]}"
+else
+  ver=''
+fi
+echo "# sshd executable: '${SSHD}' (${ver})"
+
+# for our test clients:
+[ -z "${PRIVKEY:-}" ] && export PRIVKEY="${d}/key_rsa"
+[ -z "${PUBKEY:-}" ]  && export PUBKEY="${d}/key_rsa.pub"
+cakeys="${d}/openssh_server/ca_user_keys.pub"
+
+logfsrv="$(mktemp)"; readonly logfsrv
+logfcli="$(mktemp)"; readonly logfcli
+
+echo "# sshd log: '${logfsrv}'"
+
+SSHD_FLAGS="${SSHD_FLAGS:-}"
+if [ -n "${DEBUG:-}" ]; then
+  SSHD_FLAGS+=' -d -d'
+else
+  SSHD_FLAGS+=" -E ${logfsrv}"
+fi
+
+chmod go-rwx \
+  "${d}"/openssh_server/ssh_host_* \
+  "${cakeys}"
+
+# shellcheck disable=SC2086
+"${SSHD}" \
+  -f "${SSHD_FIXTURE_CONFIG:-${d}/openssh_server/sshd_config}" \
+  -o 'Port 4711' \
+  -o 'StrictModes no' \
+  -h "${d}/openssh_server/ssh_host_rsa_key" \
+  -h "${d}/openssh_server/ssh_host_ecdsa_key" \
+  -h "${d}/openssh_server/ssh_host_ed25519_key" \
+  -o 'PidFile sshd.pid' \
+  -o "AuthorizedKeysFile ${PUBKEY} ${d}/openssh_server/authorized_keys" \
+  -o "TrustedUserCAKeys ${cakeys}" \
+  -o 'PermitRootLogin yes' \
+  -D \
+  ${SSHD_FLAGS} &
+sshdpid=$!
+
+trap 'kill "${sshdpid}"; echo "# signal killing sshd"; exit 1;' EXIT HUP INT TERM
+
+: "started sshd (${sshdpid})"
+
+SSH="$(command -v "${SSH:-ssh}" || true)"
+if [ -n "${SSH}" ]; then
+  echo "# ssh executable: '${SSH}' ($("${SSH}" -V 2>&1 || true))"
+  echo "# ssh log: '${logfcli}'"
+  chmod go-rwx "${PRIVKEY}"
+  if [[ "${uname}" = *'_NT'* ]]; then
+    export MSYS2_ARG_CONV_EXCL='/reset'
+    icacls "${PRIVKEY}" /reset
+    icacls "${PRIVKEY}" /grant:r "${USERNAME}:(R)"
+    icacls "${PRIVKEY}" /inheritance:r
+  fi
+  count=1
+  # shellcheck disable=SC2086
+  while ! "${SSH:-ssh}" -q -a -k \
+      -F /dev/null \
+      -o 'BatchMode yes' \
+      -o 'StrictHostKeyChecking no' \
+      -o 'UserKnownHostsFile /dev/null' \
+      -o 'ConnectTimeout 3' \
+      -i "${PRIVKEY}" \
+      -p 4711 ${SSH_FLAGS:-} localhost exit 2>>"${logfcli}"; do
+    ((count++))
+    if [[ "${count}" -gt 8 ]]; then
+      echo '# giving up waiting for sshd. Tests are expected to fail.'
+      echo '# sshd log:'
+      sed 's/^/#  /' < "${logfsrv}"
+      echo '# ssh test connect log:'
+      sed 's/^/#  /' < "${logfcli}"
+      break
+    fi
+    echo '# waiting for sshd...'
+    sleep 1
+  done
+else
+  echo '# giving time for sshd to launch...'
+  sleep 5
+fi
+
+# Run tests
+
+ec=0
+count=1
+total="$(echo "${tests}" | wc -w | tr -d ' ')"
+anyerror=0
+
+echo "${count}..${total}"
+
+export OPENSSH_NO_DOCKER=1
+
+for test in ${tests}; do
+  if "${test}"; then
+    res='ok'
+  else
+    testerr=$?
+    anyerror=1
+    [ "${via_args}" = '1' ] && [ "${total}" = '1' ] && ec="${testerr}"
+    res='not ok'
+  fi
+  echo "${res} ${count} - sshd-$(basename "${test}")"
+  ((count++))
+done
+
+# Stop sshd
+
+: "killing sshd (${sshdpid})"
+kill "${sshdpid}" > /dev/null 2>&1
+trap '' EXIT HUP INT TERM
+
+[ "${via_args}" = '1' ] && [ "${total}" != '1' ] && ec="${anyerror}"
+
+exit "${ec}"
diff --git a/libssh2/vms/libssh2_config.h b/libssh2/vms/libssh2_config.h
index b8f73e27..2cbe78a7 100644
--- a/libssh2/vms/libssh2_config.h
+++ b/libssh2/vms/libssh2_config.h
@@ -1,3 +1,8 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
 #ifndef LIBSSH2_CONFIG_H
 #ifdef __VMS
 
@@ -8,28 +13,28 @@
 
 #define ssize_t SSIZE_T
 
-typedef unsigned int uint32_t ;
+typedef unsigned int uint32_t;
 typedef unsigned int socklen_t; /* missing in headers on VMS */
 
 /* Have's */
 
 #define HAVE_UNISTD_H
-#define HAVE_STDLIB_H
 #define HAVE_INTTYPES_H
 #define HAVE_SYS_TIME_H
 #define HAVE_SELECT
 #define HAVE_UIO
 
-#define HAVE_SYS_SOCKET.H
+#define HAVE_SYS_SOCKET_H
 #define HAVE_NETINET_IN_H
 #define HAVE_ARPA_INET_H
 
 #define HAVE_GETTIMEOFDAY 1
+#define HAVE_SNPRINTF 1
 
 #define POSIX_C_SOURCE
 
 /* Enable the possibility of using tracing */
- 
+
 #define LIBSSH2DEBUG 1
 
 /* For selection of proper block/unblock function in session.c */
@@ -38,23 +43,23 @@ typedef unsigned int socklen_t; /* missing in headers on VMS */
 
 #include <stropts.h>
 
-/* In VMS TCP/IP Services and some BSD variants SO_STATE retrieves 
- * a bitmask revealing amongst others the blocking state of the 
+/* In VMS TCP/IP Services and some BSD variants SO_STATE retrieves
+ * a bitmask revealing amongst others the blocking state of the
  * socket. On VMS the bits are undocumented, but  SS_NBIO
- * works, I did not test the other bits. Below bitdefs are 
- * from Berkely source socketvar.h at   
+ * works, I did not test the other bits. Below bitdefs are
+ * from Berkely source socketvar.h at
  * http://ftp.fibranet.cat/UnixArchive/PDP-11/Trees/2.11BSD/sys/h/socketvar.h
  *  Socket state bits.
- *  #define SS_NOFDREF          0x001    no file table ref any more 
- *  #define SS_ISCONNECTED      0x002    socket connected to a peer 
- *  #define SS_ISCONNECTING     0x004    in process of connecting to peer 
- *  #define SS_ISDISCONNECTING  0x008    in process of disconnecting 
- *  #define SS_CANTSENDMORE     0x010    can't send more data to peer 
- *  #define SS_CANTRCVMORE      0x020    can't receive more data from peer 
- *  #define SS_RCVATMARK        0x040    at mark on input 
- *  #define SS_PRIV             0x080    privileged for broadcast, raw... 
- *  #define SS_NBIO             0x100    non-blocking ops 
- *  #define SS_ASYNC            0x200    async i/o notify 
+ *  #define SS_NOFDREF          0x001    no file table ref any more
+ *  #define SS_ISCONNECTED      0x002    socket connected to a peer
+ *  #define SS_ISCONNECTING     0x004    in process of connecting to peer
+ *  #define SS_ISDISCONNECTING  0x008    in process of disconnecting
+ *  #define SS_CANTSENDMORE     0x010    can't send more data to peer
+ *  #define SS_CANTRCVMORE      0x020    can't receive more data from peer
+ *  #define SS_RCVATMARK        0x040    at mark on input
+ *  #define SS_PRIV             0x080    privileged for broadcast, raw...
+ *  #define SS_NBIO             0x100    non-blocking ops
+ *  #define SS_ASYNC            0x200    async i/o notify
  *
  */
 
@@ -64,10 +69,10 @@ typedef unsigned int socklen_t; /* missing in headers on VMS */
  * When running on Multinet, SO_STATE renders a protocol
  * not started error. Functionally this has no impact,
  * apart from libssh2 not being able to restore the socket
- * to the proper blocking/non-blocking state.  
+ * to the proper blocking/non-blocking state.
  */
 
-#define SS_NBIO         0x100 
+#define SS_NBIO         0x100
 
 #endif
 
@@ -80,9 +85,5 @@ typedef unsigned int socklen_t; /* missing in headers on VMS */
 
 #define LIBSSH2_HAVE_ZLIB
 
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-
-#define LIBSSH2_DH_GEX_NEW 1
-
 #endif /* __VMS */
-#endif /* LIBSSH2_CONFIG_H */                             
+#endif /* LIBSSH2_CONFIG_H */
diff --git a/libssh2/vms/libssh2_make_example.dcl b/libssh2/vms/libssh2_make_example.dcl
index af4116dd..17e71962 100644
--- a/libssh2/vms/libssh2_make_example.dcl
+++ b/libssh2/vms/libssh2_make_example.dcl
@@ -8,9 +8,9 @@ $ if .not. init_status then goto YExit
 $!
 $ if what .eqs. "ALL"
 $ then
-$	call MakeAll
+$   call MakeAll
 $ else
-$	call Make 
+$   call Make
 $endif
 $!
 $YExit:
@@ -19,7 +19,7 @@ $! deassign exadir
 $! deassign objdir
 $ delete 'link_opts';*
 $ set default 'olddir'
-$exit 
+$exit
 
 $MakeAll: subroutine
 $!
@@ -45,14 +45,14 @@ $ set noon
 $!
 $ cc 'cc_include' 'cc_flags'/object=objdir:'what' exadir:'what'
 $ sev = $severity
-$ if sev .and. 2 
+$ if sev .and. 2
 $ then
-$	say "Error compiling ''what', not linked."
+$   say "Error compiling ''what', not linked."
 $ else
-$ 	if .not. (sev .and. 1)  
-$ 	then
-$		say "Compile warnings in  ''what'"
-$ 	endif
+$   if .not. (sev .and. 1)
+$   then
+$     say "Compile warnings in  ''what'"
+$   endif
 $  link/exe='what'.exe objdir:'what'.obj, 'link_opts'/opt
 $ endif
 $!
@@ -60,15 +60,15 @@ $!
 $End:
 $ delete objdir:'what'.obj;*
 $exit
-$endsubroutine 
+$endsubroutine
 
 
-$Init: 
+$Init:
 $!
 $!
 $ init_status = 1
 $ thisid = f$integer( %x'f$getjpi(0,"pid")') + "''f$cvtime(,,"second")'"
-$ mdir   = f$environment("procedure") 
+$ mdir   = f$environment("procedure")
 $ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
 $ set default 'mdir'
 $!
@@ -78,7 +78,7 @@ $!
 $ objdirfile = objdir - "[." - "]" + ".dir"
 $ if f$search( objdirfile ) .eqs. ""
 $ then
-$	create/directory 'objdir'
+$   create/directory 'objdir'
 $ endif
 $!
 $ define objdir 'objdir'
@@ -89,17 +89,17 @@ $ cc_flags   = "/name=shortened/show=all/define=(_USE_STD_STAT=1)"
 $ link_opts  = "objdir:libssh2_''thisid'.opt"
 $!
 $!
-$ what = "''p1'" 
-$ if what .eqs. "" .or. f$edit(p1,"trim,collapse,upcase") .eqs. "ALL" 
-$ then 
-$	what = "ALL"
+$ what = "''p1'"
+$ if what .eqs. "" .or. f$edit(p1,"trim,collapse,upcase") .eqs. "ALL"
+$ then
+$   what = "ALL"
 $ else
-$	what = f$parse(what,,,"name")
-$	if f$search("exadir:''what'.c") .eqs. ""
-$	then 
-$		write sys$output "Can't make ''what'"
-$		init_status = 0
-$	endif
+$   what = f$parse(what,,,"name")
+$   if f$search("exadir:''what'.c") .eqs. ""
+$   then
+$     write sys$output "Can't make ''what'"
+$     init_status = 0
+$   endif
 $ endif
 $!
 $ currentlib = f$search("libssh2*.exe")
@@ -107,19 +107,19 @@ $!
 $ define libssh2 'currentlib'
 $!
 $ how  = "''p2'"
-$ if how .eqs. "" .or. f$edit(p2,"trim,collapse,upcase") .eqs. "STATIC" 
+$ if how .eqs. "" .or. f$edit(p2,"trim,collapse,upcase") .eqs. "STATIC"
 $ then
-$ 	open/write lout 'link_opts'
-$ 	write lout "libssh2.olb/lib"
-$ 	write lout "sys$share:ssl$libcrypto_shr32.exe/share"
-$ 	write lout "sys$share:ssl$libssl_shr32.exe/share"
-$ 	write lout "gnv$libzshr/share"
-$ 	close lout
+$   open/write lout 'link_opts'
+$   write lout "libssh2.olb/lib"
+$   write lout "sys$share:ssl$libcrypto_shr32.exe/share"
+$   write lout "sys$share:ssl$libssl_shr32.exe/share"
+$   write lout "gnv$libzshr/share"
+$   close lout
 $ else
-$	how = "SHARED"
-$ 	open/write lout 'link_opts'
-$ 	write lout "libssh2/share"
-$ 	close lout
-$ endif 
+$   how = "SHARED"
+$   open/write lout 'link_opts'
+$   write lout "libssh2/share"
+$   close lout
+$ endif
 $!
 $return
diff --git a/libssh2/vms/libssh2_make_help.dcl b/libssh2/vms/libssh2_make_help.dcl
index 652671da..34bbb052 100644
--- a/libssh2/vms/libssh2_make_help.dcl
+++ b/libssh2/vms/libssh2_make_help.dcl
@@ -26,8 +26,8 @@ $ man2help -a [-]COPYING.; libssh2.hlp       -b 2
 $ man2help -a [-]NEWS.; libssh2.hlp          -b 2
 $ man2help -a [-]RELEASE-NOTES.; libssh2.hlp -b 2
 $ man2help -a [-.docs]AUTHORS.; libssh2.hlp  -b 2
-$ man2help -a [-.docs]BINDINGS.; libssh2.hlp -b 2
-$ man2help -a [-.docs]HACKING.; libssh2.hlp  -b 2
+$ copy [-.docs]BINDINGS.md; []BINDINGS.md
+$ copy [-.docs]HACKING.md; []HACKING.md
 $ if f$search("[]HACKING_CRYPTO.") .nes. "" then delete []HACKING_CRYPTO.;*
 $ copy [-.docs]HACKING-CRYPTO; []HACKING_CRYPTO.
 $ man2help -a []HACKING_CRYPTO.; libssh2.hlp -b 2
diff --git a/libssh2/vms/libssh2_make_kit.dcl b/libssh2/vms/libssh2_make_kit.dcl
index 6a149588..f96c0abf 100644
--- a/libssh2/vms/libssh2_make_kit.dcl
+++ b/libssh2/vms/libssh2_make_kit.dcl
@@ -22,24 +22,24 @@ $!
 $ set default [-]
 $!
 $ defdir  = f$environment( "default" )
-$ thisdev = f$parse(defdir,,,"device","no_conceal") 
+$ thisdev = f$parse(defdir,,,"device","no_conceal")
 $ thisdir = f$parse(defdir,,,"directory","no_conceal") - "][" - "][" - "][" - "]["
 $!
-$ libssh2_kf = thisdev + thisdir 
+$ libssh2_kf = thisdev + thisdir
 $ libssh2_kf = libssh2_kf - "]" + ".]"
 $!
 $ set default 'mdir'
 $!
 $ define/translation_attributes=concealed libssh2_kf 'libssh2_kf'
 $!
-$ product package libssh2 - 
-    /base='arch' - 
+$ product package libssh2 -
+    /base='arch' -
     /producer=jcb -
-    /source=[] - ! where to find PDF and PTF 
-    /destination=[] - ! where to put .PCSI file 
-    /material=libssh2_kf:[000000...] -      ! where to find product material 
+    /source=[] - ! where to find PDF and PTF
+    /destination=[] - ! where to put .PCSI file
+    /material=libssh2_kf:[000000...] -      ! where to find product material
     /version="''vms_majorv'.''minorv'-''patchv'''datename'" -
-    /format=sequential 
+    /format=sequential
 $!
 $End:
 $!
@@ -52,7 +52,7 @@ $!
 $ if f$trnlnm("libssh2_kf") .nes. "" then deassign libssh2_kf
 $ set default 'olddir'
 $!
-$exit 
+$exit
 $!
 $!--------------------------------------------------------------------------------
 $!
@@ -61,20 +61,20 @@ $ set process/parse=extended
 $!
 $ say    = "write sys$output"
 $!
-$ mdir   = f$environment("procedure") 
+$ mdir   = f$environment("procedure")
 $ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
 $!
 $ set default 'mdir'
 $!
-$ pipe search [-.include]*.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]*.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job majorv &l )
-$ pipe search [-.include]*.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]*.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job minorv &l )
-$ pipe search [-.include]*.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]*.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job patchv &l )
 $!
 $ majorv   = f$trnlnm("majorv")
-$ minorv   = f$integer(f$trnlnm("minorv")) 
+$ minorv   = f$integer(f$trnlnm("minorv"))
 $ patchv   = f$integer( f$trnlnm("patchv"))
 $!
 $ deassign/job majorv
@@ -106,10 +106,10 @@ $ then
 $   daily    = "FALSE"
 $   datename = "Final"
 $ else
-$   datename = "D" + f$extract(seconddash+1,8,restdir)   
+$   datename = "D" + f$extract(seconddash+1,8,restdir)
 $ endif
 $!
-$ if daily 
+$ if daily
 $ then
 $   productname = "JCB ''arch' LIBSSH2 V''vms_majorv'.''minorv'-''patchv'''datename'"
 $ else
@@ -176,7 +176,7 @@ $ write pd "    file ""[gnv.usr.share.doc.libssh2]libssh2-''versionname'.release
 $ write pd "    file ""[gnv.usr.lib]gnv$libssh2_''versionname'.exe"" source ""[vms]libssh2_''versionname'.exe"";"
 $ write pd "end product ;"
 $ close pd
-$exit 
+$exit
 $endsubroutine
 $!
 $!--------------------------------------------------------------------------------
@@ -194,7 +194,7 @@ $ write pt "=prompt JCB LIBSSH2 for OpenVMS"
 $ write pt ""
 $ write pt "libssh2 is an open source client side library that aims to implement"
 $ write pt "the SSH protocol. This is the OpenVMS port of that library."
-$ write pt "Further information at https://www.libssh2.org."
+$ write pt "Further information at https://libssh2.org/."
 $ write pt ""
 $ write pt "1 NEED_VMS83"
 $ write pt "=prompt OpenVMS 8.3 or later is not installed on your system."
@@ -219,4 +219,3 @@ $ write pt "[gnv.common_src]libssh2_''versionname'''datename'_src.bck"
 $close pt
 $exit
 $ endsubroutine
-
diff --git a/libssh2/vms/libssh2_make_lib.dcl b/libssh2/vms/libssh2_make_lib.dcl
index 56d168f2..a763445e 100644
--- a/libssh2/vms/libssh2_make_lib.dcl
+++ b/libssh2/vms/libssh2_make_lib.dcl
@@ -21,16 +21,16 @@ $ deassign objdir
 $ delete library_objects.dir;*
 $!
 $ set default 'olddir'
-$exit 
+$exit
 $!
 $!---------------------------------------------------------------------
 $!
-$Init: 
+$Init:
 $!
 $!
 $ init_status = 1
-$ thisid = f$integer( %x'f$getjpi(0,"pid")') 
-$ mdir   = f$environment("procedure") 
+$ thisid = f$integer( %x'f$getjpi(0,"pid")')
+$ mdir   = f$environment("procedure")
 $ mdir   = mdir - f$parse(mdir,,,"name") - f$parse(mdir,,,"type") - f$parse(mdir,,,"version")
 $ set default 'mdir'
 $!
@@ -50,15 +50,15 @@ $ cc_include = "/include=([],[-.include],""/gnv$zlib_include"")"
 $ cc_define = "/DEFINE=(_USE_STD_STAT=1)"
 $ link_opts  = "objdir:libssh2_''thisid'.opt"
 $!
-$ pipe search [-.include]libssh2.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]libssh2.h libssh2_version_major/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job majorv &l )
-$ pipe search [-.include]libssh2.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]libssh2.h libssh2_version_minor/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job minorv &l )
-$ pipe search [-.include]libssh2.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; - 
+$ pipe search [-.include]libssh2.h libssh2_version_patch/nohead | (read sys$input l ; l = f$element(2," ",f$edit(l,"trim,compress")) ; -
        define/job patchv &l )
 $!
 $ majorv   = f$trnlnm("majorv")
-$ minorv   = f$integer(f$trnlnm("minorv")) 
+$ minorv   = f$integer(f$trnlnm("minorv"))
 $ patchv   = f$integer( f$trnlnm("patchv"))
 $!
 $ OLBONLY = "FALSE"
@@ -81,7 +81,7 @@ $ set noon
 $ purge *.opt
 $ purge *.olb
 $ purge *.exe
-$! 
+$!
 $exit 1
 $endsubroutine
 $!
@@ -103,7 +103,7 @@ $ write uitv "sys$share:ssl$libcrypto_shr32.exe/share"
 $ write uitv "sys$share:ssl$libssl_shr32.exe/share"
 $ write uitv "gnv$libzshr/share"
 $ close uitv
-$! 
+$!
 $ link/shared/exe=libssh2_'majorv'_'minorv'_'patchv'.exe -
     libssh2.olb/lib, -
     link_libssh2_version_'majorv'_'minorv'_'patchv'.opt/opt, -
@@ -118,12 +118,12 @@ $CompileAll: subroutine
 $!
 $ set noon
 $!
-$ if f$search("objdir:*.obj;*") .nes "" 
-$ then 
+$ if f$search("objdir:*.obj;*") .nes ""
+$ then
 $   delete objdir:*.obj;*
 $ endif
-$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$ then 
+$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes ""
+$ then
 $   delete [.cxx_repository]cxx$demangler_db.;*
 $ endif
 $!
@@ -136,16 +136,16 @@ $ case = 0
 $ if OLBONLY then case = 1
 $CaseLoop:
 $!
-$ if case .eq. 0 
-$ then!camel case names 
+$ if case .eq. 0
+$ then!camel case names
 $   cc_flags = "/names=(shortened,as_is)''cc_define'"
 $   objlib = "libssh2_asis.olb"
 $ endif
 $!
-$ if case .eq. 1 
-$ then!uppercase names 
-$   if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$   then 
+$ if case .eq. 1
+$ then!uppercase names
+$   if f$search("[.cxx_repository]cxx$demangler_db.;") .nes ""
+$   then
 $      rename [.cxx_repository]cxx$demangler_db.; *.lowercase
 $      purge  [.cxx_repository]cxx$demangler_db.lowercase
 $   endif
@@ -172,8 +172,8 @@ $ delete objdir:*.obj;*
 $ if case .lt 2 then goto CaseLoop
 $!
 $ rename libssh2_up.olb libssh2.olb
-$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes "" 
-$ then 
+$ if f$search("[.cxx_repository]cxx$demangler_db.;") .nes ""
+$ then
 $    rename [.cxx_repository]cxx$demangler_db.; *.uppercase
 $    purge  [.cxx_repository]cxx$demangler_db.uppercase
 $ endif
@@ -182,10 +182,10 @@ $ if OLBONLY then exit 4
 $!
 $! For each function that is too long, create a global symbol
 $! low$'shortened-uppercase-name' with as value lowercase shortened
-$! name in it, so we can add the proper lower or mixed case 
-$! shortened name later when building the transfer vectors 
+$! name in it, so we can add the proper lower or mixed case
+$! shortened name later when building the transfer vectors
 $! for the shared image.
-$! This is to prevent two very long similar function names 
+$! This is to prevent two very long similar function names
 $! that are shortened getting mixed up when sorted alphabetically.
 $!
 $ inputfile = "[.cxx_repository]cxx$demangler_db.lowercase"
@@ -211,7 +211,7 @@ $ symvalue = ""
 $!
 $ if shortname .eqs. f$edit(shortname,"upcase")
 $ then
-$!  this is an uppercase shortname, add it 
+$!  this is an uppercase shortname, add it
 $   symname  = "u$''longname'"
 $   symvalue = "''shortname'"
 $   low$'shortname' == l$'longname'
@@ -246,7 +246,7 @@ $ library/insert 'objlib' objdir:'what'.obj
 $!
 $End:
 $exit
-$endsubroutine 
+$endsubroutine
 $!
 $!---------------------------------------------------------------------
 $!
@@ -254,7 +254,7 @@ $BuildTransferVectors: subroutine
 $!
 $! Do a balanced read of the uppercase library names
 $! and the mixed case library names, and build the
-$! transfer vectors with uppercase entry points 
+$! transfer vectors with uppercase entry points
 $! with an alternative in mixed case.
 $! For shortened names, use the low$* symbols
 $! to avoid being fooled by the sort.
@@ -267,9 +267,9 @@ $! case blind sort of all modules in both the uppercase
 $! as the case sensitive object library.
 $!
 $ sort libu.'thisid' lib.'thisid'/spec=sys$input
-/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD) 
+/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD)
 $ sort lib_asisu.'thisid' lib_asis.'thisid'/spec=sys$input
-/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD) 
+/COLLATING_SEQUENCE=(SEQUENCE= ("A" - "Z","0"-"9","_"), FOLD)
 $!
 $ open/read  in  lib.'thisid'
 $ open/read  inasis  lib_asis.'thisid'
@@ -300,12 +300,12 @@ $ endif
 $!
 $ if uitregel .nes. "" .and. mode .eq. 1
 $ then
-$   write uit "''uitregel'=PROCEDURE, -" 
-$   write uit "''uitasis'/''uitregel'=PROCEDURE, -" 
+$   write uit "''uitregel'=PROCEDURE, -"
+$   write uit "''uitasis'/''uitregel'=PROCEDURE, -"
 $!
 $   uitregel = ""
 $   uitasis  = ""
-$ endif 
+$ endif
 $!
 $ uitregel = regel
 $ if f$type( low$'uitregel' ) .nes. ""
@@ -320,14 +320,14 @@ $ mode = 1
 $!
 $ goto ReadLoop
 $EndreadLoop:
-$! 
+$!
 $! To get the closing brace after the last procedure
 $! keyword.
 $!
 $ if uitregel .nes. ""
-$ then 
-$   write uit "''uitregel'=PROCEDURE, -" 
-$   write uit "''uitasis'/''uitregel'=PROCEDURE)" 
+$ then
+$   write uit "''uitregel'=PROCEDURE, -"
+$   write uit "''uitasis'/''uitregel'=PROCEDURE)"
 $ endif
 $!
 $ write uit "CASE_SENSITIVE=NO"
diff --git a/libssh2/vms/man2help.c b/libssh2/vms/man2help.c
index 92e5f2b9..2cdad29d 100644
--- a/libssh2/vms/man2help.c
+++ b/libssh2/vms/man2help.c
@@ -1,3 +1,8 @@
+/* Copyright (C) The libssh2 project and its contributors.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -10,507 +15,550 @@
 #include <descrip.h>
 #include <rms.h>
 
-typedef struct manl{
+typedef struct manl {
     struct manl *next;
     char *filename;
-}man, *manPtr;
- 
-typedef struct pf_fabnam{
+} man, *manPtr;
+
+typedef struct pf_fabnam {
     struct FAB dfab;
     struct RAB drab;
     struct namldef dnam;
-    char   expanded_filename[NAM$C_MAXRSS + 1]; 
+    char   expanded_filename[NAM$C_MAXRSS + 1];
 } pfn, *pfnPtr;
 
 /*----------------------------------------------------------*/
 
-fpcopy( char *output, char *input, int len )
+fpcopy(char *output, char *input, int len)
 {
-char    *is, *os;
-int i;
+    char *is, *os;
+    int i;
 
-if ( len ){
-    for ( is = input, os = output, i = 0; i < len ; ++i, ++is, ++os){
+    if(len) {
+        for(is = input, os = output, i = 0; i < len; ++i, ++is, ++os) {
             *os = *is;
+        }
+        *os = 0;
+    }
+    else {
+        output[0] = 0;
     }
-    *os = 0;
-}else{
-    output[0] = 0;
 }
-}           
 
 
 /*----------------------------------------------------------*/
 /* give part of ilename in partname. See code for proper
-   value of i ( 0 = node, 1 = dev, 2 = dir,3 = name etc.
-*/ 
+   value of i ( 0 = node, 1 = dev, 2 = dir, 3 = name etc.
+*/
 
-int fnamepart( char *inputfile, char *part, int whatpart )
+int fnamepart(char *inputfile, char *part, int whatpart)
 {
-pfnPtr pf;
-int     status;
-char    ipart[6][256], *i, *p;
+    pfnPtr pf;
+    int    status;
+    char   ipart[6][256], *i, *p;
 
-pf = calloc( 1, sizeof( pfn ) );
+    pf = calloc(1, sizeof(pfn));
 
-pf->dfab = cc$rms_fab;
-pf->drab = cc$rms_rab;
-pf->dnam = cc$rms_naml;
+    pf->dfab = cc$rms_fab;
+    pf->drab = cc$rms_rab;
+    pf->dnam = cc$rms_naml;
 
-pf->dfab.fab$l_naml = &pf->dnam;
+    pf->dfab.fab$l_naml = &pf->dnam;
 
-pf->dfab.fab$l_fna = (char *) -1; 
-pf->dfab.fab$l_dna = (char *) -1; 
-pf->dfab.fab$b_fns = 0;
-pf->dfab.fab$w_ifi = 0;
+    pf->dfab.fab$l_fna = (char *) -1;
+    pf->dfab.fab$l_dna = (char *) -1;
+    pf->dfab.fab$b_fns = 0;
+    pf->dfab.fab$w_ifi = 0;
 
-pf->dnam.naml$l_long_defname = NULL; //inputfile;
-pf->dnam.naml$l_long_defname_size = 0;//strlen( inputfile );
+    pf->dnam.naml$l_long_defname = NULL;  /* inputfile; */
+    pf->dnam.naml$l_long_defname_size = 0; /* strlen(inputfile); */
 
-pf->dnam.naml$l_long_filename = inputfile;
-pf->dnam.naml$l_long_filename_size = strlen( inputfile);
+    pf->dnam.naml$l_long_filename = inputfile;
+    pf->dnam.naml$l_long_filename_size = strlen(inputfile);
 
-pf->dnam.naml$l_long_expand = pf->expanded_filename;
-pf->dnam.naml$l_long_expand_alloc = NAM$C_MAXRSS ;
+    pf->dnam.naml$l_long_expand = pf->expanded_filename;
+    pf->dnam.naml$l_long_expand_alloc = NAM$C_MAXRSS;
 
-pf->dnam.naml$b_nop |= NAML$M_SYNCHK | NAML$M_PWD;
+    pf->dnam.naml$b_nop |= NAML$M_SYNCHK | NAML$M_PWD;
 
-status = sys$parse( &pf->dfab, 0,0);
-if ( !(status&1) ){
-    free( pf );
-    return( status );
-}
+    status = sys$parse(&pf->dfab, 0, 0);
+    if(!(status&1)) {
+        free(pf);
+        return status;
+    }
 
-fpcopy ( ipart[0], pf->dnam.naml$l_long_node , pf->dnam.naml$l_long_node_size);
-fpcopy ( ipart[1], pf->dnam.naml$l_long_dev , pf->dnam.naml$l_long_dev_size);
-fpcopy ( ipart[2], pf->dnam.naml$l_long_dir , pf->dnam.naml$l_long_dir_size);
-fpcopy ( ipart[3], pf->dnam.naml$l_long_name , pf->dnam.naml$l_long_name_size);
-fpcopy ( ipart[4], pf->dnam.naml$l_long_type , pf->dnam.naml$l_long_type_size);                                               
-fpcopy ( ipart[5], pf->dnam.naml$l_long_ver , pf->dnam.naml$l_long_ver_size);
-
-for( i = ipart[ whatpart ], p = part; *i; ++i, ++p){
-   if ( p == part ){
-      *p = toupper( *i );
-   }else{
-      *p = tolower( *i );
-   }        
-}
-*p = 0;
+    fpcopy(ipart[0], pf->dnam.naml$l_long_node,
+                     pf->dnam.naml$l_long_node_size);
+    fpcopy(ipart[1], pf->dnam.naml$l_long_dev,
+                     pf->dnam.naml$l_long_dev_size);
+    fpcopy(ipart[2], pf->dnam.naml$l_long_dir,
+                     pf->dnam.naml$l_long_dir_size);
+    fpcopy(ipart[3], pf->dnam.naml$l_long_name,
+                     pf->dnam.naml$l_long_name_size);
+    fpcopy(ipart[4], pf->dnam.naml$l_long_type,
+                     pf->dnam.naml$l_long_type_size);
+    fpcopy(ipart[5], pf->dnam.naml$l_long_ver,
+                     pf->dnam.naml$l_long_ver_size);
+
+    for(i = ipart[whatpart], p = part; *i; ++i, ++p) {
+        if(p == part) {
+            *p = toupper(*i);
+        }
+        else {
+            *p = tolower(*i);
+        }
+    }
+    *p = 0;
 
-free( pf );
-return(1);
+    free(pf);
+    return 1;
 }
 /*----------------------------------------------------------*/
 
-int find_file(char *filename,char *gevonden,int *findex)
+int find_file(char *filename, char *gevonden, int *findex)
 {
-int     status;
-struct  dsc$descriptor gevondend;
-struct  dsc$descriptor filespec;
-char    gevonden_file[NAM$C_MAXRSS + 1];
-
-filespec.dsc$w_length = strlen(filename);
-filespec.dsc$b_dtype  = DSC$K_DTYPE_T;
-filespec.dsc$b_class  = DSC$K_CLASS_S; 
-filespec.dsc$a_pointer = filename;
-
-gevondend.dsc$w_length = NAM$C_MAXRSS;
-gevondend.dsc$b_dtype  = DSC$K_DTYPE_T;
-gevondend.dsc$b_class  = DSC$K_CLASS_S; 
-gevondend.dsc$a_pointer = gevonden_file;
-
-status=lib$find_file(&filespec,&gevondend,findex,0,0,0,0);
-    
-if ( (status & 1) == 1 ){
-       strcpy(gevonden,strtok(gevonden_file," "));
-}else{
-       gevonden[0] = 0;
-}
+    int     status;
+    struct  dsc$descriptor gevondend;
+    struct  dsc$descriptor filespec;
+    char    gevonden_file[NAM$C_MAXRSS + 1];
+
+    filespec.dsc$w_length = strlen(filename);
+    filespec.dsc$b_dtype  = DSC$K_DTYPE_T;
+    filespec.dsc$b_class  = DSC$K_CLASS_S;
+    filespec.dsc$a_pointer = filename;
+
+    gevondend.dsc$w_length = NAM$C_MAXRSS;
+    gevondend.dsc$b_dtype  = DSC$K_DTYPE_T;
+    gevondend.dsc$b_class  = DSC$K_CLASS_S;
+    gevondend.dsc$a_pointer = gevonden_file;
+
+    status = lib$find_file(&filespec, &gevondend, findex, 0, 0, 0, 0);
+
+    if((status & 1) == 1) {
+        /* !checksrc! disable BANNEDFUNC 1 */ /* FIXME */
+        strcpy(gevonden, strtok(gevonden_file, " "));
+    }
+    else {
+         gevonden[0] = 0;
+    }
 
-return(status);
+    return status;
 }
 
 
 /*--------------------------------------------*/
 
-manPtr addman( manPtr *manroot,char *filename )
+manPtr addman(manPtr *manroot, char *filename)
 {
-manPtr m,f;
+    manPtr m, f;
 
-m = calloc( 1, sizeof( man) );
-if ( !m ) return( NULL );
+    m = calloc(1, sizeof(man));
+    if(!m)
+        return NULL;
 
-m->filename = strdup( filename );
+    m->filename = strdup(filename);
 
-if ( *manroot == NULL ){
-   *manroot = m;    
-}else{
-   for( f = *manroot; f->next ; f = f->next );
-   f->next = m;
-}
-return(m);
+    if(!*manroot) {
+        *manroot = m;
+    }
+    else {
+        for(f = *manroot; f->next; f = f->next)
+            ;
+        f->next = m;
+    }
+    return m;
 }
 
 /*--------------------------------------------*/
-void freeman( manPtr *manroot )
+void freeman(manPtr *manroot)
 {
-manPtr m,n;
+    manPtr m, n;
 
-for( m = *manroot; m ; m = n ){
-     free( m->filename );
-     n = m->next;
-     free ( m );
-}
-*manroot = NULL;
+    for(m = *manroot; m; m = n) {
+        free(m->filename);
+        n = m->next;
+        free(m);
+    }
+    *manroot = NULL;
 }
 
 /*--------------------------------------------*/
 
-int listofmans( char *filespec, manPtr *manroot )
+int listofmans(char *filespec, manPtr *manroot)
 {
-manPtr  r;
-int     status;
-int     ffindex=0;
-char    gevonden[NAM$C_MAXRSS + 1];
-
-while(1){
-    status = find_file( filespec, gevonden, &ffindex );
-
-    if ( (status&1) ){
-        r = addman( manroot, gevonden );
-        if ( r == NULL ) return(2);
-    }else{
-        if ( !( status&1)) break;
+    manPtr  r;
+    int     status;
+    int     ffindex = 0;
+    char    gevonden[NAM$C_MAXRSS + 1];
+
+    for(;;) {
+        status = find_file(filespec, gevonden, &ffindex);
+
+        if((status&1)) {
+            r = addman(manroot, gevonden);
+            if(!r)
+                return 2;
+        }
+        else {
+            if(!(status&1))
+                break;
+        }
     }
-}
-
-lib$find_file_end( &ffindex);
-if ( status == RMS$_NMF) status = 1;
 
+    lib$find_file_end(&ffindex);
+    if(status == RMS$_NMF)
+        status = 1;
 
-return( status );
+    return status;
 }
 
 /*--------------------------------------------*/
 
-int convertman ( char *filespec, FILE *hlp , int base_level, int add_parentheses )
+int convertman(char *filespec, FILE *hlp, int base_level, int add_parentheses)
 {
-FILE    *man;
-char    *in, *uit;
-char    *m,*h;
-size_t  len, thislen, maxlen= 50000;
-int     bol,mode, return_status=1;
-char subjectname[ NAM$C_MAXRSS + 1 ];
+    FILE    *man;
+    char    *in, *uit;
+    char    *m, *h;
+    size_t  len, thislen, maxlen = 50000;
+    int     bol, mode, return_status = 1;
+    char subjectname[NAM$C_MAXRSS + 1];
 
-in  = calloc( 1, maxlen + 1 );
-uit = calloc( 1, maxlen + 1 );
+    in  = calloc(1, maxlen + 1);
+    uit = calloc(1, maxlen + 1);
 
-if ( in == NULL || uit == NULL ) return(2);
+    if(!in || !uit)
+        return 2;
 
-man = fopen( filespec, "r");
-if ( man == NULL ) return(vaxc$errno);
+    man = fopen(filespec, "r");
+    if(!man)
+        return vaxc$errno;
 
-for( len = 0; !feof( man ) && len < maxlen ; len += thislen ){
-    thislen = fread( in + len, 1, maxlen - len, man );
-}
+    for(len = 0; !feof(man) && len < maxlen; len += thislen) {
+        thislen = fread(in + len, 1, maxlen - len, man);
+    }
 
-fclose (man);
+    fclose(man);
 
-m = in;
-h = uit;
+    m = in;
+    h = uit;
 
-*(m + len ) = 0;
+    *(m + len) = 0;
 
-for ( mode = 0, bol = 1 ; *m; ++m ){
+    for(mode = 0, bol = 1; *m; ++m) {
 
-    switch ( mode ){
+        switch(mode) {
         case 0:
-          switch(*m){
+            switch(*m) {
             case '.':
-                if ( bol ){
+                if(bol) {
                     mode = 1;
-                }else{
+                }
+                else {
                     *h = *m;
                     ++h;
                 }
                 break;
             case '\\':
-                if ( bol ){
-                   *h = ' ';++h;
-                   *h = ' ';++h;
+                if(bol) {
+                    *h = ' '; ++h;
+                    *h = ' '; ++h;
                 }
                 mode = 2;
                 break;
             default:
-                if ( bol ){
-                   *h = ' ';++h;
-                   *h = ' ';++h;
+                if(bol) {
+                    *h = ' '; ++h;
+                    *h = ' '; ++h;
                 }
                 *h = *m;
                 ++h;
                 break;
-          }
-          break;
-        case 1: /* after . at bol */
+            }
+            break;
 
-          switch(*m){
+        case 1: /* after . at bol */
+            switch(*m) {
             case '\\':
-                while( *m != '\n' && *m != '\r' && *m )++m;
+                while(*m != '\n' && *m != '\r' && *m)
+                    ++m;
                 mode = 0;
                 break;
             case 'B':
-                   ++m; 
-                   *h = ' ';++h;
-                   mode = 0;
-                   break;   
+                ++m;
+                *h = ' '; ++h;
+                mode = 0;
+                break;
             case 'I':
-                    /* remove preceding eol */
-                    if ( *(m+1) != 'P' ){
+                /* remove preceding eol */
+                if(*(m + 1) != 'P') {
+                    --h;
+                    while((*h == '\n' || *h == '\r') && h > uit)
                         --h;
-                        while ( (*h == '\n' || *h == '\r') && h > uit )--h;
-                        ++h;
-                    }
+                    ++h;
+                }
 
-                    /* skip .Ix */
-                    for(;*m != ' ' && *m != '\n' && *m != '\r'; ++m); 
+                /* skip .Ix */
+                for(; *m != ' ' && *m != '\n' && *m != '\r'; ++m)
+                    ;
 
-                    /* copy line up to EOL */
+                /* copy line up to EOL */
 
-                    for(;*m != '\n' && *m != '\r' && *m; ++m, ++h)*h = *m;
+                for(; *m != '\n' && *m != '\r' && *m; ++m, ++h)
+                    *h = *m;
 
-                    /* if line ends in ., this is an EOL */
+                /* if line ends in ., this is an EOL */
 
-                    if ( *(h-1) == '.'){
-                         --h; 
-                         --m;
-                    }else{
-                        /* if line does not end in ., skip EOL in source */
+                if(*(h-1) == '.') {
+                    --h;
+                    --m;
+                }
+                else {
+                    /* if line does not end in ., skip EOL in source */
 
-                        if ( *(m+1) == '\n' || *(m+1) == '\r')++m;
-                    }
-                    mode = 0;
-                    break;
+                    if(*(m + 1) == '\n' || *(m + 1) == '\r')
+                        ++m;
+                }
+                mode = 0;
+                break;
             case 'S':
-                 if ( *(m+1) == 'H' ){
+                if(*(m + 1) == 'H') {
                     *h = '\n';++h;
-                    if ( strncmp( m+3 ,"NAME",4) == 0 || 
-                         strncmp( m+3 ,"SYNOPSIS",8) == 0 ||
-                         strncmp( m+3 ,"DESCRIPTION",11) == 0 ){
-                        while( *m != '\n' && *m != '\r')++m;
+                    if(strncmp(m + 3, "NAME", 4) == 0 ||
+                       strncmp(m + 3, "SYNOPSIS", 8) == 0 ||
+                       strncmp(m + 3, "DESCRIPTION", 11) == 0) {
+                        while(*m != '\n' && *m != '\r')
+                            ++m;
                         mode = 0;
-                    }else{
+                    }
+                    else {
                         ++m;
 
                         /* write help level, and flag it */
 
-                        *h = '0' + base_level + 1;++h;
+                        *h = '0' + base_level + 1; ++h;
                         return_status |= 2;
 
-                        *h = ' ';++h; 
+                        *h = ' '; ++h;
 
                         /* skip H (or whatever after S) and blank */
-                        ++m;++m;
+                        ++m; ++m;
 
-                        for(;*m != '\n' && *m != '\r' && *m; ++m, ++h){
+                        for(; *m != '\n' && *m != '\r' && *m; ++m, ++h) {
 
                            /* write help label in lowercase, skip quotes */
                            /* fill blanks with underscores */
 
-                           if ( *m != '\"' ){
-                                *h = tolower( *m );
-                                if (*h == ' ') *h = '_';    
-                           }else{
-                                --h;
-                           }    
-                        } 
+                           if(*m != '\"') {
+                               *h = tolower(*m);
+                               if(*h == ' ')
+                                   *h = '_';
+                           }
+                           else {
+                               --h;
+                           }
+                        }
 
                         /* Add a linefeed or two */
 
-                        *h = *m;++h;
-                        *h = *m;++h;
+                        *h = *m; ++h;
+                        *h = *m; ++h;
 
                         mode = 0;
-                    }   
-                 }
-                 break;
+                    }
+                }
+                break;
             case 'T':
-                 if ( *(m+1) == 'H' ){
+                if(*(m + 1) == 'H') {
                     *h = '0' + base_level; ++h;
                     return_status |= 2;
-                    *h = ' ';++h;
-                    for ( m = m + 3; *m != ' ' && *m ; ++m, ++h ){
-                          *h = *m;
+                    *h = ' '; ++h;
+                    for(m = m + 3; *m != ' ' && *m; ++m, ++h) {
+                        *h = *m;
                     }
-					if ( add_parentheses ){
-						 *h = '(';++h;
-						 *h = ')';++h;
-					}
-                    while( *m != '\n' && *m != '\r' && *m )++m;
+                    if(add_parentheses) {
+                        *h = '('; ++h;
+                        *h = ')'; ++h;
+                    }
+                    while(*m != '\n' && *m != '\r' && *m)
+                        ++m;
                     mode = 0;
-                 }
-                 break;
-            default:
-                ++m;
-                mode = 0;
-                break;
-           }
-           break;
-        case 2: /* after \ skip two characters or print the backslash */            
-          switch(*m){
-            case '\\':
-                *h = *m;
-                ++h;
-                mode = 0;
+                }
                 break;
             default:
                 ++m;
                 mode = 0;
                 break;
-           }
-           break;   
-    } /*end switch mode */
-
-    bol = 0;
-    if ( *m == '\n' || *m == '\r') bol = 1;
-
-}/* end for mode */
+            }
+            break;
+        case 2: /* after \ skip two characters or print the backslash */
+            switch(*m) {
+                case '\\':
+                    *h = *m;
+                    ++h;
+                    mode = 0;
+                    break;
+                default:
+                    ++m;
+                    mode = 0;
+                    break;
+            }
+            break;
+        } /* end switch mode */
 
-*h = 0;
+        bol = 0;
+        if(*m == '\n' || *m == '\r')
+            bol = 1;
 
+    } /* end for mode */
 
-if ( (return_status&2) ){
-    fprintf( hlp, "%s\n\n", uit);
-}else{
-    fnamepart( filespec, subjectname,3);
-    if ( *subjectname ){
-        fprintf( hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
-    }else{
-        /* No filename (as is the case with a logical), use first word as subject name */
-        char *n,*s;
+    *h = 0;
 
-        for(n = in; isspace( *n );++n);
-        for(s = subjectname; !(isspace( *n )); ++n,++s)*s = *n;
-        *s = 0;
 
-        fprintf( hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
+    if(return_status & 2) {
+        fprintf(hlp, "%s\n\n", uit);
+    }
+    else {
+        fnamepart(filespec, subjectname, 3);
+        if(*subjectname) {
+            fprintf(hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
+        }
+        else {
+            /* No filename (as is the case with a logical),
+               use first word as subject name */
+            char *n, *s;
+
+            for(n = in; isspace(*n); ++n)
+                ;
+            for(s = subjectname; !(isspace(*n)); ++n, ++s)
+                *s = *n;
+            *s = 0;
+
+            fprintf(hlp, "%d %s\n\n%s\n\n", base_level, subjectname, uit);
+        }
     }
-}
 
-/*
- printf( "read %d from %s, written %d to helpfile, return_status = %d\n",
-    len, filespec, strlen(uit), return_status );
-*/
+    /*
+     printf("read %d from %s, written %d to helpfile, return_status = %d\n",
+        len, filespec, strlen(uit), return_status);
+    */
 
-free( m ); 
-free( h ); 
+    free(m);
+    free(h);
 
-return ( 1);
+    return 1;
 }
 
 /*--------------------------------------------*/
 
-int convertmans( char *filespec, char *hlpfilename, int base_level, int append, int add_parentheses )
+int convertmans(char *filespec, char *hlpfilename, int base_level, int append,
+                int add_parentheses)
 {
-int status=1;
-manPtr  manroot=NULL, m;
-FILE    *hlp;
-
-if ( append ){
-    hlp = fopen( hlpfilename,"a+");
-}else{
-    hlp = fopen( hlpfilename,"w");
-}
+    int status = 1;
+    manPtr  manroot = NULL, m;
+    FILE    *hlp;
+
+    if(append) {
+        hlp = fopen(hlpfilename, "a+");
+    }
+    else {
+        hlp = fopen(hlpfilename, "w");
+    }
 
-if ( hlp == NULL ) return( vaxc$errno );
+    if(!hlp)
+        return vaxc$errno;
 
-status = listofmans( filespec, &manroot );
-if ( !(status&1) ) return( status );
+    status = listofmans(filespec, &manroot);
+    if(!(status&1))
+        return status;
 
-for ( m = manroot ; m ; m = m->next ){
-    status = convertman( m->filename, hlp , base_level, add_parentheses );
-    if ( !(status&1) ){
-        fprintf(stderr,"Convertman of %s went wrong\n", m->filename);
-        break;
+    for(m = manroot; m; m = m->next) {
+        status = convertman(m->filename, hlp, base_level, add_parentheses);
+        if(!(status&1)) {
+            fprintf(stderr, "Convertman of %s went wrong\n", m->filename);
+            break;
+        }
     }
-}
-freeman( &manroot );
-return( status );
+    freeman(&manroot);
+    return status;
 }
 
 /*--------------------------------------------*/
-void print_help()
+void print_help(void)
 {
-   fprintf( stderr, "Usage: [-a] [-b x] convertman <manfilespec> <helptextfile>\n" );
-   fprintf( stderr, "       -a append <manfilespec> to <helptextfile>\n" );
-   fprintf( stderr, "       -b <baselevel> if no headers found create one with level <baselevel>\n" );
-   fprintf( stderr, "          and the filename as title.\n" );
-   fprintf( stderr, "       -p add parentheses() to baselevel help items.\n" );
-
+    fprintf(stderr,
+        "Usage: [-a] [-b x] convertman <manfilespec> <helptextfile>\n"
+        "       -a append <manfilespec> to <helptextfile>\n"
+        "       -b <baselevel> if no headers found create one "
+                   "with level <baselevel>\n"
+        "          and the filename as title.\n"
+        "       -p add parentheses() to baselevel help items.\n");
 }
 /*--------------------------------------------*/
 
-main ( int argc, char **argv )
+main(int argc, char **argv)
 {
-int     status;
-int     i,j;
-int     append, base_level, basechange, add_parentheses;
-char    *manfile=NULL;
-char    *helpfile=NULL;
-
-if ( argc < 3 ){
-   print_help();
-   return( 1 ) ;
-}
+    int     status;
+    int     i, j;
+    int     append, base_level, basechange, add_parentheses;
+    char    *manfile = NULL;
+    char    *helpfile = NULL;
+
+    if(argc < 3) {
+        print_help();
+        return 1;
+    }
 
-append     = 0;
-base_level = 1;
-basechange = 0;
-add_parentheses = 0;
-
-for ( i = 1; i < argc; ++i){
-    if ( argv[i][0] == '-' ){
-        for( j = 1; argv[i][j] ; ++j ){
-            switch( argv[i][j] ){
-                case 'a':
-                    append = 1;
-                    break;
-                case 'b':   
-                    if ( (i+1) < argc ){
-                        base_level = atoi( argv[ i + 1 ] );
-                        basechange = 1;
-                    }
-                    break;
-                case 'p':
-                    add_parentheses = 1;
-                    break;
+    append     = 0;
+    base_level = 1;
+    basechange = 0;
+    add_parentheses = 0;
+
+    for(i = 1; i < argc; ++i) {
+        if(argv[i][0] == '-') {
+            for(j = 1; argv[i][j]; ++j) {
+                switch(argv[i][j]) {
+                    case 'a':
+                        append = 1;
+                        break;
+                    case 'b':
+                        if((i + 1) < argc) {
+                            base_level = atoi(argv[i + 1]);
+                            basechange = 1;
+                        }
+                        break;
+                    case 'p':
+                        add_parentheses = 1;
+                        break;
+                }
+            }
+            if(basechange) {
+                basechange = 0;
+                i = i + 1;
             }
         }
-        if ( basechange){
-            basechange = 0;
-            i = i + 1;
-        }
-    }else{
-        if ( manfile == NULL ){
-            manfile = strdup( argv[i]);
-        } else if ( helpfile == NULL ){
-            helpfile = strdup( argv[i]);
-        } else {
-            fprintf( stderr, "Unrecognized parameter : %s\n", argv[i]);
+        else {
+            if(!manfile) {
+                manfile = strdup(argv[i]);
+            }
+            else if(!helpfile) {
+                helpfile = strdup(argv[i]);
+            }
+            else {
+                fprintf(stderr, "Unrecognized parameter : %s\n", argv[i]);
+            }
         }
     }
-}
 
+    /*
+    fprintf(stderr,"manfile: %s, helpfile: %s, append: %d, base_level : %d\n",
+            manfile, helpfile, append, base_level);
+    */
 
-/* fprintf( stderr,"manfile: %s, helpfile: %s, append: %d, base_level : %d\n",
-        manfile, helpfile, append, base_level);
-*/
-
-status = convertmans( manfile, helpfile, base_level, append, add_parentheses );
+    status = convertmans(manfile, helpfile, base_level, append,
+                         add_parentheses);
 
-free( manfile );
-free( helpfile );
+    free(manfile);
+    free(helpfile);
 
-return( status );
+    return status;
 }
-
- 
diff --git a/libssh2/vms/readme.vms b/libssh2/vms/readme.vms
index 978da197..6356ac62 100644
--- a/libssh2/vms/readme.vms
+++ b/libssh2/vms/readme.vms
@@ -1,13 +1,13 @@
 *These are the porting notes to OpenVMS, as of 7 April 2010
-by Jose Baars. This file will be installed as 
+by Jose Baars. This file will be installed as
 libssh2*.release_notes by the product install kit.
 
 
-LIBSSH2 
+LIBSSH2
 -------
 
-LIBSSH2 is a client-side library written in C that aims to 
-implement the SSH2 protocol. It is an open source project, 
+LIBSSH2 is a client-side library written in C that aims to
+implement the SSH2 protocol. It is an open source project,
 to be found at https://libssh2.org.
 
 GNV
@@ -19,44 +19,44 @@ of the GNV project, John Malmberg.
 Installing the PCSI kit
 =======================
 
-Prerequisites 
+Prerequisites
 -------------
-- VMS version 8.3 minimal. 
+- VMS version 8.3 minimal.
   See the remarks at prerequisites for building the kit
-- TCP/IP stack, both TCP/IP services and Multinet should work. 
+- TCP/IP stack, both TCP/IP services and Multinet should work.
   See the remarks at prerequisites for building the kit
-- HP OPENSSL V1.3 minimal. 
+- HP OPENSSL V1.3 minimal.
   See the remarks at prerequisites for building the kit
-- JEM  ZLIB V1.2-3E1 minimal. 
+- JEM  ZLIB V1.2-3E1 minimal.
   See the remarks at prerequisites for building the kit
-  
-The first three dependencies are tested at installation time, and 
+
+The first three dependencies are tested at installation time, and
 installation will fail if any these products are not installed.
 The ZLIB dependency is not tested by the product installation
-procedure, as libssh2 will probably be installed as part of 
+procedure, as libssh2 will probably be installed as part of
 multiple libraries including zlib.
 
 Install
 -------
 
 
-The kit will install gnv$libssh2.exe in a directory tree that might 
-already be available on your system if you have installed other gnv* 
-libraries or utilities. 
+The kit will install gnv$libssh2.exe in a directory tree that might
+already be available on your system if you have installed other gnv*
+libraries or utilities.
 
 The directory tree for gnv$libssh2.exe will be like this:
 
 [gnv] -- [usr] -- [include] -- [libssh2] include files for libssh2
                   [lib] gnv$libssh2_x_y_z.exe
-                  [share]   -- [doc] -- [libssh2] libssh2.hlb, 
-                                        release notes (this file), 
-                                        libssh2 release notes   
+                  [share]   -- [doc] -- [libssh2] libssh2.hlb,
+                                        release notes (this file),
+                                        libssh2 release notes
 
 optional:
-                                        [example] libssh2_examples-x_y_z.bck 
+                                        [example] libssh2_examples-x_y_z.bck
                   [common_src] libssh2-x_y_z_src.bck
 
-By default, it will install the shared image and include files to 
+By default, it will install the shared image and include files to
 SYS$COMMON:[GNV...].
 
 You can override this destination by specifying the destination
@@ -71,9 +71,9 @@ Please ignore the following warnings, as the kit is not signed :
 
 Optionally, you can install a backup saveset with some programming examples,
 or a backupo saveset with the complete libssh2 source tree.
- 
-you will need to answer 'NO' to the question 
-'Do you want the default for all options'. 
+
+you will need to answer 'NO' to the question
+'Do you want the default for all options'.
 
 and 'YES' to either or both the following questions:
 
@@ -95,38 +95,38 @@ define this logical in your systartup like so:
 
 $ define/system/executive gnv$libssh2 dev:[dir..]gnv$libssh2_x_y_z.exe
 
-Optionally, you can install the executbale like so:
+Optionally, you can install the executable like so:
 
 $ mc sysgen install dev:[dir..]gnv$libssh2_x_y_z.exe/open/share/header
 
-Link your programs against gnv$libssh2, and when upgrading libssh2 
+Link your programs against gnv$libssh2, and when upgrading libssh2
 test thoroughly.
 
 If you want to be extra cautious define a system logical like this:
 
 $ define/system/executive gnv$libssh2_x_y_z dev:[dir..]gnv$libssh2_x_y_z.exe
 
-Link  programs against gnv$libssh2_x_y_z, and when upgrading libssh2 
-link against new versions. 
+Link  programs against gnv$libssh2_x_y_z, and when upgrading libssh2
+link against new versions.
 
-It is probably more convenient in the last case to link against the object 
+It is probably more convenient in the last case to link against the object
 library provided in the source backup saveset. Both an uppercase and a
-mixed case object library, called libssh2.olb and libssh2_asis.olb 
+mixed case object library, called libssh2.olb and libssh2_asis.olb
 are provided.
 
 
 Compiling and linking against libssh2
 -------------------------------------
 
-The  shared image library has a vector table with both uppercase and 
-mixed case entry points, allowing to link directly against the shared 
-image wether you need the /NAMES=AS_IS or not.
+The  shared image library has a vector table with both uppercase and
+mixed case entry points, allowing to link directly against the shared
+image whether you need the /NAMES=AS_IS or not.
 
 To link successfully, you MUST use /NAMES=shortened, as some function
 names in libssh2 are longer than the VMS maximum of 32 characters.
 
 If you chose to install the examples, you can unpack the backup
-saveset by 
+saveset by
 
 backup/sel=*.c device:[gnv.usr.share.doc.libssh2.examples]libssh2_examples-x_y_z.bck -
  []
@@ -147,7 +147,7 @@ Building gnv$libssh2
 You can build gnv$libssh2 yourself, which may have advantages, as the library is
 in full development, very regularly new features are added.
 
-For production use, it is probably advisable to use a stable version, and 
+For production use, it is probably advisable to use a stable version, and
 link against that. To check out new features, statically linking against
 the object library is probably more practical, to avoid compatibility
 issues.
@@ -161,21 +161,21 @@ You will need to have the following available:
 - An Alpha or Itanium VMS system. Due to dependencies on zlib, ssl and ODS-5,
   support on VAXen would be cumbersome at least.
 
-- VMS version 8.3 minimal. This is a requirement of gnv$zlibshr.exe against 
+- VMS version 8.3 minimal. This is a requirement of gnv$zlibshr.exe against
   which shared image library libssh2 is linked. If you use another zlib
   to link against, you can make it work under lower versions of VMS.
   I have made it work on VMS 7.3-2 with not a lot of difficulty.
   Also, if you are not interested in compression, you can choose not
-  to link against zlib at all; in that case comment out the 
+  to link against zlib at all; in that case comment out the
   #define  LIBSSH2_HAVE_ZLIB in libssh2_config.h.
 
 - TCP/IP services or Multinet for OpenVMS.
   TCPWare has not been tested.
 
-- The HP OpenSSL product. Of course, with tweaking, you can probably link 
+- The HP OpenSSL product. Of course, with tweaking, you can probably link
   it against the OpenSSL library, but that is not what I have used.
- 
-- A C compiler. I don't know any other working C compilers than 
+
+- A C compiler. I don't know any other working C compilers than
   the DEC/Compac/HP-C compiler on VMS.
 
 - An ODS-5 disk. With tweaking you'll get it to work on an ODS-2
@@ -199,7 +199,7 @@ Downloading libssh2
 -------------------
 
 At the website of libssh2, you can find stable and daily gzipped
-tarballs. if you have a computer connected to internet you can 
+tarballs. if you have a computer connected to internet you can
 download a daily build yourself by a procedure that looks a lot like
 this ( fill out your own proxy user/password, set up right symbols to
 gunzip, vmstar and curl and set up the libssh2 build version):
@@ -212,8 +212,8 @@ $ currentday = f$cvtime(,,"date") - "-" - "-"
 $!
 $ set def mydev:[mydir.libssh2]
 $!
-$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.gz") .nes. "" 
-$ then 
+$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.gz") .nes. ""
+$ then
 $   delete libssh2-'libssh2_version'-'currentday'.tar.gz;*
 $ endif
 $!
@@ -221,15 +221,15 @@ $ curl 'proxy_line' "https://libssh2.org/snapshots/libssh2-''libssh2_version'-''
                     -o libssh2-'libssh2_version'-'currentday'.tar.gz
 $!
 $!
-$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.;") .nes. "" 
-$ then 
+$ if f$search("libssh2-''libssh2_version'-''currentday'.tar.;") .nes. ""
+$ then
 $   delete libssh2-'libssh2_version'-'currentday'.tar.;*
 $ endif
 $!
 $ gunzip libssh2-'libssh2_version'-'currentday'.tar.gz
 $!
 $ tarfile = f$search("libssh2-''libssh2_version'-''currentday'.tar.;")
-$ vmstar xf 'tarfile' 
+$ vmstar xf 'tarfile'
 
 Downloading a stable build will need you to get rid of the currentday.
 
@@ -241,8 +241,8 @@ Getting the libssh2 sources from the source backup in the binary kit
 --------------------------------------------------------------------
 
 During installation of the binary kit, you are given the option
-of installing the sources. If chosen, a backup saveset with 
-the complete libssh2 directory is made available in 
+of installing the sources. If chosen, a backup saveset with
+the complete libssh2 directory is made available in
 [gnv.common_src].
 
 By restoring this backup saveset, you end up with the same
@@ -262,7 +262,7 @@ command:
 @libssh2_make_lib.dcl
 
 This should produce libssh2_x_y_z.exe in this same vms directory.
- 
+
 
 
 Building the examples
@@ -274,24 +274,24 @@ produced when building the shared image, or against the shared image
 produced in the step before.
 
 You can compile only one of the examples by giving only the
-name part of the filename of the example as p1 to the 
+name part of the filename of the example as p1 to the
 build procedure:
 
-@libssh2_make_example.dcl 
+@libssh2_make_example.dcl
 
 or for instance
 
-@libssh2_make_example.dcl sftp 
+@libssh2_make_example.dcl sftp
 
-By default, libssh2_make_example.dcl links to the object libraries 
+By default, libssh2_make_example.dcl links to the object libraries
 produced by the libssh2_make_lib.dcl procedure. If you want to link
 against the shared image library made in the same procedure, invoke
 the procedure like so:
 
 @libssh2_make_example.dcl sftp "SHARED"
 
-The procdure defines a process logical gnv$libssh2 pointing to the shared
-image library in the directory, which obviously will not survive a logout. 
+The procedure defines a process logical gnv$libssh2 pointing to the shared
+image library in the directory, which obviously will not survive a logout.
 
 
 Building the help library
@@ -309,11 +309,6 @@ Building a PCSI kit
 -------------------
 
 When you have built the shared library and the help library,
-you can build a PCSI kit by issueing this command:
+you can build a PCSI kit by issuing this command:
 
 @libssh2_make_kit.dcl
-
-
-
-
-
diff --git a/libssh2/win32/GNUmakefile b/libssh2/win32/GNUmakefile
deleted file mode 100644
index 0971d891..00000000
--- a/libssh2/win32/GNUmakefile
+++ /dev/null
@@ -1,365 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 (Win32 version - gnu make)
-## Use: make -f GNUmakefile [help|all|clean|dev|devclean|dist|distclean|dll|objclean]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-1.0.2d
-endif
-
-# Edit the path below to point to your Distribution folder.
-ifndef DISTDIR
-DISTDIR	= libssh2-$(LIBSSH2_VERSION_STR)-bin-$(ARCH)
-endif
-DISTARC	= $(DISTDIR).zip
-
-# Edit the path below to point to your Development folder.
-ifndef DEVLDIR
-DEVLDIR	= libssh2-$(LIBSSH2_VERSION_STR)-dev-$(ARCH)
-endif
-DEVLARC	= $(DEVLDIR).zip
-
-# Project root
-PROOT	= ..
-
-# Edit the vars below to change target settings.
-TARGET	= libssh2
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(LIBSSH2_VERSION_STR)
-#STACK	= 64000
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OPT	+= -DLIBSSH2DEBUG
-	OBJDIR	= debug
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK	= awk
-ZIP	= zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-ifeq ($(LIBSSH2_CC),)
-LIBSSH2_CC := $(CROSSPREFIX)gcc
-endif
-ifeq ($(LIBSSH2_AR),)
-LIBSSH2_AR := $(CROSSPREFIX)ar
-endif
-ifeq ($(LIBSSH2_RANLIB),)
-LIBSSH2_RANLIB := $(CROSSPREFIX)ranlib
-endif
-ifeq ($(LIBSSH2_DLL_A_SUFFIX),)
-LIBSSH2_DLL_A_SUFFIX := dll
-endif
-
-libssh2_dll_LIBRARY = $(TARGET)$(LIBSSH2_DLL_SUFFIX).dll
-
-# The following line defines your compiler.
-ifdef METROWERKS
-	CC = mwcc
-else
-	CC = $(LIBSSH2_CC)
-endif
-
-# Set environment var ARCH to your architecture to override autodetection.
-ifndef ARCH
-ifeq ($(findstring gcc,$(CC)),gcc)
-ifeq ($(findstring x86_64,$(shell $(CC) -dumpmachine)),x86_64)
-ARCH	= w64
-else
-ARCH	= w32
-endif
-else
-ARCH	= w32
-endif
-endif
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	= $(LIBSSH2_CFLAG_EXTRAS) $(OPT) -D$(DB) -DLIBSSH2_WIN32 -DHAVE_WINDOWS_H # -DHAVE_CONFIG_H
-LDFLAGS = $(LIBSSH2_LDFLAG_EXTRAS)
-
-ifeq ($(CC),mwcc)
-LD	= mwld
-RC	= mwwinrc
-LDFLAGS	+= -nostdlib
-AR	= $(LD)
-ARFLAGS	= -nostdlib -library -o
-LIBEXT	= lib
-#RANLIB	=
-LIBPATH	+= -lr "$(METROWERKS)/MSL" -lr "$(METROWERKS)/Win32-x86 Support"
-LDLIBS	+= -lMSL_Runtime_x86.lib -lMSL_C_x86.lib -lMSL_Extras_x86.lib
-RCFLAGS	=
-CFLAGS	+= -nostdinc -gccinc -msgstyle gcc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -ir "$(METROWERKS)/MSL" -ir "$(METROWERKS)/Win32-x86 Support"
-CFLAGS	+= -w on,nounused,nounusedexpr # -ansi strict
-else
-LIBEXT	= a
-LD	= $(LIBSSH2_CC)
-RC	= $(CROSSPREFIX)windres
-LDFLAGS	+= -s -shared -Wl,--output-def,$(libssh2_dll_LIBRARY:.dll=.def),--out-implib,$(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT)
-AR	= $(LIBSSH2_AR)
-ARFLAGS	= cru
-RANLIB	= $(LIBSSH2_RANLIB)
-RCFLAGS	= -I $(PROOT)/include -O coff
-CFLAGS	+= -fno-builtin
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall # -pedantic
-ifeq ($(ARCH),w64)
-CFLAGS	+= -m64 -D_AMD64_
-LDFLAGS += -m64
-RCFLAGS	+= -F pe-x86-64
-else
-CFLAGS	+= -m32
-LDFLAGS += -m32
-RCFLAGS	+= -F pe-i386
-endif
-endif
-
-INCLUDES = -I$(PROOT)/win32 -I$(PROOT)/include
-
-ifdef WITH_WINCNG
-CFLAGS	+= -DLIBSSH2_WINCNG
-LDLIBS	+= -lbcrypt -lcrypt32
-else
-CFLAGS	+= -DLIBSSH2_OPENSSL
-ifndef OPENSSL_INCLUDE
-	ifeq "$(wildcard $(OPENSSL_PATH)/outinc)" "$(OPENSSL_PATH)/outinc"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/outinc
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/include)" "$(OPENSSL_PATH)/include"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/include
-	endif
-endif
-ifneq "$(wildcard $(OPENSSL_INCLUDE)/openssl/opensslv.h)" "$(OPENSSL_INCLUDE)/openssl/opensslv.h"
-$(error Invalid OPENSSL_PATH: $(OPENSSL_PATH))
-endif
-INCLUDES += -I"$(OPENSSL_INCLUDE)"
-ifndef OPENSSL_LIBPATH
-	OPENSSL_LIBS_STAT = crypto ssl
-	ifeq "$(wildcard $(OPENSSL_PATH)/out)" "$(OPENSSL_PATH)/out"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/out
-		OPENSSL_LIBS_DYN = eay32 ssl32
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/lib)" "$(OPENSSL_PATH)/lib"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/lib
-		OPENSSL_LIBS_DYN = crypto.dll ssl.dll
-	endif
-endif
-ifdef LINK_OPENSSL_STATIC
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_STAT)) -lgdi32
-else
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_DYN))
-endif
-endif
-ifeq ($(CC),mwcc)
-LDLIBS	+= -lkernel32.lib -luser32.lib -lwsock32.lib
-else
-#LDLIBS	+= -lwsock32
-LDLIBS	+= -lws2_32
-endif
-
-ifdef WITH_ZLIB
-	CFLAGS += -DLIBSSH2_HAVE_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-	ifdef LINK_ZLIB_STATIC
-		LDLIBS += $(ZLIB_PATH)/libz.$(LIBEXT)
-	else
-		LDLIBS += $(ZLIB_PATH)/libz.dll.$(LIBEXT)
-	endif
-endif
-
-CFLAGS	+= $(INCLUDES)
-
-vpath %.c $(PROOT)/src
-
-ifdef WITH_WINCNG
-include $(PROOT)/Makefile.WinCNG.inc
-else
-include $(PROOT)/Makefile.OpenSSL.inc
-endif
-
-# include Makefile.inc to get CSOURCES define
-include $(PROOT)/Makefile.inc
-
-OBJECTS	:= $(patsubst %.c,%.o,$(CSOURCES))
-OBJS	:= $(addprefix $(OBJDIR)/,$(OBJECTS))
-OBJL	= $(OBJS) $(OBJDIR)/$(TARGET).res
-
-
-all: lib dll
-
-dll: prebuild $(libssh2_dll_LIBRARY)
-
-lib: prebuild $(TARGET).$(LIBEXT)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-# libssh2_config.h
-
-test: all
-	$(MAKE) -C test -f GNUmakefile
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: $(PROOT)/get_ver.awk $(PROOT)/include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $^ > $@
-
-dist: all $(DISTDIR) $(DISTDIR)/readme.txt
-	@$(call MKDIR, $(DISTDIR)/bin)
-	@$(call COPY, $(PROOT)/AUTHORS, $(DISTDIR))
-	@$(call COPY, $(PROOT)/COPYING, $(DISTDIR))
-	@$(call COPY, $(PROOT)/INSTALL, $(DISTDIR))
-	@$(call COPY, $(PROOT)/README, $(DISTDIR))
-	@$(call COPY, $(PROOT)/RELEASE-NOTES, $(DISTDIR))
-	@$(call COPY, $(libssh2_dll_LIBRARY), $(DISTDIR)/bin)
-	@echo Creating $(DISTARC)
-	@$(ZIP) $(DISTARC) $(DISTDIR)/* < $(DISTDIR)/readme.txt
-
-dev: all $(DEVLDIR) $(DEVLDIR)/readme.txt
-	@$(call MKDIR, $(DEVLDIR)/bin)
-	@$(call MKDIR, $(DEVLDIR)/include)
-	@$(call MKDIR, $(DEVLDIR)/win32)
-	@$(call COPY, $(PROOT)/AUTHORS, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/COPYING, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/INSTALL, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/README, $(DEVLDIR))
-	@$(call COPY, $(PROOT)/RELEASE-NOTES, $(DEVLDIR))
-	@$(call COPY, $(libssh2_dll_LIBRARY), $(DEVLDIR)/bin)
-	@$(call COPY, $(PROOT)/include/*.h, $(DEVLDIR)/include)
-	@$(call COPY, libssh2_config.h, $(DEVLDIR)/include)
-	@$(call COPY, *.$(LIBEXT), $(DEVLDIR)/win32)
-	@echo Creating $(DEVLARC)
-	@$(ZIP) $(DEVLARC) $(DEVLDIR)/* < $(DEVLDIR)/readme.txt
-
-distclean vclean: clean
-	$(call RMDIR, $(DISTDIR))
-	$(call DEL, $(DISTARC))
-
-devclean: clean
-	$(call RMDIR, $(DEVLDIR))
-	$(call DEL, $(DEVLARC))
-
-objclean: all
-	$(call RMDIR, $(OBJDIR))
-
-testclean: clean
-	$(MAKE) -C test -f GNUmakefile clean
-
-clean:
-#	$(call DEL, libssh2_config.h)
-	$(call DEL, $(libssh2_dll_LIBRARY) $(libssh2_dll_LIBRARY:.dll=.def) $(TARGET).$(LIBEXT) $(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT))
-	$(call RMDIR, $(OBJDIR))
-
-$(OBJDIR):
-	@$(call MKDIR, $@)
-
-$(DISTDIR):
-	@$(call MKDIR, $@)
-
-$(DEVLDIR):
-	@$(call MKDIR, $@)
-
-$(TARGET).$(LIBEXT): $(OBJS)
-	@echo Creating $@
-	@$(call DEL, $@)
-	@$(AR) $(ARFLAGS) $@ $^
-ifdef RANLIB
-	@$(RANLIB) $@
-endif
-
-$(libssh2_dll_LIBRARY) $(TARGET)$(LIBSSH2_DLL_A_SUFFIX).$(LIBEXT): $(OBJL)
-	@echo Linking $@
-	@$(call DEL, $@)
-	@$(LD) $(LDFLAGS) $^ -o $@ $(LIBPATH) $(LDLIBS)
-
-
-$(OBJDIR)/%.res: %.rc
-	@echo Creating $@
-	@$(RC) $(RCFLAGS) -i $< -o $@
-
-
-$(DISTDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a binary distribution for Win32 platform.$(DL) > $@
-	@echo $(DL)libssh version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-$(DEVLDIR)/readme.txt: GNUmakefile
-	@echo Creating $@
-	@echo $(DL)This is a development distribution for Win32 platform.$(DL) > $@
-	@echo $(DL)libssh version $(LIBSSH2_VERSION_STR)$(DL) >> $@
-	@echo $(DL)Please download the complete libssh package for$(DL) >> $@
-	@echo $(DL)any further documentation:$(DL) >> $@
-	@echo $(DL)$(WWWURL)$(DL) >> $@
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) dll$(DL)
-	@echo $(DL)$(MAKE) lib$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) dev$(DL)
-	@echo $(DL)$(MAKE) devclean$(DL)
-	@echo $(DL)$(MAKE) dist$(DL)
-	@echo $(DL)$(MAKE) distclean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)$(MAKE) test$(DL)
-	@echo $(DL)===========================================================$(DL)
diff --git a/libssh2/win32/Makefile.Watcom b/libssh2/win32/Makefile.Watcom
deleted file mode 100644
index 1e8cede6..00000000
--- a/libssh2/win32/Makefile.Watcom
+++ /dev/null
@@ -1,190 +0,0 @@
-#
-#  Watcom / OpenWatcom Win32 makefile for libssh2.
-#
-#  Comments to: Guenter Knauf http://www.gknw.net/phpbb
-#
-
-!ifndef %watcom
-!error WATCOM environment variable not set!
-!else
-SYS_INCL = -I$(%watcom)\h\nt -I$(%watcom)\h
-SYS_LIBS = $(%watcom)\lib386\nt;$(%watcom)\lib386
-!endif
-
-!ifdef %libname
-LIBNAME = $(%libname)
-!else
-LIBNAME = libssh2
-!endif
-TARGETS = $(LIBNAME).dll $(LIBNAME)_imp.lib $(LIBNAME).lib
-
-CC = wcc386
-LD = wlink
-AR = wlib
-RC = wrc
-
-!ifdef __LOADDLL__
-!  loaddll wcc386  wccd386
-!  loaddll wpp386  wppd386
-!  loaddll wlib    wlibd
-!  if $(__VERSION__) > 1270
-!    loaddll wlink   wlinkd
-!  else
-!    loaddll wlink   wlink
-!  endif
-!endif
-
-!if $(__VERSION__) < 1250                                                                                                           
-RM = del /q /f 2>NUL
-!else                                                                                                                               
-RM = rm -f                                                                                                                          
-!endif
-MD = mkdir
-RD = rmdir /q /s 2>NUL
-CP = copy
-
-CFLAGS = -3r -mf -hc -zff -zgf -zq -zm -zc -s -fr=nul -w2 -fpi -oilrtfm &
-         -wcd=201 -bt=nt -d+ -dWIN32 -DLIBSSH2_WIN32 &
-         -I. -I..\include $(SYS_INCL)
-
-!ifdef %debug
-DEBUG  = -dDEBUG=1 -dDEBUGBUILD
-CFLAGS += -d3 $(DEBUG)
-!else
-CFLAGS += -d0
-!endif
-
-!ifdef %use_ipv6
-CFLAGS += -d_WIN32_WINNT=0x0501 -dENABLE_IPV6
-!endif
-
-#
-# Change to suite.
-#
-!ifdef %zlib_root
-ZLIB_ROOT = $(%zlib_root)
-!else
-ZLIB_ROOT = ..\..\zlib-1.2.8
-!endif
-
-!ifdef %openssl_root
-OPENSSL_ROOT = $(%openssl_root)
-!else
-OPENSSL_ROOT = ..\..\openssl-0.9.8zc
-!endif
-
-!ifdef %use_zlib
-CFLAGS += -DLIBSSH2_HAVE_ZLIB -I$(ZLIB_ROOT)
-!endif
-
-!ifdef %use_wincng
-CFLAGS += -DLIBSSH2_WINCNG
-!else
-CFLAGS += -wcd=138 -dLIBSSH2_OPENSSL -I$(OPENSSL_ROOT)\inc32
-!endif
-
-!ifdef %use_watt32
-CFLAGS += -dUSE_WATT32 -I$(%watt_root)\inc
-!endif
-
-OBJ_BASE = WC_Win32.obj
-LINK_ARG = $(OBJ_BASE)\dyn\wlink.arg
-LIB_ARG  = $(OBJ_BASE)\stat\wlib.arg
-
-# In order to process Makefile.inc wmake must be called with -u switch!
-!ifndef %MAKEFLAGS
-!error You MUST call wmake with the -u switch!
-!else
-!ifdef %use_wincng
-!include ..\Makefile.WinCNG.inc
-!else
-!include ..\Makefile.OpenSSL.inc
-!endif
-!include ..\Makefile.inc
-!endif
-
-OBJS = $(CSOURCES:.c=.obj)
-OBJS = $OBJ_DIR\$(OBJS: = $OBJ_DIR\)
-
-#
-# Use $(OBJS) as a template to generate $(OBJS_STAT) and $(OBJS_DYN).
-#
-OBJ_DIR    = $(OBJ_BASE)\stat
-OBJS_STAT  = $+ $(OBJS) $-
-
-OBJ_DIR    = $(OBJ_BASE)\dyn
-OBJS_DYN   = $+ $(OBJS) $-
-
-RESOURCE   = $(OBJ_BASE)\dyn\libssh2.res
-
-.c: ..\src
-
-
-all: $(OBJ_BASE) $(TARGETS) .SYMBOLIC
-	@echo Welcome to libssh2
-
-clean: .SYMBOLIC
-	-$(RM) $(OBJS_STAT)
-	-$(RM) $(OBJS_DYN)
-	-$(RM) $(RESOURCE) $(LINK_ARG) $(LIB_ARG)
-
-vclean realclean: clean .SYMBOLIC
-	-$(RM) $(TARGETS) $(LIBNAME).map $(LIBNAME).sym
-	-$(RD) $(OBJ_BASE)\stat
-	-$(RD) $(OBJ_BASE)\dyn
-	-$(RD) $(OBJ_BASE)
-
-$(OBJ_BASE):
-	-$(MD) $^@
-	-$(MD) $^@\stat
-	-$(MD) $^@\dyn
-
-$(LIBNAME).dll: $(OBJS_DYN) $(RESOURCE) $(LINK_ARG)
-	$(LD) name $^@ @$]@
-
-$(LIBNAME).lib: $(OBJS_STAT) $(LIB_ARG)
-	$(AR) -q -b -c $^@ @$]@
-
-.ERASE
-$(RESOURCE): libssh2.rc
-	$(RC) $(DEBUG) -q -r -zm -I..\include $(SYS_INCL) $[@ -fo=$^@
-
-.ERASE
-.c{$(OBJ_BASE)\dyn}.obj:
-	$(CC) $(CFLAGS) -bd -br $[@ -fo=$^@
-
-.ERASE
-.c{$(OBJ_BASE)\stat}.obj:
-	$(CC) $(CFLAGS) $[@ -fo=$^@
-
-$(LINK_ARG): $(__MAKEFILES__)
-	%create $^@
-	@%append $^@ system nt dll
-	@%append $^@ file { $(OBJS_DYN) }
-!ifdef %debug
-	@%append $^@ debug all
-	@%append $^@ option symfile
-!endif
-	@%append $^@ option quiet, map, caseexact, eliminate, implib=$(LIBNAME)_imp.lib,
-	@%append $^@ res=$(RESOURCE) libpath $(SYS_LIBS)
-!ifdef %use_watt32
-	@%append $^@ library $(%watt_root)\lib\wattcpw_imp.lib
-!else
-	@%append $^@ library ws2_32.lib
-!endif
-!ifdef %use_zlib
-	@%append $^@ library '$(ZLIB_ROOT)\zlib.lib'
-!endif
-!ifdef %use_wincng
-	@%append $^@ library bcrypt.lib
-	@%append $^@ library crypt32.lib
-!else
-	@%append $^@ library '$(OPENSSL_ROOT)\out32\libeay32.lib'
-	@%append $^@ library '$(OPENSSL_ROOT)\out32\ssleay32.lib'
-!endif
-
-$(LIB_ARG): $(__MAKEFILES__)
-	%create $^@
-	@for %f in ($(OBJS_STAT)) do @%append $^@ +- %f
-
-
diff --git a/libssh2/win32/config.mk b/libssh2/win32/config.mk
deleted file mode 100644
index 21fe2e55..00000000
--- a/libssh2/win32/config.mk
+++ /dev/null
@@ -1,54 +0,0 @@
-
-# Tweak these for your system
-!if "$(OPENSSLINC)" == ""
-OPENSSLINC=..\openssl-0.9.8zc\inc32
-!endif
-
-!if "$(OPENSSLLIB)" == ""
-OPENSSLLIB=..\openssl-0.9.8zc\out32dll
-!endif
-
-!if "$(ZLIBINC)" == ""
-ZLIBINC=..\zlib-1.2.8
-!endif
-
-!if "$(ZLIBLIB)" == ""
-ZLIBLIB=..\zlib-1.2.8
-!endif
-
-!if "$(TARGET)" == ""
-TARGET=Release
-!endif
-
-!if "$(TARGET)" == "Debug"
-SUFFIX=_debug
-CPPFLAGS=/Od /MDd
-DLLFLAGS=/DEBUG /LDd
-!else
-CPPFLAGS=/Oi /O2 /Oy /GF /Y- /MD /DNDEBUG
-DLLFLAGS=/DEBUG /LD
-!endif
-
-CPPFLAGS=/nologo /GL /Zi /EHsc $(CPPFLAGS) /Iwin32 /Iinclude
-
-!if "$(WITH_WINCNG)" == "1"
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_WINCNG
-# LIBS=bcrypt.lib crypt32.lib
-!else
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_OPENSSL /I$(OPENSSLINC)
-LIBS=$(LIBS) $(OPENSSLLIB)\libeay32.lib $(OPENSSLLIB)\ssleay32.lib
-!endif
-
-!if "$(WITH_ZLIB)" == "1"
-CPPFLAGS=$(CPPFLAGS) /DLIBSSH2_HAVE_ZLIB /I$(ZLIBINC)
-LIBS=$(LIBS) $(ZLIBLIB)\zlib.lib
-!endif
-
-CFLAGS=$(CPPFLAGS)
-RCFLAGS=/Iinclude
-DLLFLAGS=$(CFLAGS) $(DLLFLAGS)
-LIBS=$(LIBS) ws2_32.lib user32.lib advapi32.lib gdi32.lib
-
-INTDIR=$(TARGET)\$(SUBDIR)
-
-
diff --git a/libssh2/win32/libssh2.dsp b/libssh2/win32/libssh2.dsp
deleted file mode 100644
index 1657c7bf..00000000
--- a/libssh2/win32/libssh2.dsp
+++ /dev/null
@@ -1,439 +0,0 @@
-# Microsoft Developer Studio Project File - Name="libssh2" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-# only OpenSSL and WinCNG are supported with this build system
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=libssh2 - Win32 OpenSSL Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak" CFG="libssh2 - Win32 DLL Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ENDIF
-
-# Begin Target
-
-# Name "libssh2 - Win32 OpenSSL DLL Release"
-# Name "libssh2 - Win32 OpenSSL DLL Debug"
-# Name "libssh2 - Win32 OpenSSL LIB Release"
-# Name "libssh2 - Win32 OpenSSL LIB Debug"
-# Name "libssh2 - Win32 WinCNG DLL Release"
-# Name "libssh2 - Win32 WinCNG DLL Debug"
-# Name "libssh2 - Win32 WinCNG LIB Release"
-# Name "libssh2 - Win32 WinCNG LIB Debug"
-
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx"
-# Begin Source File
-
-SOURCE=..\src\agent.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\agent_win.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\bcrypt_pbkdf.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\blowfish.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\channel.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\comp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\crypt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\global.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\hostkey.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\keepalive.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\kex.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\knownhost.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mac.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mbedtls.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\misc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\openssl.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\packet.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\pem.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\publickey.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\scp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\session.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\sftp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\transport.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\userauth.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\version.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\wincng.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx"
-# Begin Source File
-
-SOURCE=..\src\agent.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\blf.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\channel.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\comp.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\crypto.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\libssh2_config.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\libssh2_priv.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mac.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\mbedtls.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\misc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\openssl.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\packet.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\session.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\sftp.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\transport.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\userauth.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\wincng.h
-# End Source File
-# End Group
-# End Target
-# End Project
-
diff --git a/libssh2/win32/libssh2.dsw b/libssh2/win32/libssh2.dsw
deleted file mode 100644
index 36ad8fc0..00000000
--- a/libssh2/win32/libssh2.dsw
+++ /dev/null
@@ -1,41 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "libssh2"=".\libssh2.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Project: "tests"=".\tests.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
diff --git a/libssh2/win32/libssh2_config.h b/libssh2/win32/libssh2_config.h
deleted file mode 100644
index 6ac2ef43..00000000
--- a/libssh2/win32/libssh2_config.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef LIBSSH2_CONFIG_H
-#define LIBSSH2_CONFIG_H
-
-#ifndef WIN32
-#define WIN32
-#endif
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE 1
-#endif /* _CRT_SECURE_NO_DEPRECATE */
-#include <winsock2.h>
-#include <mswsock.h>
-#include <ws2tcpip.h>
-
-#ifdef __MINGW32__
-#define HAVE_UNISTD_H
-#define HAVE_INTTYPES_H
-#define HAVE_SYS_TIME_H
-#define HAVE_GETTIMEOFDAY
-#endif /* __MINGW32__ */
-
-#define HAVE_LIBCRYPT32
-#define HAVE_WINSOCK2_H
-#define HAVE_IOCTLSOCKET
-#define HAVE_SELECT
-
-#ifdef _MSC_VER
-#if _MSC_VER < 1900
-#define snprintf _snprintf
-#if _MSC_VER < 1500
-#define vsnprintf _vsnprintf
-#endif
-#define strdup _strdup
-#define strncasecmp _strnicmp
-#define strcasecmp _stricmp
-#endif
-#else
-#ifndef __MINGW32__
-#define strncasecmp strnicmp
-#define strcasecmp stricmp
-#endif /* __MINGW32__ */
-#endif /* _MSC_VER */
-
-/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
-#define LIBSSH2_DH_GEX_NEW 1
-
-#endif /* LIBSSH2_CONFIG_H */
-
diff --git a/libssh2/win32/msvcproj.foot b/libssh2/win32/msvcproj.foot
deleted file mode 100644
index 07defa46..00000000
--- a/libssh2/win32/msvcproj.foot
+++ /dev/null
@@ -1,3 +0,0 @@
-# End Target
-# End Project
-
diff --git a/libssh2/win32/msvcproj.head b/libssh2/win32/msvcproj.head
deleted file mode 100644
index eb820201..00000000
--- a/libssh2/win32/msvcproj.head
+++ /dev/null
@@ -1,256 +0,0 @@
-# Microsoft Developer Studio Project File - Name="libssh2" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-# only OpenSSL and WinCNG are supported with this build system
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=libssh2 - Win32 OpenSSL Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "libssh2.mak" CFG="libssh2 - Win32 DLL Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 OpenSSL LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG DLL Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "libssh2 - Win32 WinCNG LIB Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib libeay32.lib zlib.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 OpenSSL LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_OPENSSL" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_dll"
-# PROP BASE Intermediate_Dir "Release_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_dll"
-# PROP Intermediate_Dir "Release_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /map /debug /machine:I386
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG DLL Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_dll"
-# PROP BASE Intermediate_Dir "Debug_dll"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_dll"
-# PROP Intermediate_Dir "Debug_dll"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# SUBTRACT CPP /WX /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 gdi32.lib advapi32.lib user32.lib kernel32.lib ws2_32.lib crypt32.lib bcrypt.lib /nologo /dll /incremental:no /map /debug /machine:I386 /pdbtype:sept
-# SUBTRACT LINK32 /nodefaultlib
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release_lib"
-# PROP BASE Intermediate_Dir "Release_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_lib"
-# PROP Intermediate_Dir "Release_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\win32" /I "..\include" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-# ADD LIB32 /nologo /out:"Release_lib\libssh2.lib"
-
-!ELSEIF  "$(CFG)" == "libssh2 - Win32 WinCNG LIB Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug_lib"
-# PROP BASE Intermediate_Dir "Debug_lib"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug_lib"
-# PROP Intermediate_Dir "Debug_lib"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MD /W3 /Gm /GX /ZI /Od /I "..\win32" /I "..\include" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "LIBSSH2_WINCNG" /D "_MBCS" /D "_LIB" /D "LIBSSH2DEBUG" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"Debug_lib\libssh2d.lib"
-
-!ENDIF
-
-# Begin Target
-
-# Name "libssh2 - Win32 OpenSSL DLL Release"
-# Name "libssh2 - Win32 OpenSSL DLL Debug"
-# Name "libssh2 - Win32 OpenSSL LIB Release"
-# Name "libssh2 - Win32 OpenSSL LIB Debug"
-# Name "libssh2 - Win32 WinCNG DLL Release"
-# Name "libssh2 - Win32 WinCNG DLL Debug"
-# Name "libssh2 - Win32 WinCNG LIB Release"
-# Name "libssh2 - Win32 WinCNG LIB Debug"
-
diff --git a/libssh2/win32/rules.mk b/libssh2/win32/rules.mk
deleted file mode 100644
index bfb77847..00000000
--- a/libssh2/win32/rules.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-
-all-sub: $(INTDIR) all
-
-clean-sub: clean
-
-$(INTDIR):
-!if "$(SRCDIR)" == ""
-	@if not exist $(TARGET) mkdir $(TARGET)
-!endif
-	@if not exist $(INTDIR) mkdir $(INTDIR)
-
-{$(SUBDIR)}.c{$(INTDIR)}.obj::
-	$(CC) -c $(CFLAGS) /Fo"$(INTDIR)\\" $<
-
-
diff --git a/libssh2/win32/test/GNUmakefile b/libssh2/win32/test/GNUmakefile
deleted file mode 100644
index 5cf6e8cf..00000000
--- a/libssh2/win32/test/GNUmakefile
+++ /dev/null
@@ -1,283 +0,0 @@
-#########################################################################
-#
-## Makefile for building libssh2 samples (Win32 version - gnu make)
-## Use: make -f GNUmakefile [help]
-##
-## Hacked by: Guenter Knauf
-#
-#########################################################################
-
-# Edit the path below to point to the base of your Zlib sources.
-ifndef ZLIB_PATH
-ZLIB_PATH = ../../../zlib-1.2.8
-endif
-
-# Edit the path below to point to the base of your OpenSSL package.
-ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8zc
-endif
-
-# Project root
-PROOT	= ../..
-
-# Edit the var below to enable static linking of libssh2 and libz
-LINK_STATIC = 1
-
-# Edit the vars below to change target settings.
-SAMPLES	= $(PROOT)/example
-TARGETS := $(filter-out x11.exe,$(patsubst $(SAMPLES)/%.c,%.exe,$(strip $(wildcard $(SAMPLES)/*.c))))
-WWWURL	= https://www.libssh2.org/
-DESCR	= libssh2 $(subst .rc,,$(notdir $@)) $(LIBSSH2_VERSION_STR)
-#STACK	= 64000
-
-# must be equal to DEBUG or NDEBUG
-ifndef DB
-	DB	= NDEBUG
-	# DB	= DEBUG
-endif
-# Optimization: -O<n> or debugging: -g
-ifeq ($(DB),NDEBUG)
-	OPT	= -O2
-	OBJDIR	= release
-else
-	OPT	= -g
-	OBJDIR	= debug
-endif
-
-# Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk-20100523.zip
-AWK     = awk
-ZIP     = zip -qzr9
-
-# Platform-dependent helper tool macros
-ifeq ($(findstring /sh,$(SHELL)),/sh)
-DEL	= rm -f $1
-RMDIR	= rm -fr $1
-MKDIR	= mkdir -p $1
-COPY	= -cp -afv $1 $2
-#COPYR	= -cp -afr $1/* $2
-COPYR	= -rsync -aC $1/* $2
-TOUCH	= touch $1
-CAT	= cat
-ECHONL	= echo ""
-DL	= '
-else
-ifeq "$(OS)" "Windows_NT"
-DEL	= -del 2>NUL /q /f $(subst /,\,$1)
-RMDIR	= -rd 2>NUL /q /s $(subst /,\,$1)
-else
-DEL	= -del 2>NUL $(subst /,\,$1)
-RMDIR	= -deltree 2>NUL /y $(subst /,\,$1)
-endif
-MKDIR	= -md 2>NUL $(subst /,\,$1)
-COPY	= -copy 2>NUL /y $(subst /,\,$1) $(subst /,\,$2)
-COPYR	= -xcopy 2>NUL /q /y /e $(subst /,\,$1) $(subst /,\,$2)
-TOUCH	= copy 2>&1>NUL /b $(subst /,\,$1) +,,
-CAT	= type
-ECHONL	= $(ComSpec) /c echo.
-endif
-
-# The following line defines your compiler.
-ifdef METROWERKS
-	CC = mwcc
-else
-	CC = $(CROSSPREFIX)gcc
-endif
-
-# Set environment var ARCH to your architecture to override autodetection.
-ifndef ARCH
-ifeq ($(findstring gcc,$(CC)),gcc)
-ifeq ($(findstring x86_64,$(shell $(CC) -dumpmachine)),x86_64)
-ARCH	= w64
-else
-ARCH	= w32
-endif
-else
-ARCH	= w32
-endif
-endif
-
-# Include the version info retrieved from libssh2.h
--include $(OBJDIR)/version.inc
-
-# Global flags for all compilers
-CFLAGS	= $(OPT) -D$(DB) -DLIBSSH2_WIN32 # -DHAVE_CONFIG_H
-
-ifeq ($(CC),mwcc)
-LD	= mwld
-RC	= mwwinrc
-LDFLAGS	= -nostdlib
-AR	= $(LD)
-ARFLAGS	= -nostdlib -library -o
-LIBEXT	= lib
-LIBPATH	+= -lr "$(METROWERKS)/MSL" -lr "$(METROWERKS)/Win32-x86 Support"
-LDLIBS	+= -lMSL_Runtime_x86.lib -lMSL_C_x86.lib -lMSL_Extras_x86.lib
-LDLIBS	+= -lkernel32.lib -luser32.lib -lwsock32.lib
-RCFLAGS	=
-CFLAGS	+= -nostdinc -gccinc -msgstyle gcc -inline off -opt nointrinsics -proc 586
-CFLAGS	+= -ir "$(METROWERKS)/MSL" -ir "$(METROWERKS)/Win32-x86 Support"
-CFLAGS	+= -w on,nounused,nounusedexpr # -ansi strict
-else
-LD	= $(CROSSPREFIX)gcc
-RC	= $(CROSSPREFIX)windres
-LDFLAGS	= -s
-AR	= $(CROSSPREFIX)ar
-ARFLAGS	= -cq
-LIBEXT	= a
-#LDLIBS	+= -lwsock32
-LDLIBS	+= -lws2_32
-RCFLAGS	= -I $(PROOT)/include -O coff
-CFLAGS	+= -fno-builtin
-CFLAGS	+= -fno-strict-aliasing
-CFLAGS	+= -Wall #-Wno-unused #-pedantic
-ifeq ($(ARCH),w64)
-CFLAGS	+= -D_AMD64_
-RCFLAGS	+= -F pe-x86-64
-else
-CFLAGS	+= -m32
-RCFLAGS	+= -F pe-i386
-endif
-endif
-
-INCLUDES = -I$(PROOT)/win32 -I$(PROOT)/include
-LIBPATH += -L$(PROOT)/win32
-
-ifdef LINK_STATIC
-	LDLIBS += -llibssh2
-else
-	LDLIBS += -llibssh2dll
-endif
-
-ifdef WITH_WINCNG
-# CFLAGS	+= -DLIBSSH2_WINCNG
-LDLIBS	+= -lbcrypt -lcrypt32
-else
-# CFLAGS	+= -DLIBSSH2_OPENSSL
-ifndef OPENSSL_INCLUDE
-	ifeq "$(wildcard $(OPENSSL_PATH)/outinc)" "$(OPENSSL_PATH)/outinc"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/outinc
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/include)" "$(OPENSSL_PATH)/include"
-		OPENSSL_INCLUDE = $(OPENSSL_PATH)/include
-	endif
-endif
-ifneq "$(wildcard $(OPENSSL_INCLUDE)/openssl/opensslv.h)" "$(OPENSSL_INCLUDE)/openssl/opensslv.h"
-$(error Invalid OPENSSL_PATH: $(OPENSSL_PATH))
-endif
-INCLUDES += -I"$(OPENSSL_INCLUDE)"
-ifndef OPENSSL_LIBPATH
-	OPENSSL_LIBS_STAT = crypto ssl
-	ifeq "$(wildcard $(OPENSSL_PATH)/out)" "$(OPENSSL_PATH)/out"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/out
-		OPENSSL_LIBS_DYN = eay32 ssl32
-	endif
-	ifeq "$(wildcard $(OPENSSL_PATH)/lib)" "$(OPENSSL_PATH)/lib"
-		OPENSSL_LIBPATH = $(OPENSSL_PATH)/lib
-		OPENSSL_LIBS_DYN = crypto.dll ssl.dll
-	endif
-endif
-ifdef LINK_STATIC
-ifdef LINK_OPENSSL_STATIC
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_STAT)) -lgdi32
-else
-	LDLIBS += $(patsubst %,$(OPENSSL_LIBPATH)/lib%.$(LIBEXT), $(OPENSSL_LIBS_DYN))
-endif
-endif
-endif
-
-ifdef WITH_ZLIB
-	CFLAGS += -DLIBSSH2_HAVE_ZLIB
-	INCLUDES += -I$(ZLIB_PATH)
-	ifdef LINK_ZLIB_STATIC
-		LDLIBS += $(ZLIB_PATH)/libz.$(LIBEXT)
-	else
-		LDLIBS += $(ZLIB_PATH)/libzdll.$(LIBEXT)
-	endif
-endif
-
-CFLAGS	+= $(INCLUDES)
-
-vpath %.c $(PROOT)/example
-
-.PRECIOUS: $(OBJDIR)/%.o $(OBJDIR)/%.rc $(OBJDIR)/%.res
-
-
-all: prebuild $(TARGETS)
-
-prebuild: $(OBJDIR) $(OBJDIR)/version.inc
-
-$(OBJDIR)/%.o: %.c
-#	@echo Compiling $<
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/version.inc: $(PROOT)/include/libssh2.h $(OBJDIR)
-	@echo Creating $@
-	@$(AWK) -f $(PROOT)/get_ver.awk $< > $@
-
-objclean:
-	$(call RMDIR, $(OBJDIR))
-
-clean: objclean
-	$(call DEL, $(TARGETS))
-
-$(OBJDIR):
-	$(call MKDIR, $@)
-
-%.exe: $(OBJDIR)/%.o $(OBJDIR)/%.res
-	@echo Linking $@
-	@$(call DEL, $@)
-	$(LD) $(LDFLAGS) $^ -o $@ $(LIBPATH) $(LDLIBS)
-
-$(OBJDIR)/%.res: $(OBJDIR)/%.rc
-	@echo Creating $@
-	@$(RC) $(RCFLAGS) -i $< -o $@
-
-$(OBJDIR)/%.rc: GNUmakefile $(OBJDIR)/version.inc
-	@echo $(DL)1 VERSIONINFO$(DL) > $@
-	@echo $(DL) FILEVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) PRODUCTVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) FILEFLAGSMASK 0x3fL$(DL) >> $@
-	@echo $(DL) FILEOS 0x40004L$(DL) >> $@
-	@echo $(DL) FILEFLAGS 0x0L$(DL) >> $@
-	@echo $(DL) FILETYPE 0x1L$(DL) >> $@
-	@echo $(DL) FILESUBTYPE 0x0L$(DL) >> $@
-	@echo $(DL)BEGIN$(DL) >> $@
-	@echo $(DL)  BLOCK "StringFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    BLOCK "040904E4"$(DL) >> $@
-	@echo $(DL)    BEGIN$(DL) >> $@
-	@echo $(DL)      VALUE "LegalCopyright","\xA9 $(LIBSSH2_COPYRIGHT_STR)\0"$(DL) >> $@
-ifdef COMPANY
-	@echo $(DL)      VALUE "CompanyName","$(COMPANY)\0"$(DL) >> $@
-endif
-	@echo $(DL)      VALUE "ProductName","$(notdir $(@:.rc=.exe))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "ProductVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "License","Released under GPL.\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileDescription","$(DESCR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "InternalName","$(notdir $(@:.rc=))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "OriginalFilename","$(notdir $(@:.rc=.exe))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "WWW","$(WWWURL)\0"$(DL) >> $@
-	@echo $(DL)    END$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)  BLOCK "VarFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    VALUE "Translation", 0x409, 1252$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)END$(DL) >> $@
-ifdef ICON
-	@echo $(DL)10 ICON DISCARDABLE "$(ICON)"$(DL) >> $@
-endif
-
-help: $(OBJDIR)/version.inc
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)OpenSSL path    = $(OPENSSL_PATH)$(DL)
-	@echo $(DL)Zlib path       = $(ZLIB_PATH)$(DL)
-	@echo $(DL)===========================================================$(DL)
-	@echo $(DL)libssh $(LIBSSH2_VERSION_STR) - available targets are:$(DL)
-	@echo $(DL)$(MAKE) all$(DL)
-	@echo $(DL)$(MAKE) clean$(DL)
-	@echo $(DL)$(MAKE) objclean$(DL)
-	@echo $(DL)===========================================================$(DL)
-
-
diff --git a/libssh2/win32/tests.dsp b/libssh2/win32/tests.dsp
deleted file mode 100644
index b6df3241..00000000
--- a/libssh2/win32/tests.dsp
+++ /dev/null
@@ -1,102 +0,0 @@
-# Microsoft Developer Studio Project File - Name="tests" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=tests - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "tests.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "tests.mak" CFG="tests - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "tests - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "tests - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "tests - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "tests___Win32_Release"
-# PROP BASE Intermediate_Dir "tests___Win32_Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\include" /I "..\win32" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2.lib /nologo /subsystem:console /machine:I386 /libpath:"Release" /out:"simple.exe"
-
-!ELSEIF  "$(CFG)" == "tests - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "tests___Win32_Debug"
-# PROP BASE Intermediate_Dir "tests___Win32_Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\include" /I "..\win32" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2d.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /pdbtype:sept /libpath:"Debug" /out:"simple.exe"
-
-!ENDIF 
-
-# Begin Target
-
-# Name "tests - Win32 Release"
-# Name "tests - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\tests\simple.c
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project
diff --git a/requirements_dev.txt b/requirements_dev.txt
index c20000f7..8bf2de5c 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -5,4 +5,3 @@ sphinx
 sphinx_rtd_theme
 pytest
 pytest-rerunfailures
--e .
diff --git a/setup.cfg b/setup.cfg
index 83a80f52..b98832b5 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -12,3 +12,8 @@ max-line-length = 100
 filename = *.pyx,*.px*
 exclude = .eggs,*.egg,build
 ignore = E901,E225,E226,E227,E999
+
+[tool:pytest]
+addopts=-v --durations=10 --reruns=5
+testpaths =
+    tests
diff --git a/setup.py b/setup.py
index b27c637c..5d6d9a8b 100644
--- a/setup.py
+++ b/setup.py
@@ -1,12 +1,12 @@
-import platform
 import os
-import sys
+import platform
 from glob import glob
 
-from _setup_libssh2 import build_ssh2
+import sys
+from setuptools import setup, find_packages
 
 import versioneer
-from setuptools import setup, find_packages
+from _setup_libssh2 import build_ssh2
 
 cpython = platform.python_implementation() == 'CPython'
 
@@ -48,7 +48,7 @@
                      'boundscheck': False,
                      'optimize.use_switch': True,
                      'wraparound': False,
-                     'language_level': 2,
+                     'language_level': 3,
 }
 cython_args = {
     'cython_directives': cython_directives,
@@ -61,7 +61,10 @@
 
 runtime_library_dirs = ["$ORIGIN/."] if not SYSTEM_LIBSSH2 else None
 _lib_dir = os.path.abspath("./build_dir/src") if not SYSTEM_LIBSSH2 else "/usr/local/lib"
-include_dirs = ["libssh2/include"] if ON_WINDOWS or not SYSTEM_LIBSSH2 else ["/usr/local/include"]
+include_dirs = ["libssh2/include"] if ON_WINDOWS or not SYSTEM_LIBSSH2 else [
+    "/usr/local/include",
+    "/opt/local/include",
+]
 
 extensions = [
     Extension(sources[i].split('.')[0].replace(os.path.sep, '.'),
@@ -116,11 +119,11 @@
         'Programming Language :: C',
         'Programming Language :: Python',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
         'Topic :: System :: Shells',
         'Topic :: System :: Networking',
         'Topic :: Software Development :: Libraries',
diff --git a/ssh2/__init__.py b/ssh2/__init__.py
index e44e9d15..5080f41c 100644
--- a/ssh2/__init__.py
+++ b/ssh2/__init__.py
@@ -1,3 +1,3 @@
-from ._version import get_versions
-__version__ = get_versions()['version']
-del get_versions
+from . import _version
+__version__ = _version.get_versions()['version']
+del _version
diff --git a/ssh2/_version.py b/ssh2/_version.py
index 1c3945e4..7d0c0b3c 100644
--- a/ssh2/_version.py
+++ b/ssh2/_version.py
@@ -5,8 +5,9 @@
 # directories (produced by setup.py build) will contain a much shorter file
 # that just contains the computed version number.
 
-# This file is released into the public domain. Generated by
-# versioneer-0.18 (https://github.com/warner/python-versioneer)
+# This file is released into the public domain.
+# Generated by versioneer-0.29
+# https://github.com/python-versioneer/python-versioneer
 
 """Git implementation of _version.py."""
 
@@ -15,9 +16,11 @@
 import re
 import subprocess
 import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple
+import functools
 
 
-def get_keywords():
+def get_keywords() -> Dict[str, str]:
     """Get the keywords needed to look up the version information."""
     # these strings will be replaced by git during git-archive.
     # setup.py/versioneer.py will grep for the variable names, so they must
@@ -33,8 +36,15 @@ def get_keywords():
 class VersioneerConfig:
     """Container for Versioneer configuration parameters."""
 
+    VCS: str
+    style: str
+    tag_prefix: str
+    parentdir_prefix: str
+    versionfile_source: str
+    verbose: bool
 
-def get_config():
+
+def get_config() -> VersioneerConfig:
     """Create, populate and return the VersioneerConfig() object."""
     # these strings are filled in when 'setup.py versioneer' creates
     # _version.py
@@ -52,13 +62,13 @@ class NotThisMethod(Exception):
     """Exception raised if a method is not valid for the current scenario."""
 
 
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
-def register_vcs_handler(vcs, method):  # decorator
-    """Decorator to mark a method as the handler for a particular VCS."""
-    def decorate(f):
+def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
+    """Create decorator to mark a method as the handler of a VCS."""
+    def decorate(f: Callable) -> Callable:
         """Store f in HANDLERS[vcs][method]."""
         if vcs not in HANDLERS:
             HANDLERS[vcs] = {}
@@ -67,22 +77,35 @@ def decorate(f):
     return decorate
 
 
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
-                env=None):
+def run_command(
+    commands: List[str],
+    args: List[str],
+    cwd: Optional[str] = None,
+    verbose: bool = False,
+    hide_stderr: bool = False,
+    env: Optional[Dict[str, str]] = None,
+) -> Tuple[Optional[str], Optional[int]]:
     """Call the given command(s)."""
     assert isinstance(commands, list)
-    p = None
-    for c in commands:
+    process = None
+
+    popen_kwargs: Dict[str, Any] = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
+    for command in commands:
         try:
-            dispcmd = str([c] + args)
+            dispcmd = str([command] + args)
             # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env,
+                                       stdout=subprocess.PIPE,
+                                       stderr=(subprocess.PIPE if hide_stderr
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
@@ -93,18 +116,20 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
         if verbose:
             print("unable to find command, tried %s" % (commands,))
         return None, None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
-    if p.returncode != 0:
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
         if verbose:
             print("unable to run %s (error)" % dispcmd)
             print("stdout was %s" % stdout)
-        return None, p.returncode
-    return stdout, p.returncode
+        return None, process.returncode
+    return stdout, process.returncode
 
 
-def versions_from_parentdir(parentdir_prefix, root, verbose):
+def versions_from_parentdir(
+    parentdir_prefix: str,
+    root: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Try to determine the version from the parent directory name.
 
     Source tarballs conventionally unpack into a directory that includes both
@@ -113,15 +138,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     """
     rootdirs = []
 
-    for i in range(3):
+    for _ in range(3):
         dirname = os.path.basename(root)
         if dirname.startswith(parentdir_prefix):
             return {"version": dirname[len(parentdir_prefix):],
                     "full-revisionid": None,
                     "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
+        rootdirs.append(root)
+        root = os.path.dirname(root)  # up a level
 
     if verbose:
         print("Tried directories %s but none started with prefix %s" %
@@ -130,41 +154,48 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 @register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
+def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
     """Extract version information from the given file."""
     # the code embedded in _version.py can just fetch the value of these
     # keywords. When used from setup.py, we don't want to import _version.py,
     # so we do it with a regexp instead. This function is not used from
     # _version.py.
-    keywords = {}
+    keywords: Dict[str, str] = {}
     try:
-        f = open(versionfile_abs, "r")
-        for line in f.readlines():
-            if line.strip().startswith("git_refnames ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["refnames"] = mo.group(1)
-            if line.strip().startswith("git_full ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["full"] = mo.group(1)
-            if line.strip().startswith("git_date ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["date"] = mo.group(1)
-        f.close()
-    except EnvironmentError:
+        with open(versionfile_abs, "r") as fobj:
+            for line in fobj:
+                if line.strip().startswith("git_refnames ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["refnames"] = mo.group(1)
+                if line.strip().startswith("git_full ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["full"] = mo.group(1)
+                if line.strip().startswith("git_date ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["date"] = mo.group(1)
+    except OSError:
         pass
     return keywords
 
 
 @register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
+def git_versions_from_keywords(
+    keywords: Dict[str, str],
+    tag_prefix: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
+    if "refnames" not in keywords:
+        raise NotThisMethod("Short version file found")
     date = keywords.get("date")
     if date is not None:
+        # Use only the last line.  Previous lines may contain GPG signature
+        # information.
+        date = date.splitlines()[-1]
+
         # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
         # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
         # -like" string, which we must then edit to make compliant), because
@@ -177,11 +208,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         if verbose:
             print("keywords are unexpanded, not using")
         raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    refs = {r.strip() for r in refnames.strip("()").split(",")}
     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
     TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
     if not tags:
         # Either we're using git < 1.8.3, or there really are no tags. We use
         # a heuristic: assume all version tags have a digit. The old git %d
@@ -190,7 +221,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
         # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
+        tags = {r for r in refs if re.search(r'\d', r)}
         if verbose:
             print("discarding '%s', no digits" % ",".join(refs - tags))
     if verbose:
@@ -199,6 +230,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix):]
+            # Filter out refs that exactly match prefix or that don't start
+            # with a number once the prefix is stripped (mostly a concern
+            # when prefix is '')
+            if not re.match(r'\d', r):
+                continue
             if verbose:
                 print("picking %s" % r)
             return {"version": r,
@@ -214,7 +250,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+def git_pieces_from_vcs(
+    tag_prefix: str,
+    root: str,
+    verbose: bool,
+    runner: Callable = run_command
+) -> Dict[str, Any]:
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -225,8 +266,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %s not under git control" % root)
@@ -234,24 +282,57 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
-                                          "--always", "--long",
-                                          "--match", "%s*" % tag_prefix],
-                                   cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
     describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root)
     if full_out is None:
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
 
-    pieces = {}
+    pieces: Dict[str, Any] = {}
     pieces["long"] = full_out
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
 
+    branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"],
+                             cwd=root)
+    # --abbrev-ref was added in git-1.6.3
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+
+    if branch_name == "HEAD":
+        # If we aren't exactly on a branch, pick a branch which represents
+        # the current commit. If all else fails, we are on a branchless
+        # commit.
+        branches, rc = runner(GITS, ["branch", "--contains"], cwd=root)
+        # --contains was added in git-1.5.4
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split("\n")
+
+        # Remove the first line if we're running detached
+        if "(" in branches[0]:
+            branches.pop(0)
+
+        # Strip off the leading "* " from the list of branches.
+        branches = [branch[2:] for branch in branches]
+        if "master" in branches:
+            branch_name = "master"
+        elif not branches:
+            branch_name = None
+        else:
+            # Pick the first branch that is returned. Good or bad.
+            branch_name = branches[0]
+
+    pieces["branch"] = branch_name
+
     # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
     # TAG might have hyphens.
     git_describe = describe_out
@@ -268,7 +349,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%s'"
                                % describe_out)
             return pieces
@@ -293,26 +374,27 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
-                       cwd=root)[0].strip()
+    date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip()
+    # Use only the last line.  Previous lines may contain GPG signature
+    # information.
+    date = date.splitlines()[-1]
     pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
 
     return pieces
 
 
-def plus_or_dot(pieces):
+def plus_or_dot(pieces: Dict[str, Any]) -> str:
     """Return a + if we don't already have one, else return a ."""
     if "+" in pieces.get("closest-tag", ""):
         return "."
     return "+"
 
 
-def render_pep440(pieces):
+def render_pep440(pieces: Dict[str, Any]) -> str:
     """Build up version string, with post-release "local version identifier".
 
     Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
@@ -337,23 +419,71 @@ def render_pep440(pieces):
     return rendered
 
 
-def render_pep440_pre(pieces):
-    """TAG[.post.devDISTANCE] -- No -dirty.
+def render_pep440_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
+
+    The ".dev0" means not master branch. Note that .dev0 sorts backwards
+    (a feature branch will appear "older" than the master branch).
 
     Exceptions:
-    1: no tags. 0.post.devDISTANCE
+    1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty]
     """
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0"
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+untagged.%d.g%s" % (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
+def render_pep440_pre(pieces: Dict[str, Any]) -> str:
+    """TAG[.postN.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post0.devDISTANCE
+    """
+    if pieces["closest-tag"]:
         if pieces["distance"]:
-            rendered += ".post.dev%d" % pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%d" % (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
-        rendered = "0.post.dev%d" % pieces["distance"]
+        rendered = "0.post0.dev%d" % pieces["distance"]
     return rendered
 
 
-def render_pep440_post(pieces):
+def render_pep440_post(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX] .
 
     The ".dev0" means dirty. Note that .dev0 sorts backwards
@@ -380,12 +510,41 @@ def render_pep440_post(pieces):
     return rendered
 
 
-def render_pep440_old(pieces):
+def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
+
+    The ".dev0" means not master branch.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%s" % pieces["short"]
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+g%s" % pieces["short"]
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_old(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]] .
 
     The ".dev0" means dirty.
 
-    Eexceptions:
+    Exceptions:
     1: no tags. 0.postDISTANCE[.dev0]
     """
     if pieces["closest-tag"]:
@@ -402,7 +561,7 @@ def render_pep440_old(pieces):
     return rendered
 
 
-def render_git_describe(pieces):
+def render_git_describe(pieces: Dict[str, Any]) -> str:
     """TAG[-DISTANCE-gHEX][-dirty].
 
     Like 'git describe --tags --dirty --always'.
@@ -422,7 +581,7 @@ def render_git_describe(pieces):
     return rendered
 
 
-def render_git_describe_long(pieces):
+def render_git_describe_long(pieces: Dict[str, Any]) -> str:
     """TAG-DISTANCE-gHEX[-dirty].
 
     Like 'git describe --tags --dirty --always -long'.
@@ -442,7 +601,7 @@ def render_git_describe_long(pieces):
     return rendered
 
 
-def render(pieces, style):
+def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
     """Render the given version pieces into the requested style."""
     if pieces["error"]:
         return {"version": "unknown",
@@ -456,10 +615,14 @@ def render(pieces, style):
 
     if style == "pep440":
         rendered = render_pep440(pieces)
+    elif style == "pep440-branch":
+        rendered = render_pep440_branch(pieces)
     elif style == "pep440-pre":
         rendered = render_pep440_pre(pieces)
     elif style == "pep440-post":
         rendered = render_pep440_post(pieces)
+    elif style == "pep440-post-branch":
+        rendered = render_pep440_post_branch(pieces)
     elif style == "pep440-old":
         rendered = render_pep440_old(pieces)
     elif style == "git-describe":
@@ -474,7 +637,7 @@ def render(pieces, style):
             "date": pieces.get("date")}
 
 
-def get_versions():
+def get_versions() -> Dict[str, Any]:
     """Get version information or return default if unable to do so."""
     # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
     # __file__, we can work backwards from there to the root. Some
@@ -495,7 +658,7 @@ def get_versions():
         # versionfile_source is the relative path from the top of the source
         # tree (where the .git directory might live) to this file. Invert
         # this to find the root from __file__.
-        for i in cfg.versionfile_source.split('/'):
+        for _ in cfg.versionfile_source.split('/'):
             root = os.path.dirname(root)
     except NameError:
         return {"version": "0+unknown", "full-revisionid": None,
diff --git a/ssh2/agent.c b/ssh2/agent.c
index c483d66c..6f7c64c8 100644
--- a/ssh2/agent.c
+++ b/ssh2/agent.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.agent",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/agent.pyx"
+        ]
+    },
+    "module_name": "ssh2.agent"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -794,9 +1303,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -814,9 +1324,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -824,13 +1334,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -854,12 +1358,58 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
     PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
@@ -876,7 +1426,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -906,6 +1456,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -941,25 +1492,23 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "stringsource",
+  "<stringsource>",
   "ssh2/agent.pyx",
   "ssh2/session.pxd",
   "ssh2/pkey.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
 /* ForceInitThreads.proto */
 #ifndef __PYX_FORCE_INIT_THREADS
   #define __PYX_FORCE_INIT_THREADS 0
@@ -972,6 +1521,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -980,7 +1532,7 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey;
 struct __pyx_obj_4ssh2_5agent_Agent;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1032,6 +1584,7 @@ struct __pyx_obj_4ssh2_5agent_Agent {
   struct __pyx_obj_4ssh2_7session_Session *_session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1040,11 +1593,11 @@ struct __pyx_obj_4ssh2_5agent_Agent {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1054,28 +1607,40 @@ struct __pyx_obj_4ssh2_5agent_Agent {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1086,6 +1651,10 @@ struct __pyx_obj_4ssh2_5agent_Agent {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1097,6 +1666,57 @@ struct __pyx_obj_4ssh2_5agent_Agent {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1104,9 +1724,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
+/* ErrOccurredWithGIL.proto */
+static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void);
+
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1135,18 +1761,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* GetModuleGlobalName.proto */
 #if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
     static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
     (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1154,42 +1780,39 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
-
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
+#endif
+#endif
 #endif
 
 /* PyObjectCall.proto */
@@ -1199,62 +1822,89 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
 /* PyObjectCallMethO.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
 
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+/* TupleAndListFromArray.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
 #else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
 #endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
 #else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
 #endif
 
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
 /* RaiseDoubleKeywords.proto */
 static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
 
 /* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
     const char* function_name);
 
 /* RaiseArgTupleInvalid.proto */
@@ -1263,10 +1913,18 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
 
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
+/* WriteUnraisableException.proto */
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* ListAppend.proto */
 #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
 static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
@@ -1274,7 +1932,11 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
+        #endif
         __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
@@ -1284,6 +1946,34 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
 #define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
 #endif
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1298,29 +1988,28 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
 #endif
 
 /* Import.proto */
@@ -1329,6 +2018,146 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 /* ImportFrom.proto */
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
 
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1337,6 +2166,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1350,19 +2180,33 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1375,79 +2219,126 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.pkey' */
-static PyTypeObject *__pyx_ptype_4ssh2_4pkey_PublicKey = 0;
+/* Module declarations from "ssh2.session" */
+
+/* Module declarations from "ssh2.pkey" */
 static PyObject *(*__pyx_f_4ssh2_4pkey_PyPublicKey)(struct libssh2_agent_publickey *); /*proto*/
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 
-/* Module declarations from 'ssh2.agent' */
-static PyTypeObject *__pyx_ptype_4ssh2_5agent_Agent = 0;
+/* Module declarations from "ssh2.agent" */
 static int __pyx_f_4ssh2_5agent_auth_identity(char const *, LIBSSH2_AGENT *, struct libssh2_agent_publickey **, struct libssh2_agent_publickey *); /*proto*/
 static void __pyx_f_4ssh2_5agent_clear_agent(LIBSSH2_AGENT *); /*proto*/
 static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_agent_init(LIBSSH2_SESSION *); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.agent"
 extern int __pyx_module_is_main_ssh2__agent;
 int __pyx_module_is_main_ssh2__agent = 0;
 
-/* Implementation of 'ssh2.agent' */
+/* Implementation of "ssh2.agent" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = ".";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__18[] = "?";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_path[] = "path";
 static const char __pyx_k_pkey[] = "pkey";
+static const char __pyx_k_prev[] = "prev";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_Agent[] = "Agent";
+static const char __pyx_k_b_path[] = "b_path";
+static const char __pyx_k_c_path[] = "c_path";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_path_2[] = "_path";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_connect[] = "connect";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_session[] = "session";
 static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_identity[] = "identity";
 static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_userauth[] = "userauth";
 static const char __pyx_k_username[] = "username";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_AgentError[] = "AgentError";
+static const char __pyx_k_b_username[] = "b_username";
+static const char __pyx_k_disconnect[] = "disconnect";
 static const char __pyx_k_exceptions[] = "exceptions";
+static const char __pyx_k_identities[] = "identities";
+static const char __pyx_k_ssh2_agent[] = "ssh2.agent";
+static const char __pyx_k_username_2[] = "_username";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
+static const char __pyx_k_Agent_connect[] = "Agent.connect";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_Agent_userauth[] = "Agent.userauth";
+static const char __pyx_k_get_identities[] = "get_identities";
+static const char __pyx_k_ssh2_agent_pyx[] = "ssh2/agent.pyx";
+static const char __pyx_k_list_identities[] = "list_identities";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_Agent_disconnect[] = "Agent.disconnect";
+static const char __pyx_k_get_identity_path[] = "get_identity_path";
+static const char __pyx_k_set_identity_path[] = "set_identity_path";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
 static const char __pyx_k_AgentConnectionError[] = "AgentConnectionError";
+static const char __pyx_k_Agent_get_identities[] = "Agent.get_identities";
 static const char __pyx_k_AgentGetIdentityError[] = "AgentGetIdentityError";
+static const char __pyx_k_Agent___reduce_cython[] = "Agent.__reduce_cython__";
+static const char __pyx_k_Agent_list_identities[] = "Agent.list_identities";
+static const char __pyx_k_Agent___setstate_cython[] = "Agent.__setstate_cython__";
+static const char __pyx_k_Agent_get_identity_path[] = "Agent.get_identity_path";
+static const char __pyx_k_Agent_set_identity_path[] = "Agent.set_identity_path";
 static const char __pyx_k_AgentAuthenticationError[] = "AgentAuthenticationError";
 static const char __pyx_k_AgentListIdentitiesError[] = "AgentListIdentitiesError";
 static const char __pyx_k_Error_initialising_agent[] = "Error initialising agent";
@@ -1458,36 +2349,7 @@ static const char __pyx_k_Failure_getting_identity_for_use[] = "Failure getting
 static const char __pyx_k_Failure_requesting_identities_fr[] = "Failure requesting identities from agent";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
 static const char __pyx_k_Failure_requesting_identities_fr_2[] = "Failure requesting identities from agent.Agent must be connected first";
-static PyObject *__pyx_n_s_Agent;
-static PyObject *__pyx_n_s_AgentAuthenticationError;
-static PyObject *__pyx_n_s_AgentConnectionError;
-static PyObject *__pyx_n_s_AgentError;
-static PyObject *__pyx_n_s_AgentGetIdentityError;
-static PyObject *__pyx_n_s_AgentListIdentitiesError;
-static PyObject *__pyx_kp_s_Error_authenticating_user_s_with;
-static PyObject *__pyx_kp_s_Error_initialising_agent;
-static PyObject *__pyx_kp_s_Failure_getting_identity_for_use;
-static PyObject *__pyx_kp_s_Failure_requesting_identities_fr;
-static PyObject *__pyx_kp_s_Failure_requesting_identities_fr_2;
-static PyObject *__pyx_kp_s_No_identities_match_for_user_s;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_kp_s_Unable_to_connect_to_agent;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_exceptions;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_pkey;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_username;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_5agent_5Agent___cinit__(struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session); /* proto */
 static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_4list_identities(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self); /* proto */
@@ -1500,15 +2362,526 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(struct __pyx_o
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_5agent_Agent(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4pkey_PublicKey;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_5agent_Agent;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_5agent_Agent;
+  PyObject *__pyx_kp_u_;
+  PyObject *__pyx_n_s_Agent;
+  PyObject *__pyx_n_s_AgentAuthenticationError;
+  PyObject *__pyx_n_s_AgentConnectionError;
+  PyObject *__pyx_n_s_AgentError;
+  PyObject *__pyx_n_s_AgentGetIdentityError;
+  PyObject *__pyx_n_s_AgentListIdentitiesError;
+  PyObject *__pyx_n_s_Agent___reduce_cython;
+  PyObject *__pyx_n_s_Agent___setstate_cython;
+  PyObject *__pyx_n_s_Agent_connect;
+  PyObject *__pyx_n_s_Agent_disconnect;
+  PyObject *__pyx_n_s_Agent_get_identities;
+  PyObject *__pyx_n_s_Agent_get_identity_path;
+  PyObject *__pyx_n_s_Agent_list_identities;
+  PyObject *__pyx_n_s_Agent_set_identity_path;
+  PyObject *__pyx_n_s_Agent_userauth;
+  PyObject *__pyx_kp_u_Error_authenticating_user_s_with;
+  PyObject *__pyx_kp_u_Error_initialising_agent;
+  PyObject *__pyx_kp_u_Failure_getting_identity_for_use;
+  PyObject *__pyx_kp_u_Failure_requesting_identities_fr;
+  PyObject *__pyx_kp_u_Failure_requesting_identities_fr_2;
+  PyObject *__pyx_kp_u_No_identities_match_for_user_s;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_kp_u_Unable_to_connect_to_agent;
+  PyObject *__pyx_n_s__18;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_b_path;
+  PyObject *__pyx_n_s_b_username;
+  PyObject *__pyx_n_s_c_path;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_connect;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_n_s_disconnect;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_exceptions;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_get_identities;
+  PyObject *__pyx_n_s_get_identity_path;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_identities;
+  PyObject *__pyx_n_s_identity;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_list_identities;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_path;
+  PyObject *__pyx_n_s_path_2;
+  PyObject *__pyx_n_s_pkey;
+  PyObject *__pyx_n_s_prev;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_set_identity_path;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_agent;
+  PyObject *__pyx_kp_s_ssh2_agent_pyx;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_userauth;
+  PyObject *__pyx_n_s_username;
+  PyObject *__pyx_n_s_username_2;
+  PyObject *__pyx_tuple__2;
+  PyObject *__pyx_tuple__4;
+  PyObject *__pyx_tuple__6;
+  PyObject *__pyx_tuple__8;
+  PyObject *__pyx_tuple__11;
+  PyObject *__pyx_tuple__13;
+  PyObject *__pyx_tuple__16;
+  PyObject *__pyx_codeobj__3;
+  PyObject *__pyx_codeobj__5;
+  PyObject *__pyx_codeobj__7;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__10;
+  PyObject *__pyx_codeobj__12;
+  PyObject *__pyx_codeobj__14;
+  PyObject *__pyx_codeobj__15;
+  PyObject *__pyx_codeobj__17;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4pkey_PublicKey);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_5agent_Agent);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_5agent_Agent);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentAuthenticationError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentConnectionError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentGetIdentityError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentListIdentitiesError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_connect);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_disconnect);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_get_identities);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_get_identity_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_list_identities);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_set_identity_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Agent_userauth);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_authenticating_user_s_with);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_initialising_agent);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Failure_getting_identity_for_use);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Failure_requesting_identities_fr);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Failure_requesting_identities_fr_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_No_identities_match_for_user_s);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Unable_to_connect_to_agent);
+  Py_CLEAR(clear_module_state->__pyx_n_s__18);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_username);
+  Py_CLEAR(clear_module_state->__pyx_n_s_c_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_connect);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_disconnect);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_identities);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_identity_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_identities);
+  Py_CLEAR(clear_module_state->__pyx_n_s_identity);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_list_identities);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pkey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prev);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_set_identity_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_agent);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_agent_pyx);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth);
+  Py_CLEAR(clear_module_state->__pyx_n_s_username);
+  Py_CLEAR(clear_module_state->__pyx_n_s_username_2);
+  Py_CLEAR(clear_module_state->__pyx_tuple__2);
+  Py_CLEAR(clear_module_state->__pyx_tuple__4);
+  Py_CLEAR(clear_module_state->__pyx_tuple__6);
+  Py_CLEAR(clear_module_state->__pyx_tuple__8);
+  Py_CLEAR(clear_module_state->__pyx_tuple__11);
+  Py_CLEAR(clear_module_state->__pyx_tuple__13);
+  Py_CLEAR(clear_module_state->__pyx_tuple__16);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__5);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__7);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__10);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__12);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__14);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__15);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__17);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4pkey_PublicKey);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_5agent_Agent);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_5agent_Agent);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentAuthenticationError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentConnectionError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentGetIdentityError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentListIdentitiesError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_connect);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_disconnect);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_get_identities);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_get_identity_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_list_identities);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_set_identity_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Agent_userauth);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_authenticating_user_s_with);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_initialising_agent);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Failure_getting_identity_for_use);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Failure_requesting_identities_fr);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Failure_requesting_identities_fr_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_No_identities_match_for_user_s);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Unable_to_connect_to_agent);
+  Py_VISIT(traverse_module_state->__pyx_n_s__18);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_username);
+  Py_VISIT(traverse_module_state->__pyx_n_s_c_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_connect);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_disconnect);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_identities);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_identity_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_identities);
+  Py_VISIT(traverse_module_state->__pyx_n_s_identity);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_list_identities);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pkey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prev);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_set_identity_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_agent);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_agent_pyx);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth);
+  Py_VISIT(traverse_module_state->__pyx_n_s_username);
+  Py_VISIT(traverse_module_state->__pyx_n_s_username_2);
+  Py_VISIT(traverse_module_state->__pyx_tuple__2);
+  Py_VISIT(traverse_module_state->__pyx_tuple__4);
+  Py_VISIT(traverse_module_state->__pyx_tuple__6);
+  Py_VISIT(traverse_module_state->__pyx_tuple__8);
+  Py_VISIT(traverse_module_state->__pyx_tuple__11);
+  Py_VISIT(traverse_module_state->__pyx_tuple__13);
+  Py_VISIT(traverse_module_state->__pyx_tuple__16);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__5);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__7);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__10);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__12);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__14);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__15);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__17);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_4pkey_PublicKey __pyx_mstate_global->__pyx_ptype_4ssh2_4pkey_PublicKey
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_5agent_Agent __pyx_mstate_global->__pyx_type_4ssh2_5agent_Agent
+#endif
+#define __pyx_ptype_4ssh2_5agent_Agent __pyx_mstate_global->__pyx_ptype_4ssh2_5agent_Agent
+#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
+#define __pyx_n_s_Agent __pyx_mstate_global->__pyx_n_s_Agent
+#define __pyx_n_s_AgentAuthenticationError __pyx_mstate_global->__pyx_n_s_AgentAuthenticationError
+#define __pyx_n_s_AgentConnectionError __pyx_mstate_global->__pyx_n_s_AgentConnectionError
+#define __pyx_n_s_AgentError __pyx_mstate_global->__pyx_n_s_AgentError
+#define __pyx_n_s_AgentGetIdentityError __pyx_mstate_global->__pyx_n_s_AgentGetIdentityError
+#define __pyx_n_s_AgentListIdentitiesError __pyx_mstate_global->__pyx_n_s_AgentListIdentitiesError
+#define __pyx_n_s_Agent___reduce_cython __pyx_mstate_global->__pyx_n_s_Agent___reduce_cython
+#define __pyx_n_s_Agent___setstate_cython __pyx_mstate_global->__pyx_n_s_Agent___setstate_cython
+#define __pyx_n_s_Agent_connect __pyx_mstate_global->__pyx_n_s_Agent_connect
+#define __pyx_n_s_Agent_disconnect __pyx_mstate_global->__pyx_n_s_Agent_disconnect
+#define __pyx_n_s_Agent_get_identities __pyx_mstate_global->__pyx_n_s_Agent_get_identities
+#define __pyx_n_s_Agent_get_identity_path __pyx_mstate_global->__pyx_n_s_Agent_get_identity_path
+#define __pyx_n_s_Agent_list_identities __pyx_mstate_global->__pyx_n_s_Agent_list_identities
+#define __pyx_n_s_Agent_set_identity_path __pyx_mstate_global->__pyx_n_s_Agent_set_identity_path
+#define __pyx_n_s_Agent_userauth __pyx_mstate_global->__pyx_n_s_Agent_userauth
+#define __pyx_kp_u_Error_authenticating_user_s_with __pyx_mstate_global->__pyx_kp_u_Error_authenticating_user_s_with
+#define __pyx_kp_u_Error_initialising_agent __pyx_mstate_global->__pyx_kp_u_Error_initialising_agent
+#define __pyx_kp_u_Failure_getting_identity_for_use __pyx_mstate_global->__pyx_kp_u_Failure_getting_identity_for_use
+#define __pyx_kp_u_Failure_requesting_identities_fr __pyx_mstate_global->__pyx_kp_u_Failure_requesting_identities_fr
+#define __pyx_kp_u_Failure_requesting_identities_fr_2 __pyx_mstate_global->__pyx_kp_u_Failure_requesting_identities_fr_2
+#define __pyx_kp_u_No_identities_match_for_user_s __pyx_mstate_global->__pyx_kp_u_No_identities_match_for_user_s
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_u_Unable_to_connect_to_agent __pyx_mstate_global->__pyx_kp_u_Unable_to_connect_to_agent
+#define __pyx_n_s__18 __pyx_mstate_global->__pyx_n_s__18
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_b_path __pyx_mstate_global->__pyx_n_s_b_path
+#define __pyx_n_s_b_username __pyx_mstate_global->__pyx_n_s_b_username
+#define __pyx_n_s_c_path __pyx_mstate_global->__pyx_n_s_c_path
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_connect __pyx_mstate_global->__pyx_n_s_connect
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_n_s_disconnect __pyx_mstate_global->__pyx_n_s_disconnect
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_get_identities __pyx_mstate_global->__pyx_n_s_get_identities
+#define __pyx_n_s_get_identity_path __pyx_mstate_global->__pyx_n_s_get_identity_path
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_identities __pyx_mstate_global->__pyx_n_s_identities
+#define __pyx_n_s_identity __pyx_mstate_global->__pyx_n_s_identity
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_list_identities __pyx_mstate_global->__pyx_n_s_list_identities
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_path __pyx_mstate_global->__pyx_n_s_path
+#define __pyx_n_s_path_2 __pyx_mstate_global->__pyx_n_s_path_2
+#define __pyx_n_s_pkey __pyx_mstate_global->__pyx_n_s_pkey
+#define __pyx_n_s_prev __pyx_mstate_global->__pyx_n_s_prev
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_set_identity_path __pyx_mstate_global->__pyx_n_s_set_identity_path
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_agent __pyx_mstate_global->__pyx_n_s_ssh2_agent
+#define __pyx_kp_s_ssh2_agent_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_agent_pyx
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_userauth __pyx_mstate_global->__pyx_n_s_userauth
+#define __pyx_n_s_username __pyx_mstate_global->__pyx_n_s_username
+#define __pyx_n_s_username_2 __pyx_mstate_global->__pyx_n_s_username_2
+#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2
+#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4
+#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6
+#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3
+#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5
+#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10
+#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12
+#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14
+#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15
+#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17
+/* #### Code section: module_code ### */
 
 /* "ssh2/agent.pyx":26
  * 
  * 
  * cdef int agent_auth(char * _username,             # <<<<<<<<<<<<<<
- *                     c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
+ *                     c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil:
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  */
 
@@ -1521,8 +2894,8 @@ static int __pyx_f_4ssh2_5agent_agent_auth(char *__pyx_v__username, LIBSSH2_AGEN
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
-  int __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
+  unsigned int __pyx_t_5;
+  int __pyx_t_6;
   PyObject *__pyx_t_7 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
@@ -1534,352 +2907,312 @@ static int __pyx_f_4ssh2_5agent_agent_auth(char *__pyx_v__username, LIBSSH2_AGEN
 
   /* "ssh2/agent.pyx":28
  * cdef int agent_auth(char * _username,
- *                     c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
+ *                     c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil:
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
  */
-  /*try:*/ {
-    __pyx_v_identity = NULL;
+  __pyx_v_identity = NULL;
 
-    /* "ssh2/agent.pyx":29
- *                     c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
+  /* "ssh2/agent.pyx":29
+ *                     c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil:
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL             # <<<<<<<<<<<<<<
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
  *         clear_agent(agent)
  */
-    __pyx_v_prev = NULL;
+  __pyx_v_prev = NULL;
 
-    /* "ssh2/agent.pyx":30
+  /* "ssh2/agent.pyx":30
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *         with gil:
  */
-    __pyx_t_1 = ((libssh2_agent_list_identities(__pyx_v_agent) != 0) != 0);
-    if (__pyx_t_1) {
+  __pyx_t_1 = (libssh2_agent_list_identities(__pyx_v_agent) != 0);
+  if (unlikely(__pyx_t_1)) {
 
-      /* "ssh2/agent.pyx":31
+    /* "ssh2/agent.pyx":31
  *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
  *         clear_agent(agent)             # <<<<<<<<<<<<<<
  *         with gil:
  *             raise AgentListIdentitiesError(
  */
-      __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent);
+    __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(1, 31, __pyx_L1_error)
 
-      /* "ssh2/agent.pyx":32
+    /* "ssh2/agent.pyx":32
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
  *         clear_agent(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentListIdentitiesError(
  *                 "Failure requesting identities from agent")
  */
-      {
-          #ifdef WITH_THREAD
-          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-          #endif
-          /*try:*/ {
+    {
+        #ifdef WITH_THREAD
+        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+        #endif
+        /*try:*/ {
 
-            /* "ssh2/agent.pyx":33
+          /* "ssh2/agent.pyx":33
  *         clear_agent(agent)
  *         with gil:
  *             raise AgentListIdentitiesError(             # <<<<<<<<<<<<<<
  *                 "Failure requesting identities from agent")
  *     while 1:
  */
-            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentListIdentitiesError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 33, __pyx_L8_error)
-            __Pyx_GOTREF(__pyx_t_3);
-            __pyx_t_4 = NULL;
-            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
-              if (likely(__pyx_t_4)) {
-                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-                __Pyx_INCREF(__pyx_t_4);
-                __Pyx_INCREF(function);
-                __Pyx_DECREF_SET(__pyx_t_3, function);
-              }
+          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentListIdentitiesError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 33, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_4 = NULL;
+          __pyx_t_5 = 0;
+          #if CYTHON_UNPACK_METHODS
+          if (unlikely(PyMethod_Check(__pyx_t_3))) {
+            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+            if (likely(__pyx_t_4)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+              __Pyx_INCREF(__pyx_t_4);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_3, function);
+              __pyx_t_5 = 1;
             }
-            __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Failure_requesting_identities_fr) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Failure_requesting_identities_fr);
+          }
+          #endif
+          {
+            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Failure_requesting_identities_fr};
+            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
             __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 33, __pyx_L8_error)
+            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 33, __pyx_L5_error)
             __Pyx_GOTREF(__pyx_t_2);
             __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __PYX_ERR(1, 33, __pyx_L8_error)
           }
+          __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __PYX_ERR(1, 33, __pyx_L5_error)
+        }
 
-          /* "ssh2/agent.pyx":32
+        /* "ssh2/agent.pyx":32
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
  *         clear_agent(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentListIdentitiesError(
  *                 "Failure requesting identities from agent")
  */
-          /*finally:*/ {
-            __pyx_L8_error: {
-              #ifdef WITH_THREAD
-              __Pyx_PyGILState_Release(__pyx_gilstate_save);
-              #endif
-              goto __pyx_L4_error;
-            }
+        /*finally:*/ {
+          __pyx_L5_error: {
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L1_error;
           }
-      }
+        }
+    }
 
-      /* "ssh2/agent.pyx":30
+    /* "ssh2/agent.pyx":30
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *         with gil:
  */
-    }
+  }
 
-    /* "ssh2/agent.pyx":35
+  /* "ssh2/agent.pyx":35
  *             raise AgentListIdentitiesError(
  *                 "Failure requesting identities from agent")
  *     while 1:             # <<<<<<<<<<<<<<
  *         if auth_identity(_username, agent, &identity, prev) == 1:
  *             with gil:
  */
-    while (1) {
+  while (1) {
 
-      /* "ssh2/agent.pyx":36
+    /* "ssh2/agent.pyx":36
  *                 "Failure requesting identities from agent")
  *     while 1:
  *         if auth_identity(_username, agent, &identity, prev) == 1:             # <<<<<<<<<<<<<<
  *             with gil:
  *                 raise AgentAuthenticationError(
  */
-      __pyx_t_5 = __pyx_f_4ssh2_5agent_auth_identity(__pyx_v__username, __pyx_v_agent, (&__pyx_v_identity), __pyx_v_prev); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 36, __pyx_L4_error)
-      __pyx_t_1 = ((__pyx_t_5 == 1) != 0);
-      if (__pyx_t_1) {
+    __pyx_t_6 = __pyx_f_4ssh2_5agent_auth_identity(__pyx_v__username, __pyx_v_agent, (&__pyx_v_identity), __pyx_v_prev); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 36, __pyx_L1_error)
+    __pyx_t_1 = (__pyx_t_6 == 1);
+    if (unlikely(__pyx_t_1)) {
 
-        /* "ssh2/agent.pyx":37
+      /* "ssh2/agent.pyx":37
  *     while 1:
  *         if auth_identity(_username, agent, &identity, prev) == 1:
  *             with gil:             # <<<<<<<<<<<<<<
  *                 raise AgentAuthenticationError(
  *                     "No identities match for user %s",
  */
-        {
-            #ifdef WITH_THREAD
-            PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-            #endif
-            /*try:*/ {
+      {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+          #endif
+          /*try:*/ {
 
-              /* "ssh2/agent.pyx":38
+            /* "ssh2/agent.pyx":38
  *         if auth_identity(_username, agent, &identity, prev) == 1:
  *             with gil:
  *                 raise AgentAuthenticationError(             # <<<<<<<<<<<<<<
  *                     "No identities match for user %s",
  *                     _username)
  */
-              __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentAuthenticationError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 38, __pyx_L16_error)
-              __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentAuthenticationError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 38, __pyx_L13_error)
+            __Pyx_GOTREF(__pyx_t_3);
 
-              /* "ssh2/agent.pyx":40
+            /* "ssh2/agent.pyx":40
  *                 raise AgentAuthenticationError(
  *                     "No identities match for user %s",
  *                     _username)             # <<<<<<<<<<<<<<
  *         if c_ssh2.libssh2_agent_userauth(
  *                 agent, _username, identity) == 0:
  */
-              __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v__username); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 40, __pyx_L16_error)
-              __Pyx_GOTREF(__pyx_t_4);
-              __pyx_t_6 = NULL;
-              __pyx_t_5 = 0;
-              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-                __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
-                if (likely(__pyx_t_6)) {
-                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-                  __Pyx_INCREF(__pyx_t_6);
-                  __Pyx_INCREF(function);
-                  __Pyx_DECREF_SET(__pyx_t_3, function);
-                  __pyx_t_5 = 1;
-                }
-              }
-              #if CYTHON_FAST_PYCALL
-              if (PyFunction_Check(__pyx_t_3)) {
-                PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_s_No_identities_match_for_user_s, __pyx_t_4};
-                __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L16_error)
-                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-                __Pyx_GOTREF(__pyx_t_2);
-                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-              } else
-              #endif
-              #if CYTHON_FAST_PYCCALL
-              if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-                PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_s_No_identities_match_for_user_s, __pyx_t_4};
-                __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L16_error)
-                __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-                __Pyx_GOTREF(__pyx_t_2);
-                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-              } else
-              #endif
-              {
-                __pyx_t_7 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 38, __pyx_L16_error)
-                __Pyx_GOTREF(__pyx_t_7);
-                if (__pyx_t_6) {
-                  __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
-                }
-                __Pyx_INCREF(__pyx_kp_s_No_identities_match_for_user_s);
-                __Pyx_GIVEREF(__pyx_kp_s_No_identities_match_for_user_s);
-                PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_5, __pyx_kp_s_No_identities_match_for_user_s);
-                __Pyx_GIVEREF(__pyx_t_4);
-                PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_5, __pyx_t_4);
-                __pyx_t_4 = 0;
-                __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L16_error)
-                __Pyx_GOTREF(__pyx_t_2);
-                __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+            __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v__username); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 40, __pyx_L13_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_7 = NULL;
+            __pyx_t_5 = 0;
+            #if CYTHON_UNPACK_METHODS
+            if (unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_7)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_7);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+                __pyx_t_5 = 1;
               }
+            }
+            #endif
+            {
+              PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_kp_u_No_identities_match_for_user_s, __pyx_t_4};
+              __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5);
+              __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+              if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L13_error)
+              __Pyx_GOTREF(__pyx_t_2);
               __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-              __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-              __PYX_ERR(1, 38, __pyx_L16_error)
             }
+            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __PYX_ERR(1, 38, __pyx_L13_error)
+          }
 
-            /* "ssh2/agent.pyx":37
+          /* "ssh2/agent.pyx":37
  *     while 1:
  *         if auth_identity(_username, agent, &identity, prev) == 1:
  *             with gil:             # <<<<<<<<<<<<<<
  *                 raise AgentAuthenticationError(
  *                     "No identities match for user %s",
  */
-            /*finally:*/ {
-              __pyx_L16_error: {
-                #ifdef WITH_THREAD
-                __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                #endif
-                goto __pyx_L4_error;
-              }
+          /*finally:*/ {
+            __pyx_L13_error: {
+              #ifdef WITH_THREAD
+              __Pyx_PyGILState_Release(__pyx_gilstate_save);
+              #endif
+              goto __pyx_L1_error;
             }
-        }
+          }
+      }
 
-        /* "ssh2/agent.pyx":36
+      /* "ssh2/agent.pyx":36
  *                 "Failure requesting identities from agent")
  *     while 1:
  *         if auth_identity(_username, agent, &identity, prev) == 1:             # <<<<<<<<<<<<<<
  *             with gil:
  *                 raise AgentAuthenticationError(
  */
-      }
+    }
 
-      /* "ssh2/agent.pyx":42
+    /* "ssh2/agent.pyx":42
  *                     _username)
  *         if c_ssh2.libssh2_agent_userauth(
  *                 agent, _username, identity) == 0:             # <<<<<<<<<<<<<<
  *             clear_agent(agent)
  *             return 0
  */
-      __pyx_t_1 = ((libssh2_agent_userauth(__pyx_v_agent, __pyx_v__username, __pyx_v_identity) == 0) != 0);
+    __pyx_t_1 = (libssh2_agent_userauth(__pyx_v_agent, __pyx_v__username, __pyx_v_identity) == 0);
 
-      /* "ssh2/agent.pyx":41
+    /* "ssh2/agent.pyx":41
  *                     "No identities match for user %s",
  *                     _username)
  *         if c_ssh2.libssh2_agent_userauth(             # <<<<<<<<<<<<<<
  *                 agent, _username, identity) == 0:
  *             clear_agent(agent)
  */
-      if (__pyx_t_1) {
+    if (__pyx_t_1) {
 
-        /* "ssh2/agent.pyx":43
+      /* "ssh2/agent.pyx":43
  *         if c_ssh2.libssh2_agent_userauth(
  *                 agent, _username, identity) == 0:
  *             clear_agent(agent)             # <<<<<<<<<<<<<<
  *             return 0
  *         prev = identity
  */
-        __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent);
+      __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(1, 43, __pyx_L1_error)
 
-        /* "ssh2/agent.pyx":44
+      /* "ssh2/agent.pyx":44
  *                 agent, _username, identity) == 0:
  *             clear_agent(agent)
  *             return 0             # <<<<<<<<<<<<<<
  *         prev = identity
  *     return 1
  */
-        __pyx_r = 0;
-        goto __pyx_L3_return;
+      __pyx_r = 0;
+      goto __pyx_L0;
 
-        /* "ssh2/agent.pyx":41
+      /* "ssh2/agent.pyx":41
  *                     "No identities match for user %s",
  *                     _username)
  *         if c_ssh2.libssh2_agent_userauth(             # <<<<<<<<<<<<<<
  *                 agent, _username, identity) == 0:
  *             clear_agent(agent)
  */
-      }
+    }
 
-      /* "ssh2/agent.pyx":45
+    /* "ssh2/agent.pyx":45
  *             clear_agent(agent)
  *             return 0
  *         prev = identity             # <<<<<<<<<<<<<<
  *     return 1
  * 
  */
-      __pyx_v_prev = __pyx_v_identity;
-    }
+    __pyx_v_prev = __pyx_v_identity;
+  }
 
-    /* "ssh2/agent.pyx":46
+  /* "ssh2/agent.pyx":46
  *             return 0
  *         prev = identity
  *     return 1             # <<<<<<<<<<<<<<
  * 
  * 
  */
-    __pyx_r = 1;
-    goto __pyx_L3_return;
-  }
-
-  /* "ssh2/agent.pyx":28
- * cdef int agent_auth(char * _username,
- *                     c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
- *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL             # <<<<<<<<<<<<<<
- *     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
- *     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
- */
-  /*finally:*/ {
-    __pyx_L3_return: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L0;
-    }
-    __pyx_L4_error: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L1_error;
-    }
-  }
+  __pyx_r = 1;
+  goto __pyx_L0;
 
   /* "ssh2/agent.pyx":26
  * 
  * 
  * cdef int agent_auth(char * _username,             # <<<<<<<<<<<<<<
- *                     c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
+ *                     c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil:
  *     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
   __pyx_L1_error:;
+  #ifdef WITH_THREAD
+  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.agent.agent_auth", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 1;
-  __pyx_L0:;
   #ifdef WITH_THREAD
   __Pyx_PyGILState_Release(__pyx_gilstate_save);
   #endif
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContextNogil()
   return __pyx_r;
 }
 
@@ -1900,8 +3233,7 @@ static int __pyx_f_4ssh2_5agent_auth_identity(char const *__pyx_v_username, LIBS
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -1910,215 +3242,159 @@ static int __pyx_f_4ssh2_5agent_auth_identity(char const *__pyx_v_username, LIBS
   #endif
   __Pyx_RefNannySetupContext("auth_identity", 1);
 
-  /* "ssh2/agent.pyx":53
- *                        c_ssh2.libssh2_agent_publickey **identity,
- *                        c_ssh2.libssh2_agent_publickey *prev) nogil except -1:
- *     cdef int rc             # <<<<<<<<<<<<<<
- *     rc = c_ssh2.libssh2_agent_get_identity(
- *         agent, identity, prev)
- */
-  /*try:*/ {
-
-    /* "ssh2/agent.pyx":54
- *                        c_ssh2.libssh2_agent_publickey *prev) nogil except -1:
+  /* "ssh2/agent.pyx":54
+ *                        c_ssh2.libssh2_agent_publickey *prev) except -1 nogil:
  *     cdef int rc
  *     rc = c_ssh2.libssh2_agent_get_identity(             # <<<<<<<<<<<<<<
  *         agent, identity, prev)
  *     if rc == 1:
  */
-    __pyx_v_rc = libssh2_agent_get_identity(__pyx_v_agent, __pyx_v_identity, __pyx_v_prev);
+  __pyx_v_rc = libssh2_agent_get_identity(__pyx_v_agent, __pyx_v_identity, __pyx_v_prev);
 
-    /* "ssh2/agent.pyx":56
+  /* "ssh2/agent.pyx":56
  *     rc = c_ssh2.libssh2_agent_get_identity(
  *         agent, identity, prev)
  *     if rc == 1:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *     elif rc < 0:
  */
-    __pyx_t_1 = ((__pyx_v_rc == 1) != 0);
-    if (__pyx_t_1) {
+  __pyx_t_1 = (__pyx_v_rc == 1);
+  if (__pyx_t_1) {
 
-      /* "ssh2/agent.pyx":57
+    /* "ssh2/agent.pyx":57
  *         agent, identity, prev)
  *     if rc == 1:
  *         clear_agent(agent)             # <<<<<<<<<<<<<<
  *     elif rc < 0:
  *         clear_agent(agent)
  */
-      __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent);
+    __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(1, 57, __pyx_L1_error)
 
-      /* "ssh2/agent.pyx":56
+    /* "ssh2/agent.pyx":56
  *     rc = c_ssh2.libssh2_agent_get_identity(
  *         agent, identity, prev)
  *     if rc == 1:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *     elif rc < 0:
  */
-      goto __pyx_L6;
-    }
+    goto __pyx_L3;
+  }
 
-    /* "ssh2/agent.pyx":58
+  /* "ssh2/agent.pyx":58
  *     if rc == 1:
  *         clear_agent(agent)
  *     elif rc < 0:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *         with gil:
  */
-    __pyx_t_1 = ((__pyx_v_rc < 0) != 0);
-    if (__pyx_t_1) {
+  __pyx_t_1 = (__pyx_v_rc < 0);
+  if (unlikely(__pyx_t_1)) {
 
-      /* "ssh2/agent.pyx":59
+    /* "ssh2/agent.pyx":59
  *         clear_agent(agent)
  *     elif rc < 0:
  *         clear_agent(agent)             # <<<<<<<<<<<<<<
  *         with gil:
  *             raise AgentGetIdentityError(
  */
-      __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent);
+    __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_agent); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(1, 59, __pyx_L1_error)
 
-      /* "ssh2/agent.pyx":60
+    /* "ssh2/agent.pyx":60
  *     elif rc < 0:
  *         clear_agent(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentGetIdentityError(
  *                 "Failure getting identity for user %s from agent",
  */
-      {
-          #ifdef WITH_THREAD
-          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-          #endif
-          /*try:*/ {
+    {
+        #ifdef WITH_THREAD
+        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+        #endif
+        /*try:*/ {
 
-            /* "ssh2/agent.pyx":61
+          /* "ssh2/agent.pyx":61
  *         clear_agent(agent)
  *         with gil:
  *             raise AgentGetIdentityError(             # <<<<<<<<<<<<<<
  *                 "Failure getting identity for user %s from agent",
  *                 username)
  */
-            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentGetIdentityError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 61, __pyx_L8_error)
-            __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentGetIdentityError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 61, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
 
-            /* "ssh2/agent.pyx":63
+          /* "ssh2/agent.pyx":63
  *             raise AgentGetIdentityError(
  *                 "Failure getting identity for user %s from agent",
  *                 username)             # <<<<<<<<<<<<<<
  *     return rc
  * 
  */
-            __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_username); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 63, __pyx_L8_error)
-            __Pyx_GOTREF(__pyx_t_4);
-            __pyx_t_5 = NULL;
-            __pyx_t_6 = 0;
-            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-              __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-              if (likely(__pyx_t_5)) {
-                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-                __Pyx_INCREF(__pyx_t_5);
-                __Pyx_INCREF(function);
-                __Pyx_DECREF_SET(__pyx_t_3, function);
-                __pyx_t_6 = 1;
-              }
-            }
-            #if CYTHON_FAST_PYCALL
-            if (PyFunction_Check(__pyx_t_3)) {
-              PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Failure_getting_identity_for_use, __pyx_t_4};
-              __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L8_error)
-              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-              __Pyx_GOTREF(__pyx_t_2);
-              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-            } else
-            #endif
-            #if CYTHON_FAST_PYCCALL
-            if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-              PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Failure_getting_identity_for_use, __pyx_t_4};
-              __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L8_error)
-              __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-              __Pyx_GOTREF(__pyx_t_2);
-              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-            } else
-            #endif
-            {
-              __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 61, __pyx_L8_error)
-              __Pyx_GOTREF(__pyx_t_7);
-              if (__pyx_t_5) {
-                __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-              }
-              __Pyx_INCREF(__pyx_kp_s_Failure_getting_identity_for_use);
-              __Pyx_GIVEREF(__pyx_kp_s_Failure_getting_identity_for_use);
-              PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Failure_getting_identity_for_use);
-              __Pyx_GIVEREF(__pyx_t_4);
-              PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
-              __pyx_t_4 = 0;
-              __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L8_error)
-              __Pyx_GOTREF(__pyx_t_2);
-              __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_username); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 63, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __pyx_t_5 = NULL;
+          __pyx_t_6 = 0;
+          #if CYTHON_UNPACK_METHODS
+          if (unlikely(PyMethod_Check(__pyx_t_3))) {
+            __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+            if (likely(__pyx_t_5)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+              __Pyx_INCREF(__pyx_t_5);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_3, function);
+              __pyx_t_6 = 1;
             }
+          }
+          #endif
+          {
+            PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_u_Failure_getting_identity_for_use, __pyx_t_4};
+            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
+            __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L5_error)
+            __Pyx_GOTREF(__pyx_t_2);
             __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __PYX_ERR(1, 61, __pyx_L8_error)
           }
+          __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __PYX_ERR(1, 61, __pyx_L5_error)
+        }
 
-          /* "ssh2/agent.pyx":60
+        /* "ssh2/agent.pyx":60
  *     elif rc < 0:
  *         clear_agent(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentGetIdentityError(
  *                 "Failure getting identity for user %s from agent",
  */
-          /*finally:*/ {
-            __pyx_L8_error: {
-              #ifdef WITH_THREAD
-              __Pyx_PyGILState_Release(__pyx_gilstate_save);
-              #endif
-              goto __pyx_L4_error;
-            }
+        /*finally:*/ {
+          __pyx_L5_error: {
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L1_error;
           }
-      }
+        }
+    }
 
-      /* "ssh2/agent.pyx":58
+    /* "ssh2/agent.pyx":58
  *     if rc == 1:
  *         clear_agent(agent)
  *     elif rc < 0:             # <<<<<<<<<<<<<<
  *         clear_agent(agent)
  *         with gil:
  */
-    }
-    __pyx_L6:;
+  }
+  __pyx_L3:;
 
-    /* "ssh2/agent.pyx":64
+  /* "ssh2/agent.pyx":64
  *                 "Failure getting identity for user %s from agent",
  *                 username)
  *     return rc             # <<<<<<<<<<<<<<
  * 
  * 
  */
-    __pyx_r = __pyx_v_rc;
-    goto __pyx_L3_return;
-  }
-
-  /* "ssh2/agent.pyx":53
- *                        c_ssh2.libssh2_agent_publickey **identity,
- *                        c_ssh2.libssh2_agent_publickey *prev) nogil except -1:
- *     cdef int rc             # <<<<<<<<<<<<<<
- *     rc = c_ssh2.libssh2_agent_get_identity(
- *         agent, identity, prev)
- */
-  /*finally:*/ {
-    __pyx_L3_return: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L0;
-    }
-    __pyx_L4_error: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L1_error;
-    }
-  }
+  __pyx_r = __pyx_v_rc;
+  goto __pyx_L0;
 
   /* "ssh2/agent.pyx":49
  * 
@@ -2129,20 +3405,21 @@ static int __pyx_f_4ssh2_5agent_auth_identity(char const *__pyx_v_username, LIBS
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
   __pyx_L1_error:;
+  #ifdef WITH_THREAD
+  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.agent.auth_identity", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = -1;
-  __pyx_L0:;
   #ifdef WITH_THREAD
   __Pyx_PyGILState_Release(__pyx_gilstate_save);
   #endif
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContextNogil()
   return __pyx_r;
 }
 
@@ -2150,7 +3427,7 @@ static int __pyx_f_4ssh2_5agent_auth_identity(char const *__pyx_v_username, LIBS
  * 
  * 
  * cdef c_ssh2.LIBSSH2_AGENT * agent_init(             # <<<<<<<<<<<<<<
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
  */
 
@@ -2162,6 +3439,7 @@ static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_agent_init(LIBSSH2_SESSION *__pyx_v__
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  unsigned int __pyx_t_5;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2172,154 +3450,131 @@ static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_agent_init(LIBSSH2_SESSION *__pyx_v__
 
   /* "ssh2/agent.pyx":69
  * cdef c_ssh2.LIBSSH2_AGENT * agent_init(
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(             # <<<<<<<<<<<<<<
  *         _session)
  *     if agent is NULL:
  */
-  /*try:*/ {
-
-    /* "ssh2/agent.pyx":70
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
- *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
- *         _session)             # <<<<<<<<<<<<<<
- *     if agent is NULL:
- *         with gil:
- */
-    __pyx_v_agent = libssh2_agent_init(__pyx_v__session);
+  __pyx_v_agent = libssh2_agent_init(__pyx_v__session);
 
-    /* "ssh2/agent.pyx":71
+  /* "ssh2/agent.pyx":71
  *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
  *         _session)
  *     if agent is NULL:             # <<<<<<<<<<<<<<
  *         with gil:
  *             raise AgentError("Error initialising agent")
  */
-    __pyx_t_1 = ((__pyx_v_agent == NULL) != 0);
-    if (__pyx_t_1) {
+  __pyx_t_1 = (__pyx_v_agent == NULL);
+  if (unlikely(__pyx_t_1)) {
 
-      /* "ssh2/agent.pyx":72
+    /* "ssh2/agent.pyx":72
  *         _session)
  *     if agent is NULL:
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentError("Error initialising agent")
  *     return agent
  */
-      {
-          #ifdef WITH_THREAD
-          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-          #endif
-          /*try:*/ {
+    {
+        #ifdef WITH_THREAD
+        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+        #endif
+        /*try:*/ {
 
-            /* "ssh2/agent.pyx":73
+          /* "ssh2/agent.pyx":73
  *     if agent is NULL:
  *         with gil:
  *             raise AgentError("Error initialising agent")             # <<<<<<<<<<<<<<
  *     return agent
  * 
  */
-            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 73, __pyx_L8_error)
-            __Pyx_GOTREF(__pyx_t_3);
-            __pyx_t_4 = NULL;
-            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
-              if (likely(__pyx_t_4)) {
-                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-                __Pyx_INCREF(__pyx_t_4);
-                __Pyx_INCREF(function);
-                __Pyx_DECREF_SET(__pyx_t_3, function);
-              }
+          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 73, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_4 = NULL;
+          __pyx_t_5 = 0;
+          #if CYTHON_UNPACK_METHODS
+          if (unlikely(PyMethod_Check(__pyx_t_3))) {
+            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+            if (likely(__pyx_t_4)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+              __Pyx_INCREF(__pyx_t_4);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_3, function);
+              __pyx_t_5 = 1;
             }
-            __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Error_initialising_agent) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Error_initialising_agent);
+          }
+          #endif
+          {
+            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Error_initialising_agent};
+            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
             __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L8_error)
+            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L5_error)
             __Pyx_GOTREF(__pyx_t_2);
             __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __PYX_ERR(1, 73, __pyx_L8_error)
           }
+          __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __PYX_ERR(1, 73, __pyx_L5_error)
+        }
 
-          /* "ssh2/agent.pyx":72
+        /* "ssh2/agent.pyx":72
  *         _session)
  *     if agent is NULL:
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentError("Error initialising agent")
  *     return agent
  */
-          /*finally:*/ {
-            __pyx_L8_error: {
-              #ifdef WITH_THREAD
-              __Pyx_PyGILState_Release(__pyx_gilstate_save);
-              #endif
-              goto __pyx_L4_error;
-            }
+        /*finally:*/ {
+          __pyx_L5_error: {
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L1_error;
           }
-      }
+        }
+    }
 
-      /* "ssh2/agent.pyx":71
+    /* "ssh2/agent.pyx":71
  *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
  *         _session)
  *     if agent is NULL:             # <<<<<<<<<<<<<<
  *         with gil:
  *             raise AgentError("Error initialising agent")
  */
-    }
+  }
 
-    /* "ssh2/agent.pyx":74
+  /* "ssh2/agent.pyx":74
  *         with gil:
  *             raise AgentError("Error initialising agent")
  *     return agent             # <<<<<<<<<<<<<<
  * 
  * 
  */
-    __pyx_r = __pyx_v_agent;
-    goto __pyx_L3_return;
-  }
-
-  /* "ssh2/agent.pyx":69
- * cdef c_ssh2.LIBSSH2_AGENT * agent_init(
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
- *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(             # <<<<<<<<<<<<<<
- *         _session)
- *     if agent is NULL:
- */
-  /*finally:*/ {
-    __pyx_L3_return: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L0;
-    }
-    __pyx_L4_error: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L1_error;
-    }
-  }
+  __pyx_r = __pyx_v_agent;
+  goto __pyx_L0;
 
   /* "ssh2/agent.pyx":67
  * 
  * 
  * cdef c_ssh2.LIBSSH2_AGENT * agent_init(             # <<<<<<<<<<<<<<
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
   __pyx_L1_error:;
+  #ifdef WITH_THREAD
+  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_AddTraceback("ssh2.agent.agent_init", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __pyx_L0:;
   #ifdef WITH_THREAD
   __Pyx_PyGILState_Release(__pyx_gilstate_save);
   #endif
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContextNogil()
   return __pyx_r;
 }
 
@@ -2327,7 +3582,7 @@ static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_agent_init(LIBSSH2_SESSION *__pyx_v__
  * 
  * 
  * cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(             # <<<<<<<<<<<<<<
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent
  */
 
@@ -2339,6 +3594,7 @@ static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_init_connect_agent(LIBSSH2_SESSION *_
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  unsigned int __pyx_t_5;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2347,165 +3603,142 @@ static LIBSSH2_AGENT *__pyx_f_4ssh2_5agent_init_connect_agent(LIBSSH2_SESSION *_
   #endif
   __Pyx_RefNannySetupContext("init_connect_agent", 1);
 
-  /* "ssh2/agent.pyx":79
- * cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
- *     cdef c_ssh2.LIBSSH2_AGENT *agent             # <<<<<<<<<<<<<<
- *     agent = c_ssh2.libssh2_agent_init(_session)
- *     if c_ssh2.libssh2_agent_connect(agent) != 0:
- */
-  /*try:*/ {
-
-    /* "ssh2/agent.pyx":80
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+  /* "ssh2/agent.pyx":80
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent
  *     agent = c_ssh2.libssh2_agent_init(_session)             # <<<<<<<<<<<<<<
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:
  *         c_ssh2.libssh2_agent_free(agent)
  */
-    __pyx_v_agent = libssh2_agent_init(__pyx_v__session);
+  __pyx_v_agent = libssh2_agent_init(__pyx_v__session);
 
-    /* "ssh2/agent.pyx":81
+  /* "ssh2/agent.pyx":81
  *     cdef c_ssh2.LIBSSH2_AGENT *agent
  *     agent = c_ssh2.libssh2_agent_init(_session)
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:             # <<<<<<<<<<<<<<
  *         c_ssh2.libssh2_agent_free(agent)
  *         with gil:
  */
-    __pyx_t_1 = ((libssh2_agent_connect(__pyx_v_agent) != 0) != 0);
-    if (__pyx_t_1) {
+  __pyx_t_1 = (libssh2_agent_connect(__pyx_v_agent) != 0);
+  if (unlikely(__pyx_t_1)) {
 
-      /* "ssh2/agent.pyx":82
+    /* "ssh2/agent.pyx":82
  *     agent = c_ssh2.libssh2_agent_init(_session)
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:
  *         c_ssh2.libssh2_agent_free(agent)             # <<<<<<<<<<<<<<
  *         with gil:
  *             raise AgentConnectionError("Unable to connect to agent")
  */
-      libssh2_agent_free(__pyx_v_agent);
+    libssh2_agent_free(__pyx_v_agent);
 
-      /* "ssh2/agent.pyx":83
+    /* "ssh2/agent.pyx":83
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:
  *         c_ssh2.libssh2_agent_free(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentConnectionError("Unable to connect to agent")
  *     return agent
  */
-      {
-          #ifdef WITH_THREAD
-          PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-          #endif
-          /*try:*/ {
+    {
+        #ifdef WITH_THREAD
+        PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+        #endif
+        /*try:*/ {
 
-            /* "ssh2/agent.pyx":84
+          /* "ssh2/agent.pyx":84
  *         c_ssh2.libssh2_agent_free(agent)
  *         with gil:
  *             raise AgentConnectionError("Unable to connect to agent")             # <<<<<<<<<<<<<<
  *     return agent
  * 
  */
-            __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentConnectionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 84, __pyx_L8_error)
-            __Pyx_GOTREF(__pyx_t_3);
-            __pyx_t_4 = NULL;
-            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
-              if (likely(__pyx_t_4)) {
-                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-                __Pyx_INCREF(__pyx_t_4);
-                __Pyx_INCREF(function);
-                __Pyx_DECREF_SET(__pyx_t_3, function);
-              }
+          __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentConnectionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 84, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_4 = NULL;
+          __pyx_t_5 = 0;
+          #if CYTHON_UNPACK_METHODS
+          if (unlikely(PyMethod_Check(__pyx_t_3))) {
+            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+            if (likely(__pyx_t_4)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+              __Pyx_INCREF(__pyx_t_4);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_3, function);
+              __pyx_t_5 = 1;
             }
-            __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Unable_to_connect_to_agent) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Unable_to_connect_to_agent);
+          }
+          #endif
+          {
+            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Unable_to_connect_to_agent};
+            __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
             __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 84, __pyx_L8_error)
+            if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 84, __pyx_L5_error)
             __Pyx_GOTREF(__pyx_t_2);
             __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __PYX_ERR(1, 84, __pyx_L8_error)
           }
+          __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __PYX_ERR(1, 84, __pyx_L5_error)
+        }
 
-          /* "ssh2/agent.pyx":83
+        /* "ssh2/agent.pyx":83
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:
  *         c_ssh2.libssh2_agent_free(agent)
  *         with gil:             # <<<<<<<<<<<<<<
  *             raise AgentConnectionError("Unable to connect to agent")
  *     return agent
  */
-          /*finally:*/ {
-            __pyx_L8_error: {
-              #ifdef WITH_THREAD
-              __Pyx_PyGILState_Release(__pyx_gilstate_save);
-              #endif
-              goto __pyx_L4_error;
-            }
+        /*finally:*/ {
+          __pyx_L5_error: {
+            #ifdef WITH_THREAD
+            __Pyx_PyGILState_Release(__pyx_gilstate_save);
+            #endif
+            goto __pyx_L1_error;
           }
-      }
+        }
+    }
 
-      /* "ssh2/agent.pyx":81
+    /* "ssh2/agent.pyx":81
  *     cdef c_ssh2.LIBSSH2_AGENT *agent
  *     agent = c_ssh2.libssh2_agent_init(_session)
  *     if c_ssh2.libssh2_agent_connect(agent) != 0:             # <<<<<<<<<<<<<<
  *         c_ssh2.libssh2_agent_free(agent)
  *         with gil:
  */
-    }
+  }
 
-    /* "ssh2/agent.pyx":85
+  /* "ssh2/agent.pyx":85
  *         with gil:
  *             raise AgentConnectionError("Unable to connect to agent")
  *     return agent             # <<<<<<<<<<<<<<
  * 
  * 
  */
-    __pyx_r = __pyx_v_agent;
-    goto __pyx_L3_return;
-  }
-
-  /* "ssh2/agent.pyx":79
- * cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
- *     cdef c_ssh2.LIBSSH2_AGENT *agent             # <<<<<<<<<<<<<<
- *     agent = c_ssh2.libssh2_agent_init(_session)
- *     if c_ssh2.libssh2_agent_connect(agent) != 0:
- */
-  /*finally:*/ {
-    __pyx_L3_return: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L0;
-    }
-    __pyx_L4_error: {
-      #ifdef WITH_THREAD
-      __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-      #endif
-      goto __pyx_L1_error;
-    }
-  }
+  __pyx_r = __pyx_v_agent;
+  goto __pyx_L0;
 
   /* "ssh2/agent.pyx":77
  * 
  * 
  * cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(             # <<<<<<<<<<<<<<
- *         c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+ *         c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
  *     cdef c_ssh2.LIBSSH2_AGENT *agent
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
   __pyx_L1_error:;
+  #ifdef WITH_THREAD
+  __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+  #endif
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_AddTraceback("ssh2.agent.init_connect_agent", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __pyx_L0:;
   #ifdef WITH_THREAD
   __Pyx_PyGILState_Release(__pyx_gilstate_save);
   #endif
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContextNogil()
   return __pyx_r;
 }
 
@@ -2565,7 +3798,7 @@ static PyObject *__pyx_f_4ssh2_5agent_PyAgent(LIBSSH2_AGENT *__pyx_v_agent, stru
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyAgent", 0);
+  __Pyx_RefNannySetupContext("PyAgent", 1);
 
   /* "ssh2/agent.pyx":94
  * 
@@ -2576,11 +3809,11 @@ static PyObject *__pyx_f_4ssh2_5agent_PyAgent(LIBSSH2_AGENT *__pyx_v_agent, stru
  */
   __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(1, 94, __pyx_L1_error);
   __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_5agent_Agent(((PyTypeObject *)__pyx_ptype_4ssh2_5agent_Agent), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 94, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__agent = ((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_t_2);
   __pyx_t_2 = 0;
@@ -2602,7 +3835,7 @@ static PyObject *__pyx_f_4ssh2_5agent_PyAgent(LIBSSH2_AGENT *__pyx_v_agent, stru
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__agent));
+  __Pyx_INCREF((PyObject *)__pyx_v__agent);
   __pyx_r = ((PyObject *)__pyx_v__agent);
   goto __pyx_L0;
 
@@ -2639,44 +3872,64 @@ static PyObject *__pyx_f_4ssh2_5agent_PyAgent(LIBSSH2_AGENT *__pyx_v_agent, stru
 static int __pyx_pw_4ssh2_5agent_5Agent_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_5agent_5Agent_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 101, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 101, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 101, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 101, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 101, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.agent.Agent.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
@@ -2689,6 +3942,12 @@ static int __pyx_pw_4ssh2_5agent_5Agent_1__cinit__(PyObject *__pyx_v_self, PyObj
   __pyx_L1_error:;
   __pyx_r = -1;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2701,7 +3960,7 @@ static int __pyx_pf_4ssh2_5agent_5Agent___cinit__(struct __pyx_obj_4ssh2_5agent_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/agent.pyx":102
  * 
@@ -2729,10 +3988,10 @@ static int __pyx_pf_4ssh2_5agent_5Agent___cinit__(struct __pyx_obj_4ssh2_5agent_
  * 
  *     def __dealloc__(self):
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  __Pyx_GOTREF(__pyx_v_self->_session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_session);
   __pyx_v_self->_session = __pyx_v_session;
 
   /* "ssh2/agent.pyx":101
@@ -2765,8 +4024,10 @@ static int __pyx_pf_4ssh2_5agent_5Agent___cinit__(struct __pyx_obj_4ssh2_5agent_
 /* Python wrapper */
 static void __pyx_pw_4ssh2_5agent_5Agent_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_5agent_5Agent_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -2774,11 +4035,11 @@ static void __pyx_pw_4ssh2_5agent_5Agent_3__dealloc__(PyObject *__pyx_v_self) {
 }
 
 static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
 
   /* "ssh2/agent.pyx":107
  * 
@@ -2788,20 +4049,19 @@ static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5ag
  *         self._agent = NULL
  */
   __pyx_t_2 = (((PyObject *)__pyx_v_self->_session) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_session->_session != NULL) != 0);
-  if (__pyx_t_3) {
+  __pyx_t_2 = (__pyx_v_self->_session->_session != NULL);
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_agent != NULL) != 0);
-  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_2 = (__pyx_v_self->_agent != NULL);
+  __pyx_t_1 = __pyx_t_2;
   __pyx_L4_bool_binop_done:;
   if (__pyx_t_1) {
 
@@ -2812,7 +4072,7 @@ static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5ag
  *         self._agent = NULL
  * 
  */
-    __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_self->_agent);
+    __pyx_f_4ssh2_5agent_clear_agent(__pyx_v_self->_agent); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L1_error)
 
     /* "ssh2/agent.pyx":107
  * 
@@ -2841,7 +4101,10 @@ static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5ag
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_WriteUnraisable("ssh2.agent.Agent.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
+  __pyx_L0:;
 }
 
 /* "ssh2/agent.pyx":111
@@ -2853,12 +4116,40 @@ static void __pyx_pf_4ssh2_5agent_5Agent_2__dealloc__(struct __pyx_obj_4ssh2_5ag
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_5list_identities(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_4list_identities[] = "Agent.list_identities(self)\nThis method is a no-op - use\n        :py:func:`ssh2.agent.Agent.get_identities()` to list and retrieve\n        identities.";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_5list_identities(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_5list_identities(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_4list_identities, "Agent.list_identities(self)\nThis method is a no-op - use\n        :py:func:`ssh2.agent.Agent.get_identities()` to list and retrieve\n        identities.");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_5list_identities = {"list_identities", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_5list_identities, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_4list_identities};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_5list_identities(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("list_identities (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("list_identities", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "list_identities", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_4list_identities(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -2869,7 +4160,7 @@ static PyObject *__pyx_pw_4ssh2_5agent_5Agent_5list_identities(PyObject *__pyx_v
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_4list_identities(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("list_identities", 0);
+  __Pyx_RefNannySetupContext("list_identities", 1);
 
   /* function exit code */
   __pyx_r = Py_None; __Pyx_INCREF(Py_None);
@@ -2887,12 +4178,40 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_4list_identities(CYTHON_UNUSED str
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_7get_identities(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_6get_identities[] = "Agent.get_identities(self)\nList and get identities from agent\n\n        :rtype: list(:py:class:`ssh2.pkey.PublicKey`)";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_7get_identities(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_7get_identities(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_6get_identities, "Agent.get_identities(self)\nList and get identities from agent\n\n        :rtype: list(:py:class:`ssh2.pkey.PublicKey`)");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_7get_identities = {"get_identities", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_7get_identities, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_6get_identities};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_7get_identities(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_identities (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_identities", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_identities", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_6get_identities(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -2910,11 +4229,12 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
-  int __pyx_t_5;
+  unsigned int __pyx_t_5;
+  int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_identities", 0);
+  __Pyx_RefNannySetupContext("get_identities", 1);
 
   /* "ssh2/agent.pyx":122
  *         :rtype: list(:py:class:`ssh2.pkey.PublicKey`)"""
@@ -2953,7 +4273,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
  *             raise AgentListIdentitiesError(
  *                 "Failure requesting identities from agent."
  */
-  __pyx_t_2 = ((libssh2_agent_list_identities(__pyx_v_self->_agent) != 0) != 0);
+  __pyx_t_2 = (libssh2_agent_list_identities(__pyx_v_self->_agent) != 0);
   if (unlikely(__pyx_t_2)) {
 
     /* "ssh2/agent.pyx":126
@@ -2966,20 +4286,27 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
     __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentListIdentitiesError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 126, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_4 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_3))) {
       __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
       if (likely(__pyx_t_4)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
         __Pyx_INCREF(__pyx_t_4);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Failure_requesting_identities_fr_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Failure_requesting_identities_fr_2);
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 126, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Failure_requesting_identities_fr_2};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 126, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
     __Pyx_Raise(__pyx_t_1, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __PYX_ERR(1, 126, __pyx_L1_error)
@@ -3009,7 +4336,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
  *             identities.append(PyPublicKey(identity))
  *             prev = identity
  */
-    __pyx_t_2 = ((libssh2_agent_get_identity(__pyx_v_self->_agent, (&__pyx_v_identity), __pyx_v_prev) == 0) != 0);
+    __pyx_t_2 = (libssh2_agent_get_identity(__pyx_v_self->_agent, (&__pyx_v_identity), __pyx_v_prev) == 0);
     if (!__pyx_t_2) break;
 
     /* "ssh2/agent.pyx":131
@@ -3021,7 +4348,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
  */
     __pyx_t_1 = __pyx_f_4ssh2_4pkey_PyPublicKey(__pyx_v_identity); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 131, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_identities, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 131, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_identities, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 131, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "ssh2/agent.pyx":132
@@ -3077,59 +4404,100 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_6get_identities(struct __pyx_obj_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_9userauth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_8userauth[] = "Agent.userauth(self, username, PublicKey pkey)\nPerform user authentication with specific public key\n\n        :param username: User name to authenticate as\n        :type username: str\n        :param pkey: Public key to authenticate with\n        :type pkey: :py:class:`ssh2.pkey.PublicKey`\n\n        :raises: :py:class:`ssh2.exceptions.AgentAuthenticationError` on errors\n          authenticating.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_9userauth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_9userauth(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_8userauth, "Agent.userauth(self, username, PublicKey pkey)\nPerform user authentication with specific public key\n\n        :param username: User name to authenticate as\n        :type username: str\n        :param pkey: Public key to authenticate with\n        :type pkey: :py:class:`ssh2.pkey.PublicKey`\n\n        :raises: :py:class:`ssh2.exceptions.AgentAuthenticationError` on errors\n          authenticating.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_9userauth = {"userauth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_9userauth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_8userauth};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_9userauth(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_pkey = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_pkey,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_pkey,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 135, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pkey)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pkey)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 135, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("userauth", 1, 2, 2, 1); __PYX_ERR(1, 135, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth") < 0)) __PYX_ERR(1, 135, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth") < 0)) __PYX_ERR(1, 135, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_username = values[0];
     __pyx_v_pkey = ((struct __pyx_obj_4ssh2_4pkey_PublicKey *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 135, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 135, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.agent.Agent.userauth", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3145,6 +4513,12 @@ static PyObject *__pyx_pw_4ssh2_5agent_5Agent_9userauth(PyObject *__pyx_v_self,
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3160,12 +4534,11 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
   int __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth", 0);
+  __Pyx_RefNannySetupContext("userauth", 1);
 
   /* "ssh2/agent.pyx":149
  *         :rtype: int"""
@@ -3203,6 +4576,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3233,7 +4607,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
           __pyx_t_3 = 1;
           break;
         }
-        if (__pyx_t_3) {
+        if (unlikely(__pyx_t_3)) {
 
           /* "ssh2/agent.pyx":155
  *                 self._agent, _username, pkey._pkey)
@@ -3267,7 +4641,8 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
  */
                 __pyx_t_5 = NULL;
                 __pyx_t_6 = 0;
-                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+                #if CYTHON_UNPACK_METHODS
+                if (unlikely(PyMethod_Check(__pyx_t_4))) {
                   __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
                   if (likely(__pyx_t_5)) {
                     PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
@@ -3277,39 +4652,15 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
                     __pyx_t_6 = 1;
                   }
                 }
-                #if CYTHON_FAST_PYCALL
-                if (PyFunction_Check(__pyx_t_4)) {
-                  PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_authenticating_user_s_with, __pyx_v_username};
-                  __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 156, __pyx_L8_error)
-                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-                  __Pyx_GOTREF(__pyx_t_1);
-                } else
-                #endif
-                #if CYTHON_FAST_PYCCALL
-                if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-                  PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_authenticating_user_s_with, __pyx_v_username};
-                  __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 156, __pyx_L8_error)
-                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-                  __Pyx_GOTREF(__pyx_t_1);
-                } else
                 #endif
                 {
-                  __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 156, __pyx_L8_error)
-                  __Pyx_GOTREF(__pyx_t_7);
-                  if (__pyx_t_5) {
-                    __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-                  }
-                  __Pyx_INCREF(__pyx_kp_s_Error_authenticating_user_s_with);
-                  __Pyx_GIVEREF(__pyx_kp_s_Error_authenticating_user_s_with);
-                  PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Error_authenticating_user_s_with);
-                  __Pyx_INCREF(__pyx_v_username);
-                  __Pyx_GIVEREF(__pyx_v_username);
-                  PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_username);
-                  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 156, __pyx_L8_error)
+                  PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_u_Error_authenticating_user_s_with, __pyx_v_username};
+                  __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
+                  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+                  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 156, __pyx_L8_error)
                   __Pyx_GOTREF(__pyx_t_1);
-                  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+                  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                 }
-                __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
                 __Pyx_Raise(__pyx_t_1, 0, 0, 0);
                 __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
                 __PYX_ERR(1, 156, __pyx_L8_error)
@@ -3395,7 +4746,6 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.agent.Agent.userauth", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -3414,12 +4764,40 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_8userauth(struct __pyx_obj_4ssh2_5
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_11disconnect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_10disconnect[] = "Agent.disconnect(self)\nDisconnect from agent.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_11disconnect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_11disconnect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_10disconnect, "Agent.disconnect(self)\nDisconnect from agent.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_11disconnect = {"disconnect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_11disconnect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_10disconnect};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_11disconnect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("disconnect (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("disconnect", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "disconnect", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_10disconnect(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -3435,7 +4813,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_10disconnect(struct __pyx_obj_4ssh
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("disconnect", 0);
+  __Pyx_RefNannySetupContext("disconnect", 1);
 
   /* "ssh2/agent.pyx":166
  *         :rtype: int"""
@@ -3447,6 +4825,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_10disconnect(struct __pyx_obj_4ssh
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3523,12 +4902,40 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_10disconnect(struct __pyx_obj_4ssh
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_13connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_12connect[] = "Agent.connect(self)\nConnect to agent.\n\n        :raises: :py:class:`ssh2.exceptions.AgentConnectionError` on errors\n          connecting to agent.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_13connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_13connect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_12connect, "Agent.connect(self)\nConnect to agent.\n\n        :raises: :py:class:`ssh2.exceptions.AgentConnectionError` on errors\n          connecting to agent.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_13connect = {"connect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_13connect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_12connect};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_13connect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("connect (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("connect", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "connect", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_12connect(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -3544,10 +4951,11 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_12connect(struct __pyx_obj_4ssh2_5
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  unsigned int __pyx_t_5;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("connect", 0);
+  __Pyx_RefNannySetupContext("connect", 1);
 
   /* "ssh2/agent.pyx":178
  *         :rtype: int"""
@@ -3565,7 +4973,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_12connect(struct __pyx_obj_4ssh2_5
  *             raise AgentConnectionError("Unable to connect to agent")
  *         return rc
  */
-  __pyx_t_1 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_1 = (__pyx_v_rc != 0);
   if (unlikely(__pyx_t_1)) {
 
     /* "ssh2/agent.pyx":180
@@ -3578,20 +4986,27 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_12connect(struct __pyx_obj_4ssh2_5
     __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentConnectionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 180, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_4 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_3))) {
       __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
       if (likely(__pyx_t_4)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
         __Pyx_INCREF(__pyx_t_4);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Unable_to_connect_to_agent) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Unable_to_connect_to_agent);
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 180, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Unable_to_connect_to_agent};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 180, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __PYX_ERR(1, 180, __pyx_L1_error)
@@ -3649,12 +5064,40 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_12connect(struct __pyx_obj_4ssh2_5
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_14get_identity_path[] = "Agent.get_identity_path(self)";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_14get_identity_path, "Agent.get_identity_path(self)");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_15get_identity_path = {"get_identity_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_14get_identity_path};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_identity_path (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_identity_path", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_identity_path", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_14get_identity_path(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -3672,7 +5115,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_14get_identity_path(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_identity_path", 0);
+  __Pyx_RefNannySetupContext("get_identity_path", 1);
 
   /* "ssh2/agent.pyx":185
  *     def get_identity_path(self):
@@ -3693,6 +5136,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_14get_identity_path(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3734,7 +5178,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_14get_identity_path(struct __pyx_o
  *             return
  *         _path = c_path
  */
-  __pyx_t_1 = ((__pyx_v_c_path == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_c_path == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/agent.pyx":189
@@ -3810,25 +5254,105 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_14get_identity_path(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_16set_identity_path[] = "Agent.set_identity_path(self, path)";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_16set_identity_path, "Agent.set_identity_path(self, path)");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_17set_identity_path = {"set_identity_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_16set_identity_path};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("set_identity_path (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 193, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_identity_path") < 0)) __PYX_ERR(1, 193, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_identity_path", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 193, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.agent.Agent.set_identity_path", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 193, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3843,7 +5367,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("set_identity_path", 0);
+  __Pyx_RefNannySetupContext("set_identity_path", 1);
 
   /* "ssh2/agent.pyx":194
  * 
@@ -3881,6 +5405,7 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3938,17 +5463,45 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_16set_identity_path(struct __pyx_o
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_18__reduce_cython__[] = "Agent.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_18__reduce_cython__, "Agent.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_19__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_18__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_18__reduce_cython__(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self));
 
   /* function exit code */
@@ -3959,33 +5512,28 @@ static PyObject *__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__(PyObject *__py
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.agent.Agent.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -3995,21 +5543,104 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_18__reduce_cython__(CYTHON_UNUSED
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_5agent_5Agent_20__setstate_cython__[] = "Agent.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5agent_5Agent_20__setstate_cython__, "Agent.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_5agent_5Agent_21__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_20__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_20__setstate_cython__(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.agent.Agent.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_5agent_5Agent_20__setstate_cython__(((struct __pyx_obj_4ssh2_5agent_Agent *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4017,33 +5648,28 @@ static PyObject *__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__(PyObject *__
 static PyObject *__pyx_pf_4ssh2_5agent_5Agent_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_5agent_Agent *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.agent.Agent.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -4054,12 +5680,17 @@ static PyObject *__pyx_pf_4ssh2_5agent_5Agent_20__setstate_cython__(CYTHON_UNUSE
 static PyObject *__pyx_tp_new_4ssh2_5agent_Agent(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_5agent_Agent *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_5agent_Agent *)o);
   p->_session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_5agent_5Agent_1__cinit__(o, a, k) < 0)) goto bad;
@@ -4072,8 +5703,10 @@ static PyObject *__pyx_tp_new_4ssh2_5agent_Agent(PyTypeObject *t, PyObject *a, P
 static void __pyx_tp_dealloc_4ssh2_5agent_Agent(PyObject *o) {
   struct __pyx_obj_4ssh2_5agent_Agent *p = (struct __pyx_obj_4ssh2_5agent_Agent *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_5agent_Agent) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -4086,7 +5719,14 @@ static void __pyx_tp_dealloc_4ssh2_5agent_Agent(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_5agent_Agent(PyObject *o, visitproc v, void *a) {
@@ -4108,21 +5748,38 @@ static int __pyx_tp_clear_4ssh2_5agent_Agent(PyObject *o) {
 }
 
 static PyMethodDef __pyx_methods_4ssh2_5agent_Agent[] = {
-  {"list_identities", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_5list_identities, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_4list_identities},
-  {"get_identities", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_7get_identities, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_6get_identities},
-  {"userauth", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_9userauth, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_8userauth},
-  {"disconnect", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_11disconnect, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_10disconnect},
-  {"connect", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_13connect, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_12connect},
-  {"get_identity_path", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_14get_identity_path},
-  {"set_identity_path", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path, METH_O, __pyx_doc_4ssh2_5agent_5Agent_16set_identity_path},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_5agent_5Agent_18__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__, METH_O, __pyx_doc_4ssh2_5agent_5Agent_20__setstate_cython__},
+  {"list_identities", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_5list_identities, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_4list_identities},
+  {"get_identities", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_7get_identities, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_6get_identities},
+  {"userauth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_9userauth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_8userauth},
+  {"disconnect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_11disconnect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_10disconnect},
+  {"connect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_13connect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_12connect},
+  {"get_identity_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_15get_identity_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_14get_identity_path},
+  {"set_identity_path", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_17set_identity_path, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_16set_identity_path},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_18__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5agent_5Agent_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5agent_5Agent_20__setstate_cython__},
   {0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_5agent_Agent_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_5agent_Agent},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_5agent_Agent},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_5agent_Agent},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_5agent_Agent},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_5agent_Agent},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_5agent_Agent_spec = {
+  "ssh2.agent.Agent",
+  sizeof(struct __pyx_obj_4ssh2_5agent_Agent),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_5agent_Agent_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_5agent_Agent = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.agent.Agent", /*tp_name*/
+  "ssh2.agent.""Agent", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_5agent_Agent), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_5agent_Agent, /*tp_dealloc*/
@@ -4165,7 +5822,9 @@ static PyTypeObject __pyx_type_4ssh2_5agent_Agent = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_5agent_Agent, /*tp_new*/
@@ -4179,54 +5838,33 @@ static PyTypeObject __pyx_type_4ssh2_5agent_Agent = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_agent(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_agent},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "agent",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -4236,82 +5874,214 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_Agent, __pyx_k_Agent, sizeof(__pyx_k_Agent), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentAuthenticationError, __pyx_k_AgentAuthenticationError, sizeof(__pyx_k_AgentAuthenticationError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentConnectionError, __pyx_k_AgentConnectionError, sizeof(__pyx_k_AgentConnectionError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentError, __pyx_k_AgentError, sizeof(__pyx_k_AgentError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentGetIdentityError, __pyx_k_AgentGetIdentityError, sizeof(__pyx_k_AgentGetIdentityError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentListIdentitiesError, __pyx_k_AgentListIdentitiesError, sizeof(__pyx_k_AgentListIdentitiesError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Error_authenticating_user_s_with, __pyx_k_Error_authenticating_user_s_with, sizeof(__pyx_k_Error_authenticating_user_s_with), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_initialising_agent, __pyx_k_Error_initialising_agent, sizeof(__pyx_k_Error_initialising_agent), 0, 0, 1, 0},
-  {&__pyx_kp_s_Failure_getting_identity_for_use, __pyx_k_Failure_getting_identity_for_use, sizeof(__pyx_k_Failure_getting_identity_for_use), 0, 0, 1, 0},
-  {&__pyx_kp_s_Failure_requesting_identities_fr, __pyx_k_Failure_requesting_identities_fr, sizeof(__pyx_k_Failure_requesting_identities_fr), 0, 0, 1, 0},
-  {&__pyx_kp_s_Failure_requesting_identities_fr_2, __pyx_k_Failure_requesting_identities_fr_2, sizeof(__pyx_k_Failure_requesting_identities_fr_2), 0, 0, 1, 0},
-  {&__pyx_kp_s_No_identities_match_for_user_s, __pyx_k_No_identities_match_for_user_s, sizeof(__pyx_k_No_identities_match_for_user_s), 0, 0, 1, 0},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Unable_to_connect_to_agent, __pyx_k_Unable_to_connect_to_agent, sizeof(__pyx_k_Unable_to_connect_to_agent), 0, 0, 1, 0},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_pkey, __pyx_k_pkey, sizeof(__pyx_k_pkey), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_username, __pyx_k_username, sizeof(__pyx_k_username), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
+    {&__pyx_n_s_Agent, __pyx_k_Agent, sizeof(__pyx_k_Agent), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentAuthenticationError, __pyx_k_AgentAuthenticationError, sizeof(__pyx_k_AgentAuthenticationError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentConnectionError, __pyx_k_AgentConnectionError, sizeof(__pyx_k_AgentConnectionError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentError, __pyx_k_AgentError, sizeof(__pyx_k_AgentError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentGetIdentityError, __pyx_k_AgentGetIdentityError, sizeof(__pyx_k_AgentGetIdentityError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentListIdentitiesError, __pyx_k_AgentListIdentitiesError, sizeof(__pyx_k_AgentListIdentitiesError), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent___reduce_cython, __pyx_k_Agent___reduce_cython, sizeof(__pyx_k_Agent___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent___setstate_cython, __pyx_k_Agent___setstate_cython, sizeof(__pyx_k_Agent___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_connect, __pyx_k_Agent_connect, sizeof(__pyx_k_Agent_connect), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_disconnect, __pyx_k_Agent_disconnect, sizeof(__pyx_k_Agent_disconnect), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_get_identities, __pyx_k_Agent_get_identities, sizeof(__pyx_k_Agent_get_identities), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_get_identity_path, __pyx_k_Agent_get_identity_path, sizeof(__pyx_k_Agent_get_identity_path), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_list_identities, __pyx_k_Agent_list_identities, sizeof(__pyx_k_Agent_list_identities), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_set_identity_path, __pyx_k_Agent_set_identity_path, sizeof(__pyx_k_Agent_set_identity_path), 0, 0, 1, 1},
+    {&__pyx_n_s_Agent_userauth, __pyx_k_Agent_userauth, sizeof(__pyx_k_Agent_userauth), 0, 0, 1, 1},
+    {&__pyx_kp_u_Error_authenticating_user_s_with, __pyx_k_Error_authenticating_user_s_with, sizeof(__pyx_k_Error_authenticating_user_s_with), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_initialising_agent, __pyx_k_Error_initialising_agent, sizeof(__pyx_k_Error_initialising_agent), 0, 1, 0, 0},
+    {&__pyx_kp_u_Failure_getting_identity_for_use, __pyx_k_Failure_getting_identity_for_use, sizeof(__pyx_k_Failure_getting_identity_for_use), 0, 1, 0, 0},
+    {&__pyx_kp_u_Failure_requesting_identities_fr, __pyx_k_Failure_requesting_identities_fr, sizeof(__pyx_k_Failure_requesting_identities_fr), 0, 1, 0, 0},
+    {&__pyx_kp_u_Failure_requesting_identities_fr_2, __pyx_k_Failure_requesting_identities_fr_2, sizeof(__pyx_k_Failure_requesting_identities_fr_2), 0, 1, 0, 0},
+    {&__pyx_kp_u_No_identities_match_for_user_s, __pyx_k_No_identities_match_for_user_s, sizeof(__pyx_k_No_identities_match_for_user_s), 0, 1, 0, 0},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_kp_u_Unable_to_connect_to_agent, __pyx_k_Unable_to_connect_to_agent, sizeof(__pyx_k_Unable_to_connect_to_agent), 0, 1, 0, 0},
+    {&__pyx_n_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_b_path, __pyx_k_b_path, sizeof(__pyx_k_b_path), 0, 0, 1, 1},
+    {&__pyx_n_s_b_username, __pyx_k_b_username, sizeof(__pyx_k_b_username), 0, 0, 1, 1},
+    {&__pyx_n_s_c_path, __pyx_k_c_path, sizeof(__pyx_k_c_path), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_connect, __pyx_k_connect, sizeof(__pyx_k_connect), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_n_s_disconnect, __pyx_k_disconnect, sizeof(__pyx_k_disconnect), 0, 0, 1, 1},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_get_identities, __pyx_k_get_identities, sizeof(__pyx_k_get_identities), 0, 0, 1, 1},
+    {&__pyx_n_s_get_identity_path, __pyx_k_get_identity_path, sizeof(__pyx_k_get_identity_path), 0, 0, 1, 1},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_identities, __pyx_k_identities, sizeof(__pyx_k_identities), 0, 0, 1, 1},
+    {&__pyx_n_s_identity, __pyx_k_identity, sizeof(__pyx_k_identity), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_list_identities, __pyx_k_list_identities, sizeof(__pyx_k_list_identities), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
+    {&__pyx_n_s_path_2, __pyx_k_path_2, sizeof(__pyx_k_path_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pkey, __pyx_k_pkey, sizeof(__pyx_k_pkey), 0, 0, 1, 1},
+    {&__pyx_n_s_prev, __pyx_k_prev, sizeof(__pyx_k_prev), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_set_identity_path, __pyx_k_set_identity_path, sizeof(__pyx_k_set_identity_path), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_agent, __pyx_k_ssh2_agent, sizeof(__pyx_k_ssh2_agent), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_agent_pyx, __pyx_k_ssh2_agent_pyx, sizeof(__pyx_k_ssh2_agent_pyx), 0, 0, 1, 0},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth, __pyx_k_userauth, sizeof(__pyx_k_userauth), 0, 0, 1, 1},
+    {&__pyx_n_s_username, __pyx_k_username, sizeof(__pyx_k_username), 0, 0, 1, 1},
+    {&__pyx_n_s_username_2, __pyx_k_username_2, sizeof(__pyx_k_username_2), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/agent.pyx":111
+ *         self._agent = NULL
+ * 
+ *     def list_identities(self):             # <<<<<<<<<<<<<<
+ *         """This method is a no-op - use
+ *         :py:func:`ssh2.agent.Agent.get_identities()` to list and retrieve
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_list_identities, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(1, 111, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/agent.pyx":117
+ *         pass
+ * 
+ *     def get_identities(self):             # <<<<<<<<<<<<<<
+ *         """List and get identities from agent
+ * 
+ */
+  __pyx_tuple__4 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_rc, __pyx_n_s_identities, __pyx_n_s_identity, __pyx_n_s_prev); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_get_identities, 117, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(1, 117, __pyx_L1_error)
+
+  /* "ssh2/agent.pyx":135
+ *         return identities
+ * 
+ *     def userauth(self, username not None,             # <<<<<<<<<<<<<<
+ *                  PublicKey pkey):
+ *         """Perform user authentication with specific public key
+ */
+  __pyx_tuple__6 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_pkey, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_username_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_userauth, 135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(1, 135, __pyx_L1_error)
+
+  /* "ssh2/agent.pyx":161
+ *         return rc
+ * 
+ *     def disconnect(self):             # <<<<<<<<<<<<<<
+ *         """Disconnect from agent.
+ * 
+ */
+  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_disconnect, 161, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(1, 161, __pyx_L1_error)
+
+  /* "ssh2/agent.pyx":170
+ *         return rc
+ * 
+ *     def connect(self):             # <<<<<<<<<<<<<<
+ *         """Connect to agent.
+ * 
+ */
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_connect, 170, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 170, __pyx_L1_error)
+
+  /* "ssh2/agent.pyx":183
+ *         return rc
+ * 
+ *     def get_identity_path(self):             # <<<<<<<<<<<<<<
+ *         cdef bytes _path
+ *         cdef const char* c_path = NULL
+ */
+  __pyx_tuple__11 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_path_2, __pyx_n_s_c_path); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_get_identity_path, 183, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(1, 183, __pyx_L1_error)
+
+  /* "ssh2/agent.pyx":193
+ *         return _path
+ * 
+ *     def set_identity_path(self, path not None):             # <<<<<<<<<<<<<<
+ *         cdef bytes b_path = to_bytes(path)
+ *         cdef const char *c_path = b_path
+ */
+  __pyx_tuple__13 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_b_path, __pyx_n_s_c_path); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+  __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_agent_pyx, __pyx_n_s_set_identity_path, 193, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(1, 193, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -4364,16 +6134,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_5agent_Agent.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_5agent_Agent = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_5agent_Agent_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_5agent_Agent)) __PYX_ERR(1, 99, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_5agent_Agent_spec, __pyx_ptype_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_5agent_Agent = &__pyx_type_4ssh2_5agent_Agent;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_5agent_Agent.tp_dictoffset && __pyx_type_4ssh2_5agent_Agent.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_5agent_Agent.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_5agent_Agent->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_5agent_Agent->tp_dictoffset && __pyx_ptype_4ssh2_5agent_Agent->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_5agent_Agent->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Agent, (PyObject *)&__pyx_type_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
-  __pyx_ptype_4ssh2_5agent_Agent = &__pyx_type_4ssh2_5agent_Agent;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Agent, (PyObject *) __pyx_ptype_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_5agent_Agent) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -4391,15 +6174,12 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.pkey"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 23, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_4pkey_PublicKey = __Pyx_ImportType(__pyx_t_1, "ssh2.pkey", "PublicKey", sizeof(struct __pyx_obj_4ssh2_4pkey_PublicKey), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_4pkey_PublicKey) __PYX_ERR(3, 23, __pyx_L1_error)
+  __pyx_ptype_4ssh2_4pkey_PublicKey = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.pkey", "PublicKey", sizeof(struct __pyx_obj_4ssh2_4pkey_PublicKey), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_4pkey_PublicKey),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_4pkey_PublicKey) __PYX_ERR(3, 23, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -4427,11 +6207,11 @@ static int __Pyx_modinit_function_import_code(void) {
   /*--- Function import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.pkey"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyPublicKey", (void (**)(void))&__pyx_f_4ssh2_4pkey_PyPublicKey, "PyObject *(struct libssh2_agent_publickey *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyPublicKey", (void (**)(void))&__pyx_f_4ssh2_4pkey_PyPublicKey, "PyObject *(struct libssh2_agent_publickey *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -4442,6 +6222,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_agent(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_agent},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "agent",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -4492,12 +6321,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -4507,8 +6345,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -4518,8 +6357,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -4535,8 +6378,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_agent(PyObject *__pyx_pyinit_modul
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -4550,6 +6398,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_agent(PyObject *__pyx_pyinit_modul
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("agent", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "agent" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -4560,7 +6435,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_agent(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -4568,48 +6443,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("agent", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
@@ -4621,7 +6479,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.agent")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.agent", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.agent", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -4632,86 +6490,208 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
 
   /* "ssh2/agent.pyx":20
- * from utils cimport to_bytes
+ * from .utils cimport to_bytes
  * 
  * from .exceptions import AgentConnectionError, AgentListIdentitiesError, \             # <<<<<<<<<<<<<<
  *     AgentGetIdentityError, AgentAuthenticationError, AgentError
  * 
  */
-  __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyList_New(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_INCREF(__pyx_n_s_AgentConnectionError);
   __Pyx_GIVEREF(__pyx_n_s_AgentConnectionError);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AgentConnectionError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_AgentConnectionError)) __PYX_ERR(1, 20, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_AgentListIdentitiesError);
   __Pyx_GIVEREF(__pyx_n_s_AgentListIdentitiesError);
-  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_AgentListIdentitiesError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_AgentListIdentitiesError)) __PYX_ERR(1, 20, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_AgentGetIdentityError);
   __Pyx_GIVEREF(__pyx_n_s_AgentGetIdentityError);
-  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_AgentGetIdentityError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_AgentGetIdentityError)) __PYX_ERR(1, 20, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_AgentAuthenticationError);
   __Pyx_GIVEREF(__pyx_n_s_AgentAuthenticationError);
-  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_AgentAuthenticationError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_AgentAuthenticationError)) __PYX_ERR(1, 20, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_AgentError);
   __Pyx_GIVEREF(__pyx_n_s_AgentError);
-  PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_AgentError);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_AgentError)) __PYX_ERR(1, 20, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_AgentConnectionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AgentConnectionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentConnectionError, __pyx_t_1) < 0) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AgentListIdentitiesError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentListIdentitiesError, __pyx_t_1) < 0) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AgentGetIdentityError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentGetIdentityError, __pyx_t_1) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AgentAuthenticationError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentAuthenticationError, __pyx_t_1) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentError, __pyx_t_1) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentConnectionError, __pyx_t_2) < 0) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_AgentListIdentitiesError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentListIdentitiesError, __pyx_t_2) < 0) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_AgentGetIdentityError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentGetIdentityError, __pyx_t_2) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_AgentAuthenticationError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentAuthenticationError, __pyx_t_2) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentError, __pyx_t_2) < 0) __PYX_ERR(1, 21, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/agent.pyx":111
+ *         self._agent = NULL
+ * 
+ *     def list_identities(self):             # <<<<<<<<<<<<<<
+ *         """This method is a no-op - use
+ *         :py:func:`ssh2.agent.Agent.get_identities()` to list and retrieve
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_5list_identities, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_list_identities, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_list_identities, __pyx_t_3) < 0) __PYX_ERR(1, 111, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":117
+ *         pass
+ * 
+ *     def get_identities(self):             # <<<<<<<<<<<<<<
+ *         """List and get identities from agent
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_7get_identities, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_get_identities, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_get_identities, __pyx_t_3) < 0) __PYX_ERR(1, 117, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":135
+ *         return identities
+ * 
+ *     def userauth(self, username not None,             # <<<<<<<<<<<<<<
+ *                  PublicKey pkey):
+ *         """Perform user authentication with specific public key
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_9userauth, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_userauth, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_userauth, __pyx_t_3) < 0) __PYX_ERR(1, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":161
+ *         return rc
+ * 
+ *     def disconnect(self):             # <<<<<<<<<<<<<<
+ *         """Disconnect from agent.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_11disconnect, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_disconnect, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_disconnect, __pyx_t_3) < 0) __PYX_ERR(1, 161, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":170
+ *         return rc
+ * 
+ *     def connect(self):             # <<<<<<<<<<<<<<
+ *         """Connect to agent.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_13connect, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_connect, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_connect, __pyx_t_3) < 0) __PYX_ERR(1, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":183
+ *         return rc
+ * 
+ *     def get_identity_path(self):             # <<<<<<<<<<<<<<
+ *         cdef bytes _path
+ *         cdef const char* c_path = NULL
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_15get_identity_path, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_get_identity_path, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_get_identity_path, __pyx_t_3) < 0) __PYX_ERR(1, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "ssh2/agent.pyx":193
+ *         return _path
+ * 
+ *     def set_identity_path(self, path not None):             # <<<<<<<<<<<<<<
+ *         cdef bytes b_path = to_bytes(path)
+ *         cdef const char *c_path = b_path
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_17set_identity_path, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent_set_identity_path, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_5agent_Agent, __pyx_n_s_set_identity_path, __pyx_t_3) < 0) __PYX_ERR(1, 193, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_5agent_Agent);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent___reduce_cython, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5agent_5Agent_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Agent___setstate_cython, NULL, __pyx_n_s_ssh2_agent, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/agent.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.agent", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.agent");
   }
@@ -4725,6 +6705,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -4744,24 +6740,155 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
-#endif
-    return PyObject_GetAttr(obj, attr_name);
-}
-#endif
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -4772,6 +6899,19 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
+/* ErrOccurredWithGIL */
+static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) {
+  int err;
+  #ifdef WITH_THREAD
+  PyGILState_STATE _save = PyGILState_Ensure();
+  #endif
+  err = !!PyErr_Occurred();
+  #ifdef WITH_THREAD
+  PyGILState_Release(_save);
+  #endif
+  return err;
+}
+
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
@@ -4807,7 +6947,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 {
     PyObject *result;
 #if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
     result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
@@ -4815,6 +6955,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     } else if (unlikely(PyErr_Occurred())) {
         return NULL;
     }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
 #else
     result = PyDict_GetItem(__pyx_d, name);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
@@ -4833,31 +6981,8 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     return __Pyx_GetBuiltinName(name);
 }
 
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
-    }
-}
-#endif
-
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
 static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
@@ -4886,7 +7011,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -4902,9 +7026,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -4973,7 +7103,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
-#endif
 
 /* PyObjectCall */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -4982,8 +7111,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
     ternaryfunc call = Py_TYPE(func)->tp_call;
     if (unlikely(!call))
         return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = (*call)(func, arg, kw);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -4995,44 +7129,20 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 }
 #endif
 
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
-    }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
-    }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
-}
-
 /* PyObjectCallMethO */
 #if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -5044,75 +7154,89 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
     return result;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
-    }
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
 #endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
         }
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
-}
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
-#endif
 
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -5245,13 +7369,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -5259,6 +7379,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -5267,40 +7393,307 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
-/* RaiseDoubleKeywords */
-static void __Pyx_RaiseDoubleKeywordsError(
-    const char* func_name,
-    PyObject* kw_name)
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
 {
-    PyErr_Format(PyExc_TypeError,
-        #if PY_MAJOR_VERSION >= 3
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
-        #else
-        "%s() got multiple values for keyword argument '%s'", func_name,
-        PyString_AsString(kw_name));
-        #endif
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
 }
-
-/* ParseKeywords */
-static int __Pyx_ParseOptionalKeywords(
-    PyObject *kwds,
-    PyObject **argnames[],
-    PyObject *kwds2,
-    PyObject *values[],
-    Py_ssize_t num_pos_args,
-    const char* function_name)
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
 {
-    PyObject *key = 0, *value = 0;
-    Py_ssize_t pos = 0;
-    PyObject*** name;
-    PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -5308,6 +7701,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -5328,14 +7724,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -5362,6 +7762,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -5371,15 +7773,18 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
@@ -5412,6 +7817,8 @@ static void __Pyx_RaiseArgtupleInvalid(
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -5424,118 +7831,565 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
-#endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+/* WriteUnraisableException */
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil) {
+    PyObject *old_exc, *old_val, *old_tb;
+    PyObject *ctx;
+    __Pyx_PyThreadState_declare
+#ifdef WITH_THREAD
+    PyGILState_STATE state;
+    if (nogil)
+        state = PyGILState_Ensure();
+    else state = (PyGILState_STATE)0;
+#endif
+    CYTHON_UNUSED_VAR(clineno);
+    CYTHON_UNUSED_VAR(lineno);
+    CYTHON_UNUSED_VAR(filename);
+    CYTHON_MAYBE_UNUSED_VAR(nogil);
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
+    if (full_traceback) {
+        Py_XINCREF(old_exc);
+        Py_XINCREF(old_val);
+        Py_XINCREF(old_tb);
+        __Pyx_ErrRestore(old_exc, old_val, old_tb);
+        PyErr_PrintEx(0);
     }
-    Py_INCREF(descr);
     #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    ctx = PyString_FromString(name);
+    #else
+    ctx = PyUnicode_FromString(name);
     #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
+    __Pyx_ErrRestore(old_exc, old_val, old_tb);
+    if (!ctx) {
+        PyErr_WriteUnraisable(Py_None);
+    } else {
+        PyErr_WriteUnraisable(ctx);
+        Py_DECREF(ctx);
     }
-    return descr;
-}
+#ifdef WITH_THREAD
+    if (nogil)
+        PyGILState_Release(state);
 #endif
+}
 
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
-}
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
 #endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
 
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
     }
+#endif
     return 0;
 }
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
 #endif
 
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
-    }
-#endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
-    }
-    return result;
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
   }
   if (unlikely(ret < 0)) {
       PyErr_Clear();
@@ -5597,7 +8451,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             } else if (reduce == object_reduce || PyErr_Occurred()) {
                 goto __PYX_BAD;
             }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
                 setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
@@ -5613,8 +8467,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     }
     goto __PYX_GOOD;
 __PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
     ret = -1;
 __PYX_GOOD:
 #if !CYTHON_USE_PYTYPE_LOOKUP
@@ -5630,18 +8489,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     Py_XDECREF(setstate_cython);
     return ret;
 }
+#endif
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
     PyObject *result = 0;
     char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
@@ -5652,8 +8514,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
             module_name, class_name);
         goto bad;
     }
-#ifndef Py_LIMITED_API
+#if !CYTHON_COMPILING_IN_LIMITED_API
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
 #else
     py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
     if (!py_basicsize)
@@ -5663,22 +8526,38 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
     py_basicsize = 0;
     if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
         goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
 #endif
-    if ((size_t)basicsize < size) {
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            module_name, class_name, size, basicsize+itemsize);
         goto bad;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
         goto bad;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
         PyOS_snprintf(warning, sizeof(warning),
             "%s.%s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
@@ -5694,39 +8573,32 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
 
 /* Import */
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
     PyObject *module = 0;
-    PyObject *global_dict = 0;
     PyObject *empty_dict = 0;
-    PyObject *list;
+    PyObject *empty_list = 0;
     #if PY_MAJOR_VERSION < 3
     PyObject *py_import;
     py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
+    if (unlikely(!py_import))
         goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
+    if (!from_list) {
         empty_list = PyList_New(0);
-        if (!empty_list)
+        if (unlikely(!empty_list))
             goto bad;
-        list = empty_list;
+        from_list = empty_list;
     }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
+    #endif
     empty_dict = PyDict_New();
-    if (!empty_dict)
+    if (unlikely(!empty_dict))
         goto bad;
     {
         #if PY_MAJOR_VERSION >= 3
         if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
                 module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
                         goto bad;
                     PyErr_Clear();
                 }
@@ -5737,48 +8609,1258 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
         if (!module) {
             #if PY_MAJOR_VERSION < 3
             PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
+            if (unlikely(!py_level))
                 goto bad;
             module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
             Py_DECREF(py_level);
             #else
             module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
+                name, __pyx_d, empty_dict, from_list, level);
             #endif
         }
     }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    return module;
+}
+
+/* ImportFrom */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u_);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
 }
-
-/* ImportFrom */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
-    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
-    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
-        #else
-            "cannot import name %S", name);
-        #endif
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return value;
+    return op;
 }
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -5792,7 +9874,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -5814,6 +9896,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -5892,17 +9975,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -5937,6 +10104,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -5952,7 +10120,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -5999,6 +10167,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
@@ -6031,13 +10200,62 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__18);
+    }
+    return name;
+}
+#endif
+
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -6069,10 +10287,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -6111,7 +10362,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -6120,168 +10371,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -6307,7 +10629,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -6316,168 +10638,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -6494,7 +10887,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -6515,6 +10908,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -6539,11 +10948,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -6591,41 +11000,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -6647,11 +11065,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -6666,9 +11080,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -6685,7 +11099,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -6693,21 +11106,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -6720,9 +11118,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -6730,30 +11150,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -6808,7 +11232,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -6837,22 +11261,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -6918,13 +11346,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -6992,4 +11418,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/agent.pxd b/ssh2/agent.pxd
index 95c5ea1e..f47c40da 100644
--- a/ssh2/agent.pxd
+++ b/ssh2/agent.pxd
@@ -14,8 +14,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
-cimport c_ssh2
+from .session cimport Session
+from . cimport c_ssh2
 
 
 cdef object PyAgent(c_ssh2.LIBSSH2_AGENT *agent, Session session)
@@ -29,15 +29,15 @@ cdef class Agent:
 cdef int auth_identity(const char *username,
                        c_ssh2.LIBSSH2_AGENT *agent,
                        c_ssh2.libssh2_agent_publickey **identity,
-                       c_ssh2.libssh2_agent_publickey *prev) nogil except -1
+                       c_ssh2.libssh2_agent_publickey *prev) except -1 nogil
 
 cdef void clear_agent(c_ssh2.LIBSSH2_AGENT *agent) nogil
 
 cdef int agent_auth(char * _username,
-                    c_ssh2.LIBSSH2_AGENT * agent) nogil except 1
+                    c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil
 
 cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(
-    c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL
+    c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil
 
 cdef c_ssh2.LIBSSH2_AGENT * agent_init(
-    c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL
+    c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil
diff --git a/ssh2/agent.pyx b/ssh2/agent.pyx
index abf8ecf1..73589a85 100644
--- a/ssh2/agent.pyx
+++ b/ssh2/agent.pyx
@@ -14,17 +14,17 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from pkey cimport PublicKey, PyPublicKey
-from utils cimport to_bytes
+from .pkey cimport PublicKey, PyPublicKey
+from .utils cimport to_bytes
 
 from .exceptions import AgentConnectionError, AgentListIdentitiesError, \
     AgentGetIdentityError, AgentAuthenticationError, AgentError
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 cdef int agent_auth(char * _username,
-                    c_ssh2.LIBSSH2_AGENT * agent) nogil except 1:
+                    c_ssh2.LIBSSH2_AGENT * agent) except 1 nogil:
     cdef c_ssh2.libssh2_agent_publickey *identity = NULL
     cdef c_ssh2.libssh2_agent_publickey *prev = NULL
     if c_ssh2.libssh2_agent_list_identities(agent) != 0:
@@ -49,7 +49,7 @@ cdef int agent_auth(char * _username,
 cdef int auth_identity(const char *username,
                        c_ssh2.LIBSSH2_AGENT *agent,
                        c_ssh2.libssh2_agent_publickey **identity,
-                       c_ssh2.libssh2_agent_publickey *prev) nogil except -1:
+                       c_ssh2.libssh2_agent_publickey *prev) except -1 nogil:
     cdef int rc
     rc = c_ssh2.libssh2_agent_get_identity(
         agent, identity, prev)
@@ -65,7 +65,7 @@ cdef int auth_identity(const char *username,
 
 
 cdef c_ssh2.LIBSSH2_AGENT * agent_init(
-        c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+        c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
     cdef c_ssh2.LIBSSH2_AGENT *agent = c_ssh2.libssh2_agent_init(
         _session)
     if agent is NULL:
@@ -75,7 +75,7 @@ cdef c_ssh2.LIBSSH2_AGENT * agent_init(
 
 
 cdef c_ssh2.LIBSSH2_AGENT * init_connect_agent(
-        c_ssh2.LIBSSH2_SESSION *_session) nogil except NULL:
+        c_ssh2.LIBSSH2_SESSION *_session) except NULL nogil:
     cdef c_ssh2.LIBSSH2_AGENT *agent
     agent = c_ssh2.libssh2_agent_init(_session)
     if c_ssh2.libssh2_agent_connect(agent) != 0:
diff --git a/ssh2/c_pkey.pxd b/ssh2/c_pkey.pxd
index e66d39cb..05e63fa4 100644
--- a/ssh2/c_pkey.pxd
+++ b/ssh2/c_pkey.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 cdef extern from "libssh2_publickey.h" nogil:
     ctypedef struct LIBSSH2_PUBLICKEY:
diff --git a/ssh2/c_sftp.pxd b/ssh2/c_sftp.pxd
index a54363ba..452c6a63 100644
--- a/ssh2/c_sftp.pxd
+++ b/ssh2/c_sftp.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from c_ssh2 cimport LIBSSH2_SESSION, LIBSSH2_CHANNEL, libssh2_uint64_t
+from .c_ssh2 cimport LIBSSH2_SESSION, LIBSSH2_CHANNEL, libssh2_uint64_t
 
 
 cdef extern from "libssh2_sftp.h" nogil:
diff --git a/ssh2/c_ssh2.pxd b/ssh2/c_ssh2.pxd
index 7a0aec4a..f044e083 100644
--- a/ssh2/c_ssh2.pxd
+++ b/ssh2/c_ssh2.pxd
@@ -15,7 +15,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 from libc.time cimport time_t
-from c_stat cimport struct_stat
+from .c_stat cimport struct_stat
 
 
 cdef extern from "libssh2.h" nogil:
diff --git a/ssh2/channel.c b/ssh2/channel.c
index 79280b8b..3da14a8c 100644
--- a/ssh2/channel.c
+++ b/ssh2/channel.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.channel",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/channel.pyx"
+        ]
+    },
+    "module_name": "ssh2.channel"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
+#else
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -797,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -817,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -827,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -857,9 +1361,55 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
     PyObject* default_encoding = NULL;
@@ -879,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -909,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -944,25 +1495,28 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/channel.pyx",
-  "stringsource",
+  "<stringsource>",
   "ssh2/session.pxd",
   "ssh2/sftp.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -970,11 +1524,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -983,7 +1535,7 @@ struct __pyx_obj_4ssh2_4sftp_SFTP;
 struct __pyx_obj_4ssh2_7channel_Channel;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1037,6 +1589,7 @@ struct __pyx_obj_4ssh2_7channel_Channel {
   struct __pyx_obj_4ssh2_7session_Session *_session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1045,11 +1598,11 @@ struct __pyx_obj_4ssh2_7channel_Channel {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1059,28 +1612,40 @@ struct __pyx_obj_4ssh2_7channel_Channel {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1091,6 +1656,10 @@ struct __pyx_obj_4ssh2_7channel_Channel {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1102,50 +1671,30 @@ struct __pyx_obj_4ssh2_7channel_Channel {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* ArgTypeTest.proto */
-#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
-        __Pyx__ArgTypeTest(obj, type, name, exact))
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1157,7 +1706,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1173,6 +1722,112 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
 /* GetException.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
@@ -1190,7 +1845,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1208,6 +1863,78 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1222,29 +1949,28 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
 #endif
 
 /* Import.proto */
@@ -1253,6 +1979,146 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 /* ImportFrom.proto */
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
 
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1287,6 +2153,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1300,13 +2167,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1322,6 +2190,22 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1331,139 +2215,234 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "libc.stdlib" */
+
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.c_sftp' */
+/* Module declarations from "ssh2.c_sftp" */
 
-/* Module declarations from 'ssh2.sftp' */
-static PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP = 0;
+/* Module declarations from "ssh2.sftp" */
 
-/* Module declarations from 'ssh2.error_codes' */
+/* Module declarations from "ssh2.error_codes" */
 
-/* Module declarations from 'ssh2.channel' */
-static PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel = 0;
+/* Module declarations from "ssh2.channel" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.channel"
 extern int __pyx_module_is_main_ssh2__channel;
 int __pyx_module_is_main_ssh2__channel = 0;
 
-/* Implementation of 'ssh2.channel' */
+/* Implementation of "ssh2.channel" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
 static const char __pyx_k_[] = "";
+static const char __pyx_k__2[] = ".";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__67[] = "?";
 static const char __pyx_k_buf[] = "buf";
+static const char __pyx_k_eof[] = "eof";
+static const char __pyx_k_pty[] = "pty";
+static const char __pyx_k_cbuf[] = "cbuf";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_read[] = "read";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_size[] = "size";
 static const char __pyx_k_term[] = "term";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_b_buf[] = "b_buf";
+static const char __pyx_k_buf_2[] = "_buf";
+static const char __pyx_k_close[] = "close";
+static const char __pyx_k_flush[] = "flush";
 static const char __pyx_k_force[] = "force";
+static const char __pyx_k_m_len[] = "m_len";
+static const char __pyx_k_r_len[] = "r_len";
+static const char __pyx_k_shell[] = "shell";
 static const char __pyx_k_value[] = "value";
 static const char __pyx_k_vt100[] = "vt100";
+static const char __pyx_k_write[] = "write";
+static const char __pyx_k_b_term[] = "b_term";
+static const char __pyx_k_enable[] = "enable";
+static const char __pyx_k_errmsg[] = "errmsg";
 static const char __pyx_k_import[] = "__import__";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_setenv[] = "setenv";
+static const char __pyx_k_term_2[] = "_term";
 static const char __pyx_k_Channel[] = "Channel";
+static const char __pyx_k_b_value[] = "b_value";
+static const char __pyx_k_command[] = "command";
+static const char __pyx_k_disable[] = "disable";
+static const char __pyx_k_execute[] = "execute";
+static const char __pyx_k_langtag[] = "langtag";
 static const char __pyx_k_message[] = "message";
 static const char __pyx_k_read_ex[] = "read_ex";
 static const char __pyx_k_request[] = "request";
 static const char __pyx_k_session[] = "session";
+static const char __pyx_k_value_2[] = "_value";
 static const char __pyx_k_varname[] = "varname";
+static const char __pyx_k_x11_req[] = "x11_req";
+static const char __pyx_k_extended[] = "extended";
+static const char __pyx_k_flush_ex[] = "flush_ex";
 static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_send_eof[] = "send_eof";
 static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_wait_eof[] = "wait_eof";
+static const char __pyx_k_write_ex[] = "write_ex";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_b_command[] = "b_command";
+static const char __pyx_k_b_message[] = "b_message";
+static const char __pyx_k_b_request[] = "b_request";
+static const char __pyx_k_b_varname[] = "b_varname";
+static const char __pyx_k_command_2[] = "_command";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_message_2[] = "_message";
+static const char __pyx_k_py_errlen[] = "py_errlen";
+static const char __pyx_k_py_errmsg[] = "py_errmsg";
+static const char __pyx_k_py_siglen[] = "py_siglen";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_request_2[] = "_request";
 static const char __pyx_k_stream_id[] = "stream_id";
+static const char __pyx_k_subsystem[] = "subsystem";
+static const char __pyx_k_varname_2[] = "_varname";
 static const char __pyx_k_adjustment[] = "adjustment";
 static const char __pyx_k_auth_proto[] = "auth_proto";
+static const char __pyx_k_errmsg_len[] = "errmsg_len";
 static const char __pyx_k_exceptions[] = "exceptions";
+static const char __pyx_k_exitsignal[] = "exitsignal";
+static const char __pyx_k_py_langlen[] = "py_langlen";
+static const char __pyx_k_py_langtag[] = "py_langtag";
 static const char __pyx_k_read_avail[] = "read_avail";
+static const char __pyx_k_x11_req_ex[] = "x11_req_ex";
+static const char __pyx_k_Channel_eof[] = "Channel.eof";
+static const char __pyx_k_Channel_pty[] = "Channel.pty";
 static const char __pyx_k_MemoryError[] = "MemoryError";
 static const char __pyx_k_auth_cookie[] = "auth_cookie";
+static const char __pyx_k_b_subsystem[] = "b_subsystem";
+static const char __pyx_k_ignore_mode[] = "ignore_mode";
+static const char __pyx_k_langtag_len[] = "langtag_len";
+static const char __pyx_k_read_stderr[] = "read_stderr";
+static const char __pyx_k_storewindow[] = "storewindow";
+static const char __pyx_k_subsystem_2[] = "_subsystem";
+static const char __pyx_k_wait_closed[] = "wait_closed";
+static const char __pyx_k_window_read[] = "window_read";
 static const char __pyx_k_ChannelError[] = "ChannelError";
+static const char __pyx_k_Channel_read[] = "Channel.read";
+static const char __pyx_k_buf_tot_size[] = "buf_tot_size";
+static const char __pyx_k_flush_stderr[] = "flush_stderr";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_ssh2_channel[] = "ssh2.channel";
+static const char __pyx_k_stringsource[] = "<stringsource>";
+static const char __pyx_k_window_write[] = "window_write";
+static const char __pyx_k_write_stderr[] = "write_stderr";
+static const char __pyx_k_Channel_close[] = "Channel.close";
+static const char __pyx_k_Channel_flush[] = "Channel.flush";
+static const char __pyx_k_Channel_shell[] = "Channel.shell";
+static const char __pyx_k_Channel_write[] = "Channel.write";
+static const char __pyx_k_buf_remainder[] = "buf_remainder";
+static const char __pyx_k_bytes_written[] = "bytes_written";
+static const char __pyx_k_py_exitsignal[] = "py_exitsignal";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
 static const char __pyx_k_screen_number[] = "screen_number";
+static const char __pyx_k_Channel_setenv[] = "Channel.setenv";
+static const char __pyx_k_exitsignal_len[] = "exitsignal_len";
+static const char __pyx_k_window_read_ex[] = "window_read_ex";
+static const char __pyx_k_Channel_execute[] = "Channel.execute";
+static const char __pyx_k_Channel_read_ex[] = "Channel.read_ex";
+static const char __pyx_k_Channel_x11_req[] = "Channel.x11_req";
+static const char __pyx_k_get_exit_signal[] = "get_exit_signal";
+static const char __pyx_k_get_exit_status[] = "get_exit_status";
+static const char __pyx_k_process_startup[] = "process_startup";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_window_write_ex[] = "window_write_ex";
+static const char __pyx_k_Channel_flush_ex[] = "Channel.flush_ex";
+static const char __pyx_k_Channel_send_eof[] = "Channel.send_eof";
+static const char __pyx_k_Channel_wait_eof[] = "Channel.wait_eof";
+static const char __pyx_k_Channel_write_ex[] = "Channel.write_ex";
+static const char __pyx_k_ssh2_channel_pyx[] = "ssh2/channel.pyx";
+static const char __pyx_k_Channel_subsystem[] = "Channel.subsystem";
+static const char __pyx_k_poll_channel_read[] = "poll_channel_read";
 static const char __pyx_k_single_connection[] = "single_connection";
+static const char __pyx_k_Channel_x11_req_ex[] = "Channel.x11_req_ex";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_request_auth_agent[] = "request_auth_agent";
+static const char __pyx_k_Channel_read_stderr[] = "Channel.read_stderr";
+static const char __pyx_k_Channel_wait_closed[] = "Channel.wait_closed";
+static const char __pyx_k_Channel_window_read[] = "Channel.window_read";
 static const char __pyx_k_window_size_initial[] = "window_size_initial";
+static const char __pyx_k_Channel_flush_stderr[] = "Channel.flush_stderr";
+static const char __pyx_k_Channel_window_write[] = "Channel.window_write";
+static const char __pyx_k_Channel_write_stderr[] = "Channel.write_stderr";
+static const char __pyx_k_handle_extended_data[] = "handle_extended_data";
+static const char __pyx_k_ignore_extended_data[] = "ignore_extended_data";
+static const char __pyx_k_handle_extended_data2[] = "handle_extended_data2";
+static const char __pyx_k_receive_window_adjust[] = "receive_window_adjust";
+static const char __pyx_k_Channel_window_read_ex[] = "Channel.window_read_ex";
+static const char __pyx_k_receive_window_adjust2[] = "receive_window_adjust2";
+static const char __pyx_k_Channel___reduce_cython[] = "Channel.__reduce_cython__";
+static const char __pyx_k_Channel_get_exit_signal[] = "Channel.get_exit_signal";
+static const char __pyx_k_Channel_get_exit_status[] = "Channel.get_exit_status";
+static const char __pyx_k_Channel_process_startup[] = "Channel.process_startup";
+static const char __pyx_k_Channel_window_write_ex[] = "Channel.window_write_ex";
+static const char __pyx_k_Channel___setstate_cython[] = "Channel.__setstate_cython__";
+static const char __pyx_k_Channel_poll_channel_read[] = "Channel.poll_channel_read";
+static const char __pyx_k_Channel_request_auth_agent[] = "Channel.request_auth_agent";
+static const char __pyx_k_Channel_handle_extended_data[] = "Channel.handle_extended_data";
+static const char __pyx_k_Channel_ignore_extended_data[] = "Channel.ignore_extended_data";
+static const char __pyx_k_Channel_handle_extended_data2[] = "Channel.handle_extended_data2";
+static const char __pyx_k_Channel_receive_window_adjust[] = "Channel.receive_window_adjust";
+static const char __pyx_k_Channel_receive_window_adjust2[] = "Channel.receive_window_adjust2";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_kp_b_;
-static PyObject *__pyx_n_s_Channel;
-static PyObject *__pyx_n_s_ChannelError;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_adjustment;
-static PyObject *__pyx_n_s_auth_cookie;
-static PyObject *__pyx_n_s_auth_proto;
-static PyObject *__pyx_n_s_buf;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_exceptions;
-static PyObject *__pyx_n_s_force;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_message;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_read_avail;
-static PyObject *__pyx_n_s_read_ex;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_request;
-static PyObject *__pyx_n_s_screen_number;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_single_connection;
-static PyObject *__pyx_n_s_size;
-static PyObject *__pyx_n_s_stream_id;
-static PyObject *__pyx_n_s_term;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_value;
-static PyObject *__pyx_n_s_varname;
-static PyObject *__pyx_n_s_vt100;
-static PyObject *__pyx_n_s_window_size_initial;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_7channel_7Channel___cinit__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session); /* proto */
 static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_7session___get__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self); /* proto */
@@ -1505,58 +2484,1148 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_74__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_76__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_7channel_Channel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_int_0;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__3;
-/* Late includes */
-
-/* "ssh2/channel.pyx":27
- * 
- * 
- * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):             # <<<<<<<<<<<<<<
- *     cdef Channel _channel = Channel.__new__(Channel, session)
- *     _channel._channel = channel
- */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_7channel_Channel;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel;
+  PyObject *__pyx_kp_b_;
+  PyObject *__pyx_n_s_Channel;
+  PyObject *__pyx_n_s_ChannelError;
+  PyObject *__pyx_n_s_Channel___reduce_cython;
+  PyObject *__pyx_n_s_Channel___setstate_cython;
+  PyObject *__pyx_n_s_Channel_close;
+  PyObject *__pyx_n_s_Channel_eof;
+  PyObject *__pyx_n_s_Channel_execute;
+  PyObject *__pyx_n_s_Channel_flush;
+  PyObject *__pyx_n_s_Channel_flush_ex;
+  PyObject *__pyx_n_s_Channel_flush_stderr;
+  PyObject *__pyx_n_s_Channel_get_exit_signal;
+  PyObject *__pyx_n_s_Channel_get_exit_status;
+  PyObject *__pyx_n_s_Channel_handle_extended_data;
+  PyObject *__pyx_n_s_Channel_handle_extended_data2;
+  PyObject *__pyx_n_s_Channel_ignore_extended_data;
+  PyObject *__pyx_n_s_Channel_poll_channel_read;
+  PyObject *__pyx_n_s_Channel_process_startup;
+  PyObject *__pyx_n_s_Channel_pty;
+  PyObject *__pyx_n_s_Channel_read;
+  PyObject *__pyx_n_s_Channel_read_ex;
+  PyObject *__pyx_n_s_Channel_read_stderr;
+  PyObject *__pyx_n_s_Channel_receive_window_adjust;
+  PyObject *__pyx_n_s_Channel_receive_window_adjust2;
+  PyObject *__pyx_n_s_Channel_request_auth_agent;
+  PyObject *__pyx_n_s_Channel_send_eof;
+  PyObject *__pyx_n_s_Channel_setenv;
+  PyObject *__pyx_n_s_Channel_shell;
+  PyObject *__pyx_n_s_Channel_subsystem;
+  PyObject *__pyx_n_s_Channel_wait_closed;
+  PyObject *__pyx_n_s_Channel_wait_eof;
+  PyObject *__pyx_n_s_Channel_window_read;
+  PyObject *__pyx_n_s_Channel_window_read_ex;
+  PyObject *__pyx_n_s_Channel_window_write;
+  PyObject *__pyx_n_s_Channel_window_write_ex;
+  PyObject *__pyx_n_s_Channel_write;
+  PyObject *__pyx_n_s_Channel_write_ex;
+  PyObject *__pyx_n_s_Channel_write_stderr;
+  PyObject *__pyx_n_s_Channel_x11_req;
+  PyObject *__pyx_n_s_Channel_x11_req_ex;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_kp_u__2;
+  PyObject *__pyx_n_s__67;
+  PyObject *__pyx_n_s_adjustment;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_auth_cookie;
+  PyObject *__pyx_n_s_auth_proto;
+  PyObject *__pyx_n_s_b_buf;
+  PyObject *__pyx_n_s_b_command;
+  PyObject *__pyx_n_s_b_message;
+  PyObject *__pyx_n_s_b_request;
+  PyObject *__pyx_n_s_b_subsystem;
+  PyObject *__pyx_n_s_b_term;
+  PyObject *__pyx_n_s_b_value;
+  PyObject *__pyx_n_s_b_varname;
+  PyObject *__pyx_n_s_buf;
+  PyObject *__pyx_n_s_buf_2;
+  PyObject *__pyx_n_s_buf_remainder;
+  PyObject *__pyx_n_s_buf_tot_size;
+  PyObject *__pyx_n_s_bytes_written;
+  PyObject *__pyx_n_s_cbuf;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_close;
+  PyObject *__pyx_n_s_command;
+  PyObject *__pyx_n_s_command_2;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_eof;
+  PyObject *__pyx_n_s_errmsg;
+  PyObject *__pyx_n_s_errmsg_len;
+  PyObject *__pyx_n_s_exceptions;
+  PyObject *__pyx_n_s_execute;
+  PyObject *__pyx_n_s_exitsignal;
+  PyObject *__pyx_n_s_exitsignal_len;
+  PyObject *__pyx_n_s_extended;
+  PyObject *__pyx_n_s_flush;
+  PyObject *__pyx_n_s_flush_ex;
+  PyObject *__pyx_n_s_flush_stderr;
+  PyObject *__pyx_n_s_force;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_get_exit_signal;
+  PyObject *__pyx_n_s_get_exit_status;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_handle_extended_data;
+  PyObject *__pyx_n_s_handle_extended_data2;
+  PyObject *__pyx_n_s_ignore_extended_data;
+  PyObject *__pyx_n_s_ignore_mode;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_langtag;
+  PyObject *__pyx_n_s_langtag_len;
+  PyObject *__pyx_n_s_m_len;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_message;
+  PyObject *__pyx_n_s_message_2;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_poll_channel_read;
+  PyObject *__pyx_n_s_process_startup;
+  PyObject *__pyx_n_s_pty;
+  PyObject *__pyx_n_s_py_errlen;
+  PyObject *__pyx_n_s_py_errmsg;
+  PyObject *__pyx_n_s_py_exitsignal;
+  PyObject *__pyx_n_s_py_langlen;
+  PyObject *__pyx_n_s_py_langtag;
+  PyObject *__pyx_n_s_py_siglen;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_r_len;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_read;
+  PyObject *__pyx_n_s_read_avail;
+  PyObject *__pyx_n_s_read_ex;
+  PyObject *__pyx_n_s_read_stderr;
+  PyObject *__pyx_n_s_receive_window_adjust;
+  PyObject *__pyx_n_s_receive_window_adjust2;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_request;
+  PyObject *__pyx_n_s_request_2;
+  PyObject *__pyx_n_s_request_auth_agent;
+  PyObject *__pyx_n_s_screen_number;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_send_eof;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_setenv;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_shell;
+  PyObject *__pyx_n_s_single_connection;
+  PyObject *__pyx_n_s_size;
+  PyObject *__pyx_n_s_ssh2_channel;
+  PyObject *__pyx_kp_s_ssh2_channel_pyx;
+  PyObject *__pyx_n_s_storewindow;
+  PyObject *__pyx_n_s_stream_id;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_subsystem;
+  PyObject *__pyx_n_s_subsystem_2;
+  PyObject *__pyx_n_s_term;
+  PyObject *__pyx_n_s_term_2;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_value;
+  PyObject *__pyx_n_s_value_2;
+  PyObject *__pyx_n_s_varname;
+  PyObject *__pyx_n_s_varname_2;
+  PyObject *__pyx_n_u_vt100;
+  PyObject *__pyx_n_s_wait_closed;
+  PyObject *__pyx_n_s_wait_eof;
+  PyObject *__pyx_n_s_window_read;
+  PyObject *__pyx_n_s_window_read_ex;
+  PyObject *__pyx_n_s_window_size_initial;
+  PyObject *__pyx_n_s_window_write;
+  PyObject *__pyx_n_s_window_write_ex;
+  PyObject *__pyx_n_s_write;
+  PyObject *__pyx_n_s_write_ex;
+  PyObject *__pyx_n_s_write_stderr;
+  PyObject *__pyx_n_s_x11_req;
+  PyObject *__pyx_n_s_x11_req_ex;
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1024;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__6;
+  PyObject *__pyx_tuple__8;
+  PyObject *__pyx_tuple__10;
+  PyObject *__pyx_tuple__12;
+  PyObject *__pyx_tuple__14;
+  PyObject *__pyx_tuple__15;
+  PyObject *__pyx_tuple__17;
+  PyObject *__pyx_tuple__24;
+  PyObject *__pyx_tuple__29;
+  PyObject *__pyx_tuple__31;
+  PyObject *__pyx_tuple__33;
+  PyObject *__pyx_tuple__36;
+  PyObject *__pyx_tuple__39;
+  PyObject *__pyx_tuple__41;
+  PyObject *__pyx_tuple__43;
+  PyObject *__pyx_tuple__45;
+  PyObject *__pyx_tuple__48;
+  PyObject *__pyx_tuple__50;
+  PyObject *__pyx_tuple__52;
+  PyObject *__pyx_tuple__54;
+  PyObject *__pyx_tuple__55;
+  PyObject *__pyx_tuple__57;
+  PyObject *__pyx_tuple__59;
+  PyObject *__pyx_tuple__63;
+  PyObject *__pyx_tuple__65;
+  PyObject *__pyx_codeobj__4;
+  PyObject *__pyx_codeobj__7;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__11;
+  PyObject *__pyx_codeobj__13;
+  PyObject *__pyx_codeobj__16;
+  PyObject *__pyx_codeobj__18;
+  PyObject *__pyx_codeobj__19;
+  PyObject *__pyx_codeobj__20;
+  PyObject *__pyx_codeobj__21;
+  PyObject *__pyx_codeobj__22;
+  PyObject *__pyx_codeobj__23;
+  PyObject *__pyx_codeobj__25;
+  PyObject *__pyx_codeobj__26;
+  PyObject *__pyx_codeobj__27;
+  PyObject *__pyx_codeobj__28;
+  PyObject *__pyx_codeobj__30;
+  PyObject *__pyx_codeobj__32;
+  PyObject *__pyx_codeobj__34;
+  PyObject *__pyx_codeobj__35;
+  PyObject *__pyx_codeobj__37;
+  PyObject *__pyx_codeobj__38;
+  PyObject *__pyx_codeobj__40;
+  PyObject *__pyx_codeobj__42;
+  PyObject *__pyx_codeobj__44;
+  PyObject *__pyx_codeobj__46;
+  PyObject *__pyx_codeobj__47;
+  PyObject *__pyx_codeobj__49;
+  PyObject *__pyx_codeobj__51;
+  PyObject *__pyx_codeobj__53;
+  PyObject *__pyx_codeobj__56;
+  PyObject *__pyx_codeobj__58;
+  PyObject *__pyx_codeobj__60;
+  PyObject *__pyx_codeobj__61;
+  PyObject *__pyx_codeobj__62;
+  PyObject *__pyx_codeobj__64;
+  PyObject *__pyx_codeobj__66;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-static PyObject *__pyx_f_4ssh2_7channel_PyChannel(LIBSSH2_CHANNEL *__pyx_v_channel, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
-  struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v__channel = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyChannel", 0);
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
 
-  /* "ssh2/channel.pyx":28
- * 
- * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):
- *     cdef Channel _channel = Channel.__new__(Channel, session)             # <<<<<<<<<<<<<<
- *     _channel._channel = channel
- *     return _channel
- */
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
-  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_7channel_Channel(((PyTypeObject *)__pyx_ptype_4ssh2_7channel_Channel), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v__channel = ((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_t_2);
-  __pyx_t_2 = 0;
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
 
-  /* "ssh2/channel.pyx":29
- * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):
- *     cdef Channel _channel = Channel.__new__(Channel, session)
- *     _channel._channel = channel             # <<<<<<<<<<<<<<
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_7channel_Channel);
+  Py_CLEAR(clear_module_state->__pyx_kp_b_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_close);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_execute);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_flush);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_flush_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_flush_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_get_exit_signal);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_get_exit_status);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_handle_extended_data);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_handle_extended_data2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_ignore_extended_data);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_poll_channel_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_process_startup);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_pty);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_read_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_receive_window_adjust);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_receive_window_adjust2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_request_auth_agent);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_send_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_setenv);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_shell);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_subsystem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_wait_closed);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_wait_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_window_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_window_read_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_window_write);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_window_write_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_write);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_write_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_write_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_x11_req);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Channel_x11_req_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__2);
+  Py_CLEAR(clear_module_state->__pyx_n_s__67);
+  Py_CLEAR(clear_module_state->__pyx_n_s_adjustment);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_auth_cookie);
+  Py_CLEAR(clear_module_state->__pyx_n_s_auth_proto);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_command);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_message);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_request);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_subsystem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_term);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_value);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_varname);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf_remainder);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf_tot_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_bytes_written);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cbuf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_close);
+  Py_CLEAR(clear_module_state->__pyx_n_s_command);
+  Py_CLEAR(clear_module_state->__pyx_n_s_command_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errmsg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errmsg_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_execute);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exitsignal);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exitsignal_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_extended);
+  Py_CLEAR(clear_module_state->__pyx_n_s_flush);
+  Py_CLEAR(clear_module_state->__pyx_n_s_flush_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_flush_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_force);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_exit_signal);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_exit_status);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handle_extended_data);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handle_extended_data2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ignore_extended_data);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ignore_mode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_langtag);
+  Py_CLEAR(clear_module_state->__pyx_n_s_langtag_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_m_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_message);
+  Py_CLEAR(clear_module_state->__pyx_n_s_message_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_poll_channel_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_process_startup);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pty);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_errlen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_errmsg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_exitsignal);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_langlen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_langtag);
+  Py_CLEAR(clear_module_state->__pyx_n_s_py_siglen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_r_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_read_avail);
+  Py_CLEAR(clear_module_state->__pyx_n_s_read_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_read_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_receive_window_adjust);
+  Py_CLEAR(clear_module_state->__pyx_n_s_receive_window_adjust2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_request);
+  Py_CLEAR(clear_module_state->__pyx_n_s_request_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_request_auth_agent);
+  Py_CLEAR(clear_module_state->__pyx_n_s_screen_number);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_send_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setenv);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_shell);
+  Py_CLEAR(clear_module_state->__pyx_n_s_single_connection);
+  Py_CLEAR(clear_module_state->__pyx_n_s_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_channel);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_channel_pyx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_storewindow);
+  Py_CLEAR(clear_module_state->__pyx_n_s_stream_id);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_subsystem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_subsystem_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_term);
+  Py_CLEAR(clear_module_state->__pyx_n_s_term_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_value);
+  Py_CLEAR(clear_module_state->__pyx_n_s_value_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_varname);
+  Py_CLEAR(clear_module_state->__pyx_n_s_varname_2);
+  Py_CLEAR(clear_module_state->__pyx_n_u_vt100);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wait_closed);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wait_eof);
+  Py_CLEAR(clear_module_state->__pyx_n_s_window_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_window_read_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_window_size_initial);
+  Py_CLEAR(clear_module_state->__pyx_n_s_window_write);
+  Py_CLEAR(clear_module_state->__pyx_n_s_window_write_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_write);
+  Py_CLEAR(clear_module_state->__pyx_n_s_write_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_write_stderr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_x11_req);
+  Py_CLEAR(clear_module_state->__pyx_n_s_x11_req_ex);
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1024);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__6);
+  Py_CLEAR(clear_module_state->__pyx_tuple__8);
+  Py_CLEAR(clear_module_state->__pyx_tuple__10);
+  Py_CLEAR(clear_module_state->__pyx_tuple__12);
+  Py_CLEAR(clear_module_state->__pyx_tuple__14);
+  Py_CLEAR(clear_module_state->__pyx_tuple__15);
+  Py_CLEAR(clear_module_state->__pyx_tuple__17);
+  Py_CLEAR(clear_module_state->__pyx_tuple__24);
+  Py_CLEAR(clear_module_state->__pyx_tuple__29);
+  Py_CLEAR(clear_module_state->__pyx_tuple__31);
+  Py_CLEAR(clear_module_state->__pyx_tuple__33);
+  Py_CLEAR(clear_module_state->__pyx_tuple__36);
+  Py_CLEAR(clear_module_state->__pyx_tuple__39);
+  Py_CLEAR(clear_module_state->__pyx_tuple__41);
+  Py_CLEAR(clear_module_state->__pyx_tuple__43);
+  Py_CLEAR(clear_module_state->__pyx_tuple__45);
+  Py_CLEAR(clear_module_state->__pyx_tuple__48);
+  Py_CLEAR(clear_module_state->__pyx_tuple__50);
+  Py_CLEAR(clear_module_state->__pyx_tuple__52);
+  Py_CLEAR(clear_module_state->__pyx_tuple__54);
+  Py_CLEAR(clear_module_state->__pyx_tuple__55);
+  Py_CLEAR(clear_module_state->__pyx_tuple__57);
+  Py_CLEAR(clear_module_state->__pyx_tuple__59);
+  Py_CLEAR(clear_module_state->__pyx_tuple__63);
+  Py_CLEAR(clear_module_state->__pyx_tuple__65);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__7);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__11);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__13);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__16);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__18);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__19);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__21);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__23);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__25);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__26);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__27);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__28);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__30);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__32);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__34);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__35);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__37);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__38);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__40);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__42);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__44);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__46);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__47);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__49);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__51);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__53);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__56);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__58);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__60);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__61);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__62);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__64);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__66);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_7channel_Channel);
+  Py_VISIT(traverse_module_state->__pyx_kp_b_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_close);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_execute);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_flush);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_flush_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_flush_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_get_exit_signal);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_get_exit_status);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_handle_extended_data);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_handle_extended_data2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_ignore_extended_data);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_poll_channel_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_process_startup);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_pty);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_read_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_receive_window_adjust);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_receive_window_adjust2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_request_auth_agent);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_send_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_setenv);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_shell);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_subsystem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_wait_closed);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_wait_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_window_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_window_read_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_window_write);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_window_write_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_write);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_write_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_write_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_x11_req);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Channel_x11_req_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__2);
+  Py_VISIT(traverse_module_state->__pyx_n_s__67);
+  Py_VISIT(traverse_module_state->__pyx_n_s_adjustment);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_auth_cookie);
+  Py_VISIT(traverse_module_state->__pyx_n_s_auth_proto);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_command);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_message);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_request);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_subsystem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_term);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_value);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_varname);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf_remainder);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf_tot_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_bytes_written);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cbuf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_close);
+  Py_VISIT(traverse_module_state->__pyx_n_s_command);
+  Py_VISIT(traverse_module_state->__pyx_n_s_command_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errmsg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errmsg_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_execute);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exitsignal);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exitsignal_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_extended);
+  Py_VISIT(traverse_module_state->__pyx_n_s_flush);
+  Py_VISIT(traverse_module_state->__pyx_n_s_flush_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_flush_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_force);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_exit_signal);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_exit_status);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handle_extended_data);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handle_extended_data2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ignore_extended_data);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ignore_mode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_langtag);
+  Py_VISIT(traverse_module_state->__pyx_n_s_langtag_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_m_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_message);
+  Py_VISIT(traverse_module_state->__pyx_n_s_message_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_poll_channel_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_process_startup);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pty);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_errlen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_errmsg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_exitsignal);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_langlen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_langtag);
+  Py_VISIT(traverse_module_state->__pyx_n_s_py_siglen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_r_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_read_avail);
+  Py_VISIT(traverse_module_state->__pyx_n_s_read_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_read_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_receive_window_adjust);
+  Py_VISIT(traverse_module_state->__pyx_n_s_receive_window_adjust2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_request);
+  Py_VISIT(traverse_module_state->__pyx_n_s_request_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_request_auth_agent);
+  Py_VISIT(traverse_module_state->__pyx_n_s_screen_number);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_send_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setenv);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_shell);
+  Py_VISIT(traverse_module_state->__pyx_n_s_single_connection);
+  Py_VISIT(traverse_module_state->__pyx_n_s_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_channel);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_channel_pyx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_storewindow);
+  Py_VISIT(traverse_module_state->__pyx_n_s_stream_id);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_subsystem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_subsystem_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_term);
+  Py_VISIT(traverse_module_state->__pyx_n_s_term_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_value);
+  Py_VISIT(traverse_module_state->__pyx_n_s_value_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_varname);
+  Py_VISIT(traverse_module_state->__pyx_n_s_varname_2);
+  Py_VISIT(traverse_module_state->__pyx_n_u_vt100);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wait_closed);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wait_eof);
+  Py_VISIT(traverse_module_state->__pyx_n_s_window_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_window_read_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_window_size_initial);
+  Py_VISIT(traverse_module_state->__pyx_n_s_window_write);
+  Py_VISIT(traverse_module_state->__pyx_n_s_window_write_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_write);
+  Py_VISIT(traverse_module_state->__pyx_n_s_write_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_write_stderr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_x11_req);
+  Py_VISIT(traverse_module_state->__pyx_n_s_x11_req_ex);
+  Py_VISIT(traverse_module_state->__pyx_int_0);
+  Py_VISIT(traverse_module_state->__pyx_int_1024);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__6);
+  Py_VISIT(traverse_module_state->__pyx_tuple__8);
+  Py_VISIT(traverse_module_state->__pyx_tuple__10);
+  Py_VISIT(traverse_module_state->__pyx_tuple__12);
+  Py_VISIT(traverse_module_state->__pyx_tuple__14);
+  Py_VISIT(traverse_module_state->__pyx_tuple__15);
+  Py_VISIT(traverse_module_state->__pyx_tuple__17);
+  Py_VISIT(traverse_module_state->__pyx_tuple__24);
+  Py_VISIT(traverse_module_state->__pyx_tuple__29);
+  Py_VISIT(traverse_module_state->__pyx_tuple__31);
+  Py_VISIT(traverse_module_state->__pyx_tuple__33);
+  Py_VISIT(traverse_module_state->__pyx_tuple__36);
+  Py_VISIT(traverse_module_state->__pyx_tuple__39);
+  Py_VISIT(traverse_module_state->__pyx_tuple__41);
+  Py_VISIT(traverse_module_state->__pyx_tuple__43);
+  Py_VISIT(traverse_module_state->__pyx_tuple__45);
+  Py_VISIT(traverse_module_state->__pyx_tuple__48);
+  Py_VISIT(traverse_module_state->__pyx_tuple__50);
+  Py_VISIT(traverse_module_state->__pyx_tuple__52);
+  Py_VISIT(traverse_module_state->__pyx_tuple__54);
+  Py_VISIT(traverse_module_state->__pyx_tuple__55);
+  Py_VISIT(traverse_module_state->__pyx_tuple__57);
+  Py_VISIT(traverse_module_state->__pyx_tuple__59);
+  Py_VISIT(traverse_module_state->__pyx_tuple__63);
+  Py_VISIT(traverse_module_state->__pyx_tuple__65);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__7);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__11);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__13);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__16);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__18);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__19);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__21);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__23);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__25);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__26);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__27);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__28);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__30);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__32);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__34);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__35);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__37);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__38);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__40);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__42);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__44);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__46);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__47);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__49);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__51);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__53);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__56);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__58);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__60);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__61);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__62);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__64);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__66);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_4sftp_SFTP __pyx_mstate_global->__pyx_ptype_4ssh2_4sftp_SFTP
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_7channel_Channel __pyx_mstate_global->__pyx_type_4ssh2_7channel_Channel
+#endif
+#define __pyx_ptype_4ssh2_7channel_Channel __pyx_mstate_global->__pyx_ptype_4ssh2_7channel_Channel
+#define __pyx_kp_b_ __pyx_mstate_global->__pyx_kp_b_
+#define __pyx_n_s_Channel __pyx_mstate_global->__pyx_n_s_Channel
+#define __pyx_n_s_ChannelError __pyx_mstate_global->__pyx_n_s_ChannelError
+#define __pyx_n_s_Channel___reduce_cython __pyx_mstate_global->__pyx_n_s_Channel___reduce_cython
+#define __pyx_n_s_Channel___setstate_cython __pyx_mstate_global->__pyx_n_s_Channel___setstate_cython
+#define __pyx_n_s_Channel_close __pyx_mstate_global->__pyx_n_s_Channel_close
+#define __pyx_n_s_Channel_eof __pyx_mstate_global->__pyx_n_s_Channel_eof
+#define __pyx_n_s_Channel_execute __pyx_mstate_global->__pyx_n_s_Channel_execute
+#define __pyx_n_s_Channel_flush __pyx_mstate_global->__pyx_n_s_Channel_flush
+#define __pyx_n_s_Channel_flush_ex __pyx_mstate_global->__pyx_n_s_Channel_flush_ex
+#define __pyx_n_s_Channel_flush_stderr __pyx_mstate_global->__pyx_n_s_Channel_flush_stderr
+#define __pyx_n_s_Channel_get_exit_signal __pyx_mstate_global->__pyx_n_s_Channel_get_exit_signal
+#define __pyx_n_s_Channel_get_exit_status __pyx_mstate_global->__pyx_n_s_Channel_get_exit_status
+#define __pyx_n_s_Channel_handle_extended_data __pyx_mstate_global->__pyx_n_s_Channel_handle_extended_data
+#define __pyx_n_s_Channel_handle_extended_data2 __pyx_mstate_global->__pyx_n_s_Channel_handle_extended_data2
+#define __pyx_n_s_Channel_ignore_extended_data __pyx_mstate_global->__pyx_n_s_Channel_ignore_extended_data
+#define __pyx_n_s_Channel_poll_channel_read __pyx_mstate_global->__pyx_n_s_Channel_poll_channel_read
+#define __pyx_n_s_Channel_process_startup __pyx_mstate_global->__pyx_n_s_Channel_process_startup
+#define __pyx_n_s_Channel_pty __pyx_mstate_global->__pyx_n_s_Channel_pty
+#define __pyx_n_s_Channel_read __pyx_mstate_global->__pyx_n_s_Channel_read
+#define __pyx_n_s_Channel_read_ex __pyx_mstate_global->__pyx_n_s_Channel_read_ex
+#define __pyx_n_s_Channel_read_stderr __pyx_mstate_global->__pyx_n_s_Channel_read_stderr
+#define __pyx_n_s_Channel_receive_window_adjust __pyx_mstate_global->__pyx_n_s_Channel_receive_window_adjust
+#define __pyx_n_s_Channel_receive_window_adjust2 __pyx_mstate_global->__pyx_n_s_Channel_receive_window_adjust2
+#define __pyx_n_s_Channel_request_auth_agent __pyx_mstate_global->__pyx_n_s_Channel_request_auth_agent
+#define __pyx_n_s_Channel_send_eof __pyx_mstate_global->__pyx_n_s_Channel_send_eof
+#define __pyx_n_s_Channel_setenv __pyx_mstate_global->__pyx_n_s_Channel_setenv
+#define __pyx_n_s_Channel_shell __pyx_mstate_global->__pyx_n_s_Channel_shell
+#define __pyx_n_s_Channel_subsystem __pyx_mstate_global->__pyx_n_s_Channel_subsystem
+#define __pyx_n_s_Channel_wait_closed __pyx_mstate_global->__pyx_n_s_Channel_wait_closed
+#define __pyx_n_s_Channel_wait_eof __pyx_mstate_global->__pyx_n_s_Channel_wait_eof
+#define __pyx_n_s_Channel_window_read __pyx_mstate_global->__pyx_n_s_Channel_window_read
+#define __pyx_n_s_Channel_window_read_ex __pyx_mstate_global->__pyx_n_s_Channel_window_read_ex
+#define __pyx_n_s_Channel_window_write __pyx_mstate_global->__pyx_n_s_Channel_window_write
+#define __pyx_n_s_Channel_window_write_ex __pyx_mstate_global->__pyx_n_s_Channel_window_write_ex
+#define __pyx_n_s_Channel_write __pyx_mstate_global->__pyx_n_s_Channel_write
+#define __pyx_n_s_Channel_write_ex __pyx_mstate_global->__pyx_n_s_Channel_write_ex
+#define __pyx_n_s_Channel_write_stderr __pyx_mstate_global->__pyx_n_s_Channel_write_stderr
+#define __pyx_n_s_Channel_x11_req __pyx_mstate_global->__pyx_n_s_Channel_x11_req
+#define __pyx_n_s_Channel_x11_req_ex __pyx_mstate_global->__pyx_n_s_Channel_x11_req_ex
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2
+#define __pyx_n_s__67 __pyx_mstate_global->__pyx_n_s__67
+#define __pyx_n_s_adjustment __pyx_mstate_global->__pyx_n_s_adjustment
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_auth_cookie __pyx_mstate_global->__pyx_n_s_auth_cookie
+#define __pyx_n_s_auth_proto __pyx_mstate_global->__pyx_n_s_auth_proto
+#define __pyx_n_s_b_buf __pyx_mstate_global->__pyx_n_s_b_buf
+#define __pyx_n_s_b_command __pyx_mstate_global->__pyx_n_s_b_command
+#define __pyx_n_s_b_message __pyx_mstate_global->__pyx_n_s_b_message
+#define __pyx_n_s_b_request __pyx_mstate_global->__pyx_n_s_b_request
+#define __pyx_n_s_b_subsystem __pyx_mstate_global->__pyx_n_s_b_subsystem
+#define __pyx_n_s_b_term __pyx_mstate_global->__pyx_n_s_b_term
+#define __pyx_n_s_b_value __pyx_mstate_global->__pyx_n_s_b_value
+#define __pyx_n_s_b_varname __pyx_mstate_global->__pyx_n_s_b_varname
+#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf
+#define __pyx_n_s_buf_2 __pyx_mstate_global->__pyx_n_s_buf_2
+#define __pyx_n_s_buf_remainder __pyx_mstate_global->__pyx_n_s_buf_remainder
+#define __pyx_n_s_buf_tot_size __pyx_mstate_global->__pyx_n_s_buf_tot_size
+#define __pyx_n_s_bytes_written __pyx_mstate_global->__pyx_n_s_bytes_written
+#define __pyx_n_s_cbuf __pyx_mstate_global->__pyx_n_s_cbuf
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close
+#define __pyx_n_s_command __pyx_mstate_global->__pyx_n_s_command
+#define __pyx_n_s_command_2 __pyx_mstate_global->__pyx_n_s_command_2
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_eof __pyx_mstate_global->__pyx_n_s_eof
+#define __pyx_n_s_errmsg __pyx_mstate_global->__pyx_n_s_errmsg
+#define __pyx_n_s_errmsg_len __pyx_mstate_global->__pyx_n_s_errmsg_len
+#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions
+#define __pyx_n_s_execute __pyx_mstate_global->__pyx_n_s_execute
+#define __pyx_n_s_exitsignal __pyx_mstate_global->__pyx_n_s_exitsignal
+#define __pyx_n_s_exitsignal_len __pyx_mstate_global->__pyx_n_s_exitsignal_len
+#define __pyx_n_s_extended __pyx_mstate_global->__pyx_n_s_extended
+#define __pyx_n_s_flush __pyx_mstate_global->__pyx_n_s_flush
+#define __pyx_n_s_flush_ex __pyx_mstate_global->__pyx_n_s_flush_ex
+#define __pyx_n_s_flush_stderr __pyx_mstate_global->__pyx_n_s_flush_stderr
+#define __pyx_n_s_force __pyx_mstate_global->__pyx_n_s_force
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_get_exit_signal __pyx_mstate_global->__pyx_n_s_get_exit_signal
+#define __pyx_n_s_get_exit_status __pyx_mstate_global->__pyx_n_s_get_exit_status
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_handle_extended_data __pyx_mstate_global->__pyx_n_s_handle_extended_data
+#define __pyx_n_s_handle_extended_data2 __pyx_mstate_global->__pyx_n_s_handle_extended_data2
+#define __pyx_n_s_ignore_extended_data __pyx_mstate_global->__pyx_n_s_ignore_extended_data
+#define __pyx_n_s_ignore_mode __pyx_mstate_global->__pyx_n_s_ignore_mode
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_langtag __pyx_mstate_global->__pyx_n_s_langtag
+#define __pyx_n_s_langtag_len __pyx_mstate_global->__pyx_n_s_langtag_len
+#define __pyx_n_s_m_len __pyx_mstate_global->__pyx_n_s_m_len
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_message __pyx_mstate_global->__pyx_n_s_message
+#define __pyx_n_s_message_2 __pyx_mstate_global->__pyx_n_s_message_2
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_poll_channel_read __pyx_mstate_global->__pyx_n_s_poll_channel_read
+#define __pyx_n_s_process_startup __pyx_mstate_global->__pyx_n_s_process_startup
+#define __pyx_n_s_pty __pyx_mstate_global->__pyx_n_s_pty
+#define __pyx_n_s_py_errlen __pyx_mstate_global->__pyx_n_s_py_errlen
+#define __pyx_n_s_py_errmsg __pyx_mstate_global->__pyx_n_s_py_errmsg
+#define __pyx_n_s_py_exitsignal __pyx_mstate_global->__pyx_n_s_py_exitsignal
+#define __pyx_n_s_py_langlen __pyx_mstate_global->__pyx_n_s_py_langlen
+#define __pyx_n_s_py_langtag __pyx_mstate_global->__pyx_n_s_py_langtag
+#define __pyx_n_s_py_siglen __pyx_mstate_global->__pyx_n_s_py_siglen
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_r_len __pyx_mstate_global->__pyx_n_s_r_len
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_read __pyx_mstate_global->__pyx_n_s_read
+#define __pyx_n_s_read_avail __pyx_mstate_global->__pyx_n_s_read_avail
+#define __pyx_n_s_read_ex __pyx_mstate_global->__pyx_n_s_read_ex
+#define __pyx_n_s_read_stderr __pyx_mstate_global->__pyx_n_s_read_stderr
+#define __pyx_n_s_receive_window_adjust __pyx_mstate_global->__pyx_n_s_receive_window_adjust
+#define __pyx_n_s_receive_window_adjust2 __pyx_mstate_global->__pyx_n_s_receive_window_adjust2
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_request __pyx_mstate_global->__pyx_n_s_request
+#define __pyx_n_s_request_2 __pyx_mstate_global->__pyx_n_s_request_2
+#define __pyx_n_s_request_auth_agent __pyx_mstate_global->__pyx_n_s_request_auth_agent
+#define __pyx_n_s_screen_number __pyx_mstate_global->__pyx_n_s_screen_number
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_send_eof __pyx_mstate_global->__pyx_n_s_send_eof
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_setenv __pyx_mstate_global->__pyx_n_s_setenv
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_shell __pyx_mstate_global->__pyx_n_s_shell
+#define __pyx_n_s_single_connection __pyx_mstate_global->__pyx_n_s_single_connection
+#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size
+#define __pyx_n_s_ssh2_channel __pyx_mstate_global->__pyx_n_s_ssh2_channel
+#define __pyx_kp_s_ssh2_channel_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_channel_pyx
+#define __pyx_n_s_storewindow __pyx_mstate_global->__pyx_n_s_storewindow
+#define __pyx_n_s_stream_id __pyx_mstate_global->__pyx_n_s_stream_id
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_subsystem __pyx_mstate_global->__pyx_n_s_subsystem
+#define __pyx_n_s_subsystem_2 __pyx_mstate_global->__pyx_n_s_subsystem_2
+#define __pyx_n_s_term __pyx_mstate_global->__pyx_n_s_term
+#define __pyx_n_s_term_2 __pyx_mstate_global->__pyx_n_s_term_2
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value
+#define __pyx_n_s_value_2 __pyx_mstate_global->__pyx_n_s_value_2
+#define __pyx_n_s_varname __pyx_mstate_global->__pyx_n_s_varname
+#define __pyx_n_s_varname_2 __pyx_mstate_global->__pyx_n_s_varname_2
+#define __pyx_n_u_vt100 __pyx_mstate_global->__pyx_n_u_vt100
+#define __pyx_n_s_wait_closed __pyx_mstate_global->__pyx_n_s_wait_closed
+#define __pyx_n_s_wait_eof __pyx_mstate_global->__pyx_n_s_wait_eof
+#define __pyx_n_s_window_read __pyx_mstate_global->__pyx_n_s_window_read
+#define __pyx_n_s_window_read_ex __pyx_mstate_global->__pyx_n_s_window_read_ex
+#define __pyx_n_s_window_size_initial __pyx_mstate_global->__pyx_n_s_window_size_initial
+#define __pyx_n_s_window_write __pyx_mstate_global->__pyx_n_s_window_write
+#define __pyx_n_s_window_write_ex __pyx_mstate_global->__pyx_n_s_window_write_ex
+#define __pyx_n_s_write __pyx_mstate_global->__pyx_n_s_write
+#define __pyx_n_s_write_ex __pyx_mstate_global->__pyx_n_s_write_ex
+#define __pyx_n_s_write_stderr __pyx_mstate_global->__pyx_n_s_write_stderr
+#define __pyx_n_s_x11_req __pyx_mstate_global->__pyx_n_s_x11_req
+#define __pyx_n_s_x11_req_ex __pyx_mstate_global->__pyx_n_s_x11_req_ex
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6
+#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
+#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
+#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24
+#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29
+#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31
+#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33
+#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36
+#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39
+#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41
+#define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43
+#define __pyx_tuple__45 __pyx_mstate_global->__pyx_tuple__45
+#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48
+#define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50
+#define __pyx_tuple__52 __pyx_mstate_global->__pyx_tuple__52
+#define __pyx_tuple__54 __pyx_mstate_global->__pyx_tuple__54
+#define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55
+#define __pyx_tuple__57 __pyx_mstate_global->__pyx_tuple__57
+#define __pyx_tuple__59 __pyx_mstate_global->__pyx_tuple__59
+#define __pyx_tuple__63 __pyx_mstate_global->__pyx_tuple__63
+#define __pyx_tuple__65 __pyx_mstate_global->__pyx_tuple__65
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11
+#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13
+#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16
+#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18
+#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23
+#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25
+#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26
+#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27
+#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28
+#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30
+#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32
+#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34
+#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35
+#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37
+#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38
+#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40
+#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42
+#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44
+#define __pyx_codeobj__46 __pyx_mstate_global->__pyx_codeobj__46
+#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47
+#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49
+#define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51
+#define __pyx_codeobj__53 __pyx_mstate_global->__pyx_codeobj__53
+#define __pyx_codeobj__56 __pyx_mstate_global->__pyx_codeobj__56
+#define __pyx_codeobj__58 __pyx_mstate_global->__pyx_codeobj__58
+#define __pyx_codeobj__60 __pyx_mstate_global->__pyx_codeobj__60
+#define __pyx_codeobj__61 __pyx_mstate_global->__pyx_codeobj__61
+#define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62
+#define __pyx_codeobj__64 __pyx_mstate_global->__pyx_codeobj__64
+#define __pyx_codeobj__66 __pyx_mstate_global->__pyx_codeobj__66
+/* #### Code section: module_code ### */
+
+/* "ssh2/channel.pyx":28
+ * 
+ * 
+ * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):             # <<<<<<<<<<<<<<
+ *     cdef Channel _channel = Channel.__new__(Channel, session)
+ *     _channel._channel = channel
+ */
+
+static PyObject *__pyx_f_4ssh2_7channel_PyChannel(LIBSSH2_CHANNEL *__pyx_v_channel, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
+  struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v__channel = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyChannel", 1);
+
+  /* "ssh2/channel.pyx":29
+ * 
+ * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):
+ *     cdef Channel _channel = Channel.__new__(Channel, session)             # <<<<<<<<<<<<<<
+ *     _channel._channel = channel
+ *     return _channel
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(0, 29, __pyx_L1_error);
+  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_7channel_Channel(((PyTypeObject *)__pyx_ptype_4ssh2_7channel_Channel), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v__channel = ((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "ssh2/channel.pyx":30
+ * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):
+ *     cdef Channel _channel = Channel.__new__(Channel, session)
+ *     _channel._channel = channel             # <<<<<<<<<<<<<<
  *     return _channel
  * 
  */
   __pyx_v__channel->_channel = __pyx_v_channel;
 
-  /* "ssh2/channel.pyx":30
+  /* "ssh2/channel.pyx":31
  *     cdef Channel _channel = Channel.__new__(Channel, session)
  *     _channel._channel = channel
  *     return _channel             # <<<<<<<<<<<<<<
@@ -1564,11 +3633,11 @@ static PyObject *__pyx_f_4ssh2_7channel_PyChannel(LIBSSH2_CHANNEL *__pyx_v_chann
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__channel));
+  __Pyx_INCREF((PyObject *)__pyx_v__channel);
   __pyx_r = ((PyObject *)__pyx_v__channel);
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":27
+  /* "ssh2/channel.pyx":28
  * 
  * 
  * cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):             # <<<<<<<<<<<<<<
@@ -1589,7 +3658,7 @@ static PyObject *__pyx_f_4ssh2_7channel_PyChannel(LIBSSH2_CHANNEL *__pyx_v_chann
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":35
+/* "ssh2/channel.pyx":36
  * cdef class Channel:
  * 
  *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
@@ -1601,49 +3670,69 @@ static PyObject *__pyx_f_4ssh2_7channel_PyChannel(LIBSSH2_CHANNEL *__pyx_v_chann
 static int __pyx_pw_4ssh2_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 35, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 36, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 35, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 36, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(0, 35, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(0, 36, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel___cinit__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_session);
 
   /* function exit code */
@@ -1651,6 +3740,12 @@ static int __pyx_pw_4ssh2_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, P
   __pyx_L1_error:;
   __pyx_r = -1;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1658,22 +3753,22 @@ static int __pyx_pw_4ssh2_7channel_7Channel_1__cinit__(PyObject *__pyx_v_self, P
 static int __pyx_pf_4ssh2_7channel_7Channel___cinit__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
   int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
-  /* "ssh2/channel.pyx":36
+  /* "ssh2/channel.pyx":37
  * 
  *     def __cinit__(self, Session session):
  *         self._session = session             # <<<<<<<<<<<<<<
  * 
  *     def __dealloc__(self):
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  __Pyx_GOTREF(__pyx_v_self->_session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_session);
   __pyx_v_self->_session = __pyx_v_session;
 
-  /* "ssh2/channel.pyx":35
+  /* "ssh2/channel.pyx":36
  * cdef class Channel:
  * 
  *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
@@ -1687,7 +3782,7 @@ static int __pyx_pf_4ssh2_7channel_7Channel___cinit__(struct __pyx_obj_4ssh2_7ch
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":38
+/* "ssh2/channel.pyx":39
  *         self._session = session
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -1698,8 +3793,10 @@ static int __pyx_pf_4ssh2_7channel_7Channel___cinit__(struct __pyx_obj_4ssh2_7ch
 /* Python wrapper */
 static void __pyx_pw_4ssh2_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -1707,13 +3804,10 @@ static void __pyx_pw_4ssh2_7channel_7Channel_3__dealloc__(PyObject *__pyx_v_self
 }
 
 static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
-  /* "ssh2/channel.pyx":39
+  /* "ssh2/channel.pyx":40
  * 
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._channel is not NULL:             # <<<<<<<<<<<<<<
@@ -1721,24 +3815,23 @@ static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2
  *         self._channel = NULL
  */
   __pyx_t_2 = (((PyObject *)__pyx_v_self->_session) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_session->_session != NULL) != 0);
-  if (__pyx_t_3) {
+  __pyx_t_2 = (__pyx_v_self->_session->_session != NULL);
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_channel != NULL) != 0);
-  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_2 = (__pyx_v_self->_channel != NULL);
+  __pyx_t_1 = __pyx_t_2;
   __pyx_L4_bool_binop_done:;
   if (__pyx_t_1) {
 
-    /* "ssh2/channel.pyx":40
+    /* "ssh2/channel.pyx":41
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._channel is not NULL:
  *             c_ssh2.libssh2_channel_free(self._channel)             # <<<<<<<<<<<<<<
@@ -1747,7 +3840,7 @@ static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2
  */
     (void)(libssh2_channel_free(__pyx_v_self->_channel));
 
-    /* "ssh2/channel.pyx":39
+    /* "ssh2/channel.pyx":40
  * 
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._channel is not NULL:             # <<<<<<<<<<<<<<
@@ -1756,7 +3849,7 @@ static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2
  */
   }
 
-  /* "ssh2/channel.pyx":41
+  /* "ssh2/channel.pyx":42
  *         if self._session is not None and self._session._session is not NULL and self._channel is not NULL:
  *             c_ssh2.libssh2_channel_free(self._channel)
  *         self._channel = NULL             # <<<<<<<<<<<<<<
@@ -1765,7 +3858,7 @@ static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2
  */
   __pyx_v_self->_channel = NULL;
 
-  /* "ssh2/channel.pyx":38
+  /* "ssh2/channel.pyx":39
  *         self._session = session
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -1774,23 +3867,24 @@ static void __pyx_pf_4ssh2_7channel_7Channel_2__dealloc__(struct __pyx_obj_4ssh2
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
 /* "ssh2/channel.pyx":44
+ *         self._channel = NULL
  * 
- *     @property
- *     def session(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def session(self):
  *         """Originating session."""
- *         return self._session
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7session_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7session_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_7session___get__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -1801,9 +3895,9 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7session_1__get__(PyObject *__
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_7session___get__(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/channel.pyx":46
+  /* "ssh2/channel.pyx":47
  *     def session(self):
  *         """Originating session."""
  *         return self._session             # <<<<<<<<<<<<<<
@@ -1811,16 +3905,16 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_7session___get__(struct __pyx_
  *     def pty(self, term="vt100"):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_self->_session);
   __pyx_r = ((PyObject *)__pyx_v_self->_session);
   goto __pyx_L0;
 
   /* "ssh2/channel.pyx":44
+ *         self._channel = NULL
  * 
- *     @property
- *     def session(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def session(self):
  *         """Originating session."""
- *         return self._session
  */
 
   /* function exit code */
@@ -1830,7 +3924,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_7session___get__(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":48
+/* "ssh2/channel.pyx":49
  *         return self._session
  * 
  *     def pty(self, term="vt100"):             # <<<<<<<<<<<<<<
@@ -1839,43 +3933,69 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_7session___get__(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_4pty[] = "Channel.pty(self, term='vt100')\nRequest a PTY (physical terminal emulation) on the channel.\n\n        :param term: Terminal type to emulate.\n        :type term: str\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_4pty, "Channel.pty(self, term=u'vt100')\nRequest a PTY (physical terminal emulation) on the channel.\n\n        :param term: Terminal type to emulate.\n        :type term: str\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_5pty = {"pty", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_5pty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_4pty};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_term = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("pty (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_term,0};
-    PyObject* values[1] = {0};
-    values[0] = ((PyObject *)__pyx_n_s_vt100);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_term,0};
+    values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_vt100));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_term);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_term);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "pty") < 0)) __PYX_ERR(0, 48, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "pty") < 0)) __PYX_ERR(0, 49, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -1883,10 +4003,18 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, P
     }
     __pyx_v_term = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("pty", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 48, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("pty", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 49, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.pty", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -1894,6 +4022,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_5pty(PyObject *__pyx_v_self, P
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_4pty(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_term);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1910,21 +4044,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("pty", 0);
+  __Pyx_RefNannySetupContext("pty", 1);
 
-  /* "ssh2/channel.pyx":54
+  /* "ssh2/channel.pyx":55
  *         :type term: str
  *         """
  *         cdef bytes b_term = to_bytes(term)             # <<<<<<<<<<<<<<
  *         cdef const char *_term = b_term
  *         cdef int rc
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_term); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_term); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_term = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":55
+  /* "ssh2/channel.pyx":56
  *         """
  *         cdef bytes b_term = to_bytes(term)
  *         cdef const char *_term = b_term             # <<<<<<<<<<<<<<
@@ -1933,12 +4067,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
  */
   if (unlikely(__pyx_v_b_term == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 55, __pyx_L1_error)
+    __PYX_ERR(0, 56, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_term); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_term); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 56, __pyx_L1_error)
   __pyx_v__term = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":57
+  /* "ssh2/channel.pyx":58
  *         cdef const char *_term = b_term
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -1948,12 +4082,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":58
+        /* "ssh2/channel.pyx":59
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_request_pty(             # <<<<<<<<<<<<<<
@@ -1963,7 +4098,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
         __pyx_v_rc = libssh2_channel_request_pty(__pyx_v_self->_channel, __pyx_v__term);
       }
 
-      /* "ssh2/channel.pyx":57
+      /* "ssh2/channel.pyx":58
  *         cdef const char *_term = b_term
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -1982,7 +4117,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
       }
   }
 
-  /* "ssh2/channel.pyx":60
+  /* "ssh2/channel.pyx":61
  *             rc = c_ssh2.libssh2_channel_request_pty(
  *                 self._channel, _term)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -1990,14 +4125,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
  *     def execute(self, command not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 60, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 61, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":48
+  /* "ssh2/channel.pyx":49
  *         return self._session
  * 
  *     def pty(self, term="vt100"):             # <<<<<<<<<<<<<<
@@ -2017,7 +4152,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":62
+/* "ssh2/channel.pyx":63
  *         return handle_error_codes(rc)
  * 
  *     def execute(self, command not None):             # <<<<<<<<<<<<<<
@@ -2026,25 +4161,105 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_4pty(struct __pyx_obj_4ssh2_7c
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7execute(PyObject *__pyx_v_self, PyObject *__pyx_v_command); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_6execute[] = "Channel.execute(self, command)\nExecute command.\n\n        :param command: Command to execute\n        :type command: str\n\n        :raises: :py:class:`ssh2.exceptions.ChannelError` on errors executing\n          command\n\n        :rtype: int\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7execute(PyObject *__pyx_v_self, PyObject *__pyx_v_command) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7execute(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_6execute, "Channel.execute(self, command)\nExecute command.\n\n        :param command: Command to execute\n        :type command: str\n\n        :raises: :py:class:`ssh2.exceptions.ChannelError` on errors executing\n          command\n\n        :rtype: int\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_7execute = {"execute", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_7execute, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_6execute};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_7execute(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_command = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("execute (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_command,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_command)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "execute") < 0)) __PYX_ERR(0, 63, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_command = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("execute", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 63, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.execute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_command) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "command"); __PYX_ERR(0, 62, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "command"); __PYX_ERR(0, 63, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_6execute(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_command));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_6execute(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_command);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2061,21 +4276,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("execute", 0);
+  __Pyx_RefNannySetupContext("execute", 1);
 
-  /* "ssh2/channel.pyx":74
+  /* "ssh2/channel.pyx":75
  *         """
  *         cdef int rc
  *         cdef bytes b_command = to_bytes(command)             # <<<<<<<<<<<<<<
  *         cdef char *_command = b_command
  *         with nogil:
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_command); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_command); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_command = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":75
+  /* "ssh2/channel.pyx":76
  *         cdef int rc
  *         cdef bytes b_command = to_bytes(command)
  *         cdef char *_command = b_command             # <<<<<<<<<<<<<<
@@ -2084,12 +4299,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
  */
   if (unlikely(__pyx_v_b_command == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 75, __pyx_L1_error)
+    __PYX_ERR(0, 76, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_command); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_command); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error)
   __pyx_v__command = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":76
+  /* "ssh2/channel.pyx":77
  *         cdef bytes b_command = to_bytes(command)
  *         cdef char *_command = b_command
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2099,12 +4314,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":77
+        /* "ssh2/channel.pyx":78
  *         cdef char *_command = b_command
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_exec(             # <<<<<<<<<<<<<<
@@ -2114,7 +4330,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
         __pyx_v_rc = libssh2_channel_exec(__pyx_v_self->_channel, __pyx_v__command);
       }
 
-      /* "ssh2/channel.pyx":76
+      /* "ssh2/channel.pyx":77
  *         cdef bytes b_command = to_bytes(command)
  *         cdef char *_command = b_command
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2133,7 +4349,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
       }
   }
 
-  /* "ssh2/channel.pyx":79
+  /* "ssh2/channel.pyx":80
  *             rc = c_ssh2.libssh2_channel_exec(
  *                 self._channel, _command)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -2141,14 +4357,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
  *     def subsystem(self, subsystem not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 79, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 80, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":62
+  /* "ssh2/channel.pyx":63
  *         return handle_error_codes(rc)
  * 
  *     def execute(self, command not None):             # <<<<<<<<<<<<<<
@@ -2168,7 +4384,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":81
+/* "ssh2/channel.pyx":82
  *         return handle_error_codes(rc)
  * 
  *     def subsystem(self, subsystem not None):             # <<<<<<<<<<<<<<
@@ -2177,25 +4393,105 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_6execute(struct __pyx_obj_4ssh
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_9subsystem(PyObject *__pyx_v_self, PyObject *__pyx_v_subsystem); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_8subsystem[] = "Channel.subsystem(self, subsystem)\nRequest subsystem from channel.\n\n        :param subsystem: Name of subsystem\n        :type subsystem: str";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_9subsystem(PyObject *__pyx_v_self, PyObject *__pyx_v_subsystem) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_9subsystem(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_8subsystem, "Channel.subsystem(self, subsystem)\nRequest subsystem from channel.\n\n        :param subsystem: Name of subsystem\n        :type subsystem: str");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_9subsystem = {"subsystem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_9subsystem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_8subsystem};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_9subsystem(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_subsystem = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("subsystem (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_subsystem,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_subsystem)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 82, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "subsystem") < 0)) __PYX_ERR(0, 82, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_subsystem = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("subsystem", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 82, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.subsystem", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_subsystem) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "subsystem"); __PYX_ERR(0, 81, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "subsystem"); __PYX_ERR(0, 82, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_8subsystem(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_subsystem));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_8subsystem(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_subsystem);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2212,21 +4508,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("subsystem", 0);
+  __Pyx_RefNannySetupContext("subsystem", 1);
 
-  /* "ssh2/channel.pyx":87
+  /* "ssh2/channel.pyx":88
  *         :type subsystem: str"""
  *         cdef int rc
  *         cdef bytes b_subsystem = to_bytes(subsystem)             # <<<<<<<<<<<<<<
  *         cdef char *_subsystem = b_subsystem
  *         with nogil:
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_subsystem); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_subsystem); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_subsystem = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":88
+  /* "ssh2/channel.pyx":89
  *         cdef int rc
  *         cdef bytes b_subsystem = to_bytes(subsystem)
  *         cdef char *_subsystem = b_subsystem             # <<<<<<<<<<<<<<
@@ -2235,12 +4531,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
  */
   if (unlikely(__pyx_v_b_subsystem == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 88, __pyx_L1_error)
+    __PYX_ERR(0, 89, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_subsystem); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_subsystem); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 89, __pyx_L1_error)
   __pyx_v__subsystem = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":89
+  /* "ssh2/channel.pyx":90
  *         cdef bytes b_subsystem = to_bytes(subsystem)
  *         cdef char *_subsystem = b_subsystem
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2250,12 +4546,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":90
+        /* "ssh2/channel.pyx":91
  *         cdef char *_subsystem = b_subsystem
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_subsystem(             # <<<<<<<<<<<<<<
@@ -2265,7 +4562,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
         __pyx_v_rc = libssh2_channel_subsystem(__pyx_v_self->_channel, __pyx_v__subsystem);
       }
 
-      /* "ssh2/channel.pyx":89
+      /* "ssh2/channel.pyx":90
  *         cdef bytes b_subsystem = to_bytes(subsystem)
  *         cdef char *_subsystem = b_subsystem
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2284,7 +4581,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/channel.pyx":92
+  /* "ssh2/channel.pyx":93
  *             rc = c_ssh2.libssh2_channel_subsystem(
  *                 self._channel, _subsystem)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -2292,14 +4589,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
  *     def shell(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 92, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 93, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":81
+  /* "ssh2/channel.pyx":82
  *         return handle_error_codes(rc)
  * 
  *     def subsystem(self, subsystem not None):             # <<<<<<<<<<<<<<
@@ -2319,7 +4616,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":94
+/* "ssh2/channel.pyx":95
  *         return handle_error_codes(rc)
  * 
  *     def shell(self):             # <<<<<<<<<<<<<<
@@ -2328,12 +4625,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_8subsystem(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_11shell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_10shell[] = "Channel.shell(self)\nRequest interactive shell from channel.\n\n        :raises: :py:class:`ssh2.exceptions.ChannelError` on errors requesting\n          interactive shell.\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_11shell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_11shell(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_10shell, "Channel.shell(self)\nRequest interactive shell from channel.\n\n        :raises: :py:class:`ssh2.exceptions.ChannelError` on errors requesting\n          interactive shell.\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_11shell = {"shell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_11shell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_10shell};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_11shell(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("shell (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("shell", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "shell", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_10shell(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -2350,9 +4675,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("shell", 0);
+  __Pyx_RefNannySetupContext("shell", 1);
 
-  /* "ssh2/channel.pyx":101
+  /* "ssh2/channel.pyx":102
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2362,12 +4687,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":102
+        /* "ssh2/channel.pyx":103
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_shell(self._channel)             # <<<<<<<<<<<<<<
@@ -2377,7 +4703,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
         __pyx_v_rc = libssh2_channel_shell(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":101
+      /* "ssh2/channel.pyx":102
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2396,7 +4722,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
       }
   }
 
-  /* "ssh2/channel.pyx":103
+  /* "ssh2/channel.pyx":104
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_shell(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -2404,14 +4730,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
  *     def read(self, size_t size=1024):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 103, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 104, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":94
+  /* "ssh2/channel.pyx":95
  *         return handle_error_codes(rc)
  * 
  *     def shell(self):             # <<<<<<<<<<<<<<
@@ -2430,7 +4756,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":105
+/* "ssh2/channel.pyx":106
  *         return handle_error_codes(rc)
  * 
  *     def read(self, size_t size=1024):             # <<<<<<<<<<<<<<
@@ -2439,57 +4765,91 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_10shell(struct __pyx_obj_4ssh2
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_13read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_12read[] = "Channel.read(self, size_t size=1024)\nRead the stdout stream.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :param size: Max buffer size to read.\n        :type size: int\n\n        :rtype: (int, bytes)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_13read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_13read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_12read, "Channel.read(self, size_t size=1024)\nRead the stdout stream.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :param size: Max buffer size to read.\n        :type size: int\n\n        :rtype: (int, bytes)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_13read = {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_13read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_12read};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_13read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_size;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("read (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read") < 0)) __PYX_ERR(0, 105, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read") < 0)) __PYX_ERR(0, 106, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     if (values[0]) {
-      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L3_error)
+      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L3_error)
     } else {
       __pyx_v_size = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("read", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 105, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("read", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 106, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.read", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2497,6 +4857,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_13read(PyObject *__pyx_v_self,
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_12read(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_size);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2510,9 +4876,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_12read(struct __pyx_obj_4ssh2_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("read", 0);
+  __Pyx_RefNannySetupContext("read", 1);
 
-  /* "ssh2/channel.pyx":116
+  /* "ssh2/channel.pyx":117
  * 
  *         :rtype: (int, bytes)"""
  *         return self.read_ex(size=size, stream_id=0)             # <<<<<<<<<<<<<<
@@ -2520,16 +4886,16 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_12read(struct __pyx_obj_4ssh2_
  *     def read_ex(self, size_t size=1024, int stream_id=0):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_read_ex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_read_ex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_3) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_3) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stream_id, __pyx_int_0) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 116, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stream_id, __pyx_int_0) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -2537,7 +4903,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_12read(struct __pyx_obj_4ssh2_
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":105
+  /* "ssh2/channel.pyx":106
  *         return handle_error_codes(rc)
  * 
  *     def read(self, size_t size=1024):             # <<<<<<<<<<<<<<
@@ -2558,7 +4924,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_12read(struct __pyx_obj_4ssh2_
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":118
+/* "ssh2/channel.pyx":119
  *         return self.read_ex(size=size, stream_id=0)
  * 
  *     def read_ex(self, size_t size=1024, int stream_id=0):             # <<<<<<<<<<<<<<
@@ -2567,73 +4933,108 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_12read(struct __pyx_obj_4ssh2_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_15read_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_14read_ex[] = "Channel.read_ex(self, size_t size=1024, int stream_id=0)\nRead the stream with given id.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :param size: Max buffer size to read.\n        :type size: int\n\n        :rtype: (int, bytes)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_15read_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_15read_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_14read_ex, "Channel.read_ex(self, size_t size=1024, int stream_id=0)\nRead the stream with given id.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :param size: Max buffer size to read.\n        :type size: int\n\n        :rtype: (int, bytes)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_15read_ex = {"read_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_15read_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_14read_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_15read_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_size;
   int __pyx_v_stream_id;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("read_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_stream_id,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,&__pyx_n_s_stream_id,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stream_id);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stream_id);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_ex") < 0)) __PYX_ERR(0, 118, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read_ex") < 0)) __PYX_ERR(0, 119, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     if (values[0]) {
-      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error)
+      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)
     } else {
       __pyx_v_size = ((size_t)0x400);
     }
     if (values[1]) {
-      __pyx_v_stream_id = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L3_error)
+      __pyx_v_stream_id = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L3_error)
     } else {
       __pyx_v_stream_id = ((int)0);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("read_ex", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 118, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("read_ex", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 119, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.read_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2641,6 +5042,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_15read_ex(PyObject *__pyx_v_se
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_14read_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_size, __pyx_v_stream_id);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2666,9 +5073,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("read_ex", 0);
+  __Pyx_RefNannySetupContext("read_ex", 1);
 
-  /* "ssh2/channel.pyx":129
+  /* "ssh2/channel.pyx":130
  * 
  *         :rtype: (int, bytes)"""
  *         cdef bytes buf = b''             # <<<<<<<<<<<<<<
@@ -2678,7 +5085,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
   __Pyx_INCREF(__pyx_kp_b_);
   __pyx_v_buf = __pyx_kp_b_;
 
-  /* "ssh2/channel.pyx":132
+  /* "ssh2/channel.pyx":133
  *         cdef char *cbuf
  *         cdef ssize_t rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2688,12 +5095,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":133
+        /* "ssh2/channel.pyx":134
  *         cdef ssize_t rc
  *         with nogil:
  *             cbuf = <char *>malloc(sizeof(char)*size)             # <<<<<<<<<<<<<<
@@ -2702,17 +5110,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
  */
         __pyx_v_cbuf = ((char *)malloc(((sizeof(char)) * __pyx_v_size)));
 
-        /* "ssh2/channel.pyx":134
+        /* "ssh2/channel.pyx":135
  *         with nogil:
  *             cbuf = <char *>malloc(sizeof(char)*size)
  *             if cbuf is NULL:             # <<<<<<<<<<<<<<
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0);
-        if (__pyx_t_1) {
+        __pyx_t_1 = (__pyx_v_cbuf == NULL);
+        if (unlikely(__pyx_t_1)) {
 
-          /* "ssh2/channel.pyx":135
+          /* "ssh2/channel.pyx":136
  *             cbuf = <char *>malloc(sizeof(char)*size)
  *             if cbuf is NULL:
  *                 with gil:             # <<<<<<<<<<<<<<
@@ -2725,17 +5133,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
               #endif
               /*try:*/ {
 
-                /* "ssh2/channel.pyx":136
+                /* "ssh2/channel.pyx":137
  *             if cbuf is NULL:
  *                 with gil:
  *                     raise MemoryError             # <<<<<<<<<<<<<<
  *             rc = c_ssh2.libssh2_channel_read_ex(
  *                 self._channel, stream_id, cbuf, size)
  */
-                PyErr_NoMemory(); __PYX_ERR(0, 136, __pyx_L8_error)
+                PyErr_NoMemory(); __PYX_ERR(0, 137, __pyx_L8_error)
               }
 
-              /* "ssh2/channel.pyx":135
+              /* "ssh2/channel.pyx":136
  *             cbuf = <char *>malloc(sizeof(char)*size)
  *             if cbuf is NULL:
  *                 with gil:             # <<<<<<<<<<<<<<
@@ -2752,7 +5160,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
               }
           }
 
-          /* "ssh2/channel.pyx":134
+          /* "ssh2/channel.pyx":135
  *         with nogil:
  *             cbuf = <char *>malloc(sizeof(char)*size)
  *             if cbuf is NULL:             # <<<<<<<<<<<<<<
@@ -2761,7 +5169,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
  */
         }
 
-        /* "ssh2/channel.pyx":137
+        /* "ssh2/channel.pyx":138
  *                 with gil:
  *                     raise MemoryError
  *             rc = c_ssh2.libssh2_channel_read_ex(             # <<<<<<<<<<<<<<
@@ -2771,7 +5179,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
         __pyx_v_rc = libssh2_channel_read_ex(__pyx_v_self->_channel, __pyx_v_stream_id, __pyx_v_cbuf, __pyx_v_size);
       }
 
-      /* "ssh2/channel.pyx":132
+      /* "ssh2/channel.pyx":133
  *         cdef char *cbuf
  *         cdef ssize_t rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -2797,7 +5205,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
       }
   }
 
-  /* "ssh2/channel.pyx":139
+  /* "ssh2/channel.pyx":140
  *             rc = c_ssh2.libssh2_channel_read_ex(
  *                 self._channel, stream_id, cbuf, size)
  *         try:             # <<<<<<<<<<<<<<
@@ -2806,29 +5214,29 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
  */
   /*try:*/ {
 
-    /* "ssh2/channel.pyx":140
+    /* "ssh2/channel.pyx":141
  *                 self._channel, stream_id, cbuf, size)
  *         try:
  *             if rc > 0:             # <<<<<<<<<<<<<<
  *                 buf = cbuf[:rc]
  *         finally:
  */
-    __pyx_t_1 = ((__pyx_v_rc > 0) != 0);
+    __pyx_t_1 = (__pyx_v_rc > 0);
     if (__pyx_t_1) {
 
-      /* "ssh2/channel.pyx":141
+      /* "ssh2/channel.pyx":142
  *         try:
  *             if rc > 0:
  *                 buf = cbuf[:rc]             # <<<<<<<<<<<<<<
  *         finally:
  *             free(cbuf)
  */
-      __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_cbuf + 0, __pyx_v_rc - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L11_error)
+      __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_cbuf + 0, __pyx_v_rc - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF_SET(__pyx_v_buf, ((PyObject*)__pyx_t_2));
       __pyx_t_2 = 0;
 
-      /* "ssh2/channel.pyx":140
+      /* "ssh2/channel.pyx":141
  *                 self._channel, stream_id, cbuf, size)
  *         try:
  *             if rc > 0:             # <<<<<<<<<<<<<<
@@ -2838,7 +5246,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
     }
   }
 
-  /* "ssh2/channel.pyx":143
+  /* "ssh2/channel.pyx":144
  *                 buf = cbuf[:rc]
  *         finally:
  *             free(cbuf)             # <<<<<<<<<<<<<<
@@ -2885,16 +5293,16 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
     __pyx_L12:;
   }
 
-  /* "ssh2/channel.pyx":144
+  /* "ssh2/channel.pyx":145
  *         finally:
  *             free(cbuf)
  *         handle_error_codes(rc)             # <<<<<<<<<<<<<<
  *         return rc, buf
  * 
  */
-  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 144, __pyx_L1_error)
+  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 145, __pyx_L1_error)
 
-  /* "ssh2/channel.pyx":145
+  /* "ssh2/channel.pyx":146
  *             free(cbuf)
  *         handle_error_codes(rc)
  *         return rc, buf             # <<<<<<<<<<<<<<
@@ -2902,21 +5310,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
  *     def read_stderr(self, size_t size=1024):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_12);
   __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_buf);
   __Pyx_GIVEREF(__pyx_v_buf);
-  PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 146, __pyx_L1_error);
   __pyx_t_2 = 0;
   __pyx_r = __pyx_t_12;
   __pyx_t_12 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":118
+  /* "ssh2/channel.pyx":119
  *         return self.read_ex(size=size, stream_id=0)
  * 
  *     def read_ex(self, size_t size=1024, int stream_id=0):             # <<<<<<<<<<<<<<
@@ -2937,7 +5345,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":147
+/* "ssh2/channel.pyx":148
  *         return rc, buf
  * 
  *     def read_stderr(self, size_t size=1024):             # <<<<<<<<<<<<<<
@@ -2946,57 +5354,91 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_14read_ex(struct __pyx_obj_4ss
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_17read_stderr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_16read_stderr[] = "Channel.read_stderr(self, size_t size=1024)\nRead the stderr stream.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :rtype: (int, bytes)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_17read_stderr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_17read_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_16read_stderr, "Channel.read_stderr(self, size_t size=1024)\nRead the stderr stream.\n        Returns return code and output buffer tuple.\n\n        Return code is the size of the buffer when positive.\n        Negative values are error codes.\n\n        :rtype: (int, bytes)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_17read_stderr = {"read_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_17read_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_16read_stderr};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_17read_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_size;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("read_stderr (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_size,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_stderr") < 0)) __PYX_ERR(0, 147, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read_stderr") < 0)) __PYX_ERR(0, 148, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     if (values[0]) {
-      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L3_error)
+      __pyx_v_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
     } else {
       __pyx_v_size = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("read_stderr", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 147, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("read_stderr", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.read_stderr", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3004,6 +5446,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_17read_stderr(PyObject *__pyx_
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_16read_stderr(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_size);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3017,9 +5465,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_16read_stderr(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("read_stderr", 0);
+  __Pyx_RefNannySetupContext("read_stderr", 1);
 
-  /* "ssh2/channel.pyx":155
+  /* "ssh2/channel.pyx":156
  * 
  *         :rtype: (int, bytes)"""
  *         return self.read_ex(             # <<<<<<<<<<<<<<
@@ -3027,35 +5475,35 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_16read_stderr(struct __pyx_obj
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_read_ex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_read_ex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
 
-  /* "ssh2/channel.pyx":156
+  /* "ssh2/channel.pyx":157
  *         :rtype: (int, bytes)"""
  *         return self.read_ex(
  *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)             # <<<<<<<<<<<<<<
  * 
  *     def eof(self):
  */
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_3) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_t_3) < 0) __PYX_ERR(0, 157, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyInt_From_int(SSH_EXTENDED_DATA_STDERR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(SSH_EXTENDED_DATA_STDERR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stream_id, __pyx_t_3) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stream_id, __pyx_t_3) < 0) __PYX_ERR(0, 157, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "ssh2/channel.pyx":155
+  /* "ssh2/channel.pyx":156
  * 
  *         :rtype: (int, bytes)"""
  *         return self.read_ex(             # <<<<<<<<<<<<<<
  *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)
  * 
  */
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 156, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -3063,7 +5511,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_16read_stderr(struct __pyx_obj
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":147
+  /* "ssh2/channel.pyx":148
  *         return rc, buf
  * 
  *     def read_stderr(self, size_t size=1024):             # <<<<<<<<<<<<<<
@@ -3084,7 +5532,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_16read_stderr(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":158
+/* "ssh2/channel.pyx":159
  *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)
  * 
  *     def eof(self):             # <<<<<<<<<<<<<<
@@ -3093,12 +5541,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_16read_stderr(struct __pyx_obj
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_19eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_18eof[] = "Channel.eof(self)\nGet channel EOF status.\n\n        :rtype: bool";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_19eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_19eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_18eof, "Channel.eof(self)\nGet channel EOF status.\n\n        :rtype: bool");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_19eof = {"eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_19eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_18eof};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_19eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("eof (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("eof", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eof", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_18eof(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3115,9 +5591,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("eof", 0);
+  __Pyx_RefNannySetupContext("eof", 1);
 
-  /* "ssh2/channel.pyx":163
+  /* "ssh2/channel.pyx":164
  *         :rtype: bool"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3127,12 +5603,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":164
+        /* "ssh2/channel.pyx":165
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_eof(self._channel)             # <<<<<<<<<<<<<<
@@ -3142,7 +5619,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
         __pyx_v_rc = libssh2_channel_eof(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":163
+      /* "ssh2/channel.pyx":164
  *         :rtype: bool"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3161,7 +5638,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
       }
   }
 
-  /* "ssh2/channel.pyx":165
+  /* "ssh2/channel.pyx":166
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_eof(self._channel)
  *         return bool(rc)             # <<<<<<<<<<<<<<
@@ -3169,17 +5646,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
  *     def send_eof(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 166, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":158
+  /* "ssh2/channel.pyx":159
  *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)
  * 
  *     def eof(self):             # <<<<<<<<<<<<<<
@@ -3198,7 +5675,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":167
+/* "ssh2/channel.pyx":168
  *         return bool(rc)
  * 
  *     def send_eof(self):             # <<<<<<<<<<<<<<
@@ -3207,12 +5684,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_18eof(struct __pyx_obj_4ssh2_7
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_21send_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_20send_eof[] = "Channel.send_eof(self)\nTell the remote host that no further data will be sent on the\n        specified channel. Processes typically interpret this as a closed stdin\n        descriptor.\n\n        Returns 0 on success or negative on failure.\n        It returns ``LIBSSH2_ERROR_EAGAIN`` when it would otherwise block.\n\n        :rtype: int\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_21send_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_21send_eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_20send_eof, "Channel.send_eof(self)\nTell the remote host that no further data will be sent on the\n        specified channel. Processes typically interpret this as a closed stdin\n        descriptor.\n\n        Returns 0 on success or negative on failure.\n        It returns ``LIBSSH2_ERROR_EAGAIN`` when it would otherwise block.\n\n        :rtype: int\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_21send_eof = {"send_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_21send_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_20send_eof};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_21send_eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("send_eof (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("send_eof", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "send_eof", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_20send_eof(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3229,9 +5734,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("send_eof", 0);
+  __Pyx_RefNannySetupContext("send_eof", 1);
 
-  /* "ssh2/channel.pyx":178
+  /* "ssh2/channel.pyx":179
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3241,12 +5746,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":179
+        /* "ssh2/channel.pyx":180
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_send_eof(self._channel)             # <<<<<<<<<<<<<<
@@ -3256,7 +5762,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
         __pyx_v_rc = libssh2_channel_send_eof(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":178
+      /* "ssh2/channel.pyx":179
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3275,7 +5781,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/channel.pyx":180
+  /* "ssh2/channel.pyx":181
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_send_eof(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3283,14 +5789,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
  *     def wait_eof(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 180, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 181, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":167
+  /* "ssh2/channel.pyx":168
  *         return bool(rc)
  * 
  *     def send_eof(self):             # <<<<<<<<<<<<<<
@@ -3309,7 +5815,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":182
+/* "ssh2/channel.pyx":183
  *         return handle_error_codes(rc)
  * 
  *     def wait_eof(self):             # <<<<<<<<<<<<<<
@@ -3318,12 +5824,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_20send_eof(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_23wait_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_22wait_eof[] = "Channel.wait_eof(self)\nWait for the remote end to acknowledge an EOF request.\n\n        Returns 0 on success or negative on failure. It returns\n        :py:class:`ssh2.error_codes.LIBSSH2_ERROR_EAGAIN` when it\n        would otherwise block.\n\n        :rtype: int\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_23wait_eof(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_23wait_eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_22wait_eof, "Channel.wait_eof(self)\nWait for the remote end to acknowledge an EOF request.\n\n        Returns 0 on success or negative on failure. It returns\n        :py:class:`ssh2.error_codes.LIBSSH2_ERROR_EAGAIN` when it\n        would otherwise block.\n\n        :rtype: int\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_23wait_eof = {"wait_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_23wait_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_22wait_eof};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_23wait_eof(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("wait_eof (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("wait_eof", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "wait_eof", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_22wait_eof(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3340,9 +5874,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("wait_eof", 0);
+  __Pyx_RefNannySetupContext("wait_eof", 1);
 
-  /* "ssh2/channel.pyx":192
+  /* "ssh2/channel.pyx":193
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3352,12 +5886,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":193
+        /* "ssh2/channel.pyx":194
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_wait_eof(self._channel)             # <<<<<<<<<<<<<<
@@ -3367,7 +5902,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
         __pyx_v_rc = libssh2_channel_wait_eof(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":192
+      /* "ssh2/channel.pyx":193
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3386,7 +5921,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/channel.pyx":194
+  /* "ssh2/channel.pyx":195
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_wait_eof(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3394,14 +5929,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
  *     def close(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 194, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 195, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":182
+  /* "ssh2/channel.pyx":183
  *         return handle_error_codes(rc)
  * 
  *     def wait_eof(self):             # <<<<<<<<<<<<<<
@@ -3420,7 +5955,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":196
+/* "ssh2/channel.pyx":197
  *         return handle_error_codes(rc)
  * 
  *     def close(self):             # <<<<<<<<<<<<<<
@@ -3429,12 +5964,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_22wait_eof(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_25close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_24close[] = "Channel.close(self)\nClose channel. Typically done to be able to get exit status.";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_25close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_25close(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_24close, "Channel.close(self)\nClose channel. Typically done to be able to get exit status.");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_25close = {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_25close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_24close};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_25close(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("close", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_24close(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3451,9 +6014,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("close", 0);
+  __Pyx_RefNannySetupContext("close", 1);
 
-  /* "ssh2/channel.pyx":199
+  /* "ssh2/channel.pyx":200
  *         """Close channel. Typically done to be able to get exit status."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3463,12 +6026,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":200
+        /* "ssh2/channel.pyx":201
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_close(self._channel)             # <<<<<<<<<<<<<<
@@ -3478,7 +6042,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
         __pyx_v_rc = libssh2_channel_close(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":199
+      /* "ssh2/channel.pyx":200
  *         """Close channel. Typically done to be able to get exit status."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3497,7 +6061,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
       }
   }
 
-  /* "ssh2/channel.pyx":201
+  /* "ssh2/channel.pyx":202
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_close(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3505,14 +6069,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
  *     def flush(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 201, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":196
+  /* "ssh2/channel.pyx":197
  *         return handle_error_codes(rc)
  * 
  *     def close(self):             # <<<<<<<<<<<<<<
@@ -3531,7 +6095,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":203
+/* "ssh2/channel.pyx":204
  *         return handle_error_codes(rc)
  * 
  *     def flush(self):             # <<<<<<<<<<<<<<
@@ -3540,12 +6104,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_24close(struct __pyx_obj_4ssh2
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_27flush(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_26flush[] = "Channel.flush(self)\nFlush stdout stream";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_27flush(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_27flush(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_26flush, "Channel.flush(self)\nFlush stdout stream");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_27flush = {"flush", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_27flush, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_26flush};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_27flush(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("flush (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("flush", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "flush", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_26flush(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3562,9 +6154,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("flush", 0);
+  __Pyx_RefNannySetupContext("flush", 1);
 
-  /* "ssh2/channel.pyx":206
+  /* "ssh2/channel.pyx":207
  *         """Flush stdout stream"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3574,12 +6166,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":207
+        /* "ssh2/channel.pyx":208
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush(self._channel)             # <<<<<<<<<<<<<<
@@ -3589,7 +6182,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
         __pyx_v_rc = libssh2_channel_flush(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":206
+      /* "ssh2/channel.pyx":207
  *         """Flush stdout stream"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3608,7 +6201,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
       }
   }
 
-  /* "ssh2/channel.pyx":208
+  /* "ssh2/channel.pyx":209
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3616,14 +6209,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
  *     def flush_ex(self, int stream_id):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 208, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 209, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":203
+  /* "ssh2/channel.pyx":204
  *         return handle_error_codes(rc)
  * 
  *     def flush(self):             # <<<<<<<<<<<<<<
@@ -3642,7 +6235,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":210
+/* "ssh2/channel.pyx":211
  *         return handle_error_codes(rc)
  * 
  *     def flush_ex(self, int stream_id):             # <<<<<<<<<<<<<<
@@ -3651,28 +6244,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_26flush(struct __pyx_obj_4ssh2
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_29flush_ex(PyObject *__pyx_v_self, PyObject *__pyx_arg_stream_id); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_28flush_ex[] = "Channel.flush_ex(self, int stream_id)\nFlush stream with id";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_29flush_ex(PyObject *__pyx_v_self, PyObject *__pyx_arg_stream_id) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_29flush_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_28flush_ex, "Channel.flush_ex(self, int stream_id)\nFlush stream with id");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_29flush_ex = {"flush_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_29flush_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_28flush_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_29flush_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_stream_id;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("flush_ex (wrapper)", 0);
-  assert(__pyx_arg_stream_id); {
-    __pyx_v_stream_id = __Pyx_PyInt_As_int(__pyx_arg_stream_id); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 210, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stream_id,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stream_id)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 211, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "flush_ex") < 0)) __PYX_ERR(0, 211, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_stream_id = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 211, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("flush_ex", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 211, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.flush_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_28flush_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_stream_id));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_28flush_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_stream_id);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3686,9 +6349,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("flush_ex", 0);
+  __Pyx_RefNannySetupContext("flush_ex", 1);
 
-  /* "ssh2/channel.pyx":213
+  /* "ssh2/channel.pyx":214
  *         """Flush stream with id"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3698,12 +6361,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":214
+        /* "ssh2/channel.pyx":215
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush_ex(self._channel, stream_id)             # <<<<<<<<<<<<<<
@@ -3713,7 +6377,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
         __pyx_v_rc = libssh2_channel_flush_ex(__pyx_v_self->_channel, __pyx_v_stream_id);
       }
 
-      /* "ssh2/channel.pyx":213
+      /* "ssh2/channel.pyx":214
  *         """Flush stream with id"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3732,7 +6396,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/channel.pyx":215
+  /* "ssh2/channel.pyx":216
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush_ex(self._channel, stream_id)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3740,14 +6404,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
  *     def flush_stderr(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 215, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 216, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":210
+  /* "ssh2/channel.pyx":211
  *         return handle_error_codes(rc)
  * 
  *     def flush_ex(self, int stream_id):             # <<<<<<<<<<<<<<
@@ -3766,7 +6430,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":217
+/* "ssh2/channel.pyx":218
  *         return handle_error_codes(rc)
  * 
  *     def flush_stderr(self):             # <<<<<<<<<<<<<<
@@ -3775,12 +6439,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_28flush_ex(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_30flush_stderr[] = "Channel.flush_stderr(self)\nFlush stderr stream";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_30flush_stderr, "Channel.flush_stderr(self)\nFlush stderr stream");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_31flush_stderr = {"flush_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_30flush_stderr};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("flush_stderr (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("flush_stderr", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "flush_stderr", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3797,9 +6489,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("flush_stderr", 0);
+  __Pyx_RefNannySetupContext("flush_stderr", 1);
 
-  /* "ssh2/channel.pyx":220
+  /* "ssh2/channel.pyx":221
  *         """Flush stderr stream"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3809,12 +6501,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":221
+        /* "ssh2/channel.pyx":222
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush_stderr(self._channel)             # <<<<<<<<<<<<<<
@@ -3824,7 +6517,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
         __pyx_v_rc = libssh2_channel_flush_stderr(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":220
+      /* "ssh2/channel.pyx":221
  *         """Flush stderr stream"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3843,7 +6536,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
       }
   }
 
-  /* "ssh2/channel.pyx":222
+  /* "ssh2/channel.pyx":223
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_flush_stderr(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3851,14 +6544,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
  *     def wait_closed(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 222, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 223, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":217
+  /* "ssh2/channel.pyx":218
  *         return handle_error_codes(rc)
  * 
  *     def flush_stderr(self):             # <<<<<<<<<<<<<<
@@ -3877,7 +6570,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":224
+/* "ssh2/channel.pyx":225
  *         return handle_error_codes(rc)
  * 
  *     def wait_closed(self):             # <<<<<<<<<<<<<<
@@ -3886,12 +6579,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_30flush_stderr(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_33wait_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_32wait_closed[] = "Channel.wait_closed(self)\nWait for server to acknowledge channel close command.";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_33wait_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_33wait_closed(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_32wait_closed, "Channel.wait_closed(self)\nWait for server to acknowledge channel close command.");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_33wait_closed = {"wait_closed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_33wait_closed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_32wait_closed};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_33wait_closed(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("wait_closed (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("wait_closed", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "wait_closed", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_32wait_closed(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -3908,9 +6629,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("wait_closed", 0);
+  __Pyx_RefNannySetupContext("wait_closed", 1);
 
-  /* "ssh2/channel.pyx":227
+  /* "ssh2/channel.pyx":228
  *         """Wait for server to acknowledge channel close command."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3920,12 +6641,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":228
+        /* "ssh2/channel.pyx":229
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_wait_closed(self._channel)             # <<<<<<<<<<<<<<
@@ -3935,7 +6657,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
         __pyx_v_rc = libssh2_channel_wait_closed(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":227
+      /* "ssh2/channel.pyx":228
  *         """Wait for server to acknowledge channel close command."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3954,7 +6676,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
       }
   }
 
-  /* "ssh2/channel.pyx":229
+  /* "ssh2/channel.pyx":230
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_wait_closed(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -3962,14 +6684,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
  *     def get_exit_status(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 229, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 230, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":224
+  /* "ssh2/channel.pyx":225
  *         return handle_error_codes(rc)
  * 
  *     def wait_closed(self):             # <<<<<<<<<<<<<<
@@ -3988,7 +6710,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":231
+/* "ssh2/channel.pyx":232
  *         return handle_error_codes(rc)
  * 
  *     def get_exit_status(self):             # <<<<<<<<<<<<<<
@@ -3997,12 +6719,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_32wait_closed(struct __pyx_obj
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_34get_exit_status[] = "Channel.get_exit_status(self)\nGet exit status of command.\n\n        Note that ``0`` is also failure code for this function.\n\n        Best used in non-blocking mode to avoid it being impossible to tell if\n        ``0`` indicates failure or an actual exit status of ``0``";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_34get_exit_status, "Channel.get_exit_status(self)\nGet exit status of command.\n\n        Note that ``0`` is also failure code for this function.\n\n        Best used in non-blocking mode to avoid it being impossible to tell if\n        ``0`` indicates failure or an actual exit status of ``0``.\n\n        Exceptions are raised as with all functions in case of an SSH2Error.\n\n        :rtype: int\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_35get_exit_status = {"get_exit_status", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_34get_exit_status};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_exit_status (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_exit_status", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_exit_status", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_34get_exit_status(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -4019,39 +6769,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_34get_exit_status(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_exit_status", 0);
+  __Pyx_RefNannySetupContext("get_exit_status", 1);
 
-  /* "ssh2/channel.pyx":239
- *         ``0`` indicates failure or an actual exit status of ``0``"""
+  /* "ssh2/channel.pyx":245
+ *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
  *             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)
- *         return handle_error_codes(rc)
+ *         handle_error_codes(rc)
  */
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":240
+        /* "ssh2/channel.pyx":246
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)             # <<<<<<<<<<<<<<
- *         return handle_error_codes(rc)
- * 
+ *         handle_error_codes(rc)
+ *         return rc
  */
         __pyx_v_rc = libssh2_channel_get_exit_status(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":239
- *         ``0`` indicates failure or an actual exit status of ``0``"""
+      /* "ssh2/channel.pyx":245
+ *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
  *             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)
- *         return handle_error_codes(rc)
+ *         handle_error_codes(rc)
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -4065,22 +6816,30 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_34get_exit_status(struct __pyx
       }
   }
 
-  /* "ssh2/channel.pyx":241
+  /* "ssh2/channel.pyx":247
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)
- *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
+ *         handle_error_codes(rc)             # <<<<<<<<<<<<<<
+ *         return rc
+ * 
+ */
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 247, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":248
+ *             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)
+ *         handle_error_codes(rc)
+ *         return rc             # <<<<<<<<<<<<<<
  * 
  *     def get_exit_signal(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 241, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":231
+  /* "ssh2/channel.pyx":232
  *         return handle_error_codes(rc)
  * 
  *     def get_exit_status(self):             # <<<<<<<<<<<<<<
@@ -4099,8 +6858,8 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_34get_exit_status(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":243
- *         return handle_error_codes(rc)
+/* "ssh2/channel.pyx":250
+ *         return rc
  * 
  *     def get_exit_signal(self):             # <<<<<<<<<<<<<<
  *         """Get exit signal, message and language tag, if any, for command.
@@ -4108,12 +6867,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_34get_exit_status(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_36get_exit_signal[] = "Channel.get_exit_signal(self)\nGet exit signal, message and language tag, if any, for command.\n\n        Returns (`returncode``, ``exit signal``, ``error message``,\n          ``language tag``) tuple.\n\n        :rtype: tuple(int, bytes, bytes, bytes)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_36get_exit_signal, "Channel.get_exit_signal(self)\nGet exit signal, message and language tag, if any, for command.\n\n        Returns (`returncode``, ``exit signal``, ``error message``,\n          ``language tag``) tuple.\n\n        :rtype: tuple(int, bytes, bytes, bytes)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_37get_exit_signal = {"get_exit_signal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_36get_exit_signal};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_exit_signal (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_exit_signal", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_exit_signal", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -4144,19 +6931,19 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_exit_signal", 0);
+  __Pyx_RefNannySetupContext("get_exit_signal", 1);
 
-  /* "ssh2/channel.pyx":250
- * 
- *         :rtype: tuple(int, bytes, bytes, bytes)"""
+  /* "ssh2/channel.pyx":258
+ *         :rtype: tuple(int, bytes, bytes, bytes)
+ *         """
  *         cdef char *exitsignal = <char *>b'none'             # <<<<<<<<<<<<<<
  *         cdef size_t *exitsignal_len = <size_t *>0
  *         cdef char *errmsg = <char *>b'none'
  */
   __pyx_v_exitsignal = ((char *)((char *)"none"));
 
-  /* "ssh2/channel.pyx":251
- *         :rtype: tuple(int, bytes, bytes, bytes)"""
+  /* "ssh2/channel.pyx":259
+ *         """
  *         cdef char *exitsignal = <char *>b'none'
  *         cdef size_t *exitsignal_len = <size_t *>0             # <<<<<<<<<<<<<<
  *         cdef char *errmsg = <char *>b'none'
@@ -4164,7 +6951,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_exitsignal_len = ((size_t *)0);
 
-  /* "ssh2/channel.pyx":252
+  /* "ssh2/channel.pyx":260
  *         cdef char *exitsignal = <char *>b'none'
  *         cdef size_t *exitsignal_len = <size_t *>0
  *         cdef char *errmsg = <char *>b'none'             # <<<<<<<<<<<<<<
@@ -4173,7 +6960,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_errmsg = ((char *)((char *)"none"));
 
-  /* "ssh2/channel.pyx":253
+  /* "ssh2/channel.pyx":261
  *         cdef size_t *exitsignal_len = <size_t *>0
  *         cdef char *errmsg = <char *>b'none'
  *         cdef size_t *errmsg_len = <size_t *>0             # <<<<<<<<<<<<<<
@@ -4182,7 +6969,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_errmsg_len = ((size_t *)0);
 
-  /* "ssh2/channel.pyx":254
+  /* "ssh2/channel.pyx":262
  *         cdef char *errmsg = <char *>b'none'
  *         cdef size_t *errmsg_len = <size_t *>0
  *         cdef char *langtag = <char *>b'none'             # <<<<<<<<<<<<<<
@@ -4191,7 +6978,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_langtag = ((char *)((char *)"none"));
 
-  /* "ssh2/channel.pyx":255
+  /* "ssh2/channel.pyx":263
  *         cdef size_t *errmsg_len = <size_t *>0
  *         cdef char *langtag = <char *>b'none'
  *         cdef size_t *langtag_len = <size_t *>0             # <<<<<<<<<<<<<<
@@ -4200,7 +6987,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_langtag_len = ((size_t *)0);
 
-  /* "ssh2/channel.pyx":257
+  /* "ssh2/channel.pyx":265
  *         cdef size_t *langtag_len = <size_t *>0
  *         cdef int rc
  *         cdef bytes py_exitsignal = None             # <<<<<<<<<<<<<<
@@ -4210,7 +6997,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   __Pyx_INCREF(Py_None);
   __pyx_v_py_exitsignal = ((PyObject*)Py_None);
 
-  /* "ssh2/channel.pyx":258
+  /* "ssh2/channel.pyx":266
  *         cdef int rc
  *         cdef bytes py_exitsignal = None
  *         cdef bytes py_errmsg = None             # <<<<<<<<<<<<<<
@@ -4220,7 +7007,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   __Pyx_INCREF(Py_None);
   __pyx_v_py_errmsg = ((PyObject*)Py_None);
 
-  /* "ssh2/channel.pyx":259
+  /* "ssh2/channel.pyx":267
  *         cdef bytes py_exitsignal = None
  *         cdef bytes py_errmsg = None
  *         cdef bytes py_langtag = None             # <<<<<<<<<<<<<<
@@ -4230,7 +7017,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   __Pyx_INCREF(Py_None);
   __pyx_v_py_langtag = ((PyObject*)Py_None);
 
-  /* "ssh2/channel.pyx":260
+  /* "ssh2/channel.pyx":268
  *         cdef bytes py_errmsg = None
  *         cdef bytes py_langtag = None
  *         cdef size_t py_siglen = 0             # <<<<<<<<<<<<<<
@@ -4239,7 +7026,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_py_siglen = 0;
 
-  /* "ssh2/channel.pyx":261
+  /* "ssh2/channel.pyx":269
  *         cdef bytes py_langtag = None
  *         cdef size_t py_siglen = 0
  *         cdef size_t py_errlen = 0             # <<<<<<<<<<<<<<
@@ -4248,7 +7035,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_py_errlen = 0;
 
-  /* "ssh2/channel.pyx":262
+  /* "ssh2/channel.pyx":270
  *         cdef size_t py_siglen = 0
  *         cdef size_t py_errlen = 0
  *         cdef size_t py_langlen = 0             # <<<<<<<<<<<<<<
@@ -4257,7 +7044,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   __pyx_v_py_langlen = 0;
 
-  /* "ssh2/channel.pyx":263
+  /* "ssh2/channel.pyx":271
  *         cdef size_t py_errlen = 0
  *         cdef size_t py_langlen = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4267,12 +7054,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":264
+        /* "ssh2/channel.pyx":272
  *         cdef size_t py_langlen = 0
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_get_exit_signal(             # <<<<<<<<<<<<<<
@@ -4281,17 +7069,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
         __pyx_v_rc = libssh2_channel_get_exit_signal(__pyx_v_self->_channel, (&__pyx_v_exitsignal), __pyx_v_exitsignal_len, (&__pyx_v_errmsg), __pyx_v_errmsg_len, (&__pyx_v_langtag), __pyx_v_langtag_len);
 
-        /* "ssh2/channel.pyx":267
+        /* "ssh2/channel.pyx":275
  *                 self._channel, &exitsignal, exitsignal_len, &errmsg,
  *                 errmsg_len, &langtag, langtag_len)
  *             if exitsignal_len is not NULL:             # <<<<<<<<<<<<<<
  *                 py_siglen = <size_t>exitsignal_len
  *             if errmsg_len is not NULL:
  */
-        __pyx_t_1 = ((__pyx_v_exitsignal_len != NULL) != 0);
+        __pyx_t_1 = (__pyx_v_exitsignal_len != NULL);
         if (__pyx_t_1) {
 
-          /* "ssh2/channel.pyx":268
+          /* "ssh2/channel.pyx":276
  *                 errmsg_len, &langtag, langtag_len)
  *             if exitsignal_len is not NULL:
  *                 py_siglen = <size_t>exitsignal_len             # <<<<<<<<<<<<<<
@@ -4300,7 +7088,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
           __pyx_v_py_siglen = ((size_t)__pyx_v_exitsignal_len);
 
-          /* "ssh2/channel.pyx":267
+          /* "ssh2/channel.pyx":275
  *                 self._channel, &exitsignal, exitsignal_len, &errmsg,
  *                 errmsg_len, &langtag, langtag_len)
  *             if exitsignal_len is not NULL:             # <<<<<<<<<<<<<<
@@ -4309,17 +7097,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
         }
 
-        /* "ssh2/channel.pyx":269
+        /* "ssh2/channel.pyx":277
  *             if exitsignal_len is not NULL:
  *                 py_siglen = <size_t>exitsignal_len
  *             if errmsg_len is not NULL:             # <<<<<<<<<<<<<<
  *                 py_errlen = <size_t>errmsg_len
  *             if langtag_len is not NULL:
  */
-        __pyx_t_1 = ((__pyx_v_errmsg_len != NULL) != 0);
+        __pyx_t_1 = (__pyx_v_errmsg_len != NULL);
         if (__pyx_t_1) {
 
-          /* "ssh2/channel.pyx":270
+          /* "ssh2/channel.pyx":278
  *                 py_siglen = <size_t>exitsignal_len
  *             if errmsg_len is not NULL:
  *                 py_errlen = <size_t>errmsg_len             # <<<<<<<<<<<<<<
@@ -4328,7 +7116,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
           __pyx_v_py_errlen = ((size_t)__pyx_v_errmsg_len);
 
-          /* "ssh2/channel.pyx":269
+          /* "ssh2/channel.pyx":277
  *             if exitsignal_len is not NULL:
  *                 py_siglen = <size_t>exitsignal_len
  *             if errmsg_len is not NULL:             # <<<<<<<<<<<<<<
@@ -4337,17 +7125,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
         }
 
-        /* "ssh2/channel.pyx":271
+        /* "ssh2/channel.pyx":279
  *             if errmsg_len is not NULL:
  *                 py_errlen = <size_t>errmsg_len
  *             if langtag_len is not NULL:             # <<<<<<<<<<<<<<
  *                 py_langlen = <size_t>langtag_len
  *         if py_siglen > 0:
  */
-        __pyx_t_1 = ((__pyx_v_langtag_len != NULL) != 0);
+        __pyx_t_1 = (__pyx_v_langtag_len != NULL);
         if (__pyx_t_1) {
 
-          /* "ssh2/channel.pyx":272
+          /* "ssh2/channel.pyx":280
  *                 py_errlen = <size_t>errmsg_len
  *             if langtag_len is not NULL:
  *                 py_langlen = <size_t>langtag_len             # <<<<<<<<<<<<<<
@@ -4356,7 +7144,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
           __pyx_v_py_langlen = ((size_t)__pyx_v_langtag_len);
 
-          /* "ssh2/channel.pyx":271
+          /* "ssh2/channel.pyx":279
  *             if errmsg_len is not NULL:
  *                 py_errlen = <size_t>errmsg_len
  *             if langtag_len is not NULL:             # <<<<<<<<<<<<<<
@@ -4366,7 +7154,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
         }
       }
 
-      /* "ssh2/channel.pyx":263
+      /* "ssh2/channel.pyx":271
  *         cdef size_t py_errlen = 0
  *         cdef size_t py_langlen = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4385,29 +7173,29 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
       }
   }
 
-  /* "ssh2/channel.pyx":273
+  /* "ssh2/channel.pyx":281
  *             if langtag_len is not NULL:
  *                 py_langlen = <size_t>langtag_len
  *         if py_siglen > 0:             # <<<<<<<<<<<<<<
  *             py_exitsignal = exitsignal[:py_siglen]
  *         if py_errlen > 0:
  */
-  __pyx_t_1 = ((__pyx_v_py_siglen > 0) != 0);
+  __pyx_t_1 = (__pyx_v_py_siglen > 0);
   if (__pyx_t_1) {
 
-    /* "ssh2/channel.pyx":274
+    /* "ssh2/channel.pyx":282
  *                 py_langlen = <size_t>langtag_len
  *         if py_siglen > 0:
  *             py_exitsignal = exitsignal[:py_siglen]             # <<<<<<<<<<<<<<
  *         if py_errlen > 0:
  *             py_errmsg = errmsg[:py_errlen]
  */
-    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_exitsignal + 0, __pyx_v_py_siglen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_exitsignal + 0, __pyx_v_py_siglen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF_SET(__pyx_v_py_exitsignal, ((PyObject*)__pyx_t_2));
     __pyx_t_2 = 0;
 
-    /* "ssh2/channel.pyx":273
+    /* "ssh2/channel.pyx":281
  *             if langtag_len is not NULL:
  *                 py_langlen = <size_t>langtag_len
  *         if py_siglen > 0:             # <<<<<<<<<<<<<<
@@ -4416,29 +7204,29 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   }
 
-  /* "ssh2/channel.pyx":275
+  /* "ssh2/channel.pyx":283
  *         if py_siglen > 0:
  *             py_exitsignal = exitsignal[:py_siglen]
  *         if py_errlen > 0:             # <<<<<<<<<<<<<<
  *             py_errmsg = errmsg[:py_errlen]
  *         if py_langlen > 0:
  */
-  __pyx_t_1 = ((__pyx_v_py_errlen > 0) != 0);
+  __pyx_t_1 = (__pyx_v_py_errlen > 0);
   if (__pyx_t_1) {
 
-    /* "ssh2/channel.pyx":276
+    /* "ssh2/channel.pyx":284
  *             py_exitsignal = exitsignal[:py_siglen]
  *         if py_errlen > 0:
  *             py_errmsg = errmsg[:py_errlen]             # <<<<<<<<<<<<<<
  *         if py_langlen > 0:
  *             py_langtag = langtag[:py_langlen]
  */
-    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_errmsg + 0, __pyx_v_py_errlen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_errmsg + 0, __pyx_v_py_errlen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 284, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF_SET(__pyx_v_py_errmsg, ((PyObject*)__pyx_t_2));
     __pyx_t_2 = 0;
 
-    /* "ssh2/channel.pyx":275
+    /* "ssh2/channel.pyx":283
  *         if py_siglen > 0:
  *             py_exitsignal = exitsignal[:py_siglen]
  *         if py_errlen > 0:             # <<<<<<<<<<<<<<
@@ -4447,68 +7235,76 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
   }
 
-  /* "ssh2/channel.pyx":277
+  /* "ssh2/channel.pyx":285
  *         if py_errlen > 0:
  *             py_errmsg = errmsg[:py_errlen]
  *         if py_langlen > 0:             # <<<<<<<<<<<<<<
  *             py_langtag = langtag[:py_langlen]
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
+ *         handle_error_codes(rc)
  */
-  __pyx_t_1 = ((__pyx_v_py_langlen > 0) != 0);
+  __pyx_t_1 = (__pyx_v_py_langlen > 0);
   if (__pyx_t_1) {
 
-    /* "ssh2/channel.pyx":278
+    /* "ssh2/channel.pyx":286
  *             py_errmsg = errmsg[:py_errlen]
  *         if py_langlen > 0:
  *             py_langtag = langtag[:py_langlen]             # <<<<<<<<<<<<<<
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
- * 
+ *         handle_error_codes(rc)
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
  */
-    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_langtag + 0, __pyx_v_py_langlen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_langtag + 0, __pyx_v_py_langlen - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF_SET(__pyx_v_py_langtag, ((PyObject*)__pyx_t_2));
     __pyx_t_2 = 0;
 
-    /* "ssh2/channel.pyx":277
+    /* "ssh2/channel.pyx":285
  *         if py_errlen > 0:
  *             py_errmsg = errmsg[:py_errlen]
  *         if py_langlen > 0:             # <<<<<<<<<<<<<<
  *             py_langtag = langtag[:py_langlen]
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
+ *         handle_error_codes(rc)
  */
   }
 
-  /* "ssh2/channel.pyx":279
+  /* "ssh2/channel.pyx":287
  *         if py_langlen > 0:
  *             py_langtag = langtag[:py_langlen]
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag             # <<<<<<<<<<<<<<
+ *         handle_error_codes(rc)             # <<<<<<<<<<<<<<
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
+ * 
+ */
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 287, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":288
+ *             py_langtag = langtag[:py_langlen]
+ *         handle_error_codes(rc)
+ *         return rc, py_exitsignal, py_errmsg, py_langtag             # <<<<<<<<<<<<<<
  * 
  *     def setenv(self, varname not None, value not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 279, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 279, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_py_exitsignal);
   __Pyx_GIVEREF(__pyx_v_py_exitsignal);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_py_exitsignal);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_py_exitsignal)) __PYX_ERR(0, 288, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_py_errmsg);
   __Pyx_GIVEREF(__pyx_v_py_errmsg);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_py_errmsg);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_py_errmsg)) __PYX_ERR(0, 288, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_py_langtag);
   __Pyx_GIVEREF(__pyx_v_py_langtag);
-  PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_py_langtag);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_py_langtag)) __PYX_ERR(0, 288, __pyx_L1_error);
   __pyx_t_2 = 0;
   __pyx_r = __pyx_t_4;
   __pyx_t_4 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":243
- *         return handle_error_codes(rc)
+  /* "ssh2/channel.pyx":250
+ *         return rc
  * 
  *     def get_exit_signal(self):             # <<<<<<<<<<<<<<
  *         """Get exit signal, message and language tag, if any, for command.
@@ -4530,8 +7326,8 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":281
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
+/* "ssh2/channel.pyx":290
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
  * 
  *     def setenv(self, varname not None, value not None):             # <<<<<<<<<<<<<<
  *         """Set environment variable on channel.
@@ -4539,68 +7335,109 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_36get_exit_signal(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_39setenv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_38setenv[] = "Channel.setenv(self, varname, value)\nSet environment variable on channel.\n\n        :param varname: Name of variable to set.\n        :type varname: str\n        :param value: Value of variable.\n        :type value: str\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_39setenv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_39setenv(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_38setenv, "Channel.setenv(self, varname, value)\nSet environment variable on channel.\n\n        :param varname: Name of variable to set.\n        :type varname: str\n        :param value: Value of variable.\n        :type value: str\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_39setenv = {"setenv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_39setenv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_38setenv};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_39setenv(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_varname = 0;
   PyObject *__pyx_v_value = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("setenv (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_varname,&__pyx_n_s_value,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_varname,&__pyx_n_s_value,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_varname)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_varname)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 290, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 290, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("setenv", 1, 2, 2, 1); __PYX_ERR(0, 281, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("setenv", 1, 2, 2, 1); __PYX_ERR(0, 290, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setenv") < 0)) __PYX_ERR(0, 281, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setenv") < 0)) __PYX_ERR(0, 290, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_varname = values[0];
     __pyx_v_value = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("setenv", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 281, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("setenv", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 290, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.setenv", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_varname) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "varname"); __PYX_ERR(0, 281, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "varname"); __PYX_ERR(0, 290, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_value) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "value"); __PYX_ERR(0, 281, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "value"); __PYX_ERR(0, 290, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_38setenv(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_varname, __pyx_v_value);
 
@@ -4609,6 +7446,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_39setenv(PyObject *__pyx_v_sel
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4627,33 +7470,33 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("setenv", 0);
+  __Pyx_RefNannySetupContext("setenv", 1);
 
-  /* "ssh2/channel.pyx":291
+  /* "ssh2/channel.pyx":300
  *         :rtype: int"""
  *         cdef int rc
  *         cdef bytes b_varname = to_bytes(varname)             # <<<<<<<<<<<<<<
  *         cdef bytes b_value = to_bytes(value)
  *         cdef char *_varname = b_varname
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_varname = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":292
+  /* "ssh2/channel.pyx":301
  *         cdef int rc
  *         cdef bytes b_varname = to_bytes(varname)
  *         cdef bytes b_value = to_bytes(value)             # <<<<<<<<<<<<<<
  *         cdef char *_varname = b_varname
  *         cdef char *_value = b_value
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_value = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":293
+  /* "ssh2/channel.pyx":302
  *         cdef bytes b_varname = to_bytes(varname)
  *         cdef bytes b_value = to_bytes(value)
  *         cdef char *_varname = b_varname             # <<<<<<<<<<<<<<
@@ -4662,12 +7505,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
  */
   if (unlikely(__pyx_v_b_varname == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 293, __pyx_L1_error)
+    __PYX_ERR(0, 302, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_varname); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 293, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_varname); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 302, __pyx_L1_error)
   __pyx_v__varname = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":294
+  /* "ssh2/channel.pyx":303
  *         cdef bytes b_value = to_bytes(value)
  *         cdef char *_varname = b_varname
  *         cdef char *_value = b_value             # <<<<<<<<<<<<<<
@@ -4676,12 +7519,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
  */
   if (unlikely(__pyx_v_b_value == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 294, __pyx_L1_error)
+    __PYX_ERR(0, 303, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_value); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_value); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 303, __pyx_L1_error)
   __pyx_v__value = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":295
+  /* "ssh2/channel.pyx":304
  *         cdef char *_varname = b_varname
  *         cdef char *_value = b_value
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4691,12 +7534,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":296
+        /* "ssh2/channel.pyx":305
  *         cdef char *_value = b_value
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_setenv(             # <<<<<<<<<<<<<<
@@ -4706,7 +7550,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
         __pyx_v_rc = libssh2_channel_setenv(__pyx_v_self->_channel, __pyx_v__varname, __pyx_v__value);
       }
 
-      /* "ssh2/channel.pyx":295
+      /* "ssh2/channel.pyx":304
  *         cdef char *_varname = b_varname
  *         cdef char *_value = b_value
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4725,7 +7569,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
       }
   }
 
-  /* "ssh2/channel.pyx":298
+  /* "ssh2/channel.pyx":307
  *             rc = c_ssh2.libssh2_channel_setenv(
  *                 self._channel, _varname, _value)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -4733,15 +7577,15 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
  *     def window_read_ex(self, unsigned long read_avail,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 298, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 307, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 307, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":281
- *         return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
+  /* "ssh2/channel.pyx":290
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
  * 
  *     def setenv(self, varname not None, value not None):             # <<<<<<<<<<<<<<
  *         """Set environment variable on channel.
@@ -4761,7 +7605,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":300
+/* "ssh2/channel.pyx":309
  *         return handle_error_codes(rc)
  * 
  *     def window_read_ex(self, unsigned long read_avail,             # <<<<<<<<<<<<<<
@@ -4770,59 +7614,100 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_38setenv(struct __pyx_obj_4ssh
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_40window_read_ex[] = "Channel.window_read_ex(self, unsigned long read_avail, unsigned long window_size_initial)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_40window_read_ex, "Channel.window_read_ex(self, unsigned long read_avail, unsigned long window_size_initial)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_41window_read_ex = {"window_read_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_40window_read_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   unsigned long __pyx_v_read_avail;
   unsigned long __pyx_v_window_size_initial;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("window_read_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_read_avail,&__pyx_n_s_window_size_initial,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_read_avail,&__pyx_n_s_window_size_initial,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_read_avail)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_read_avail)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_window_size_initial)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_window_size_initial)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("window_read_ex", 1, 2, 2, 1); __PYX_ERR(0, 300, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("window_read_ex", 1, 2, 2, 1); __PYX_ERR(0, 309, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "window_read_ex") < 0)) __PYX_ERR(0, 300, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "window_read_ex") < 0)) __PYX_ERR(0, 309, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_read_avail = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_read_avail == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L3_error)
-    __pyx_v_window_size_initial = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_window_size_initial == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 301, __pyx_L3_error)
+    __pyx_v_read_avail = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_read_avail == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
+    __pyx_v_window_size_initial = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_window_size_initial == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("window_read_ex", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 300, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("window_read_ex", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 309, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.window_read_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4830,6 +7715,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex(PyObject *__p
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_read_avail, __pyx_v_window_size_initial);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4843,9 +7734,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("window_read_ex", 0);
+  __Pyx_RefNannySetupContext("window_read_ex", 1);
 
-  /* "ssh2/channel.pyx":303
+  /* "ssh2/channel.pyx":312
  *                        unsigned long window_size_initial):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4855,12 +7746,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":304
+        /* "ssh2/channel.pyx":313
  *         cdef unsigned long rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_read_ex(             # <<<<<<<<<<<<<<
@@ -4870,7 +7762,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
         __pyx_v_rc = libssh2_channel_window_read_ex(__pyx_v_self->_channel, (&__pyx_v_read_avail), (&__pyx_v_window_size_initial));
       }
 
-      /* "ssh2/channel.pyx":303
+      /* "ssh2/channel.pyx":312
  *                        unsigned long window_size_initial):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4889,7 +7781,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
       }
   }
 
-  /* "ssh2/channel.pyx":306
+  /* "ssh2/channel.pyx":315
  *             rc = c_ssh2.libssh2_channel_window_read_ex(
  *                 self._channel, &read_avail, &window_size_initial)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -4897,14 +7789,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
  *     def window_read(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 306, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 315, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":300
+  /* "ssh2/channel.pyx":309
  *         return handle_error_codes(rc)
  * 
  *     def window_read_ex(self, unsigned long read_avail,             # <<<<<<<<<<<<<<
@@ -4923,7 +7815,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":308
+/* "ssh2/channel.pyx":317
  *         return handle_error_codes(rc)
  * 
  *     def window_read(self):             # <<<<<<<<<<<<<<
@@ -4932,12 +7824,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_40window_read_ex(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_43window_read(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_42window_read[] = "Channel.window_read(self)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_43window_read(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_43window_read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_42window_read, "Channel.window_read(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_43window_read = {"window_read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_43window_read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_42window_read};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_43window_read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("window_read (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("window_read", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "window_read", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_42window_read(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -4954,9 +7874,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("window_read", 0);
+  __Pyx_RefNannySetupContext("window_read", 1);
 
-  /* "ssh2/channel.pyx":310
+  /* "ssh2/channel.pyx":319
  *     def window_read(self):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4966,12 +7886,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":311
+        /* "ssh2/channel.pyx":320
  *         cdef unsigned long rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_read(self._channel)             # <<<<<<<<<<<<<<
@@ -4981,7 +7902,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
         __pyx_v_rc = libssh2_channel_window_read(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":310
+      /* "ssh2/channel.pyx":319
  *     def window_read(self):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5000,7 +7921,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
       }
   }
 
-  /* "ssh2/channel.pyx":312
+  /* "ssh2/channel.pyx":321
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_read(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5008,14 +7929,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
  *     def window_write_ex(self, unsigned long window_size_initial):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 312, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 321, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":308
+  /* "ssh2/channel.pyx":317
  *         return handle_error_codes(rc)
  * 
  *     def window_read(self):             # <<<<<<<<<<<<<<
@@ -5034,7 +7955,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":314
+/* "ssh2/channel.pyx":323
  *         return handle_error_codes(rc)
  * 
  *     def window_write_ex(self, unsigned long window_size_initial):             # <<<<<<<<<<<<<<
@@ -5043,28 +7964,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_42window_read(struct __pyx_obj
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex(PyObject *__pyx_v_self, PyObject *__pyx_arg_window_size_initial); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_44window_write_ex[] = "Channel.window_write_ex(self, unsigned long window_size_initial)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex(PyObject *__pyx_v_self, PyObject *__pyx_arg_window_size_initial) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_44window_write_ex, "Channel.window_write_ex(self, unsigned long window_size_initial)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_45window_write_ex = {"window_write_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_44window_write_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   unsigned long __pyx_v_window_size_initial;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("window_write_ex (wrapper)", 0);
-  assert(__pyx_arg_window_size_initial); {
-    __pyx_v_window_size_initial = __Pyx_PyInt_As_unsigned_long(__pyx_arg_window_size_initial); if (unlikely((__pyx_v_window_size_initial == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 314, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_window_size_initial,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_window_size_initial)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 323, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "window_write_ex") < 0)) __PYX_ERR(0, 323, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_window_size_initial = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_window_size_initial == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 323, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("window_write_ex", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 323, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.window_write_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((unsigned long)__pyx_v_window_size_initial));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_window_size_initial);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5078,9 +8069,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("window_write_ex", 0);
+  __Pyx_RefNannySetupContext("window_write_ex", 1);
 
-  /* "ssh2/channel.pyx":316
+  /* "ssh2/channel.pyx":325
  *     def window_write_ex(self, unsigned long window_size_initial):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5090,12 +8081,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":317
+        /* "ssh2/channel.pyx":326
  *         cdef unsigned long rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_write_ex(             # <<<<<<<<<<<<<<
@@ -5105,7 +8097,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
         __pyx_v_rc = libssh2_channel_window_write_ex(__pyx_v_self->_channel, (&__pyx_v_window_size_initial));
       }
 
-      /* "ssh2/channel.pyx":316
+      /* "ssh2/channel.pyx":325
  *     def window_write_ex(self, unsigned long window_size_initial):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5124,7 +8116,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
       }
   }
 
-  /* "ssh2/channel.pyx":319
+  /* "ssh2/channel.pyx":328
  *             rc = c_ssh2.libssh2_channel_window_write_ex(
  *                 self._channel, &window_size_initial)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5132,14 +8124,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
  *     def window_write(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 319, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 328, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 328, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":314
+  /* "ssh2/channel.pyx":323
  *         return handle_error_codes(rc)
  * 
  *     def window_write_ex(self, unsigned long window_size_initial):             # <<<<<<<<<<<<<<
@@ -5158,7 +8150,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":321
+/* "ssh2/channel.pyx":330
  *         return handle_error_codes(rc)
  * 
  *     def window_write(self):             # <<<<<<<<<<<<<<
@@ -5167,14 +8159,42 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_44window_write_ex(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_47window_write(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_46window_write[] = "Channel.window_write(self)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_47window_write(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_47window_write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_46window_write, "Channel.window_write(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_47window_write = {"window_write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_47window_write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_46window_write};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_47window_write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("window_write (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_46window_write(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
-
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("window_write", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "window_write", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_46window_write(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
+
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -5189,9 +8209,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("window_write", 0);
+  __Pyx_RefNannySetupContext("window_write", 1);
 
-  /* "ssh2/channel.pyx":323
+  /* "ssh2/channel.pyx":332
  *     def window_write(self):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5201,12 +8221,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":324
+        /* "ssh2/channel.pyx":333
  *         cdef unsigned long rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_write(self._channel)             # <<<<<<<<<<<<<<
@@ -5216,7 +8237,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
         __pyx_v_rc = libssh2_channel_window_write(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":323
+      /* "ssh2/channel.pyx":332
  *     def window_write(self):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5235,7 +8256,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
       }
   }
 
-  /* "ssh2/channel.pyx":325
+  /* "ssh2/channel.pyx":334
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_window_write(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5243,14 +8264,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
  *     def receive_window_adjust(self, unsigned long adjustment,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 325, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 325, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 334, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":321
+  /* "ssh2/channel.pyx":330
  *         return handle_error_codes(rc)
  * 
  *     def window_write(self):             # <<<<<<<<<<<<<<
@@ -5269,7 +8290,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":327
+/* "ssh2/channel.pyx":336
  *         return handle_error_codes(rc)
  * 
  *     def receive_window_adjust(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
@@ -5278,59 +8299,100 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_46window_write(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_48receive_window_adjust[] = "Channel.receive_window_adjust(self, unsigned long adjustment, unsigned long force)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_48receive_window_adjust, "Channel.receive_window_adjust(self, unsigned long adjustment, unsigned long force)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_49receive_window_adjust = {"receive_window_adjust", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_48receive_window_adjust};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   unsigned long __pyx_v_adjustment;
   unsigned long __pyx_v_force;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("receive_window_adjust (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_adjustment,&__pyx_n_s_force,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_adjustment,&__pyx_n_s_force,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_adjustment)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_adjustment)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_force)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("receive_window_adjust", 1, 2, 2, 1); __PYX_ERR(0, 327, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("receive_window_adjust", 1, 2, 2, 1); __PYX_ERR(0, 336, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "receive_window_adjust") < 0)) __PYX_ERR(0, 327, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "receive_window_adjust") < 0)) __PYX_ERR(0, 336, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_adjustment = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_adjustment == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 327, __pyx_L3_error)
-    __pyx_v_force = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_force == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 328, __pyx_L3_error)
+    __pyx_v_adjustment = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_adjustment == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L3_error)
+    __pyx_v_force = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_force == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("receive_window_adjust", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 327, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("receive_window_adjust", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 336, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.receive_window_adjust", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -5338,6 +8400,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust(PyObje
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_adjustment, __pyx_v_force);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5351,9 +8419,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("receive_window_adjust", 0);
+  __Pyx_RefNannySetupContext("receive_window_adjust", 1);
 
-  /* "ssh2/channel.pyx":330
+  /* "ssh2/channel.pyx":339
  *                               unsigned long force):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5363,12 +8431,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":331
+        /* "ssh2/channel.pyx":340
  *         cdef unsigned long rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_receive_window_adjust(             # <<<<<<<<<<<<<<
@@ -5378,7 +8447,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
         __pyx_v_rc = libssh2_channel_receive_window_adjust(__pyx_v_self->_channel, __pyx_v_adjustment, __pyx_v_force);
       }
 
-      /* "ssh2/channel.pyx":330
+      /* "ssh2/channel.pyx":339
  *                               unsigned long force):
  *         cdef unsigned long rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5397,7 +8466,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
       }
   }
 
-  /* "ssh2/channel.pyx":333
+  /* "ssh2/channel.pyx":342
  *             rc = c_ssh2.libssh2_channel_receive_window_adjust(
  *                 self._channel, adjustment, force)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5405,14 +8474,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
  *     def receive_window_adjust2(self, unsigned long adjustment,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 333, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 342, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 342, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":327
+  /* "ssh2/channel.pyx":336
  *         return handle_error_codes(rc)
  * 
  *     def receive_window_adjust(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
@@ -5431,7 +8500,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":335
+/* "ssh2/channel.pyx":344
  *         return handle_error_codes(rc)
  * 
  *     def receive_window_adjust2(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
@@ -5440,59 +8509,100 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_48receive_window_adjust(struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_50receive_window_adjust2[] = "Channel.receive_window_adjust2(self, unsigned long adjustment, unsigned long force)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_50receive_window_adjust2, "Channel.receive_window_adjust2(self, unsigned long adjustment, unsigned long force)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_51receive_window_adjust2 = {"receive_window_adjust2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_50receive_window_adjust2};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   unsigned long __pyx_v_adjustment;
   unsigned long __pyx_v_force;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("receive_window_adjust2 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_adjustment,&__pyx_n_s_force,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_adjustment,&__pyx_n_s_force,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_adjustment)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_adjustment)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_force)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("receive_window_adjust2", 1, 2, 2, 1); __PYX_ERR(0, 335, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("receive_window_adjust2", 1, 2, 2, 1); __PYX_ERR(0, 344, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "receive_window_adjust2") < 0)) __PYX_ERR(0, 335, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "receive_window_adjust2") < 0)) __PYX_ERR(0, 344, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_adjustment = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_adjustment == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 335, __pyx_L3_error)
-    __pyx_v_force = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_force == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L3_error)
+    __pyx_v_adjustment = __Pyx_PyInt_As_unsigned_long(values[0]); if (unlikely((__pyx_v_adjustment == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 344, __pyx_L3_error)
+    __pyx_v_force = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_force == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 345, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("receive_window_adjust2", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 335, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("receive_window_adjust2", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 344, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.receive_window_adjust2", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -5500,6 +8610,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2(PyObj
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_adjustment, __pyx_v_force);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5514,9 +8630,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("receive_window_adjust2", 0);
+  __Pyx_RefNannySetupContext("receive_window_adjust2", 1);
 
-  /* "ssh2/channel.pyx":338
+  /* "ssh2/channel.pyx":347
  *                                unsigned long force):
  *         cdef unsigned long rc
  *         cdef unsigned int storewindow = 0             # <<<<<<<<<<<<<<
@@ -5525,7 +8641,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
  */
   __pyx_v_storewindow = 0;
 
-  /* "ssh2/channel.pyx":339
+  /* "ssh2/channel.pyx":348
  *         cdef unsigned long rc
  *         cdef unsigned int storewindow = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5535,12 +8651,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":340
+        /* "ssh2/channel.pyx":349
  *         cdef unsigned int storewindow = 0
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_receive_window_adjust2(             # <<<<<<<<<<<<<<
@@ -5550,7 +8667,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
         __pyx_v_rc = libssh2_channel_receive_window_adjust2(__pyx_v_self->_channel, __pyx_v_adjustment, __pyx_v_force, (&__pyx_v_storewindow));
       }
 
-      /* "ssh2/channel.pyx":339
+      /* "ssh2/channel.pyx":348
  *         cdef unsigned long rc
  *         cdef unsigned int storewindow = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5569,7 +8686,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
       }
   }
 
-  /* "ssh2/channel.pyx":342
+  /* "ssh2/channel.pyx":351
  *             rc = c_ssh2.libssh2_channel_receive_window_adjust2(
  *                 self._channel, adjustment, force, &storewindow)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5577,14 +8694,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
  *     def write(self, buf not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 342, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 342, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 351, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 351, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":335
+  /* "ssh2/channel.pyx":344
  *         return handle_error_codes(rc)
  * 
  *     def receive_window_adjust2(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
@@ -5603,7 +8720,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":344
+/* "ssh2/channel.pyx":353
  *         return handle_error_codes(rc)
  * 
  *     def write(self, buf not None):             # <<<<<<<<<<<<<<
@@ -5612,25 +8729,105 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_50receive_window_adjust2(struc
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_53write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_52write[] = "Channel.write(self, buf)\nWrite buffer to stdin.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_53write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_53write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_52write, "Channel.write(self, buf)\nWrite buffer to stdin.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_53write = {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_53write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_52write};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_53write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_buf = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("write (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 353, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write") < 0)) __PYX_ERR(0, 353, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_buf = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("write", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 353, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_buf) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 344, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 353, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_52write(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_buf));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_52write(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_buf);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5655,21 +8852,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("write", 0);
+  __Pyx_RefNannySetupContext("write", 1);
 
-  /* "ssh2/channel.pyx":369
+  /* "ssh2/channel.pyx":378
  *         :rtype: tuple(int, int)
  *         """
  *         cdef bytes b_buf = to_bytes(buf)             # <<<<<<<<<<<<<<
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_buf = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":370
+  /* "ssh2/channel.pyx":379
  *         """
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf             # <<<<<<<<<<<<<<
@@ -5678,12 +8875,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 370, __pyx_L1_error)
+    __PYX_ERR(0, 379, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 370, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L1_error)
   __pyx_v__buf = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":371
+  /* "ssh2/channel.pyx":380
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)             # <<<<<<<<<<<<<<
@@ -5692,12 +8889,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(0, 371, __pyx_L1_error)
+    __PYX_ERR(0, 380, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 371, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 380, __pyx_L1_error)
   __pyx_v_buf_remainder = __pyx_t_3;
 
-  /* "ssh2/channel.pyx":372
+  /* "ssh2/channel.pyx":381
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  *         cdef size_t buf_tot_size = buf_remainder             # <<<<<<<<<<<<<<
@@ -5706,7 +8903,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
   __pyx_v_buf_tot_size = __pyx_v_buf_remainder;
 
-  /* "ssh2/channel.pyx":374
+  /* "ssh2/channel.pyx":383
  *         cdef size_t buf_tot_size = buf_remainder
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0             # <<<<<<<<<<<<<<
@@ -5715,7 +8912,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
   __pyx_v_bytes_written = 0;
 
-  /* "ssh2/channel.pyx":375
+  /* "ssh2/channel.pyx":384
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5725,12 +8922,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":376
+        /* "ssh2/channel.pyx":385
  *         cdef size_t bytes_written = 0
  *         with nogil:
  *             while buf_remainder > 0:             # <<<<<<<<<<<<<<
@@ -5738,10 +8936,10 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  *                     self._channel, _buf, buf_remainder)
  */
         while (1) {
-          __pyx_t_4 = ((__pyx_v_buf_remainder > 0) != 0);
+          __pyx_t_4 = (__pyx_v_buf_remainder > 0);
           if (!__pyx_t_4) break;
 
-          /* "ssh2/channel.pyx":377
+          /* "ssh2/channel.pyx":386
  *         with nogil:
  *             while buf_remainder > 0:
  *                 rc = c_ssh2.libssh2_channel_write(             # <<<<<<<<<<<<<<
@@ -5750,25 +8948,25 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
           __pyx_v_rc = libssh2_channel_write(__pyx_v_self->_channel, __pyx_v__buf, __pyx_v_buf_remainder);
 
-          /* "ssh2/channel.pyx":379
+          /* "ssh2/channel.pyx":388
  *                 rc = c_ssh2.libssh2_channel_write(
  *                     self._channel, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     # Error that will raise exception
  *                     with gil:
  */
-          __pyx_t_5 = ((__pyx_v_rc < 0) != 0);
+          __pyx_t_5 = (__pyx_v_rc < 0);
           if (__pyx_t_5) {
           } else {
             __pyx_t_4 = __pyx_t_5;
             goto __pyx_L9_bool_binop_done;
           }
-          __pyx_t_5 = ((__pyx_v_rc != LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_5 = (__pyx_v_rc != LIBSSH2_ERROR_EAGAIN);
           __pyx_t_4 = __pyx_t_5;
           __pyx_L9_bool_binop_done:;
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":381
+            /* "ssh2/channel.pyx":390
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -5781,7 +8979,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
                 #endif
                 /*try:*/ {
 
-                  /* "ssh2/channel.pyx":382
+                  /* "ssh2/channel.pyx":391
  *                     # Error that will raise exception
  *                     with gil:
  *                         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5789,15 +8987,15 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  *                     break
  */
                   __Pyx_XDECREF(__pyx_r);
-                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 382, __pyx_L14_error)
-                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 382, __pyx_L14_error)
+                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 391, __pyx_L14_error)
+                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 391, __pyx_L14_error)
                   __Pyx_GOTREF(__pyx_t_1);
                   __pyx_r = __pyx_t_1;
                   __pyx_t_1 = 0;
                   goto __pyx_L13_return;
                 }
 
-                /* "ssh2/channel.pyx":381
+                /* "ssh2/channel.pyx":390
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -5820,7 +9018,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
                 }
             }
 
-            /* "ssh2/channel.pyx":379
+            /* "ssh2/channel.pyx":388
  *                 rc = c_ssh2.libssh2_channel_write(
  *                     self._channel, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -5829,17 +9027,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
           }
 
-          /* "ssh2/channel.pyx":383
+          /* "ssh2/channel.pyx":392
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     break
  *                 _buf += rc
  */
-          __pyx_t_4 = ((__pyx_v_rc == LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_4 = (__pyx_v_rc == LIBSSH2_ERROR_EAGAIN);
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":384
+            /* "ssh2/channel.pyx":393
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break             # <<<<<<<<<<<<<<
@@ -5848,7 +9046,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
             goto __pyx_L7_break;
 
-            /* "ssh2/channel.pyx":383
+            /* "ssh2/channel.pyx":392
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -5857,7 +9055,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
           }
 
-          /* "ssh2/channel.pyx":385
+          /* "ssh2/channel.pyx":394
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break
  *                 _buf += rc             # <<<<<<<<<<<<<<
@@ -5866,7 +9064,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
           __pyx_v__buf = (__pyx_v__buf + __pyx_v_rc);
 
-          /* "ssh2/channel.pyx":386
+          /* "ssh2/channel.pyx":395
  *                     break
  *                 _buf += rc
  *                 buf_remainder -= rc             # <<<<<<<<<<<<<<
@@ -5877,7 +9075,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
         }
         __pyx_L7_break:;
 
-        /* "ssh2/channel.pyx":387
+        /* "ssh2/channel.pyx":396
  *                 _buf += rc
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder             # <<<<<<<<<<<<<<
@@ -5887,7 +9085,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
         __pyx_v_bytes_written = (__pyx_v_buf_tot_size - __pyx_v_buf_remainder);
       }
 
-      /* "ssh2/channel.pyx":375
+      /* "ssh2/channel.pyx":384
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5920,7 +9118,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
       }
   }
 
-  /* "ssh2/channel.pyx":388
+  /* "ssh2/channel.pyx":397
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder
  *         return rc, bytes_written             # <<<<<<<<<<<<<<
@@ -5928,23 +9126,23 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  *     def write_ex(self, int stream_id, buf not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error)
+  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 388, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 388, __pyx_L1_error)
+  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_7);
-  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 397, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_t_7 = 0;
   __pyx_r = __pyx_t_8;
   __pyx_t_8 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":344
+  /* "ssh2/channel.pyx":353
  *         return handle_error_codes(rc)
  * 
  *     def write(self, buf not None):             # <<<<<<<<<<<<<<
@@ -5966,7 +9164,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":390
+/* "ssh2/channel.pyx":399
  *         return rc, bytes_written
  * 
  *     def write_ex(self, int stream_id, buf not None):             # <<<<<<<<<<<<<<
@@ -5975,65 +9173,106 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_52write(struct __pyx_obj_4ssh2
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_55write_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_54write_ex[] = "Channel.write_ex(self, int stream_id, buf)\nWrite buffer to specified stream id.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to the function, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param stream_id: Id of stream to write to\n        :type stream_id: int\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_55write_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_55write_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_54write_ex, "Channel.write_ex(self, int stream_id, buf)\nWrite buffer to specified stream id.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to the function, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param stream_id: Id of stream to write to\n        :type stream_id: int\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_55write_ex = {"write_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_55write_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_54write_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_55write_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_stream_id;
   PyObject *__pyx_v_buf = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("write_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stream_id,&__pyx_n_s_buf,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stream_id,&__pyx_n_s_buf,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stream_id)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stream_id)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buf)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("write_ex", 1, 2, 2, 1); __PYX_ERR(0, 390, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("write_ex", 1, 2, 2, 1); __PYX_ERR(0, 399, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "write_ex") < 0)) __PYX_ERR(0, 390, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write_ex") < 0)) __PYX_ERR(0, 399, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_stream_id = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 390, __pyx_L3_error)
+    __pyx_v_stream_id = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_stream_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L3_error)
     __pyx_v_buf = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("write_ex", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 390, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("write_ex", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 399, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.write_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_buf) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 390, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 399, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_54write_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_stream_id, __pyx_v_buf);
 
@@ -6042,6 +9281,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_55write_ex(PyObject *__pyx_v_s
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6066,21 +9311,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("write_ex", 0);
+  __Pyx_RefNannySetupContext("write_ex", 1);
 
-  /* "ssh2/channel.pyx":417
+  /* "ssh2/channel.pyx":426
  *         :rtype: tuple(int, int)
  *         """
  *         cdef bytes b_buf = to_bytes(buf)             # <<<<<<<<<<<<<<
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_buf = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":418
+  /* "ssh2/channel.pyx":427
  *         """
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf             # <<<<<<<<<<<<<<
@@ -6089,12 +9334,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 418, __pyx_L1_error)
+    __PYX_ERR(0, 427, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 418, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 427, __pyx_L1_error)
   __pyx_v__buf = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":419
+  /* "ssh2/channel.pyx":428
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)             # <<<<<<<<<<<<<<
@@ -6103,12 +9348,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(0, 419, __pyx_L1_error)
+    __PYX_ERR(0, 428, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 419, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 428, __pyx_L1_error)
   __pyx_v_buf_remainder = __pyx_t_3;
 
-  /* "ssh2/channel.pyx":420
+  /* "ssh2/channel.pyx":429
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  *         cdef size_t buf_tot_size = buf_remainder             # <<<<<<<<<<<<<<
@@ -6117,7 +9362,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
   __pyx_v_buf_tot_size = __pyx_v_buf_remainder;
 
-  /* "ssh2/channel.pyx":422
+  /* "ssh2/channel.pyx":431
  *         cdef size_t buf_tot_size = buf_remainder
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0             # <<<<<<<<<<<<<<
@@ -6126,7 +9371,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
   __pyx_v_bytes_written = 0;
 
-  /* "ssh2/channel.pyx":423
+  /* "ssh2/channel.pyx":432
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6136,12 +9381,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":425
+        /* "ssh2/channel.pyx":434
  *         with nogil:
  *             # Write until buffer has been fully written or socket is blocked
  *             while buf_remainder > 0:             # <<<<<<<<<<<<<<
@@ -6149,10 +9395,10 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  *                     self._channel, stream_id, _buf, buf_remainder)
  */
         while (1) {
-          __pyx_t_4 = ((__pyx_v_buf_remainder > 0) != 0);
+          __pyx_t_4 = (__pyx_v_buf_remainder > 0);
           if (!__pyx_t_4) break;
 
-          /* "ssh2/channel.pyx":426
+          /* "ssh2/channel.pyx":435
  *             # Write until buffer has been fully written or socket is blocked
  *             while buf_remainder > 0:
  *                 rc = c_ssh2.libssh2_channel_write_ex(             # <<<<<<<<<<<<<<
@@ -6161,25 +9407,25 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
           __pyx_v_rc = libssh2_channel_write_ex(__pyx_v_self->_channel, __pyx_v_stream_id, __pyx_v__buf, __pyx_v_buf_remainder);
 
-          /* "ssh2/channel.pyx":428
+          /* "ssh2/channel.pyx":437
  *                 rc = c_ssh2.libssh2_channel_write_ex(
  *                     self._channel, stream_id, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     # Error that will raise exception
  *                     with gil:
  */
-          __pyx_t_5 = ((__pyx_v_rc < 0) != 0);
+          __pyx_t_5 = (__pyx_v_rc < 0);
           if (__pyx_t_5) {
           } else {
             __pyx_t_4 = __pyx_t_5;
             goto __pyx_L9_bool_binop_done;
           }
-          __pyx_t_5 = ((__pyx_v_rc != LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_5 = (__pyx_v_rc != LIBSSH2_ERROR_EAGAIN);
           __pyx_t_4 = __pyx_t_5;
           __pyx_L9_bool_binop_done:;
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":430
+            /* "ssh2/channel.pyx":439
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -6192,7 +9438,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
                 #endif
                 /*try:*/ {
 
-                  /* "ssh2/channel.pyx":431
+                  /* "ssh2/channel.pyx":440
  *                     # Error that will raise exception
  *                     with gil:
  *                         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -6200,15 +9446,15 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  *                     break
  */
                   __Pyx_XDECREF(__pyx_r);
-                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 431, __pyx_L14_error)
-                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L14_error)
+                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 440, __pyx_L14_error)
+                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 440, __pyx_L14_error)
                   __Pyx_GOTREF(__pyx_t_1);
                   __pyx_r = __pyx_t_1;
                   __pyx_t_1 = 0;
                   goto __pyx_L13_return;
                 }
 
-                /* "ssh2/channel.pyx":430
+                /* "ssh2/channel.pyx":439
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -6231,7 +9477,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
                 }
             }
 
-            /* "ssh2/channel.pyx":428
+            /* "ssh2/channel.pyx":437
  *                 rc = c_ssh2.libssh2_channel_write_ex(
  *                     self._channel, stream_id, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -6240,17 +9486,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
           }
 
-          /* "ssh2/channel.pyx":432
+          /* "ssh2/channel.pyx":441
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     break
  *                 _buf += rc
  */
-          __pyx_t_4 = ((__pyx_v_rc == LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_4 = (__pyx_v_rc == LIBSSH2_ERROR_EAGAIN);
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":433
+            /* "ssh2/channel.pyx":442
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break             # <<<<<<<<<<<<<<
@@ -6259,7 +9505,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
             goto __pyx_L7_break;
 
-            /* "ssh2/channel.pyx":432
+            /* "ssh2/channel.pyx":441
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -6268,7 +9514,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
           }
 
-          /* "ssh2/channel.pyx":434
+          /* "ssh2/channel.pyx":443
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break
  *                 _buf += rc             # <<<<<<<<<<<<<<
@@ -6277,7 +9523,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
           __pyx_v__buf = (__pyx_v__buf + __pyx_v_rc);
 
-          /* "ssh2/channel.pyx":435
+          /* "ssh2/channel.pyx":444
  *                     break
  *                 _buf += rc
  *                 buf_remainder -= rc             # <<<<<<<<<<<<<<
@@ -6288,7 +9534,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
         }
         __pyx_L7_break:;
 
-        /* "ssh2/channel.pyx":436
+        /* "ssh2/channel.pyx":445
  *                 _buf += rc
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder             # <<<<<<<<<<<<<<
@@ -6298,7 +9544,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
         __pyx_v_bytes_written = (__pyx_v_buf_tot_size - __pyx_v_buf_remainder);
       }
 
-      /* "ssh2/channel.pyx":423
+      /* "ssh2/channel.pyx":432
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6331,7 +9577,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/channel.pyx":437
+  /* "ssh2/channel.pyx":446
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder
  *         return rc, bytes_written             # <<<<<<<<<<<<<<
@@ -6339,23 +9585,23 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  *     def write_stderr(self, buf not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 437, __pyx_L1_error)
+  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 437, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 437, __pyx_L1_error)
+  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_7);
-  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 446, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_t_7 = 0;
   __pyx_r = __pyx_t_8;
   __pyx_t_8 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":390
+  /* "ssh2/channel.pyx":399
  *         return rc, bytes_written
  * 
  *     def write_ex(self, int stream_id, buf not None):             # <<<<<<<<<<<<<<
@@ -6377,7 +9623,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":439
+/* "ssh2/channel.pyx":448
  *         return rc, bytes_written
  * 
  *     def write_stderr(self, buf not None):             # <<<<<<<<<<<<<<
@@ -6386,25 +9632,105 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_54write_ex(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_57write_stderr(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_56write_stderr[] = "Channel.write_stderr(self, buf)\nWrite buffer to stderr.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_57write_stderr(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_57write_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_56write_stderr, "Channel.write_stderr(self, buf)\nWrite buffer to stderr.\n\n        Returns tuple of (``return_code``, ``bytes_written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``return_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        .. note::\n          While this function handles unicode strings for ``buf``\n          argument, ``bytes_written`` offset will always be for the *bytes*\n          representation thereof as returned by the C function calls which only\n          handle byte strings.\n\n        :param buf: Buffer to write\n        :type buf: str\n\n        :rtype: tuple(int, int)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_57write_stderr = {"write_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_57write_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_56write_stderr};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_57write_stderr(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_buf = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("write_stderr (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write_stderr") < 0)) __PYX_ERR(0, 448, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_buf = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("write_stderr", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 448, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.write_stderr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_buf) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 439, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "buf"); __PYX_ERR(0, 448, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_56write_stderr(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v_buf));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_56write_stderr(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_buf);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6429,21 +9755,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("write_stderr", 0);
+  __Pyx_RefNannySetupContext("write_stderr", 1);
 
-  /* "ssh2/channel.pyx":464
+  /* "ssh2/channel.pyx":473
  *         :rtype: tuple(int, int)
  *         """
  *         cdef bytes b_buf = to_bytes(buf)             # <<<<<<<<<<<<<<
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_buf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 473, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_buf = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":465
+  /* "ssh2/channel.pyx":474
  *         """
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf             # <<<<<<<<<<<<<<
@@ -6452,12 +9778,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 465, __pyx_L1_error)
+    __PYX_ERR(0, 474, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 465, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_buf); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error)
   __pyx_v__buf = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":466
+  /* "ssh2/channel.pyx":475
  *         cdef bytes b_buf = to_bytes(buf)
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)             # <<<<<<<<<<<<<<
@@ -6466,12 +9792,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
   if (unlikely(__pyx_v_b_buf == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(0, 466, __pyx_L1_error)
+    __PYX_ERR(0, 475, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 466, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_buf); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 475, __pyx_L1_error)
   __pyx_v_buf_remainder = __pyx_t_3;
 
-  /* "ssh2/channel.pyx":467
+  /* "ssh2/channel.pyx":476
  *         cdef const char *_buf = b_buf
  *         cdef size_t buf_remainder = len(b_buf)
  *         cdef size_t buf_tot_size = buf_remainder             # <<<<<<<<<<<<<<
@@ -6480,7 +9806,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
   __pyx_v_buf_tot_size = __pyx_v_buf_remainder;
 
-  /* "ssh2/channel.pyx":469
+  /* "ssh2/channel.pyx":478
  *         cdef size_t buf_tot_size = buf_remainder
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0             # <<<<<<<<<<<<<<
@@ -6489,7 +9815,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
   __pyx_v_bytes_written = 0;
 
-  /* "ssh2/channel.pyx":470
+  /* "ssh2/channel.pyx":479
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6499,12 +9825,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":471
+        /* "ssh2/channel.pyx":480
  *         cdef size_t bytes_written = 0
  *         with nogil:
  *             while buf_remainder > 0:             # <<<<<<<<<<<<<<
@@ -6512,10 +9839,10 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  *                     self._channel, _buf, buf_remainder)
  */
         while (1) {
-          __pyx_t_4 = ((__pyx_v_buf_remainder > 0) != 0);
+          __pyx_t_4 = (__pyx_v_buf_remainder > 0);
           if (!__pyx_t_4) break;
 
-          /* "ssh2/channel.pyx":472
+          /* "ssh2/channel.pyx":481
  *         with nogil:
  *             while buf_remainder > 0:
  *                 rc = c_ssh2.libssh2_channel_write_stderr(             # <<<<<<<<<<<<<<
@@ -6524,25 +9851,25 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
           __pyx_v_rc = libssh2_channel_write_stderr(__pyx_v_self->_channel, __pyx_v__buf, __pyx_v_buf_remainder);
 
-          /* "ssh2/channel.pyx":474
+          /* "ssh2/channel.pyx":483
  *                 rc = c_ssh2.libssh2_channel_write_stderr(
  *                     self._channel, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     # Error that will raise exception
  *                     with gil:
  */
-          __pyx_t_5 = ((__pyx_v_rc < 0) != 0);
+          __pyx_t_5 = (__pyx_v_rc < 0);
           if (__pyx_t_5) {
           } else {
             __pyx_t_4 = __pyx_t_5;
             goto __pyx_L9_bool_binop_done;
           }
-          __pyx_t_5 = ((__pyx_v_rc != LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_5 = (__pyx_v_rc != LIBSSH2_ERROR_EAGAIN);
           __pyx_t_4 = __pyx_t_5;
           __pyx_L9_bool_binop_done:;
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":476
+            /* "ssh2/channel.pyx":485
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -6555,7 +9882,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
                 #endif
                 /*try:*/ {
 
-                  /* "ssh2/channel.pyx":477
+                  /* "ssh2/channel.pyx":486
  *                     # Error that will raise exception
  *                     with gil:
  *                         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -6563,15 +9890,15 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  *                     break
  */
                   __Pyx_XDECREF(__pyx_r);
-                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 477, __pyx_L14_error)
-                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 477, __pyx_L14_error)
+                  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 486, __pyx_L14_error)
+                  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 486, __pyx_L14_error)
                   __Pyx_GOTREF(__pyx_t_1);
                   __pyx_r = __pyx_t_1;
                   __pyx_t_1 = 0;
                   goto __pyx_L13_return;
                 }
 
-                /* "ssh2/channel.pyx":476
+                /* "ssh2/channel.pyx":485
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     # Error that will raise exception
  *                     with gil:             # <<<<<<<<<<<<<<
@@ -6594,7 +9921,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
                 }
             }
 
-            /* "ssh2/channel.pyx":474
+            /* "ssh2/channel.pyx":483
  *                 rc = c_ssh2.libssh2_channel_write_stderr(
  *                     self._channel, _buf, buf_remainder)
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -6603,17 +9930,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
           }
 
-          /* "ssh2/channel.pyx":478
+          /* "ssh2/channel.pyx":487
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
  *                     break
  *                 _buf += rc
  */
-          __pyx_t_4 = ((__pyx_v_rc == LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_4 = (__pyx_v_rc == LIBSSH2_ERROR_EAGAIN);
           if (__pyx_t_4) {
 
-            /* "ssh2/channel.pyx":479
+            /* "ssh2/channel.pyx":488
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break             # <<<<<<<<<<<<<<
@@ -6622,7 +9949,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
             goto __pyx_L7_break;
 
-            /* "ssh2/channel.pyx":478
+            /* "ssh2/channel.pyx":487
  *                     with gil:
  *                         return handle_error_codes(rc)
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:             # <<<<<<<<<<<<<<
@@ -6631,7 +9958,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
           }
 
-          /* "ssh2/channel.pyx":480
+          /* "ssh2/channel.pyx":489
  *                 elif rc == c_ssh2.LIBSSH2_ERROR_EAGAIN:
  *                     break
  *                 _buf += rc             # <<<<<<<<<<<<<<
@@ -6640,7 +9967,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
           __pyx_v__buf = (__pyx_v__buf + __pyx_v_rc);
 
-          /* "ssh2/channel.pyx":481
+          /* "ssh2/channel.pyx":490
  *                     break
  *                 _buf += rc
  *                 buf_remainder -= rc             # <<<<<<<<<<<<<<
@@ -6651,7 +9978,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
         }
         __pyx_L7_break:;
 
-        /* "ssh2/channel.pyx":482
+        /* "ssh2/channel.pyx":491
  *                 _buf += rc
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder             # <<<<<<<<<<<<<<
@@ -6661,7 +9988,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
         __pyx_v_bytes_written = (__pyx_v_buf_tot_size - __pyx_v_buf_remainder);
       }
 
-      /* "ssh2/channel.pyx":470
+      /* "ssh2/channel.pyx":479
  *         cdef ssize_t rc
  *         cdef size_t bytes_written = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6694,7 +10021,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
       }
   }
 
-  /* "ssh2/channel.pyx":483
+  /* "ssh2/channel.pyx":492
  *                 buf_remainder -= rc
  *             bytes_written = buf_tot_size - buf_remainder
  *         return rc, bytes_written             # <<<<<<<<<<<<<<
@@ -6702,23 +10029,23 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  *     def x11_req(self, int screen_number):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 483, __pyx_L1_error)
+  __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 492, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_bytes_written); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 483, __pyx_L1_error)
+  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 492, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 492, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_7);
-  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_t_7 = 0;
   __pyx_r = __pyx_t_8;
   __pyx_t_8 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":439
+  /* "ssh2/channel.pyx":448
  *         return rc, bytes_written
  * 
  *     def write_stderr(self, buf not None):             # <<<<<<<<<<<<<<
@@ -6740,7 +10067,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":485
+/* "ssh2/channel.pyx":494
  *         return rc, bytes_written
  * 
  *     def x11_req(self, int screen_number):             # <<<<<<<<<<<<<<
@@ -6749,28 +10076,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_56write_stderr(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_59x11_req(PyObject *__pyx_v_self, PyObject *__pyx_arg_screen_number); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_58x11_req[] = "Channel.x11_req(self, int screen_number)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_59x11_req(PyObject *__pyx_v_self, PyObject *__pyx_arg_screen_number) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_59x11_req(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_58x11_req, "Channel.x11_req(self, int screen_number)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_59x11_req = {"x11_req", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_59x11_req, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_58x11_req};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_59x11_req(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_screen_number;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("x11_req (wrapper)", 0);
-  assert(__pyx_arg_screen_number); {
-    __pyx_v_screen_number = __Pyx_PyInt_As_int(__pyx_arg_screen_number); if (unlikely((__pyx_v_screen_number == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_screen_number,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_screen_number)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "x11_req") < 0)) __PYX_ERR(0, 494, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_screen_number = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_screen_number == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("x11_req", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 494, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.x11_req", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_58x11_req(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_screen_number));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_58x11_req(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_screen_number);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6784,9 +10181,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("x11_req", 0);
+  __Pyx_RefNannySetupContext("x11_req", 1);
 
-  /* "ssh2/channel.pyx":487
+  /* "ssh2/channel.pyx":496
  *     def x11_req(self, int screen_number):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6796,12 +10193,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":488
+        /* "ssh2/channel.pyx":497
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_x11_req(             # <<<<<<<<<<<<<<
@@ -6811,7 +10209,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
         __pyx_v_rc = libssh2_channel_x11_req(__pyx_v_self->_channel, __pyx_v_screen_number);
       }
 
-      /* "ssh2/channel.pyx":487
+      /* "ssh2/channel.pyx":496
  *     def x11_req(self, int screen_number):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6830,7 +10228,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
       }
   }
 
-  /* "ssh2/channel.pyx":490
+  /* "ssh2/channel.pyx":499
  *             rc = c_ssh2.libssh2_channel_x11_req(
  *                 self._channel, screen_number)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -6838,14 +10236,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
  *     def x11_req_ex(self, int single_connection,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 490, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 490, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 499, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 499, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":485
+  /* "ssh2/channel.pyx":494
  *         return rc, bytes_written
  * 
  *     def x11_req(self, int screen_number):             # <<<<<<<<<<<<<<
@@ -6864,7 +10262,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":492
+/* "ssh2/channel.pyx":501
  *         return handle_error_codes(rc)
  * 
  *     def x11_req_ex(self, int single_connection,             # <<<<<<<<<<<<<<
@@ -6873,81 +10271,130 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_58x11_req(struct __pyx_obj_4ss
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_60x11_req_ex[] = "Channel.x11_req_ex(self, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_60x11_req_ex, "Channel.x11_req_ex(self, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_61x11_req_ex = {"x11_req_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_60x11_req_ex};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_single_connection;
   char const *__pyx_v_auth_proto;
   char const *__pyx_v_auth_cookie;
   int __pyx_v_screen_number;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("x11_req_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_single_connection,&__pyx_n_s_auth_proto,&__pyx_n_s_auth_cookie,&__pyx_n_s_screen_number,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_single_connection,&__pyx_n_s_auth_proto,&__pyx_n_s_auth_cookie,&__pyx_n_s_screen_number,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_single_connection)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_single_connection)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_auth_proto)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_auth_proto)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 1); __PYX_ERR(0, 492, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 1); __PYX_ERR(0, 501, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_auth_cookie)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_auth_cookie)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 2); __PYX_ERR(0, 492, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 2); __PYX_ERR(0, 501, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_number)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_screen_number)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 3); __PYX_ERR(0, 492, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, 3); __PYX_ERR(0, 501, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "x11_req_ex") < 0)) __PYX_ERR(0, 492, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "x11_req_ex") < 0)) __PYX_ERR(0, 501, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
     }
-    __pyx_v_single_connection = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_single_connection == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L3_error)
-    __pyx_v_auth_proto = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_auth_proto) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L3_error)
-    __pyx_v_auth_cookie = __Pyx_PyObject_AsString(values[2]); if (unlikely((!__pyx_v_auth_cookie) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L3_error)
-    __pyx_v_screen_number = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_screen_number == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 495, __pyx_L3_error)
+    __pyx_v_single_connection = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_single_connection == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L3_error)
+    __pyx_v_auth_proto = __Pyx_PyObject_AsString(values[1]); if (unlikely((!__pyx_v_auth_proto) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L3_error)
+    __pyx_v_auth_cookie = __Pyx_PyObject_AsString(values[2]); if (unlikely((!__pyx_v_auth_cookie) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L3_error)
+    __pyx_v_screen_number = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_screen_number == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 492, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("x11_req_ex", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 501, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.x11_req_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -6955,6 +10402,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex(PyObject *__pyx_v
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_single_connection, __pyx_v_auth_proto, __pyx_v_auth_cookie, __pyx_v_screen_number);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6968,9 +10421,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("x11_req_ex", 0);
+  __Pyx_RefNannySetupContext("x11_req_ex", 1);
 
-  /* "ssh2/channel.pyx":497
+  /* "ssh2/channel.pyx":506
  *                    int screen_number):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6980,12 +10433,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":498
+        /* "ssh2/channel.pyx":507
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_x11_req_ex(             # <<<<<<<<<<<<<<
@@ -6995,7 +10449,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
         __pyx_v_rc = libssh2_channel_x11_req_ex(__pyx_v_self->_channel, __pyx_v_single_connection, __pyx_v_auth_proto, __pyx_v_auth_cookie, __pyx_v_screen_number);
       }
 
-      /* "ssh2/channel.pyx":497
+      /* "ssh2/channel.pyx":506
  *                    int screen_number):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7014,7 +10468,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/channel.pyx":501
+  /* "ssh2/channel.pyx":510
  *                 self._channel, single_connection,
  *                 auth_proto, auth_cookie, screen_number)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -7022,14 +10476,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
  *     def process_startup(self, request, message=None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 501, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 501, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 510, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 510, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":492
+  /* "ssh2/channel.pyx":501
  *         return handle_error_codes(rc)
  * 
  *     def x11_req_ex(self, int single_connection,             # <<<<<<<<<<<<<<
@@ -7048,7 +10502,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":503
+/* "ssh2/channel.pyx":512
  *         return handle_error_codes(rc)
  * 
  *     def process_startup(self, request, message=None):             # <<<<<<<<<<<<<<
@@ -7057,52 +10511,82 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_60x11_req_ex(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_62process_startup[] = "Channel.process_startup(self, request, message=None)\nStartup process on server for request with message.\n\n        Request is a supported SSH subsystem and clients would typically use\n        one of execute/shell/subsystem functions depending on request type.\n\n        :param request: Request type (exec/shell/subsystem).\n        :type request: str\n        :param message: Request message. Content depends on request type\n          and can be ``None``.\n        :type message: str or ``None``\n        ";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_62process_startup, "Channel.process_startup(self, request, message=None)\nStartup process on server for request with message.\n\n        Request is a supported SSH subsystem and clients would typically use\n        one of execute/shell/subsystem functions depending on request type.\n\n        :param request: Request type (exec/shell/subsystem).\n        :type request: str\n        :param message: Request message. Content depends on request type\n          and can be ``None``.\n        :type message: str or ``None``\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_63process_startup = {"process_startup", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_63process_startup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_62process_startup};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_request = 0;
   PyObject *__pyx_v_message = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("process_startup (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_request,&__pyx_n_s_message,0};
-    PyObject* values[2] = {0,0};
-    values[1] = ((PyObject *)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_request,&__pyx_n_s_message,0};
+    values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_request)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_request)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_message);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_message);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "process_startup") < 0)) __PYX_ERR(0, 503, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "process_startup") < 0)) __PYX_ERR(0, 512, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -7110,10 +10594,18 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__
     __pyx_v_request = values[0];
     __pyx_v_message = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("process_startup", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 503, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("process_startup", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 512, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.process_startup", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -7121,6 +10613,12 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_63process_startup(PyObject *__
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_62process_startup(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_request, __pyx_v_message);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7140,25 +10638,24 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
   Py_ssize_t __pyx_t_3;
   int __pyx_t_4;
   int __pyx_t_5;
-  int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("process_startup", 0);
+  __Pyx_RefNannySetupContext("process_startup", 1);
 
-  /* "ssh2/channel.pyx":515
+  /* "ssh2/channel.pyx":524
  *         :type message: str or ``None``
  *         """
  *         cdef bytes b_request = to_bytes(request)             # <<<<<<<<<<<<<<
  *         cdef bytes b_message = None
  *         cdef char *_request = b_request
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_request); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 515, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_request); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 524, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_request = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/channel.pyx":516
+  /* "ssh2/channel.pyx":525
  *         """
  *         cdef bytes b_request = to_bytes(request)
  *         cdef bytes b_message = None             # <<<<<<<<<<<<<<
@@ -7168,7 +10665,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
   __Pyx_INCREF(Py_None);
   __pyx_v_b_message = ((PyObject*)Py_None);
 
-  /* "ssh2/channel.pyx":517
+  /* "ssh2/channel.pyx":526
  *         cdef bytes b_request = to_bytes(request)
  *         cdef bytes b_message = None
  *         cdef char *_request = b_request             # <<<<<<<<<<<<<<
@@ -7177,12 +10674,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
   if (unlikely(__pyx_v_b_request == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 517, __pyx_L1_error)
+    __PYX_ERR(0, 526, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_request); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_request); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error)
   __pyx_v__request = __pyx_t_2;
 
-  /* "ssh2/channel.pyx":518
+  /* "ssh2/channel.pyx":527
  *         cdef bytes b_message = None
  *         cdef char *_request = b_request
  *         cdef char *_message = NULL             # <<<<<<<<<<<<<<
@@ -7191,7 +10688,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
   __pyx_v__message = NULL;
 
-  /* "ssh2/channel.pyx":519
+  /* "ssh2/channel.pyx":528
  *         cdef char *_request = b_request
  *         cdef char *_message = NULL
  *         cdef size_t r_len = len(b_request)             # <<<<<<<<<<<<<<
@@ -7200,12 +10697,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
   if (unlikely(__pyx_v_b_request == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(0, 519, __pyx_L1_error)
+    __PYX_ERR(0, 528, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_request); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 519, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_request); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 528, __pyx_L1_error)
   __pyx_v_r_len = __pyx_t_3;
 
-  /* "ssh2/channel.pyx":520
+  /* "ssh2/channel.pyx":529
  *         cdef char *_message = NULL
  *         cdef size_t r_len = len(b_request)
  *         cdef size_t m_len = 0             # <<<<<<<<<<<<<<
@@ -7214,7 +10711,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
   __pyx_v_m_len = 0;
 
-  /* "ssh2/channel.pyx":521
+  /* "ssh2/channel.pyx":530
  *         cdef size_t r_len = len(b_request)
  *         cdef size_t m_len = 0
  *         if message is not None:             # <<<<<<<<<<<<<<
@@ -7222,22 +10719,21 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  *             _message = b_message
  */
   __pyx_t_4 = (__pyx_v_message != Py_None);
-  __pyx_t_5 = (__pyx_t_4 != 0);
-  if (__pyx_t_5) {
+  if (__pyx_t_4) {
 
-    /* "ssh2/channel.pyx":522
+    /* "ssh2/channel.pyx":531
  *         cdef size_t m_len = 0
  *         if message is not None:
  *             b_message = to_bytes(message)             # <<<<<<<<<<<<<<
  *             _message = b_message
  *             m_len = len(b_message)
  */
-    __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 522, __pyx_L1_error)
+    __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 531, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF_SET(__pyx_v_b_message, ((PyObject*)__pyx_t_1));
     __pyx_t_1 = 0;
 
-    /* "ssh2/channel.pyx":523
+    /* "ssh2/channel.pyx":532
  *         if message is not None:
  *             b_message = to_bytes(message)
  *             _message = b_message             # <<<<<<<<<<<<<<
@@ -7246,12 +10742,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
     if (unlikely(__pyx_v_b_message == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(0, 523, __pyx_L1_error)
+      __PYX_ERR(0, 532, __pyx_L1_error)
     }
-    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_message); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_message); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 532, __pyx_L1_error)
     __pyx_v__message = __pyx_t_2;
 
-    /* "ssh2/channel.pyx":524
+    /* "ssh2/channel.pyx":533
  *             b_message = to_bytes(message)
  *             _message = b_message
  *             m_len = len(b_message)             # <<<<<<<<<<<<<<
@@ -7260,12 +10756,12 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
     if (unlikely(__pyx_v_b_message == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-      __PYX_ERR(0, 524, __pyx_L1_error)
+      __PYX_ERR(0, 533, __pyx_L1_error)
     }
-    __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_message); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 524, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_message); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 533, __pyx_L1_error)
     __pyx_v_m_len = __pyx_t_3;
 
-    /* "ssh2/channel.pyx":521
+    /* "ssh2/channel.pyx":530
  *         cdef size_t r_len = len(b_request)
  *         cdef size_t m_len = 0
  *         if message is not None:             # <<<<<<<<<<<<<<
@@ -7274,7 +10770,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
   }
 
-  /* "ssh2/channel.pyx":526
+  /* "ssh2/channel.pyx":535
  *             m_len = len(b_message)
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7284,12 +10780,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":527
+        /* "ssh2/channel.pyx":536
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_process_startup(             # <<<<<<<<<<<<<<
@@ -7299,7 +10796,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
         __pyx_v_rc = libssh2_channel_process_startup(__pyx_v_self->_channel, __pyx_v__request, __pyx_v_r_len, __pyx_v__message, __pyx_v_m_len);
       }
 
-      /* "ssh2/channel.pyx":526
+      /* "ssh2/channel.pyx":535
  *             m_len = len(b_message)
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7318,7 +10815,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
       }
   }
 
-  /* "ssh2/channel.pyx":529
+  /* "ssh2/channel.pyx":538
  *             rc = c_ssh2.libssh2_channel_process_startup(
  *                 self._channel, _request, r_len, _message, m_len)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -7326,14 +10823,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  *     def poll_channel_read(self, int extended):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 529, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error)
+  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 538, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 538, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":503
+  /* "ssh2/channel.pyx":512
  *         return handle_error_codes(rc)
  * 
  *     def process_startup(self, request, message=None):             # <<<<<<<<<<<<<<
@@ -7354,7 +10851,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":531
+/* "ssh2/channel.pyx":540
  *         return handle_error_codes(rc)
  * 
  *     def poll_channel_read(self, int extended):             # <<<<<<<<<<<<<<
@@ -7363,29 +10860,99 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_62process_startup(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read(PyObject *__pyx_v_self, PyObject *__pyx_arg_extended); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_64poll_channel_read[] = "Channel.poll_channel_read(self, int extended)\nDeprecated - use session.block_directions and socket polling\n        instead";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read(PyObject *__pyx_v_self, PyObject *__pyx_arg_extended) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_64poll_channel_read, "Channel.poll_channel_read(self, int extended)\nDeprecated - use session.block_directions and socket polling\n        instead");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_65poll_channel_read = {"poll_channel_read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_64poll_channel_read};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_extended;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("poll_channel_read (wrapper)", 0);
-  assert(__pyx_arg_extended); {
-    __pyx_v_extended = __Pyx_PyInt_As_int(__pyx_arg_extended); if (unlikely((__pyx_v_extended == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 531, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.channel.Channel.poll_channel_read", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_extended));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extended,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_extended)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "poll_channel_read") < 0)) __PYX_ERR(0, 540, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_extended = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_extended == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L3_error)
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("poll_channel_read", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 540, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.poll_channel_read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_extended);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
@@ -7398,9 +10965,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("poll_channel_read", 0);
+  __Pyx_RefNannySetupContext("poll_channel_read", 1);
 
-  /* "ssh2/channel.pyx":535
+  /* "ssh2/channel.pyx":544
  *         instead"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7410,12 +10977,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":536
+        /* "ssh2/channel.pyx":545
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_poll_channel_read(self._channel, extended)             # <<<<<<<<<<<<<<
@@ -7425,7 +10993,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
         __pyx_v_rc = libssh2_poll_channel_read(__pyx_v_self->_channel, __pyx_v_extended);
       }
 
-      /* "ssh2/channel.pyx":535
+      /* "ssh2/channel.pyx":544
  *         instead"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7444,7 +11012,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
       }
   }
 
-  /* "ssh2/channel.pyx":537
+  /* "ssh2/channel.pyx":546
  *         with nogil:
  *             rc = c_ssh2.libssh2_poll_channel_read(self._channel, extended)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -7452,14 +11020,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
  *     def handle_extended_data(self, int ignore_mode):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 537, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 537, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 546, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 546, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":531
+  /* "ssh2/channel.pyx":540
  *         return handle_error_codes(rc)
  * 
  *     def poll_channel_read(self, int extended):             # <<<<<<<<<<<<<<
@@ -7478,7 +11046,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":539
+/* "ssh2/channel.pyx":548
  *         return handle_error_codes(rc)
  * 
  *     def handle_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7487,28 +11055,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_64poll_channel_read(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_66handle_extended_data[] = "Channel.handle_extended_data(self, int ignore_mode)\nDeprecated, use handle_extended_data2";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_66handle_extended_data, "Channel.handle_extended_data(self, int ignore_mode)\nDeprecated, use handle_extended_data2");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_67handle_extended_data = {"handle_extended_data", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_66handle_extended_data};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_ignore_mode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("handle_extended_data (wrapper)", 0);
-  assert(__pyx_arg_ignore_mode); {
-    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(__pyx_arg_ignore_mode); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 539, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ignore_mode,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ignore_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "handle_extended_data") < 0)) __PYX_ERR(0, 548, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("handle_extended_data", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 548, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.handle_extended_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_ignore_mode));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_ignore_mode);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7516,9 +11154,9 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data(PyObjec
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, int __pyx_v_ignore_mode) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("handle_extended_data", 0);
+  __Pyx_RefNannySetupContext("handle_extended_data", 1);
 
-  /* "ssh2/channel.pyx":541
+  /* "ssh2/channel.pyx":550
  *     def handle_extended_data(self, int ignore_mode):
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7528,12 +11166,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":542
+        /* "ssh2/channel.pyx":551
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:
  *             c_ssh2.libssh2_channel_handle_extended_data(             # <<<<<<<<<<<<<<
@@ -7543,7 +11182,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct
         libssh2_channel_handle_extended_data(__pyx_v_self->_channel, __pyx_v_ignore_mode);
       }
 
-      /* "ssh2/channel.pyx":541
+      /* "ssh2/channel.pyx":550
  *     def handle_extended_data(self, int ignore_mode):
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7562,7 +11201,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct
       }
   }
 
-  /* "ssh2/channel.pyx":539
+  /* "ssh2/channel.pyx":548
  *         return handle_error_codes(rc)
  * 
  *     def handle_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7577,7 +11216,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":545
+/* "ssh2/channel.pyx":554
  *                 self._channel, ignore_mode)
  * 
  *     def handle_extended_data2(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7586,28 +11225,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_66handle_extended_data(struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_68handle_extended_data2[] = "Channel.handle_extended_data2(self, int ignore_mode)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_68handle_extended_data2, "Channel.handle_extended_data2(self, int ignore_mode)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_69handle_extended_data2 = {"handle_extended_data2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_68handle_extended_data2};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_ignore_mode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("handle_extended_data2 (wrapper)", 0);
-  assert(__pyx_arg_ignore_mode); {
-    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(__pyx_arg_ignore_mode); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 545, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ignore_mode,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ignore_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 554, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "handle_extended_data2") < 0)) __PYX_ERR(0, 554, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 554, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("handle_extended_data2", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 554, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.handle_extended_data2", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_ignore_mode));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_ignore_mode);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7621,9 +11330,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("handle_extended_data2", 0);
+  __Pyx_RefNannySetupContext("handle_extended_data2", 1);
 
-  /* "ssh2/channel.pyx":547
+  /* "ssh2/channel.pyx":556
  *     def handle_extended_data2(self, int ignore_mode):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7633,12 +11342,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":548
+        /* "ssh2/channel.pyx":557
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_handle_extended_data2(             # <<<<<<<<<<<<<<
@@ -7648,7 +11358,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
         __pyx_v_rc = libssh2_channel_handle_extended_data2(__pyx_v_self->_channel, __pyx_v_ignore_mode);
       }
 
-      /* "ssh2/channel.pyx":547
+      /* "ssh2/channel.pyx":556
  *     def handle_extended_data2(self, int ignore_mode):
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7667,7 +11377,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
       }
   }
 
-  /* "ssh2/channel.pyx":550
+  /* "ssh2/channel.pyx":559
  *             rc = c_ssh2.libssh2_channel_handle_extended_data2(
  *                 self._channel, ignore_mode)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -7675,14 +11385,14 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
  *     def ignore_extended_data(self, int ignore_mode):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 550, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 550, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 559, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 559, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":545
+  /* "ssh2/channel.pyx":554
  *                 self._channel, ignore_mode)
  * 
  *     def handle_extended_data2(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7701,7 +11411,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":552
+/* "ssh2/channel.pyx":561
  *         return handle_error_codes(rc)
  * 
  *     def ignore_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7710,28 +11420,98 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_68handle_extended_data2(struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_70ignore_extended_data[] = "Channel.ignore_extended_data(self, int ignore_mode)\nDeprecated, use handle_extended_data2";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_ignore_mode) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_70ignore_extended_data, "Channel.ignore_extended_data(self, int ignore_mode)\nDeprecated, use handle_extended_data2");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_71ignore_extended_data = {"ignore_extended_data", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_70ignore_extended_data};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_ignore_mode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("ignore_extended_data (wrapper)", 0);
-  assert(__pyx_arg_ignore_mode); {
-    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(__pyx_arg_ignore_mode); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ignore_mode,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ignore_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ignore_extended_data") < 0)) __PYX_ERR(0, 561, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_ignore_mode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ignore_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("ignore_extended_data", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 561, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.channel.Channel.ignore_extended_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((int)__pyx_v_ignore_mode));
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v_ignore_mode);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7739,9 +11519,9 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data(PyObjec
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, int __pyx_v_ignore_mode) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ignore_extended_data", 0);
+  __Pyx_RefNannySetupContext("ignore_extended_data", 1);
 
-  /* "ssh2/channel.pyx":554
+  /* "ssh2/channel.pyx":563
  *     def ignore_extended_data(self, int ignore_mode):
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7751,12 +11531,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":555
+        /* "ssh2/channel.pyx":564
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:
  *             c_ssh2.libssh2_channel_handle_extended_data(             # <<<<<<<<<<<<<<
@@ -7766,7 +11547,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct
         libssh2_channel_handle_extended_data(__pyx_v_self->_channel, __pyx_v_ignore_mode);
       }
 
-      /* "ssh2/channel.pyx":554
+      /* "ssh2/channel.pyx":563
  *     def ignore_extended_data(self, int ignore_mode):
  *         """Deprecated, use handle_extended_data2"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7785,7 +11566,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct
       }
   }
 
-  /* "ssh2/channel.pyx":552
+  /* "ssh2/channel.pyx":561
  *         return handle_error_codes(rc)
  * 
  *     def ignore_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
@@ -7800,7 +11581,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct
   return __pyx_r;
 }
 
-/* "ssh2/channel.pyx":558
+/* "ssh2/channel.pyx":567
  *                 self._channel, ignore_mode)
  * 
  *     def request_auth_agent(self):             # <<<<<<<<<<<<<<
@@ -7809,12 +11590,40 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_70ignore_extended_data(struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_72request_auth_agent[] = "Channel.request_auth_agent(self)\nRequest SSH agent authentication forwarding on channel.";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_72request_auth_agent, "Channel.request_auth_agent(self)\nRequest SSH agent authentication forwarding on channel.");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_73request_auth_agent = {"request_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_72request_auth_agent};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("request_auth_agent (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("request_auth_agent", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "request_auth_agent", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -7831,9 +11640,9 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("request_auth_agent", 0);
+  __Pyx_RefNannySetupContext("request_auth_agent", 1);
 
-  /* "ssh2/channel.pyx":561
+  /* "ssh2/channel.pyx":570
  *         """Request SSH agent authentication forwarding on channel."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7843,12 +11652,13 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/channel.pyx":562
+        /* "ssh2/channel.pyx":571
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_request_auth_agent(self._channel)             # <<<<<<<<<<<<<<
@@ -7857,7 +11667,7 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
         __pyx_v_rc = libssh2_channel_request_auth_agent(__pyx_v_self->_channel);
       }
 
-      /* "ssh2/channel.pyx":561
+      /* "ssh2/channel.pyx":570
  *         """Request SSH agent authentication forwarding on channel."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7876,20 +11686,20 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
       }
   }
 
-  /* "ssh2/channel.pyx":563
+  /* "ssh2/channel.pyx":572
  *         with nogil:
  *             rc = c_ssh2.libssh2_channel_request_auth_agent(self._channel)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 563, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 563, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 572, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 572, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/channel.pyx":558
+  /* "ssh2/channel.pyx":567
  *                 self._channel, ignore_mode)
  * 
  *     def request_auth_agent(self):             # <<<<<<<<<<<<<<
@@ -7910,17 +11720,45 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_72request_auth_agent(struct __
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_74__reduce_cython__[] = "Channel.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_74__reduce_cython__, "Channel.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_75__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_74__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_74__reduce_cython__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self));
 
   /* function exit code */
@@ -7931,33 +11769,28 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__(PyObject *
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_74__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.channel.Channel.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -7967,21 +11800,104 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_74__reduce_cython__(CYTHON_UNU
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_7channel_7Channel_76__setstate_cython__[] = "Channel.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7channel_7Channel_76__setstate_cython__, "Channel.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_7channel_7Channel_77__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_76__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_76__setstate_cython__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.channel.Channel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7channel_7Channel_76__setstate_cython__(((struct __pyx_obj_4ssh2_7channel_Channel *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7989,33 +11905,28 @@ static PyObject *__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__(PyObject
 static PyObject *__pyx_pf_4ssh2_7channel_7Channel_76__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7channel_Channel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.channel.Channel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -8026,12 +11937,17 @@ static PyObject *__pyx_pf_4ssh2_7channel_7Channel_76__setstate_cython__(CYTHON_U
 static PyObject *__pyx_tp_new_4ssh2_7channel_Channel(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_7channel_Channel *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_7channel_Channel *)o);
   p->_session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_7channel_7Channel_1__cinit__(o, a, k) < 0)) goto bad;
@@ -8044,8 +11960,10 @@ static PyObject *__pyx_tp_new_4ssh2_7channel_Channel(PyTypeObject *t, PyObject *
 static void __pyx_tp_dealloc_4ssh2_7channel_Channel(PyObject *o) {
   struct __pyx_obj_4ssh2_7channel_Channel *p = (struct __pyx_obj_4ssh2_7channel_Channel *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_7channel_Channel) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -8058,7 +11976,14 @@ static void __pyx_tp_dealloc_4ssh2_7channel_Channel(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_7channel_Channel(PyObject *o, visitproc v, void *a) {
@@ -8084,54 +12009,72 @@ static PyObject *__pyx_getprop_4ssh2_7channel_7Channel_session(PyObject *o, CYTH
 }
 
 static PyMethodDef __pyx_methods_4ssh2_7channel_Channel[] = {
-  {"pty", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_5pty, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_4pty},
-  {"execute", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_7execute, METH_O, __pyx_doc_4ssh2_7channel_7Channel_6execute},
-  {"subsystem", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_9subsystem, METH_O, __pyx_doc_4ssh2_7channel_7Channel_8subsystem},
-  {"shell", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_11shell, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_10shell},
-  {"read", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_13read, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_12read},
-  {"read_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_15read_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_14read_ex},
-  {"read_stderr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_17read_stderr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_16read_stderr},
-  {"eof", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_19eof, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_18eof},
-  {"send_eof", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_21send_eof, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_20send_eof},
-  {"wait_eof", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_23wait_eof, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_22wait_eof},
-  {"close", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_25close, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_24close},
-  {"flush", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_27flush, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_26flush},
-  {"flush_ex", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_29flush_ex, METH_O, __pyx_doc_4ssh2_7channel_7Channel_28flush_ex},
-  {"flush_stderr", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_30flush_stderr},
-  {"wait_closed", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_33wait_closed, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_32wait_closed},
-  {"get_exit_status", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_34get_exit_status},
-  {"get_exit_signal", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_36get_exit_signal},
-  {"setenv", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_39setenv, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_38setenv},
-  {"window_read_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_40window_read_ex},
-  {"window_read", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_43window_read, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_42window_read},
-  {"window_write_ex", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex, METH_O, __pyx_doc_4ssh2_7channel_7Channel_44window_write_ex},
-  {"window_write", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_47window_write, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_46window_write},
-  {"receive_window_adjust", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_48receive_window_adjust},
-  {"receive_window_adjust2", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_50receive_window_adjust2},
-  {"write", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_53write, METH_O, __pyx_doc_4ssh2_7channel_7Channel_52write},
-  {"write_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_55write_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_54write_ex},
-  {"write_stderr", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_57write_stderr, METH_O, __pyx_doc_4ssh2_7channel_7Channel_56write_stderr},
-  {"x11_req", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_59x11_req, METH_O, __pyx_doc_4ssh2_7channel_7Channel_58x11_req},
-  {"x11_req_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_60x11_req_ex},
-  {"process_startup", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_63process_startup, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_62process_startup},
-  {"poll_channel_read", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read, METH_O, __pyx_doc_4ssh2_7channel_7Channel_64poll_channel_read},
-  {"handle_extended_data", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data, METH_O, __pyx_doc_4ssh2_7channel_7Channel_66handle_extended_data},
-  {"handle_extended_data2", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2, METH_O, __pyx_doc_4ssh2_7channel_7Channel_68handle_extended_data2},
-  {"ignore_extended_data", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data, METH_O, __pyx_doc_4ssh2_7channel_7Channel_70ignore_extended_data},
-  {"request_auth_agent", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_72request_auth_agent},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_7channel_7Channel_74__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__, METH_O, __pyx_doc_4ssh2_7channel_7Channel_76__setstate_cython__},
+  {"pty", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_5pty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_4pty},
+  {"execute", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_7execute, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_6execute},
+  {"subsystem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_9subsystem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_8subsystem},
+  {"shell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_11shell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_10shell},
+  {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_13read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_12read},
+  {"read_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_15read_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_14read_ex},
+  {"read_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_17read_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_16read_stderr},
+  {"eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_19eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_18eof},
+  {"send_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_21send_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_20send_eof},
+  {"wait_eof", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_23wait_eof, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_22wait_eof},
+  {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_25close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_24close},
+  {"flush", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_27flush, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_26flush},
+  {"flush_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_29flush_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_28flush_ex},
+  {"flush_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_31flush_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_30flush_stderr},
+  {"wait_closed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_33wait_closed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_32wait_closed},
+  {"get_exit_status", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_35get_exit_status, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_34get_exit_status},
+  {"get_exit_signal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_37get_exit_signal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_36get_exit_signal},
+  {"setenv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_39setenv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_38setenv},
+  {"window_read_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_41window_read_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_40window_read_ex},
+  {"window_read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_43window_read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_42window_read},
+  {"window_write_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_45window_write_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_44window_write_ex},
+  {"window_write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_47window_write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_46window_write},
+  {"receive_window_adjust", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_49receive_window_adjust, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_48receive_window_adjust},
+  {"receive_window_adjust2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_51receive_window_adjust2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_50receive_window_adjust2},
+  {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_53write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_52write},
+  {"write_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_55write_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_54write_ex},
+  {"write_stderr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_57write_stderr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_56write_stderr},
+  {"x11_req", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_59x11_req, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_58x11_req},
+  {"x11_req_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_61x11_req_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_60x11_req_ex},
+  {"process_startup", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_63process_startup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_62process_startup},
+  {"poll_channel_read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_65poll_channel_read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_64poll_channel_read},
+  {"handle_extended_data", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_67handle_extended_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_66handle_extended_data},
+  {"handle_extended_data2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_69handle_extended_data2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_68handle_extended_data2},
+  {"ignore_extended_data", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_71ignore_extended_data, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_70ignore_extended_data},
+  {"request_auth_agent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_73request_auth_agent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_72request_auth_agent},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_75__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_74__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7channel_7Channel_77__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7channel_7Channel_76__setstate_cython__},
   {0, 0, 0, 0}
 };
 
 static struct PyGetSetDef __pyx_getsets_4ssh2_7channel_Channel[] = {
-  {(char *)"session", __pyx_getprop_4ssh2_7channel_7Channel_session, 0, (char *)"Originating session.", 0},
+  {(char *)"session", __pyx_getprop_4ssh2_7channel_7Channel_session, 0, (char *)PyDoc_STR("Originating session."), 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_7channel_Channel_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_7channel_Channel},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_7channel_Channel},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_7channel_Channel},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_7channel_Channel},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_7channel_Channel},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_7channel_Channel},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_7channel_Channel_spec = {
+  "ssh2.channel.Channel",
+  sizeof(struct __pyx_obj_4ssh2_7channel_Channel),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_7channel_Channel_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_7channel_Channel = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.channel.Channel", /*tp_name*/
+  "ssh2.channel.""Channel", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_7channel_Channel), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_7channel_Channel, /*tp_dealloc*/
@@ -8174,7 +12117,9 @@ static PyTypeObject __pyx_type_4ssh2_7channel_Channel = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_7channel_Channel, /*tp_new*/
@@ -8188,54 +12133,33 @@ static PyTypeObject __pyx_type_4ssh2_7channel_Channel = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_channel(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_channel},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "channel",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -8245,1385 +12169,4826 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 0, 0},
-  {&__pyx_n_s_Channel, __pyx_k_Channel, sizeof(__pyx_k_Channel), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_adjustment, __pyx_k_adjustment, sizeof(__pyx_k_adjustment), 0, 0, 1, 1},
-  {&__pyx_n_s_auth_cookie, __pyx_k_auth_cookie, sizeof(__pyx_k_auth_cookie), 0, 0, 1, 1},
-  {&__pyx_n_s_auth_proto, __pyx_k_auth_proto, sizeof(__pyx_k_auth_proto), 0, 0, 1, 1},
-  {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_force, __pyx_k_force, sizeof(__pyx_k_force), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_message, __pyx_k_message, sizeof(__pyx_k_message), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_read_avail, __pyx_k_read_avail, sizeof(__pyx_k_read_avail), 0, 0, 1, 1},
-  {&__pyx_n_s_read_ex, __pyx_k_read_ex, sizeof(__pyx_k_read_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_request, __pyx_k_request, sizeof(__pyx_k_request), 0, 0, 1, 1},
-  {&__pyx_n_s_screen_number, __pyx_k_screen_number, sizeof(__pyx_k_screen_number), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_single_connection, __pyx_k_single_connection, sizeof(__pyx_k_single_connection), 0, 0, 1, 1},
-  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_id, __pyx_k_stream_id, sizeof(__pyx_k_stream_id), 0, 0, 1, 1},
-  {&__pyx_n_s_term, __pyx_k_term, sizeof(__pyx_k_term), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
-  {&__pyx_n_s_varname, __pyx_k_varname, sizeof(__pyx_k_varname), 0, 0, 1, 1},
-  {&__pyx_n_s_vt100, __pyx_k_vt100, sizeof(__pyx_k_vt100), 0, 0, 1, 1},
-  {&__pyx_n_s_window_size_initial, __pyx_k_window_size_initial, sizeof(__pyx_k_window_size_initial), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 0, 0},
+    {&__pyx_n_s_Channel, __pyx_k_Channel, sizeof(__pyx_k_Channel), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel___reduce_cython, __pyx_k_Channel___reduce_cython, sizeof(__pyx_k_Channel___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel___setstate_cython, __pyx_k_Channel___setstate_cython, sizeof(__pyx_k_Channel___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_close, __pyx_k_Channel_close, sizeof(__pyx_k_Channel_close), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_eof, __pyx_k_Channel_eof, sizeof(__pyx_k_Channel_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_execute, __pyx_k_Channel_execute, sizeof(__pyx_k_Channel_execute), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_flush, __pyx_k_Channel_flush, sizeof(__pyx_k_Channel_flush), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_flush_ex, __pyx_k_Channel_flush_ex, sizeof(__pyx_k_Channel_flush_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_flush_stderr, __pyx_k_Channel_flush_stderr, sizeof(__pyx_k_Channel_flush_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_get_exit_signal, __pyx_k_Channel_get_exit_signal, sizeof(__pyx_k_Channel_get_exit_signal), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_get_exit_status, __pyx_k_Channel_get_exit_status, sizeof(__pyx_k_Channel_get_exit_status), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_handle_extended_data, __pyx_k_Channel_handle_extended_data, sizeof(__pyx_k_Channel_handle_extended_data), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_handle_extended_data2, __pyx_k_Channel_handle_extended_data2, sizeof(__pyx_k_Channel_handle_extended_data2), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_ignore_extended_data, __pyx_k_Channel_ignore_extended_data, sizeof(__pyx_k_Channel_ignore_extended_data), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_poll_channel_read, __pyx_k_Channel_poll_channel_read, sizeof(__pyx_k_Channel_poll_channel_read), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_process_startup, __pyx_k_Channel_process_startup, sizeof(__pyx_k_Channel_process_startup), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_pty, __pyx_k_Channel_pty, sizeof(__pyx_k_Channel_pty), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_read, __pyx_k_Channel_read, sizeof(__pyx_k_Channel_read), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_read_ex, __pyx_k_Channel_read_ex, sizeof(__pyx_k_Channel_read_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_read_stderr, __pyx_k_Channel_read_stderr, sizeof(__pyx_k_Channel_read_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_receive_window_adjust, __pyx_k_Channel_receive_window_adjust, sizeof(__pyx_k_Channel_receive_window_adjust), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_receive_window_adjust2, __pyx_k_Channel_receive_window_adjust2, sizeof(__pyx_k_Channel_receive_window_adjust2), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_request_auth_agent, __pyx_k_Channel_request_auth_agent, sizeof(__pyx_k_Channel_request_auth_agent), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_send_eof, __pyx_k_Channel_send_eof, sizeof(__pyx_k_Channel_send_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_setenv, __pyx_k_Channel_setenv, sizeof(__pyx_k_Channel_setenv), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_shell, __pyx_k_Channel_shell, sizeof(__pyx_k_Channel_shell), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_subsystem, __pyx_k_Channel_subsystem, sizeof(__pyx_k_Channel_subsystem), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_wait_closed, __pyx_k_Channel_wait_closed, sizeof(__pyx_k_Channel_wait_closed), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_wait_eof, __pyx_k_Channel_wait_eof, sizeof(__pyx_k_Channel_wait_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_window_read, __pyx_k_Channel_window_read, sizeof(__pyx_k_Channel_window_read), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_window_read_ex, __pyx_k_Channel_window_read_ex, sizeof(__pyx_k_Channel_window_read_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_window_write, __pyx_k_Channel_window_write, sizeof(__pyx_k_Channel_window_write), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_window_write_ex, __pyx_k_Channel_window_write_ex, sizeof(__pyx_k_Channel_window_write_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_write, __pyx_k_Channel_write, sizeof(__pyx_k_Channel_write), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_write_ex, __pyx_k_Channel_write_ex, sizeof(__pyx_k_Channel_write_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_write_stderr, __pyx_k_Channel_write_stderr, sizeof(__pyx_k_Channel_write_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_x11_req, __pyx_k_Channel_x11_req, sizeof(__pyx_k_Channel_x11_req), 0, 0, 1, 1},
+    {&__pyx_n_s_Channel_x11_req_ex, __pyx_k_Channel_x11_req_ex, sizeof(__pyx_k_Channel_x11_req_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0},
+    {&__pyx_n_s__67, __pyx_k__67, sizeof(__pyx_k__67), 0, 0, 1, 1},
+    {&__pyx_n_s_adjustment, __pyx_k_adjustment, sizeof(__pyx_k_adjustment), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_auth_cookie, __pyx_k_auth_cookie, sizeof(__pyx_k_auth_cookie), 0, 0, 1, 1},
+    {&__pyx_n_s_auth_proto, __pyx_k_auth_proto, sizeof(__pyx_k_auth_proto), 0, 0, 1, 1},
+    {&__pyx_n_s_b_buf, __pyx_k_b_buf, sizeof(__pyx_k_b_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_b_command, __pyx_k_b_command, sizeof(__pyx_k_b_command), 0, 0, 1, 1},
+    {&__pyx_n_s_b_message, __pyx_k_b_message, sizeof(__pyx_k_b_message), 0, 0, 1, 1},
+    {&__pyx_n_s_b_request, __pyx_k_b_request, sizeof(__pyx_k_b_request), 0, 0, 1, 1},
+    {&__pyx_n_s_b_subsystem, __pyx_k_b_subsystem, sizeof(__pyx_k_b_subsystem), 0, 0, 1, 1},
+    {&__pyx_n_s_b_term, __pyx_k_b_term, sizeof(__pyx_k_b_term), 0, 0, 1, 1},
+    {&__pyx_n_s_b_value, __pyx_k_b_value, sizeof(__pyx_k_b_value), 0, 0, 1, 1},
+    {&__pyx_n_s_b_varname, __pyx_k_b_varname, sizeof(__pyx_k_b_varname), 0, 0, 1, 1},
+    {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_buf_2, __pyx_k_buf_2, sizeof(__pyx_k_buf_2), 0, 0, 1, 1},
+    {&__pyx_n_s_buf_remainder, __pyx_k_buf_remainder, sizeof(__pyx_k_buf_remainder), 0, 0, 1, 1},
+    {&__pyx_n_s_buf_tot_size, __pyx_k_buf_tot_size, sizeof(__pyx_k_buf_tot_size), 0, 0, 1, 1},
+    {&__pyx_n_s_bytes_written, __pyx_k_bytes_written, sizeof(__pyx_k_bytes_written), 0, 0, 1, 1},
+    {&__pyx_n_s_cbuf, __pyx_k_cbuf, sizeof(__pyx_k_cbuf), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
+    {&__pyx_n_s_command, __pyx_k_command, sizeof(__pyx_k_command), 0, 0, 1, 1},
+    {&__pyx_n_s_command_2, __pyx_k_command_2, sizeof(__pyx_k_command_2), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_eof, __pyx_k_eof, sizeof(__pyx_k_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_errmsg, __pyx_k_errmsg, sizeof(__pyx_k_errmsg), 0, 0, 1, 1},
+    {&__pyx_n_s_errmsg_len, __pyx_k_errmsg_len, sizeof(__pyx_k_errmsg_len), 0, 0, 1, 1},
+    {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
+    {&__pyx_n_s_execute, __pyx_k_execute, sizeof(__pyx_k_execute), 0, 0, 1, 1},
+    {&__pyx_n_s_exitsignal, __pyx_k_exitsignal, sizeof(__pyx_k_exitsignal), 0, 0, 1, 1},
+    {&__pyx_n_s_exitsignal_len, __pyx_k_exitsignal_len, sizeof(__pyx_k_exitsignal_len), 0, 0, 1, 1},
+    {&__pyx_n_s_extended, __pyx_k_extended, sizeof(__pyx_k_extended), 0, 0, 1, 1},
+    {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1},
+    {&__pyx_n_s_flush_ex, __pyx_k_flush_ex, sizeof(__pyx_k_flush_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_flush_stderr, __pyx_k_flush_stderr, sizeof(__pyx_k_flush_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_force, __pyx_k_force, sizeof(__pyx_k_force), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_get_exit_signal, __pyx_k_get_exit_signal, sizeof(__pyx_k_get_exit_signal), 0, 0, 1, 1},
+    {&__pyx_n_s_get_exit_status, __pyx_k_get_exit_status, sizeof(__pyx_k_get_exit_status), 0, 0, 1, 1},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_handle_extended_data, __pyx_k_handle_extended_data, sizeof(__pyx_k_handle_extended_data), 0, 0, 1, 1},
+    {&__pyx_n_s_handle_extended_data2, __pyx_k_handle_extended_data2, sizeof(__pyx_k_handle_extended_data2), 0, 0, 1, 1},
+    {&__pyx_n_s_ignore_extended_data, __pyx_k_ignore_extended_data, sizeof(__pyx_k_ignore_extended_data), 0, 0, 1, 1},
+    {&__pyx_n_s_ignore_mode, __pyx_k_ignore_mode, sizeof(__pyx_k_ignore_mode), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_langtag, __pyx_k_langtag, sizeof(__pyx_k_langtag), 0, 0, 1, 1},
+    {&__pyx_n_s_langtag_len, __pyx_k_langtag_len, sizeof(__pyx_k_langtag_len), 0, 0, 1, 1},
+    {&__pyx_n_s_m_len, __pyx_k_m_len, sizeof(__pyx_k_m_len), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_message, __pyx_k_message, sizeof(__pyx_k_message), 0, 0, 1, 1},
+    {&__pyx_n_s_message_2, __pyx_k_message_2, sizeof(__pyx_k_message_2), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_poll_channel_read, __pyx_k_poll_channel_read, sizeof(__pyx_k_poll_channel_read), 0, 0, 1, 1},
+    {&__pyx_n_s_process_startup, __pyx_k_process_startup, sizeof(__pyx_k_process_startup), 0, 0, 1, 1},
+    {&__pyx_n_s_pty, __pyx_k_pty, sizeof(__pyx_k_pty), 0, 0, 1, 1},
+    {&__pyx_n_s_py_errlen, __pyx_k_py_errlen, sizeof(__pyx_k_py_errlen), 0, 0, 1, 1},
+    {&__pyx_n_s_py_errmsg, __pyx_k_py_errmsg, sizeof(__pyx_k_py_errmsg), 0, 0, 1, 1},
+    {&__pyx_n_s_py_exitsignal, __pyx_k_py_exitsignal, sizeof(__pyx_k_py_exitsignal), 0, 0, 1, 1},
+    {&__pyx_n_s_py_langlen, __pyx_k_py_langlen, sizeof(__pyx_k_py_langlen), 0, 0, 1, 1},
+    {&__pyx_n_s_py_langtag, __pyx_k_py_langtag, sizeof(__pyx_k_py_langtag), 0, 0, 1, 1},
+    {&__pyx_n_s_py_siglen, __pyx_k_py_siglen, sizeof(__pyx_k_py_siglen), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_r_len, __pyx_k_r_len, sizeof(__pyx_k_r_len), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1},
+    {&__pyx_n_s_read_avail, __pyx_k_read_avail, sizeof(__pyx_k_read_avail), 0, 0, 1, 1},
+    {&__pyx_n_s_read_ex, __pyx_k_read_ex, sizeof(__pyx_k_read_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_read_stderr, __pyx_k_read_stderr, sizeof(__pyx_k_read_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_receive_window_adjust, __pyx_k_receive_window_adjust, sizeof(__pyx_k_receive_window_adjust), 0, 0, 1, 1},
+    {&__pyx_n_s_receive_window_adjust2, __pyx_k_receive_window_adjust2, sizeof(__pyx_k_receive_window_adjust2), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_request, __pyx_k_request, sizeof(__pyx_k_request), 0, 0, 1, 1},
+    {&__pyx_n_s_request_2, __pyx_k_request_2, sizeof(__pyx_k_request_2), 0, 0, 1, 1},
+    {&__pyx_n_s_request_auth_agent, __pyx_k_request_auth_agent, sizeof(__pyx_k_request_auth_agent), 0, 0, 1, 1},
+    {&__pyx_n_s_screen_number, __pyx_k_screen_number, sizeof(__pyx_k_screen_number), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_send_eof, __pyx_k_send_eof, sizeof(__pyx_k_send_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_setenv, __pyx_k_setenv, sizeof(__pyx_k_setenv), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_shell, __pyx_k_shell, sizeof(__pyx_k_shell), 0, 0, 1, 1},
+    {&__pyx_n_s_single_connection, __pyx_k_single_connection, sizeof(__pyx_k_single_connection), 0, 0, 1, 1},
+    {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_channel, __pyx_k_ssh2_channel, sizeof(__pyx_k_ssh2_channel), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_channel_pyx, __pyx_k_ssh2_channel_pyx, sizeof(__pyx_k_ssh2_channel_pyx), 0, 0, 1, 0},
+    {&__pyx_n_s_storewindow, __pyx_k_storewindow, sizeof(__pyx_k_storewindow), 0, 0, 1, 1},
+    {&__pyx_n_s_stream_id, __pyx_k_stream_id, sizeof(__pyx_k_stream_id), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_subsystem, __pyx_k_subsystem, sizeof(__pyx_k_subsystem), 0, 0, 1, 1},
+    {&__pyx_n_s_subsystem_2, __pyx_k_subsystem_2, sizeof(__pyx_k_subsystem_2), 0, 0, 1, 1},
+    {&__pyx_n_s_term, __pyx_k_term, sizeof(__pyx_k_term), 0, 0, 1, 1},
+    {&__pyx_n_s_term_2, __pyx_k_term_2, sizeof(__pyx_k_term_2), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
+    {&__pyx_n_s_value_2, __pyx_k_value_2, sizeof(__pyx_k_value_2), 0, 0, 1, 1},
+    {&__pyx_n_s_varname, __pyx_k_varname, sizeof(__pyx_k_varname), 0, 0, 1, 1},
+    {&__pyx_n_s_varname_2, __pyx_k_varname_2, sizeof(__pyx_k_varname_2), 0, 0, 1, 1},
+    {&__pyx_n_u_vt100, __pyx_k_vt100, sizeof(__pyx_k_vt100), 0, 1, 0, 1},
+    {&__pyx_n_s_wait_closed, __pyx_k_wait_closed, sizeof(__pyx_k_wait_closed), 0, 0, 1, 1},
+    {&__pyx_n_s_wait_eof, __pyx_k_wait_eof, sizeof(__pyx_k_wait_eof), 0, 0, 1, 1},
+    {&__pyx_n_s_window_read, __pyx_k_window_read, sizeof(__pyx_k_window_read), 0, 0, 1, 1},
+    {&__pyx_n_s_window_read_ex, __pyx_k_window_read_ex, sizeof(__pyx_k_window_read_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_window_size_initial, __pyx_k_window_size_initial, sizeof(__pyx_k_window_size_initial), 0, 0, 1, 1},
+    {&__pyx_n_s_window_write, __pyx_k_window_write, sizeof(__pyx_k_window_write), 0, 0, 1, 1},
+    {&__pyx_n_s_window_write_ex, __pyx_k_window_write_ex, sizeof(__pyx_k_window_write_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1},
+    {&__pyx_n_s_write_ex, __pyx_k_write_ex, sizeof(__pyx_k_write_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_write_stderr, __pyx_k_write_stderr, sizeof(__pyx_k_write_stderr), 0, 0, 1, 1},
+    {&__pyx_n_s_x11_req, __pyx_k_x11_req, sizeof(__pyx_k_x11_req), 0, 0, 1, 1},
+    {&__pyx_n_s_x11_req_ex, __pyx_k_x11_req_ex, sizeof(__pyx_k_x11_req_ex), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 136, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 137, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "ssh2/channel.pyx":49
+ *         return self._session
+ * 
+ *     def pty(self, term="vt100"):             # <<<<<<<<<<<<<<
+ *         """Request a PTY (physical terminal emulation) on the channel.
+ * 
  */
-  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 4, __pyx_L1_error)
+  __pyx_tuple__3 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_term, __pyx_n_s_b_term, __pyx_n_s_term_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 49, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__3);
   __Pyx_GIVEREF(__pyx_tuple__3);
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_pty, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_u_vt100); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "ssh2/channel.pyx":63
+ *         return handle_error_codes(rc)
+ * 
+ *     def execute(self, command not None):             # <<<<<<<<<<<<<<
+ *         """Execute command.
+ * 
+ */
+  __pyx_tuple__6 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_command, __pyx_n_s_rc, __pyx_n_s_b_command, __pyx_n_s_command_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_execute, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 63, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":82
+ *         return handle_error_codes(rc)
+ * 
+ *     def subsystem(self, subsystem not None):             # <<<<<<<<<<<<<<
+ *         """Request subsystem from channel.
+ * 
+ */
+  __pyx_tuple__8 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_subsystem, __pyx_n_s_rc, __pyx_n_s_b_subsystem, __pyx_n_s_subsystem_2); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_subsystem, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 82, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":95
+ *         return handle_error_codes(rc)
+ * 
+ *     def shell(self):             # <<<<<<<<<<<<<<
+ *         """Request interactive shell from channel.
+ * 
+ */
+  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_shell, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 95, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":106
+ *         return handle_error_codes(rc)
+ * 
+ *     def read(self, size_t size=1024):             # <<<<<<<<<<<<<<
+ *         """Read the stdout stream.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_tuple__12 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_size); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_read, 106, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_int_1024); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+
+  /* "ssh2/channel.pyx":119
+ *         return self.read_ex(size=size, stream_id=0)
+ * 
+ *     def read_ex(self, size_t size=1024, int stream_id=0):             # <<<<<<<<<<<<<<
+ *         """Read the stream with given id.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_size, __pyx_n_s_stream_id, __pyx_n_s_buf, __pyx_n_s_cbuf, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+  __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_read_ex, 119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __pyx_tuple__17 = PyTuple_Pack(2, __pyx_int_1024, __pyx_int_0); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+  /* "ssh2/channel.pyx":148
+ *         return rc, buf
+ * 
+ *     def read_stderr(self, size_t size=1024):             # <<<<<<<<<<<<<<
+ *         """Read the stderr stream.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_read_stderr, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 148, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":159
+ *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)
+ * 
+ *     def eof(self):             # <<<<<<<<<<<<<<
+ *         """Get channel EOF status.
+ * 
+ */
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_eof, 159, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 159, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":168
+ *         return bool(rc)
+ * 
+ *     def send_eof(self):             # <<<<<<<<<<<<<<
+ *         """Tell the remote host that no further data will be sent on the
+ *         specified channel. Processes typically interpret this as a closed stdin
+ */
+  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_send_eof, 168, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 168, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":183
+ *         return handle_error_codes(rc)
+ * 
+ *     def wait_eof(self):             # <<<<<<<<<<<<<<
+ *         """Wait for the remote end to acknowledge an EOF request.
+ * 
+ */
+  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_wait_eof, 183, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 183, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":197
+ *         return handle_error_codes(rc)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close channel. Typically done to be able to get exit status."""
+ *         cdef int rc
+ */
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_close, 197, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 197, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":204
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush(self):             # <<<<<<<<<<<<<<
+ *         """Flush stdout stream"""
+ *         cdef int rc
+ */
+  __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_flush, 204, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 204, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":211
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush_ex(self, int stream_id):             # <<<<<<<<<<<<<<
+ *         """Flush stream with id"""
+ *         cdef int rc
+ */
+  __pyx_tuple__24 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_stream_id, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+  __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_flush_ex, 211, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 211, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":218
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush_stderr(self):             # <<<<<<<<<<<<<<
+ *         """Flush stderr stream"""
+ *         cdef int rc
+ */
+  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_flush_stderr, 218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 218, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":225
+ *         return handle_error_codes(rc)
+ * 
+ *     def wait_closed(self):             # <<<<<<<<<<<<<<
+ *         """Wait for server to acknowledge channel close command."""
+ *         cdef int rc
+ */
+  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_wait_closed, 225, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 225, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":232
+ *         return handle_error_codes(rc)
+ * 
+ *     def get_exit_status(self):             # <<<<<<<<<<<<<<
+ *         """Get exit status of command.
+ * 
+ */
+  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_get_exit_status, 232, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 232, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":250
+ *         return rc
+ * 
+ *     def get_exit_signal(self):             # <<<<<<<<<<<<<<
+ *         """Get exit signal, message and language tag, if any, for command.
+ * 
+ */
+  __pyx_tuple__29 = PyTuple_Pack(14, __pyx_n_s_self, __pyx_n_s_exitsignal, __pyx_n_s_exitsignal_len, __pyx_n_s_errmsg, __pyx_n_s_errmsg_len, __pyx_n_s_langtag, __pyx_n_s_langtag_len, __pyx_n_s_rc, __pyx_n_s_py_exitsignal, __pyx_n_s_py_errmsg, __pyx_n_s_py_langtag, __pyx_n_s_py_siglen, __pyx_n_s_py_errlen, __pyx_n_s_py_langlen); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+  __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_get_exit_signal, 250, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 250, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":290
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
+ * 
+ *     def setenv(self, varname not None, value not None):             # <<<<<<<<<<<<<<
+ *         """Set environment variable on channel.
+ * 
+ */
+  __pyx_tuple__31 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_varname, __pyx_n_s_value, __pyx_n_s_rc, __pyx_n_s_b_varname, __pyx_n_s_b_value, __pyx_n_s_varname_2, __pyx_n_s_value_2); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_setenv, 290, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 290, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":309
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_read_ex(self, unsigned long read_avail,             # <<<<<<<<<<<<<<
+ *                        unsigned long window_size_initial):
+ *         cdef unsigned long rc
+ */
+  __pyx_tuple__33 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_read_avail, __pyx_n_s_window_size_initial, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_window_read_ex, 309, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 309, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":317
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_read(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_window_read, 317, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 317, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":323
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_write_ex(self, unsigned long window_size_initial):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_tuple__36 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_window_size_initial, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 323, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__36);
+  __Pyx_GIVEREF(__pyx_tuple__36);
+  __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_window_write_ex, 323, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 323, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":330
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_write(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_window_write, 330, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 330, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":336
+ *         return handle_error_codes(rc)
+ * 
+ *     def receive_window_adjust(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
+ *                               unsigned long force):
+ *         cdef unsigned long rc
+ */
+  __pyx_tuple__39 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_adjustment, __pyx_n_s_force, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 336, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+  __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_receive_window_adjust, 336, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 336, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":344
+ *         return handle_error_codes(rc)
+ * 
+ *     def receive_window_adjust2(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
+ *                                unsigned long force):
+ *         cdef unsigned long rc
+ */
+  __pyx_tuple__41 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_adjustment, __pyx_n_s_force, __pyx_n_s_rc, __pyx_n_s_storewindow); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 344, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__41);
+  __Pyx_GIVEREF(__pyx_tuple__41);
+  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_receive_window_adjust2, 344, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 344, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":353
+ *         return handle_error_codes(rc)
+ * 
+ *     def write(self, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to stdin.
+ * 
+ */
+  __pyx_tuple__43 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_buf, __pyx_n_s_b_buf, __pyx_n_s_buf_2, __pyx_n_s_buf_remainder, __pyx_n_s_buf_tot_size, __pyx_n_s_rc, __pyx_n_s_bytes_written); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 353, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__43);
+  __Pyx_GIVEREF(__pyx_tuple__43);
+  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_write, 353, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 353, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":399
+ *         return rc, bytes_written
+ * 
+ *     def write_ex(self, int stream_id, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to specified stream id.
+ * 
+ */
+  __pyx_tuple__45 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_stream_id, __pyx_n_s_buf, __pyx_n_s_b_buf, __pyx_n_s_buf_2, __pyx_n_s_buf_remainder, __pyx_n_s_buf_tot_size, __pyx_n_s_rc, __pyx_n_s_bytes_written); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 399, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__45);
+  __Pyx_GIVEREF(__pyx_tuple__45);
+  __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_write_ex, 399, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 399, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":448
+ *         return rc, bytes_written
+ * 
+ *     def write_stderr(self, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to stderr.
+ * 
+ */
+  __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_write_stderr, 448, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 448, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":494
+ *         return rc, bytes_written
+ * 
+ *     def x11_req(self, int screen_number):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_tuple__48 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_screen_number, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__48);
+  __Pyx_GIVEREF(__pyx_tuple__48);
+  __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_x11_req, 494, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 494, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":501
+ *         return handle_error_codes(rc)
+ * 
+ *     def x11_req_ex(self, int single_connection,             # <<<<<<<<<<<<<<
+ *                    const char *auth_proto,
+ *                    const char *auth_cookie,
+ */
+  __pyx_tuple__50 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_single_connection, __pyx_n_s_auth_proto, __pyx_n_s_auth_cookie, __pyx_n_s_screen_number, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 501, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__50);
+  __Pyx_GIVEREF(__pyx_tuple__50);
+  __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_x11_req_ex, 501, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 501, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":512
+ *         return handle_error_codes(rc)
+ * 
+ *     def process_startup(self, request, message=None):             # <<<<<<<<<<<<<<
+ *         """Startup process on server for request with message.
+ * 
+ */
+  __pyx_tuple__52 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_request, __pyx_n_s_message, __pyx_n_s_b_request, __pyx_n_s_b_message, __pyx_n_s_request_2, __pyx_n_s_message_2, __pyx_n_s_r_len, __pyx_n_s_m_len, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 512, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__52);
+  __Pyx_GIVEREF(__pyx_tuple__52);
+  __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_process_startup, 512, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(0, 512, __pyx_L1_error)
+  __pyx_tuple__54 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 512, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__54);
+  __Pyx_GIVEREF(__pyx_tuple__54);
+
+  /* "ssh2/channel.pyx":540
+ *         return handle_error_codes(rc)
+ * 
+ *     def poll_channel_read(self, int extended):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use session.block_directions and socket polling
+ *         instead"""
+ */
+  __pyx_tuple__55 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_extended, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 540, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__55);
+  __Pyx_GIVEREF(__pyx_tuple__55);
+  __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_poll_channel_read, 540, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(0, 540, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":548
+ *         return handle_error_codes(rc)
+ * 
+ *     def handle_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use handle_extended_data2"""
+ *         with nogil:
+ */
+  __pyx_tuple__57 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_ignore_mode); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__57);
+  __Pyx_GIVEREF(__pyx_tuple__57);
+  __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__57, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_handle_extended_data, 548, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(0, 548, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":554
+ *                 self._channel, ignore_mode)
+ * 
+ *     def handle_extended_data2(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_tuple__59 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_ignore_mode, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 554, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__59);
+  __Pyx_GIVEREF(__pyx_tuple__59);
+  __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_handle_extended_data2, 554, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(0, 554, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":561
+ *         return handle_error_codes(rc)
+ * 
+ *     def ignore_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use handle_extended_data2"""
+ *         with nogil:
+ */
+  __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__57, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_ignore_extended_data, 561, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 561, __pyx_L1_error)
+
+  /* "ssh2/channel.pyx":567
+ *                 self._channel, ignore_mode)
+ * 
+ *     def request_auth_agent(self):             # <<<<<<<<<<<<<<
+ *         """Request SSH agent authentication forwarding on channel."""
+ *         cdef int rc
+ */
+  __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_channel_pyx, __pyx_n_s_request_auth_agent, 567, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(0, 567, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_tuple__63 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__63);
+  __Pyx_GIVEREF(__pyx_tuple__63);
+  __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(1, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__65 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__65);
+  __Pyx_GIVEREF(__pyx_tuple__65);
+  __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+/* #### Code section: init_constants ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
+
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  if (__Pyx_ExportFunction("PyChannel", (void (*)(void))__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_7channel_Channel = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_7channel_Channel_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_7channel_Channel)) __PYX_ERR(0, 34, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_7channel_Channel_spec, __pyx_ptype_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_7channel_Channel = &__pyx_type_4ssh2_7channel_Channel;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_7channel_Channel->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_7channel_Channel->tp_dictoffset && __pyx_ptype_4ssh2_7channel_Channel->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_7channel_Channel->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Channel, (PyObject *) __pyx_ptype_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  #endif
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_4sftp_SFTP),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(3, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_variable_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
   return -1;
 }
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
+
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_channel(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_channel},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "channel",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
+#endif
+#endif
+
+
+#if PY_MAJOR_VERSION < 3
+__Pyx_PyMODINIT_FUNC initchannel(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initchannel(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_channel(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_channel(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    #if PY_VERSION_HEX >= 0x030700A1
+    static PY_INT64_T main_interpreter_id = -1;
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return (unlikely(current_id == -1)) ? -1 : 0;
+    } else if (unlikely(main_interpreter_id != current_id))
+    #else
+    static PyInterpreterState *main_interpreter = NULL;
+    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
+    if (!main_interpreter) {
+        main_interpreter = current_interpreter;
+    } else if (unlikely(main_interpreter != current_interpreter))
+    #endif
+    {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
+            result = PyDict_SetItemString(moddict, to_name, value);
+#endif
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+#endif
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_channel(PyObject *__pyx_pyinit_module)
+#endif
+#endif
+{
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module 'channel' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #elif PY_MAJOR_VERSION >= 3
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("channel", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "channel" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if CYTHON_REFNANNY
+__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+if (!__Pyx_RefNanny) {
+  PyErr_Clear();
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+  if (!__Pyx_RefNanny)
+      Py_FatalError("failed to import 'refnanny' module");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_channel(void)", 0);
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pxy_PyFrame_Initialize_Offsets
+  __Pxy_PyFrame_Initialize_Offsets();
+  #endif
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_AsyncGen_USED
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  PyEval_InitThreads();
+  #endif
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_ssh2__channel) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "ssh2.channel")) {
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.channel", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code();
+  (void)__Pyx_modinit_variable_export_code();
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code();
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "ssh2/channel.pyx":19
+ * from libc.stdlib cimport malloc, free
+ * 
+ * from .exceptions import ChannelError             # <<<<<<<<<<<<<<
+ * 
+ * from .session cimport Session
+ */
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_n_s_ChannelError);
+  __Pyx_GIVEREF(__pyx_n_s_ChannelError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_ChannelError)) __PYX_ERR(0, 19, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/channel.pyx":49
+ *         return self._session
+ * 
+ *     def pty(self, term="vt100"):             # <<<<<<<<<<<<<<
+ *         """Request a PTY (physical terminal emulation) on the channel.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_5pty, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_pty, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__5);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_pty, __pyx_t_3) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":63
+ *         return handle_error_codes(rc)
+ * 
+ *     def execute(self, command not None):             # <<<<<<<<<<<<<<
+ *         """Execute command.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_7execute, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_execute, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_execute, __pyx_t_3) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":82
+ *         return handle_error_codes(rc)
+ * 
+ *     def subsystem(self, subsystem not None):             # <<<<<<<<<<<<<<
+ *         """Request subsystem from channel.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_9subsystem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_subsystem, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_subsystem, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":95
+ *         return handle_error_codes(rc)
+ * 
+ *     def shell(self):             # <<<<<<<<<<<<<<
+ *         """Request interactive shell from channel.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_11shell, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_shell, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_shell, __pyx_t_3) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":106
+ *         return handle_error_codes(rc)
+ * 
+ *     def read(self, size_t size=1024):             # <<<<<<<<<<<<<<
+ *         """Read the stdout stream.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_13read, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__14);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_read, __pyx_t_3) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":119
+ *         return self.read_ex(size=size, stream_id=0)
+ * 
+ *     def read_ex(self, size_t size=1024, int stream_id=0):             # <<<<<<<<<<<<<<
+ *         """Read the stream with given id.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_15read_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__17);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_read_ex, __pyx_t_3) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":148
+ *         return rc, buf
+ * 
+ *     def read_stderr(self, size_t size=1024):             # <<<<<<<<<<<<<<
+ *         """Read the stderr stream.
+ *         Returns return code and output buffer tuple.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_17read_stderr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_read_stderr, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__14);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_read_stderr, __pyx_t_3) < 0) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":159
+ *             size=size, stream_id=c_ssh2.SSH_EXTENDED_DATA_STDERR)
+ * 
+ *     def eof(self):             # <<<<<<<<<<<<<<
+ *         """Get channel EOF status.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_19eof, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_eof, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_eof, __pyx_t_3) < 0) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":168
+ *         return bool(rc)
+ * 
+ *     def send_eof(self):             # <<<<<<<<<<<<<<
+ *         """Tell the remote host that no further data will be sent on the
+ *         specified channel. Processes typically interpret this as a closed stdin
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_21send_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_send_eof, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_send_eof, __pyx_t_3) < 0) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":183
+ *         return handle_error_codes(rc)
+ * 
+ *     def wait_eof(self):             # <<<<<<<<<<<<<<
+ *         """Wait for the remote end to acknowledge an EOF request.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_23wait_eof, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_wait_eof, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_wait_eof, __pyx_t_3) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":197
+ *         return handle_error_codes(rc)
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close channel. Typically done to be able to get exit status."""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_25close, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_close, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_close, __pyx_t_3) < 0) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":204
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush(self):             # <<<<<<<<<<<<<<
+ *         """Flush stdout stream"""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_27flush, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_flush, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_flush, __pyx_t_3) < 0) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":211
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush_ex(self, int stream_id):             # <<<<<<<<<<<<<<
+ *         """Flush stream with id"""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_29flush_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_flush_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_flush_ex, __pyx_t_3) < 0) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":218
+ *         return handle_error_codes(rc)
+ * 
+ *     def flush_stderr(self):             # <<<<<<<<<<<<<<
+ *         """Flush stderr stream"""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_31flush_stderr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_flush_stderr, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_flush_stderr, __pyx_t_3) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":225
+ *         return handle_error_codes(rc)
+ * 
+ *     def wait_closed(self):             # <<<<<<<<<<<<<<
+ *         """Wait for server to acknowledge channel close command."""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_33wait_closed, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_wait_closed, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_wait_closed, __pyx_t_3) < 0) __PYX_ERR(0, 225, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":232
+ *         return handle_error_codes(rc)
+ * 
+ *     def get_exit_status(self):             # <<<<<<<<<<<<<<
+ *         """Get exit status of command.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_35get_exit_status, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_get_exit_status, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_get_exit_status, __pyx_t_3) < 0) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":250
+ *         return rc
+ * 
+ *     def get_exit_signal(self):             # <<<<<<<<<<<<<<
+ *         """Get exit signal, message and language tag, if any, for command.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_37get_exit_signal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_get_exit_signal, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_get_exit_signal, __pyx_t_3) < 0) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":290
+ *         return rc, py_exitsignal, py_errmsg, py_langtag
+ * 
+ *     def setenv(self, varname not None, value not None):             # <<<<<<<<<<<<<<
+ *         """Set environment variable on channel.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_39setenv, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_setenv, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_setenv, __pyx_t_3) < 0) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":309
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_read_ex(self, unsigned long read_avail,             # <<<<<<<<<<<<<<
+ *                        unsigned long window_size_initial):
+ *         cdef unsigned long rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_41window_read_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_window_read_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_window_read_ex, __pyx_t_3) < 0) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":317
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_read(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_43window_read, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_window_read, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_window_read, __pyx_t_3) < 0) __PYX_ERR(0, 317, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":323
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_write_ex(self, unsigned long window_size_initial):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_45window_write_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_window_write_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_window_write_ex, __pyx_t_3) < 0) __PYX_ERR(0, 323, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":330
+ *         return handle_error_codes(rc)
+ * 
+ *     def window_write(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_47window_write, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_window_write, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_window_write, __pyx_t_3) < 0) __PYX_ERR(0, 330, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":336
+ *         return handle_error_codes(rc)
+ * 
+ *     def receive_window_adjust(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
+ *                               unsigned long force):
+ *         cdef unsigned long rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_49receive_window_adjust, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_receive_window_adjust, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_receive_window_adjust, __pyx_t_3) < 0) __PYX_ERR(0, 336, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":344
+ *         return handle_error_codes(rc)
+ * 
+ *     def receive_window_adjust2(self, unsigned long adjustment,             # <<<<<<<<<<<<<<
+ *                                unsigned long force):
+ *         cdef unsigned long rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_51receive_window_adjust2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_receive_window_adjust2, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 344, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_receive_window_adjust2, __pyx_t_3) < 0) __PYX_ERR(0, 344, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":353
+ *         return handle_error_codes(rc)
+ * 
+ *     def write(self, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to stdin.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_53write, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_write, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 353, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_write, __pyx_t_3) < 0) __PYX_ERR(0, 353, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":399
+ *         return rc, bytes_written
+ * 
+ *     def write_ex(self, int stream_id, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to specified stream id.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_55write_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_write_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 399, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_write_ex, __pyx_t_3) < 0) __PYX_ERR(0, 399, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":448
+ *         return rc, bytes_written
+ * 
+ *     def write_stderr(self, buf not None):             # <<<<<<<<<<<<<<
+ *         """Write buffer to stderr.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_57write_stderr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_write_stderr, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_write_stderr, __pyx_t_3) < 0) __PYX_ERR(0, 448, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":494
+ *         return rc, bytes_written
+ * 
+ *     def x11_req(self, int screen_number):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_59x11_req, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_x11_req, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_x11_req, __pyx_t_3) < 0) __PYX_ERR(0, 494, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":501
+ *         return handle_error_codes(rc)
+ * 
+ *     def x11_req_ex(self, int single_connection,             # <<<<<<<<<<<<<<
+ *                    const char *auth_proto,
+ *                    const char *auth_cookie,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_61x11_req_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_x11_req_ex, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 501, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_x11_req_ex, __pyx_t_3) < 0) __PYX_ERR(0, 501, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":512
+ *         return handle_error_codes(rc)
+ * 
+ *     def process_startup(self, request, message=None):             # <<<<<<<<<<<<<<
+ *         """Startup process on server for request with message.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_63process_startup, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_process_startup, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 512, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__54);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_process_startup, __pyx_t_3) < 0) __PYX_ERR(0, 512, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":540
+ *         return handle_error_codes(rc)
+ * 
+ *     def poll_channel_read(self, int extended):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use session.block_directions and socket polling
+ *         instead"""
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_65poll_channel_read, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_poll_channel_read, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 540, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_poll_channel_read, __pyx_t_3) < 0) __PYX_ERR(0, 540, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":548
+ *         return handle_error_codes(rc)
+ * 
+ *     def handle_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use handle_extended_data2"""
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_67handle_extended_data, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_handle_extended_data, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_handle_extended_data, __pyx_t_3) < 0) __PYX_ERR(0, 548, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":554
+ *                 self._channel, ignore_mode)
+ * 
+ *     def handle_extended_data2(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_69handle_extended_data2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_handle_extended_data2, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 554, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_handle_extended_data2, __pyx_t_3) < 0) __PYX_ERR(0, 554, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":561
+ *         return handle_error_codes(rc)
+ * 
+ *     def ignore_extended_data(self, int ignore_mode):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use handle_extended_data2"""
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_71ignore_extended_data, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_ignore_extended_data, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 561, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_ignore_extended_data, __pyx_t_3) < 0) __PYX_ERR(0, 561, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "ssh2/channel.pyx":567
+ *                 self._channel, ignore_mode)
+ * 
+ *     def request_auth_agent(self):             # <<<<<<<<<<<<<<
+ *         """Request SSH agent authentication forwarding on channel."""
+ *         cdef int rc
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_73request_auth_agent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel_request_auth_agent, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7channel_Channel, __pyx_n_s_request_auth_agent, __pyx_t_3) < 0) __PYX_ERR(0, 567, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7channel_Channel);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_75__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel___reduce_cython, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7channel_7Channel_77__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Channel___setstate_cython, NULL, __pyx_n_s_ssh2_channel, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/channel.pyx":1
+ * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
+ * # Copyright (C) 2017-2020 Panos Kittenis
+ * #
+ */
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  if (__pyx_m) {
+    if (__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init ssh2.channel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init ssh2.channel");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #elif PY_MAJOR_VERSION >= 3
+  return __pyx_m;
+  #else
+  return;
+  #endif
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* ArgTypeTest */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
+        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
+#endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* GetException */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+  #endif
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
+    }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* SwapException */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = *type;
+    exc_info->exc_value = *value;
+    exc_info->exc_traceback = *tb;
+  #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = *type;
+    tstate->exc_value = *value;
+    tstate->exc_traceback = *tb;
+  #endif
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
+    PyErr_SetExcInfo(*type, *value, *tb);
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#endif
+
+/* GetTopmostException */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+/* SaveResetException */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #endif
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+  #endif
 }
+#endif
 
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+/* RaiseException */
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
 
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
 }
-
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
 }
+#endif
 
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  if (__Pyx_ExportFunction("PyChannel", (void (*)(void))__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
 }
+#endif
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_7channel_Channel.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_7channel_Channel.tp_dictoffset && __pyx_type_4ssh2_7channel_Channel.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_7channel_Channel.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Channel, (PyObject *)&__pyx_type_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_7channel_Channel) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7channel_Channel = &__pyx_type_4ssh2_7channel_Channel;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
 }
-
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
-  __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 26, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(3, 26, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
 
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
-static int __Pyx_modinit_function_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
-  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
-
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
 #else
-#define __Pyx_PyMODINIT_FUNC void
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
 #endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
 #else
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
 #else
-#define __Pyx_PyMODINIT_FUNC PyObject *
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
 #endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
 #endif
+    *method = attr;
+    return 0;
+}
 
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
 
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC initchannel(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC initchannel(void)
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
 #else
-__Pyx_PyMODINIT_FUNC PyInit_channel(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit_channel(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
-}
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
-    #else
-    static PyInterpreterState *main_interpreter = NULL;
-    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
-    if (!main_interpreter) {
-        main_interpreter = current_interpreter;
-    } else if (unlikely(main_interpreter != current_interpreter))
-    #endif
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
     {
-        PyErr_SetString(
-            PyExc_ImportError,
-            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
-        return -1;
-    }
-    return 0;
-}
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
-    PyObject *value = PyObject_GetAttrString(spec, from_name);
-    int result = 0;
-    if (likely(value)) {
-        if (allow_none || value != Py_None) {
-            result = PyDict_SetItemString(moddict, to_name, value);
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
-        Py_DECREF(value);
-    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Clear();
-    } else {
-        result = -1;
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
     }
-    return result;
-}
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
-    PyObject *module = NULL, *moddict, *modname;
-    if (__Pyx_check_single_interpreter())
-        return NULL;
-    if (__pyx_m)
-        return __Pyx_NewRef(__pyx_m);
-    modname = PyObject_GetAttrString(spec, "name");
-    if (unlikely(!modname)) goto bad;
-    module = PyModule_NewObject(modname);
-    Py_DECREF(modname);
-    if (unlikely(!module)) goto bad;
-    moddict = PyModule_GetDict(module);
-    if (unlikely(!moddict)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
-    return module;
-bad:
-    Py_XDECREF(module);
-    return NULL;
+    return 0;
 }
+#endif
 
-
-static CYTHON_SMALL_CODE int __pyx_pymod_exec_channel(PyObject *__pyx_pyinit_module)
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
 #endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
 #endif
-{
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  if (__pyx_m) {
-    if (__pyx_m == __pyx_pyinit_module) return 0;
-    PyErr_SetString(PyExc_RuntimeError, "Module 'channel' has already been imported. Re-initialisation is not supported.");
-    return -1;
-  }
-  #elif PY_MAJOR_VERSION >= 3
-  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
-  #endif
-  #if CYTHON_REFNANNY
-__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
-if (!__Pyx_RefNanny) {
-  PyErr_Clear();
-  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
-  if (!__Pyx_RefNanny)
-      Py_FatalError("failed to import 'refnanny' module");
-}
+#else
+        (void)__Pyx_PyObject_CallMethod0;
 #endif
-  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_channel(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pxy_PyFrame_Initialize_Offsets
-  __Pxy_PyFrame_Initialize_Offsets();
-  #endif
-  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  /*--- Library function declarations ---*/
-  /*--- Threads initialization code ---*/
-  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
-  PyEval_InitThreads();
-  #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("channel", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
-  /*--- Initialize various global constants etc. ---*/
-  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
-  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  if (__pyx_module_is_main_ssh2__channel) {
-    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  }
-  #if PY_MAJOR_VERSION >= 3
-  {
-    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "ssh2.channel")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.channel", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
     }
-  }
-  #endif
-  /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Global type/function init code ---*/
-  (void)__Pyx_modinit_global_init_code();
-  (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Execution code ---*/
-  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
-  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-
-  /* "ssh2/channel.pyx":19
- * from libc.stdlib cimport malloc, free
- * from session cimport Session
- * from exceptions import ChannelError             # <<<<<<<<<<<<<<
- * from utils cimport to_bytes, handle_error_codes
- * 
- */
-  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s_ChannelError);
-  __Pyx_GIVEREF(__pyx_n_s_ChannelError);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ChannelError);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  /* "ssh2/channel.pyx":1
- * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
- * # Copyright (C) 2017-2020 Panos Kittenis
- * #
- */
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+#endif
+    return r;
+#endif
+}
 
-  /*--- Wrapped vars code ---*/
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
 
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  if (__pyx_m) {
-    if (__pyx_d) {
-      __Pyx_AddTraceback("init ssh2.channel", __pyx_clineno, __pyx_lineno, __pyx_filename);
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
     }
-    Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init ssh2.channel");
-  }
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  return (__pyx_m != NULL) ? 0 : -1;
-  #elif PY_MAJOR_VERSION >= 3
-  return __pyx_m;
-  #else
-  return;
-  #endif
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
 }
+#endif
 
-/* --- Runtime support code --- */
-/* Refnanny */
-#if CYTHON_REFNANNY
-static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
-    PyObject *m = NULL, *p = NULL;
-    void *r = NULL;
-    m = PyImport_ImportModule(modname);
-    if (!m) goto end;
-    p = PyObject_GetAttrString(m, "RefNannyAPI");
-    if (!p) goto end;
-    r = PyLong_AsVoidPtr(p);
-end:
-    Py_XDECREF(p);
-    Py_XDECREF(m);
-    return (__Pyx_RefNannyAPIStruct *)r;
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
 }
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
 #endif
-
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
 #endif
-    return PyObject_GetAttr(obj, attr_name);
-}
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
 #endif
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
 #endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
     }
-    return result;
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
 }
+#endif
 
-/* RaiseDoubleKeywords */
-static void __Pyx_RaiseDoubleKeywordsError(
-    const char* func_name,
-    PyObject* kw_name)
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
-    PyErr_Format(PyExc_TypeError,
-        #if PY_MAJOR_VERSION >= 3
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
-        #else
-        "%s() got multiple values for keyword argument '%s'", func_name,
-        PyString_AsString(kw_name));
-        #endif
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
 }
+#endif
 
-/* ParseKeywords */
-static int __Pyx_ParseOptionalKeywords(
-    PyObject *kwds,
-    PyObject **argnames[],
-    PyObject *kwds2,
-    PyObject *values[],
-    Py_ssize_t num_pos_args,
-    const char* function_name)
-{
-    PyObject *key = 0, *value = 0;
-    Py_ssize_t pos = 0;
-    PyObject*** name;
-    PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
-        while (*name && (**name != key)) name++;
-        if (*name) {
-            values[name-argnames] = value;
-            continue;
-        }
-        name = first_kw_arg;
-        #if PY_MAJOR_VERSION < 3
-        if (likely(PyString_Check(key))) {
-            while (*name) {
-                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
-                        && _PyString_Eq(**name, key)) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    if ((**argname == key) || (
-                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
-                             && _PyString_Eq(**argname, key))) {
-                        goto arg_passed_twice;
-                    }
-                    argname++;
+/* Import */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *module = 0;
+    PyObject *empty_dict = 0;
+    PyObject *empty_list = 0;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (unlikely(!py_import))
+        goto bad;
+    if (!from_list) {
+        empty_list = PyList_New(0);
+        if (unlikely(!empty_list))
+            goto bad;
+        from_list = empty_list;
+    }
+    #endif
+    empty_dict = PyDict_New();
+    if (unlikely(!empty_dict))
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
+                module = PyImport_ImportModuleLevelObject(
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
+                        goto bad;
+                    PyErr_Clear();
                 }
             }
-        } else
+            level = 0;
+        }
         #endif
-        if (likely(PyUnicode_Check(key))) {
-            while (*name) {
-                int cmp = (**name == key) ? 0 :
-                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                #endif
-                    PyUnicode_Compare(**name, key);
-                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                if (cmp == 0) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    int cmp = (**argname == key) ? 0 :
-                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                    #endif
-                        PyUnicode_Compare(**argname, key);
-                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                    if (cmp == 0) goto arg_passed_twice;
-                    argname++;
-                }
-            }
-        } else
-            goto invalid_keyword_type;
-        if (kwds2) {
-            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
-        } else {
-            goto invalid_keyword;
+        if (!module) {
+            #if PY_MAJOR_VERSION < 3
+            PyObject *py_level = PyInt_FromLong(level);
+            if (unlikely(!py_level))
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, __pyx_d, empty_dict, from_list, level);
+            #endif
         }
     }
-    return 0;
-arg_passed_twice:
-    __Pyx_RaiseDoubleKeywordsError(function_name, key);
-    goto bad;
-invalid_keyword_type:
-    PyErr_Format(PyExc_TypeError,
-        "%.200s() keywords must be strings", function_name);
-    goto bad;
-invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
     #if PY_MAJOR_VERSION < 3
-        "%.200s() got an unexpected keyword argument '%.200s'",
-        function_name, PyString_AsString(key));
-    #else
-        "%s() got an unexpected keyword argument '%U'",
-        function_name, key);
+    Py_XDECREF(py_import);
     #endif
-bad:
-    return -1;
+    return module;
 }
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
-{
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
+/* ImportFrom */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
     }
-    if (exact) {
-        more_or_less = "exactly";
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
     }
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                 func_name, more_or_less, num_expected,
-                 (num_expected == 1) ? "" : "s", num_found);
+    return value;
 }
 
-/* ArgTypeTest */
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
-{
-    if (unlikely(!type)) {
-        PyErr_SetString(PyExc_SystemError, "Missing type object");
-        return 0;
-    }
-    else if (exact) {
-        #if PY_MAJOR_VERSION == 2
-        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
-        #endif
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
     }
-    else {
-        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
     }
-    PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
     return 0;
 }
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
         return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
     }
-    return result;
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
 }
 #endif
 
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
 }
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
 }
 #endif
-
-/* GetException */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
 #else
-static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
 #endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
 {
-    PyObject *local_type, *local_value, *local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    local_type = tstate->curexc_type;
-    local_value = tstate->curexc_value;
-    local_tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
 #else
-    PyErr_Fetch(&local_type, &local_value, &local_tb);
-#endif
-    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
-    if (unlikely(tstate->curexc_type))
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
 #else
-    if (unlikely(PyErr_Occurred()))
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
 #endif
-        goto bad;
-    #if PY_MAJOR_VERSION >= 3
-    if (local_tb) {
-        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
-            goto bad;
     }
-    #endif
-    Py_XINCREF(local_tb);
-    Py_XINCREF(local_type);
-    Py_XINCREF(local_value);
-    *type = local_type;
-    *value = local_value;
-    *tb = local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    #if CYTHON_USE_EXC_INFO_STACK
-    {
-        _PyErr_StackItem *exc_info = tstate->exc_info;
-        tmp_type = exc_info->exc_type;
-        tmp_value = exc_info->exc_value;
-        tmp_tb = exc_info->exc_traceback;
-        exc_info->exc_type = local_type;
-        exc_info->exc_value = local_value;
-        exc_info->exc_traceback = local_tb;
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
     }
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = local_type;
-    tstate->exc_value = local_value;
-    tstate->exc_traceback = local_tb;
-    #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #else
-    PyErr_SetExcInfo(local_type, local_value, local_tb);
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #endif
-    return 0;
-bad:
-    *type = 0;
-    *value = 0;
-    *tb = 0;
-    Py_XDECREF(local_type);
-    Py_XDECREF(local_value);
-    Py_XDECREF(local_tb);
-    return -1;
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
 }
-
-/* SwapException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = *type;
-    exc_info->exc_value = *value;
-    exc_info->exc_traceback = *tb;
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = *type;
-    tstate->exc_value = *value;
-    tstate->exc_traceback = *tb;
-    #endif
-    *type = tmp_type;
-    *value = tmp_value;
-    *tb = tmp_tb;
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
 }
-#else
-static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
-    PyErr_SetExcInfo(*type, *value, *tb);
-    *type = tmp_type;
-    *value = tmp_value;
-    *tb = tmp_tb;
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
 }
-#endif
-
-/* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem *
-__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
-           exc_info->previous_item != NULL)
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
     {
-        exc_info = exc_info->previous_item;
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
     }
-    return exc_info;
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
 }
-#endif
-
-/* SaveResetException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
-    *type = exc_info->exc_type;
-    *value = exc_info->exc_value;
-    *tb = exc_info->exc_traceback;
-    #else
-    *type = tstate->exc_type;
-    *value = tstate->exc_value;
-    *tb = tstate->exc_traceback;
-    #endif
-    Py_XINCREF(*type);
-    Py_XINCREF(*value);
-    Py_XINCREF(*tb);
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
 }
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = type;
-    exc_info->exc_value = value;
-    exc_info->exc_traceback = tb;
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
     #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = type;
-    tstate->exc_value = value;
-    tstate->exc_traceback = tb;
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
     #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+    Py_DECREF(res);
+    return result;
 }
-#endif
-
-/* RaiseException */
-#if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
-    __Pyx_PyThreadState_declare
-    Py_XINCREF(type);
-    if (!value || value == Py_None)
-        value = NULL;
-    else
-        Py_INCREF(value);
-    if (!tb || tb == Py_None)
-        tb = NULL;
-    else {
-        Py_INCREF(tb);
-        if (!PyTraceBack_Check(tb)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: arg 3 must be a traceback or None");
-            goto raise_error;
-        }
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
     }
-    if (PyType_Check(type)) {
-#if CYTHON_COMPILING_IN_PYPY
-        if (!value) {
-            Py_INCREF(Py_None);
-            value = Py_None;
-        }
-#endif
-        PyErr_NormalizeException(&type, &value, &tb);
-    } else {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto raise_error;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(type);
-        Py_INCREF(type);
-        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: exception class must be a subclass of BaseException");
-            goto raise_error;
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
         }
     }
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrRestore(type, value, tb);
-    return;
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(tb);
-    return;
+    Py_INCREF(result);
+    return result;
 }
-#else
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
-    PyObject* owned_instance = NULL;
-    if (tb == Py_None) {
-        tb = 0;
-    } else if (tb && !PyTraceBack_Check(tb)) {
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
-            "raise: arg 3 must be a traceback or None");
-        goto bad;
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
     }
-    if (value == Py_None)
-        value = 0;
-    if (PyExceptionInstance_Check(type)) {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto bad;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(value);
-    } else if (PyExceptionClass_Check(type)) {
-        PyObject *instance_class = NULL;
-        if (value && PyExceptionInstance_Check(value)) {
-            instance_class = (PyObject*) Py_TYPE(value);
-            if (instance_class != type) {
-                int is_subclass = PyObject_IsSubclass(instance_class, type);
-                if (!is_subclass) {
-                    instance_class = NULL;
-                } else if (unlikely(is_subclass == -1)) {
-                    goto bad;
-                } else {
-                    type = instance_class;
-                }
-            }
-        }
-        if (!instance_class) {
-            PyObject *args;
-            if (!value)
-                args = PyTuple_New(0);
-            else if (PyTuple_Check(value)) {
-                Py_INCREF(value);
-                args = value;
-            } else
-                args = PyTuple_Pack(1, value);
-            if (!args)
-                goto bad;
-            owned_instance = PyObject_Call(type, args, NULL);
-            Py_DECREF(args);
-            if (!owned_instance)
-                goto bad;
-            value = owned_instance;
-            if (!PyExceptionInstance_Check(value)) {
-                PyErr_Format(PyExc_TypeError,
-                             "calling %R should have returned an instance of "
-                             "BaseException, not %R",
-                             type, Py_TYPE(value));
-                goto bad;
-            }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
         }
-    } else {
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
-            "raise: exception class must be a subclass of BaseException");
-        goto bad;
+                        "__annotations__ must be set to a dict object");
+        return -1;
     }
-    if (cause) {
-        PyObject *fixed_cause;
-        if (cause == Py_None) {
-            fixed_cause = NULL;
-        } else if (PyExceptionClass_Check(cause)) {
-            fixed_cause = PyObject_CallObject(cause, NULL);
-            if (fixed_cause == NULL)
-                goto bad;
-        } else if (PyExceptionInstance_Check(cause)) {
-            fixed_cause = cause;
-            Py_INCREF(fixed_cause);
-        } else {
-            PyErr_SetString(PyExc_TypeError,
-                            "exception causes must derive from "
-                            "BaseException");
-            goto bad;
-        }
-        PyException_SetCause(value, fixed_cause);
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
     }
-    PyErr_SetObject(type, value);
-    if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
 #else
-        PyThreadState *tstate = __Pyx_PyThreadState_Current;
-        PyObject* tmp_tb = tstate->curexc_traceback;
-        if (tb != tmp_tb) {
-            Py_INCREF(tb);
-            tstate->curexc_traceback = tb;
-            Py_XDECREF(tmp_tb);
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
         }
 #endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
     }
-bad:
-    Py_XDECREF(owned_instance);
-    return;
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
 }
 #endif
-
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
 #if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
 #endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
-    }
-    return descr;
 }
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
 #endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+#endif
+    return (PyObject *) op;
 }
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
 #endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
     }
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
     }
     return 0;
 }
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
-#endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
-    }
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
     }
-    return result;
+    return 0;
 }
-
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
 #else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
-    }
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
 #endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
     }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
-        }
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
 #endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
     return ret;
 }
-
-/* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
 {
-    PyObject *result = 0;
-    char warning[200];
-    Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
-    PyObject *py_basicsize;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
 #endif
-    result = PyObject_GetAttrString(module, class_name);
-    if (!result)
-        goto bad;
-    if (!PyType_Check(result)) {
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
         PyErr_Format(PyExc_TypeError,
-            "%.200s.%.200s is not a type object",
-            module_name, class_name);
-        goto bad;
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-#ifndef Py_LIMITED_API
-    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
 #endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
 }
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
 #endif
-
-/* Import */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
-    PyObject *module = 0;
-    PyObject *global_dict = 0;
-    PyObject *empty_dict = 0;
-    PyObject *list;
-    #if PY_MAJOR_VERSION < 3
-    PyObject *py_import;
-    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
-        goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
-        empty_list = PyList_New(0);
-        if (!empty_list)
-            goto bad;
-        list = empty_list;
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
-    empty_dict = PyDict_New();
-    if (!empty_dict)
-        goto bad;
-    {
-        #if PY_MAJOR_VERSION >= 3
-        if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
-                module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
-                        goto bad;
-                    PyErr_Clear();
-                }
-            }
-            level = 0;
-        }
-        #endif
-        if (!module) {
-            #if PY_MAJOR_VERSION < 3
-            PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
-                goto bad;
-            module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
-            Py_DECREF(py_level);
-            #else
-            module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
-            #endif
-        }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
 }
 
-/* ImportFrom */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
-    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
-    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
-        #else
-            "cannot import name %S", name);
-        #endif
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return value;
+    return op;
 }
 
 /* PyDictVersioning */
@@ -9654,12 +17019,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -9673,7 +17039,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -9695,6 +17061,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -9773,17 +17140,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -9818,6 +17269,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -9833,7 +17285,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -9880,6 +17332,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -9916,7 +17369,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -9925,168 +17378,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -10112,7 +17636,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -10121,168 +17645,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -10308,7 +17903,7 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned long) < sizeof(long)) {
+        if ((sizeof(unsigned long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -10317,168 +17912,239 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
             }
             return (unsigned long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned long) -1;
+        val = __Pyx_PyInt_As_unsigned_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned long) 1) << (sizeof(unsigned long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned long) -1;
-        }
-    } else {
-        unsigned long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned long) -1;
-        val = __Pyx_PyInt_As_unsigned_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -10522,12 +18188,132 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
         int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__67);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -10560,10 +18346,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -10580,7 +18399,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -10589,168 +18408,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -10767,7 +18657,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -10788,6 +18678,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -10812,11 +18718,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -10864,41 +18770,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -10920,11 +18835,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -10939,9 +18850,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -10958,7 +18869,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -10966,21 +18876,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -10993,9 +18888,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -11003,30 +18920,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -11081,7 +19002,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -11110,22 +19031,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -11191,13 +19116,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -11265,4 +19188,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/channel.pxd b/ssh2/channel.pxd
index fc0af51b..4384e68f 100644
--- a/ssh2/channel.pxd
+++ b/ssh2/channel.pxd
@@ -14,8 +14,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
-cimport c_ssh2
+from .session cimport Session
+from . cimport c_ssh2
 
 
 cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session)
diff --git a/ssh2/channel.pyx b/ssh2/channel.pyx
index 1e7c6ad0..5691a3a2 100644
--- a/ssh2/channel.pyx
+++ b/ssh2/channel.pyx
@@ -15,13 +15,14 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 from libc.stdlib cimport malloc, free
-from session cimport Session
-from exceptions import ChannelError
-from utils cimport to_bytes, handle_error_codes
 
-cimport c_ssh2
-cimport sftp
-cimport error_codes
+from .exceptions import ChannelError
+
+from .session cimport Session
+from .utils cimport to_bytes, handle_error_codes
+from . cimport c_ssh2
+from . cimport sftp
+from . cimport error_codes
 
 
 cdef object PyChannel(c_ssh2.LIBSSH2_CHANNEL *channel, Session session):
@@ -234,11 +235,17 @@ cdef class Channel:
         Note that ``0`` is also failure code for this function.
 
         Best used in non-blocking mode to avoid it being impossible to tell if
-        ``0`` indicates failure or an actual exit status of ``0``"""
+        ``0`` indicates failure or an actual exit status of ``0``.
+
+        Exceptions are raised as with all functions in case of an SSH2Error.
+
+        :rtype: int
+        """
         cdef int rc
         with nogil:
             rc = c_ssh2.libssh2_channel_get_exit_status(self._channel)
-        return handle_error_codes(rc)
+        handle_error_codes(rc)
+        return rc
 
     def get_exit_signal(self):
         """Get exit signal, message and language tag, if any, for command.
@@ -246,7 +253,8 @@ cdef class Channel:
         Returns (`returncode``, ``exit signal``, ``error message``,
           ``language tag``) tuple.
 
-        :rtype: tuple(int, bytes, bytes, bytes)"""
+        :rtype: tuple(int, bytes, bytes, bytes)
+        """
         cdef char *exitsignal = <char *>b'none'
         cdef size_t *exitsignal_len = <size_t *>0
         cdef char *errmsg = <char *>b'none'
@@ -276,7 +284,8 @@ cdef class Channel:
             py_errmsg = errmsg[:py_errlen]
         if py_langlen > 0:
             py_langtag = langtag[:py_langlen]
-        return handle_error_codes(rc), py_exitsignal, py_errmsg, py_langtag
+        handle_error_codes(rc)
+        return rc, py_exitsignal, py_errmsg, py_langtag
 
     def setenv(self, varname not None, value not None):
         """Set environment variable on channel.
diff --git a/ssh2/error_codes.c b/ssh2/error_codes.c
index 0cc3f814..f7c06227 100644
--- a/ssh2/error_codes.c
+++ b/ssh2/error_codes.c
@@ -1,22 +1,69 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "libssh2/include/libssh2.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.error_codes",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/error_codes.pyx"
+        ]
+    },
+    "module_name": "ssh2.error_codes"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +82,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +90,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +127,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +147,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
   #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +275,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +304,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +315,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +338,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +365,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +389,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +473,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +497,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +514,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
+        #else
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +576,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +611,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +763,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +780,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +870,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +916,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +950,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
+#else
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1044,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1059,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1101,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1118,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1165,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1185,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1225,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -793,9 +1301,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -813,9 +1322,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -823,13 +1332,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -853,8 +1356,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -875,7 +1424,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -905,6 +1454,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -940,24 +1490,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/error_codes.pyx",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -966,11 +1518,11 @@ static const char *__pyx_f[] = {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -980,28 +1532,40 @@ static const char *__pyx_f[] = {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1012,6 +1576,10 @@ static const char *__pyx_f[] = {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1049,22 +1617,30 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
 #endif
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1076,7 +1652,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1092,6 +1668,16 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1100,6 +1686,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1113,18 +1700,32 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
 
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
@@ -1138,37 +1739,50 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.error_codes' */
+/* Module declarations from "ssh2.c_ssh2" */
+
+/* Module declarations from "ssh2.error_codes" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.error_codes"
 extern int __pyx_module_is_main_ssh2__error_codes;
 int __pyx_module_is_main_ssh2__error_codes = 0;
 
-/* Implementation of 'ssh2.error_codes' */
+/* Implementation of "ssh2.error_codes" */
+/* #### Code section: global_var ### */
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = "?";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
 static const char __pyx_k_test[] = "__test__";
@@ -1224,98 +1838,377 @@ static const char __pyx_k_LIBSSH2_ERROR_METHOD_NOT_SUPPORT[] = "LIBSSH2_ERROR_ME
 static const char __pyx_k_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL[] = "LIBSSH2_ERROR_PUBLICKEY_PROTOCOL";
 static const char __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN[] = "LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED";
 static const char __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI[] = "LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED";
-static PyObject *__pyx_n_s_LIBSSH2CHANNEL_EAGAIN;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_ALLOC;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_BAD_USE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_COMPRESS;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_DECRYPT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_EAGAIN;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_ENCRYPT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_FILE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_INVAL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_NONE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_PROTO;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_TIMEOUT;
-static PyObject *__pyx_n_s_LIBSSH2_ERROR_ZLIB;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_test;
-/* Late includes */
+/* #### Code section: decls ### */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyObject *__pyx_n_s_;
+  PyObject *__pyx_n_s_LIBSSH2CHANNEL_EAGAIN;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_ALLOC;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_BAD_USE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_COMPRESS;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_DECRYPT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_EAGAIN;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_ENCRYPT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_FILE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_INVAL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_NONE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_PROTO;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_TIMEOUT;
+  PyObject *__pyx_n_s_LIBSSH2_ERROR_ZLIB;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_test;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-static PyMethodDef __pyx_methods[] = {
-  {0, 0, 0, 0}
-};
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
 
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_error_codes(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_error_codes},
-  {0, NULL}
-};
-#endif
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
 
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "error_codes",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
   #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
   #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
+  Py_CLEAR(clear_module_state->__pyx_n_s_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2CHANNEL_EAGAIN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_ALLOC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_BAD_USE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_COMPRESS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_DECRYPT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_EAGAIN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_ENCRYPT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_FILE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_INVAL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_NONE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_PROTO);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_TIMEOUT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_ERROR_ZLIB);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_n_s_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2CHANNEL_EAGAIN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_ALLOC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_BAD_USE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_COMPRESS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_DECRYPT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_EAGAIN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_ENCRYPT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_FILE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_INVAL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_NONE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_PROTO);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_TIMEOUT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_ERROR_ZLIB);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  return 0;
+}
 #endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_n_s_ __pyx_mstate_global->__pyx_n_s_
+#define __pyx_n_s_LIBSSH2CHANNEL_EAGAIN __pyx_mstate_global->__pyx_n_s_LIBSSH2CHANNEL_EAGAIN
+#define __pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL
+#define __pyx_n_s_LIBSSH2_ERROR_ALLOC __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_ALLOC
+#define __pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI
+#define __pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET
+#define __pyx_n_s_LIBSSH2_ERROR_BAD_USE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_BAD_USE
+#define __pyx_n_s_LIBSSH2_ERROR_BANNER_RECV __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV
+#define __pyx_n_s_LIBSSH2_ERROR_BANNER_SEND __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND
+#define __pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC
+#define __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL
+#define __pyx_n_s_LIBSSH2_ERROR_COMPRESS __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_COMPRESS
+#define __pyx_n_s_LIBSSH2_ERROR_DECRYPT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_DECRYPT
+#define __pyx_n_s_LIBSSH2_ERROR_EAGAIN __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_EAGAIN
+#define __pyx_n_s_LIBSSH2_ERROR_ENCRYPT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_ENCRYPT
+#define __pyx_n_s_LIBSSH2_ERROR_FILE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_FILE
+#define __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT
+#define __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN
+#define __pyx_n_s_LIBSSH2_ERROR_INVAL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_INVAL
+#define __pyx_n_s_LIBSSH2_ERROR_INVALID_MAC __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC
+#define __pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE
+#define __pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE
+#define __pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE
+#define __pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU
+#define __pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS
+#define __pyx_n_s_LIBSSH2_ERROR_METHOD_NONE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE
+#define __pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT
+#define __pyx_n_s_LIBSSH2_ERROR_NONE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_NONE
+#define __pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY
+#define __pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED
+#define __pyx_n_s_LIBSSH2_ERROR_PROTO __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_PROTO
+#define __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL
+#define __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN
+#define __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI
+#define __pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED
+#define __pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL
+#define __pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL
+#define __pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT
+#define __pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE
+#define __pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV
+#define __pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND
+#define __pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT
+#define __pyx_n_s_LIBSSH2_ERROR_TIMEOUT __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_TIMEOUT
+#define __pyx_n_s_LIBSSH2_ERROR_ZLIB __pyx_mstate_global->__pyx_n_s_LIBSSH2_ERROR_ZLIB
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+/* #### Code section: module_code ### */
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -1325,68 +2218,75 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_LIBSSH2CHANNEL_EAGAIN, __pyx_k_LIBSSH2CHANNEL_EAGAIN, sizeof(__pyx_k_LIBSSH2CHANNEL_EAGAIN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL, __pyx_k_LIBSSH2_ERROR_AGENT_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_AGENT_PROTOCOL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_ALLOC, __pyx_k_LIBSSH2_ERROR_ALLOC, sizeof(__pyx_k_LIBSSH2_ERROR_ALLOC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI, __pyx_k_LIBSSH2_ERROR_AUTHENTICATION_FAI, sizeof(__pyx_k_LIBSSH2_ERROR_AUTHENTICATION_FAI), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET, __pyx_k_LIBSSH2_ERROR_BAD_SOCKET, sizeof(__pyx_k_LIBSSH2_ERROR_BAD_SOCKET), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_BAD_USE, __pyx_k_LIBSSH2_ERROR_BAD_USE, sizeof(__pyx_k_LIBSSH2_ERROR_BAD_USE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV, __pyx_k_LIBSSH2_ERROR_BANNER_RECV, sizeof(__pyx_k_LIBSSH2_ERROR_BANNER_RECV), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND, __pyx_k_LIBSSH2_ERROR_BANNER_SEND, sizeof(__pyx_k_LIBSSH2_ERROR_BANNER_SEND), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL, __pyx_k_LIBSSH2_ERROR_BUFFER_TOO_SMALL, sizeof(__pyx_k_LIBSSH2_ERROR_BUFFER_TOO_SMALL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED, __pyx_k_LIBSSH2_ERROR_CHANNEL_CLOSED, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_CLOSED), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT, __pyx_k_LIBSSH2_ERROR_CHANNEL_EOF_SENT, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_EOF_SENT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE, __pyx_k_LIBSSH2_ERROR_CHANNEL_FAILURE, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_FAILURE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, __pyx_k_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_OUTOFORDER), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, __pyx_k_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_PACKET_EXC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, __pyx_k_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_REQUEST_DE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN, __pyx_k_LIBSSH2_ERROR_CHANNEL_UNKNOWN, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_UNKNOWN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, __pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, __pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_COMPRESS, __pyx_k_LIBSSH2_ERROR_COMPRESS, sizeof(__pyx_k_LIBSSH2_ERROR_COMPRESS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_DECRYPT, __pyx_k_LIBSSH2_ERROR_DECRYPT, sizeof(__pyx_k_LIBSSH2_ERROR_DECRYPT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_EAGAIN, __pyx_k_LIBSSH2_ERROR_EAGAIN, sizeof(__pyx_k_LIBSSH2_ERROR_EAGAIN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_ENCRYPT, __pyx_k_LIBSSH2_ERROR_ENCRYPT, sizeof(__pyx_k_LIBSSH2_ERROR_ENCRYPT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_FILE, __pyx_k_LIBSSH2_ERROR_FILE, sizeof(__pyx_k_LIBSSH2_ERROR_FILE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT, __pyx_k_LIBSSH2_ERROR_HOSTKEY_INIT, sizeof(__pyx_k_LIBSSH2_ERROR_HOSTKEY_INIT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN, __pyx_k_LIBSSH2_ERROR_HOSTKEY_SIGN, sizeof(__pyx_k_LIBSSH2_ERROR_HOSTKEY_SIGN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_INVAL, __pyx_k_LIBSSH2_ERROR_INVAL, sizeof(__pyx_k_LIBSSH2_ERROR_INVAL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC, __pyx_k_LIBSSH2_ERROR_INVALID_MAC, sizeof(__pyx_k_LIBSSH2_ERROR_INVALID_MAC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE, __pyx_k_LIBSSH2_ERROR_INVALID_POLL_TYPE, sizeof(__pyx_k_LIBSSH2_ERROR_INVALID_POLL_TYPE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE, __pyx_k_LIBSSH2_ERROR_KEX_FAILURE, sizeof(__pyx_k_LIBSSH2_ERROR_KEX_FAILURE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, __pyx_k_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, sizeof(__pyx_k_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, __pyx_k_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, sizeof(__pyx_k_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS, __pyx_k_LIBSSH2_ERROR_KNOWN_HOSTS, sizeof(__pyx_k_LIBSSH2_ERROR_KNOWN_HOSTS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE, __pyx_k_LIBSSH2_ERROR_METHOD_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_METHOD_NONE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, __pyx_k_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, sizeof(__pyx_k_LIBSSH2_ERROR_METHOD_NOT_SUPPORT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_NONE, __pyx_k_LIBSSH2_ERROR_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_NONE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY, __pyx_k_LIBSSH2_ERROR_OUT_OF_BOUNDARY, sizeof(__pyx_k_LIBSSH2_ERROR_OUT_OF_BOUNDARY), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED, __pyx_k_LIBSSH2_ERROR_PASSWORD_EXPIRED, sizeof(__pyx_k_LIBSSH2_ERROR_PASSWORD_EXPIRED), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_PROTO, __pyx_k_LIBSSH2_ERROR_PROTO, sizeof(__pyx_k_LIBSSH2_ERROR_PROTO), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED, __pyx_k_LIBSSH2_ERROR_REQUEST_DENIED, sizeof(__pyx_k_LIBSSH2_ERROR_REQUEST_DENIED), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL, __pyx_k_LIBSSH2_ERROR_SCP_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_SCP_PROTOCOL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL, __pyx_k_LIBSSH2_ERROR_SFTP_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_SFTP_PROTOCOL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT, __pyx_k_LIBSSH2_ERROR_SOCKET_DISCONNECT, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_DISCONNECT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE, __pyx_k_LIBSSH2_ERROR_SOCKET_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_NONE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV, __pyx_k_LIBSSH2_ERROR_SOCKET_RECV, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_RECV), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND, __pyx_k_LIBSSH2_ERROR_SOCKET_SEND, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_SEND), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT, __pyx_k_LIBSSH2_ERROR_SOCKET_TIMEOUT, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_TIMEOUT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_TIMEOUT, __pyx_k_LIBSSH2_ERROR_TIMEOUT, sizeof(__pyx_k_LIBSSH2_ERROR_TIMEOUT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_ERROR_ZLIB, __pyx_k_LIBSSH2_ERROR_ZLIB, sizeof(__pyx_k_LIBSSH2_ERROR_ZLIB), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2CHANNEL_EAGAIN, __pyx_k_LIBSSH2CHANNEL_EAGAIN, sizeof(__pyx_k_LIBSSH2CHANNEL_EAGAIN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL, __pyx_k_LIBSSH2_ERROR_AGENT_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_AGENT_PROTOCOL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_ALLOC, __pyx_k_LIBSSH2_ERROR_ALLOC, sizeof(__pyx_k_LIBSSH2_ERROR_ALLOC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI, __pyx_k_LIBSSH2_ERROR_AUTHENTICATION_FAI, sizeof(__pyx_k_LIBSSH2_ERROR_AUTHENTICATION_FAI), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET, __pyx_k_LIBSSH2_ERROR_BAD_SOCKET, sizeof(__pyx_k_LIBSSH2_ERROR_BAD_SOCKET), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_BAD_USE, __pyx_k_LIBSSH2_ERROR_BAD_USE, sizeof(__pyx_k_LIBSSH2_ERROR_BAD_USE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_BANNER_RECV, __pyx_k_LIBSSH2_ERROR_BANNER_RECV, sizeof(__pyx_k_LIBSSH2_ERROR_BANNER_RECV), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_BANNER_SEND, __pyx_k_LIBSSH2_ERROR_BANNER_SEND, sizeof(__pyx_k_LIBSSH2_ERROR_BANNER_SEND), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL, __pyx_k_LIBSSH2_ERROR_BUFFER_TOO_SMALL, sizeof(__pyx_k_LIBSSH2_ERROR_BUFFER_TOO_SMALL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED, __pyx_k_LIBSSH2_ERROR_CHANNEL_CLOSED, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_CLOSED), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT, __pyx_k_LIBSSH2_ERROR_CHANNEL_EOF_SENT, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_EOF_SENT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE, __pyx_k_LIBSSH2_ERROR_CHANNEL_FAILURE, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_FAILURE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, __pyx_k_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_OUTOFORDER), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, __pyx_k_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_PACKET_EXC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, __pyx_k_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_REQUEST_DE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN, __pyx_k_LIBSSH2_ERROR_CHANNEL_UNKNOWN, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_UNKNOWN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, __pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, __pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, sizeof(__pyx_k_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_COMPRESS, __pyx_k_LIBSSH2_ERROR_COMPRESS, sizeof(__pyx_k_LIBSSH2_ERROR_COMPRESS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_DECRYPT, __pyx_k_LIBSSH2_ERROR_DECRYPT, sizeof(__pyx_k_LIBSSH2_ERROR_DECRYPT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_EAGAIN, __pyx_k_LIBSSH2_ERROR_EAGAIN, sizeof(__pyx_k_LIBSSH2_ERROR_EAGAIN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_ENCRYPT, __pyx_k_LIBSSH2_ERROR_ENCRYPT, sizeof(__pyx_k_LIBSSH2_ERROR_ENCRYPT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_FILE, __pyx_k_LIBSSH2_ERROR_FILE, sizeof(__pyx_k_LIBSSH2_ERROR_FILE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT, __pyx_k_LIBSSH2_ERROR_HOSTKEY_INIT, sizeof(__pyx_k_LIBSSH2_ERROR_HOSTKEY_INIT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN, __pyx_k_LIBSSH2_ERROR_HOSTKEY_SIGN, sizeof(__pyx_k_LIBSSH2_ERROR_HOSTKEY_SIGN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_INVAL, __pyx_k_LIBSSH2_ERROR_INVAL, sizeof(__pyx_k_LIBSSH2_ERROR_INVAL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_INVALID_MAC, __pyx_k_LIBSSH2_ERROR_INVALID_MAC, sizeof(__pyx_k_LIBSSH2_ERROR_INVALID_MAC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE, __pyx_k_LIBSSH2_ERROR_INVALID_POLL_TYPE, sizeof(__pyx_k_LIBSSH2_ERROR_INVALID_POLL_TYPE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE, __pyx_k_LIBSSH2_ERROR_KEX_FAILURE, sizeof(__pyx_k_LIBSSH2_ERROR_KEX_FAILURE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, __pyx_k_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, sizeof(__pyx_k_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, __pyx_k_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, sizeof(__pyx_k_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS, __pyx_k_LIBSSH2_ERROR_KNOWN_HOSTS, sizeof(__pyx_k_LIBSSH2_ERROR_KNOWN_HOSTS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_METHOD_NONE, __pyx_k_LIBSSH2_ERROR_METHOD_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_METHOD_NONE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, __pyx_k_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, sizeof(__pyx_k_LIBSSH2_ERROR_METHOD_NOT_SUPPORT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_NONE, __pyx_k_LIBSSH2_ERROR_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_NONE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY, __pyx_k_LIBSSH2_ERROR_OUT_OF_BOUNDARY, sizeof(__pyx_k_LIBSSH2_ERROR_OUT_OF_BOUNDARY), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED, __pyx_k_LIBSSH2_ERROR_PASSWORD_EXPIRED, sizeof(__pyx_k_LIBSSH2_ERROR_PASSWORD_EXPIRED), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_PROTO, __pyx_k_LIBSSH2_ERROR_PROTO, sizeof(__pyx_k_LIBSSH2_ERROR_PROTO), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, __pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, sizeof(__pyx_k_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED, __pyx_k_LIBSSH2_ERROR_REQUEST_DENIED, sizeof(__pyx_k_LIBSSH2_ERROR_REQUEST_DENIED), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL, __pyx_k_LIBSSH2_ERROR_SCP_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_SCP_PROTOCOL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL, __pyx_k_LIBSSH2_ERROR_SFTP_PROTOCOL, sizeof(__pyx_k_LIBSSH2_ERROR_SFTP_PROTOCOL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT, __pyx_k_LIBSSH2_ERROR_SOCKET_DISCONNECT, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_DISCONNECT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE, __pyx_k_LIBSSH2_ERROR_SOCKET_NONE, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_NONE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV, __pyx_k_LIBSSH2_ERROR_SOCKET_RECV, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_RECV), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND, __pyx_k_LIBSSH2_ERROR_SOCKET_SEND, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_SEND), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT, __pyx_k_LIBSSH2_ERROR_SOCKET_TIMEOUT, sizeof(__pyx_k_LIBSSH2_ERROR_SOCKET_TIMEOUT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_TIMEOUT, __pyx_k_LIBSSH2_ERROR_TIMEOUT, sizeof(__pyx_k_LIBSSH2_ERROR_TIMEOUT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_ERROR_ZLIB, __pyx_k_LIBSSH2_ERROR_ZLIB, sizeof(__pyx_k_LIBSSH2_ERROR_ZLIB), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   return 0;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
@@ -1394,13 +2294,20 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyFinishContext();
   return 0;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -1467,6 +2374,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_error_codes(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_error_codes},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "error_codes",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -1517,12 +2473,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -1532,8 +2497,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -1543,8 +2509,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -1560,7 +2530,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_error_codes(PyObject *__pyx_pyinit
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -1574,6 +2549,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_error_codes(PyObject *__pyx_pyinit
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("error_codes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "error_codes" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -1584,7 +2586,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_error_codes(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -1592,48 +2594,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("error_codes", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -1645,7 +2630,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.error_codes")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.error_codes", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.error_codes", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -1673,10 +2658,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SOCKET_NONE = error_codes._LIBSSH2_ERROR_SOCKET_NONE
  * LIBSSH2_ERROR_BANNER_RECV = error_codes._LIBSSH2_ERROR_BANNER_RECV
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_NONE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_NONE, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_NONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_NONE, __pyx_t_2) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":22
  * 
@@ -1685,10 +2670,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_BANNER_RECV = error_codes._LIBSSH2_ERROR_BANNER_RECV
  * LIBSSH2_ERROR_BANNER_SEND = error_codes._LIBSSH2_ERROR_BANNER_SEND
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SOCKET_NONE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE, __pyx_t_1) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SOCKET_NONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_NONE, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":23
  * LIBSSH2_ERROR_NONE = error_codes._LIBSSH2_ERROR_NONE
@@ -1697,10 +2682,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_BANNER_SEND = error_codes._LIBSSH2_ERROR_BANNER_SEND
  * LIBSSH2_ERROR_SOCKET_SEND = error_codes._LIBSSH2_ERROR_SOCKET_SEND
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_BANNER_RECV); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BANNER_RECV, __pyx_t_1) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_BANNER_RECV); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BANNER_RECV, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":24
  * LIBSSH2_ERROR_SOCKET_NONE = error_codes._LIBSSH2_ERROR_SOCKET_NONE
@@ -1709,10 +2694,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SOCKET_SEND = error_codes._LIBSSH2_ERROR_SOCKET_SEND
  * LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE \
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_BANNER_SEND); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BANNER_SEND, __pyx_t_1) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_BANNER_SEND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BANNER_SEND, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":25
  * LIBSSH2_ERROR_BANNER_RECV = error_codes._LIBSSH2_ERROR_BANNER_RECV
@@ -1721,10 +2706,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE \
  *     = error_codes._LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SOCKET_SEND); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND, __pyx_t_1) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SOCKET_SEND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_SEND, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":27
  * LIBSSH2_ERROR_SOCKET_SEND = error_codes._LIBSSH2_ERROR_SOCKET_SEND
@@ -1733,10 +2718,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_TIMEOUT = error_codes._LIBSSH2_ERROR_TIMEOUT
  * LIBSSH2_ERROR_HOSTKEY_INIT = error_codes._LIBSSH2_ERROR_HOSTKEY_INIT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, __pyx_t_1) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEY_EXCHANGE_FAILU, __pyx_t_2) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":28
  * LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE \
@@ -1745,10 +2730,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_HOSTKEY_INIT = error_codes._LIBSSH2_ERROR_HOSTKEY_INIT
  * LIBSSH2_ERROR_HOSTKEY_SIGN = error_codes._LIBSSH2_ERROR_HOSTKEY_SIGN
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_TIMEOUT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_TIMEOUT, __pyx_t_1) < 0) __PYX_ERR(0, 28, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_TIMEOUT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_TIMEOUT, __pyx_t_2) < 0) __PYX_ERR(0, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":29
  *     = error_codes._LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE
@@ -1757,10 +2742,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_HOSTKEY_SIGN = error_codes._LIBSSH2_ERROR_HOSTKEY_SIGN
  * LIBSSH2_ERROR_DECRYPT = error_codes._LIBSSH2_ERROR_DECRYPT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_HOSTKEY_INIT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT, __pyx_t_1) < 0) __PYX_ERR(0, 29, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_HOSTKEY_INIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_INIT, __pyx_t_2) < 0) __PYX_ERR(0, 29, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":30
  * LIBSSH2_ERROR_TIMEOUT = error_codes._LIBSSH2_ERROR_TIMEOUT
@@ -1769,10 +2754,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_DECRYPT = error_codes._LIBSSH2_ERROR_DECRYPT
  * LIBSSH2_ERROR_SOCKET_DISCONNECT = error_codes._LIBSSH2_ERROR_SOCKET_DISCONNECT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_HOSTKEY_SIGN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN, __pyx_t_1) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_HOSTKEY_SIGN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_HOSTKEY_SIGN, __pyx_t_2) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":31
  * LIBSSH2_ERROR_HOSTKEY_INIT = error_codes._LIBSSH2_ERROR_HOSTKEY_INIT
@@ -1781,10 +2766,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SOCKET_DISCONNECT = error_codes._LIBSSH2_ERROR_SOCKET_DISCONNECT
  * LIBSSH2_ERROR_PROTO = error_codes._LIBSSH2_ERROR_PROTO
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_DECRYPT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_DECRYPT, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_DECRYPT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_DECRYPT, __pyx_t_2) < 0) __PYX_ERR(0, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":32
  * LIBSSH2_ERROR_HOSTKEY_SIGN = error_codes._LIBSSH2_ERROR_HOSTKEY_SIGN
@@ -1793,10 +2778,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_PROTO = error_codes._LIBSSH2_ERROR_PROTO
  * LIBSSH2_ERROR_PASSWORD_EXPIRED = error_codes._LIBSSH2_ERROR_PASSWORD_EXPIRED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SOCKET_DISCONNECT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT, __pyx_t_1) < 0) __PYX_ERR(0, 32, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SOCKET_DISCONNECT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_DISCONNECT, __pyx_t_2) < 0) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":33
  * LIBSSH2_ERROR_DECRYPT = error_codes._LIBSSH2_ERROR_DECRYPT
@@ -1805,10 +2790,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_PASSWORD_EXPIRED = error_codes._LIBSSH2_ERROR_PASSWORD_EXPIRED
  * LIBSSH2_ERROR_FILE = error_codes._LIBSSH2_ERROR_FILE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_PROTO); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PROTO, __pyx_t_1) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_PROTO); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PROTO, __pyx_t_2) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":34
  * LIBSSH2_ERROR_SOCKET_DISCONNECT = error_codes._LIBSSH2_ERROR_SOCKET_DISCONNECT
@@ -1817,10 +2802,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_FILE = error_codes._LIBSSH2_ERROR_FILE
  * LIBSSH2_ERROR_METHOD_NONE \
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_PASSWORD_EXPIRED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED, __pyx_t_1) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_PASSWORD_EXPIRED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PASSWORD_EXPIRED, __pyx_t_2) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":35
  * LIBSSH2_ERROR_PROTO = error_codes._LIBSSH2_ERROR_PROTO
@@ -1829,10 +2814,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_METHOD_NONE \
  *     = error_codes._LIBSSH2_ERROR_METHOD_NONE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_FILE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_FILE, __pyx_t_1) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_FILE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_FILE, __pyx_t_2) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":37
  * LIBSSH2_ERROR_FILE = error_codes._LIBSSH2_ERROR_FILE
@@ -1841,10 +2826,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_AUTHENTICATION_FAILED \
  *     = error_codes._LIBSSH2_ERROR_AUTHENTICATION_FAILED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_METHOD_NONE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_METHOD_NONE, __pyx_t_1) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_METHOD_NONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_METHOD_NONE, __pyx_t_2) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":39
  *     = error_codes._LIBSSH2_ERROR_METHOD_NONE
@@ -1853,10 +2838,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED \
  *     = error_codes._LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_AUTHENTICATION_FAILED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_AUTHENTICATION_FAILED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_AUTHENTICATION_FAI, __pyx_t_2) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":41
  *     = error_codes._LIBSSH2_ERROR_AUTHENTICATION_FAILED
@@ -1865,10 +2850,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED \
  *     = error_codes._LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_AUTHENTICATION_FAILED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, __pyx_t_1) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_AUTHENTICATION_FAILED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNRECOGN, __pyx_t_2) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":43
  *     = error_codes._LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED
@@ -1877,10 +2862,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_OUTOFORDER = error_codes._LIBSSH2_ERROR_CHANNEL_OUTOFORDER
  * LIBSSH2_ERROR_CHANNEL_FAILURE = error_codes._LIBSSH2_ERROR_CHANNEL_FAILURE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_UNVERIFI, __pyx_t_2) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":44
  * LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED \
@@ -1889,10 +2874,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_FAILURE = error_codes._LIBSSH2_ERROR_CHANNEL_FAILURE
  * LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED \
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_OUTOFORDER); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_OUTOFORDER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_OUTOFORDER, __pyx_t_2) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":45
  *     = error_codes._LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED
@@ -1901,10 +2886,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED \
  *     = error_codes._LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_FAILURE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE, __pyx_t_1) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_FAILURE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_FAILURE, __pyx_t_2) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":47
  * LIBSSH2_ERROR_CHANNEL_FAILURE = error_codes._LIBSSH2_ERROR_CHANNEL_FAILURE
@@ -1913,10 +2898,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_UNKNOWN = error_codes._LIBSSH2_ERROR_CHANNEL_UNKNOWN
  * LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED \
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_REQUEST_DE, __pyx_t_2) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":48
  * LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED \
@@ -1925,10 +2910,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED \
  *     = error_codes._LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_UNKNOWN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN, __pyx_t_1) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_UNKNOWN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_UNKNOWN, __pyx_t_2) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":50
  * LIBSSH2_ERROR_CHANNEL_UNKNOWN = error_codes._LIBSSH2_ERROR_CHANNEL_UNKNOWN
@@ -1937,10 +2922,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED \
  *     = error_codes._LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, __pyx_t_1) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_EXC, __pyx_t_2) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":52
  *     = error_codes._LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED
@@ -1949,10 +2934,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_CLOSED = error_codes._LIBSSH2_ERROR_CHANNEL_CLOSED
  * LIBSSH2_ERROR_CHANNEL_EOF_SENT = error_codes._LIBSSH2_ERROR_CHANNEL_EOF_SENT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, __pyx_t_1) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_PACKET_EXC, __pyx_t_2) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":53
  * LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED \
@@ -1961,10 +2946,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_EOF_SENT = error_codes._LIBSSH2_ERROR_CHANNEL_EOF_SENT
  * LIBSSH2_ERROR_SCP_PROTOCOL = error_codes._LIBSSH2_ERROR_SCP_PROTOCOL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_CLOSED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED, __pyx_t_1) < 0) __PYX_ERR(0, 53, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_CLOSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_CLOSED, __pyx_t_2) < 0) __PYX_ERR(0, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":54
  *     = error_codes._LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED
@@ -1973,10 +2958,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SCP_PROTOCOL = error_codes._LIBSSH2_ERROR_SCP_PROTOCOL
  * LIBSSH2_ERROR_ZLIB = error_codes._LIBSSH2_ERROR_ZLIB
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_EOF_SENT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT, __pyx_t_1) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_EOF_SENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_EOF_SENT, __pyx_t_2) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":55
  * LIBSSH2_ERROR_CHANNEL_CLOSED = error_codes._LIBSSH2_ERROR_CHANNEL_CLOSED
@@ -1985,10 +2970,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_ZLIB = error_codes._LIBSSH2_ERROR_ZLIB
  * LIBSSH2_ERROR_SOCKET_TIMEOUT = error_codes._LIBSSH2_ERROR_SOCKET_TIMEOUT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SCP_PROTOCOL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SCP_PROTOCOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SCP_PROTOCOL, __pyx_t_2) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":56
  * LIBSSH2_ERROR_CHANNEL_EOF_SENT = error_codes._LIBSSH2_ERROR_CHANNEL_EOF_SENT
@@ -1997,10 +2982,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SOCKET_TIMEOUT = error_codes._LIBSSH2_ERROR_SOCKET_TIMEOUT
  * LIBSSH2_ERROR_SFTP_PROTOCOL = error_codes._LIBSSH2_ERROR_SFTP_PROTOCOL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_ZLIB); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ZLIB, __pyx_t_1) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_ZLIB); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ZLIB, __pyx_t_2) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":57
  * LIBSSH2_ERROR_SCP_PROTOCOL = error_codes._LIBSSH2_ERROR_SCP_PROTOCOL
@@ -2009,10 +2994,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SFTP_PROTOCOL = error_codes._LIBSSH2_ERROR_SFTP_PROTOCOL
  * LIBSSH2_ERROR_REQUEST_DENIED = error_codes._LIBSSH2_ERROR_REQUEST_DENIED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SOCKET_TIMEOUT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SOCKET_TIMEOUT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_TIMEOUT, __pyx_t_2) < 0) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":58
  * LIBSSH2_ERROR_ZLIB = error_codes._LIBSSH2_ERROR_ZLIB
@@ -2021,10 +3006,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_REQUEST_DENIED = error_codes._LIBSSH2_ERROR_REQUEST_DENIED
  * LIBSSH2_ERROR_METHOD_NOT_SUPPORTED \
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SFTP_PROTOCOL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL, __pyx_t_1) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SFTP_PROTOCOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SFTP_PROTOCOL, __pyx_t_2) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":59
  * LIBSSH2_ERROR_SOCKET_TIMEOUT = error_codes._LIBSSH2_ERROR_SOCKET_TIMEOUT
@@ -2033,10 +3018,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_METHOD_NOT_SUPPORTED \
  *     = error_codes._LIBSSH2_ERROR_METHOD_NOT_SUPPORTED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_REQUEST_DENIED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED, __pyx_t_1) < 0) __PYX_ERR(0, 59, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_REQUEST_DENIED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_REQUEST_DENIED, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":61
  * LIBSSH2_ERROR_REQUEST_DENIED = error_codes._LIBSSH2_ERROR_REQUEST_DENIED
@@ -2045,10 +3030,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_INVAL = error_codes._LIBSSH2_ERROR_INVAL
  * LIBSSH2_ERROR_INVALID_POLL_TYPE = error_codes._LIBSSH2_ERROR_INVALID_POLL_TYPE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_METHOD_NOT_SUPPORTED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_METHOD_NOT_SUPPORTED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_METHOD_NOT_SUPPORT, __pyx_t_2) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":62
  * LIBSSH2_ERROR_METHOD_NOT_SUPPORTED \
@@ -2057,10 +3042,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_INVALID_POLL_TYPE = error_codes._LIBSSH2_ERROR_INVALID_POLL_TYPE
  * LIBSSH2_ERROR_PUBLICKEY_PROTOCOL = error_codes._LIBSSH2_ERROR_PUBLICKEY_PROTOCOL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_INVAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVAL, __pyx_t_1) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_INVAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVAL, __pyx_t_2) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":63
  *     = error_codes._LIBSSH2_ERROR_METHOD_NOT_SUPPORTED
@@ -2069,10 +3054,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_PUBLICKEY_PROTOCOL = error_codes._LIBSSH2_ERROR_PUBLICKEY_PROTOCOL
  * LIBSSH2_ERROR_EAGAIN = error_codes._LIBSSH2_ERROR_EAGAIN
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_INVALID_POLL_TYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE, __pyx_t_1) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_INVALID_POLL_TYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVALID_POLL_TYPE, __pyx_t_2) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":64
  * LIBSSH2_ERROR_INVAL = error_codes._LIBSSH2_ERROR_INVAL
@@ -2081,10 +3066,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_EAGAIN = error_codes._LIBSSH2_ERROR_EAGAIN
  * LIBSSH2CHANNEL_EAGAIN = error_codes._LIBSSH2CHANNEL_EAGAIN
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_PUBLICKEY_PROTOCOL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, __pyx_t_1) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_PUBLICKEY_PROTOCOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, __pyx_t_2) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":65
  * LIBSSH2_ERROR_INVALID_POLL_TYPE = error_codes._LIBSSH2_ERROR_INVALID_POLL_TYPE
@@ -2093,10 +3078,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2CHANNEL_EAGAIN = error_codes._LIBSSH2CHANNEL_EAGAIN
  * LIBSSH2_ERROR_BUFFER_TOO_SMALL = error_codes._LIBSSH2_ERROR_BUFFER_TOO_SMALL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_EAGAIN, __pyx_t_1) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_EAGAIN, __pyx_t_2) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":66
  * LIBSSH2_ERROR_PUBLICKEY_PROTOCOL = error_codes._LIBSSH2_ERROR_PUBLICKEY_PROTOCOL
@@ -2105,10 +3090,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_BUFFER_TOO_SMALL = error_codes._LIBSSH2_ERROR_BUFFER_TOO_SMALL
  * LIBSSH2_ERROR_BAD_USE = error_codes._LIBSSH2_ERROR_BAD_USE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2CHANNEL_EAGAIN, __pyx_t_1) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2CHANNEL_EAGAIN, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":67
  * LIBSSH2_ERROR_EAGAIN = error_codes._LIBSSH2_ERROR_EAGAIN
@@ -2117,10 +3102,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_BAD_USE = error_codes._LIBSSH2_ERROR_BAD_USE
  * LIBSSH2_ERROR_COMPRESS = error_codes._LIBSSH2_ERROR_COMPRESS
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_BUFFER_TOO_SMALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL, __pyx_t_1) < 0) __PYX_ERR(0, 67, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_BUFFER_TOO_SMALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BUFFER_TOO_SMALL, __pyx_t_2) < 0) __PYX_ERR(0, 67, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":68
  * LIBSSH2CHANNEL_EAGAIN = error_codes._LIBSSH2CHANNEL_EAGAIN
@@ -2129,10 +3114,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_COMPRESS = error_codes._LIBSSH2_ERROR_COMPRESS
  * LIBSSH2_ERROR_OUT_OF_BOUNDARY = error_codes._LIBSSH2_ERROR_OUT_OF_BOUNDARY
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_BAD_USE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BAD_USE, __pyx_t_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_BAD_USE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BAD_USE, __pyx_t_2) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":69
  * LIBSSH2_ERROR_BUFFER_TOO_SMALL = error_codes._LIBSSH2_ERROR_BUFFER_TOO_SMALL
@@ -2141,10 +3126,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_OUT_OF_BOUNDARY = error_codes._LIBSSH2_ERROR_OUT_OF_BOUNDARY
  * LIBSSH2_ERROR_AGENT_PROTOCOL = error_codes._LIBSSH2_ERROR_AGENT_PROTOCOL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_COMPRESS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_COMPRESS, __pyx_t_1) < 0) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_COMPRESS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_COMPRESS, __pyx_t_2) < 0) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":70
  * LIBSSH2_ERROR_BAD_USE = error_codes._LIBSSH2_ERROR_BAD_USE
@@ -2153,10 +3138,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_AGENT_PROTOCOL = error_codes._LIBSSH2_ERROR_AGENT_PROTOCOL
  * LIBSSH2_ERROR_SOCKET_RECV = error_codes._LIBSSH2_ERROR_SOCKET_RECV
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_OUT_OF_BOUNDARY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY, __pyx_t_1) < 0) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_OUT_OF_BOUNDARY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_OUT_OF_BOUNDARY, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":71
  * LIBSSH2_ERROR_COMPRESS = error_codes._LIBSSH2_ERROR_COMPRESS
@@ -2165,10 +3150,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_SOCKET_RECV = error_codes._LIBSSH2_ERROR_SOCKET_RECV
  * LIBSSH2_ERROR_ENCRYPT = error_codes._LIBSSH2_ERROR_ENCRYPT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_AGENT_PROTOCOL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL, __pyx_t_1) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_AGENT_PROTOCOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_AGENT_PROTOCOL, __pyx_t_2) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":72
  * LIBSSH2_ERROR_OUT_OF_BOUNDARY = error_codes._LIBSSH2_ERROR_OUT_OF_BOUNDARY
@@ -2177,10 +3162,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_ENCRYPT = error_codes._LIBSSH2_ERROR_ENCRYPT
  * LIBSSH2_ERROR_BAD_SOCKET = error_codes._LIBSSH2_ERROR_BAD_SOCKET
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_SOCKET_RECV); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV, __pyx_t_1) < 0) __PYX_ERR(0, 72, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_SOCKET_RECV); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_SOCKET_RECV, __pyx_t_2) < 0) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":73
  * LIBSSH2_ERROR_AGENT_PROTOCOL = error_codes._LIBSSH2_ERROR_AGENT_PROTOCOL
@@ -2189,10 +3174,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_BAD_SOCKET = error_codes._LIBSSH2_ERROR_BAD_SOCKET
  * LIBSSH2_ERROR_INVALID_MAC = error_codes._LIBSSH2_ERROR_INVALID_MAC
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_ENCRYPT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ENCRYPT, __pyx_t_1) < 0) __PYX_ERR(0, 73, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_ENCRYPT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ENCRYPT, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":74
  * LIBSSH2_ERROR_SOCKET_RECV = error_codes._LIBSSH2_ERROR_SOCKET_RECV
@@ -2201,10 +3186,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_INVALID_MAC = error_codes._LIBSSH2_ERROR_INVALID_MAC
  * LIBSSH2_ERROR_KEX_FAILURE = error_codes._LIBSSH2_ERROR_KEX_FAILURE
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_BAD_SOCKET); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET, __pyx_t_1) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_BAD_SOCKET); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_BAD_SOCKET, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":75
  * LIBSSH2_ERROR_ENCRYPT = error_codes._LIBSSH2_ERROR_ENCRYPT
@@ -2213,10 +3198,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_KEX_FAILURE = error_codes._LIBSSH2_ERROR_KEX_FAILURE
  * LIBSSH2_ERROR_ALLOC = error_codes._LIBSSH2_ERROR_ALLOC
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_INVALID_MAC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVALID_MAC, __pyx_t_1) < 0) __PYX_ERR(0, 75, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_INVALID_MAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_INVALID_MAC, __pyx_t_2) < 0) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":76
  * LIBSSH2_ERROR_BAD_SOCKET = error_codes._LIBSSH2_ERROR_BAD_SOCKET
@@ -2225,10 +3210,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_ALLOC = error_codes._LIBSSH2_ERROR_ALLOC
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_KEX_FAILURE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE, __pyx_t_1) < 0) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_KEX_FAILURE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEX_FAILURE, __pyx_t_2) < 0) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":77
  * LIBSSH2_ERROR_INVALID_MAC = error_codes._LIBSSH2_ERROR_INVALID_MAC
@@ -2237,10 +3222,10 @@ if (!__Pyx_RefNanny) {
  * 
  * LIBSSH2_ERROR_KNOWN_HOSTS = error_codes._LIBSSH2_ERROR_KNOWN_HOSTS
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_ALLOC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ALLOC, __pyx_t_1) < 0) __PYX_ERR(0, 77, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_ALLOC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_ALLOC, __pyx_t_2) < 0) __PYX_ERR(0, 77, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":79
  * LIBSSH2_ERROR_ALLOC = error_codes._LIBSSH2_ERROR_ALLOC
@@ -2249,10 +3234,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_CHANNEL_WINDOW_FULL = \
  *     error_codes._LIBSSH2_ERROR_CHANNEL_WINDOW_FULL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_KNOWN_HOSTS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS, __pyx_t_1) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_KNOWN_HOSTS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KNOWN_HOSTS, __pyx_t_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":81
  * LIBSSH2_ERROR_KNOWN_HOSTS = error_codes._LIBSSH2_ERROR_KNOWN_HOSTS
@@ -2261,41 +3246,51 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_ERROR_KEYFILE_AUTH_FAILED = \
  *     error_codes._LIBSSH2_ERROR_KEYFILE_AUTH_FAILED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_CHANNEL_WINDOW_FULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, __pyx_t_1) < 0) __PYX_ERR(0, 80, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_CHANNEL_WINDOW_FULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_CHANNEL_WINDOW_FUL, __pyx_t_2) < 0) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":83
  *     error_codes._LIBSSH2_ERROR_CHANNEL_WINDOW_FULL
  * LIBSSH2_ERROR_KEYFILE_AUTH_FAILED = \
  *     error_codes._LIBSSH2_ERROR_KEYFILE_AUTH_FAILED             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_KEYFILE_AUTH_FAILED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, __pyx_t_1) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_KEYFILE_AUTH_FAILED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_ERROR_KEYFILE_AUTH_FAILE, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/error_codes.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.error_codes", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.error_codes");
   }
@@ -2309,6 +3304,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -2354,23 +3365,67 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
 #endif
-    return PyObject_GetAttr(obj, attr_name);
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
 }
 #endif
 
 /* PyErrFetchRestore */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     tmp_type = tstate->curexc_type;
     tmp_value = tstate->curexc_value;
@@ -2381,25 +3436,89 @@ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObjec
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+#endif
 }
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
     *type = tstate->curexc_type;
     *value = tstate->curexc_value;
     *tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
 }
 #endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -2413,7 +3532,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -2435,6 +3554,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -2513,17 +3633,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -2558,6 +3762,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -2573,7 +3778,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -2620,9 +3825,10 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
@@ -2652,12 +3858,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s_);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -2690,10 +3945,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -2732,7 +4020,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -2741,168 +4029,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -2928,7 +4287,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -2937,168 +4296,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -3115,7 +4545,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -3136,6 +4566,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -3160,11 +4606,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -3212,47 +4658,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -3260,30 +4737,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -3338,7 +4819,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -3367,22 +4848,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -3448,13 +4933,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -3522,4 +5005,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/error_codes.pyx b/ssh2/error_codes.pyx
index e450a4a4..0fa974f9 100644
--- a/ssh2/error_codes.pyx
+++ b/ssh2/error_codes.pyx
@@ -14,8 +14,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport error_codes
-cimport c_ssh2
+from . cimport error_codes
+from . cimport c_ssh2
 
 
 LIBSSH2_ERROR_NONE = error_codes._LIBSSH2_ERROR_NONE
diff --git a/ssh2/exceptions.c b/ssh2/exceptions.c
index d580daa4..5221bf76 100644
--- a/ssh2/exceptions.c
+++ b/ssh2/exceptions.c
@@ -1,22 +1,66 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.exceptions",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/exceptions.pyx"
+        ]
+    },
+    "module_name": "ssh2.exceptions"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
+#else
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +79,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +87,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +124,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +144,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +272,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +301,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +312,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +335,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +362,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +386,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +470,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +494,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +511,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +573,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +608,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +760,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +777,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +867,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +913,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +947,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1041,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1056,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1098,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1115,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1162,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1182,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1222,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -789,9 +1294,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -809,9 +1315,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -819,13 +1325,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -849,8 +1349,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -871,7 +1417,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -901,6 +1447,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -936,24 +1483,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/exceptions.pyx",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -962,11 +1511,11 @@ static const char *__pyx_f[] = {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -976,28 +1525,40 @@ static const char *__pyx_f[] = {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
           }
-#else
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
+#else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1008,6 +1569,10 @@ static const char *__pyx_f[] = {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1019,8 +1584,110 @@ static const char *__pyx_f[] = {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* CalculateMetaclass.proto */
-static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
 
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
@@ -1029,15 +1696,37 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* Py3UpdateBases.proto */
+static PyObject* __Pyx_PEP560_update_bases(PyObject *bases);
+
+/* CalculateMetaclass.proto */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* PyObjectCall2Args.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* PyObjectLookupSpecial.proto */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 0)
+#define __Pyx_PyObject_LookupSpecial(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 1)
+static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error);
+#else
+#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n)
+#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
+#endif
+
 /* Py3ClassCreate.proto */
 static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
                                            PyObject *mkw, PyObject *modname, PyObject *doc);
 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
                                       PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);
 
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1066,18 +1755,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* GetModuleGlobalName.proto */
 #if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
     static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
     (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1085,42 +1774,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
-#endif
-
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1129,6 +1782,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1142,13 +1796,27 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1164,37 +1832,51 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'ssh2.exceptions' */
+/* Module declarations from "ssh2.exceptions" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.exceptions"
 extern int __pyx_module_is_main_ssh2__exceptions;
 int __pyx_module_is_main_ssh2__exceptions = 0;
 
-/* Implementation of 'ssh2.exceptions' */
+/* Implementation of "ssh2.exceptions" */
+/* #### Code section: global_var ### */
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = "?";
 static const char __pyx_k_doc[] = "__doc__";
+static const char __pyx_k_dict[] = "__dict__";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_super[] = "super";
 static const char __pyx_k_module[] = "__module__";
 static const char __pyx_k_Timeout[] = "Timeout";
 static const char __pyx_k_prepare[] = "__prepare__";
 static const char __pyx_k_qualname[] = "__qualname__";
+static const char __pyx_k_set_name[] = "__set_name__";
 static const char __pyx_k_FileError[] = "FileError";
 static const char __pyx_k_SFTPError[] = "SFTPError";
 static const char __pyx_k_SSH2Error[] = "SSH2Error";
@@ -1203,6 +1885,7 @@ static const char __pyx_k_metaclass[] = "__metaclass__";
 static const char __pyx_k_AgentError[] = "AgentError";
 static const char __pyx_k_AllocError[] = "AllocError";
 static const char __pyx_k_BadUseError[] = "BadUseError";
+static const char __pyx_k_mro_entries[] = "__mro_entries__";
 static const char __pyx_k_ChannelError[] = "ChannelError";
 static const char __pyx_k_DecryptError[] = "DecryptError";
 static const char __pyx_k_EncryptError[] = "EncryptError";
@@ -1211,6 +1894,7 @@ static const char __pyx_k_UnknownError[] = "UnknownError";
 static const char __pyx_k_CompressError[] = "CompressError";
 static const char __pyx_k_ProtocolError[] = "ProtocolError";
 static const char __pyx_k_SocketTimeout[] = "SocketTimeout";
+static const char __pyx_k_init_subclass[] = "__init_subclass__";
 static const char __pyx_k_BadSocketError[] = "BadSocketError";
 static const char __pyx_k_ChannelFailure[] = "ChannelFailure";
 static const char __pyx_k_KnownHostError[] = "KnownHostError";
@@ -1343,199 +2027,781 @@ static const char __pyx_k_Raised_on_socket_disconnection_e[] = "Raised on socket
 static const char __pyx_k_Raised_on_something_preventing_k[] = "Raised on something preventing known host check to be made";
 static const char __pyx_k_Raised_on_unknown_channel_errors[] = "Raised on unknown channel errors";
 static const char __pyx_k_Raised_on_use_of_bad_socket_erro[] = "Raised on use of bad socket errors";
-static PyObject *__pyx_n_s_AgentAuthenticationError;
-static PyObject *__pyx_n_s_AgentConnectionError;
-static PyObject *__pyx_n_s_AgentError;
-static PyObject *__pyx_n_s_AgentGetIdentityError;
-static PyObject *__pyx_n_s_AgentListIdentitiesError;
-static PyObject *__pyx_n_s_AgentProtocolError;
-static PyObject *__pyx_n_s_AllocError;
-static PyObject *__pyx_n_s_AuthenticationError;
-static PyObject *__pyx_n_s_BadSocketError;
-static PyObject *__pyx_n_s_BadUseError;
-static PyObject *__pyx_n_s_BannerRecvError;
-static PyObject *__pyx_n_s_BannerSendError;
-static PyObject *__pyx_kp_s_Base_class_for_KnownHost_errors;
-static PyObject *__pyx_kp_s_Base_class_for_SFTP_errors;
-static PyObject *__pyx_kp_s_Base_class_for_all_SSH_Agent_err;
-static PyObject *__pyx_kp_s_Base_class_for_all_authenticatio;
-static PyObject *__pyx_kp_s_Base_class_for_all_channel_error;
-static PyObject *__pyx_kp_s_Base_class_for_all_public_key_pr;
-static PyObject *__pyx_kp_s_Base_class_for_all_session_error;
-static PyObject *__pyx_kp_s_Base_class_for_all_ssh2_python_e;
-static PyObject *__pyx_n_s_BufferTooSmallError;
-static PyObject *__pyx_n_s_ChannelClosedError;
-static PyObject *__pyx_n_s_ChannelEOFSentError;
-static PyObject *__pyx_n_s_ChannelError;
-static PyObject *__pyx_n_s_ChannelFailure;
-static PyObject *__pyx_n_s_ChannelOutOfOrderError;
-static PyObject *__pyx_n_s_ChannelPacketExceeded;
-static PyObject *__pyx_n_s_ChannelRequestDenied;
-static PyObject *__pyx_n_s_ChannelUnknownError;
-static PyObject *__pyx_n_s_ChannelWindowExceeded;
-static PyObject *__pyx_n_s_ChannelWindowFullError;
-static PyObject *__pyx_n_s_CompressError;
-static PyObject *__pyx_n_s_DecryptError;
-static PyObject *__pyx_n_s_EncryptError;
-static PyObject *__pyx_n_s_FileError;
-static PyObject *__pyx_n_s_HostkeyInitError;
-static PyObject *__pyx_n_s_HostkeySignError;
-static PyObject *__pyx_n_s_InvalidMACError;
-static PyObject *__pyx_n_s_InvalidPollTypeError;
-static PyObject *__pyx_n_s_InvalidRequestError;
-static PyObject *__pyx_n_s_KexFailureError;
-static PyObject *__pyx_n_s_KeyExchangeError;
-static PyObject *__pyx_n_s_KeyfileAuthFailedError;
-static PyObject *__pyx_n_s_KnownHostAddError;
-static PyObject *__pyx_n_s_KnownHostCheckError;
-static PyObject *__pyx_n_s_KnownHostCheckFailure;
-static PyObject *__pyx_n_s_KnownHostCheckMisMatchError;
-static PyObject *__pyx_n_s_KnownHostCheckNotFoundError;
-static PyObject *__pyx_n_s_KnownHostDeleteError;
-static PyObject *__pyx_n_s_KnownHostError;
-static PyObject *__pyx_n_s_KnownHostGetError;
-static PyObject *__pyx_n_s_KnownHostReadFileError;
-static PyObject *__pyx_n_s_KnownHostReadLineError;
-static PyObject *__pyx_n_s_KnownHostWriteFileError;
-static PyObject *__pyx_n_s_KnownHostWriteLineError;
-static PyObject *__pyx_n_s_MethodNoneError;
-static PyObject *__pyx_n_s_MethodNotSupported;
-static PyObject *__pyx_n_s_OutOfBoundaryError;
-static PyObject *__pyx_n_s_PasswordExpiredError;
-static PyObject *__pyx_n_s_ProtocolError;
-static PyObject *__pyx_n_s_PublicKeyError;
-static PyObject *__pyx_n_s_PublicKeyInitError;
-static PyObject *__pyx_n_s_PublicKeyProtocolError;
-static PyObject *__pyx_n_s_PublickeyUnverifiedError;
-static PyObject *__pyx_kp_s_Raised_on_API_bad_use_errors;
-static PyObject *__pyx_kp_s_Raised_on_KEX_failure;
-static PyObject *__pyx_kp_s_Raised_on_SCP_protocol_errors;
-static PyObject *__pyx_kp_s_Raised_on_SFTP_handle_errors;
-static PyObject *__pyx_kp_s_Raised_on_SFTP_protocol_errors;
-static PyObject *__pyx_kp_s_Raised_on_SSH_Agent_authenticati;
-static PyObject *__pyx_kp_s_Raised_on_SSH_Agent_connection_e;
-static PyObject *__pyx_kp_s_Raised_on_SSH_Agent_get_identity;
-static PyObject *__pyx_kp_s_Raised_on_SSH_Agent_list_identit;
-static PyObject *__pyx_kp_s_Raised_on_SSH_agent_protocol_err;
-static PyObject *__pyx_kp_s_Raised_on_allocation_error;
-static PyObject *__pyx_kp_s_Raised_on_any_known_host_check_e;
-static PyObject *__pyx_kp_s_Raised_on_authentication_method;
-static PyObject *__pyx_kp_s_Raised_on_buffer_too_small_error;
-static PyObject *__pyx_kp_s_Raised_on_channel_EOF_errors;
-static PyObject *__pyx_kp_s_Raised_on_channel_closed_errors;
-static PyObject *__pyx_kp_s_Raised_on_channel_commands_out_o;
-static PyObject *__pyx_kp_s_Raised_on_channel_failures;
-static PyObject *__pyx_kp_s_Raised_on_channel_max_packet_len;
-static PyObject *__pyx_kp_s_Raised_on_channel_request_denied;
-static PyObject *__pyx_kp_s_Raised_on_channel_window_exceede;
-static PyObject *__pyx_kp_s_Raised_on_channel_window_full_er;
-static PyObject *__pyx_kp_s_Raised_on_compression_errors;
-static PyObject *__pyx_kp_s_Raised_on_decryption_errors;
-static PyObject *__pyx_kp_s_Raised_on_encryption_errors;
-static PyObject *__pyx_kp_s_Raised_on_errors_adding_known_ho;
-static PyObject *__pyx_kp_s_Raised_on_errors_deleting_known;
-static PyObject *__pyx_kp_s_Raised_on_errors_exchanging_keys;
-static PyObject *__pyx_kp_s_Raised_on_errors_getting_server;
-static PyObject *__pyx_kp_s_Raised_on_errors_initialiasing_h;
-static PyObject *__pyx_kp_s_Raised_on_errors_initialising_pu;
-static PyObject *__pyx_kp_s_Raised_on_errors_reading_from_kn;
-static PyObject *__pyx_kp_s_Raised_on_errors_reading_line_fr;
-static PyObject *__pyx_kp_s_Raised_on_errors_receiving_banne;
-static PyObject *__pyx_kp_s_Raised_on_errors_retrieving_know;
-static PyObject *__pyx_kp_s_Raised_on_errors_sending_banner;
-static PyObject *__pyx_kp_s_Raised_on_errors_signing_host_ke;
-static PyObject *__pyx_kp_s_Raised_on_errors_writing_line_to;
-static PyObject *__pyx_kp_s_Raised_on_errors_writing_to_know;
-static PyObject *__pyx_kp_s_Raised_on_file_errors;
-static PyObject *__pyx_kp_s_Raised_on_invalid_MAC;
-static PyObject *__pyx_kp_s_Raised_on_invalid_method_errors;
-static PyObject *__pyx_kp_s_Raised_on_invalid_poll_type_erro;
-static PyObject *__pyx_kp_s_Raised_on_invalid_request_errors;
-static PyObject *__pyx_kp_s_Raised_on_key_file_authenticatio;
-static PyObject *__pyx_kp_s_Raised_on_keys_do_not_match_for;
-static PyObject *__pyx_kp_s_Raised_on_no_match_for_known_hos;
-static PyObject *__pyx_kp_s_Raised_on_non_specific_or_unknow;
-static PyObject *__pyx_kp_s_Raised_on_out_of_boundary_errors;
-static PyObject *__pyx_kp_s_Raised_on_password_expired_error;
-static PyObject *__pyx_kp_s_Raised_on_protocol_errors;
-static PyObject *__pyx_kp_s_Raised_on_public_key_protocol_er;
-static PyObject *__pyx_kp_s_Raised_on_public_key_verificatio;
-static PyObject *__pyx_kp_s_Raised_on_request_denied_errors;
-static PyObject *__pyx_kp_s_Raised_on_session_handshake_erro;
-static PyObject *__pyx_kp_s_Raised_on_session_startup_errors;
-static PyObject *__pyx_kp_s_Raised_on_socket_disconnection_e;
-static PyObject *__pyx_kp_s_Raised_on_socket_receive_errors;
-static PyObject *__pyx_kp_s_Raised_on_socket_send_errors;
-static PyObject *__pyx_kp_s_Raised_on_socket_timeouts;
-static PyObject *__pyx_kp_s_Raised_on_something_preventing_k;
-static PyObject *__pyx_kp_s_Raised_on_timeouts;
-static PyObject *__pyx_kp_s_Raised_on_unknown_channel_errors;
-static PyObject *__pyx_kp_s_Raised_on_use_of_bad_socket_erro;
-static PyObject *__pyx_kp_s_Raised_on_zlib_errors;
-static PyObject *__pyx_n_s_RequestDeniedError;
-static PyObject *__pyx_n_s_SCPProtocolError;
-static PyObject *__pyx_n_s_SFTPError;
-static PyObject *__pyx_n_s_SFTPHandleError;
-static PyObject *__pyx_n_s_SFTPProtocolError;
-static PyObject *__pyx_n_s_SSH2Error;
-static PyObject *__pyx_n_s_SessionError;
-static PyObject *__pyx_n_s_SessionHandshakeError;
-static PyObject *__pyx_n_s_SessionHostKeyError;
-static PyObject *__pyx_n_s_SessionStartupError;
-static PyObject *__pyx_n_s_SocketDisconnectError;
-static PyObject *__pyx_n_s_SocketRecvError;
-static PyObject *__pyx_n_s_SocketSendError;
-static PyObject *__pyx_n_s_SocketTimeout;
-static PyObject *__pyx_n_s_Timeout;
-static PyObject *__pyx_n_s_UnknownError;
-static PyObject *__pyx_n_s_ZlibError;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_doc;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_metaclass;
-static PyObject *__pyx_n_s_module;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_prepare;
-static PyObject *__pyx_n_s_qualname;
-static PyObject *__pyx_n_s_ssh2_exceptions;
-static PyObject *__pyx_n_s_test;
-/* Late includes */
+/* #### Code section: decls ### */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyObject *__pyx_n_s_;
+  PyObject *__pyx_n_s_AgentAuthenticationError;
+  PyObject *__pyx_n_s_AgentConnectionError;
+  PyObject *__pyx_n_s_AgentError;
+  PyObject *__pyx_n_s_AgentGetIdentityError;
+  PyObject *__pyx_n_s_AgentListIdentitiesError;
+  PyObject *__pyx_n_s_AgentProtocolError;
+  PyObject *__pyx_n_s_AllocError;
+  PyObject *__pyx_n_s_AuthenticationError;
+  PyObject *__pyx_n_s_BadSocketError;
+  PyObject *__pyx_n_s_BadUseError;
+  PyObject *__pyx_n_s_BannerRecvError;
+  PyObject *__pyx_n_s_BannerSendError;
+  PyObject *__pyx_kp_s_Base_class_for_KnownHost_errors;
+  PyObject *__pyx_kp_s_Base_class_for_SFTP_errors;
+  PyObject *__pyx_kp_s_Base_class_for_all_SSH_Agent_err;
+  PyObject *__pyx_kp_s_Base_class_for_all_authenticatio;
+  PyObject *__pyx_kp_s_Base_class_for_all_channel_error;
+  PyObject *__pyx_kp_s_Base_class_for_all_public_key_pr;
+  PyObject *__pyx_kp_s_Base_class_for_all_session_error;
+  PyObject *__pyx_kp_s_Base_class_for_all_ssh2_python_e;
+  PyObject *__pyx_n_s_BufferTooSmallError;
+  PyObject *__pyx_n_s_ChannelClosedError;
+  PyObject *__pyx_n_s_ChannelEOFSentError;
+  PyObject *__pyx_n_s_ChannelError;
+  PyObject *__pyx_n_s_ChannelFailure;
+  PyObject *__pyx_n_s_ChannelOutOfOrderError;
+  PyObject *__pyx_n_s_ChannelPacketExceeded;
+  PyObject *__pyx_n_s_ChannelRequestDenied;
+  PyObject *__pyx_n_s_ChannelUnknownError;
+  PyObject *__pyx_n_s_ChannelWindowExceeded;
+  PyObject *__pyx_n_s_ChannelWindowFullError;
+  PyObject *__pyx_n_s_CompressError;
+  PyObject *__pyx_n_s_DecryptError;
+  PyObject *__pyx_n_s_EncryptError;
+  PyObject *__pyx_n_s_FileError;
+  PyObject *__pyx_n_s_HostkeyInitError;
+  PyObject *__pyx_n_s_HostkeySignError;
+  PyObject *__pyx_n_s_InvalidMACError;
+  PyObject *__pyx_n_s_InvalidPollTypeError;
+  PyObject *__pyx_n_s_InvalidRequestError;
+  PyObject *__pyx_n_s_KexFailureError;
+  PyObject *__pyx_n_s_KeyExchangeError;
+  PyObject *__pyx_n_s_KeyfileAuthFailedError;
+  PyObject *__pyx_n_s_KnownHostAddError;
+  PyObject *__pyx_n_s_KnownHostCheckError;
+  PyObject *__pyx_n_s_KnownHostCheckFailure;
+  PyObject *__pyx_n_s_KnownHostCheckMisMatchError;
+  PyObject *__pyx_n_s_KnownHostCheckNotFoundError;
+  PyObject *__pyx_n_s_KnownHostDeleteError;
+  PyObject *__pyx_n_s_KnownHostError;
+  PyObject *__pyx_n_s_KnownHostGetError;
+  PyObject *__pyx_n_s_KnownHostReadFileError;
+  PyObject *__pyx_n_s_KnownHostReadLineError;
+  PyObject *__pyx_n_s_KnownHostWriteFileError;
+  PyObject *__pyx_n_s_KnownHostWriteLineError;
+  PyObject *__pyx_n_s_MethodNoneError;
+  PyObject *__pyx_n_s_MethodNotSupported;
+  PyObject *__pyx_n_s_OutOfBoundaryError;
+  PyObject *__pyx_n_s_PasswordExpiredError;
+  PyObject *__pyx_n_s_ProtocolError;
+  PyObject *__pyx_n_s_PublicKeyError;
+  PyObject *__pyx_n_s_PublicKeyInitError;
+  PyObject *__pyx_n_s_PublicKeyProtocolError;
+  PyObject *__pyx_n_s_PublickeyUnverifiedError;
+  PyObject *__pyx_kp_s_Raised_on_API_bad_use_errors;
+  PyObject *__pyx_kp_s_Raised_on_KEX_failure;
+  PyObject *__pyx_kp_s_Raised_on_SCP_protocol_errors;
+  PyObject *__pyx_kp_s_Raised_on_SFTP_handle_errors;
+  PyObject *__pyx_kp_s_Raised_on_SFTP_protocol_errors;
+  PyObject *__pyx_kp_s_Raised_on_SSH_Agent_authenticati;
+  PyObject *__pyx_kp_s_Raised_on_SSH_Agent_connection_e;
+  PyObject *__pyx_kp_s_Raised_on_SSH_Agent_get_identity;
+  PyObject *__pyx_kp_s_Raised_on_SSH_Agent_list_identit;
+  PyObject *__pyx_kp_s_Raised_on_SSH_agent_protocol_err;
+  PyObject *__pyx_kp_s_Raised_on_allocation_error;
+  PyObject *__pyx_kp_s_Raised_on_any_known_host_check_e;
+  PyObject *__pyx_kp_s_Raised_on_authentication_method;
+  PyObject *__pyx_kp_s_Raised_on_buffer_too_small_error;
+  PyObject *__pyx_kp_s_Raised_on_channel_EOF_errors;
+  PyObject *__pyx_kp_s_Raised_on_channel_closed_errors;
+  PyObject *__pyx_kp_s_Raised_on_channel_commands_out_o;
+  PyObject *__pyx_kp_s_Raised_on_channel_failures;
+  PyObject *__pyx_kp_s_Raised_on_channel_max_packet_len;
+  PyObject *__pyx_kp_s_Raised_on_channel_request_denied;
+  PyObject *__pyx_kp_s_Raised_on_channel_window_exceede;
+  PyObject *__pyx_kp_s_Raised_on_channel_window_full_er;
+  PyObject *__pyx_kp_s_Raised_on_compression_errors;
+  PyObject *__pyx_kp_s_Raised_on_decryption_errors;
+  PyObject *__pyx_kp_s_Raised_on_encryption_errors;
+  PyObject *__pyx_kp_s_Raised_on_errors_adding_known_ho;
+  PyObject *__pyx_kp_s_Raised_on_errors_deleting_known;
+  PyObject *__pyx_kp_s_Raised_on_errors_exchanging_keys;
+  PyObject *__pyx_kp_s_Raised_on_errors_getting_server;
+  PyObject *__pyx_kp_s_Raised_on_errors_initialiasing_h;
+  PyObject *__pyx_kp_s_Raised_on_errors_initialising_pu;
+  PyObject *__pyx_kp_s_Raised_on_errors_reading_from_kn;
+  PyObject *__pyx_kp_s_Raised_on_errors_reading_line_fr;
+  PyObject *__pyx_kp_s_Raised_on_errors_receiving_banne;
+  PyObject *__pyx_kp_s_Raised_on_errors_retrieving_know;
+  PyObject *__pyx_kp_s_Raised_on_errors_sending_banner;
+  PyObject *__pyx_kp_s_Raised_on_errors_signing_host_ke;
+  PyObject *__pyx_kp_s_Raised_on_errors_writing_line_to;
+  PyObject *__pyx_kp_s_Raised_on_errors_writing_to_know;
+  PyObject *__pyx_kp_s_Raised_on_file_errors;
+  PyObject *__pyx_kp_s_Raised_on_invalid_MAC;
+  PyObject *__pyx_kp_s_Raised_on_invalid_method_errors;
+  PyObject *__pyx_kp_s_Raised_on_invalid_poll_type_erro;
+  PyObject *__pyx_kp_s_Raised_on_invalid_request_errors;
+  PyObject *__pyx_kp_s_Raised_on_key_file_authenticatio;
+  PyObject *__pyx_kp_s_Raised_on_keys_do_not_match_for;
+  PyObject *__pyx_kp_s_Raised_on_no_match_for_known_hos;
+  PyObject *__pyx_kp_s_Raised_on_non_specific_or_unknow;
+  PyObject *__pyx_kp_s_Raised_on_out_of_boundary_errors;
+  PyObject *__pyx_kp_s_Raised_on_password_expired_error;
+  PyObject *__pyx_kp_s_Raised_on_protocol_errors;
+  PyObject *__pyx_kp_s_Raised_on_public_key_protocol_er;
+  PyObject *__pyx_kp_s_Raised_on_public_key_verificatio;
+  PyObject *__pyx_kp_s_Raised_on_request_denied_errors;
+  PyObject *__pyx_kp_s_Raised_on_session_handshake_erro;
+  PyObject *__pyx_kp_s_Raised_on_session_startup_errors;
+  PyObject *__pyx_kp_s_Raised_on_socket_disconnection_e;
+  PyObject *__pyx_kp_s_Raised_on_socket_receive_errors;
+  PyObject *__pyx_kp_s_Raised_on_socket_send_errors;
+  PyObject *__pyx_kp_s_Raised_on_socket_timeouts;
+  PyObject *__pyx_kp_s_Raised_on_something_preventing_k;
+  PyObject *__pyx_kp_s_Raised_on_timeouts;
+  PyObject *__pyx_kp_s_Raised_on_unknown_channel_errors;
+  PyObject *__pyx_kp_s_Raised_on_use_of_bad_socket_erro;
+  PyObject *__pyx_kp_s_Raised_on_zlib_errors;
+  PyObject *__pyx_n_s_RequestDeniedError;
+  PyObject *__pyx_n_s_SCPProtocolError;
+  PyObject *__pyx_n_s_SFTPError;
+  PyObject *__pyx_n_s_SFTPHandleError;
+  PyObject *__pyx_n_s_SFTPProtocolError;
+  PyObject *__pyx_n_s_SSH2Error;
+  PyObject *__pyx_n_s_SessionError;
+  PyObject *__pyx_n_s_SessionHandshakeError;
+  PyObject *__pyx_n_s_SessionHostKeyError;
+  PyObject *__pyx_n_s_SessionStartupError;
+  PyObject *__pyx_n_s_SocketDisconnectError;
+  PyObject *__pyx_n_s_SocketRecvError;
+  PyObject *__pyx_n_s_SocketSendError;
+  PyObject *__pyx_n_s_SocketTimeout;
+  PyObject *__pyx_n_s_Timeout;
+  PyObject *__pyx_n_s_UnknownError;
+  PyObject *__pyx_n_s_ZlibError;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_dict;
+  PyObject *__pyx_n_s_doc;
+  PyObject *__pyx_n_s_init_subclass;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_metaclass;
+  PyObject *__pyx_n_s_module;
+  PyObject *__pyx_n_s_mro_entries;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_prepare;
+  PyObject *__pyx_n_s_qualname;
+  PyObject *__pyx_n_s_set_name;
+  PyObject *__pyx_n_s_ssh2_exceptions;
+  PyObject *__pyx_n_s_super;
+  PyObject *__pyx_n_s_test;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-static PyMethodDef __pyx_methods[] = {
-  {0, 0, 0, 0}
-};
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
 
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_exceptions(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_exceptions},
-  {0, NULL}
-};
-#endif
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
 
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "exceptions",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
   #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
   #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
+  Py_CLEAR(clear_module_state->__pyx_n_s_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentAuthenticationError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentConnectionError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentGetIdentityError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentListIdentitiesError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AllocError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AuthenticationError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BadSocketError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BadUseError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BannerRecvError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BannerSendError);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_KnownHost_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_SFTP_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_SSH_Agent_err);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_authenticatio);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_channel_error);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_public_key_pr);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_session_error);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Base_class_for_all_ssh2_python_e);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BufferTooSmallError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelClosedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelEOFSentError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelFailure);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelOutOfOrderError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelPacketExceeded);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelRequestDenied);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelUnknownError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelWindowExceeded);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelWindowFullError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_CompressError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_DecryptError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_EncryptError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_FileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_HostkeyInitError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_HostkeySignError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidMACError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidPollTypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidRequestError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KexFailureError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KeyExchangeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KeyfileAuthFailedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostAddError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckFailure);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckMisMatchError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckNotFoundError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostDeleteError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostGetError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostReadFileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostReadLineError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostWriteFileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostWriteLineError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodNoneError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodNotSupported);
+  Py_CLEAR(clear_module_state->__pyx_n_s_OutOfBoundaryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PasswordExpiredError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyInitError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublickeyUnverifiedError);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_API_bad_use_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_KEX_failure);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SCP_protocol_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SFTP_handle_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SFTP_protocol_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_Agent_authenticati);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_Agent_connection_e);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_Agent_get_identity);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_Agent_list_identit);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_SSH_agent_protocol_err);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_allocation_error);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_any_known_host_check_e);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_authentication_method);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_buffer_too_small_error);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_EOF_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_closed_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_commands_out_o);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_failures);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_max_packet_len);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_request_denied);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_window_exceede);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_channel_window_full_er);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_compression_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_decryption_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_encryption_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_adding_known_ho);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_deleting_known);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_exchanging_keys);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_getting_server);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_initialiasing_h);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_initialising_pu);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_reading_from_kn);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_reading_line_fr);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_receiving_banne);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_retrieving_know);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_sending_banner);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_signing_host_ke);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_writing_line_to);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_errors_writing_to_know);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_file_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_invalid_MAC);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_invalid_method_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_invalid_poll_type_erro);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_invalid_request_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_key_file_authenticatio);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_keys_do_not_match_for);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_no_match_for_known_hos);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_non_specific_or_unknow);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_out_of_boundary_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_password_expired_error);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_protocol_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_public_key_protocol_er);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_public_key_verificatio);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_request_denied_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_session_handshake_erro);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_session_startup_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_socket_disconnection_e);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_socket_receive_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_socket_send_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_socket_timeouts);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_something_preventing_k);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_timeouts);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_unknown_channel_errors);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_use_of_bad_socket_erro);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_Raised_on_zlib_errors);
+  Py_CLEAR(clear_module_state->__pyx_n_s_RequestDeniedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SCPProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandleError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SSH2Error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SessionError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SessionHandshakeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SessionHostKeyError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SessionStartupError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketDisconnectError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketRecvError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketSendError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketTimeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_UnknownError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ZlibError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_dict);
+  Py_CLEAR(clear_module_state->__pyx_n_s_doc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_metaclass);
+  Py_CLEAR(clear_module_state->__pyx_n_s_module);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mro_entries);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prepare);
+  Py_CLEAR(clear_module_state->__pyx_n_s_qualname);
+  Py_CLEAR(clear_module_state->__pyx_n_s_set_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_super);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_n_s_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentAuthenticationError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentConnectionError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentGetIdentityError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentListIdentitiesError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AllocError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AuthenticationError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BadSocketError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BadUseError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BannerRecvError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BannerSendError);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_KnownHost_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_SFTP_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_SSH_Agent_err);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_authenticatio);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_channel_error);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_public_key_pr);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_session_error);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Base_class_for_all_ssh2_python_e);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BufferTooSmallError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelClosedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelEOFSentError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelFailure);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelOutOfOrderError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelPacketExceeded);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelRequestDenied);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelUnknownError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelWindowExceeded);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelWindowFullError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_CompressError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_DecryptError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_EncryptError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_FileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_HostkeyInitError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_HostkeySignError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidMACError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidPollTypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidRequestError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KexFailureError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KeyExchangeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KeyfileAuthFailedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostAddError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckFailure);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckMisMatchError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckNotFoundError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostDeleteError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostGetError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostReadFileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostReadLineError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostWriteFileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostWriteLineError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodNoneError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodNotSupported);
+  Py_VISIT(traverse_module_state->__pyx_n_s_OutOfBoundaryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PasswordExpiredError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyInitError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublickeyUnverifiedError);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_API_bad_use_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_KEX_failure);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SCP_protocol_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SFTP_handle_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SFTP_protocol_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_Agent_authenticati);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_Agent_connection_e);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_Agent_get_identity);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_Agent_list_identit);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_SSH_agent_protocol_err);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_allocation_error);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_any_known_host_check_e);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_authentication_method);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_buffer_too_small_error);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_EOF_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_closed_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_commands_out_o);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_failures);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_max_packet_len);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_request_denied);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_window_exceede);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_channel_window_full_er);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_compression_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_decryption_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_encryption_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_adding_known_ho);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_deleting_known);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_exchanging_keys);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_getting_server);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_initialiasing_h);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_initialising_pu);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_reading_from_kn);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_reading_line_fr);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_receiving_banne);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_retrieving_know);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_sending_banner);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_signing_host_ke);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_writing_line_to);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_errors_writing_to_know);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_file_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_invalid_MAC);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_invalid_method_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_invalid_poll_type_erro);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_invalid_request_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_key_file_authenticatio);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_keys_do_not_match_for);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_no_match_for_known_hos);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_non_specific_or_unknow);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_out_of_boundary_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_password_expired_error);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_protocol_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_public_key_protocol_er);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_public_key_verificatio);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_request_denied_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_session_handshake_erro);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_session_startup_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_socket_disconnection_e);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_socket_receive_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_socket_send_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_socket_timeouts);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_something_preventing_k);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_timeouts);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_unknown_channel_errors);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_use_of_bad_socket_erro);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_Raised_on_zlib_errors);
+  Py_VISIT(traverse_module_state->__pyx_n_s_RequestDeniedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SCPProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandleError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SSH2Error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SessionError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SessionHandshakeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SessionHostKeyError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SessionStartupError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketDisconnectError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketRecvError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketSendError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketTimeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_UnknownError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ZlibError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_dict);
+  Py_VISIT(traverse_module_state->__pyx_n_s_doc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_metaclass);
+  Py_VISIT(traverse_module_state->__pyx_n_s_module);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mro_entries);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prepare);
+  Py_VISIT(traverse_module_state->__pyx_n_s_qualname);
+  Py_VISIT(traverse_module_state->__pyx_n_s_set_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_super);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  return 0;
+}
 #endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_n_s_ __pyx_mstate_global->__pyx_n_s_
+#define __pyx_n_s_AgentAuthenticationError __pyx_mstate_global->__pyx_n_s_AgentAuthenticationError
+#define __pyx_n_s_AgentConnectionError __pyx_mstate_global->__pyx_n_s_AgentConnectionError
+#define __pyx_n_s_AgentError __pyx_mstate_global->__pyx_n_s_AgentError
+#define __pyx_n_s_AgentGetIdentityError __pyx_mstate_global->__pyx_n_s_AgentGetIdentityError
+#define __pyx_n_s_AgentListIdentitiesError __pyx_mstate_global->__pyx_n_s_AgentListIdentitiesError
+#define __pyx_n_s_AgentProtocolError __pyx_mstate_global->__pyx_n_s_AgentProtocolError
+#define __pyx_n_s_AllocError __pyx_mstate_global->__pyx_n_s_AllocError
+#define __pyx_n_s_AuthenticationError __pyx_mstate_global->__pyx_n_s_AuthenticationError
+#define __pyx_n_s_BadSocketError __pyx_mstate_global->__pyx_n_s_BadSocketError
+#define __pyx_n_s_BadUseError __pyx_mstate_global->__pyx_n_s_BadUseError
+#define __pyx_n_s_BannerRecvError __pyx_mstate_global->__pyx_n_s_BannerRecvError
+#define __pyx_n_s_BannerSendError __pyx_mstate_global->__pyx_n_s_BannerSendError
+#define __pyx_kp_s_Base_class_for_KnownHost_errors __pyx_mstate_global->__pyx_kp_s_Base_class_for_KnownHost_errors
+#define __pyx_kp_s_Base_class_for_SFTP_errors __pyx_mstate_global->__pyx_kp_s_Base_class_for_SFTP_errors
+#define __pyx_kp_s_Base_class_for_all_SSH_Agent_err __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_SSH_Agent_err
+#define __pyx_kp_s_Base_class_for_all_authenticatio __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_authenticatio
+#define __pyx_kp_s_Base_class_for_all_channel_error __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_channel_error
+#define __pyx_kp_s_Base_class_for_all_public_key_pr __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_public_key_pr
+#define __pyx_kp_s_Base_class_for_all_session_error __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_session_error
+#define __pyx_kp_s_Base_class_for_all_ssh2_python_e __pyx_mstate_global->__pyx_kp_s_Base_class_for_all_ssh2_python_e
+#define __pyx_n_s_BufferTooSmallError __pyx_mstate_global->__pyx_n_s_BufferTooSmallError
+#define __pyx_n_s_ChannelClosedError __pyx_mstate_global->__pyx_n_s_ChannelClosedError
+#define __pyx_n_s_ChannelEOFSentError __pyx_mstate_global->__pyx_n_s_ChannelEOFSentError
+#define __pyx_n_s_ChannelError __pyx_mstate_global->__pyx_n_s_ChannelError
+#define __pyx_n_s_ChannelFailure __pyx_mstate_global->__pyx_n_s_ChannelFailure
+#define __pyx_n_s_ChannelOutOfOrderError __pyx_mstate_global->__pyx_n_s_ChannelOutOfOrderError
+#define __pyx_n_s_ChannelPacketExceeded __pyx_mstate_global->__pyx_n_s_ChannelPacketExceeded
+#define __pyx_n_s_ChannelRequestDenied __pyx_mstate_global->__pyx_n_s_ChannelRequestDenied
+#define __pyx_n_s_ChannelUnknownError __pyx_mstate_global->__pyx_n_s_ChannelUnknownError
+#define __pyx_n_s_ChannelWindowExceeded __pyx_mstate_global->__pyx_n_s_ChannelWindowExceeded
+#define __pyx_n_s_ChannelWindowFullError __pyx_mstate_global->__pyx_n_s_ChannelWindowFullError
+#define __pyx_n_s_CompressError __pyx_mstate_global->__pyx_n_s_CompressError
+#define __pyx_n_s_DecryptError __pyx_mstate_global->__pyx_n_s_DecryptError
+#define __pyx_n_s_EncryptError __pyx_mstate_global->__pyx_n_s_EncryptError
+#define __pyx_n_s_FileError __pyx_mstate_global->__pyx_n_s_FileError
+#define __pyx_n_s_HostkeyInitError __pyx_mstate_global->__pyx_n_s_HostkeyInitError
+#define __pyx_n_s_HostkeySignError __pyx_mstate_global->__pyx_n_s_HostkeySignError
+#define __pyx_n_s_InvalidMACError __pyx_mstate_global->__pyx_n_s_InvalidMACError
+#define __pyx_n_s_InvalidPollTypeError __pyx_mstate_global->__pyx_n_s_InvalidPollTypeError
+#define __pyx_n_s_InvalidRequestError __pyx_mstate_global->__pyx_n_s_InvalidRequestError
+#define __pyx_n_s_KexFailureError __pyx_mstate_global->__pyx_n_s_KexFailureError
+#define __pyx_n_s_KeyExchangeError __pyx_mstate_global->__pyx_n_s_KeyExchangeError
+#define __pyx_n_s_KeyfileAuthFailedError __pyx_mstate_global->__pyx_n_s_KeyfileAuthFailedError
+#define __pyx_n_s_KnownHostAddError __pyx_mstate_global->__pyx_n_s_KnownHostAddError
+#define __pyx_n_s_KnownHostCheckError __pyx_mstate_global->__pyx_n_s_KnownHostCheckError
+#define __pyx_n_s_KnownHostCheckFailure __pyx_mstate_global->__pyx_n_s_KnownHostCheckFailure
+#define __pyx_n_s_KnownHostCheckMisMatchError __pyx_mstate_global->__pyx_n_s_KnownHostCheckMisMatchError
+#define __pyx_n_s_KnownHostCheckNotFoundError __pyx_mstate_global->__pyx_n_s_KnownHostCheckNotFoundError
+#define __pyx_n_s_KnownHostDeleteError __pyx_mstate_global->__pyx_n_s_KnownHostDeleteError
+#define __pyx_n_s_KnownHostError __pyx_mstate_global->__pyx_n_s_KnownHostError
+#define __pyx_n_s_KnownHostGetError __pyx_mstate_global->__pyx_n_s_KnownHostGetError
+#define __pyx_n_s_KnownHostReadFileError __pyx_mstate_global->__pyx_n_s_KnownHostReadFileError
+#define __pyx_n_s_KnownHostReadLineError __pyx_mstate_global->__pyx_n_s_KnownHostReadLineError
+#define __pyx_n_s_KnownHostWriteFileError __pyx_mstate_global->__pyx_n_s_KnownHostWriteFileError
+#define __pyx_n_s_KnownHostWriteLineError __pyx_mstate_global->__pyx_n_s_KnownHostWriteLineError
+#define __pyx_n_s_MethodNoneError __pyx_mstate_global->__pyx_n_s_MethodNoneError
+#define __pyx_n_s_MethodNotSupported __pyx_mstate_global->__pyx_n_s_MethodNotSupported
+#define __pyx_n_s_OutOfBoundaryError __pyx_mstate_global->__pyx_n_s_OutOfBoundaryError
+#define __pyx_n_s_PasswordExpiredError __pyx_mstate_global->__pyx_n_s_PasswordExpiredError
+#define __pyx_n_s_ProtocolError __pyx_mstate_global->__pyx_n_s_ProtocolError
+#define __pyx_n_s_PublicKeyError __pyx_mstate_global->__pyx_n_s_PublicKeyError
+#define __pyx_n_s_PublicKeyInitError __pyx_mstate_global->__pyx_n_s_PublicKeyInitError
+#define __pyx_n_s_PublicKeyProtocolError __pyx_mstate_global->__pyx_n_s_PublicKeyProtocolError
+#define __pyx_n_s_PublickeyUnverifiedError __pyx_mstate_global->__pyx_n_s_PublickeyUnverifiedError
+#define __pyx_kp_s_Raised_on_API_bad_use_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_API_bad_use_errors
+#define __pyx_kp_s_Raised_on_KEX_failure __pyx_mstate_global->__pyx_kp_s_Raised_on_KEX_failure
+#define __pyx_kp_s_Raised_on_SCP_protocol_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_SCP_protocol_errors
+#define __pyx_kp_s_Raised_on_SFTP_handle_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_SFTP_handle_errors
+#define __pyx_kp_s_Raised_on_SFTP_protocol_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_SFTP_protocol_errors
+#define __pyx_kp_s_Raised_on_SSH_Agent_authenticati __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_Agent_authenticati
+#define __pyx_kp_s_Raised_on_SSH_Agent_connection_e __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_Agent_connection_e
+#define __pyx_kp_s_Raised_on_SSH_Agent_get_identity __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_Agent_get_identity
+#define __pyx_kp_s_Raised_on_SSH_Agent_list_identit __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_Agent_list_identit
+#define __pyx_kp_s_Raised_on_SSH_agent_protocol_err __pyx_mstate_global->__pyx_kp_s_Raised_on_SSH_agent_protocol_err
+#define __pyx_kp_s_Raised_on_allocation_error __pyx_mstate_global->__pyx_kp_s_Raised_on_allocation_error
+#define __pyx_kp_s_Raised_on_any_known_host_check_e __pyx_mstate_global->__pyx_kp_s_Raised_on_any_known_host_check_e
+#define __pyx_kp_s_Raised_on_authentication_method __pyx_mstate_global->__pyx_kp_s_Raised_on_authentication_method
+#define __pyx_kp_s_Raised_on_buffer_too_small_error __pyx_mstate_global->__pyx_kp_s_Raised_on_buffer_too_small_error
+#define __pyx_kp_s_Raised_on_channel_EOF_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_EOF_errors
+#define __pyx_kp_s_Raised_on_channel_closed_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_closed_errors
+#define __pyx_kp_s_Raised_on_channel_commands_out_o __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_commands_out_o
+#define __pyx_kp_s_Raised_on_channel_failures __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_failures
+#define __pyx_kp_s_Raised_on_channel_max_packet_len __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_max_packet_len
+#define __pyx_kp_s_Raised_on_channel_request_denied __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_request_denied
+#define __pyx_kp_s_Raised_on_channel_window_exceede __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_window_exceede
+#define __pyx_kp_s_Raised_on_channel_window_full_er __pyx_mstate_global->__pyx_kp_s_Raised_on_channel_window_full_er
+#define __pyx_kp_s_Raised_on_compression_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_compression_errors
+#define __pyx_kp_s_Raised_on_decryption_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_decryption_errors
+#define __pyx_kp_s_Raised_on_encryption_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_encryption_errors
+#define __pyx_kp_s_Raised_on_errors_adding_known_ho __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_adding_known_ho
+#define __pyx_kp_s_Raised_on_errors_deleting_known __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_deleting_known
+#define __pyx_kp_s_Raised_on_errors_exchanging_keys __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_exchanging_keys
+#define __pyx_kp_s_Raised_on_errors_getting_server __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_getting_server
+#define __pyx_kp_s_Raised_on_errors_initialiasing_h __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_initialiasing_h
+#define __pyx_kp_s_Raised_on_errors_initialising_pu __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_initialising_pu
+#define __pyx_kp_s_Raised_on_errors_reading_from_kn __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_reading_from_kn
+#define __pyx_kp_s_Raised_on_errors_reading_line_fr __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_reading_line_fr
+#define __pyx_kp_s_Raised_on_errors_receiving_banne __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_receiving_banne
+#define __pyx_kp_s_Raised_on_errors_retrieving_know __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_retrieving_know
+#define __pyx_kp_s_Raised_on_errors_sending_banner __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_sending_banner
+#define __pyx_kp_s_Raised_on_errors_signing_host_ke __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_signing_host_ke
+#define __pyx_kp_s_Raised_on_errors_writing_line_to __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_writing_line_to
+#define __pyx_kp_s_Raised_on_errors_writing_to_know __pyx_mstate_global->__pyx_kp_s_Raised_on_errors_writing_to_know
+#define __pyx_kp_s_Raised_on_file_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_file_errors
+#define __pyx_kp_s_Raised_on_invalid_MAC __pyx_mstate_global->__pyx_kp_s_Raised_on_invalid_MAC
+#define __pyx_kp_s_Raised_on_invalid_method_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_invalid_method_errors
+#define __pyx_kp_s_Raised_on_invalid_poll_type_erro __pyx_mstate_global->__pyx_kp_s_Raised_on_invalid_poll_type_erro
+#define __pyx_kp_s_Raised_on_invalid_request_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_invalid_request_errors
+#define __pyx_kp_s_Raised_on_key_file_authenticatio __pyx_mstate_global->__pyx_kp_s_Raised_on_key_file_authenticatio
+#define __pyx_kp_s_Raised_on_keys_do_not_match_for __pyx_mstate_global->__pyx_kp_s_Raised_on_keys_do_not_match_for
+#define __pyx_kp_s_Raised_on_no_match_for_known_hos __pyx_mstate_global->__pyx_kp_s_Raised_on_no_match_for_known_hos
+#define __pyx_kp_s_Raised_on_non_specific_or_unknow __pyx_mstate_global->__pyx_kp_s_Raised_on_non_specific_or_unknow
+#define __pyx_kp_s_Raised_on_out_of_boundary_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_out_of_boundary_errors
+#define __pyx_kp_s_Raised_on_password_expired_error __pyx_mstate_global->__pyx_kp_s_Raised_on_password_expired_error
+#define __pyx_kp_s_Raised_on_protocol_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_protocol_errors
+#define __pyx_kp_s_Raised_on_public_key_protocol_er __pyx_mstate_global->__pyx_kp_s_Raised_on_public_key_protocol_er
+#define __pyx_kp_s_Raised_on_public_key_verificatio __pyx_mstate_global->__pyx_kp_s_Raised_on_public_key_verificatio
+#define __pyx_kp_s_Raised_on_request_denied_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_request_denied_errors
+#define __pyx_kp_s_Raised_on_session_handshake_erro __pyx_mstate_global->__pyx_kp_s_Raised_on_session_handshake_erro
+#define __pyx_kp_s_Raised_on_session_startup_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_session_startup_errors
+#define __pyx_kp_s_Raised_on_socket_disconnection_e __pyx_mstate_global->__pyx_kp_s_Raised_on_socket_disconnection_e
+#define __pyx_kp_s_Raised_on_socket_receive_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_socket_receive_errors
+#define __pyx_kp_s_Raised_on_socket_send_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_socket_send_errors
+#define __pyx_kp_s_Raised_on_socket_timeouts __pyx_mstate_global->__pyx_kp_s_Raised_on_socket_timeouts
+#define __pyx_kp_s_Raised_on_something_preventing_k __pyx_mstate_global->__pyx_kp_s_Raised_on_something_preventing_k
+#define __pyx_kp_s_Raised_on_timeouts __pyx_mstate_global->__pyx_kp_s_Raised_on_timeouts
+#define __pyx_kp_s_Raised_on_unknown_channel_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_unknown_channel_errors
+#define __pyx_kp_s_Raised_on_use_of_bad_socket_erro __pyx_mstate_global->__pyx_kp_s_Raised_on_use_of_bad_socket_erro
+#define __pyx_kp_s_Raised_on_zlib_errors __pyx_mstate_global->__pyx_kp_s_Raised_on_zlib_errors
+#define __pyx_n_s_RequestDeniedError __pyx_mstate_global->__pyx_n_s_RequestDeniedError
+#define __pyx_n_s_SCPProtocolError __pyx_mstate_global->__pyx_n_s_SCPProtocolError
+#define __pyx_n_s_SFTPError __pyx_mstate_global->__pyx_n_s_SFTPError
+#define __pyx_n_s_SFTPHandleError __pyx_mstate_global->__pyx_n_s_SFTPHandleError
+#define __pyx_n_s_SFTPProtocolError __pyx_mstate_global->__pyx_n_s_SFTPProtocolError
+#define __pyx_n_s_SSH2Error __pyx_mstate_global->__pyx_n_s_SSH2Error
+#define __pyx_n_s_SessionError __pyx_mstate_global->__pyx_n_s_SessionError
+#define __pyx_n_s_SessionHandshakeError __pyx_mstate_global->__pyx_n_s_SessionHandshakeError
+#define __pyx_n_s_SessionHostKeyError __pyx_mstate_global->__pyx_n_s_SessionHostKeyError
+#define __pyx_n_s_SessionStartupError __pyx_mstate_global->__pyx_n_s_SessionStartupError
+#define __pyx_n_s_SocketDisconnectError __pyx_mstate_global->__pyx_n_s_SocketDisconnectError
+#define __pyx_n_s_SocketRecvError __pyx_mstate_global->__pyx_n_s_SocketRecvError
+#define __pyx_n_s_SocketSendError __pyx_mstate_global->__pyx_n_s_SocketSendError
+#define __pyx_n_s_SocketTimeout __pyx_mstate_global->__pyx_n_s_SocketTimeout
+#define __pyx_n_s_Timeout __pyx_mstate_global->__pyx_n_s_Timeout
+#define __pyx_n_s_UnknownError __pyx_mstate_global->__pyx_n_s_UnknownError
+#define __pyx_n_s_ZlibError __pyx_mstate_global->__pyx_n_s_ZlibError
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict
+#define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc
+#define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass
+#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module
+#define __pyx_n_s_mro_entries __pyx_mstate_global->__pyx_n_s_mro_entries
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare
+#define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname
+#define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name
+#define __pyx_n_s_ssh2_exceptions __pyx_mstate_global->__pyx_n_s_ssh2_exceptions
+#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+/* #### Code section: module_code ### */
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -1545,169 +2811,181 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_AgentAuthenticationError, __pyx_k_AgentAuthenticationError, sizeof(__pyx_k_AgentAuthenticationError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentConnectionError, __pyx_k_AgentConnectionError, sizeof(__pyx_k_AgentConnectionError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentError, __pyx_k_AgentError, sizeof(__pyx_k_AgentError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentGetIdentityError, __pyx_k_AgentGetIdentityError, sizeof(__pyx_k_AgentGetIdentityError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentListIdentitiesError, __pyx_k_AgentListIdentitiesError, sizeof(__pyx_k_AgentListIdentitiesError), 0, 0, 1, 1},
-  {&__pyx_n_s_AgentProtocolError, __pyx_k_AgentProtocolError, sizeof(__pyx_k_AgentProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_AllocError, __pyx_k_AllocError, sizeof(__pyx_k_AllocError), 0, 0, 1, 1},
-  {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1},
-  {&__pyx_n_s_BadSocketError, __pyx_k_BadSocketError, sizeof(__pyx_k_BadSocketError), 0, 0, 1, 1},
-  {&__pyx_n_s_BadUseError, __pyx_k_BadUseError, sizeof(__pyx_k_BadUseError), 0, 0, 1, 1},
-  {&__pyx_n_s_BannerRecvError, __pyx_k_BannerRecvError, sizeof(__pyx_k_BannerRecvError), 0, 0, 1, 1},
-  {&__pyx_n_s_BannerSendError, __pyx_k_BannerSendError, sizeof(__pyx_k_BannerSendError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Base_class_for_KnownHost_errors, __pyx_k_Base_class_for_KnownHost_errors, sizeof(__pyx_k_Base_class_for_KnownHost_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_SFTP_errors, __pyx_k_Base_class_for_SFTP_errors, sizeof(__pyx_k_Base_class_for_SFTP_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_SSH_Agent_err, __pyx_k_Base_class_for_all_SSH_Agent_err, sizeof(__pyx_k_Base_class_for_all_SSH_Agent_err), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_authenticatio, __pyx_k_Base_class_for_all_authenticatio, sizeof(__pyx_k_Base_class_for_all_authenticatio), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_channel_error, __pyx_k_Base_class_for_all_channel_error, sizeof(__pyx_k_Base_class_for_all_channel_error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_public_key_pr, __pyx_k_Base_class_for_all_public_key_pr, sizeof(__pyx_k_Base_class_for_all_public_key_pr), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_session_error, __pyx_k_Base_class_for_all_session_error, sizeof(__pyx_k_Base_class_for_all_session_error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Base_class_for_all_ssh2_python_e, __pyx_k_Base_class_for_all_ssh2_python_e, sizeof(__pyx_k_Base_class_for_all_ssh2_python_e), 0, 0, 1, 0},
-  {&__pyx_n_s_BufferTooSmallError, __pyx_k_BufferTooSmallError, sizeof(__pyx_k_BufferTooSmallError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelClosedError, __pyx_k_ChannelClosedError, sizeof(__pyx_k_ChannelClosedError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelEOFSentError, __pyx_k_ChannelEOFSentError, sizeof(__pyx_k_ChannelEOFSentError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelFailure, __pyx_k_ChannelFailure, sizeof(__pyx_k_ChannelFailure), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelOutOfOrderError, __pyx_k_ChannelOutOfOrderError, sizeof(__pyx_k_ChannelOutOfOrderError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelPacketExceeded, __pyx_k_ChannelPacketExceeded, sizeof(__pyx_k_ChannelPacketExceeded), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelRequestDenied, __pyx_k_ChannelRequestDenied, sizeof(__pyx_k_ChannelRequestDenied), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelUnknownError, __pyx_k_ChannelUnknownError, sizeof(__pyx_k_ChannelUnknownError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelWindowExceeded, __pyx_k_ChannelWindowExceeded, sizeof(__pyx_k_ChannelWindowExceeded), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelWindowFullError, __pyx_k_ChannelWindowFullError, sizeof(__pyx_k_ChannelWindowFullError), 0, 0, 1, 1},
-  {&__pyx_n_s_CompressError, __pyx_k_CompressError, sizeof(__pyx_k_CompressError), 0, 0, 1, 1},
-  {&__pyx_n_s_DecryptError, __pyx_k_DecryptError, sizeof(__pyx_k_DecryptError), 0, 0, 1, 1},
-  {&__pyx_n_s_EncryptError, __pyx_k_EncryptError, sizeof(__pyx_k_EncryptError), 0, 0, 1, 1},
-  {&__pyx_n_s_FileError, __pyx_k_FileError, sizeof(__pyx_k_FileError), 0, 0, 1, 1},
-  {&__pyx_n_s_HostkeyInitError, __pyx_k_HostkeyInitError, sizeof(__pyx_k_HostkeyInitError), 0, 0, 1, 1},
-  {&__pyx_n_s_HostkeySignError, __pyx_k_HostkeySignError, sizeof(__pyx_k_HostkeySignError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidMACError, __pyx_k_InvalidMACError, sizeof(__pyx_k_InvalidMACError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidPollTypeError, __pyx_k_InvalidPollTypeError, sizeof(__pyx_k_InvalidPollTypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidRequestError, __pyx_k_InvalidRequestError, sizeof(__pyx_k_InvalidRequestError), 0, 0, 1, 1},
-  {&__pyx_n_s_KexFailureError, __pyx_k_KexFailureError, sizeof(__pyx_k_KexFailureError), 0, 0, 1, 1},
-  {&__pyx_n_s_KeyExchangeError, __pyx_k_KeyExchangeError, sizeof(__pyx_k_KeyExchangeError), 0, 0, 1, 1},
-  {&__pyx_n_s_KeyfileAuthFailedError, __pyx_k_KeyfileAuthFailedError, sizeof(__pyx_k_KeyfileAuthFailedError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostAddError, __pyx_k_KnownHostAddError, sizeof(__pyx_k_KnownHostAddError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckError, __pyx_k_KnownHostCheckError, sizeof(__pyx_k_KnownHostCheckError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckFailure, __pyx_k_KnownHostCheckFailure, sizeof(__pyx_k_KnownHostCheckFailure), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckMisMatchError, __pyx_k_KnownHostCheckMisMatchError, sizeof(__pyx_k_KnownHostCheckMisMatchError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckNotFoundError, __pyx_k_KnownHostCheckNotFoundError, sizeof(__pyx_k_KnownHostCheckNotFoundError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostDeleteError, __pyx_k_KnownHostDeleteError, sizeof(__pyx_k_KnownHostDeleteError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostGetError, __pyx_k_KnownHostGetError, sizeof(__pyx_k_KnownHostGetError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostReadFileError, __pyx_k_KnownHostReadFileError, sizeof(__pyx_k_KnownHostReadFileError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostReadLineError, __pyx_k_KnownHostReadLineError, sizeof(__pyx_k_KnownHostReadLineError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostWriteFileError, __pyx_k_KnownHostWriteFileError, sizeof(__pyx_k_KnownHostWriteFileError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostWriteLineError, __pyx_k_KnownHostWriteLineError, sizeof(__pyx_k_KnownHostWriteLineError), 0, 0, 1, 1},
-  {&__pyx_n_s_MethodNoneError, __pyx_k_MethodNoneError, sizeof(__pyx_k_MethodNoneError), 0, 0, 1, 1},
-  {&__pyx_n_s_MethodNotSupported, __pyx_k_MethodNotSupported, sizeof(__pyx_k_MethodNotSupported), 0, 0, 1, 1},
-  {&__pyx_n_s_OutOfBoundaryError, __pyx_k_OutOfBoundaryError, sizeof(__pyx_k_OutOfBoundaryError), 0, 0, 1, 1},
-  {&__pyx_n_s_PasswordExpiredError, __pyx_k_PasswordExpiredError, sizeof(__pyx_k_PasswordExpiredError), 0, 0, 1, 1},
-  {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyError, __pyx_k_PublicKeyError, sizeof(__pyx_k_PublicKeyError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyInitError, __pyx_k_PublicKeyInitError, sizeof(__pyx_k_PublicKeyInitError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyProtocolError, __pyx_k_PublicKeyProtocolError, sizeof(__pyx_k_PublicKeyProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublickeyUnverifiedError, __pyx_k_PublickeyUnverifiedError, sizeof(__pyx_k_PublickeyUnverifiedError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Raised_on_API_bad_use_errors, __pyx_k_Raised_on_API_bad_use_errors, sizeof(__pyx_k_Raised_on_API_bad_use_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_KEX_failure, __pyx_k_Raised_on_KEX_failure, sizeof(__pyx_k_Raised_on_KEX_failure), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SCP_protocol_errors, __pyx_k_Raised_on_SCP_protocol_errors, sizeof(__pyx_k_Raised_on_SCP_protocol_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SFTP_handle_errors, __pyx_k_Raised_on_SFTP_handle_errors, sizeof(__pyx_k_Raised_on_SFTP_handle_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SFTP_protocol_errors, __pyx_k_Raised_on_SFTP_protocol_errors, sizeof(__pyx_k_Raised_on_SFTP_protocol_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SSH_Agent_authenticati, __pyx_k_Raised_on_SSH_Agent_authenticati, sizeof(__pyx_k_Raised_on_SSH_Agent_authenticati), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SSH_Agent_connection_e, __pyx_k_Raised_on_SSH_Agent_connection_e, sizeof(__pyx_k_Raised_on_SSH_Agent_connection_e), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SSH_Agent_get_identity, __pyx_k_Raised_on_SSH_Agent_get_identity, sizeof(__pyx_k_Raised_on_SSH_Agent_get_identity), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SSH_Agent_list_identit, __pyx_k_Raised_on_SSH_Agent_list_identit, sizeof(__pyx_k_Raised_on_SSH_Agent_list_identit), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_SSH_agent_protocol_err, __pyx_k_Raised_on_SSH_agent_protocol_err, sizeof(__pyx_k_Raised_on_SSH_agent_protocol_err), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_allocation_error, __pyx_k_Raised_on_allocation_error, sizeof(__pyx_k_Raised_on_allocation_error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_any_known_host_check_e, __pyx_k_Raised_on_any_known_host_check_e, sizeof(__pyx_k_Raised_on_any_known_host_check_e), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_authentication_method, __pyx_k_Raised_on_authentication_method, sizeof(__pyx_k_Raised_on_authentication_method), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_buffer_too_small_error, __pyx_k_Raised_on_buffer_too_small_error, sizeof(__pyx_k_Raised_on_buffer_too_small_error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_EOF_errors, __pyx_k_Raised_on_channel_EOF_errors, sizeof(__pyx_k_Raised_on_channel_EOF_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_closed_errors, __pyx_k_Raised_on_channel_closed_errors, sizeof(__pyx_k_Raised_on_channel_closed_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_commands_out_o, __pyx_k_Raised_on_channel_commands_out_o, sizeof(__pyx_k_Raised_on_channel_commands_out_o), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_failures, __pyx_k_Raised_on_channel_failures, sizeof(__pyx_k_Raised_on_channel_failures), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_max_packet_len, __pyx_k_Raised_on_channel_max_packet_len, sizeof(__pyx_k_Raised_on_channel_max_packet_len), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_request_denied, __pyx_k_Raised_on_channel_request_denied, sizeof(__pyx_k_Raised_on_channel_request_denied), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_window_exceede, __pyx_k_Raised_on_channel_window_exceede, sizeof(__pyx_k_Raised_on_channel_window_exceede), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_channel_window_full_er, __pyx_k_Raised_on_channel_window_full_er, sizeof(__pyx_k_Raised_on_channel_window_full_er), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_compression_errors, __pyx_k_Raised_on_compression_errors, sizeof(__pyx_k_Raised_on_compression_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_decryption_errors, __pyx_k_Raised_on_decryption_errors, sizeof(__pyx_k_Raised_on_decryption_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_encryption_errors, __pyx_k_Raised_on_encryption_errors, sizeof(__pyx_k_Raised_on_encryption_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_adding_known_ho, __pyx_k_Raised_on_errors_adding_known_ho, sizeof(__pyx_k_Raised_on_errors_adding_known_ho), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_deleting_known, __pyx_k_Raised_on_errors_deleting_known, sizeof(__pyx_k_Raised_on_errors_deleting_known), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_exchanging_keys, __pyx_k_Raised_on_errors_exchanging_keys, sizeof(__pyx_k_Raised_on_errors_exchanging_keys), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_getting_server, __pyx_k_Raised_on_errors_getting_server, sizeof(__pyx_k_Raised_on_errors_getting_server), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_initialiasing_h, __pyx_k_Raised_on_errors_initialiasing_h, sizeof(__pyx_k_Raised_on_errors_initialiasing_h), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_initialising_pu, __pyx_k_Raised_on_errors_initialising_pu, sizeof(__pyx_k_Raised_on_errors_initialising_pu), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_reading_from_kn, __pyx_k_Raised_on_errors_reading_from_kn, sizeof(__pyx_k_Raised_on_errors_reading_from_kn), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_reading_line_fr, __pyx_k_Raised_on_errors_reading_line_fr, sizeof(__pyx_k_Raised_on_errors_reading_line_fr), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_receiving_banne, __pyx_k_Raised_on_errors_receiving_banne, sizeof(__pyx_k_Raised_on_errors_receiving_banne), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_retrieving_know, __pyx_k_Raised_on_errors_retrieving_know, sizeof(__pyx_k_Raised_on_errors_retrieving_know), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_sending_banner, __pyx_k_Raised_on_errors_sending_banner, sizeof(__pyx_k_Raised_on_errors_sending_banner), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_signing_host_ke, __pyx_k_Raised_on_errors_signing_host_ke, sizeof(__pyx_k_Raised_on_errors_signing_host_ke), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_writing_line_to, __pyx_k_Raised_on_errors_writing_line_to, sizeof(__pyx_k_Raised_on_errors_writing_line_to), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_errors_writing_to_know, __pyx_k_Raised_on_errors_writing_to_know, sizeof(__pyx_k_Raised_on_errors_writing_to_know), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_file_errors, __pyx_k_Raised_on_file_errors, sizeof(__pyx_k_Raised_on_file_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_invalid_MAC, __pyx_k_Raised_on_invalid_MAC, sizeof(__pyx_k_Raised_on_invalid_MAC), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_invalid_method_errors, __pyx_k_Raised_on_invalid_method_errors, sizeof(__pyx_k_Raised_on_invalid_method_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_invalid_poll_type_erro, __pyx_k_Raised_on_invalid_poll_type_erro, sizeof(__pyx_k_Raised_on_invalid_poll_type_erro), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_invalid_request_errors, __pyx_k_Raised_on_invalid_request_errors, sizeof(__pyx_k_Raised_on_invalid_request_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_key_file_authenticatio, __pyx_k_Raised_on_key_file_authenticatio, sizeof(__pyx_k_Raised_on_key_file_authenticatio), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_keys_do_not_match_for, __pyx_k_Raised_on_keys_do_not_match_for, sizeof(__pyx_k_Raised_on_keys_do_not_match_for), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_no_match_for_known_hos, __pyx_k_Raised_on_no_match_for_known_hos, sizeof(__pyx_k_Raised_on_no_match_for_known_hos), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_non_specific_or_unknow, __pyx_k_Raised_on_non_specific_or_unknow, sizeof(__pyx_k_Raised_on_non_specific_or_unknow), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_out_of_boundary_errors, __pyx_k_Raised_on_out_of_boundary_errors, sizeof(__pyx_k_Raised_on_out_of_boundary_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_password_expired_error, __pyx_k_Raised_on_password_expired_error, sizeof(__pyx_k_Raised_on_password_expired_error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_protocol_errors, __pyx_k_Raised_on_protocol_errors, sizeof(__pyx_k_Raised_on_protocol_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_public_key_protocol_er, __pyx_k_Raised_on_public_key_protocol_er, sizeof(__pyx_k_Raised_on_public_key_protocol_er), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_public_key_verificatio, __pyx_k_Raised_on_public_key_verificatio, sizeof(__pyx_k_Raised_on_public_key_verificatio), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_request_denied_errors, __pyx_k_Raised_on_request_denied_errors, sizeof(__pyx_k_Raised_on_request_denied_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_session_handshake_erro, __pyx_k_Raised_on_session_handshake_erro, sizeof(__pyx_k_Raised_on_session_handshake_erro), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_session_startup_errors, __pyx_k_Raised_on_session_startup_errors, sizeof(__pyx_k_Raised_on_session_startup_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_socket_disconnection_e, __pyx_k_Raised_on_socket_disconnection_e, sizeof(__pyx_k_Raised_on_socket_disconnection_e), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_socket_receive_errors, __pyx_k_Raised_on_socket_receive_errors, sizeof(__pyx_k_Raised_on_socket_receive_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_socket_send_errors, __pyx_k_Raised_on_socket_send_errors, sizeof(__pyx_k_Raised_on_socket_send_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_socket_timeouts, __pyx_k_Raised_on_socket_timeouts, sizeof(__pyx_k_Raised_on_socket_timeouts), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_something_preventing_k, __pyx_k_Raised_on_something_preventing_k, sizeof(__pyx_k_Raised_on_something_preventing_k), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_timeouts, __pyx_k_Raised_on_timeouts, sizeof(__pyx_k_Raised_on_timeouts), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_unknown_channel_errors, __pyx_k_Raised_on_unknown_channel_errors, sizeof(__pyx_k_Raised_on_unknown_channel_errors), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_use_of_bad_socket_erro, __pyx_k_Raised_on_use_of_bad_socket_erro, sizeof(__pyx_k_Raised_on_use_of_bad_socket_erro), 0, 0, 1, 0},
-  {&__pyx_kp_s_Raised_on_zlib_errors, __pyx_k_Raised_on_zlib_errors, sizeof(__pyx_k_Raised_on_zlib_errors), 0, 0, 1, 0},
-  {&__pyx_n_s_RequestDeniedError, __pyx_k_RequestDeniedError, sizeof(__pyx_k_RequestDeniedError), 0, 0, 1, 1},
-  {&__pyx_n_s_SCPProtocolError, __pyx_k_SCPProtocolError, sizeof(__pyx_k_SCPProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPError, __pyx_k_SFTPError, sizeof(__pyx_k_SFTPError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPHandleError, __pyx_k_SFTPHandleError, sizeof(__pyx_k_SFTPHandleError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPProtocolError, __pyx_k_SFTPProtocolError, sizeof(__pyx_k_SFTPProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_SSH2Error, __pyx_k_SSH2Error, sizeof(__pyx_k_SSH2Error), 0, 0, 1, 1},
-  {&__pyx_n_s_SessionError, __pyx_k_SessionError, sizeof(__pyx_k_SessionError), 0, 0, 1, 1},
-  {&__pyx_n_s_SessionHandshakeError, __pyx_k_SessionHandshakeError, sizeof(__pyx_k_SessionHandshakeError), 0, 0, 1, 1},
-  {&__pyx_n_s_SessionHostKeyError, __pyx_k_SessionHostKeyError, sizeof(__pyx_k_SessionHostKeyError), 0, 0, 1, 1},
-  {&__pyx_n_s_SessionStartupError, __pyx_k_SessionStartupError, sizeof(__pyx_k_SessionStartupError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketDisconnectError, __pyx_k_SocketDisconnectError, sizeof(__pyx_k_SocketDisconnectError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketRecvError, __pyx_k_SocketRecvError, sizeof(__pyx_k_SocketRecvError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketSendError, __pyx_k_SocketSendError, sizeof(__pyx_k_SocketSendError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketTimeout, __pyx_k_SocketTimeout, sizeof(__pyx_k_SocketTimeout), 0, 0, 1, 1},
-  {&__pyx_n_s_Timeout, __pyx_k_Timeout, sizeof(__pyx_k_Timeout), 0, 0, 1, 1},
-  {&__pyx_n_s_UnknownError, __pyx_k_UnknownError, sizeof(__pyx_k_UnknownError), 0, 0, 1, 1},
-  {&__pyx_n_s_ZlibError, __pyx_k_ZlibError, sizeof(__pyx_k_ZlibError), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},
-  {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
-  {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
-  {&__pyx_n_s_ssh2_exceptions, __pyx_k_ssh2_exceptions, sizeof(__pyx_k_ssh2_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentAuthenticationError, __pyx_k_AgentAuthenticationError, sizeof(__pyx_k_AgentAuthenticationError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentConnectionError, __pyx_k_AgentConnectionError, sizeof(__pyx_k_AgentConnectionError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentError, __pyx_k_AgentError, sizeof(__pyx_k_AgentError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentGetIdentityError, __pyx_k_AgentGetIdentityError, sizeof(__pyx_k_AgentGetIdentityError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentListIdentitiesError, __pyx_k_AgentListIdentitiesError, sizeof(__pyx_k_AgentListIdentitiesError), 0, 0, 1, 1},
+    {&__pyx_n_s_AgentProtocolError, __pyx_k_AgentProtocolError, sizeof(__pyx_k_AgentProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_AllocError, __pyx_k_AllocError, sizeof(__pyx_k_AllocError), 0, 0, 1, 1},
+    {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1},
+    {&__pyx_n_s_BadSocketError, __pyx_k_BadSocketError, sizeof(__pyx_k_BadSocketError), 0, 0, 1, 1},
+    {&__pyx_n_s_BadUseError, __pyx_k_BadUseError, sizeof(__pyx_k_BadUseError), 0, 0, 1, 1},
+    {&__pyx_n_s_BannerRecvError, __pyx_k_BannerRecvError, sizeof(__pyx_k_BannerRecvError), 0, 0, 1, 1},
+    {&__pyx_n_s_BannerSendError, __pyx_k_BannerSendError, sizeof(__pyx_k_BannerSendError), 0, 0, 1, 1},
+    {&__pyx_kp_s_Base_class_for_KnownHost_errors, __pyx_k_Base_class_for_KnownHost_errors, sizeof(__pyx_k_Base_class_for_KnownHost_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_SFTP_errors, __pyx_k_Base_class_for_SFTP_errors, sizeof(__pyx_k_Base_class_for_SFTP_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_SSH_Agent_err, __pyx_k_Base_class_for_all_SSH_Agent_err, sizeof(__pyx_k_Base_class_for_all_SSH_Agent_err), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_authenticatio, __pyx_k_Base_class_for_all_authenticatio, sizeof(__pyx_k_Base_class_for_all_authenticatio), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_channel_error, __pyx_k_Base_class_for_all_channel_error, sizeof(__pyx_k_Base_class_for_all_channel_error), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_public_key_pr, __pyx_k_Base_class_for_all_public_key_pr, sizeof(__pyx_k_Base_class_for_all_public_key_pr), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_session_error, __pyx_k_Base_class_for_all_session_error, sizeof(__pyx_k_Base_class_for_all_session_error), 0, 0, 1, 0},
+    {&__pyx_kp_s_Base_class_for_all_ssh2_python_e, __pyx_k_Base_class_for_all_ssh2_python_e, sizeof(__pyx_k_Base_class_for_all_ssh2_python_e), 0, 0, 1, 0},
+    {&__pyx_n_s_BufferTooSmallError, __pyx_k_BufferTooSmallError, sizeof(__pyx_k_BufferTooSmallError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelClosedError, __pyx_k_ChannelClosedError, sizeof(__pyx_k_ChannelClosedError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelEOFSentError, __pyx_k_ChannelEOFSentError, sizeof(__pyx_k_ChannelEOFSentError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelFailure, __pyx_k_ChannelFailure, sizeof(__pyx_k_ChannelFailure), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelOutOfOrderError, __pyx_k_ChannelOutOfOrderError, sizeof(__pyx_k_ChannelOutOfOrderError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelPacketExceeded, __pyx_k_ChannelPacketExceeded, sizeof(__pyx_k_ChannelPacketExceeded), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelRequestDenied, __pyx_k_ChannelRequestDenied, sizeof(__pyx_k_ChannelRequestDenied), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelUnknownError, __pyx_k_ChannelUnknownError, sizeof(__pyx_k_ChannelUnknownError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelWindowExceeded, __pyx_k_ChannelWindowExceeded, sizeof(__pyx_k_ChannelWindowExceeded), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelWindowFullError, __pyx_k_ChannelWindowFullError, sizeof(__pyx_k_ChannelWindowFullError), 0, 0, 1, 1},
+    {&__pyx_n_s_CompressError, __pyx_k_CompressError, sizeof(__pyx_k_CompressError), 0, 0, 1, 1},
+    {&__pyx_n_s_DecryptError, __pyx_k_DecryptError, sizeof(__pyx_k_DecryptError), 0, 0, 1, 1},
+    {&__pyx_n_s_EncryptError, __pyx_k_EncryptError, sizeof(__pyx_k_EncryptError), 0, 0, 1, 1},
+    {&__pyx_n_s_FileError, __pyx_k_FileError, sizeof(__pyx_k_FileError), 0, 0, 1, 1},
+    {&__pyx_n_s_HostkeyInitError, __pyx_k_HostkeyInitError, sizeof(__pyx_k_HostkeyInitError), 0, 0, 1, 1},
+    {&__pyx_n_s_HostkeySignError, __pyx_k_HostkeySignError, sizeof(__pyx_k_HostkeySignError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidMACError, __pyx_k_InvalidMACError, sizeof(__pyx_k_InvalidMACError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidPollTypeError, __pyx_k_InvalidPollTypeError, sizeof(__pyx_k_InvalidPollTypeError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidRequestError, __pyx_k_InvalidRequestError, sizeof(__pyx_k_InvalidRequestError), 0, 0, 1, 1},
+    {&__pyx_n_s_KexFailureError, __pyx_k_KexFailureError, sizeof(__pyx_k_KexFailureError), 0, 0, 1, 1},
+    {&__pyx_n_s_KeyExchangeError, __pyx_k_KeyExchangeError, sizeof(__pyx_k_KeyExchangeError), 0, 0, 1, 1},
+    {&__pyx_n_s_KeyfileAuthFailedError, __pyx_k_KeyfileAuthFailedError, sizeof(__pyx_k_KeyfileAuthFailedError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostAddError, __pyx_k_KnownHostAddError, sizeof(__pyx_k_KnownHostAddError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckError, __pyx_k_KnownHostCheckError, sizeof(__pyx_k_KnownHostCheckError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckFailure, __pyx_k_KnownHostCheckFailure, sizeof(__pyx_k_KnownHostCheckFailure), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckMisMatchError, __pyx_k_KnownHostCheckMisMatchError, sizeof(__pyx_k_KnownHostCheckMisMatchError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckNotFoundError, __pyx_k_KnownHostCheckNotFoundError, sizeof(__pyx_k_KnownHostCheckNotFoundError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostDeleteError, __pyx_k_KnownHostDeleteError, sizeof(__pyx_k_KnownHostDeleteError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostGetError, __pyx_k_KnownHostGetError, sizeof(__pyx_k_KnownHostGetError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostReadFileError, __pyx_k_KnownHostReadFileError, sizeof(__pyx_k_KnownHostReadFileError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostReadLineError, __pyx_k_KnownHostReadLineError, sizeof(__pyx_k_KnownHostReadLineError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostWriteFileError, __pyx_k_KnownHostWriteFileError, sizeof(__pyx_k_KnownHostWriteFileError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostWriteLineError, __pyx_k_KnownHostWriteLineError, sizeof(__pyx_k_KnownHostWriteLineError), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodNoneError, __pyx_k_MethodNoneError, sizeof(__pyx_k_MethodNoneError), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodNotSupported, __pyx_k_MethodNotSupported, sizeof(__pyx_k_MethodNotSupported), 0, 0, 1, 1},
+    {&__pyx_n_s_OutOfBoundaryError, __pyx_k_OutOfBoundaryError, sizeof(__pyx_k_OutOfBoundaryError), 0, 0, 1, 1},
+    {&__pyx_n_s_PasswordExpiredError, __pyx_k_PasswordExpiredError, sizeof(__pyx_k_PasswordExpiredError), 0, 0, 1, 1},
+    {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyError, __pyx_k_PublicKeyError, sizeof(__pyx_k_PublicKeyError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyInitError, __pyx_k_PublicKeyInitError, sizeof(__pyx_k_PublicKeyInitError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyProtocolError, __pyx_k_PublicKeyProtocolError, sizeof(__pyx_k_PublicKeyProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublickeyUnverifiedError, __pyx_k_PublickeyUnverifiedError, sizeof(__pyx_k_PublickeyUnverifiedError), 0, 0, 1, 1},
+    {&__pyx_kp_s_Raised_on_API_bad_use_errors, __pyx_k_Raised_on_API_bad_use_errors, sizeof(__pyx_k_Raised_on_API_bad_use_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_KEX_failure, __pyx_k_Raised_on_KEX_failure, sizeof(__pyx_k_Raised_on_KEX_failure), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SCP_protocol_errors, __pyx_k_Raised_on_SCP_protocol_errors, sizeof(__pyx_k_Raised_on_SCP_protocol_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SFTP_handle_errors, __pyx_k_Raised_on_SFTP_handle_errors, sizeof(__pyx_k_Raised_on_SFTP_handle_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SFTP_protocol_errors, __pyx_k_Raised_on_SFTP_protocol_errors, sizeof(__pyx_k_Raised_on_SFTP_protocol_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SSH_Agent_authenticati, __pyx_k_Raised_on_SSH_Agent_authenticati, sizeof(__pyx_k_Raised_on_SSH_Agent_authenticati), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SSH_Agent_connection_e, __pyx_k_Raised_on_SSH_Agent_connection_e, sizeof(__pyx_k_Raised_on_SSH_Agent_connection_e), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SSH_Agent_get_identity, __pyx_k_Raised_on_SSH_Agent_get_identity, sizeof(__pyx_k_Raised_on_SSH_Agent_get_identity), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SSH_Agent_list_identit, __pyx_k_Raised_on_SSH_Agent_list_identit, sizeof(__pyx_k_Raised_on_SSH_Agent_list_identit), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_SSH_agent_protocol_err, __pyx_k_Raised_on_SSH_agent_protocol_err, sizeof(__pyx_k_Raised_on_SSH_agent_protocol_err), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_allocation_error, __pyx_k_Raised_on_allocation_error, sizeof(__pyx_k_Raised_on_allocation_error), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_any_known_host_check_e, __pyx_k_Raised_on_any_known_host_check_e, sizeof(__pyx_k_Raised_on_any_known_host_check_e), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_authentication_method, __pyx_k_Raised_on_authentication_method, sizeof(__pyx_k_Raised_on_authentication_method), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_buffer_too_small_error, __pyx_k_Raised_on_buffer_too_small_error, sizeof(__pyx_k_Raised_on_buffer_too_small_error), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_EOF_errors, __pyx_k_Raised_on_channel_EOF_errors, sizeof(__pyx_k_Raised_on_channel_EOF_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_closed_errors, __pyx_k_Raised_on_channel_closed_errors, sizeof(__pyx_k_Raised_on_channel_closed_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_commands_out_o, __pyx_k_Raised_on_channel_commands_out_o, sizeof(__pyx_k_Raised_on_channel_commands_out_o), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_failures, __pyx_k_Raised_on_channel_failures, sizeof(__pyx_k_Raised_on_channel_failures), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_max_packet_len, __pyx_k_Raised_on_channel_max_packet_len, sizeof(__pyx_k_Raised_on_channel_max_packet_len), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_request_denied, __pyx_k_Raised_on_channel_request_denied, sizeof(__pyx_k_Raised_on_channel_request_denied), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_window_exceede, __pyx_k_Raised_on_channel_window_exceede, sizeof(__pyx_k_Raised_on_channel_window_exceede), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_channel_window_full_er, __pyx_k_Raised_on_channel_window_full_er, sizeof(__pyx_k_Raised_on_channel_window_full_er), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_compression_errors, __pyx_k_Raised_on_compression_errors, sizeof(__pyx_k_Raised_on_compression_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_decryption_errors, __pyx_k_Raised_on_decryption_errors, sizeof(__pyx_k_Raised_on_decryption_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_encryption_errors, __pyx_k_Raised_on_encryption_errors, sizeof(__pyx_k_Raised_on_encryption_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_adding_known_ho, __pyx_k_Raised_on_errors_adding_known_ho, sizeof(__pyx_k_Raised_on_errors_adding_known_ho), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_deleting_known, __pyx_k_Raised_on_errors_deleting_known, sizeof(__pyx_k_Raised_on_errors_deleting_known), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_exchanging_keys, __pyx_k_Raised_on_errors_exchanging_keys, sizeof(__pyx_k_Raised_on_errors_exchanging_keys), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_getting_server, __pyx_k_Raised_on_errors_getting_server, sizeof(__pyx_k_Raised_on_errors_getting_server), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_initialiasing_h, __pyx_k_Raised_on_errors_initialiasing_h, sizeof(__pyx_k_Raised_on_errors_initialiasing_h), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_initialising_pu, __pyx_k_Raised_on_errors_initialising_pu, sizeof(__pyx_k_Raised_on_errors_initialising_pu), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_reading_from_kn, __pyx_k_Raised_on_errors_reading_from_kn, sizeof(__pyx_k_Raised_on_errors_reading_from_kn), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_reading_line_fr, __pyx_k_Raised_on_errors_reading_line_fr, sizeof(__pyx_k_Raised_on_errors_reading_line_fr), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_receiving_banne, __pyx_k_Raised_on_errors_receiving_banne, sizeof(__pyx_k_Raised_on_errors_receiving_banne), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_retrieving_know, __pyx_k_Raised_on_errors_retrieving_know, sizeof(__pyx_k_Raised_on_errors_retrieving_know), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_sending_banner, __pyx_k_Raised_on_errors_sending_banner, sizeof(__pyx_k_Raised_on_errors_sending_banner), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_signing_host_ke, __pyx_k_Raised_on_errors_signing_host_ke, sizeof(__pyx_k_Raised_on_errors_signing_host_ke), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_writing_line_to, __pyx_k_Raised_on_errors_writing_line_to, sizeof(__pyx_k_Raised_on_errors_writing_line_to), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_errors_writing_to_know, __pyx_k_Raised_on_errors_writing_to_know, sizeof(__pyx_k_Raised_on_errors_writing_to_know), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_file_errors, __pyx_k_Raised_on_file_errors, sizeof(__pyx_k_Raised_on_file_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_invalid_MAC, __pyx_k_Raised_on_invalid_MAC, sizeof(__pyx_k_Raised_on_invalid_MAC), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_invalid_method_errors, __pyx_k_Raised_on_invalid_method_errors, sizeof(__pyx_k_Raised_on_invalid_method_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_invalid_poll_type_erro, __pyx_k_Raised_on_invalid_poll_type_erro, sizeof(__pyx_k_Raised_on_invalid_poll_type_erro), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_invalid_request_errors, __pyx_k_Raised_on_invalid_request_errors, sizeof(__pyx_k_Raised_on_invalid_request_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_key_file_authenticatio, __pyx_k_Raised_on_key_file_authenticatio, sizeof(__pyx_k_Raised_on_key_file_authenticatio), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_keys_do_not_match_for, __pyx_k_Raised_on_keys_do_not_match_for, sizeof(__pyx_k_Raised_on_keys_do_not_match_for), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_no_match_for_known_hos, __pyx_k_Raised_on_no_match_for_known_hos, sizeof(__pyx_k_Raised_on_no_match_for_known_hos), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_non_specific_or_unknow, __pyx_k_Raised_on_non_specific_or_unknow, sizeof(__pyx_k_Raised_on_non_specific_or_unknow), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_out_of_boundary_errors, __pyx_k_Raised_on_out_of_boundary_errors, sizeof(__pyx_k_Raised_on_out_of_boundary_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_password_expired_error, __pyx_k_Raised_on_password_expired_error, sizeof(__pyx_k_Raised_on_password_expired_error), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_protocol_errors, __pyx_k_Raised_on_protocol_errors, sizeof(__pyx_k_Raised_on_protocol_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_public_key_protocol_er, __pyx_k_Raised_on_public_key_protocol_er, sizeof(__pyx_k_Raised_on_public_key_protocol_er), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_public_key_verificatio, __pyx_k_Raised_on_public_key_verificatio, sizeof(__pyx_k_Raised_on_public_key_verificatio), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_request_denied_errors, __pyx_k_Raised_on_request_denied_errors, sizeof(__pyx_k_Raised_on_request_denied_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_session_handshake_erro, __pyx_k_Raised_on_session_handshake_erro, sizeof(__pyx_k_Raised_on_session_handshake_erro), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_session_startup_errors, __pyx_k_Raised_on_session_startup_errors, sizeof(__pyx_k_Raised_on_session_startup_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_socket_disconnection_e, __pyx_k_Raised_on_socket_disconnection_e, sizeof(__pyx_k_Raised_on_socket_disconnection_e), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_socket_receive_errors, __pyx_k_Raised_on_socket_receive_errors, sizeof(__pyx_k_Raised_on_socket_receive_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_socket_send_errors, __pyx_k_Raised_on_socket_send_errors, sizeof(__pyx_k_Raised_on_socket_send_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_socket_timeouts, __pyx_k_Raised_on_socket_timeouts, sizeof(__pyx_k_Raised_on_socket_timeouts), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_something_preventing_k, __pyx_k_Raised_on_something_preventing_k, sizeof(__pyx_k_Raised_on_something_preventing_k), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_timeouts, __pyx_k_Raised_on_timeouts, sizeof(__pyx_k_Raised_on_timeouts), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_unknown_channel_errors, __pyx_k_Raised_on_unknown_channel_errors, sizeof(__pyx_k_Raised_on_unknown_channel_errors), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_use_of_bad_socket_erro, __pyx_k_Raised_on_use_of_bad_socket_erro, sizeof(__pyx_k_Raised_on_use_of_bad_socket_erro), 0, 0, 1, 0},
+    {&__pyx_kp_s_Raised_on_zlib_errors, __pyx_k_Raised_on_zlib_errors, sizeof(__pyx_k_Raised_on_zlib_errors), 0, 0, 1, 0},
+    {&__pyx_n_s_RequestDeniedError, __pyx_k_RequestDeniedError, sizeof(__pyx_k_RequestDeniedError), 0, 0, 1, 1},
+    {&__pyx_n_s_SCPProtocolError, __pyx_k_SCPProtocolError, sizeof(__pyx_k_SCPProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPError, __pyx_k_SFTPError, sizeof(__pyx_k_SFTPError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandleError, __pyx_k_SFTPHandleError, sizeof(__pyx_k_SFTPHandleError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPProtocolError, __pyx_k_SFTPProtocolError, sizeof(__pyx_k_SFTPProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_SSH2Error, __pyx_k_SSH2Error, sizeof(__pyx_k_SSH2Error), 0, 0, 1, 1},
+    {&__pyx_n_s_SessionError, __pyx_k_SessionError, sizeof(__pyx_k_SessionError), 0, 0, 1, 1},
+    {&__pyx_n_s_SessionHandshakeError, __pyx_k_SessionHandshakeError, sizeof(__pyx_k_SessionHandshakeError), 0, 0, 1, 1},
+    {&__pyx_n_s_SessionHostKeyError, __pyx_k_SessionHostKeyError, sizeof(__pyx_k_SessionHostKeyError), 0, 0, 1, 1},
+    {&__pyx_n_s_SessionStartupError, __pyx_k_SessionStartupError, sizeof(__pyx_k_SessionStartupError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketDisconnectError, __pyx_k_SocketDisconnectError, sizeof(__pyx_k_SocketDisconnectError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketRecvError, __pyx_k_SocketRecvError, sizeof(__pyx_k_SocketRecvError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketSendError, __pyx_k_SocketSendError, sizeof(__pyx_k_SocketSendError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketTimeout, __pyx_k_SocketTimeout, sizeof(__pyx_k_SocketTimeout), 0, 0, 1, 1},
+    {&__pyx_n_s_Timeout, __pyx_k_Timeout, sizeof(__pyx_k_Timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_UnknownError, __pyx_k_UnknownError, sizeof(__pyx_k_UnknownError), 0, 0, 1, 1},
+    {&__pyx_n_s_ZlibError, __pyx_k_ZlibError, sizeof(__pyx_k_ZlibError), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1},
+    {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
+    {&__pyx_n_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},
+    {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},
+    {&__pyx_n_s_mro_entries, __pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
+    {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
+    {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_exceptions, __pyx_k_ssh2_exceptions, sizeof(__pyx_k_ssh2_exceptions), 0, 0, 1, 1},
+    {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   return 0;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
@@ -1715,13 +2993,20 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyFinishContext();
   return 0;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -1788,6 +3073,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_exceptions(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_exceptions},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "exceptions",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -1838,12 +3172,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -1853,8 +3196,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -1864,8 +3208,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -1881,10 +3229,15 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_exceptions(PyObject *__pyx_pyinit_
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -1898,6 +3251,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_exceptions(PyObject *__pyx_pyinit_
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("exceptions", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "exceptions" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -1908,7 +3288,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_exceptions(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -1916,48 +3296,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("exceptions", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -1969,7 +3332,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.exceptions")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.exceptions", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.exceptions", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -1997,22 +3360,28 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all ssh2-python errors"""
  * 
  */
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
-  __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SSH2Error, __pyx_n_s_SSH2Error, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_ssh2_python_e); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_INCREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]));
+  __Pyx_GIVEREF((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]));
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])))) __PYX_ERR(0, 18, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SSH2Error, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH2Error, __pyx_t_4) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_SSH2Error, __pyx_n_s_SSH2Error, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_ssh2_python_e); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 18, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SSH2Error, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SSH2Error, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":22
  * 
@@ -2021,24 +3390,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all SSH Agent errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AgentError, __pyx_n_s_AgentError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_SSH_Agent_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AgentError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentError, __pyx_t_4) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_AgentError, __pyx_n_s_AgentError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_SSH_Agent_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 22, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_AgentError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentError, __pyx_t_4) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":26
  * 
@@ -2047,24 +3422,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all authentication errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_AuthenticationError, __pyx_n_s_AuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_authenticatio); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AuthenticationError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_AuthenticationError, __pyx_n_s_AuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_authenticatio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationError, __pyx_t_4) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 26, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AuthenticationError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AuthenticationError, __pyx_t_5) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":30
  * 
@@ -2073,24 +3454,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SSH Agent connection errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AgentConnectionError, __pyx_n_s_AgentConnectionError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_connection_e); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AgentConnectionError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentConnectionError, __pyx_t_4) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_AgentConnectionError, __pyx_n_s_AgentConnectionError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_connection_e); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 30, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_AgentConnectionError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentConnectionError, __pyx_t_2) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":34
  * 
@@ -2099,24 +3486,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SSH Agent authentication errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_AgentAuthenticationError, __pyx_n_s_AgentAuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_authenticati); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AgentAuthenticationError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_AgentAuthenticationError, __pyx_n_s_AgentAuthenticationError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_authenticati); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 34, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_AgentAuthenticationError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentAuthenticationError, __pyx_t_4) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":38
  * 
@@ -2125,24 +3518,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SSH Agent list identities errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AgentListIdentitiesError, __pyx_n_s_AgentListIdentitiesError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_list_identit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AgentListIdentitiesError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_AgentListIdentitiesError, __pyx_n_s_AgentListIdentitiesError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_list_identit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentListIdentitiesError, __pyx_t_4) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 38, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AgentListIdentitiesError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentListIdentitiesError, __pyx_t_5) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":42
  * 
@@ -2151,24 +3550,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SSH Agent get identity errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AgentError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_AgentGetIdentityError, __pyx_n_s_AgentGetIdentityError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_get_identity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_AgentGetIdentityError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentGetIdentityError, __pyx_t_4) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_AgentGetIdentityError, __pyx_n_s_AgentGetIdentityError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_Agent_get_identity); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 42, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_AgentGetIdentityError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentGetIdentityError, __pyx_t_2) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":46
  * 
@@ -2177,24 +3582,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SSH agent protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_AgentProtocolError, __pyx_n_s_AgentProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_agent_protocol_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AgentProtocolError, __pyx_n_s_AgentProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SSH_agent_protocol_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AgentProtocolError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 46, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_AgentProtocolError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_AgentProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":50
  * 
@@ -2203,24 +3614,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all session errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SessionError, __pyx_n_s_SessionError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_session_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SessionError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_SessionError, __pyx_n_s_SessionError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_session_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionError, __pyx_t_4) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 50, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SessionError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionError, __pyx_t_5) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":54
  * 
@@ -2229,24 +3646,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on session startup errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SessionStartupError, __pyx_n_s_SessionStartupError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_session_startup_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SessionStartupError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionStartupError, __pyx_t_4) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_SessionStartupError, __pyx_n_s_SessionStartupError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_session_startup_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 54, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SessionStartupError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionStartupError, __pyx_t_2) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":58
  * 
@@ -2255,24 +3678,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on session handshake errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SessionHandshakeError, __pyx_n_s_SessionHandshakeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_session_handshake_erro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SessionHandshakeError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_SessionHandshakeError, __pyx_n_s_SessionHandshakeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_session_handshake_erro); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 58, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SessionHandshakeError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionHandshakeError, __pyx_t_4) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":62
  * 
@@ -2281,24 +3710,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors getting server host key"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SessionHostKeyError, __pyx_n_s_SessionHostKeyError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_getting_server); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SessionHostKeyError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_SessionHostKeyError, __pyx_n_s_SessionHostKeyError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_getting_server); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionHostKeyError, __pyx_t_4) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 62, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SessionHostKeyError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionHostKeyError, __pyx_t_5) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":66
  * 
@@ -2307,24 +3742,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors receiving banner"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_BannerRecvError, __pyx_n_s_BannerRecvError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_receiving_banne); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BannerRecvError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BannerRecvError, __pyx_t_4) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_BannerRecvError, __pyx_n_s_BannerRecvError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_receiving_banne); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 66, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_BannerRecvError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BannerRecvError, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":70
  * 
@@ -2333,24 +3774,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors sending banner"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_BannerSendError, __pyx_n_s_BannerSendError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_sending_banner); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_BannerSendError, __pyx_n_s_BannerSendError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_sending_banner); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_BannerSendError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 70, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_BannerSendError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 70, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_BannerSendError, __pyx_t_4) < 0) __PYX_ERR(0, 70, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":74
  * 
@@ -2359,24 +3806,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors exchanging keys"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KeyExchangeError, __pyx_n_s_KeyExchangeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_exchanging_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyExchangeError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KeyExchangeError, __pyx_n_s_KeyExchangeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_exchanging_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 74, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExchangeError, __pyx_t_4) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 74, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyExchangeError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyExchangeError, __pyx_t_5) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":78
  * 
@@ -2385,24 +3838,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on timeouts"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_Timeout, __pyx_n_s_Timeout, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_timeouts); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Timeout, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Timeout, __pyx_t_4) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_Timeout, __pyx_n_s_Timeout, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_timeouts); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 78, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_Timeout, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Timeout, __pyx_t_2) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":82
  * 
@@ -2411,24 +3870,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors initialiasing host key"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_HostkeyInitError, __pyx_n_s_HostkeyInitError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_initialiasing_h); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_HostkeyInitError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_HostkeyInitError, __pyx_n_s_HostkeyInitError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_initialiasing_h); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 82, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_HostkeyInitError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostkeyInitError, __pyx_t_4) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":86
  * 
@@ -2437,24 +3902,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors signing host key"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_HostkeySignError, __pyx_n_s_HostkeySignError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_signing_host_ke); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_HostkeySignError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_HostkeySignError, __pyx_n_s_HostkeySignError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_signing_host_ke); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostkeySignError, __pyx_t_4) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 86, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_HostkeySignError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HostkeySignError, __pyx_t_5) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":90
  * 
@@ -2463,24 +3934,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on decryption errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_DecryptError, __pyx_n_s_DecryptError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_decryption_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 90, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_DecryptError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DecryptError, __pyx_t_4) < 0) __PYX_ERR(0, 90, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_DecryptError, __pyx_n_s_DecryptError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_decryption_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 90, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_DecryptError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DecryptError, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":94
  * 
@@ -2489,24 +3966,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on socket disconnection errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_SocketDisconnectError, __pyx_n_s_SocketDisconnectError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_disconnection_e); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SocketDisconnectError, __pyx_n_s_SocketDisconnectError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_disconnection_e); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SocketDisconnectError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 94, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SocketDisconnectError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketDisconnectError, __pyx_t_4) < 0) __PYX_ERR(0, 94, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":98
  * 
@@ -2515,24 +3998,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ProtocolError, __pyx_n_s_ProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_protocol_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ProtocolError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_ProtocolError, __pyx_n_s_ProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_protocol_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 98, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 98, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ProtocolError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProtocolError, __pyx_t_5) < 0) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":102
  * 
@@ -2541,24 +4030,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on password expired errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_PasswordExpiredError, __pyx_n_s_PasswordExpiredError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_password_expired_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_PasswordExpiredError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PasswordExpiredError, __pyx_t_4) < 0) __PYX_ERR(0, 102, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_PasswordExpiredError, __pyx_n_s_PasswordExpiredError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_password_expired_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 102, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_PasswordExpiredError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PasswordExpiredError, __pyx_t_2) < 0) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":106
  * 
@@ -2567,24 +4062,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on file errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FileError, __pyx_n_s_FileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_file_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FileError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_FileError, __pyx_n_s_FileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_file_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 106, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_FileError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_FileError, __pyx_t_4) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":110
  * 
@@ -2593,24 +4094,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on invalid method errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MethodNoneError, __pyx_n_s_MethodNoneError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_method_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MethodNoneError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_MethodNoneError, __pyx_n_s_MethodNoneError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_method_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MethodNoneError, __pyx_t_4) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 110, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MethodNoneError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MethodNoneError, __pyx_t_5) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":114
  * 
@@ -2619,24 +4126,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all public key protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_PublicKeyError, __pyx_n_s_PublicKeyError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_public_key_pr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 114, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PublicKeyError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 114, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyError, __pyx_t_4) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_PublicKeyError, __pyx_n_s_PublicKeyError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_public_key_pr); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 114, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_PublicKeyError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyError, __pyx_t_2) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":118
  * 
@@ -2645,24 +4158,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors initialising public key system"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PublicKeyError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PublicKeyError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_PublicKeyInitError, __pyx_n_s_PublicKeyInitError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_initialising_pu); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_PublicKeyInitError, __pyx_n_s_PublicKeyInitError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_initialising_pu); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_PublicKeyInitError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 118, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_PublicKeyInitError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyInitError, __pyx_t_4) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":122
  * 
@@ -2671,24 +4190,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on public key verification errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_PublickeyUnverifiedError, __pyx_n_s_PublickeyUnverifiedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_public_key_verificatio); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_AuthenticationError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PublickeyUnverifiedError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_PublickeyUnverifiedError, __pyx_n_s_PublickeyUnverifiedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_public_key_verificatio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublickeyUnverifiedError, __pyx_t_4) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 122, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PublickeyUnverifiedError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublickeyUnverifiedError, __pyx_t_5) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":126
  * 
@@ -2697,24 +4222,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for all channel errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ChannelError, __pyx_n_s_ChannelError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_channel_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ChannelError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_4) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_ChannelError, __pyx_n_s_ChannelError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_all_channel_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 126, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_ChannelError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_2) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":130
  * 
@@ -2723,24 +4254,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel commands out of order errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelOutOfOrderError, __pyx_n_s_ChannelOutOfOrderError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_commands_out_o); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelOutOfOrderError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_ChannelOutOfOrderError, __pyx_n_s_ChannelOutOfOrderError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_commands_out_o); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 130, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ChannelOutOfOrderError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelOutOfOrderError, __pyx_t_4) < 0) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":134
  * 
@@ -2749,24 +4286,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel failures"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ChannelFailure, __pyx_n_s_ChannelFailure, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_failures); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ChannelFailure, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_ChannelFailure, __pyx_n_s_ChannelFailure, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_failures); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelFailure, __pyx_t_4) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 134, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelFailure, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelFailure, __pyx_t_5) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":138
  * 
@@ -2775,24 +4318,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel request denied errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelRequestDenied, __pyx_n_s_ChannelRequestDenied, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_request_denied); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelRequestDenied, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelRequestDenied, __pyx_t_4) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_ChannelRequestDenied, __pyx_n_s_ChannelRequestDenied, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_request_denied); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 138, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_ChannelRequestDenied, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelRequestDenied, __pyx_t_2) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":142
  * 
@@ -2801,24 +4350,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on unknown channel errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_ChannelUnknownError, __pyx_n_s_ChannelUnknownError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_unknown_channel_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ChannelUnknownError, __pyx_n_s_ChannelUnknownError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_unknown_channel_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ChannelUnknownError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 142, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ChannelUnknownError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelUnknownError, __pyx_t_4) < 0) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":146
  * 
@@ -2827,24 +4382,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel window exceeded errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelWindowExceeded, __pyx_n_s_ChannelWindowExceeded, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_window_exceede); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelWindowExceeded, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_ChannelWindowExceeded, __pyx_n_s_ChannelWindowExceeded, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_window_exceede); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelWindowExceeded, __pyx_t_4) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 146, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelWindowExceeded, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelWindowExceeded, __pyx_t_5) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":150
  * 
@@ -2853,24 +4414,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel max packet length exceeded errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ChannelPacketExceeded, __pyx_n_s_ChannelPacketExceeded, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_max_packet_len); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ChannelPacketExceeded, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelPacketExceeded, __pyx_t_4) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_ChannelPacketExceeded, __pyx_n_s_ChannelPacketExceeded, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_max_packet_len); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 150, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_ChannelPacketExceeded, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelPacketExceeded, __pyx_t_2) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":154
  * 
@@ -2879,24 +4446,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel closed errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelClosedError, __pyx_n_s_ChannelClosedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_closed_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelClosedError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_ChannelClosedError, __pyx_n_s_ChannelClosedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_closed_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 154, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ChannelClosedError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelClosedError, __pyx_t_4) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":158
  * 
@@ -2905,24 +4478,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel EOF errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ChannelEOFSentError, __pyx_n_s_ChannelEOFSentError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_EOF_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ChannelEOFSentError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_ChannelEOFSentError, __pyx_n_s_ChannelEOFSentError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_EOF_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelEOFSentError, __pyx_t_4) < 0) __PYX_ERR(0, 158, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 158, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelEOFSentError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelEOFSentError, __pyx_t_5) < 0) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":162
  * 
@@ -2931,24 +4510,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SCP protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SCPProtocolError, __pyx_n_s_SCPProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SCP_protocol_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SCPProtocolError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SCPProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 162, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_SCPProtocolError, __pyx_n_s_SCPProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SCP_protocol_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 162, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SCPProtocolError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SCPProtocolError, __pyx_t_2) < 0) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":166
  * 
@@ -2957,24 +4542,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on zlib errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_ZlibError, __pyx_n_s_ZlibError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_zlib_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_ZlibError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_ZlibError, __pyx_n_s_ZlibError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_zlib_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 166, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ZlibError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ZlibError, __pyx_t_4) < 0) __PYX_ERR(0, 166, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":170
  * 
@@ -2983,24 +4574,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on socket timeouts"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SocketTimeout, __pyx_n_s_SocketTimeout, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_timeouts); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SocketTimeout, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_SocketTimeout, __pyx_n_s_SocketTimeout, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_timeouts); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketTimeout, __pyx_t_4) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 170, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SocketTimeout, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketTimeout, __pyx_t_5) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":174
  * 
@@ -3009,24 +4606,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on request denied errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_RequestDeniedError, __pyx_n_s_RequestDeniedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_request_denied_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_RequestDeniedError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestDeniedError, __pyx_t_4) < 0) __PYX_ERR(0, 174, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_RequestDeniedError, __pyx_n_s_RequestDeniedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_request_denied_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 174, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_RequestDeniedError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestDeniedError, __pyx_t_2) < 0) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":178
  * 
@@ -3035,24 +4638,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on authentication method not supported errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_MethodNotSupported, __pyx_n_s_MethodNotSupported, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_authentication_method); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MethodNotSupported, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_MethodNotSupported, __pyx_n_s_MethodNotSupported, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_authentication_method); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 178, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_MethodNotSupported, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_MethodNotSupported, __pyx_t_4) < 0) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":182
  * 
@@ -3061,24 +4670,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on invalid request errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_InvalidRequestError, __pyx_n_s_InvalidRequestError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_request_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 182, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_InvalidRequestError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_InvalidRequestError, __pyx_n_s_InvalidRequestError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_request_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidRequestError, __pyx_t_4) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 182, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_InvalidRequestError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidRequestError, __pyx_t_5) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":186
  * 
@@ -3087,24 +4702,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on invalid poll type errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_InvalidPollTypeError, __pyx_n_s_InvalidPollTypeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_poll_type_erro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_InvalidPollTypeError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidPollTypeError, __pyx_t_4) < 0) __PYX_ERR(0, 186, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_InvalidPollTypeError, __pyx_n_s_InvalidPollTypeError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_poll_type_erro); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 186, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_InvalidPollTypeError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidPollTypeError, __pyx_t_2) < 0) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":190
  * 
@@ -3113,24 +4734,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on public key protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_PublicKeyProtocolError, __pyx_n_s_PublicKeyProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_public_key_protocol_er); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_PublicKeyProtocolError, __pyx_n_s_PublicKeyProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_public_key_protocol_er); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_PublicKeyProtocolError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 190, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 190, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_PublicKeyProtocolError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 190, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 190, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":194
  * 
@@ -3139,24 +4766,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on buffer too small errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_BufferTooSmallError, __pyx_n_s_BufferTooSmallError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_buffer_too_small_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BufferTooSmallError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_BufferTooSmallError, __pyx_n_s_BufferTooSmallError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_buffer_too_small_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BufferTooSmallError, __pyx_t_4) < 0) __PYX_ERR(0, 194, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 194, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BufferTooSmallError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BufferTooSmallError, __pyx_t_5) < 0) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":198
  * 
@@ -3165,24 +4798,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on API bad use errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_BadUseError, __pyx_n_s_BadUseError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_API_bad_use_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_BadUseError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 198, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BadUseError, __pyx_t_4) < 0) __PYX_ERR(0, 198, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_BadUseError, __pyx_n_s_BadUseError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_API_bad_use_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 198, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_BadUseError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BadUseError, __pyx_t_2) < 0) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":202
  * 
@@ -3191,24 +4830,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on compression errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_CompressError, __pyx_n_s_CompressError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_compression_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_CompressError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_CompressError, __pyx_n_s_CompressError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_compression_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 202, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_CompressError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 202, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_CompressError, __pyx_t_4) < 0) __PYX_ERR(0, 202, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":206
  * 
@@ -3217,24 +4862,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on out of boundary errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_OutOfBoundaryError, __pyx_n_s_OutOfBoundaryError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_out_of_boundary_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 206, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_OutOfBoundaryError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_OutOfBoundaryError, __pyx_n_s_OutOfBoundaryError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_out_of_boundary_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_OutOfBoundaryError, __pyx_t_4) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 206, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_OutOfBoundaryError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_OutOfBoundaryError, __pyx_t_5) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":210
  * 
@@ -3243,24 +4894,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on socket receive errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SocketRecvError, __pyx_n_s_SocketRecvError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_receive_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SocketRecvError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketRecvError, __pyx_t_4) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_SocketRecvError, __pyx_n_s_SocketRecvError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_receive_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 210, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SocketRecvError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketRecvError, __pyx_t_2) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":214
  * 
@@ -3269,24 +4926,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on socket send errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_SocketSendError, __pyx_n_s_SocketSendError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_send_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SocketSendError, __pyx_n_s_SocketSendError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_socket_send_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SocketSendError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 214, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SocketSendError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_SocketSendError, __pyx_t_4) < 0) __PYX_ERR(0, 214, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":218
  * 
@@ -3295,24 +4958,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on encryption errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_EncryptError, __pyx_n_s_EncryptError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_encryption_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EncryptError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_EncryptError, __pyx_n_s_EncryptError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_encryption_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EncryptError, __pyx_t_4) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 218, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EncryptError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EncryptError, __pyx_t_5) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":222
  * 
@@ -3321,24 +4990,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on use of bad socket errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_BadSocketError, __pyx_n_s_BadSocketError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_use_of_bad_socket_erro); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_BadSocketError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BadSocketError, __pyx_t_4) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_BadSocketError, __pyx_n_s_BadSocketError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_use_of_bad_socket_erro); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 222, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_BadSocketError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BadSocketError, __pyx_t_2) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":226
  * 
@@ -3347,24 +5022,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for SFTP errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SFTPError, __pyx_n_s_SFTPError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_SFTP_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SFTPError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_SFTPError, __pyx_n_s_SFTPError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_SFTP_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 226, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_SFTPError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPError, __pyx_t_4) < 0) __PYX_ERR(0, 226, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":230
  * 
@@ -3373,24 +5054,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SFTP protocol errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_SFTPProtocolError, __pyx_n_s_SFTPProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SFTP_protocol_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_SFTPProtocolError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_SFTPProtocolError, __pyx_n_s_SFTPProtocolError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SFTP_protocol_errors); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPProtocolError, __pyx_t_4) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 230, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SFTPProtocolError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPProtocolError, __pyx_t_5) < 0) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":234
  * 
@@ -3399,24 +5086,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on SFTP handle errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SFTPError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_SFTPHandleError, __pyx_n_s_SFTPHandleError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SFTP_handle_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SFTPHandleError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPHandleError, __pyx_t_4) < 0) __PYX_ERR(0, 234, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_SFTPHandleError, __pyx_n_s_SFTPHandleError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_SFTP_handle_errors); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 234, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_SFTPHandleError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SFTPHandleError, __pyx_t_2) < 0) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":238
  * 
@@ -3425,24 +5118,30 @@ if (!__Pyx_RefNanny) {
  *     """Base class for KnownHost errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_KnownHostError, __pyx_n_s_KnownHostError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_KnownHost_errors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostError, __pyx_n_s_KnownHostError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Base_class_for_KnownHost_errors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 238, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_KnownHostError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostError, __pyx_t_4) < 0) __PYX_ERR(0, 238, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":242
  * 
@@ -3451,24 +5150,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors adding known host entries"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostAddError, __pyx_n_s_KnownHostAddError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_adding_known_ho); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostAddError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KnownHostAddError, __pyx_n_s_KnownHostAddError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_adding_known_ho); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostAddError, __pyx_t_4) < 0) __PYX_ERR(0, 242, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 242, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostAddError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostAddError, __pyx_t_5) < 0) __PYX_ERR(0, 242, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":246
  * 
@@ -3477,24 +5182,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on any known host check errors"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostCheckError, __pyx_n_s_KnownHostCheckError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_any_known_host_check_e); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostCheckError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckError, __pyx_t_4) < 0) __PYX_ERR(0, 246, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_KnownHostCheckError, __pyx_n_s_KnownHostCheckError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_any_known_host_check_e); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 246, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_KnownHostCheckError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckError, __pyx_t_2) < 0) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":250
  * 
@@ -3503,24 +5214,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on something preventing known host check to be made"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostCheckFailure, __pyx_n_s_KnownHostCheckFailure, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_something_preventing_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostCheckFailure, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_KnownHostCheckFailure, __pyx_n_s_KnownHostCheckFailure, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_something_preventing_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 250, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_KnownHostCheckFailure, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckFailure, __pyx_t_4) < 0) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":254
  * 
@@ -3529,24 +5246,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on no match for known host check"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 254, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_n_s_KnownHostCheckNotFoundError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_no_match_for_known_hos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_n_s_KnownHostCheckNotFoundError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_no_match_for_known_hos); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_4) < 0) __PYX_ERR(0, 254, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 254, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_5) < 0) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":258
  * 
@@ -3555,24 +5278,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on keys do not match for known host"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_n_s_KnownHostCheckMisMatchError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_keys_do_not_match_for); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 258, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_4) < 0) __PYX_ERR(0, 258, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_n_s_KnownHostCheckMisMatchError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_keys_do_not_match_for); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 258, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_2) < 0) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":262
  * 
@@ -3581,24 +5310,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors deleting known host entry"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_KnownHostDeleteError, __pyx_n_s_KnownHostDeleteError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_deleting_known); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostDeleteError, __pyx_n_s_KnownHostDeleteError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_deleting_known); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostDeleteError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 262, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_KnownHostDeleteError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostDeleteError, __pyx_t_4) < 0) __PYX_ERR(0, 262, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":266
  * 
@@ -3607,24 +5342,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors reading line from known hosts file"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostReadLineError, __pyx_n_s_KnownHostReadLineError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_reading_line_fr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 266, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostReadLineError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KnownHostReadLineError, __pyx_n_s_KnownHostReadLineError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_reading_line_fr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadLineError, __pyx_t_4) < 0) __PYX_ERR(0, 266, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 266, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostReadLineError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadLineError, __pyx_t_5) < 0) __PYX_ERR(0, 266, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":270
  * 
@@ -3633,24 +5374,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors reading from known hosts file"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 270, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostReadFileError, __pyx_n_s_KnownHostReadFileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_reading_from_kn); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostReadFileError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadFileError, __pyx_t_4) < 0) __PYX_ERR(0, 270, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_KnownHostReadFileError, __pyx_n_s_KnownHostReadFileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_reading_from_kn); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 270, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_KnownHostReadFileError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadFileError, __pyx_t_2) < 0) __PYX_ERR(0, 270, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":274
  * 
@@ -3659,24 +5406,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors writing line to known hosts file"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 274, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostWriteLineError, __pyx_n_s_KnownHostWriteLineError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_writing_line_to); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostWriteLineError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_KnownHostWriteLineError, __pyx_n_s_KnownHostWriteLineError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_writing_line_to); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 274, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_KnownHostWriteLineError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteLineError, __pyx_t_4) < 0) __PYX_ERR(0, 274, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":278
  * 
@@ -3685,24 +5438,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors writing to known hosts file"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KnownHostWriteFileError, __pyx_n_s_KnownHostWriteFileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_writing_to_know); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KnownHostWriteFileError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KnownHostWriteFileError, __pyx_n_s_KnownHostWriteFileError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_writing_to_know); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteFileError, __pyx_t_4) < 0) __PYX_ERR(0, 278, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 278, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostWriteFileError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteFileError, __pyx_t_5) < 0) __PYX_ERR(0, 278, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":282
  * 
@@ -3711,24 +5470,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on errors retrieving known host entries"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 282, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KnownHostGetError, __pyx_n_s_KnownHostGetError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_retrieving_know); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KnownHostGetError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostGetError, __pyx_t_4) < 0) __PYX_ERR(0, 282, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_KnownHostGetError, __pyx_n_s_KnownHostGetError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_errors_retrieving_know); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 282, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_KnownHostGetError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostGetError, __pyx_t_2) < 0) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":286
  * 
@@ -3737,24 +5502,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on invalid MAC"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_InvalidMACError, __pyx_n_s_InvalidMACError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_MAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_InvalidMACError, __pyx_n_s_InvalidMACError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_invalid_MAC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_InvalidMACError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 286, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_InvalidMACError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_InvalidMACError, __pyx_t_4) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":290
  * 
@@ -3763,24 +5534,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on KEX failure"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 290, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 290, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_KexFailureError, __pyx_n_s_KexFailureError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_KEX_failure); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KexFailureError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KexFailureError, __pyx_n_s_KexFailureError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_KEX_failure); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 290, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KexFailureError, __pyx_t_4) < 0) __PYX_ERR(0, 290, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 290, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KexFailureError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KexFailureError, __pyx_t_5) < 0) __PYX_ERR(0, 290, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":294
  * 
@@ -3789,24 +5566,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on allocation error"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_AllocError, __pyx_n_s_AllocError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_allocation_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_AllocError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 294, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AllocError, __pyx_t_4) < 0) __PYX_ERR(0, 294, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_AllocError, __pyx_n_s_AllocError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_allocation_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 294, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_AllocError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AllocError, __pyx_t_2) < 0) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/exceptions.pyx":298
  * 
@@ -3815,24 +5598,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on channel window full error"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_ChannelWindowFullError, __pyx_n_s_ChannelWindowFullError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_window_full_er); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_ChannelWindowFullError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_5, __pyx_t_3, __pyx_n_s_ChannelWindowFullError, __pyx_n_s_ChannelWindowFullError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_channel_window_full_er); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__pyx_t_3 != __pyx_t_4) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_2, "__orig_bases__", __pyx_t_4) < 0))) __PYX_ERR(0, 298, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_5, __pyx_n_s_ChannelWindowFullError, __pyx_t_3, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 298, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelWindowFullError, __pyx_t_4) < 0) __PYX_ERR(0, 298, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":302
  * 
@@ -3841,24 +5630,30 @@ if (!__Pyx_RefNanny) {
  *     """Raised on key file authentication error"""
  * 
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 302, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_KeyfileAuthFailedError, __pyx_n_s_KeyfileAuthFailedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_key_file_authenticatio); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_KeyfileAuthFailedError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_3, __pyx_n_s_KeyfileAuthFailedError, __pyx_n_s_KeyfileAuthFailedError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_key_file_authenticatio); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 302, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyfileAuthFailedError, __pyx_t_4) < 0) __PYX_ERR(0, 302, __pyx_L1_error)
+  if (__pyx_t_3 != __pyx_t_5) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_t_5) < 0))) __PYX_ERR(0, 302, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_KeyfileAuthFailedError, __pyx_t_3, __pyx_t_4, NULL, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KeyfileAuthFailedError, __pyx_t_5) < 0) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/exceptions.pyx":306
  * 
@@ -3866,50 +5661,66 @@ if (!__Pyx_RefNanny) {
  * class UnknownError(SSH2Error):             # <<<<<<<<<<<<<<
  *     """Raised on non-specific or unknown errors"""
  */
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 306, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SSH2Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_UnknownError, __pyx_n_s_UnknownError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_non_specific_or_unknow); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PEP560_update_bases(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_UnknownError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 306, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnknownError, __pyx_t_4) < 0) __PYX_ERR(0, 306, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_3, __pyx_n_s_UnknownError, __pyx_n_s_UnknownError, (PyObject *) NULL, __pyx_n_s_ssh2_exceptions, __pyx_kp_s_Raised_on_non_specific_or_unknow); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__pyx_t_3 != __pyx_t_2) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_5, "__orig_bases__", __pyx_t_2) < 0))) __PYX_ERR(0, 306, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_n_s_UnknownError, __pyx_t_3, __pyx_t_5, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_UnknownError, __pyx_t_2) < 0) __PYX_ERR(0, 306, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/exceptions.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.exceptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init ssh2.exceptions");
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init ssh2.exceptions");
   }
   __pyx_L0:;
   __Pyx_RefNannyFinishContext();
@@ -3921,6 +5732,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -3940,12 +5767,493 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* Py3UpdateBases */
+static PyObject*
+__Pyx_PEP560_update_bases(PyObject *bases)
+{
+    Py_ssize_t i, j, size_bases;
+    PyObject *base, *meth, *new_base, *result, *new_bases = NULL;
+    size_bases = PyTuple_GET_SIZE(bases);
+    for (i = 0; i < size_bases; i++) {
+        base  = PyTuple_GET_ITEM(bases, i);
+        if (PyType_Check(base)) {
+            if (new_bases) {
+                if (PyList_Append(new_bases, base) < 0) {
+                    goto error;
+                }
+            }
+            continue;
+        }
+        meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_n_s_mro_entries);
+        if (!meth && PyErr_Occurred()) {
+            goto error;
+        }
+        if (!meth) {
+            if (new_bases) {
+                if (PyList_Append(new_bases, base) < 0) {
+                    goto error;
+                }
+            }
+            continue;
+        }
+        new_base = __Pyx_PyObject_CallOneArg(meth, bases);
+        Py_DECREF(meth);
+        if (!new_base) {
+            goto error;
+        }
+        if (!PyTuple_Check(new_base)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "__mro_entries__ must return a tuple");
+            Py_DECREF(new_base);
+            goto error;
+        }
+        if (!new_bases) {
+            if (!(new_bases = PyList_New(i))) {
+                goto error;
+            }
+            for (j = 0; j < i; j++) {
+                base = PyTuple_GET_ITEM(bases, j);
+                PyList_SET_ITEM(new_bases, j, base);
+                Py_INCREF(base);
+            }
+        }
+        j = PyList_GET_SIZE(new_bases);
+        if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {
+            goto error;
+        }
+        Py_DECREF(new_base);
+    }
+    if (!new_bases) {
+        Py_INCREF(bases);
+        return bases;
+    }
+    result = PyList_AsTuple(new_bases);
+    Py_DECREF(new_bases);
+    return result;
+error:
+    Py_XDECREF(new_bases);
+    return NULL;
+}
+
 /* CalculateMetaclass */
 static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
-    Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
+    Py_ssize_t i, nbases;
+#if CYTHON_ASSUME_SAFE_MACROS
+    nbases = PyTuple_GET_SIZE(bases);
+#else
+    nbases = PyTuple_Size(bases);
+    if (nbases < 0) return NULL;
+#endif
     for (i=0; i < nbases; i++) {
         PyTypeObject *tmptype;
+#if CYTHON_ASSUME_SAFE_MACROS
         PyObject *tmp = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *tmp = PyTuple_GetItem(bases, i);
+        if (!tmp) return NULL;
+#endif
         tmptype = Py_TYPE(tmp);
 #if PY_MAJOR_VERSION < 3
         if (tmptype == &PyClass_Type)
@@ -3979,17 +6287,47 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas
     return (PyObject*) metaclass;
 }
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
 #endif
-    return PyObject_GetAttr(obj, attr_name);
+    }
+    return result;
+}
+
+/* PyObjectCall2Args */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args[3] = {NULL, arg1, arg2};
+    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectLookupSpecial */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) {
+    PyObject *res;
+    PyTypeObject *tp = Py_TYPE(obj);
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(PyInstance_Check(obj)))
+        return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name);
+#endif
+    res = _PyType_Lookup(tp, attr_name);
+    if (likely(res)) {
+        descrgetfunc f = Py_TYPE(res)->tp_descr_get;
+        if (!f) {
+            Py_INCREF(res);
+        } else {
+            res = f(res, obj, (PyObject *)tp);
+        }
+    } else if (with_error) {
+        PyErr_SetObject(PyExc_AttributeError, attr_name);
+    }
+    return res;
 }
 #endif
 
@@ -3998,20 +6336,14 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases,
                                            PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
     PyObject *ns;
     if (metaclass) {
-        PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);
+        PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare);
         if (prep) {
-            PyObject *pargs = PyTuple_Pack(2, name, bases);
-            if (unlikely(!pargs)) {
-                Py_DECREF(prep);
-                return NULL;
-            }
-            ns = PyObject_Call(prep, pargs, mkw);
+            PyObject *pargs[3] = {NULL, name, bases};
+            ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
             Py_DECREF(prep);
-            Py_DECREF(pargs);
         } else {
-            if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
+            if (unlikely(PyErr_Occurred()))
                 return NULL;
-            PyErr_Clear();
             ns = PyDict_New();
         }
     } else {
@@ -4020,18 +6352,153 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases,
     if (unlikely(!ns))
         return NULL;
     if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
+#if PY_VERSION_HEX >= 0x03030000
     if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
+#else
+    CYTHON_MAYBE_UNUSED_VAR(qualname);
+#endif
     if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
     return ns;
 bad:
     Py_DECREF(ns);
     return NULL;
 }
+#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS
+static int __Pyx_SetNamesPEP487(PyObject *type_obj) {
+    PyTypeObject *type = (PyTypeObject*) type_obj;
+    PyObject *names_to_set, *key, *value, *set_name, *tmp;
+    Py_ssize_t i = 0;
+#if CYTHON_USE_TYPE_SLOTS
+    names_to_set = PyDict_Copy(type->tp_dict);
+#else
+    {
+        PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict);
+        names_to_set = NULL;
+        if (likely(d)) {
+            PyObject *names_to_set = PyDict_New();
+            int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1;
+            Py_DECREF(d);
+            if (unlikely(ret < 0))
+                Py_CLEAR(names_to_set);
+        }
+    }
+#endif
+    if (unlikely(names_to_set == NULL))
+        goto bad;
+    while (PyDict_Next(names_to_set, &i, &key, &value)) {
+        set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name);
+        if (unlikely(set_name != NULL)) {
+            tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key);
+            Py_DECREF(set_name);
+            if (unlikely(tmp == NULL)) {
+                __Pyx_TypeName value_type_name =
+                    __Pyx_PyType_GetName(Py_TYPE(value));
+                __Pyx_TypeName type_name = __Pyx_PyType_GetName(type);
+                PyErr_Format(PyExc_RuntimeError,
+#if PY_MAJOR_VERSION >= 3
+                    "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'",
+                    value_type_name, key, type_name);
+#else
+                    "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'",
+                    value_type_name,
+                    PyString_Check(key) ? PyString_AS_STRING(key) : "?",
+                    type_name);
+#endif
+                goto bad;
+            } else {
+                Py_DECREF(tmp);
+            }
+        }
+        else if (unlikely(PyErr_Occurred())) {
+            goto bad;
+        }
+    }
+    Py_DECREF(names_to_set);
+    return 0;
+bad:
+    Py_XDECREF(names_to_set);
+    return -1;
+}
+static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) {
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    PyTypeObject *type = (PyTypeObject*) type_obj;
+    PyObject *mro = type->tp_mro;
+    Py_ssize_t i, nbases;
+    if (unlikely(!mro)) goto done;
+    (void) &__Pyx_GetBuiltinName;
+    Py_INCREF(mro);
+    nbases = PyTuple_GET_SIZE(mro);
+    assert(PyTuple_GET_ITEM(mro, 0) == type_obj);
+    for (i = 1; i < nbases-1; i++) {
+        PyObject *base, *dict, *meth;
+        base = PyTuple_GET_ITEM(mro, i);
+        dict = ((PyTypeObject *)base)->tp_dict;
+        meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass);
+        if (unlikely(meth)) {
+            descrgetfunc f = Py_TYPE(meth)->tp_descr_get;
+            PyObject *res;
+            Py_INCREF(meth);
+            if (likely(f)) {
+                res = f(meth, NULL, type_obj);
+                Py_DECREF(meth);
+                if (unlikely(!res)) goto bad;
+                meth = res;
+            }
+            res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw);
+            Py_DECREF(meth);
+            if (unlikely(!res)) goto bad;
+            Py_DECREF(res);
+            goto done;
+        } else if (unlikely(PyErr_Occurred())) {
+            goto bad;
+        }
+    }
+done:
+    Py_XDECREF(mro);
+    return type_obj;
+bad:
+    Py_XDECREF(mro);
+    Py_DECREF(type_obj);
+    return NULL;
+#else
+    PyObject *super_type, *super, *func, *res;
+#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type)
+    super_type = __Pyx_GetBuiltinName(__pyx_n_s_super);
+#else
+    super_type = (PyObject*) &PySuper_Type;
+    (void) &__Pyx_GetBuiltinName;
+#endif
+    super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL;
+#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type)
+    Py_XDECREF(super_type);
+#endif
+    if (unlikely(!super)) {
+        Py_CLEAR(type_obj);
+        goto done;
+    }
+    func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass);
+    Py_DECREF(super);
+    if (likely(!func)) {
+        if (unlikely(PyErr_Occurred()))
+            Py_CLEAR(type_obj);
+        goto done;
+    }
+    res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw);
+    Py_DECREF(func);
+    if (unlikely(!res))
+        Py_CLEAR(type_obj);
+    Py_XDECREF(res);
+done:
+    return type_obj;
+#endif
+}
+#endif
 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                       PyObject *dict, PyObject *mkw,
                                       int calculate_metaclass, int allow_py2_metaclass) {
-    PyObject *result, *margs;
+    PyObject *result;
     PyObject *owned_metaclass = NULL;
+    PyObject *margs[4] = {NULL, name, bases, dict};
     if (allow_py2_metaclass) {
         owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
         if (owned_metaclass) {
@@ -4049,28 +6516,25 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj
             return NULL;
         owned_metaclass = metaclass;
     }
-    margs = PyTuple_Pack(3, name, bases, dict);
-    if (unlikely(!margs)) {
-        result = NULL;
-    } else {
-        result = PyObject_Call(metaclass, margs, mkw);
-        Py_DECREF(margs);
-    }
-    Py_XDECREF(owned_metaclass);
-    return result;
-}
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
+    result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET,
+#if PY_VERSION_HEX < 0x030600A4
+        (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+        mkw
 #endif
+    );
+    Py_XDECREF(owned_metaclass);
+#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS
+    if (likely(result) && likely(PyType_Check(result))) {
+        if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) {
+            Py_CLEAR(result);
+        } else {
+            result = __Pyx_InitSubclassPEP487(result, mkw);
+        }
     }
+#else
+    (void) &__Pyx_GetBuiltinName;
+#endif
     return result;
 }
 
@@ -4109,7 +6573,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 {
     PyObject *result;
 #if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
     result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
@@ -4117,6 +6581,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     } else if (unlikely(PyErr_Occurred())) {
         return NULL;
     }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
 #else
     result = PyDict_GetItem(__pyx_d, name);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
@@ -4135,38 +6607,15 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     return __Pyx_GetBuiltinName(name);
 }
 
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -4180,7 +6629,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -4202,6 +6651,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -4280,17 +6730,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -4325,6 +6859,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -4340,7 +6875,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -4387,6 +6922,23 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s_);
+    }
+    return name;
+}
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -4419,10 +6971,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -4461,7 +7046,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -4470,168 +7055,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
         }
-        {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
 #else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
+        }
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4657,7 +7313,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -4666,168 +7322,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
         }
-        {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
 #else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
+        }
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4844,7 +7571,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -4865,6 +7592,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -4889,11 +7632,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -4941,47 +7684,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -4989,30 +7763,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -5067,7 +7845,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -5096,22 +7874,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -5177,13 +7959,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -5251,4 +8031,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/fileinfo.c b/ssh2/fileinfo.c
index 261bd114..6bb5ecab 100644
--- a/ssh2/fileinfo.c
+++ b/ssh2/fileinfo.c
@@ -1,22 +1,67 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.fileinfo",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/fileinfo.pyx"
+        ]
+    },
+    "module_name": "ssh2.fileinfo"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +80,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +88,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +125,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +145,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +273,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +302,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +313,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +336,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +363,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +387,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +471,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +495,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +512,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
+        #else
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +574,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +609,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +761,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +778,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +868,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +914,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +948,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1042,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1057,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1099,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1116,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1163,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1183,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1223,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -795,9 +1301,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -815,9 +1322,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -825,13 +1332,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -855,8 +1356,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -877,7 +1424,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -907,6 +1454,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -942,29 +1490,35 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/fileinfo.pyx",
-  "stringsource",
+  "<stringsource>",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_8fileinfo_FileInfo;
 
 /* "ssh2/fileinfo.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class FileInfo:             # <<<<<<<<<<<<<<
  *     """Representation of stat structure"""
@@ -975,6 +1529,7 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
   libssh2_struct_stat *_stat;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -983,11 +1538,11 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -997,28 +1552,40 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1029,6 +1596,10 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1040,39 +1611,30 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1084,7 +1646,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1100,9 +1662,181 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1117,19 +1851,150 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+/* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
 #else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
 #endif
 
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
 
-/* SetupReduce.proto */
-static int __Pyx_setup_reduce(PyObject* type_obj);
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1165,6 +2030,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1178,13 +2044,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1200,6 +2067,19 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntFromPy.proto */
 static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 
@@ -1209,73 +2089,84 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.fileinfo' */
-static PyTypeObject *__pyx_ptype_4ssh2_8fileinfo_FileInfo = 0;
+/* Module declarations from "ssh2.fileinfo" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.fileinfo"
 extern int __pyx_module_is_main_ssh2__fileinfo;
 int __pyx_module_is_main_ssh2__fileinfo = 0;
 
-/* Implementation of 'ssh2.fileinfo' */
+/* Implementation of "ssh2.fileinfo" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k__5[] = "?";
+static const char __pyx_k_gc[] = "gc";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_FileInfo[] = "FileInfo";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_ssh2_fileinfo[] = "ssh2.fileinfo";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_FileInfo___reduce_cython[] = "FileInfo.__reduce_cython__";
+static const char __pyx_k_FileInfo___setstate_cython[] = "FileInfo.__setstate_cython__";
 static const char __pyx_k_Available_only_when_built_on_lib[] = "Available only when built on libssh2 >= ``1.7``";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_FileInfo;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self); /* proto */
 static void __pyx_pf_4ssh2_8fileinfo_8FileInfo_2__dealloc__(struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_size___get__(struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self); /* proto */
@@ -1293,9 +2184,288 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_ctime___get__(struct __p
 static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_8fileinfo_FileInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_8fileinfo_FileInfo;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8fileinfo_FileInfo;
+  PyObject *__pyx_n_s_FileInfo;
+  PyObject *__pyx_n_s_FileInfo___reduce_cython;
+  PyObject *__pyx_n_s_FileInfo___setstate_cython;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s__5;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_fileinfo;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_codeobj__2;
+  PyObject *__pyx_codeobj__4;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8fileinfo_FileInfo);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_8fileinfo_FileInfo);
+  Py_CLEAR(clear_module_state->__pyx_n_s_FileInfo);
+  Py_CLEAR(clear_module_state->__pyx_n_s_FileInfo___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_FileInfo___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__5);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_fileinfo);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__2);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8fileinfo_FileInfo);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_8fileinfo_FileInfo);
+  Py_VISIT(traverse_module_state->__pyx_n_s_FileInfo);
+  Py_VISIT(traverse_module_state->__pyx_n_s_FileInfo___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_FileInfo___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__5);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_fileinfo);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__2);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_8fileinfo_FileInfo __pyx_mstate_global->__pyx_type_4ssh2_8fileinfo_FileInfo
+#endif
+#define __pyx_ptype_4ssh2_8fileinfo_FileInfo __pyx_mstate_global->__pyx_ptype_4ssh2_8fileinfo_FileInfo
+#define __pyx_n_s_FileInfo __pyx_mstate_global->__pyx_n_s_FileInfo
+#define __pyx_n_s_FileInfo___reduce_cython __pyx_mstate_global->__pyx_n_s_FileInfo___reduce_cython
+#define __pyx_n_s_FileInfo___setstate_cython __pyx_mstate_global->__pyx_n_s_FileInfo___setstate_cython
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s__5 __pyx_mstate_global->__pyx_n_s__5
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_fileinfo __pyx_mstate_global->__pyx_n_s_ssh2_fileinfo
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+/* #### Code section: module_code ### */
 
 /* "ssh2/fileinfo.pyx":27
  *     """Representation of stat structure - libssh2 >= 1.7"""
@@ -1308,12 +2478,20 @@ static PyObject *__pyx_tuple__2;
 /* Python wrapper */
 static int __pyx_pw_4ssh2_8fileinfo_8FileInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_8fileinfo_8FileInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
-    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1323,12 +2501,10 @@ static int __pyx_pw_4ssh2_8fileinfo_8FileInfo_1__cinit__(PyObject *__pyx_v_self,
 
 static int __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
 
   /* "ssh2/fileinfo.pyx":28
  * 
@@ -1346,7 +2522,7 @@ static int __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(struct __pyx_obj_4ssh2_8
  *             raise MemoryError
  * 
  */
-  __pyx_t_1 = ((__pyx_v_self->_stat == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_stat == NULL);
   if (unlikely(__pyx_t_1)) {
 
     /* "ssh2/fileinfo.pyx":31
@@ -1382,7 +2558,6 @@ static int __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(struct __pyx_obj_4ssh2_8
   __Pyx_AddTraceback("ssh2.fileinfo.FileInfo.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
@@ -1397,8 +2572,10 @@ static int __pyx_pf_4ssh2_8fileinfo_8FileInfo___cinit__(struct __pyx_obj_4ssh2_8
 /* Python wrapper */
 static void __pyx_pw_4ssh2_8fileinfo_8FileInfo_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_8fileinfo_8FileInfo_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_8fileinfo_8FileInfo_2__dealloc__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1406,8 +2583,6 @@ static void __pyx_pw_4ssh2_8fileinfo_8FileInfo_3__dealloc__(PyObject *__pyx_v_se
 }
 
 static void __pyx_pf_4ssh2_8fileinfo_8FileInfo_2__dealloc__(struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/fileinfo.pyx":34
  * 
@@ -1427,23 +2602,24 @@ static void __pyx_pf_4ssh2_8fileinfo_8FileInfo_2__dealloc__(struct __pyx_obj_4ss
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
-/* "ssh2/fileinfo.pyx":37
+/* "ssh2/fileinfo.pyx":36
+ *         free(self._stat)
  * 
- *     @property
- *     def st_size(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_size(self):
  *         return self._stat.st_size
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_size_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_size_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_size___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1458,7 +2634,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_size___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":38
  *     @property
@@ -1474,12 +2650,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_size___get__(struct __py
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":37
+  /* "ssh2/fileinfo.pyx":36
+ *         free(self._stat)
  * 
- *     @property
- *     def st_size(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_size(self):
  *         return self._stat.st_size
- * 
  */
 
   /* function exit code */
@@ -1493,20 +2669,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_size___get__(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":41
+/* "ssh2/fileinfo.pyx":40
+ *         return self._stat.st_size
  * 
- *     @property
- *     def st_mode(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mode(self):
  *         return self._stat.st_mode
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_mode_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_mode_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_mode___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1521,7 +2699,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_mode___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":42
  *     @property
@@ -1537,12 +2715,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_mode___get__(struct __py
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":41
+  /* "ssh2/fileinfo.pyx":40
+ *         return self._stat.st_size
  * 
- *     @property
- *     def st_mode(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mode(self):
  *         return self._stat.st_mode
- * 
  */
 
   /* function exit code */
@@ -1556,20 +2734,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_mode___get__(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":45
+/* "ssh2/fileinfo.pyx":44
+ *         return self._stat.st_mode
  * 
- *     @property
- *     def st_ino(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ino(self):
  *         return self._stat.st_ino
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_ino_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_ino_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_ino___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1584,7 +2764,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_ino___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":46
  *     @property
@@ -1600,12 +2780,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_ino___get__(struct __pyx
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":45
+  /* "ssh2/fileinfo.pyx":44
+ *         return self._stat.st_mode
  * 
- *     @property
- *     def st_ino(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ino(self):
  *         return self._stat.st_ino
- * 
  */
 
   /* function exit code */
@@ -1619,20 +2799,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_ino___get__(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":49
+/* "ssh2/fileinfo.pyx":48
+ *         return self._stat.st_ino
  * 
- *     @property
- *     def st_nlink(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_nlink(self):
  *         return self._stat.st_nlink
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_nlink_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_nlink_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_nlink___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1647,7 +2829,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_nlink___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":50
  *     @property
@@ -1663,12 +2845,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_nlink___get__(struct __p
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":49
+  /* "ssh2/fileinfo.pyx":48
+ *         return self._stat.st_ino
  * 
- *     @property
- *     def st_nlink(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_nlink(self):
  *         return self._stat.st_nlink
- * 
  */
 
   /* function exit code */
@@ -1682,20 +2864,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_nlink___get__(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":53
+/* "ssh2/fileinfo.pyx":52
+ *         return self._stat.st_nlink
  * 
- *     @property
- *     def st_uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_uid(self):
  *         return self._stat.st_uid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_uid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_uid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_uid___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1710,7 +2894,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_uid___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":54
  *     @property
@@ -1726,12 +2910,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_uid___get__(struct __pyx
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":53
+  /* "ssh2/fileinfo.pyx":52
+ *         return self._stat.st_nlink
  * 
- *     @property
- *     def st_uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_uid(self):
  *         return self._stat.st_uid
- * 
  */
 
   /* function exit code */
@@ -1745,20 +2929,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_uid___get__(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":57
+/* "ssh2/fileinfo.pyx":56
+ *         return self._stat.st_uid
  * 
- *     @property
- *     def st_gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_gid(self):
  *         return self._stat.st_gid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_gid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_6st_gid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_gid___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1773,7 +2959,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_gid___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":58
  *     @property
@@ -1789,12 +2975,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_gid___get__(struct __pyx
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":57
+  /* "ssh2/fileinfo.pyx":56
+ *         return self._stat.st_uid
  * 
- *     @property
- *     def st_gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_gid(self):
  *         return self._stat.st_gid
- * 
  */
 
   /* function exit code */
@@ -1808,20 +2994,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6st_gid___get__(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":61
+/* "ssh2/fileinfo.pyx":60
+ *         return self._stat.st_gid
  * 
- *     @property
- *     def st_rdev(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_rdev(self):
  *         return self._stat.st_rdev
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_rdev_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7st_rdev_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_rdev___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1836,7 +3024,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_rdev___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":62
  *     @property
@@ -1852,12 +3040,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_rdev___get__(struct __py
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":61
+  /* "ssh2/fileinfo.pyx":60
+ *         return self._stat.st_gid
  * 
- *     @property
- *     def st_rdev(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_rdev(self):
  *         return self._stat.st_rdev
- * 
  */
 
   /* function exit code */
@@ -1871,20 +3059,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_7st_rdev___get__(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":65
+/* "ssh2/fileinfo.pyx":64
+ *         return self._stat.st_rdev
  * 
- *     @property
- *     def st_blksize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blksize(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blksize
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_10st_blksize_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_10st_blksize_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_10st_blksize___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1899,7 +3089,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_10st_blksize___get__(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":67
  *     def st_blksize(self):
@@ -1915,12 +3105,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_10st_blksize___get__(struct
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":65
+  /* "ssh2/fileinfo.pyx":64
+ *         return self._stat.st_rdev
  * 
- *     @property
- *     def st_blksize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blksize(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blksize
  */
 
   /* function exit code */
@@ -1934,20 +3124,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_10st_blksize___get__(struct
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":72
+/* "ssh2/fileinfo.pyx":71
+ *             return None
  * 
- *     @property
- *     def st_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blocks(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blocks
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_9st_blocks_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_9st_blocks_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_9st_blocks___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1962,7 +3154,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_9st_blocks___get__(struct __
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":74
  *     def st_blocks(self):
@@ -1978,12 +3170,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_9st_blocks___get__(struct __
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":72
+  /* "ssh2/fileinfo.pyx":71
+ *             return None
  * 
- *     @property
- *     def st_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blocks(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blocks
  */
 
   /* function exit code */
@@ -1997,20 +3189,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_9st_blocks___get__(struct __
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":79
+/* "ssh2/fileinfo.pyx":78
+ *             return None
  * 
- *     @property
- *     def st_atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_atime(self):
  *         return self._stat.st_atime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_atime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_atime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_atime___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2025,7 +3219,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_atime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":80
  *     @property
@@ -2041,12 +3235,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_atime___get__(struct __p
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":79
+  /* "ssh2/fileinfo.pyx":78
+ *             return None
  * 
- *     @property
- *     def st_atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_atime(self):
  *         return self._stat.st_atime
- * 
  */
 
   /* function exit code */
@@ -2060,20 +3254,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_atime___get__(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":83
+/* "ssh2/fileinfo.pyx":82
+ *         return self._stat.st_atime
  * 
- *     @property
- *     def st_mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mtime(self):
  *         return self._stat.st_mtime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_mtime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_mtime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_mtime___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2088,7 +3284,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_mtime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":84
  *     @property
@@ -2104,12 +3300,12 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_mtime___get__(struct __p
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":83
+  /* "ssh2/fileinfo.pyx":82
+ *         return self._stat.st_atime
  * 
- *     @property
- *     def st_mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mtime(self):
  *         return self._stat.st_mtime
- * 
  */
 
   /* function exit code */
@@ -2123,19 +3319,22 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_mtime___get__(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/fileinfo.pyx":87
+/* "ssh2/fileinfo.pyx":86
+ *         return self._stat.st_mtime
  * 
- *     @property
- *     def st_ctime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ctime(self):
  *         return self._stat.st_ctime
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_ctime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_8st_ctime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_ctime___get__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2150,7 +3349,7 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_ctime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/fileinfo.pyx":88
  *     @property
@@ -2164,10 +3363,11 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_ctime___get__(struct __p
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/fileinfo.pyx":87
+  /* "ssh2/fileinfo.pyx":86
+ *         return self._stat.st_mtime
  * 
- *     @property
- *     def st_ctime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ctime(self):
  *         return self._stat.st_ctime
  */
 
@@ -2184,17 +3384,45 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_8st_ctime___get__(struct __p
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__[] = "FileInfo.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__, "FileInfo.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2205,33 +3433,28 @@ static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__(PyObject
 static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.fileinfo.FileInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2241,21 +3464,104 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__(CYTHON_UN
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__[] = "FileInfo.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__, "FileInfo.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.fileinfo.FileInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__(((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2263,33 +3569,28 @@ static PyObject *__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__(PyObjec
 static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8fileinfo_FileInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.fileinfo.FileInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2299,12 +3600,17 @@ static PyObject *__pyx_pf_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__(CYTHON_
 
 static PyObject *__pyx_tp_new_4ssh2_8fileinfo_FileInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   if (unlikely(__pyx_pw_4ssh2_8fileinfo_8FileInfo_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
   return o;
   bad:
@@ -2314,8 +3620,10 @@ static PyObject *__pyx_tp_new_4ssh2_8fileinfo_FileInfo(PyTypeObject *t, CYTHON_U
 
 static void __pyx_tp_dealloc_4ssh2_8fileinfo_FileInfo(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_8fileinfo_FileInfo) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   {
@@ -2326,7 +3634,14 @@ static void __pyx_tp_dealloc_4ssh2_8fileinfo_FileInfo(PyObject *o) {
     __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyObject *__pyx_getprop_4ssh2_8fileinfo_8FileInfo_st_size(PyObject *o, CYTHON_UNUSED void *x) {
@@ -2378,8 +3693,8 @@ static PyObject *__pyx_getprop_4ssh2_8fileinfo_8FileInfo_st_ctime(PyObject *o, C
 }
 
 static PyMethodDef __pyx_methods_4ssh2_8fileinfo_FileInfo[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__, METH_O, __pyx_doc_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8fileinfo_8FileInfo_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8fileinfo_8FileInfo_6__setstate_cython__},
   {0, 0, 0, 0}
 };
 
@@ -2398,10 +3713,27 @@ static struct PyGetSetDef __pyx_getsets_4ssh2_8fileinfo_FileInfo[] = {
   {(char *)"st_ctime", __pyx_getprop_4ssh2_8fileinfo_8FileInfo_st_ctime, 0, (char *)0, 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_8fileinfo_FileInfo_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_8fileinfo_FileInfo},
+  {Py_tp_doc, (void *)PyDoc_STR("Representation of stat structure - libssh2 >= 1.7")},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_8fileinfo_FileInfo},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_8fileinfo_FileInfo},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_8fileinfo_FileInfo},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_8fileinfo_FileInfo_spec = {
+  "ssh2.fileinfo.FileInfo",
+  sizeof(struct __pyx_obj_4ssh2_8fileinfo_FileInfo),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_8fileinfo_FileInfo_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_8fileinfo_FileInfo = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.fileinfo.FileInfo", /*tp_name*/
+  "ssh2.fileinfo.""FileInfo", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_8fileinfo_FileInfo), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_8fileinfo_FileInfo, /*tp_dealloc*/
@@ -2430,7 +3762,7 @@ static PyTypeObject __pyx_type_4ssh2_8fileinfo_FileInfo = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  "Representation of stat structure - libssh2 >= 1.7", /*tp_doc*/
+  PyDoc_STR("Representation of stat structure - libssh2 >= 1.7"), /*tp_doc*/
   0, /*tp_traverse*/
   0, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -2444,7 +3776,9 @@ static PyTypeObject __pyx_type_4ssh2_8fileinfo_FileInfo = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_8fileinfo_FileInfo, /*tp_new*/
@@ -2458,54 +3792,33 @@ static PyTypeObject __pyx_type_4ssh2_8fileinfo_FileInfo = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_fileinfo(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_fileinfo},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "fileinfo",
-    __pyx_k_Available_only_when_built_on_lib, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -2515,24 +3828,42 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_FileInfo, __pyx_k_FileInfo, sizeof(__pyx_k_FileInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_FileInfo, __pyx_k_FileInfo, sizeof(__pyx_k_FileInfo), 0, 0, 1, 1},
+    {&__pyx_n_s_FileInfo___reduce_cython, __pyx_k_FileInfo___reduce_cython, sizeof(__pyx_k_FileInfo___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_FileInfo___setstate_cython, __pyx_k_FileInfo___setstate_cython, sizeof(__pyx_k_FileInfo___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_fileinfo, __pyx_k_ssh2_fileinfo, sizeof(__pyx_k_ssh2_fileinfo), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 31, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
@@ -2540,42 +3871,52 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(1, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(1, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -2616,16 +3957,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_8fileinfo_FileInfo.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_8fileinfo_FileInfo = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_8fileinfo_FileInfo_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_8fileinfo_FileInfo)) __PYX_ERR(0, 24, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_8fileinfo_FileInfo_spec, __pyx_ptype_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_8fileinfo_FileInfo = &__pyx_type_4ssh2_8fileinfo_FileInfo;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_8fileinfo_FileInfo.tp_dictoffset && __pyx_type_4ssh2_8fileinfo_FileInfo.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_8fileinfo_FileInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_8fileinfo_FileInfo->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_8fileinfo_FileInfo->tp_dictoffset && __pyx_ptype_4ssh2_8fileinfo_FileInfo->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_8fileinfo_FileInfo->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FileInfo, (PyObject *)&__pyx_type_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __pyx_ptype_4ssh2_8fileinfo_FileInfo = &__pyx_type_4ssh2_8fileinfo_FileInfo;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FileInfo, (PyObject *) __pyx_ptype_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_8fileinfo_FileInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -2658,6 +4012,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_fileinfo(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_fileinfo},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "fileinfo",
+      __pyx_k_Available_only_when_built_on_lib, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -2708,12 +4111,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -2723,8 +4135,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -2734,8 +4147,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -2751,7 +4168,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_fileinfo(PyObject *__pyx_pyinit_mo
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2765,6 +4187,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_fileinfo(PyObject *__pyx_pyinit_mo
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("fileinfo", __pyx_methods, __pyx_k_Available_only_when_built_on_lib, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "fileinfo" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -2775,7 +4224,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_fileinfo(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -2783,48 +4232,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("fileinfo", __pyx_methods, __pyx_k_Available_only_when_built_on_lib, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -2836,7 +4268,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.fileinfo")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.fileinfo", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.fileinfo", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -2848,7 +4280,7 @@ if (!__Pyx_RefNanny) {
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
   (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_type_import_code();
   (void)__Pyx_modinit_variable_import_code();
   (void)__Pyx_modinit_function_import_code();
@@ -2857,26 +4289,57 @@ if (!__Pyx_RefNanny) {
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
 
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8fileinfo_8FileInfo_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FileInfo___reduce_cython, NULL, __pyx_n_s_ssh2_fileinfo, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8fileinfo_8FileInfo_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FileInfo___setstate_cython, NULL, __pyx_n_s_ssh2_fileinfo, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
   /* "ssh2/fileinfo.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.fileinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.fileinfo");
   }
@@ -2890,6 +4353,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -2909,40 +4388,396 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
 #endif
-    return PyObject_GetAttr(obj, attr_name);
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
 }
-#endif
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
 #endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
     }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
     return result;
 }
+#endif
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
     Py_ssize_t num_found)
 {
     Py_ssize_t num_expected;
@@ -2965,25 +4800,58 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 /* KeywordStringCheck */
 static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict,
+    PyObject *kw,
     const char* function_name,
     int kw_allowed)
 {
     PyObject* key = 0;
     Py_ssize_t pos = 0;
 #if CYTHON_COMPILING_IN_PYPY
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
         goto invalid_keyword;
     return 1;
 #else
-    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
         #if PY_MAJOR_VERSION < 3
         if (unlikely(!PyString_Check(key)))
         #endif
             if (unlikely(!PyUnicode_Check(key)))
                 goto invalid_keyword_type;
     }
-    if ((!kw_allowed) && unlikely(key))
+    if (!kw_allowed && unlikely(key))
         goto invalid_keyword;
     return 1;
 invalid_keyword_type:
@@ -2992,66 +4860,23 @@ static int __Pyx_CheckKeywordStrings(
     return 0;
 #endif
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
     return 0;
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -3184,13 +5009,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -3198,6 +5019,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -3206,205 +5033,2137 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
-#endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
+}
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
     PyObject *descr;
     PyTypeObject *tp = Py_TYPE(obj);
     if (unlikely(!PyString_Check(attr_name))) {
         return PyObject_GenericGetAttr(obj, attr_name);
     }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
+#endif
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
     }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
         }
     }
-    return descr;
+    Py_INCREF(result);
+    return result;
 }
-#endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
 }
-#endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
     }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
     }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
 }
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
 #endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
     }
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
     }
-    return result;
+    return 0;
 }
-
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
 #else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
     }
-#endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+            return NULL;
         }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
     }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    self = ((PyCFunctionObject*)func)->m_self;
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
         }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
 #endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
-    return ret;
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
 }
 
 /* PyDictVersioning */
@@ -3435,12 +7194,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -3454,7 +7214,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -3476,6 +7236,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -3554,17 +7315,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -3599,6 +7444,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -3614,7 +7460,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -3661,6 +7507,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value) {
@@ -3693,10 +7540,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned P
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned PY_LONG_LONG),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned PY_LONG_LONG));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3731,10 +7611,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3769,10 +7682,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3807,12 +7753,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(time_t),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(time_t));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__5);
     }
+    return name;
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -3849,7 +7844,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3858,168 +7853,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4045,7 +8111,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -4054,168 +8120,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4232,7 +8369,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -4253,6 +8390,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -4277,11 +8430,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -4329,47 +8482,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -4377,30 +8561,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -4455,7 +8643,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -4484,22 +8672,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -4565,13 +8757,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -4639,4 +8829,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/fileinfo.pxd b/ssh2/fileinfo.pxd
index 594d3ec0..9fd6f4c9 100644
--- a/ssh2/fileinfo.pxd
+++ b/ssh2/fileinfo.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 cdef class FileInfo:
     """Representation of stat structure"""
diff --git a/ssh2/fileinfo.pyx b/ssh2/fileinfo.pyx
index 9a6630ac..f0afd63a 100644
--- a/ssh2/fileinfo.pyx
+++ b/ssh2/fileinfo.pyx
@@ -18,7 +18,7 @@
 
 from libc.stdlib cimport malloc, free
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 cdef class FileInfo:
diff --git a/ssh2/knownhost.c b/ssh2/knownhost.c
index 85cf8f0d..ec32044b 100644
--- a/ssh2/knownhost.c
+++ b/ssh2/knownhost.c
@@ -1,22 +1,71 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "libssh2/include/libssh2.h",
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.knownhost",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/knownhost.pyx"
+        ]
+    },
+    "module_name": "ssh2.knownhost"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +84,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +92,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +129,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +149,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +277,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +306,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +317,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +340,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +367,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +391,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +475,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +499,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +516,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +578,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +613,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +765,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +782,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +872,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +918,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +952,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1046,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1061,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1103,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1120,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1167,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1187,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1227,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -796,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -816,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -826,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -856,12 +1361,58 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
     PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
@@ -878,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -908,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -943,24 +1495,27 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/knownhost.pyx",
-  "stringsource",
+  "<stringsource>",
   "ssh2/session.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -968,11 +1523,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -981,7 +1534,7 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry;
 struct __pyx_obj_4ssh2_9knownhost_KnownHost;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1034,6 +1587,7 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
   struct __pyx_obj_4ssh2_7session_Session *_session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1042,11 +1596,11 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1056,28 +1610,40 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1088,6 +1654,10 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1099,6 +1669,57 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1106,38 +1727,109 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
+#endif
+#endif
 #endif
 
 /* PyObjectCall.proto */
@@ -1152,22 +1844,16 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallNoArg.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
-#else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
-#endif
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1197,18 +1883,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* GetModuleGlobalName.proto */
 #if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
     static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
     (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1216,45 +1902,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
-#endif
-
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
@@ -1262,17 +1909,14 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
 
 /* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
     const char* function_name);
 
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
@@ -1293,7 +1937,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1315,7 +1959,11 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
+        #endif
         __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
@@ -1325,6 +1973,34 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
 #define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
 #endif
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1339,29 +2015,28 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
 #endif
 
 /* Import.proto */
@@ -1370,6 +2045,146 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 /* ImportFrom.proto */
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
 
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1378,6 +2193,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1391,18 +2207,19 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
 
 /* CIntFromPy.proto */
 static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
@@ -1413,6 +2230,22 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
 
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1422,65 +2255,81 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 
-/* Module declarations from 'ssh2.error_codes' */
+/* Module declarations from "ssh2.error_codes" */
 
-/* Module declarations from 'ssh2.knownhost' */
-static PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHostEntry = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHost = 0;
+/* Module declarations from "ssh2.knownhost" */
 static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhost_PyKnownHostEntry(struct libssh2_knownhost *); /*proto*/
 static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhost_PyNewKnownHostEntry(void); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.knownhost"
 extern int __pyx_module_is_main_ssh2__knownhost;
 int __pyx_module_is_main_ssh2__knownhost = 0;
 
-/* Implementation of 'ssh2.knownhost' */
+/* Implementation of "ssh2.knownhost" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
 static PyObject *__pyx_builtin_NotImplementedError;
-static const char __pyx_k__6[] = "";
+/* #### Code section: string_decls ### */
+static const char __pyx_k__4[] = "";
+static const char __pyx_k__6[] = ".";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__35[] = "?";
+static const char __pyx_k_add[] = "add";
+static const char __pyx_k_buf[] = "buf";
+static const char __pyx_k_get[] = "get";
 static const char __pyx_k_key[] = "key";
+static const char __pyx_k_addc[] = "addc";
 static const char __pyx_k_host[] = "host";
 static const char __pyx_k_line[] = "line";
 static const char __pyx_k_main[] = "__main__";
@@ -1489,46 +2338,91 @@ static const char __pyx_k_port[] = "port";
 static const char __pyx_k_prev[] = "prev";
 static const char __pyx_k_repr[] = "__repr__";
 static const char __pyx_k_salt[] = "salt";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_check[] = "check";
 static const char __pyx_k_entry[] = "entry";
+static const char __pyx_k_key_2[] = "_key";
+static const char __pyx_k_store[] = "_store";
 static const char __pyx_k_base64[] = "base64";
+static const char __pyx_k_checkp[] = "checkp";
+static const char __pyx_k_delete[] = "delete";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_f_type[] = "f_type";
+static const char __pyx_k_host_2[] = "_host";
 static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_keylen[] = "keylen";
+static const char __pyx_k_line_2[] = "_line";
 static const char __pyx_k_name_2[] = "__name__";
+static const char __pyx_k_outlen[] = "outlen";
+static const char __pyx_k_output[] = "output";
+static const char __pyx_k_prev_2[] = "_prev";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_salt_2[] = "_salt";
 static const char __pyx_k_buf_len[] = "buf_len";
 static const char __pyx_k_comment[] = "comment";
+static const char __pyx_k_dealloc[] = "_dealloc__";
+static const char __pyx_k_disable[] = "disable";
+static const char __pyx_k_entries[] = "entries";
 static const char __pyx_k_session[] = "session";
 static const char __pyx_k_filename[] = "filename";
 static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_line_len[] = "line_len";
+static const char __pyx_k_readfile[] = "readfile";
+static const char __pyx_k_readline[] = "readline";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_typemask[] = "typemask";
 static const char __pyx_k_KnownHost[] = "KnownHost";
 static const char __pyx_k_TypeError[] = "TypeError";
 static const char __pyx_k_b64decode[] = "b64decode";
+static const char __pyx_k_comment_2[] = "_comment";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_writefile[] = "writefile";
 static const char __pyx_k_writeline[] = "writeline";
+static const char __pyx_k_b_filename[] = "b_filename";
 static const char __pyx_k_exceptions[] = "exceptions";
+static const char __pyx_k_filename_2[] = "_filename";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_comment_len[] = "comment_len";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
+static const char __pyx_k_KnownHost_add[] = "KnownHost.add";
+static const char __pyx_k_KnownHost_get[] = "KnownHost.get";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
 static const char __pyx_k_KnownHostEntry[] = "KnownHostEntry";
 static const char __pyx_k_KnownHostError[] = "KnownHostError";
+static const char __pyx_k_KnownHost_addc[] = "KnownHost.addc";
+static const char __pyx_k_ssh2_knownhost[] = "ssh2.knownhost";
+static const char __pyx_k_KnownHost_check[] = "KnownHost.check";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_KnownHost_checkp[] = "KnownHost.checkp";
+static const char __pyx_k_KnownHost_delete[] = "KnownHost.delete";
 static const char __pyx_k_KnownHostAddError[] = "KnownHostAddError";
 static const char __pyx_k_KnownHostGetError[] = "KnownHostGetError";
+static const char __pyx_k_KnownHost_readfile[] = "KnownHost.readfile";
+static const char __pyx_k_KnownHost_readline[] = "KnownHost.readline";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_ssh2_knownhost_pyx[] = "ssh2/knownhost.pyx";
 static const char __pyx_k_KnownHostCheckError[] = "KnownHostCheckError";
+static const char __pyx_k_KnownHost_writefile[] = "KnownHost.writefile";
+static const char __pyx_k_KnownHost_writeline[] = "KnownHost.writeline";
 static const char __pyx_k_NotImplementedError[] = "NotImplementedError";
 static const char __pyx_k_KnownHostDeleteError[] = "KnownHostDeleteError";
 static const char __pyx_k_KnownHostCheckFailure[] = "KnownHostCheckFailure";
 static const char __pyx_k_KnownHostReadFileError[] = "KnownHostReadFileError";
 static const char __pyx_k_KnownHostReadLineError[] = "KnownHostReadLineError";
+static const char __pyx_k_KnownHostEntry__dealloc[] = "KnownHostEntry._dealloc__";
 static const char __pyx_k_KnownHostWriteFileError[] = "KnownHostWriteFileError";
 static const char __pyx_k_KnownHostWriteLineError[] = "KnownHostWriteLineError";
+static const char __pyx_k_KnownHost___reduce_cython[] = "KnownHost.__reduce_cython__";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEY_MASK[] = "LIBSSH2_KNOWNHOST_KEY_MASK";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEY_RSA1[] = "LIBSSH2_KNOWNHOST_KEY_RSA1";
 static const char __pyx_k_KnownHostCheckMisMatchError[] = "KnownHostCheckMisMatchError";
 static const char __pyx_k_KnownHostCheckNotFoundError[] = "KnownHostCheckNotFoundError";
+static const char __pyx_k_KnownHost___setstate_cython[] = "KnownHost.__setstate_cython__";
 static const char __pyx_k_Known_host_entry_for_host_s[] = "Known host entry for host: %s";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEY_SHIFT[] = "LIBSSH2_KNOWNHOST_KEY_SHIFT";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_TYPE_MASK[] = "LIBSSH2_KNOWNHOST_TYPE_MASK";
@@ -1541,6 +2435,7 @@ static const char __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_MASK[] = "LIBSSH2_KNOWNHOST_K
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEY_ED25519[] = "LIBSSH2_KNOWNHOST_KEY_ED25519";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEY_UNKNOWN[] = "LIBSSH2_KNOWNHOST_KEY_UNKNOWN";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_TYPE_CUSTOM[] = "LIBSSH2_KNOWNHOST_TYPE_CUSTOM";
+static const char __pyx_k_KnownHostEntry___reduce_cython[] = "KnownHostEntry.__reduce_cython__";
 static const char __pyx_k_Error_deleting_known_host_entry[] = "Error deleting known host entry - error code %s";
 static const char __pyx_k_Host_s_not_found_in_known_hosts[] = "Host %s not found in known hosts collection";
 static const char __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_BASE64[] = "LIBSSH2_KNOWNHOST_KEYENC_BASE64";
@@ -1556,87 +2451,10 @@ static const char __pyx_k_Error_reading_known_hosts_file_s[] = "Error reading kn
 static const char __pyx_k_Error_retrieving_known_hosts_err[] = "Error retrieving known hosts - error code %s";
 static const char __pyx_k_Error_writing_known_hosts_to_fil[] = "Error writing known hosts to file %s";
 static const char __pyx_k_Error_writing_line_for_known_hos[] = "Error writing line for known host entry - error code %s";
+static const char __pyx_k_KnownHostEntry___setstate_cython[] = "KnownHostEntry.__setstate_cython__";
 static const char __pyx_k_Known_host_key_for_host_s_does_n[] = "Known host key for host %s does not match provided key - error code %s";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_kp_s_Could_not_check_known_host_entry;
-static PyObject *__pyx_kp_s_Error_adding_known_host_entry_fo;
-static PyObject *__pyx_kp_s_Error_deleting_known_host_entry;
-static PyObject *__pyx_kp_s_Error_deleting_line_from_known_h;
-static PyObject *__pyx_kp_s_Error_reading_known_hosts_file_s;
-static PyObject *__pyx_kp_s_Error_retrieving_known_hosts_err;
-static PyObject *__pyx_kp_s_Error_writing_known_hosts_to_fil;
-static PyObject *__pyx_kp_s_Error_writing_line_for_known_hos;
-static PyObject *__pyx_kp_s_Host_s_not_found_in_known_hosts;
-static PyObject *__pyx_n_s_KnownHost;
-static PyObject *__pyx_n_s_KnownHostAddError;
-static PyObject *__pyx_n_s_KnownHostCheckError;
-static PyObject *__pyx_n_s_KnownHostCheckFailure;
-static PyObject *__pyx_n_s_KnownHostCheckMisMatchError;
-static PyObject *__pyx_n_s_KnownHostCheckNotFoundError;
-static PyObject *__pyx_n_s_KnownHostDeleteError;
-static PyObject *__pyx_n_s_KnownHostEntry;
-static PyObject *__pyx_n_s_KnownHostError;
-static PyObject *__pyx_n_s_KnownHostGetError;
-static PyObject *__pyx_n_s_KnownHostReadFileError;
-static PyObject *__pyx_n_s_KnownHostReadLineError;
-static PyObject *__pyx_n_s_KnownHostWriteFileError;
-static PyObject *__pyx_n_s_KnownHostWriteLineError;
-static PyObject *__pyx_kp_s_Known_host_entry_for_host_s;
-static PyObject *__pyx_kp_s_Known_host_key_for_host_s_does_n;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN;
-static PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_NotImplementedError;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_kp_s_Unknown_error_occurred_checking;
-static PyObject *__pyx_kp_b__6;
-static PyObject *__pyx_n_s_b64decode;
-static PyObject *__pyx_n_s_base64;
-static PyObject *__pyx_n_s_buf_len;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_comment;
-static PyObject *__pyx_n_s_entry;
-static PyObject *__pyx_n_s_exceptions;
-static PyObject *__pyx_n_s_f_type;
-static PyObject *__pyx_n_s_filename;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_host;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_key;
-static PyObject *__pyx_n_s_line;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_name_2;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_port;
-static PyObject *__pyx_n_s_prev;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_repr;
-static PyObject *__pyx_n_s_salt;
-static PyObject *__pyx_kp_s_self__store_cannot_be_converted;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_typemask;
-static PyObject *__pyx_n_s_writeline;
+/* #### Code section: decls ### */
 static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_self); /* proto */
@@ -1662,54 +2480,891 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_24__reduce_cython__(CYTHON
 static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_9knownhost_KnownHost(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static int __pyx_k__3;
-static int __pyx_k__4;
-static int __pyx_k__5;
-static int __pyx_k__7;
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__8;
-static PyObject *__pyx_tuple__9;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_9knownhost_KnownHostEntry;
+  PyObject *__pyx_type_4ssh2_9knownhost_KnownHost;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHostEntry;
+  PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHost;
+  PyObject *__pyx_kp_u_Could_not_check_known_host_entry;
+  PyObject *__pyx_kp_u_Error_adding_known_host_entry_fo;
+  PyObject *__pyx_kp_u_Error_deleting_known_host_entry;
+  PyObject *__pyx_kp_u_Error_deleting_line_from_known_h;
+  PyObject *__pyx_kp_u_Error_reading_known_hosts_file_s;
+  PyObject *__pyx_kp_u_Error_retrieving_known_hosts_err;
+  PyObject *__pyx_kp_u_Error_writing_known_hosts_to_fil;
+  PyObject *__pyx_kp_u_Error_writing_line_for_known_hos;
+  PyObject *__pyx_kp_u_Host_s_not_found_in_known_hosts;
+  PyObject *__pyx_n_s_KnownHost;
+  PyObject *__pyx_n_s_KnownHostAddError;
+  PyObject *__pyx_n_s_KnownHostCheckError;
+  PyObject *__pyx_n_s_KnownHostCheckFailure;
+  PyObject *__pyx_n_s_KnownHostCheckMisMatchError;
+  PyObject *__pyx_n_s_KnownHostCheckNotFoundError;
+  PyObject *__pyx_n_s_KnownHostDeleteError;
+  PyObject *__pyx_n_s_KnownHostEntry;
+  PyObject *__pyx_n_s_KnownHostEntry___reduce_cython;
+  PyObject *__pyx_n_s_KnownHostEntry___setstate_cython;
+  PyObject *__pyx_n_s_KnownHostEntry__dealloc;
+  PyObject *__pyx_n_s_KnownHostError;
+  PyObject *__pyx_n_s_KnownHostGetError;
+  PyObject *__pyx_n_s_KnownHostReadFileError;
+  PyObject *__pyx_n_s_KnownHostReadLineError;
+  PyObject *__pyx_n_s_KnownHostWriteFileError;
+  PyObject *__pyx_n_s_KnownHostWriteLineError;
+  PyObject *__pyx_n_s_KnownHost___reduce_cython;
+  PyObject *__pyx_n_s_KnownHost___setstate_cython;
+  PyObject *__pyx_n_s_KnownHost_add;
+  PyObject *__pyx_n_s_KnownHost_addc;
+  PyObject *__pyx_n_s_KnownHost_check;
+  PyObject *__pyx_n_s_KnownHost_checkp;
+  PyObject *__pyx_n_s_KnownHost_delete;
+  PyObject *__pyx_n_s_KnownHost_get;
+  PyObject *__pyx_n_s_KnownHost_readfile;
+  PyObject *__pyx_n_s_KnownHost_readline;
+  PyObject *__pyx_n_s_KnownHost_writefile;
+  PyObject *__pyx_n_s_KnownHost_writeline;
+  PyObject *__pyx_kp_u_Known_host_entry_for_host_s;
+  PyObject *__pyx_kp_u_Known_host_key_for_host_s_does_n;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN;
+  PyObject *__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_NotImplementedError;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_kp_u_Unknown_error_occurred_checking;
+  PyObject *__pyx_n_s__35;
+  PyObject *__pyx_kp_b__4;
+  PyObject *__pyx_kp_u__6;
+  PyObject *__pyx_n_s_add;
+  PyObject *__pyx_n_s_addc;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_b64decode;
+  PyObject *__pyx_n_s_b_filename;
+  PyObject *__pyx_n_s_base64;
+  PyObject *__pyx_n_s_buf;
+  PyObject *__pyx_n_s_buf_len;
+  PyObject *__pyx_n_s_check;
+  PyObject *__pyx_n_s_checkp;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_comment;
+  PyObject *__pyx_n_s_comment_2;
+  PyObject *__pyx_n_s_comment_len;
+  PyObject *__pyx_n_s_dealloc;
+  PyObject *__pyx_n_s_delete;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_entries;
+  PyObject *__pyx_n_s_entry;
+  PyObject *__pyx_n_s_exceptions;
+  PyObject *__pyx_n_s_f_type;
+  PyObject *__pyx_n_s_filename;
+  PyObject *__pyx_n_s_filename_2;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_get;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_host;
+  PyObject *__pyx_n_s_host_2;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_key;
+  PyObject *__pyx_n_s_key_2;
+  PyObject *__pyx_n_s_keylen;
+  PyObject *__pyx_n_s_line;
+  PyObject *__pyx_n_s_line_2;
+  PyObject *__pyx_n_s_line_len;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_name_2;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_outlen;
+  PyObject *__pyx_n_s_output;
+  PyObject *__pyx_n_s_port;
+  PyObject *__pyx_n_s_prev;
+  PyObject *__pyx_n_s_prev_2;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_readfile;
+  PyObject *__pyx_n_s_readline;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_repr;
+  PyObject *__pyx_n_s_salt;
+  PyObject *__pyx_n_s_salt_2;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_kp_s_self__store_cannot_be_converted;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_knownhost;
+  PyObject *__pyx_kp_s_ssh2_knownhost_pyx;
+  PyObject *__pyx_n_s_store;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_typemask;
+  PyObject *__pyx_n_s_writefile;
+  PyObject *__pyx_n_s_writeline;
+  PyObject *__pyx_int_1024;
+  int __pyx_k_;
+  int __pyx_k__2;
+  int __pyx_k__3;
+  int __pyx_k__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_tuple__10;
+  PyObject *__pyx_tuple__12;
+  PyObject *__pyx_tuple__14;
+  PyObject *__pyx_tuple__16;
+  PyObject *__pyx_tuple__17;
+  PyObject *__pyx_tuple__19;
+  PyObject *__pyx_tuple__21;
+  PyObject *__pyx_tuple__23;
+  PyObject *__pyx_tuple__25;
+  PyObject *__pyx_tuple__27;
+  PyObject *__pyx_tuple__30;
+  PyObject *__pyx_tuple__32;
+  PyObject *__pyx_codeobj__8;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__11;
+  PyObject *__pyx_codeobj__13;
+  PyObject *__pyx_codeobj__15;
+  PyObject *__pyx_codeobj__18;
+  PyObject *__pyx_codeobj__20;
+  PyObject *__pyx_codeobj__22;
+  PyObject *__pyx_codeobj__24;
+  PyObject *__pyx_codeobj__26;
+  PyObject *__pyx_codeobj__28;
+  PyObject *__pyx_codeobj__29;
+  PyObject *__pyx_codeobj__31;
+  PyObject *__pyx_codeobj__33;
+  PyObject *__pyx_codeobj__34;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-/* "ssh2/knownhost.pyx":55
- * 
- * 
- * cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr):             # <<<<<<<<<<<<<<
- *     cdef KnownHost known_host = KnownHost.__new__(KnownHost, session)
- *     known_host._ptr = _ptr
- */
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
 
-static struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_f_4ssh2_9knownhost_PyKnownHost(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session, LIBSSH2_KNOWNHOSTS *__pyx_v__ptr) {
-  struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_known_host = 0;
-  struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_9knownhost_KnownHostEntry);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHost);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_9knownhost_KnownHost);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Could_not_check_known_host_entry);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_adding_known_host_entry_fo);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_deleting_known_host_entry);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_deleting_line_from_known_h);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_reading_known_hosts_file_s);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_retrieving_known_hosts_err);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_writing_known_hosts_to_fil);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_writing_line_for_known_hos);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Host_s_not_found_in_known_hosts);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostAddError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckFailure);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckMisMatchError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostCheckNotFoundError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostDeleteError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostEntry);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostEntry___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostEntry___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostEntry__dealloc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostGetError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostReadFileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostReadLineError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostWriteFileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostWriteLineError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_add);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_addc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_check);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_checkp);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_delete);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_get);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_readfile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_readline);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_writefile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHost_writeline);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Known_host_entry_for_host_s);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Known_host_key_for_host_s_does_n);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_NotImplementedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Unknown_error_occurred_checking);
+  Py_CLEAR(clear_module_state->__pyx_n_s__35);
+  Py_CLEAR(clear_module_state->__pyx_kp_b__4);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__6);
+  Py_CLEAR(clear_module_state->__pyx_n_s_add);
+  Py_CLEAR(clear_module_state->__pyx_n_s_addc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b64decode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_base64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_check);
+  Py_CLEAR(clear_module_state->__pyx_n_s_checkp);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_comment);
+  Py_CLEAR(clear_module_state->__pyx_n_s_comment_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_comment_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_dealloc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_delete);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_entries);
+  Py_CLEAR(clear_module_state->__pyx_n_s_entry);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_f_type);
+  Py_CLEAR(clear_module_state->__pyx_n_s_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_filename_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_host);
+  Py_CLEAR(clear_module_state->__pyx_n_s_host_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_keylen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_line);
+  Py_CLEAR(clear_module_state->__pyx_n_s_line_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_line_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_outlen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_output);
+  Py_CLEAR(clear_module_state->__pyx_n_s_port);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prev);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prev_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readfile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readline);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_repr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_salt);
+  Py_CLEAR(clear_module_state->__pyx_n_s_salt_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_self__store_cannot_be_converted);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_knownhost);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_knownhost_pyx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_store);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_typemask);
+  Py_CLEAR(clear_module_state->__pyx_n_s_writefile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_writeline);
+  Py_CLEAR(clear_module_state->__pyx_int_1024);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_tuple__10);
+  Py_CLEAR(clear_module_state->__pyx_tuple__12);
+  Py_CLEAR(clear_module_state->__pyx_tuple__14);
+  Py_CLEAR(clear_module_state->__pyx_tuple__16);
+  Py_CLEAR(clear_module_state->__pyx_tuple__17);
+  Py_CLEAR(clear_module_state->__pyx_tuple__19);
+  Py_CLEAR(clear_module_state->__pyx_tuple__21);
+  Py_CLEAR(clear_module_state->__pyx_tuple__23);
+  Py_CLEAR(clear_module_state->__pyx_tuple__25);
+  Py_CLEAR(clear_module_state->__pyx_tuple__27);
+  Py_CLEAR(clear_module_state->__pyx_tuple__30);
+  Py_CLEAR(clear_module_state->__pyx_tuple__32);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__11);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__13);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__15);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__18);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__24);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__26);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__28);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__29);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__31);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__33);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__34);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_9knownhost_KnownHostEntry);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHost);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_9knownhost_KnownHost);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Could_not_check_known_host_entry);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_adding_known_host_entry_fo);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_deleting_known_host_entry);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_deleting_line_from_known_h);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_reading_known_hosts_file_s);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_retrieving_known_hosts_err);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_writing_known_hosts_to_fil);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_writing_line_for_known_hos);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Host_s_not_found_in_known_hosts);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostAddError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckFailure);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckMisMatchError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostCheckNotFoundError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostDeleteError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostEntry);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostEntry___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostEntry___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostEntry__dealloc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostGetError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostReadFileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostReadLineError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostWriteFileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostWriteLineError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_add);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_addc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_check);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_checkp);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_delete);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_get);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_readfile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_readline);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_writefile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHost_writeline);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Known_host_entry_for_host_s);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Known_host_key_for_host_s_does_n);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_NotImplementedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Unknown_error_occurred_checking);
+  Py_VISIT(traverse_module_state->__pyx_n_s__35);
+  Py_VISIT(traverse_module_state->__pyx_kp_b__4);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__6);
+  Py_VISIT(traverse_module_state->__pyx_n_s_add);
+  Py_VISIT(traverse_module_state->__pyx_n_s_addc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b64decode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_base64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_check);
+  Py_VISIT(traverse_module_state->__pyx_n_s_checkp);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_comment);
+  Py_VISIT(traverse_module_state->__pyx_n_s_comment_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_comment_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_dealloc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_delete);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_entries);
+  Py_VISIT(traverse_module_state->__pyx_n_s_entry);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_f_type);
+  Py_VISIT(traverse_module_state->__pyx_n_s_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_filename_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_host);
+  Py_VISIT(traverse_module_state->__pyx_n_s_host_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_keylen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_line);
+  Py_VISIT(traverse_module_state->__pyx_n_s_line_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_line_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_outlen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_output);
+  Py_VISIT(traverse_module_state->__pyx_n_s_port);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prev);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prev_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readfile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readline);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_repr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_salt);
+  Py_VISIT(traverse_module_state->__pyx_n_s_salt_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_self__store_cannot_be_converted);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_knownhost);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_knownhost_pyx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_store);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_typemask);
+  Py_VISIT(traverse_module_state->__pyx_n_s_writefile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_writeline);
+  Py_VISIT(traverse_module_state->__pyx_int_1024);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_tuple__10);
+  Py_VISIT(traverse_module_state->__pyx_tuple__12);
+  Py_VISIT(traverse_module_state->__pyx_tuple__14);
+  Py_VISIT(traverse_module_state->__pyx_tuple__16);
+  Py_VISIT(traverse_module_state->__pyx_tuple__17);
+  Py_VISIT(traverse_module_state->__pyx_tuple__19);
+  Py_VISIT(traverse_module_state->__pyx_tuple__21);
+  Py_VISIT(traverse_module_state->__pyx_tuple__23);
+  Py_VISIT(traverse_module_state->__pyx_tuple__25);
+  Py_VISIT(traverse_module_state->__pyx_tuple__27);
+  Py_VISIT(traverse_module_state->__pyx_tuple__30);
+  Py_VISIT(traverse_module_state->__pyx_tuple__32);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__11);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__13);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__15);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__18);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__24);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__26);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__28);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__29);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__31);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__33);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__34);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_9knownhost_KnownHostEntry __pyx_mstate_global->__pyx_type_4ssh2_9knownhost_KnownHostEntry
+#define __pyx_type_4ssh2_9knownhost_KnownHost __pyx_mstate_global->__pyx_type_4ssh2_9knownhost_KnownHost
+#endif
+#define __pyx_ptype_4ssh2_9knownhost_KnownHostEntry __pyx_mstate_global->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry
+#define __pyx_ptype_4ssh2_9knownhost_KnownHost __pyx_mstate_global->__pyx_ptype_4ssh2_9knownhost_KnownHost
+#define __pyx_kp_u_Could_not_check_known_host_entry __pyx_mstate_global->__pyx_kp_u_Could_not_check_known_host_entry
+#define __pyx_kp_u_Error_adding_known_host_entry_fo __pyx_mstate_global->__pyx_kp_u_Error_adding_known_host_entry_fo
+#define __pyx_kp_u_Error_deleting_known_host_entry __pyx_mstate_global->__pyx_kp_u_Error_deleting_known_host_entry
+#define __pyx_kp_u_Error_deleting_line_from_known_h __pyx_mstate_global->__pyx_kp_u_Error_deleting_line_from_known_h
+#define __pyx_kp_u_Error_reading_known_hosts_file_s __pyx_mstate_global->__pyx_kp_u_Error_reading_known_hosts_file_s
+#define __pyx_kp_u_Error_retrieving_known_hosts_err __pyx_mstate_global->__pyx_kp_u_Error_retrieving_known_hosts_err
+#define __pyx_kp_u_Error_writing_known_hosts_to_fil __pyx_mstate_global->__pyx_kp_u_Error_writing_known_hosts_to_fil
+#define __pyx_kp_u_Error_writing_line_for_known_hos __pyx_mstate_global->__pyx_kp_u_Error_writing_line_for_known_hos
+#define __pyx_kp_u_Host_s_not_found_in_known_hosts __pyx_mstate_global->__pyx_kp_u_Host_s_not_found_in_known_hosts
+#define __pyx_n_s_KnownHost __pyx_mstate_global->__pyx_n_s_KnownHost
+#define __pyx_n_s_KnownHostAddError __pyx_mstate_global->__pyx_n_s_KnownHostAddError
+#define __pyx_n_s_KnownHostCheckError __pyx_mstate_global->__pyx_n_s_KnownHostCheckError
+#define __pyx_n_s_KnownHostCheckFailure __pyx_mstate_global->__pyx_n_s_KnownHostCheckFailure
+#define __pyx_n_s_KnownHostCheckMisMatchError __pyx_mstate_global->__pyx_n_s_KnownHostCheckMisMatchError
+#define __pyx_n_s_KnownHostCheckNotFoundError __pyx_mstate_global->__pyx_n_s_KnownHostCheckNotFoundError
+#define __pyx_n_s_KnownHostDeleteError __pyx_mstate_global->__pyx_n_s_KnownHostDeleteError
+#define __pyx_n_s_KnownHostEntry __pyx_mstate_global->__pyx_n_s_KnownHostEntry
+#define __pyx_n_s_KnownHostEntry___reduce_cython __pyx_mstate_global->__pyx_n_s_KnownHostEntry___reduce_cython
+#define __pyx_n_s_KnownHostEntry___setstate_cython __pyx_mstate_global->__pyx_n_s_KnownHostEntry___setstate_cython
+#define __pyx_n_s_KnownHostEntry__dealloc __pyx_mstate_global->__pyx_n_s_KnownHostEntry__dealloc
+#define __pyx_n_s_KnownHostError __pyx_mstate_global->__pyx_n_s_KnownHostError
+#define __pyx_n_s_KnownHostGetError __pyx_mstate_global->__pyx_n_s_KnownHostGetError
+#define __pyx_n_s_KnownHostReadFileError __pyx_mstate_global->__pyx_n_s_KnownHostReadFileError
+#define __pyx_n_s_KnownHostReadLineError __pyx_mstate_global->__pyx_n_s_KnownHostReadLineError
+#define __pyx_n_s_KnownHostWriteFileError __pyx_mstate_global->__pyx_n_s_KnownHostWriteFileError
+#define __pyx_n_s_KnownHostWriteLineError __pyx_mstate_global->__pyx_n_s_KnownHostWriteLineError
+#define __pyx_n_s_KnownHost___reduce_cython __pyx_mstate_global->__pyx_n_s_KnownHost___reduce_cython
+#define __pyx_n_s_KnownHost___setstate_cython __pyx_mstate_global->__pyx_n_s_KnownHost___setstate_cython
+#define __pyx_n_s_KnownHost_add __pyx_mstate_global->__pyx_n_s_KnownHost_add
+#define __pyx_n_s_KnownHost_addc __pyx_mstate_global->__pyx_n_s_KnownHost_addc
+#define __pyx_n_s_KnownHost_check __pyx_mstate_global->__pyx_n_s_KnownHost_check
+#define __pyx_n_s_KnownHost_checkp __pyx_mstate_global->__pyx_n_s_KnownHost_checkp
+#define __pyx_n_s_KnownHost_delete __pyx_mstate_global->__pyx_n_s_KnownHost_delete
+#define __pyx_n_s_KnownHost_get __pyx_mstate_global->__pyx_n_s_KnownHost_get
+#define __pyx_n_s_KnownHost_readfile __pyx_mstate_global->__pyx_n_s_KnownHost_readfile
+#define __pyx_n_s_KnownHost_readline __pyx_mstate_global->__pyx_n_s_KnownHost_readline
+#define __pyx_n_s_KnownHost_writefile __pyx_mstate_global->__pyx_n_s_KnownHost_writefile
+#define __pyx_n_s_KnownHost_writeline __pyx_mstate_global->__pyx_n_s_KnownHost_writeline
+#define __pyx_kp_u_Known_host_entry_for_host_s __pyx_mstate_global->__pyx_kp_u_Known_host_entry_for_host_s
+#define __pyx_kp_u_Known_host_key_for_host_s_does_n __pyx_mstate_global->__pyx_kp_u_Known_host_key_for_host_s_does_n
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN
+#define __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1 __pyx_mstate_global->__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_NotImplementedError __pyx_mstate_global->__pyx_n_s_NotImplementedError
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_u_Unknown_error_occurred_checking __pyx_mstate_global->__pyx_kp_u_Unknown_error_occurred_checking
+#define __pyx_n_s__35 __pyx_mstate_global->__pyx_n_s__35
+#define __pyx_kp_b__4 __pyx_mstate_global->__pyx_kp_b__4
+#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6
+#define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add
+#define __pyx_n_s_addc __pyx_mstate_global->__pyx_n_s_addc
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_b64decode __pyx_mstate_global->__pyx_n_s_b64decode
+#define __pyx_n_s_b_filename __pyx_mstate_global->__pyx_n_s_b_filename
+#define __pyx_n_s_base64 __pyx_mstate_global->__pyx_n_s_base64
+#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf
+#define __pyx_n_s_buf_len __pyx_mstate_global->__pyx_n_s_buf_len
+#define __pyx_n_s_check __pyx_mstate_global->__pyx_n_s_check
+#define __pyx_n_s_checkp __pyx_mstate_global->__pyx_n_s_checkp
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_comment __pyx_mstate_global->__pyx_n_s_comment
+#define __pyx_n_s_comment_2 __pyx_mstate_global->__pyx_n_s_comment_2
+#define __pyx_n_s_comment_len __pyx_mstate_global->__pyx_n_s_comment_len
+#define __pyx_n_s_dealloc __pyx_mstate_global->__pyx_n_s_dealloc
+#define __pyx_n_s_delete __pyx_mstate_global->__pyx_n_s_delete
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_entries __pyx_mstate_global->__pyx_n_s_entries
+#define __pyx_n_s_entry __pyx_mstate_global->__pyx_n_s_entry
+#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions
+#define __pyx_n_s_f_type __pyx_mstate_global->__pyx_n_s_f_type
+#define __pyx_n_s_filename __pyx_mstate_global->__pyx_n_s_filename
+#define __pyx_n_s_filename_2 __pyx_mstate_global->__pyx_n_s_filename_2
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_host __pyx_mstate_global->__pyx_n_s_host
+#define __pyx_n_s_host_2 __pyx_mstate_global->__pyx_n_s_host_2
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key
+#define __pyx_n_s_key_2 __pyx_mstate_global->__pyx_n_s_key_2
+#define __pyx_n_s_keylen __pyx_mstate_global->__pyx_n_s_keylen
+#define __pyx_n_s_line __pyx_mstate_global->__pyx_n_s_line
+#define __pyx_n_s_line_2 __pyx_mstate_global->__pyx_n_s_line_2
+#define __pyx_n_s_line_len __pyx_mstate_global->__pyx_n_s_line_len
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_outlen __pyx_mstate_global->__pyx_n_s_outlen
+#define __pyx_n_s_output __pyx_mstate_global->__pyx_n_s_output
+#define __pyx_n_s_port __pyx_mstate_global->__pyx_n_s_port
+#define __pyx_n_s_prev __pyx_mstate_global->__pyx_n_s_prev
+#define __pyx_n_s_prev_2 __pyx_mstate_global->__pyx_n_s_prev_2
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_readfile __pyx_mstate_global->__pyx_n_s_readfile
+#define __pyx_n_s_readline __pyx_mstate_global->__pyx_n_s_readline
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_repr __pyx_mstate_global->__pyx_n_s_repr
+#define __pyx_n_s_salt __pyx_mstate_global->__pyx_n_s_salt
+#define __pyx_n_s_salt_2 __pyx_mstate_global->__pyx_n_s_salt_2
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_kp_s_self__store_cannot_be_converted __pyx_mstate_global->__pyx_kp_s_self__store_cannot_be_converted
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_knownhost __pyx_mstate_global->__pyx_n_s_ssh2_knownhost
+#define __pyx_kp_s_ssh2_knownhost_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_knownhost_pyx
+#define __pyx_n_s_store __pyx_mstate_global->__pyx_n_s_store
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_typemask __pyx_mstate_global->__pyx_n_s_typemask
+#define __pyx_n_s_writefile __pyx_mstate_global->__pyx_n_s_writefile
+#define __pyx_n_s_writeline __pyx_mstate_global->__pyx_n_s_writeline
+#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024
+#define __pyx_k_ __pyx_mstate_global->__pyx_k_
+#define __pyx_k__2 __pyx_mstate_global->__pyx_k__2
+#define __pyx_k__3 __pyx_mstate_global->__pyx_k__3
+#define __pyx_k__5 __pyx_mstate_global->__pyx_k__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
+#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19
+#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
+#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23
+#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25
+#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27
+#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30
+#define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11
+#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13
+#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15
+#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24
+#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26
+#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28
+#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29
+#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31
+#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33
+#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34
+/* #### Code section: module_code ### */
+
+/* "ssh2/knownhost.pyx":56
+ * 
+ * 
+ * cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr):             # <<<<<<<<<<<<<<
+ *     cdef KnownHost known_host = KnownHost.__new__(KnownHost, session)
+ *     known_host._ptr = _ptr
+ */
+
+static struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_f_4ssh2_9knownhost_PyKnownHost(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session, LIBSSH2_KNOWNHOSTS *__pyx_v__ptr) {
+  struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_known_host = 0;
+  struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyKnownHost", 0);
+  __Pyx_RefNannySetupContext("PyKnownHost", 1);
 
-  /* "ssh2/knownhost.pyx":56
+  /* "ssh2/knownhost.pyx":57
  * 
  * cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr):
  *     cdef KnownHost known_host = KnownHost.__new__(KnownHost, session)             # <<<<<<<<<<<<<<
  *     known_host._ptr = _ptr
  *     return known_host
  */
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
-  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHost(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(0, 57, __pyx_L1_error);
+  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHost(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_known_host = ((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_t_2);
   __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":57
+  /* "ssh2/knownhost.pyx":58
  * cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr):
  *     cdef KnownHost known_host = KnownHost.__new__(KnownHost, session)
  *     known_host._ptr = _ptr             # <<<<<<<<<<<<<<
@@ -1718,19 +3373,19 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_f_4ssh2_9knownhost_PyK
  */
   __pyx_v_known_host->_ptr = __pyx_v__ptr;
 
-  /* "ssh2/knownhost.pyx":58
+  /* "ssh2/knownhost.pyx":59
  *     cdef KnownHost known_host = KnownHost.__new__(KnownHost, session)
  *     known_host._ptr = _ptr
  *     return known_host             # <<<<<<<<<<<<<<
  * 
  * 
  */
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_known_host));
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_known_host);
   __pyx_r = __pyx_v_known_host;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":55
+  /* "ssh2/knownhost.pyx":56
  * 
  * 
  * cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr):             # <<<<<<<<<<<<<<
@@ -1751,7 +3406,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_f_4ssh2_9knownhost_PyK
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":61
+/* "ssh2/knownhost.pyx":62
  * 
  * 
  * cdef KnownHostEntry PyKnownHostEntry(c_ssh2.libssh2_knownhost *_entry):             # <<<<<<<<<<<<<<
@@ -1767,21 +3422,21 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyKnownHostEntry", 0);
+  __Pyx_RefNannySetupContext("PyKnownHostEntry", 1);
 
-  /* "ssh2/knownhost.pyx":62
+  /* "ssh2/knownhost.pyx":63
  * 
  * cdef KnownHostEntry PyKnownHostEntry(c_ssh2.libssh2_knownhost *_entry):
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)             # <<<<<<<<<<<<<<
  *     entry._store = _entry
  *     return entry
  */
-  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHostEntry), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHostEntry), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_1);
   __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":63
+  /* "ssh2/knownhost.pyx":64
  * cdef KnownHostEntry PyKnownHostEntry(c_ssh2.libssh2_knownhost *_entry):
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)
  *     entry._store = _entry             # <<<<<<<<<<<<<<
@@ -1790,19 +3445,19 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
   __pyx_v_entry->_store = __pyx_v__entry;
 
-  /* "ssh2/knownhost.pyx":64
+  /* "ssh2/knownhost.pyx":65
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)
  *     entry._store = _entry
  *     return entry             # <<<<<<<<<<<<<<
  * 
  * 
  */
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_entry));
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_entry);
   __pyx_r = __pyx_v_entry;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":61
+  /* "ssh2/knownhost.pyx":62
  * 
  * 
  * cdef KnownHostEntry PyKnownHostEntry(c_ssh2.libssh2_knownhost *_entry):             # <<<<<<<<<<<<<<
@@ -1822,7 +3477,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":67
+/* "ssh2/knownhost.pyx":68
  * 
  * 
  * cdef KnownHostEntry PyNewKnownHostEntry():             # <<<<<<<<<<<<<<
@@ -1840,21 +3495,21 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyNewKnownHostEntry", 0);
+  __Pyx_RefNannySetupContext("PyNewKnownHostEntry", 1);
 
-  /* "ssh2/knownhost.pyx":68
+  /* "ssh2/knownhost.pyx":69
  * 
  * cdef KnownHostEntry PyNewKnownHostEntry():
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.libssh2_knownhost *_entry
  *     with nogil:
  */
-  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHostEntry), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(((PyTypeObject *)__pyx_ptype_4ssh2_9knownhost_KnownHostEntry), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_1);
   __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":70
+  /* "ssh2/knownhost.pyx":71
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)
  *     cdef c_ssh2.libssh2_knownhost *_entry
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -1864,12 +3519,13 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":71
+        /* "ssh2/knownhost.pyx":72
  *     cdef c_ssh2.libssh2_knownhost *_entry
  *     with nogil:
  *         _entry = <c_ssh2.libssh2_knownhost *>malloc(             # <<<<<<<<<<<<<<
@@ -1878,17 +3534,17 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry = ((struct libssh2_knownhost *)malloc((sizeof(struct libssh2_knownhost))));
 
-        /* "ssh2/knownhost.pyx":73
+        /* "ssh2/knownhost.pyx":74
  *         _entry = <c_ssh2.libssh2_knownhost *>malloc(
  *             sizeof(c_ssh2.libssh2_knownhost))
  *         if _entry is NULL:             # <<<<<<<<<<<<<<
  *             with gil:
  *                 raise MemoryError
  */
-        __pyx_t_2 = ((__pyx_v__entry == NULL) != 0);
-        if (__pyx_t_2) {
+        __pyx_t_2 = (__pyx_v__entry == NULL);
+        if (unlikely(__pyx_t_2)) {
 
-          /* "ssh2/knownhost.pyx":74
+          /* "ssh2/knownhost.pyx":75
  *             sizeof(c_ssh2.libssh2_knownhost))
  *         if _entry is NULL:
  *             with gil:             # <<<<<<<<<<<<<<
@@ -1901,17 +3557,17 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
               #endif
               /*try:*/ {
 
-                /* "ssh2/knownhost.pyx":75
+                /* "ssh2/knownhost.pyx":76
  *         if _entry is NULL:
  *             with gil:
  *                 raise MemoryError             # <<<<<<<<<<<<<<
  *         _entry.magic = 0
  *         _entry.node = NULL
  */
-                PyErr_NoMemory(); __PYX_ERR(0, 75, __pyx_L8_error)
+                PyErr_NoMemory(); __PYX_ERR(0, 76, __pyx_L8_error)
               }
 
-              /* "ssh2/knownhost.pyx":74
+              /* "ssh2/knownhost.pyx":75
  *             sizeof(c_ssh2.libssh2_knownhost))
  *         if _entry is NULL:
  *             with gil:             # <<<<<<<<<<<<<<
@@ -1928,7 +3584,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
               }
           }
 
-          /* "ssh2/knownhost.pyx":73
+          /* "ssh2/knownhost.pyx":74
  *         _entry = <c_ssh2.libssh2_knownhost *>malloc(
  *             sizeof(c_ssh2.libssh2_knownhost))
  *         if _entry is NULL:             # <<<<<<<<<<<<<<
@@ -1937,7 +3593,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         }
 
-        /* "ssh2/knownhost.pyx":76
+        /* "ssh2/knownhost.pyx":77
  *             with gil:
  *                 raise MemoryError
  *         _entry.magic = 0             # <<<<<<<<<<<<<<
@@ -1946,7 +3602,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry->magic = 0;
 
-        /* "ssh2/knownhost.pyx":77
+        /* "ssh2/knownhost.pyx":78
  *                 raise MemoryError
  *         _entry.magic = 0
  *         _entry.node = NULL             # <<<<<<<<<<<<<<
@@ -1955,7 +3611,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry->node = NULL;
 
-        /* "ssh2/knownhost.pyx":78
+        /* "ssh2/knownhost.pyx":79
  *         _entry.magic = 0
  *         _entry.node = NULL
  *         _entry.name = NULL             # <<<<<<<<<<<<<<
@@ -1964,7 +3620,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry->name = NULL;
 
-        /* "ssh2/knownhost.pyx":79
+        /* "ssh2/knownhost.pyx":80
  *         _entry.node = NULL
  *         _entry.name = NULL
  *         _entry.key = NULL             # <<<<<<<<<<<<<<
@@ -1973,7 +3629,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry->key = NULL;
 
-        /* "ssh2/knownhost.pyx":80
+        /* "ssh2/knownhost.pyx":81
  *         _entry.name = NULL
  *         _entry.key = NULL
  *         _entry.typemask = -1             # <<<<<<<<<<<<<<
@@ -1982,7 +3638,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
  */
         __pyx_v__entry->typemask = -1;
 
-        /* "ssh2/knownhost.pyx":81
+        /* "ssh2/knownhost.pyx":82
  *         _entry.key = NULL
  *         _entry.typemask = -1
  *         entry._store = _entry             # <<<<<<<<<<<<<<
@@ -1992,7 +3648,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
         __pyx_v_entry->_store = __pyx_v__entry;
       }
 
-      /* "ssh2/knownhost.pyx":70
+      /* "ssh2/knownhost.pyx":71
  *     cdef KnownHostEntry entry = KnownHostEntry.__new__(KnownHostEntry)
  *     cdef c_ssh2.libssh2_knownhost *_entry
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -2018,19 +3674,19 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
       }
   }
 
-  /* "ssh2/knownhost.pyx":82
+  /* "ssh2/knownhost.pyx":83
  *         _entry.typemask = -1
  *         entry._store = _entry
  *     return entry             # <<<<<<<<<<<<<<
  * 
  * 
  */
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_entry));
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_entry);
   __pyx_r = __pyx_v_entry;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":67
+  /* "ssh2/knownhost.pyx":68
  * 
  * 
  * cdef KnownHostEntry PyNewKnownHostEntry():             # <<<<<<<<<<<<<<
@@ -2050,7 +3706,7 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":88
+/* "ssh2/knownhost.pyx":89
  *     """Class representing a single known host entry."""
  * 
  *     def __repr__(self):             # <<<<<<<<<<<<<<
@@ -2061,9 +3717,11 @@ static struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_f_4ssh2_9knownhos
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2079,9 +3737,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__repr__", 0);
+  __Pyx_RefNannySetupContext("__repr__", 1);
 
-  /* "ssh2/knownhost.pyx":89
+  /* "ssh2/knownhost.pyx":90
  * 
  *     def __repr__(self):
  *         return "Known host entry for host: %s" % (self.name)             # <<<<<<<<<<<<<<
@@ -2089,16 +3747,16 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(struct __py
  *     def __str__(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Known_host_entry_for_host_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Known_host_entry_for_host_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":88
+  /* "ssh2/knownhost.pyx":89
  *     """Class representing a single known host entry."""
  * 
  *     def __repr__(self):             # <<<<<<<<<<<<<<
@@ -2118,7 +3776,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":91
+/* "ssh2/knownhost.pyx":92
  *         return "Known host entry for host: %s" % (self.name)
  * 
  *     def __str__(self):             # <<<<<<<<<<<<<<
@@ -2129,9 +3787,11 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry___repr__(struct __py
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_3__str__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_3__str__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2145,12 +3805,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(struct __py
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  unsigned int __pyx_t_4;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__str__", 0);
+  __Pyx_RefNannySetupContext("__str__", 1);
 
-  /* "ssh2/knownhost.pyx":92
+  /* "ssh2/knownhost.pyx":93
  * 
  *     def __str__(self):
  *         return self.__repr__()             # <<<<<<<<<<<<<<
@@ -2158,28 +3819,35 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(struct __py
  *     def _dealloc__(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_repr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_repr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_4 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":91
+  /* "ssh2/knownhost.pyx":92
  *         return "Known host entry for host: %s" % (self.name)
  * 
  *     def __str__(self):             # <<<<<<<<<<<<<<
@@ -2200,7 +3868,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":94
+/* "ssh2/knownhost.pyx":95
  *         return self.__repr__()
  * 
  *     def _dealloc__(self):             # <<<<<<<<<<<<<<
@@ -2209,12 +3877,40 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_2__str__(struct __py
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__[] = "KnownHostEntry._dealloc__(self)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__, "KnownHostEntry._dealloc__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__ = {"_dealloc__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__};
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("_dealloc__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("_dealloc__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "_dealloc__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2226,19 +3922,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  __Pyx_RefNannySetupContext("_dealloc__", 0);
+  __Pyx_RefNannySetupContext("_dealloc__", 1);
 
-  /* "ssh2/knownhost.pyx":95
+  /* "ssh2/knownhost.pyx":96
  * 
  *     def _dealloc__(self):
  *         if self._store is not NULL:             # <<<<<<<<<<<<<<
  *             with nogil:
  *                 free(self._store)
  */
-  __pyx_t_1 = ((__pyx_v_self->_store != NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_store != NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/knownhost.pyx":96
+    /* "ssh2/knownhost.pyx":97
  *     def _dealloc__(self):
  *         if self._store is not NULL:
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -2248,12 +3944,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
         /*try:*/ {
 
-          /* "ssh2/knownhost.pyx":97
+          /* "ssh2/knownhost.pyx":98
  *         if self._store is not NULL:
  *             with nogil:
  *                 free(self._store)             # <<<<<<<<<<<<<<
@@ -2263,7 +3960,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
           free(__pyx_v_self->_store);
         }
 
-        /* "ssh2/knownhost.pyx":96
+        /* "ssh2/knownhost.pyx":97
  *     def _dealloc__(self):
  *         if self._store is not NULL:
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -2282,7 +3979,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
         }
     }
 
-    /* "ssh2/knownhost.pyx":95
+    /* "ssh2/knownhost.pyx":96
  * 
  *     def _dealloc__(self):
  *         if self._store is not NULL:             # <<<<<<<<<<<<<<
@@ -2291,7 +3988,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
  */
   }
 
-  /* "ssh2/knownhost.pyx":98
+  /* "ssh2/knownhost.pyx":99
  *             with nogil:
  *                 free(self._store)
  *         self._store = NULL             # <<<<<<<<<<<<<<
@@ -2300,7 +3997,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
  */
   __pyx_v_self->_store = NULL;
 
-  /* "ssh2/knownhost.pyx":94
+  /* "ssh2/knownhost.pyx":95
  *         return self.__repr__()
  * 
  *     def _dealloc__(self):             # <<<<<<<<<<<<<<
@@ -2316,19 +4013,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__(struct _
 }
 
 /* "ssh2/knownhost.pyx":101
+ *         self._store = NULL
  * 
- *     @property
- *     def magic(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def magic(self):
  *         """Entry magic number."""
- *         return self._store.magic
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5magic_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5magic_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_5magic___get__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2343,9 +4042,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_5magic___get__(struc
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/knownhost.pyx":103
+  /* "ssh2/knownhost.pyx":104
  *     def magic(self):
  *         """Entry magic number."""
  *         return self._store.magic             # <<<<<<<<<<<<<<
@@ -2353,18 +4052,18 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_5magic___get__(struc
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_store->magic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_self->_store->magic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/knownhost.pyx":101
+ *         self._store = NULL
  * 
- *     @property
- *     def magic(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def magic(self):
  *         """Entry magic number."""
- *         return self._store.magic
  */
 
   /* function exit code */
@@ -2379,19 +4078,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_5magic___get__(struc
 }
 
 /* "ssh2/knownhost.pyx":106
+ *         return self._store.magic
  * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
  *         """Name of host."""
- *         return self._store.name if self._store.name is not NULL \
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_4name_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_4name_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4name___get__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2403,13 +4104,14 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4name___get__(struct
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/knownhost.pyx":108
+  /* "ssh2/knownhost.pyx":109
  *     def name(self):
  *         """Name of host."""
  *         return self._store.name if self._store.name is not NULL \             # <<<<<<<<<<<<<<
@@ -2417,14 +4119,15 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4name___get__(struct
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  if (((__pyx_v_self->_store->name != NULL) != 0)) {
-    __pyx_t_2 = __Pyx_PyBytes_FromString(__pyx_v_self->_store->name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_1 = __pyx_t_2;
-    __pyx_t_2 = 0;
+  __pyx_t_2 = (__pyx_v_self->_store->name != NULL);
+  if (__pyx_t_2) {
+    __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->_store->name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_3 = 0;
   } else {
 
-    /* "ssh2/knownhost.pyx":109
+    /* "ssh2/knownhost.pyx":110
  *         """Name of host."""
  *         return self._store.name if self._store.name is not NULL \
  *             else None             # <<<<<<<<<<<<<<
@@ -2439,17 +4142,17 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4name___get__(struct
   goto __pyx_L0;
 
   /* "ssh2/knownhost.pyx":106
+ *         return self._store.magic
  * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
  *         """Name of host."""
- *         return self._store.name if self._store.name is not NULL \
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHostEntry.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -2459,19 +4162,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_4name___get__(struct
 }
 
 /* "ssh2/knownhost.pyx":112
+ *             else None
  * 
- *     @property
- *     def key(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def key(self):
  *         """Key byte string.
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_3key_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_3key_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_3key___get__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2483,16 +4188,18 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_3key___get__(struct
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  unsigned int __pyx_t_7;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/knownhost.pyx":122
+  /* "ssh2/knownhost.pyx":123
  *         base64 encoded, contrary to documentation, and ``KnownHostEntry.key``
  *         will need to be re-encoded as base64 to get actual key."""
  *         return b64decode(self._store.key) \             # <<<<<<<<<<<<<<
@@ -2501,47 +4208,55 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_3key___get__(struct
  */
   __Pyx_XDECREF(__pyx_r);
 
-  /* "ssh2/knownhost.pyx":123
+  /* "ssh2/knownhost.pyx":124
  *         will need to be re-encoded as base64 to get actual key."""
  *         return b64decode(self._store.key) \
  *             if self._store.key is not NULL else None             # <<<<<<<<<<<<<<
  * 
  *     @property
  */
-  if (((__pyx_v_self->_store->key != NULL) != 0)) {
+  __pyx_t_2 = (__pyx_v_self->_store->key != NULL);
+  if (__pyx_t_2) {
 
-    /* "ssh2/knownhost.pyx":122
+    /* "ssh2/knownhost.pyx":123
  *         base64 encoded, contrary to documentation, and ``KnownHostEntry.key``
  *         will need to be re-encoded as base64 to get actual key."""
  *         return b64decode(self._store.key) \             # <<<<<<<<<<<<<<
  *             if self._store.key is not NULL else None
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_b64decode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->_store->key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_b64decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_5 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-      if (likely(__pyx_t_5)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-        __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_self->_store->key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_6);
         __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_7 = 1;
       }
     }
-    __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_1 = __pyx_t_2;
-    __pyx_t_2 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
+      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_3 = 0;
   } else {
 
-    /* "ssh2/knownhost.pyx":123
+    /* "ssh2/knownhost.pyx":124
  *         will need to be re-encoded as base64 to get actual key."""
  *         return b64decode(self._store.key) \
  *             if self._store.key is not NULL else None             # <<<<<<<<<<<<<<
@@ -2556,20 +4271,20 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_3key___get__(struct
   goto __pyx_L0;
 
   /* "ssh2/knownhost.pyx":112
+ *             else None
  * 
- *     @property
- *     def key(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def key(self):
  *         """Key byte string.
- * 
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHostEntry.key.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -2579,19 +4294,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_3key___get__(struct
 }
 
 /* "ssh2/knownhost.pyx":126
+ *             if self._store.key is not NULL else None
  * 
- *     @property
- *     def typemask(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def typemask(self):
  *         """Type mask of host entry."""
- *         return self._store.typemask
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_8typemask_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_8typemask_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8typemask___get__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2606,9 +4323,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8typemask___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/knownhost.pyx":128
+  /* "ssh2/knownhost.pyx":129
  *     def typemask(self):
  *         """Type mask of host entry."""
  *         return self._store.typemask             # <<<<<<<<<<<<<<
@@ -2616,18 +4333,18 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8typemask___get__(st
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_store->typemask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_store->typemask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 129, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/knownhost.pyx":126
+ *             if self._store.key is not NULL else None
  * 
- *     @property
- *     def typemask(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def typemask(self):
  *         """Type mask of host entry."""
- *         return self._store.typemask
  */
 
   /* function exit code */
@@ -2643,17 +4360,45 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8typemask___get__(st
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__[] = "KnownHostEntry.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__, "KnownHostEntry.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self));
 
   /* function exit code */
@@ -2664,33 +4409,28 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__(P
 static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__store_cannot_be_converted, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHostEntry.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2700,21 +4440,104 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__(C
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__[] = "KnownHostEntry.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__, "KnownHostEntry.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.knownhost.KnownHostEntry.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2722,33 +4545,28 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__
 static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__store_cannot_be_converted, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHostEntry.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2756,7 +4574,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":134
+/* "ssh2/knownhost.pyx":135
  *     """Manage known host entries."""
  * 
  *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
@@ -2768,49 +4586,69 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__
 static int __pyx_pw_4ssh2_9knownhost_9KnownHost_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_9knownhost_9KnownHost_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 135, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 134, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 135, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 134, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 135, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(0, 134, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(0, 135, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost___cinit__(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_session);
 
   /* function exit code */
@@ -2818,6 +4656,12 @@ static int __pyx_pw_4ssh2_9knownhost_9KnownHost_1__cinit__(PyObject *__pyx_v_sel
   __pyx_L1_error:;
   __pyx_r = -1;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2825,9 +4669,9 @@ static int __pyx_pw_4ssh2_9knownhost_9KnownHost_1__cinit__(PyObject *__pyx_v_sel
 static int __pyx_pf_4ssh2_9knownhost_9KnownHost___cinit__(struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
   int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
-  /* "ssh2/knownhost.pyx":135
+  /* "ssh2/knownhost.pyx":136
  * 
  *     def __cinit__(self, Session session):
  *         self._ptr = NULL             # <<<<<<<<<<<<<<
@@ -2836,20 +4680,20 @@ static int __pyx_pf_4ssh2_9knownhost_9KnownHost___cinit__(struct __pyx_obj_4ssh2
  */
   __pyx_v_self->_ptr = NULL;
 
-  /* "ssh2/knownhost.pyx":136
+  /* "ssh2/knownhost.pyx":137
  *     def __cinit__(self, Session session):
  *         self._ptr = NULL
  *         self._session = session             # <<<<<<<<<<<<<<
  * 
  *     def __dealloc__(self):
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  __Pyx_GOTREF(__pyx_v_self->_session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_session);
   __pyx_v_self->_session = __pyx_v_session;
 
-  /* "ssh2/knownhost.pyx":134
+  /* "ssh2/knownhost.pyx":135
  *     """Manage known host entries."""
  * 
  *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
@@ -2863,7 +4707,7 @@ static int __pyx_pf_4ssh2_9knownhost_9KnownHost___cinit__(struct __pyx_obj_4ssh2
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":138
+/* "ssh2/knownhost.pyx":139
  *         self._session = session
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -2874,8 +4718,10 @@ static int __pyx_pf_4ssh2_9knownhost_9KnownHost___cinit__(struct __pyx_obj_4ssh2
 /* Python wrapper */
 static void __pyx_pw_4ssh2_9knownhost_9KnownHost_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_9knownhost_9KnownHost_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self));
 
   /* function exit code */
@@ -2883,13 +4729,10 @@ static void __pyx_pw_4ssh2_9knownhost_9KnownHost_3__dealloc__(PyObject *__pyx_v_
 }
 
 static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
-  /* "ssh2/knownhost.pyx":139
+  /* "ssh2/knownhost.pyx":140
  * 
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._ptr is not NULL:             # <<<<<<<<<<<<<<
@@ -2897,24 +4740,23 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  *         self._ptr = NULL
  */
   __pyx_t_2 = (((PyObject *)__pyx_v_self->_session) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_session->_session != NULL) != 0);
-  if (__pyx_t_3) {
+  __pyx_t_2 = (__pyx_v_self->_session->_session != NULL);
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_ptr != NULL) != 0);
-  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_2 = (__pyx_v_self->_ptr != NULL);
+  __pyx_t_1 = __pyx_t_2;
   __pyx_L4_bool_binop_done:;
   if (__pyx_t_1) {
 
-    /* "ssh2/knownhost.pyx":140
+    /* "ssh2/knownhost.pyx":141
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._ptr is not NULL:
  *             c_ssh2.libssh2_knownhost_free(self._ptr)             # <<<<<<<<<<<<<<
@@ -2923,7 +4765,7 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  */
     libssh2_knownhost_free(__pyx_v_self->_ptr);
 
-    /* "ssh2/knownhost.pyx":139
+    /* "ssh2/knownhost.pyx":140
  * 
  *     def __dealloc__(self):
  *         if self._session is not None and self._session._session is not NULL and self._ptr is not NULL:             # <<<<<<<<<<<<<<
@@ -2932,7 +4774,7 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  */
   }
 
-  /* "ssh2/knownhost.pyx":141
+  /* "ssh2/knownhost.pyx":142
  *         if self._session is not None and self._session._session is not NULL and self._ptr is not NULL:
  *             c_ssh2.libssh2_knownhost_free(self._ptr)
  *         self._ptr = NULL             # <<<<<<<<<<<<<<
@@ -2941,7 +4783,7 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  */
   __pyx_v_self->_ptr = NULL;
 
-  /* "ssh2/knownhost.pyx":138
+  /* "ssh2/knownhost.pyx":139
  *         self._session = session
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -2950,10 +4792,9 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
-/* "ssh2/knownhost.pyx":143
+/* "ssh2/knownhost.pyx":144
  *         self._ptr = NULL
  * 
  *     def add(self, bytes host, bytes salt, bytes key, int typemask):             # <<<<<<<<<<<<<<
@@ -2962,88 +4803,137 @@ static void __pyx_pf_4ssh2_9knownhost_9KnownHost_2__dealloc__(struct __pyx_obj_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_4add[] = "KnownHost.add(self, bytes host, bytes salt, bytes key, int typemask)\nDeprecated - use ``self.addc``";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_5add(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_4add, "KnownHost.add(self, bytes host, bytes salt, bytes key, int typemask)\nDeprecated - use ``self.addc``");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_5add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_5add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_4add};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_5add(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   CYTHON_UNUSED PyObject *__pyx_v_host = 0;
   CYTHON_UNUSED PyObject *__pyx_v_salt = 0;
   CYTHON_UNUSED PyObject *__pyx_v_key = 0;
   CYTHON_UNUSED int __pyx_v_typemask;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("add (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_salt,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_salt,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_salt)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_salt)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 1); __PYX_ERR(0, 143, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 1); __PYX_ERR(0, 144, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 2); __PYX_ERR(0, 143, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 2); __PYX_ERR(0, 144, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_typemask)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typemask)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 3); __PYX_ERR(0, 143, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 3); __PYX_ERR(0, 144, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) __PYX_ERR(0, 143, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(0, 144, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
     }
     __pyx_v_host = ((PyObject*)values[0]);
     __pyx_v_salt = ((PyObject*)values[1]);
     __pyx_v_key = ((PyObject*)values[2]);
-    __pyx_v_typemask = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L3_error)
+    __pyx_v_typemask = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 144, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 143, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 144, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.add", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(0, 143, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_salt), (&PyBytes_Type), 1, "salt", 1))) __PYX_ERR(0, 143, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 1, "key", 1))) __PYX_ERR(0, 143, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(0, 144, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_salt), (&PyBytes_Type), 1, "salt", 1))) __PYX_ERR(0, 144, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 1, "key", 1))) __PYX_ERR(0, 144, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_4add(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_host, __pyx_v_salt, __pyx_v_key, __pyx_v_typemask);
 
   /* function exit code */
@@ -3051,6 +4941,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_5add(PyObject *__pyx_v_sel
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3061,9 +4957,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_4add(CYTHON_UNUSED struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("add", 0);
+  __Pyx_RefNannySetupContext("add", 1);
 
-  /* "ssh2/knownhost.pyx":145
+  /* "ssh2/knownhost.pyx":146
  *     def add(self, bytes host, bytes salt, bytes key, int typemask):
  *         """Deprecated - use ``self.addc``"""
  *         raise NotImplementedError             # <<<<<<<<<<<<<<
@@ -3071,9 +4967,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_4add(CYTHON_UNUSED struct
  *     def addc(self, bytes host not None, bytes key not None,
  */
   __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
-  __PYX_ERR(0, 145, __pyx_L1_error)
+  __PYX_ERR(0, 146, __pyx_L1_error)
 
-  /* "ssh2/knownhost.pyx":143
+  /* "ssh2/knownhost.pyx":144
  *         self._ptr = NULL
  * 
  *     def add(self, bytes host, bytes salt, bytes key, int typemask):             # <<<<<<<<<<<<<<
@@ -3090,7 +4986,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_4add(CYTHON_UNUSED struct
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":147
+/* "ssh2/knownhost.pyx":148
  *         raise NotImplementedError
  * 
  *     def addc(self, bytes host not None, bytes key not None,             # <<<<<<<<<<<<<<
@@ -3099,117 +4995,164 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_4add(CYTHON_UNUSED struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_6addc[] = "KnownHost.addc(self, bytes host, bytes key, int typemask, bytes salt=None, bytes comment=None)\nAdds a host and its key to known hosts collection.\n\n        Note - ``libssh2`` expects correct use of hashed hosts when\n        ``LIBSSH2_KNOWNHOST_TYPE_SHA1`` is part of typemask. Incorrect use of\n        hashed host typemask without appropriate hashed host and salt values\n        will result in host entries being added to the collection without a\n        host name.\n\n        :param host: Host to add key for.\n        :type host: bytes\n        :param key: Key to add.\n        :type key: bytes\n        :param typemask: Bitmask of one of each from\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_TYPE_*``,\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEYENC_*`` and\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEY_*`` for example for plain text\n          host, raw key encoding and SSH RSA key ``type`` would be\n          ``LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW |\n          LIBSSH2_KNOWNHOST_KEY_SSHRSA``.\n        :param salt: Salt used for host hashing if host is hashed.\n          Defaults to ``None``.\n        :type salt: bytes\n        :param comment: Comment to add for host. Defaults to ``None``.\n        :type comment: bytes\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostAddError` on errors adding\n          known host entry.";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_6addc, "KnownHost.addc(self, bytes host, bytes key, int typemask, bytes salt=None, bytes comment=None)\nAdds a host and its key to known hosts collection.\n\n        Note - ``libssh2`` expects correct use of hashed hosts when\n        ``LIBSSH2_KNOWNHOST_TYPE_SHA1`` is part of typemask. Incorrect use of\n        hashed host typemask without appropriate hashed host and salt values\n        will result in host entries being added to the collection without a\n        host name.\n\n        :param host: Host to add key for.\n        :type host: bytes\n        :param key: Key to add.\n        :type key: bytes\n        :param typemask: Bitmask of one of each from\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_TYPE_*``,\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEYENC_*`` and\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEY_*`` for example for plain text\n          host, raw key encoding and SSH RSA key ``type`` would be\n          ``LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW |\n          LIBSSH2_KNOWNHOST_KEY_SSHRSA``.\n        :param salt: Salt used for host hashing if host is hashed.\n          Defaults to ``None``.\n        :type salt: bytes\n        :param comment: Comment to add for host. Defaults to ``None``.\n        :type comment: bytes\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostAddError` on errors adding\n          known host entry.");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_7addc = {"addc", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_6addc};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_host = 0;
   PyObject *__pyx_v_key = 0;
   int __pyx_v_typemask;
   PyObject *__pyx_v_salt = 0;
   PyObject *__pyx_v_comment = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("addc (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_key,&__pyx_n_s_typemask,&__pyx_n_s_salt,&__pyx_n_s_comment,0};
-    PyObject* values[5] = {0,0,0,0,0};
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_key,&__pyx_n_s_typemask,&__pyx_n_s_salt,&__pyx_n_s_comment,0};
 
-    /* "ssh2/knownhost.pyx":148
+    /* "ssh2/knownhost.pyx":149
  * 
  *     def addc(self, bytes host not None, bytes key not None,
  *              int typemask, bytes salt=None, bytes comment=None):             # <<<<<<<<<<<<<<
  *         """Adds a host and its key to known hosts collection.
  * 
  */
-    values[3] = ((PyObject*)Py_None);
-    values[4] = ((PyObject*)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject*)Py_None));
+    values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject*)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, 1); __PYX_ERR(0, 147, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, 1); __PYX_ERR(0, 148, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_typemask)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typemask)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, 2); __PYX_ERR(0, 147, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, 2); __PYX_ERR(0, 148, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_salt);
-          if (value) { values[3] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_salt);
+          if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comment);
-          if (value) { values[4] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_comment);
+          if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "addc") < 0)) __PYX_ERR(0, 147, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addc") < 0)) __PYX_ERR(0, 148, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+        values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_host = ((PyObject*)values[0]);
     __pyx_v_key = ((PyObject*)values[1]);
-    __pyx_v_typemask = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 148, __pyx_L3_error)
+    __pyx_v_typemask = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 149, __pyx_L3_error)
     __pyx_v_salt = ((PyObject*)values[3]);
     __pyx_v_comment = ((PyObject*)values[4]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 147, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("addc", 0, 3, 5, __pyx_nargs); __PYX_ERR(0, 148, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.addc", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 0, "host", 1))) __PYX_ERR(0, 147, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 1))) __PYX_ERR(0, 147, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_salt), (&PyBytes_Type), 1, "salt", 1))) __PYX_ERR(0, 148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_comment), (&PyBytes_Type), 1, "comment", 1))) __PYX_ERR(0, 148, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 0, "host", 1))) __PYX_ERR(0, 148, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 1))) __PYX_ERR(0, 148, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_salt), (&PyBytes_Type), 1, "salt", 1))) __PYX_ERR(0, 149, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_comment), (&PyBytes_Type), 1, "comment", 1))) __PYX_ERR(0, 149, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_host, __pyx_v_key, __pyx_v_typemask, __pyx_v_salt, __pyx_v_comment);
 
-  /* "ssh2/knownhost.pyx":147
+  /* "ssh2/knownhost.pyx":148
  *         raise NotImplementedError
  * 
  *     def addc(self, bytes host not None, bytes key not None,             # <<<<<<<<<<<<<<
@@ -3222,6 +5165,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc(PyObject *__pyx_v_se
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3240,40 +5189,38 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
   Py_ssize_t __pyx_t_1;
   char *__pyx_t_2;
   int __pyx_t_3;
-  int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  size_t __pyx_t_6;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  int __pyx_t_10;
-  PyObject *__pyx_t_11 = NULL;
+  unsigned int __pyx_t_9;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("addc", 0);
+  __Pyx_RefNannySetupContext("addc", 1);
 
-  /* "ssh2/knownhost.pyx":176
+  /* "ssh2/knownhost.pyx":177
  *         :raises: :py:class:`ssh2.exceptions.KnownHostAddError` on errors adding
  *           known host entry."""
  *         cdef size_t keylen = len(key)             # <<<<<<<<<<<<<<
  *         cdef size_t comment_len
  *         cdef char *_host = host
  */
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 176, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 177, __pyx_L1_error)
   __pyx_v_keylen = __pyx_t_1;
 
-  /* "ssh2/knownhost.pyx":178
+  /* "ssh2/knownhost.pyx":179
  *         cdef size_t keylen = len(key)
  *         cdef size_t comment_len
  *         cdef char *_host = host             # <<<<<<<<<<<<<<
  *         cdef char *_salt
  *         if salt is not None:
  */
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 178, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L1_error)
   __pyx_v__host = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":180
+  /* "ssh2/knownhost.pyx":181
  *         cdef char *_host = host
  *         cdef char *_salt
  *         if salt is not None:             # <<<<<<<<<<<<<<
@@ -3281,10 +5228,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  *         else:
  */
   __pyx_t_3 = (__pyx_v_salt != ((PyObject*)Py_None));
-  __pyx_t_4 = (__pyx_t_3 != 0);
-  if (__pyx_t_4) {
+  if (__pyx_t_3) {
 
-    /* "ssh2/knownhost.pyx":181
+    /* "ssh2/knownhost.pyx":182
  *         cdef char *_salt
  *         if salt is not None:
  *             _salt = salt             # <<<<<<<<<<<<<<
@@ -3293,12 +5239,12 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  */
     if (unlikely(__pyx_v_salt == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(0, 181, __pyx_L1_error)
+      __PYX_ERR(0, 182, __pyx_L1_error)
     }
-    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_salt); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_salt); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 182, __pyx_L1_error)
     __pyx_v__salt = __pyx_t_2;
 
-    /* "ssh2/knownhost.pyx":180
+    /* "ssh2/knownhost.pyx":181
  *         cdef char *_host = host
  *         cdef char *_salt
  *         if salt is not None:             # <<<<<<<<<<<<<<
@@ -3308,7 +5254,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
     goto __pyx_L3;
   }
 
-  /* "ssh2/knownhost.pyx":183
+  /* "ssh2/knownhost.pyx":184
  *             _salt = salt
  *         else:
  *             _salt = ""             # <<<<<<<<<<<<<<
@@ -3320,28 +5266,27 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
   }
   __pyx_L3:;
 
-  /* "ssh2/knownhost.pyx":184
+  /* "ssh2/knownhost.pyx":185
  *         else:
  *             _salt = ""
  *         cdef char *_key = key             # <<<<<<<<<<<<<<
  *         cdef char *_comment
  *         if comment is not None:
  */
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_key); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 184, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_key); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error)
   __pyx_v__key = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":186
+  /* "ssh2/knownhost.pyx":187
  *         cdef char *_key = key
  *         cdef char *_comment
  *         if comment is not None:             # <<<<<<<<<<<<<<
  *             _comment = comment
  *         else:
  */
-  __pyx_t_4 = (__pyx_v_comment != ((PyObject*)Py_None));
-  __pyx_t_3 = (__pyx_t_4 != 0);
+  __pyx_t_3 = (__pyx_v_comment != ((PyObject*)Py_None));
   if (__pyx_t_3) {
 
-    /* "ssh2/knownhost.pyx":187
+    /* "ssh2/knownhost.pyx":188
  *         cdef char *_comment
  *         if comment is not None:
  *             _comment = comment             # <<<<<<<<<<<<<<
@@ -3350,12 +5295,12 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  */
     if (unlikely(__pyx_v_comment == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(0, 187, __pyx_L1_error)
+      __PYX_ERR(0, 188, __pyx_L1_error)
     }
-    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_comment); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 187, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_comment); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error)
     __pyx_v__comment = __pyx_t_2;
 
-    /* "ssh2/knownhost.pyx":186
+    /* "ssh2/knownhost.pyx":187
  *         cdef char *_key = key
  *         cdef char *_comment
  *         if comment is not None:             # <<<<<<<<<<<<<<
@@ -3365,7 +5310,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
     goto __pyx_L4;
   }
 
-  /* "ssh2/knownhost.pyx":189
+  /* "ssh2/knownhost.pyx":190
  *             _comment = comment
  *         else:
  *             _comment = NULL             # <<<<<<<<<<<<<<
@@ -3377,19 +5322,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
   }
   __pyx_L4:;
 
-  /* "ssh2/knownhost.pyx":191
+  /* "ssh2/knownhost.pyx":192
  *             _comment = NULL
  *         cdef int rc
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()             # <<<<<<<<<<<<<<
  *         comment_len = len(comment) if comment is not None else 0
  *         with nogil:
  */
-  __pyx_t_5 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyNewKnownHostEntry()); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 191, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_t_5);
-  __pyx_t_5 = 0;
+  __pyx_t_4 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyNewKnownHostEntry()); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_t_4);
+  __pyx_t_4 = 0;
 
-  /* "ssh2/knownhost.pyx":192
+  /* "ssh2/knownhost.pyx":193
  *         cdef int rc
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         comment_len = len(comment) if comment is not None else 0             # <<<<<<<<<<<<<<
@@ -3397,19 +5342,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  *             rc = c_ssh2.libssh2_knownhost_addc(
  */
   __pyx_t_3 = (__pyx_v_comment != ((PyObject*)Py_None));
-  if ((__pyx_t_3 != 0)) {
+  if (__pyx_t_3) {
     if (unlikely(__pyx_v_comment == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-      __PYX_ERR(0, 192, __pyx_L1_error)
+      __PYX_ERR(0, 193, __pyx_L1_error)
     }
-    __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_comment); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 192, __pyx_L1_error)
-    __pyx_t_6 = __pyx_t_1;
+    __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_comment); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 193, __pyx_L1_error)
+    __pyx_t_5 = __pyx_t_1;
   } else {
-    __pyx_t_6 = 0;
+    __pyx_t_5 = 0;
   }
-  __pyx_v_comment_len = __pyx_t_6;
+  __pyx_v_comment_len = __pyx_t_5;
 
-  /* "ssh2/knownhost.pyx":193
+  /* "ssh2/knownhost.pyx":194
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         comment_len = len(comment) if comment is not None else 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3419,12 +5364,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":194
+        /* "ssh2/knownhost.pyx":195
  *         comment_len = len(comment) if comment is not None else 0
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_addc(             # <<<<<<<<<<<<<<
@@ -3434,7 +5380,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
         __pyx_v_rc = libssh2_knownhost_addc(__pyx_v_self->_ptr, __pyx_v__host, __pyx_v__salt, __pyx_v__key, __pyx_v_keylen, __pyx_v__comment, __pyx_v_comment_len, __pyx_v_typemask, (&__pyx_v_entry->_store));
       }
 
-      /* "ssh2/knownhost.pyx":193
+      /* "ssh2/knownhost.pyx":194
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         comment_len = len(comment) if comment is not None else 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3453,90 +5399,63 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
       }
   }
 
-  /* "ssh2/knownhost.pyx":197
+  /* "ssh2/knownhost.pyx":198
  *                 self._ptr, _host, _salt, _key, keylen, _comment, comment_len,
  *                 typemask, &entry._store)
  *         if rc != 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostAddError(
  *                 "Error adding known host entry for host %s - error code %s",
  */
-  __pyx_t_3 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_3 = (__pyx_v_rc != 0);
   if (unlikely(__pyx_t_3)) {
 
-    /* "ssh2/knownhost.pyx":198
+    /* "ssh2/knownhost.pyx":199
  *                 typemask, &entry._store)
  *         if rc != 0:
  *             raise KnownHostAddError(             # <<<<<<<<<<<<<<
  *                 "Error adding known host entry for host %s - error code %s",
  *                 host, rc)
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_KnownHostAddError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 198, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_KnownHostAddError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
 
-    /* "ssh2/knownhost.pyx":200
+    /* "ssh2/knownhost.pyx":201
  *             raise KnownHostAddError(
  *                 "Error adding known host entry for host %s - error code %s",
  *                 host, rc)             # <<<<<<<<<<<<<<
  *         return entry
  * 
  */
-    __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 200, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_9 = NULL;
-    __pyx_t_10 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
-      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7);
-      if (likely(__pyx_t_9)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-        __Pyx_INCREF(__pyx_t_9);
+    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    __pyx_t_9 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
         __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_7, function);
-        __pyx_t_10 = 1;
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+        __pyx_t_9 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_7)) {
-      PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_kp_s_Error_adding_known_host_entry_fo, __pyx_v_host, __pyx_t_8};
-      __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 198, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
-      PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_kp_s_Error_adding_known_host_entry_fo, __pyx_v_host, __pyx_t_8};
-      __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 198, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    } else
     #endif
     {
-      __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 198, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      if (__pyx_t_9) {
-        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_adding_known_host_entry_fo);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_adding_known_host_entry_fo);
-      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_kp_s_Error_adding_known_host_entry_fo);
-      __Pyx_INCREF(__pyx_v_host);
-      __Pyx_GIVEREF(__pyx_v_host);
-      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_host);
-      __Pyx_GIVEREF(__pyx_t_8);
-      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_8);
-      __pyx_t_8 = 0;
-      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 198, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_kp_u_Error_adding_known_host_entry_fo, __pyx_v_host, __pyx_t_7};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_9, 3+__pyx_t_9);
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 199, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
     }
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __PYX_ERR(0, 198, __pyx_L1_error)
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(0, 199, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":197
+    /* "ssh2/knownhost.pyx":198
  *                 self._ptr, _host, _salt, _key, keylen, _comment, comment_len,
  *                 typemask, &entry._store)
  *         if rc != 0:             # <<<<<<<<<<<<<<
@@ -3545,7 +5464,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  */
   }
 
-  /* "ssh2/knownhost.pyx":201
+  /* "ssh2/knownhost.pyx":202
  *                 "Error adding known host entry for host %s - error code %s",
  *                 host, rc)
  *         return entry             # <<<<<<<<<<<<<<
@@ -3553,11 +5472,11 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  *     def check(self, bytes host, bytes key, int typemask):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_entry));
+  __Pyx_INCREF((PyObject *)__pyx_v_entry);
   __pyx_r = ((PyObject *)__pyx_v_entry);
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":147
+  /* "ssh2/knownhost.pyx":148
  *         raise NotImplementedError
  * 
  *     def addc(self, bytes host not None, bytes key not None,             # <<<<<<<<<<<<<<
@@ -3567,11 +5486,10 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_7);
   __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_XDECREF(__pyx_t_11);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.addc", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -3581,7 +5499,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":203
+/* "ssh2/knownhost.pyx":204
  *         return entry
  * 
  *     def check(self, bytes host, bytes key, int typemask):             # <<<<<<<<<<<<<<
@@ -3590,76 +5508,121 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_6addc(struct __pyx_obj_4ss
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_9check(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_8check[] = "KnownHost.check(self, bytes host, bytes key, int typemask)\nDeprecated - use ``self.checkp``";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_9check(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_9check(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_8check, "KnownHost.check(self, bytes host, bytes key, int typemask)\nDeprecated - use ``self.checkp``");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_9check = {"check", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_9check, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_8check};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_9check(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   CYTHON_UNUSED PyObject *__pyx_v_host = 0;
   CYTHON_UNUSED PyObject *__pyx_v_key = 0;
   CYTHON_UNUSED int __pyx_v_typemask;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("check (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, 1); __PYX_ERR(0, 203, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, 1); __PYX_ERR(0, 204, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_typemask)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typemask)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, 2); __PYX_ERR(0, 203, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, 2); __PYX_ERR(0, 204, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "check") < 0)) __PYX_ERR(0, 203, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "check") < 0)) __PYX_ERR(0, 204, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+    } else if (unlikely(__pyx_nargs != 3)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
     }
     __pyx_v_host = ((PyObject*)values[0]);
     __pyx_v_key = ((PyObject*)values[1]);
-    __pyx_v_typemask = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
+    __pyx_v_typemask = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 203, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("check", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 204, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.check", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(0, 203, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 1, "key", 1))) __PYX_ERR(0, 203, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 1, "host", 1))) __PYX_ERR(0, 204, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 1, "key", 1))) __PYX_ERR(0, 204, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_8check(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_host, __pyx_v_key, __pyx_v_typemask);
 
   /* function exit code */
@@ -3667,6 +5630,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_9check(PyObject *__pyx_v_s
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3677,9 +5646,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_8check(CYTHON_UNUSED struc
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("check", 0);
+  __Pyx_RefNannySetupContext("check", 1);
 
-  /* "ssh2/knownhost.pyx":205
+  /* "ssh2/knownhost.pyx":206
  *     def check(self, bytes host, bytes key, int typemask):
  *         """Deprecated - use ``self.checkp``"""
  *         raise NotImplementedError             # <<<<<<<<<<<<<<
@@ -3687,9 +5656,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_8check(CYTHON_UNUSED struc
  *     def checkp(self, bytes host not None, int port, bytes key not None,
  */
   __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
-  __PYX_ERR(0, 205, __pyx_L1_error)
+  __PYX_ERR(0, 206, __pyx_L1_error)
 
-  /* "ssh2/knownhost.pyx":203
+  /* "ssh2/knownhost.pyx":204
  *         return entry
  * 
  *     def check(self, bytes host, bytes key, int typemask):             # <<<<<<<<<<<<<<
@@ -3706,7 +5675,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_8check(CYTHON_UNUSED struc
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":207
+/* "ssh2/knownhost.pyx":208
  *         raise NotImplementedError
  * 
  *     def checkp(self, bytes host not None, int port, bytes key not None,             # <<<<<<<<<<<<<<
@@ -3715,87 +5684,136 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_8check(CYTHON_UNUSED struc
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_10checkp[] = "KnownHost.checkp(self, bytes host, int port, bytes key, int typemask)\nCheck a host and its key against the known hosts collection and\n        return known host entry, if any.\n\n        Note that server key provided to this function must be base64 encoded\n        only if checking against a ``self.addc`` added known public key.\n        When using ``self.readfile`` and a known_hosts file, encoding is not\n        needed.\n\n        :py:class:`ssh2.exceptions.KnownHostCheckError` is base class for all\n        host check error exceptions and can be used to catch all host check\n        errors.\n\n        :param host: Host to check.\n        :type host: bytes\n        :param key: Key of host to check.\n        :type key: bytes\n        :param typemask: Bitmask of one of each from\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_TYPE_*``,\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEYENC_*`` and\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEY_*`` for example for plain text\n          host, raw key encoding and SSH RSA key ``type`` would be\n          ``LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW |\n          LIBSSH2_KNOWNHOST_KEY_SSHRSA``.\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckMisMatchError` on\n          provided key mis-match error with found key from known hosts.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckNotFoundError` on\n          host not found in known hosts.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckFailure` on failure\n          checking known host entry.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckError` on unknown\n          errors checking known host.\n\n        :rtype: :py:class:`ssh2.knownhost.KnownHostEntry`";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_10checkp, "KnownHost.checkp(self, bytes host, int port, bytes key, int typemask)\nCheck a host and its key against the known hosts collection and\n        return known host entry, if any.\n\n        Note that server key provided to this function must be base64 encoded\n        only if checking against a ``self.addc`` added known public key.\n        When using ``self.readfile`` and a known_hosts file, encoding is not\n        needed.\n\n        :py:class:`ssh2.exceptions.KnownHostCheckError` is base class for all\n        host check error exceptions and can be used to catch all host check\n        errors.\n\n        :param host: Host to check.\n        :type host: bytes\n        :param key: Key of host to check.\n        :type key: bytes\n        :param typemask: Bitmask of one of each from\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_TYPE_*``,\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEYENC_*`` and\n          ``ssh2.knownhost.LIBSSH2_KNOWNHOST_KEY_*`` for example for plain text\n          host, raw key encoding and SSH RSA key ``type`` would be\n          ``LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW |\n          LIBSSH2_KNOWNHOST_KEY_SSHRSA``.\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckMisMatchError` on\n          provided key mis-match error with found key from known hosts.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckNotFoundError` on\n          host not found in known hosts.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckFailure` on failure\n          checking known host entry.\n        :raises: :py:class:`ssh2.exceptions.KnownHostCheckError` on unknown\n          errors checking known host.\n\n        :rtype: :py:class:`ssh2.knownhost.KnownHostEntry`");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_11checkp = {"checkp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_10checkp};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_host = 0;
   int __pyx_v_port;
   PyObject *__pyx_v_key = 0;
   int __pyx_v_typemask;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("checkp (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_key,&__pyx_n_s_typemask,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 1); __PYX_ERR(0, 207, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 1); __PYX_ERR(0, 208, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_key)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 2); __PYX_ERR(0, 207, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 2); __PYX_ERR(0, 208, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_typemask)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_typemask)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 3); __PYX_ERR(0, 207, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, 3); __PYX_ERR(0, 208, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkp") < 0)) __PYX_ERR(0, 207, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "checkp") < 0)) __PYX_ERR(0, 208, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
     }
     __pyx_v_host = ((PyObject*)values[0]);
-    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 207, __pyx_L3_error)
+    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
     __pyx_v_key = ((PyObject*)values[2]);
-    __pyx_v_typemask = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 208, __pyx_L3_error)
+    __pyx_v_typemask = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_typemask == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 209, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 207, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("checkp", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 208, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.checkp", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 0, "host", 1))) __PYX_ERR(0, 207, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 1))) __PYX_ERR(0, 207, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_host), (&PyBytes_Type), 0, "host", 1))) __PYX_ERR(0, 208, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_key), (&PyBytes_Type), 0, "key", 1))) __PYX_ERR(0, 208, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_host, __pyx_v_port, __pyx_v_key, __pyx_v_typemask);
 
   /* function exit code */
@@ -3803,6 +5821,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp(PyObject *__pyx_v
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3822,56 +5846,55 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
   PyObject *__pyx_t_5 = NULL;
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
+  unsigned int __pyx_t_8;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("checkp", 0);
+  __Pyx_RefNannySetupContext("checkp", 1);
 
-  /* "ssh2/knownhost.pyx":243
+  /* "ssh2/knownhost.pyx":244
  * 
  *         :rtype: :py:class:`ssh2.knownhost.KnownHostEntry`"""
  *         cdef char *_host = host             # <<<<<<<<<<<<<<
  *         cdef char *_key = key
  *         cdef size_t keylen = len(key)
  */
-  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_host); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 243, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_host); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error)
   __pyx_v__host = __pyx_t_1;
 
-  /* "ssh2/knownhost.pyx":244
+  /* "ssh2/knownhost.pyx":245
  *         :rtype: :py:class:`ssh2.knownhost.KnownHostEntry`"""
  *         cdef char *_host = host
  *         cdef char *_key = key             # <<<<<<<<<<<<<<
  *         cdef size_t keylen = len(key)
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  */
-  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_key); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_key); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 245, __pyx_L1_error)
   __pyx_v__key = __pyx_t_1;
 
-  /* "ssh2/knownhost.pyx":245
+  /* "ssh2/knownhost.pyx":246
  *         cdef char *_host = host
  *         cdef char *_key = key
  *         cdef size_t keylen = len(key)             # <<<<<<<<<<<<<<
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         cdef int rc
  */
-  __pyx_t_2 = PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 245, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_key); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 246, __pyx_L1_error)
   __pyx_v_keylen = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":246
+  /* "ssh2/knownhost.pyx":247
  *         cdef char *_key = key
  *         cdef size_t keylen = len(key)
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()             # <<<<<<<<<<<<<<
  *         cdef int rc
  *         with nogil:
  */
-  __pyx_t_3 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyNewKnownHostEntry()); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __pyx_t_3 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyNewKnownHostEntry()); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 247, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_t_3);
   __pyx_t_3 = 0;
 
-  /* "ssh2/knownhost.pyx":248
+  /* "ssh2/knownhost.pyx":249
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3881,12 +5904,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":249
+        /* "ssh2/knownhost.pyx":250
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_checkp(             # <<<<<<<<<<<<<<
@@ -3896,7 +5920,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
         __pyx_v_rc = libssh2_knownhost_checkp(__pyx_v_self->_ptr, __pyx_v__host, __pyx_v_port, __pyx_v__key, __pyx_v_keylen, __pyx_v_typemask, (&__pyx_v_entry->_store));
       }
 
-      /* "ssh2/knownhost.pyx":248
+      /* "ssh2/knownhost.pyx":249
  *         cdef KnownHostEntry entry = PyNewKnownHostEntry()
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3915,17 +5939,17 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/knownhost.pyx":251
+  /* "ssh2/knownhost.pyx":252
  *             rc = c_ssh2.libssh2_knownhost_checkp(
  *                 self._ptr, _host, port, _key, keylen, typemask, &entry._store)
  *         if rc != c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MATCH:             # <<<<<<<<<<<<<<
  *             if rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_FAILURE:
  *                 raise KnownHostCheckFailure(
  */
-  __pyx_t_4 = ((__pyx_v_rc != LIBSSH2_KNOWNHOST_CHECK_MATCH) != 0);
+  __pyx_t_4 = (__pyx_v_rc != LIBSSH2_KNOWNHOST_CHECK_MATCH);
   if (__pyx_t_4) {
 
-    /* "ssh2/knownhost.pyx":252
+    /* "ssh2/knownhost.pyx":253
  *                 self._ptr, _host, port, _key, keylen, typemask, &entry._store)
  *         if rc != c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MATCH:
  *             if rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_FAILURE:             # <<<<<<<<<<<<<<
@@ -3935,28 +5959,29 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
     switch (__pyx_v_rc) {
       case LIBSSH2_KNOWNHOST_CHECK_FAILURE:
 
-      /* "ssh2/knownhost.pyx":253
+      /* "ssh2/knownhost.pyx":254
  *         if rc != c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MATCH:
  *             if rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_FAILURE:
  *                 raise KnownHostCheckFailure(             # <<<<<<<<<<<<<<
  *                     "Could not check known host entry for host %s "
  *                     "- error code %s", host, rc)
  */
-      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckFailure); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 253, __pyx_L1_error)
+      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckFailure); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 254, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
 
-      /* "ssh2/knownhost.pyx":255
+      /* "ssh2/knownhost.pyx":256
  *                 raise KnownHostCheckFailure(
  *                     "Could not check known host entry for host %s "
  *                     "- error code %s", host, rc)             # <<<<<<<<<<<<<<
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
  *                 raise KnownHostCheckNotFoundError(
  */
-      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 255, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 256, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_6);
       __pyx_t_7 = NULL;
       __pyx_t_8 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_5))) {
         __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
         if (likely(__pyx_t_7)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
@@ -3966,49 +5991,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
           __pyx_t_8 = 1;
         }
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_kp_s_Could_not_check_known_host_entry, __pyx_v_host, __pyx_t_6};
-        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
       #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_kp_s_Could_not_check_known_host_entry, __pyx_v_host, __pyx_t_6};
-        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error)
+      {
+        PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_kp_u_Could_not_check_known_host_entry, __pyx_v_host, __pyx_t_6};
+        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 3+__pyx_t_8);
         __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
         __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 253, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (__pyx_t_7) {
-          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
-        }
-        __Pyx_INCREF(__pyx_kp_s_Could_not_check_known_host_entry);
-        __Pyx_GIVEREF(__pyx_kp_s_Could_not_check_known_host_entry);
-        PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_kp_s_Could_not_check_known_host_entry);
-        __Pyx_INCREF(__pyx_v_host);
-        __Pyx_GIVEREF(__pyx_v_host);
-        PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_host);
-        __Pyx_GIVEREF(__pyx_t_6);
-        PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6);
-        __pyx_t_6 = 0;
-        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error)
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       }
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       __Pyx_Raise(__pyx_t_3, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(0, 253, __pyx_L1_error)
+      __PYX_ERR(0, 254, __pyx_L1_error)
 
-      /* "ssh2/knownhost.pyx":252
+      /* "ssh2/knownhost.pyx":253
  *                 self._ptr, _host, port, _key, keylen, typemask, &entry._store)
  *         if rc != c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MATCH:
  *             if rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_FAILURE:             # <<<<<<<<<<<<<<
@@ -4018,73 +6015,50 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
       break;
       case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
 
-      /* "ssh2/knownhost.pyx":257
+      /* "ssh2/knownhost.pyx":258
  *                     "- error code %s", host, rc)
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
  *                 raise KnownHostCheckNotFoundError(             # <<<<<<<<<<<<<<
  *                     "Host %s not found in known hosts collection", host)
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
  */
-      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 257, __pyx_L1_error)
+      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckNotFoundError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 258, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
 
-      /* "ssh2/knownhost.pyx":258
+      /* "ssh2/knownhost.pyx":259
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
  *                 raise KnownHostCheckNotFoundError(
  *                     "Host %s not found in known hosts collection", host)             # <<<<<<<<<<<<<<
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
  *                 raise KnownHostCheckMisMatchError(
  */
-      __pyx_t_9 = NULL;
+      __pyx_t_6 = NULL;
       __pyx_t_8 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
-        if (likely(__pyx_t_9)) {
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_6)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_6);
           __Pyx_INCREF(function);
           __Pyx_DECREF_SET(__pyx_t_5, function);
           __pyx_t_8 = 1;
         }
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_s_Host_s_not_found_in_known_hosts, __pyx_v_host};
-        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 257, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_s_Host_s_not_found_in_known_hosts, __pyx_v_host};
-        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 257, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-      } else
       #endif
       {
-        __pyx_t_6 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_6);
-        if (__pyx_t_9) {
-          __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); __pyx_t_9 = NULL;
-        }
-        __Pyx_INCREF(__pyx_kp_s_Host_s_not_found_in_known_hosts);
-        __Pyx_GIVEREF(__pyx_kp_s_Host_s_not_found_in_known_hosts);
-        PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_8, __pyx_kp_s_Host_s_not_found_in_known_hosts);
-        __Pyx_INCREF(__pyx_v_host);
-        __Pyx_GIVEREF(__pyx_v_host);
-        PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_8, __pyx_v_host);
-        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 257, __pyx_L1_error)
+        PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_kp_u_Host_s_not_found_in_known_hosts, __pyx_v_host};
+        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       }
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       __Pyx_Raise(__pyx_t_3, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(0, 257, __pyx_L1_error)
+      __PYX_ERR(0, 258, __pyx_L1_error)
 
-      /* "ssh2/knownhost.pyx":256
+      /* "ssh2/knownhost.pyx":257
  *                     "Could not check known host entry for host %s "
  *                     "- error code %s", host, rc)
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:             # <<<<<<<<<<<<<<
@@ -4094,80 +6068,53 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
       break;
       case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
 
-      /* "ssh2/knownhost.pyx":260
+      /* "ssh2/knownhost.pyx":261
  *                     "Host %s not found in known hosts collection", host)
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
  *                 raise KnownHostCheckMisMatchError(             # <<<<<<<<<<<<<<
  *                     "Known host key for host %s does not match provided key - "
  *                     "error code %s", host, rc)
  */
-      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckMisMatchError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 260, __pyx_L1_error)
+      __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckMisMatchError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 261, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
 
-      /* "ssh2/knownhost.pyx":262
+      /* "ssh2/knownhost.pyx":263
  *                 raise KnownHostCheckMisMatchError(
  *                     "Known host key for host %s does not match provided key - "
  *                     "error code %s", host, rc)             # <<<<<<<<<<<<<<
  *             raise KnownHostCheckError(
  *                 "Unknown error occurred checking known host %s", host)
  */
-      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 262, __pyx_L1_error)
+      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 263, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_9 = NULL;
+      __pyx_t_7 = NULL;
       __pyx_t_8 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
-        if (likely(__pyx_t_9)) {
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_5))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+        if (likely(__pyx_t_7)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-          __Pyx_INCREF(__pyx_t_9);
+          __Pyx_INCREF(__pyx_t_7);
           __Pyx_INCREF(function);
           __Pyx_DECREF_SET(__pyx_t_5, function);
           __pyx_t_8 = 1;
         }
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_kp_s_Known_host_key_for_host_s_does_n, __pyx_v_host, __pyx_t_6};
-        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_kp_s_Known_host_key_for_host_s_does_n, __pyx_v_host, __pyx_t_6};
-        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      } else
       #endif
       {
-        __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        if (__pyx_t_9) {
-          __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
-        }
-        __Pyx_INCREF(__pyx_kp_s_Known_host_key_for_host_s_does_n);
-        __Pyx_GIVEREF(__pyx_kp_s_Known_host_key_for_host_s_does_n);
-        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_kp_s_Known_host_key_for_host_s_does_n);
-        __Pyx_INCREF(__pyx_v_host);
-        __Pyx_GIVEREF(__pyx_v_host);
-        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_v_host);
-        __Pyx_GIVEREF(__pyx_t_6);
-        PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_t_6);
-        __pyx_t_6 = 0;
-        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
+        PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_kp_u_Known_host_key_for_host_s_does_n, __pyx_v_host, __pyx_t_6};
+        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 3+__pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       }
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
       __Pyx_Raise(__pyx_t_3, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(0, 260, __pyx_L1_error)
+      __PYX_ERR(0, 261, __pyx_L1_error)
 
-      /* "ssh2/knownhost.pyx":259
+      /* "ssh2/knownhost.pyx":260
  *                 raise KnownHostCheckNotFoundError(
  *                     "Host %s not found in known hosts collection", host)
  *             elif rc == c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MISMATCH:             # <<<<<<<<<<<<<<
@@ -4178,73 +6125,50 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
       default: break;
     }
 
-    /* "ssh2/knownhost.pyx":263
+    /* "ssh2/knownhost.pyx":264
  *                     "Known host key for host %s does not match provided key - "
  *                     "error code %s", host, rc)
  *             raise KnownHostCheckError(             # <<<<<<<<<<<<<<
  *                 "Unknown error occurred checking known host %s", host)
  *         return entry
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 263, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
 
-    /* "ssh2/knownhost.pyx":264
+    /* "ssh2/knownhost.pyx":265
  *                     "error code %s", host, rc)
  *             raise KnownHostCheckError(
  *                 "Unknown error occurred checking known host %s", host)             # <<<<<<<<<<<<<<
  *         return entry
  * 
  */
-    __pyx_t_7 = NULL;
+    __pyx_t_6 = NULL;
     __pyx_t_8 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
-      if (likely(__pyx_t_7)) {
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_6)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_6);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_5, function);
         __pyx_t_8 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_5)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_s_Unknown_error_occurred_checking, __pyx_v_host};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_s_Unknown_error_occurred_checking, __pyx_v_host};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-    } else
     #endif
     {
-      __pyx_t_6 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 263, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      if (__pyx_t_7) {
-        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Unknown_error_occurred_checking);
-      __Pyx_GIVEREF(__pyx_kp_s_Unknown_error_occurred_checking);
-      PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_8, __pyx_kp_s_Unknown_error_occurred_checking);
-      __Pyx_INCREF(__pyx_v_host);
-      __Pyx_GIVEREF(__pyx_v_host);
-      PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_8, __pyx_v_host);
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error)
+      PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_kp_u_Unknown_error_occurred_checking, __pyx_v_host};
+      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(0, 263, __pyx_L1_error)
+    __PYX_ERR(0, 264, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":251
+    /* "ssh2/knownhost.pyx":252
  *             rc = c_ssh2.libssh2_knownhost_checkp(
  *                 self._ptr, _host, port, _key, keylen, typemask, &entry._store)
  *         if rc != c_ssh2.LIBSSH2_KNOWNHOST_CHECK_MATCH:             # <<<<<<<<<<<<<<
@@ -4253,7 +6177,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
  */
   }
 
-  /* "ssh2/knownhost.pyx":265
+  /* "ssh2/knownhost.pyx":266
  *             raise KnownHostCheckError(
  *                 "Unknown error occurred checking known host %s", host)
  *         return entry             # <<<<<<<<<<<<<<
@@ -4261,11 +6185,11 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
  *     def delete(self, KnownHostEntry entry not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_entry));
+  __Pyx_INCREF((PyObject *)__pyx_v_entry);
   __pyx_r = ((PyObject *)__pyx_v_entry);
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":207
+  /* "ssh2/knownhost.pyx":208
  *         raise NotImplementedError
  * 
  *     def checkp(self, bytes host not None, int port, bytes key not None,             # <<<<<<<<<<<<<<
@@ -4279,7 +6203,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_9);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.checkp", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -4289,7 +6212,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":267
+/* "ssh2/knownhost.pyx":268
  *         return entry
  * 
  *     def delete(self, KnownHostEntry entry not None):             # <<<<<<<<<<<<<<
@@ -4298,23 +6221,103 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_10checkp(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete(PyObject *__pyx_v_self, PyObject *__pyx_v_entry); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_12delete[] = "KnownHost.delete(self, KnownHostEntry entry)\nDelete given known host entry from collection of known hosts.\n\n        :param entry: Known host entry to delete.\n        :type entry: :py:class:`ssh2.knownhost.KnownHostEntry`\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostDeleteError` on errors\n          deleting host entry.";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete(PyObject *__pyx_v_self, PyObject *__pyx_v_entry) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_12delete, "KnownHost.delete(self, KnownHostEntry entry)\nDelete given known host entry from collection of known hosts.\n\n        :param entry: Known host entry to delete.\n        :type entry: :py:class:`ssh2.knownhost.KnownHostEntry`\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostDeleteError` on errors\n          deleting host entry.");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_13delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_12delete};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_entry = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("delete (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_entry), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 0, "entry", 0))) __PYX_ERR(0, 267, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)__pyx_v_entry));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entry,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entry)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 268, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delete") < 0)) __PYX_ERR(0, 268, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("delete", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 268, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.knownhost.KnownHost.delete", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_entry), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 0, "entry", 0))) __PYX_ERR(0, 268, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_entry);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4328,14 +6331,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("delete", 0);
+  __Pyx_RefNannySetupContext("delete", 1);
 
-  /* "ssh2/knownhost.pyx":276
+  /* "ssh2/knownhost.pyx":277
  *           deleting host entry."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4345,12 +6347,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":277
+        /* "ssh2/knownhost.pyx":278
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_del(self._ptr, entry._store)             # <<<<<<<<<<<<<<
@@ -4360,7 +6363,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
         __pyx_v_rc = libssh2_knownhost_del(__pyx_v_self->_ptr, __pyx_v_entry->_store);
       }
 
-      /* "ssh2/knownhost.pyx":276
+      /* "ssh2/knownhost.pyx":277
  *           deleting host entry."""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4379,38 +6382,39 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/knownhost.pyx":278
+  /* "ssh2/knownhost.pyx":279
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_del(self._ptr, entry._store)
  *         if rc != 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostDeleteError(
  *                 "Error deleting known host entry - error code %s", rc)
  */
-  __pyx_t_1 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_1 = (__pyx_v_rc != 0);
   if (unlikely(__pyx_t_1)) {
 
-    /* "ssh2/knownhost.pyx":279
+    /* "ssh2/knownhost.pyx":280
  *             rc = c_ssh2.libssh2_knownhost_del(self._ptr, entry._store)
  *         if rc != 0:
  *             raise KnownHostDeleteError(             # <<<<<<<<<<<<<<
  *                 "Error deleting known host entry - error code %s", rc)
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostDeleteError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_KnownHostDeleteError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
 
-    /* "ssh2/knownhost.pyx":280
+    /* "ssh2/knownhost.pyx":281
  *         if rc != 0:
  *             raise KnownHostDeleteError(
  *                 "Error deleting known host entry - error code %s", rc)             # <<<<<<<<<<<<<<
  * 
  *     def readline(self, bytes line not None,
  */
-    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __pyx_t_5 = NULL;
     __pyx_t_6 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_3))) {
       __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
       if (likely(__pyx_t_5)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
@@ -4420,46 +6424,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
         __pyx_t_6 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_3)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_deleting_known_host_entry, __pyx_t_4};
-      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    } else
     #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_deleting_known_host_entry, __pyx_t_4};
-      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error)
+    {
+      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_u_Error_deleting_known_host_entry, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
       __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 279, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      if (__pyx_t_5) {
-        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_deleting_known_host_entry);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_deleting_known_host_entry);
-      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Error_deleting_known_host_entry);
-      __Pyx_GIVEREF(__pyx_t_4);
-      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
-      __pyx_t_4 = 0;
-      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 279, __pyx_L1_error)
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 280, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     }
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(0, 279, __pyx_L1_error)
+    __PYX_ERR(0, 280, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":278
+    /* "ssh2/knownhost.pyx":279
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_del(self._ptr, entry._store)
  *         if rc != 0:             # <<<<<<<<<<<<<<
@@ -4468,7 +6447,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
  */
   }
 
-  /* "ssh2/knownhost.pyx":267
+  /* "ssh2/knownhost.pyx":268
  *         return entry
  * 
  *     def delete(self, KnownHostEntry entry not None):             # <<<<<<<<<<<<<<
@@ -4484,7 +6463,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.delete", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -4493,7 +6471,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":282
+/* "ssh2/knownhost.pyx":283
  *                 "Error deleting known host entry - error code %s", rc)
  * 
  *     def readline(self, bytes line not None,             # <<<<<<<<<<<<<<
@@ -4502,71 +6480,109 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_12delete(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_14readline[] = "KnownHost.readline(self, bytes line, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nRead line from known hosts file and add to known hosts\n        collection. Only OpenSSH known hosts file format is currently supported.\n\n        Note - When using readline, the key values returned by ``self.get`` will\n        need to be base64 encoded as libssh2's readline does not encode them\n        when adding, unlike ``self.readfile`` and ``self.addc``.\n\n        :param line: Byte string representing line to read.\n        :type line: bytes\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostReadLineError` on errors\n          reading line.";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_14readline, "KnownHost.readline(self, bytes line, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nRead line from known hosts file and add to known hosts\n        collection. Only OpenSSH known hosts file format is currently supported.\n\n        Note - When using readline, the key values returned by ``self.get`` will\n        need to be base64 encoded as libssh2's readline does not encode them\n        when adding, unlike ``self.readfile`` and ``self.addc``.\n\n        :param line: Byte string representing line to read.\n        :type line: bytes\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostReadLineError` on errors\n          reading line.");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_15readline = {"readline", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_14readline};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_line = 0;
   int __pyx_v_f_type;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("readline (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_line,&__pyx_n_s_f_type,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_line,&__pyx_n_s_f_type,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_line)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_line)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f_type);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f_type);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readline") < 0)) __PYX_ERR(0, 282, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readline") < 0)) __PYX_ERR(0, 283, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_line = ((PyObject*)values[0]);
     if (values[1]) {
-      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
+      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L3_error)
     } else {
-      __pyx_v_f_type = __pyx_k__3;
+      __pyx_v_f_type = __pyx_k_;
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("readline", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 282, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("readline", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 283, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.readline", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_line), (&PyBytes_Type), 0, "line", 1))) __PYX_ERR(0, 282, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_line), (&PyBytes_Type), 0, "line", 1))) __PYX_ERR(0, 283, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_line, __pyx_v_f_type);
 
   /* function exit code */
@@ -4574,6 +6590,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline(PyObject *__pyx
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4591,34 +6613,33 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
   PyObject *__pyx_t_5 = NULL;
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
+  unsigned int __pyx_t_8;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("readline", 0);
+  __Pyx_RefNannySetupContext("readline", 1);
 
-  /* "ssh2/knownhost.pyx":297
+  /* "ssh2/knownhost.pyx":298
  *           reading line."""
  *         cdef int rc
  *         cdef char *_line = line             # <<<<<<<<<<<<<<
  *         cdef size_t line_len = len(line)
  *         with nogil:
  */
-  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_line); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 297, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_line); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 298, __pyx_L1_error)
   __pyx_v__line = __pyx_t_1;
 
-  /* "ssh2/knownhost.pyx":298
+  /* "ssh2/knownhost.pyx":299
  *         cdef int rc
  *         cdef char *_line = line
  *         cdef size_t line_len = len(line)             # <<<<<<<<<<<<<<
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_readline(
  */
-  __pyx_t_2 = PyBytes_GET_SIZE(__pyx_v_line); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 298, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_line); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 299, __pyx_L1_error)
   __pyx_v_line_len = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":299
+  /* "ssh2/knownhost.pyx":300
  *         cdef char *_line = line
  *         cdef size_t line_len = len(line)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4628,12 +6649,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":300
+        /* "ssh2/knownhost.pyx":301
  *         cdef size_t line_len = len(line)
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_readline(             # <<<<<<<<<<<<<<
@@ -4643,7 +6665,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
         __pyx_v_rc = libssh2_knownhost_readline(__pyx_v_self->_ptr, __pyx_v__line, __pyx_v_line_len, __pyx_v_f_type);
       }
 
-      /* "ssh2/knownhost.pyx":299
+      /* "ssh2/knownhost.pyx":300
  *         cdef char *_line = line
  *         cdef size_t line_len = len(line)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4662,38 +6684,39 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
       }
   }
 
-  /* "ssh2/knownhost.pyx":302
+  /* "ssh2/knownhost.pyx":303
  *             rc = c_ssh2.libssh2_knownhost_readline(
  *                 self._ptr, _line, line_len, f_type)
  *         if rc != 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostReadLineError(
  *                 "Error deleting line from known hosts - error code %s", rc)
  */
-  __pyx_t_3 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_3 = (__pyx_v_rc != 0);
   if (unlikely(__pyx_t_3)) {
 
-    /* "ssh2/knownhost.pyx":303
+    /* "ssh2/knownhost.pyx":304
  *                 self._ptr, _line, line_len, f_type)
  *         if rc != 0:
  *             raise KnownHostReadLineError(             # <<<<<<<<<<<<<<
  *                 "Error deleting line from known hosts - error code %s", rc)
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostReadLineError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 303, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostReadLineError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 304, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
 
-    /* "ssh2/knownhost.pyx":304
+    /* "ssh2/knownhost.pyx":305
  *         if rc != 0:
  *             raise KnownHostReadLineError(
  *                 "Error deleting line from known hosts - error code %s", rc)             # <<<<<<<<<<<<<<
  * 
  *     def readfile(self, filename not None,
  */
-    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 304, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 305, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_6);
     __pyx_t_7 = NULL;
     __pyx_t_8 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
       __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
       if (likely(__pyx_t_7)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
@@ -4703,46 +6726,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
         __pyx_t_8 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_5)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_s_Error_deleting_line_from_known_h, __pyx_t_6};
-      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 303, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    } else
     #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_s_Error_deleting_line_from_known_h, __pyx_t_6};
-      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 303, __pyx_L1_error)
+    {
+      PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_kp_u_Error_deleting_line_from_known_h, __pyx_t_6};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
       __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_GOTREF(__pyx_t_4);
       __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 303, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      if (__pyx_t_7) {
-        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_deleting_line_from_known_h);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_deleting_line_from_known_h);
-      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_kp_s_Error_deleting_line_from_known_h);
-      __Pyx_GIVEREF(__pyx_t_6);
-      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6);
-      __pyx_t_6 = 0;
-      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 303, __pyx_L1_error)
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 304, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __Pyx_Raise(__pyx_t_4, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __PYX_ERR(0, 303, __pyx_L1_error)
+    __PYX_ERR(0, 304, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":302
+    /* "ssh2/knownhost.pyx":303
  *             rc = c_ssh2.libssh2_knownhost_readline(
  *                 self._ptr, _line, line_len, f_type)
  *         if rc != 0:             # <<<<<<<<<<<<<<
@@ -4751,7 +6749,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
  */
   }
 
-  /* "ssh2/knownhost.pyx":282
+  /* "ssh2/knownhost.pyx":283
  *                 "Error deleting known host entry - error code %s", rc)
  * 
  *     def readline(self, bytes line not None,             # <<<<<<<<<<<<<<
@@ -4767,7 +6765,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_9);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.readline", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -4776,7 +6773,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":306
+/* "ssh2/knownhost.pyx":307
  *                 "Error deleting line from known hosts - error code %s", rc)
  * 
  *     def readfile(self, filename not None,             # <<<<<<<<<<<<<<
@@ -4785,72 +6782,110 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_14readline(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_16readfile[] = "KnownHost.readfile(self, filename, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nRead known hosts file and add hosts to known hosts collection.\n        Only OpenSSH known hosts file format is currently supported.\n\n        Returns number of successfully read host entries.\n\n        :param filename: File name to read.\n        :type filename: str\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostReadFileError` on errors\n          reading file.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_16readfile, "KnownHost.readfile(self, filename, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nRead known hosts file and add hosts to known hosts collection.\n        Only OpenSSH known hosts file format is currently supported.\n\n        Returns number of successfully read host entries.\n\n        :param filename: File name to read.\n        :type filename: str\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostReadFileError` on errors\n          reading file.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_17readfile = {"readfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_16readfile};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_filename = 0;
   int __pyx_v_f_type;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("readfile (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_f_type,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_f_type,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f_type);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f_type);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readfile") < 0)) __PYX_ERR(0, 306, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readfile") < 0)) __PYX_ERR(0, 307, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_filename = values[0];
     if (values[1]) {
-      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L3_error)
+      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 308, __pyx_L3_error)
     } else {
-      __pyx_v_f_type = __pyx_k__4;
+      __pyx_v_f_type = __pyx_k__2;
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("readfile", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 306, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("readfile", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 307, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.readfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_filename) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "filename"); __PYX_ERR(0, 306, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "filename"); __PYX_ERR(0, 307, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_filename, __pyx_v_f_type);
 
@@ -4859,6 +6894,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile(PyObject *__pyx
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4875,26 +6916,25 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   PyObject *__pyx_t_6 = NULL;
-  int __pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
+  unsigned int __pyx_t_7;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("readfile", 0);
+  __Pyx_RefNannySetupContext("readfile", 1);
 
-  /* "ssh2/knownhost.pyx":320
+  /* "ssh2/knownhost.pyx":321
  * 
  *         :rtype: int"""
  *         cdef bytes b_filename = to_bytes(filename)             # <<<<<<<<<<<<<<
  *         cdef char *_filename = b_filename
  *         cdef int rc
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_filename); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_filename); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 321, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_filename = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":321
+  /* "ssh2/knownhost.pyx":322
  *         :rtype: int"""
  *         cdef bytes b_filename = to_bytes(filename)
  *         cdef char *_filename = b_filename             # <<<<<<<<<<<<<<
@@ -4903,12 +6943,12 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
  */
   if (unlikely(__pyx_v_b_filename == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 321, __pyx_L1_error)
+    __PYX_ERR(0, 322, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_filename); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_filename); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L1_error)
   __pyx_v__filename = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":323
+  /* "ssh2/knownhost.pyx":324
  *         cdef char *_filename = b_filename
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4918,12 +6958,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":324
+        /* "ssh2/knownhost.pyx":325
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_readfile(             # <<<<<<<<<<<<<<
@@ -4933,7 +6974,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
         __pyx_v_rc = libssh2_knownhost_readfile(__pyx_v_self->_ptr, __pyx_v__filename, __pyx_v_f_type);
       }
 
-      /* "ssh2/knownhost.pyx":323
+      /* "ssh2/knownhost.pyx":324
  *         cdef char *_filename = b_filename
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4952,38 +6993,39 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
       }
   }
 
-  /* "ssh2/knownhost.pyx":326
+  /* "ssh2/knownhost.pyx":327
  *             rc = c_ssh2.libssh2_knownhost_readfile(
  *                 self._ptr, _filename, f_type)
  *         if rc < 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostReadFileError(
  *                 "Error reading known hosts file %s - error code %s",
  */
-  __pyx_t_3 = ((__pyx_v_rc < 0) != 0);
+  __pyx_t_3 = (__pyx_v_rc < 0);
   if (unlikely(__pyx_t_3)) {
 
-    /* "ssh2/knownhost.pyx":327
+    /* "ssh2/knownhost.pyx":328
  *                 self._ptr, _filename, f_type)
  *         if rc < 0:
  *             raise KnownHostReadFileError(             # <<<<<<<<<<<<<<
  *                 "Error reading known hosts file %s - error code %s",
  *                 filename, rc)
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostReadFileError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 327, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostReadFileError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
 
-    /* "ssh2/knownhost.pyx":329
+    /* "ssh2/knownhost.pyx":330
  *             raise KnownHostReadFileError(
  *                 "Error reading known hosts file %s - error code %s",
  *                 filename, rc)             # <<<<<<<<<<<<<<
  *         return rc
  * 
  */
-    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 329, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __pyx_t_6 = NULL;
     __pyx_t_7 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
       __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
       if (likely(__pyx_t_6)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
@@ -4993,49 +7035,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
         __pyx_t_7 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_4)) {
-      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_kp_s_Error_reading_known_hosts_file_s, __pyx_v_filename, __pyx_t_5};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    } else
     #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-      PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_kp_s_Error_reading_known_hosts_file_s, __pyx_v_filename, __pyx_t_5};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error)
+    {
+      PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_kp_u_Error_reading_known_hosts_file_s, __pyx_v_filename, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 3+__pyx_t_7);
       __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 327, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      if (__pyx_t_6) {
-        __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_reading_known_hosts_file_s);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_reading_known_hosts_file_s);
-      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_kp_s_Error_reading_known_hosts_file_s);
-      __Pyx_INCREF(__pyx_v_filename);
-      __Pyx_GIVEREF(__pyx_v_filename);
-      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_filename);
-      __Pyx_GIVEREF(__pyx_t_5);
-      PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5);
-      __pyx_t_5 = 0;
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error)
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 328, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     }
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     __Pyx_Raise(__pyx_t_1, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __PYX_ERR(0, 327, __pyx_L1_error)
+    __PYX_ERR(0, 328, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":326
+    /* "ssh2/knownhost.pyx":327
  *             rc = c_ssh2.libssh2_knownhost_readfile(
  *                 self._ptr, _filename, f_type)
  *         if rc < 0:             # <<<<<<<<<<<<<<
@@ -5044,7 +7058,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
  */
   }
 
-  /* "ssh2/knownhost.pyx":330
+  /* "ssh2/knownhost.pyx":331
  *                 "Error reading known hosts file %s - error code %s",
  *                 filename, rc)
  *         return rc             # <<<<<<<<<<<<<<
@@ -5052,13 +7066,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
  *     def writeline(self, KnownHostEntry entry,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 331, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":306
+  /* "ssh2/knownhost.pyx":307
  *                 "Error deleting line from known hosts - error code %s", rc)
  * 
  *     def readfile(self, filename not None,             # <<<<<<<<<<<<<<
@@ -5072,7 +7086,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_8);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.readfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -5082,7 +7095,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":332
+/* "ssh2/knownhost.pyx":333
  *         return rc
  * 
  *     def writeline(self, KnownHostEntry entry,             # <<<<<<<<<<<<<<
@@ -5091,87 +7104,126 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_16readfile(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_18writeline[] = "KnownHost.writeline(self, KnownHostEntry entry, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH, size_t buf_len=1024)\nConvert a single known host entry to a single line of output\n        for writing. Only OpenSSH known hosts file format is currently\n        supported.\n\n        :param entry: Known host entry to write line for.\n        :type entry: :py:class:`ssh2.knownhost.KnownHostEntry`\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostWriteLineError` on errors\n          writing line.\n\n        :rtype: bytes";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_18writeline, "KnownHost.writeline(self, KnownHostEntry entry, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH, size_t buf_len=1024)\nConvert a single known host entry to a single line of output\n        for writing. Only OpenSSH known hosts file format is currently\n        supported.\n\n        :param entry: Known host entry to write line for.\n        :type entry: :py:class:`ssh2.knownhost.KnownHostEntry`\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostWriteLineError` on errors\n          writing line.\n\n        :rtype: bytes");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_19writeline = {"writeline", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_18writeline};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_entry = 0;
   int __pyx_v_f_type;
   size_t __pyx_v_buf_len;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("writeline (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entry,&__pyx_n_s_f_type,&__pyx_n_s_buf_len,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entry,&__pyx_n_s_f_type,&__pyx_n_s_buf_len,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_entry)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entry)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 333, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f_type);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f_type);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 333, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buf_len);
-          if (value) { values[2] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf_len);
+          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 333, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "writeline") < 0)) __PYX_ERR(0, 332, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeline") < 0)) __PYX_ERR(0, 333, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_entry = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)values[0]);
     if (values[1]) {
-      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 333, __pyx_L3_error)
+      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 334, __pyx_L3_error)
     } else {
-      __pyx_v_f_type = __pyx_k__5;
+      __pyx_v_f_type = __pyx_k__3;
     }
     if (values[2]) {
-      __pyx_v_buf_len = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_buf_len == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 334, __pyx_L3_error)
+      __pyx_v_buf_len = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_buf_len == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 335, __pyx_L3_error)
     } else {
       __pyx_v_buf_len = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("writeline", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 332, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("writeline", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 333, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.writeline", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_entry), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 1, "entry", 0))) __PYX_ERR(0, 332, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_entry), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 1, "entry", 0))) __PYX_ERR(0, 333, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_entry, __pyx_v_f_type, __pyx_v_buf_len);
 
   /* function exit code */
@@ -5179,6 +7231,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline(PyObject *__py
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5195,8 +7253,8 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
+  int __pyx_t_7;
   int __pyx_t_8;
   char const *__pyx_t_9;
   PyObject *__pyx_t_10 = NULL;
@@ -5208,19 +7266,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("writeline", 0);
+  __Pyx_RefNannySetupContext("writeline", 1);
 
-  /* "ssh2/knownhost.pyx":346
+  /* "ssh2/knownhost.pyx":347
  * 
  *         :rtype: bytes"""
  *         cdef bytes output = b""             # <<<<<<<<<<<<<<
  *         cdef size_t outlen = 0
  *         cdef char *buf
  */
-  __Pyx_INCREF(__pyx_kp_b__6);
-  __pyx_v_output = __pyx_kp_b__6;
+  __Pyx_INCREF(__pyx_kp_b__4);
+  __pyx_v_output = __pyx_kp_b__4;
 
-  /* "ssh2/knownhost.pyx":347
+  /* "ssh2/knownhost.pyx":348
  *         :rtype: bytes"""
  *         cdef bytes output = b""
  *         cdef size_t outlen = 0             # <<<<<<<<<<<<<<
@@ -5229,7 +7287,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
   __pyx_v_outlen = 0;
 
-  /* "ssh2/knownhost.pyx":350
+  /* "ssh2/knownhost.pyx":351
  *         cdef char *buf
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5239,12 +7297,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":351
+        /* "ssh2/knownhost.pyx":352
  *         cdef int rc
  *         with nogil:
  *             buf = <char *>malloc(sizeof(char)*buf_len)             # <<<<<<<<<<<<<<
@@ -5253,17 +7312,17 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
         __pyx_v_buf = ((char *)malloc(((sizeof(char)) * __pyx_v_buf_len)));
 
-        /* "ssh2/knownhost.pyx":352
+        /* "ssh2/knownhost.pyx":353
  *         with nogil:
  *             buf = <char *>malloc(sizeof(char)*buf_len)
  *             if buf is NULL:             # <<<<<<<<<<<<<<
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_1 = ((__pyx_v_buf == NULL) != 0);
-        if (__pyx_t_1) {
+        __pyx_t_1 = (__pyx_v_buf == NULL);
+        if (unlikely(__pyx_t_1)) {
 
-          /* "ssh2/knownhost.pyx":353
+          /* "ssh2/knownhost.pyx":354
  *             buf = <char *>malloc(sizeof(char)*buf_len)
  *             if buf is NULL:
  *                 with gil:             # <<<<<<<<<<<<<<
@@ -5276,17 +7335,17 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
               #endif
               /*try:*/ {
 
-                /* "ssh2/knownhost.pyx":354
+                /* "ssh2/knownhost.pyx":355
  *             if buf is NULL:
  *                 with gil:
  *                     raise MemoryError             # <<<<<<<<<<<<<<
  *             rc = c_ssh2.libssh2_knownhost_writeline(
  *                 self._ptr, entry._store, buf, buf_len, &outlen, f_type)
  */
-                PyErr_NoMemory(); __PYX_ERR(0, 354, __pyx_L8_error)
+                PyErr_NoMemory(); __PYX_ERR(0, 355, __pyx_L8_error)
               }
 
-              /* "ssh2/knownhost.pyx":353
+              /* "ssh2/knownhost.pyx":354
  *             buf = <char *>malloc(sizeof(char)*buf_len)
  *             if buf is NULL:
  *                 with gil:             # <<<<<<<<<<<<<<
@@ -5303,7 +7362,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
               }
           }
 
-          /* "ssh2/knownhost.pyx":352
+          /* "ssh2/knownhost.pyx":353
  *         with nogil:
  *             buf = <char *>malloc(sizeof(char)*buf_len)
  *             if buf is NULL:             # <<<<<<<<<<<<<<
@@ -5312,7 +7371,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
         }
 
-        /* "ssh2/knownhost.pyx":355
+        /* "ssh2/knownhost.pyx":356
  *                 with gil:
  *                     raise MemoryError
  *             rc = c_ssh2.libssh2_knownhost_writeline(             # <<<<<<<<<<<<<<
@@ -5322,7 +7381,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
         __pyx_v_rc = libssh2_knownhost_writeline(__pyx_v_self->_ptr, __pyx_v_entry->_store, __pyx_v_buf, __pyx_v_buf_len, (&__pyx_v_outlen), __pyx_v_f_type);
       }
 
-      /* "ssh2/knownhost.pyx":350
+      /* "ssh2/knownhost.pyx":351
  *         cdef char *buf
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5348,7 +7407,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
       }
   }
 
-  /* "ssh2/knownhost.pyx":357
+  /* "ssh2/knownhost.pyx":358
  *             rc = c_ssh2.libssh2_knownhost_writeline(
  *                 self._ptr, entry._store, buf, buf_len, &outlen, f_type)
  *         try:             # <<<<<<<<<<<<<<
@@ -5357,17 +7416,17 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
   /*try:*/ {
 
-    /* "ssh2/knownhost.pyx":358
+    /* "ssh2/knownhost.pyx":359
  *                 self._ptr, entry._store, buf, buf_len, &outlen, f_type)
  *         try:
  *             if rc == _LIBSSH2_ERROR_BUFFER_TOO_SMALL:             # <<<<<<<<<<<<<<
  *                 return self.writeline(entry, buf_len=buf_len*2)
  *             elif rc != 0:
  */
-    __pyx_t_1 = ((__pyx_v_rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) != 0);
+    __pyx_t_1 = (__pyx_v_rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL);
     if (__pyx_t_1) {
 
-      /* "ssh2/knownhost.pyx":359
+      /* "ssh2/knownhost.pyx":360
  *         try:
  *             if rc == _LIBSSH2_ERROR_BUFFER_TOO_SMALL:
  *                 return self.writeline(entry, buf_len=buf_len*2)             # <<<<<<<<<<<<<<
@@ -5375,20 +7434,20 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  *                 raise KnownHostWriteLineError(
  */
       __Pyx_XDECREF(__pyx_r);
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_writeline); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L11_error)
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_writeline); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 359, __pyx_L11_error)
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_INCREF(((PyObject *)__pyx_v_entry));
-      __Pyx_GIVEREF(((PyObject *)__pyx_v_entry));
-      PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_entry));
-      __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 359, __pyx_L11_error)
+      __Pyx_INCREF((PyObject *)__pyx_v_entry);
+      __Pyx_GIVEREF((PyObject *)__pyx_v_entry);
+      if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_entry))) __PYX_ERR(0, 360, __pyx_L11_error);
+      __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_buf_len * 2)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L11_error)
+      __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_buf_len * 2)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_5);
-      if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_buf_len, __pyx_t_5) < 0) __PYX_ERR(0, 359, __pyx_L11_error)
+      if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_buf_len, __pyx_t_5) < 0) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L11_error)
+      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 360, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -5397,7 +7456,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
       __pyx_t_5 = 0;
       goto __pyx_L10_return;
 
-      /* "ssh2/knownhost.pyx":358
+      /* "ssh2/knownhost.pyx":359
  *                 self._ptr, entry._store, buf, buf_len, &outlen, f_type)
  *         try:
  *             if rc == _LIBSSH2_ERROR_BUFFER_TOO_SMALL:             # <<<<<<<<<<<<<<
@@ -5406,38 +7465,39 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
     }
 
-    /* "ssh2/knownhost.pyx":360
+    /* "ssh2/knownhost.pyx":361
  *             if rc == _LIBSSH2_ERROR_BUFFER_TOO_SMALL:
  *                 return self.writeline(entry, buf_len=buf_len*2)
  *             elif rc != 0:             # <<<<<<<<<<<<<<
  *                 raise KnownHostWriteLineError(
  *                     "Error writing line for known host entry - error code %s",
  */
-    __pyx_t_1 = ((__pyx_v_rc != 0) != 0);
+    __pyx_t_1 = (__pyx_v_rc != 0);
     if (unlikely(__pyx_t_1)) {
 
-      /* "ssh2/knownhost.pyx":361
+      /* "ssh2/knownhost.pyx":362
  *                 return self.writeline(entry, buf_len=buf_len*2)
  *             elif rc != 0:
  *                 raise KnownHostWriteLineError(             # <<<<<<<<<<<<<<
  *                     "Error writing line for known host entry - error code %s",
  *                     rc)
  */
-      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostWriteLineError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 361, __pyx_L11_error)
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostWriteLineError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 362, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_4);
 
-      /* "ssh2/knownhost.pyx":363
+      /* "ssh2/knownhost.pyx":364
  *                 raise KnownHostWriteLineError(
  *                     "Error writing line for known host entry - error code %s",
  *                     rc)             # <<<<<<<<<<<<<<
  *             if outlen > 0:
  *                 output = buf[:outlen]
  */
-      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L11_error)
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_3);
       __pyx_t_2 = NULL;
       __pyx_t_6 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
         __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
         if (likely(__pyx_t_2)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
@@ -5447,46 +7507,21 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
           __pyx_t_6 = 1;
         }
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_4)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_kp_s_Error_writing_line_for_known_hos, __pyx_t_3};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L11_error)
-        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      } else
       #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_kp_s_Error_writing_line_for_known_hos, __pyx_t_3};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L11_error)
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_kp_u_Error_writing_line_for_known_hos, __pyx_t_3};
+        __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
         __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 361, __pyx_L11_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        if (__pyx_t_2) {
-          __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL;
-        }
-        __Pyx_INCREF(__pyx_kp_s_Error_writing_line_for_known_hos);
-        __Pyx_GIVEREF(__pyx_kp_s_Error_writing_line_for_known_hos);
-        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Error_writing_line_for_known_hos);
-        __Pyx_GIVEREF(__pyx_t_3);
-        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3);
-        __pyx_t_3 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 361, __pyx_L11_error)
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 362, __pyx_L11_error)
         __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       }
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_Raise(__pyx_t_5, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __PYX_ERR(0, 361, __pyx_L11_error)
+      __PYX_ERR(0, 362, __pyx_L11_error)
 
-      /* "ssh2/knownhost.pyx":360
+      /* "ssh2/knownhost.pyx":361
  *             if rc == _LIBSSH2_ERROR_BUFFER_TOO_SMALL:
  *                 return self.writeline(entry, buf_len=buf_len*2)
  *             elif rc != 0:             # <<<<<<<<<<<<<<
@@ -5495,29 +7530,29 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
     }
 
-    /* "ssh2/knownhost.pyx":364
+    /* "ssh2/knownhost.pyx":365
  *                     "Error writing line for known host entry - error code %s",
  *                     rc)
  *             if outlen > 0:             # <<<<<<<<<<<<<<
  *                 output = buf[:outlen]
  *         finally:
  */
-    __pyx_t_1 = ((__pyx_v_outlen > 0) != 0);
+    __pyx_t_1 = (__pyx_v_outlen > 0);
     if (__pyx_t_1) {
 
-      /* "ssh2/knownhost.pyx":365
+      /* "ssh2/knownhost.pyx":366
  *                     rc)
  *             if outlen > 0:
  *                 output = buf[:outlen]             # <<<<<<<<<<<<<<
  *         finally:
  *             free(buf)
  */
-      __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf + 0, __pyx_v_outlen - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 365, __pyx_L11_error)
+      __pyx_t_5 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_buf + 0, __pyx_v_outlen - 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 366, __pyx_L11_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_DECREF_SET(__pyx_v_output, ((PyObject*)__pyx_t_5));
       __pyx_t_5 = 0;
 
-      /* "ssh2/knownhost.pyx":364
+      /* "ssh2/knownhost.pyx":365
  *                     "Error writing line for known host entry - error code %s",
  *                     rc)
  *             if outlen > 0:             # <<<<<<<<<<<<<<
@@ -5527,7 +7562,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
     }
   }
 
-  /* "ssh2/knownhost.pyx":367
+  /* "ssh2/knownhost.pyx":368
  *                 output = buf[:outlen]
  *         finally:
  *             free(buf)             # <<<<<<<<<<<<<<
@@ -5548,7 +7583,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
       __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
       __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
       if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
       if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
       __Pyx_XGOTREF(__pyx_t_10);
@@ -5557,7 +7591,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
       __Pyx_XGOTREF(__pyx_t_13);
       __Pyx_XGOTREF(__pyx_t_14);
       __Pyx_XGOTREF(__pyx_t_15);
-      __pyx_t_6 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename;
+      __pyx_t_7 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename;
       {
         free(__pyx_v_buf);
       }
@@ -5572,7 +7606,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
       __Pyx_XGIVEREF(__pyx_t_12);
       __Pyx_ErrRestore(__pyx_t_10, __pyx_t_11, __pyx_t_12);
       __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0;
-      __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9;
+      __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9;
       goto __pyx_L1_error;
     }
     __pyx_L10_return: {
@@ -5586,7 +7620,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
     __pyx_L12:;
   }
 
-  /* "ssh2/knownhost.pyx":368
+  /* "ssh2/knownhost.pyx":369
  *         finally:
  *             free(buf)
  *         return output             # <<<<<<<<<<<<<<
@@ -5598,7 +7632,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   __pyx_r = __pyx_v_output;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":332
+  /* "ssh2/knownhost.pyx":333
  *         return rc
  * 
  *     def writeline(self, KnownHostEntry entry,             # <<<<<<<<<<<<<<
@@ -5612,7 +7646,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.writeline", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -5622,7 +7655,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":370
+/* "ssh2/knownhost.pyx":371
  *         return output
  * 
  *     def writefile(self, filename not None,             # <<<<<<<<<<<<<<
@@ -5631,72 +7664,110 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_18writeline(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_20writefile[] = "KnownHost.writefile(self, filename, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nWrite all known host entries to file. Only OpenSSH known hosts file\n        format is currently supported.\n\n        :param filename: File name to write known hosts to.\n        :type filename: str\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostWriteFileError` on errors\n          writing to file.";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_20writefile, "KnownHost.writefile(self, filename, int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH)\nWrite all known host entries to file. Only OpenSSH known hosts file\n        format is currently supported.\n\n        :param filename: File name to write known hosts to.\n        :type filename: str\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostWriteFileError` on errors\n          writing to file.");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_21writefile = {"writefile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_20writefile};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_filename = 0;
   int __pyx_v_f_type;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("writefile (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_f_type,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_f_type,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 371, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f_type);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_f_type);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 371, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "writefile") < 0)) __PYX_ERR(0, 370, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writefile") < 0)) __PYX_ERR(0, 371, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_filename = values[0];
     if (values[1]) {
-      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 371, __pyx_L3_error)
+      __pyx_v_f_type = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_f_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 372, __pyx_L3_error)
     } else {
-      __pyx_v_f_type = __pyx_k__7;
+      __pyx_v_f_type = __pyx_k__5;
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("writefile", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 370, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("writefile", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 371, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.writefile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_filename) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "filename"); __PYX_ERR(0, 370, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "filename"); __PYX_ERR(0, 371, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_filename, __pyx_v_f_type);
 
@@ -5705,6 +7776,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile(PyObject *__py
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5720,26 +7797,25 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
   int __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("writefile", 0);
+  __Pyx_RefNannySetupContext("writefile", 1);
 
-  /* "ssh2/knownhost.pyx":380
+  /* "ssh2/knownhost.pyx":381
  *         :raises: :py:class:`ssh2.exceptions.KnownHostWriteFileError` on errors
  *           writing to file."""
  *         cdef bytes b_filename = to_bytes(filename)             # <<<<<<<<<<<<<<
  *         cdef char *_filename = b_filename
  *         cdef int rc
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_filename); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_filename); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_filename = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":381
+  /* "ssh2/knownhost.pyx":382
  *           writing to file."""
  *         cdef bytes b_filename = to_bytes(filename)
  *         cdef char *_filename = b_filename             # <<<<<<<<<<<<<<
@@ -5748,12 +7824,12 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
  */
   if (unlikely(__pyx_v_b_filename == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(0, 381, __pyx_L1_error)
+    __PYX_ERR(0, 382, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_filename); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_filename); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 382, __pyx_L1_error)
   __pyx_v__filename = __pyx_t_2;
 
-  /* "ssh2/knownhost.pyx":383
+  /* "ssh2/knownhost.pyx":384
  *         cdef char *_filename = b_filename
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5763,12 +7839,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":384
+        /* "ssh2/knownhost.pyx":385
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_writefile(             # <<<<<<<<<<<<<<
@@ -5778,7 +7855,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
         __pyx_v_rc = libssh2_knownhost_writefile(__pyx_v_self->_ptr, __pyx_v__filename, __pyx_v_f_type);
       }
 
-      /* "ssh2/knownhost.pyx":383
+      /* "ssh2/knownhost.pyx":384
  *         cdef char *_filename = b_filename
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5797,27 +7874,27 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
       }
   }
 
-  /* "ssh2/knownhost.pyx":386
+  /* "ssh2/knownhost.pyx":387
  *             rc = c_ssh2.libssh2_knownhost_writefile(
  *                 self._ptr, _filename, f_type)
  *         if rc != 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostWriteFileError(
  *                 "Error writing known hosts to file %s", filename)
  */
-  __pyx_t_3 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_3 = (__pyx_v_rc != 0);
   if (unlikely(__pyx_t_3)) {
 
-    /* "ssh2/knownhost.pyx":387
+    /* "ssh2/knownhost.pyx":388
  *                 self._ptr, _filename, f_type)
  *         if rc != 0:
  *             raise KnownHostWriteFileError(             # <<<<<<<<<<<<<<
  *                 "Error writing known hosts to file %s", filename)
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostWriteFileError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 387, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_KnownHostWriteFileError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 388, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
 
-    /* "ssh2/knownhost.pyx":388
+    /* "ssh2/knownhost.pyx":389
  *         if rc != 0:
  *             raise KnownHostWriteFileError(
  *                 "Error writing known hosts to file %s", filename)             # <<<<<<<<<<<<<<
@@ -5826,7 +7903,8 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
  */
     __pyx_t_5 = NULL;
     __pyx_t_6 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
       __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
       if (likely(__pyx_t_5)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
@@ -5836,44 +7914,20 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
         __pyx_t_6 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_4)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_writing_known_hosts_to_fil, __pyx_v_filename};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_writing_known_hosts_to_fil, __pyx_v_filename};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-    } else
     #endif
     {
-      __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      if (__pyx_t_5) {
-        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_writing_known_hosts_to_fil);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_writing_known_hosts_to_fil);
-      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Error_writing_known_hosts_to_fil);
-      __Pyx_INCREF(__pyx_v_filename);
-      __Pyx_GIVEREF(__pyx_v_filename);
-      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_filename);
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error)
+      PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_u_Error_writing_known_hosts_to_fil, __pyx_v_filename};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     }
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     __Pyx_Raise(__pyx_t_1, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __PYX_ERR(0, 387, __pyx_L1_error)
+    __PYX_ERR(0, 388, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":386
+    /* "ssh2/knownhost.pyx":387
  *             rc = c_ssh2.libssh2_knownhost_writefile(
  *                 self._ptr, _filename, f_type)
  *         if rc != 0:             # <<<<<<<<<<<<<<
@@ -5882,7 +7936,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
  */
   }
 
-  /* "ssh2/knownhost.pyx":370
+  /* "ssh2/knownhost.pyx":371
  *         return output
  * 
  *     def writefile(self, filename not None,             # <<<<<<<<<<<<<<
@@ -5897,7 +7951,6 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.writefile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -5907,7 +7960,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
   return __pyx_r;
 }
 
-/* "ssh2/knownhost.pyx":390
+/* "ssh2/knownhost.pyx":391
  *                 "Error writing known hosts to file %s", filename)
  * 
  *     def get(self, KnownHostEntry prev=None):             # <<<<<<<<<<<<<<
@@ -5916,43 +7969,69 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_20writefile(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_22get[] = "KnownHost.get(self, KnownHostEntry prev=None)\nRetrieve all host entries in known hosts collection.\n\n        :param prev: (Optional) Existing known host entry to start retrieval\n          from. All hosts are retrieved when prev is ``None`` which is the\n          default.\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostGetError` on errors\n          retrieving known host collection.\n\n        :rtype: list(:py:class:`ssh2.knownhost.KnownHostEntry`)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_22get, "KnownHost.get(self, KnownHostEntry prev=None)\nRetrieve all host entries in known hosts collection.\n\n        :param prev: (Optional) Existing known host entry to start retrieval\n          from. All hosts are retrieved when prev is ``None`` which is the\n          default.\n\n        :raises: :py:class:`ssh2.exceptions.KnownHostGetError` on errors\n          retrieving known host collection.\n\n        :rtype: list(:py:class:`ssh2.knownhost.KnownHostEntry`)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_23get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_23get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_22get};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *__pyx_v_prev = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prev,0};
-    PyObject* values[1] = {0};
-    values[0] = (PyObject *)((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prev,0};
+    values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prev);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_prev);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get") < 0)) __PYX_ERR(0, 390, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 391, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -5960,15 +8039,23 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_se
     }
     __pyx_v_prev = ((struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("get", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 390, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("get", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 391, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.get", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prev), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 1, "prev", 0))) __PYX_ERR(0, 390, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prev), __pyx_ptype_4ssh2_9knownhost_KnownHostEntry, 1, "prev", 0))) __PYX_ERR(0, 391, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_22get(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v_prev);
 
   /* function exit code */
@@ -5976,6 +8063,12 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_23get(PyObject *__pyx_v_se
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5989,20 +8082,18 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   int __pyx_t_2;
-  int __pyx_t_3;
-  struct libssh2_knownhost *__pyx_t_4;
-  int __pyx_t_5;
+  struct libssh2_knownhost *__pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
   PyObject *__pyx_t_6 = NULL;
   PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  int __pyx_t_9;
-  PyObject *__pyx_t_10 = NULL;
+  unsigned int __pyx_t_8;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get", 0);
+  __Pyx_RefNannySetupContext("get", 1);
 
-  /* "ssh2/knownhost.pyx":401
+  /* "ssh2/knownhost.pyx":402
  * 
  *         :rtype: list(:py:class:`ssh2.knownhost.KnownHostEntry`)"""
  *         cdef c_ssh2.libssh2_knownhost *_store = NULL             # <<<<<<<<<<<<<<
@@ -6011,7 +8102,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  */
   __pyx_v__store = NULL;
 
-  /* "ssh2/knownhost.pyx":402
+  /* "ssh2/knownhost.pyx":403
  *         :rtype: list(:py:class:`ssh2.knownhost.KnownHostEntry`)"""
  *         cdef c_ssh2.libssh2_knownhost *_store = NULL
  *         cdef c_ssh2.libssh2_knownhost *_prev = NULL             # <<<<<<<<<<<<<<
@@ -6020,19 +8111,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  */
   __pyx_v__prev = NULL;
 
-  /* "ssh2/knownhost.pyx":404
+  /* "ssh2/knownhost.pyx":405
  *         cdef c_ssh2.libssh2_knownhost *_prev = NULL
  *         cdef int rc
  *         cdef list entries = []             # <<<<<<<<<<<<<<
  *         if prev is not None:
  *             _prev = prev._store
  */
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 404, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_entries = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":405
+  /* "ssh2/knownhost.pyx":406
  *         cdef int rc
  *         cdef list entries = []
  *         if prev is not None:             # <<<<<<<<<<<<<<
@@ -6040,20 +8131,19 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  *         with nogil:
  */
   __pyx_t_2 = (((PyObject *)__pyx_v_prev) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/knownhost.pyx":406
+    /* "ssh2/knownhost.pyx":407
  *         cdef list entries = []
  *         if prev is not None:
  *             _prev = prev._store             # <<<<<<<<<<<<<<
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_get(
  */
-    __pyx_t_4 = __pyx_v_prev->_store;
-    __pyx_v__prev = __pyx_t_4;
+    __pyx_t_3 = __pyx_v_prev->_store;
+    __pyx_v__prev = __pyx_t_3;
 
-    /* "ssh2/knownhost.pyx":405
+    /* "ssh2/knownhost.pyx":406
  *         cdef int rc
  *         cdef list entries = []
  *         if prev is not None:             # <<<<<<<<<<<<<<
@@ -6062,7 +8152,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  */
   }
 
-  /* "ssh2/knownhost.pyx":407
+  /* "ssh2/knownhost.pyx":408
  *         if prev is not None:
  *             _prev = prev._store
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6072,12 +8162,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/knownhost.pyx":408
+        /* "ssh2/knownhost.pyx":409
  *             _prev = prev._store
  *         with nogil:
  *             rc = c_ssh2.libssh2_knownhost_get(             # <<<<<<<<<<<<<<
@@ -6087,7 +8178,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
         __pyx_v_rc = libssh2_knownhost_get(__pyx_v_self->_ptr, (&__pyx_v__store), __pyx_v__prev);
       }
 
-      /* "ssh2/knownhost.pyx":407
+      /* "ssh2/knownhost.pyx":408
  *         if prev is not None:
  *             _prev = prev._store
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6106,7 +8197,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
       }
   }
 
-  /* "ssh2/knownhost.pyx":410
+  /* "ssh2/knownhost.pyx":411
  *             rc = c_ssh2.libssh2_knownhost_get(
  *                 self._ptr, &_store, _prev)
  *         while rc == 0:             # <<<<<<<<<<<<<<
@@ -6114,22 +8205,22 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  *             _prev = _store
  */
   while (1) {
-    __pyx_t_3 = ((__pyx_v_rc == 0) != 0);
-    if (!__pyx_t_3) break;
+    __pyx_t_2 = (__pyx_v_rc == 0);
+    if (!__pyx_t_2) break;
 
-    /* "ssh2/knownhost.pyx":411
+    /* "ssh2/knownhost.pyx":412
  *                 self._ptr, &_store, _prev)
  *         while rc == 0:
  *             entries.append(PyKnownHostEntry(_store))             # <<<<<<<<<<<<<<
  *             _prev = _store
  *             with nogil:
  */
-    __pyx_t_1 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyKnownHostEntry(__pyx_v__store)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error)
+    __pyx_t_1 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyKnownHostEntry(__pyx_v__store)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_entries, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 411, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_entries, __pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 412, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "ssh2/knownhost.pyx":412
+    /* "ssh2/knownhost.pyx":413
  *         while rc == 0:
  *             entries.append(PyKnownHostEntry(_store))
  *             _prev = _store             # <<<<<<<<<<<<<<
@@ -6138,7 +8229,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  */
     __pyx_v__prev = __pyx_v__store;
 
-    /* "ssh2/knownhost.pyx":413
+    /* "ssh2/knownhost.pyx":414
  *             entries.append(PyKnownHostEntry(_store))
  *             _prev = _store
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -6148,12 +8239,13 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
         /*try:*/ {
 
-          /* "ssh2/knownhost.pyx":414
+          /* "ssh2/knownhost.pyx":415
  *             _prev = _store
  *             with nogil:
  *                 rc = c_ssh2.libssh2_knownhost_get(             # <<<<<<<<<<<<<<
@@ -6163,7 +8255,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
           __pyx_v_rc = libssh2_knownhost_get(__pyx_v_self->_ptr, (&__pyx_v__store), __pyx_v__prev);
         }
 
-        /* "ssh2/knownhost.pyx":413
+        /* "ssh2/knownhost.pyx":414
  *             entries.append(PyKnownHostEntry(_store))
  *             _prev = _store
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -6183,86 +8275,62 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
     }
   }
 
-  /* "ssh2/knownhost.pyx":416
+  /* "ssh2/knownhost.pyx":417
  *                 rc = c_ssh2.libssh2_knownhost_get(
  *                     self._ptr, &_store, _prev)
  *         if rc < 0:             # <<<<<<<<<<<<<<
  *             raise KnownHostGetError(
  *                 "Error retrieving known hosts - error code %s", rc)
  */
-  __pyx_t_3 = ((__pyx_v_rc < 0) != 0);
-  if (unlikely(__pyx_t_3)) {
+  __pyx_t_2 = (__pyx_v_rc < 0);
+  if (unlikely(__pyx_t_2)) {
 
-    /* "ssh2/knownhost.pyx":417
+    /* "ssh2/knownhost.pyx":418
  *                     self._ptr, &_store, _prev)
  *         if rc < 0:
  *             raise KnownHostGetError(             # <<<<<<<<<<<<<<
  *                 "Error retrieving known hosts - error code %s", rc)
  *         return entries
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_KnownHostGetError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_KnownHostGetError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 418, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
 
-    /* "ssh2/knownhost.pyx":418
+    /* "ssh2/knownhost.pyx":419
  *         if rc < 0:
  *             raise KnownHostGetError(
  *                 "Error retrieving known hosts - error code %s", rc)             # <<<<<<<<<<<<<<
  *         return entries
  */
-    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 418, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_8 = NULL;
-    __pyx_t_9 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
-      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
-      if (likely(__pyx_t_8)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-        __Pyx_INCREF(__pyx_t_8);
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    __pyx_t_8 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_7);
         __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_6, function);
-        __pyx_t_9 = 1;
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_8 = 1;
       }
     }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_6)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_s_Error_retrieving_known_hosts_err, __pyx_t_7};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_s_Error_retrieving_known_hosts_err, __pyx_t_7};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
     #endif
     {
-      __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 417, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      if (__pyx_t_8) {
-        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
-      }
-      __Pyx_INCREF(__pyx_kp_s_Error_retrieving_known_hosts_err);
-      __Pyx_GIVEREF(__pyx_kp_s_Error_retrieving_known_hosts_err);
-      PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_kp_s_Error_retrieving_known_hosts_err);
-      __Pyx_GIVEREF(__pyx_t_7);
-      PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
-      __pyx_t_7 = 0;
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error)
+      PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_kp_u_Error_retrieving_known_hosts_err, __pyx_t_6};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8);
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
     __Pyx_Raise(__pyx_t_1, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __PYX_ERR(0, 417, __pyx_L1_error)
+    __PYX_ERR(0, 418, __pyx_L1_error)
 
-    /* "ssh2/knownhost.pyx":416
+    /* "ssh2/knownhost.pyx":417
  *                 rc = c_ssh2.libssh2_knownhost_get(
  *                     self._ptr, &_store, _prev)
  *         if rc < 0:             # <<<<<<<<<<<<<<
@@ -6271,7 +8339,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
  */
   }
 
-  /* "ssh2/knownhost.pyx":419
+  /* "ssh2/knownhost.pyx":420
  *             raise KnownHostGetError(
  *                 "Error retrieving known hosts - error code %s", rc)
  *         return entries             # <<<<<<<<<<<<<<
@@ -6281,7 +8349,7 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
   __pyx_r = __pyx_v_entries;
   goto __pyx_L0;
 
-  /* "ssh2/knownhost.pyx":390
+  /* "ssh2/knownhost.pyx":391
  *                 "Error writing known hosts to file %s", filename)
  * 
  *     def get(self, KnownHostEntry prev=None):             # <<<<<<<<<<<<<<
@@ -6292,10 +8360,9 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_10);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.get", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -6307,17 +8374,45 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_22get(struct __pyx_obj_4ss
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_24__reduce_cython__[] = "KnownHost.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_24__reduce_cython__, "KnownHost.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_25__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_24__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_24__reduce_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self));
 
   /* function exit code */
@@ -6328,33 +8423,28 @@ static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__(PyObje
 static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -6364,55 +8454,133 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_24__reduce_cython__(CYTHON
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_9knownhost_9KnownHost_26__setstate_cython__[] = "KnownHost.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9knownhost_9KnownHost_26__setstate_cython__, "KnownHost.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_9knownhost_9KnownHost_27__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_26__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(1, 4, __pyx_L1_error)
-
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.knownhost.KnownHost.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)__pyx_v_self), __pyx_v___pyx_state);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9knownhost_KnownHost *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
+
+  /* "(tree fragment)":4
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
+ */
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(1, 4, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.knownhost.KnownHost.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -6422,22 +8590,36 @@ static PyObject *__pyx_pf_4ssh2_9knownhost_9KnownHost_26__setstate_cython__(CYTH
 
 static PyObject *__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   return o;
 }
 
 static void __pyx_tp_dealloc_4ssh2_9knownhost_KnownHostEntry(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_9knownhost_KnownHostEntry) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyObject *__pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_magic(PyObject *o, CYTHON_UNUSED void *x) {
@@ -6456,24 +8638,48 @@ static PyObject *__pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_typemask(PyObje
   return __pyx_pw_4ssh2_9knownhost_14KnownHostEntry_8typemask_1__get__(o);
 }
 
+static PyObject *__pyx_specialmethod___pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) {
+  return __pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__(self);
+}
+
 static PyMethodDef __pyx_methods_4ssh2_9knownhost_KnownHostEntry[] = {
-  {"_dealloc__", (PyCFunction)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__, METH_NOARGS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__, METH_O, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__},
+  {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__, METH_NOARGS|METH_COEXIST, 0},
+  {"_dealloc__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_4_dealloc__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_6__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_14KnownHostEntry_8__setstate_cython__},
   {0, 0, 0, 0}
 };
 
 static struct PyGetSetDef __pyx_getsets_4ssh2_9knownhost_KnownHostEntry[] = {
-  {(char *)"magic", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_magic, 0, (char *)"Entry magic number.", 0},
-  {(char *)"name", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_name, 0, (char *)"Name of host.", 0},
-  {(char *)"key", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_key, 0, (char *)"Key byte string.\n\n        Key is stored base64 encoded according to ``libssh2`` documentation\n        and is returned by this property as a base64 decoded byte string.\n\n        Note that in some cases, like keys added by\n        :py:func:`ssh2.knownhost.KnownHost.readline`, the stored key is not\n        base64 encoded, contrary to documentation, and ``KnownHostEntry.key``\n        will need to be re-encoded as base64 to get actual key.", 0},
-  {(char *)"typemask", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_typemask, 0, (char *)"Type mask of host entry.", 0},
+  {(char *)"magic", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_magic, 0, (char *)PyDoc_STR("Entry magic number."), 0},
+  {(char *)"name", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_name, 0, (char *)PyDoc_STR("Name of host."), 0},
+  {(char *)"key", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_key, 0, (char *)PyDoc_STR("Key byte string.\n\n        Key is stored base64 encoded according to ``libssh2`` documentation\n        and is returned by this property as a base64 decoded byte string.\n\n        Note that in some cases, like keys added by\n        :py:func:`ssh2.knownhost.KnownHost.readline`, the stored key is not\n        base64 encoded, contrary to documentation, and ``KnownHostEntry.key``\n        will need to be re-encoded as base64 to get actual key."), 0},
+  {(char *)"typemask", __pyx_getprop_4ssh2_9knownhost_14KnownHostEntry_typemask, 0, (char *)PyDoc_STR("Type mask of host entry."), 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_9knownhost_KnownHostEntry_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_9knownhost_KnownHostEntry},
+  {Py_tp_repr, (void *)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_1__repr__},
+  {Py_tp_str, (void *)__pyx_pw_4ssh2_9knownhost_14KnownHostEntry_3__str__},
+  {Py_tp_doc, (void *)PyDoc_STR("Class representing a single known host entry.")},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_9knownhost_KnownHostEntry},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_9knownhost_KnownHostEntry},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_9knownhost_KnownHostEntry},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_9knownhost_KnownHostEntry_spec = {
+  "ssh2.knownhost.KnownHostEntry",
+  sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_9knownhost_KnownHostEntry_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHostEntry = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.knownhost.KnownHostEntry", /*tp_name*/
+  "ssh2.knownhost.""KnownHostEntry", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_9knownhost_KnownHostEntry, /*tp_dealloc*/
@@ -6502,7 +8708,7 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHostEntry = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  "Class representing a single known host entry.", /*tp_doc*/
+  PyDoc_STR("Class representing a single known host entry."), /*tp_doc*/
   0, /*tp_traverse*/
   0, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -6516,7 +8722,9 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHostEntry = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_9knownhost_KnownHostEntry, /*tp_new*/
@@ -6530,28 +8738,44 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHostEntry = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_9knownhost_KnownHost(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_9knownhost_KnownHost *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_9knownhost_KnownHost *)o);
   p->_session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_9knownhost_9KnownHost_1__cinit__(o, a, k) < 0)) goto bad;
@@ -6564,8 +8788,10 @@ static PyObject *__pyx_tp_new_4ssh2_9knownhost_KnownHost(PyTypeObject *t, PyObje
 static void __pyx_tp_dealloc_4ssh2_9knownhost_KnownHost(PyObject *o) {
   struct __pyx_obj_4ssh2_9knownhost_KnownHost *p = (struct __pyx_obj_4ssh2_9knownhost_KnownHost *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_9knownhost_KnownHost) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -6578,7 +8804,14 @@ static void __pyx_tp_dealloc_4ssh2_9knownhost_KnownHost(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_9knownhost_KnownHost(PyObject *o, visitproc v, void *a) {
@@ -6600,24 +8833,42 @@ static int __pyx_tp_clear_4ssh2_9knownhost_KnownHost(PyObject *o) {
 }
 
 static PyMethodDef __pyx_methods_4ssh2_9knownhost_KnownHost[] = {
-  {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_4add},
-  {"addc", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_6addc},
-  {"check", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_9check, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_8check},
-  {"checkp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_10checkp},
-  {"delete", (PyCFunction)__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete, METH_O, __pyx_doc_4ssh2_9knownhost_9KnownHost_12delete},
-  {"readline", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_14readline},
-  {"readfile", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_16readfile},
-  {"writeline", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_18writeline},
-  {"writefile", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_20writefile},
-  {"get", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_23get, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_22get},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_9knownhost_9KnownHost_24__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__, METH_O, __pyx_doc_4ssh2_9knownhost_9KnownHost_26__setstate_cython__},
+  {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_5add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_4add},
+  {"addc", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_7addc, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_6addc},
+  {"check", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_9check, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_8check},
+  {"checkp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_11checkp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_10checkp},
+  {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_13delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_12delete},
+  {"readline", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_15readline, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_14readline},
+  {"readfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_17readfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_16readfile},
+  {"writeline", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_19writeline, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_18writeline},
+  {"writefile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_21writefile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_20writefile},
+  {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_23get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_22get},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_25__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_24__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9knownhost_9KnownHost_27__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9knownhost_9KnownHost_26__setstate_cython__},
   {0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_9knownhost_KnownHost_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_9knownhost_KnownHost},
+  {Py_tp_doc, (void *)PyDoc_STR("Manage known host entries.")},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_9knownhost_KnownHost},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_9knownhost_KnownHost},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_9knownhost_KnownHost},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_9knownhost_KnownHost},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_9knownhost_KnownHost_spec = {
+  "ssh2.knownhost.KnownHost",
+  sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHost),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_9knownhost_KnownHost_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHost = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.knownhost.KnownHost", /*tp_name*/
+  "ssh2.knownhost.""KnownHost", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHost), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_9knownhost_KnownHost, /*tp_dealloc*/
@@ -6646,7 +8897,7 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHost = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "Manage known host entries.", /*tp_doc*/
+  PyDoc_STR("Manage known host entries."), /*tp_doc*/
   __pyx_tp_traverse_4ssh2_9knownhost_KnownHost, /*tp_traverse*/
   __pyx_tp_clear_4ssh2_9knownhost_KnownHost, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -6660,7 +8911,9 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHost = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_9knownhost_KnownHost, /*tp_new*/
@@ -6674,54 +8927,33 @@ static PyTypeObject __pyx_type_4ssh2_9knownhost_KnownHost = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_knownhost(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_knownhost},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "knownhost",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -6731,152 +8963,351 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_kp_s_Could_not_check_known_host_entry, __pyx_k_Could_not_check_known_host_entry, sizeof(__pyx_k_Could_not_check_known_host_entry), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_adding_known_host_entry_fo, __pyx_k_Error_adding_known_host_entry_fo, sizeof(__pyx_k_Error_adding_known_host_entry_fo), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_deleting_known_host_entry, __pyx_k_Error_deleting_known_host_entry, sizeof(__pyx_k_Error_deleting_known_host_entry), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_deleting_line_from_known_h, __pyx_k_Error_deleting_line_from_known_h, sizeof(__pyx_k_Error_deleting_line_from_known_h), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_reading_known_hosts_file_s, __pyx_k_Error_reading_known_hosts_file_s, sizeof(__pyx_k_Error_reading_known_hosts_file_s), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_retrieving_known_hosts_err, __pyx_k_Error_retrieving_known_hosts_err, sizeof(__pyx_k_Error_retrieving_known_hosts_err), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_writing_known_hosts_to_fil, __pyx_k_Error_writing_known_hosts_to_fil, sizeof(__pyx_k_Error_writing_known_hosts_to_fil), 0, 0, 1, 0},
-  {&__pyx_kp_s_Error_writing_line_for_known_hos, __pyx_k_Error_writing_line_for_known_hos, sizeof(__pyx_k_Error_writing_line_for_known_hos), 0, 0, 1, 0},
-  {&__pyx_kp_s_Host_s_not_found_in_known_hosts, __pyx_k_Host_s_not_found_in_known_hosts, sizeof(__pyx_k_Host_s_not_found_in_known_hosts), 0, 0, 1, 0},
-  {&__pyx_n_s_KnownHost, __pyx_k_KnownHost, sizeof(__pyx_k_KnownHost), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostAddError, __pyx_k_KnownHostAddError, sizeof(__pyx_k_KnownHostAddError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckError, __pyx_k_KnownHostCheckError, sizeof(__pyx_k_KnownHostCheckError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckFailure, __pyx_k_KnownHostCheckFailure, sizeof(__pyx_k_KnownHostCheckFailure), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckMisMatchError, __pyx_k_KnownHostCheckMisMatchError, sizeof(__pyx_k_KnownHostCheckMisMatchError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostCheckNotFoundError, __pyx_k_KnownHostCheckNotFoundError, sizeof(__pyx_k_KnownHostCheckNotFoundError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostDeleteError, __pyx_k_KnownHostDeleteError, sizeof(__pyx_k_KnownHostDeleteError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostEntry, __pyx_k_KnownHostEntry, sizeof(__pyx_k_KnownHostEntry), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostGetError, __pyx_k_KnownHostGetError, sizeof(__pyx_k_KnownHostGetError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostReadFileError, __pyx_k_KnownHostReadFileError, sizeof(__pyx_k_KnownHostReadFileError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostReadLineError, __pyx_k_KnownHostReadLineError, sizeof(__pyx_k_KnownHostReadLineError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostWriteFileError, __pyx_k_KnownHostWriteFileError, sizeof(__pyx_k_KnownHostWriteFileError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostWriteLineError, __pyx_k_KnownHostWriteLineError, sizeof(__pyx_k_KnownHostWriteLineError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Known_host_entry_for_host_s, __pyx_k_Known_host_entry_for_host_s, sizeof(__pyx_k_Known_host_entry_for_host_s), 0, 0, 1, 0},
-  {&__pyx_kp_s_Known_host_key_for_host_s_does_n, __pyx_k_Known_host_key_for_host_s_does_n, sizeof(__pyx_k_Known_host_key_for_host_s_does_n), 0, 0, 1, 0},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_BASE64, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_BASE64), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_MASK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_RAW, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_RAW), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_256), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_384), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_521), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ED25519, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ED25519), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK, __pyx_k_LIBSSH2_KNOWNHOST_KEY_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_MASK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1, __pyx_k_LIBSSH2_KNOWNHOST_KEY_RSA1, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_RSA1), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SHIFT, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SHIFT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHDSS, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHDSS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHRSA, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHRSA), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, __pyx_k_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_UNKNOWN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_CUSTOM), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_MASK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_PLAIN, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_PLAIN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_SHA1, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_SHA1), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Unknown_error_occurred_checking, __pyx_k_Unknown_error_occurred_checking, sizeof(__pyx_k_Unknown_error_occurred_checking), 0, 0, 1, 0},
-  {&__pyx_kp_b__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 0, 0},
-  {&__pyx_n_s_b64decode, __pyx_k_b64decode, sizeof(__pyx_k_b64decode), 0, 0, 1, 1},
-  {&__pyx_n_s_base64, __pyx_k_base64, sizeof(__pyx_k_base64), 0, 0, 1, 1},
-  {&__pyx_n_s_buf_len, __pyx_k_buf_len, sizeof(__pyx_k_buf_len), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_comment, __pyx_k_comment, sizeof(__pyx_k_comment), 0, 0, 1, 1},
-  {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1},
-  {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_f_type, __pyx_k_f_type, sizeof(__pyx_k_f_type), 0, 0, 1, 1},
-  {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_host, __pyx_k_host, sizeof(__pyx_k_host), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1},
-  {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1},
-  {&__pyx_n_s_prev, __pyx_k_prev, sizeof(__pyx_k_prev), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1},
-  {&__pyx_n_s_salt, __pyx_k_salt, sizeof(__pyx_k_salt), 0, 0, 1, 1},
-  {&__pyx_kp_s_self__store_cannot_be_converted, __pyx_k_self__store_cannot_be_converted, sizeof(__pyx_k_self__store_cannot_be_converted), 0, 0, 1, 0},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_typemask, __pyx_k_typemask, sizeof(__pyx_k_typemask), 0, 0, 1, 1},
-  {&__pyx_n_s_writeline, __pyx_k_writeline, sizeof(__pyx_k_writeline), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_u_Could_not_check_known_host_entry, __pyx_k_Could_not_check_known_host_entry, sizeof(__pyx_k_Could_not_check_known_host_entry), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_adding_known_host_entry_fo, __pyx_k_Error_adding_known_host_entry_fo, sizeof(__pyx_k_Error_adding_known_host_entry_fo), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_deleting_known_host_entry, __pyx_k_Error_deleting_known_host_entry, sizeof(__pyx_k_Error_deleting_known_host_entry), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_deleting_line_from_known_h, __pyx_k_Error_deleting_line_from_known_h, sizeof(__pyx_k_Error_deleting_line_from_known_h), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_reading_known_hosts_file_s, __pyx_k_Error_reading_known_hosts_file_s, sizeof(__pyx_k_Error_reading_known_hosts_file_s), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_retrieving_known_hosts_err, __pyx_k_Error_retrieving_known_hosts_err, sizeof(__pyx_k_Error_retrieving_known_hosts_err), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_writing_known_hosts_to_fil, __pyx_k_Error_writing_known_hosts_to_fil, sizeof(__pyx_k_Error_writing_known_hosts_to_fil), 0, 1, 0, 0},
+    {&__pyx_kp_u_Error_writing_line_for_known_hos, __pyx_k_Error_writing_line_for_known_hos, sizeof(__pyx_k_Error_writing_line_for_known_hos), 0, 1, 0, 0},
+    {&__pyx_kp_u_Host_s_not_found_in_known_hosts, __pyx_k_Host_s_not_found_in_known_hosts, sizeof(__pyx_k_Host_s_not_found_in_known_hosts), 0, 1, 0, 0},
+    {&__pyx_n_s_KnownHost, __pyx_k_KnownHost, sizeof(__pyx_k_KnownHost), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostAddError, __pyx_k_KnownHostAddError, sizeof(__pyx_k_KnownHostAddError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckError, __pyx_k_KnownHostCheckError, sizeof(__pyx_k_KnownHostCheckError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckFailure, __pyx_k_KnownHostCheckFailure, sizeof(__pyx_k_KnownHostCheckFailure), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckMisMatchError, __pyx_k_KnownHostCheckMisMatchError, sizeof(__pyx_k_KnownHostCheckMisMatchError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostCheckNotFoundError, __pyx_k_KnownHostCheckNotFoundError, sizeof(__pyx_k_KnownHostCheckNotFoundError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostDeleteError, __pyx_k_KnownHostDeleteError, sizeof(__pyx_k_KnownHostDeleteError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostEntry, __pyx_k_KnownHostEntry, sizeof(__pyx_k_KnownHostEntry), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostEntry___reduce_cython, __pyx_k_KnownHostEntry___reduce_cython, sizeof(__pyx_k_KnownHostEntry___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostEntry___setstate_cython, __pyx_k_KnownHostEntry___setstate_cython, sizeof(__pyx_k_KnownHostEntry___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostEntry__dealloc, __pyx_k_KnownHostEntry__dealloc, sizeof(__pyx_k_KnownHostEntry__dealloc), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostGetError, __pyx_k_KnownHostGetError, sizeof(__pyx_k_KnownHostGetError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostReadFileError, __pyx_k_KnownHostReadFileError, sizeof(__pyx_k_KnownHostReadFileError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostReadLineError, __pyx_k_KnownHostReadLineError, sizeof(__pyx_k_KnownHostReadLineError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostWriteFileError, __pyx_k_KnownHostWriteFileError, sizeof(__pyx_k_KnownHostWriteFileError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostWriteLineError, __pyx_k_KnownHostWriteLineError, sizeof(__pyx_k_KnownHostWriteLineError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost___reduce_cython, __pyx_k_KnownHost___reduce_cython, sizeof(__pyx_k_KnownHost___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost___setstate_cython, __pyx_k_KnownHost___setstate_cython, sizeof(__pyx_k_KnownHost___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_add, __pyx_k_KnownHost_add, sizeof(__pyx_k_KnownHost_add), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_addc, __pyx_k_KnownHost_addc, sizeof(__pyx_k_KnownHost_addc), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_check, __pyx_k_KnownHost_check, sizeof(__pyx_k_KnownHost_check), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_checkp, __pyx_k_KnownHost_checkp, sizeof(__pyx_k_KnownHost_checkp), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_delete, __pyx_k_KnownHost_delete, sizeof(__pyx_k_KnownHost_delete), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_get, __pyx_k_KnownHost_get, sizeof(__pyx_k_KnownHost_get), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_readfile, __pyx_k_KnownHost_readfile, sizeof(__pyx_k_KnownHost_readfile), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_readline, __pyx_k_KnownHost_readline, sizeof(__pyx_k_KnownHost_readline), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_writefile, __pyx_k_KnownHost_writefile, sizeof(__pyx_k_KnownHost_writefile), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHost_writeline, __pyx_k_KnownHost_writeline, sizeof(__pyx_k_KnownHost_writeline), 0, 0, 1, 1},
+    {&__pyx_kp_u_Known_host_entry_for_host_s, __pyx_k_Known_host_entry_for_host_s, sizeof(__pyx_k_Known_host_entry_for_host_s), 0, 1, 0, 0},
+    {&__pyx_kp_u_Known_host_key_for_host_s_does_n, __pyx_k_Known_host_key_for_host_s_does_n, sizeof(__pyx_k_Known_host_key_for_host_s_does_n), 0, 1, 0, 0},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_BASE64, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_BASE64), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_MASK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW, __pyx_k_LIBSSH2_KNOWNHOST_KEYENC_RAW, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEYENC_RAW), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_256), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_384), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ECDSA_521), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519, __pyx_k_LIBSSH2_KNOWNHOST_KEY_ED25519, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_ED25519), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK, __pyx_k_LIBSSH2_KNOWNHOST_KEY_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_MASK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1, __pyx_k_LIBSSH2_KNOWNHOST_KEY_RSA1, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_RSA1), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SHIFT, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SHIFT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHDSS, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHDSS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA, __pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHRSA, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_SSHRSA), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, __pyx_k_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_KEY_UNKNOWN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_CUSTOM), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_MASK, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_MASK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_PLAIN, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_PLAIN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1, __pyx_k_LIBSSH2_KNOWNHOST_TYPE_SHA1, sizeof(__pyx_k_LIBSSH2_KNOWNHOST_TYPE_SHA1), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_kp_u_Unknown_error_occurred_checking, __pyx_k_Unknown_error_occurred_checking, sizeof(__pyx_k_Unknown_error_occurred_checking), 0, 1, 0, 0},
+    {&__pyx_n_s__35, __pyx_k__35, sizeof(__pyx_k__35), 0, 0, 1, 1},
+    {&__pyx_kp_b__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 0, 0},
+    {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0},
+    {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
+    {&__pyx_n_s_addc, __pyx_k_addc, sizeof(__pyx_k_addc), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_b64decode, __pyx_k_b64decode, sizeof(__pyx_k_b64decode), 0, 0, 1, 1},
+    {&__pyx_n_s_b_filename, __pyx_k_b_filename, sizeof(__pyx_k_b_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_base64, __pyx_k_base64, sizeof(__pyx_k_base64), 0, 0, 1, 1},
+    {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_buf_len, __pyx_k_buf_len, sizeof(__pyx_k_buf_len), 0, 0, 1, 1},
+    {&__pyx_n_s_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 0, 1, 1},
+    {&__pyx_n_s_checkp, __pyx_k_checkp, sizeof(__pyx_k_checkp), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_comment, __pyx_k_comment, sizeof(__pyx_k_comment), 0, 0, 1, 1},
+    {&__pyx_n_s_comment_2, __pyx_k_comment_2, sizeof(__pyx_k_comment_2), 0, 0, 1, 1},
+    {&__pyx_n_s_comment_len, __pyx_k_comment_len, sizeof(__pyx_k_comment_len), 0, 0, 1, 1},
+    {&__pyx_n_s_dealloc, __pyx_k_dealloc, sizeof(__pyx_k_dealloc), 0, 0, 1, 1},
+    {&__pyx_n_s_delete, __pyx_k_delete, sizeof(__pyx_k_delete), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_entries, __pyx_k_entries, sizeof(__pyx_k_entries), 0, 0, 1, 1},
+    {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1},
+    {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
+    {&__pyx_n_s_f_type, __pyx_k_f_type, sizeof(__pyx_k_f_type), 0, 0, 1, 1},
+    {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_filename_2, __pyx_k_filename_2, sizeof(__pyx_k_filename_2), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_host, __pyx_k_host, sizeof(__pyx_k_host), 0, 0, 1, 1},
+    {&__pyx_n_s_host_2, __pyx_k_host_2, sizeof(__pyx_k_host_2), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1},
+    {&__pyx_n_s_key_2, __pyx_k_key_2, sizeof(__pyx_k_key_2), 0, 0, 1, 1},
+    {&__pyx_n_s_keylen, __pyx_k_keylen, sizeof(__pyx_k_keylen), 0, 0, 1, 1},
+    {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1},
+    {&__pyx_n_s_line_2, __pyx_k_line_2, sizeof(__pyx_k_line_2), 0, 0, 1, 1},
+    {&__pyx_n_s_line_len, __pyx_k_line_len, sizeof(__pyx_k_line_len), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_outlen, __pyx_k_outlen, sizeof(__pyx_k_outlen), 0, 0, 1, 1},
+    {&__pyx_n_s_output, __pyx_k_output, sizeof(__pyx_k_output), 0, 0, 1, 1},
+    {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1},
+    {&__pyx_n_s_prev, __pyx_k_prev, sizeof(__pyx_k_prev), 0, 0, 1, 1},
+    {&__pyx_n_s_prev_2, __pyx_k_prev_2, sizeof(__pyx_k_prev_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_readfile, __pyx_k_readfile, sizeof(__pyx_k_readfile), 0, 0, 1, 1},
+    {&__pyx_n_s_readline, __pyx_k_readline, sizeof(__pyx_k_readline), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1},
+    {&__pyx_n_s_salt, __pyx_k_salt, sizeof(__pyx_k_salt), 0, 0, 1, 1},
+    {&__pyx_n_s_salt_2, __pyx_k_salt_2, sizeof(__pyx_k_salt_2), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_kp_s_self__store_cannot_be_converted, __pyx_k_self__store_cannot_be_converted, sizeof(__pyx_k_self__store_cannot_be_converted), 0, 0, 1, 0},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_knownhost, __pyx_k_ssh2_knownhost, sizeof(__pyx_k_ssh2_knownhost), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_knownhost_pyx, __pyx_k_ssh2_knownhost_pyx, sizeof(__pyx_k_ssh2_knownhost_pyx), 0, 0, 1, 0},
+    {&__pyx_n_s_store, __pyx_k_store, sizeof(__pyx_k_store), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_typemask, __pyx_k_typemask, sizeof(__pyx_k_typemask), 0, 0, 1, 1},
+    {&__pyx_n_s_writefile, __pyx_k_writefile, sizeof(__pyx_k_writefile), 0, 0, 1, 1},
+    {&__pyx_n_s_writeline, __pyx_k_writeline, sizeof(__pyx_k_writeline), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 75, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 76, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
-  __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 146, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+  /* "ssh2/knownhost.pyx":95
+ *         return self.__repr__()
+ * 
+ *     def _dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._store is not NULL:
+ *             with nogil:
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_self__store_cannot_be_converted); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_dealloc, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 95, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("self._store cannot be converted to a Python object for pickling")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_self__store_cannot_be_converted); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(1, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":2
+  /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(1, 3, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/knownhost.pyx":144
+ *         self._ptr = NULL
+ * 
+ *     def add(self, bytes host, bytes salt, bytes key, int typemask):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use ``self.addc``"""
+ *         raise NotImplementedError
+ */
+  __pyx_tuple__12 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_salt, __pyx_n_s_key, __pyx_n_s_typemask); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_add, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 144, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":148
+ *         raise NotImplementedError
+ * 
+ *     def addc(self, bytes host not None, bytes key not None,             # <<<<<<<<<<<<<<
+ *              int typemask, bytes salt=None, bytes comment=None):
+ *         """Adds a host and its key to known hosts collection.
+ */
+  __pyx_tuple__14 = PyTuple_Pack(14, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_key, __pyx_n_s_typemask, __pyx_n_s_salt, __pyx_n_s_comment, __pyx_n_s_keylen, __pyx_n_s_comment_len, __pyx_n_s_host_2, __pyx_n_s_salt_2, __pyx_n_s_key_2, __pyx_n_s_comment_2, __pyx_n_s_rc, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_addc, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __pyx_tuple__16 = PyTuple_Pack(2, Py_None, Py_None); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+
+  /* "ssh2/knownhost.pyx":204
+ *         return entry
+ * 
+ *     def check(self, bytes host, bytes key, int typemask):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use ``self.checkp``"""
+ *         raise NotImplementedError
+ */
+  __pyx_tuple__17 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_key, __pyx_n_s_typemask); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_check, 204, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 204, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":208
+ *         raise NotImplementedError
+ * 
+ *     def checkp(self, bytes host not None, int port, bytes key not None,             # <<<<<<<<<<<<<<
+ *                int typemask):
+ *         """Check a host and its key against the known hosts collection and
+ */
+  __pyx_tuple__19 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_port, __pyx_n_s_key, __pyx_n_s_typemask, __pyx_n_s_host_2, __pyx_n_s_key_2, __pyx_n_s_keylen, __pyx_n_s_entry, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_checkp, 208, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 208, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":268
+ *         return entry
+ * 
+ *     def delete(self, KnownHostEntry entry not None):             # <<<<<<<<<<<<<<
+ *         """Delete given known host entry from collection of known hosts.
+ * 
+ */
+  __pyx_tuple__21 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_entry, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_delete, 268, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 268, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":283
+ *                 "Error deleting known host entry - error code %s", rc)
+ * 
+ *     def readline(self, bytes line not None,             # <<<<<<<<<<<<<<
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Read line from known hosts file and add to known hosts
+ */
+  __pyx_tuple__23 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_line, __pyx_n_s_f_type, __pyx_n_s_rc, __pyx_n_s_line_2, __pyx_n_s_line_len); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+  __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_readline, 283, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 283, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":307
+ *                 "Error deleting line from known hosts - error code %s", rc)
+ * 
+ *     def readfile(self, filename not None,             # <<<<<<<<<<<<<<
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Read known hosts file and add hosts to known hosts collection.
+ */
+  __pyx_tuple__25 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_f_type, __pyx_n_s_b_filename, __pyx_n_s_filename_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_readfile, 307, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 307, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":333
+ *         return rc
+ * 
+ *     def writeline(self, KnownHostEntry entry,             # <<<<<<<<<<<<<<
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH,
+ *                   size_t buf_len=1024):
+ */
+  __pyx_tuple__27 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_entry, __pyx_n_s_f_type, __pyx_n_s_buf_len, __pyx_n_s_output, __pyx_n_s_outlen, __pyx_n_s_buf, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_writeline, 333, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 333, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":371
+ *         return output
+ * 
+ *     def writefile(self, filename not None,             # <<<<<<<<<<<<<<
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Write all known host entries to file. Only OpenSSH known hosts file
+ */
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_writefile, 371, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 371, __pyx_L1_error)
+
+  /* "ssh2/knownhost.pyx":391
+ *                 "Error writing known hosts to file %s", filename)
+ * 
+ *     def get(self, KnownHostEntry prev=None):             # <<<<<<<<<<<<<<
+ *         """Retrieve all host entries in known hosts collection.
+ * 
+ */
+  __pyx_tuple__30 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_prev, __pyx_n_s_store, __pyx_n_s_prev_2, __pyx_n_s_rc, __pyx_n_s_entries); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 391, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_knownhost_pyx, __pyx_n_s_get, 391, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 391, __pyx_L1_error)
+  __pyx_tuple__32 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 391, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__32);
+  __Pyx_GIVEREF(__pyx_tuple__32);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__9);
-  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(1, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(1, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -6924,26 +9355,52 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_9knownhost_KnownHostEntry.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_9knownhost_KnownHostEntry.tp_dictoffset && __pyx_type_4ssh2_9knownhost_KnownHostEntry.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_9knownhost_KnownHostEntry.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KnownHostEntry, (PyObject *)&__pyx_type_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_9knownhost_KnownHostEntry = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_9knownhost_KnownHostEntry_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_9knownhost_KnownHostEntry)) __PYX_ERR(0, 86, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_9knownhost_KnownHostEntry_spec, __pyx_ptype_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_9knownhost_KnownHostEntry = &__pyx_type_4ssh2_9knownhost_KnownHostEntry;
-  if (PyType_Ready(&__pyx_type_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_9knownhost_KnownHost.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_9knownhost_KnownHost.tp_dictoffset && __pyx_type_4ssh2_9knownhost_KnownHost.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_9knownhost_KnownHost.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_9knownhost_KnownHostEntry->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_9knownhost_KnownHostEntry->tp_dictoffset && __pyx_ptype_4ssh2_9knownhost_KnownHostEntry->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_9knownhost_KnownHostEntry->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KnownHost, (PyObject *)&__pyx_type_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KnownHostEntry, (PyObject *) __pyx_ptype_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_9knownhost_KnownHostEntry) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_9knownhost_KnownHost = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_9knownhost_KnownHost_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_9knownhost_KnownHost)) __PYX_ERR(0, 132, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_9knownhost_KnownHost_spec, __pyx_ptype_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_9knownhost_KnownHost = &__pyx_type_4ssh2_9knownhost_KnownHost;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_9knownhost_KnownHost->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_9knownhost_KnownHost->tp_dictoffset && __pyx_ptype_4ssh2_9knownhost_KnownHost->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_9knownhost_KnownHost->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_KnownHost, (PyObject *) __pyx_ptype_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_9knownhost_KnownHost) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -6961,10 +9418,8 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -6992,7 +9447,7 @@ static int __Pyx_modinit_function_import_code(void) {
   /*--- Function import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -7003,19 +9458,68 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
-#else
-#define __Pyx_PyMODINIT_FUNC void
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_knownhost(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_knownhost},
+  {0, NULL}
+};
 #endif
-#else
+
 #ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
-#else
-#define __Pyx_PyMODINIT_FUNC PyObject *
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "knownhost",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
 #endif
 #endif
 
@@ -7053,12 +9557,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -7068,8 +9581,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -7079,8 +9593,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -7096,8 +9614,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_knownhost(PyObject *__pyx_pyinit_m
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -7111,6 +9634,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_knownhost(PyObject *__pyx_pyinit_m
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("knownhost", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "knownhost" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -7121,7 +9671,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_knownhost(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -7129,48 +9679,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("knownhost", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -7182,7 +9715,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.knownhost")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.knownhost", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.knownhost", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -7193,11 +9726,11 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -7208,381 +9741,617 @@ if (!__Pyx_RefNanny) {
  * 
  * from base64 import b64decode             # <<<<<<<<<<<<<<
  * from libc.stdlib cimport malloc, free
- * from session cimport Session
+ * 
  */
-  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_INCREF(__pyx_n_s_b64decode);
   __Pyx_GIVEREF(__pyx_n_s_b64decode);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_b64decode);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_base64, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_b64decode)) __PYX_ERR(0, 17, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_base64, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_b64decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_b64decode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_b64decode, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_b64decode, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "ssh2/knownhost.pyx":21
- * from session cimport Session
- * from utils cimport to_bytes
+  /* "ssh2/knownhost.pyx":22
+ * from .session cimport Session
+ * from .utils cimport to_bytes
  * from .exceptions import KnownHostAddError, KnownHostCheckMisMatchError, \             # <<<<<<<<<<<<<<
  *     KnownHostCheckFailure, KnownHostCheckNotFoundError, KnownHostError, \
  *     KnownHostDeleteError, KnownHostReadLineError, KnownHostReadFileError, \
  */
-  __pyx_t_2 = PyList_New(12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyList_New(12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_INCREF(__pyx_n_s_KnownHostAddError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostAddError);
-  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_KnownHostAddError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_KnownHostAddError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostCheckMisMatchError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostCheckMisMatchError);
-  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_KnownHostCheckMisMatchError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_KnownHostCheckMisMatchError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostCheckFailure);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostCheckFailure);
-  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_KnownHostCheckFailure);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_KnownHostCheckFailure)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostCheckNotFoundError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostCheckNotFoundError);
-  PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_KnownHostCheckNotFoundError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_n_s_KnownHostCheckNotFoundError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostError);
-  PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_KnownHostError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 4, __pyx_n_s_KnownHostError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostDeleteError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostDeleteError);
-  PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_KnownHostDeleteError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 5, __pyx_n_s_KnownHostDeleteError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostReadLineError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostReadLineError);
-  PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_KnownHostReadLineError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 6, __pyx_n_s_KnownHostReadLineError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostReadFileError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostReadFileError);
-  PyList_SET_ITEM(__pyx_t_2, 7, __pyx_n_s_KnownHostReadFileError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 7, __pyx_n_s_KnownHostReadFileError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostWriteLineError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostWriteLineError);
-  PyList_SET_ITEM(__pyx_t_2, 8, __pyx_n_s_KnownHostWriteLineError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 8, __pyx_n_s_KnownHostWriteLineError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostWriteFileError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostWriteFileError);
-  PyList_SET_ITEM(__pyx_t_2, 9, __pyx_n_s_KnownHostWriteFileError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 9, __pyx_n_s_KnownHostWriteFileError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostGetError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostGetError);
-  PyList_SET_ITEM(__pyx_t_2, 10, __pyx_n_s_KnownHostGetError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 10, __pyx_n_s_KnownHostGetError)) __PYX_ERR(0, 22, __pyx_L1_error);
   __Pyx_INCREF(__pyx_n_s_KnownHostCheckError);
   __Pyx_GIVEREF(__pyx_n_s_KnownHostCheckError);
-  PyList_SET_ITEM(__pyx_t_2, 11, __pyx_n_s_KnownHostCheckError);
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_2, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostAddError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostAddError, __pyx_t_2) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostCheckMisMatchError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_2) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostCheckFailure); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckFailure, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostCheckNotFoundError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostError, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostDeleteError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostDeleteError, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostReadLineError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadLineError, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostReadFileError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadFileError, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostWriteLineError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteLineError, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostWriteFileError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 11, __pyx_n_s_KnownHostCheckError)) __PYX_ERR(0, 22, __pyx_L1_error);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteFileError, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostGetError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostGetError, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckError, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostAddError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostAddError, __pyx_t_3) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostCheckMisMatchError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckMisMatchError, __pyx_t_3) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostCheckFailure); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckFailure, __pyx_t_3) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostCheckNotFoundError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckNotFoundError, __pyx_t_3) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostError, __pyx_t_3) < 0) __PYX_ERR(0, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostDeleteError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostDeleteError, __pyx_t_3) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostReadLineError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadLineError, __pyx_t_3) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostReadFileError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostReadFileError, __pyx_t_3) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostWriteLineError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteLineError, __pyx_t_3) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostWriteFileError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostWriteFileError, __pyx_t_3) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostGetError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostGetError, __pyx_t_3) < 0) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostCheckError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostCheckError, __pyx_t_3) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "ssh2/knownhost.pyx":32
+  /* "ssh2/knownhost.pyx":33
  * 
  * # Host format type masks
  * LIBSSH2_KNOWNHOST_TYPE_MASK = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_MASK             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_TYPE_PLAIN = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_PLAIN
  * LIBSSH2_KNOWNHOST_TYPE_SHA1 = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_SHA1
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_TYPE_MASK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK, __pyx_t_1) < 0) __PYX_ERR(0, 32, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_TYPE_MASK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_MASK, __pyx_t_2) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":33
+  /* "ssh2/knownhost.pyx":34
  * # Host format type masks
  * LIBSSH2_KNOWNHOST_TYPE_MASK = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_MASK
  * LIBSSH2_KNOWNHOST_TYPE_PLAIN = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_PLAIN             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_TYPE_SHA1 = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_SHA1
  * LIBSSH2_KNOWNHOST_TYPE_CUSTOM = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_CUSTOM
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_TYPE_PLAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN, __pyx_t_1) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_TYPE_PLAIN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_PLAIN, __pyx_t_2) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":34
+  /* "ssh2/knownhost.pyx":35
  * LIBSSH2_KNOWNHOST_TYPE_MASK = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_MASK
  * LIBSSH2_KNOWNHOST_TYPE_PLAIN = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_PLAIN
  * LIBSSH2_KNOWNHOST_TYPE_SHA1 = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_SHA1             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_TYPE_CUSTOM = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_CUSTOM
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_TYPE_SHA1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1, __pyx_t_1) < 0) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_TYPE_SHA1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_SHA1, __pyx_t_2) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":35
+  /* "ssh2/knownhost.pyx":36
  * LIBSSH2_KNOWNHOST_TYPE_PLAIN = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_PLAIN
  * LIBSSH2_KNOWNHOST_TYPE_SHA1 = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_SHA1
  * LIBSSH2_KNOWNHOST_TYPE_CUSTOM = c_ssh2.LIBSSH2_KNOWNHOST_TYPE_CUSTOM             # <<<<<<<<<<<<<<
  * 
  * # Key format type masks
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_TYPE_CUSTOM); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, __pyx_t_1) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_TYPE_CUSTOM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_TYPE_CUSTOM, __pyx_t_2) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":38
+  /* "ssh2/knownhost.pyx":39
  * 
  * # Key format type masks
  * LIBSSH2_KNOWNHOST_KEYENC_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_MASK             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEYENC_RAW = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_RAW
  * LIBSSH2_KNOWNHOST_KEYENC_BASE64 = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_BASE64
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEYENC_MASK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEYENC_MASK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_MASK, __pyx_t_2) < 0) __PYX_ERR(0, 39, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":39
+  /* "ssh2/knownhost.pyx":40
  * # Key format type masks
  * LIBSSH2_KNOWNHOST_KEYENC_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_MASK
  * LIBSSH2_KNOWNHOST_KEYENC_RAW = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_RAW             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEYENC_BASE64 = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_BASE64
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEYENC_RAW); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW, __pyx_t_1) < 0) __PYX_ERR(0, 39, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEYENC_RAW); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_RAW, __pyx_t_2) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":40
+  /* "ssh2/knownhost.pyx":41
  * LIBSSH2_KNOWNHOST_KEYENC_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_MASK
  * LIBSSH2_KNOWNHOST_KEYENC_RAW = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_RAW
  * LIBSSH2_KNOWNHOST_KEYENC_BASE64 = c_ssh2.LIBSSH2_KNOWNHOST_KEYENC_BASE64             # <<<<<<<<<<<<<<
  * 
  * # Key type masks
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEYENC_BASE64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64, __pyx_t_1) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEYENC_BASE64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEYENC_BASE64, __pyx_t_2) < 0) __PYX_ERR(0, 41, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":43
+  /* "ssh2/knownhost.pyx":44
  * 
  * # Key type masks
  * LIBSSH2_KNOWNHOST_KEY_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEY_MASK             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_SHIFT = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SHIFT
  * LIBSSH2_KNOWNHOST_KEY_RSA1 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_RSA1
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_MASK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK, __pyx_t_1) < 0) __PYX_ERR(0, 43, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_MASK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_MASK, __pyx_t_2) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":44
+  /* "ssh2/knownhost.pyx":45
  * # Key type masks
  * LIBSSH2_KNOWNHOST_KEY_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEY_MASK
  * LIBSSH2_KNOWNHOST_KEY_SHIFT = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SHIFT             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_RSA1 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_RSA1
  * LIBSSH2_KNOWNHOST_KEY_SSHRSA = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHRSA
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_SHIFT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_SHIFT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SHIFT, __pyx_t_2) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":45
+  /* "ssh2/knownhost.pyx":46
  * LIBSSH2_KNOWNHOST_KEY_MASK = c_ssh2.LIBSSH2_KNOWNHOST_KEY_MASK
  * LIBSSH2_KNOWNHOST_KEY_SHIFT = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SHIFT
  * LIBSSH2_KNOWNHOST_KEY_RSA1 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_RSA1             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_SSHRSA = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHRSA
  * LIBSSH2_KNOWNHOST_KEY_SSHDSS = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHDSS
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_RSA1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1, __pyx_t_1) < 0) __PYX_ERR(0, 45, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_RSA1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_RSA1, __pyx_t_2) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":46
+  /* "ssh2/knownhost.pyx":47
  * LIBSSH2_KNOWNHOST_KEY_SHIFT = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SHIFT
  * LIBSSH2_KNOWNHOST_KEY_RSA1 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_RSA1
  * LIBSSH2_KNOWNHOST_KEY_SSHRSA = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHRSA             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_SSHDSS = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHDSS
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_256 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_256
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_SSHRSA); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_SSHRSA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHRSA, __pyx_t_2) < 0) __PYX_ERR(0, 47, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":47
+  /* "ssh2/knownhost.pyx":48
  * LIBSSH2_KNOWNHOST_KEY_RSA1 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_RSA1
  * LIBSSH2_KNOWNHOST_KEY_SSHRSA = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHRSA
  * LIBSSH2_KNOWNHOST_KEY_SSHDSS = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHDSS             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_256 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_256
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_384 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_384
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_SSHDSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS, __pyx_t_1) < 0) __PYX_ERR(0, 47, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_SSHDSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_SSHDSS, __pyx_t_2) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":48
+  /* "ssh2/knownhost.pyx":49
  * LIBSSH2_KNOWNHOST_KEY_SSHRSA = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHRSA
  * LIBSSH2_KNOWNHOST_KEY_SSHDSS = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHDSS
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_256 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_256             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_384 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_384
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_521 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_521
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_ECDSA_256); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, __pyx_t_1) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_ECDSA_256); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_256, __pyx_t_2) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":49
+  /* "ssh2/knownhost.pyx":50
  * LIBSSH2_KNOWNHOST_KEY_SSHDSS = c_ssh2.LIBSSH2_KNOWNHOST_KEY_SSHDSS
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_256 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_256
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_384 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_384             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_521 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_521
  * LIBSSH2_KNOWNHOST_KEY_ED25519 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ED25519
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_ECDSA_384); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, __pyx_t_1) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_ECDSA_384); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_384, __pyx_t_2) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":50
+  /* "ssh2/knownhost.pyx":51
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_256 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_256
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_384 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_384
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_521 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_521             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_ED25519 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ED25519
  * LIBSSH2_KNOWNHOST_KEY_UNKNOWN = c_ssh2.LIBSSH2_KNOWNHOST_KEY_UNKNOWN
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_ECDSA_521); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, __pyx_t_1) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_ECDSA_521); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ECDSA_521, __pyx_t_2) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":51
+  /* "ssh2/knownhost.pyx":52
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_384 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_384
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_521 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_521
  * LIBSSH2_KNOWNHOST_KEY_ED25519 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ED25519             # <<<<<<<<<<<<<<
  * LIBSSH2_KNOWNHOST_KEY_UNKNOWN = c_ssh2.LIBSSH2_KNOWNHOST_KEY_UNKNOWN
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_ED25519); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519, __pyx_t_1) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_ED25519); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_ED25519, __pyx_t_2) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":52
+  /* "ssh2/knownhost.pyx":53
  * LIBSSH2_KNOWNHOST_KEY_ECDSA_521 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ECDSA_521
  * LIBSSH2_KNOWNHOST_KEY_ED25519 = c_ssh2.LIBSSH2_KNOWNHOST_KEY_ED25519
  * LIBSSH2_KNOWNHOST_KEY_UNKNOWN = c_ssh2.LIBSSH2_KNOWNHOST_KEY_UNKNOWN             # <<<<<<<<<<<<<<
  * 
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_KNOWNHOST_KEY_UNKNOWN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_KEY_UNKNOWN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_KNOWNHOST_KEY_UNKNOWN, __pyx_t_2) < 0) __PYX_ERR(0, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":283
+  /* "ssh2/knownhost.pyx":95
+ *         return self.__repr__()
  * 
- *     def readline(self, bytes line not None,
- *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
- *         """Read line from known hosts file and add to known hosts
- *         collection. Only OpenSSH known hosts file format is currently supported.
+ *     def _dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self._store is not NULL:
+ *             with nogil:
  */
-  __pyx_k__3 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_5_dealloc__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHostEntry__dealloc, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHostEntry, __pyx_n_s_dealloc, __pyx_t_2) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHostEntry);
 
-  /* "ssh2/knownhost.pyx":307
- * 
- *     def readfile(self, filename not None,
- *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
- *         """Read known hosts file and add hosts to known hosts collection.
- *         Only OpenSSH known hosts file format is currently supported.
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
  */
-  __pyx_k__4 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHostEntry___reduce_cython, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":333
- * 
- *     def writeline(self, KnownHostEntry entry,
- *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH,             # <<<<<<<<<<<<<<
- *                   size_t buf_len=1024):
- *         """Convert a single known host entry to a single line of output
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._store cannot be converted to a Python object for pickling"
  */
-  __pyx_k__5 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_14KnownHostEntry_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHostEntry___setstate_cython, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/knownhost.pyx":371
+  /* "ssh2/knownhost.pyx":144
+ *         self._ptr = NULL
  * 
- *     def writefile(self, filename not None,
- *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
- *         """Write all known host entries to file. Only OpenSSH known hosts file
- *         format is currently supported.
+ *     def add(self, bytes host, bytes salt, bytes key, int typemask):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use ``self.addc``"""
+ *         raise NotImplementedError
  */
-  __pyx_k__7 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_5add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_add, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_add, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":148
+ *         raise NotImplementedError
+ * 
+ *     def addc(self, bytes host not None, bytes key not None,             # <<<<<<<<<<<<<<
+ *              int typemask, bytes salt=None, bytes comment=None):
+ *         """Adds a host and its key to known hosts collection.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_7addc, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_addc, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__16);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_addc, __pyx_t_2) < 0) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":204
+ *         return entry
+ * 
+ *     def check(self, bytes host, bytes key, int typemask):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use ``self.checkp``"""
+ *         raise NotImplementedError
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_9check, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_check, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_check, __pyx_t_2) < 0) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":208
+ *         raise NotImplementedError
+ * 
+ *     def checkp(self, bytes host not None, int port, bytes key not None,             # <<<<<<<<<<<<<<
+ *                int typemask):
+ *         """Check a host and its key against the known hosts collection and
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_11checkp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_checkp, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_checkp, __pyx_t_2) < 0) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":268
+ *         return entry
+ * 
+ *     def delete(self, KnownHostEntry entry not None):             # <<<<<<<<<<<<<<
+ *         """Delete given known host entry from collection of known hosts.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_13delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_delete, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_delete, __pyx_t_2) < 0) __PYX_ERR(0, 268, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":284
+ * 
+ *     def readline(self, bytes line not None,
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
+ *         """Read line from known hosts file and add to known hosts
+ *         collection. Only OpenSSH known hosts file format is currently supported.
+ */
+  __pyx_k_ = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+
+  /* "ssh2/knownhost.pyx":283
+ *                 "Error deleting known host entry - error code %s", rc)
+ * 
+ *     def readline(self, bytes line not None,             # <<<<<<<<<<<<<<
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Read line from known hosts file and add to known hosts
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_FILE_OPENSSH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_15readline, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_readline, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_readline, __pyx_t_2) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":308
+ * 
+ *     def readfile(self, filename not None,
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
+ *         """Read known hosts file and add hosts to known hosts collection.
+ *         Only OpenSSH known hosts file format is currently supported.
+ */
+  __pyx_k__2 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+
+  /* "ssh2/knownhost.pyx":307
+ *                 "Error deleting line from known hosts - error code %s", rc)
+ * 
+ *     def readfile(self, filename not None,             # <<<<<<<<<<<<<<
+ *                  int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Read known hosts file and add hosts to known hosts collection.
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_FILE_OPENSSH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 308, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 307, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_17readfile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_readfile, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_readfile, __pyx_t_2) < 0) __PYX_ERR(0, 307, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":334
+ * 
+ *     def writeline(self, KnownHostEntry entry,
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH,             # <<<<<<<<<<<<<<
+ *                   size_t buf_len=1024):
+ *         """Convert a single known host entry to a single line of output
+ */
+  __pyx_k__3 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+
+  /* "ssh2/knownhost.pyx":333
+ *         return rc
+ * 
+ *     def writeline(self, KnownHostEntry entry,             # <<<<<<<<<<<<<<
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH,
+ *                   size_t buf_len=1024):
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_FILE_OPENSSH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_1024);
+  __Pyx_GIVEREF(__pyx_int_1024);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_1024)) __PYX_ERR(0, 333, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_19writeline, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_writeline, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_writeline, __pyx_t_2) < 0) __PYX_ERR(0, 333, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":372
+ * 
+ *     def writefile(self, filename not None,
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):             # <<<<<<<<<<<<<<
+ *         """Write all known host entries to file. Only OpenSSH known hosts file
+ *         format is currently supported.
+ */
+  __pyx_k__5 = LIBSSH2_KNOWNHOST_FILE_OPENSSH;
+
+  /* "ssh2/knownhost.pyx":371
+ *         return output
+ * 
+ *     def writefile(self, filename not None,             # <<<<<<<<<<<<<<
+ *                   int f_type=c_ssh2.LIBSSH2_KNOWNHOST_FILE_OPENSSH):
+ *         """Write all known host entries to file. Only OpenSSH known hosts file
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_KNOWNHOST_FILE_OPENSSH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 371, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_21writefile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_writefile, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_writefile, __pyx_t_2) < 0) __PYX_ERR(0, 371, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "ssh2/knownhost.pyx":391
+ *                 "Error writing known hosts to file %s", filename)
+ * 
+ *     def get(self, KnownHostEntry prev=None):             # <<<<<<<<<<<<<<
+ *         """Retrieve all host entries in known hosts collection.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_23get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost_get, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__32);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9knownhost_KnownHost, __pyx_n_s_get, __pyx_t_2) < 0) __PYX_ERR(0, 391, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9knownhost_KnownHost);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_25__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost___reduce_cython, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9knownhost_9KnownHost_27__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_KnownHost___setstate_cython, NULL, __pyx_n_s_ssh2_knownhost, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/knownhost.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.knownhost", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.knownhost");
   }
@@ -7596,6 +10365,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -7615,6 +10400,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
 /* PyObjectGetAttrStr */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
@@ -7629,10 +10516,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -7643,13 +10559,238 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
-/* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
-static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
-                                               PyObject *globals) {
-    PyFrameObject *f;
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject **fastlocals;
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
     Py_ssize_t i;
     PyObject *result;
     assert(globals != NULL);
@@ -7673,7 +10814,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -7689,9 +10829,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -7760,7 +10906,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
-#endif
 
 /* PyObjectCall */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -7769,8 +10914,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
     ternaryfunc call = Py_TYPE(func)->tp_call;
     if (unlikely(!call))
         return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = (*call)(func, arg, kw);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -7787,10 +10937,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -7802,90 +10957,183 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallNoArg */
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
 #if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
     }
 #endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
         }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
     }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
-#endif
 
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
     } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+        num_expected = num_max;
+        more_or_less = "at most";
     }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
 }
-#endif
 
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
-    }
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
 #endif
+            goto invalid_keyword;
         }
-    }
-    return __Pyx__PyObject_CallOneArg(func, arg);
-}
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
 #else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
 #endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
 
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -7922,7 +11170,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 {
     PyObject *result;
 #if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
     result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
@@ -7930,6 +11178,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     } else if (unlikely(PyErr_Occurred())) {
         return NULL;
     }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
 #else
     result = PyDict_GetItem(__pyx_d, name);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
@@ -7948,64 +11204,11 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     return __Pyx_GetBuiltinName(name);
 }
 
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
-    }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
-    }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
-}
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -8138,13 +11341,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -8152,10 +11351,16 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
-#endif
-    }
-bad:
-    Py_XDECREF(owned_instance);
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
     return;
 }
 #endif
@@ -8177,6 +11382,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -8187,13 +11393,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
         name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -8201,6 +11448,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -8221,14 +11471,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -8255,6 +11509,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -8264,47 +11520,26 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
-{
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
-    }
-    if (exact) {
-        more_or_less = "exactly";
-    }
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                 func_name, more_or_less, num_expected,
-                 (num_expected == 1) ? "" : "s", num_found);
-}
-
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -8317,9 +11552,13 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
@@ -8330,20 +11569,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject
 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #endif
 {
-    PyObject *local_type, *local_value, *local_tb;
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
 #if CYTHON_FAST_THREAD_STATE
     PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
     local_type = tstate->curexc_type;
     local_value = tstate->curexc_value;
     local_tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
+  #endif
 #else
     PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
     if (unlikely(tstate->curexc_type))
 #else
     if (unlikely(PyErr_Occurred()))
@@ -8365,12 +11616,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
     #if CYTHON_USE_EXC_INFO_STACK
     {
         _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
         tmp_type = exc_info->exc_type;
         tmp_value = exc_info->exc_value;
         tmp_tb = exc_info->exc_traceback;
         exc_info->exc_type = local_type;
         exc_info->exc_value = local_value;
         exc_info->exc_traceback = local_tb;
+      #endif
     }
     #else
     tmp_type = tstate->exc_type;
@@ -8401,7 +11661,26 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
     tmp_type = exc_info->exc_type;
     tmp_value = exc_info->exc_value;
@@ -8409,14 +11688,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
     exc_info->exc_type = *type;
     exc_info->exc_value = *value;
     exc_info->exc_traceback = *tb;
-    #else
+  #else
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
-    #endif
+  #endif
     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
@@ -8433,12 +11712,12 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem *
 __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 {
     _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
            exc_info->previous_item != NULL)
     {
         exc_info = exc_info->previous_item;
@@ -8450,21 +11729,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 /* SaveResetException */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
     *type = exc_info->exc_type;
     *value = exc_info->exc_value;
     *tb = exc_info->exc_traceback;
-    #else
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
-    #endif
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
+  #endif
 }
 static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     #if CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -8485,20 +11789,392 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+  #endif
+}
+#endif
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
 }
 #endif
 
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
 /* PyObject_GenericGetAttrNoDict */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
     PyErr_Format(PyExc_AttributeError,
 #if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
 #endif
+    __Pyx_DECREF_TypeName(type_name);
     return NULL;
 }
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
@@ -8538,58 +12214,12 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 }
 #endif
 
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
-#endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
-    }
-#endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
-    }
-    return result;
-}
-
 /* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
   int ret;
   PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2);
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2);
   if (likely(name_attr)) {
       ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
   } else {
@@ -8655,7 +12285,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             } else if (reduce == object_reduce || PyErr_Occurred()) {
                 goto __PYX_BAD;
             }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
                 setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
@@ -8669,174 +12299,1402 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             PyType_Modified((PyTypeObject*)type_obj);
         }
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
+{
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* Import */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *module = 0;
+    PyObject *empty_dict = 0;
+    PyObject *empty_list = 0;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (unlikely(!py_import))
+        goto bad;
+    if (!from_list) {
+        empty_list = PyList_New(0);
+        if (unlikely(!empty_list))
+            goto bad;
+        from_list = empty_list;
+    }
+    #endif
+    empty_dict = PyDict_New();
+    if (unlikely(!empty_dict))
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
+                module = PyImport_ImportModuleLevelObject(
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_MAJOR_VERSION < 3
+            PyObject *py_level = PyInt_FromLong(level);
+            if (unlikely(!py_level))
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, __pyx_d, empty_dict, from_list, level);
+            #endif
+        }
+    }
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    return module;
+}
+
+/* ImportFrom */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__6);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
 #endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
     return ret;
 }
-
-/* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
 {
-    PyObject *result = 0;
-    char warning[200];
-    Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
-    PyObject *py_basicsize;
-#endif
-    result = PyObject_GetAttrString(module, class_name);
-    if (!result)
-        goto bad;
-    if (!PyType_Check(result)) {
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
         PyErr_Format(PyExc_TypeError,
-            "%.200s.%.200s is not a type object",
-            module_name, class_name);
-        goto bad;
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-#ifndef Py_LIMITED_API
-    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
-#endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
 }
-#endif
-
-/* Import */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
-    PyObject *module = 0;
-    PyObject *global_dict = 0;
-    PyObject *empty_dict = 0;
-    PyObject *list;
-    #if PY_MAJOR_VERSION < 3
-    PyObject *py_import;
-    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
-        goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
-        empty_list = PyList_New(0);
-        if (!empty_list)
-            goto bad;
-        list = empty_list;
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
-    empty_dict = PyDict_New();
-    if (!empty_dict)
-        goto bad;
-    {
-        #if PY_MAJOR_VERSION >= 3
-        if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
-                module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
-                        goto bad;
-                    PyErr_Clear();
-                }
-            }
-            level = 0;
-        }
-        #endif
-        if (!module) {
-            #if PY_MAJOR_VERSION < 3
-            PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
-                goto bad;
-            module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
-            Py_DECREF(py_level);
-            #else
-            module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
-            #endif
-        }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
+    return 0;
 }
-
-/* ImportFrom */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
-    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
-    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
-        #else
-            "cannot import name %S", name);
-        #endif
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return value;
+    return op;
 }
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -8850,7 +13708,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -8872,6 +13730,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -8950,17 +13809,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -8995,6 +13938,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -9010,7 +13954,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -9057,6 +14001,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -9081,7 +14026,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     }
 
 /* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
@@ -9111,10 +14056,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -9131,7 +14109,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -9140,168 +14118,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -9327,7 +14376,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -9336,168 +14385,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -9541,12 +14661,132 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value)
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name_2);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__35);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -9579,10 +14819,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -9599,7 +14872,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -9608,168 +14881,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -9786,7 +15130,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -9807,6 +15151,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -9831,11 +15191,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -9883,41 +15243,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -9939,11 +15308,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -9958,9 +15323,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -9977,7 +15342,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -9985,21 +15349,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -10012,9 +15361,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -10022,30 +15393,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -10100,7 +15475,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -10129,22 +15504,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -10210,13 +15589,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -10284,4 +15661,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/knownhost.pxd b/ssh2/knownhost.pxd
index 4e36e452..458b8218 100644
--- a/ssh2/knownhost.pxd
+++ b/ssh2/knownhost.pxd
@@ -14,8 +14,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
-cimport c_ssh2
+from .session cimport Session
+from . cimport c_ssh2
 
 
 cdef KnownHost PyKnownHost(Session session, c_ssh2.LIBSSH2_KNOWNHOSTS *_ptr)
diff --git a/ssh2/knownhost.pyx b/ssh2/knownhost.pyx
index 9ec0dad9..776783fb 100644
--- a/ssh2/knownhost.pyx
+++ b/ssh2/knownhost.pyx
@@ -16,16 +16,17 @@
 
 from base64 import b64decode
 from libc.stdlib cimport malloc, free
-from session cimport Session
-from utils cimport to_bytes
+
+from .session cimport Session
+from .utils cimport to_bytes
 from .exceptions import KnownHostAddError, KnownHostCheckMisMatchError, \
     KnownHostCheckFailure, KnownHostCheckNotFoundError, KnownHostError, \
     KnownHostDeleteError, KnownHostReadLineError, KnownHostReadFileError, \
     KnownHostWriteLineError, KnownHostWriteFileError, KnownHostGetError, \
     KnownHostCheckError
-from error_codes cimport _LIBSSH2_ERROR_BUFFER_TOO_SMALL
+from .error_codes cimport _LIBSSH2_ERROR_BUFFER_TOO_SMALL
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 # Host format type masks
diff --git a/ssh2/listener.c b/ssh2/listener.c
index f7b3b8fc..b66d6331 100644
--- a/ssh2/listener.c
+++ b/ssh2/listener.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.listener",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/listener.pyx"
+        ]
+    },
+    "module_name": "ssh2.listener"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
+#else
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
+#else
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -794,9 +1303,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -814,9 +1324,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -824,13 +1334,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -854,14 +1358,60 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
-    PyObject* ascii_chars_u = NULL;
-    PyObject* ascii_chars_b = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
     sys = PyImport_ImportModule("sys");
     if (!sys) goto bad;
@@ -876,7 +1426,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -906,6 +1456,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -941,25 +1492,28 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "stringsource",
+  "<stringsource>",
   "ssh2/listener.pyx",
   "ssh2/session.pxd",
   "ssh2/channel.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -967,11 +1521,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -980,7 +1532,7 @@ struct __pyx_obj_4ssh2_7channel_Channel;
 struct __pyx_obj_4ssh2_8listener_Listener;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1034,6 +1586,7 @@ struct __pyx_obj_4ssh2_8listener_Listener {
   struct __pyx_obj_4ssh2_7session_Session *_session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1042,11 +1595,11 @@ struct __pyx_obj_4ssh2_8listener_Listener {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1056,28 +1609,40 @@ struct __pyx_obj_4ssh2_8listener_Listener {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1088,6 +1653,10 @@ struct __pyx_obj_4ssh2_8listener_Listener {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1099,47 +1668,30 @@ struct __pyx_obj_4ssh2_8listener_Listener {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* ExtTypeTest.proto */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1151,7 +1703,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1167,9 +1719,187 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1184,31 +1914,170 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
 #endif
 
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1243,6 +2112,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1256,19 +2126,33 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1281,93 +2165,447 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.channel' */
-static PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel = 0;
+/* Module declarations from "ssh2.session" */
+
+/* Module declarations from "ssh2.channel" */
 static PyObject *(*__pyx_f_4ssh2_7channel_PyChannel)(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.listener' */
-static PyTypeObject *__pyx_ptype_4ssh2_8listener_Listener = 0;
+/* Module declarations from "ssh2.listener" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.listener"
 extern int __pyx_module_is_main_ssh2__listener;
 int __pyx_module_is_main_ssh2__listener = 0;
 
-/* Implementation of 'ssh2.listener' */
+/* Implementation of "ssh2.listener" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k__9[] = "?";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_channel[] = "channel";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_session[] = "session";
 static const char __pyx_k_Listener[] = "Listener";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_ssh2_listener[] = "ssh2.listener";
+static const char __pyx_k_forward_accept[] = "forward_accept";
+static const char __pyx_k_forward_cancel[] = "forward_cancel";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_ssh2_listener_pyx[] = "ssh2/listener.pyx";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_Listener_forward_accept[] = "Listener.forward_accept";
+static const char __pyx_k_Listener_forward_cancel[] = "Listener.forward_cancel";
+static const char __pyx_k_Listener___reduce_cython[] = "Listener.__reduce_cython__";
+static const char __pyx_k_Listener___setstate_cython[] = "Listener.__setstate_cython__";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_Listener;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
-static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, PyObject *__pyx_v_session); /* proto */
+/* #### Code section: decls ### */
+static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session); /* proto */
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_2forward_accept(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_4forward_cancel(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_8listener_Listener(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_8listener_Listener;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8listener_Listener;
+  PyObject *__pyx_n_s_Listener;
+  PyObject *__pyx_n_s_Listener___reduce_cython;
+  PyObject *__pyx_n_s_Listener___setstate_cython;
+  PyObject *__pyx_n_s_Listener_forward_accept;
+  PyObject *__pyx_n_s_Listener_forward_cancel;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s__9;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_channel;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_forward_accept;
+  PyObject *__pyx_n_s_forward_cancel;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_listener;
+  PyObject *__pyx_kp_s_ssh2_listener_pyx;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_codeobj__2;
+  PyObject *__pyx_codeobj__4;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__8;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8listener_Listener);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_8listener_Listener);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Listener);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Listener___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Listener___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Listener_forward_accept);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Listener_forward_cancel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__9);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_forward_accept);
+  Py_CLEAR(clear_module_state->__pyx_n_s_forward_cancel);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_listener);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_listener_pyx);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__2);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8listener_Listener);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_8listener_Listener);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Listener);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Listener___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Listener___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Listener_forward_accept);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Listener_forward_cancel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__9);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_forward_accept);
+  Py_VISIT(traverse_module_state->__pyx_n_s_forward_cancel);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_listener);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_listener_pyx);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__2);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7channel_Channel __pyx_mstate_global->__pyx_ptype_4ssh2_7channel_Channel
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_8listener_Listener __pyx_mstate_global->__pyx_type_4ssh2_8listener_Listener
+#endif
+#define __pyx_ptype_4ssh2_8listener_Listener __pyx_mstate_global->__pyx_ptype_4ssh2_8listener_Listener
+#define __pyx_n_s_Listener __pyx_mstate_global->__pyx_n_s_Listener
+#define __pyx_n_s_Listener___reduce_cython __pyx_mstate_global->__pyx_n_s_Listener___reduce_cython
+#define __pyx_n_s_Listener___setstate_cython __pyx_mstate_global->__pyx_n_s_Listener___setstate_cython
+#define __pyx_n_s_Listener_forward_accept __pyx_mstate_global->__pyx_n_s_Listener_forward_accept
+#define __pyx_n_s_Listener_forward_cancel __pyx_mstate_global->__pyx_n_s_Listener_forward_cancel
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s__9 __pyx_mstate_global->__pyx_n_s__9
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_channel __pyx_mstate_global->__pyx_n_s_channel
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_forward_accept __pyx_mstate_global->__pyx_n_s_forward_accept
+#define __pyx_n_s_forward_cancel __pyx_mstate_global->__pyx_n_s_forward_cancel
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_listener __pyx_mstate_global->__pyx_n_s_ssh2_listener
+#define __pyx_kp_s_ssh2_listener_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_listener_pyx
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+/* #### Code section: module_code ### */
 
 /* "ssh2/listener.pyx":24
  * 
@@ -1386,7 +2624,7 @@ static PyObject *__pyx_f_4ssh2_8listener_PyListener(LIBSSH2_LISTENER *__pyx_v_li
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyListener", 0);
+  __Pyx_RefNannySetupContext("PyListener", 1);
 
   /* "ssh2/listener.pyx":25
  * 
@@ -1397,11 +2635,11 @@ static PyObject *__pyx_f_4ssh2_8listener_PyListener(LIBSSH2_LISTENER *__pyx_v_li
  */
   __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 25, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(1, 25, __pyx_L1_error);
   __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_8listener_Listener(((PyTypeObject *)__pyx_ptype_4ssh2_8listener_Listener), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 25, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__listener = ((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_t_2);
   __pyx_t_2 = 0;
@@ -1423,7 +2661,7 @@ static PyObject *__pyx_f_4ssh2_8listener_PyListener(LIBSSH2_LISTENER *__pyx_v_li
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__listener));
+  __Pyx_INCREF((PyObject *)__pyx_v__listener);
   __pyx_r = ((PyObject *)__pyx_v__listener);
   goto __pyx_L0;
 
@@ -1451,7 +2689,7 @@ static PyObject *__pyx_f_4ssh2_8listener_PyListener(LIBSSH2_LISTENER *__pyx_v_li
 /* "ssh2/listener.pyx":32
  * cdef class Listener:
  * 
- *     def __cinit__(self, session):             # <<<<<<<<<<<<<<
+ *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
  *         self._listener = NULL
  *         self._session = session
  */
@@ -1459,68 +2697,95 @@ static PyObject *__pyx_f_4ssh2_8listener_PyListener(LIBSSH2_LISTENER *__pyx_v_li
 /* Python wrapper */
 static int __pyx_pw_4ssh2_8listener_8Listener_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_8listener_8Listener_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_session = 0;
+  struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 32, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 32, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 32, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
-    __pyx_v_session = values[0];
+    __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 32, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 32, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.listener.Listener.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
   __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(1, 32, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_8listener_8Listener___cinit__(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self), __pyx_v_session);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, PyObject *__pyx_v_session) {
+static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
   int __pyx_r;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/listener.pyx":33
  * 
- *     def __cinit__(self, session):
+ *     def __cinit__(self, Session session):
  *         self._listener = NULL             # <<<<<<<<<<<<<<
  *         self._session = session
  * 
@@ -1528,37 +2793,28 @@ static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8
   __pyx_v_self->_listener = NULL;
 
   /* "ssh2/listener.pyx":34
- *     def __cinit__(self, session):
+ *     def __cinit__(self, Session session):
  *         self._listener = NULL
  *         self._session = session             # <<<<<<<<<<<<<<
  * 
  *     def forward_accept(self):
  */
-  if (!(likely(((__pyx_v_session) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_session, __pyx_ptype_4ssh2_7session_Session))))) __PYX_ERR(1, 34, __pyx_L1_error)
-  __pyx_t_1 = __pyx_v_session;
-  __Pyx_INCREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_1);
-  __Pyx_GOTREF(__pyx_v_self->_session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_session));
-  __pyx_v_self->_session = ((struct __pyx_obj_4ssh2_7session_Session *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_session);
+  __pyx_v_self->_session = __pyx_v_session;
 
   /* "ssh2/listener.pyx":32
  * cdef class Listener:
  * 
- *     def __cinit__(self, session):             # <<<<<<<<<<<<<<
+ *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
  *         self._listener = NULL
  *         self._session = session
  */
 
   /* function exit code */
   __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.listener.Listener.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1572,14 +2828,42 @@ static int __pyx_pf_4ssh2_8listener_8Listener___cinit__(struct __pyx_obj_4ssh2_8
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_3forward_accept(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_8listener_8Listener_2forward_accept[] = "Listener.forward_accept(self)";
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_3forward_accept(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_3forward_accept(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8listener_8Listener_2forward_accept, "Listener.forward_accept(self)");
+static PyMethodDef __pyx_mdef_4ssh2_8listener_8Listener_3forward_accept = {"forward_accept", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_3forward_accept, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_2forward_accept};
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_3forward_accept(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("forward_accept (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_2forward_accept(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self));
-
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("forward_accept", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "forward_accept", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_2forward_accept(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self));
+
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -1596,7 +2880,7 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_2forward_accept(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("forward_accept", 0);
+  __Pyx_RefNannySetupContext("forward_accept", 1);
 
   /* "ssh2/listener.pyx":38
  *     def forward_accept(self):
@@ -1608,6 +2892,7 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_2forward_accept(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -1649,7 +2934,7 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_2forward_accept(struct __pyx
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session._session))
  */
-  __pyx_t_1 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_channel == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/listener.pyx":42
@@ -1738,12 +3023,40 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_2forward_accept(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_8listener_8Listener_4forward_cancel[] = "Listener.forward_cancel(self)";
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8listener_8Listener_4forward_cancel, "Listener.forward_cancel(self)");
+static PyMethodDef __pyx_mdef_4ssh2_8listener_8Listener_5forward_cancel = {"forward_cancel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_4forward_cancel};
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("forward_cancel (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("forward_cancel", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "forward_cancel", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_4forward_cancel(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self));
 
   /* function exit code */
@@ -1760,7 +3073,7 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_4forward_cancel(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("forward_cancel", 0);
+  __Pyx_RefNannySetupContext("forward_cancel", 1);
 
   /* "ssh2/listener.pyx":48
  *     def forward_cancel(self):
@@ -1772,6 +3085,7 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_4forward_cancel(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -1840,17 +3154,45 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_4forward_cancel(struct __pyx
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_8listener_8Listener_6__reduce_cython__[] = "Listener.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8listener_8Listener_6__reduce_cython__, "Listener.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_8listener_8Listener_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_6__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_6__reduce_cython__(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self));
 
   /* function exit code */
@@ -1861,33 +3203,28 @@ static PyObject *__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__(PyObject
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.listener.Listener.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1897,21 +3234,104 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_6__reduce_cython__(CYTHON_UN
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_8listener_8Listener_8__setstate_cython__[] = "Listener.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8listener_8Listener_8__setstate_cython__, "Listener.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_8listener_8Listener_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_8__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_8__setstate_cython__(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.listener.Listener.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_8listener_8Listener_8__setstate_cython__(((struct __pyx_obj_4ssh2_8listener_Listener *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1919,33 +3339,28 @@ static PyObject *__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__(PyObjec
 static PyObject *__pyx_pf_4ssh2_8listener_8Listener_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8listener_Listener *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.listener.Listener.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1956,12 +3371,17 @@ static PyObject *__pyx_pf_4ssh2_8listener_8Listener_8__setstate_cython__(CYTHON_
 static PyObject *__pyx_tp_new_4ssh2_8listener_Listener(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_8listener_Listener *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_8listener_Listener *)o);
   p->_session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_8listener_8Listener_1__cinit__(o, a, k) < 0)) goto bad;
@@ -1974,13 +3394,22 @@ static PyObject *__pyx_tp_new_4ssh2_8listener_Listener(PyTypeObject *t, PyObject
 static void __pyx_tp_dealloc_4ssh2_8listener_Listener(PyObject *o) {
   struct __pyx_obj_4ssh2_8listener_Listener *p = (struct __pyx_obj_4ssh2_8listener_Listener *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_8listener_Listener) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
   Py_CLEAR(p->_session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_8listener_Listener(PyObject *o, visitproc v, void *a) {
@@ -2002,16 +3431,33 @@ static int __pyx_tp_clear_4ssh2_8listener_Listener(PyObject *o) {
 }
 
 static PyMethodDef __pyx_methods_4ssh2_8listener_Listener[] = {
-  {"forward_accept", (PyCFunction)__pyx_pw_4ssh2_8listener_8Listener_3forward_accept, METH_NOARGS, __pyx_doc_4ssh2_8listener_8Listener_2forward_accept},
-  {"forward_cancel", (PyCFunction)__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel, METH_NOARGS, __pyx_doc_4ssh2_8listener_8Listener_4forward_cancel},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_8listener_8Listener_6__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__, METH_O, __pyx_doc_4ssh2_8listener_8Listener_8__setstate_cython__},
+  {"forward_accept", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_3forward_accept, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_2forward_accept},
+  {"forward_cancel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_5forward_cancel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_4forward_cancel},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_6__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8listener_8Listener_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8listener_8Listener_8__setstate_cython__},
   {0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_8listener_Listener_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_8listener_Listener},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_8listener_Listener},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_8listener_Listener},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_8listener_Listener},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_8listener_Listener},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_8listener_Listener_spec = {
+  "ssh2.listener.Listener",
+  sizeof(struct __pyx_obj_4ssh2_8listener_Listener),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_8listener_Listener_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_8listener_Listener = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.listener.Listener", /*tp_name*/
+  "ssh2.listener.""Listener", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_8listener_Listener), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_8listener_Listener, /*tp_dealloc*/
@@ -2054,7 +3500,9 @@ static PyTypeObject __pyx_type_4ssh2_8listener_Listener = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_8listener_Listener, /*tp_new*/
@@ -2068,54 +3516,33 @@ static PyTypeObject __pyx_type_4ssh2_8listener_Listener = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_listener(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_listener},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "listener",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -2125,66 +3552,125 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_Listener, __pyx_k_Listener, sizeof(__pyx_k_Listener), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_Listener, __pyx_k_Listener, sizeof(__pyx_k_Listener), 0, 0, 1, 1},
+    {&__pyx_n_s_Listener___reduce_cython, __pyx_k_Listener___reduce_cython, sizeof(__pyx_k_Listener___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Listener___setstate_cython, __pyx_k_Listener___setstate_cython, sizeof(__pyx_k_Listener___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Listener_forward_accept, __pyx_k_Listener_forward_accept, sizeof(__pyx_k_Listener_forward_accept), 0, 0, 1, 1},
+    {&__pyx_n_s_Listener_forward_cancel, __pyx_k_Listener_forward_cancel, sizeof(__pyx_k_Listener_forward_cancel), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_forward_accept, __pyx_k_forward_accept, sizeof(__pyx_k_forward_accept), 0, 0, 1, 1},
+    {&__pyx_n_s_forward_cancel, __pyx_k_forward_cancel, sizeof(__pyx_k_forward_cancel), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_listener, __pyx_k_ssh2_listener, sizeof(__pyx_k_ssh2_listener), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_listener_pyx, __pyx_k_ssh2_listener_pyx, sizeof(__pyx_k_ssh2_listener_pyx), 0, 0, 1, 0},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/listener.pyx":36
+ *         self._session = session
+ * 
+ *     def forward_accept(self):             # <<<<<<<<<<<<<<
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
+ *         with nogil:
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_channel); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 36, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_listener_pyx, __pyx_n_s_forward_accept, 36, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(1, 36, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/listener.pyx":46
+ *         return PyChannel(channel, self._session)
+ * 
+ *     def forward_cancel(self):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_listener_pyx, __pyx_n_s_forward_cancel, 46, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(1, 46, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -2232,16 +3718,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_8listener_Listener.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_8listener_Listener = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_8listener_Listener_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_8listener_Listener)) __PYX_ERR(1, 30, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_8listener_Listener_spec, __pyx_ptype_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_8listener_Listener = &__pyx_type_4ssh2_8listener_Listener;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_8listener_Listener.tp_dictoffset && __pyx_type_4ssh2_8listener_Listener.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_8listener_Listener.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_8listener_Listener->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_8listener_Listener->tp_dictoffset && __pyx_ptype_4ssh2_8listener_Listener->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_8listener_Listener->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Listener, (PyObject *)&__pyx_type_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  __pyx_ptype_4ssh2_8listener_Listener = &__pyx_type_4ssh2_8listener_Listener;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Listener, (PyObject *) __pyx_ptype_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_8listener_Listener) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -2259,15 +3758,12 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 24, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(3, 24, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7channel_Channel),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(3, 24, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -2295,11 +3791,11 @@ static int __Pyx_modinit_function_import_code(void) {
   /*--- Function import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -2310,6 +3806,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_listener(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_listener},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "listener",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -2360,12 +3905,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -2375,8 +3929,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -2386,8 +3941,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -2403,7 +3962,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_listener(PyObject *__pyx_pyinit_mo
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2417,6 +3981,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_listener(PyObject *__pyx_pyinit_mo
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("listener", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "listener" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -2427,7 +4018,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_listener(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -2435,48 +4026,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("listener", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
@@ -2488,7 +4062,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.listener")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.listener", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.listener", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -2499,36 +4073,93 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
 
+  /* "ssh2/listener.pyx":36
+ *         self._session = session
+ * 
+ *     def forward_accept(self):             # <<<<<<<<<<<<<<
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
+ *         with nogil:
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8listener_8Listener_3forward_accept, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Listener_forward_accept, NULL, __pyx_n_s_ssh2_listener, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_8listener_Listener, __pyx_n_s_forward_accept, __pyx_t_2) < 0) __PYX_ERR(1, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_8listener_Listener);
+
+  /* "ssh2/listener.pyx":46
+ *         return PyChannel(channel, self._session)
+ * 
+ *     def forward_cancel(self):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8listener_8Listener_5forward_cancel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Listener_forward_cancel, NULL, __pyx_n_s_ssh2_listener, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_8listener_Listener, __pyx_n_s_forward_cancel, __pyx_t_2) < 0) __PYX_ERR(1, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_8listener_Listener);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8listener_8Listener_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Listener___reduce_cython, NULL, __pyx_n_s_ssh2_listener, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8listener_8Listener_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Listener___setstate_cython, NULL, __pyx_n_s_ssh2_listener, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
   /* "ssh2/listener.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.listener", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.listener");
   }
@@ -2542,6 +4173,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -2561,8 +4208,110 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
     PyTypeObject* tp = Py_TYPE(obj);
     if (likely(tp->tp_getattro))
@@ -2575,10 +4324,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -2589,6 +4367,231 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
 /* RaiseDoubleKeywords */
 static void __Pyx_RaiseDoubleKeywordsError(
     const char* func_name,
@@ -2606,6 +4609,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -2616,13 +4620,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
         name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -2630,6 +4675,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -2650,14 +4698,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -2684,6 +4736,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -2693,15 +4747,18 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
@@ -2731,68 +4788,112 @@ static void __Pyx_RaiseArgtupleInvalid(
                  (num_expected == 1) ? "" : "s", num_found);
 }
 
-/* ExtTypeTest */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+/* ArgTypeTest */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
     }
-    if (likely(__Pyx_TypeCheck(obj, type)))
-        return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
+        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
     }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
 #endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
 
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -2925,13 +5026,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -2939,6 +5036,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -2947,156 +5050,732 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
 #endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
         }
+        if (changed)
+            PyType_Modified(type);
     }
-    return descr;
+#endif
+    return 0;
 }
 #endif
 
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
 }
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
 #endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
 #if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
     }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
     }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
 }
 #endif
 
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
     PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
     }
+    return result;
+}
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
     }
     return result;
 }
+#endif
 
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
-#else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
     }
 #endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
-#else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
         }
-#endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
         }
+        #endif
     }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
+#endif
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
 #endif
     reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
     if (reduce_ex == object_reduce_ex) {
@@ -3114,7 +5793,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             } else if (reduce == object_reduce || PyErr_Occurred()) {
                 goto __PYX_BAD;
             }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
                 setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
@@ -3130,8 +5809,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     }
     goto __PYX_GOOD;
 __PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
     ret = -1;
 __PYX_GOOD:
 #if !CYTHON_USE_PYTYPE_LOOKUP
@@ -3147,18 +5831,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     Py_XDECREF(setstate_cython);
     return ret;
 }
+#endif
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
     PyObject *result = 0;
     char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
@@ -3169,45 +5856,1242 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
             module_name, class_name);
         goto bad;
     }
-#ifndef Py_LIMITED_API
+#if !CYTHON_COMPILING_IN_LIMITED_API
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
 #endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
-    }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return op;
 }
-#endif
 
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -3237,12 +7121,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -3256,7 +7141,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -3278,6 +7163,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -3356,17 +7242,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -3401,6 +7371,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -3416,7 +7387,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -3463,6 +7434,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
@@ -3495,12 +7467,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__9);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -3533,10 +7554,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3575,7 +7629,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3584,168 +7638,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -3771,7 +7896,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3780,168 +7905,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -3958,7 +8154,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -3979,6 +8175,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -4003,11 +8215,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -4055,41 +8267,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -4111,11 +8332,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -4130,9 +8347,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -4149,7 +8366,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -4157,21 +8373,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -4184,9 +8385,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -4194,30 +8417,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -4272,7 +8499,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -4301,22 +8528,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -4382,13 +8613,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -4456,4 +8685,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/listener.pxd b/ssh2/listener.pxd
index bb91776f..4831a978 100644
--- a/ssh2/listener.pxd
+++ b/ssh2/listener.pxd
@@ -14,9 +14,9 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
+from .session cimport Session
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 cdef object PyListener(c_ssh2.LIBSSH2_LISTENER *listener, Session session)
 
diff --git a/ssh2/listener.pyx b/ssh2/listener.pyx
index 22201bf0..b74ed27f 100644
--- a/ssh2/listener.pyx
+++ b/ssh2/listener.pyx
@@ -14,11 +14,11 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
-from channel cimport PyChannel
-from utils cimport handle_error_codes
+from .session cimport Session
+from .channel cimport PyChannel
+from .utils cimport handle_error_codes
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 cdef object PyListener(c_ssh2.LIBSSH2_LISTENER *listener, Session session):
@@ -29,7 +29,7 @@ cdef object PyListener(c_ssh2.LIBSSH2_LISTENER *listener, Session session):
 
 cdef class Listener:
 
-    def __cinit__(self, session):
+    def __cinit__(self, Session session):
         self._listener = NULL
         self._session = session
 
diff --git a/ssh2/pkey.c b/ssh2/pkey.c
index 8bd3b4e7..085c5a9f 100644
--- a/ssh2/pkey.c
+++ b/ssh2/pkey.c
@@ -1,22 +1,66 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.pkey",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/pkey.pyx"
+        ]
+    },
+    "module_name": "ssh2.pkey"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
+#else
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +79,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +87,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +124,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +144,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +272,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +301,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +312,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +335,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +362,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +386,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +470,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +494,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +511,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +573,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +608,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +760,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +777,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +867,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +913,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +947,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1041,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1056,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1098,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1115,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1162,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1182,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1222,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -793,9 +1298,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -813,9 +1319,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -823,13 +1329,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -853,8 +1353,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -875,7 +1421,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -905,6 +1451,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -940,23 +1487,29 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "stringsource",
+  "<stringsource>",
   "ssh2/pkey.pyx",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_4pkey_PublicKey;
@@ -972,6 +1525,7 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey {
   struct libssh2_agent_publickey *_pkey;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -980,11 +1534,11 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -994,28 +1548,40 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1026,6 +1592,10 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1037,39 +1607,30 @@ struct __pyx_obj_4ssh2_4pkey_PublicKey {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1081,7 +1642,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1097,9 +1658,181 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1114,19 +1847,150 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+/* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
 #else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
 #endif
 
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
 
-/* SetupReduce.proto */
-static int __Pyx_setup_reduce(PyObject* type_obj);
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1162,6 +2026,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1175,19 +2040,33 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1200,18 +2079,23 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
@@ -1219,49 +2103,56 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.pkey' */
-static PyTypeObject *__pyx_ptype_4ssh2_4pkey_PublicKey = 0;
+/* Module declarations from "ssh2.c_ssh2" */
+
+/* Module declarations from "ssh2.pkey" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.pkey"
 extern int __pyx_module_is_main_ssh2__pkey;
 int __pyx_module_is_main_ssh2__pkey = 0;
 
-/* Implementation of 'ssh2.pkey' */
+/* Implementation of "ssh2.pkey" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k__5[] = "?";
+static const char __pyx_k_gc[] = "gc";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_PublicKey[] = "PublicKey";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_ssh2_pkey[] = "ssh2.pkey";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_PublicKey___reduce_cython[] = "PublicKey.__reduce_cython__";
+static const char __pyx_k_PublicKey___setstate_cython[] = "PublicKey.__setstate_cython__";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_PublicKey;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_4pkey_9PublicKey___cinit__(struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self); /* proto */
@@ -1270,9 +2161,276 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(struct __pyx_o
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_4pkey_PublicKey(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_4pkey_PublicKey;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4pkey_PublicKey;
+  PyObject *__pyx_n_s_PublicKey;
+  PyObject *__pyx_n_s_PublicKey___reduce_cython;
+  PyObject *__pyx_n_s_PublicKey___setstate_cython;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s__5;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_pkey;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_codeobj__2;
+  PyObject *__pyx_codeobj__4;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4pkey_PublicKey);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_4pkey_PublicKey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKey___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKey___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__5);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_pkey);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__2);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4pkey_PublicKey);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_4pkey_PublicKey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKey___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKey___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__5);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_pkey);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__2);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_4pkey_PublicKey __pyx_mstate_global->__pyx_type_4ssh2_4pkey_PublicKey
+#endif
+#define __pyx_ptype_4ssh2_4pkey_PublicKey __pyx_mstate_global->__pyx_ptype_4ssh2_4pkey_PublicKey
+#define __pyx_n_s_PublicKey __pyx_mstate_global->__pyx_n_s_PublicKey
+#define __pyx_n_s_PublicKey___reduce_cython __pyx_mstate_global->__pyx_n_s_PublicKey___reduce_cython
+#define __pyx_n_s_PublicKey___setstate_cython __pyx_mstate_global->__pyx_n_s_PublicKey___setstate_cython
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s__5 __pyx_mstate_global->__pyx_n_s__5
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_pkey __pyx_mstate_global->__pyx_n_s_ssh2_pkey
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+/* #### Code section: module_code ### */
 
 /* "ssh2/pkey.pyx":20
  * 
@@ -1290,7 +2448,7 @@ static PyObject *__pyx_f_4ssh2_4pkey_PyPublicKey(struct libssh2_agent_publickey
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyPublicKey", 0);
+  __Pyx_RefNannySetupContext("PyPublicKey", 1);
 
   /* "ssh2/pkey.pyx":21
  * 
@@ -1300,7 +2458,7 @@ static PyObject *__pyx_f_4ssh2_4pkey_PyPublicKey(struct libssh2_agent_publickey
  *     return _pkey
  */
   __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_4pkey_PublicKey(((PyTypeObject *)__pyx_ptype_4ssh2_4pkey_PublicKey), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 21, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
+  __Pyx_GOTREF((PyObject *)__pyx_t_1);
   __pyx_v__pkey = ((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_t_1);
   __pyx_t_1 = 0;
 
@@ -1321,7 +2479,7 @@ static PyObject *__pyx_f_4ssh2_4pkey_PyPublicKey(struct libssh2_agent_publickey
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__pkey));
+  __Pyx_INCREF((PyObject *)__pyx_v__pkey);
   __pyx_r = ((PyObject *)__pyx_v__pkey);
   goto __pyx_L0;
 
@@ -1356,12 +2514,20 @@ static PyObject *__pyx_f_4ssh2_4pkey_PyPublicKey(struct libssh2_agent_publickey
 /* Python wrapper */
 static int __pyx_pw_4ssh2_4pkey_9PublicKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_4pkey_9PublicKey_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
-    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey___cinit__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1371,8 +2537,6 @@ static int __pyx_pw_4ssh2_4pkey_9PublicKey_1__cinit__(PyObject *__pyx_v_self, Py
 
 static int __pyx_pf_4ssh2_4pkey_9PublicKey___cinit__(struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__", 0);
 
   /* "ssh2/pkey.pyx":32
  * 
@@ -1393,24 +2557,25 @@ static int __pyx_pf_4ssh2_4pkey_9PublicKey___cinit__(struct __pyx_obj_4ssh2_4pke
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/pkey.pyx":35
+/* "ssh2/pkey.pyx":34
+ *         self._pkey = NULL
  * 
- *     @property
- *     def blob(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob(self):
  *         """Blob of public key data.
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_4blob_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_4blob_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1426,7 +2591,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/pkey.pyx":40
  *         :rtype: bytes
@@ -1435,7 +2600,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(struct __pyx_obj_
  *             return
  *         return self._pkey.blob[:self._pkey.blob_len]
  */
-  __pyx_t_1 = ((__pyx_v_self->_pkey == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_pkey == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/pkey.pyx":41
@@ -1472,12 +2637,12 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(struct __pyx_obj_
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/pkey.pyx":35
+  /* "ssh2/pkey.pyx":34
+ *         self._pkey = NULL
  * 
- *     @property
- *     def blob(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob(self):
  *         """Blob of public key data.
- * 
  */
 
   /* function exit code */
@@ -1491,20 +2656,22 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4blob___get__(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/pkey.pyx":45
+/* "ssh2/pkey.pyx":44
+ *         return self._pkey.blob[:self._pkey.blob_len]
  * 
- *     @property
- *     def magic(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def magic(self):
  *         """Magic number of public key.
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5magic_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5magic_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1520,7 +2687,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/pkey.pyx":50
  *         :rtype: int
@@ -1529,7 +2696,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(struct __pyx_obj
  *             return
  *         return self._pkey.magic
  */
-  __pyx_t_1 = ((__pyx_v_self->_pkey == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_pkey == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/pkey.pyx":51
@@ -1566,12 +2733,12 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(struct __pyx_obj
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/pkey.pyx":45
+  /* "ssh2/pkey.pyx":44
+ *         return self._pkey.blob[:self._pkey.blob_len]
  * 
- *     @property
- *     def magic(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def magic(self):
  *         """Magic number of public key.
- * 
  */
 
   /* function exit code */
@@ -1585,20 +2752,22 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_5magic___get__(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/pkey.pyx":55
+/* "ssh2/pkey.pyx":54
+ *         return self._pkey.magic
  * 
- *     @property
- *     def blob_len(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob_len(self):
  *         """Blob length of public key.
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_8blob_len_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_8blob_len_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_8blob_len___get__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1614,7 +2783,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_8blob_len___get__(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/pkey.pyx":60
  *         :rtype: int
@@ -1623,7 +2792,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_8blob_len___get__(struct __pyx_
  *             return
  *         return self._pkey.blob_len
  */
-  __pyx_t_1 = ((__pyx_v_self->_pkey == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_pkey == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/pkey.pyx":61
@@ -1660,12 +2829,12 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_8blob_len___get__(struct __pyx_
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/pkey.pyx":55
+  /* "ssh2/pkey.pyx":54
+ *         return self._pkey.magic
  * 
- *     @property
- *     def blob_len(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob_len(self):
  *         """Blob length of public key.
- * 
  */
 
   /* function exit code */
@@ -1679,20 +2848,22 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_8blob_len___get__(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/pkey.pyx":65
+/* "ssh2/pkey.pyx":64
+ *         return self._pkey.blob_len
  * 
- *     @property
- *     def comment(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def comment(self):
  *         """Public key comment
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_7comment_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_7comment_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1708,7 +2879,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/pkey.pyx":70
  *         :rtype: bytes
@@ -1717,7 +2888,7 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(struct __pyx_o
  *             return
  *         return self._pkey.comment
  */
-  __pyx_t_1 = ((__pyx_v_self->_pkey == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_pkey == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/pkey.pyx":71
@@ -1751,12 +2922,12 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(struct __pyx_o
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/pkey.pyx":65
+  /* "ssh2/pkey.pyx":64
+ *         return self._pkey.blob_len
  * 
- *     @property
- *     def comment(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def comment(self):
  *         """Public key comment
- * 
  */
 
   /* function exit code */
@@ -1772,17 +2943,45 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_7comment___get__(struct __pyx_o
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_4pkey_9PublicKey_2__reduce_cython__[] = "PublicKey.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4pkey_9PublicKey_2__reduce_cython__, "PublicKey.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_4pkey_9PublicKey_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4pkey_9PublicKey_2__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_2__reduce_cython__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self));
 
   /* function exit code */
@@ -1793,33 +2992,28 @@ static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__(PyObject *__
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.pkey.PublicKey.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1829,21 +3023,104 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_2__reduce_cython__(CYTHON_UNUSE
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_4pkey_9PublicKey_4__setstate_cython__[] = "PublicKey.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4pkey_9PublicKey_4__setstate_cython__, "PublicKey.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_4pkey_9PublicKey_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4pkey_9PublicKey_4__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_4__setstate_cython__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.pkey.PublicKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_4pkey_9PublicKey_4__setstate_cython__(((struct __pyx_obj_4ssh2_4pkey_PublicKey *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1851,33 +3128,28 @@ static PyObject *__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__(PyObject *
 static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4pkey_PublicKey *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.pkey.PublicKey.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1887,12 +3159,17 @@ static PyObject *__pyx_pf_4ssh2_4pkey_9PublicKey_4__setstate_cython__(CYTHON_UNU
 
 static PyObject *__pyx_tp_new_4ssh2_4pkey_PublicKey(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   if (unlikely(__pyx_pw_4ssh2_4pkey_9PublicKey_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
   return o;
   bad:
@@ -1902,11 +3179,20 @@ static PyObject *__pyx_tp_new_4ssh2_4pkey_PublicKey(PyTypeObject *t, CYTHON_UNUS
 
 static void __pyx_tp_dealloc_4ssh2_4pkey_PublicKey(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_4pkey_PublicKey) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyObject *__pyx_getprop_4ssh2_4pkey_9PublicKey_blob(PyObject *o, CYTHON_UNUSED void *x) {
@@ -1926,22 +3212,39 @@ static PyObject *__pyx_getprop_4ssh2_4pkey_9PublicKey_comment(PyObject *o, CYTHO
 }
 
 static PyMethodDef __pyx_methods_4ssh2_4pkey_PublicKey[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_4pkey_9PublicKey_2__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__, METH_O, __pyx_doc_4ssh2_4pkey_9PublicKey_4__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4pkey_9PublicKey_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4pkey_9PublicKey_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4pkey_9PublicKey_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4pkey_9PublicKey_4__setstate_cython__},
   {0, 0, 0, 0}
 };
 
 static struct PyGetSetDef __pyx_getsets_4ssh2_4pkey_PublicKey[] = {
-  {(char *)"blob", __pyx_getprop_4ssh2_4pkey_9PublicKey_blob, 0, (char *)"Blob of public key data.\n\n        :rtype: bytes\n        ", 0},
-  {(char *)"magic", __pyx_getprop_4ssh2_4pkey_9PublicKey_magic, 0, (char *)"Magic number of public key.\n\n        :rtype: int\n        ", 0},
-  {(char *)"blob_len", __pyx_getprop_4ssh2_4pkey_9PublicKey_blob_len, 0, (char *)"Blob length of public key.\n\n        :rtype: int\n        ", 0},
-  {(char *)"comment", __pyx_getprop_4ssh2_4pkey_9PublicKey_comment, 0, (char *)"Public key comment\n\n        :rtype: bytes\n        ", 0},
+  {(char *)"blob", __pyx_getprop_4ssh2_4pkey_9PublicKey_blob, 0, (char *)PyDoc_STR("Blob of public key data.\n\n        :rtype: bytes\n        "), 0},
+  {(char *)"magic", __pyx_getprop_4ssh2_4pkey_9PublicKey_magic, 0, (char *)PyDoc_STR("Magic number of public key.\n\n        :rtype: int\n        "), 0},
+  {(char *)"blob_len", __pyx_getprop_4ssh2_4pkey_9PublicKey_blob_len, 0, (char *)PyDoc_STR("Blob length of public key.\n\n        :rtype: int\n        "), 0},
+  {(char *)"comment", __pyx_getprop_4ssh2_4pkey_9PublicKey_comment, 0, (char *)PyDoc_STR("Public key comment\n\n        :rtype: bytes\n        "), 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_4pkey_PublicKey_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_4pkey_PublicKey},
+  {Py_tp_doc, (void *)PyDoc_STR("Extension class for representing public key data from libssh2.\n\n    Can be used for authentication via :py:func:`ssh2.agent.Agent.userauth`")},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_4pkey_PublicKey},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_4pkey_PublicKey},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_4pkey_PublicKey},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_4pkey_PublicKey_spec = {
+  "ssh2.pkey.PublicKey",
+  sizeof(struct __pyx_obj_4ssh2_4pkey_PublicKey),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_4pkey_PublicKey_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_4pkey_PublicKey = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.pkey.PublicKey", /*tp_name*/
+  "ssh2.pkey.""PublicKey", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_4pkey_PublicKey), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_4pkey_PublicKey, /*tp_dealloc*/
@@ -1970,7 +3273,7 @@ static PyTypeObject __pyx_type_4ssh2_4pkey_PublicKey = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  "Extension class for representing public key data from libssh2.\n\n    Can be used for authentication via :py:func:`ssh2.agent.Agent.userauth`", /*tp_doc*/
+  PyDoc_STR("Extension class for representing public key data from libssh2.\n\n    Can be used for authentication via :py:func:`ssh2.agent.Agent.userauth`"), /*tp_doc*/
   0, /*tp_traverse*/
   0, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -1984,7 +3287,9 @@ static PyTypeObject __pyx_type_4ssh2_4pkey_PublicKey = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_4pkey_PublicKey, /*tp_new*/
@@ -1998,54 +3303,33 @@ static PyTypeObject __pyx_type_4ssh2_4pkey_PublicKey = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_pkey(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_pkey},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "pkey",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -2055,65 +3339,93 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_PublicKey, __pyx_k_PublicKey, sizeof(__pyx_k_PublicKey), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_PublicKey, __pyx_k_PublicKey, sizeof(__pyx_k_PublicKey), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKey___reduce_cython, __pyx_k_PublicKey___reduce_cython, sizeof(__pyx_k_PublicKey___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKey___setstate_cython, __pyx_k_PublicKey___setstate_cython, sizeof(__pyx_k_PublicKey___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_pkey, __pyx_k_ssh2_pkey, sizeof(__pyx_k_ssh2_pkey), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -2161,16 +3473,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_4pkey_PublicKey.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_4pkey_PublicKey = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_4pkey_PublicKey_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_4pkey_PublicKey)) __PYX_ERR(1, 26, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_4pkey_PublicKey_spec, __pyx_ptype_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_4pkey_PublicKey = &__pyx_type_4ssh2_4pkey_PublicKey;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_4pkey_PublicKey->tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_4pkey_PublicKey.tp_dictoffset && __pyx_type_4ssh2_4pkey_PublicKey.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_4pkey_PublicKey.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_4pkey_PublicKey->tp_dictoffset && __pyx_ptype_4ssh2_4pkey_PublicKey->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_4pkey_PublicKey->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKey, (PyObject *)&__pyx_type_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  __pyx_ptype_4ssh2_4pkey_PublicKey = &__pyx_type_4ssh2_4pkey_PublicKey;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKey, (PyObject *) __pyx_ptype_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_4pkey_PublicKey) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -2203,6 +3528,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_pkey(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_pkey},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "pkey",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -2253,12 +3627,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -2268,8 +3651,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -2279,8 +3663,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -2296,7 +3684,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_pkey(PyObject *__pyx_pyinit_module
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2310,6 +3703,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_pkey(PyObject *__pyx_pyinit_module
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("pkey", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "pkey" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -2320,7 +3740,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_pkey(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -2328,48 +3748,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("pkey", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
@@ -2381,7 +3784,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.pkey")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.pkey", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.pkey", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -2392,8 +3795,8 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   (void)__Pyx_modinit_type_import_code();
   (void)__Pyx_modinit_variable_import_code();
   (void)__Pyx_modinit_function_import_code();
@@ -2402,26 +3805,57 @@ if (!__Pyx_RefNanny) {
   if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
 
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4pkey_9PublicKey_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKey___reduce_cython, NULL, __pyx_n_s_ssh2_pkey, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4pkey_9PublicKey_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKey___setstate_cython, NULL, __pyx_n_s_ssh2_pkey, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
   /* "ssh2/pkey.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.pkey", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.pkey");
   }
@@ -2435,6 +3869,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -2454,6 +3904,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
 /* PyObjectGetAttrStr */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
@@ -2468,10 +4020,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -2482,27 +4063,252 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
 {
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
     }
-    if (exact) {
-        more_or_less = "exactly";
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
     }
-    PyErr_Format(PyExc_TypeError,
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
                  "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                  func_name, more_or_less, num_expected,
                  (num_expected == 1) ? "" : "s", num_found);
@@ -2510,25 +4316,58 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 /* KeywordStringCheck */
 static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict,
+    PyObject *kw,
     const char* function_name,
     int kw_allowed)
 {
     PyObject* key = 0;
     Py_ssize_t pos = 0;
 #if CYTHON_COMPILING_IN_PYPY
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
         goto invalid_keyword;
     return 1;
 #else
-    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
         #if PY_MAJOR_VERSION < 3
         if (unlikely(!PyString_Check(key)))
         #endif
             if (unlikely(!PyUnicode_Check(key)))
                 goto invalid_keyword_type;
     }
-    if ((!kw_allowed) && unlikely(key))
+    if (!kw_allowed && unlikely(key))
         goto invalid_keyword;
     return 1;
 invalid_keyword_type:
@@ -2537,66 +4376,23 @@ static int __Pyx_CheckKeywordStrings(
     return 0;
 #endif
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
     return 0;
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -2729,13 +4525,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -2743,6 +4535,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -2751,205 +4549,2137 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
 #endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
+            value = kwvalues[pos];
+            pos++;
         }
-    }
-    return descr;
-}
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
 #endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
-}
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
 #endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
 }
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
-#endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
     PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
     }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
     }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
     return result;
 }
+#endif
 
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
 #else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
     }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
 #endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
-    }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
+#endif
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
-        }
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
-#endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
-    return ret;
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
 }
 
 /* PyDictVersioning */
@@ -2980,12 +6710,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -2999,7 +6730,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -3021,6 +6752,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -3099,17 +6831,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -3144,6 +6960,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -3159,7 +6976,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -3206,6 +7023,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) {
@@ -3238,12 +7056,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value)
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__5);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -3276,10 +7143,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3318,7 +7218,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3327,168 +7227,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -3514,7 +7485,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3523,168 +7494,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -3701,7 +7743,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -3722,6 +7764,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -3746,11 +7804,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -3798,41 +7856,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -3854,11 +7921,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -3873,9 +7936,31 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -3883,30 +7968,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -3961,7 +8050,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -3990,22 +8079,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -4071,13 +8164,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -4145,4 +8236,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/pkey.pxd b/ssh2/pkey.pxd
index 61341d1c..f99c96ee 100644
--- a/ssh2/pkey.pxd
+++ b/ssh2/pkey.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 cdef object PyPublicKey(c_ssh2.libssh2_agent_publickey *pkey)
diff --git a/ssh2/pkey.pyx b/ssh2/pkey.pyx
index afceb0a6..2004115b 100644
--- a/ssh2/pkey.pyx
+++ b/ssh2/pkey.pyx
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 
 cdef object PyPublicKey(c_ssh2.libssh2_agent_publickey *pkey):
diff --git a/ssh2/publickey.c b/ssh2/publickey.c
index 166c2446..6b0e7d50 100644
--- a/ssh2/publickey.c
+++ b/ssh2/publickey.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.publickey",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/publickey.pyx"
+        ]
+    },
+    "module_name": "ssh2.publickey"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -797,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -817,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -827,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -857,12 +1361,58 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
     PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
@@ -879,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -909,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -944,24 +1495,27 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "stringsource",
+  "<stringsource>",
   "ssh2/publickey.pyx",
   "ssh2/session.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -969,11 +1523,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -983,7 +1535,7 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute;
 struct __pyx_obj_4ssh2_9publickey_PublicKeySystem;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1050,6 +1602,7 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeySystem {
   struct __pyx_obj_4ssh2_7session_Session *session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1058,11 +1611,11 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeySystem {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1072,28 +1625,40 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeySystem {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1104,6 +1669,10 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeySystem {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1115,50 +1684,30 @@ struct __pyx_obj_4ssh2_9publickey_PublicKeySystem {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* ArgTypeTest.proto */
-#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
-        __Pyx__ArgTypeTest(obj, type, name, exact))
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1170,7 +1719,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1186,31 +1735,19 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
-/* WriteUnraisableException.proto */
-static void __Pyx_WriteUnraisable(const char *name, int clineno,
-                                  int lineno, const char *filename,
-                                  int full_traceback, int nogil);
-
-/* ListCompAppend.proto */
-#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
-static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
-    PyListObject* L = (PyListObject*) list;
-    Py_ssize_t len = Py_SIZE(list);
-    if (likely(L->allocated > len)) {
-        Py_INCREF(x);
-        PyList_SET_ITEM(list, len, x);
-        __Pyx_SET_SIZE(list, len + 1);
-        return 0;
-    }
-    return PyList_Append(list, x);
-}
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
 #else
-#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
 /* DictGetItem.proto */
 #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
 static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
@@ -1223,7 +1760,7 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1238,14 +1775,6 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 #define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
 /* GetException.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
@@ -1254,6 +1783,195 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject
 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
 #endif
 
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len)) {
+        Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
+        PyList_SET_ITEM(list, len, x);
+        #endif
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1268,22 +1986,169 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
 #endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1319,6 +2184,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1332,16 +2198,20 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
 /* CIntFromPy.proto */
 static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *);
 
@@ -1360,6 +2230,19 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1372,142 +2255,149 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'ssh2.c_pkey' */
+/* Module declarations from "ssh2.c_pkey" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.publickey' */
-static PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeyList = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeySystem = 0;
+/* Module declarations from "ssh2.publickey" */
 static PyObject *__pyx_f_4ssh2_9publickey_PyPublicKeyList(libssh2_publickey_list *); /*proto*/
 static libssh2_publickey_attribute *__pyx_f_4ssh2_9publickey_to_c_attr(PyObject *); /*proto*/
 static libssh2_publickey_attribute __pyx_convert__from_py_libssh2_publickey_attribute(PyObject *); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.publickey"
 extern int __pyx_module_is_main_ssh2__publickey;
 int __pyx_module_is_main_ssh2__publickey = 0;
 
-/* Implementation of 'ssh2.publickey' */
+/* Implementation of "ssh2.publickey" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_TypeError;
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_range;
 static PyObject *__pyx_builtin_KeyError;
 static PyObject *__pyx_builtin_ValueError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k_i[] = "i";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__23[] = "?";
+static const char __pyx_k_add[] = "add";
 static const char __pyx_k_attr[] = "attr";
 static const char __pyx_k_blob[] = "blob";
+static const char __pyx_k_keys[] = "keys";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "name";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_attrs[] = "attrs";
 static const char __pyx_k_range[] = "range";
 static const char __pyx_k_value[] = "value";
+static const char __pyx_k_blob_2[] = "_blob";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_name_2[] = "__name__";
+static const char __pyx_k_name_3[] = "_name";
 static const char __pyx_k_pkey_s[] = "pkey_s";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_remove[] = "remove";
+static const char __pyx_k_attrs_2[] = "_attrs";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_session[] = "session";
 static const char __pyx_k_KeyError[] = "KeyError";
 static const char __pyx_k_blob_len[] = "blob_len";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_name_len[] = "name_len";
+static const char __pyx_k_num_keys[] = "num_keys";
 static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_shutdown[] = "shutdown";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_list_free[] = "list_free";
 static const char __pyx_k_mandatory[] = "mandatory";
 static const char __pyx_k_num_attrs[] = "num_attrs";
 static const char __pyx_k_overwrite[] = "overwrite";
+static const char __pyx_k_pkey_list[] = "pkey_list";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_value_len[] = "value_len";
 static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_list_fetch[] = "list_fetch";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_PublicKeyList[] = "PublicKeyList";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_ssh2_publickey[] = "ssh2.publickey";
 static const char __pyx_k_PublicKeySystem[] = "PublicKeySystem";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
 static const char __pyx_k_PublicKeyAttribute[] = "PublicKeyAttribute";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_ssh2_publickey_pyx[] = "ssh2/publickey.pyx";
+static const char __pyx_k_PublicKeySystem_add[] = "PublicKeySystem.add";
+static const char __pyx_k_PublicKeySystem_remove[] = "PublicKeySystem.remove";
+static const char __pyx_k_PublicKeySystem_shutdown[] = "PublicKeySystem.shutdown";
+static const char __pyx_k_PublicKeySystem_list_free[] = "PublicKeySystem.list_free";
+static const char __pyx_k_PublicKeySystem_list_fetch[] = "PublicKeySystem.list_fetch";
+static const char __pyx_k_PublicKeyList___reduce_cython[] = "PublicKeyList.__reduce_cython__";
+static const char __pyx_k_PublicKeyList___setstate_cython[] = "PublicKeyList.__setstate_cython__";
+static const char __pyx_k_PublicKeySystem___reduce_cython[] = "PublicKeySystem.__reduce_cython__";
 static const char __pyx_k_No_value_specified_for_struct_at[] = "No value specified for struct attribute 'name'";
+static const char __pyx_k_PublicKeyAttribute___reduce_cyth[] = "PublicKeyAttribute.__reduce_cython__";
+static const char __pyx_k_PublicKeyAttribute___setstate_cy[] = "PublicKeyAttribute.__setstate_cython__";
+static const char __pyx_k_PublicKeySystem___setstate_cytho[] = "PublicKeySystem.__setstate_cython__";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
 static const char __pyx_k_No_value_specified_for_struct_at_2[] = "No value specified for struct attribute 'name_len'";
 static const char __pyx_k_No_value_specified_for_struct_at_3[] = "No value specified for struct attribute 'value'";
 static const char __pyx_k_No_value_specified_for_struct_at_4[] = "No value specified for struct attribute 'value_len'";
 static const char __pyx_k_No_value_specified_for_struct_at_5[] = "No value specified for struct attribute 'mandatory'";
-static PyObject *__pyx_n_s_KeyError;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_kp_s_No_value_specified_for_struct_at;
-static PyObject *__pyx_kp_s_No_value_specified_for_struct_at_2;
-static PyObject *__pyx_kp_s_No_value_specified_for_struct_at_3;
-static PyObject *__pyx_kp_s_No_value_specified_for_struct_at_4;
-static PyObject *__pyx_kp_s_No_value_specified_for_struct_at_5;
-static PyObject *__pyx_n_s_PublicKeyAttribute;
-static PyObject *__pyx_n_s_PublicKeyList;
-static PyObject *__pyx_n_s_PublicKeySystem;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_ValueError;
-static PyObject *__pyx_n_s_attr;
-static PyObject *__pyx_n_s_attrs;
-static PyObject *__pyx_n_s_blob;
-static PyObject *__pyx_n_s_blob_len;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_mandatory;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_name_2;
-static PyObject *__pyx_n_s_name_len;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_num_attrs;
-static PyObject *__pyx_n_s_overwrite;
-static PyObject *__pyx_n_s_pkey_s;
-static PyObject *__pyx_n_s_range;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_value;
-static PyObject *__pyx_n_s_value_len;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_9publickey_13PublicKeyList___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self, struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s); /* proto */
 static void __pyx_pf_4ssh2_9publickey_13PublicKeyList_2__dealloc__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4name___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self); /* proto */
@@ -1537,570 +2427,1486 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython
 static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyList(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeySystem(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__3;
-static PyObject *__pyx_tuple__4;
-static PyObject *__pyx_tuple__5;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_tuple__7;
-static PyObject *__pyx_tuple__8;
-static PyObject *__pyx_tuple__9;
-static PyObject *__pyx_tuple__10;
-static PyObject *__pyx_tuple__11;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_9publickey_PublicKeyList;
+  PyObject *__pyx_type_4ssh2_9publickey_PublicKeyAttribute;
+  PyObject *__pyx_type_4ssh2_9publickey_PublicKeySystem;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeyList;
+  PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute;
+  PyTypeObject *__pyx_ptype_4ssh2_9publickey_PublicKeySystem;
+  PyObject *__pyx_n_s_KeyError;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_kp_s_No_value_specified_for_struct_at;
+  PyObject *__pyx_kp_s_No_value_specified_for_struct_at_2;
+  PyObject *__pyx_kp_s_No_value_specified_for_struct_at_3;
+  PyObject *__pyx_kp_s_No_value_specified_for_struct_at_4;
+  PyObject *__pyx_kp_s_No_value_specified_for_struct_at_5;
+  PyObject *__pyx_n_s_PublicKeyAttribute;
+  PyObject *__pyx_n_s_PublicKeyAttribute___reduce_cyth;
+  PyObject *__pyx_n_s_PublicKeyAttribute___setstate_cy;
+  PyObject *__pyx_n_s_PublicKeyList;
+  PyObject *__pyx_n_s_PublicKeyList___reduce_cython;
+  PyObject *__pyx_n_s_PublicKeyList___setstate_cython;
+  PyObject *__pyx_n_s_PublicKeySystem;
+  PyObject *__pyx_n_s_PublicKeySystem___reduce_cython;
+  PyObject *__pyx_n_s_PublicKeySystem___setstate_cytho;
+  PyObject *__pyx_n_s_PublicKeySystem_add;
+  PyObject *__pyx_n_s_PublicKeySystem_list_fetch;
+  PyObject *__pyx_n_s_PublicKeySystem_list_free;
+  PyObject *__pyx_n_s_PublicKeySystem_remove;
+  PyObject *__pyx_n_s_PublicKeySystem_shutdown;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s_ValueError;
+  PyObject *__pyx_n_s__23;
+  PyObject *__pyx_n_s_add;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_attr;
+  PyObject *__pyx_n_s_attrs;
+  PyObject *__pyx_n_s_attrs_2;
+  PyObject *__pyx_n_s_blob;
+  PyObject *__pyx_n_s_blob_2;
+  PyObject *__pyx_n_s_blob_len;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_i;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_keys;
+  PyObject *__pyx_n_s_list_fetch;
+  PyObject *__pyx_n_s_list_free;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_mandatory;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_name_2;
+  PyObject *__pyx_n_s_name_3;
+  PyObject *__pyx_n_s_name_len;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_num_attrs;
+  PyObject *__pyx_n_s_num_keys;
+  PyObject *__pyx_n_s_overwrite;
+  PyObject *__pyx_n_s_pkey_list;
+  PyObject *__pyx_n_s_pkey_s;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_range;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_remove;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_shutdown;
+  PyObject *__pyx_n_s_ssh2_publickey;
+  PyObject *__pyx_kp_s_ssh2_publickey_pyx;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_value;
+  PyObject *__pyx_n_s_value_len;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__2;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_tuple__4;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__6;
+  PyObject *__pyx_tuple__8;
+  PyObject *__pyx_tuple__12;
+  PyObject *__pyx_tuple__14;
+  PyObject *__pyx_tuple__16;
+  PyObject *__pyx_tuple__19;
+  PyObject *__pyx_codeobj__7;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__10;
+  PyObject *__pyx_codeobj__11;
+  PyObject *__pyx_codeobj__13;
+  PyObject *__pyx_codeobj__15;
+  PyObject *__pyx_codeobj__17;
+  PyObject *__pyx_codeobj__18;
+  PyObject *__pyx_codeobj__20;
+  PyObject *__pyx_codeobj__21;
+  PyObject *__pyx_codeobj__22;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-/* "ssh2/publickey.pyx":24
- * 
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeyList);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_9publickey_PublicKeyList);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_9publickey_PublicKeyAttribute);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_9publickey_PublicKeySystem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KeyError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at_3);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at_4);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at_5);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyAttribute);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyAttribute___reduce_cyth);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyAttribute___setstate_cy);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyList);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyList___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyList___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem___setstate_cytho);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem_add);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem_list_fetch);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem_list_free);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem_remove);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeySystem_shutdown);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ValueError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__23);
+  Py_CLEAR(clear_module_state->__pyx_n_s_add);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_attr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_attrs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_attrs_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_blob);
+  Py_CLEAR(clear_module_state->__pyx_n_s_blob_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_blob_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_i);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_keys);
+  Py_CLEAR(clear_module_state->__pyx_n_s_list_fetch);
+  Py_CLEAR(clear_module_state->__pyx_n_s_list_free);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mandatory);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name_3);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name_len);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_num_attrs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_num_keys);
+  Py_CLEAR(clear_module_state->__pyx_n_s_overwrite);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pkey_list);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pkey_s);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_range);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_remove);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_shutdown);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_publickey);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_publickey_pyx);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_value);
+  Py_CLEAR(clear_module_state->__pyx_n_s_value_len);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__2);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_tuple__4);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__6);
+  Py_CLEAR(clear_module_state->__pyx_tuple__8);
+  Py_CLEAR(clear_module_state->__pyx_tuple__12);
+  Py_CLEAR(clear_module_state->__pyx_tuple__14);
+  Py_CLEAR(clear_module_state->__pyx_tuple__16);
+  Py_CLEAR(clear_module_state->__pyx_tuple__19);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__7);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__10);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__11);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__13);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__15);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__17);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__18);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__21);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeyList);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_9publickey_PublicKeyList);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_9publickey_PublicKeyAttribute);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_9publickey_PublicKeySystem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KeyError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at_3);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at_4);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at_5);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyAttribute);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyAttribute___reduce_cyth);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyAttribute___setstate_cy);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyList);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyList___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyList___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem___setstate_cytho);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem_add);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem_list_fetch);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem_list_free);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem_remove);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeySystem_shutdown);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ValueError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__23);
+  Py_VISIT(traverse_module_state->__pyx_n_s_add);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_attr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_attrs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_attrs_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_blob);
+  Py_VISIT(traverse_module_state->__pyx_n_s_blob_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_blob_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_i);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_keys);
+  Py_VISIT(traverse_module_state->__pyx_n_s_list_fetch);
+  Py_VISIT(traverse_module_state->__pyx_n_s_list_free);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mandatory);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name_3);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name_len);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_num_attrs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_num_keys);
+  Py_VISIT(traverse_module_state->__pyx_n_s_overwrite);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pkey_list);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pkey_s);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_range);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_remove);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_shutdown);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_publickey);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_publickey_pyx);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_value);
+  Py_VISIT(traverse_module_state->__pyx_n_s_value_len);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__2);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_tuple__4);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__6);
+  Py_VISIT(traverse_module_state->__pyx_tuple__8);
+  Py_VISIT(traverse_module_state->__pyx_tuple__12);
+  Py_VISIT(traverse_module_state->__pyx_tuple__14);
+  Py_VISIT(traverse_module_state->__pyx_tuple__16);
+  Py_VISIT(traverse_module_state->__pyx_tuple__19);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__7);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__10);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__11);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__13);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__15);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__17);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__18);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__21);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_9publickey_PublicKeyList __pyx_mstate_global->__pyx_type_4ssh2_9publickey_PublicKeyList
+#define __pyx_type_4ssh2_9publickey_PublicKeyAttribute __pyx_mstate_global->__pyx_type_4ssh2_9publickey_PublicKeyAttribute
+#define __pyx_type_4ssh2_9publickey_PublicKeySystem __pyx_mstate_global->__pyx_type_4ssh2_9publickey_PublicKeySystem
+#endif
+#define __pyx_ptype_4ssh2_9publickey_PublicKeyList __pyx_mstate_global->__pyx_ptype_4ssh2_9publickey_PublicKeyList
+#define __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute __pyx_mstate_global->__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute
+#define __pyx_ptype_4ssh2_9publickey_PublicKeySystem __pyx_mstate_global->__pyx_ptype_4ssh2_9publickey_PublicKeySystem
+#define __pyx_n_s_KeyError __pyx_mstate_global->__pyx_n_s_KeyError
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_kp_s_No_value_specified_for_struct_at __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at
+#define __pyx_kp_s_No_value_specified_for_struct_at_2 __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at_2
+#define __pyx_kp_s_No_value_specified_for_struct_at_3 __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at_3
+#define __pyx_kp_s_No_value_specified_for_struct_at_4 __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at_4
+#define __pyx_kp_s_No_value_specified_for_struct_at_5 __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at_5
+#define __pyx_n_s_PublicKeyAttribute __pyx_mstate_global->__pyx_n_s_PublicKeyAttribute
+#define __pyx_n_s_PublicKeyAttribute___reduce_cyth __pyx_mstate_global->__pyx_n_s_PublicKeyAttribute___reduce_cyth
+#define __pyx_n_s_PublicKeyAttribute___setstate_cy __pyx_mstate_global->__pyx_n_s_PublicKeyAttribute___setstate_cy
+#define __pyx_n_s_PublicKeyList __pyx_mstate_global->__pyx_n_s_PublicKeyList
+#define __pyx_n_s_PublicKeyList___reduce_cython __pyx_mstate_global->__pyx_n_s_PublicKeyList___reduce_cython
+#define __pyx_n_s_PublicKeyList___setstate_cython __pyx_mstate_global->__pyx_n_s_PublicKeyList___setstate_cython
+#define __pyx_n_s_PublicKeySystem __pyx_mstate_global->__pyx_n_s_PublicKeySystem
+#define __pyx_n_s_PublicKeySystem___reduce_cython __pyx_mstate_global->__pyx_n_s_PublicKeySystem___reduce_cython
+#define __pyx_n_s_PublicKeySystem___setstate_cytho __pyx_mstate_global->__pyx_n_s_PublicKeySystem___setstate_cytho
+#define __pyx_n_s_PublicKeySystem_add __pyx_mstate_global->__pyx_n_s_PublicKeySystem_add
+#define __pyx_n_s_PublicKeySystem_list_fetch __pyx_mstate_global->__pyx_n_s_PublicKeySystem_list_fetch
+#define __pyx_n_s_PublicKeySystem_list_free __pyx_mstate_global->__pyx_n_s_PublicKeySystem_list_free
+#define __pyx_n_s_PublicKeySystem_remove __pyx_mstate_global->__pyx_n_s_PublicKeySystem_remove
+#define __pyx_n_s_PublicKeySystem_shutdown __pyx_mstate_global->__pyx_n_s_PublicKeySystem_shutdown
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError
+#define __pyx_n_s__23 __pyx_mstate_global->__pyx_n_s__23
+#define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_attr __pyx_mstate_global->__pyx_n_s_attr
+#define __pyx_n_s_attrs __pyx_mstate_global->__pyx_n_s_attrs
+#define __pyx_n_s_attrs_2 __pyx_mstate_global->__pyx_n_s_attrs_2
+#define __pyx_n_s_blob __pyx_mstate_global->__pyx_n_s_blob
+#define __pyx_n_s_blob_2 __pyx_mstate_global->__pyx_n_s_blob_2
+#define __pyx_n_s_blob_len __pyx_mstate_global->__pyx_n_s_blob_len
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_keys __pyx_mstate_global->__pyx_n_s_keys
+#define __pyx_n_s_list_fetch __pyx_mstate_global->__pyx_n_s_list_fetch
+#define __pyx_n_s_list_free __pyx_mstate_global->__pyx_n_s_list_free
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_mandatory __pyx_mstate_global->__pyx_n_s_mandatory
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2
+#define __pyx_n_s_name_3 __pyx_mstate_global->__pyx_n_s_name_3
+#define __pyx_n_s_name_len __pyx_mstate_global->__pyx_n_s_name_len
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_num_attrs __pyx_mstate_global->__pyx_n_s_num_attrs
+#define __pyx_n_s_num_keys __pyx_mstate_global->__pyx_n_s_num_keys
+#define __pyx_n_s_overwrite __pyx_mstate_global->__pyx_n_s_overwrite
+#define __pyx_n_s_pkey_list __pyx_mstate_global->__pyx_n_s_pkey_list
+#define __pyx_n_s_pkey_s __pyx_mstate_global->__pyx_n_s_pkey_s
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_remove __pyx_mstate_global->__pyx_n_s_remove
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_shutdown __pyx_mstate_global->__pyx_n_s_shutdown
+#define __pyx_n_s_ssh2_publickey __pyx_mstate_global->__pyx_n_s_ssh2_publickey
+#define __pyx_kp_s_ssh2_publickey_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_publickey_pyx
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value
+#define __pyx_n_s_value_len __pyx_mstate_global->__pyx_n_s_value_len
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6
+#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
+#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19
+#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10
+#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11
+#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13
+#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15
+#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17
+#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+/* #### Code section: module_code ### */
+
+/* "FromPyStructUtility":12
  * 
- * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):             # <<<<<<<<<<<<<<
- *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
- *     key_list.key_list = _list
+ * @cname("__pyx_convert__from_py_libssh2_publickey_attribute")
+ * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:             # <<<<<<<<<<<<<<
+ *     cdef struct_type result
+ *     if not PyMapping_Check(obj):
  */
 
-static PyObject *__pyx_f_4ssh2_9publickey_PyPublicKeyList(libssh2_publickey_list *__pyx_v__list) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_key_list = 0;
-  PyObject *__pyx_r = NULL;
+static libssh2_publickey_attribute __pyx_convert__from_py_libssh2_publickey_attribute(PyObject *__pyx_v_obj) {
+  libssh2_publickey_attribute __pyx_v_result;
+  PyObject *__pyx_v_value = NULL;
+  libssh2_publickey_attribute __pyx_r;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  char const *__pyx_t_10;
+  unsigned long __pyx_t_11;
+  char const *__pyx_t_12;
+  char __pyx_t_13;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyPublicKeyList", 0);
+  __Pyx_RefNannySetupContext("__pyx_convert__from_py_libssh2_publickey_attribute", 1);
 
-  /* "ssh2/publickey.pyx":25
+  /* "FromPyStructUtility":14
+ * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:
+ *     cdef struct_type result
+ *     if not PyMapping_Check(obj):             # <<<<<<<<<<<<<<
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
  * 
- * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):
- *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)             # <<<<<<<<<<<<<<
- *     key_list.key_list = _list
- *     return key_list
  */
-  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9publickey_PublicKeyList(((PyTypeObject *)__pyx_ptype_4ssh2_9publickey_PublicKeyList), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 25, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
-  __pyx_v_key_list = ((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_t_1 = (!PyMapping_Check(__pyx_v_obj));
+  if (__pyx_t_1) {
 
-  /* "ssh2/publickey.pyx":26
- * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):
- *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
- *     key_list.key_list = _list             # <<<<<<<<<<<<<<
- *     return key_list
+    /* "FromPyStructUtility":15
+ *     cdef struct_type result
+ *     if not PyMapping_Check(obj):
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)             # <<<<<<<<<<<<<<
  * 
+ *     try:
  */
-  __pyx_v_key_list->key_list = __pyx_v__list;
+    __pyx_t_2 = __Pyx_RaiseUnexpectedTypeError(((char const *)"a mapping"), __pyx_v_obj); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(0, 15, __pyx_L1_error)
 
-  /* "ssh2/publickey.pyx":27
- *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
- *     key_list.key_list = _list
- *     return key_list             # <<<<<<<<<<<<<<
- * 
+    /* "FromPyStructUtility":14
+ * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:
+ *     cdef struct_type result
+ *     if not PyMapping_Check(obj):             # <<<<<<<<<<<<<<
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
  * 
  */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_key_list));
-  __pyx_r = ((PyObject *)__pyx_v_key_list);
-  goto __pyx_L0;
+  }
 
-  /* "ssh2/publickey.pyx":24
+  /* "FromPyStructUtility":17
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
  * 
- * 
- * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):             # <<<<<<<<<<<<<<
- *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
- *     key_list.key_list = _list
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name']
+ *     except KeyError:
  */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    /*try:*/ {
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PyPublicKeyList", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_key_list);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "ssh2/publickey.pyx":34
- *     cdef PublicKeySystem pkey_s
+      /* "FromPyStructUtility":18
  * 
- *     def __cinit__(self, PublicKeySystem pkey_s):             # <<<<<<<<<<<<<<
- *         self.key_list = NULL
- *         self.pkey_s = pkey_s
+ *     try:
+ *         value = obj['name']             # <<<<<<<<<<<<<<
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name'")
  */
+      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 18, __pyx_L4_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_v_value = __pyx_t_6;
+      __pyx_t_6 = 0;
 
-/* Python wrapper */
-static int __pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s = 0;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pkey_s,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pkey_s)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 34, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      /* "FromPyStructUtility":17
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
+ * 
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name']
+ *     except KeyError:
+ */
     }
-    __pyx_v_pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)values[0]);
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 34, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pkey_s), __pyx_ptype_4ssh2_9publickey_PublicKeySystem, 1, "pkey_s", 0))) __PYX_ERR(1, 34, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self), __pyx_v_pkey_s);
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static int __pyx_pf_4ssh2_9publickey_13PublicKeyList___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self, struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L9_try_end;
+    __pyx_L4_error:;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
 
-  /* "ssh2/publickey.pyx":35
- * 
- *     def __cinit__(self, PublicKeySystem pkey_s):
- *         self.key_list = NULL             # <<<<<<<<<<<<<<
- *         self.pkey_s = pkey_s
- * 
+    /* "FromPyStructUtility":19
+ *     try:
+ *         value = obj['name']
+ *     except KeyError:             # <<<<<<<<<<<<<<
+ *         raise ValueError("No value specified for struct attribute 'name'")
+ *     result.name = value
  */
-  __pyx_v_self->key_list = NULL;
+    __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_2) {
+      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 19, __pyx_L6_except_error)
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
 
-  /* "ssh2/publickey.pyx":36
- *     def __cinit__(self, PublicKeySystem pkey_s):
- *         self.key_list = NULL
- *         self.pkey_s = pkey_s             # <<<<<<<<<<<<<<
- * 
- *     def __dealloc__(self):
+      /* "FromPyStructUtility":20
+ *         value = obj['name']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name'")             # <<<<<<<<<<<<<<
+ *     result.name = value
+ *     try:
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_pkey_s));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_pkey_s));
-  __Pyx_GOTREF(__pyx_v_self->pkey_s);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->pkey_s));
-  __pyx_v_self->pkey_s = __pyx_v_pkey_s;
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L6_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __PYX_ERR(0, 20, __pyx_L6_except_error)
+    }
+    goto __pyx_L6_except_error;
 
-  /* "ssh2/publickey.pyx":34
- *     cdef PublicKeySystem pkey_s
+    /* "FromPyStructUtility":17
+ *         __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
  * 
- *     def __cinit__(self, PublicKeySystem pkey_s):             # <<<<<<<<<<<<<<
- *         self.key_list = NULL
- *         self.pkey_s = pkey_s
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name']
+ *     except KeyError:
  */
+    __pyx_L6_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+    goto __pyx_L1_error;
+    __pyx_L9_try_end:;
+  }
 
-  /* function exit code */
-  __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  /* "FromPyStructUtility":21
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name'")
+ *     result.name = value             # <<<<<<<<<<<<<<
+ *     try:
+ *         value = obj['name_len']
+ */
+  __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_value); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 21, __pyx_L1_error)
+  __pyx_v_result.name = __pyx_t_10;
 
-/* "ssh2/publickey.pyx":38
- *         self.pkey_s = pkey_s
- * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         with nogil:
- *             c_pkey.libssh2_publickey_list_free(
+  /* "FromPyStructUtility":22
+ *         raise ValueError("No value specified for struct attribute 'name'")
+ *     result.name = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name_len']
+ *     except KeyError:
  */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
 
-/* Python wrapper */
-static void __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(PyObject *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
-  __pyx_pf_4ssh2_9publickey_13PublicKeyList_2__dealloc__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
+      /* "FromPyStructUtility":23
+ *     result.name = value
+ *     try:
+ *         value = obj['name_len']             # <<<<<<<<<<<<<<
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ */
+      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_name_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 23, __pyx_L12_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8);
+      __pyx_t_8 = 0;
 
-static void __pyx_pf_4ssh2_9publickey_13PublicKeyList_2__dealloc__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
+      /* "FromPyStructUtility":22
+ *         raise ValueError("No value specified for struct attribute 'name'")
+ *     result.name = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name_len']
+ *     except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L17_try_end;
+    __pyx_L12_error:;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
 
-  /* "ssh2/publickey.pyx":39
- * 
- *     def __dealloc__(self):
- *         with nogil:             # <<<<<<<<<<<<<<
- *             c_pkey.libssh2_publickey_list_free(
- *                 self.pkey_s.pkey_s, self.key_list)
+    /* "FromPyStructUtility":24
+ *     try:
+ *         value = obj['name_len']
+ *     except KeyError:             # <<<<<<<<<<<<<<
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ *     result.name_len = value
  */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
+    __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_2) {
+      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(0, 24, __pyx_L14_except_error)
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
 
-        /* "ssh2/publickey.pyx":40
- *     def __dealloc__(self):
- *         with nogil:
- *             c_pkey.libssh2_publickey_list_free(             # <<<<<<<<<<<<<<
- *                 self.pkey_s.pkey_s, self.key_list)
- * 
+      /* "FromPyStructUtility":25
+ *         value = obj['name_len']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name_len'")             # <<<<<<<<<<<<<<
+ *     result.name_len = value
+ *     try:
  */
-        libssh2_publickey_list_free(__pyx_v_self->pkey_s->pkey_s, __pyx_v_self->key_list);
-      }
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 25, __pyx_L14_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __PYX_ERR(0, 25, __pyx_L14_except_error)
+    }
+    goto __pyx_L14_except_error;
 
-      /* "ssh2/publickey.pyx":39
- * 
- *     def __dealloc__(self):
- *         with nogil:             # <<<<<<<<<<<<<<
- *             c_pkey.libssh2_publickey_list_free(
- *                 self.pkey_s.pkey_s, self.key_list)
+    /* "FromPyStructUtility":22
+ *         raise ValueError("No value specified for struct attribute 'name'")
+ *     result.name = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['name_len']
+ *     except KeyError:
  */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L5;
-        }
-        __pyx_L5:;
-      }
+    __pyx_L14_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L17_try_end:;
   }
 
-  /* "ssh2/publickey.pyx":38
- *         self.pkey_s = pkey_s
- * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         with nogil:
- *             c_pkey.libssh2_publickey_list_free(
+  /* "FromPyStructUtility":26
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ *     result.name_len = value             # <<<<<<<<<<<<<<
+ *     try:
+ *         value = obj['value']
  */
+  __pyx_t_11 = __Pyx_PyInt_As_unsigned_long(__pyx_v_value); if (unlikely((__pyx_t_11 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L1_error)
+  __pyx_v_result.name_len = __pyx_t_11;
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-/* "ssh2/publickey.pyx":44
- * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name
- * 
+  /* "FromPyStructUtility":27
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ *     result.name_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value']
+ *     except KeyError:
  */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    /*try:*/ {
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4name___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4name___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+      /* "FromPyStructUtility":28
+ *     result.name_len = value
+ *     try:
+ *         value = obj['value']             # <<<<<<<<<<<<<<
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ */
+      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 28, __pyx_L20_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_6);
+      __pyx_t_6 = 0;
 
-  /* "ssh2/publickey.pyx":45
- *     @property
- *     def name(self):
- *         return self.attr.name             # <<<<<<<<<<<<<<
- * 
- *     @property
+      /* "FromPyStructUtility":27
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ *     result.name_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value']
+ *     except KeyError:
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+    }
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L25_try_end;
+    __pyx_L20_error:;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
 
-  /* "ssh2/publickey.pyx":44
- * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name
- * 
+    /* "FromPyStructUtility":29
+ *     try:
+ *         value = obj['value']
+ *     except KeyError:             # <<<<<<<<<<<<<<
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ *     result.value = value
  */
+    __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_2) {
+      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 29, __pyx_L22_except_error)
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+      /* "FromPyStructUtility":30
+ *         value = obj['value']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value'")             # <<<<<<<<<<<<<<
+ *     result.value = value
+ *     try:
+ */
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 30, __pyx_L22_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __PYX_ERR(0, 30, __pyx_L22_except_error)
+    }
+    goto __pyx_L22_except_error;
 
-/* "ssh2/publickey.pyx":48
- * 
- *     @property
- *     def name_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name_len
- * 
+    /* "FromPyStructUtility":27
+ *         raise ValueError("No value specified for struct attribute 'name_len'")
+ *     result.name_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value']
+ *     except KeyError:
  */
+    __pyx_L22_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+    goto __pyx_L1_error;
+    __pyx_L25_try_end:;
+  }
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_8name_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
+  /* "FromPyStructUtility":31
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ *     result.value = value             # <<<<<<<<<<<<<<
+ *     try:
+ *         value = obj['value_len']
+ */
+  __pyx_t_12 = __Pyx_PyObject_AsString(__pyx_v_value); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error)
+  __pyx_v_result.value = __pyx_t_12;
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  /* "FromPyStructUtility":32
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ *     result.value = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value_len']
+ *     except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
 
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_8name_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+      /* "FromPyStructUtility":33
+ *     result.value = value
+ *     try:
+ *         value = obj['value_len']             # <<<<<<<<<<<<<<
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ */
+      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_value_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 33, __pyx_L28_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8);
+      __pyx_t_8 = 0;
 
-  /* "ssh2/publickey.pyx":49
- *     @property
- *     def name_len(self):
- *         return self.attr.name_len             # <<<<<<<<<<<<<<
+      /* "FromPyStructUtility":32
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ *     result.value = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value_len']
+ *     except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L33_try_end;
+    __pyx_L28_error:;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "FromPyStructUtility":34
+ *     try:
+ *         value = obj['value_len']
+ *     except KeyError:             # <<<<<<<<<<<<<<
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ *     result.value_len = value
+ */
+    __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_2) {
+      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(0, 34, __pyx_L30_except_error)
+      __Pyx_XGOTREF(__pyx_t_8);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_6);
+
+      /* "FromPyStructUtility":35
+ *         value = obj['value_len']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value_len'")             # <<<<<<<<<<<<<<
+ *     result.value_len = value
+ *     try:
+ */
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 35, __pyx_L30_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __PYX_ERR(0, 35, __pyx_L30_except_error)
+    }
+    goto __pyx_L30_except_error;
+
+    /* "FromPyStructUtility":32
+ *         raise ValueError("No value specified for struct attribute 'value'")
+ *     result.value = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['value_len']
+ *     except KeyError:
+ */
+    __pyx_L30_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L33_try_end:;
+  }
+
+  /* "FromPyStructUtility":36
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ *     result.value_len = value             # <<<<<<<<<<<<<<
+ *     try:
+ *         value = obj['mandatory']
+ */
+  __pyx_t_11 = __Pyx_PyInt_As_unsigned_long(__pyx_v_value); if (unlikely((__pyx_t_11 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L1_error)
+  __pyx_v_result.value_len = __pyx_t_11;
+
+  /* "FromPyStructUtility":37
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ *     result.value_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['mandatory']
+ *     except KeyError:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
+    __Pyx_XGOTREF(__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_4);
+    __Pyx_XGOTREF(__pyx_t_5);
+    /*try:*/ {
+
+      /* "FromPyStructUtility":38
+ *     result.value_len = value
+ *     try:
+ *         value = obj['mandatory']             # <<<<<<<<<<<<<<
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")
+ */
+      __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_mandatory); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 38, __pyx_L36_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "FromPyStructUtility":37
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ *     result.value_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['mandatory']
+ *     except KeyError:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L41_try_end;
+    __pyx_L36_error:;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    /* "FromPyStructUtility":39
+ *     try:
+ *         value = obj['mandatory']
+ *     except KeyError:             # <<<<<<<<<<<<<<
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")
+ *     result.mandatory = value
+ */
+    __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+    if (__pyx_t_2) {
+      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 39, __pyx_L38_except_error)
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_8);
+
+      /* "FromPyStructUtility":40
+ *         value = obj['mandatory']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")             # <<<<<<<<<<<<<<
+ *     result.mandatory = value
+ *     return result
+ */
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 40, __pyx_L38_except_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __PYX_ERR(0, 40, __pyx_L38_except_error)
+    }
+    goto __pyx_L38_except_error;
+
+    /* "FromPyStructUtility":37
+ *         raise ValueError("No value specified for struct attribute 'value_len'")
+ *     result.value_len = value
+ *     try:             # <<<<<<<<<<<<<<
+ *         value = obj['mandatory']
+ *     except KeyError:
+ */
+    __pyx_L38_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_XGIVEREF(__pyx_t_4);
+    __Pyx_XGIVEREF(__pyx_t_5);
+    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
+    goto __pyx_L1_error;
+    __pyx_L41_try_end:;
+  }
+
+  /* "FromPyStructUtility":41
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")
+ *     result.mandatory = value             # <<<<<<<<<<<<<<
+ *     return result
  * 
- *     @property
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+  __pyx_t_13 = __Pyx_PyInt_As_char(__pyx_v_value); if (unlikely((__pyx_t_13 == (char)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error)
+  __pyx_v_result.mandatory = __pyx_t_13;
 
-  /* "ssh2/publickey.pyx":48
+  /* "FromPyStructUtility":42
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")
+ *     result.mandatory = value
+ *     return result             # <<<<<<<<<<<<<<
  * 
- *     @property
- *     def name_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name_len
  * 
+ */
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
+  /* "FromPyStructUtility":12
+ * 
+ * @cname("__pyx_convert__from_py_libssh2_publickey_attribute")
+ * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:             # <<<<<<<<<<<<<<
+ *     cdef struct_type result
+ *     if not PyMapping_Check(obj):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.name_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_pretend_to_initialize(&__pyx_r);
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF(__pyx_v_value);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":52
+/* "ssh2/publickey.pyx":24
  * 
- *     @property
- *     def blob(self):             # <<<<<<<<<<<<<<
- *         return self.attr.blob
  * 
+ * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):             # <<<<<<<<<<<<<<
+ *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
+ *     key_list.key_list = _list
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4blob___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4blob___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
+static PyObject *__pyx_f_4ssh2_9publickey_PyPublicKeyList(libssh2_publickey_list *__pyx_v__list) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_key_list = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("PyPublicKeyList", 1);
 
-  /* "ssh2/publickey.pyx":53
- *     @property
- *     def blob(self):
- *         return self.attr.blob             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":25
  * 
- *     @property
+ * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):
+ *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)             # <<<<<<<<<<<<<<
+ *     key_list.key_list = _list
+ *     return key_list
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_blob); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 53, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_tp_new_4ssh2_9publickey_PublicKeyList(((PyTypeObject *)__pyx_ptype_4ssh2_9publickey_PublicKeyList), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 25, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_1);
+  __pyx_v_key_list = ((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "ssh2/publickey.pyx":26
+ * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):
+ *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
+ *     key_list.key_list = _list             # <<<<<<<<<<<<<<
+ *     return key_list
+ * 
+ */
+  __pyx_v_key_list->key_list = __pyx_v__list;
+
+  /* "ssh2/publickey.pyx":27
+ *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
+ *     key_list.key_list = _list
+ *     return key_list             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_key_list);
+  __pyx_r = ((PyObject *)__pyx_v_key_list);
   goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":52
+  /* "ssh2/publickey.pyx":24
  * 
- *     @property
- *     def blob(self):             # <<<<<<<<<<<<<<
- *         return self.attr.blob
  * 
+ * cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):             # <<<<<<<<<<<<<<
+ *     cdef PublicKeyList key_list = PublicKeyList.__new__(PublicKeyList)
+ *     key_list.key_list = _list
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.blob.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("ssh2.publickey.PyPublicKeyList", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_key_list);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":56
- * 
- *     @property
- *     def blob_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.blob_len
+/* "ssh2/publickey.pyx":34
+ *     cdef PublicKeySystem pkey_s
  * 
+ *     def __cinit__(self, PublicKeySystem pkey_s):             # <<<<<<<<<<<<<<
+ *         self.key_list = NULL
+ *         self.pkey_s = pkey_s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
+static int __pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_8blob_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pkey_s,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pkey_s)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 34, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 34, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+    }
+    __pyx_v_pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 34, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pkey_s), __pyx_ptype_4ssh2_9publickey_PublicKeySystem, 1, "pkey_s", 0))) __PYX_ERR(1, 34, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self), __pyx_v_pkey_s);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_8blob_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
+static int __pyx_pf_4ssh2_9publickey_13PublicKeyList___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self, struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s) {
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
-  /* "ssh2/publickey.pyx":57
- *     @property
- *     def blob_len(self):
- *         return self.attr.blob_len             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":35
+ * 
+ *     def __cinit__(self, PublicKeySystem pkey_s):
+ *         self.key_list = NULL             # <<<<<<<<<<<<<<
+ *         self.pkey_s = pkey_s
  * 
- *     @property
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 57, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_blob_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 57, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+  __pyx_v_self->key_list = NULL;
 
-  /* "ssh2/publickey.pyx":56
+  /* "ssh2/publickey.pyx":36
+ *     def __cinit__(self, PublicKeySystem pkey_s):
+ *         self.key_list = NULL
+ *         self.pkey_s = pkey_s             # <<<<<<<<<<<<<<
  * 
- *     @property
- *     def blob_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.blob_len
+ *     def __dealloc__(self):
+ */
+  __Pyx_INCREF((PyObject *)__pyx_v_pkey_s);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_pkey_s);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->pkey_s);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->pkey_s);
+  __pyx_v_self->pkey_s = __pyx_v_pkey_s;
+
+  /* "ssh2/publickey.pyx":34
+ *     cdef PublicKeySystem pkey_s
  * 
+ *     def __cinit__(self, PublicKeySystem pkey_s):             # <<<<<<<<<<<<<<
+ *         self.key_list = NULL
+ *         self.pkey_s = pkey_s
  */
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.blob_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
+  __pyx_r = 0;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":60
+/* "ssh2/publickey.pyx":38
+ *         self.pkey_s = pkey_s
  * 
- *     @property
- *     def num_attrs(self):             # <<<<<<<<<<<<<<
- *         return self.attr.num_attrs
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             c_pkey.libssh2_publickey_list_free(
+ */
+
+/* Python wrapper */
+static void __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_pf_4ssh2_9publickey_13PublicKeyList_2__dealloc__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_4ssh2_9publickey_13PublicKeyList_2__dealloc__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
+
+  /* "ssh2/publickey.pyx":39
+ * 
+ *     def __dealloc__(self):
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             c_pkey.libssh2_publickey_list_free(
+ *                 self.pkey_s.pkey_s, self.key_list)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      _save = NULL;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+
+        /* "ssh2/publickey.pyx":40
+ *     def __dealloc__(self):
+ *         with nogil:
+ *             c_pkey.libssh2_publickey_list_free(             # <<<<<<<<<<<<<<
+ *                 self.pkey_s.pkey_s, self.key_list)
+ * 
+ */
+        libssh2_publickey_list_free(__pyx_v_self->pkey_s->pkey_s, __pyx_v_self->key_list);
+      }
+
+      /* "ssh2/publickey.pyx":39
+ * 
+ *     def __dealloc__(self):
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             c_pkey.libssh2_publickey_list_free(
+ *                 self.pkey_s.pkey_s, self.key_list)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "ssh2/publickey.pyx":38
+ *         self.pkey_s = pkey_s
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             c_pkey.libssh2_publickey_list_free(
+ */
+
+  /* function exit code */
+}
+
+/* "ssh2/publickey.pyx":43
+ *                 self.pkey_s.pkey_s, self.key_list)
  * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
+ *         return self.attr.name
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4name___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4name___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -2108,38 +3914,38 @@ static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/publickey.pyx":61
+  /* "ssh2/publickey.pyx":45
  *     @property
- *     def num_attrs(self):
- *         return self.attr.num_attrs             # <<<<<<<<<<<<<<
- * 
+ *     def name(self):
+ *         return self.attr.name             # <<<<<<<<<<<<<<
  * 
+ *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_num_attrs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":60
- * 
- *     @property
- *     def num_attrs(self):             # <<<<<<<<<<<<<<
- *         return self.attr.num_attrs
+  /* "ssh2/publickey.pyx":43
+ *                 self.pkey_s.pkey_s, self.key_list)
  * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
+ *         return self.attr.name
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.num_attrs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2147,378 +3953,279 @@ static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(st
   return __pyx_r;
 }
 
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+/* "ssh2/publickey.pyx":47
+ *         return self.attr.name
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name_len(self):
+ *         return self.attr.name_len
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__[] = "PublicKeyList.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_8name_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_8name_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/publickey.pyx":49
+ *     @property
+ *     def name_len(self):
+ *         return self.attr.name_len             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 49, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(0, 2, __pyx_L1_error)
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+  /* "ssh2/publickey.pyx":47
+ *         return self.attr.name
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name_len(self):
+ *         return self.attr.name_len
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.name_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
+  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+/* "ssh2/publickey.pyx":51
+ *         return self.attr.name_len
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob(self):
+ *         return self.attr.blob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__[] = "PublicKeyList.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4blob___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4blob___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":53
+ *     @property
+ *     def blob(self):
+ *         return self.attr.blob             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_blob); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(0, 4, __pyx_L1_error)
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/publickey.pyx":51
+ *         return self.attr.name_len
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob(self):
+ *         return self.attr.blob
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.blob.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
+  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":68
- *     cdef c_pkey.libssh2_publickey_attribute attr
+/* "ssh2/publickey.pyx":55
+ *         return self.attr.blob
  * 
- *     def __cinit__(self, bytes name, bytes value, char mandatory):             # <<<<<<<<<<<<<<
- *         cdef char *_name = name
- *         cdef char *_value = value
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob_len(self):
+ *         return self.attr.blob_len
  */
 
 /* Python wrapper */
-static int __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_name = 0;
-  PyObject *__pyx_v_value = 0;
-  char __pyx_v_mandatory;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_mandatory,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(1, 68, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mandatory)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(1, 68, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 68, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-    }
-    __pyx_v_name = ((PyObject*)values[0]);
-    __pyx_v_value = ((PyObject*)values[1]);
-    __pyx_v_mandatory = __Pyx_PyInt_As_char(values[2]); if (unlikely((__pyx_v_mandatory == (char)-1) && PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 68, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 68, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) __PYX_ERR(1, 68, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self), __pyx_v_name, __pyx_v_value, __pyx_v_mandatory);
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_8blob_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = -1;
-  __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static int __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value, char __pyx_v_mandatory) {
-  char *__pyx_v__name;
-  char *__pyx_v__value;
-  unsigned long __pyx_v_name_len;
-  unsigned long __pyx_v_value_len;
-  int __pyx_r;
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_8blob_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  char *__pyx_t_1;
-  Py_ssize_t __pyx_t_2;
-  libssh2_publickey_attribute __pyx_t_3;
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/publickey.pyx":69
+  /* "ssh2/publickey.pyx":57
+ *     @property
+ *     def blob_len(self):
+ *         return self.attr.blob_len             # <<<<<<<<<<<<<<
  * 
- *     def __cinit__(self, bytes name, bytes value, char mandatory):
- *         cdef char *_name = name             # <<<<<<<<<<<<<<
- *         cdef char *_value = value
- *         cdef unsigned long name_len = len(name)
- */
-  if (unlikely(__pyx_v_name == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 69, __pyx_L1_error)
-  }
-  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(1, 69, __pyx_L1_error)
-  __pyx_v__name = __pyx_t_1;
-
-  /* "ssh2/publickey.pyx":70
- *     def __cinit__(self, bytes name, bytes value, char mandatory):
- *         cdef char *_name = name
- *         cdef char *_value = value             # <<<<<<<<<<<<<<
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long value_len = len(value)
+ *     @property
  */
-  if (unlikely(__pyx_v_value == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 70, __pyx_L1_error)
-  }
-  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_value); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(1, 70, __pyx_L1_error)
-  __pyx_v__value = __pyx_t_1;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_blob_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":71
- *         cdef char *_name = name
- *         cdef char *_value = value
- *         cdef unsigned long name_len = len(name)             # <<<<<<<<<<<<<<
- *         cdef unsigned long value_len = len(value)
- *         self.attr = c_pkey.libssh2_publickey_attribute(
+  /* "ssh2/publickey.pyx":55
+ *         return self.attr.blob
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def blob_len(self):
+ *         return self.attr.blob_len
  */
-  if (unlikely(__pyx_v_name == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 71, __pyx_L1_error)
-  }
-  __pyx_t_2 = PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 71, __pyx_L1_error)
-  __pyx_v_name_len = __pyx_t_2;
 
-  /* "ssh2/publickey.pyx":72
- *         cdef char *_value = value
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long value_len = len(value)             # <<<<<<<<<<<<<<
- *         self.attr = c_pkey.libssh2_publickey_attribute(
- *             _name, name_len, _value, value_len, mandatory)
- */
-  if (unlikely(__pyx_v_value == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 72, __pyx_L1_error)
-  }
-  __pyx_t_2 = PyBytes_GET_SIZE(__pyx_v_value); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 72, __pyx_L1_error)
-  __pyx_v_value_len = __pyx_t_2;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.blob_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  /* "ssh2/publickey.pyx":74
- *         cdef unsigned long value_len = len(value)
- *         self.attr = c_pkey.libssh2_publickey_attribute(
- *             _name, name_len, _value, value_len, mandatory)             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __pyx_t_3.name = __pyx_v__name;
-  __pyx_t_3.name_len = __pyx_v_name_len;
-  __pyx_t_3.value = __pyx_v__value;
-  __pyx_t_3.value_len = __pyx_v_value_len;
-  __pyx_t_3.mandatory = __pyx_v_mandatory;
-
-  /* "ssh2/publickey.pyx":73
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long value_len = len(value)
- *         self.attr = c_pkey.libssh2_publickey_attribute(             # <<<<<<<<<<<<<<
- *             _name, name_len, _value, value_len, mandatory)
- * 
- */
-  __pyx_v_self->attr = __pyx_t_3;
-
-  /* "ssh2/publickey.pyx":68
- *     cdef c_pkey.libssh2_publickey_attribute attr
- * 
- *     def __cinit__(self, bytes name, bytes value, char mandatory):             # <<<<<<<<<<<<<<
- *         cdef char *_name = name
- *         cdef char *_value = value
- */
-
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "ssh2/publickey.pyx":77
- * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name
+/* "ssh2/publickey.pyx":59
+ *         return self.attr.blob_len
  * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def num_attrs(self):
+ *         return self.attr.num_attrs
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4name___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4name___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_9num_attrs___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/publickey.pyx":78
+  /* "ssh2/publickey.pyx":61
  *     @property
- *     def name(self):
- *         return self.attr.name             # <<<<<<<<<<<<<<
+ *     def num_attrs(self):
+ *         return self.attr.num_attrs             # <<<<<<<<<<<<<<
+ * 
  * 
- *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->attr.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 78, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 61, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_num_attrs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":77
- * 
- *     @property
- *     def name(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name
+  /* "ssh2/publickey.pyx":59
+ *         return self.attr.blob_len
  * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def num_attrs(self):
+ *         return self.attr.num_attrs
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.num_attrs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2526,894 +4233,1208 @@ static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4name___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":81
- * 
- *     @property
- *     def name_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name_len
- * 
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__, "PublicKeyList.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_8name_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_8name_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
-  /* "ssh2/publickey.pyx":82
- *     @property
- *     def name_len(self):
- *         return self.attr.name_len             # <<<<<<<<<<<<<<
- * 
- *     @property
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->attr.name_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(0, 2, __pyx_L1_error)
 
-  /* "ssh2/publickey.pyx":81
- * 
- *     @property
- *     def name_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.name_len
- * 
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.name_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":85
- * 
- *     @property
- *     def value(self):             # <<<<<<<<<<<<<<
- *         return self.attr.value
- * 
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_5value___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_5value___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__, "PublicKeyList.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
-
-  /* "ssh2/publickey.pyx":86
- *     @property
- *     def value(self):
- *         return self.attr.value             # <<<<<<<<<<<<<<
- * 
- *     @property
- */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->attr.value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 86, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-  /* "ssh2/publickey.pyx":85
- * 
- *     @property
- *     def value(self):             # <<<<<<<<<<<<<<
- *         return self.attr.value
- * 
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.value.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-/* "ssh2/publickey.pyx":89
- * 
- *     @property
- *     def value_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.value_len
- * 
- */
-
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(PyObject *__pyx_v_self) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9value_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9value_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyList *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
-  /* "ssh2/publickey.pyx":90
- *     @property
- *     def value_len(self):
- *         return self.attr.value_len             # <<<<<<<<<<<<<<
- * 
- *     @property
+  /* "(tree fragment)":4
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->attr.value_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(0, 4, __pyx_L1_error)
 
-  /* "ssh2/publickey.pyx":89
- * 
- *     @property
- *     def value_len(self):             # <<<<<<<<<<<<<<
- *         return self.attr.value_len
- * 
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.value_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyList.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":93
- * 
- *     @property
- *     def mandatory(self):             # <<<<<<<<<<<<<<
- *         return self.attr.mandatory
+/* "ssh2/publickey.pyx":68
+ *     cdef c_pkey.libssh2_publickey_attribute attr
  * 
+ *     def __cinit__(self, bytes name, bytes value, char mandatory):             # <<<<<<<<<<<<<<
+ *         cdef char *_name = name
+ *         cdef char *_value = value
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(PyObject *__pyx_v_self); /*proto*/
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
+static int __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_value = 0;
+  char __pyx_v_mandatory;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9mandatory___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_mandatory,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(1, 68, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mandatory)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(1, 68, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 68, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+      values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1);
+      values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2);
+    }
+    __pyx_v_name = ((PyObject*)values[0]);
+    __pyx_v_value = ((PyObject*)values[1]);
+    __pyx_v_mandatory = __Pyx_PyInt_As_char(values[2]); if (unlikely((__pyx_v_mandatory == (char)-1) && PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L3_error)
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 68, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 68, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) __PYX_ERR(1, 68, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self), __pyx_v_name, __pyx_v_value, __pyx_v_mandatory);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9mandatory___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+static int __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value, char __pyx_v_mandatory) {
+  char *__pyx_v__name;
+  char *__pyx_v__value;
+  unsigned long __pyx_v_name_len;
+  unsigned long __pyx_v_value_len;
+  int __pyx_r;
+  char *__pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  libssh2_publickey_attribute __pyx_t_3;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
 
-  /* "ssh2/publickey.pyx":94
- *     @property
- *     def mandatory(self):
- *         return self.attr.mandatory             # <<<<<<<<<<<<<<
- * 
+  /* "ssh2/publickey.pyx":69
  * 
+ *     def __cinit__(self, bytes name, bytes value, char mandatory):
+ *         cdef char *_name = name             # <<<<<<<<<<<<<<
+ *         cdef char *_value = value
+ *         cdef unsigned long name_len = len(name)
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_char(__pyx_v_self->attr.mandatory); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+  if (unlikely(__pyx_v_name == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+    __PYX_ERR(1, 69, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_name); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(1, 69, __pyx_L1_error)
+  __pyx_v__name = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":70
+ *     def __cinit__(self, bytes name, bytes value, char mandatory):
+ *         cdef char *_name = name
+ *         cdef char *_value = value             # <<<<<<<<<<<<<<
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long value_len = len(value)
+ */
+  if (unlikely(__pyx_v_value == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+    __PYX_ERR(1, 70, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyBytes_AsWritableString(__pyx_v_value); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(1, 70, __pyx_L1_error)
+  __pyx_v__value = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":71
+ *         cdef char *_name = name
+ *         cdef char *_value = value
+ *         cdef unsigned long name_len = len(name)             # <<<<<<<<<<<<<<
+ *         cdef unsigned long value_len = len(value)
+ *         self.attr = c_pkey.libssh2_publickey_attribute(
+ */
+  if (unlikely(__pyx_v_name == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 71, __pyx_L1_error)
+  }
+  __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 71, __pyx_L1_error)
+  __pyx_v_name_len = __pyx_t_2;
+
+  /* "ssh2/publickey.pyx":72
+ *         cdef char *_value = value
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long value_len = len(value)             # <<<<<<<<<<<<<<
+ *         self.attr = c_pkey.libssh2_publickey_attribute(
+ *             _name, name_len, _value, value_len, mandatory)
+ */
+  if (unlikely(__pyx_v_value == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 72, __pyx_L1_error)
+  }
+  __pyx_t_2 = __Pyx_PyBytes_GET_SIZE(__pyx_v_value); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 72, __pyx_L1_error)
+  __pyx_v_value_len = __pyx_t_2;
 
-  /* "ssh2/publickey.pyx":93
+  /* "ssh2/publickey.pyx":74
+ *         cdef unsigned long value_len = len(value)
+ *         self.attr = c_pkey.libssh2_publickey_attribute(
+ *             _name, name_len, _value, value_len, mandatory)             # <<<<<<<<<<<<<<
  * 
  *     @property
- *     def mandatory(self):             # <<<<<<<<<<<<<<
- *         return self.attr.mandatory
+ */
+  __pyx_t_3.name = __pyx_v__name;
+  __pyx_t_3.name_len = __pyx_v_name_len;
+  __pyx_t_3.value = __pyx_v__value;
+  __pyx_t_3.value_len = __pyx_v_value_len;
+  __pyx_t_3.mandatory = __pyx_v_mandatory;
+
+  /* "ssh2/publickey.pyx":73
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long value_len = len(value)
+ *         self.attr = c_pkey.libssh2_publickey_attribute(             # <<<<<<<<<<<<<<
+ *             _name, name_len, _value, value_len, mandatory)
+ * 
+ */
+  __pyx_v_self->attr = __pyx_t_3;
+
+  /* "ssh2/publickey.pyx":68
+ *     cdef c_pkey.libssh2_publickey_attribute attr
  * 
+ *     def __cinit__(self, bytes name, bytes value, char mandatory):             # <<<<<<<<<<<<<<
+ *         cdef char *_name = name
+ *         cdef char *_value = value
  */
 
   /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.mandatory.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+/* "ssh2/publickey.pyx":76
+ *             _name, name_len, _value, value_len, mandatory)
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
+ *         return self.attr.name
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__[] = "PublicKeyAttribute.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4name___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4name___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/publickey.pyx":78
+ *     @property
+ *     def name(self):
+ *         return self.attr.name             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->attr.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 78, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(0, 2, __pyx_L1_error)
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+  /* "ssh2/publickey.pyx":76
+ *             _name, name_len, _value, value_len, mandatory)
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name(self):
+ *         return self.attr.name
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
+  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+/* "ssh2/publickey.pyx":80
+ *         return self.attr.name
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name_len(self):
+ *         return self.attr.name_len
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__[] = "PublicKeyAttribute.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_8name_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_8name_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":82
+ *     @property
+ *     def name_len(self):
+ *         return self.attr.name_len             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->attr.name_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 82, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(0, 4, __pyx_L1_error)
-
-  /* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  /* function exit code */
+  /* "ssh2/publickey.pyx":80
+ *         return self.attr.name
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def name_len(self):
+ *         return self.attr.name_len
+ */
+
+  /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.name_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
+  __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":97
- * 
+/* "ssh2/publickey.pyx":84
+ *         return self.attr.name_len
  * 
- * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):             # <<<<<<<<<<<<<<
- *     cdef c_pkey.libssh2_publickey_attribute *_attrs
- *     cdef size_t size = len(attrs)
+ *     @property             # <<<<<<<<<<<<<<
+ *     def value(self):
+ *         return self.attr.value
  */
 
-static libssh2_publickey_attribute *__pyx_f_4ssh2_9publickey_to_c_attr(PyObject *__pyx_v_attrs) {
-  libssh2_publickey_attribute *__pyx_v__attrs;
-  size_t __pyx_v_size;
-  libssh2_publickey_attribute __pyx_v_attr;
-  size_t __pyx_v_i;
-  libssh2_publickey_attribute *__pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  size_t __pyx_t_3;
-  size_t __pyx_t_4;
-  size_t __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  libssh2_publickey_attribute __pyx_t_7;
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_5value___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_5value___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("to_c_attr", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/publickey.pyx":99
- * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):
- *     cdef c_pkey.libssh2_publickey_attribute *_attrs
- *     cdef size_t size = len(attrs)             # <<<<<<<<<<<<<<
- *     cdef c_pkey.libssh2_publickey_attribute attr
- *     with nogil:
+  /* "ssh2/publickey.pyx":86
+ *     @property
+ *     def value(self):
+ *         return self.attr.value             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-  if (unlikely(__pyx_v_attrs == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 99, __pyx_L1_error)
-  }
-  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_attrs); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 99, __pyx_L1_error)
-  __pyx_v_size = __pyx_t_1;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->attr.value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":101
- *     cdef size_t size = len(attrs)
- *     cdef c_pkey.libssh2_publickey_attribute attr
- *     with nogil:             # <<<<<<<<<<<<<<
- *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+  /* "ssh2/publickey.pyx":84
+ *         return self.attr.name_len
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def value(self):
+ *         return self.attr.value
  */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
 
-        /* "ssh2/publickey.pyx":102
- *     cdef c_pkey.libssh2_publickey_attribute attr
- *     with nogil:
- *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(             # <<<<<<<<<<<<<<
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
- *         if _attrs is NULL:
- */
-        __pyx_v__attrs = ((libssh2_publickey_attribute *)malloc(((__pyx_v_size + 1) * (sizeof(libssh2_publickey_attribute)))));
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.value.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-        /* "ssh2/publickey.pyx":104
- *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
- *         if _attrs is NULL:             # <<<<<<<<<<<<<<
- *             with gil:
- *                 raise MemoryError
+/* "ssh2/publickey.pyx":88
+ *         return self.attr.value
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def value_len(self):
+ *         return self.attr.value_len
  */
-        __pyx_t_2 = ((__pyx_v__attrs == NULL) != 0);
-        if (__pyx_t_2) {
 
-          /* "ssh2/publickey.pyx":105
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
- *         if _attrs is NULL:
- *             with gil:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- *     for i in range(size):
- */
-          {
-              #ifdef WITH_THREAD
-              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
-              #endif
-              /*try:*/ {
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9value_len___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
 
-                /* "ssh2/publickey.pyx":106
- *         if _attrs is NULL:
- *             with gil:
- *                 raise MemoryError             # <<<<<<<<<<<<<<
- *     for i in range(size):
- *         attr = attrs[i].attr
- */
-                PyErr_NoMemory(); __PYX_ERR(1, 106, __pyx_L8_error)
-              }
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-              /* "ssh2/publickey.pyx":105
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
- *         if _attrs is NULL:
- *             with gil:             # <<<<<<<<<<<<<<
- *                 raise MemoryError
- *     for i in range(size):
- */
-              /*finally:*/ {
-                __pyx_L8_error: {
-                  #ifdef WITH_THREAD
-                  __Pyx_PyGILState_Release(__pyx_gilstate_save);
-                  #endif
-                  goto __pyx_L4_error;
-                }
-              }
-          }
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9value_len___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-          /* "ssh2/publickey.pyx":104
- *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
- *         if _attrs is NULL:             # <<<<<<<<<<<<<<
- *             with gil:
- *                 raise MemoryError
+  /* "ssh2/publickey.pyx":90
+ *     @property
+ *     def value_len(self):
+ *         return self.attr.value_len             # <<<<<<<<<<<<<<
+ * 
+ *     @property
  */
-        }
-      }
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->attr.value_len); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-      /* "ssh2/publickey.pyx":101
- *     cdef size_t size = len(attrs)
- *     cdef c_pkey.libssh2_publickey_attribute attr
- *     with nogil:             # <<<<<<<<<<<<<<
- *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
- *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+  /* "ssh2/publickey.pyx":88
+ *         return self.attr.value
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def value_len(self):
+ *         return self.attr.value_len
  */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L5;
-        }
-        __pyx_L4_error: {
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L1_error;
-        }
-        __pyx_L5:;
-      }
-  }
 
-  /* "ssh2/publickey.pyx":107
- *             with gil:
- *                 raise MemoryError
- *     for i in range(size):             # <<<<<<<<<<<<<<
- *         attr = attrs[i].attr
- *         with nogil:
- */
-  __pyx_t_3 = __pyx_v_size;
-  __pyx_t_4 = __pyx_t_3;
-  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-    __pyx_v_i = __pyx_t_5;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.value_len.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    /* "ssh2/publickey.pyx":108
- *                 raise MemoryError
- *     for i in range(size):
- *         attr = attrs[i].attr             # <<<<<<<<<<<<<<
- *         with nogil:
- *             _attrs[i] = attr
+/* "ssh2/publickey.pyx":92
+ *         return self.attr.value_len
+ * 
+ *     @property             # <<<<<<<<<<<<<<
+ *     def mandatory(self):
+ *         return self.attr.mandatory
  */
-    if (unlikely(__pyx_v_attrs == Py_None)) {
-      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(1, 108, __pyx_L1_error)
-    }
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(PyList_GET_ITEM(__pyx_v_attrs, __pyx_v_i), __pyx_n_s_attr); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 108, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_7 = __pyx_convert__from_py_libssh2_publickey_attribute(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __pyx_v_attr = __pyx_t_7;
 
-    /* "ssh2/publickey.pyx":109
- *     for i in range(size):
- *         attr = attrs[i].attr
- *         with nogil:             # <<<<<<<<<<<<<<
- *             _attrs[i] = attr
- *     return _attrs
- */
-    {
-        #ifdef WITH_THREAD
-        PyThreadState *_save;
-        Py_UNBLOCK_THREADS
-        __Pyx_FastGIL_Remember();
-        #endif
-        /*try:*/ {
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9mandatory___get__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
 
-          /* "ssh2/publickey.pyx":110
- *         attr = attrs[i].attr
- *         with nogil:
- *             _attrs[i] = attr             # <<<<<<<<<<<<<<
- *     return _attrs
- * 
- */
-          (__pyx_v__attrs[__pyx_v_i]) = __pyx_v_attr;
-        }
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-        /* "ssh2/publickey.pyx":109
- *     for i in range(size):
- *         attr = attrs[i].attr
- *         with nogil:             # <<<<<<<<<<<<<<
- *             _attrs[i] = attr
- *     return _attrs
- */
-        /*finally:*/ {
-          /*normal exit:*/{
-            #ifdef WITH_THREAD
-            __Pyx_FastGIL_Forget();
-            Py_BLOCK_THREADS
-            #endif
-            goto __pyx_L16;
-          }
-          __pyx_L16:;
-        }
-    }
-  }
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_9mandatory___get__(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/publickey.pyx":111
- *         with nogil:
- *             _attrs[i] = attr
- *     return _attrs             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":94
+ *     @property
+ *     def mandatory(self):
+ *         return self.attr.mandatory             # <<<<<<<<<<<<<<
  * 
  * 
  */
-  __pyx_r = __pyx_v__attrs;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_char(__pyx_v_self->attr.mandatory); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":97
- * 
+  /* "ssh2/publickey.pyx":92
+ *         return self.attr.value_len
  * 
- * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):             # <<<<<<<<<<<<<<
- *     cdef c_pkey.libssh2_publickey_attribute *_attrs
- *     cdef size_t size = len(attrs)
+ *     @property             # <<<<<<<<<<<<<<
+ *     def mandatory(self):
+ *         return self.attr.mandatory
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_WriteUnraisable("ssh2.publickey.to_c_attr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.mandatory.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":114
- * 
- * 
- * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,             # <<<<<<<<<<<<<<
- *                               Session session):
- *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
  */
 
-static PyObject *__pyx_f_4ssh2_9publickey_PyPublicKeySystem(LIBSSH2_PUBLICKEY *__pyx_v__pkey_s, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__, "PublicKeyAttribute.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PyPublicKeySystem", 0);
-
-  /* "ssh2/publickey.pyx":116
- * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,
- *                               Session session):
- *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(             # <<<<<<<<<<<<<<
- *         PublicKeySystem, session)
- *     pkey_s.pkey_s = _pkey_s
- */
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 116, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
-  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_9publickey_PublicKeySystem(((PyTypeObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 116, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  /* "ssh2/publickey.pyx":118
- *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
- *         PublicKeySystem, session)
- *     pkey_s.pkey_s = _pkey_s             # <<<<<<<<<<<<<<
- *     return pkey_s
- * 
- */
-  __pyx_v_pkey_s->pkey_s = __pyx_v__pkey_s;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
-  /* "ssh2/publickey.pyx":119
- *         PublicKeySystem, session)
- *     pkey_s.pkey_s = _pkey_s
- *     return pkey_s             # <<<<<<<<<<<<<<
- * 
- * 
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_pkey_s));
-  __pyx_r = ((PyObject *)__pyx_v_pkey_s);
-  goto __pyx_L0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(0, 2, __pyx_L1_error)
 
-  /* "ssh2/publickey.pyx":114
- * 
- * 
- * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,             # <<<<<<<<<<<<<<
- *                               Session session):
- *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("ssh2.publickey.PyPublicKeySystem", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_pkey_s);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":129
- *     cdef Session session
- * 
- *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
- *         self.pkey_s = NULL
- *         self.session = session
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static int __pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__, "PublicKeyAttribute.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  int __pyx_r;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 129, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
     }
-    __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
+    __pyx_v___pyx_state = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 129, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
-  return -1;
+  return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(1, 129, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_session);
+  __pyx_r = __pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = -1;
-  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static int __pyx_pf_4ssh2_9publickey_15PublicKeySystem___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
-  int __pyx_r;
+static PyObject *__pyx_pf_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__", 0);
-
-  /* "ssh2/publickey.pyx":130
- * 
- *     def __cinit__(self, Session session):
- *         self.pkey_s = NULL             # <<<<<<<<<<<<<<
- *         self.session = session
- * 
- */
-  __pyx_v_self->pkey_s = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
-  /* "ssh2/publickey.pyx":131
- *     def __cinit__(self, Session session):
- *         self.pkey_s = NULL
- *         self.session = session             # <<<<<<<<<<<<<<
- * 
- *     def __dealloc__(self):
+  /* "(tree fragment)":4
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  __Pyx_GOTREF(__pyx_v_self->session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->session));
-  __pyx_v_self->session = __pyx_v_session;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(0, 4, __pyx_L1_error)
 
-  /* "ssh2/publickey.pyx":129
- *     cdef Session session
- * 
- *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
- *         self.pkey_s = NULL
- *         self.session = session
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeyAttribute.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":133
- *         self.session = session
+/* "ssh2/publickey.pyx":97
  * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
- *             with nogil:
+ * 
+ * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):             # <<<<<<<<<<<<<<
+ *     cdef c_pkey.libssh2_publickey_attribute *_attrs
+ *     cdef size_t size = len(attrs)
  */
 
-/* Python wrapper */
-static void __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
-static void __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(PyObject *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
-  __pyx_pf_4ssh2_9publickey_15PublicKeySystem_2__dealloc__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-static void __pyx_pf_4ssh2_9publickey_15PublicKeySystem_2__dealloc__(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
+static libssh2_publickey_attribute *__pyx_f_4ssh2_9publickey_to_c_attr(PyObject *__pyx_v_attrs) {
+  libssh2_publickey_attribute *__pyx_v__attrs;
+  size_t __pyx_v_size;
+  libssh2_publickey_attribute __pyx_v_attr;
+  size_t __pyx_v_i;
+  libssh2_publickey_attribute *__pyx_r;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
+  Py_ssize_t __pyx_t_1;
   int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
+  size_t __pyx_t_3;
+  size_t __pyx_t_4;
+  size_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  libssh2_publickey_attribute __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("to_c_attr", 1);
 
-  /* "ssh2/publickey.pyx":134
- * 
- *     def __dealloc__(self):
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:             # <<<<<<<<<<<<<<
- *             with nogil:
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
+  /* "ssh2/publickey.pyx":99
+ * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):
+ *     cdef c_pkey.libssh2_publickey_attribute *_attrs
+ *     cdef size_t size = len(attrs)             # <<<<<<<<<<<<<<
+ *     cdef c_pkey.libssh2_publickey_attribute attr
+ *     with nogil:
  */
-  __pyx_t_2 = (((PyObject *)__pyx_v_self->session) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
-  } else {
-    __pyx_t_1 = __pyx_t_3;
-    goto __pyx_L4_bool_binop_done;
+  if (unlikely(__pyx_v_attrs == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 99, __pyx_L1_error)
   }
-  __pyx_t_3 = ((__pyx_v_self->session->_session != NULL) != 0);
-  if (__pyx_t_3) {
-  } else {
-    __pyx_t_1 = __pyx_t_3;
-    goto __pyx_L4_bool_binop_done;
+  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_attrs); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 99, __pyx_L1_error)
+  __pyx_v_size = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":101
+ *     cdef size_t size = len(attrs)
+ *     cdef c_pkey.libssh2_publickey_attribute attr
+ *     with nogil:             # <<<<<<<<<<<<<<
+ *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      _save = NULL;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+
+        /* "ssh2/publickey.pyx":102
+ *     cdef c_pkey.libssh2_publickey_attribute attr
+ *     with nogil:
+ *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(             # <<<<<<<<<<<<<<
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ *         if _attrs is NULL:
+ */
+        __pyx_v__attrs = ((libssh2_publickey_attribute *)malloc(((__pyx_v_size + 1) * (sizeof(libssh2_publickey_attribute)))));
+
+        /* "ssh2/publickey.pyx":104
+ *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ *         if _attrs is NULL:             # <<<<<<<<<<<<<<
+ *             with gil:
+ *                 raise MemoryError
+ */
+        __pyx_t_2 = (__pyx_v__attrs == NULL);
+        if (unlikely(__pyx_t_2)) {
+
+          /* "ssh2/publickey.pyx":105
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ *         if _attrs is NULL:
+ *             with gil:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ *     for i in range(size):
+ */
+          {
+              #ifdef WITH_THREAD
+              PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
+              #endif
+              /*try:*/ {
+
+                /* "ssh2/publickey.pyx":106
+ *         if _attrs is NULL:
+ *             with gil:
+ *                 raise MemoryError             # <<<<<<<<<<<<<<
+ *     for i in range(size):
+ *         attr = attrs[i].attr
+ */
+                PyErr_NoMemory(); __PYX_ERR(1, 106, __pyx_L8_error)
+              }
+
+              /* "ssh2/publickey.pyx":105
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ *         if _attrs is NULL:
+ *             with gil:             # <<<<<<<<<<<<<<
+ *                 raise MemoryError
+ *     for i in range(size):
+ */
+              /*finally:*/ {
+                __pyx_L8_error: {
+                  #ifdef WITH_THREAD
+                  __Pyx_PyGILState_Release(__pyx_gilstate_save);
+                  #endif
+                  goto __pyx_L4_error;
+                }
+              }
+          }
+
+          /* "ssh2/publickey.pyx":104
+ *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ *         if _attrs is NULL:             # <<<<<<<<<<<<<<
+ *             with gil:
+ *                 raise MemoryError
+ */
+        }
+      }
+
+      /* "ssh2/publickey.pyx":101
+ *     cdef size_t size = len(attrs)
+ *     cdef c_pkey.libssh2_publickey_attribute attr
+ *     with nogil:             # <<<<<<<<<<<<<<
+ *         _attrs = <c_pkey.libssh2_publickey_attribute *>malloc(
+ *             (size + 1) * sizeof(c_pkey.libssh2_publickey_attribute))
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
   }
-  __pyx_t_3 = ((__pyx_v_self->pkey_s != NULL) != 0);
-  __pyx_t_1 = __pyx_t_3;
-  __pyx_L4_bool_binop_done:;
-  if (__pyx_t_1) {
 
-    /* "ssh2/publickey.pyx":135
- *     def __dealloc__(self):
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
- *             with nogil:             # <<<<<<<<<<<<<<
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
- *         self.pkey_s = NULL
+  /* "ssh2/publickey.pyx":107
+ *             with gil:
+ *                 raise MemoryError
+ *     for i in range(size):             # <<<<<<<<<<<<<<
+ *         attr = attrs[i].attr
+ *         with nogil:
+ */
+  __pyx_t_3 = __pyx_v_size;
+  __pyx_t_4 = __pyx_t_3;
+  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+    __pyx_v_i = __pyx_t_5;
+
+    /* "ssh2/publickey.pyx":108
+ *                 raise MemoryError
+ *     for i in range(size):
+ *         attr = attrs[i].attr             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             _attrs[i] = attr
+ */
+    if (unlikely(__pyx_v_attrs == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(1, 108, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(PyList_GET_ITEM(__pyx_v_attrs, __pyx_v_i), __pyx_n_s_attr); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 108, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __pyx_convert__from_py_libssh2_publickey_attribute(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_v_attr = __pyx_t_7;
+
+    /* "ssh2/publickey.pyx":109
+ *     for i in range(size):
+ *         attr = attrs[i].attr
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             _attrs[i] = attr
+ *     return _attrs
  */
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
         /*try:*/ {
 
-          /* "ssh2/publickey.pyx":136
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
- *             with nogil:
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)             # <<<<<<<<<<<<<<
- *         self.pkey_s = NULL
+          /* "ssh2/publickey.pyx":110
+ *         attr = attrs[i].attr
+ *         with nogil:
+ *             _attrs[i] = attr             # <<<<<<<<<<<<<<
+ *     return _attrs
  * 
  */
-          (void)(libssh2_publickey_shutdown(__pyx_v_self->pkey_s));
+          (__pyx_v__attrs[__pyx_v_i]) = __pyx_v_attr;
         }
 
-        /* "ssh2/publickey.pyx":135
- *     def __dealloc__(self):
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
- *             with nogil:             # <<<<<<<<<<<<<<
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
- *         self.pkey_s = NULL
+        /* "ssh2/publickey.pyx":109
+ *     for i in range(size):
+ *         attr = attrs[i].attr
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             _attrs[i] = attr
+ *     return _attrs
  */
         /*finally:*/ {
           /*normal exit:*/{
@@ -3421,562 +5442,723 @@ static void __pyx_pf_4ssh2_9publickey_15PublicKeySystem_2__dealloc__(struct __py
             __Pyx_FastGIL_Forget();
             Py_BLOCK_THREADS
             #endif
-            goto __pyx_L9;
+            goto __pyx_L16;
           }
-          __pyx_L9:;
+          __pyx_L16:;
         }
     }
+  }
 
-    /* "ssh2/publickey.pyx":134
+  /* "ssh2/publickey.pyx":111
+ *         with nogil:
+ *             _attrs[i] = attr
+ *     return _attrs             # <<<<<<<<<<<<<<
+ * 
  * 
- *     def __dealloc__(self):
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:             # <<<<<<<<<<<<<<
- *             with nogil:
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
  */
-  }
+  __pyx_r = __pyx_v__attrs;
+  goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":137
- *             with nogil:
- *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
- *         self.pkey_s = NULL             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":97
  * 
- *     def add(self, bytes name, bytes blob,
+ * 
+ * cdef c_pkey.libssh2_publickey_attribute * to_c_attr(list attrs):             # <<<<<<<<<<<<<<
+ *     cdef c_pkey.libssh2_publickey_attribute *_attrs
+ *     cdef size_t size = len(attrs)
  */
-  __pyx_v_self->pkey_s = NULL;
 
-  /* "ssh2/publickey.pyx":133
- *         self.session = session
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("ssh2.publickey.to_c_attr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "ssh2/publickey.pyx":114
  * 
- *     def __dealloc__(self):             # <<<<<<<<<<<<<<
- *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
- *             with nogil:
+ * 
+ * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,             # <<<<<<<<<<<<<<
+ *                               Session session):
+ *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
+ */
+
+static PyObject *__pyx_f_4ssh2_9publickey_PyPublicKeySystem(LIBSSH2_PUBLICKEY *__pyx_v__pkey_s, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_pkey_s = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyPublicKeySystem", 1);
+
+  /* "ssh2/publickey.pyx":116
+ * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,
+ *                               Session session):
+ *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(             # <<<<<<<<<<<<<<
+ *         PublicKeySystem, session)
+ *     pkey_s.pkey_s = _pkey_s
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(1, 116, __pyx_L1_error);
+  __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_9publickey_PublicKeySystem(((PyTypeObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 116, __pyx_L1_error)
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "ssh2/publickey.pyx":118
+ *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
+ *         PublicKeySystem, session)
+ *     pkey_s.pkey_s = _pkey_s             # <<<<<<<<<<<<<<
+ *     return pkey_s
+ * 
+ */
+  __pyx_v_pkey_s->pkey_s = __pyx_v__pkey_s;
+
+  /* "ssh2/publickey.pyx":119
+ *         PublicKeySystem, session)
+ *     pkey_s.pkey_s = _pkey_s
+ *     return pkey_s             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_pkey_s);
+  __pyx_r = ((PyObject *)__pyx_v_pkey_s);
+  goto __pyx_L0;
+
+  /* "ssh2/publickey.pyx":114
+ * 
+ * 
+ * cdef object PyPublicKeySystem(c_pkey.LIBSSH2_PUBLICKEY *_pkey_s,             # <<<<<<<<<<<<<<
+ *                               Session session):
+ *     cdef PublicKeySystem pkey_s = PublicKeySystem.__new__(
  */
 
   /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("ssh2.publickey.PyPublicKeySystem", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pkey_s);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":139
- *         self.pkey_s = NULL
+/* "ssh2/publickey.pyx":129
+ *     cdef Session session
  * 
- *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
- *             char overwrite,
- *             list attrs):
+ *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
+ *         self.pkey_s = NULL
+ *         self.session = session
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_4add[] = "PublicKeySystem.add(self, bytes name, bytes blob, char overwrite, list attrs)";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_name = 0;
-  PyObject *__pyx_v_blob = 0;
-  char __pyx_v_overwrite;
-  PyObject *__pyx_v_attrs = 0;
+static int __pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  PyObject *__pyx_r = 0;
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("add (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_blob,&__pyx_n_s_overwrite,&__pyx_n_s_attrs,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_blob)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 1); __PYX_ERR(1, 139, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_overwrite)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 2); __PYX_ERR(1, 139, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attrs)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 3); __PYX_ERR(1, 139, __pyx_L3_error)
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
         }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 129, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) __PYX_ERR(1, 139, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 129, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
-    __pyx_v_name = ((PyObject*)values[0]);
-    __pyx_v_blob = ((PyObject*)values[1]);
-    __pyx_v_overwrite = __Pyx_PyInt_As_char(values[2]); if (unlikely((__pyx_v_overwrite == (char)-1) && PyErr_Occurred())) __PYX_ERR(1, 140, __pyx_L3_error)
-    __pyx_v_attrs = ((PyObject*)values[3]);
+    __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 139, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 129, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.add", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
-  return NULL;
+  return -1;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 139, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_blob), (&PyBytes_Type), 1, "blob", 1))) __PYX_ERR(1, 139, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_attrs), (&PyList_Type), 1, "attrs", 1))) __PYX_ERR(1, 141, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_4add(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_name, __pyx_v_blob, __pyx_v_overwrite, __pyx_v_attrs);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_session), __pyx_ptype_4ssh2_7session_Session, 1, "session", 0))) __PYX_ERR(1, 129, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem___cinit__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_session);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
-  __pyx_r = NULL;
+  __pyx_r = -1;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_4add(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_blob, char __pyx_v_overwrite, PyObject *__pyx_v_attrs) {
-  unsigned long __pyx_v_name_len;
-  unsigned long __pyx_v_num_attrs;
-  libssh2_publickey_attribute *__pyx_v__attrs;
-  unsigned char const *__pyx_v__name;
-  size_t __pyx_v_blob_len;
-  unsigned char const *__pyx_v__blob;
-  int __pyx_v_rc;
-  PyObject *__pyx_r = NULL;
+static int __pyx_pf_4ssh2_9publickey_15PublicKeySystem___cinit__(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session) {
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  Py_ssize_t __pyx_t_1;
-  int __pyx_t_2;
-  unsigned char const *__pyx_t_3;
-  unsigned char const *__pyx_t_4;
-  int __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("add", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
-  /* "ssh2/publickey.pyx":142
- *             char overwrite,
- *             list attrs):
- *         cdef unsigned long name_len = len(name)             # <<<<<<<<<<<<<<
- *         cdef unsigned long num_attrs = len(attrs)
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
+  /* "ssh2/publickey.pyx":130
+ * 
+ *     def __cinit__(self, Session session):
+ *         self.pkey_s = NULL             # <<<<<<<<<<<<<<
+ *         self.session = session
+ * 
  */
-  if (unlikely(__pyx_v_name == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 142, __pyx_L1_error)
-  }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 142, __pyx_L1_error)
-  __pyx_v_name_len = __pyx_t_1;
+  __pyx_v_self->pkey_s = NULL;
 
-  /* "ssh2/publickey.pyx":143
- *             list attrs):
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long num_attrs = len(attrs)             # <<<<<<<<<<<<<<
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
- *         if num_attrs > 0:
+  /* "ssh2/publickey.pyx":131
+ *     def __cinit__(self, Session session):
+ *         self.pkey_s = NULL
+ *         self.session = session             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
  */
-  if (unlikely(__pyx_v_attrs == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 143, __pyx_L1_error)
-  }
-  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_attrs); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 143, __pyx_L1_error)
-  __pyx_v_num_attrs = __pyx_t_1;
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->session);
+  __pyx_v_self->session = __pyx_v_session;
 
-  /* "ssh2/publickey.pyx":144
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long num_attrs = len(attrs)
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL             # <<<<<<<<<<<<<<
- *         if num_attrs > 0:
- *             _attrs = to_c_attr(attrs)
+  /* "ssh2/publickey.pyx":129
+ *     cdef Session session
+ * 
+ *     def __cinit__(self, Session session):             # <<<<<<<<<<<<<<
+ *         self.pkey_s = NULL
+ *         self.session = session
  */
-  __pyx_v__attrs = NULL;
 
-  /* "ssh2/publickey.pyx":145
- *         cdef unsigned long num_attrs = len(attrs)
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
- *         if num_attrs > 0:             # <<<<<<<<<<<<<<
- *             _attrs = to_c_attr(attrs)
- *         cdef const unsigned char *_name = name
- */
-  __pyx_t_2 = ((__pyx_v_num_attrs > 0) != 0);
-  if (__pyx_t_2) {
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    /* "ssh2/publickey.pyx":146
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
- *         if num_attrs > 0:
- *             _attrs = to_c_attr(attrs)             # <<<<<<<<<<<<<<
- *         cdef const unsigned char *_name = name
- *         cdef size_t blob_len = len(blob)
+/* "ssh2/publickey.pyx":133
+ *         self.session = session
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
+ *             with nogil:
  */
-    __pyx_v__attrs = __pyx_f_4ssh2_9publickey_to_c_attr(__pyx_v_attrs);
 
-    /* "ssh2/publickey.pyx":145
- *         cdef unsigned long num_attrs = len(attrs)
- *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
- *         if num_attrs > 0:             # <<<<<<<<<<<<<<
- *             _attrs = to_c_attr(attrs)
- *         cdef const unsigned char *_name = name
- */
-  }
+/* Python wrapper */
+static void __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_pf_4ssh2_9publickey_15PublicKeySystem_2__dealloc__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
 
-  /* "ssh2/publickey.pyx":147
- *         if num_attrs > 0:
- *             _attrs = to_c_attr(attrs)
- *         cdef const unsigned char *_name = name             # <<<<<<<<<<<<<<
- *         cdef size_t blob_len = len(blob)
- *         cdef const unsigned char *_blob = blob
- */
-  if (unlikely(__pyx_v_name == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 147, __pyx_L1_error)
-  }
-  __pyx_t_3 = __Pyx_PyBytes_AsUString(__pyx_v_name); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 147, __pyx_L1_error)
-  __pyx_v__name = __pyx_t_3;
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
 
-  /* "ssh2/publickey.pyx":148
- *             _attrs = to_c_attr(attrs)
- *         cdef const unsigned char *_name = name
- *         cdef size_t blob_len = len(blob)             # <<<<<<<<<<<<<<
- *         cdef const unsigned char *_blob = blob
- *         with nogil:
- */
-  if (unlikely(__pyx_v_blob == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 148, __pyx_L1_error)
-  }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_blob); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 148, __pyx_L1_error)
-  __pyx_v_blob_len = __pyx_t_1;
+static void __pyx_pf_4ssh2_9publickey_15PublicKeySystem_2__dealloc__(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
+  int __pyx_t_1;
+  int __pyx_t_2;
 
-  /* "ssh2/publickey.pyx":149
- *         cdef const unsigned char *_name = name
- *         cdef size_t blob_len = len(blob)
- *         cdef const unsigned char *_blob = blob             # <<<<<<<<<<<<<<
- *         with nogil:
- *             rc = c_pkey.libssh2_publickey_add_ex(
+  /* "ssh2/publickey.pyx":134
+ * 
+ *     def __dealloc__(self):
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:             # <<<<<<<<<<<<<<
+ *             with nogil:
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
  */
-  if (unlikely(__pyx_v_blob == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 149, __pyx_L1_error)
+  __pyx_t_2 = (((PyObject *)__pyx_v_self->session) != Py_None);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsUString(__pyx_v_blob); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error)
-  __pyx_v__blob = __pyx_t_4;
-
-  /* "ssh2/publickey.pyx":150
- *         cdef size_t blob_len = len(blob)
- *         cdef const unsigned char *_blob = blob
- *         with nogil:             # <<<<<<<<<<<<<<
- *             rc = c_pkey.libssh2_publickey_add_ex(
- *                 self.pkey_s, _name, name_len, _blob,
- */
-  {
-      #ifdef WITH_THREAD
-      PyThreadState *_save;
-      Py_UNBLOCK_THREADS
-      __Pyx_FastGIL_Remember();
-      #endif
-      /*try:*/ {
-
-        /* "ssh2/publickey.pyx":151
- *         cdef const unsigned char *_blob = blob
- *         with nogil:
- *             rc = c_pkey.libssh2_publickey_add_ex(             # <<<<<<<<<<<<<<
- *                 self.pkey_s, _name, name_len, _blob,
- *                 blob_len, overwrite, num_attrs, _attrs)
- */
-        __pyx_v_rc = libssh2_publickey_add_ex(__pyx_v_self->pkey_s, __pyx_v__name, __pyx_v_name_len, __pyx_v__blob, __pyx_v_blob_len, __pyx_v_overwrite, __pyx_v_num_attrs, __pyx_v__attrs);
+  __pyx_t_2 = (__pyx_v_self->session->_session != NULL);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_2 = (__pyx_v_self->pkey_s != NULL);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_1) {
 
-        /* "ssh2/publickey.pyx":154
- *                 self.pkey_s, _name, name_len, _blob,
- *                 blob_len, overwrite, num_attrs, _attrs)
- *             if _attrs is not NULL:             # <<<<<<<<<<<<<<
- *                 free(_attrs)
- *         return handle_error_codes(rc)
+    /* "ssh2/publickey.pyx":135
+ *     def __dealloc__(self):
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
+ *             with nogil:             # <<<<<<<<<<<<<<
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
+ *         self.pkey_s = NULL
  */
-        __pyx_t_2 = ((__pyx_v__attrs != NULL) != 0);
-        if (__pyx_t_2) {
+    {
+        #ifdef WITH_THREAD
+        PyThreadState *_save;
+        _save = NULL;
+        Py_UNBLOCK_THREADS
+        __Pyx_FastGIL_Remember();
+        #endif
+        /*try:*/ {
 
-          /* "ssh2/publickey.pyx":155
- *                 blob_len, overwrite, num_attrs, _attrs)
- *             if _attrs is not NULL:
- *                 free(_attrs)             # <<<<<<<<<<<<<<
- *         return handle_error_codes(rc)
+          /* "ssh2/publickey.pyx":136
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
+ *             with nogil:
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)             # <<<<<<<<<<<<<<
+ *         self.pkey_s = NULL
  * 
  */
-          free(__pyx_v__attrs);
+          (void)(libssh2_publickey_shutdown(__pyx_v_self->pkey_s));
+        }
 
-          /* "ssh2/publickey.pyx":154
- *                 self.pkey_s, _name, name_len, _blob,
- *                 blob_len, overwrite, num_attrs, _attrs)
- *             if _attrs is not NULL:             # <<<<<<<<<<<<<<
- *                 free(_attrs)
- *         return handle_error_codes(rc)
+        /* "ssh2/publickey.pyx":135
+ *     def __dealloc__(self):
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
+ *             with nogil:             # <<<<<<<<<<<<<<
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
+ *         self.pkey_s = NULL
  */
+        /*finally:*/ {
+          /*normal exit:*/{
+            #ifdef WITH_THREAD
+            __Pyx_FastGIL_Forget();
+            Py_BLOCK_THREADS
+            #endif
+            goto __pyx_L9;
+          }
+          __pyx_L9:;
         }
-      }
+    }
 
-      /* "ssh2/publickey.pyx":150
- *         cdef size_t blob_len = len(blob)
- *         cdef const unsigned char *_blob = blob
- *         with nogil:             # <<<<<<<<<<<<<<
- *             rc = c_pkey.libssh2_publickey_add_ex(
- *                 self.pkey_s, _name, name_len, _blob,
+    /* "ssh2/publickey.pyx":134
+ * 
+ *     def __dealloc__(self):
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:             # <<<<<<<<<<<<<<
+ *             with nogil:
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
  */
-      /*finally:*/ {
-        /*normal exit:*/{
-          #ifdef WITH_THREAD
-          __Pyx_FastGIL_Forget();
-          Py_BLOCK_THREADS
-          #endif
-          goto __pyx_L6;
-        }
-        __pyx_L6:;
-      }
   }
 
-  /* "ssh2/publickey.pyx":156
- *             if _attrs is not NULL:
- *                 free(_attrs)
- *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
+  /* "ssh2/publickey.pyx":137
+ *             with nogil:
+ *                 c_pkey.libssh2_publickey_shutdown(self.pkey_s)
+ *         self.pkey_s = NULL             # <<<<<<<<<<<<<<
  * 
- *     def remove(self, bytes name, bytes blob):
+ *     def add(self, bytes name, bytes blob,
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 156, __pyx_L1_error)
-  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 156, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_r = __pyx_t_6;
-  __pyx_t_6 = 0;
-  goto __pyx_L0;
+  __pyx_v_self->pkey_s = NULL;
 
-  /* "ssh2/publickey.pyx":139
- *         self.pkey_s = NULL
+  /* "ssh2/publickey.pyx":133
+ *         self.session = session
  * 
- *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
- *             char overwrite,
- *             list attrs):
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         if self.session is not None and self.session._session is not NULL and self.pkey_s is not NULL:
+ *             with nogil:
  */
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.add", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":158
- *         return handle_error_codes(rc)
+/* "ssh2/publickey.pyx":139
+ *         self.pkey_s = NULL
  * 
- *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long blob_len = len(blob)
+ *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
+ *             char overwrite,
+ *             list attrs):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_6remove[] = "PublicKeySystem.remove(self, bytes name, bytes blob)";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_4add, "PublicKeySystem.add(self, bytes name, bytes blob, char overwrite, list attrs)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_5add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_4add};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_name = 0;
   PyObject *__pyx_v_blob = 0;
+  char __pyx_v_overwrite;
+  PyObject *__pyx_v_attrs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("remove (wrapper)", 0);
+  __Pyx_RefNannySetupContext("add (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_blob,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_blob,&__pyx_n_s_overwrite,&__pyx_n_s_attrs,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_blob)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_blob)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, 1); __PYX_ERR(1, 158, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 1); __PYX_ERR(1, 139, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_overwrite)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 2); __PYX_ERR(1, 139, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_attrs)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 139, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 3); __PYX_ERR(1, 139, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "remove") < 0)) __PYX_ERR(1, 158, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(1, 139, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
     }
     __pyx_v_name = ((PyObject*)values[0]);
     __pyx_v_blob = ((PyObject*)values[1]);
+    __pyx_v_overwrite = __Pyx_PyInt_As_char(values[2]); if (unlikely((__pyx_v_overwrite == (char)-1) && PyErr_Occurred())) __PYX_ERR(1, 140, __pyx_L3_error)
+    __pyx_v_attrs = ((PyObject*)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 158, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, __pyx_nargs); __PYX_ERR(1, 139, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.add", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 158, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_blob), (&PyBytes_Type), 1, "blob", 1))) __PYX_ERR(1, 158, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_name, __pyx_v_blob);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 139, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_blob), (&PyBytes_Type), 1, "blob", 1))) __PYX_ERR(1, 139, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_attrs), (&PyList_Type), 1, "attrs", 1))) __PYX_ERR(1, 141, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_4add(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_name, __pyx_v_blob, __pyx_v_overwrite, __pyx_v_attrs);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_blob) {
+static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_4add(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_blob, char __pyx_v_overwrite, PyObject *__pyx_v_attrs) {
   unsigned long __pyx_v_name_len;
-  unsigned long __pyx_v_blob_len;
+  unsigned long __pyx_v_num_attrs;
+  libssh2_publickey_attribute *__pyx_v__attrs;
   unsigned char const *__pyx_v__name;
+  size_t __pyx_v_blob_len;
   unsigned char const *__pyx_v__blob;
   int __pyx_v_rc;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   Py_ssize_t __pyx_t_1;
-  unsigned char const *__pyx_t_2;
-  unsigned char const *__pyx_t_3;
-  int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_2;
+  libssh2_publickey_attribute *__pyx_t_3;
+  unsigned char const *__pyx_t_4;
+  unsigned char const *__pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("remove", 0);
+  __Pyx_RefNannySetupContext("add", 1);
 
-  /* "ssh2/publickey.pyx":159
- * 
- *     def remove(self, bytes name, bytes blob):
+  /* "ssh2/publickey.pyx":142
+ *             char overwrite,
+ *             list attrs):
  *         cdef unsigned long name_len = len(name)             # <<<<<<<<<<<<<<
- *         cdef unsigned long blob_len = len(blob)
- *         cdef const unsigned char *_name = name
+ *         cdef unsigned long num_attrs = len(attrs)
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
  */
   if (unlikely(__pyx_v_name == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 159, __pyx_L1_error)
+    __PYX_ERR(1, 142, __pyx_L1_error)
   }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 159, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 142, __pyx_L1_error)
   __pyx_v_name_len = __pyx_t_1;
 
-  /* "ssh2/publickey.pyx":160
- *     def remove(self, bytes name, bytes blob):
+  /* "ssh2/publickey.pyx":143
+ *             list attrs):
  *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long blob_len = len(blob)             # <<<<<<<<<<<<<<
- *         cdef const unsigned char *_name = name
- *         cdef const unsigned char *_blob = blob
+ *         cdef unsigned long num_attrs = len(attrs)             # <<<<<<<<<<<<<<
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
+ *         if num_attrs > 0:
  */
-  if (unlikely(__pyx_v_blob == Py_None)) {
+  if (unlikely(__pyx_v_attrs == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 160, __pyx_L1_error)
+    __PYX_ERR(1, 143, __pyx_L1_error)
   }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_blob); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 160, __pyx_L1_error)
-  __pyx_v_blob_len = __pyx_t_1;
+  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_attrs); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 143, __pyx_L1_error)
+  __pyx_v_num_attrs = __pyx_t_1;
 
-  /* "ssh2/publickey.pyx":161
+  /* "ssh2/publickey.pyx":144
  *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long blob_len = len(blob)
+ *         cdef unsigned long num_attrs = len(attrs)
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL             # <<<<<<<<<<<<<<
+ *         if num_attrs > 0:
+ *             _attrs = to_c_attr(attrs)
+ */
+  __pyx_v__attrs = NULL;
+
+  /* "ssh2/publickey.pyx":145
+ *         cdef unsigned long num_attrs = len(attrs)
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
+ *         if num_attrs > 0:             # <<<<<<<<<<<<<<
+ *             _attrs = to_c_attr(attrs)
+ *         cdef const unsigned char *_name = name
+ */
+  __pyx_t_2 = (__pyx_v_num_attrs > 0);
+  if (__pyx_t_2) {
+
+    /* "ssh2/publickey.pyx":146
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
+ *         if num_attrs > 0:
+ *             _attrs = to_c_attr(attrs)             # <<<<<<<<<<<<<<
+ *         cdef const unsigned char *_name = name
+ *         cdef size_t blob_len = len(blob)
+ */
+    __pyx_t_3 = __pyx_f_4ssh2_9publickey_to_c_attr(__pyx_v_attrs); if (unlikely(__pyx_t_3 == ((libssh2_publickey_attribute *)NULL) && PyErr_Occurred())) __PYX_ERR(1, 146, __pyx_L1_error)
+    __pyx_v__attrs = __pyx_t_3;
+
+    /* "ssh2/publickey.pyx":145
+ *         cdef unsigned long num_attrs = len(attrs)
+ *         cdef c_pkey.libssh2_publickey_attribute *_attrs = NULL
+ *         if num_attrs > 0:             # <<<<<<<<<<<<<<
+ *             _attrs = to_c_attr(attrs)
+ *         cdef const unsigned char *_name = name
+ */
+  }
+
+  /* "ssh2/publickey.pyx":147
+ *         if num_attrs > 0:
+ *             _attrs = to_c_attr(attrs)
  *         cdef const unsigned char *_name = name             # <<<<<<<<<<<<<<
+ *         cdef size_t blob_len = len(blob)
  *         cdef const unsigned char *_blob = blob
- *         with nogil:
  */
   if (unlikely(__pyx_v_name == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 161, __pyx_L1_error)
+    __PYX_ERR(1, 147, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsUString(__pyx_v_name); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 161, __pyx_L1_error)
-  __pyx_v__name = __pyx_t_2;
+  __pyx_t_4 = __Pyx_PyBytes_AsUString(__pyx_v_name); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 147, __pyx_L1_error)
+  __pyx_v__name = __pyx_t_4;
 
-  /* "ssh2/publickey.pyx":162
- *         cdef unsigned long blob_len = len(blob)
+  /* "ssh2/publickey.pyx":148
+ *             _attrs = to_c_attr(attrs)
+ *         cdef const unsigned char *_name = name
+ *         cdef size_t blob_len = len(blob)             # <<<<<<<<<<<<<<
+ *         cdef const unsigned char *_blob = blob
+ *         with nogil:
+ */
+  if (unlikely(__pyx_v_blob == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 148, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_blob); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 148, __pyx_L1_error)
+  __pyx_v_blob_len = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":149
  *         cdef const unsigned char *_name = name
+ *         cdef size_t blob_len = len(blob)
  *         cdef const unsigned char *_blob = blob             # <<<<<<<<<<<<<<
  *         with nogil:
- *             rc = c_pkey.libssh2_publickey_remove_ex(
+ *             rc = c_pkey.libssh2_publickey_add_ex(
  */
   if (unlikely(__pyx_v_blob == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 162, __pyx_L1_error)
+    __PYX_ERR(1, 149, __pyx_L1_error)
   }
-  __pyx_t_3 = __Pyx_PyBytes_AsUString(__pyx_v_blob); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 162, __pyx_L1_error)
-  __pyx_v__blob = __pyx_t_3;
+  __pyx_t_5 = __Pyx_PyBytes_AsUString(__pyx_v_blob); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error)
+  __pyx_v__blob = __pyx_t_5;
 
-  /* "ssh2/publickey.pyx":163
- *         cdef const unsigned char *_name = name
+  /* "ssh2/publickey.pyx":150
+ *         cdef size_t blob_len = len(blob)
  *         cdef const unsigned char *_blob = blob
  *         with nogil:             # <<<<<<<<<<<<<<
- *             rc = c_pkey.libssh2_publickey_remove_ex(
- *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ *             rc = c_pkey.libssh2_publickey_add_ex(
+ *                 self.pkey_s, _name, name_len, _blob,
  */
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/publickey.pyx":164
+        /* "ssh2/publickey.pyx":151
  *         cdef const unsigned char *_blob = blob
  *         with nogil:
- *             rc = c_pkey.libssh2_publickey_remove_ex(             # <<<<<<<<<<<<<<
- *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ *             rc = c_pkey.libssh2_publickey_add_ex(             # <<<<<<<<<<<<<<
+ *                 self.pkey_s, _name, name_len, _blob,
+ *                 blob_len, overwrite, num_attrs, _attrs)
+ */
+        __pyx_v_rc = libssh2_publickey_add_ex(__pyx_v_self->pkey_s, __pyx_v__name, __pyx_v_name_len, __pyx_v__blob, __pyx_v_blob_len, __pyx_v_overwrite, __pyx_v_num_attrs, __pyx_v__attrs);
+
+        /* "ssh2/publickey.pyx":154
+ *                 self.pkey_s, _name, name_len, _blob,
+ *                 blob_len, overwrite, num_attrs, _attrs)
+ *             if _attrs is not NULL:             # <<<<<<<<<<<<<<
+ *                 free(_attrs)
  *         return handle_error_codes(rc)
  */
-        __pyx_v_rc = libssh2_publickey_remove_ex(__pyx_v_self->pkey_s, __pyx_v__name, __pyx_v_name_len, __pyx_v__blob, __pyx_v_blob_len);
+        __pyx_t_2 = (__pyx_v__attrs != NULL);
+        if (__pyx_t_2) {
+
+          /* "ssh2/publickey.pyx":155
+ *                 blob_len, overwrite, num_attrs, _attrs)
+ *             if _attrs is not NULL:
+ *                 free(_attrs)             # <<<<<<<<<<<<<<
+ *         return handle_error_codes(rc)
+ * 
+ */
+          free(__pyx_v__attrs);
+
+          /* "ssh2/publickey.pyx":154
+ *                 self.pkey_s, _name, name_len, _blob,
+ *                 blob_len, overwrite, num_attrs, _attrs)
+ *             if _attrs is not NULL:             # <<<<<<<<<<<<<<
+ *                 free(_attrs)
+ *         return handle_error_codes(rc)
+ */
+        }
       }
 
-      /* "ssh2/publickey.pyx":163
- *         cdef const unsigned char *_name = name
+      /* "ssh2/publickey.pyx":150
+ *         cdef size_t blob_len = len(blob)
  *         cdef const unsigned char *_blob = blob
  *         with nogil:             # <<<<<<<<<<<<<<
- *             rc = c_pkey.libssh2_publickey_remove_ex(
- *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ *             rc = c_pkey.libssh2_publickey_add_ex(
+ *                 self.pkey_s, _name, name_len, _blob,
  */
       /*finally:*/ {
         /*normal exit:*/{
@@ -3984,39 +6166,39 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(struct __py
           __Pyx_FastGIL_Forget();
           Py_BLOCK_THREADS
           #endif
-          goto __pyx_L5;
+          goto __pyx_L6;
         }
-        __pyx_L5:;
+        __pyx_L6:;
       }
   }
 
-  /* "ssh2/publickey.pyx":166
- *             rc = c_pkey.libssh2_publickey_remove_ex(
- *                 self.pkey_s, _name, name_len, _blob, blob_len)
+  /* "ssh2/publickey.pyx":156
+ *             if _attrs is not NULL:
+ *                 free(_attrs)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
  * 
- *     def list_fetch(self):
+ *     def remove(self, bytes name, bytes blob):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 166, __pyx_L1_error)
-  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_r = __pyx_t_5;
-  __pyx_t_5 = 0;
+  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 156, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_r = __pyx_t_7;
+  __pyx_t_7 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/publickey.pyx":158
- *         return handle_error_codes(rc)
+  /* "ssh2/publickey.pyx":139
+ *         self.pkey_s = NULL
  * 
- *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
- *         cdef unsigned long name_len = len(name)
- *         cdef unsigned long blob_len = len(blob)
+ *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
+ *             char overwrite,
+ *             list attrs):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.add", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -4024,34 +6206,341 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/publickey.pyx":168
+/* "ssh2/publickey.pyx":158
  *         return handle_error_codes(rc)
  * 
- *     def list_fetch(self):             # <<<<<<<<<<<<<<
- *         cdef unsigned long num_keys = 0
- *         cdef c_pkey.libssh2_publickey_list **pkey_list = NULL
+ *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_8list_fetch[] = "PublicKeySystem.list_fetch(self)";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_6remove, "PublicKeySystem.remove(self, bytes name, bytes blob)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_7remove = {"remove", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_6remove};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_blob = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("list_fetch (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
-
-  /* function exit code */
+  __Pyx_RefNannySetupContext("remove (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_blob,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 158, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_blob)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 158, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, 1); __PYX_ERR(1, 158, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "remove") < 0)) __PYX_ERR(1, 158, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+    }
+    __pyx_v_name = ((PyObject*)values[0]);
+    __pyx_v_blob = ((PyObject*)values[1]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 158, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(1, 158, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_blob), (&PyBytes_Type), 1, "blob", 1))) __PYX_ERR(1, 158, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v_name, __pyx_v_blob);
 
-static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
-  unsigned long __pyx_v_num_keys;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_6remove(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_blob) {
+  unsigned long __pyx_v_name_len;
+  unsigned long __pyx_v_blob_len;
+  unsigned char const *__pyx_v__name;
+  unsigned char const *__pyx_v__blob;
+  int __pyx_v_rc;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  unsigned char const *__pyx_t_2;
+  unsigned char const *__pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("remove", 1);
+
+  /* "ssh2/publickey.pyx":159
+ * 
+ *     def remove(self, bytes name, bytes blob):
+ *         cdef unsigned long name_len = len(name)             # <<<<<<<<<<<<<<
+ *         cdef unsigned long blob_len = len(blob)
+ *         cdef const unsigned char *_name = name
+ */
+  if (unlikely(__pyx_v_name == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 159, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_name); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 159, __pyx_L1_error)
+  __pyx_v_name_len = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":160
+ *     def remove(self, bytes name, bytes blob):
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)             # <<<<<<<<<<<<<<
+ *         cdef const unsigned char *_name = name
+ *         cdef const unsigned char *_blob = blob
+ */
+  if (unlikely(__pyx_v_blob == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(1, 160, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_blob); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 160, __pyx_L1_error)
+  __pyx_v_blob_len = __pyx_t_1;
+
+  /* "ssh2/publickey.pyx":161
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)
+ *         cdef const unsigned char *_name = name             # <<<<<<<<<<<<<<
+ *         cdef const unsigned char *_blob = blob
+ *         with nogil:
+ */
+  if (unlikely(__pyx_v_name == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+    __PYX_ERR(1, 161, __pyx_L1_error)
+  }
+  __pyx_t_2 = __Pyx_PyBytes_AsUString(__pyx_v_name); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 161, __pyx_L1_error)
+  __pyx_v__name = __pyx_t_2;
+
+  /* "ssh2/publickey.pyx":162
+ *         cdef unsigned long blob_len = len(blob)
+ *         cdef const unsigned char *_name = name
+ *         cdef const unsigned char *_blob = blob             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             rc = c_pkey.libssh2_publickey_remove_ex(
+ */
+  if (unlikely(__pyx_v_blob == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
+    __PYX_ERR(1, 162, __pyx_L1_error)
+  }
+  __pyx_t_3 = __Pyx_PyBytes_AsUString(__pyx_v_blob); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 162, __pyx_L1_error)
+  __pyx_v__blob = __pyx_t_3;
+
+  /* "ssh2/publickey.pyx":163
+ *         cdef const unsigned char *_name = name
+ *         cdef const unsigned char *_blob = blob
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             rc = c_pkey.libssh2_publickey_remove_ex(
+ *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      _save = NULL;
+      Py_UNBLOCK_THREADS
+      __Pyx_FastGIL_Remember();
+      #endif
+      /*try:*/ {
+
+        /* "ssh2/publickey.pyx":164
+ *         cdef const unsigned char *_blob = blob
+ *         with nogil:
+ *             rc = c_pkey.libssh2_publickey_remove_ex(             # <<<<<<<<<<<<<<
+ *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ *         return handle_error_codes(rc)
+ */
+        __pyx_v_rc = libssh2_publickey_remove_ex(__pyx_v_self->pkey_s, __pyx_v__name, __pyx_v_name_len, __pyx_v__blob, __pyx_v_blob_len);
+      }
+
+      /* "ssh2/publickey.pyx":163
+ *         cdef const unsigned char *_name = name
+ *         cdef const unsigned char *_blob = blob
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             rc = c_pkey.libssh2_publickey_remove_ex(
+ *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          __Pyx_FastGIL_Forget();
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "ssh2/publickey.pyx":166
+ *             rc = c_pkey.libssh2_publickey_remove_ex(
+ *                 self.pkey_s, _name, name_len, _blob, blob_len)
+ *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
+ * 
+ *     def list_fetch(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 166, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "ssh2/publickey.pyx":158
+ *         return handle_error_codes(rc)
+ * 
+ *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "ssh2/publickey.pyx":168
+ *         return handle_error_codes(rc)
+ * 
+ *     def list_fetch(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long num_keys = 0
+ *         cdef c_pkey.libssh2_publickey_list **pkey_list = NULL
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_8list_fetch, "PublicKeySystem.list_fetch(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_9list_fetch = {"list_fetch", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_8list_fetch};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("list_fetch (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("list_fetch", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "list_fetch", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
+  unsigned long __pyx_v_num_keys;
   libssh2_publickey_list **__pyx_v_pkey_list;
   int __pyx_v_rc;
   PyObject *__pyx_v_keys = 0;
-  unsigned long __pyx_v_i;
+  unsigned long __pyx_7genexpr__pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
@@ -4064,7 +6553,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("list_fetch", 0);
+  __Pyx_RefNannySetupContext("list_fetch", 1);
 
   /* "ssh2/publickey.pyx":169
  * 
@@ -4094,6 +6583,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4135,7 +6625,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
  *             return handle_error_codes(rc)
  *         if num_keys < 1:
  */
-  __pyx_t_1 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_1 = (__pyx_v_rc != 0);
   if (__pyx_t_1) {
 
     /* "ssh2/publickey.pyx":177
@@ -4169,7 +6659,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
  *             return []
  *         keys = [PyPublicKeyList(pkey_list[i]) for i in range(num_keys)]
  */
-  __pyx_t_1 = ((__pyx_v_num_keys < 1) != 0);
+  __pyx_t_1 = (__pyx_v_num_keys < 1);
   if (__pyx_t_1) {
 
     /* "ssh2/publickey.pyx":179
@@ -4202,17 +6692,19 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
  *         return keys
  * 
  */
-  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 180, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __pyx_v_num_keys;
-  __pyx_t_5 = __pyx_t_4;
-  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-    __pyx_v_i = __pyx_t_6;
-    __pyx_t_7 = __pyx_f_4ssh2_9publickey_PyPublicKeyList((__pyx_v_pkey_list[__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 180, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_7))) __PYX_ERR(1, 180, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  }
+  { /* enter inner scope */
+    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __pyx_v_num_keys;
+    __pyx_t_5 = __pyx_t_4;
+    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+      __pyx_7genexpr__pyx_v_i = __pyx_t_6;
+      __pyx_t_7 = __pyx_f_4ssh2_9publickey_PyPublicKeyList((__pyx_v_pkey_list[__pyx_7genexpr__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 180, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_7))) __PYX_ERR(1, 180, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    }
+  } /* exit inner scope */
   __pyx_v_keys = ((PyObject*)__pyx_t_3);
   __pyx_t_3 = 0;
 
@@ -4258,12 +6750,40 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_8list_fetch(struct
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_10list_free[] = "PublicKeySystem.list_free(self)\nNo-op - list_free called automatically by\n        :py:class:`ssh2.publickey.PublicKeyList` destructor";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_10list_free, "PublicKeySystem.list_free(self)\nNo-op - list_free called automatically by\n        :py:class:`ssh2.publickey.PublicKeyList` destructor");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_11list_free = {"list_free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_10list_free};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("list_free (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("list_free", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "list_free", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_10list_free(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
 
   /* function exit code */
@@ -4274,7 +6794,7 @@ static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free(PyObjec
 static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_10list_free(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("list_free", 0);
+  __Pyx_RefNannySetupContext("list_free", 1);
 
   /* function exit code */
   __pyx_r = Py_None; __Pyx_INCREF(Py_None);
@@ -4292,12 +6812,40 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_10list_free(CYTHON_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_12shutdown[] = "PublicKeySystem.shutdown(self)\nShutdown public key subsystem.\n        Called automatically by object destructor";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_12shutdown, "PublicKeySystem.shutdown(self)\nShutdown public key subsystem.\n        Called automatically by object destructor");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_13shutdown = {"shutdown", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_12shutdown};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("shutdown (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("shutdown", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "shutdown", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_12shutdown(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
 
   /* function exit code */
@@ -4314,7 +6862,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_12shutdown(struct _
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("shutdown", 0);
+  __Pyx_RefNannySetupContext("shutdown", 1);
 
   /* "ssh2/publickey.pyx":192
  *         Called automatically by object destructor"""
@@ -4326,6 +6874,7 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_12shutdown(struct _
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4393,17 +6942,45 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_12shutdown(struct _
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__[] = "PublicKeySystem.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__, "PublicKeySystem.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self));
 
   /* function exit code */
@@ -4414,33 +6991,28 @@ static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__
 static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -4450,55 +7022,133 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__[] = "PublicKeySystem.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__, "PublicKeySystem.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__(((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
 static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.publickey.PublicKeySystem.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -4506,703 +7156,494 @@ static PyObject *__pyx_pf_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython
   return __pyx_r;
 }
 
-/* "FromPyStructUtility":11
- * 
- * @cname("__pyx_convert__from_py_libssh2_publickey_attribute")
- * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:             # <<<<<<<<<<<<<<
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):
- */
-
-static libssh2_publickey_attribute __pyx_convert__from_py_libssh2_publickey_attribute(PyObject *__pyx_v_obj) {
-  libssh2_publickey_attribute __pyx_v_result;
-  PyObject *__pyx_v_value = NULL;
-  libssh2_publickey_attribute __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  char const *__pyx_t_10;
-  unsigned long __pyx_t_11;
-  char const *__pyx_t_12;
-  char __pyx_t_13;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__pyx_convert__from_py_libssh2_publickey_attribute", 0);
-
-  /* "FromPyStructUtility":13
- * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):             # <<<<<<<<<<<<<<
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)
- * 
- */
-  __pyx_t_1 = ((!(PyMapping_Check(__pyx_v_obj) != 0)) != 0);
-  if (__pyx_t_1) {
-
-    /* "FromPyStructUtility":14
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)             # <<<<<<<<<<<<<<
- * 
- *     try:
- */
-    __pyx_t_2 = PyErr_Format(__pyx_builtin_TypeError, ((char const *)"Expected %.16s, got %.200s"), ((char *)"a mapping"), Py_TYPE(__pyx_v_obj)->tp_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    /* "FromPyStructUtility":13
- * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):             # <<<<<<<<<<<<<<
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)
- * 
- */
+static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyList(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p;
+  PyObject *o;
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
+  if (unlikely(!o)) return 0;
+  #endif
+  p = ((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o);
+  p->pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
 
-  /* "FromPyStructUtility":16
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)
- * 
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name']
- *     except KeyError:
- */
+static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList(PyObject *o) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
+  PyObject_GC_UnTrack(o);
   {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
-    __Pyx_XGOTREF(__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_5);
-    /*try:*/ {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->pkey_s);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+  (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
+}
 
-      /* "FromPyStructUtility":17
- * 
- *     try:
- *         value = obj['name']             # <<<<<<<<<<<<<<
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name'")
- */
-      __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L4_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_v_value = __pyx_t_2;
-      __pyx_t_2 = 0;
+static int __pyx_tp_traverse_4ssh2_9publickey_PublicKeyList(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
+  if (p->pkey_s) {
+    e = (*v)(((PyObject *)p->pkey_s), a); if (e) return e;
+  }
+  return 0;
+}
 
-      /* "FromPyStructUtility":16
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)
- * 
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name']
- *     except KeyError:
- */
-    }
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    goto __pyx_L9_try_end;
-    __pyx_L4_error:;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+static int __pyx_tp_clear_4ssh2_9publickey_PublicKeyList(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
+  tmp = ((PyObject*)p->pkey_s);
+  p->pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
 
-    /* "FromPyStructUtility":18
- *     try:
- *         value = obj['name']
- *     except KeyError:             # <<<<<<<<<<<<<<
- *         raise ValueError("No value specified for struct attribute 'name'")
- *     result.name = value
- */
-    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
-    if (__pyx_t_6) {
-      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 18, __pyx_L6_except_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_GOTREF(__pyx_t_8);
+static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_name(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(o);
+}
 
-      /* "FromPyStructUtility":19
- *         value = obj['name']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name'")             # <<<<<<<<<<<<<<
- *     result.name = value
- *     try:
- */
-      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L6_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __PYX_ERR(0, 19, __pyx_L6_except_error)
-    }
-    goto __pyx_L6_except_error;
-    __pyx_L6_except_error:;
+static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_name_len(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(o);
+}
 
-    /* "FromPyStructUtility":16
- *         PyErr_Format(TypeError, b"Expected %.16s, got %.200s", b"a mapping", Py_TYPE(obj).tp_name)
- * 
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name']
- *     except KeyError:
- */
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_XGIVEREF(__pyx_t_5);
-    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
-    goto __pyx_L1_error;
-    __pyx_L9_try_end:;
-  }
+static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(o);
+}
 
-  /* "FromPyStructUtility":20
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name'")
- *     result.name = value             # <<<<<<<<<<<<<<
- *     try:
- *         value = obj['name_len']
- */
-  __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_value); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 20, __pyx_L1_error)
-  __pyx_v_result.name = __pyx_t_10;
+static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob_len(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(o);
+}
 
-  /* "FromPyStructUtility":21
- *         raise ValueError("No value specified for struct attribute 'name'")
- *     result.name = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name_len']
- *     except KeyError:
- */
-  {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_5);
-    __Pyx_XGOTREF(__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_3);
-    /*try:*/ {
+static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_num_attrs(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(o);
+}
 
-      /* "FromPyStructUtility":22
- *     result.name = value
- *     try:
- *         value = obj['name_len']             # <<<<<<<<<<<<<<
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- */
-      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_name_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 22, __pyx_L12_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8);
-      __pyx_t_8 = 0;
+static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeyList[] = {
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__},
+  {0, 0, 0, 0}
+};
 
-      /* "FromPyStructUtility":21
- *         raise ValueError("No value specified for struct attribute 'name'")
- *     result.name = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name_len']
- *     except KeyError:
- */
-    }
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    goto __pyx_L17_try_end;
-    __pyx_L12_error:;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+static struct PyGetSetDef __pyx_getsets_4ssh2_9publickey_PublicKeyList[] = {
+  {(char *)"name", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_name, 0, (char *)0, 0},
+  {(char *)"name_len", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_name_len, 0, (char *)0, 0},
+  {(char *)"blob", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob, 0, (char *)0, 0},
+  {(char *)"blob_len", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob_len, 0, (char *)0, 0},
+  {(char *)"num_attrs", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_num_attrs, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_9publickey_PublicKeyList_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_9publickey_PublicKeyList},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_9publickey_PublicKeyList},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_9publickey_PublicKeyList},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_9publickey_PublicKeyList},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_9publickey_PublicKeyList},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_9publickey_PublicKeyList_spec = {
+  "ssh2.publickey.PublicKeyList",
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyList),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_9publickey_PublicKeyList_slots,
+};
+#else
 
-    /* "FromPyStructUtility":23
- *     try:
- *         value = obj['name_len']
- *     except KeyError:             # <<<<<<<<<<<<<<
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- *     result.name_len = value
- */
-    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
-    if (__pyx_t_6) {
-      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L14_except_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_GOTREF(__pyx_t_2);
-
-      /* "FromPyStructUtility":24
- *         value = obj['name_len']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name_len'")             # <<<<<<<<<<<<<<
- *     result.name_len = value
- *     try:
- */
-      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 24, __pyx_L14_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __PYX_ERR(0, 24, __pyx_L14_except_error)
-    }
-    goto __pyx_L14_except_error;
-    __pyx_L14_except_error:;
+static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyList = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "ssh2.publickey.""PublicKeyList", /*tp_name*/
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyList), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_4ssh2_9publickey_PublicKeyList, /*tp_traverse*/
+  __pyx_tp_clear_4ssh2_9publickey_PublicKeyList, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_4ssh2_9publickey_PublicKeyList, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_4ssh2_9publickey_PublicKeyList, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
+  0, /*tp_dictoffset*/
+  #endif
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_4ssh2_9publickey_PublicKeyList, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
+  0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+  0, /*tp_vectorcall*/
+  #endif
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+  0, /*tp_pypy_flags*/
+  #endif
+};
+#endif
 
-    /* "FromPyStructUtility":21
- *         raise ValueError("No value specified for struct attribute 'name'")
- *     result.name = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['name_len']
- *     except KeyError:
- */
-    __Pyx_XGIVEREF(__pyx_t_5);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
-    goto __pyx_L1_error;
-    __pyx_L17_try_end:;
+static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
+  if (unlikely(!o)) return 0;
+  #endif
+  if (unlikely(__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
 
-  /* "FromPyStructUtility":25
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- *     result.name_len = value             # <<<<<<<<<<<<<<
- *     try:
- *         value = obj['value']
- */
-  __pyx_t_11 = __Pyx_PyInt_As_unsigned_long(__pyx_v_value); if (unlikely((__pyx_t_11 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 25, __pyx_L1_error)
-  __pyx_v_result.name_len = __pyx_t_11;
-
-  /* "FromPyStructUtility":26
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- *     result.name_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value']
- *     except KeyError:
- */
+static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute(PyObject *o) {
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+  (*Py_TYPE(o)->tp_free)(o);
+  #else
   {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
-    __Pyx_XGOTREF(__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_5);
-    /*try:*/ {
-
-      /* "FromPyStructUtility":27
- *     result.name_len = value
- *     try:
- *         value = obj['value']             # <<<<<<<<<<<<<<
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value'")
- */
-      __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 27, __pyx_L20_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
-      __pyx_t_2 = 0;
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
+}
 
-      /* "FromPyStructUtility":26
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- *     result.name_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value']
- *     except KeyError:
- */
-    }
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    goto __pyx_L25_try_end;
-    __pyx_L20_error:;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(o);
+}
 
-    /* "FromPyStructUtility":28
- *     try:
- *         value = obj['value']
- *     except KeyError:             # <<<<<<<<<<<<<<
- *         raise ValueError("No value specified for struct attribute 'value'")
- *     result.value = value
- */
-    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
-    if (__pyx_t_6) {
-      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 28, __pyx_L22_except_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_GOTREF(__pyx_t_8);
+static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name_len(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(o);
+}
 
-      /* "FromPyStructUtility":29
- *         value = obj['value']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value'")             # <<<<<<<<<<<<<<
- *     result.value = value
- *     try:
- */
-      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 29, __pyx_L22_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __PYX_ERR(0, 29, __pyx_L22_except_error)
-    }
-    goto __pyx_L22_except_error;
-    __pyx_L22_except_error:;
+static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(o);
+}
 
-    /* "FromPyStructUtility":26
- *         raise ValueError("No value specified for struct attribute 'name_len'")
- *     result.name_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value']
- *     except KeyError:
- */
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_XGIVEREF(__pyx_t_5);
-    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
-    goto __pyx_L1_error;
-    __pyx_L25_try_end:;
-  }
+static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value_len(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(o);
+}
 
-  /* "FromPyStructUtility":30
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value'")
- *     result.value = value             # <<<<<<<<<<<<<<
- *     try:
- *         value = obj['value_len']
- */
-  __pyx_t_12 = __Pyx_PyObject_AsString(__pyx_v_value); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L1_error)
-  __pyx_v_result.value = __pyx_t_12;
+static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_mandatory(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(o);
+}
 
-  /* "FromPyStructUtility":31
- *         raise ValueError("No value specified for struct attribute 'value'")
- *     result.value = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value_len']
- *     except KeyError:
- */
-  {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_5);
-    __Pyx_XGOTREF(__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_3);
-    /*try:*/ {
+static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeyAttribute[] = {
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__},
+  {0, 0, 0, 0}
+};
 
-      /* "FromPyStructUtility":32
- *     result.value = value
- *     try:
- *         value = obj['value_len']             # <<<<<<<<<<<<<<
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- */
-      __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_value_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 32, __pyx_L28_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8);
-      __pyx_t_8 = 0;
+static struct PyGetSetDef __pyx_getsets_4ssh2_9publickey_PublicKeyAttribute[] = {
+  {(char *)"name", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name, 0, (char *)0, 0},
+  {(char *)"name_len", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name_len, 0, (char *)0, 0},
+  {(char *)"value", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value, 0, (char *)0, 0},
+  {(char *)"value_len", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value_len, 0, (char *)0, 0},
+  {(char *)"mandatory", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_mandatory, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_9publickey_PublicKeyAttribute_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute},
+  {Py_tp_doc, (void *)PyDoc_STR("Public key attributes")},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_9publickey_PublicKeyAttribute},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_9publickey_PublicKeyAttribute},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_9publickey_PublicKeyAttribute_spec = {
+  "ssh2.publickey.PublicKeyAttribute",
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_9publickey_PublicKeyAttribute_slots,
+};
+#else
 
-      /* "FromPyStructUtility":31
- *         raise ValueError("No value specified for struct attribute 'value'")
- *     result.value = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value_len']
- *     except KeyError:
- */
-    }
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    goto __pyx_L33_try_end;
-    __pyx_L28_error:;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyAttribute = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "ssh2.publickey.""PublicKeyAttribute", /*tp_name*/
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  PyDoc_STR("Public key attributes"), /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_4ssh2_9publickey_PublicKeyAttribute, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_4ssh2_9publickey_PublicKeyAttribute, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
+  0, /*tp_dictoffset*/
+  #endif
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
+  0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+  0, /*tp_vectorcall*/
+  #endif
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+  0, /*tp_pypy_flags*/
+  #endif
+};
+#endif
 
-    /* "FromPyStructUtility":33
- *     try:
- *         value = obj['value_len']
- *     except KeyError:             # <<<<<<<<<<<<<<
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- *     result.value_len = value
- */
-    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
-    if (__pyx_t_6) {
-      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_2) < 0) __PYX_ERR(0, 33, __pyx_L30_except_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_GOTREF(__pyx_t_2);
+static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeySystem(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p;
+  PyObject *o;
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  #endif
+  p = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o);
+  p->session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
+  if (unlikely(__pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
 
-      /* "FromPyStructUtility":34
- *         value = obj['value_len']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value_len'")             # <<<<<<<<<<<<<<
- *     result.value_len = value
- *     try:
- */
-      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 34, __pyx_L30_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __PYX_ERR(0, 34, __pyx_L30_except_error)
+static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem(PyObject *o) {
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
     }
-    goto __pyx_L30_except_error;
-    __pyx_L30_except_error:;
-
-    /* "FromPyStructUtility":31
- *         raise ValueError("No value specified for struct attribute 'value'")
- *     result.value = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['value_len']
- *     except KeyError:
- */
-    __Pyx_XGIVEREF(__pyx_t_5);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
-    goto __pyx_L1_error;
-    __pyx_L33_try_end:;
   }
-
-  /* "FromPyStructUtility":35
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- *     result.value_len = value             # <<<<<<<<<<<<<<
- *     try:
- *         value = obj['mandatory']
- */
-  __pyx_t_11 = __Pyx_PyInt_As_unsigned_long(__pyx_v_value); if (unlikely((__pyx_t_11 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L1_error)
-  __pyx_v_result.value_len = __pyx_t_11;
-
-  /* "FromPyStructUtility":36
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- *     result.value_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['mandatory']
- *     except KeyError:
- */
+  #endif
+  PyObject_GC_UnTrack(o);
   {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
-    __Pyx_XGOTREF(__pyx_t_3);
-    __Pyx_XGOTREF(__pyx_t_4);
-    __Pyx_XGOTREF(__pyx_t_5);
-    /*try:*/ {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
+    __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(o);
+    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
+    PyErr_Restore(etype, eval, etb);
+  }
+  Py_CLEAR(p->session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+  (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
+}
 
-      /* "FromPyStructUtility":37
- *     result.value_len = value
- *     try:
- *         value = obj['mandatory']             # <<<<<<<<<<<<<<
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'mandatory'")
- */
-      __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_mandatory); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L36_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
-      __pyx_t_2 = 0;
+static int __pyx_tp_traverse_4ssh2_9publickey_PublicKeySystem(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
+  if (p->session) {
+    e = (*v)(((PyObject *)p->session), a); if (e) return e;
+  }
+  return 0;
+}
 
-      /* "FromPyStructUtility":36
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- *     result.value_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['mandatory']
- *     except KeyError:
- */
-    }
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    goto __pyx_L41_try_end;
-    __pyx_L36_error:;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+static int __pyx_tp_clear_4ssh2_9publickey_PublicKeySystem(PyObject *o) {
+  PyObject* tmp;
+  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
+  tmp = ((PyObject*)p->session);
+  p->session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
+  Py_XDECREF(tmp);
+  return 0;
+}
 
-    /* "FromPyStructUtility":38
- *     try:
- *         value = obj['mandatory']
- *     except KeyError:             # <<<<<<<<<<<<<<
- *         raise ValueError("No value specified for struct attribute 'mandatory'")
- *     result.mandatory = value
- */
-    __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
-    if (__pyx_t_6) {
-      __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 38, __pyx_L38_except_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_GOTREF(__pyx_t_8);
+static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeySystem[] = {
+  {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_4add},
+  {"remove", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_6remove},
+  {"list_fetch", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_8list_fetch},
+  {"list_free", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_10list_free},
+  {"shutdown", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_12shutdown},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__},
+  {0, 0, 0, 0}
+};
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_9publickey_PublicKeySystem_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem},
+  {Py_tp_doc, (void *)PyDoc_STR("Public Key subsystem. Methods for managing public keys on remote\n    server, like with the ``ssh-*-id`` utilities.\n    Not related to pkey authentication.")},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_9publickey_PublicKeySystem},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_9publickey_PublicKeySystem},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_9publickey_PublicKeySystem},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_9publickey_PublicKeySystem},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_9publickey_PublicKeySystem_spec = {
+  "ssh2.publickey.PublicKeySystem",
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_9publickey_PublicKeySystem_slots,
+};
+#else
 
-      /* "FromPyStructUtility":39
- *         value = obj['mandatory']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'mandatory'")             # <<<<<<<<<<<<<<
- *     result.mandatory = value
- *     return result
- */
-      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L38_except_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_Raise(__pyx_t_9, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __PYX_ERR(0, 39, __pyx_L38_except_error)
-    }
-    goto __pyx_L38_except_error;
-    __pyx_L38_except_error:;
-
-    /* "FromPyStructUtility":36
- *         raise ValueError("No value specified for struct attribute 'value_len'")
- *     result.value_len = value
- *     try:             # <<<<<<<<<<<<<<
- *         value = obj['mandatory']
- *     except KeyError:
- */
-    __Pyx_XGIVEREF(__pyx_t_3);
-    __Pyx_XGIVEREF(__pyx_t_4);
-    __Pyx_XGIVEREF(__pyx_t_5);
-    __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
-    goto __pyx_L1_error;
-    __pyx_L41_try_end:;
-  }
-
-  /* "FromPyStructUtility":40
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'mandatory'")
- *     result.mandatory = value             # <<<<<<<<<<<<<<
- *     return result
- * 
- */
-  __pyx_t_13 = __Pyx_PyInt_As_char(__pyx_v_value); if (unlikely((__pyx_t_13 == (char)-1) && PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L1_error)
-  __pyx_v_result.mandatory = __pyx_t_13;
-
-  /* "FromPyStructUtility":41
- *         raise ValueError("No value specified for struct attribute 'mandatory'")
- *     result.mandatory = value
- *     return result             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_r = __pyx_v_result;
-  goto __pyx_L0;
-
-  /* "FromPyStructUtility":11
- * 
- * @cname("__pyx_convert__from_py_libssh2_publickey_attribute")
- * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:             # <<<<<<<<<<<<<<
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):
- */
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_libssh2_publickey_attribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_pretend_to_initialize(&__pyx_r);
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyList(PyTypeObject *t, PyObject *a, PyObject *k) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p;
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o);
-  p->pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)Py_None); Py_INCREF(Py_None);
-  if (unlikely(__pyx_pw_4ssh2_9publickey_13PublicKeyList_1__cinit__(o, a, k) < 0)) goto bad;
-  return o;
-  bad:
-  Py_DECREF(o); o = 0;
-  return NULL;
-}
-
-static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList(PyObject *o) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  PyObject_GC_UnTrack(o);
-  {
-    PyObject *etype, *eval, *etb;
-    PyErr_Fetch(&etype, &eval, &etb);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
-    __pyx_pw_4ssh2_9publickey_13PublicKeyList_3__dealloc__(o);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
-    PyErr_Restore(etype, eval, etb);
-  }
-  Py_CLEAR(p->pkey_s);
-  (*Py_TYPE(o)->tp_free)(o);
-}
-
-static int __pyx_tp_traverse_4ssh2_9publickey_PublicKeyList(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
-  if (p->pkey_s) {
-    e = (*v)(((PyObject *)p->pkey_s), a); if (e) return e;
-  }
-  return 0;
-}
-
-static int __pyx_tp_clear_4ssh2_9publickey_PublicKeyList(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_obj_4ssh2_9publickey_PublicKeyList *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeyList *)o;
-  tmp = ((PyObject*)p->pkey_s);
-  p->pkey_s = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)Py_None); Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  return 0;
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_name(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_4name_1__get__(o);
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_name_len(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_8name_len_1__get__(o);
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_4blob_1__get__(o);
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob_len(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_8blob_len_1__get__(o);
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_13PublicKeyList_num_attrs(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_13PublicKeyList_9num_attrs_1__get__(o);
-}
-
-static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeyList[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_9publickey_13PublicKeyList_4__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__, METH_O, __pyx_doc_4ssh2_9publickey_13PublicKeyList_6__setstate_cython__},
-  {0, 0, 0, 0}
-};
-
-static struct PyGetSetDef __pyx_getsets_4ssh2_9publickey_PublicKeyList[] = {
-  {(char *)"name", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_name, 0, (char *)0, 0},
-  {(char *)"name_len", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_name_len, 0, (char *)0, 0},
-  {(char *)"blob", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob, 0, (char *)0, 0},
-  {(char *)"blob_len", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_blob_len, 0, (char *)0, 0},
-  {(char *)"num_attrs", __pyx_getprop_4ssh2_9publickey_13PublicKeyList_num_attrs, 0, (char *)0, 0},
-  {0, 0, 0, 0, 0}
-};
-
-static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyList = {
+static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeySystem = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.publickey.PublicKeyList", /*tp_name*/
-  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyList), /*tp_basicsize*/
+  "ssh2.publickey.""PublicKeySystem", /*tp_name*/
+  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem), /*tp_basicsize*/
   0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyList, /*tp_dealloc*/
+  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem, /*tp_dealloc*/
   #if PY_VERSION_HEX < 0x030800b4
   0, /*tp_print*/
   #endif
@@ -5228,24 +7669,26 @@ static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyList = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_4ssh2_9publickey_PublicKeyList, /*tp_traverse*/
-  __pyx_tp_clear_4ssh2_9publickey_PublicKeyList, /*tp_clear*/
+  PyDoc_STR("Public Key subsystem. Methods for managing public keys on remote\n    server, like with the ``ssh-*-id`` utilities.\n    Not related to pkey authentication."), /*tp_doc*/
+  __pyx_tp_traverse_4ssh2_9publickey_PublicKeySystem, /*tp_traverse*/
+  __pyx_tp_clear_4ssh2_9publickey_PublicKeySystem, /*tp_clear*/
   0, /*tp_richcompare*/
   0, /*tp_weaklistoffset*/
   0, /*tp_iter*/
   0, /*tp_iternext*/
-  __pyx_methods_4ssh2_9publickey_PublicKeyList, /*tp_methods*/
+  __pyx_methods_4ssh2_9publickey_PublicKeySystem, /*tp_methods*/
   0, /*tp_members*/
-  __pyx_getsets_4ssh2_9publickey_PublicKeyList, /*tp_getset*/
+  0, /*tp_getset*/
   0, /*tp_base*/
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
-  __pyx_tp_new_4ssh2_9publickey_PublicKeyList, /*tp_new*/
+  __pyx_tp_new_4ssh2_9publickey_PublicKeySystem, /*tp_new*/
   0, /*tp_free*/
   0, /*tp_is_gc*/
   0, /*tp_bases*/
@@ -5256,292 +7699,496 @@ static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyList = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
-static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute(PyTypeObject *t, PyObject *a, PyObject *k) {
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  if (unlikely(__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_1__cinit__(o, a, k) < 0)) goto bad;
-  return o;
-  bad:
-  Py_DECREF(o); o = 0;
-  return NULL;
-}
-
-static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute(PyObject *o) {
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  (*Py_TYPE(o)->tp_free)(o);
-}
-
-static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_4name_1__get__(o);
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+#ifndef CYTHON_SMALL_CODE
+#if defined(__clang__)
+    #define CYTHON_SMALL_CODE
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_kp_s_No_value_specified_for_struct_at, __pyx_k_No_value_specified_for_struct_at, sizeof(__pyx_k_No_value_specified_for_struct_at), 0, 0, 1, 0},
+    {&__pyx_kp_s_No_value_specified_for_struct_at_2, __pyx_k_No_value_specified_for_struct_at_2, sizeof(__pyx_k_No_value_specified_for_struct_at_2), 0, 0, 1, 0},
+    {&__pyx_kp_s_No_value_specified_for_struct_at_3, __pyx_k_No_value_specified_for_struct_at_3, sizeof(__pyx_k_No_value_specified_for_struct_at_3), 0, 0, 1, 0},
+    {&__pyx_kp_s_No_value_specified_for_struct_at_4, __pyx_k_No_value_specified_for_struct_at_4, sizeof(__pyx_k_No_value_specified_for_struct_at_4), 0, 0, 1, 0},
+    {&__pyx_kp_s_No_value_specified_for_struct_at_5, __pyx_k_No_value_specified_for_struct_at_5, sizeof(__pyx_k_No_value_specified_for_struct_at_5), 0, 0, 1, 0},
+    {&__pyx_n_s_PublicKeyAttribute, __pyx_k_PublicKeyAttribute, sizeof(__pyx_k_PublicKeyAttribute), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyAttribute___reduce_cyth, __pyx_k_PublicKeyAttribute___reduce_cyth, sizeof(__pyx_k_PublicKeyAttribute___reduce_cyth), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyAttribute___setstate_cy, __pyx_k_PublicKeyAttribute___setstate_cy, sizeof(__pyx_k_PublicKeyAttribute___setstate_cy), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyList, __pyx_k_PublicKeyList, sizeof(__pyx_k_PublicKeyList), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyList___reduce_cython, __pyx_k_PublicKeyList___reduce_cython, sizeof(__pyx_k_PublicKeyList___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyList___setstate_cython, __pyx_k_PublicKeyList___setstate_cython, sizeof(__pyx_k_PublicKeyList___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem, __pyx_k_PublicKeySystem, sizeof(__pyx_k_PublicKeySystem), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem___reduce_cython, __pyx_k_PublicKeySystem___reduce_cython, sizeof(__pyx_k_PublicKeySystem___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem___setstate_cytho, __pyx_k_PublicKeySystem___setstate_cytho, sizeof(__pyx_k_PublicKeySystem___setstate_cytho), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem_add, __pyx_k_PublicKeySystem_add, sizeof(__pyx_k_PublicKeySystem_add), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem_list_fetch, __pyx_k_PublicKeySystem_list_fetch, sizeof(__pyx_k_PublicKeySystem_list_fetch), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem_list_free, __pyx_k_PublicKeySystem_list_free, sizeof(__pyx_k_PublicKeySystem_list_free), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem_remove, __pyx_k_PublicKeySystem_remove, sizeof(__pyx_k_PublicKeySystem_remove), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeySystem_shutdown, __pyx_k_PublicKeySystem_shutdown, sizeof(__pyx_k_PublicKeySystem_shutdown), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+    {&__pyx_n_s__23, __pyx_k__23, sizeof(__pyx_k__23), 0, 0, 1, 1},
+    {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_attr, __pyx_k_attr, sizeof(__pyx_k_attr), 0, 0, 1, 1},
+    {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
+    {&__pyx_n_s_attrs_2, __pyx_k_attrs_2, sizeof(__pyx_k_attrs_2), 0, 0, 1, 1},
+    {&__pyx_n_s_blob, __pyx_k_blob, sizeof(__pyx_k_blob), 0, 0, 1, 1},
+    {&__pyx_n_s_blob_2, __pyx_k_blob_2, sizeof(__pyx_k_blob_2), 0, 0, 1, 1},
+    {&__pyx_n_s_blob_len, __pyx_k_blob_len, sizeof(__pyx_k_blob_len), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1},
+    {&__pyx_n_s_list_fetch, __pyx_k_list_fetch, sizeof(__pyx_k_list_fetch), 0, 0, 1, 1},
+    {&__pyx_n_s_list_free, __pyx_k_list_free, sizeof(__pyx_k_list_free), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_mandatory, __pyx_k_mandatory, sizeof(__pyx_k_mandatory), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
+    {&__pyx_n_s_name_3, __pyx_k_name_3, sizeof(__pyx_k_name_3), 0, 0, 1, 1},
+    {&__pyx_n_s_name_len, __pyx_k_name_len, sizeof(__pyx_k_name_len), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_num_attrs, __pyx_k_num_attrs, sizeof(__pyx_k_num_attrs), 0, 0, 1, 1},
+    {&__pyx_n_s_num_keys, __pyx_k_num_keys, sizeof(__pyx_k_num_keys), 0, 0, 1, 1},
+    {&__pyx_n_s_overwrite, __pyx_k_overwrite, sizeof(__pyx_k_overwrite), 0, 0, 1, 1},
+    {&__pyx_n_s_pkey_list, __pyx_k_pkey_list, sizeof(__pyx_k_pkey_list), 0, 0, 1, 1},
+    {&__pyx_n_s_pkey_s, __pyx_k_pkey_s, sizeof(__pyx_k_pkey_s), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_remove, __pyx_k_remove, sizeof(__pyx_k_remove), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_shutdown, __pyx_k_shutdown, sizeof(__pyx_k_shutdown), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_publickey, __pyx_k_ssh2_publickey, sizeof(__pyx_k_ssh2_publickey), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_publickey_pyx, __pyx_k_ssh2_publickey_pyx, sizeof(__pyx_k_ssh2_publickey_pyx), 0, 0, 1, 0},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
+    {&__pyx_n_s_value_len, __pyx_k_value_len, sizeof(__pyx_k_value_len), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 106, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 107, __pyx_L1_error)
+  __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 19, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 20, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
 }
+/* #### Code section: cached_constants ### */
 
-static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name_len(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_8name_len_1__get__(o);
-}
+static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5value_1__get__(o);
-}
+  /* "FromPyStructUtility":20
+ *         value = obj['name']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name'")             # <<<<<<<<<<<<<<
+ *     result.name = value
+ *     try:
+ */
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
 
-static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value_len(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9value_len_1__get__(o);
-}
+  /* "FromPyStructUtility":25
+ *         value = obj['name_len']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'name_len'")             # <<<<<<<<<<<<<<
+ *     result.name_len = value
+ *     try:
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_2); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 25, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
 
-static PyObject *__pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_mandatory(PyObject *o, CYTHON_UNUSED void *x) {
-  return __pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_9mandatory_1__get__(o);
-}
+  /* "FromPyStructUtility":30
+ *         value = obj['value']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value'")             # <<<<<<<<<<<<<<
+ *     result.value = value
+ *     try:
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_3); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
 
-static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeyAttribute[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_2__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__, METH_O, __pyx_doc_4ssh2_9publickey_18PublicKeyAttribute_4__setstate_cython__},
-  {0, 0, 0, 0}
-};
+  /* "FromPyStructUtility":35
+ *         value = obj['value_len']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'value_len'")             # <<<<<<<<<<<<<<
+ *     result.value_len = value
+ *     try:
+ */
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_4); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
 
-static struct PyGetSetDef __pyx_getsets_4ssh2_9publickey_PublicKeyAttribute[] = {
-  {(char *)"name", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name, 0, (char *)0, 0},
-  {(char *)"name_len", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_name_len, 0, (char *)0, 0},
-  {(char *)"value", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value, 0, (char *)0, 0},
-  {(char *)"value_len", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_value_len, 0, (char *)0, 0},
-  {(char *)"mandatory", __pyx_getprop_4ssh2_9publickey_18PublicKeyAttribute_mandatory, 0, (char *)0, 0},
-  {0, 0, 0, 0, 0}
-};
+  /* "FromPyStructUtility":40
+ *         value = obj['mandatory']
+ *     except KeyError:
+ *         raise ValueError("No value specified for struct attribute 'mandatory'")             # <<<<<<<<<<<<<<
+ *     result.mandatory = value
+ *     return result
+ */
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_5); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
 
-static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeyAttribute = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.publickey.PublicKeyAttribute", /*tp_name*/
-  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeyAttribute), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeyAttribute, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  "Public key attributes", /*tp_doc*/
-  0, /*tp_traverse*/
-  0, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods_4ssh2_9publickey_PublicKeyAttribute, /*tp_methods*/
-  0, /*tp_members*/
-  __pyx_getsets_4ssh2_9publickey_PublicKeyAttribute, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4ssh2_9publickey_PublicKeyAttribute, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
-  #endif
-};
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 1, __pyx_L1_error)
 
-static PyObject *__pyx_tp_new_4ssh2_9publickey_PublicKeySystem(PyTypeObject *t, PyObject *a, PyObject *k) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p;
-  PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
-    o = (*t->tp_alloc)(t, 0);
-  } else {
-    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
-  }
-  if (unlikely(!o)) return 0;
-  p = ((struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o);
-  p->session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
-  if (unlikely(__pyx_pw_4ssh2_9publickey_15PublicKeySystem_1__cinit__(o, a, k) < 0)) goto bad;
-  return o;
-  bad:
-  Py_DECREF(o); o = 0;
-  return NULL;
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 3, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 3, __pyx_L1_error)
+
+  /* "ssh2/publickey.pyx":139
+ *         self.pkey_s = NULL
+ * 
+ *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
+ *             char overwrite,
+ *             list attrs):
+ */
+  __pyx_tuple__12 = PyTuple_Pack(12, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_blob, __pyx_n_s_overwrite, __pyx_n_s_attrs, __pyx_n_s_name_len, __pyx_n_s_num_attrs, __pyx_n_s_attrs_2, __pyx_n_s_name_3, __pyx_n_s_blob_len, __pyx_n_s_blob_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_publickey_pyx, __pyx_n_s_add, 139, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 139, __pyx_L1_error)
+
+  /* "ssh2/publickey.pyx":158
+ *         return handle_error_codes(rc)
+ * 
+ *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)
+ */
+  __pyx_tuple__14 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_blob, __pyx_n_s_name_len, __pyx_n_s_blob_len, __pyx_n_s_name_3, __pyx_n_s_blob_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_publickey_pyx, __pyx_n_s_remove, 158, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 158, __pyx_L1_error)
+
+  /* "ssh2/publickey.pyx":168
+ *         return handle_error_codes(rc)
+ * 
+ *     def list_fetch(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long num_keys = 0
+ *         cdef c_pkey.libssh2_publickey_list **pkey_list = NULL
+ */
+  __pyx_tuple__16 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_num_keys, __pyx_n_s_pkey_list, __pyx_n_s_rc, __pyx_n_s_keys, __pyx_n_s_i); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_publickey_pyx, __pyx_n_s_list_fetch, 168, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(1, 168, __pyx_L1_error)
+
+  /* "ssh2/publickey.pyx":183
+ *         return keys
+ * 
+ *     def list_free(self):             # <<<<<<<<<<<<<<
+ *         """No-op - list_free called automatically by
+ *         :py:class:`ssh2.publickey.PublicKeyList` destructor"""
+ */
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_publickey_pyx, __pyx_n_s_list_free, 183, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(1, 183, __pyx_L1_error)
+
+  /* "ssh2/publickey.pyx":188
+ *         pass
+ * 
+ *     def shutdown(self):             # <<<<<<<<<<<<<<
+ *         """Shutdown public key subsystem.
+ *         Called automatically by object destructor"""
+ */
+  __pyx_tuple__19 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_publickey_pyx, __pyx_n_s_shutdown, 188, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 188, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
 }
+/* #### Code section: init_constants ### */
 
-static void __pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem(PyObject *o) {
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
-  #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
-  }
-  #endif
-  PyObject_GC_UnTrack(o);
-  {
-    PyObject *etype, *eval, *etb;
-    PyErr_Fetch(&etype, &eval, &etb);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
-    __pyx_pw_4ssh2_9publickey_15PublicKeySystem_3__dealloc__(o);
-    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
-    PyErr_Restore(etype, eval, etb);
-  }
-  Py_CLEAR(p->session);
-  (*Py_TYPE(o)->tp_free)(o);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error);
+  return 0;
+  __pyx_L1_error:;
+  return -1;
 }
+/* #### Code section: init_globals ### */
 
-static int __pyx_tp_traverse_4ssh2_9publickey_PublicKeySystem(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
-  if (p->session) {
-    e = (*v)(((PyObject *)p->session), a); if (e) return e;
-  }
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
   return 0;
 }
+/* #### Code section: init_module ### */
 
-static int __pyx_tp_clear_4ssh2_9publickey_PublicKeySystem(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *p = (struct __pyx_obj_4ssh2_9publickey_PublicKeySystem *)o;
-  tmp = ((PyObject*)p->session);
-  p->session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
   return 0;
 }
 
-static PyMethodDef __pyx_methods_4ssh2_9publickey_PublicKeySystem[] = {
-  {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_5add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_4add},
-  {"remove", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_7remove, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_6remove},
-  {"list_fetch", (PyCFunction)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_9list_fetch, METH_NOARGS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_8list_fetch},
-  {"list_free", (PyCFunction)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_11list_free, METH_NOARGS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_10list_free},
-  {"shutdown", (PyCFunction)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_13shutdown, METH_NOARGS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_12shutdown},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_14__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__, METH_O, __pyx_doc_4ssh2_9publickey_15PublicKeySystem_16__setstate_cython__},
-  {0, 0, 0, 0}
-};
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-static PyTypeObject __pyx_type_4ssh2_9publickey_PublicKeySystem = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.publickey.PublicKeySystem", /*tp_name*/
-  sizeof(struct __pyx_obj_4ssh2_9publickey_PublicKeySystem), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4ssh2_9publickey_PublicKeySystem, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  if (__Pyx_ExportFunction("PyPublicKeyList", (void (*)(void))__pyx_f_4ssh2_9publickey_PyPublicKeyList, "PyObject *(libssh2_publickey_list *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ExportFunction("PyPublicKeySystem", (void (*)(void))__pyx_f_4ssh2_9publickey_PyPublicKeySystem, "PyObject *(LIBSSH2_PUBLICKEY *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_9publickey_PublicKeyList = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_9publickey_PublicKeyList_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_9publickey_PublicKeyList)) __PYX_ERR(1, 30, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_9publickey_PublicKeyList_spec, __pyx_ptype_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_9publickey_PublicKeyList = &__pyx_type_4ssh2_9publickey_PublicKeyList;
   #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
+  #if !CYTHON_COMPILING_IN_LIMITED_API
   #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "Public Key subsystem. Methods for managing public keys on remote\n    server, like with the ``ssh-*-id`` utilities.\n    Not related to pkey authentication.", /*tp_doc*/
-  __pyx_tp_traverse_4ssh2_9publickey_PublicKeySystem, /*tp_traverse*/
-  __pyx_tp_clear_4ssh2_9publickey_PublicKeySystem, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  __pyx_methods_4ssh2_9publickey_PublicKeySystem, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4ssh2_9publickey_PublicKeySystem, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
   #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_9publickey_PublicKeyList->tp_print = 0;
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_9publickey_PublicKeyList->tp_dictoffset && __pyx_ptype_4ssh2_9publickey_PublicKeyList->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_9publickey_PublicKeyList->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeyList, (PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
   #endif
-};
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_9publickey_PublicKeyAttribute_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute)) __PYX_ERR(1, 64, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_9publickey_PublicKeyAttribute_spec, __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute = &__pyx_type_4ssh2_9publickey_PublicKeyAttribute;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_9publickey_PublicKeyAttribute->tp_dictoffset && __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeyAttribute, (PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_9publickey_PublicKeySystem = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_9publickey_PublicKeySystem_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_9publickey_PublicKeySystem)) __PYX_ERR(1, 122, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_9publickey_PublicKeySystem_spec, __pyx_ptype_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_9publickey_PublicKeySystem = &__pyx_type_4ssh2_9publickey_PublicKeySystem;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_9publickey_PublicKeySystem->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_9publickey_PublicKeySystem->tp_dictoffset && __pyx_ptype_4ssh2_9publickey_PublicKeySystem->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_9publickey_PublicKeySystem->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeySystem, (PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
+  #endif
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_variable_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
 
-static PyMethodDef __pyx_methods[] = {
-  {0, 0, 0, 0}
-};
 
 #if PY_MAJOR_VERSION >= 3
 #if CYTHON_PEP489_MULTI_PHASE_INIT
@@ -5554,1463 +8201,3563 @@ static PyModuleDef_Slot __pyx_moduledef_slots[] = {
 };
 #endif
 
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "publickey",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
   #else
-    NULL, /* m_reload */
+  static struct PyModuleDef __pyx_moduledef =
   #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
+  {
+      PyModuleDef_HEAD_INIT,
+      "publickey",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
 #endif
-#ifndef CYTHON_SMALL_CODE
-#if defined(__clang__)
-    #define CYTHON_SMALL_CODE
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-    #define CYTHON_SMALL_CODE __attribute__((cold))
+#endif
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
 #else
-    #define CYTHON_SMALL_CODE
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
 #endif
 #endif
 
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_kp_s_No_value_specified_for_struct_at, __pyx_k_No_value_specified_for_struct_at, sizeof(__pyx_k_No_value_specified_for_struct_at), 0, 0, 1, 0},
-  {&__pyx_kp_s_No_value_specified_for_struct_at_2, __pyx_k_No_value_specified_for_struct_at_2, sizeof(__pyx_k_No_value_specified_for_struct_at_2), 0, 0, 1, 0},
-  {&__pyx_kp_s_No_value_specified_for_struct_at_3, __pyx_k_No_value_specified_for_struct_at_3, sizeof(__pyx_k_No_value_specified_for_struct_at_3), 0, 0, 1, 0},
-  {&__pyx_kp_s_No_value_specified_for_struct_at_4, __pyx_k_No_value_specified_for_struct_at_4, sizeof(__pyx_k_No_value_specified_for_struct_at_4), 0, 0, 1, 0},
-  {&__pyx_kp_s_No_value_specified_for_struct_at_5, __pyx_k_No_value_specified_for_struct_at_5, sizeof(__pyx_k_No_value_specified_for_struct_at_5), 0, 0, 1, 0},
-  {&__pyx_n_s_PublicKeyAttribute, __pyx_k_PublicKeyAttribute, sizeof(__pyx_k_PublicKeyAttribute), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyList, __pyx_k_PublicKeyList, sizeof(__pyx_k_PublicKeyList), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeySystem, __pyx_k_PublicKeySystem, sizeof(__pyx_k_PublicKeySystem), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
-  {&__pyx_n_s_attr, __pyx_k_attr, sizeof(__pyx_k_attr), 0, 0, 1, 1},
-  {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
-  {&__pyx_n_s_blob, __pyx_k_blob, sizeof(__pyx_k_blob), 0, 0, 1, 1},
-  {&__pyx_n_s_blob_len, __pyx_k_blob_len, sizeof(__pyx_k_blob_len), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_mandatory, __pyx_k_mandatory, sizeof(__pyx_k_mandatory), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
-  {&__pyx_n_s_name_len, __pyx_k_name_len, sizeof(__pyx_k_name_len), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_num_attrs, __pyx_k_num_attrs, sizeof(__pyx_k_num_attrs), 0, 0, 1, 1},
-  {&__pyx_n_s_overwrite, __pyx_k_overwrite, sizeof(__pyx_k_overwrite), 0, 0, 1, 1},
-  {&__pyx_n_s_pkey_s, __pyx_k_pkey_s, sizeof(__pyx_k_pkey_s), 0, 0, 1, 1},
-  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
-  {&__pyx_n_s_value_len, __pyx_k_value_len, sizeof(__pyx_k_value_len), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
-static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
-  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 106, __pyx_L1_error)
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 107, __pyx_L1_error)
-  __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 18, __pyx_L1_error)
-  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 19, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__4);
-  __Pyx_GIVEREF(__pyx_tuple__4);
-
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__5);
-  __Pyx_GIVEREF(__pyx_tuple__5);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
-
-  /* "FromPyStructUtility":19
- *         value = obj['name']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name'")             # <<<<<<<<<<<<<<
- *     result.name = value
- *     try:
- */
-  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__7);
-  __Pyx_GIVEREF(__pyx_tuple__7);
-
-  /* "FromPyStructUtility":24
- *         value = obj['name_len']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'name_len'")             # <<<<<<<<<<<<<<
- *     result.name_len = value
- *     try:
- */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_2); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
 
-  /* "FromPyStructUtility":29
- *         value = obj['value']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value'")             # <<<<<<<<<<<<<<
- *     result.value = value
- *     try:
- */
-  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_3); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 29, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__9);
-  __Pyx_GIVEREF(__pyx_tuple__9);
+#if PY_MAJOR_VERSION < 3
+__Pyx_PyMODINIT_FUNC initpublickey(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initpublickey(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_publickey(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_publickey(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    #if PY_VERSION_HEX >= 0x030700A1
+    static PY_INT64_T main_interpreter_id = -1;
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return (unlikely(current_id == -1)) ? -1 : 0;
+    } else if (unlikely(main_interpreter_id != current_id))
+    #else
+    static PyInterpreterState *main_interpreter = NULL;
+    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
+    if (!main_interpreter) {
+        main_interpreter = current_interpreter;
+    } else if (unlikely(main_interpreter != current_interpreter))
+    #endif
+    {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
+            result = PyDict_SetItemString(moddict, to_name, value);
+#endif
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+#endif
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
 
-  /* "FromPyStructUtility":34
- *         value = obj['value_len']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'value_len'")             # <<<<<<<<<<<<<<
- *     result.value_len = value
- *     try:
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_publickey(PyObject *__pyx_pyinit_module)
+#endif
+#endif
+{
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module 'publickey' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #elif PY_MAJOR_VERSION >= 3
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("publickey", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "publickey" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #if CYTHON_REFNANNY
+__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+if (!__Pyx_RefNanny) {
+  PyErr_Clear();
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+  if (!__Pyx_RefNanny)
+      Py_FatalError("failed to import 'refnanny' module");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_publickey(void)", 0);
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #ifdef __Pxy_PyFrame_Initialize_Offsets
+  __Pxy_PyFrame_Initialize_Offsets();
+  #endif
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_AsyncGen_USED
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  PyEval_InitThreads();
+  #endif
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_ssh2__publickey) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "ssh2.publickey")) {
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.publickey", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code();
+  (void)__Pyx_modinit_variable_export_code();
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code();
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
  */
-  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_4); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__10);
-  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_13PublicKeyList_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeyList___reduce_cython, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "FromPyStructUtility":39
- *         value = obj['mandatory']
- *     except KeyError:
- *         raise ValueError("No value specified for struct attribute 'mandatory'")             # <<<<<<<<<<<<<<
- *     result.mandatory = value
- *     return result
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_5); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 39, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__11);
-  __Pyx_GIVEREF(__pyx_tuple__11);
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_13PublicKeyList_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeyList___setstate_cython, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_18PublicKeyAttribute_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeyAttribute___reduce_cyth, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_18PublicKeyAttribute_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeyAttribute___setstate_cy, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/publickey.pyx":139
+ *         self.pkey_s = NULL
+ * 
+ *     def add(self, bytes name, bytes blob,             # <<<<<<<<<<<<<<
+ *             char overwrite,
+ *             list attrs):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_5add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem_add, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem, __pyx_n_s_add, __pyx_t_2) < 0) __PYX_ERR(1, 139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+
+  /* "ssh2/publickey.pyx":158
+ *         return handle_error_codes(rc)
+ * 
+ *     def remove(self, bytes name, bytes blob):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long name_len = len(name)
+ *         cdef unsigned long blob_len = len(blob)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_7remove, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem_remove, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem, __pyx_n_s_remove, __pyx_t_2) < 0) __PYX_ERR(1, 158, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+
+  /* "ssh2/publickey.pyx":168
+ *         return handle_error_codes(rc)
+ * 
+ *     def list_fetch(self):             # <<<<<<<<<<<<<<
+ *         cdef unsigned long num_keys = 0
+ *         cdef c_pkey.libssh2_publickey_list **pkey_list = NULL
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_9list_fetch, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem_list_fetch, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem, __pyx_n_s_list_fetch, __pyx_t_2) < 0) __PYX_ERR(1, 168, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+
+  /* "ssh2/publickey.pyx":183
+ *         return keys
+ * 
+ *     def list_free(self):             # <<<<<<<<<<<<<<
+ *         """No-op - list_free called automatically by
+ *         :py:class:`ssh2.publickey.PublicKeyList` destructor"""
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_11list_free, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem_list_free, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem, __pyx_n_s_list_free, __pyx_t_2) < 0) __PYX_ERR(1, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+
+  /* "ssh2/publickey.pyx":188
+ *         pass
+ * 
+ *     def shutdown(self):             # <<<<<<<<<<<<<<
+ *         """Shutdown public key subsystem.
+ *         Called automatically by object destructor"""
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_13shutdown, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem_shutdown, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_9publickey_PublicKeySystem, __pyx_n_s_shutdown, __pyx_t_2) < 0) __PYX_ERR(1, 188, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_9publickey_PublicKeySystem);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem___reduce_cython, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_9publickey_15PublicKeySystem_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PublicKeySystem___setstate_cytho, NULL, __pyx_n_s_ssh2_publickey, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/publickey.pyx":1
+ * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
+ * # Copyright (C) 2017-2020 Panos Kittenis
+ * #
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  if (__pyx_m) {
+    if (__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init ssh2.publickey", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init ssh2.publickey");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #elif PY_MAJOR_VERSION >= 3
+  return __pyx_m;
+  #else
+  return;
+  #endif
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* DictGetItem */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            if (unlikely(PyTuple_Check(key))) {
+                PyObject* args = PyTuple_Pack(1, key);
+                if (likely(args)) {
+                    PyErr_SetObject(PyExc_KeyError, args);
+                    Py_DECREF(args);
+                }
+            } else {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#endif
+
+/* GetTopmostException */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+/* SaveResetException */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #endif
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+  #endif
+}
+#endif
+
+/* GetException */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+  #endif
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
+    }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* RaiseException */
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
 }
+#endif
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
-  return 0;
-  __pyx_L1_error:;
-  return -1;
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
 }
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
 
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
-
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
 }
 
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
 }
 
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  if (__Pyx_ExportFunction("PyPublicKeyList", (void (*)(void))__pyx_f_4ssh2_9publickey_PyPublicKeyList, "PyObject *(libssh2_publickey_list *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ExportFunction("PyPublicKeySystem", (void (*)(void))__pyx_f_4ssh2_9publickey_PyPublicKeySystem, "PyObject *(LIBSSH2_PUBLICKEY *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
 }
+#endif
+#endif
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_9publickey_PublicKeyList.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_9publickey_PublicKeyList.tp_dictoffset && __pyx_type_4ssh2_9publickey_PublicKeyList.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_9publickey_PublicKeyList.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeyList, (PyObject *)&__pyx_type_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_9publickey_PublicKeyList) < 0) __PYX_ERR(1, 30, __pyx_L1_error)
-  __pyx_ptype_4ssh2_9publickey_PublicKeyList = &__pyx_type_4ssh2_9publickey_PublicKeyList;
-  if (PyType_Ready(&__pyx_type_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_9publickey_PublicKeyAttribute.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_9publickey_PublicKeyAttribute.tp_dictoffset && __pyx_type_4ssh2_9publickey_PublicKeyAttribute.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_9publickey_PublicKeyAttribute.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeyAttribute, (PyObject *)&__pyx_type_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_9publickey_PublicKeyAttribute) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
-  __pyx_ptype_4ssh2_9publickey_PublicKeyAttribute = &__pyx_type_4ssh2_9publickey_PublicKeyAttribute;
-  if (PyType_Ready(&__pyx_type_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_9publickey_PublicKeySystem.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_9publickey_PublicKeySystem.tp_dictoffset && __pyx_type_4ssh2_9publickey_PublicKeySystem.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_9publickey_PublicKeySystem.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PublicKeySystem, (PyObject *)&__pyx_type_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_9publickey_PublicKeySystem) < 0) __PYX_ERR(1, 122, __pyx_L1_error)
-  __pyx_ptype_4ssh2_9publickey_PublicKeySystem = &__pyx_type_4ssh2_9publickey_PublicKeySystem;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
 }
 
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
-  __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
 }
 
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
 }
 
-static int __Pyx_modinit_function_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
-  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
+/* ArgTypeTest */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
+        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
 }
 
-
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
 #else
-#define __Pyx_PyMODINIT_FUNC void
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
 #endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
 #else
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
 #else
-#define __Pyx_PyMODINIT_FUNC PyObject *
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
 #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
 #endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
+#endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
 
-
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC initpublickey(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC initpublickey(void)
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
 #else
-__Pyx_PyMODINIT_FUNC PyInit_publickey(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit_publickey(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
     #else
-    static PyInterpreterState *main_interpreter = NULL;
-    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
-    if (!main_interpreter) {
-        main_interpreter = current_interpreter;
-    } else if (unlikely(main_interpreter != current_interpreter))
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
     #endif
-    {
-        PyErr_SetString(
-            PyExc_ImportError,
-            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
-        return -1;
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
     }
-    return 0;
-}
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
-    PyObject *value = PyObject_GetAttrString(spec, from_name);
-    int result = 0;
-    if (likely(value)) {
-        if (allow_none || value != Py_None) {
-            result = PyDict_SetItemString(moddict, to_name, value);
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
         }
-        Py_DECREF(value);
-    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Clear();
-    } else {
-        result = -1;
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
     }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
-    PyObject *module = NULL, *moddict, *modname;
-    if (__Pyx_check_single_interpreter())
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
-    if (__pyx_m)
-        return __Pyx_NewRef(__pyx_m);
-    modname = PyObject_GetAttrString(spec, "name");
-    if (unlikely(!modname)) goto bad;
-    module = PyModule_NewObject(modname);
-    Py_DECREF(modname);
-    if (unlikely(!module)) goto bad;
-    moddict = PyModule_GetDict(module);
-    if (unlikely(!moddict)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
-    return module;
-bad:
-    Py_XDECREF(module);
-    return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
 }
-
-
-static CYTHON_SMALL_CODE int __pyx_pymod_exec_publickey(PyObject *__pyx_pyinit_module)
-#endif
 #endif
-{
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  if (__pyx_m) {
-    if (__pyx_m == __pyx_pyinit_module) return 0;
-    PyErr_SetString(PyExc_RuntimeError, "Module 'publickey' has already been imported. Re-initialisation is not supported.");
-    return -1;
-  }
-  #elif PY_MAJOR_VERSION >= 3
-  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
-  #endif
-  #if CYTHON_REFNANNY
-__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
-if (!__Pyx_RefNanny) {
-  PyErr_Clear();
-  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
-  if (!__Pyx_RefNanny)
-      Py_FatalError("failed to import 'refnanny' module");
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
 }
 #endif
-  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_publickey(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #ifdef __Pxy_PyFrame_Initialize_Offsets
-  __Pxy_PyFrame_Initialize_Offsets();
-  #endif
-  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  /*--- Library function declarations ---*/
-  /*--- Threads initialization code ---*/
-  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
-  PyEval_InitThreads();
-  #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("publickey", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
-  /*--- Initialize various global constants etc. ---*/
-  if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
-  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  if (__pyx_module_is_main_ssh2__publickey) {
-    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  }
-  #if PY_MAJOR_VERSION >= 3
-  {
-    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "ssh2.publickey")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.publickey", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
     }
-  }
-  #endif
-  /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  /*--- Global type/function init code ---*/
-  (void)__Pyx_modinit_global_init_code();
-  (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  /*--- Execution code ---*/
-  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
-  if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-
-  /* "ssh2/publickey.pyx":1
- * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
- * # Copyright (C) 2017-2020 Panos Kittenis
- * #
- */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  /* "FromPyStructUtility":11
- * 
- * @cname("__pyx_convert__from_py_libssh2_publickey_attribute")
- * cdef struct_type __pyx_convert__from_py_libssh2_publickey_attribute(obj) except *:             # <<<<<<<<<<<<<<
- *     cdef struct_type result
- *     if not PyMapping_Check(obj):
- */
-
-  /*--- Wrapped vars code ---*/
-
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  if (__pyx_m) {
-    if (__pyx_d) {
-      __Pyx_AddTraceback("init ssh2.publickey", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
     }
-    Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init ssh2.publickey");
-  }
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  return (__pyx_m != NULL) ? 0 : -1;
-  #elif PY_MAJOR_VERSION >= 3
-  return __pyx_m;
-  #else
-  return;
-  #endif
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
 
-/* --- Runtime support code --- */
-/* Refnanny */
-#if CYTHON_REFNANNY
-static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
-    PyObject *m = NULL, *p = NULL;
-    void *r = NULL;
-    m = PyImport_ImportModule(modname);
-    if (!m) goto end;
-    p = PyObject_GetAttrString(m, "RefNannyAPI");
-    if (!p) goto end;
-    r = PyLong_AsVoidPtr(p);
-end:
-    Py_XDECREF(p);
-    Py_XDECREF(m);
-    return (__Pyx_RefNannyAPIStruct *)r;
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
-#endif
-    return PyObject_GetAttr(obj, attr_name);
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
 #if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
 #endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
     }
-    return result;
+#endif
+    *method = attr;
+    return 0;
 }
 
-/* RaiseDoubleKeywords */
-static void __Pyx_RaiseDoubleKeywordsError(
-    const char* func_name,
-    PyObject* kw_name)
-{
-    PyErr_Format(PyExc_TypeError,
-        #if PY_MAJOR_VERSION >= 3
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
-        #else
-        "%s() got multiple values for keyword argument '%s'", func_name,
-        PyString_AsString(kw_name));
-        #endif
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
 }
 
-/* ParseKeywords */
-static int __Pyx_ParseOptionalKeywords(
-    PyObject *kwds,
-    PyObject **argnames[],
-    PyObject *kwds2,
-    PyObject *values[],
-    Py_ssize_t num_pos_args,
-    const char* function_name)
-{
-    PyObject *key = 0, *value = 0;
-    Py_ssize_t pos = 0;
-    PyObject*** name;
-    PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
-        while (*name && (**name != key)) name++;
-        if (*name) {
-            values[name-argnames] = value;
-            continue;
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
-        name = first_kw_arg;
-        #if PY_MAJOR_VERSION < 3
-        if (likely(PyString_Check(key))) {
-            while (*name) {
-                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
-                        && _PyString_Eq(**name, key)) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    if ((**argname == key) || (
-                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
-                             && _PyString_Eq(**argname, key))) {
-                        goto arg_passed_twice;
-                    }
-                    argname++;
-                }
-            }
-        } else
-        #endif
-        if (likely(PyUnicode_Check(key))) {
-            while (*name) {
-                int cmp = (**name == key) ? 0 :
-                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                #endif
-                    PyUnicode_Compare(**name, key);
-                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                if (cmp == 0) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    int cmp = (**argname == key) ? 0 :
-                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                    #endif
-                        PyUnicode_Compare(**argname, key);
-                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                    if (cmp == 0) goto arg_passed_twice;
-                    argname++;
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
                 }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
             }
-        } else
-            goto invalid_keyword_type;
-        if (kwds2) {
-            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
-        } else {
-            goto invalid_keyword;
         }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
     }
     return 0;
-arg_passed_twice:
-    __Pyx_RaiseDoubleKeywordsError(function_name, key);
-    goto bad;
-invalid_keyword_type:
-    PyErr_Format(PyExc_TypeError,
-        "%.200s() keywords must be strings", function_name);
-    goto bad;
-invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
-    #if PY_MAJOR_VERSION < 3
-        "%.200s() got an unexpected keyword argument '%.200s'",
-        function_name, PyString_AsString(key));
-    #else
-        "%s() got an unexpected keyword argument '%U'",
-        function_name, key);
-    #endif
-bad:
-    return -1;
 }
+#endif
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
-{
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
-    }
-    if (exact) {
-        more_or_less = "exactly";
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
     }
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                 func_name, more_or_less, num_expected,
-                 (num_expected == 1) ? "" : "s", num_found);
+#endif
+    return r;
+#endif
 }
 
-/* ArgTypeTest */
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
-{
-    if (unlikely(!type)) {
-        PyErr_SetString(PyExc_SystemError, "Missing type object");
-        return 0;
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
     }
-    else if (exact) {
-        #if PY_MAJOR_VERSION == 2
-        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
-        #endif
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
     }
-    else {
-        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
     }
-    PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
-    return 0;
+    return descr;
 }
+#endif
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
     }
-    return result;
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
 }
 #endif
 
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
 }
-#endif
-
-/* RaiseException */
-#if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
-    __Pyx_PyThreadState_declare
-    Py_XINCREF(type);
-    if (!value || value == Py_None)
-        value = NULL;
-    else
-        Py_INCREF(value);
-    if (!tb || tb == Py_None)
-        tb = NULL;
-    else {
-        Py_INCREF(tb);
-        if (!PyTraceBack_Check(tb)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: arg 3 must be a traceback or None");
-            goto raise_error;
-        }
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
     }
-    if (PyType_Check(type)) {
-#if CYTHON_COMPILING_IN_PYPY
-        if (!value) {
-            Py_INCREF(Py_None);
-            value = Py_None;
-        }
 #endif
-        PyErr_NormalizeException(&type, &value, &tb);
-    } else {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto raise_error;
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
         }
-        value = type;
-        type = (PyObject*) Py_TYPE(type);
-        Py_INCREF(type);
-        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: exception class must be a subclass of BaseException");
-            goto raise_error;
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
         }
     }
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrRestore(type, value, tb);
-    return;
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(tb);
-    return;
-}
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
 #else
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
-    PyObject* owned_instance = NULL;
-    if (tb == Py_None) {
-        tb = 0;
-    } else if (tb && !PyTraceBack_Check(tb)) {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: arg 3 must be a traceback or None");
-        goto bad;
-    }
-    if (value == Py_None)
-        value = 0;
-    if (PyExceptionInstance_Check(type)) {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto bad;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(value);
-    } else if (PyExceptionClass_Check(type)) {
-        PyObject *instance_class = NULL;
-        if (value && PyExceptionInstance_Check(value)) {
-            instance_class = (PyObject*) Py_TYPE(value);
-            if (instance_class != type) {
-                int is_subclass = PyObject_IsSubclass(instance_class, type);
-                if (!is_subclass) {
-                    instance_class = NULL;
-                } else if (unlikely(is_subclass == -1)) {
-                    goto bad;
-                } else {
-                    type = instance_class;
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
                 }
             }
+            PyType_Modified((PyTypeObject*)type_obj);
         }
-        if (!instance_class) {
-            PyObject *args;
-            if (!value)
-                args = PyTuple_New(0);
-            else if (PyTuple_Check(value)) {
-                Py_INCREF(value);
-                args = value;
-            } else
-                args = PyTuple_Pack(1, value);
-            if (!args)
-                goto bad;
-            owned_instance = PyObject_Call(type, args, NULL);
-            Py_DECREF(args);
-            if (!owned_instance)
-                goto bad;
-            value = owned_instance;
-            if (!PyExceptionInstance_Check(value)) {
-                PyErr_Format(PyExc_TypeError,
-                             "calling %R should have returned an instance of "
-                             "BaseException, not %R",
-                             type, Py_TYPE(value));
-                goto bad;
-            }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
+{
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
         }
-    } else {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: exception class must be a subclass of BaseException");
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
         goto bad;
     }
-    if (cause) {
-        PyObject *fixed_cause;
-        if (cause == Py_None) {
-            fixed_cause = NULL;
-        } else if (PyExceptionClass_Check(cause)) {
-            fixed_cause = PyObject_CallObject(cause, NULL);
-            if (fixed_cause == NULL)
-                goto bad;
-        } else if (PyExceptionInstance_Check(cause)) {
-            fixed_cause = cause;
-            Py_INCREF(fixed_cause);
-        } else {
-            PyErr_SetString(PyExc_TypeError,
-                            "exception causes must derive from "
-                            "BaseException");
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
             goto bad;
         }
-        PyException_SetCause(value, fixed_cause);
+        goto done;
     }
-    PyErr_SetObject(type, value);
-    if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
 #else
-        PyThreadState *tstate = __Pyx_PyThreadState_Current;
-        PyObject* tmp_tb = tstate->curexc_traceback;
-        if (tb != tmp_tb) {
-            Py_INCREF(tb);
-            tstate->curexc_traceback = tb;
-            Py_XDECREF(tmp_tb);
-        }
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
 #endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
     }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
 bad:
-    Py_XDECREF(owned_instance);
-    return;
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
 }
 #endif
 
-/* WriteUnraisableException */
-static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
-                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
-                                  int full_traceback, CYTHON_UNUSED int nogil) {
-    PyObject *old_exc, *old_val, *old_tb;
-    PyObject *ctx;
-    __Pyx_PyThreadState_declare
-#ifdef WITH_THREAD
-    PyGILState_STATE state;
-    if (nogil)
-        state = PyGILState_Ensure();
-#ifdef _MSC_VER
-    else state = (PyGILState_STATE)-1;
-#endif
-#endif
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
-    if (full_traceback) {
-        Py_XINCREF(old_exc);
-        Py_XINCREF(old_val);
-        Py_XINCREF(old_tb);
-        __Pyx_ErrRestore(old_exc, old_val, old_tb);
-        PyErr_PrintEx(1);
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
     }
-    #if PY_MAJOR_VERSION < 3
-    ctx = PyString_FromString(name);
-    #else
-    ctx = PyUnicode_FromString(name);
-    #endif
-    __Pyx_ErrRestore(old_exc, old_val, old_tb);
-    if (!ctx) {
-        PyErr_WriteUnraisable(Py_None);
-    } else {
-        PyErr_WriteUnraisable(ctx);
-        Py_DECREF(ctx);
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
     }
-#ifdef WITH_THREAD
-    if (nogil)
-        PyGILState_Release(state);
-#endif
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
 }
+#endif
 
-/* DictGetItem */
-#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
-static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
-    PyObject *value;
-    value = PyDict_GetItemWithError(d, key);
-    if (unlikely(!value)) {
-        if (!PyErr_Occurred()) {
-            if (unlikely(PyTuple_Check(key))) {
-                PyObject* args = PyTuple_Pack(1, key);
-                if (likely(args)) {
-                    PyErr_SetObject(PyExc_KeyError, args);
-                    Py_DECREF(args);
-                }
-            } else {
-                PyErr_SetObject(PyExc_KeyError, key);
-            }
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
         }
-        return NULL;
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
     }
     Py_INCREF(value);
-    return value;
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
 }
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #endif
-
-/* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem *
-__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
-           exc_info->previous_item != NULL)
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
     {
-        exc_info = exc_info->previous_item;
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
     }
-    return exc_info;
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
 }
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
 #endif
-
-/* SaveResetException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
-    *type = exc_info->exc_type;
-    *value = exc_info->exc_value;
-    *tb = exc_info->exc_traceback;
-    #else
-    *type = tstate->exc_type;
-    *value = tstate->exc_value;
-    *tb = tstate->exc_traceback;
-    #endif
-    Py_XINCREF(*type);
-    Py_XINCREF(*value);
-    Py_XINCREF(*tb);
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
 }
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = type;
-    exc_info->exc_value = value;
-    exc_info->exc_traceback = tb;
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
     #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = type;
-    tstate->exc_value = value;
-    tstate->exc_traceback = tb;
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
     #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+    Py_DECREF(res);
+    return result;
 }
-#endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
     }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
     }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
     return 0;
 }
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
 }
-#endif
-
-/* GetException */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
 #else
-static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
 #endif
-{
-    PyObject *local_type, *local_value, *local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    local_type = tstate->curexc_type;
-    local_value = tstate->curexc_value;
-    local_tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-#else
-    PyErr_Fetch(&local_type, &local_value, &local_tb);
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
 #endif
-    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
-    if (unlikely(tstate->curexc_type))
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
 #else
-    if (unlikely(PyErr_Occurred()))
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
 #endif
-        goto bad;
-    #if PY_MAJOR_VERSION >= 3
-    if (local_tb) {
-        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
-            goto bad;
-    }
-    #endif
-    Py_XINCREF(local_tb);
-    Py_XINCREF(local_type);
-    Py_XINCREF(local_value);
-    *type = local_type;
-    *value = local_value;
-    *tb = local_tb;
-#if CYTHON_FAST_THREAD_STATE
-    #if CYTHON_USE_EXC_INFO_STACK
-    {
-        _PyErr_StackItem *exc_info = tstate->exc_info;
-        tmp_type = exc_info->exc_type;
-        tmp_value = exc_info->exc_value;
-        tmp_tb = exc_info->exc_traceback;
-        exc_info->exc_type = local_type;
-        exc_info->exc_value = local_value;
-        exc_info->exc_traceback = local_tb;
-    }
-    #else
-    tmp_type = tstate->exc_type;
-    tmp_value = tstate->exc_value;
-    tmp_tb = tstate->exc_traceback;
-    tstate->exc_type = local_type;
-    tstate->exc_value = local_value;
-    tstate->exc_traceback = local_tb;
-    #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
 #else
-    PyErr_SetExcInfo(local_type, local_value, local_tb);
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
 #endif
-    return 0;
-bad:
-    *type = 0;
-    *value = 0;
-    *tb = 0;
-    Py_XDECREF(local_type);
-    Py_XDECREF(local_value);
-    Py_XDECREF(local_tb);
-    return -1;
-}
-
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
 #if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
 #endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
-    }
-    return descr;
 }
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
 #endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
-}
 #endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+    return (PyObject *) op;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
     }
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
     }
-    return result;
+    return 0;
 }
-
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
 #else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
     }
-#endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+            return NULL;
         }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
     }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    self = ((PyCFunctionObject*)func)->m_self;
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
         }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
-#endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
     return ret;
 }
-
-/* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
 {
-    PyObject *result = 0;
-    char warning[200];
-    Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
-    PyObject *py_basicsize;
-#endif
-    result = PyObject_GetAttrString(module, class_name);
-    if (!result)
-        goto bad;
-    if (!PyType_Check(result)) {
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
         PyErr_Format(PyExc_TypeError,
-            "%.200s.%.200s is not a type object",
-            module_name, class_name);
-        goto bad;
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-#ifndef Py_LIMITED_API
-    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
-#endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
 }
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
 #endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
 
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -7040,12 +11787,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -7059,7 +11807,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -7081,6 +11829,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -7159,17 +11908,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -7204,6 +12037,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -7219,7 +12053,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -7266,6 +12100,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -7289,6 +12124,17 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
         return (target_type) value;\
     }
 
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
 /* CIntFromPy */
 static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -7302,7 +12148,7 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(char) < sizeof(long)) {
+        if ((sizeof(char) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -7311,168 +12157,239 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
             }
             return (char) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        char val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (char) -1;
+        val = __Pyx_PyInt_As_char(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (char) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) {
                             return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) {
                             return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) >= 4 * PyLong_SHIFT)) {
                             return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (char) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (char) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(char) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(char) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (char) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(char,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
                             return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(char) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
                             return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
                             return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(char) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
                             return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) {
                             return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(char) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) {
                             return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(char) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
+        if ((sizeof(char) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        char val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (char) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            char val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (char) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (char) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (char) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((char) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((char) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (char) -1;
-        }
-    } else {
-        char val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (char) -1;
-        val = __Pyx_PyInt_As_char(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -7516,10 +12433,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -7554,10 +12504,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(char),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(char));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -7574,7 +12557,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -7583,168 +12566,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -7770,7 +12824,7 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned long) < sizeof(long)) {
+        if ((sizeof(unsigned long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -7779,168 +12833,239 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
             }
             return (unsigned long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned long) -1;
+        val = __Pyx_PyInt_As_unsigned_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned long) 1) << (sizeof(unsigned long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned long) -1;
-        }
-    } else {
-        unsigned long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned long) -1;
-        val = __Pyx_PyInt_As_unsigned_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -7984,12 +13109,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name_2);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__23);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -8022,10 +13196,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -8042,7 +13249,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8051,168 +13258,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8238,7 +13516,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8247,168 +13525,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8425,7 +13774,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -8446,6 +13795,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -8470,11 +13835,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -8522,41 +13887,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -8578,11 +13952,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -8597,9 +13967,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -8616,7 +13986,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -8624,21 +13993,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -8651,9 +14005,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -8661,30 +14037,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -8739,7 +14119,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -8768,22 +14148,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -8849,13 +14233,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -8923,4 +14305,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/publickey.pxd b/ssh2/publickey.pxd
index ec334579..78bd5591 100644
--- a/ssh2/publickey.pxd
+++ b/ssh2/publickey.pxd
@@ -14,8 +14,8 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
-cimport c_pkey
+from .session cimport Session
+from . cimport c_pkey
 
 
 cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list)
diff --git a/ssh2/publickey.pyx b/ssh2/publickey.pyx
index 5ea44866..0102aa0a 100644
--- a/ssh2/publickey.pyx
+++ b/ssh2/publickey.pyx
@@ -16,9 +16,9 @@
 
 from libc.stdlib cimport malloc, free
 
-from session cimport Session
-from utils cimport to_bytes, handle_error_codes
-cimport c_pkey
+from .session cimport Session
+from .utils cimport to_bytes, handle_error_codes
+from . cimport c_pkey
 
 
 cdef object PyPublicKeyList(c_pkey.libssh2_publickey_list *_list):
diff --git a/ssh2/session.c b/ssh2/session.c
index 4083177e..376bfd45 100644
--- a/ssh2/session.c
+++ b/ssh2/session.c
@@ -1,22 +1,87 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.session",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/session.pyx"
+        ]
+    },
+    "module_name": "ssh2.session"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
+
+    #if PY_MAJOR_VERSION >= 3
+      #define __Pyx_PyFloat_FromString(obj)  PyFloat_FromString(obj)
+    #else
+      #define __Pyx_PyFloat_FromString(obj)  PyFloat_FromString(obj, NULL)
+    #endif
+    
+
+    #if PY_MAJOR_VERSION <= 2
+    #define PyDict_GetItemWithError _PyDict_GetItemWithError
+    #endif
+    
+
+    #if (PY_VERSION_HEX < 0x030700b1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600)) && !defined(PyContextVar_Get)
+    #define PyContextVar_Get(var, d, v)         ((d) ?             ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) :             ((v)[0] = NULL, 0)         )
+    #endif
+    
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +100,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +108,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +145,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +165,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +293,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +322,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +333,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +356,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +383,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +407,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +491,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +515,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +532,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +594,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +629,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +781,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +798,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +888,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +934,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +968,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1062,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1077,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1119,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1136,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1183,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1203,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,12 +1243,21 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
-  #ifdef __cplusplus
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
+  #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
     #define __PYX_EXTERN_C extern
@@ -800,9 +1326,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -820,9 +1347,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -830,13 +1357,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -860,8 +1381,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -882,7 +1449,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -912,6 +1479,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -947,25 +1515,23 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "stringsource",
+  "<stringsource>",
   "ssh2/session.pyx",
-  "env/lib/python3.9/site-packages/Cython/Includes/cpython/type.pxd",
-  "env/lib/python3.9/site-packages/Cython/Includes/cpython/bool.pxd",
-  "env/lib/python3.9/site-packages/Cython/Includes/cpython/complex.pxd",
+  "env/lib/python3.12/site-packages/Cython/Includes/cpython/contextvars.pxd",
+  "env/lib/python3.12/site-packages/Cython/Includes/cpython/type.pxd",
+  "env/lib/python3.12/site-packages/Cython/Includes/cpython/bool.pxd",
+  "env/lib/python3.12/site-packages/Cython/Includes/cpython/complex.pxd",
   "ssh2/agent.pxd",
   "ssh2/channel.pxd",
   "ssh2/listener.pxd",
@@ -974,6 +1540,12 @@ static const char *__pyx_f[] = {
   "ssh2/knownhost.pxd",
   "ssh2/fileinfo.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -981,11 +1553,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_5agent_Agent;
@@ -999,6 +1569,32 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo;
 struct __pyx_obj_4ssh2_7session_Session;
 struct __pyx_obj_4ssh2_7session_MethodType;
 struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive;
+struct __pyx_opt_args_7cpython_11contextvars_get_value;
+struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default;
+
+/* "cpython/contextvars.pxd":112
+ * 
+ * 
+ * cdef inline object get_value(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the default value of the context variable,
+ */
+struct __pyx_opt_args_7cpython_11contextvars_get_value {
+  int __pyx_n;
+  PyObject *default_value;
+};
+
+/* "cpython/contextvars.pxd":129
+ * 
+ * 
+ * cdef inline object get_value_no_default(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the provided default value if no such value was found.
+ */
+struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default {
+  int __pyx_n;
+  PyObject *default_value;
+};
 
 /* "agent.pxd":24
  * 
@@ -1097,7 +1693,7 @@ struct __pyx_obj_4ssh2_9knownhost_KnownHost {
 
 
 /* "fileinfo.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class FileInfo:             # <<<<<<<<<<<<<<
  *     """Representation of stat structure"""
@@ -1110,7 +1706,7 @@ struct __pyx_obj_4ssh2_8fileinfo_FileInfo {
 
 
 /* "ssh2/session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1137,7 +1733,7 @@ struct __pyx_obj_4ssh2_7session_MethodType {
 };
 
 
-/* "ssh2/session.pyx":312
+/* "ssh2/session.pyx":311
  *         return handle_error_codes(rc)
  * 
  *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
@@ -1149,6 +1745,7 @@ struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
   PyObject *__pyx_v_password;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1157,11 +1754,11 @@ struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1171,28 +1768,40 @@ struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1203,6 +1812,10 @@ struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1214,44 +1827,30 @@ struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1263,7 +1862,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1279,110 +1878,249 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
 #endif
-
-/* PyObjectCallMethO.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
 #endif
 
-/* PyObjectCallNoArg.proto */
+/* PyObjectCall.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
 #else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
 #endif
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
 
-/* UnpackUnboundCMethod.proto */
-typedef struct {
-    PyObject *type;
-    PyObject **method_name;
-    PyCFunction func;
-    PyObject *method;
-    int flag;
-} __Pyx_CachedCFunction;
-
-/* CallUnboundCMethod1.proto */
-static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg);
-#else
-#define __Pyx_CallUnboundCMethod1(cfunc, self, arg)  __Pyx__CallUnboundCMethod1(cfunc, self, arg)
-#endif
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
 
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
-/* None.proto */
+/* RaiseClosureNameError.proto */
 static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname);
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
 /* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
 static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
 
 /* CythonFunctionShared.proto */
-#define __Pyx_CyFunction_USED 1
+#define __Pyx_CyFunction_USED
 #define __Pyx_CYFUNCTION_STATICMETHOD  0x01
 #define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
 #define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
 #define __Pyx_CyFunction_GetClosure(f)\
     (((__pyx_CyFunctionObject *) (f))->func_closure)
-#define __Pyx_CyFunction_GetClassObj(f)\
-    (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
 #define __Pyx_CyFunction_Defaults(type, f)\
     ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
 #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
     ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
 typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
     PyCFunctionObject func;
-#if PY_VERSION_HEX < 0x030500A0
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
     PyObject *func_weakreflist;
 #endif
     PyObject *func_dict;
@@ -1392,23 +2130,32 @@ typedef struct {
     PyObject *func_globals;
     PyObject *func_code;
     PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
     PyObject *func_classobj;
+#endif
     void *defaults;
     int defaults_pyobjects;
-    size_t defaults_size;  // used by FusedFunction for copying defaults
+    size_t defaults_size;
     int flags;
     PyObject *defaults_tuple;
     PyObject *defaults_kwdict;
     PyObject *(*defaults_getter)(PyObject *);
     PyObject *func_annotations;
+    PyObject *func_is_coroutine;
 } __pyx_CyFunctionObject;
-static PyTypeObject *__pyx_CyFunctionType = 0;
-#define __Pyx_CyFunction_Check(obj)  (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
 static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
                                       int flags, PyObject* qualname,
-                                      PyObject *self,
+                                      PyObject *closure,
                                       PyObject *module, PyObject *globals,
                                       PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
 static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
                                                          size_t size,
                                                          int pyobjects);
@@ -1418,7 +2165,18 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
                                                              PyObject *dict);
 static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
                                                               PyObject *dict);
-static int __pyx_CyFunction_init(void);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
 
 /* CythonFunction.proto */
 static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
@@ -1444,7 +2202,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1459,6 +2217,9 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 #define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
 #endif
 
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1487,18 +2248,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* GetModuleGlobalName.proto */
 #if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
     static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
     (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1506,9 +2267,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
 /* ListCompAppend.proto */
 #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
 static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
@@ -1516,7 +2274,11 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len)) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
+        #endif
         __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
@@ -1526,8 +2288,22 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
 #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
 #endif
 
-/* IncludeStringH.proto */
-#include <string.h>
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
 
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
@@ -1543,29 +2319,28 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
 #endif
 
 /* Import.proto */
@@ -1582,6 +2357,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1595,18 +2371,19 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
 
 /* CIntFromPy.proto */
 static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
@@ -1626,339 +2403,435 @@ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *);
 /* CIntFromPy.proto */
 static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
 
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self); /* proto*/
+
+/* Module declarations from "ssh2" */
+
+/* Module declarations from "libc.stddef" */
+
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "cpython.version" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "__builtin__" */
 
-/* Module declarations from 'cpython.version' */
+/* Module declarations from "cpython.type" */
 
-/* Module declarations from '__builtin__' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'cpython.type' */
-static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+/* Module declarations from "libc.stdio" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "cpython.object" */
 
-/* Module declarations from 'libc.stdio' */
+/* Module declarations from "cpython.ref" */
 
-/* Module declarations from 'cpython.object' */
+/* Module declarations from "cpython.exc" */
 
-/* Module declarations from 'cpython.ref' */
+/* Module declarations from "cpython.module" */
 
-/* Module declarations from 'cpython.exc' */
+/* Module declarations from "cpython.mem" */
 
-/* Module declarations from 'cpython.module' */
+/* Module declarations from "cpython.tuple" */
 
-/* Module declarations from 'cpython.mem' */
+/* Module declarations from "cpython.list" */
 
-/* Module declarations from 'cpython.tuple' */
+/* Module declarations from "cpython.sequence" */
 
-/* Module declarations from 'cpython.list' */
+/* Module declarations from "cpython.mapping" */
 
-/* Module declarations from 'cpython.sequence' */
+/* Module declarations from "cpython.iterator" */
 
-/* Module declarations from 'cpython.mapping' */
+/* Module declarations from "cpython.number" */
 
-/* Module declarations from 'cpython.iterator' */
+/* Module declarations from "cpython.int" */
 
-/* Module declarations from 'cpython.number' */
+/* Module declarations from "__builtin__" */
 
-/* Module declarations from 'cpython.int' */
+/* Module declarations from "cpython.bool" */
 
-/* Module declarations from '__builtin__' */
+/* Module declarations from "cpython.long" */
 
-/* Module declarations from 'cpython.bool' */
-static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
+/* Module declarations from "cpython.float" */
 
-/* Module declarations from 'cpython.long' */
+/* Module declarations from "__builtin__" */
 
-/* Module declarations from 'cpython.float' */
+/* Module declarations from "cpython.complex" */
 
-/* Module declarations from '__builtin__' */
+/* Module declarations from "cpython.string" */
 
-/* Module declarations from 'cpython.complex' */
-static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
+/* Module declarations from "cpython.unicode" */
 
-/* Module declarations from 'cpython.string' */
+/* Module declarations from "cpython.pyport" */
 
-/* Module declarations from 'cpython.unicode' */
+/* Module declarations from "cpython.dict" */
 
-/* Module declarations from 'cpython.dict' */
+/* Module declarations from "cpython.instance" */
 
-/* Module declarations from 'cpython.instance' */
+/* Module declarations from "cpython.function" */
 
-/* Module declarations from 'cpython.function' */
+/* Module declarations from "cpython.method" */
 
-/* Module declarations from 'cpython.method' */
+/* Module declarations from "cpython.weakref" */
 
-/* Module declarations from 'cpython.weakref' */
+/* Module declarations from "cpython.getargs" */
 
-/* Module declarations from 'cpython.getargs' */
+/* Module declarations from "cpython.pythread" */
 
-/* Module declarations from 'cpython.pythread' */
+/* Module declarations from "cpython.pystate" */
 
-/* Module declarations from 'cpython.pystate' */
+/* Module declarations from "cpython.cobject" */
 
-/* Module declarations from 'cpython.cobject' */
+/* Module declarations from "cpython.oldbuffer" */
 
-/* Module declarations from 'cpython.oldbuffer' */
+/* Module declarations from "cpython.set" */
 
-/* Module declarations from 'cpython.set' */
+/* Module declarations from "cpython.buffer" */
 
-/* Module declarations from 'cpython.buffer' */
+/* Module declarations from "cpython.bytes" */
 
-/* Module declarations from 'cpython.bytes' */
+/* Module declarations from "cpython.pycapsule" */
 
-/* Module declarations from 'cpython.pycapsule' */
+/* Module declarations from "cpython.contextvars" */
 
-/* Module declarations from 'cpython' */
+/* Module declarations from "cpython" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.agent' */
-static PyTypeObject *__pyx_ptype_4ssh2_5agent_Agent = 0;
+/* Module declarations from "ssh2.agent" */
 static PyObject *(*__pyx_f_4ssh2_5agent_PyAgent)(LIBSSH2_AGENT *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 static int (*__pyx_f_4ssh2_5agent_agent_auth)(char *, LIBSSH2_AGENT *); /*proto*/
 static LIBSSH2_AGENT *(*__pyx_f_4ssh2_5agent_init_connect_agent)(LIBSSH2_SESSION *); /*proto*/
 static LIBSSH2_AGENT *(*__pyx_f_4ssh2_5agent_agent_init)(LIBSSH2_SESSION *); /*proto*/
 
-/* Module declarations from 'ssh2.channel' */
-static PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel = 0;
+/* Module declarations from "ssh2.channel" */
 static PyObject *(*__pyx_f_4ssh2_7channel_PyChannel)(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.listener' */
-static PyTypeObject *__pyx_ptype_4ssh2_8listener_Listener = 0;
+/* Module declarations from "ssh2.listener" */
 static PyObject *(*__pyx_f_4ssh2_8listener_PyListener)(LIBSSH2_LISTENER *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.c_sftp' */
+/* Module declarations from "ssh2.c_sftp" */
 
-/* Module declarations from 'ssh2.sftp' */
-static PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP = 0;
+/* Module declarations from "ssh2.sftp" */
 static PyObject *(*__pyx_f_4ssh2_4sftp_PySFTP)(LIBSSH2_SFTP *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.c_pkey' */
+/* Module declarations from "ssh2.c_pkey" */
 
-/* Module declarations from 'ssh2.publickey' */
+/* Module declarations from "ssh2.publickey" */
 static PyObject *(*__pyx_f_4ssh2_9publickey_PyPublicKeySystem)(LIBSSH2_PUBLICKEY *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 static PyObject *(*__pyx_f_4ssh2_5utils_to_str)(char *); /*proto*/
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.statinfo' */
-static PyTypeObject *__pyx_ptype_4ssh2_8statinfo_StatInfo = 0;
+/* Module declarations from "ssh2.statinfo" */
 
-/* Module declarations from 'ssh2.knownhost' */
-static PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHostEntry = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHost = 0;
+/* Module declarations from "ssh2.knownhost" */
 static struct __pyx_obj_4ssh2_9knownhost_KnownHost *(*__pyx_f_4ssh2_9knownhost_PyKnownHost)(struct __pyx_obj_4ssh2_7session_Session *, LIBSSH2_KNOWNHOSTS *); /*proto*/
 
-/* Module declarations from 'ssh2.fileinfo' */
-static PyTypeObject *__pyx_ptype_4ssh2_8fileinfo_FileInfo = 0;
+/* Module declarations from "ssh2.fileinfo" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = 0;
+/* Module declarations from "ssh2.session" */
 static void __pyx_f_4ssh2_7session_kbd_callback(char const *, int, char const *, int, int, LIBSSH2_USERAUTH_KBDINT_PROMPT const *, LIBSSH2_USERAUTH_KBDINT_RESPONSE *, void **); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.session"
 extern int __pyx_module_is_main_ssh2__session;
 int __pyx_module_is_main_ssh2__session = 0;
 
-/* Implementation of 'ssh2.session' */
+/* Implementation of "ssh2.session" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_TypeError;
 static PyObject *__pyx_builtin_range;
 static PyObject *__pyx_builtin_MemoryError;
-static const char __pyx_k__3[] = ",";
-static const char __pyx_k__4[] = "";
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = ",";
+static const char __pyx_k_i[] = "i";
+static const char __pyx_k__2[] = "";
+static const char __pyx_k__4[] = ".";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__89[] = "?";
+static const char __pyx_k_key[] = "key";
+static const char __pyx_k_msg[] = "msg";
+static const char __pyx_k_algs[] = "algs";
+static const char __pyx_k_auth[] = "_auth";
+static const char __pyx_k_hash[] = "_hash";
 static const char __pyx_k_host[] = "host";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_mode[] = "mode";
 static const char __pyx_k_name[] = "__name__";
 static const char __pyx_k_path[] = "path";
+static const char __pyx_k_pkey[] = "_pkey";
 static const char __pyx_k_port[] = "port";
+static const char __pyx_k_prev[] = "prev";
+static const char __pyx_k_self[] = "self";
+static const char __pyx_k_sftp[] = "_sftp";
 static const char __pyx_k_size[] = "size";
+static const char __pyx_k_sock[] = "sock";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_agent[] = "agent";
 static const char __pyx_k_atime[] = "atime";
+static const char __pyx_k_key_2[] = "_key";
 static const char __pyx_k_mtime[] = "mtime";
 static const char __pyx_k_prefs[] = "prefs";
 static const char __pyx_k_range[] = "range";
 static const char __pyx_k_shost[] = "shost";
-static const char __pyx_k_split[] = "split";
 static const char __pyx_k_sport[] = "sport";
 static const char __pyx_k_value[] = "value";
+static const char __pyx_k_auth_2[] = "auth";
+static const char __pyx_k_b_hash[] = "b_hash";
+static const char __pyx_k_b_host[] = "b_host";
+static const char __pyx_k_b_path[] = "b_path";
+static const char __pyx_k_c_algs[] = "c_algs";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_errmsg[] = "errmsg";
+static const char __pyx_k_host_2[] = "_host";
 static const char __pyx_k_import[] = "__import__";
 static const char __pyx_k_passwd[] = "passwd";
+static const char __pyx_k_path_2[] = "_path";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_sock_2[] = "_sock";
 static const char __pyx_k_Session[] = "Session";
+static const char __pyx_k_b_prefs[] = "b_prefs";
+static const char __pyx_k_b_shost[] = "b_shost";
+static const char __pyx_k_c_prefs[] = "c_prefs";
+static const char __pyx_k_channel[] = "channel";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_errcode[] = "errcode";
+static const char __pyx_k_hostkey[] = "hostkey";
+static const char __pyx_k_key_len[] = "key_len";
+static const char __pyx_k_methods[] = "methods";
+static const char __pyx_k_seconds[] = "seconds";
+static const char __pyx_k_shost_2[] = "_shost";
+static const char __pyx_k_startup[] = "startup";
+static const char __pyx_k_timeout[] = "timeout";
+static const char __pyx_k_b_errmsg[] = "b_errmsg";
+static const char __pyx_k_blocking[] = "blocking";
+static const char __pyx_k_errmsg_2[] = "_errmsg";
+static const char __pyx_k_fileinfo[] = "fileinfo";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_hostname[] = "hostname";
+static const char __pyx_k_identity[] = "identity";
 static const char __pyx_k_interval[] = "interval";
+static const char __pyx_k_key_type[] = "key_type";
+static const char __pyx_k_listener[] = "listener";
 static const char __pyx_k_msg_size[] = "msg_size";
 static const char __pyx_k_password[] = "password";
+static const char __pyx_k_scp_recv[] = "scp_recv";
+static const char __pyx_k_scp_send[] = "scp_send";
 static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_statinfo[] = "statinfo";
 static const char __pyx_k_username[] = "username";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_c_seconds[] = "c_seconds";
+static const char __pyx_k_error_msg[] = "_error_msg";
+static const char __pyx_k_handshake[] = "handshake";
+static const char __pyx_k_hash_type[] = "hash_type";
+static const char __pyx_k_isenabled[] = "isenabled";
 static const char __pyx_k_publickey[] = "publickey";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_scp_recv2[] = "scp_recv2";
+static const char __pyx_k_sftp_init[] = "sftp_init";
 static const char __pyx_k_MethodType[] = "MethodType";
+static const char __pyx_k_agent_auth[] = "agent_auth";
+static const char __pyx_k_agent_init[] = "agent_init";
+static const char __pyx_k_b_hostname[] = "b_hostname";
+static const char __pyx_k_b_password[] = "b_password";
+static const char __pyx_k_b_username[] = "b_username";
+static const char __pyx_k_bound_port[] = "bound_port";
+static const char __pyx_k_disconnect[] = "disconnect";
+static const char __pyx_k_errmsg_len[] = "errmsg_len";
 static const char __pyx_k_exceptions[] = "exceptions";
+static const char __pyx_k_hostname_2[] = "_hostname";
+static const char __pyx_k_last_errno[] = "last_errno";
+static const char __pyx_k_last_error[] = "last_error";
 static const char __pyx_k_passphrase[] = "passphrase";
+static const char __pyx_k_password_2[] = "_password";
 static const char __pyx_k_privatekey[] = "privatekey";
 static const char __pyx_k_pubkeydata[] = "pubkeydata";
+static const char __pyx_k_scp_send64[] = "scp_send64";
+static const char __pyx_k_username_2[] = "_username";
 static const char __pyx_k_want_reply[] = "want_reply";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_b_publickey[] = "b_publickey";
+static const char __pyx_k_get_timeout[] = "get_timeout";
+static const char __pyx_k_known_hosts[] = "known_hosts";
+static const char __pyx_k_method_pref[] = "method_pref";
 static const char __pyx_k_method_type[] = "method_type";
+static const char __pyx_k_publickey_2[] = "_publickey";
+static const char __pyx_k_set_timeout[] = "set_timeout";
 static const char __pyx_k_ChannelError[] = "ChannelError";
+static const char __pyx_k_b_passphrase[] = "b_passphrase";
+static const char __pyx_k_b_privatekey[] = "b_privatekey";
+static const char __pyx_k_direct_tcpip[] = "direct_tcpip";
+static const char __pyx_k_get_blocking[] = "get_blocking";
+static const char __pyx_k_hostkey_hash[] = "hostkey_hash";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_open_session[] = "open_session";
+static const char __pyx_k_passphrase_2[] = "_passphrase";
+static const char __pyx_k_privatekey_2[] = "_privatekey";
+static const char __pyx_k_pubkeydata_2[] = "_pubkeydata";
+static const char __pyx_k_set_blocking[] = "set_blocking";
 static const char __pyx_k_ssh2_session[] = "ssh2.session";
+static const char __pyx_k_stringsource[] = "<stringsource>";
+static const char __pyx_k_username_len[] = "username_len";
 static const char __pyx_k_queue_maxsize[] = "queue_maxsize";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_userauth_list[] = "userauth_list";
 static const char __pyx_k_KnownHostError[] = "KnownHostError";
+static const char __pyx_k_forward_listen[] = "forward_listen";
+static const char __pyx_k_keepalive_send[] = "keepalive_send";
+static const char __pyx_k_knownhost_init[] = "knownhost_init";
+static const char __pyx_k_pubkeydata_len[] = "pubkeydata_len";
+static const char __pyx_k_publickey_init[] = "publickey_init";
+static const char __pyx_k_set_last_error[] = "set_last_error";
+static const char __pyx_k_supported_algs[] = "supported_algs";
+static const char __pyx_k_Session_hostkey[] = "Session.hostkey";
+static const char __pyx_k_Session_methods[] = "Session.methods";
+static const char __pyx_k_Session_startup[] = "Session.startup";
+static const char __pyx_k_direct_tcpip_ex[] = "direct_tcpip_ex";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_Session_scp_recv[] = "Session.scp_recv";
+static const char __pyx_k_Session_scp_send[] = "Session.scp_send";
+static const char __pyx_k_block_directions[] = "block_directions";
+static const char __pyx_k_keepalive_config[] = "keepalive_config";
 static const char __pyx_k_ssh2_session_pyx[] = "ssh2/session.pyx";
+static const char __pyx_k_Session_handshake[] = "Session.handshake";
+static const char __pyx_k_Session_scp_recv2[] = "Session.scp_recv2";
+static const char __pyx_k_Session_sftp_init[] = "Session.sftp_init";
+static const char __pyx_k_forward_listen_ex[] = "forward_listen_ex";
 static const char __pyx_k_publickeyfiledata[] = "publickeyfiledata";
+static const char __pyx_k_userauth_password[] = "userauth_password";
 static const char __pyx_k_LIBSSH2_METHOD_KEX[] = "LIBSSH2_METHOD_KEX";
 static const char __pyx_k_PublicKeyInitError[] = "PublicKeyInitError";
+static const char __pyx_k_Session_agent_auth[] = "Session.agent_auth";
+static const char __pyx_k_Session_agent_init[] = "Session.agent_init";
+static const char __pyx_k_Session_disconnect[] = "Session.disconnect";
+static const char __pyx_k_Session_last_errno[] = "Session.last_errno";
+static const char __pyx_k_Session_last_error[] = "Session.last_error";
+static const char __pyx_k_Session_scp_send64[] = "Session.scp_send64";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_privatekeydata_len[] = "privatekeydata_len";
 static const char __pyx_k_privatekeyfiledata[] = "privatekeyfiledata";
+static const char __pyx_k_userauth_publickey[] = "userauth_publickey";
 static const char __pyx_k_SessionHostKeyError[] = "SessionHostKeyError";
+static const char __pyx_k_Session_get_timeout[] = "Session.get_timeout";
+static const char __pyx_k_Session_method_pref[] = "Session.method_pref";
+static const char __pyx_k_Session_set_timeout[] = "Session.set_timeout";
+static const char __pyx_k_publickeyfiledata_2[] = "_publickeyfiledata";
+static const char __pyx_k_Session_direct_tcpip[] = "Session.direct_tcpip";
+static const char __pyx_k_Session_get_blocking[] = "Session.get_blocking";
+static const char __pyx_k_Session_hostkey_hash[] = "Session.hostkey_hash";
+static const char __pyx_k_Session_open_session[] = "Session.open_session";
+static const char __pyx_k_Session_set_blocking[] = "Session.set_blocking";
+static const char __pyx_k_privatekeyfiledata_2[] = "_privatekeyfiledata";
 static const char __pyx_k_LIBSSH2_METHOD_MAC_CS[] = "LIBSSH2_METHOD_MAC_CS";
 static const char __pyx_k_LIBSSH2_METHOD_MAC_SC[] = "LIBSSH2_METHOD_MAC_SC";
+static const char __pyx_k_Session_userauth_list[] = "Session.userauth_list";
 static const char __pyx_k_LIBSSH2_METHOD_COMP_CS[] = "LIBSSH2_METHOD_COMP_CS";
 static const char __pyx_k_LIBSSH2_METHOD_COMP_SC[] = "LIBSSH2_METHOD_COMP_SC";
 static const char __pyx_k_LIBSSH2_METHOD_HOSTKEY[] = "LIBSSH2_METHOD_HOSTKEY";
 static const char __pyx_k_LIBSSH2_METHOD_LANG_CS[] = "LIBSSH2_METHOD_LANG_CS";
 static const char __pyx_k_LIBSSH2_METHOD_LANG_SC[] = "LIBSSH2_METHOD_LANG_SC";
+static const char __pyx_k_Session_forward_listen[] = "Session.forward_listen";
+static const char __pyx_k_Session_keepalive_send[] = "Session.keepalive_send";
+static const char __pyx_k_Session_knownhost_init[] = "Session.knownhost_init";
+static const char __pyx_k_Session_publickey_init[] = "Session.publickey_init";
+static const char __pyx_k_Session_set_last_error[] = "Session.set_last_error";
+static const char __pyx_k_Session_supported_algs[] = "Session.supported_algs";
+static const char __pyx_k_userauth_authenticated[] = "userauth_authenticated";
 static const char __pyx_k_LIBSSH2_METHOD_CRYPT_CS[] = "LIBSSH2_METHOD_CRYPT_CS";
 static const char __pyx_k_LIBSSH2_METHOD_CRYPT_SC[] = "LIBSSH2_METHOD_CRYPT_SC";
+static const char __pyx_k_Session___reduce_cython[] = "Session.__reduce_cython__";
+static const char __pyx_k_Session_direct_tcpip_ex[] = "Session.direct_tcpip_ex";
 static const char __pyx_k_LIBSSH2_HOSTKEY_HASH_MD5[] = "LIBSSH2_HOSTKEY_HASH_MD5";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_DSS[] = "LIBSSH2_HOSTKEY_TYPE_DSS";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_RSA[] = "LIBSSH2_HOSTKEY_TYPE_RSA";
+static const char __pyx_k_Session_block_directions[] = "Session.block_directions";
+static const char __pyx_k_Session_keepalive_config[] = "Session.keepalive_config";
 static const char __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA1[] = "LIBSSH2_HOSTKEY_HASH_SHA1";
+static const char __pyx_k_Session___setstate_cython[] = "Session.__setstate_cython__";
+static const char __pyx_k_Session_forward_listen_ex[] = "Session.forward_listen_ex";
+static const char __pyx_k_Session_userauth_password[] = "Session.userauth_password";
+static const char __pyx_k_MethodType___reduce_cython[] = "MethodType.__reduce_cython__";
+static const char __pyx_k_Session_userauth_publickey[] = "Session.userauth_publickey";
 static const char __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA256[] = "LIBSSH2_HOSTKEY_HASH_SHA256";
+static const char __pyx_k_userauth_hostbased_fromfile[] = "userauth_hostbased_fromfile";
+static const char __pyx_k_userauth_publickey_fromfile[] = "userauth_publickey_fromfile";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_ED25519[] = "LIBSSH2_HOSTKEY_TYPE_ED25519";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_UNKNOWN[] = "LIBSSH2_HOSTKEY_TYPE_UNKNOWN";
+static const char __pyx_k_MethodType___setstate_cython[] = "MethodType.__setstate_cython__";
+static const char __pyx_k_userauth_keyboardinteractive[] = "userauth_keyboardinteractive";
 static const char __pyx_k_LIBSSH2_SESSION_BLOCK_INBOUND[] = "LIBSSH2_SESSION_BLOCK_INBOUND";
+static const char __pyx_k_userauth_publickey_frommemory[] = "userauth_publickey_frommemory";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_256[] = "LIBSSH2_HOSTKEY_TYPE_ECDSA_256";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_384[] = "LIBSSH2_HOSTKEY_TYPE_ECDSA_384";
 static const char __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_521[] = "LIBSSH2_HOSTKEY_TYPE_ECDSA_521";
 static const char __pyx_k_LIBSSH2_SESSION_BLOCK_OUTBOUND[] = "LIBSSH2_SESSION_BLOCK_OUTBOUND";
+static const char __pyx_k_Session_userauth_authenticated[] = "Session.userauth_authenticated";
 static const char __pyx_k_Error_retrieving_server_host_key[] = "Error retrieving server host key for session";
+static const char __pyx_k_Session_userauth_hostbased_fromf[] = "Session.userauth_hostbased_fromfile";
+static const char __pyx_k_Session_userauth_keyboardinterac[] = "Session.userauth_keyboardinteractive";
+static const char __pyx_k_Session_userauth_publickey_fromf[] = "Session.userauth_publickey_fromfile";
+static const char __pyx_k_Session_userauth_publickey_fromm[] = "Session.userauth_publickey_frommemory";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
 static const char __pyx_k_userauth_keyboardinteractive_loc[] = "userauth_keyboardinteractive.<locals>.passwd";
-static PyObject *__pyx_n_s_ChannelError;
-static PyObject *__pyx_kp_s_Error_retrieving_server_host_key;
-static PyObject *__pyx_n_s_KnownHostError;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA;
-static PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_COMP_CS;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_COMP_SC;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_HOSTKEY;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_KEX;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_LANG_CS;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_LANG_SC;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_MAC_CS;
-static PyObject *__pyx_n_s_LIBSSH2_METHOD_MAC_SC;
-static PyObject *__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND;
-static PyObject *__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_MethodType;
-static PyObject *__pyx_n_s_PublicKeyInitError;
-static PyObject *__pyx_n_s_Session;
-static PyObject *__pyx_n_s_SessionHostKeyError;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_kp_s__3;
-static PyObject *__pyx_kp_b__4;
-static PyObject *__pyx_kp_s__4;
-static PyObject *__pyx_n_s_atime;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_errcode;
-static PyObject *__pyx_n_s_errmsg;
-static PyObject *__pyx_n_s_exceptions;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_host;
-static PyObject *__pyx_n_s_hostname;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_interval;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_method_type;
-static PyObject *__pyx_n_s_mode;
-static PyObject *__pyx_n_s_msg_size;
-static PyObject *__pyx_n_s_mtime;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_passphrase;
-static PyObject *__pyx_n_s_passwd;
-static PyObject *__pyx_n_s_password;
-static PyObject *__pyx_n_s_path;
-static PyObject *__pyx_n_s_port;
-static PyObject *__pyx_n_s_prefs;
-static PyObject *__pyx_n_s_privatekey;
-static PyObject *__pyx_n_s_privatekeyfiledata;
-static PyObject *__pyx_n_s_pubkeydata;
-static PyObject *__pyx_n_s_publickey;
-static PyObject *__pyx_n_s_publickeyfiledata;
-static PyObject *__pyx_n_s_queue_maxsize;
-static PyObject *__pyx_n_s_range;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_shost;
-static PyObject *__pyx_n_s_size;
-static PyObject *__pyx_n_s_split;
-static PyObject *__pyx_n_s_sport;
-static PyObject *__pyx_n_s_ssh2_session;
-static PyObject *__pyx_kp_s_ssh2_session_pyx;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_userauth_keyboardinteractive_loc;
-static PyObject *__pyx_n_s_username;
-static PyObject *__pyx_n_s_value;
-static PyObject *__pyx_n_s_want_reply;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_7session_10MethodType___cinit__(struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
 static PyObject *__pyx_pf_4ssh2_7session_10MethodType_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_7session_10MethodType_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
@@ -2012,188 +2885,2316 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_86__setstate_cython__(CYTHON_U
 static PyObject *__pyx_tp_new_4ssh2_7session_Session(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_7session_MethodType(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static __Pyx_CachedCFunction __pyx_umethod_PyString_Type_split = {0, &__pyx_n_s_split, 0, 0, 0};
-static PyObject *__pyx_int_0;
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_tuple__7;
-static PyObject *__pyx_codeobj__5;
-/* Late includes */
-
-/* "ssh2/session.pyx":57
- * 
- * cdef class MethodType:
- *     def __cinit__(self, value):             # <<<<<<<<<<<<<<
- *         self.value = value
- * 
- */
-
-/* Python wrapper */
-static int __pyx_pw_4ssh2_7session_10MethodType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static int __pyx_pw_4ssh2_7session_10MethodType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_value = 0;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 57, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-    }
-    __pyx_v_value = values[0];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 57, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("ssh2.session.MethodType.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType___cinit__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self), __pyx_v_value);
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_7cpython_4type_type;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_7cpython_4bool_bool;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_7cpython_7complex_complex;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_5agent_Agent;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8listener_Listener;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8statinfo_StatInfo;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHostEntry;
+  PyTypeObject *__pyx_ptype_4ssh2_9knownhost_KnownHost;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8fileinfo_FileInfo;
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_7session_Session;
+  PyObject *__pyx_type_4ssh2_7session_MethodType;
+  PyObject *__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  PyTypeObject *__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive;
+  PyObject *__pyx_kp_u_;
+  PyObject *__pyx_n_s_ChannelError;
+  PyObject *__pyx_kp_u_Error_retrieving_server_host_key;
+  PyObject *__pyx_n_s_KnownHostError;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA;
+  PyObject *__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_COMP_CS;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_COMP_SC;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_HOSTKEY;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_KEX;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_LANG_CS;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_LANG_SC;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_MAC_CS;
+  PyObject *__pyx_n_s_LIBSSH2_METHOD_MAC_SC;
+  PyObject *__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND;
+  PyObject *__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_MethodType;
+  PyObject *__pyx_n_s_MethodType___reduce_cython;
+  PyObject *__pyx_n_s_MethodType___setstate_cython;
+  PyObject *__pyx_n_s_PublicKeyInitError;
+  PyObject *__pyx_n_s_Session;
+  PyObject *__pyx_n_s_SessionHostKeyError;
+  PyObject *__pyx_n_s_Session___reduce_cython;
+  PyObject *__pyx_n_s_Session___setstate_cython;
+  PyObject *__pyx_n_s_Session_agent_auth;
+  PyObject *__pyx_n_s_Session_agent_init;
+  PyObject *__pyx_n_s_Session_block_directions;
+  PyObject *__pyx_n_s_Session_direct_tcpip;
+  PyObject *__pyx_n_s_Session_direct_tcpip_ex;
+  PyObject *__pyx_n_s_Session_disconnect;
+  PyObject *__pyx_n_s_Session_forward_listen;
+  PyObject *__pyx_n_s_Session_forward_listen_ex;
+  PyObject *__pyx_n_s_Session_get_blocking;
+  PyObject *__pyx_n_s_Session_get_timeout;
+  PyObject *__pyx_n_s_Session_handshake;
+  PyObject *__pyx_n_s_Session_hostkey;
+  PyObject *__pyx_n_s_Session_hostkey_hash;
+  PyObject *__pyx_n_s_Session_keepalive_config;
+  PyObject *__pyx_n_s_Session_keepalive_send;
+  PyObject *__pyx_n_s_Session_knownhost_init;
+  PyObject *__pyx_n_s_Session_last_errno;
+  PyObject *__pyx_n_s_Session_last_error;
+  PyObject *__pyx_n_s_Session_method_pref;
+  PyObject *__pyx_n_s_Session_methods;
+  PyObject *__pyx_n_s_Session_open_session;
+  PyObject *__pyx_n_s_Session_publickey_init;
+  PyObject *__pyx_n_s_Session_scp_recv;
+  PyObject *__pyx_n_s_Session_scp_recv2;
+  PyObject *__pyx_n_s_Session_scp_send;
+  PyObject *__pyx_n_s_Session_scp_send64;
+  PyObject *__pyx_n_s_Session_set_blocking;
+  PyObject *__pyx_n_s_Session_set_last_error;
+  PyObject *__pyx_n_s_Session_set_timeout;
+  PyObject *__pyx_n_s_Session_sftp_init;
+  PyObject *__pyx_n_s_Session_startup;
+  PyObject *__pyx_n_s_Session_supported_algs;
+  PyObject *__pyx_n_s_Session_userauth_authenticated;
+  PyObject *__pyx_n_s_Session_userauth_hostbased_fromf;
+  PyObject *__pyx_n_s_Session_userauth_keyboardinterac;
+  PyObject *__pyx_n_s_Session_userauth_list;
+  PyObject *__pyx_n_s_Session_userauth_password;
+  PyObject *__pyx_n_s_Session_userauth_publickey;
+  PyObject *__pyx_n_s_Session_userauth_publickey_fromf;
+  PyObject *__pyx_n_s_Session_userauth_publickey_fromm;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_kp_b__2;
+  PyObject *__pyx_kp_u__2;
+  PyObject *__pyx_kp_u__4;
+  PyObject *__pyx_n_s__89;
+  PyObject *__pyx_n_s_agent;
+  PyObject *__pyx_n_s_agent_auth;
+  PyObject *__pyx_n_s_agent_init;
+  PyObject *__pyx_n_s_algs;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_atime;
+  PyObject *__pyx_n_s_auth;
+  PyObject *__pyx_n_s_auth_2;
+  PyObject *__pyx_n_s_b_errmsg;
+  PyObject *__pyx_n_s_b_hash;
+  PyObject *__pyx_n_s_b_host;
+  PyObject *__pyx_n_s_b_hostname;
+  PyObject *__pyx_n_s_b_passphrase;
+  PyObject *__pyx_n_s_b_password;
+  PyObject *__pyx_n_s_b_path;
+  PyObject *__pyx_n_s_b_prefs;
+  PyObject *__pyx_n_s_b_privatekey;
+  PyObject *__pyx_n_s_b_publickey;
+  PyObject *__pyx_n_s_b_shost;
+  PyObject *__pyx_n_s_b_username;
+  PyObject *__pyx_n_s_block_directions;
+  PyObject *__pyx_n_s_blocking;
+  PyObject *__pyx_n_s_bound_port;
+  PyObject *__pyx_n_s_c_algs;
+  PyObject *__pyx_n_s_c_prefs;
+  PyObject *__pyx_n_s_c_seconds;
+  PyObject *__pyx_n_s_channel;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_direct_tcpip;
+  PyObject *__pyx_n_s_direct_tcpip_ex;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_n_s_disconnect;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_errcode;
+  PyObject *__pyx_n_s_errmsg;
+  PyObject *__pyx_n_s_errmsg_2;
+  PyObject *__pyx_n_s_errmsg_len;
+  PyObject *__pyx_n_s_error_msg;
+  PyObject *__pyx_n_s_exceptions;
+  PyObject *__pyx_n_s_fileinfo;
+  PyObject *__pyx_n_s_forward_listen;
+  PyObject *__pyx_n_s_forward_listen_ex;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_get_blocking;
+  PyObject *__pyx_n_s_get_timeout;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_handshake;
+  PyObject *__pyx_n_s_hash;
+  PyObject *__pyx_n_s_hash_type;
+  PyObject *__pyx_n_s_host;
+  PyObject *__pyx_n_s_host_2;
+  PyObject *__pyx_n_s_hostkey;
+  PyObject *__pyx_n_s_hostkey_hash;
+  PyObject *__pyx_n_s_hostname;
+  PyObject *__pyx_n_s_hostname_2;
+  PyObject *__pyx_n_s_i;
+  PyObject *__pyx_n_s_identity;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_interval;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_keepalive_config;
+  PyObject *__pyx_n_s_keepalive_send;
+  PyObject *__pyx_n_s_key;
+  PyObject *__pyx_n_s_key_2;
+  PyObject *__pyx_n_s_key_len;
+  PyObject *__pyx_n_s_key_type;
+  PyObject *__pyx_n_s_known_hosts;
+  PyObject *__pyx_n_s_knownhost_init;
+  PyObject *__pyx_n_s_last_errno;
+  PyObject *__pyx_n_s_last_error;
+  PyObject *__pyx_n_s_listener;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_method_pref;
+  PyObject *__pyx_n_s_method_type;
+  PyObject *__pyx_n_s_methods;
+  PyObject *__pyx_n_s_mode;
+  PyObject *__pyx_n_s_msg;
+  PyObject *__pyx_n_s_msg_size;
+  PyObject *__pyx_n_s_mtime;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_open_session;
+  PyObject *__pyx_n_s_passphrase;
+  PyObject *__pyx_n_s_passphrase_2;
+  PyObject *__pyx_n_s_passwd;
+  PyObject *__pyx_n_s_password;
+  PyObject *__pyx_n_s_password_2;
+  PyObject *__pyx_n_s_path;
+  PyObject *__pyx_n_s_path_2;
+  PyObject *__pyx_n_s_pkey;
+  PyObject *__pyx_n_s_port;
+  PyObject *__pyx_n_s_prefs;
+  PyObject *__pyx_n_s_prev;
+  PyObject *__pyx_n_s_privatekey;
+  PyObject *__pyx_n_s_privatekey_2;
+  PyObject *__pyx_n_s_privatekeydata_len;
+  PyObject *__pyx_n_s_privatekeyfiledata;
+  PyObject *__pyx_n_s_privatekeyfiledata_2;
+  PyObject *__pyx_n_s_pubkeydata;
+  PyObject *__pyx_n_s_pubkeydata_2;
+  PyObject *__pyx_n_s_pubkeydata_len;
+  PyObject *__pyx_n_s_publickey;
+  PyObject *__pyx_n_s_publickey_2;
+  PyObject *__pyx_n_s_publickey_init;
+  PyObject *__pyx_n_s_publickeyfiledata;
+  PyObject *__pyx_n_s_publickeyfiledata_2;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_queue_maxsize;
+  PyObject *__pyx_n_s_range;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_scp_recv;
+  PyObject *__pyx_n_s_scp_recv2;
+  PyObject *__pyx_n_s_scp_send;
+  PyObject *__pyx_n_s_scp_send64;
+  PyObject *__pyx_n_s_seconds;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_set_blocking;
+  PyObject *__pyx_n_s_set_last_error;
+  PyObject *__pyx_n_s_set_timeout;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_sftp;
+  PyObject *__pyx_n_s_sftp_init;
+  PyObject *__pyx_n_s_shost;
+  PyObject *__pyx_n_s_shost_2;
+  PyObject *__pyx_n_s_size;
+  PyObject *__pyx_n_s_sock;
+  PyObject *__pyx_n_s_sock_2;
+  PyObject *__pyx_n_s_sport;
+  PyObject *__pyx_n_s_ssh2_session;
+  PyObject *__pyx_kp_s_ssh2_session_pyx;
+  PyObject *__pyx_n_s_startup;
+  PyObject *__pyx_n_s_statinfo;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_supported_algs;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_timeout;
+  PyObject *__pyx_n_s_userauth_authenticated;
+  PyObject *__pyx_n_s_userauth_hostbased_fromfile;
+  PyObject *__pyx_n_s_userauth_keyboardinteractive;
+  PyObject *__pyx_n_s_userauth_keyboardinteractive_loc;
+  PyObject *__pyx_n_s_userauth_list;
+  PyObject *__pyx_n_s_userauth_password;
+  PyObject *__pyx_n_s_userauth_publickey;
+  PyObject *__pyx_n_s_userauth_publickey_fromfile;
+  PyObject *__pyx_n_s_userauth_publickey_frommemory;
+  PyObject *__pyx_n_s_username;
+  PyObject *__pyx_n_s_username_2;
+  PyObject *__pyx_n_s_username_len;
+  PyObject *__pyx_n_s_value;
+  PyObject *__pyx_n_s_want_reply;
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1024;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_tuple__9;
+  PyObject *__pyx_tuple__11;
+  PyObject *__pyx_tuple__14;
+  PyObject *__pyx_tuple__17;
+  PyObject *__pyx_tuple__21;
+  PyObject *__pyx_tuple__23;
+  PyObject *__pyx_tuple__25;
+  PyObject *__pyx_tuple__26;
+  PyObject *__pyx_tuple__28;
+  PyObject *__pyx_tuple__30;
+  PyObject *__pyx_tuple__31;
+  PyObject *__pyx_tuple__33;
+  PyObject *__pyx_tuple__35;
+  PyObject *__pyx_tuple__37;
+  PyObject *__pyx_tuple__39;
+  PyObject *__pyx_tuple__41;
+  PyObject *__pyx_tuple__43;
+  PyObject *__pyx_tuple__45;
+  PyObject *__pyx_tuple__48;
+  PyObject *__pyx_tuple__50;
+  PyObject *__pyx_tuple__52;
+  PyObject *__pyx_tuple__53;
+  PyObject *__pyx_tuple__55;
+  PyObject *__pyx_tuple__57;
+  PyObject *__pyx_tuple__59;
+  PyObject *__pyx_tuple__61;
+  PyObject *__pyx_tuple__63;
+  PyObject *__pyx_tuple__65;
+  PyObject *__pyx_tuple__67;
+  PyObject *__pyx_tuple__69;
+  PyObject *__pyx_tuple__71;
+  PyObject *__pyx_tuple__73;
+  PyObject *__pyx_tuple__75;
+  PyObject *__pyx_tuple__77;
+  PyObject *__pyx_tuple__79;
+  PyObject *__pyx_tuple__81;
+  PyObject *__pyx_tuple__83;
+  PyObject *__pyx_tuple__85;
+  PyObject *__pyx_codeobj__3;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__8;
+  PyObject *__pyx_codeobj__10;
+  PyObject *__pyx_codeobj__12;
+  PyObject *__pyx_codeobj__13;
+  PyObject *__pyx_codeobj__15;
+  PyObject *__pyx_codeobj__16;
+  PyObject *__pyx_codeobj__18;
+  PyObject *__pyx_codeobj__19;
+  PyObject *__pyx_codeobj__20;
+  PyObject *__pyx_codeobj__22;
+  PyObject *__pyx_codeobj__24;
+  PyObject *__pyx_codeobj__27;
+  PyObject *__pyx_codeobj__29;
+  PyObject *__pyx_codeobj__32;
+  PyObject *__pyx_codeobj__34;
+  PyObject *__pyx_codeobj__36;
+  PyObject *__pyx_codeobj__38;
+  PyObject *__pyx_codeobj__40;
+  PyObject *__pyx_codeobj__42;
+  PyObject *__pyx_codeobj__44;
+  PyObject *__pyx_codeobj__46;
+  PyObject *__pyx_codeobj__47;
+  PyObject *__pyx_codeobj__49;
+  PyObject *__pyx_codeobj__51;
+  PyObject *__pyx_codeobj__54;
+  PyObject *__pyx_codeobj__56;
+  PyObject *__pyx_codeobj__58;
+  PyObject *__pyx_codeobj__60;
+  PyObject *__pyx_codeobj__62;
+  PyObject *__pyx_codeobj__64;
+  PyObject *__pyx_codeobj__66;
+  PyObject *__pyx_codeobj__68;
+  PyObject *__pyx_codeobj__70;
+  PyObject *__pyx_codeobj__72;
+  PyObject *__pyx_codeobj__74;
+  PyObject *__pyx_codeobj__76;
+  PyObject *__pyx_codeobj__78;
+  PyObject *__pyx_codeobj__80;
+  PyObject *__pyx_codeobj__82;
+  PyObject *__pyx_codeobj__84;
+  PyObject *__pyx_codeobj__86;
+  PyObject *__pyx_codeobj__87;
+  PyObject *__pyx_codeobj__88;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
 
-static int __pyx_pf_4ssh2_7session_10MethodType___cinit__(struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self, PyObject *__pyx_v_value) {
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
 
-  /* "ssh2/session.pyx":58
- * cdef class MethodType:
- *     def __cinit__(self, value):
- *         self.value = value             # <<<<<<<<<<<<<<
- * 
- * 
- */
-  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 58, __pyx_L1_error)
-  __pyx_v_self->value = __pyx_t_1;
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type);
+  Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool);
+  Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_5agent_Agent);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8listener_Listener);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8statinfo_StatInfo);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHost);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8fileinfo_FileInfo);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelError);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_retrieving_server_host_key);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_COMP_CS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_COMP_SC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_HOSTKEY);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_KEX);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_LANG_CS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_LANG_SC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_MAC_CS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_METHOD_MAC_SC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodType___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodType___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyInitError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SessionHostKeyError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_agent_auth);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_agent_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_block_directions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_direct_tcpip);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_direct_tcpip_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_disconnect);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_forward_listen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_forward_listen_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_get_blocking);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_get_timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_handshake);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_hostkey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_hostkey_hash);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_keepalive_config);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_keepalive_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_knownhost_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_last_errno);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_method_pref);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_methods);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_open_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_publickey_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_scp_recv);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_scp_recv2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_scp_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_scp_send64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_set_blocking);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_set_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_set_timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_sftp_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_startup);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_supported_algs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_authenticated);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_hostbased_fromf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_keyboardinterac);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_list);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_password);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_publickey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_publickey_fromf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Session_userauth_publickey_fromm);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_kp_b__2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__4);
+  Py_CLEAR(clear_module_state->__pyx_n_s__89);
+  Py_CLEAR(clear_module_state->__pyx_n_s_agent);
+  Py_CLEAR(clear_module_state->__pyx_n_s_agent_auth);
+  Py_CLEAR(clear_module_state->__pyx_n_s_agent_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_algs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_atime);
+  Py_CLEAR(clear_module_state->__pyx_n_s_auth);
+  Py_CLEAR(clear_module_state->__pyx_n_s_auth_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_errmsg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_hash);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_host);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_hostname);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_passphrase);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_password);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_prefs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_privatekey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_publickey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_shost);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_username);
+  Py_CLEAR(clear_module_state->__pyx_n_s_block_directions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_blocking);
+  Py_CLEAR(clear_module_state->__pyx_n_s_bound_port);
+  Py_CLEAR(clear_module_state->__pyx_n_s_c_algs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_c_prefs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_c_seconds);
+  Py_CLEAR(clear_module_state->__pyx_n_s_channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_direct_tcpip);
+  Py_CLEAR(clear_module_state->__pyx_n_s_direct_tcpip_ex);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_disconnect);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errcode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errmsg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errmsg_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errmsg_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_error_msg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fileinfo);
+  Py_CLEAR(clear_module_state->__pyx_n_s_forward_listen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_forward_listen_ex);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_blocking);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handshake);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hash);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hash_type);
+  Py_CLEAR(clear_module_state->__pyx_n_s_host);
+  Py_CLEAR(clear_module_state->__pyx_n_s_host_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hostkey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hostkey_hash);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hostname);
+  Py_CLEAR(clear_module_state->__pyx_n_s_hostname_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_i);
+  Py_CLEAR(clear_module_state->__pyx_n_s_identity);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_interval);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_keepalive_config);
+  Py_CLEAR(clear_module_state->__pyx_n_s_keepalive_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_key_type);
+  Py_CLEAR(clear_module_state->__pyx_n_s_known_hosts);
+  Py_CLEAR(clear_module_state->__pyx_n_s_knownhost_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_last_errno);
+  Py_CLEAR(clear_module_state->__pyx_n_s_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_listener);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_method_pref);
+  Py_CLEAR(clear_module_state->__pyx_n_s_method_type);
+  Py_CLEAR(clear_module_state->__pyx_n_s_methods);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_msg);
+  Py_CLEAR(clear_module_state->__pyx_n_s_msg_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mtime);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_open_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_passphrase);
+  Py_CLEAR(clear_module_state->__pyx_n_s_passphrase_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_passwd);
+  Py_CLEAR(clear_module_state->__pyx_n_s_password);
+  Py_CLEAR(clear_module_state->__pyx_n_s_password_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pkey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_port);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prefs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prev);
+  Py_CLEAR(clear_module_state->__pyx_n_s_privatekey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_privatekey_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_privatekeydata_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_privatekeyfiledata);
+  Py_CLEAR(clear_module_state->__pyx_n_s_privatekeyfiledata_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pubkeydata);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pubkeydata_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pubkeydata_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_publickey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_publickey_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_publickey_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_publickeyfiledata);
+  Py_CLEAR(clear_module_state->__pyx_n_s_publickeyfiledata_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_queue_maxsize);
+  Py_CLEAR(clear_module_state->__pyx_n_s_range);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_scp_recv);
+  Py_CLEAR(clear_module_state->__pyx_n_s_scp_recv2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_scp_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_scp_send64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_seconds);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_set_blocking);
+  Py_CLEAR(clear_module_state->__pyx_n_s_set_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_set_timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sftp);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sftp_init);
+  Py_CLEAR(clear_module_state->__pyx_n_s_shost);
+  Py_CLEAR(clear_module_state->__pyx_n_s_shost_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sock);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sock_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sport);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_session);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_session_pyx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_startup);
+  Py_CLEAR(clear_module_state->__pyx_n_s_statinfo);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_supported_algs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_authenticated);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_hostbased_fromfile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_keyboardinteractive);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_keyboardinteractive_loc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_list);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_password);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_publickey);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_publickey_fromfile);
+  Py_CLEAR(clear_module_state->__pyx_n_s_userauth_publickey_frommemory);
+  Py_CLEAR(clear_module_state->__pyx_n_s_username);
+  Py_CLEAR(clear_module_state->__pyx_n_s_username_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_username_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_value);
+  Py_CLEAR(clear_module_state->__pyx_n_s_want_reply);
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1024);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_tuple__9);
+  Py_CLEAR(clear_module_state->__pyx_tuple__11);
+  Py_CLEAR(clear_module_state->__pyx_tuple__14);
+  Py_CLEAR(clear_module_state->__pyx_tuple__17);
+  Py_CLEAR(clear_module_state->__pyx_tuple__21);
+  Py_CLEAR(clear_module_state->__pyx_tuple__23);
+  Py_CLEAR(clear_module_state->__pyx_tuple__25);
+  Py_CLEAR(clear_module_state->__pyx_tuple__26);
+  Py_CLEAR(clear_module_state->__pyx_tuple__28);
+  Py_CLEAR(clear_module_state->__pyx_tuple__30);
+  Py_CLEAR(clear_module_state->__pyx_tuple__31);
+  Py_CLEAR(clear_module_state->__pyx_tuple__33);
+  Py_CLEAR(clear_module_state->__pyx_tuple__35);
+  Py_CLEAR(clear_module_state->__pyx_tuple__37);
+  Py_CLEAR(clear_module_state->__pyx_tuple__39);
+  Py_CLEAR(clear_module_state->__pyx_tuple__41);
+  Py_CLEAR(clear_module_state->__pyx_tuple__43);
+  Py_CLEAR(clear_module_state->__pyx_tuple__45);
+  Py_CLEAR(clear_module_state->__pyx_tuple__48);
+  Py_CLEAR(clear_module_state->__pyx_tuple__50);
+  Py_CLEAR(clear_module_state->__pyx_tuple__52);
+  Py_CLEAR(clear_module_state->__pyx_tuple__53);
+  Py_CLEAR(clear_module_state->__pyx_tuple__55);
+  Py_CLEAR(clear_module_state->__pyx_tuple__57);
+  Py_CLEAR(clear_module_state->__pyx_tuple__59);
+  Py_CLEAR(clear_module_state->__pyx_tuple__61);
+  Py_CLEAR(clear_module_state->__pyx_tuple__63);
+  Py_CLEAR(clear_module_state->__pyx_tuple__65);
+  Py_CLEAR(clear_module_state->__pyx_tuple__67);
+  Py_CLEAR(clear_module_state->__pyx_tuple__69);
+  Py_CLEAR(clear_module_state->__pyx_tuple__71);
+  Py_CLEAR(clear_module_state->__pyx_tuple__73);
+  Py_CLEAR(clear_module_state->__pyx_tuple__75);
+  Py_CLEAR(clear_module_state->__pyx_tuple__77);
+  Py_CLEAR(clear_module_state->__pyx_tuple__79);
+  Py_CLEAR(clear_module_state->__pyx_tuple__81);
+  Py_CLEAR(clear_module_state->__pyx_tuple__83);
+  Py_CLEAR(clear_module_state->__pyx_tuple__85);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__10);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__12);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__13);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__15);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__16);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__18);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__19);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__24);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__27);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__29);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__32);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__34);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__36);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__38);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__40);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__42);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__44);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__46);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__47);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__49);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__51);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__54);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__56);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__58);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__60);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__62);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__64);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__66);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__68);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__70);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__72);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__74);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__76);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__78);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__80);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__82);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__84);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__86);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__87);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__88);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type);
+  Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4bool_bool);
+  Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_5agent_Agent);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8listener_Listener);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8statinfo_StatInfo);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_9knownhost_KnownHost);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8fileinfo_FileInfo);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelError);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_retrieving_server_host_key);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_COMP_CS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_COMP_SC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_HOSTKEY);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_KEX);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_LANG_CS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_LANG_SC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_MAC_CS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_METHOD_MAC_SC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodType___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodType___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyInitError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SessionHostKeyError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_agent_auth);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_agent_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_block_directions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_direct_tcpip);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_direct_tcpip_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_disconnect);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_forward_listen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_forward_listen_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_get_blocking);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_get_timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_handshake);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_hostkey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_hostkey_hash);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_keepalive_config);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_keepalive_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_knownhost_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_last_errno);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_method_pref);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_methods);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_open_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_publickey_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_scp_recv);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_scp_recv2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_scp_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_scp_send64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_set_blocking);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_set_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_set_timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_sftp_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_startup);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_supported_algs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_authenticated);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_hostbased_fromf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_keyboardinterac);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_list);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_password);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_publickey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_publickey_fromf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Session_userauth_publickey_fromm);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_kp_b__2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__4);
+  Py_VISIT(traverse_module_state->__pyx_n_s__89);
+  Py_VISIT(traverse_module_state->__pyx_n_s_agent);
+  Py_VISIT(traverse_module_state->__pyx_n_s_agent_auth);
+  Py_VISIT(traverse_module_state->__pyx_n_s_agent_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_algs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_atime);
+  Py_VISIT(traverse_module_state->__pyx_n_s_auth);
+  Py_VISIT(traverse_module_state->__pyx_n_s_auth_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_errmsg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_hash);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_host);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_hostname);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_passphrase);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_password);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_prefs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_privatekey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_publickey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_shost);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_username);
+  Py_VISIT(traverse_module_state->__pyx_n_s_block_directions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_blocking);
+  Py_VISIT(traverse_module_state->__pyx_n_s_bound_port);
+  Py_VISIT(traverse_module_state->__pyx_n_s_c_algs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_c_prefs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_c_seconds);
+  Py_VISIT(traverse_module_state->__pyx_n_s_channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_direct_tcpip);
+  Py_VISIT(traverse_module_state->__pyx_n_s_direct_tcpip_ex);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_disconnect);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errcode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errmsg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errmsg_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errmsg_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_error_msg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fileinfo);
+  Py_VISIT(traverse_module_state->__pyx_n_s_forward_listen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_forward_listen_ex);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_blocking);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handshake);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hash);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hash_type);
+  Py_VISIT(traverse_module_state->__pyx_n_s_host);
+  Py_VISIT(traverse_module_state->__pyx_n_s_host_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hostkey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hostkey_hash);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hostname);
+  Py_VISIT(traverse_module_state->__pyx_n_s_hostname_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_i);
+  Py_VISIT(traverse_module_state->__pyx_n_s_identity);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_interval);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_keepalive_config);
+  Py_VISIT(traverse_module_state->__pyx_n_s_keepalive_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_key_type);
+  Py_VISIT(traverse_module_state->__pyx_n_s_known_hosts);
+  Py_VISIT(traverse_module_state->__pyx_n_s_knownhost_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_last_errno);
+  Py_VISIT(traverse_module_state->__pyx_n_s_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_listener);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_method_pref);
+  Py_VISIT(traverse_module_state->__pyx_n_s_method_type);
+  Py_VISIT(traverse_module_state->__pyx_n_s_methods);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_msg);
+  Py_VISIT(traverse_module_state->__pyx_n_s_msg_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mtime);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_open_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_passphrase);
+  Py_VISIT(traverse_module_state->__pyx_n_s_passphrase_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_passwd);
+  Py_VISIT(traverse_module_state->__pyx_n_s_password);
+  Py_VISIT(traverse_module_state->__pyx_n_s_password_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pkey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_port);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prefs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prev);
+  Py_VISIT(traverse_module_state->__pyx_n_s_privatekey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_privatekey_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_privatekeydata_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_privatekeyfiledata);
+  Py_VISIT(traverse_module_state->__pyx_n_s_privatekeyfiledata_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pubkeydata);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pubkeydata_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pubkeydata_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_publickey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_publickey_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_publickey_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_publickeyfiledata);
+  Py_VISIT(traverse_module_state->__pyx_n_s_publickeyfiledata_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_queue_maxsize);
+  Py_VISIT(traverse_module_state->__pyx_n_s_range);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_scp_recv);
+  Py_VISIT(traverse_module_state->__pyx_n_s_scp_recv2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_scp_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_scp_send64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_seconds);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_set_blocking);
+  Py_VISIT(traverse_module_state->__pyx_n_s_set_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_set_timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sftp);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sftp_init);
+  Py_VISIT(traverse_module_state->__pyx_n_s_shost);
+  Py_VISIT(traverse_module_state->__pyx_n_s_shost_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sock);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sock_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sport);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_session);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_session_pyx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_startup);
+  Py_VISIT(traverse_module_state->__pyx_n_s_statinfo);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_supported_algs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_authenticated);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_hostbased_fromfile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_keyboardinteractive);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_keyboardinteractive_loc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_list);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_password);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_publickey);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_publickey_fromfile);
+  Py_VISIT(traverse_module_state->__pyx_n_s_userauth_publickey_frommemory);
+  Py_VISIT(traverse_module_state->__pyx_n_s_username);
+  Py_VISIT(traverse_module_state->__pyx_n_s_username_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_username_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_value);
+  Py_VISIT(traverse_module_state->__pyx_n_s_want_reply);
+  Py_VISIT(traverse_module_state->__pyx_int_0);
+  Py_VISIT(traverse_module_state->__pyx_int_1024);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_tuple__9);
+  Py_VISIT(traverse_module_state->__pyx_tuple__11);
+  Py_VISIT(traverse_module_state->__pyx_tuple__14);
+  Py_VISIT(traverse_module_state->__pyx_tuple__17);
+  Py_VISIT(traverse_module_state->__pyx_tuple__21);
+  Py_VISIT(traverse_module_state->__pyx_tuple__23);
+  Py_VISIT(traverse_module_state->__pyx_tuple__25);
+  Py_VISIT(traverse_module_state->__pyx_tuple__26);
+  Py_VISIT(traverse_module_state->__pyx_tuple__28);
+  Py_VISIT(traverse_module_state->__pyx_tuple__30);
+  Py_VISIT(traverse_module_state->__pyx_tuple__31);
+  Py_VISIT(traverse_module_state->__pyx_tuple__33);
+  Py_VISIT(traverse_module_state->__pyx_tuple__35);
+  Py_VISIT(traverse_module_state->__pyx_tuple__37);
+  Py_VISIT(traverse_module_state->__pyx_tuple__39);
+  Py_VISIT(traverse_module_state->__pyx_tuple__41);
+  Py_VISIT(traverse_module_state->__pyx_tuple__43);
+  Py_VISIT(traverse_module_state->__pyx_tuple__45);
+  Py_VISIT(traverse_module_state->__pyx_tuple__48);
+  Py_VISIT(traverse_module_state->__pyx_tuple__50);
+  Py_VISIT(traverse_module_state->__pyx_tuple__52);
+  Py_VISIT(traverse_module_state->__pyx_tuple__53);
+  Py_VISIT(traverse_module_state->__pyx_tuple__55);
+  Py_VISIT(traverse_module_state->__pyx_tuple__57);
+  Py_VISIT(traverse_module_state->__pyx_tuple__59);
+  Py_VISIT(traverse_module_state->__pyx_tuple__61);
+  Py_VISIT(traverse_module_state->__pyx_tuple__63);
+  Py_VISIT(traverse_module_state->__pyx_tuple__65);
+  Py_VISIT(traverse_module_state->__pyx_tuple__67);
+  Py_VISIT(traverse_module_state->__pyx_tuple__69);
+  Py_VISIT(traverse_module_state->__pyx_tuple__71);
+  Py_VISIT(traverse_module_state->__pyx_tuple__73);
+  Py_VISIT(traverse_module_state->__pyx_tuple__75);
+  Py_VISIT(traverse_module_state->__pyx_tuple__77);
+  Py_VISIT(traverse_module_state->__pyx_tuple__79);
+  Py_VISIT(traverse_module_state->__pyx_tuple__81);
+  Py_VISIT(traverse_module_state->__pyx_tuple__83);
+  Py_VISIT(traverse_module_state->__pyx_tuple__85);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__10);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__12);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__13);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__15);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__16);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__18);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__19);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__24);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__27);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__29);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__32);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__34);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__36);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__38);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__40);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__42);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__44);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__46);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__47);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__49);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__51);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__54);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__56);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__58);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__60);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__62);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__64);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__66);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__68);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__70);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__72);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__74);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__76);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__78);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__80);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__82);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__84);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__86);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__87);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__88);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_5agent_Agent __pyx_mstate_global->__pyx_ptype_4ssh2_5agent_Agent
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7channel_Channel __pyx_mstate_global->__pyx_ptype_4ssh2_7channel_Channel
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_8listener_Listener __pyx_mstate_global->__pyx_ptype_4ssh2_8listener_Listener
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_4sftp_SFTP __pyx_mstate_global->__pyx_ptype_4ssh2_4sftp_SFTP
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_8statinfo_StatInfo __pyx_mstate_global->__pyx_ptype_4ssh2_8statinfo_StatInfo
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_9knownhost_KnownHostEntry __pyx_mstate_global->__pyx_ptype_4ssh2_9knownhost_KnownHostEntry
+#define __pyx_ptype_4ssh2_9knownhost_KnownHost __pyx_mstate_global->__pyx_ptype_4ssh2_9knownhost_KnownHost
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_8fileinfo_FileInfo __pyx_mstate_global->__pyx_ptype_4ssh2_8fileinfo_FileInfo
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_7session_Session __pyx_mstate_global->__pyx_type_4ssh2_7session_Session
+#define __pyx_type_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_type_4ssh2_7session_MethodType
+#define __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive __pyx_mstate_global->__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#define __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive __pyx_mstate_global->__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive
+#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
+#define __pyx_n_s_ChannelError __pyx_mstate_global->__pyx_n_s_ChannelError
+#define __pyx_kp_u_Error_retrieving_server_host_key __pyx_mstate_global->__pyx_kp_u_Error_retrieving_server_host_key
+#define __pyx_n_s_KnownHostError __pyx_mstate_global->__pyx_n_s_KnownHostError
+#define __pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5
+#define __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1
+#define __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519 __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA
+#define __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN __pyx_mstate_global->__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN
+#define __pyx_n_s_LIBSSH2_METHOD_COMP_CS __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_COMP_CS
+#define __pyx_n_s_LIBSSH2_METHOD_COMP_SC __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_COMP_SC
+#define __pyx_n_s_LIBSSH2_METHOD_CRYPT_CS __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS
+#define __pyx_n_s_LIBSSH2_METHOD_CRYPT_SC __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC
+#define __pyx_n_s_LIBSSH2_METHOD_HOSTKEY __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_HOSTKEY
+#define __pyx_n_s_LIBSSH2_METHOD_KEX __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_KEX
+#define __pyx_n_s_LIBSSH2_METHOD_LANG_CS __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_LANG_CS
+#define __pyx_n_s_LIBSSH2_METHOD_LANG_SC __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_LANG_SC
+#define __pyx_n_s_LIBSSH2_METHOD_MAC_CS __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_MAC_CS
+#define __pyx_n_s_LIBSSH2_METHOD_MAC_SC __pyx_mstate_global->__pyx_n_s_LIBSSH2_METHOD_MAC_SC
+#define __pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND __pyx_mstate_global->__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND
+#define __pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND __pyx_mstate_global->__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_MethodType __pyx_mstate_global->__pyx_n_s_MethodType
+#define __pyx_n_s_MethodType___reduce_cython __pyx_mstate_global->__pyx_n_s_MethodType___reduce_cython
+#define __pyx_n_s_MethodType___setstate_cython __pyx_mstate_global->__pyx_n_s_MethodType___setstate_cython
+#define __pyx_n_s_PublicKeyInitError __pyx_mstate_global->__pyx_n_s_PublicKeyInitError
+#define __pyx_n_s_Session __pyx_mstate_global->__pyx_n_s_Session
+#define __pyx_n_s_SessionHostKeyError __pyx_mstate_global->__pyx_n_s_SessionHostKeyError
+#define __pyx_n_s_Session___reduce_cython __pyx_mstate_global->__pyx_n_s_Session___reduce_cython
+#define __pyx_n_s_Session___setstate_cython __pyx_mstate_global->__pyx_n_s_Session___setstate_cython
+#define __pyx_n_s_Session_agent_auth __pyx_mstate_global->__pyx_n_s_Session_agent_auth
+#define __pyx_n_s_Session_agent_init __pyx_mstate_global->__pyx_n_s_Session_agent_init
+#define __pyx_n_s_Session_block_directions __pyx_mstate_global->__pyx_n_s_Session_block_directions
+#define __pyx_n_s_Session_direct_tcpip __pyx_mstate_global->__pyx_n_s_Session_direct_tcpip
+#define __pyx_n_s_Session_direct_tcpip_ex __pyx_mstate_global->__pyx_n_s_Session_direct_tcpip_ex
+#define __pyx_n_s_Session_disconnect __pyx_mstate_global->__pyx_n_s_Session_disconnect
+#define __pyx_n_s_Session_forward_listen __pyx_mstate_global->__pyx_n_s_Session_forward_listen
+#define __pyx_n_s_Session_forward_listen_ex __pyx_mstate_global->__pyx_n_s_Session_forward_listen_ex
+#define __pyx_n_s_Session_get_blocking __pyx_mstate_global->__pyx_n_s_Session_get_blocking
+#define __pyx_n_s_Session_get_timeout __pyx_mstate_global->__pyx_n_s_Session_get_timeout
+#define __pyx_n_s_Session_handshake __pyx_mstate_global->__pyx_n_s_Session_handshake
+#define __pyx_n_s_Session_hostkey __pyx_mstate_global->__pyx_n_s_Session_hostkey
+#define __pyx_n_s_Session_hostkey_hash __pyx_mstate_global->__pyx_n_s_Session_hostkey_hash
+#define __pyx_n_s_Session_keepalive_config __pyx_mstate_global->__pyx_n_s_Session_keepalive_config
+#define __pyx_n_s_Session_keepalive_send __pyx_mstate_global->__pyx_n_s_Session_keepalive_send
+#define __pyx_n_s_Session_knownhost_init __pyx_mstate_global->__pyx_n_s_Session_knownhost_init
+#define __pyx_n_s_Session_last_errno __pyx_mstate_global->__pyx_n_s_Session_last_errno
+#define __pyx_n_s_Session_last_error __pyx_mstate_global->__pyx_n_s_Session_last_error
+#define __pyx_n_s_Session_method_pref __pyx_mstate_global->__pyx_n_s_Session_method_pref
+#define __pyx_n_s_Session_methods __pyx_mstate_global->__pyx_n_s_Session_methods
+#define __pyx_n_s_Session_open_session __pyx_mstate_global->__pyx_n_s_Session_open_session
+#define __pyx_n_s_Session_publickey_init __pyx_mstate_global->__pyx_n_s_Session_publickey_init
+#define __pyx_n_s_Session_scp_recv __pyx_mstate_global->__pyx_n_s_Session_scp_recv
+#define __pyx_n_s_Session_scp_recv2 __pyx_mstate_global->__pyx_n_s_Session_scp_recv2
+#define __pyx_n_s_Session_scp_send __pyx_mstate_global->__pyx_n_s_Session_scp_send
+#define __pyx_n_s_Session_scp_send64 __pyx_mstate_global->__pyx_n_s_Session_scp_send64
+#define __pyx_n_s_Session_set_blocking __pyx_mstate_global->__pyx_n_s_Session_set_blocking
+#define __pyx_n_s_Session_set_last_error __pyx_mstate_global->__pyx_n_s_Session_set_last_error
+#define __pyx_n_s_Session_set_timeout __pyx_mstate_global->__pyx_n_s_Session_set_timeout
+#define __pyx_n_s_Session_sftp_init __pyx_mstate_global->__pyx_n_s_Session_sftp_init
+#define __pyx_n_s_Session_startup __pyx_mstate_global->__pyx_n_s_Session_startup
+#define __pyx_n_s_Session_supported_algs __pyx_mstate_global->__pyx_n_s_Session_supported_algs
+#define __pyx_n_s_Session_userauth_authenticated __pyx_mstate_global->__pyx_n_s_Session_userauth_authenticated
+#define __pyx_n_s_Session_userauth_hostbased_fromf __pyx_mstate_global->__pyx_n_s_Session_userauth_hostbased_fromf
+#define __pyx_n_s_Session_userauth_keyboardinterac __pyx_mstate_global->__pyx_n_s_Session_userauth_keyboardinterac
+#define __pyx_n_s_Session_userauth_list __pyx_mstate_global->__pyx_n_s_Session_userauth_list
+#define __pyx_n_s_Session_userauth_password __pyx_mstate_global->__pyx_n_s_Session_userauth_password
+#define __pyx_n_s_Session_userauth_publickey __pyx_mstate_global->__pyx_n_s_Session_userauth_publickey
+#define __pyx_n_s_Session_userauth_publickey_fromf __pyx_mstate_global->__pyx_n_s_Session_userauth_publickey_fromf
+#define __pyx_n_s_Session_userauth_publickey_fromm __pyx_mstate_global->__pyx_n_s_Session_userauth_publickey_fromm
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_b__2 __pyx_mstate_global->__pyx_kp_b__2
+#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2
+#define __pyx_kp_u__4 __pyx_mstate_global->__pyx_kp_u__4
+#define __pyx_n_s__89 __pyx_mstate_global->__pyx_n_s__89
+#define __pyx_n_s_agent __pyx_mstate_global->__pyx_n_s_agent
+#define __pyx_n_s_agent_auth __pyx_mstate_global->__pyx_n_s_agent_auth
+#define __pyx_n_s_agent_init __pyx_mstate_global->__pyx_n_s_agent_init
+#define __pyx_n_s_algs __pyx_mstate_global->__pyx_n_s_algs
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_atime __pyx_mstate_global->__pyx_n_s_atime
+#define __pyx_n_s_auth __pyx_mstate_global->__pyx_n_s_auth
+#define __pyx_n_s_auth_2 __pyx_mstate_global->__pyx_n_s_auth_2
+#define __pyx_n_s_b_errmsg __pyx_mstate_global->__pyx_n_s_b_errmsg
+#define __pyx_n_s_b_hash __pyx_mstate_global->__pyx_n_s_b_hash
+#define __pyx_n_s_b_host __pyx_mstate_global->__pyx_n_s_b_host
+#define __pyx_n_s_b_hostname __pyx_mstate_global->__pyx_n_s_b_hostname
+#define __pyx_n_s_b_passphrase __pyx_mstate_global->__pyx_n_s_b_passphrase
+#define __pyx_n_s_b_password __pyx_mstate_global->__pyx_n_s_b_password
+#define __pyx_n_s_b_path __pyx_mstate_global->__pyx_n_s_b_path
+#define __pyx_n_s_b_prefs __pyx_mstate_global->__pyx_n_s_b_prefs
+#define __pyx_n_s_b_privatekey __pyx_mstate_global->__pyx_n_s_b_privatekey
+#define __pyx_n_s_b_publickey __pyx_mstate_global->__pyx_n_s_b_publickey
+#define __pyx_n_s_b_shost __pyx_mstate_global->__pyx_n_s_b_shost
+#define __pyx_n_s_b_username __pyx_mstate_global->__pyx_n_s_b_username
+#define __pyx_n_s_block_directions __pyx_mstate_global->__pyx_n_s_block_directions
+#define __pyx_n_s_blocking __pyx_mstate_global->__pyx_n_s_blocking
+#define __pyx_n_s_bound_port __pyx_mstate_global->__pyx_n_s_bound_port
+#define __pyx_n_s_c_algs __pyx_mstate_global->__pyx_n_s_c_algs
+#define __pyx_n_s_c_prefs __pyx_mstate_global->__pyx_n_s_c_prefs
+#define __pyx_n_s_c_seconds __pyx_mstate_global->__pyx_n_s_c_seconds
+#define __pyx_n_s_channel __pyx_mstate_global->__pyx_n_s_channel
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_direct_tcpip __pyx_mstate_global->__pyx_n_s_direct_tcpip
+#define __pyx_n_s_direct_tcpip_ex __pyx_mstate_global->__pyx_n_s_direct_tcpip_ex
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_n_s_disconnect __pyx_mstate_global->__pyx_n_s_disconnect
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_errcode __pyx_mstate_global->__pyx_n_s_errcode
+#define __pyx_n_s_errmsg __pyx_mstate_global->__pyx_n_s_errmsg
+#define __pyx_n_s_errmsg_2 __pyx_mstate_global->__pyx_n_s_errmsg_2
+#define __pyx_n_s_errmsg_len __pyx_mstate_global->__pyx_n_s_errmsg_len
+#define __pyx_n_s_error_msg __pyx_mstate_global->__pyx_n_s_error_msg
+#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions
+#define __pyx_n_s_fileinfo __pyx_mstate_global->__pyx_n_s_fileinfo
+#define __pyx_n_s_forward_listen __pyx_mstate_global->__pyx_n_s_forward_listen
+#define __pyx_n_s_forward_listen_ex __pyx_mstate_global->__pyx_n_s_forward_listen_ex
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_get_blocking __pyx_mstate_global->__pyx_n_s_get_blocking
+#define __pyx_n_s_get_timeout __pyx_mstate_global->__pyx_n_s_get_timeout
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_handshake __pyx_mstate_global->__pyx_n_s_handshake
+#define __pyx_n_s_hash __pyx_mstate_global->__pyx_n_s_hash
+#define __pyx_n_s_hash_type __pyx_mstate_global->__pyx_n_s_hash_type
+#define __pyx_n_s_host __pyx_mstate_global->__pyx_n_s_host
+#define __pyx_n_s_host_2 __pyx_mstate_global->__pyx_n_s_host_2
+#define __pyx_n_s_hostkey __pyx_mstate_global->__pyx_n_s_hostkey
+#define __pyx_n_s_hostkey_hash __pyx_mstate_global->__pyx_n_s_hostkey_hash
+#define __pyx_n_s_hostname __pyx_mstate_global->__pyx_n_s_hostname
+#define __pyx_n_s_hostname_2 __pyx_mstate_global->__pyx_n_s_hostname_2
+#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i
+#define __pyx_n_s_identity __pyx_mstate_global->__pyx_n_s_identity
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_interval __pyx_mstate_global->__pyx_n_s_interval
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_keepalive_config __pyx_mstate_global->__pyx_n_s_keepalive_config
+#define __pyx_n_s_keepalive_send __pyx_mstate_global->__pyx_n_s_keepalive_send
+#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key
+#define __pyx_n_s_key_2 __pyx_mstate_global->__pyx_n_s_key_2
+#define __pyx_n_s_key_len __pyx_mstate_global->__pyx_n_s_key_len
+#define __pyx_n_s_key_type __pyx_mstate_global->__pyx_n_s_key_type
+#define __pyx_n_s_known_hosts __pyx_mstate_global->__pyx_n_s_known_hosts
+#define __pyx_n_s_knownhost_init __pyx_mstate_global->__pyx_n_s_knownhost_init
+#define __pyx_n_s_last_errno __pyx_mstate_global->__pyx_n_s_last_errno
+#define __pyx_n_s_last_error __pyx_mstate_global->__pyx_n_s_last_error
+#define __pyx_n_s_listener __pyx_mstate_global->__pyx_n_s_listener
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_method_pref __pyx_mstate_global->__pyx_n_s_method_pref
+#define __pyx_n_s_method_type __pyx_mstate_global->__pyx_n_s_method_type
+#define __pyx_n_s_methods __pyx_mstate_global->__pyx_n_s_methods
+#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode
+#define __pyx_n_s_msg __pyx_mstate_global->__pyx_n_s_msg
+#define __pyx_n_s_msg_size __pyx_mstate_global->__pyx_n_s_msg_size
+#define __pyx_n_s_mtime __pyx_mstate_global->__pyx_n_s_mtime
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_open_session __pyx_mstate_global->__pyx_n_s_open_session
+#define __pyx_n_s_passphrase __pyx_mstate_global->__pyx_n_s_passphrase
+#define __pyx_n_s_passphrase_2 __pyx_mstate_global->__pyx_n_s_passphrase_2
+#define __pyx_n_s_passwd __pyx_mstate_global->__pyx_n_s_passwd
+#define __pyx_n_s_password __pyx_mstate_global->__pyx_n_s_password
+#define __pyx_n_s_password_2 __pyx_mstate_global->__pyx_n_s_password_2
+#define __pyx_n_s_path __pyx_mstate_global->__pyx_n_s_path
+#define __pyx_n_s_path_2 __pyx_mstate_global->__pyx_n_s_path_2
+#define __pyx_n_s_pkey __pyx_mstate_global->__pyx_n_s_pkey
+#define __pyx_n_s_port __pyx_mstate_global->__pyx_n_s_port
+#define __pyx_n_s_prefs __pyx_mstate_global->__pyx_n_s_prefs
+#define __pyx_n_s_prev __pyx_mstate_global->__pyx_n_s_prev
+#define __pyx_n_s_privatekey __pyx_mstate_global->__pyx_n_s_privatekey
+#define __pyx_n_s_privatekey_2 __pyx_mstate_global->__pyx_n_s_privatekey_2
+#define __pyx_n_s_privatekeydata_len __pyx_mstate_global->__pyx_n_s_privatekeydata_len
+#define __pyx_n_s_privatekeyfiledata __pyx_mstate_global->__pyx_n_s_privatekeyfiledata
+#define __pyx_n_s_privatekeyfiledata_2 __pyx_mstate_global->__pyx_n_s_privatekeyfiledata_2
+#define __pyx_n_s_pubkeydata __pyx_mstate_global->__pyx_n_s_pubkeydata
+#define __pyx_n_s_pubkeydata_2 __pyx_mstate_global->__pyx_n_s_pubkeydata_2
+#define __pyx_n_s_pubkeydata_len __pyx_mstate_global->__pyx_n_s_pubkeydata_len
+#define __pyx_n_s_publickey __pyx_mstate_global->__pyx_n_s_publickey
+#define __pyx_n_s_publickey_2 __pyx_mstate_global->__pyx_n_s_publickey_2
+#define __pyx_n_s_publickey_init __pyx_mstate_global->__pyx_n_s_publickey_init
+#define __pyx_n_s_publickeyfiledata __pyx_mstate_global->__pyx_n_s_publickeyfiledata
+#define __pyx_n_s_publickeyfiledata_2 __pyx_mstate_global->__pyx_n_s_publickeyfiledata_2
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_queue_maxsize __pyx_mstate_global->__pyx_n_s_queue_maxsize
+#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_scp_recv __pyx_mstate_global->__pyx_n_s_scp_recv
+#define __pyx_n_s_scp_recv2 __pyx_mstate_global->__pyx_n_s_scp_recv2
+#define __pyx_n_s_scp_send __pyx_mstate_global->__pyx_n_s_scp_send
+#define __pyx_n_s_scp_send64 __pyx_mstate_global->__pyx_n_s_scp_send64
+#define __pyx_n_s_seconds __pyx_mstate_global->__pyx_n_s_seconds
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_set_blocking __pyx_mstate_global->__pyx_n_s_set_blocking
+#define __pyx_n_s_set_last_error __pyx_mstate_global->__pyx_n_s_set_last_error
+#define __pyx_n_s_set_timeout __pyx_mstate_global->__pyx_n_s_set_timeout
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_sftp __pyx_mstate_global->__pyx_n_s_sftp
+#define __pyx_n_s_sftp_init __pyx_mstate_global->__pyx_n_s_sftp_init
+#define __pyx_n_s_shost __pyx_mstate_global->__pyx_n_s_shost
+#define __pyx_n_s_shost_2 __pyx_mstate_global->__pyx_n_s_shost_2
+#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size
+#define __pyx_n_s_sock __pyx_mstate_global->__pyx_n_s_sock
+#define __pyx_n_s_sock_2 __pyx_mstate_global->__pyx_n_s_sock_2
+#define __pyx_n_s_sport __pyx_mstate_global->__pyx_n_s_sport
+#define __pyx_n_s_ssh2_session __pyx_mstate_global->__pyx_n_s_ssh2_session
+#define __pyx_kp_s_ssh2_session_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_session_pyx
+#define __pyx_n_s_startup __pyx_mstate_global->__pyx_n_s_startup
+#define __pyx_n_s_statinfo __pyx_mstate_global->__pyx_n_s_statinfo
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_supported_algs __pyx_mstate_global->__pyx_n_s_supported_algs
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_timeout __pyx_mstate_global->__pyx_n_s_timeout
+#define __pyx_n_s_userauth_authenticated __pyx_mstate_global->__pyx_n_s_userauth_authenticated
+#define __pyx_n_s_userauth_hostbased_fromfile __pyx_mstate_global->__pyx_n_s_userauth_hostbased_fromfile
+#define __pyx_n_s_userauth_keyboardinteractive __pyx_mstate_global->__pyx_n_s_userauth_keyboardinteractive
+#define __pyx_n_s_userauth_keyboardinteractive_loc __pyx_mstate_global->__pyx_n_s_userauth_keyboardinteractive_loc
+#define __pyx_n_s_userauth_list __pyx_mstate_global->__pyx_n_s_userauth_list
+#define __pyx_n_s_userauth_password __pyx_mstate_global->__pyx_n_s_userauth_password
+#define __pyx_n_s_userauth_publickey __pyx_mstate_global->__pyx_n_s_userauth_publickey
+#define __pyx_n_s_userauth_publickey_fromfile __pyx_mstate_global->__pyx_n_s_userauth_publickey_fromfile
+#define __pyx_n_s_userauth_publickey_frommemory __pyx_mstate_global->__pyx_n_s_userauth_publickey_frommemory
+#define __pyx_n_s_username __pyx_mstate_global->__pyx_n_s_username
+#define __pyx_n_s_username_2 __pyx_mstate_global->__pyx_n_s_username_2
+#define __pyx_n_s_username_len __pyx_mstate_global->__pyx_n_s_username_len
+#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value
+#define __pyx_n_s_want_reply __pyx_mstate_global->__pyx_n_s_want_reply
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
+#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23
+#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25
+#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26
+#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28
+#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30
+#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31
+#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33
+#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35
+#define __pyx_tuple__37 __pyx_mstate_global->__pyx_tuple__37
+#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39
+#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41
+#define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43
+#define __pyx_tuple__45 __pyx_mstate_global->__pyx_tuple__45
+#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48
+#define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50
+#define __pyx_tuple__52 __pyx_mstate_global->__pyx_tuple__52
+#define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53
+#define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55
+#define __pyx_tuple__57 __pyx_mstate_global->__pyx_tuple__57
+#define __pyx_tuple__59 __pyx_mstate_global->__pyx_tuple__59
+#define __pyx_tuple__61 __pyx_mstate_global->__pyx_tuple__61
+#define __pyx_tuple__63 __pyx_mstate_global->__pyx_tuple__63
+#define __pyx_tuple__65 __pyx_mstate_global->__pyx_tuple__65
+#define __pyx_tuple__67 __pyx_mstate_global->__pyx_tuple__67
+#define __pyx_tuple__69 __pyx_mstate_global->__pyx_tuple__69
+#define __pyx_tuple__71 __pyx_mstate_global->__pyx_tuple__71
+#define __pyx_tuple__73 __pyx_mstate_global->__pyx_tuple__73
+#define __pyx_tuple__75 __pyx_mstate_global->__pyx_tuple__75
+#define __pyx_tuple__77 __pyx_mstate_global->__pyx_tuple__77
+#define __pyx_tuple__79 __pyx_mstate_global->__pyx_tuple__79
+#define __pyx_tuple__81 __pyx_mstate_global->__pyx_tuple__81
+#define __pyx_tuple__83 __pyx_mstate_global->__pyx_tuple__83
+#define __pyx_tuple__85 __pyx_mstate_global->__pyx_tuple__85
+#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10
+#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12
+#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13
+#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15
+#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16
+#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18
+#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24
+#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27
+#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29
+#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32
+#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34
+#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36
+#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38
+#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40
+#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42
+#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44
+#define __pyx_codeobj__46 __pyx_mstate_global->__pyx_codeobj__46
+#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47
+#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49
+#define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51
+#define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54
+#define __pyx_codeobj__56 __pyx_mstate_global->__pyx_codeobj__56
+#define __pyx_codeobj__58 __pyx_mstate_global->__pyx_codeobj__58
+#define __pyx_codeobj__60 __pyx_mstate_global->__pyx_codeobj__60
+#define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62
+#define __pyx_codeobj__64 __pyx_mstate_global->__pyx_codeobj__64
+#define __pyx_codeobj__66 __pyx_mstate_global->__pyx_codeobj__66
+#define __pyx_codeobj__68 __pyx_mstate_global->__pyx_codeobj__68
+#define __pyx_codeobj__70 __pyx_mstate_global->__pyx_codeobj__70
+#define __pyx_codeobj__72 __pyx_mstate_global->__pyx_codeobj__72
+#define __pyx_codeobj__74 __pyx_mstate_global->__pyx_codeobj__74
+#define __pyx_codeobj__76 __pyx_mstate_global->__pyx_codeobj__76
+#define __pyx_codeobj__78 __pyx_mstate_global->__pyx_codeobj__78
+#define __pyx_codeobj__80 __pyx_mstate_global->__pyx_codeobj__80
+#define __pyx_codeobj__82 __pyx_mstate_global->__pyx_codeobj__82
+#define __pyx_codeobj__84 __pyx_mstate_global->__pyx_codeobj__84
+#define __pyx_codeobj__86 __pyx_mstate_global->__pyx_codeobj__86
+#define __pyx_codeobj__87 __pyx_mstate_global->__pyx_codeobj__87
+#define __pyx_codeobj__88 __pyx_mstate_global->__pyx_codeobj__88
+/* #### Code section: module_code ### */
+
+/* "cpython/complex.pxd":19
+ * 
+ *         @property
+ *         cdef inline double real(self) noexcept:             # <<<<<<<<<<<<<<
+ *             return self.cval.real
+ * 
+ */
+
+static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self) {
+  double __pyx_r;
+
+  /* "cpython/complex.pxd":20
+ *         @property
+ *         cdef inline double real(self) noexcept:
+ *             return self.cval.real             # <<<<<<<<<<<<<<
+ * 
+ *         @property
+ */
+  __pyx_r = __pyx_v_self->cval.real;
+  goto __pyx_L0;
 
-  /* "ssh2/session.pyx":57
+  /* "cpython/complex.pxd":19
  * 
- * cdef class MethodType:
- *     def __cinit__(self, value):             # <<<<<<<<<<<<<<
- *         self.value = value
+ *         @property
+ *         cdef inline double real(self) noexcept:             # <<<<<<<<<<<<<<
+ *             return self.cval.real
  * 
  */
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_AddTraceback("ssh2.session.MethodType.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+/* "cpython/complex.pxd":23
+ * 
+ *         @property
+ *         cdef inline double imag(self) noexcept:             # <<<<<<<<<<<<<<
+ *             return self.cval.imag
+ * 
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_10MethodType_2__reduce_cython__[] = "MethodType.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType_2__reduce_cython__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self));
+static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self) {
+  double __pyx_r;
+
+  /* "cpython/complex.pxd":24
+ *         @property
+ *         cdef inline double imag(self) noexcept:
+ *             return self.cval.imag             # <<<<<<<<<<<<<<
+ * 
+ *     # PyTypeObject PyComplex_Type
+ */
+  __pyx_r = __pyx_v_self->cval.imag;
+  goto __pyx_L0;
+
+  /* "cpython/complex.pxd":23
+ * 
+ *         @property
+ *         cdef inline double imag(self) noexcept:             # <<<<<<<<<<<<<<
+ *             return self.cval.imag
+ * 
+ */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  __pyx_L0:;
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4ssh2_7session_10MethodType_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self) {
+/* "cpython/contextvars.pxd":112
+ * 
+ * 
+ * cdef inline object get_value(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the default value of the context variable,
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value *__pyx_optional_args) {
+  PyObject *__pyx_v_default_value = ((PyObject *)Py_None);
+  PyObject *__pyx_v_value;
+  PyObject *__pyx_v_pyvalue = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("get_value", 1);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_default_value = __pyx_optional_args->default_value;
+    }
+  }
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "cpython/contextvars.pxd":117
+ *     or None if no such value or default was found.
+ *     """
+ *     cdef PyObject *value = NULL             # <<<<<<<<<<<<<<
+ *     PyContextVar_Get(var, NULL, &value)
+ *     if value is NULL:
+ */
+  __pyx_v_value = NULL;
+
+  /* "cpython/contextvars.pxd":118
+ *     """
+ *     cdef PyObject *value = NULL
+ *     PyContextVar_Get(var, NULL, &value)             # <<<<<<<<<<<<<<
+ *     if value is NULL:
+ *         # context variable does not have a default
+ */
+  __pyx_t_1 = PyContextVar_Get(__pyx_v_var, NULL, (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 118, __pyx_L1_error)
+
+  /* "cpython/contextvars.pxd":119
+ *     cdef PyObject *value = NULL
+ *     PyContextVar_Get(var, NULL, &value)
+ *     if value is NULL:             # <<<<<<<<<<<<<<
+ *         # context variable does not have a default
+ *         pyvalue = default_value
+ */
+  __pyx_t_2 = (__pyx_v_value == NULL);
+  if (__pyx_t_2) {
+
+    /* "cpython/contextvars.pxd":121
+ *     if value is NULL:
+ *         # context variable does not have a default
+ *         pyvalue = default_value             # <<<<<<<<<<<<<<
+ *     else:
+ *         # value or default value of context variable
+ */
+    __Pyx_INCREF(__pyx_v_default_value);
+    __pyx_v_pyvalue = __pyx_v_default_value;
+
+    /* "cpython/contextvars.pxd":119
+ *     cdef PyObject *value = NULL
+ *     PyContextVar_Get(var, NULL, &value)
+ *     if value is NULL:             # <<<<<<<<<<<<<<
+ *         # context variable does not have a default
+ *         pyvalue = default_value
+ */
+    goto __pyx_L3;
+  }
+
+  /* "cpython/contextvars.pxd":124
+ *     else:
+ *         # value or default value of context variable
+ *         pyvalue = <object>value             # <<<<<<<<<<<<<<
+ *         Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+ *     return pyvalue
+ */
+  /*else*/ {
+    __pyx_t_3 = ((PyObject *)__pyx_v_value);
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_v_pyvalue = __pyx_t_3;
+    __pyx_t_3 = 0;
+
+    /* "cpython/contextvars.pxd":125
+ *         # value or default value of context variable
+ *         pyvalue = <object>value
+ *         Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'             # <<<<<<<<<<<<<<
+ *     return pyvalue
+ * 
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __PYX_ERR(0, 2, __pyx_L1_error)
+    Py_XDECREF(__pyx_v_value);
+  }
+  __pyx_L3:;
 
-  /* "(tree fragment)":1
- * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
+  /* "cpython/contextvars.pxd":126
+ *         pyvalue = <object>value
+ *         Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+ *     return pyvalue             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_pyvalue);
+  __pyx_r = __pyx_v_pyvalue;
+  goto __pyx_L0;
+
+  /* "cpython/contextvars.pxd":112
+ * 
+ * 
+ * cdef inline object get_value(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the default value of the context variable,
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("ssh2.session.MethodType.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("cpython.contextvars.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_pyvalue);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "(tree fragment)":3
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+/* "cpython/contextvars.pxd":129
+ * 
+ * 
+ * cdef inline object get_value_no_default(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the provided default value if no such value was found.
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_7session_10MethodType_4__setstate_cython__[] = "MethodType.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value_no_default(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default *__pyx_optional_args) {
+  PyObject *__pyx_v_default_value = ((PyObject *)Py_None);
+  PyObject *__pyx_v_value;
+  PyObject *__pyx_v_pyvalue = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_value_no_default", 1);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_default_value = __pyx_optional_args->default_value;
+    }
+  }
+
+  /* "cpython/contextvars.pxd":135
+ *     Ignores the default value of the context variable, if any.
+ *     """
+ *     cdef PyObject *value = NULL             # <<<<<<<<<<<<<<
+ *     PyContextVar_Get(var, <PyObject*>default_value, &value)
+ *     # value of context variable or 'default_value'
+ */
+  __pyx_v_value = NULL;
+
+  /* "cpython/contextvars.pxd":136
+ *     """
+ *     cdef PyObject *value = NULL
+ *     PyContextVar_Get(var, <PyObject*>default_value, &value)             # <<<<<<<<<<<<<<
+ *     # value of context variable or 'default_value'
+ *     pyvalue = <object>value
+ */
+  __pyx_t_1 = PyContextVar_Get(__pyx_v_var, ((PyObject *)__pyx_v_default_value), (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 136, __pyx_L1_error)
+
+  /* "cpython/contextvars.pxd":138
+ *     PyContextVar_Get(var, <PyObject*>default_value, &value)
+ *     # value of context variable or 'default_value'
+ *     pyvalue = <object>value             # <<<<<<<<<<<<<<
+ *     Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+ *     return pyvalue
+ */
+  __pyx_t_2 = ((PyObject *)__pyx_v_value);
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_v_pyvalue = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  /* "cpython/contextvars.pxd":139
+ *     # value of context variable or 'default_value'
+ *     pyvalue = <object>value
+ *     Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'             # <<<<<<<<<<<<<<
+ *     return pyvalue
+ */
+  Py_XDECREF(__pyx_v_value);
+
+  /* "cpython/contextvars.pxd":140
+ *     pyvalue = <object>value
+ *     Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+ *     return pyvalue             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_pyvalue);
+  __pyx_r = __pyx_v_pyvalue;
+  goto __pyx_L0;
+
+  /* "cpython/contextvars.pxd":129
+ * 
+ * 
+ * cdef inline object get_value_no_default(var, default_value=None):             # <<<<<<<<<<<<<<
+ *     """Return a new reference to the value of the context variable,
+ *     or the provided default value if no such value was found.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cpython.contextvars.get_value_no_default", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_pyvalue);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "ssh2/session.pyx":57
+ * 
+ * cdef class MethodType:
+ *     def __cinit__(self, value):             # <<<<<<<<<<<<<<
+ *         self.value = value
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_4ssh2_7session_10MethodType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_4ssh2_7session_10MethodType_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_value = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 57, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 57, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
+    }
+    __pyx_v_value = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 57, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.MethodType.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType___cinit__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self), __pyx_v_value);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_4ssh2_7session_10MethodType___cinit__(struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self, PyObject *__pyx_v_value) {
+  int __pyx_r;
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "ssh2/session.pyx":58
+ * cdef class MethodType:
+ *     def __cinit__(self, value):
+ *         self.value = value             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 58, __pyx_L1_error)
+  __pyx_v_self->value = __pyx_t_1;
+
+  /* "ssh2/session.pyx":57
+ * 
+ * cdef class MethodType:
+ *     def __cinit__(self, value):             # <<<<<<<<<<<<<<
+ *         self.value = value
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("ssh2.session.MethodType.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_10MethodType_2__reduce_cython__, "MethodType.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_10MethodType_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_10MethodType_2__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
+  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType_2__reduce_cython__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4ssh2_7session_10MethodType_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
+
+  /* "(tree fragment)":2
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
+ * def __setstate_cython__(self, __pyx_state):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
+  __PYX_ERR(0, 2, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("ssh2.session.MethodType.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_10MethodType_4__setstate_cython__, "MethodType.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_10MethodType_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_10MethodType_4__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType_4__setstate_cython__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.MethodType.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7session_10MethodType_4__setstate_cython__(((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2201,33 +5202,28 @@ static PyObject *__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__(PyObj
 static PyObject *__pyx_pf_4ssh2_7session_10MethodType_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.session.MethodType.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2254,9 +5250,9 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
   void *__pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
   int __pyx_t_3;
-  int __pyx_t_4;
+  PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
+  unsigned int __pyx_t_6;
   Py_ssize_t __pyx_t_7;
   char *__pyx_t_8;
   size_t __pyx_t_9;
@@ -2265,7 +5261,7 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("kbd_callback", 0);
+  __Pyx_RefNannySetupContext("kbd_callback", 1);
 
   /* "ssh2/session.pyx":79
  *                        c_ssh2.LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
@@ -2288,8 +5284,7 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
  *     cdef bytes b_password = to_bytes(py_sess._kbd_callback())
  */
   __pyx_t_3 = (__pyx_v_py_sess->_kbd_callback == Py_None);
-  __pyx_t_4 = (__pyx_t_3 != 0);
-  if (__pyx_t_4) {
+  if (__pyx_t_3) {
 
     /* "ssh2/session.pyx":81
  *     py_sess = (<Session>c_dereference(abstract))
@@ -2317,26 +5312,33 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
  *     cdef char *_password = b_password
  */
   __Pyx_INCREF(__pyx_v_py_sess->_kbd_callback);
-  __pyx_t_5 = __pyx_v_py_sess->_kbd_callback; __pyx_t_6 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
-    if (likely(__pyx_t_6)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-      __Pyx_INCREF(__pyx_t_6);
+  __pyx_t_4 = __pyx_v_py_sess->_kbd_callback; __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
       __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_5, function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_6 = 1;
     }
   }
-  __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_t_4 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_b_password = ((PyObject*)__pyx_t_5);
-  __pyx_t_5 = 0;
+  __pyx_v_b_password = ((PyObject*)__pyx_t_4);
+  __pyx_t_4 = 0;
 
   /* "ssh2/session.pyx":83
  *         return
@@ -2349,7 +5351,7 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
     __PYX_ERR(1, 83, __pyx_L1_error)
   }
-  __pyx_t_7 = PyBytes_GET_SIZE(__pyx_v_b_password); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 83, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_password); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 83, __pyx_L1_error)
   __pyx_v__len = __pyx_t_7;
 
   /* "ssh2/session.pyx":84
@@ -2373,8 +5375,8 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
  *         _password_copy = <char *>malloc(sizeof(char) * _len)
  *         for i in range(_len):
  */
-  __pyx_t_4 = ((__pyx_v_num_prompts == 1) != 0);
-  if (__pyx_t_4) {
+  __pyx_t_3 = (__pyx_v_num_prompts == 1);
+  if (__pyx_t_3) {
 
     /* "ssh2/session.pyx":87
  *     cdef char *_password_copy
@@ -2446,8 +5448,8 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
   goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.session.kbd_callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_py_sess);
@@ -2466,12 +5468,20 @@ static void __pyx_f_4ssh2_7session_kbd_callback(CYTHON_UNUSED char const *__pyx_
 /* Python wrapper */
 static int __pyx_pw_4ssh2_7session_7Session_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_7session_7Session_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
-    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session___cinit__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -2486,7 +5496,7 @@ static int __pyx_pf_4ssh2_7session_7Session___cinit__(struct __pyx_obj_4ssh2_7se
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/session.pyx":99
  * 
@@ -2504,7 +5514,7 @@ static int __pyx_pf_4ssh2_7session_7Session___cinit__(struct __pyx_obj_4ssh2_7se
  *             raise MemoryError
  *         self._sock = 0
  */
-  __pyx_t_1 = ((__pyx_v_self->_session == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_session == NULL);
   if (unlikely(__pyx_t_1)) {
 
     /* "ssh2/session.pyx":102
@@ -2590,8 +5600,10 @@ static int __pyx_pf_4ssh2_7session_7Session___cinit__(struct __pyx_obj_4ssh2_7se
 /* Python wrapper */
 static void __pyx_pw_4ssh2_7session_7Session_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_7session_7Session_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_7session_7Session_2__dealloc__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -2599,9 +5611,7 @@ static void __pyx_pw_4ssh2_7session_7Session_3__dealloc__(PyObject *__pyx_v_self
 }
 
 static void __pyx_pf_4ssh2_7session_7Session_2__dealloc__(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/session.pyx":108
  * 
@@ -2610,7 +5620,7 @@ static void __pyx_pf_4ssh2_7session_7Session_2__dealloc__(struct __pyx_obj_4ssh2
  *             c_ssh2.libssh2_session_free(self._session)
  *         self._session = NULL
  */
-  __pyx_t_1 = ((__pyx_v_self->_session != NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_session != NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/session.pyx":109
@@ -2649,7 +5659,6 @@ static void __pyx_pf_4ssh2_7session_7Session_2__dealloc__(struct __pyx_obj_4ssh2
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
 /* "ssh2/session.pyx":112
@@ -2661,12 +5670,40 @@ static void __pyx_pf_4ssh2_7session_7Session_2__dealloc__(struct __pyx_obj_4ssh2
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_5disconnect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_4disconnect[] = "Session.disconnect(self)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_5disconnect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_5disconnect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_4disconnect, "Session.disconnect(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_5disconnect = {"disconnect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_5disconnect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_4disconnect};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_5disconnect(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("disconnect (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("disconnect", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "disconnect", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_4disconnect(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -2683,7 +5720,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_4disconnect(struct __pyx_obj_4
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("disconnect", 0);
+  __Pyx_RefNannySetupContext("disconnect", 1);
 
   /* "ssh2/session.pyx":114
  *     def disconnect(self):
@@ -2695,6 +5732,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_4disconnect(struct __pyx_obj_4
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2772,25 +5810,105 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_4disconnect(struct __pyx_obj_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_7handshake(PyObject *__pyx_v_self, PyObject *__pyx_v_sock); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_6handshake[] = "Session.handshake(self, sock)\nPerform SSH handshake.\n\n        Must be called after Session initialisation.";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_7handshake(PyObject *__pyx_v_self, PyObject *__pyx_v_sock) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_7handshake(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_6handshake, "Session.handshake(self, sock)\nPerform SSH handshake.\n\n        Must be called after Session initialisation.");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_7handshake = {"handshake", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_7handshake, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_6handshake};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_7handshake(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_sock = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("handshake (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sock)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 118, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "handshake") < 0)) __PYX_ERR(1, 118, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_sock = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("handshake", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 118, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.handshake", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_sock) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "sock"); __PYX_ERR(1, 118, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_6handshake(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_sock));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_6handshake(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_sock);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2805,7 +5923,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_6handshake(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("handshake", 0);
+  __Pyx_RefNannySetupContext("handshake", 1);
 
   /* "ssh2/session.pyx":122
  * 
@@ -2827,6 +5945,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_6handshake(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2926,15 +6045,98 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_6handshake(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_9startup(PyObject *__pyx_v_self, PyObject *__pyx_v_sock); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_8startup[] = "Session.startup(self, sock)\nDeprecated - use self.handshake";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_9startup(PyObject *__pyx_v_self, PyObject *__pyx_v_sock) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_9startup(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_8startup, "Session.startup(self, sock)\nDeprecated - use self.handshake");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_9startup = {"startup", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_9startup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_8startup};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_9startup(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_sock = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("startup (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_8startup(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_sock));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sock)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 130, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "startup") < 0)) __PYX_ERR(1, 130, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_sock = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("startup", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 130, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.startup", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_8startup(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_sock);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2949,37 +6151,37 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_8startup(struct __pyx_obj_4ssh
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("startup", 0);
+  __Pyx_RefNannySetupContext("startup", 1);
 
   /* "ssh2/session.pyx":132
  *     def startup(self, sock):
  *         """Deprecated - use self.handshake"""
  *         cdef int _sock = PyObject_AsFileDescriptor(sock)             # <<<<<<<<<<<<<<
- *         cdef int rc
- *         rc = c_ssh2.libssh2_session_startup(self._session, _sock)
+ *         cdef int rc = c_ssh2.libssh2_session_startup(self._session, _sock)
+ *         return handle_error_codes(rc)
  */
   __pyx_t_1 = PyObject_AsFileDescriptor(__pyx_v_sock); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 132, __pyx_L1_error)
   __pyx_v__sock = __pyx_t_1;
 
-  /* "ssh2/session.pyx":134
+  /* "ssh2/session.pyx":133
+ *         """Deprecated - use self.handshake"""
  *         cdef int _sock = PyObject_AsFileDescriptor(sock)
- *         cdef int rc
- *         rc = c_ssh2.libssh2_session_startup(self._session, _sock)             # <<<<<<<<<<<<<<
+ *         cdef int rc = c_ssh2.libssh2_session_startup(self._session, _sock)             # <<<<<<<<<<<<<<
  *         return handle_error_codes(rc)
  * 
  */
   __pyx_v_rc = libssh2_session_startup(__pyx_v_self->_session, __pyx_v__sock);
 
-  /* "ssh2/session.pyx":135
- *         cdef int rc
- *         rc = c_ssh2.libssh2_session_startup(self._session, _sock)
+  /* "ssh2/session.pyx":134
+ *         cdef int _sock = PyObject_AsFileDescriptor(sock)
+ *         cdef int rc = c_ssh2.libssh2_session_startup(self._session, _sock)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
  * 
  *     def set_blocking(self, bint blocking):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 135, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 135, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 134, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
@@ -3004,7 +6206,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_8startup(struct __pyx_obj_4ssh
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":137
+/* "ssh2/session.pyx":136
  *         return handle_error_codes(rc)
  * 
  *     def set_blocking(self, bint blocking):             # <<<<<<<<<<<<<<
@@ -3013,28 +6215,98 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_8startup(struct __pyx_obj_4ssh
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_11set_blocking(PyObject *__pyx_v_self, PyObject *__pyx_arg_blocking); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_10set_blocking[] = "Session.set_blocking(self, bool blocking)\nSet session blocking mode on/off.\n\n        :param blocking: ``False`` for non-blocking, ``True`` for blocking.\n          Session default is blocking unless set otherwise.\n        :type blocking: bool";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_11set_blocking(PyObject *__pyx_v_self, PyObject *__pyx_arg_blocking) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_11set_blocking(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_10set_blocking, "Session.set_blocking(self, bool blocking)\nSet session blocking mode on/off.\n\n        :param blocking: ``False`` for non-blocking, ``True`` for blocking.\n          Session default is blocking unless set otherwise.\n        :type blocking: bool");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_11set_blocking = {"set_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_11set_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_10set_blocking};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_11set_blocking(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_blocking;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("set_blocking (wrapper)", 0);
-  assert(__pyx_arg_blocking); {
-    __pyx_v_blocking = __Pyx_PyObject_IsTrue(__pyx_arg_blocking); if (unlikely((__pyx_v_blocking == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 137, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_blocking,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_blocking)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 136, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_blocking") < 0)) __PYX_ERR(1, 136, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_blocking = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_blocking == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 136, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_blocking", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 136, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.set_blocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_10set_blocking(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((int)__pyx_v_blocking));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_10set_blocking(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_blocking);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3042,9 +6314,9 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_11set_blocking(PyObject *__pyx
 static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self, int __pyx_v_blocking) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_blocking", 0);
+  __Pyx_RefNannySetupContext("set_blocking", 1);
 
-  /* "ssh2/session.pyx":143
+  /* "ssh2/session.pyx":142
  *           Session default is blocking unless set otherwise.
  *         :type blocking: bool"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3054,12 +6326,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":144
+        /* "ssh2/session.pyx":143
  *         :type blocking: bool"""
  *         with nogil:
  *             c_ssh2.libssh2_session_set_blocking(             # <<<<<<<<<<<<<<
@@ -3069,7 +6342,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_ob
         libssh2_session_set_blocking(__pyx_v_self->_session, __pyx_v_blocking);
       }
 
-      /* "ssh2/session.pyx":143
+      /* "ssh2/session.pyx":142
  *           Session default is blocking unless set otherwise.
  *         :type blocking: bool"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3088,7 +6361,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_ob
       }
   }
 
-  /* "ssh2/session.pyx":137
+  /* "ssh2/session.pyx":136
  *         return handle_error_codes(rc)
  * 
  *     def set_blocking(self, bint blocking):             # <<<<<<<<<<<<<<
@@ -3103,7 +6376,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":147
+/* "ssh2/session.pyx":146
  *                 self._session, blocking)
  * 
  *     def get_blocking(self):             # <<<<<<<<<<<<<<
@@ -3112,12 +6385,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_10set_blocking(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_13get_blocking(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_12get_blocking[] = "Session.get_blocking(self)\nGet session blocking mode enabled True/False.\n\n        :rtype: bool";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_13get_blocking(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_13get_blocking(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_12get_blocking, "Session.get_blocking(self)\nGet session blocking mode enabled True/False.\n\n        :rtype: bool");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_13get_blocking = {"get_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_13get_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_12get_blocking};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_13get_blocking(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_blocking (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_blocking", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_blocking", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_12get_blocking(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -3134,9 +6435,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_blocking", 0);
+  __Pyx_RefNannySetupContext("get_blocking", 1);
 
-  /* "ssh2/session.pyx":152
+  /* "ssh2/session.pyx":151
  *         :rtype: bool"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3146,12 +6447,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":153
+        /* "ssh2/session.pyx":152
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_get_blocking(self._session)             # <<<<<<<<<<<<<<
@@ -3161,7 +6463,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
         __pyx_v_rc = libssh2_session_get_blocking(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":152
+      /* "ssh2/session.pyx":151
  *         :rtype: bool"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3180,7 +6482,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
       }
   }
 
-  /* "ssh2/session.pyx":154
+  /* "ssh2/session.pyx":153
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_get_blocking(self._session)
  *         return bool(rc)             # <<<<<<<<<<<<<<
@@ -3188,17 +6490,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
  *     def set_timeout(self, long timeout):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 154, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 154, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 153, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 154, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":147
+  /* "ssh2/session.pyx":146
  *                 self._session, blocking)
  * 
  *     def get_blocking(self):             # <<<<<<<<<<<<<<
@@ -3217,7 +6519,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":156
+/* "ssh2/session.pyx":155
  *         return bool(rc)
  * 
  *     def set_timeout(self, long timeout):             # <<<<<<<<<<<<<<
@@ -3226,28 +6528,98 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_12get_blocking(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_15set_timeout(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_14set_timeout[] = "Session.set_timeout(self, long timeout)\nSet the timeout in milliseconds for how long a blocking\n        call may wait until the situation is considered an error and\n        :py:class:`ssh2.error_codes.LIBSSH2_ERROR_TIMEOUT` is returned.\n\n        By default or if timeout set is zero, blocking calls do not\n        time out.\n        :param timeout: Milliseconds to wait before timeout.";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_15set_timeout(PyObject *__pyx_v_self, PyObject *__pyx_arg_timeout) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_15set_timeout(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_14set_timeout, "Session.set_timeout(self, long timeout)\nSet the timeout in milliseconds for how long a blocking\n        call may wait until the situation is considered an error and\n        :py:class:`ssh2.error_codes.LIBSSH2_ERROR_TIMEOUT` is returned.\n\n        By default or if timeout set is zero, blocking calls do not\n        time out.\n        :param timeout: Milliseconds to wait before timeout.");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_15set_timeout = {"set_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_15set_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_14set_timeout};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_15set_timeout(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   long __pyx_v_timeout;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("set_timeout (wrapper)", 0);
-  assert(__pyx_arg_timeout); {
-    __pyx_v_timeout = __Pyx_PyInt_As_long(__pyx_arg_timeout); if (unlikely((__pyx_v_timeout == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 156, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 155, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_timeout") < 0)) __PYX_ERR(1, 155, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_timeout = __Pyx_PyInt_As_long(values[0]); if (unlikely((__pyx_v_timeout == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 155, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_timeout", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 155, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.set_timeout", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_14set_timeout(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((long)__pyx_v_timeout));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_14set_timeout(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_timeout);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3255,9 +6627,9 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_15set_timeout(PyObject *__pyx_
 static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self, long __pyx_v_timeout) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_timeout", 0);
+  __Pyx_RefNannySetupContext("set_timeout", 1);
 
-  /* "ssh2/session.pyx":164
+  /* "ssh2/session.pyx":163
  *         time out.
  *         :param timeout: Milliseconds to wait before timeout."""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3267,12 +6639,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":165
+        /* "ssh2/session.pyx":164
  *         :param timeout: Milliseconds to wait before timeout."""
  *         with nogil:
  *             c_ssh2.libssh2_session_set_timeout(self._session, timeout)             # <<<<<<<<<<<<<<
@@ -3282,7 +6655,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj
         libssh2_session_set_timeout(__pyx_v_self->_session, __pyx_v_timeout);
       }
 
-      /* "ssh2/session.pyx":164
+      /* "ssh2/session.pyx":163
  *         time out.
  *         :param timeout: Milliseconds to wait before timeout."""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3301,7 +6674,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj
       }
   }
 
-  /* "ssh2/session.pyx":156
+  /* "ssh2/session.pyx":155
  *         return bool(rc)
  * 
  *     def set_timeout(self, long timeout):             # <<<<<<<<<<<<<<
@@ -3316,7 +6689,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":167
+/* "ssh2/session.pyx":166
  *             c_ssh2.libssh2_session_set_timeout(self._session, timeout)
  * 
  *     def get_timeout(self):             # <<<<<<<<<<<<<<
@@ -3325,12 +6698,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_14set_timeout(struct __pyx_obj
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_17get_timeout(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_16get_timeout[] = "Session.get_timeout(self)\nGet current session timeout setting";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_17get_timeout(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_17get_timeout(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_16get_timeout, "Session.get_timeout(self)\nGet current session timeout setting");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_17get_timeout = {"get_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_17get_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_16get_timeout};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_17get_timeout(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_timeout (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_timeout", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_timeout", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_16get_timeout(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -3346,9 +6747,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_timeout", 0);
+  __Pyx_RefNannySetupContext("get_timeout", 1);
 
-  /* "ssh2/session.pyx":170
+  /* "ssh2/session.pyx":169
  *         """Get current session timeout setting"""
  *         cdef long timeout
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3358,12 +6759,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":171
+        /* "ssh2/session.pyx":170
  *         cdef long timeout
  *         with nogil:
  *             timeout = c_ssh2.libssh2_session_get_timeout(self._session)             # <<<<<<<<<<<<<<
@@ -3373,7 +6775,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
         __pyx_v_timeout = libssh2_session_get_timeout(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":170
+      /* "ssh2/session.pyx":169
  *         """Get current session timeout setting"""
  *         cdef long timeout
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3392,7 +6794,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
       }
   }
 
-  /* "ssh2/session.pyx":172
+  /* "ssh2/session.pyx":171
  *         with nogil:
  *             timeout = c_ssh2.libssh2_session_get_timeout(self._session)
  *         return timeout             # <<<<<<<<<<<<<<
@@ -3400,13 +6802,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
  *     def userauth_authenticated(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 172, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":167
+  /* "ssh2/session.pyx":166
  *             c_ssh2.libssh2_session_set_timeout(self._session, timeout)
  * 
  *     def get_timeout(self):             # <<<<<<<<<<<<<<
@@ -3425,7 +6827,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":174
+/* "ssh2/session.pyx":173
  *         return timeout
  * 
  *     def userauth_authenticated(self):             # <<<<<<<<<<<<<<
@@ -3434,12 +6836,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_16get_timeout(struct __pyx_obj
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_18userauth_authenticated[] = "Session.userauth_authenticated(self)\nTrue/False for is user authenticated or not.\n\n        :rtype: bool";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_18userauth_authenticated, "Session.userauth_authenticated(self)\nTrue/False for is user authenticated or not.\n\n        :rtype: bool");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_19userauth_authenticated = {"userauth_authenticated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_18userauth_authenticated};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_authenticated (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("userauth_authenticated", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "userauth_authenticated", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -3456,9 +6886,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_authenticated", 0);
+  __Pyx_RefNannySetupContext("userauth_authenticated", 1);
 
-  /* "ssh2/session.pyx":179
+  /* "ssh2/session.pyx":178
  *         :rtype: bool"""
  *         cdef bint rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3468,12 +6898,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":180
+        /* "ssh2/session.pyx":179
  *         cdef bint rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_authenticated(self._session)             # <<<<<<<<<<<<<<
@@ -3483,7 +6914,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
         __pyx_v_rc = libssh2_userauth_authenticated(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":179
+      /* "ssh2/session.pyx":178
  *         :rtype: bool"""
  *         cdef bint rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3502,7 +6933,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
       }
   }
 
-  /* "ssh2/session.pyx":181
+  /* "ssh2/session.pyx":180
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_authenticated(self._session)
  *         return bool(rc)             # <<<<<<<<<<<<<<
@@ -3511,13 +6942,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
  */
   __Pyx_XDECREF(__pyx_r);
   __pyx_t_1 = __pyx_v_rc;
-  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 181, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":174
+  /* "ssh2/session.pyx":173
  *         return timeout
  * 
  *     def userauth_authenticated(self):             # <<<<<<<<<<<<<<
@@ -3536,34 +6967,114 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_18userauth_authenticated(struc
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":183
+/* "ssh2/session.pyx":182
  *         return bool(rc)
  * 
  *     def userauth_list(self, username not None):             # <<<<<<<<<<<<<<
- *         """Retrieve available authentication methods list.
+ *         """Retrieve available authentication methodslist.
  * 
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_21userauth_list(PyObject *__pyx_v_self, PyObject *__pyx_v_username); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_20userauth_list[] = "Session.userauth_list(self, username)\nRetrieve available authentication methods list.\n\n        :rtype: list";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_21userauth_list(PyObject *__pyx_v_self, PyObject *__pyx_v_username) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_21userauth_list(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_20userauth_list, "Session.userauth_list(self, username)\nRetrieve available authentication methodslist.\n\n        :rtype: list");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_21userauth_list = {"userauth_list", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_21userauth_list, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_20userauth_list};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_21userauth_list(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_username = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_list (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 182, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_list") < 0)) __PYX_ERR(1, 182, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_username = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("userauth_list", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 182, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.userauth_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 183, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 182, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_20userauth_list(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_username));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_20userauth_list(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3583,21 +7094,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_list", 0);
+  __Pyx_RefNannySetupContext("userauth_list", 1);
 
-  /* "ssh2/session.pyx":187
+  /* "ssh2/session.pyx":186
  * 
  *         :rtype: list"""
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef size_t username_len = len(b_username)
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 187, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 186, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":188
+  /* "ssh2/session.pyx":187
  *         :rtype: list"""
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -3606,12 +7117,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 188, __pyx_L1_error)
+    __PYX_ERR(1, 187, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 188, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 187, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":189
+  /* "ssh2/session.pyx":188
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username
  *         cdef size_t username_len = len(b_username)             # <<<<<<<<<<<<<<
@@ -3620,12 +7131,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 189, __pyx_L1_error)
+    __PYX_ERR(1, 188, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_username); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 189, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_username); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 188, __pyx_L1_error)
   __pyx_v_username_len = __pyx_t_3;
 
-  /* "ssh2/session.pyx":192
+  /* "ssh2/session.pyx":191
  *         cdef char *_auth
  *         cdef str auth
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3635,12 +7146,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":193
+        /* "ssh2/session.pyx":192
  *         cdef str auth
  *         with nogil:
  *             _auth = c_ssh2.libssh2_userauth_list(             # <<<<<<<<<<<<<<
@@ -3650,7 +7162,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
         __pyx_v__auth = libssh2_userauth_list(__pyx_v_self->_session, __pyx_v__username, __pyx_v_username_len);
       }
 
-      /* "ssh2/session.pyx":192
+      /* "ssh2/session.pyx":191
  *         cdef char *_auth
  *         cdef str auth
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -3669,17 +7181,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
       }
   }
 
-  /* "ssh2/session.pyx":195
+  /* "ssh2/session.pyx":194
  *             _auth = c_ssh2.libssh2_userauth_list(
  *                 self._session, _username, username_len)
  *         if _auth is NULL:             # <<<<<<<<<<<<<<
  *             return
  *         auth = to_str(_auth)
  */
-  __pyx_t_4 = ((__pyx_v__auth == NULL) != 0);
+  __pyx_t_4 = (__pyx_v__auth == NULL);
   if (__pyx_t_4) {
 
-    /* "ssh2/session.pyx":196
+    /* "ssh2/session.pyx":195
  *                 self._session, _username, username_len)
  *         if _auth is NULL:
  *             return             # <<<<<<<<<<<<<<
@@ -3690,7 +7202,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
     __pyx_r = Py_None; __Pyx_INCREF(Py_None);
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":195
+    /* "ssh2/session.pyx":194
  *             _auth = c_ssh2.libssh2_userauth_list(
  *                 self._session, _username, username_len)
  *         if _auth is NULL:             # <<<<<<<<<<<<<<
@@ -3699,20 +7211,20 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
  */
   }
 
-  /* "ssh2/session.pyx":197
+  /* "ssh2/session.pyx":196
  *         if _auth is NULL:
  *             return
  *         auth = to_str(_auth)             # <<<<<<<<<<<<<<
  *         return auth.split(',')
  * 
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_str(__pyx_v__auth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 197, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_str(__pyx_v__auth); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 196, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 197, __pyx_L1_error)
+  if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(1, 196, __pyx_L1_error)
   __pyx_v_auth = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":198
+  /* "ssh2/session.pyx":197
  *             return
  *         auth = to_str(_auth)
  *         return auth.split(',')             # <<<<<<<<<<<<<<
@@ -3720,17 +7232,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
  *     def userauth_publickey_fromfile(self, username not None,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyString_Type_split, __pyx_v_auth, __pyx_kp_s__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 198, __pyx_L1_error)
+  if (unlikely(__pyx_v_auth == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "split");
+    __PYX_ERR(1, 197, __pyx_L1_error)
+  }
+  __pyx_t_1 = PyUnicode_Split(__pyx_v_auth, __Pyx_NoneAsNull(__pyx_kp_u_), -1L); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 197, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":183
+  /* "ssh2/session.pyx":182
  *         return bool(rc)
  * 
  *     def userauth_list(self, username not None):             # <<<<<<<<<<<<<<
- *         """Retrieve available authentication methods list.
+ *         """Retrieve available authentication methodslist.
  * 
  */
 
@@ -3747,7 +7263,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":200
+/* "ssh2/session.pyx":199
  *         return auth.split(',')
  * 
  *     def userauth_publickey_fromfile(self, username not None,             # <<<<<<<<<<<<<<
@@ -3756,82 +7272,117 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_20userauth_list(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_22userauth_publickey_fromfile[] = "Session.userauth_publickey_fromfile(self, username, privatekey, passphrase='', publickey=None)\nAuthenticate with public key from file.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_22userauth_publickey_fromfile, "Session.userauth_publickey_fromfile(self, username, privatekey, passphrase=u'', publickey=None)\nAuthenticate with public key from file.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_23userauth_publickey_fromfile = {"userauth_publickey_fromfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_22userauth_publickey_fromfile};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_privatekey = 0;
   PyObject *__pyx_v_passphrase = 0;
   PyObject *__pyx_v_publickey = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_publickey_fromfile (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekey,&__pyx_n_s_passphrase,&__pyx_n_s_publickey,0};
-    PyObject* values[4] = {0,0,0,0};
-    values[2] = ((PyObject *)__pyx_kp_s__4);
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekey,&__pyx_n_s_passphrase,&__pyx_n_s_publickey,0};
+    values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__2));
 
-    /* "ssh2/session.pyx":203
+    /* "ssh2/session.pyx":202
  *                                     privatekey not None,
  *                                     passphrase='',
  *                                     publickey=None):             # <<<<<<<<<<<<<<
  *         """Authenticate with public key from file.
  * 
  */
-    values[3] = ((PyObject *)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 199, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_privatekey)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_privatekey)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 199, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_publickey_fromfile", 0, 2, 4, 1); __PYX_ERR(1, 200, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_publickey_fromfile", 0, 2, 4, 1); __PYX_ERR(1, 199, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase);
-          if (value) { values[2] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase);
+          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 199, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_publickey);
-          if (value) { values[3] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_publickey);
+          if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 199, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_publickey_fromfile") < 0)) __PYX_ERR(1, 200, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_publickey_fromfile") < 0)) __PYX_ERR(1, 199, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -3841,23 +7392,31 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(
     __pyx_v_passphrase = values[2];
     __pyx_v_publickey = values[3];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_publickey_fromfile", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 200, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_publickey_fromfile", 0, 2, 4, __pyx_nargs); __PYX_ERR(1, 199, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_publickey_fromfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 200, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 199, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_privatekey) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "privatekey"); __PYX_ERR(1, 201, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "privatekey"); __PYX_ERR(1, 200, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_privatekey, __pyx_v_passphrase, __pyx_v_publickey);
 
-  /* "ssh2/session.pyx":200
+  /* "ssh2/session.pyx":199
  *         return auth.split(',')
  * 
  *     def userauth_publickey_fromfile(self, username not None,             # <<<<<<<<<<<<<<
@@ -3870,6 +7429,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile(
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3891,25 +7456,24 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
   PyObject *__pyx_t_3 = NULL;
   char *__pyx_t_4;
   int __pyx_t_5;
-  int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_publickey_fromfile", 0);
+  __Pyx_RefNannySetupContext("userauth_publickey_fromfile", 1);
 
-  /* "ssh2/session.pyx":208
+  /* "ssh2/session.pyx":207
  *         :rtype: int"""
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":210
+  /* "ssh2/session.pyx":209
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None             # <<<<<<<<<<<<<<
@@ -3917,22 +7481,22 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  */
   __pyx_t_2 = (__pyx_v_publickey != Py_None);
-  if ((__pyx_t_2 != 0)) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":209
+    /* "ssh2/session.pyx":208
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \             # <<<<<<<<<<<<<<
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  */
-    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_publickey); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 209, __pyx_L1_error)
+    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_publickey); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 208, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_1 = __pyx_t_3;
     __pyx_t_3 = 0;
   } else {
 
-    /* "ssh2/session.pyx":210
+    /* "ssh2/session.pyx":209
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None             # <<<<<<<<<<<<<<
@@ -3942,34 +7506,43 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
     __Pyx_INCREF(Py_None);
     __pyx_t_1 = Py_None;
   }
+
+  /* "ssh2/session.pyx":208
+ *         cdef int rc
+ *         cdef bytes b_username = to_bytes(username)
+ *         cdef bytes b_publickey = to_bytes(publickey) \             # <<<<<<<<<<<<<<
+ *             if publickey is not None else None
+ *         cdef bytes b_privatekey = to_bytes(privatekey)
+ */
+  if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(1, 208, __pyx_L1_error)
   __pyx_v_b_publickey = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":211
+  /* "ssh2/session.pyx":210
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)             # <<<<<<<<<<<<<<
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_privatekey); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 211, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_privatekey); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_privatekey = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":212
+  /* "ssh2/session.pyx":211
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  *         cdef bytes b_passphrase = to_bytes(passphrase)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 212, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 211, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_passphrase = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":213
+  /* "ssh2/session.pyx":212
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -3978,12 +7551,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 213, __pyx_L1_error)
+    __PYX_ERR(1, 212, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 213, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 212, __pyx_L1_error)
   __pyx_v__username = __pyx_t_4;
 
-  /* "ssh2/session.pyx":214
+  /* "ssh2/session.pyx":213
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL             # <<<<<<<<<<<<<<
@@ -3992,7 +7565,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
   __pyx_v__publickey = NULL;
 
-  /* "ssh2/session.pyx":215
+  /* "ssh2/session.pyx":214
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL
  *         cdef char *_privatekey = b_privatekey             # <<<<<<<<<<<<<<
@@ -4001,12 +7574,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
   if (unlikely(__pyx_v_b_privatekey == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 215, __pyx_L1_error)
+    __PYX_ERR(1, 214, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_privatekey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 215, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_privatekey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 214, __pyx_L1_error)
   __pyx_v__privatekey = __pyx_t_4;
 
-  /* "ssh2/session.pyx":216
+  /* "ssh2/session.pyx":215
  *         cdef char *_publickey = NULL
  *         cdef char *_privatekey = b_privatekey
  *         cdef char *_passphrase = b_passphrase             # <<<<<<<<<<<<<<
@@ -4015,12 +7588,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
   if (unlikely(__pyx_v_b_passphrase == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 216, __pyx_L1_error)
+    __PYX_ERR(1, 215, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 216, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 215, __pyx_L1_error)
   __pyx_v__passphrase = __pyx_t_4;
 
-  /* "ssh2/session.pyx":217
+  /* "ssh2/session.pyx":216
  *         cdef char *_privatekey = b_privatekey
  *         cdef char *_passphrase = b_passphrase
  *         if b_publickey is not None:             # <<<<<<<<<<<<<<
@@ -4028,10 +7601,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  *         with nogil:
  */
   __pyx_t_2 = (__pyx_v_b_publickey != ((PyObject*)Py_None));
-  __pyx_t_5 = (__pyx_t_2 != 0);
-  if (__pyx_t_5) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":218
+    /* "ssh2/session.pyx":217
  *         cdef char *_passphrase = b_passphrase
  *         if b_publickey is not None:
  *             _publickey = b_publickey             # <<<<<<<<<<<<<<
@@ -4040,12 +7612,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
     if (unlikely(__pyx_v_b_publickey == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(1, 218, __pyx_L1_error)
+      __PYX_ERR(1, 217, __pyx_L1_error)
     }
-    __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_publickey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 218, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_publickey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 217, __pyx_L1_error)
     __pyx_v__publickey = __pyx_t_4;
 
-    /* "ssh2/session.pyx":217
+    /* "ssh2/session.pyx":216
  *         cdef char *_privatekey = b_privatekey
  *         cdef char *_passphrase = b_passphrase
  *         if b_publickey is not None:             # <<<<<<<<<<<<<<
@@ -4054,7 +7626,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
   }
 
-  /* "ssh2/session.pyx":219
+  /* "ssh2/session.pyx":218
  *         if b_publickey is not None:
  *             _publickey = b_publickey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4064,12 +7636,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":220
+        /* "ssh2/session.pyx":219
  *             _publickey = b_publickey
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_publickey_fromfile(             # <<<<<<<<<<<<<<
@@ -4079,7 +7652,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
         __pyx_v_rc = libssh2_userauth_publickey_fromfile(__pyx_v_self->_session, __pyx_v__username, __pyx_v__publickey, __pyx_v__privatekey, __pyx_v__passphrase);
       }
 
-      /* "ssh2/session.pyx":219
+      /* "ssh2/session.pyx":218
  *         if b_publickey is not None:
  *             _publickey = b_publickey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4098,7 +7671,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
       }
   }
 
-  /* "ssh2/session.pyx":222
+  /* "ssh2/session.pyx":221
  *             rc = c_ssh2.libssh2_userauth_publickey_fromfile(
  *                 self._session, _username, _publickey, _privatekey, _passphrase)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -4106,14 +7679,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  *     def userauth_publickey(self, username not None,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 222, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 222, __pyx_L1_error)
+  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 221, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":200
+  /* "ssh2/session.pyx":199
  *         return auth.split(',')
  * 
  *     def userauth_publickey_fromfile(self, username not None,             # <<<<<<<<<<<<<<
@@ -4137,7 +7710,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":224
+/* "ssh2/session.pyx":223
  *         return handle_error_codes(rc)
  * 
  *     def userauth_publickey(self, username not None,             # <<<<<<<<<<<<<<
@@ -4146,67 +7719,108 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_22userauth_publickey_fromfile(
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_25userauth_publickey(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_24userauth_publickey[] = "Session.userauth_publickey(self, username, bytes pubkeydata)\nPerform public key authentication with provided public key data\n\n        :param username: User name to authenticate as\n        :type username: str\n        :param pubkeydata: Public key data\n        :type pubkeydata: bytes\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_25userauth_publickey(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_25userauth_publickey(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_24userauth_publickey, "Session.userauth_publickey(self, username, bytes pubkeydata)\nPerform public key authentication with provided public key data\n\n        :param username: User name to authenticate as\n        :type username: str\n        :param pubkeydata: Public key data\n        :type pubkeydata: bytes\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_25userauth_publickey = {"userauth_publickey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_25userauth_publickey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_24userauth_publickey};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_25userauth_publickey(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_pubkeydata = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_publickey (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_pubkeydata,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_pubkeydata,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 223, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pubkeydata)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pubkeydata)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 223, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_publickey", 1, 2, 2, 1); __PYX_ERR(1, 224, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_publickey", 1, 2, 2, 1); __PYX_ERR(1, 223, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_publickey") < 0)) __PYX_ERR(1, 224, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_publickey") < 0)) __PYX_ERR(1, 223, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_username = values[0];
     __pyx_v_pubkeydata = ((PyObject*)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_publickey", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 224, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_publickey", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 223, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_publickey", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 224, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 223, __pyx_L1_error)
   }
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pubkeydata), (&PyBytes_Type), 0, "pubkeydata", 1))) __PYX_ERR(1, 225, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pubkeydata), (&PyBytes_Type), 0, "pubkeydata", 1))) __PYX_ERR(1, 224, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_24userauth_publickey(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_pubkeydata);
 
   /* function exit code */
@@ -4214,6 +7828,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_25userauth_publickey(PyObject
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4234,21 +7854,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_publickey", 0);
+  __Pyx_RefNannySetupContext("userauth_publickey", 1);
 
-  /* "ssh2/session.pyx":235
+  /* "ssh2/session.pyx":234
  *         :rtype: int"""
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef unsigned char *_pubkeydata = pubkeydata
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":236
+  /* "ssh2/session.pyx":235
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -4257,32 +7877,32 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 236, __pyx_L1_error)
+    __PYX_ERR(1, 235, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 236, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 235, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":237
+  /* "ssh2/session.pyx":236
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username
  *         cdef unsigned char *_pubkeydata = pubkeydata             # <<<<<<<<<<<<<<
  *         cdef size_t pubkeydata_len = len(pubkeydata)
  *         with nogil:
  */
-  __pyx_t_3 = __Pyx_PyBytes_AsWritableUString(__pyx_v_pubkeydata); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 237, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_AsWritableUString(__pyx_v_pubkeydata); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 236, __pyx_L1_error)
   __pyx_v__pubkeydata = __pyx_t_3;
 
-  /* "ssh2/session.pyx":238
+  /* "ssh2/session.pyx":237
  *         cdef char *_username = b_username
  *         cdef unsigned char *_pubkeydata = pubkeydata
  *         cdef size_t pubkeydata_len = len(pubkeydata)             # <<<<<<<<<<<<<<
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_publickey(
  */
-  __pyx_t_4 = PyBytes_GET_SIZE(__pyx_v_pubkeydata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 238, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_GET_SIZE(__pyx_v_pubkeydata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 237, __pyx_L1_error)
   __pyx_v_pubkeydata_len = __pyx_t_4;
 
-  /* "ssh2/session.pyx":239
+  /* "ssh2/session.pyx":238
  *         cdef unsigned char *_pubkeydata = pubkeydata
  *         cdef size_t pubkeydata_len = len(pubkeydata)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4292,12 +7912,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":240
+        /* "ssh2/session.pyx":239
  *         cdef size_t pubkeydata_len = len(pubkeydata)
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_publickey(             # <<<<<<<<<<<<<<
@@ -4307,7 +7928,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
         __pyx_v_rc = libssh2_userauth_publickey(__pyx_v_self->_session, __pyx_v__username, __pyx_v__pubkeydata, __pyx_v_pubkeydata_len, NULL, NULL);
       }
 
-      /* "ssh2/session.pyx":239
+      /* "ssh2/session.pyx":238
  *         cdef unsigned char *_pubkeydata = pubkeydata
  *         cdef size_t pubkeydata_len = len(pubkeydata)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4326,7 +7947,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
       }
   }
 
-  /* "ssh2/session.pyx":243
+  /* "ssh2/session.pyx":242
  *                 self._session, _username, _pubkeydata,
  *                 pubkeydata_len, NULL, NULL)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -4334,14 +7955,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
  *     def userauth_hostbased_fromfile(self,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 243, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L1_error)
+  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 242, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":224
+  /* "ssh2/session.pyx":223
  *         return handle_error_codes(rc)
  * 
  *     def userauth_publickey(self, username not None,             # <<<<<<<<<<<<<<
@@ -4361,7 +7982,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":245
+/* "ssh2/session.pyx":244
  *         return handle_error_codes(rc)
  * 
  *     def userauth_hostbased_fromfile(self,             # <<<<<<<<<<<<<<
@@ -4370,92 +7991,131 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_24userauth_publickey(struct __
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_26userauth_hostbased_fromfile[] = "Session.userauth_hostbased_fromfile(self, username, privatekey, hostname, publickey=None, passphrase='')";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_26userauth_hostbased_fromfile, "Session.userauth_hostbased_fromfile(self, username, privatekey, hostname, publickey=None, passphrase=u'')");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_27userauth_hostbased_fromfile = {"userauth_hostbased_fromfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_26userauth_hostbased_fromfile};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_privatekey = 0;
   PyObject *__pyx_v_hostname = 0;
   PyObject *__pyx_v_publickey = 0;
   PyObject *__pyx_v_passphrase = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_hostbased_fromfile (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekey,&__pyx_n_s_hostname,&__pyx_n_s_publickey,&__pyx_n_s_passphrase,0};
-    PyObject* values[5] = {0,0,0,0,0};
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekey,&__pyx_n_s_hostname,&__pyx_n_s_publickey,&__pyx_n_s_passphrase,0};
 
-    /* "ssh2/session.pyx":249
+    /* "ssh2/session.pyx":248
  *                                     privatekey not None,
  *                                     hostname not None,
  *                                     publickey=None,             # <<<<<<<<<<<<<<
  *                                     passphrase=''):
  *         cdef int rc
  */
-    values[3] = ((PyObject *)Py_None);
-    values[4] = ((PyObject *)__pyx_kp_s__4);
-    if (unlikely(__pyx_kwds)) {
+    values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None));
+    values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__2));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 244, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_privatekey)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_privatekey)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 244, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, 1); __PYX_ERR(1, 245, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, 1); __PYX_ERR(1, 244, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_hostname)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_hostname)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 244, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, 2); __PYX_ERR(1, 245, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, 2); __PYX_ERR(1, 244, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_publickey);
-          if (value) { values[3] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_publickey);
+          if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 244, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase);
-          if (value) { values[4] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase);
+          if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 244, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_hostbased_fromfile") < 0)) __PYX_ERR(1, 245, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_hostbased_fromfile") < 0)) __PYX_ERR(1, 244, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+        values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -4466,26 +8126,34 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(
     __pyx_v_publickey = values[3];
     __pyx_v_passphrase = values[4];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 245, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_hostbased_fromfile", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 244, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_hostbased_fromfile", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 246, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 245, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_privatekey) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "privatekey"); __PYX_ERR(1, 247, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "privatekey"); __PYX_ERR(1, 246, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_hostname) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "hostname"); __PYX_ERR(1, 248, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "hostname"); __PYX_ERR(1, 247, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_privatekey, __pyx_v_hostname, __pyx_v_publickey, __pyx_v_passphrase);
 
-  /* "ssh2/session.pyx":245
+  /* "ssh2/session.pyx":244
  *         return handle_error_codes(rc)
  * 
  *     def userauth_hostbased_fromfile(self,             # <<<<<<<<<<<<<<
@@ -4498,6 +8166,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile(
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4521,25 +8195,24 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
   PyObject *__pyx_t_3 = NULL;
   char *__pyx_t_4;
   int __pyx_t_5;
-  int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_hostbased_fromfile", 0);
+  __Pyx_RefNannySetupContext("userauth_hostbased_fromfile", 1);
 
-  /* "ssh2/session.pyx":252
+  /* "ssh2/session.pyx":251
  *                                     passphrase=''):
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 252, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 251, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":254
+  /* "ssh2/session.pyx":253
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None             # <<<<<<<<<<<<<<
@@ -4547,22 +8220,22 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  */
   __pyx_t_2 = (__pyx_v_publickey != Py_None);
-  if ((__pyx_t_2 != 0)) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":253
+    /* "ssh2/session.pyx":252
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \             # <<<<<<<<<<<<<<
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  */
-    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_publickey); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error)
+    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_publickey); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_1 = __pyx_t_3;
     __pyx_t_3 = 0;
   } else {
 
-    /* "ssh2/session.pyx":254
+    /* "ssh2/session.pyx":253
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None             # <<<<<<<<<<<<<<
@@ -4572,46 +8245,55 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
     __Pyx_INCREF(Py_None);
     __pyx_t_1 = Py_None;
   }
+
+  /* "ssh2/session.pyx":252
+ *         cdef int rc
+ *         cdef bytes b_username = to_bytes(username)
+ *         cdef bytes b_publickey = to_bytes(publickey) \             # <<<<<<<<<<<<<<
+ *             if publickey is not None else None
+ *         cdef bytes b_privatekey = to_bytes(privatekey)
+ */
+  if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(1, 252, __pyx_L1_error)
   __pyx_v_b_publickey = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":255
+  /* "ssh2/session.pyx":254
  *         cdef bytes b_publickey = to_bytes(publickey) \
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)             # <<<<<<<<<<<<<<
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef bytes b_hostname = to_bytes(hostname)
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_privatekey); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 255, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_privatekey); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 254, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_privatekey = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":256
+  /* "ssh2/session.pyx":255
  *             if publickey is not None else None
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  *         cdef bytes b_passphrase = to_bytes(passphrase)             # <<<<<<<<<<<<<<
  *         cdef bytes b_hostname = to_bytes(hostname)
  *         cdef char *_username = b_username
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 256, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 255, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_passphrase = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":257
+  /* "ssh2/session.pyx":256
  *         cdef bytes b_privatekey = to_bytes(privatekey)
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef bytes b_hostname = to_bytes(hostname)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_hostname); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 257, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_hostname); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 256, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_hostname = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":258
+  /* "ssh2/session.pyx":257
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef bytes b_hostname = to_bytes(hostname)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -4620,12 +8302,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 258, __pyx_L1_error)
+    __PYX_ERR(1, 257, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 258, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 257, __pyx_L1_error)
   __pyx_v__username = __pyx_t_4;
 
-  /* "ssh2/session.pyx":259
+  /* "ssh2/session.pyx":258
  *         cdef bytes b_hostname = to_bytes(hostname)
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL             # <<<<<<<<<<<<<<
@@ -4634,7 +8316,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   __pyx_v__publickey = NULL;
 
-  /* "ssh2/session.pyx":260
+  /* "ssh2/session.pyx":259
  *         cdef char *_username = b_username
  *         cdef char *_publickey = NULL
  *         cdef char *_privatekey = b_privatekey             # <<<<<<<<<<<<<<
@@ -4643,12 +8325,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   if (unlikely(__pyx_v_b_privatekey == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 260, __pyx_L1_error)
+    __PYX_ERR(1, 259, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_privatekey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 260, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_privatekey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 259, __pyx_L1_error)
   __pyx_v__privatekey = __pyx_t_4;
 
-  /* "ssh2/session.pyx":261
+  /* "ssh2/session.pyx":260
  *         cdef char *_publickey = NULL
  *         cdef char *_privatekey = b_privatekey
  *         cdef char *_passphrase = b_passphrase             # <<<<<<<<<<<<<<
@@ -4657,12 +8339,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   if (unlikely(__pyx_v_b_passphrase == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 261, __pyx_L1_error)
+    __PYX_ERR(1, 260, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 261, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 260, __pyx_L1_error)
   __pyx_v__passphrase = __pyx_t_4;
 
-  /* "ssh2/session.pyx":262
+  /* "ssh2/session.pyx":261
  *         cdef char *_privatekey = b_privatekey
  *         cdef char *_passphrase = b_passphrase
  *         cdef char *_hostname = b_hostname             # <<<<<<<<<<<<<<
@@ -4671,12 +8353,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   if (unlikely(__pyx_v_b_hostname == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 262, __pyx_L1_error)
+    __PYX_ERR(1, 261, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_hostname); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 262, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_hostname); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 261, __pyx_L1_error)
   __pyx_v__hostname = __pyx_t_4;
 
-  /* "ssh2/session.pyx":263
+  /* "ssh2/session.pyx":262
  *         cdef char *_passphrase = b_passphrase
  *         cdef char *_hostname = b_hostname
  *         if b_publickey is not None:             # <<<<<<<<<<<<<<
@@ -4684,10 +8366,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  *         with nogil:
  */
   __pyx_t_2 = (__pyx_v_b_publickey != ((PyObject*)Py_None));
-  __pyx_t_5 = (__pyx_t_2 != 0);
-  if (__pyx_t_5) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":264
+    /* "ssh2/session.pyx":263
  *         cdef char *_hostname = b_hostname
  *         if b_publickey is not None:
  *             _publickey = b_publickey             # <<<<<<<<<<<<<<
@@ -4696,12 +8377,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
     if (unlikely(__pyx_v_b_publickey == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(1, 264, __pyx_L1_error)
+      __PYX_ERR(1, 263, __pyx_L1_error)
     }
-    __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_publickey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 264, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_publickey); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 263, __pyx_L1_error)
     __pyx_v__publickey = __pyx_t_4;
 
-    /* "ssh2/session.pyx":263
+    /* "ssh2/session.pyx":262
  *         cdef char *_passphrase = b_passphrase
  *         cdef char *_hostname = b_hostname
  *         if b_publickey is not None:             # <<<<<<<<<<<<<<
@@ -4710,7 +8391,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
   }
 
-  /* "ssh2/session.pyx":265
+  /* "ssh2/session.pyx":264
  *         if b_publickey is not None:
  *             _publickey = b_publickey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4720,12 +8401,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":266
+        /* "ssh2/session.pyx":265
  *             _publickey = b_publickey
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_hostbased_fromfile(             # <<<<<<<<<<<<<<
@@ -4735,7 +8417,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
         __pyx_v_rc = libssh2_userauth_hostbased_fromfile(__pyx_v_self->_session, __pyx_v__username, __pyx_v__publickey, __pyx_v__privatekey, __pyx_v__passphrase, __pyx_v__hostname);
       }
 
-      /* "ssh2/session.pyx":265
+      /* "ssh2/session.pyx":264
  *         if b_publickey is not None:
  *             _publickey = b_publickey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -4754,7 +8436,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
       }
   }
 
-  /* "ssh2/session.pyx":269
+  /* "ssh2/session.pyx":268
  *                 self._session, _username, _publickey,
  *                 _privatekey, _passphrase, _hostname)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -4762,14 +8444,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  *     def userauth_publickey_frommemory(
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 269, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 269, __pyx_L1_error)
+  __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 268, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 268, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":245
+  /* "ssh2/session.pyx":244
  *         return handle_error_codes(rc)
  * 
  *     def userauth_hostbased_fromfile(self,             # <<<<<<<<<<<<<<
@@ -4794,7 +8476,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":271
+/* "ssh2/session.pyx":270
  *         return handle_error_codes(rc)
  * 
  *     def userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
@@ -4803,82 +8485,117 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_26userauth_hostbased_fromfile(
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_28userauth_publickey_frommemory[] = "Session.userauth_publickey_frommemory(self, username, bytes privatekeyfiledata, passphrase='', bytes publickeyfiledata=None)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_28userauth_publickey_frommemory, "Session.userauth_publickey_frommemory(self, username, bytes privatekeyfiledata, passphrase=u'', bytes publickeyfiledata=None)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_29userauth_publickey_frommemory = {"userauth_publickey_frommemory", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_28userauth_publickey_frommemory};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_privatekeyfiledata = 0;
   PyObject *__pyx_v_passphrase = 0;
   PyObject *__pyx_v_publickeyfiledata = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_publickey_frommemory (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekeyfiledata,&__pyx_n_s_passphrase,&__pyx_n_s_publickeyfiledata,0};
-    PyObject* values[4] = {0,0,0,0};
-    values[2] = ((PyObject *)__pyx_kp_s__4);
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_privatekeyfiledata,&__pyx_n_s_passphrase,&__pyx_n_s_publickeyfiledata,0};
+    values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__2));
 
-    /* "ssh2/session.pyx":273
+    /* "ssh2/session.pyx":272
  *     def userauth_publickey_frommemory(
  *             self, username, bytes privatekeyfiledata,
  *             passphrase='', bytes publickeyfiledata=None):             # <<<<<<<<<<<<<<
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  */
-    values[3] = ((PyObject*)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject*)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 270, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_privatekeyfiledata)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_privatekeyfiledata)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 270, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_publickey_frommemory", 0, 2, 4, 1); __PYX_ERR(1, 271, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_publickey_frommemory", 0, 2, 4, 1); __PYX_ERR(1, 270, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_passphrase);
-          if (value) { values[2] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_passphrase);
+          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 270, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_publickeyfiledata);
-          if (value) { values[3] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_publickeyfiledata);
+          if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 270, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_publickey_frommemory") < 0)) __PYX_ERR(1, 271, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_publickey_frommemory") < 0)) __PYX_ERR(1, 270, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -4888,19 +8605,27 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemor
     __pyx_v_passphrase = values[2];
     __pyx_v_publickeyfiledata = ((PyObject*)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_publickey_frommemory", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 271, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_publickey_frommemory", 0, 2, 4, __pyx_nargs); __PYX_ERR(1, 270, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_publickey_frommemory", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_privatekeyfiledata), (&PyBytes_Type), 1, "privatekeyfiledata", 1))) __PYX_ERR(1, 272, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_publickeyfiledata), (&PyBytes_Type), 1, "publickeyfiledata", 1))) __PYX_ERR(1, 273, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_privatekeyfiledata), (&PyBytes_Type), 1, "privatekeyfiledata", 1))) __PYX_ERR(1, 271, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_publickeyfiledata), (&PyBytes_Type), 1, "publickeyfiledata", 1))) __PYX_ERR(1, 272, __pyx_L1_error)
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemory(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_privatekeyfiledata, __pyx_v_passphrase, __pyx_v_publickeyfiledata);
 
-  /* "ssh2/session.pyx":271
+  /* "ssh2/session.pyx":270
  *         return handle_error_codes(rc)
  * 
  *     def userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
@@ -4913,6 +8638,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemor
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4936,37 +8667,36 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
   Py_ssize_t __pyx_t_4;
   int __pyx_t_5;
   int __pyx_t_6;
-  int __pyx_t_7;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_publickey_frommemory", 0);
+  __Pyx_RefNannySetupContext("userauth_publickey_frommemory", 1);
 
-  /* "ssh2/session.pyx":275
+  /* "ssh2/session.pyx":274
  *             passphrase='', bytes publickeyfiledata=None):
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 274, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":276
+  /* "ssh2/session.pyx":275
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_passphrase = to_bytes(passphrase)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef char *_passphrase = b_passphrase
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 276, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_passphrase); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_passphrase = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":277
+  /* "ssh2/session.pyx":276
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -4975,12 +8705,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 277, __pyx_L1_error)
+    __PYX_ERR(1, 276, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 277, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 276, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":278
+  /* "ssh2/session.pyx":277
  *         cdef bytes b_passphrase = to_bytes(passphrase)
  *         cdef char *_username = b_username
  *         cdef char *_passphrase = b_passphrase             # <<<<<<<<<<<<<<
@@ -4989,12 +8719,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   if (unlikely(__pyx_v_b_passphrase == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 278, __pyx_L1_error)
+    __PYX_ERR(1, 277, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 278, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_passphrase); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 277, __pyx_L1_error)
   __pyx_v__passphrase = __pyx_t_2;
 
-  /* "ssh2/session.pyx":279
+  /* "ssh2/session.pyx":278
  *         cdef char *_username = b_username
  *         cdef char *_passphrase = b_passphrase
  *         cdef char *_publickeyfiledata = NULL             # <<<<<<<<<<<<<<
@@ -5003,7 +8733,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   __pyx_v__publickeyfiledata = NULL;
 
-  /* "ssh2/session.pyx":280
+  /* "ssh2/session.pyx":279
  *         cdef char *_passphrase = b_passphrase
  *         cdef char *_publickeyfiledata = NULL
  *         cdef char *_privatekeyfiledata = privatekeyfiledata             # <<<<<<<<<<<<<<
@@ -5012,12 +8742,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   if (unlikely(__pyx_v_privatekeyfiledata == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 280, __pyx_L1_error)
+    __PYX_ERR(1, 279, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_privatekeyfiledata); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 280, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_privatekeyfiledata); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 279, __pyx_L1_error)
   __pyx_v__privatekeyfiledata = __pyx_t_2;
 
-  /* "ssh2/session.pyx":282
+  /* "ssh2/session.pyx":281
  *         cdef char *_privatekeyfiledata = privatekeyfiledata
  *         cdef size_t username_len, privatekeydata_len
  *         cdef size_t pubkeydata_len = 0             # <<<<<<<<<<<<<<
@@ -5026,7 +8756,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   __pyx_v_pubkeydata_len = 0;
 
-  /* "ssh2/session.pyx":284
+  /* "ssh2/session.pyx":283
  *         cdef size_t pubkeydata_len = 0
  *         username_len, privatekeydata_len = \
  *             len(b_username), len(privatekeyfiledata)             # <<<<<<<<<<<<<<
@@ -5035,18 +8765,18 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 284, __pyx_L1_error)
+    __PYX_ERR(1, 283, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_username); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 284, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_username); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 283, __pyx_L1_error)
   if (unlikely(__pyx_v_privatekeyfiledata == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(1, 284, __pyx_L1_error)
+    __PYX_ERR(1, 283, __pyx_L1_error)
   }
-  __pyx_t_4 = PyBytes_GET_SIZE(__pyx_v_privatekeyfiledata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 284, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBytes_GET_SIZE(__pyx_v_privatekeyfiledata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 283, __pyx_L1_error)
   __pyx_v_username_len = __pyx_t_3;
   __pyx_v_privatekeydata_len = __pyx_t_4;
 
-  /* "ssh2/session.pyx":285
+  /* "ssh2/session.pyx":284
  *         username_len, privatekeydata_len = \
  *             len(b_username), len(privatekeyfiledata)
  *         if publickeyfiledata is not None:             # <<<<<<<<<<<<<<
@@ -5054,10 +8784,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  *             pubkeydata_len = len(publickeyfiledata)
  */
   __pyx_t_5 = (__pyx_v_publickeyfiledata != ((PyObject*)Py_None));
-  __pyx_t_6 = (__pyx_t_5 != 0);
-  if (__pyx_t_6) {
+  if (__pyx_t_5) {
 
-    /* "ssh2/session.pyx":286
+    /* "ssh2/session.pyx":285
  *             len(b_username), len(privatekeyfiledata)
  *         if publickeyfiledata is not None:
  *             _publickeyfiledata = publickeyfiledata             # <<<<<<<<<<<<<<
@@ -5066,12 +8795,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
     if (unlikely(__pyx_v_publickeyfiledata == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(1, 286, __pyx_L1_error)
+      __PYX_ERR(1, 285, __pyx_L1_error)
     }
-    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_publickeyfiledata); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 286, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_publickeyfiledata); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 285, __pyx_L1_error)
     __pyx_v__publickeyfiledata = __pyx_t_2;
 
-    /* "ssh2/session.pyx":287
+    /* "ssh2/session.pyx":286
  *         if publickeyfiledata is not None:
  *             _publickeyfiledata = publickeyfiledata
  *             pubkeydata_len = len(publickeyfiledata)             # <<<<<<<<<<<<<<
@@ -5080,12 +8809,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
     if (unlikely(__pyx_v_publickeyfiledata == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-      __PYX_ERR(1, 287, __pyx_L1_error)
+      __PYX_ERR(1, 286, __pyx_L1_error)
     }
-    __pyx_t_4 = PyBytes_GET_SIZE(__pyx_v_publickeyfiledata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 287, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyBytes_GET_SIZE(__pyx_v_publickeyfiledata); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 286, __pyx_L1_error)
     __pyx_v_pubkeydata_len = __pyx_t_4;
 
-    /* "ssh2/session.pyx":285
+    /* "ssh2/session.pyx":284
  *         username_len, privatekeydata_len = \
  *             len(b_username), len(privatekeyfiledata)
  *         if publickeyfiledata is not None:             # <<<<<<<<<<<<<<
@@ -5094,7 +8823,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
   }
 
-  /* "ssh2/session.pyx":288
+  /* "ssh2/session.pyx":287
  *             _publickeyfiledata = publickeyfiledata
  *             pubkeydata_len = len(publickeyfiledata)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5104,12 +8833,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":289
+        /* "ssh2/session.pyx":288
  *             pubkeydata_len = len(publickeyfiledata)
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
@@ -5119,7 +8849,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
         __pyx_v_rc = libssh2_userauth_publickey_frommemory(__pyx_v_self->_session, __pyx_v__username, __pyx_v_username_len, __pyx_v__publickeyfiledata, __pyx_v_pubkeydata_len, __pyx_v__privatekeyfiledata, __pyx_v_privatekeydata_len, __pyx_v__passphrase);
       }
 
-      /* "ssh2/session.pyx":288
+      /* "ssh2/session.pyx":287
  *             _publickeyfiledata = publickeyfiledata
  *             pubkeydata_len = len(publickeyfiledata)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5138,7 +8868,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
       }
   }
 
-  /* "ssh2/session.pyx":293
+  /* "ssh2/session.pyx":292
  *                 pubkeydata_len, _privatekeyfiledata,
  *                 privatekeydata_len, _passphrase)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5146,14 +8876,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  *     def userauth_password(self, username not None, password not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_7 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 293, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error)
+  __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 292, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":271
+  /* "ssh2/session.pyx":270
  *         return handle_error_codes(rc)
  * 
  *     def userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
@@ -5174,7 +8904,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":295
+/* "ssh2/session.pyx":294
  *         return handle_error_codes(rc)
  * 
  *     def userauth_password(self, username not None, password not None):             # <<<<<<<<<<<<<<
@@ -5183,68 +8913,109 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_publickey_frommemor
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_31userauth_password(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_30userauth_password[] = "Session.userauth_password(self, username, password)\nPerform password authentication\n\n        :param username: User name to authenticate.\n        :type username: str\n        :param password: Password\n        :type password: str";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_31userauth_password(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_31userauth_password(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_30userauth_password, "Session.userauth_password(self, username, password)\nPerform password authentication\n\n        :param username: User name to authenticate.\n        :type username: str\n        :param password: Password\n        :type password: str");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_31userauth_password = {"userauth_password", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_31userauth_password, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_30userauth_password};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_31userauth_password(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_password = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_password (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_password,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_password,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 294, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_password)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_password)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 294, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_password", 1, 2, 2, 1); __PYX_ERR(1, 295, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_password", 1, 2, 2, 1); __PYX_ERR(1, 294, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_password") < 0)) __PYX_ERR(1, 295, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_password") < 0)) __PYX_ERR(1, 294, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_username = values[0];
     __pyx_v_password = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_password", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 295, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_password", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 294, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_password", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 295, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 294, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_password) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "password"); __PYX_ERR(1, 295, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "password"); __PYX_ERR(1, 294, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_30userauth_password(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_password);
 
@@ -5253,6 +9024,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_31userauth_password(PyObject *
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5272,33 +9049,33 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("userauth_password", 0);
+  __Pyx_RefNannySetupContext("userauth_password", 1);
 
-  /* "ssh2/session.pyx":303
+  /* "ssh2/session.pyx":302
  *         :type password: str"""
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef bytes b_password = to_bytes(password)
  *         cdef const char *_username = b_username
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 303, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 302, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":304
+  /* "ssh2/session.pyx":303
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_password = to_bytes(password)             # <<<<<<<<<<<<<<
  *         cdef const char *_username = b_username
  *         cdef const char *_password = b_password
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_password); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 304, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_password); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_password = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":305
+  /* "ssh2/session.pyx":304
  *         cdef bytes b_username = to_bytes(username)
  *         cdef bytes b_password = to_bytes(password)
  *         cdef const char *_username = b_username             # <<<<<<<<<<<<<<
@@ -5307,12 +9084,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 305, __pyx_L1_error)
+    __PYX_ERR(1, 304, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 305, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":306
+  /* "ssh2/session.pyx":305
  *         cdef bytes b_password = to_bytes(password)
  *         cdef const char *_username = b_username
  *         cdef const char *_password = b_password             # <<<<<<<<<<<<<<
@@ -5321,12 +9098,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
  */
   if (unlikely(__pyx_v_b_password == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 306, __pyx_L1_error)
+    __PYX_ERR(1, 305, __pyx_L1_error)
   }
-  __pyx_t_3 = __Pyx_PyBytes_AsString(__pyx_v_b_password); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 306, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_AsString(__pyx_v_b_password); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 305, __pyx_L1_error)
   __pyx_v__password = __pyx_t_3;
 
-  /* "ssh2/session.pyx":307
+  /* "ssh2/session.pyx":306
  *         cdef const char *_username = b_username
  *         cdef const char *_password = b_password
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5336,12 +9113,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":308
+        /* "ssh2/session.pyx":307
  *         cdef const char *_password = b_password
  *         with nogil:
  *             rc = c_ssh2.libssh2_userauth_password(             # <<<<<<<<<<<<<<
@@ -5351,7 +9129,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
         __pyx_v_rc = libssh2_userauth_password(__pyx_v_self->_session, __pyx_v__username, __pyx_v__password);
       }
 
-      /* "ssh2/session.pyx":307
+      /* "ssh2/session.pyx":306
  *         cdef const char *_username = b_username
  *         cdef const char *_password = b_password
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5370,7 +9148,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
       }
   }
 
-  /* "ssh2/session.pyx":310
+  /* "ssh2/session.pyx":309
  *             rc = c_ssh2.libssh2_userauth_password(
  *                 self._session, _username, _password)
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5378,14 +9156,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
  *     def userauth_keyboardinteractive(self, username not None,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 310, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 310, __pyx_L1_error)
+  __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 309, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 309, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":295
+  /* "ssh2/session.pyx":294
  *         return handle_error_codes(rc)
  * 
  *     def userauth_password(self, username not None, password not None):             # <<<<<<<<<<<<<<
@@ -5406,7 +9184,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":312
+/* "ssh2/session.pyx":311
  *         return handle_error_codes(rc)
  * 
  *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
@@ -5415,68 +9193,109 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_30userauth_password(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_32userauth_keyboardinteractive[] = "Session.userauth_keyboardinteractive(self, username, password)\nPerform keyboard-interactive authentication\n\n        :param username: User name to authenticate.\n        :type username: str\n        :param password: Password\n        :type password: str\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_32userauth_keyboardinteractive, "Session.userauth_keyboardinteractive(self, username, password)\nPerform keyboard-interactive authentication\n\n        :param username: User name to authenticate.\n        :type username: str\n        :param password: Password\n        :type password: str\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_33userauth_keyboardinteractive = {"userauth_keyboardinteractive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_32userauth_keyboardinteractive};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_username = 0;
   PyObject *__pyx_v_password = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("userauth_keyboardinteractive (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_password,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,&__pyx_n_s_password,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_username)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 311, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_password)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_password)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 311, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("userauth_keyboardinteractive", 1, 2, 2, 1); __PYX_ERR(1, 312, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("userauth_keyboardinteractive", 1, 2, 2, 1); __PYX_ERR(1, 311, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "userauth_keyboardinteractive") < 0)) __PYX_ERR(1, 312, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "userauth_keyboardinteractive") < 0)) __PYX_ERR(1, 311, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_username = values[0];
     __pyx_v_password = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("userauth_keyboardinteractive", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 312, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("userauth_keyboardinteractive", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 311, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.userauth_keyboardinteractive", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 312, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 311, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_password) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "password"); __PYX_ERR(1, 313, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "password"); __PYX_ERR(1, 312, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username, __pyx_v_password);
 
@@ -5485,11 +9304,17 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":325
+/* "ssh2/session.pyx":324
  *         cdef const char *_username = b_username
  * 
  *         def passwd():             # <<<<<<<<<<<<<<
@@ -5501,9 +9326,11 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive
 static PyObject *__pyx_pw_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
 static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd = {"passwd", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd, METH_NOARGS, 0};
 static PyObject *__pyx_pw_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("passwd (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_28userauth_keyboardinteractive_passwd(__pyx_self);
 
   /* function exit code */
@@ -5519,11 +9346,11 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_keyboardinteractive
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("passwd", 0);
+  __Pyx_RefNannySetupContext("passwd", 1);
   __pyx_outer_scope = (struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *) __Pyx_CyFunction_GetClosure(__pyx_self);
   __pyx_cur_scope = __pyx_outer_scope;
 
-  /* "ssh2/session.pyx":326
+  /* "ssh2/session.pyx":325
  * 
  *         def passwd():
  *             return password             # <<<<<<<<<<<<<<
@@ -5531,12 +9358,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_keyboardinteractive
  *         self._kbd_callback = passwd
  */
   __Pyx_XDECREF(__pyx_r);
-  if (unlikely(!__pyx_cur_scope->__pyx_v_password)) { __Pyx_RaiseClosureNameError("password"); __PYX_ERR(1, 326, __pyx_L1_error) }
+  if (unlikely(!__pyx_cur_scope->__pyx_v_password)) { __Pyx_RaiseClosureNameError("password"); __PYX_ERR(1, 325, __pyx_L1_error) }
   __Pyx_INCREF(__pyx_cur_scope->__pyx_v_password);
   __pyx_r = __pyx_cur_scope->__pyx_v_password;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":325
+  /* "ssh2/session.pyx":324
  *         cdef const char *_username = b_username
  * 
  *         def passwd():             # <<<<<<<<<<<<<<
@@ -5554,7 +9381,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_28userauth_keyboardinteractive
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":312
+/* "ssh2/session.pyx":311
  *         return handle_error_codes(rc)
  * 
  *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
@@ -5581,27 +9408,27 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
   if (unlikely(!__pyx_cur_scope)) {
     __pyx_cur_scope = ((struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *)Py_None);
     __Pyx_INCREF(Py_None);
-    __PYX_ERR(1, 312, __pyx_L1_error)
+    __PYX_ERR(1, 311, __pyx_L1_error)
   } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
   }
   __pyx_cur_scope->__pyx_v_password = __pyx_v_password;
   __Pyx_INCREF(__pyx_cur_scope->__pyx_v_password);
   __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_password);
 
-  /* "ssh2/session.pyx":322
+  /* "ssh2/session.pyx":321
  *         """
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef const char *_username = b_username
  * 
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 322, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 321, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":323
+  /* "ssh2/session.pyx":322
  *         cdef int rc
  *         cdef bytes b_username = to_bytes(username)
  *         cdef const char *_username = b_username             # <<<<<<<<<<<<<<
@@ -5610,24 +9437,24 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 323, __pyx_L1_error)
+    __PYX_ERR(1, 322, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 323, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 322, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":325
+  /* "ssh2/session.pyx":324
  *         cdef const char *_username = b_username
  * 
  *         def passwd():             # <<<<<<<<<<<<<<
  *             return password
  * 
  */
-  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd, 0, __pyx_n_s_userauth_keyboardinteractive_loc, ((PyObject*)__pyx_cur_scope), __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 325, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_28userauth_keyboardinteractive_1passwd, 0, __pyx_n_s_userauth_keyboardinteractive_loc, ((PyObject*)__pyx_cur_scope), __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 324, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_passwd = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":328
+  /* "ssh2/session.pyx":327
  *             return password
  * 
  *         self._kbd_callback = passwd             # <<<<<<<<<<<<<<
@@ -5640,7 +9467,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
   __Pyx_DECREF(__pyx_v_self->_kbd_callback);
   __pyx_v_self->_kbd_callback = __pyx_v_passwd;
 
-  /* "ssh2/session.pyx":329
+  /* "ssh2/session.pyx":328
  * 
  *         self._kbd_callback = passwd
  *         rc = c_ssh2.libssh2_userauth_keyboard_interactive(             # <<<<<<<<<<<<<<
@@ -5649,7 +9476,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
  */
   __pyx_v_rc = libssh2_userauth_keyboard_interactive(__pyx_v_self->_session, __pyx_v__username, (&__pyx_f_4ssh2_7session_kbd_callback));
 
-  /* "ssh2/session.pyx":331
+  /* "ssh2/session.pyx":330
  *         rc = c_ssh2.libssh2_userauth_keyboard_interactive(
  *             self._session, _username, &kbd_callback)
  *         self._kbd_callback = None             # <<<<<<<<<<<<<<
@@ -5662,7 +9489,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
   __Pyx_DECREF(__pyx_v_self->_kbd_callback);
   __pyx_v_self->_kbd_callback = Py_None;
 
-  /* "ssh2/session.pyx":332
+  /* "ssh2/session.pyx":331
  *             self._session, _username, &kbd_callback)
  *         self._kbd_callback = None
  *         return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -5670,14 +9497,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
  *     def agent_init(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 332, __pyx_L1_error)
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 332, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 331, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 331, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":312
+  /* "ssh2/session.pyx":311
  *         return handle_error_codes(rc)
  * 
  *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
@@ -5693,13 +9520,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_b_username);
   __Pyx_XDECREF(__pyx_v_passwd);
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":334
+/* "ssh2/session.pyx":333
  *         return handle_error_codes(rc)
  * 
  *     def agent_init(self):             # <<<<<<<<<<<<<<
@@ -5708,12 +9535,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_32userauth_keyboardinteractive
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_35agent_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_34agent_init[] = "Session.agent_init(self)\nInitialise SSH agent.\n\n        :rtype: :py:class:`ssh2.agent.Agent`\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_35agent_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_35agent_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_34agent_init, "Session.agent_init(self)\nInitialise SSH agent.\n\n        :rtype: :py:class:`ssh2.agent.Agent`\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_35agent_init = {"agent_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_35agent_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_34agent_init};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_35agent_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("agent_init (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("agent_init", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "agent_init", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_34agent_init(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -5730,9 +9585,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("agent_init", 0);
+  __Pyx_RefNannySetupContext("agent_init", 1);
 
-  /* "ssh2/session.pyx":340
+  /* "ssh2/session.pyx":339
  *         """
  *         cdef c_ssh2.LIBSSH2_AGENT *agent
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5742,23 +9597,24 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":341
+        /* "ssh2/session.pyx":340
  *         cdef c_ssh2.LIBSSH2_AGENT *agent
  *         with nogil:
  *             agent = agent_init(self._session)             # <<<<<<<<<<<<<<
  *         return PyAgent(agent, self)
  * 
  */
-        __pyx_t_1 = __pyx_f_4ssh2_5agent_agent_init(__pyx_v_self->_session); if (unlikely(__pyx_t_1 == ((LIBSSH2_AGENT *)NULL))) __PYX_ERR(1, 341, __pyx_L4_error)
+        __pyx_t_1 = __pyx_f_4ssh2_5agent_agent_init(__pyx_v_self->_session); if (unlikely(__pyx_t_1 == ((LIBSSH2_AGENT *)NULL))) __PYX_ERR(1, 340, __pyx_L4_error)
         __pyx_v_agent = __pyx_t_1;
       }
 
-      /* "ssh2/session.pyx":340
+      /* "ssh2/session.pyx":339
  *         """
  *         cdef c_ssh2.LIBSSH2_AGENT *agent
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5784,7 +9640,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/session.pyx":342
+  /* "ssh2/session.pyx":341
  *         with nogil:
  *             agent = agent_init(self._session)
  *         return PyAgent(agent, self)             # <<<<<<<<<<<<<<
@@ -5792,13 +9648,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
  *     def agent_auth(self, username not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __pyx_f_4ssh2_5agent_PyAgent(__pyx_v_agent, __pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 342, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_4ssh2_5agent_PyAgent(__pyx_v_agent, __pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":334
+  /* "ssh2/session.pyx":333
  *         return handle_error_codes(rc)
  * 
  *     def agent_init(self):             # <<<<<<<<<<<<<<
@@ -5817,7 +9673,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":344
+/* "ssh2/session.pyx":343
  *         return PyAgent(agent, self)
  * 
  *     def agent_auth(self, username not None):             # <<<<<<<<<<<<<<
@@ -5826,25 +9682,105 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_34agent_init(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_37agent_auth(PyObject *__pyx_v_self, PyObject *__pyx_v_username); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_36agent_auth[] = "Session.agent_auth(self, username)\nConvenience function for performing user authentication via SSH Agent.\n\n        Initialises, connects to, gets list of identities from and attempts\n        authentication with each identity from SSH agent.\n\n        Note that agent connections cannot be used in non-blocking mode -\n        clients should call `set_blocking(0)` *after* calling this function.\n\n        On completion, or any errors, agent is disconnected and resources freed.\n\n        All steps are performed in C space which makes this function perform\n        better than calling the individual Agent class functions from\n        Python.\n\n        :raises: :py:class:`MemoryError` on error initialising agent\n        :raises: :py:class:`ssh2.exceptions.AgentConnectionError` on error\n          connecting to agent\n        :raises: :py:class:`ssh2.exceptions.AgentListIdentitiesError` on error\n          getting identities from agent\n        :raises: :py:class:`ssh2.exceptions.AgentAuthenticationError` on no\n          successful authentication with all available identities.\n        :raises: :py:class:`ssh2.exceptions.AgentGetIdentityError` on error\n          getting known identity from agent\n\n        :rtype: None";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_37agent_auth(PyObject *__pyx_v_self, PyObject *__pyx_v_username) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_37agent_auth(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_36agent_auth, "Session.agent_auth(self, username)\nConvenience function for performing user authentication via SSH Agent.\n\n        Initialises, connects to, gets list of identities from and attempts\n        authentication with each identity from SSH agent.\n\n        Note that agent connections cannot be used in non-blocking mode -\n        clients should call `set_blocking(0)` *after* calling this function.\n\n        On completion, or any errors, agent is disconnected and resources freed.\n\n        All steps are performed in C space which makes this function perform\n        better than calling the individual Agent class functions from\n        Python.\n\n        :raises: :py:class:`MemoryError` on error initialising agent\n        :raises: :py:class:`ssh2.exceptions.AgentConnectionError` on error\n          connecting to agent\n        :raises: :py:class:`ssh2.exceptions.AgentListIdentitiesError` on error\n          getting identities from agent\n        :raises: :py:class:`ssh2.exceptions.AgentAuthenticationError` on no\n          successful authentication with all available identities.\n        :raises: :py:class:`ssh2.exceptions.AgentGetIdentityError` on error\n          getting known identity from agent\n\n        :rtype: None");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_37agent_auth = {"agent_auth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_37agent_auth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_36agent_auth};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_37agent_auth(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_username = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("agent_auth (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_username,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_username)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 343, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "agent_auth") < 0)) __PYX_ERR(1, 343, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_username = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("agent_auth", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 343, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.agent_auth", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_username) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 344, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "username"); __PYX_ERR(1, 343, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_36agent_auth(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_username));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_36agent_auth(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_username);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5864,21 +9800,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("agent_auth", 0);
+  __Pyx_RefNannySetupContext("agent_auth", 1);
 
-  /* "ssh2/session.pyx":370
+  /* "ssh2/session.pyx":369
  * 
  *         :rtype: None"""
  *         cdef bytes b_username = to_bytes(username)             # <<<<<<<<<<<<<<
  *         cdef char *_username = b_username
  *         cdef c_ssh2.LIBSSH2_AGENT *agent = NULL
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 370, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_username); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 369, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_username = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":371
+  /* "ssh2/session.pyx":370
  *         :rtype: None"""
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username             # <<<<<<<<<<<<<<
@@ -5887,12 +9823,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
  */
   if (unlikely(__pyx_v_b_username == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 371, __pyx_L1_error)
+    __PYX_ERR(1, 370, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 371, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_username); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 370, __pyx_L1_error)
   __pyx_v__username = __pyx_t_2;
 
-  /* "ssh2/session.pyx":372
+  /* "ssh2/session.pyx":371
  *         cdef bytes b_username = to_bytes(username)
  *         cdef char *_username = b_username
  *         cdef c_ssh2.LIBSSH2_AGENT *agent = NULL             # <<<<<<<<<<<<<<
@@ -5901,7 +9837,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
  */
   __pyx_v_agent = NULL;
 
-  /* "ssh2/session.pyx":373
+  /* "ssh2/session.pyx":372
  *         cdef char *_username = b_username
  *         cdef c_ssh2.LIBSSH2_AGENT *agent = NULL
  *         cdef c_ssh2.libssh2_agent_publickey *identity = NULL             # <<<<<<<<<<<<<<
@@ -5910,7 +9846,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
  */
   __pyx_v_identity = NULL;
 
-  /* "ssh2/session.pyx":374
+  /* "ssh2/session.pyx":373
  *         cdef c_ssh2.LIBSSH2_AGENT *agent = NULL
  *         cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  *         cdef c_ssh2.libssh2_agent_publickey *prev = NULL             # <<<<<<<<<<<<<<
@@ -5919,17 +9855,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
  */
   __pyx_v_prev = NULL;
 
-  /* "ssh2/session.pyx":375
+  /* "ssh2/session.pyx":374
  *         cdef c_ssh2.libssh2_agent_publickey *identity = NULL
  *         cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *         agent = init_connect_agent(self._session)             # <<<<<<<<<<<<<<
  *         with nogil:
  *             agent_auth(_username, agent)
  */
-  __pyx_t_3 = __pyx_f_4ssh2_5agent_init_connect_agent(__pyx_v_self->_session); if (unlikely(__pyx_t_3 == ((LIBSSH2_AGENT *)NULL))) __PYX_ERR(1, 375, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5agent_init_connect_agent(__pyx_v_self->_session); if (unlikely(__pyx_t_3 == ((LIBSSH2_AGENT *)NULL))) __PYX_ERR(1, 374, __pyx_L1_error)
   __pyx_v_agent = __pyx_t_3;
 
-  /* "ssh2/session.pyx":376
+  /* "ssh2/session.pyx":375
  *         cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *         agent = init_connect_agent(self._session)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5939,22 +9875,23 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":377
+        /* "ssh2/session.pyx":376
  *         agent = init_connect_agent(self._session)
  *         with nogil:
  *             agent_auth(_username, agent)             # <<<<<<<<<<<<<<
  * 
  *     def open_session(self):
  */
-        __pyx_t_4 = __pyx_f_4ssh2_5agent_agent_auth(__pyx_v__username, __pyx_v_agent); if (unlikely(__pyx_t_4 == ((int)1))) __PYX_ERR(1, 377, __pyx_L4_error)
+        __pyx_t_4 = __pyx_f_4ssh2_5agent_agent_auth(__pyx_v__username, __pyx_v_agent); if (unlikely(__pyx_t_4 == ((int)1))) __PYX_ERR(1, 376, __pyx_L4_error)
       }
 
-      /* "ssh2/session.pyx":376
+      /* "ssh2/session.pyx":375
  *         cdef c_ssh2.libssh2_agent_publickey *prev = NULL
  *         agent = init_connect_agent(self._session)
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -5980,7 +9917,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/session.pyx":344
+  /* "ssh2/session.pyx":343
  *         return PyAgent(agent, self)
  * 
  *     def agent_auth(self, username not None):             # <<<<<<<<<<<<<<
@@ -6002,7 +9939,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":379
+/* "ssh2/session.pyx":378
  *             agent_auth(_username, agent)
  * 
  *     def open_session(self):             # <<<<<<<<<<<<<<
@@ -6011,12 +9948,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_36agent_auth(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_39open_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_38open_session[] = "Session.open_session(self)\nOpen new channel session.\n\n        :rtype: :py:class:`ssh2.channel.Channel`\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_39open_session(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_39open_session(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_38open_session, "Session.open_session(self)\nOpen new channel session.\n\n        :rtype: :py:class:`ssh2.channel.Channel`\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_39open_session = {"open_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_39open_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_38open_session};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_39open_session(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("open_session (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("open_session", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "open_session", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_38open_session(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -6034,9 +9999,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("open_session", 0);
+  __Pyx_RefNannySetupContext("open_session", 1);
 
-  /* "ssh2/session.pyx":385
+  /* "ssh2/session.pyx":384
  *         """
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6046,12 +10011,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":386
+        /* "ssh2/session.pyx":385
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  *             channel = c_ssh2.libssh2_channel_open_session(             # <<<<<<<<<<<<<<
@@ -6061,7 +10027,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
         __pyx_v_channel = libssh2_channel_open_session(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":385
+      /* "ssh2/session.pyx":384
  *         """
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6080,17 +10046,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
       }
   }
 
-  /* "ssh2/session.pyx":388
+  /* "ssh2/session.pyx":387
  *             channel = c_ssh2.libssh2_channel_open_session(
  *                 self._session)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_1 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_channel == NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":389
+    /* "ssh2/session.pyx":388
  *                 self._session)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -6099,29 +10065,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":390
+    /* "ssh2/session.pyx":389
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self)
  * 
  */
-    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 389, __pyx_L1_error)
+    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 388, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":389
+    /* "ssh2/session.pyx":388
  *                 self._session)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self)
  */
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 389, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 388, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":388
+    /* "ssh2/session.pyx":387
  *             channel = c_ssh2.libssh2_channel_open_session(
  *                 self._session)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -6130,7 +10096,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
  */
   }
 
-  /* "ssh2/session.pyx":391
+  /* "ssh2/session.pyx":390
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self)             # <<<<<<<<<<<<<<
@@ -6138,13 +10104,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
  *     def direct_tcpip_ex(self, host not None, int port,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 391, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 390, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":379
+  /* "ssh2/session.pyx":378
  *             agent_auth(_username, agent)
  * 
  *     def open_session(self):             # <<<<<<<<<<<<<<
@@ -6163,7 +10129,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":393
+/* "ssh2/session.pyx":392
  *         return PyChannel(channel, self)
  * 
  *     def direct_tcpip_ex(self, host not None, int port,             # <<<<<<<<<<<<<<
@@ -6172,90 +10138,139 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_38open_session(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_40direct_tcpip_ex[] = "Session.direct_tcpip_ex(self, host, int port, shost, int sport)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_40direct_tcpip_ex, "Session.direct_tcpip_ex(self, host, int port, shost, int sport)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_41direct_tcpip_ex = {"direct_tcpip_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_40direct_tcpip_ex};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_host = 0;
   int __pyx_v_port;
   PyObject *__pyx_v_shost = 0;
   int __pyx_v_sport;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("direct_tcpip_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_shost,&__pyx_n_s_sport,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_shost,&__pyx_n_s_sport,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 392, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 392, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 1); __PYX_ERR(1, 393, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 1); __PYX_ERR(1, 392, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shost)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shost)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 392, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 2); __PYX_ERR(1, 393, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 2); __PYX_ERR(1, 392, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sport)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sport)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 392, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 3); __PYX_ERR(1, 393, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, 3); __PYX_ERR(1, 392, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "direct_tcpip_ex") < 0)) __PYX_ERR(1, 393, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "direct_tcpip_ex") < 0)) __PYX_ERR(1, 392, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
     }
     __pyx_v_host = values[0];
-    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 393, __pyx_L3_error)
+    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 392, __pyx_L3_error)
     __pyx_v_shost = values[2];
-    __pyx_v_sport = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_sport == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 394, __pyx_L3_error)
+    __pyx_v_sport = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_sport == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 393, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 393, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("direct_tcpip_ex", 1, 4, 4, __pyx_nargs); __PYX_ERR(1, 392, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.direct_tcpip_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_host) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "host"); __PYX_ERR(1, 393, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "host"); __PYX_ERR(1, 392, __pyx_L1_error)
   }
   if (unlikely(((PyObject *)__pyx_v_shost) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "shost"); __PYX_ERR(1, 394, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "shost"); __PYX_ERR(1, 393, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_host, __pyx_v_port, __pyx_v_shost, __pyx_v_sport);
 
@@ -6264,6 +10279,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex(PyObject *__
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6283,33 +10304,33 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("direct_tcpip_ex", 0);
+  __Pyx_RefNannySetupContext("direct_tcpip_ex", 1);
 
-  /* "ssh2/session.pyx":396
+  /* "ssh2/session.pyx":395
  *                         shost not None, int sport):
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         cdef bytes b_host = to_bytes(host)             # <<<<<<<<<<<<<<
  *         cdef bytes b_shost = to_bytes(shost)
  *         cdef char *_host = b_host
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 395, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_host = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":397
+  /* "ssh2/session.pyx":396
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         cdef bytes b_host = to_bytes(host)
  *         cdef bytes b_shost = to_bytes(shost)             # <<<<<<<<<<<<<<
  *         cdef char *_host = b_host
  *         cdef char *_shost = b_shost
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_shost); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 397, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_shost); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_shost = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":398
+  /* "ssh2/session.pyx":397
  *         cdef bytes b_host = to_bytes(host)
  *         cdef bytes b_shost = to_bytes(shost)
  *         cdef char *_host = b_host             # <<<<<<<<<<<<<<
@@ -6318,12 +10339,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  */
   if (unlikely(__pyx_v_b_host == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 398, __pyx_L1_error)
+    __PYX_ERR(1, 397, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 398, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 397, __pyx_L1_error)
   __pyx_v__host = __pyx_t_2;
 
-  /* "ssh2/session.pyx":399
+  /* "ssh2/session.pyx":398
  *         cdef bytes b_shost = to_bytes(shost)
  *         cdef char *_host = b_host
  *         cdef char *_shost = b_shost             # <<<<<<<<<<<<<<
@@ -6332,12 +10353,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  */
   if (unlikely(__pyx_v_b_shost == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 399, __pyx_L1_error)
+    __PYX_ERR(1, 398, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_shost); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 399, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_shost); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 398, __pyx_L1_error)
   __pyx_v__shost = __pyx_t_2;
 
-  /* "ssh2/session.pyx":400
+  /* "ssh2/session.pyx":399
  *         cdef char *_host = b_host
  *         cdef char *_shost = b_shost
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6347,12 +10368,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":401
+        /* "ssh2/session.pyx":400
  *         cdef char *_shost = b_shost
  *         with nogil:
  *             channel = c_ssh2.libssh2_channel_direct_tcpip_ex(             # <<<<<<<<<<<<<<
@@ -6362,7 +10384,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
         __pyx_v_channel = libssh2_channel_direct_tcpip_ex(__pyx_v_self->_session, __pyx_v__host, __pyx_v_port, __pyx_v__shost, __pyx_v_sport);
       }
 
-      /* "ssh2/session.pyx":400
+      /* "ssh2/session.pyx":399
  *         cdef char *_host = b_host
  *         cdef char *_shost = b_shost
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6381,17 +10403,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
       }
   }
 
-  /* "ssh2/session.pyx":403
+  /* "ssh2/session.pyx":402
  *             channel = c_ssh2.libssh2_channel_direct_tcpip_ex(
  *                 self._session, _host, port, _shost, sport)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":404
+    /* "ssh2/session.pyx":403
  *                 self._session, _host, port, _shost, sport)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -6400,29 +10422,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":405
+    /* "ssh2/session.pyx":404
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self)
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 404, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 403, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":404
+    /* "ssh2/session.pyx":403
  *                 self._session, _host, port, _shost, sport)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self)
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 404, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 403, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":403
+    /* "ssh2/session.pyx":402
  *             channel = c_ssh2.libssh2_channel_direct_tcpip_ex(
  *                 self._session, _host, port, _shost, sport)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -6431,7 +10453,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  */
   }
 
-  /* "ssh2/session.pyx":406
+  /* "ssh2/session.pyx":405
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self)             # <<<<<<<<<<<<<<
@@ -6439,13 +10461,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  *     def direct_tcpip(self, host not None, int port):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 406, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 405, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":393
+  /* "ssh2/session.pyx":392
  *         return PyChannel(channel, self)
  * 
  *     def direct_tcpip_ex(self, host not None, int port,             # <<<<<<<<<<<<<<
@@ -6466,7 +10488,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":408
+/* "ssh2/session.pyx":407
  *         return PyChannel(channel, self)
  * 
  *     def direct_tcpip(self, host not None, int port):             # <<<<<<<<<<<<<<
@@ -6475,65 +10497,106 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_40direct_tcpip_ex(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_43direct_tcpip(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_42direct_tcpip[] = "Session.direct_tcpip(self, host, int port)\nOpen direct TCP/IP channel to host:port\n\n        Channel will be listening on an available open port on client side\n        as assigned by OS.\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_43direct_tcpip(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_43direct_tcpip(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_42direct_tcpip, "Session.direct_tcpip(self, host, int port)\nOpen direct TCP/IP channel to host:port\n\n        Channel will be listening on an available open port on client side\n        as assigned by OS.\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_43direct_tcpip = {"direct_tcpip", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_43direct_tcpip, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_42direct_tcpip};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_43direct_tcpip(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_host = 0;
   int __pyx_v_port;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("direct_tcpip (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 407, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 407, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("direct_tcpip", 1, 2, 2, 1); __PYX_ERR(1, 408, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("direct_tcpip", 1, 2, 2, 1); __PYX_ERR(1, 407, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "direct_tcpip") < 0)) __PYX_ERR(1, 408, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "direct_tcpip") < 0)) __PYX_ERR(1, 407, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_host = values[0];
-    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 408, __pyx_L3_error)
+    __pyx_v_port = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 407, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("direct_tcpip", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 408, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("direct_tcpip", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 407, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.direct_tcpip", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_host) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "host"); __PYX_ERR(1, 408, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "host"); __PYX_ERR(1, 407, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_42direct_tcpip(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_host, __pyx_v_port);
 
@@ -6542,6 +10605,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_43direct_tcpip(PyObject *__pyx
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6559,21 +10628,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("direct_tcpip", 0);
+  __Pyx_RefNannySetupContext("direct_tcpip", 1);
 
-  /* "ssh2/session.pyx":415
+  /* "ssh2/session.pyx":414
  *         """
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         cdef bytes b_host = to_bytes(host)             # <<<<<<<<<<<<<<
  *         cdef char *_host = b_host
  *         with nogil:
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 415, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 414, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_host = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":416
+  /* "ssh2/session.pyx":415
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         cdef bytes b_host = to_bytes(host)
  *         cdef char *_host = b_host             # <<<<<<<<<<<<<<
@@ -6582,12 +10651,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
  */
   if (unlikely(__pyx_v_b_host == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 416, __pyx_L1_error)
+    __PYX_ERR(1, 415, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 416, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 415, __pyx_L1_error)
   __pyx_v__host = __pyx_t_2;
 
-  /* "ssh2/session.pyx":417
+  /* "ssh2/session.pyx":416
  *         cdef bytes b_host = to_bytes(host)
  *         cdef char *_host = b_host
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6597,12 +10666,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":418
+        /* "ssh2/session.pyx":417
  *         cdef char *_host = b_host
  *         with nogil:
  *             channel = c_ssh2.libssh2_channel_direct_tcpip(             # <<<<<<<<<<<<<<
@@ -6612,7 +10682,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
         __pyx_v_channel = libssh2_channel_direct_tcpip(__pyx_v_self->_session, __pyx_v__host, __pyx_v_port);
       }
 
-      /* "ssh2/session.pyx":417
+      /* "ssh2/session.pyx":416
  *         cdef bytes b_host = to_bytes(host)
  *         cdef char *_host = b_host
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6631,17 +10701,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
       }
   }
 
-  /* "ssh2/session.pyx":420
+  /* "ssh2/session.pyx":419
  *             channel = c_ssh2.libssh2_channel_direct_tcpip(
  *                 self._session, _host, port)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":421
+    /* "ssh2/session.pyx":420
  *                 self._session, _host, port)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -6650,29 +10720,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":422
+    /* "ssh2/session.pyx":421
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self)
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 421, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 420, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":421
+    /* "ssh2/session.pyx":420
  *                 self._session, _host, port)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self)
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 421, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 420, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":420
+    /* "ssh2/session.pyx":419
  *             channel = c_ssh2.libssh2_channel_direct_tcpip(
  *                 self._session, _host, port)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -6681,7 +10751,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
  */
   }
 
-  /* "ssh2/session.pyx":423
+  /* "ssh2/session.pyx":422
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self)             # <<<<<<<<<<<<<<
@@ -6689,13 +10759,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
  *     def block_directions(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 423, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 422, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":408
+  /* "ssh2/session.pyx":407
  *         return PyChannel(channel, self)
  * 
  *     def direct_tcpip(self, host not None, int port):             # <<<<<<<<<<<<<<
@@ -6715,7 +10785,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":425
+/* "ssh2/session.pyx":424
  *         return PyChannel(channel, self)
  * 
  *     def block_directions(self):             # <<<<<<<<<<<<<<
@@ -6724,12 +10794,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_42direct_tcpip(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_45block_directions(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_44block_directions[] = "Session.block_directions(self)\nGet blocked directions for the current session.\n\n        From libssh2 documentation:\n\n        Can be a combination of:\n\n        ``ssh2.session.LIBSSH2_SESSION_BLOCK_INBOUND``: Inbound direction\n        blocked.\n\n        ``ssh2.session.LIBSSH2_SESSION_BLOCK_OUTBOUND``: Outbound direction\n        blocked.\n\n        Application should wait for data to be available for socket prior to\n        calling a libssh2 function again. If ``LIBSSH2_SESSION_BLOCK_INBOUND``\n        is set select should contain the session socket in readfds set.\n\n        Correspondingly in case of ``LIBSSH2_SESSION_BLOCK_OUTBOUND`` writefds\n        set should contain the socket.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_45block_directions(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_45block_directions(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_44block_directions, "Session.block_directions(self)\nGet blocked directions for the current session.\n\n        From libssh2 documentation:\n\n        Can be a combination of:\n\n        ``ssh2.session.LIBSSH2_SESSION_BLOCK_INBOUND``: Inbound direction\n        blocked.\n\n        ``ssh2.session.LIBSSH2_SESSION_BLOCK_OUTBOUND``: Outbound direction\n        blocked.\n\n        Application should wait for data to be available for socket prior to\n        calling a libssh2 function again. If ``LIBSSH2_SESSION_BLOCK_INBOUND``\n        is set select should contain the session socket in readfds set.\n\n        Correspondingly in case of ``LIBSSH2_SESSION_BLOCK_OUTBOUND`` writefds\n        set should contain the socket.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_45block_directions = {"block_directions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_45block_directions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_44block_directions};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_45block_directions(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("block_directions (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("block_directions", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "block_directions", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_44block_directions(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -6745,9 +10843,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("block_directions", 0);
+  __Pyx_RefNannySetupContext("block_directions", 1);
 
-  /* "ssh2/session.pyx":447
+  /* "ssh2/session.pyx":446
  *         :rtype: int"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6757,12 +10855,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":448
+        /* "ssh2/session.pyx":447
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_block_directions(             # <<<<<<<<<<<<<<
@@ -6772,7 +10871,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
         __pyx_v_rc = libssh2_session_block_directions(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":447
+      /* "ssh2/session.pyx":446
  *         :rtype: int"""
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6791,7 +10890,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
       }
   }
 
-  /* "ssh2/session.pyx":450
+  /* "ssh2/session.pyx":449
  *             rc = c_ssh2.libssh2_session_block_directions(
  *                 self._session)
  *         return rc             # <<<<<<<<<<<<<<
@@ -6799,13 +10898,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
  *     def forward_listen(self, int port):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 450, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 449, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":425
+  /* "ssh2/session.pyx":424
  *         return PyChannel(channel, self)
  * 
  *     def block_directions(self):             # <<<<<<<<<<<<<<
@@ -6824,7 +10923,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":452
+/* "ssh2/session.pyx":451
  *         return rc
  * 
  *     def forward_listen(self, int port):             # <<<<<<<<<<<<<<
@@ -6833,28 +10932,98 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_44block_directions(struct __py
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_47forward_listen(PyObject *__pyx_v_self, PyObject *__pyx_arg_port); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_46forward_listen[] = "Session.forward_listen(self, int port)\nCreate forward listener on port.\n\n        :param port: Port to listen on.\n        :type port: int\n\n        :rtype: :py:class:`ssh2.listener.Listener` or None";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_47forward_listen(PyObject *__pyx_v_self, PyObject *__pyx_arg_port) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_47forward_listen(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_46forward_listen, "Session.forward_listen(self, int port)\nCreate forward listener on port.\n\n        :param port: Port to listen on.\n        :type port: int\n\n        :rtype: :py:class:`ssh2.listener.Listener` or None");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_47forward_listen = {"forward_listen", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_47forward_listen, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_46forward_listen};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_47forward_listen(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_port;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("forward_listen (wrapper)", 0);
-  assert(__pyx_arg_port); {
-    __pyx_v_port = __Pyx_PyInt_As_int(__pyx_arg_port); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 452, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_port,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "forward_listen") < 0)) __PYX_ERR(1, 451, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_port = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("forward_listen", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 451, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.forward_listen", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_46forward_listen(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((int)__pyx_v_port));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_46forward_listen(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_port);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6869,9 +11038,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("forward_listen", 0);
+  __Pyx_RefNannySetupContext("forward_listen", 1);
 
-  /* "ssh2/session.pyx":460
+  /* "ssh2/session.pyx":459
  *         :rtype: :py:class:`ssh2.listener.Listener` or None"""
  *         cdef c_ssh2.LIBSSH2_LISTENER *listener
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6881,12 +11050,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":461
+        /* "ssh2/session.pyx":460
  *         cdef c_ssh2.LIBSSH2_LISTENER *listener
  *         with nogil:
  *             listener = c_ssh2.libssh2_channel_forward_listen(             # <<<<<<<<<<<<<<
@@ -6896,7 +11066,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
         __pyx_v_listener = libssh2_channel_forward_listen(__pyx_v_self->_session, __pyx_v_port);
       }
 
-      /* "ssh2/session.pyx":460
+      /* "ssh2/session.pyx":459
  *         :rtype: :py:class:`ssh2.listener.Listener` or None"""
  *         cdef c_ssh2.LIBSSH2_LISTENER *listener
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -6915,17 +11085,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":463
+  /* "ssh2/session.pyx":462
  *             listener = c_ssh2.libssh2_channel_forward_listen(
  *                 self._session, port)
  *         if listener is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_1 = ((__pyx_v_listener == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_listener == NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":464
+    /* "ssh2/session.pyx":463
  *                 self._session, port)
  *         if listener is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -6934,29 +11104,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":465
+    /* "ssh2/session.pyx":464
  *         if listener is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyListener(listener, self)
  * 
  */
-    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 464, __pyx_L1_error)
+    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 463, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":464
+    /* "ssh2/session.pyx":463
  *                 self._session, port)
  *         if listener is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyListener(listener, self)
  */
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 464, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 463, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":463
+    /* "ssh2/session.pyx":462
  *             listener = c_ssh2.libssh2_channel_forward_listen(
  *                 self._session, port)
  *         if listener is NULL:             # <<<<<<<<<<<<<<
@@ -6965,7 +11135,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
  */
   }
 
-  /* "ssh2/session.pyx":466
+  /* "ssh2/session.pyx":465
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyListener(listener, self)             # <<<<<<<<<<<<<<
@@ -6973,13 +11143,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
  *     def forward_listen_ex(self, int queue_maxsize, host=None, int port=0):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_8listener_PyListener(__pyx_v_listener, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 466, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_8listener_PyListener(__pyx_v_listener, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 465, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":452
+  /* "ssh2/session.pyx":451
  *         return rc
  * 
  *     def forward_listen(self, int port):             # <<<<<<<<<<<<<<
@@ -6998,7 +11168,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":468
+/* "ssh2/session.pyx":467
  *         return PyListener(listener, self)
  * 
  *     def forward_listen_ex(self, int queue_maxsize, host=None, int port=0):             # <<<<<<<<<<<<<<
@@ -7007,79 +11177,118 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_46forward_listen(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_48forward_listen_ex[] = "Session.forward_listen_ex(self, int queue_maxsize, host=None, int port=0)\n\n        Instruct the remote SSH server to begin listening for inbound\n        TCP/IP connections. New connections will be queued by the library\n        until accepted by ``ssh2.channel.Channel.forward_accept``.\n\n        :param queue_maxsize: Maximum number of pending connections to queue\n          before rejecting further attempts.\n        :type queue_maxsize: int\n        :param host:  Address to bind to on the remote host. Binding\n          to 0.0.0.0 (default when `None` is passed) will bind to all available\n          addresses.\n        :type host: str\n        :param port: port to bind to on the remote host. When 0 is passed\n          (the default), the remote host will select the first available\n          dynamic port.\n        :type port: int\n        :returns: (listener, bound_port) tuple where bound_port is the\n          listen port bound on the remote host. Useful when requesting\n          dynamic port numbers.\n        :rtype: (:py:class:`ssh2.listener.Listener`, int)\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_48forward_listen_ex, "Session.forward_listen_ex(self, int queue_maxsize, host=None, int port=0)\n\n        Instruct the remote SSH server to begin listening for inbound\n        TCP/IP connections. New connections will be queued by the library\n        until accepted by ``ssh2.channel.Channel.forward_accept``.\n\n        :param queue_maxsize: Maximum number of pending connections to queue\n          before rejecting further attempts.\n        :type queue_maxsize: int\n        :param host:  Address to bind to on the remote host. Binding\n          to 0.0.0.0 (default when `None` is passed) will bind to all available\n          addresses.\n        :type host: str\n        :param port: port to bind to on the remote host. When 0 is passed\n          (the default), the remote host will select the first available\n          dynamic port.\n        :type port: int\n        :returns: (listener, bound_port) tuple where bound_port is the\n          listen port bound on the remote host. Useful when requesting\n          dynamic port numbers.\n        :rtype: (:py:class:`ssh2.listener.Listener`, int)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_49forward_listen_ex = {"forward_listen_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_48forward_listen_ex};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_queue_maxsize;
   PyObject *__pyx_v_host = 0;
   int __pyx_v_port;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("forward_listen_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_queue_maxsize,&__pyx_n_s_host,&__pyx_n_s_port,0};
-    PyObject* values[3] = {0,0,0};
-    values[1] = ((PyObject *)Py_None);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_queue_maxsize,&__pyx_n_s_host,&__pyx_n_s_port,0};
+    values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_queue_maxsize)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_queue_maxsize)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_host);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_host);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_port);
-          if (value) { values[2] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_port);
+          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "forward_listen_ex") < 0)) __PYX_ERR(1, 468, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "forward_listen_ex") < 0)) __PYX_ERR(1, 467, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_queue_maxsize = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_queue_maxsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 468, __pyx_L3_error)
+    __pyx_v_queue_maxsize = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_queue_maxsize == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L3_error)
     __pyx_v_host = values[1];
     if (values[2]) {
-      __pyx_v_port = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 468, __pyx_L3_error)
+      __pyx_v_port = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_port == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L3_error)
     } else {
       __pyx_v_port = ((int)0);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("forward_listen_ex", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 468, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("forward_listen_ex", 0, 1, 3, __pyx_nargs); __PYX_ERR(1, 467, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.forward_listen_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -7087,6 +11296,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex(PyObject *
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_queue_maxsize, __pyx_v_host, __pyx_v_port);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7101,16 +11316,15 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
   PyObject *__pyx_t_1 = NULL;
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  char *__pyx_t_5;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  char *__pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("forward_listen_ex", 0);
+  __Pyx_RefNannySetupContext("forward_listen_ex", 1);
 
-  /* "ssh2/session.pyx":491
+  /* "ssh2/session.pyx":490
  *         """
  *         cdef c_ssh2.LIBSSH2_LISTENER *listener
  *         cdef bytes b_host = None if host is None else to_bytes(host)             # <<<<<<<<<<<<<<
@@ -7118,19 +11332,20 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  *         if b_host is not None:
  */
   __pyx_t_2 = (__pyx_v_host == Py_None);
-  if ((__pyx_t_2 != 0)) {
+  if (__pyx_t_2) {
     __Pyx_INCREF(Py_None);
     __pyx_t_1 = Py_None;
   } else {
-    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 491, __pyx_L1_error)
+    __pyx_t_3 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_host); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 490, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_1 = __pyx_t_3;
     __pyx_t_3 = 0;
   }
+  if (!(likely(PyBytes_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_1))) __PYX_ERR(1, 490, __pyx_L1_error)
   __pyx_v_b_host = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":492
+  /* "ssh2/session.pyx":491
  *         cdef c_ssh2.LIBSSH2_LISTENER *listener
  *         cdef bytes b_host = None if host is None else to_bytes(host)
  *         cdef char *_host = NULL             # <<<<<<<<<<<<<<
@@ -7139,7 +11354,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
   __pyx_v__host = NULL;
 
-  /* "ssh2/session.pyx":493
+  /* "ssh2/session.pyx":492
  *         cdef bytes b_host = None if host is None else to_bytes(host)
  *         cdef char *_host = NULL
  *         if b_host is not None:             # <<<<<<<<<<<<<<
@@ -7147,10 +11362,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  *         cdef int bound_port = 0
  */
   __pyx_t_2 = (__pyx_v_b_host != ((PyObject*)Py_None));
-  __pyx_t_4 = (__pyx_t_2 != 0);
-  if (__pyx_t_4) {
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":494
+    /* "ssh2/session.pyx":493
  *         cdef char *_host = NULL
  *         if b_host is not None:
  *             _host = b_host             # <<<<<<<<<<<<<<
@@ -7159,12 +11373,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
     if (unlikely(__pyx_v_b_host == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-      __PYX_ERR(1, 494, __pyx_L1_error)
+      __PYX_ERR(1, 493, __pyx_L1_error)
     }
-    __pyx_t_5 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 494, __pyx_L1_error)
-    __pyx_v__host = __pyx_t_5;
+    __pyx_t_4 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_host); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(1, 493, __pyx_L1_error)
+    __pyx_v__host = __pyx_t_4;
 
-    /* "ssh2/session.pyx":493
+    /* "ssh2/session.pyx":492
  *         cdef bytes b_host = None if host is None else to_bytes(host)
  *         cdef char *_host = NULL
  *         if b_host is not None:             # <<<<<<<<<<<<<<
@@ -7173,7 +11387,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
   }
 
-  /* "ssh2/session.pyx":495
+  /* "ssh2/session.pyx":494
  *         if b_host is not None:
  *             _host = b_host
  *         cdef int bound_port = 0             # <<<<<<<<<<<<<<
@@ -7182,7 +11396,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
   __pyx_v_bound_port = 0;
 
-  /* "ssh2/session.pyx":496
+  /* "ssh2/session.pyx":495
  *             _host = b_host
  *         cdef int bound_port = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7192,12 +11406,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":497
+        /* "ssh2/session.pyx":496
  *         cdef int bound_port = 0
  *         with nogil:
  *             listener = c_ssh2.libssh2_channel_forward_listen_ex(             # <<<<<<<<<<<<<<
@@ -7207,7 +11422,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
         __pyx_v_listener = libssh2_channel_forward_listen_ex(__pyx_v_self->_session, __pyx_v__host, __pyx_v_port, (&__pyx_v_bound_port), __pyx_v_queue_maxsize);
       }
 
-      /* "ssh2/session.pyx":496
+      /* "ssh2/session.pyx":495
  *             _host = b_host
  *         cdef int bound_port = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7226,17 +11441,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
       }
   }
 
-  /* "ssh2/session.pyx":499
+  /* "ssh2/session.pyx":498
  *             listener = c_ssh2.libssh2_channel_forward_listen_ex(
  *                 self._session, _host, port, &bound_port, queue_maxsize)
  *         if listener is NULL:             # <<<<<<<<<<<<<<
  *             return (handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session)), 0)
  */
-  __pyx_t_4 = ((__pyx_v_listener == NULL) != 0);
-  if (__pyx_t_4) {
+  __pyx_t_2 = (__pyx_v_listener == NULL);
+  if (__pyx_t_2) {
 
-    /* "ssh2/session.pyx":500
+    /* "ssh2/session.pyx":499
  *                 self._session, _host, port, &bound_port, queue_maxsize)
  *         if listener is NULL:
  *             return (handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -7245,37 +11460,37 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":501
+    /* "ssh2/session.pyx":500
  *         if listener is NULL:
  *             return (handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session)), 0)             # <<<<<<<<<<<<<<
  *         return (PyListener(listener, self), bound_port)
  * 
  */
-    __pyx_t_6 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 500, __pyx_L1_error)
+    __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 499, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":500
+    /* "ssh2/session.pyx":499
  *                 self._session, _host, port, &bound_port, queue_maxsize)
  *         if listener is NULL:
  *             return (handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session)), 0)
  *         return (PyListener(listener, self), bound_port)
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 500, __pyx_L1_error)
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 499, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error);
     __Pyx_INCREF(__pyx_int_0);
     __Pyx_GIVEREF(__pyx_int_0);
-    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(1, 499, __pyx_L1_error);
     __pyx_t_1 = 0;
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":499
+    /* "ssh2/session.pyx":498
  *             listener = c_ssh2.libssh2_channel_forward_listen_ex(
  *                 self._session, _host, port, &bound_port, queue_maxsize)
  *         if listener is NULL:             # <<<<<<<<<<<<<<
@@ -7284,7 +11499,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
   }
 
-  /* "ssh2/session.pyx":502
+  /* "ssh2/session.pyx":501
  *             return (handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session)), 0)
  *         return (PyListener(listener, self), bound_port)             # <<<<<<<<<<<<<<
@@ -7292,23 +11507,23 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  *     def sftp_init(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_8listener_PyListener(__pyx_v_listener, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 502, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_8listener_PyListener(__pyx_v_listener, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 501, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_bound_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_bound_port); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 501, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 502, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 501, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
   __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3)) __PYX_ERR(1, 501, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1)) __PYX_ERR(1, 501, __pyx_L1_error);
   __pyx_t_3 = 0;
   __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_7;
-  __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":468
+  /* "ssh2/session.pyx":467
  *         return PyListener(listener, self)
  * 
  *     def forward_listen_ex(self, int queue_maxsize, host=None, int port=0):             # <<<<<<<<<<<<<<
@@ -7320,7 +11535,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.session.Session.forward_listen_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -7330,7 +11545,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":504
+/* "ssh2/session.pyx":503
  *         return (PyListener(listener, self), bound_port)
  * 
  *     def sftp_init(self):             # <<<<<<<<<<<<<<
@@ -7339,12 +11554,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_48forward_listen_ex(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_51sftp_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_50sftp_init[] = "Session.sftp_init(self)\nInitialise SFTP channel.\n\n        :rtype: :py:class:`ssh2.sftp.SFTP`\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_51sftp_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_51sftp_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_50sftp_init, "Session.sftp_init(self)\nInitialise SFTP channel.\n\n        :rtype: :py:class:`ssh2.sftp.SFTP`\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_51sftp_init = {"sftp_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_51sftp_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_50sftp_init};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_51sftp_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("sftp_init (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("sftp_init", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sftp_init", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_50sftp_init(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -7362,9 +11605,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("sftp_init", 0);
+  __Pyx_RefNannySetupContext("sftp_init", 1);
 
-  /* "ssh2/session.pyx":510
+  /* "ssh2/session.pyx":509
  *         """
  *         cdef c_sftp.LIBSSH2_SFTP *_sftp
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7374,12 +11617,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":511
+        /* "ssh2/session.pyx":510
  *         cdef c_sftp.LIBSSH2_SFTP *_sftp
  *         with nogil:
  *             _sftp = c_sftp.libssh2_sftp_init(self._session)             # <<<<<<<<<<<<<<
@@ -7389,7 +11633,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
         __pyx_v__sftp = libssh2_sftp_init(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":510
+      /* "ssh2/session.pyx":509
  *         """
  *         cdef c_sftp.LIBSSH2_SFTP *_sftp
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7408,17 +11652,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
       }
   }
 
-  /* "ssh2/session.pyx":512
+  /* "ssh2/session.pyx":511
  *         with nogil:
  *             _sftp = c_sftp.libssh2_sftp_init(self._session)
  *         if _sftp is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_1 = ((__pyx_v__sftp == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__sftp == NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":513
+    /* "ssh2/session.pyx":512
  *             _sftp = c_sftp.libssh2_sftp_init(self._session)
  *         if _sftp is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -7427,29 +11671,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":514
+    /* "ssh2/session.pyx":513
  *         if _sftp is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PySFTP(_sftp, self)
  * 
  */
-    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 513, __pyx_L1_error)
+    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 512, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":513
+    /* "ssh2/session.pyx":512
  *             _sftp = c_sftp.libssh2_sftp_init(self._session)
  *         if _sftp is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PySFTP(_sftp, self)
  */
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 513, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 512, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":512
+    /* "ssh2/session.pyx":511
  *         with nogil:
  *             _sftp = c_sftp.libssh2_sftp_init(self._session)
  *         if _sftp is NULL:             # <<<<<<<<<<<<<<
@@ -7458,7 +11702,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
  */
   }
 
-  /* "ssh2/session.pyx":515
+  /* "ssh2/session.pyx":514
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PySFTP(_sftp, self)             # <<<<<<<<<<<<<<
@@ -7466,13 +11710,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
  *     def last_error(self, size_t msg_size=1024):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __pyx_f_4ssh2_4sftp_PySFTP(__pyx_v__sftp, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_4sftp_PySFTP(__pyx_v__sftp, __pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":504
+  /* "ssh2/session.pyx":503
  *         return (PyListener(listener, self), bound_port)
  * 
  *     def sftp_init(self):             # <<<<<<<<<<<<<<
@@ -7491,7 +11735,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":517
+/* "ssh2/session.pyx":516
  *         return PySFTP(_sftp, self)
  * 
  *     def last_error(self, size_t msg_size=1024):             # <<<<<<<<<<<<<<
@@ -7500,57 +11744,91 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_50sftp_init(struct __pyx_obj_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_53last_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_52last_error[] = "Session.last_error(self, size_t msg_size=1024)\nRetrieve last error message from libssh2, if any.\n        Returns empty string on no error message.\n\n        :rtype: str\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_53last_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_53last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_52last_error, "Session.last_error(self, size_t msg_size=1024)\nRetrieve last error message from libssh2, if any.\n        Returns empty string on no error message.\n\n        :rtype: str\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_53last_error = {"last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_53last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_52last_error};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_53last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_msg_size;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("last_error (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_msg_size,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_msg_size,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msg_size);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_msg_size);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 516, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "last_error") < 0)) __PYX_ERR(1, 517, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "last_error") < 0)) __PYX_ERR(1, 516, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     if (values[0]) {
-      __pyx_v_msg_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_msg_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 517, __pyx_L3_error)
+      __pyx_v_msg_size = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_msg_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 516, __pyx_L3_error)
     } else {
       __pyx_v_msg_size = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("last_error", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 517, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("last_error", 0, 0, 1, __pyx_nargs); __PYX_ERR(1, 516, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.last_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -7558,6 +11836,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_53last_error(PyObject *__pyx_v
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_52last_error(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_msg_size);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7570,31 +11854,32 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
-  int __pyx_t_3;
+  char *__pyx_t_3;
   int __pyx_t_4;
-  char const *__pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_5;
+  char const *__pyx_t_6;
   PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
   PyObject *__pyx_t_9 = NULL;
   PyObject *__pyx_t_10 = NULL;
   PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("last_error", 0);
+  __Pyx_RefNannySetupContext("last_error", 1);
 
-  /* "ssh2/session.pyx":524
+  /* "ssh2/session.pyx":523
  *         """
  *         cdef char *_error_msg
  *         cdef bytes msg = b''             # <<<<<<<<<<<<<<
  *         cdef int errmsg_len = 0
  *         with nogil:
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_msg = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_msg = __pyx_kp_b__2;
 
-  /* "ssh2/session.pyx":525
+  /* "ssh2/session.pyx":524
  *         cdef char *_error_msg
  *         cdef bytes msg = b''
  *         cdef int errmsg_len = 0             # <<<<<<<<<<<<<<
@@ -7603,7 +11888,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
  */
   __pyx_v_errmsg_len = 0;
 
-  /* "ssh2/session.pyx":526
+  /* "ssh2/session.pyx":525
  *         cdef bytes msg = b''
  *         cdef int errmsg_len = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7613,12 +11898,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":527
+        /* "ssh2/session.pyx":526
  *         cdef int errmsg_len = 0
  *         with nogil:
  *             _error_msg = <char *>malloc(sizeof(char) * msg_size)             # <<<<<<<<<<<<<<
@@ -7627,7 +11913,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
  */
         __pyx_v__error_msg = ((char *)malloc(((sizeof(char)) * __pyx_v_msg_size)));
 
-        /* "ssh2/session.pyx":528
+        /* "ssh2/session.pyx":527
  *         with nogil:
  *             _error_msg = <char *>malloc(sizeof(char) * msg_size)
  *             c_ssh2.libssh2_session_last_error(             # <<<<<<<<<<<<<<
@@ -7637,7 +11923,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
         (void)(libssh2_session_last_error(__pyx_v_self->_session, (&__pyx_v__error_msg), (&__pyx_v_errmsg_len), 1));
       }
 
-      /* "ssh2/session.pyx":526
+      /* "ssh2/session.pyx":525
  *         cdef bytes msg = b''
  *         cdef int errmsg_len = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7656,7 +11942,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/session.pyx":530
+  /* "ssh2/session.pyx":529
  *             c_ssh2.libssh2_session_last_error(
  *                 self._session, &_error_msg, &errmsg_len, 1)
  *         try:             # <<<<<<<<<<<<<<
@@ -7665,52 +11951,55 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
  */
   /*try:*/ {
 
-    /* "ssh2/session.pyx":531
+    /* "ssh2/session.pyx":530
  *                 self._session, &_error_msg, &errmsg_len, 1)
  *         try:
  *             if errmsg_len > 0:             # <<<<<<<<<<<<<<
  *                 msg = _error_msg[:errmsg_len]
- *             return msg
+ *             return to_str(msg)
  */
-    __pyx_t_1 = ((__pyx_v_errmsg_len > 0) != 0);
+    __pyx_t_1 = (__pyx_v_errmsg_len > 0);
     if (__pyx_t_1) {
 
-      /* "ssh2/session.pyx":532
+      /* "ssh2/session.pyx":531
  *         try:
  *             if errmsg_len > 0:
  *                 msg = _error_msg[:errmsg_len]             # <<<<<<<<<<<<<<
- *             return msg
+ *             return to_str(msg)
  *         finally:
  */
-      __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v__error_msg + 0, __pyx_v_errmsg_len - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L7_error)
+      __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v__error_msg + 0, __pyx_v_errmsg_len - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 531, __pyx_L7_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_2));
       __pyx_t_2 = 0;
 
-      /* "ssh2/session.pyx":531
+      /* "ssh2/session.pyx":530
  *                 self._session, &_error_msg, &errmsg_len, 1)
  *         try:
  *             if errmsg_len > 0:             # <<<<<<<<<<<<<<
  *                 msg = _error_msg[:errmsg_len]
- *             return msg
+ *             return to_str(msg)
  */
     }
 
-    /* "ssh2/session.pyx":533
+    /* "ssh2/session.pyx":532
  *             if errmsg_len > 0:
  *                 msg = _error_msg[:errmsg_len]
- *             return msg             # <<<<<<<<<<<<<<
+ *             return to_str(msg)             # <<<<<<<<<<<<<<
  *         finally:
  *             free(_error_msg)
  */
     __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(__pyx_v_msg);
-    __pyx_r = __pyx_v_msg;
+    __pyx_t_3 = __Pyx_PyBytes_AsWritableString(__pyx_v_msg); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(1, 532, __pyx_L7_error)
+    __pyx_t_2 = __pyx_f_4ssh2_5utils_to_str(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L7_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_r = __pyx_t_2;
+    __pyx_t_2 = 0;
     goto __pyx_L6_return;
   }
 
-  /* "ssh2/session.pyx":535
- *             return msg
+  /* "ssh2/session.pyx":534
+ *             return to_str(msg)
  *         finally:
  *             free(_error_msg)             # <<<<<<<<<<<<<<
  * 
@@ -7721,45 +12010,45 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
     /*exception exit:*/{
       __Pyx_PyThreadState_declare
       __Pyx_PyThreadState_assign
-      __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0;
+      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
       __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
-      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
-      __Pyx_XGOTREF(__pyx_t_6);
+      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
+      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
       __Pyx_XGOTREF(__pyx_t_7);
       __Pyx_XGOTREF(__pyx_t_8);
       __Pyx_XGOTREF(__pyx_t_9);
       __Pyx_XGOTREF(__pyx_t_10);
       __Pyx_XGOTREF(__pyx_t_11);
-      __pyx_t_3 = __pyx_lineno; __pyx_t_4 = __pyx_clineno; __pyx_t_5 = __pyx_filename;
+      __Pyx_XGOTREF(__pyx_t_12);
+      __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename;
       {
         free(__pyx_v__error_msg);
       }
       if (PY_MAJOR_VERSION >= 3) {
-        __Pyx_XGIVEREF(__pyx_t_9);
         __Pyx_XGIVEREF(__pyx_t_10);
         __Pyx_XGIVEREF(__pyx_t_11);
-        __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
       }
-      __Pyx_XGIVEREF(__pyx_t_6);
       __Pyx_XGIVEREF(__pyx_t_7);
       __Pyx_XGIVEREF(__pyx_t_8);
-      __Pyx_ErrRestore(__pyx_t_6, __pyx_t_7, __pyx_t_8);
-      __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0;
-      __pyx_lineno = __pyx_t_3; __pyx_clineno = __pyx_t_4; __pyx_filename = __pyx_t_5;
+      __Pyx_XGIVEREF(__pyx_t_9);
+      __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9);
+      __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0;
+      __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6;
       goto __pyx_L1_error;
     }
     __pyx_L6_return: {
-      __pyx_t_11 = __pyx_r;
+      __pyx_t_12 = __pyx_r;
       __pyx_r = 0;
       free(__pyx_v__error_msg);
-      __pyx_r = __pyx_t_11;
-      __pyx_t_11 = 0;
+      __pyx_r = __pyx_t_12;
+      __pyx_t_12 = 0;
       goto __pyx_L0;
     }
   }
 
-  /* "ssh2/session.pyx":517
+  /* "ssh2/session.pyx":516
  *         return PySFTP(_sftp, self)
  * 
  *     def last_error(self, size_t msg_size=1024):             # <<<<<<<<<<<<<<
@@ -7779,7 +12068,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":537
+/* "ssh2/session.pyx":536
  *             free(_error_msg)
  * 
  *     def last_errno(self):             # <<<<<<<<<<<<<<
@@ -7788,12 +12077,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_52last_error(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_55last_errno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_54last_errno[] = "Session.last_errno(self)\nRetrieve last error number from libssh2, if any.\n        Returns 0 on no last error.\n\n        :rtype: int\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_55last_errno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_55last_errno(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_54last_errno, "Session.last_errno(self)\nRetrieve last error number from libssh2, if any.\n        Returns 0 on no last error.\n\n        :rtype: int\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_55last_errno = {"last_errno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_55last_errno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_54last_errno};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_55last_errno(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("last_errno (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("last_errno", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "last_errno", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_54last_errno(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -7809,9 +12126,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("last_errno", 0);
+  __Pyx_RefNannySetupContext("last_errno", 1);
 
-  /* "ssh2/session.pyx":544
+  /* "ssh2/session.pyx":543
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7821,12 +12138,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":545
+        /* "ssh2/session.pyx":544
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -7836,7 +12154,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
         __pyx_v_rc = libssh2_session_last_errno(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":544
+      /* "ssh2/session.pyx":543
  *         """
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -7855,7 +12173,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/session.pyx":547
+  /* "ssh2/session.pyx":546
  *             rc = c_ssh2.libssh2_session_last_errno(
  *                 self._session)
  *         return rc             # <<<<<<<<<<<<<<
@@ -7863,13 +12181,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
  *     def set_last_error(self, int errcode, errmsg not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 547, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 546, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":537
+  /* "ssh2/session.pyx":536
  *             free(_error_msg)
  * 
  *     def last_errno(self):             # <<<<<<<<<<<<<<
@@ -7888,7 +12206,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":549
+/* "ssh2/session.pyx":548
  *         return rc
  * 
  *     def set_last_error(self, int errcode, errmsg not None):             # <<<<<<<<<<<<<<
@@ -7897,65 +12215,106 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_54last_errno(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_57set_last_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_56set_last_error[] = "Session.set_last_error(self, int errcode, errmsg)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_57set_last_error(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_57set_last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_56set_last_error, "Session.set_last_error(self, int errcode, errmsg)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_57set_last_error = {"set_last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_57set_last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_56set_last_error};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_57set_last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_errcode;
   PyObject *__pyx_v_errmsg = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("set_last_error (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_errcode,&__pyx_n_s_errmsg,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_errcode,&__pyx_n_s_errmsg,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_errcode)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_errcode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 548, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_errmsg)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_errmsg)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 548, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("set_last_error", 1, 2, 2, 1); __PYX_ERR(1, 549, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("set_last_error", 1, 2, 2, 1); __PYX_ERR(1, 548, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_last_error") < 0)) __PYX_ERR(1, 549, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set_last_error") < 0)) __PYX_ERR(1, 548, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_errcode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_errcode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 549, __pyx_L3_error)
+    __pyx_v_errcode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_errcode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 548, __pyx_L3_error)
     __pyx_v_errmsg = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("set_last_error", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 549, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("set_last_error", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 548, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.set_last_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_errmsg) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "errmsg"); __PYX_ERR(1, 549, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "errmsg"); __PYX_ERR(1, 548, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_56set_last_error(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_errcode, __pyx_v_errmsg);
 
@@ -7964,6 +12323,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_57set_last_error(PyObject *__p
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7979,21 +12344,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("set_last_error", 0);
+  __Pyx_RefNannySetupContext("set_last_error", 1);
 
-  /* "ssh2/session.pyx":550
+  /* "ssh2/session.pyx":549
  * 
  *     def set_last_error(self, int errcode, errmsg not None):
  *         cdef bytes b_errmsg = to_bytes(errmsg)             # <<<<<<<<<<<<<<
  *         cdef char *_errmsg = b_errmsg
  *         cdef int rc
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_errmsg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 550, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_errmsg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 549, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_errmsg = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":551
+  /* "ssh2/session.pyx":550
  *     def set_last_error(self, int errcode, errmsg not None):
  *         cdef bytes b_errmsg = to_bytes(errmsg)
  *         cdef char *_errmsg = b_errmsg             # <<<<<<<<<<<<<<
@@ -8002,12 +12367,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
  */
   if (unlikely(__pyx_v_b_errmsg == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 551, __pyx_L1_error)
+    __PYX_ERR(1, 550, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_errmsg); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 551, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_errmsg); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 550, __pyx_L1_error)
   __pyx_v__errmsg = __pyx_t_2;
 
-  /* "ssh2/session.pyx":553
+  /* "ssh2/session.pyx":552
  *         cdef char *_errmsg = b_errmsg
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8017,12 +12382,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":554
+        /* "ssh2/session.pyx":553
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_set_last_error(             # <<<<<<<<<<<<<<
@@ -8032,7 +12398,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
         __pyx_v_rc = libssh2_session_set_last_error(__pyx_v_self->_session, __pyx_v_errcode, __pyx_v__errmsg);
       }
 
-      /* "ssh2/session.pyx":553
+      /* "ssh2/session.pyx":552
  *         cdef char *_errmsg = b_errmsg
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8051,7 +12417,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":556
+  /* "ssh2/session.pyx":555
  *             rc = c_ssh2.libssh2_session_set_last_error(
  *                 self._session, errcode, _errmsg)
  *         return rc             # <<<<<<<<<<<<<<
@@ -8059,13 +12425,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
  *     def scp_recv(self, path not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 555, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":549
+  /* "ssh2/session.pyx":548
  *         return rc
  * 
  *     def set_last_error(self, int errcode, errmsg not None):             # <<<<<<<<<<<<<<
@@ -8085,7 +12451,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":558
+/* "ssh2/session.pyx":557
  *         return rc
  * 
  *     def scp_recv(self, path not None):             # <<<<<<<<<<<<<<
@@ -8094,25 +12460,105 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_56set_last_error(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_59scp_recv(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_58scp_recv[] = "Session.scp_recv(self, path)\nReceive file via SCP.\n\n        Deprecated in favour or recv2 (requires libssh2 >= 1.7).\n\n        :param path: File path to receive.\n        :type path: str\n\n        :rtype: tuple(:py:class:`ssh2.channel.Channel`,\n          :py:class:`ssh2.statinfo.StatInfo`) or None";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_59scp_recv(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_59scp_recv(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_58scp_recv, "Session.scp_recv(self, path)\nReceive file via SCP.\n\n        Deprecated in favour or recv2 (requires libssh2 >= 1.7).\n\n        :param path: File path to receive.\n        :type path: str\n\n        :rtype: tuple(:py:class:`ssh2.channel.Channel`,\n          :py:class:`ssh2.statinfo.StatInfo`) or None");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_59scp_recv = {"scp_recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_59scp_recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_58scp_recv};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_59scp_recv(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("scp_recv (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 557, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "scp_recv") < 0)) __PYX_ERR(1, 557, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("scp_recv", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 557, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.scp_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 558, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 557, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_58scp_recv(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_58scp_recv(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -8132,21 +12578,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("scp_recv", 0);
+  __Pyx_RefNannySetupContext("scp_recv", 1);
 
-  /* "ssh2/session.pyx":568
+  /* "ssh2/session.pyx":567
  *         :rtype: tuple(:py:class:`ssh2.channel.Channel`,
  *           :py:class:`ssh2.statinfo.StatInfo`) or None"""
  *         cdef bytes b_path = to_bytes(path)             # <<<<<<<<<<<<<<
  *         cdef char *_path = b_path
  *         cdef StatInfo statinfo = StatInfo()
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 568, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 567, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_path = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":569
+  /* "ssh2/session.pyx":568
  *           :py:class:`ssh2.statinfo.StatInfo`) or None"""
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path             # <<<<<<<<<<<<<<
@@ -8155,24 +12601,24 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
  */
   if (unlikely(__pyx_v_b_path == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 569, __pyx_L1_error)
+    __PYX_ERR(1, 568, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 569, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 568, __pyx_L1_error)
   __pyx_v__path = __pyx_t_2;
 
-  /* "ssh2/session.pyx":570
+  /* "ssh2/session.pyx":569
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path
  *         cdef StatInfo statinfo = StatInfo()             # <<<<<<<<<<<<<<
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  */
-  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_4ssh2_8statinfo_StatInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 570, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_4ssh2_8statinfo_StatInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_statinfo = ((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":572
+  /* "ssh2/session.pyx":571
  *         cdef StatInfo statinfo = StatInfo()
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8182,12 +12628,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":573
+        /* "ssh2/session.pyx":572
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  *             channel = c_ssh2.libssh2_scp_recv(             # <<<<<<<<<<<<<<
@@ -8197,7 +12644,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
         __pyx_v_channel = libssh2_scp_recv(__pyx_v_self->_session, __pyx_v__path, __pyx_v_statinfo->_stat);
       }
 
-      /* "ssh2/session.pyx":572
+      /* "ssh2/session.pyx":571
  *         cdef StatInfo statinfo = StatInfo()
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8216,17 +12663,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/session.pyx":575
+  /* "ssh2/session.pyx":574
  *             channel = c_ssh2.libssh2_scp_recv(
  *                 self._session, _path, statinfo._stat)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":576
+    /* "ssh2/session.pyx":575
  *                 self._session, _path, statinfo._stat)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -8235,29 +12682,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":577
+    /* "ssh2/session.pyx":576
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self), statinfo
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 576, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 575, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":576
+    /* "ssh2/session.pyx":575
  *                 self._session, _path, statinfo._stat)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self), statinfo
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 576, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 575, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":575
+    /* "ssh2/session.pyx":574
  *             channel = c_ssh2.libssh2_scp_recv(
  *                 self._session, _path, statinfo._stat)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -8266,7 +12713,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
  */
   }
 
-  /* "ssh2/session.pyx":578
+  /* "ssh2/session.pyx":577
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self), statinfo             # <<<<<<<<<<<<<<
@@ -8274,21 +12721,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
  *     def scp_recv2(self, path not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 578, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 577, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 578, __pyx_L1_error)
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 577, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_statinfo));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_statinfo));
-  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_statinfo));
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(1, 577, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_statinfo);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_statinfo);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_statinfo))) __PYX_ERR(1, 577, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_r = __pyx_t_5;
   __pyx_t_5 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":558
+  /* "ssh2/session.pyx":557
  *         return rc
  * 
  *     def scp_recv(self, path not None):             # <<<<<<<<<<<<<<
@@ -8310,7 +12757,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":580
+/* "ssh2/session.pyx":579
  *         return PyChannel(channel, self), statinfo
  * 
  *     def scp_recv2(self, path not None):             # <<<<<<<<<<<<<<
@@ -8319,25 +12766,105 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_58scp_recv(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_61scp_recv2(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_60scp_recv2[] = "Session.scp_recv2(self, path)\nReceive file via SCP.\n\n        :param path: File path to receive.\n        :type path: str\n\n        :rtype: tuple(:py:class:`ssh2.channel.Channel`,\n          :py:class:`ssh2.fileinfo.FileInfo`) or ``None``";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_61scp_recv2(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_61scp_recv2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_60scp_recv2, "Session.scp_recv2(self, path)\nReceive file via SCP.\n\n        :param path: File path to receive.\n        :type path: str\n\n        :rtype: tuple(:py:class:`ssh2.channel.Channel`,\n          :py:class:`ssh2.fileinfo.FileInfo`) or ``None``");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_61scp_recv2 = {"scp_recv2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_61scp_recv2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_60scp_recv2};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_61scp_recv2(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("scp_recv2 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 579, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "scp_recv2") < 0)) __PYX_ERR(1, 579, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("scp_recv2", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 579, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.scp_recv2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 580, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 579, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_60scp_recv2(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_60scp_recv2(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -8357,33 +12884,33 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("scp_recv2", 0);
+  __Pyx_RefNannySetupContext("scp_recv2", 1);
 
-  /* "ssh2/session.pyx":588
+  /* "ssh2/session.pyx":587
  *         :rtype: tuple(:py:class:`ssh2.channel.Channel`,
  *           :py:class:`ssh2.fileinfo.FileInfo`) or ``None``"""
  *         cdef FileInfo fileinfo = FileInfo()             # <<<<<<<<<<<<<<
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path
  */
-  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_4ssh2_8fileinfo_FileInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_4ssh2_8fileinfo_FileInfo)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_fileinfo = ((struct __pyx_obj_4ssh2_8fileinfo_FileInfo *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":589
+  /* "ssh2/session.pyx":588
  *           :py:class:`ssh2.fileinfo.FileInfo`) or ``None``"""
  *         cdef FileInfo fileinfo = FileInfo()
  *         cdef bytes b_path = to_bytes(path)             # <<<<<<<<<<<<<<
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_path = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":590
+  /* "ssh2/session.pyx":589
  *         cdef FileInfo fileinfo = FileInfo()
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path             # <<<<<<<<<<<<<<
@@ -8392,12 +12919,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
  */
   if (unlikely(__pyx_v_b_path == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 590, __pyx_L1_error)
+    __PYX_ERR(1, 589, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 590, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 589, __pyx_L1_error)
   __pyx_v__path = __pyx_t_2;
 
-  /* "ssh2/session.pyx":592
+  /* "ssh2/session.pyx":591
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8407,12 +12934,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":593
+        /* "ssh2/session.pyx":592
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  *             channel = c_ssh2.libssh2_scp_recv2(             # <<<<<<<<<<<<<<
@@ -8422,7 +12950,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
         __pyx_v_channel = libssh2_scp_recv2(__pyx_v_self->_session, __pyx_v__path, __pyx_v_fileinfo->_stat);
       }
 
-      /* "ssh2/session.pyx":592
+      /* "ssh2/session.pyx":591
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8441,17 +12969,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
       }
   }
 
-  /* "ssh2/session.pyx":595
+  /* "ssh2/session.pyx":594
  *             channel = c_ssh2.libssh2_scp_recv2(
  *                 self._session, _path, fileinfo._stat)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":596
+    /* "ssh2/session.pyx":595
  *                 self._session, _path, fileinfo._stat)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -8460,29 +12988,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":597
+    /* "ssh2/session.pyx":596
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self), fileinfo
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 596, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 595, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":596
+    /* "ssh2/session.pyx":595
  *                 self._session, _path, fileinfo._stat)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self), fileinfo
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":595
+    /* "ssh2/session.pyx":594
  *             channel = c_ssh2.libssh2_scp_recv2(
  *                 self._session, _path, fileinfo._stat)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -8491,7 +13019,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
  */
   }
 
-  /* "ssh2/session.pyx":598
+  /* "ssh2/session.pyx":597
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self), fileinfo             # <<<<<<<<<<<<<<
@@ -8499,21 +13027,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
  *     def scp_send(self, path not None, int mode, size_t size):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 598, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 597, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 598, __pyx_L1_error)
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 597, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_fileinfo));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_fileinfo));
-  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_fileinfo));
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(1, 597, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_fileinfo);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_fileinfo);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_fileinfo))) __PYX_ERR(1, 597, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_r = __pyx_t_5;
   __pyx_t_5 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":580
+  /* "ssh2/session.pyx":579
  *         return PyChannel(channel, self), statinfo
  * 
  *     def scp_recv2(self, path not None):             # <<<<<<<<<<<<<<
@@ -8535,7 +13063,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":600
+/* "ssh2/session.pyx":599
  *         return PyChannel(channel, self), fileinfo
  * 
  *     def scp_send(self, path not None, int mode, size_t size):             # <<<<<<<<<<<<<<
@@ -8544,76 +13072,121 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_60scp_recv2(struct __pyx_obj_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_63scp_send(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_62scp_send[] = "Session.scp_send(self, path, int mode, size_t size)\nDeprecated in favour of scp_send64. Send file via SCP.\n\n        :param path: Local file path to send.\n        :type path: str\n        :param mode: File mode.\n        :type mode: int\n        :param size: size of file\n        :type size: int\n\n        :rtype: :py:class:`ssh2.channel.Channel`";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_63scp_send(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_63scp_send(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_62scp_send, "Session.scp_send(self, path, int mode, size_t size)\nDeprecated in favour of scp_send64. Send file via SCP.\n\n        :param path: Local file path to send.\n        :type path: str\n        :param mode: File mode.\n        :type mode: int\n        :param size: size of file\n        :type size: int\n\n        :rtype: :py:class:`ssh2.channel.Channel`");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_63scp_send = {"scp_send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_63scp_send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_62scp_send};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_63scp_send(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   int __pyx_v_mode;
   size_t __pyx_v_size;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("scp_send (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,&__pyx_n_s_size,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,&__pyx_n_s_size,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 599, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 599, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, 1); __PYX_ERR(1, 600, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, 1); __PYX_ERR(1, 599, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 599, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, 2); __PYX_ERR(1, 600, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, 2); __PYX_ERR(1, 599, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "scp_send") < 0)) __PYX_ERR(1, 600, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "scp_send") < 0)) __PYX_ERR(1, 599, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+    } else if (unlikely(__pyx_nargs != 3)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
     }
     __pyx_v_path = values[0];
-    __pyx_v_mode = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 600, __pyx_L3_error)
-    __pyx_v_size = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 600, __pyx_L3_error)
+    __pyx_v_mode = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 599, __pyx_L3_error)
+    __pyx_v_size = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_size == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 599, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 600, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("scp_send", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 599, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.scp_send", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 600, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 599, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_62scp_send(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_path, __pyx_v_mode, __pyx_v_size);
 
@@ -8622,6 +13195,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_63scp_send(PyObject *__pyx_v_s
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -8639,21 +13218,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("scp_send", 0);
+  __Pyx_RefNannySetupContext("scp_send", 1);
 
-  /* "ssh2/session.pyx":611
+  /* "ssh2/session.pyx":610
  * 
  *         :rtype: :py:class:`ssh2.channel.Channel`"""
  *         cdef bytes b_path = to_bytes(path)             # <<<<<<<<<<<<<<
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 611, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 610, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_path = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":612
+  /* "ssh2/session.pyx":611
  *         :rtype: :py:class:`ssh2.channel.Channel`"""
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path             # <<<<<<<<<<<<<<
@@ -8662,12 +13241,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
  */
   if (unlikely(__pyx_v_b_path == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 612, __pyx_L1_error)
+    __PYX_ERR(1, 611, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 612, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 611, __pyx_L1_error)
   __pyx_v__path = __pyx_t_2;
 
-  /* "ssh2/session.pyx":614
+  /* "ssh2/session.pyx":613
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8677,12 +13256,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":615
+        /* "ssh2/session.pyx":614
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  *             channel = c_ssh2.libssh2_scp_send(             # <<<<<<<<<<<<<<
@@ -8692,7 +13272,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
         __pyx_v_channel = libssh2_scp_send(__pyx_v_self->_session, __pyx_v__path, __pyx_v_mode, __pyx_v_size);
       }
 
-      /* "ssh2/session.pyx":614
+      /* "ssh2/session.pyx":613
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8711,17 +13291,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
       }
   }
 
-  /* "ssh2/session.pyx":617
+  /* "ssh2/session.pyx":616
  *             channel = c_ssh2.libssh2_scp_send(
  *                 self._session, _path, mode, size)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":618
+    /* "ssh2/session.pyx":617
  *                 self._session, _path, mode, size)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -8730,29 +13310,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":619
+    /* "ssh2/session.pyx":618
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self)
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 618, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 617, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":618
+    /* "ssh2/session.pyx":617
  *                 self._session, _path, mode, size)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self)
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":617
+    /* "ssh2/session.pyx":616
  *             channel = c_ssh2.libssh2_scp_send(
  *                 self._session, _path, mode, size)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -8761,7 +13341,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
  */
   }
 
-  /* "ssh2/session.pyx":620
+  /* "ssh2/session.pyx":619
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self)             # <<<<<<<<<<<<<<
@@ -8769,13 +13349,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
  *     def scp_send64(self, path not None, int mode, c_ssh2.libssh2_uint64_t size,
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 620, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 619, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":600
+  /* "ssh2/session.pyx":599
  *         return PyChannel(channel, self), fileinfo
  * 
  *     def scp_send(self, path not None, int mode, size_t size):             # <<<<<<<<<<<<<<
@@ -8795,7 +13375,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":622
+/* "ssh2/session.pyx":621
  *         return PyChannel(channel, self)
  * 
  *     def scp_send64(self, path not None, int mode, c_ssh2.libssh2_uint64_t size,             # <<<<<<<<<<<<<<
@@ -8804,98 +13384,151 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_62scp_send(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_65scp_send64(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_64scp_send64[] = "Session.scp_send64(self, path, int mode, libssh2_uint64_t size, time_t mtime, time_t atime)\nSend file via SCP.\n\n        :param path: Local file path to send.\n        :type path: str\n        :param mode: File mode.\n        :type mode: int\n        :param size: size of file\n        :type size: int\n\n        :rtype: :py:class:`ssh2.channel.Channel`";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_65scp_send64(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_65scp_send64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_64scp_send64, "Session.scp_send64(self, path, int mode, libssh2_uint64_t size, time_t mtime, time_t atime)\nSend file via SCP.\n\n        :param path: Local file path to send.\n        :type path: str\n        :param mode: File mode.\n        :type mode: int\n        :param size: size of file\n        :type size: int\n\n        :rtype: :py:class:`ssh2.channel.Channel`");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_65scp_send64 = {"scp_send64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_65scp_send64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_64scp_send64};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_65scp_send64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   int __pyx_v_mode;
   libssh2_uint64_t __pyx_v_size;
   time_t __pyx_v_mtime;
   time_t __pyx_v_atime;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("scp_send64 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,&__pyx_n_s_size,&__pyx_n_s_mtime,&__pyx_n_s_atime,0};
-    PyObject* values[5] = {0,0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,&__pyx_n_s_size,&__pyx_n_s_mtime,&__pyx_n_s_atime,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 1); __PYX_ERR(1, 622, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 1); __PYX_ERR(1, 621, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_size)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 2); __PYX_ERR(1, 622, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 2); __PYX_ERR(1, 621, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mtime)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mtime)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 3); __PYX_ERR(1, 622, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 3); __PYX_ERR(1, 621, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atime)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_atime)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 4); __PYX_ERR(1, 622, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, 4); __PYX_ERR(1, 621, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "scp_send64") < 0)) __PYX_ERR(1, 622, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "scp_send64") < 0)) __PYX_ERR(1, 621, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+    } else if (unlikely(__pyx_nargs != 5)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
+      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
     }
     __pyx_v_path = values[0];
-    __pyx_v_mode = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 622, __pyx_L3_error)
-    __pyx_v_size = __Pyx_PyInt_As_libssh2_uint64_t(values[2]); if (unlikely((__pyx_v_size == ((libssh2_uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 622, __pyx_L3_error)
-    __pyx_v_mtime = __Pyx_PyInt_As_time_t(values[3]); if (unlikely((__pyx_v_mtime == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 623, __pyx_L3_error)
-    __pyx_v_atime = __Pyx_PyInt_As_time_t(values[4]); if (unlikely((__pyx_v_atime == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 623, __pyx_L3_error)
+    __pyx_v_mode = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_mode == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
+    __pyx_v_size = __Pyx_PyInt_As_libssh2_uint64_t(values[2]); if (unlikely((__pyx_v_size == ((libssh2_uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 621, __pyx_L3_error)
+    __pyx_v_mtime = __Pyx_PyInt_As_time_t(values[3]); if (unlikely((__pyx_v_mtime == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 622, __pyx_L3_error)
+    __pyx_v_atime = __Pyx_PyInt_As_time_t(values[4]); if (unlikely((__pyx_v_atime == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 622, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 622, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("scp_send64", 1, 5, 5, __pyx_nargs); __PYX_ERR(1, 621, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.scp_send64", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 622, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(1, 621, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_64scp_send64(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_path, __pyx_v_mode, __pyx_v_size, __pyx_v_mtime, __pyx_v_atime);
 
@@ -8904,6 +13537,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_65scp_send64(PyObject *__pyx_v
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -8921,21 +13560,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("scp_send64", 0);
+  __Pyx_RefNannySetupContext("scp_send64", 1);
 
-  /* "ssh2/session.pyx":634
+  /* "ssh2/session.pyx":633
  * 
  *         :rtype: :py:class:`ssh2.channel.Channel`"""
  *         cdef bytes b_path = to_bytes(path)             # <<<<<<<<<<<<<<
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 634, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 633, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_path = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":635
+  /* "ssh2/session.pyx":634
  *         :rtype: :py:class:`ssh2.channel.Channel`"""
  *         cdef bytes b_path = to_bytes(path)
  *         cdef char *_path = b_path             # <<<<<<<<<<<<<<
@@ -8944,12 +13583,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
  */
   if (unlikely(__pyx_v_b_path == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 635, __pyx_L1_error)
+    __PYX_ERR(1, 634, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 635, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsWritableString(__pyx_v_b_path); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 634, __pyx_L1_error)
   __pyx_v__path = __pyx_t_2;
 
-  /* "ssh2/session.pyx":637
+  /* "ssh2/session.pyx":636
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8959,12 +13598,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":638
+        /* "ssh2/session.pyx":637
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:
  *             channel = c_ssh2.libssh2_scp_send64(             # <<<<<<<<<<<<<<
@@ -8974,7 +13614,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
         __pyx_v_channel = libssh2_scp_send64(__pyx_v_self->_session, __pyx_v__path, __pyx_v_mode, __pyx_v_size, __pyx_v_mtime, __pyx_v_atime);
       }
 
-      /* "ssh2/session.pyx":637
+      /* "ssh2/session.pyx":636
  *         cdef char *_path = b_path
  *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -8993,17 +13633,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
       }
   }
 
-  /* "ssh2/session.pyx":640
+  /* "ssh2/session.pyx":639
  *             channel = c_ssh2.libssh2_scp_send64(
  *                 self._session, _path, mode, size, mtime, atime)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  */
-  __pyx_t_3 = ((__pyx_v_channel == NULL) != 0);
+  __pyx_t_3 = (__pyx_v_channel == NULL);
   if (__pyx_t_3) {
 
-    /* "ssh2/session.pyx":641
+    /* "ssh2/session.pyx":640
  *                 self._session, _path, mode, size, mtime, atime)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
@@ -9012,29 +13652,29 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
  */
     __Pyx_XDECREF(__pyx_r);
 
-    /* "ssh2/session.pyx":642
+    /* "ssh2/session.pyx":641
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))             # <<<<<<<<<<<<<<
  *         return PyChannel(channel, self)
  * 
  */
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 641, __pyx_L1_error)
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(libssh2_session_last_errno(__pyx_v_self->_session), 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 640, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":641
+    /* "ssh2/session.pyx":640
  *                 self._session, _path, mode, size, mtime, atime)
  *         if channel is NULL:
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(             # <<<<<<<<<<<<<<
  *                 self._session))
  *         return PyChannel(channel, self)
  */
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 641, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 640, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":640
+    /* "ssh2/session.pyx":639
  *             channel = c_ssh2.libssh2_scp_send64(
  *                 self._session, _path, mode, size, mtime, atime)
  *         if channel is NULL:             # <<<<<<<<<<<<<<
@@ -9043,7 +13683,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
  */
   }
 
-  /* "ssh2/session.pyx":643
+  /* "ssh2/session.pyx":642
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session))
  *         return PyChannel(channel, self)             # <<<<<<<<<<<<<<
@@ -9051,13 +13691,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
  *     def publickey_init(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 643, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_7channel_PyChannel(__pyx_v_channel, __pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 642, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":622
+  /* "ssh2/session.pyx":621
  *         return PyChannel(channel, self)
  * 
  *     def scp_send64(self, path not None, int mode, c_ssh2.libssh2_uint64_t size,             # <<<<<<<<<<<<<<
@@ -9077,7 +13717,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":645
+/* "ssh2/session.pyx":644
  *         return PyChannel(channel, self)
  * 
  *     def publickey_init(self):             # <<<<<<<<<<<<<<
@@ -9086,12 +13726,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_64scp_send64(struct __pyx_obj_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_67publickey_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_66publickey_init[] = "Session.publickey_init(self)\nInitialise public key subsystem for managing remote server\n        public keys";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_67publickey_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_67publickey_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_66publickey_init, "Session.publickey_init(self)\nInitialise public key subsystem for managing remote server\n        public keys");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_67publickey_init = {"publickey_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_67publickey_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_66publickey_init};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_67publickey_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("publickey_init (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("publickey_init", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "publickey_init", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_66publickey_init(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -9108,9 +13776,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("publickey_init", 0);
+  __Pyx_RefNannySetupContext("publickey_init", 1);
 
-  /* "ssh2/session.pyx":649
+  /* "ssh2/session.pyx":648
  *         public keys"""
  *         cdef c_pkey.LIBSSH2_PUBLICKEY *_pkey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9120,12 +13788,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":650
+        /* "ssh2/session.pyx":649
  *         cdef c_pkey.LIBSSH2_PUBLICKEY *_pkey
  *         with nogil:
  *             _pkey = c_pkey.libssh2_publickey_init(self._session)             # <<<<<<<<<<<<<<
@@ -9135,7 +13804,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
         __pyx_v__pkey = libssh2_publickey_init(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":649
+      /* "ssh2/session.pyx":648
  *         public keys"""
  *         cdef c_pkey.LIBSSH2_PUBLICKEY *_pkey
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9154,30 +13823,30 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":651
+  /* "ssh2/session.pyx":650
  *         with nogil:
  *             _pkey = c_pkey.libssh2_publickey_init(self._session)
  *         if _pkey is NULL:             # <<<<<<<<<<<<<<
  *             raise PublicKeyInitError
  *         return PyPublicKeySystem(_pkey, self)
  */
-  __pyx_t_1 = ((__pyx_v__pkey == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__pkey == NULL);
   if (unlikely(__pyx_t_1)) {
 
-    /* "ssh2/session.pyx":652
+    /* "ssh2/session.pyx":651
  *             _pkey = c_pkey.libssh2_publickey_init(self._session)
  *         if _pkey is NULL:
  *             raise PublicKeyInitError             # <<<<<<<<<<<<<<
  *         return PyPublicKeySystem(_pkey, self)
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PublicKeyInitError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 652, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PublicKeyInitError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 651, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 652, __pyx_L1_error)
+    __PYX_ERR(1, 651, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":651
+    /* "ssh2/session.pyx":650
  *         with nogil:
  *             _pkey = c_pkey.libssh2_publickey_init(self._session)
  *         if _pkey is NULL:             # <<<<<<<<<<<<<<
@@ -9186,7 +13855,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
  */
   }
 
-  /* "ssh2/session.pyx":653
+  /* "ssh2/session.pyx":652
  *         if _pkey is NULL:
  *             raise PublicKeyInitError
  *         return PyPublicKeySystem(_pkey, self)             # <<<<<<<<<<<<<<
@@ -9194,13 +13863,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
  *     def hostkey_hash(self, int hash_type):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __pyx_f_4ssh2_9publickey_PyPublicKeySystem(__pyx_v__pkey, __pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_4ssh2_9publickey_PyPublicKeySystem(__pyx_v__pkey, __pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 652, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":645
+  /* "ssh2/session.pyx":644
  *         return PyChannel(channel, self)
  * 
  *     def publickey_init(self):             # <<<<<<<<<<<<<<
@@ -9219,7 +13888,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":655
+/* "ssh2/session.pyx":654
  *         return PyPublicKeySystem(_pkey, self)
  * 
  *     def hostkey_hash(self, int hash_type):             # <<<<<<<<<<<<<<
@@ -9228,28 +13897,98 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_66publickey_init(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_69hostkey_hash(PyObject *__pyx_v_self, PyObject *__pyx_arg_hash_type); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_68hostkey_hash[] = "Session.hostkey_hash(self, int hash_type)\nGet computed digest of the remote system's host key.\n\n        :param hash_type: One of ``ssh2.session.LIBSSH2_HOSTKEY_HASH_MD5`` or\n          ``ssh2.session.LIBSSH2_HOSTKEY_HASH_SHA1``\n        :type hash_type: int\n\n        :rtype: bytes";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_69hostkey_hash(PyObject *__pyx_v_self, PyObject *__pyx_arg_hash_type) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_69hostkey_hash(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_68hostkey_hash, "Session.hostkey_hash(self, int hash_type)\nGet computed digest of the remote system's host key.\n\n        :param hash_type: One of ``ssh2.session.LIBSSH2_HOSTKEY_HASH_MD5`` or\n          ``ssh2.session.LIBSSH2_HOSTKEY_HASH_SHA1``\n        :type hash_type: int\n\n        :rtype: bytes");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_69hostkey_hash = {"hostkey_hash", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_69hostkey_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_68hostkey_hash};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_69hostkey_hash(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_hash_type;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("hostkey_hash (wrapper)", 0);
-  assert(__pyx_arg_hash_type); {
-    __pyx_v_hash_type = __Pyx_PyInt_As_int(__pyx_arg_hash_type); if (unlikely((__pyx_v_hash_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 655, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_hash_type,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_hash_type)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 654, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "hostkey_hash") < 0)) __PYX_ERR(1, 654, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_hash_type = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_hash_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 654, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("hostkey_hash", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 654, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.hostkey_hash", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_68hostkey_hash(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((int)__pyx_v_hash_type));
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_68hostkey_hash(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_hash_type);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -9264,9 +14003,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("hostkey_hash", 0);
+  __Pyx_RefNannySetupContext("hostkey_hash", 1);
 
-  /* "ssh2/session.pyx":665
+  /* "ssh2/session.pyx":664
  *         cdef const char *_hash
  *         cdef bytes b_hash
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9276,12 +14015,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":666
+        /* "ssh2/session.pyx":665
  *         cdef bytes b_hash
  *         with nogil:
  *             _hash = c_ssh2.libssh2_hostkey_hash(self._session, hash_type)             # <<<<<<<<<<<<<<
@@ -9291,7 +14031,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
         __pyx_v__hash = libssh2_hostkey_hash(__pyx_v_self->_session, __pyx_v_hash_type);
       }
 
-      /* "ssh2/session.pyx":665
+      /* "ssh2/session.pyx":664
  *         cdef const char *_hash
  *         cdef bytes b_hash
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9310,17 +14050,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
       }
   }
 
-  /* "ssh2/session.pyx":667
+  /* "ssh2/session.pyx":666
  *         with nogil:
  *             _hash = c_ssh2.libssh2_hostkey_hash(self._session, hash_type)
  *         if _hash is NULL:             # <<<<<<<<<<<<<<
  *             return
  *         b_hash = _hash
  */
-  __pyx_t_1 = ((__pyx_v__hash == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__hash == NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":668
+    /* "ssh2/session.pyx":667
  *             _hash = c_ssh2.libssh2_hostkey_hash(self._session, hash_type)
  *         if _hash is NULL:
  *             return             # <<<<<<<<<<<<<<
@@ -9331,7 +14071,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
     __pyx_r = Py_None; __Pyx_INCREF(Py_None);
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":667
+    /* "ssh2/session.pyx":666
  *         with nogil:
  *             _hash = c_ssh2.libssh2_hostkey_hash(self._session, hash_type)
  *         if _hash is NULL:             # <<<<<<<<<<<<<<
@@ -9340,19 +14080,19 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
  */
   }
 
-  /* "ssh2/session.pyx":669
+  /* "ssh2/session.pyx":668
  *         if _hash is NULL:
  *             return
  *         b_hash = _hash             # <<<<<<<<<<<<<<
  *         return b_hash
  * 
  */
-  __pyx_t_2 = __Pyx_PyBytes_FromString(__pyx_v__hash); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 669, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_FromString(__pyx_v__hash); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 668, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_v_b_hash = ((PyObject*)__pyx_t_2);
   __pyx_t_2 = 0;
 
-  /* "ssh2/session.pyx":670
+  /* "ssh2/session.pyx":669
  *             return
  *         b_hash = _hash
  *         return b_hash             # <<<<<<<<<<<<<<
@@ -9364,7 +14104,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
   __pyx_r = __pyx_v_b_hash;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":655
+  /* "ssh2/session.pyx":654
  *         return PyPublicKeySystem(_pkey, self)
  * 
  *     def hostkey_hash(self, int hash_type):             # <<<<<<<<<<<<<<
@@ -9384,7 +14124,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":672
+/* "ssh2/session.pyx":671
  *         return b_hash
  * 
  *     def hostkey(self):             # <<<<<<<<<<<<<<
@@ -9393,12 +14133,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_68hostkey_hash(struct __pyx_ob
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_71hostkey(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_70hostkey[] = "Session.hostkey(self)\nGet server host key for this session.\n\n        Returns key, key_type tuple where key_type is one of\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_RSA`,\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_DSS`, or\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_UNKNOWN`\n\n        :rtype: tuple(bytes, int)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_71hostkey(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_71hostkey(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_70hostkey, "Session.hostkey(self)\nGet server host key for this session.\n\n        Returns key, key_type tuple where key_type is one of\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_RSA`,\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_DSS`, or\n        :py:class:`ssh2.session.LIBSSH2_HOSTKEY_TYPE_UNKNOWN`\n\n        :rtype: tuple(bytes, int)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_71hostkey = {"hostkey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_71hostkey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_70hostkey};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_71hostkey(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("hostkey (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("hostkey", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "hostkey", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_70hostkey(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -9417,22 +14185,23 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
+  unsigned int __pyx_t_5;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("hostkey", 0);
+  __Pyx_RefNannySetupContext("hostkey", 1);
 
-  /* "ssh2/session.pyx":681
+  /* "ssh2/session.pyx":680
  * 
  *         :rtype: tuple(bytes, int)"""
  *         cdef bytes key = b""             # <<<<<<<<<<<<<<
  *         cdef const char *_key
  *         cdef size_t key_len = 0
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_key = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_key = __pyx_kp_b__2;
 
-  /* "ssh2/session.pyx":683
+  /* "ssh2/session.pyx":682
  *         cdef bytes key = b""
  *         cdef const char *_key
  *         cdef size_t key_len = 0             # <<<<<<<<<<<<<<
@@ -9441,7 +14210,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
  */
   __pyx_v_key_len = 0;
 
-  /* "ssh2/session.pyx":684
+  /* "ssh2/session.pyx":683
  *         cdef const char *_key
  *         cdef size_t key_len = 0
  *         cdef int key_type = 0             # <<<<<<<<<<<<<<
@@ -9450,7 +14219,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
  */
   __pyx_v_key_type = 0;
 
-  /* "ssh2/session.pyx":685
+  /* "ssh2/session.pyx":684
  *         cdef size_t key_len = 0
  *         cdef int key_type = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9460,12 +14229,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":686
+        /* "ssh2/session.pyx":685
  *         cdef int key_type = 0
  *         with nogil:
  *             _key = c_ssh2.libssh2_session_hostkey(             # <<<<<<<<<<<<<<
@@ -9475,7 +14245,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
         __pyx_v__key = libssh2_session_hostkey(__pyx_v_self->_session, (&__pyx_v_key_len), (&__pyx_v_key_type));
       }
 
-      /* "ssh2/session.pyx":685
+      /* "ssh2/session.pyx":684
  *         cdef size_t key_len = 0
  *         cdef int key_type = 0
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9494,45 +14264,52 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
       }
   }
 
-  /* "ssh2/session.pyx":688
+  /* "ssh2/session.pyx":687
  *             _key = c_ssh2.libssh2_session_hostkey(
  *                 self._session, &key_len, &key_type)
  *         if _key is NULL:             # <<<<<<<<<<<<<<
  *             raise SessionHostKeyError(
  *                 "Error retrieving server host key for session")
  */
-  __pyx_t_1 = ((__pyx_v__key == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__key == NULL);
   if (unlikely(__pyx_t_1)) {
 
-    /* "ssh2/session.pyx":689
+    /* "ssh2/session.pyx":688
  *                 self._session, &key_len, &key_type)
  *         if _key is NULL:
  *             raise SessionHostKeyError(             # <<<<<<<<<<<<<<
  *                 "Error retrieving server host key for session")
  *         key = _key[:key_len]
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionHostKeyError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 689, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SessionHostKeyError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 688, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_4 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_3))) {
       __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
       if (likely(__pyx_t_4)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
         __Pyx_INCREF(__pyx_t_4);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_Error_retrieving_server_host_key) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_Error_retrieving_server_host_key);
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 689, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_kp_u_Error_retrieving_server_host_key};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 688, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 689, __pyx_L1_error)
+    __PYX_ERR(1, 688, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":688
+    /* "ssh2/session.pyx":687
  *             _key = c_ssh2.libssh2_session_hostkey(
  *                 self._session, &key_len, &key_type)
  *         if _key is NULL:             # <<<<<<<<<<<<<<
@@ -9541,19 +14318,19 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
  */
   }
 
-  /* "ssh2/session.pyx":691
+  /* "ssh2/session.pyx":690
  *             raise SessionHostKeyError(
  *                 "Error retrieving server host key for session")
  *         key = _key[:key_len]             # <<<<<<<<<<<<<<
  *         return key, key_type
  * 
  */
-  __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v__key + 0, __pyx_v_key_len - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 691, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(__pyx_v__key + 0, __pyx_v_key_len - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF_SET(__pyx_v_key, ((PyObject*)__pyx_t_2));
   __pyx_t_2 = 0;
 
-  /* "ssh2/session.pyx":692
+  /* "ssh2/session.pyx":691
  *                 "Error retrieving server host key for session")
  *         key = _key[:key_len]
  *         return key, key_type             # <<<<<<<<<<<<<<
@@ -9561,21 +14338,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
  *     def knownhost_init(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_key_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 692, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_key_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 691, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 692, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 691, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_INCREF(__pyx_v_key);
   __Pyx_GIVEREF(__pyx_v_key);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_key);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_key)) __PYX_ERR(1, 691, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 691, __pyx_L1_error);
   __pyx_t_2 = 0;
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":672
+  /* "ssh2/session.pyx":671
  *         return b_hash
  * 
  *     def hostkey(self):             # <<<<<<<<<<<<<<
@@ -9597,7 +14374,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":694
+/* "ssh2/session.pyx":693
  *         return key, key_type
  * 
  *     def knownhost_init(self):             # <<<<<<<<<<<<<<
@@ -9606,12 +14383,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_70hostkey(struct __pyx_obj_4ss
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_73knownhost_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_72knownhost_init[] = "Session.knownhost_init(self)\nInitialise a collection of known hosts for this session.\n\n        :rtype: :py:class:`ssh2.knownhost.KnownHost`";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_73knownhost_init(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_73knownhost_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_72knownhost_init, "Session.knownhost_init(self)\nInitialise a collection of known hosts for this session.\n\n        :rtype: :py:class:`ssh2.knownhost.KnownHost`");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_73knownhost_init = {"knownhost_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_73knownhost_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_72knownhost_init};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_73knownhost_init(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("knownhost_init (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("knownhost_init", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "knownhost_init", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_72knownhost_init(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -9628,9 +14433,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("knownhost_init", 0);
+  __Pyx_RefNannySetupContext("knownhost_init", 1);
 
-  /* "ssh2/session.pyx":699
+  /* "ssh2/session.pyx":698
  *         :rtype: :py:class:`ssh2.knownhost.KnownHost`"""
  *         cdef c_ssh2.LIBSSH2_KNOWNHOSTS *known_hosts
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9640,12 +14445,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":700
+        /* "ssh2/session.pyx":699
  *         cdef c_ssh2.LIBSSH2_KNOWNHOSTS *known_hosts
  *         with nogil:
  *             known_hosts = c_ssh2.libssh2_knownhost_init(             # <<<<<<<<<<<<<<
@@ -9655,7 +14461,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
         __pyx_v_known_hosts = libssh2_knownhost_init(__pyx_v_self->_session);
       }
 
-      /* "ssh2/session.pyx":699
+      /* "ssh2/session.pyx":698
  *         :rtype: :py:class:`ssh2.knownhost.KnownHost`"""
  *         cdef c_ssh2.LIBSSH2_KNOWNHOSTS *known_hosts
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9674,30 +14480,30 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":702
+  /* "ssh2/session.pyx":701
  *             known_hosts = c_ssh2.libssh2_knownhost_init(
  *                 self._session)
  *         if known_hosts is NULL:             # <<<<<<<<<<<<<<
  *             raise KnownHostError
  *         return PyKnownHost(self, known_hosts)
  */
-  __pyx_t_1 = ((__pyx_v_known_hosts == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_known_hosts == NULL);
   if (unlikely(__pyx_t_1)) {
 
-    /* "ssh2/session.pyx":703
+    /* "ssh2/session.pyx":702
  *                 self._session)
  *         if known_hosts is NULL:
  *             raise KnownHostError             # <<<<<<<<<<<<<<
  *         return PyKnownHost(self, known_hosts)
  * 
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 703, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 702, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_Raise(__pyx_t_2, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(1, 703, __pyx_L1_error)
+    __PYX_ERR(1, 702, __pyx_L1_error)
 
-    /* "ssh2/session.pyx":702
+    /* "ssh2/session.pyx":701
  *             known_hosts = c_ssh2.libssh2_knownhost_init(
  *                 self._session)
  *         if known_hosts is NULL:             # <<<<<<<<<<<<<<
@@ -9706,7 +14512,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
  */
   }
 
-  /* "ssh2/session.pyx":704
+  /* "ssh2/session.pyx":703
  *         if known_hosts is NULL:
  *             raise KnownHostError
  *         return PyKnownHost(self, known_hosts)             # <<<<<<<<<<<<<<
@@ -9714,13 +14520,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
  *     def keepalive_config(self, bint want_reply, unsigned interval):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyKnownHost(__pyx_v_self, __pyx_v_known_hosts)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 704, __pyx_L1_error)
+  __pyx_t_2 = ((PyObject *)__pyx_f_4ssh2_9knownhost_PyKnownHost(__pyx_v_self, __pyx_v_known_hosts)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 703, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":694
+  /* "ssh2/session.pyx":693
  *         return key, key_type
  * 
  *     def knownhost_init(self):             # <<<<<<<<<<<<<<
@@ -9739,7 +14545,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":706
+/* "ssh2/session.pyx":705
  *         return PyKnownHost(self, known_hosts)
  * 
  *     def keepalive_config(self, bint want_reply, unsigned interval):             # <<<<<<<<<<<<<<
@@ -9748,59 +14554,100 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_72knownhost_init(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_74keepalive_config[] = "Session.keepalive_config(self, bool want_reply, unsigned int interval)\n\n        Configure keep alive settings.\n\n        :param want_reply: True/False for reply wanted from server on keep\n          alive messages being sent or not.\n        :type want_reply: bool\n        :param interval: Required keep alive interval. Set to ``0`` to disable\n          keepalives.\n        :type interval: int";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_74keepalive_config, "Session.keepalive_config(self, bool want_reply, unsigned int interval)\n\n        Configure keep alive settings.\n\n        :param want_reply: True/False for reply wanted from server on keep\n          alive messages being sent or not.\n        :type want_reply: bool\n        :param interval: Required keep alive interval. Set to ``0`` to disable\n          keepalives.\n        :type interval: int");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_75keepalive_config = {"keepalive_config", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_75keepalive_config, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_74keepalive_config};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_want_reply;
   unsigned int __pyx_v_interval;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("keepalive_config (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_want_reply,&__pyx_n_s_interval,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_want_reply,&__pyx_n_s_interval,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_want_reply)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_want_reply)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 705, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_interval)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 705, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("keepalive_config", 1, 2, 2, 1); __PYX_ERR(1, 706, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("keepalive_config", 1, 2, 2, 1); __PYX_ERR(1, 705, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "keepalive_config") < 0)) __PYX_ERR(1, 706, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "keepalive_config") < 0)) __PYX_ERR(1, 705, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    __pyx_v_want_reply = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_want_reply == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 706, __pyx_L3_error)
-    __pyx_v_interval = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_interval == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(1, 706, __pyx_L3_error)
+    __pyx_v_want_reply = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_want_reply == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 705, __pyx_L3_error)
+    __pyx_v_interval = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_interval == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(1, 705, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("keepalive_config", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 706, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("keepalive_config", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 705, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.keepalive_config", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -9808,6 +14655,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *_
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_74keepalive_config(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_want_reply, __pyx_v_interval);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -9815,9 +14668,9 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_75keepalive_config(PyObject *_
 static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self, int __pyx_v_want_reply, unsigned int __pyx_v_interval) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("keepalive_config", 0);
+  __Pyx_RefNannySetupContext("keepalive_config", 1);
 
-  /* "ssh2/session.pyx":716
+  /* "ssh2/session.pyx":715
  *           keepalives.
  *         :type interval: int"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9827,12 +14680,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __py
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":717
+        /* "ssh2/session.pyx":716
  *         :type interval: int"""
  *         with nogil:
  *             c_ssh2.libssh2_keepalive_config(self._session, want_reply, interval)             # <<<<<<<<<<<<<<
@@ -9842,7 +14696,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __py
         libssh2_keepalive_config(__pyx_v_self->_session, __pyx_v_want_reply, __pyx_v_interval);
       }
 
-      /* "ssh2/session.pyx":716
+      /* "ssh2/session.pyx":715
  *           keepalives.
  *         :type interval: int"""
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9861,7 +14715,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __py
       }
   }
 
-  /* "ssh2/session.pyx":706
+  /* "ssh2/session.pyx":705
  *         return PyKnownHost(self, known_hosts)
  * 
  *     def keepalive_config(self, bint want_reply, unsigned interval):             # <<<<<<<<<<<<<<
@@ -9876,7 +14730,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __py
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":719
+/* "ssh2/session.pyx":718
  *             c_ssh2.libssh2_keepalive_config(self._session, want_reply, interval)
  * 
  *     def keepalive_send(self):             # <<<<<<<<<<<<<<
@@ -9885,12 +14739,40 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_74keepalive_config(struct __py
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_77keepalive_send(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_76keepalive_send[] = "Session.keepalive_send(self)\nSend keepalive.\n\n        Returns seconds remaining before next keep alive should be sent.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_77keepalive_send(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_77keepalive_send(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_76keepalive_send, "Session.keepalive_send(self)\nSend keepalive.\n\n        Returns seconds remaining before next keep alive should be sent.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_77keepalive_send = {"keepalive_send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_77keepalive_send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_76keepalive_send};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_77keepalive_send(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("keepalive_send (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("keepalive_send", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "keepalive_send", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_76keepalive_send(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -9909,9 +14791,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("keepalive_send", 0);
+  __Pyx_RefNannySetupContext("keepalive_send", 1);
 
-  /* "ssh2/session.pyx":725
+  /* "ssh2/session.pyx":724
  * 
  *         :rtype: int"""
  *         cdef int seconds = 0             # <<<<<<<<<<<<<<
@@ -9920,7 +14802,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
  */
   __pyx_v_seconds = 0;
 
-  /* "ssh2/session.pyx":726
+  /* "ssh2/session.pyx":725
  *         :rtype: int"""
  *         cdef int seconds = 0
  *         cdef int c_seconds = 0             # <<<<<<<<<<<<<<
@@ -9929,7 +14811,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
  */
   __pyx_v_c_seconds = 0;
 
-  /* "ssh2/session.pyx":728
+  /* "ssh2/session.pyx":727
  *         cdef int c_seconds = 0
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9939,12 +14821,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":729
+        /* "ssh2/session.pyx":728
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_keepalive_send(self._session, &c_seconds)             # <<<<<<<<<<<<<<
@@ -9954,7 +14837,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
         __pyx_v_rc = libssh2_keepalive_send(__pyx_v_self->_session, (&__pyx_v_c_seconds));
       }
 
-      /* "ssh2/session.pyx":728
+      /* "ssh2/session.pyx":727
  *         cdef int c_seconds = 0
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -9973,16 +14856,16 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":730
+  /* "ssh2/session.pyx":729
  *         with nogil:
  *             rc = c_ssh2.libssh2_keepalive_send(self._session, &c_seconds)
  *         handle_error_codes(rc)             # <<<<<<<<<<<<<<
  *         return c_seconds
  * 
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 730, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 729, __pyx_L1_error)
 
-  /* "ssh2/session.pyx":731
+  /* "ssh2/session.pyx":730
  *             rc = c_ssh2.libssh2_keepalive_send(self._session, &c_seconds)
  *         handle_error_codes(rc)
  *         return c_seconds             # <<<<<<<<<<<<<<
@@ -9990,13 +14873,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
  *     def supported_algs(self, MethodType method_type):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_c_seconds); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 731, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_c_seconds); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 730, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":719
+  /* "ssh2/session.pyx":718
  *             c_ssh2.libssh2_keepalive_config(self._session, want_reply, interval)
  * 
  *     def keepalive_send(self):             # <<<<<<<<<<<<<<
@@ -10015,7 +14898,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":733
+/* "ssh2/session.pyx":732
  *         return c_seconds
  * 
  *     def supported_algs(self, MethodType method_type):             # <<<<<<<<<<<<<<
@@ -10024,23 +14907,103 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_76keepalive_send(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_79supported_algs(PyObject *__pyx_v_self, PyObject *__pyx_v_method_type); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_78supported_algs[] = "Session.supported_algs(self, MethodType method_type)\nGet supportd algorithms for method type.\n\n        :param method_type: Type of method to get\n        :type method_type: :py:class:`MethodType`\n\n        :returns: List of supported algorithms.\n        :rtype: list(str)\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_79supported_algs(PyObject *__pyx_v_self, PyObject *__pyx_v_method_type) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_79supported_algs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_78supported_algs, "Session.supported_algs(self, MethodType method_type)\nGet supportd algorithms for method type.\n\n        :param method_type: Type of method to get\n        :type method_type: :py:class:`MethodType`\n\n        :returns: List of supported algorithms.\n        :rtype: list(str)\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_79supported_algs = {"supported_algs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_79supported_algs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_78supported_algs};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_79supported_algs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_method_type = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("supported_algs (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 733, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_78supported_algs(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_method_type));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method_type,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_method_type)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 732, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "supported_algs") < 0)) __PYX_ERR(1, 732, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_method_type = ((struct __pyx_obj_4ssh2_7session_MethodType *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("supported_algs", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 732, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.supported_algs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 732, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_78supported_algs(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_method_type);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -10049,7 +15012,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
   char const **__pyx_v_c_algs;
   int __pyx_v_rc;
   PyObject *__pyx_v_algs = NULL;
-  int __pyx_v_i;
+  int __pyx_7genexpr__pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
@@ -10068,9 +15031,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("supported_algs", 0);
+  __Pyx_RefNannySetupContext("supported_algs", 1);
 
-  /* "ssh2/session.pyx":744
+  /* "ssh2/session.pyx":743
  *         cdef const char **c_algs
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -10080,12 +15043,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":745
+        /* "ssh2/session.pyx":744
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_supported_algs(             # <<<<<<<<<<<<<<
@@ -10095,7 +15059,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
         __pyx_v_rc = libssh2_session_supported_algs(__pyx_v_self->_session, __pyx_v_method_type->value, (&__pyx_v_c_algs));
       }
 
-      /* "ssh2/session.pyx":744
+      /* "ssh2/session.pyx":743
  *         cdef const char **c_algs
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -10114,17 +15078,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
       }
   }
 
-  /* "ssh2/session.pyx":747
+  /* "ssh2/session.pyx":746
  *             rc = c_ssh2.libssh2_session_supported_algs(
  *                 self._session, method_type.value, &c_algs)
  *         if rc < 0:             # <<<<<<<<<<<<<<
  *             return handle_error_codes(rc)
  *         elif rc == 0:
  */
-  __pyx_t_1 = ((__pyx_v_rc < 0) != 0);
+  __pyx_t_1 = (__pyx_v_rc < 0);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":748
+    /* "ssh2/session.pyx":747
  *                 self._session, method_type.value, &c_algs)
  *         if rc < 0:
  *             return handle_error_codes(rc)             # <<<<<<<<<<<<<<
@@ -10132,14 +15096,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  *             return []
  */
     __Pyx_XDECREF(__pyx_r);
-    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 748, __pyx_L1_error)
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error)
+    __pyx_t_2 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 747, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 747, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":747
+    /* "ssh2/session.pyx":746
  *             rc = c_ssh2.libssh2_session_supported_algs(
  *                 self._session, method_type.value, &c_algs)
  *         if rc < 0:             # <<<<<<<<<<<<<<
@@ -10148,17 +15112,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  */
   }
 
-  /* "ssh2/session.pyx":749
+  /* "ssh2/session.pyx":748
  *         if rc < 0:
  *             return handle_error_codes(rc)
  *         elif rc == 0:             # <<<<<<<<<<<<<<
  *             return []
  *         try:
  */
-  __pyx_t_1 = ((__pyx_v_rc == 0) != 0);
+  __pyx_t_1 = (__pyx_v_rc == 0);
   if (__pyx_t_1) {
 
-    /* "ssh2/session.pyx":750
+    /* "ssh2/session.pyx":749
  *             return handle_error_codes(rc)
  *         elif rc == 0:
  *             return []             # <<<<<<<<<<<<<<
@@ -10166,13 +15130,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  *             algs = [to_str(c_algs[i]) for i in range(rc)]
  */
     __Pyx_XDECREF(__pyx_r);
-    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 750, __pyx_L1_error)
+    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 749, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_r = __pyx_t_3;
     __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "ssh2/session.pyx":749
+    /* "ssh2/session.pyx":748
  *         if rc < 0:
  *             return handle_error_codes(rc)
  *         elif rc == 0:             # <<<<<<<<<<<<<<
@@ -10181,7 +15145,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  */
   }
 
-  /* "ssh2/session.pyx":751
+  /* "ssh2/session.pyx":750
  *         elif rc == 0:
  *             return []
  *         try:             # <<<<<<<<<<<<<<
@@ -10190,29 +15154,31 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  */
   /*try:*/ {
 
-    /* "ssh2/session.pyx":752
+    /* "ssh2/session.pyx":751
  *             return []
  *         try:
  *             algs = [to_str(c_algs[i]) for i in range(rc)]             # <<<<<<<<<<<<<<
  *         finally:
  *             with nogil:
  */
-    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 752, __pyx_L8_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_2 = __pyx_v_rc;
-    __pyx_t_4 = __pyx_t_2;
-    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-      __pyx_v_i = __pyx_t_5;
-      __pyx_t_6 = __pyx_f_4ssh2_5utils_to_str((__pyx_v_c_algs[__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 752, __pyx_L8_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 752, __pyx_L8_error)
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    }
+    { /* enter inner scope */
+      __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 751, __pyx_L8_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_2 = __pyx_v_rc;
+      __pyx_t_4 = __pyx_t_2;
+      for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+        __pyx_7genexpr__pyx_v_i = __pyx_t_5;
+        __pyx_t_6 = __pyx_f_4ssh2_5utils_to_str((__pyx_v_c_algs[__pyx_7genexpr__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 751, __pyx_L8_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 751, __pyx_L8_error)
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      }
+    } /* exit inner scope */
     __pyx_v_algs = ((PyObject*)__pyx_t_3);
     __pyx_t_3 = 0;
   }
 
-  /* "ssh2/session.pyx":754
+  /* "ssh2/session.pyx":753
  *             algs = [to_str(c_algs[i]) for i in range(rc)]
  *         finally:
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -10224,12 +15190,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
       {
           #ifdef WITH_THREAD
           PyThreadState *_save;
+          _save = NULL;
           Py_UNBLOCK_THREADS
           __Pyx_FastGIL_Remember();
           #endif
           /*try:*/ {
 
-            /* "ssh2/session.pyx":755
+            /* "ssh2/session.pyx":754
  *         finally:
  *             with nogil:
  *                 c_ssh2.libssh2_free(self._session, c_algs)             # <<<<<<<<<<<<<<
@@ -10239,7 +15206,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
             libssh2_free(__pyx_v_self->_session, __pyx_v_c_algs);
           }
 
-          /* "ssh2/session.pyx":754
+          /* "ssh2/session.pyx":753
  *             algs = [to_str(c_algs[i]) for i in range(rc)]
  *         finally:
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -10279,12 +15246,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
         {
             #ifdef WITH_THREAD
             PyThreadState *_save;
+            _save = NULL;
             Py_UNBLOCK_THREADS
             __Pyx_FastGIL_Remember();
             #endif
             /*try:*/ {
 
-              /* "ssh2/session.pyx":755
+              /* "ssh2/session.pyx":754
  *         finally:
  *             with nogil:
  *                 c_ssh2.libssh2_free(self._session, c_algs)             # <<<<<<<<<<<<<<
@@ -10294,7 +15262,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
               libssh2_free(__pyx_v_self->_session, __pyx_v_c_algs);
             }
 
-            /* "ssh2/session.pyx":754
+            /* "ssh2/session.pyx":753
  *             algs = [to_str(c_algs[i]) for i in range(rc)]
  *         finally:
  *             with nogil:             # <<<<<<<<<<<<<<
@@ -10330,7 +15298,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
     __pyx_L9:;
   }
 
-  /* "ssh2/session.pyx":756
+  /* "ssh2/session.pyx":755
  *             with nogil:
  *                 c_ssh2.libssh2_free(self._session, c_algs)
  *         return algs             # <<<<<<<<<<<<<<
@@ -10342,7 +15310,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
   __pyx_r = __pyx_v_algs;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":733
+  /* "ssh2/session.pyx":732
  *         return c_seconds
  * 
  *     def supported_algs(self, MethodType method_type):             # <<<<<<<<<<<<<<
@@ -10363,7 +15331,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":758
+/* "ssh2/session.pyx":757
  *         return algs
  * 
  *     def methods(self, MethodType method_type):             # <<<<<<<<<<<<<<
@@ -10372,23 +15340,103 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_78supported_algs(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_81methods(PyObject *__pyx_v_self, PyObject *__pyx_v_method_type); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_80methods[] = "Session.methods(self, MethodType method_type)\nGet currently active algorithms for method type.\n\n        :param method_type: Type of method to get\n        :type method_type: :py:class:`MethodType`\n\n        :rtype: str\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_81methods(PyObject *__pyx_v_self, PyObject *__pyx_v_method_type) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_81methods(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_80methods, "Session.methods(self, MethodType method_type)\nGet currently active algorithms for method type.\n\n        :param method_type: Type of method to get\n        :type method_type: :py:class:`MethodType`\n\n        :rtype: str\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_81methods = {"methods", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_81methods, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_80methods};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_81methods(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_method_type = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("methods (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 758, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_80methods(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((struct __pyx_obj_4ssh2_7session_MethodType *)__pyx_v_method_type));
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method_type,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_method_type)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 757, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "methods") < 0)) __PYX_ERR(1, 757, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_method_type = ((struct __pyx_obj_4ssh2_7session_MethodType *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("methods", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 757, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.methods", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 757, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_80methods(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_method_type);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -10397,15 +15445,48 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
   char const *__pyx_v_methods;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("methods", 0);
+  __Pyx_RefNannySetupContext("methods", 1);
+
+  /* "ssh2/session.pyx":765
+ *         :rtype: str
+ *         """
+ *         if not self.sock:             # <<<<<<<<<<<<<<
+ *             return
+ *         with nogil:
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->sock); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 765, __pyx_L1_error)
+  __pyx_t_2 = (!__pyx_t_1);
+  if (__pyx_t_2) {
+
+    /* "ssh2/session.pyx":766
+ *         """
+ *         if not self.sock:
+ *             return             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             methods = c_ssh2.libssh2_session_methods(
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
 
-  /* "ssh2/session.pyx":766
+    /* "ssh2/session.pyx":765
  *         :rtype: str
  *         """
+ *         if not self.sock:             # <<<<<<<<<<<<<<
+ *             return
+ *         with nogil:
+ */
+  }
+
+  /* "ssh2/session.pyx":767
+ *         if not self.sock:
+ *             return
  *         with nogil:             # <<<<<<<<<<<<<<
  *             methods = c_ssh2.libssh2_session_methods(
  *                 self._session, method_type.value)
@@ -10413,13 +15494,14 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":767
- *         """
+        /* "ssh2/session.pyx":768
+ *             return
  *         with nogil:
  *             methods = c_ssh2.libssh2_session_methods(             # <<<<<<<<<<<<<<
  *                 self._session, method_type.value)
@@ -10428,9 +15510,9 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
         __pyx_v_methods = libssh2_session_methods(__pyx_v_self->_session, __pyx_v_method_type->value);
       }
 
-      /* "ssh2/session.pyx":766
- *         :rtype: str
- *         """
+      /* "ssh2/session.pyx":767
+ *         if not self.sock:
+ *             return
  *         with nogil:             # <<<<<<<<<<<<<<
  *             methods = c_ssh2.libssh2_session_methods(
  *                 self._session, method_type.value)
@@ -10441,13 +15523,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
           __Pyx_FastGIL_Forget();
           Py_BLOCK_THREADS
           #endif
-          goto __pyx_L5;
+          goto __pyx_L6;
         }
-        __pyx_L5:;
+        __pyx_L6:;
       }
   }
 
-  /* "ssh2/session.pyx":769
+  /* "ssh2/session.pyx":770
  *             methods = c_ssh2.libssh2_session_methods(
  *                 self._session, method_type.value)
  *         return to_str(methods)             # <<<<<<<<<<<<<<
@@ -10455,13 +15537,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
  *     def method_pref(self, MethodType method_type, prefs not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_str(__pyx_v_methods); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 769, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_to_str(__pyx_v_methods); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":758
+  /* "ssh2/session.pyx":757
  *         return algs
  * 
  *     def methods(self, MethodType method_type):             # <<<<<<<<<<<<<<
@@ -10471,7 +15553,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
   __Pyx_AddTraceback("ssh2.session.Session.methods", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -10480,7 +15562,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
   return __pyx_r;
 }
 
-/* "ssh2/session.pyx":771
+/* "ssh2/session.pyx":772
  *         return to_str(methods)
  * 
  *     def method_pref(self, MethodType method_type, prefs not None):             # <<<<<<<<<<<<<<
@@ -10489,66 +15571,107 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_80methods(struct __pyx_obj_4ss
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_83method_pref(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_82method_pref[] = "Session.method_pref(self, MethodType method_type, prefs)\nSet preference for session method.\n\n        See :py:func:`Session.supported_algs` for supported algorithms\n        for method type.\n\n        :param method_type: A supported session method LIBSSH2_METHOD_*\n        :type method_type: :py:class:`MethodType`\n        :param prefs: Algorithm preference for method type provided.\n        :type prefs: str\n\n        :rtype: int\n        :raises: :py:class:`ssh2.exceptions.MethodNotSupported`\n          on unsupported method preference\n        ";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_83method_pref(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_83method_pref(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_82method_pref, "Session.method_pref(self, MethodType method_type, prefs)\nSet preference for session method.\n\n        See :py:func:`Session.supported_algs` for supported algorithms\n        for method type.\n\n        :param method_type: A supported session method LIBSSH2_METHOD_*\n        :type method_type: :py:class:`MethodType`\n        :param prefs: Algorithm preference for method type provided.\n        :type prefs: str\n\n        :rtype: int\n        :raises: :py:class:`ssh2.exceptions.MethodNotSupported`\n          on unsupported method preference\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_83method_pref = {"method_pref", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_83method_pref, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_82method_pref};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_83method_pref(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   struct __pyx_obj_4ssh2_7session_MethodType *__pyx_v_method_type = 0;
   PyObject *__pyx_v_prefs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("method_pref (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method_type,&__pyx_n_s_prefs,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method_type,&__pyx_n_s_prefs,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method_type)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_method_type)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 772, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefs)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_prefs)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 772, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("method_pref", 1, 2, 2, 1); __PYX_ERR(1, 771, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("method_pref", 1, 2, 2, 1); __PYX_ERR(1, 772, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "method_pref") < 0)) __PYX_ERR(1, 771, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "method_pref") < 0)) __PYX_ERR(1, 772, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_method_type = ((struct __pyx_obj_4ssh2_7session_MethodType *)values[0]);
     __pyx_v_prefs = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("method_pref", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 771, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("method_pref", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 772, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.session.Session.method_pref", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 771, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_method_type), __pyx_ptype_4ssh2_7session_MethodType, 1, "method_type", 0))) __PYX_ERR(1, 772, __pyx_L1_error)
   if (unlikely(((PyObject *)__pyx_v_prefs) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "prefs"); __PYX_ERR(1, 771, __pyx_L1_error)
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "prefs"); __PYX_ERR(1, 772, __pyx_L1_error)
   }
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_82method_pref(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v_method_type, __pyx_v_prefs);
 
@@ -10557,6 +15680,12 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_83method_pref(PyObject *__pyx_
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -10573,21 +15702,21 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("method_pref", 0);
+  __Pyx_RefNannySetupContext("method_pref", 1);
 
-  /* "ssh2/session.pyx":786
+  /* "ssh2/session.pyx":787
  *           on unsupported method preference
  *         """
  *         cdef bytes b_prefs = to_bytes(prefs)             # <<<<<<<<<<<<<<
  *         cdef const char *c_prefs = b_prefs
  *         cdef int rc
  */
-  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_prefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 786, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4ssh2_5utils_to_bytes(__pyx_v_prefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 787, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_b_prefs = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "ssh2/session.pyx":787
+  /* "ssh2/session.pyx":788
  *         """
  *         cdef bytes b_prefs = to_bytes(prefs)
  *         cdef const char *c_prefs = b_prefs             # <<<<<<<<<<<<<<
@@ -10596,12 +15725,12 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
  */
   if (unlikely(__pyx_v_b_prefs == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found");
-    __PYX_ERR(1, 787, __pyx_L1_error)
+    __PYX_ERR(1, 788, __pyx_L1_error)
   }
-  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_prefs); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 787, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_AsString(__pyx_v_b_prefs); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 788, __pyx_L1_error)
   __pyx_v_c_prefs = __pyx_t_2;
 
-  /* "ssh2/session.pyx":789
+  /* "ssh2/session.pyx":790
  *         cdef const char *c_prefs = b_prefs
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -10611,12 +15740,13 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
       /*try:*/ {
 
-        /* "ssh2/session.pyx":790
+        /* "ssh2/session.pyx":791
  *         cdef int rc
  *         with nogil:
  *             rc = c_ssh2.libssh2_session_method_pref(             # <<<<<<<<<<<<<<
@@ -10626,7 +15756,7 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
         __pyx_v_rc = libssh2_session_method_pref(__pyx_v_self->_session, __pyx_v_method_type->value, __pyx_v_c_prefs);
       }
 
-      /* "ssh2/session.pyx":789
+      /* "ssh2/session.pyx":790
  *         cdef const char *c_prefs = b_prefs
  *         cdef int rc
  *         with nogil:             # <<<<<<<<<<<<<<
@@ -10645,27 +15775,27 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
       }
   }
 
-  /* "ssh2/session.pyx":792
+  /* "ssh2/session.pyx":793
  *             rc = c_ssh2.libssh2_session_method_pref(
  *                 self._session, method_type.value, c_prefs)
  *         handle_error_codes(rc)             # <<<<<<<<<<<<<<
  *         return rc
  */
-  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 792, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 793, __pyx_L1_error)
 
-  /* "ssh2/session.pyx":793
+  /* "ssh2/session.pyx":794
  *                 self._session, method_type.value, c_prefs)
  *         handle_error_codes(rc)
  *         return rc             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 793, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rc); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 794, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/session.pyx":771
+  /* "ssh2/session.pyx":772
  *         return to_str(methods)
  * 
  *     def method_pref(self, MethodType method_type, prefs not None):             # <<<<<<<<<<<<<<
@@ -10696,9 +15826,11 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_82method_pref(struct __pyx_obj
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_7session_7Session_4sock_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_7session_7Session_4sock_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_4sock___get__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -10709,7 +15841,7 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_4sock_1__get__(PyObject *__pyx
 static PyObject *__pyx_pf_4ssh2_7session_7Session_4sock___get__(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
   __Pyx_XDECREF(__pyx_r);
   __Pyx_INCREF(__pyx_v_self->sock);
   __pyx_r = __pyx_v_self->sock;
@@ -10733,9 +15865,11 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_4sock___get__(struct __pyx_obj
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_7session_7Session_13_kbd_callback_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_7session_7Session_13_kbd_callback_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_13_kbd_callback___get__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -10746,7 +15880,7 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_13_kbd_callback_1__get__(PyObj
 static PyObject *__pyx_pf_4ssh2_7session_7Session_13_kbd_callback___get__(struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
   __Pyx_XDECREF(__pyx_r);
   __Pyx_INCREF(__pyx_v_self->_kbd_callback);
   __pyx_r = __pyx_v_self->_kbd_callback;
@@ -10761,17 +15895,45 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_13_kbd_callback___get__(struct
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_84__reduce_cython__[] = "Session.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_84__reduce_cython__, "Session.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_85__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_84__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_7session_7Session_84__reduce_cython__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self));
 
   /* function exit code */
@@ -10782,33 +15944,28 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__(PyObject *
 static PyObject *__pyx_pf_4ssh2_7session_7Session_84__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.session.Session.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -10818,21 +15975,104 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_84__reduce_cython__(CYTHON_UNU
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_7session_7Session_86__setstate_cython__[] = "Session.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_7session_7Session_86__setstate_cython__, "Session.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_7session_7Session_87__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_86__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_7session_7Session_86__setstate_cython__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.session.Session.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_7session_7Session_86__setstate_cython__(((struct __pyx_obj_4ssh2_7session_Session *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -10840,33 +16080,28 @@ static PyObject *__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__(PyObject
 static PyObject *__pyx_pf_4ssh2_7session_7Session_86__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_7session_Session *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(0, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.session.Session.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -10877,12 +16112,17 @@ static PyObject *__pyx_pf_4ssh2_7session_7Session_86__setstate_cython__(CYTHON_U
 static PyObject *__pyx_tp_new_4ssh2_7session_Session(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   struct __pyx_obj_4ssh2_7session_Session *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_7session_Session *)o);
   p->sock = Py_None; Py_INCREF(Py_None);
   p->_kbd_callback = Py_None; Py_INCREF(Py_None);
@@ -10896,8 +16136,10 @@ static PyObject *__pyx_tp_new_4ssh2_7session_Session(PyTypeObject *t, CYTHON_UNU
 static void __pyx_tp_dealloc_4ssh2_7session_Session(PyObject *o) {
   struct __pyx_obj_4ssh2_7session_Session *p = (struct __pyx_obj_4ssh2_7session_Session *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_7session_Session) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -10911,7 +16153,14 @@ static void __pyx_tp_dealloc_4ssh2_7session_Session(PyObject *o) {
   }
   Py_CLEAR(p->sock);
   Py_CLEAR(p->_kbd_callback);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_7session_Session(PyObject *o, visitproc v, void *a) {
@@ -10947,48 +16196,48 @@ static PyObject *__pyx_getprop_4ssh2_7session_7Session__kbd_callback(PyObject *o
 }
 
 static PyMethodDef __pyx_methods_4ssh2_7session_Session[] = {
-  {"disconnect", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_5disconnect, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_4disconnect},
-  {"handshake", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_7handshake, METH_O, __pyx_doc_4ssh2_7session_7Session_6handshake},
-  {"startup", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_9startup, METH_O, __pyx_doc_4ssh2_7session_7Session_8startup},
-  {"set_blocking", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_11set_blocking, METH_O, __pyx_doc_4ssh2_7session_7Session_10set_blocking},
-  {"get_blocking", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_13get_blocking, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_12get_blocking},
-  {"set_timeout", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_15set_timeout, METH_O, __pyx_doc_4ssh2_7session_7Session_14set_timeout},
-  {"get_timeout", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_17get_timeout, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_16get_timeout},
-  {"userauth_authenticated", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_18userauth_authenticated},
-  {"userauth_list", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_21userauth_list, METH_O, __pyx_doc_4ssh2_7session_7Session_20userauth_list},
-  {"userauth_publickey_fromfile", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_22userauth_publickey_fromfile},
-  {"userauth_publickey", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_25userauth_publickey, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_24userauth_publickey},
-  {"userauth_hostbased_fromfile", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_26userauth_hostbased_fromfile},
-  {"userauth_publickey_frommemory", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_28userauth_publickey_frommemory},
-  {"userauth_password", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_31userauth_password, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_30userauth_password},
-  {"userauth_keyboardinteractive", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_32userauth_keyboardinteractive},
-  {"agent_init", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_35agent_init, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_34agent_init},
-  {"agent_auth", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_37agent_auth, METH_O, __pyx_doc_4ssh2_7session_7Session_36agent_auth},
-  {"open_session", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_39open_session, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_38open_session},
-  {"direct_tcpip_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_40direct_tcpip_ex},
-  {"direct_tcpip", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_43direct_tcpip, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_42direct_tcpip},
-  {"block_directions", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_45block_directions, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_44block_directions},
-  {"forward_listen", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_47forward_listen, METH_O, __pyx_doc_4ssh2_7session_7Session_46forward_listen},
-  {"forward_listen_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_48forward_listen_ex},
-  {"sftp_init", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_51sftp_init, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_50sftp_init},
-  {"last_error", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_53last_error, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_52last_error},
-  {"last_errno", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_55last_errno, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_54last_errno},
-  {"set_last_error", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_57set_last_error, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_56set_last_error},
-  {"scp_recv", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_59scp_recv, METH_O, __pyx_doc_4ssh2_7session_7Session_58scp_recv},
-  {"scp_recv2", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_61scp_recv2, METH_O, __pyx_doc_4ssh2_7session_7Session_60scp_recv2},
-  {"scp_send", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_63scp_send, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_62scp_send},
-  {"scp_send64", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_65scp_send64, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_64scp_send64},
-  {"publickey_init", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_67publickey_init, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_66publickey_init},
-  {"hostkey_hash", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_69hostkey_hash, METH_O, __pyx_doc_4ssh2_7session_7Session_68hostkey_hash},
-  {"hostkey", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_71hostkey, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_70hostkey},
-  {"knownhost_init", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_73knownhost_init, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_72knownhost_init},
-  {"keepalive_config", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_75keepalive_config, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_74keepalive_config},
-  {"keepalive_send", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_77keepalive_send, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_76keepalive_send},
-  {"supported_algs", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_79supported_algs, METH_O, __pyx_doc_4ssh2_7session_7Session_78supported_algs},
-  {"methods", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_81methods, METH_O, __pyx_doc_4ssh2_7session_7Session_80methods},
-  {"method_pref", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_7session_7Session_83method_pref, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_82method_pref},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_7session_7Session_84__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__, METH_O, __pyx_doc_4ssh2_7session_7Session_86__setstate_cython__},
+  {"disconnect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_5disconnect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_4disconnect},
+  {"handshake", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_7handshake, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_6handshake},
+  {"startup", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_9startup, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_8startup},
+  {"set_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_11set_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_10set_blocking},
+  {"get_blocking", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_13get_blocking, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_12get_blocking},
+  {"set_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_15set_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_14set_timeout},
+  {"get_timeout", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_17get_timeout, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_16get_timeout},
+  {"userauth_authenticated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_19userauth_authenticated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_18userauth_authenticated},
+  {"userauth_list", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_21userauth_list, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_20userauth_list},
+  {"userauth_publickey_fromfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_23userauth_publickey_fromfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_22userauth_publickey_fromfile},
+  {"userauth_publickey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_25userauth_publickey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_24userauth_publickey},
+  {"userauth_hostbased_fromfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_27userauth_hostbased_fromfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_26userauth_hostbased_fromfile},
+  {"userauth_publickey_frommemory", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_29userauth_publickey_frommemory, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_28userauth_publickey_frommemory},
+  {"userauth_password", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_31userauth_password, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_30userauth_password},
+  {"userauth_keyboardinteractive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_33userauth_keyboardinteractive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_32userauth_keyboardinteractive},
+  {"agent_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_35agent_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_34agent_init},
+  {"agent_auth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_37agent_auth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_36agent_auth},
+  {"open_session", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_39open_session, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_38open_session},
+  {"direct_tcpip_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_41direct_tcpip_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_40direct_tcpip_ex},
+  {"direct_tcpip", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_43direct_tcpip, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_42direct_tcpip},
+  {"block_directions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_45block_directions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_44block_directions},
+  {"forward_listen", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_47forward_listen, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_46forward_listen},
+  {"forward_listen_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_49forward_listen_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_48forward_listen_ex},
+  {"sftp_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_51sftp_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_50sftp_init},
+  {"last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_53last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_52last_error},
+  {"last_errno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_55last_errno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_54last_errno},
+  {"set_last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_57set_last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_56set_last_error},
+  {"scp_recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_59scp_recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_58scp_recv},
+  {"scp_recv2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_61scp_recv2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_60scp_recv2},
+  {"scp_send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_63scp_send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_62scp_send},
+  {"scp_send64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_65scp_send64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_64scp_send64},
+  {"publickey_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_67publickey_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_66publickey_init},
+  {"hostkey_hash", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_69hostkey_hash, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_68hostkey_hash},
+  {"hostkey", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_71hostkey, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_70hostkey},
+  {"knownhost_init", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_73knownhost_init, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_72knownhost_init},
+  {"keepalive_config", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_75keepalive_config, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_74keepalive_config},
+  {"keepalive_send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_77keepalive_send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_76keepalive_send},
+  {"supported_algs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_79supported_algs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_78supported_algs},
+  {"methods", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_81methods, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_80methods},
+  {"method_pref", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_83method_pref, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_82method_pref},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_85__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_84__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_7Session_87__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_7Session_86__setstate_cython__},
   {0, 0, 0, 0}
 };
 
@@ -10997,10 +16246,29 @@ static struct PyGetSetDef __pyx_getsets_4ssh2_7session_Session[] = {
   {(char *)"_kbd_callback", __pyx_getprop_4ssh2_7session_7Session__kbd_callback, 0, (char *)0, 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_7session_Session_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_7session_Session},
+  {Py_tp_doc, (void *)PyDoc_STR("LibSSH2 Session class providing session functions")},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_7session_Session},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_7session_Session},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_7session_Session},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_7session_Session},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_7session_Session},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_7session_Session_spec = {
+  "ssh2.session.Session",
+  sizeof(struct __pyx_obj_4ssh2_7session_Session),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_7session_Session_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_7session_Session = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.session.Session", /*tp_name*/
+  "ssh2.session.""Session", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_7session_Session), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_7session_Session, /*tp_dealloc*/
@@ -11029,7 +16297,7 @@ static PyTypeObject __pyx_type_4ssh2_7session_Session = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "LibSSH2 Session class providing session functions", /*tp_doc*/
+  PyDoc_STR("LibSSH2 Session class providing session functions"), /*tp_doc*/
   __pyx_tp_traverse_4ssh2_7session_Session, /*tp_traverse*/
   __pyx_tp_clear_4ssh2_7session_Session, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -11043,7 +16311,9 @@ static PyTypeObject __pyx_type_4ssh2_7session_Session = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_7session_Session, /*tp_new*/
@@ -11057,27 +16327,43 @@ static PyTypeObject __pyx_type_4ssh2_7session_Session = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_7session_MethodType(PyTypeObject *t, PyObject *a, PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   if (unlikely(__pyx_pw_4ssh2_7session_10MethodType_1__cinit__(o, a, k) < 0)) goto bad;
   return o;
   bad:
@@ -11087,22 +16373,46 @@ static PyObject *__pyx_tp_new_4ssh2_7session_MethodType(PyTypeObject *t, PyObjec
 
 static void __pyx_tp_dealloc_4ssh2_7session_MethodType(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_7session_MethodType) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyMethodDef __pyx_methods_4ssh2_7session_MethodType[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_7session_10MethodType_2__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__, METH_O, __pyx_doc_4ssh2_7session_10MethodType_4__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_10MethodType_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_10MethodType_2__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_7session_10MethodType_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_7session_10MethodType_4__setstate_cython__},
   {0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_7session_MethodType_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_7session_MethodType},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_7session_MethodType},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_7session_MethodType},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_7session_MethodType_spec = {
+  "ssh2.session.MethodType",
+  sizeof(struct __pyx_obj_4ssh2_7session_MethodType),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_7session_MethodType_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_7session_MethodType = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.session.MethodType", /*tp_name*/
+  "ssh2.session.""MethodType", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_7session_MethodType), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_7session_MethodType, /*tp_dealloc*/
@@ -11145,7 +16455,9 @@ static PyTypeObject __pyx_type_4ssh2_7session_MethodType = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_7session_MethodType, /*tp_new*/
@@ -11159,44 +16471,82 @@ static PyTypeObject __pyx_type_4ssh2_7session_MethodType = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
+#if CYTHON_USE_FREELISTS
 static struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *__pyx_freelist_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive[8];
 static int __pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = 0;
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive)))) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  #if CYTHON_USE_FREELISTS
+  if (likely((int)(__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive)))) {
     o = (PyObject*)__pyx_freelist_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive[--__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive];
     memset(o, 0, sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive));
     (void) PyObject_INIT(o, t);
     PyObject_GC_Track(o);
-  } else {
+  } else
+  #endif
+  {
     o = (*t->tp_alloc)(t, 0);
     if (unlikely(!o)) return 0;
   }
+  #endif
   return o;
 }
 
 static void __pyx_tp_dealloc_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive(PyObject *o) {
   struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *p = (struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
   PyObject_GC_UnTrack(o);
   Py_CLEAR(p->__pyx_v_password);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive)))) {
+  #if CYTHON_USE_FREELISTS
+  if (((int)(__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive)))) {
     __pyx_freelist_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive[__pyx_freecount_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive++] = ((struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive *)o);
-  } else {
+  } else
+  #endif
+  {
+    #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
     (*Py_TYPE(o)->tp_free)(o);
+    #else
+    {
+      freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+      if (tp_free) tp_free(o);
+    }
+    #endif
   }
 }
 
@@ -11217,10 +16567,26 @@ static int __pyx_tp_clear_4ssh2_7session___pyx_scope_struct__userauth_keyboardin
   Py_XDECREF(tmp);
   return 0;
 }
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive_spec = {
+  "ssh2.session.__pyx_scope_struct__userauth_keyboardinteractive",
+  sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
+  __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.session.__pyx_scope_struct__userauth_keyboardinteractive", /*tp_name*/
+  "ssh2.session.""__pyx_scope_struct__userauth_keyboardinteractive", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive, /*tp_dealloc*/
@@ -11248,7 +16614,7 @@ static PyTypeObject __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keybo
   0, /*tp_getattro*/
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
   0, /*tp_doc*/
   __pyx_tp_traverse_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive, /*tp_traverse*/
   __pyx_tp_clear_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive, /*tp_clear*/
@@ -11263,7 +16629,9 @@ static PyTypeObject __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keybo
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive, /*tp_new*/
@@ -11277,54 +16645,33 @@ static PyTypeObject __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keybo
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_session(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_session},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "session",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -11334,90 +16681,250 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Error_retrieving_server_host_key, __pyx_k_Error_retrieving_server_host_key, sizeof(__pyx_k_Error_retrieving_server_host_key), 0, 0, 1, 0},
-  {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5, __pyx_k_LIBSSH2_HOSTKEY_HASH_MD5, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_MD5), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1, __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA1, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_SHA1), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256, __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA256, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_SHA256), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS, __pyx_k_LIBSSH2_HOSTKEY_TYPE_DSS, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_DSS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_256), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_384), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_521), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ED25519, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ED25519), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA, __pyx_k_LIBSSH2_HOSTKEY_TYPE_RSA, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_RSA), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, __pyx_k_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_UNKNOWN), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_COMP_CS, __pyx_k_LIBSSH2_METHOD_COMP_CS, sizeof(__pyx_k_LIBSSH2_METHOD_COMP_CS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_COMP_SC, __pyx_k_LIBSSH2_METHOD_COMP_SC, sizeof(__pyx_k_LIBSSH2_METHOD_COMP_SC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS, __pyx_k_LIBSSH2_METHOD_CRYPT_CS, sizeof(__pyx_k_LIBSSH2_METHOD_CRYPT_CS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC, __pyx_k_LIBSSH2_METHOD_CRYPT_SC, sizeof(__pyx_k_LIBSSH2_METHOD_CRYPT_SC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_HOSTKEY, __pyx_k_LIBSSH2_METHOD_HOSTKEY, sizeof(__pyx_k_LIBSSH2_METHOD_HOSTKEY), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_KEX, __pyx_k_LIBSSH2_METHOD_KEX, sizeof(__pyx_k_LIBSSH2_METHOD_KEX), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_LANG_CS, __pyx_k_LIBSSH2_METHOD_LANG_CS, sizeof(__pyx_k_LIBSSH2_METHOD_LANG_CS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_LANG_SC, __pyx_k_LIBSSH2_METHOD_LANG_SC, sizeof(__pyx_k_LIBSSH2_METHOD_LANG_SC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_MAC_CS, __pyx_k_LIBSSH2_METHOD_MAC_CS, sizeof(__pyx_k_LIBSSH2_METHOD_MAC_CS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_METHOD_MAC_SC, __pyx_k_LIBSSH2_METHOD_MAC_SC, sizeof(__pyx_k_LIBSSH2_METHOD_MAC_SC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND, __pyx_k_LIBSSH2_SESSION_BLOCK_INBOUND, sizeof(__pyx_k_LIBSSH2_SESSION_BLOCK_INBOUND), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND, __pyx_k_LIBSSH2_SESSION_BLOCK_OUTBOUND, sizeof(__pyx_k_LIBSSH2_SESSION_BLOCK_OUTBOUND), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_MethodType, __pyx_k_MethodType, sizeof(__pyx_k_MethodType), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyInitError, __pyx_k_PublicKeyInitError, sizeof(__pyx_k_PublicKeyInitError), 0, 0, 1, 1},
-  {&__pyx_n_s_Session, __pyx_k_Session, sizeof(__pyx_k_Session), 0, 0, 1, 1},
-  {&__pyx_n_s_SessionHostKeyError, __pyx_k_SessionHostKeyError, sizeof(__pyx_k_SessionHostKeyError), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0},
-  {&__pyx_kp_b__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 0, 0},
-  {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0},
-  {&__pyx_n_s_atime, __pyx_k_atime, sizeof(__pyx_k_atime), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_errcode, __pyx_k_errcode, sizeof(__pyx_k_errcode), 0, 0, 1, 1},
-  {&__pyx_n_s_errmsg, __pyx_k_errmsg, sizeof(__pyx_k_errmsg), 0, 0, 1, 1},
-  {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_host, __pyx_k_host, sizeof(__pyx_k_host), 0, 0, 1, 1},
-  {&__pyx_n_s_hostname, __pyx_k_hostname, sizeof(__pyx_k_hostname), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_interval, __pyx_k_interval, sizeof(__pyx_k_interval), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_method_type, __pyx_k_method_type, sizeof(__pyx_k_method_type), 0, 0, 1, 1},
-  {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
-  {&__pyx_n_s_msg_size, __pyx_k_msg_size, sizeof(__pyx_k_msg_size), 0, 0, 1, 1},
-  {&__pyx_n_s_mtime, __pyx_k_mtime, sizeof(__pyx_k_mtime), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_passphrase, __pyx_k_passphrase, sizeof(__pyx_k_passphrase), 0, 0, 1, 1},
-  {&__pyx_n_s_passwd, __pyx_k_passwd, sizeof(__pyx_k_passwd), 0, 0, 1, 1},
-  {&__pyx_n_s_password, __pyx_k_password, sizeof(__pyx_k_password), 0, 0, 1, 1},
-  {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
-  {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1},
-  {&__pyx_n_s_prefs, __pyx_k_prefs, sizeof(__pyx_k_prefs), 0, 0, 1, 1},
-  {&__pyx_n_s_privatekey, __pyx_k_privatekey, sizeof(__pyx_k_privatekey), 0, 0, 1, 1},
-  {&__pyx_n_s_privatekeyfiledata, __pyx_k_privatekeyfiledata, sizeof(__pyx_k_privatekeyfiledata), 0, 0, 1, 1},
-  {&__pyx_n_s_pubkeydata, __pyx_k_pubkeydata, sizeof(__pyx_k_pubkeydata), 0, 0, 1, 1},
-  {&__pyx_n_s_publickey, __pyx_k_publickey, sizeof(__pyx_k_publickey), 0, 0, 1, 1},
-  {&__pyx_n_s_publickeyfiledata, __pyx_k_publickeyfiledata, sizeof(__pyx_k_publickeyfiledata), 0, 0, 1, 1},
-  {&__pyx_n_s_queue_maxsize, __pyx_k_queue_maxsize, sizeof(__pyx_k_queue_maxsize), 0, 0, 1, 1},
-  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_shost, __pyx_k_shost, sizeof(__pyx_k_shost), 0, 0, 1, 1},
-  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
-  {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1},
-  {&__pyx_n_s_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 0, 1, 1},
-  {&__pyx_n_s_ssh2_session, __pyx_k_ssh2_session, sizeof(__pyx_k_ssh2_session), 0, 0, 1, 1},
-  {&__pyx_kp_s_ssh2_session_pyx, __pyx_k_ssh2_session_pyx, sizeof(__pyx_k_ssh2_session_pyx), 0, 0, 1, 0},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_userauth_keyboardinteractive_loc, __pyx_k_userauth_keyboardinteractive_loc, sizeof(__pyx_k_userauth_keyboardinteractive_loc), 0, 0, 1, 1},
-  {&__pyx_n_s_username, __pyx_k_username, sizeof(__pyx_k_username), 0, 0, 1, 1},
-  {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
-  {&__pyx_n_s_want_reply, __pyx_k_want_reply, sizeof(__pyx_k_want_reply), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
+    {&__pyx_n_s_ChannelError, __pyx_k_ChannelError, sizeof(__pyx_k_ChannelError), 0, 0, 1, 1},
+    {&__pyx_kp_u_Error_retrieving_server_host_key, __pyx_k_Error_retrieving_server_host_key, sizeof(__pyx_k_Error_retrieving_server_host_key), 0, 1, 0, 0},
+    {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5, __pyx_k_LIBSSH2_HOSTKEY_HASH_MD5, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_MD5), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1, __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA1, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_SHA1), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256, __pyx_k_LIBSSH2_HOSTKEY_HASH_SHA256, sizeof(__pyx_k_LIBSSH2_HOSTKEY_HASH_SHA256), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS, __pyx_k_LIBSSH2_HOSTKEY_TYPE_DSS, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_DSS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_256), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_384), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ECDSA_521), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519, __pyx_k_LIBSSH2_HOSTKEY_TYPE_ED25519, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_ED25519), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA, __pyx_k_LIBSSH2_HOSTKEY_TYPE_RSA, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_RSA), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, __pyx_k_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, sizeof(__pyx_k_LIBSSH2_HOSTKEY_TYPE_UNKNOWN), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_COMP_CS, __pyx_k_LIBSSH2_METHOD_COMP_CS, sizeof(__pyx_k_LIBSSH2_METHOD_COMP_CS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_COMP_SC, __pyx_k_LIBSSH2_METHOD_COMP_SC, sizeof(__pyx_k_LIBSSH2_METHOD_COMP_SC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_CRYPT_CS, __pyx_k_LIBSSH2_METHOD_CRYPT_CS, sizeof(__pyx_k_LIBSSH2_METHOD_CRYPT_CS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_CRYPT_SC, __pyx_k_LIBSSH2_METHOD_CRYPT_SC, sizeof(__pyx_k_LIBSSH2_METHOD_CRYPT_SC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_HOSTKEY, __pyx_k_LIBSSH2_METHOD_HOSTKEY, sizeof(__pyx_k_LIBSSH2_METHOD_HOSTKEY), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_KEX, __pyx_k_LIBSSH2_METHOD_KEX, sizeof(__pyx_k_LIBSSH2_METHOD_KEX), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_LANG_CS, __pyx_k_LIBSSH2_METHOD_LANG_CS, sizeof(__pyx_k_LIBSSH2_METHOD_LANG_CS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_LANG_SC, __pyx_k_LIBSSH2_METHOD_LANG_SC, sizeof(__pyx_k_LIBSSH2_METHOD_LANG_SC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_MAC_CS, __pyx_k_LIBSSH2_METHOD_MAC_CS, sizeof(__pyx_k_LIBSSH2_METHOD_MAC_CS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_METHOD_MAC_SC, __pyx_k_LIBSSH2_METHOD_MAC_SC, sizeof(__pyx_k_LIBSSH2_METHOD_MAC_SC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND, __pyx_k_LIBSSH2_SESSION_BLOCK_INBOUND, sizeof(__pyx_k_LIBSSH2_SESSION_BLOCK_INBOUND), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND, __pyx_k_LIBSSH2_SESSION_BLOCK_OUTBOUND, sizeof(__pyx_k_LIBSSH2_SESSION_BLOCK_OUTBOUND), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodType, __pyx_k_MethodType, sizeof(__pyx_k_MethodType), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodType___reduce_cython, __pyx_k_MethodType___reduce_cython, sizeof(__pyx_k_MethodType___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodType___setstate_cython, __pyx_k_MethodType___setstate_cython, sizeof(__pyx_k_MethodType___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyInitError, __pyx_k_PublicKeyInitError, sizeof(__pyx_k_PublicKeyInitError), 0, 0, 1, 1},
+    {&__pyx_n_s_Session, __pyx_k_Session, sizeof(__pyx_k_Session), 0, 0, 1, 1},
+    {&__pyx_n_s_SessionHostKeyError, __pyx_k_SessionHostKeyError, sizeof(__pyx_k_SessionHostKeyError), 0, 0, 1, 1},
+    {&__pyx_n_s_Session___reduce_cython, __pyx_k_Session___reduce_cython, sizeof(__pyx_k_Session___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Session___setstate_cython, __pyx_k_Session___setstate_cython, sizeof(__pyx_k_Session___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_agent_auth, __pyx_k_Session_agent_auth, sizeof(__pyx_k_Session_agent_auth), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_agent_init, __pyx_k_Session_agent_init, sizeof(__pyx_k_Session_agent_init), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_block_directions, __pyx_k_Session_block_directions, sizeof(__pyx_k_Session_block_directions), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_direct_tcpip, __pyx_k_Session_direct_tcpip, sizeof(__pyx_k_Session_direct_tcpip), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_direct_tcpip_ex, __pyx_k_Session_direct_tcpip_ex, sizeof(__pyx_k_Session_direct_tcpip_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_disconnect, __pyx_k_Session_disconnect, sizeof(__pyx_k_Session_disconnect), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_forward_listen, __pyx_k_Session_forward_listen, sizeof(__pyx_k_Session_forward_listen), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_forward_listen_ex, __pyx_k_Session_forward_listen_ex, sizeof(__pyx_k_Session_forward_listen_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_get_blocking, __pyx_k_Session_get_blocking, sizeof(__pyx_k_Session_get_blocking), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_get_timeout, __pyx_k_Session_get_timeout, sizeof(__pyx_k_Session_get_timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_handshake, __pyx_k_Session_handshake, sizeof(__pyx_k_Session_handshake), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_hostkey, __pyx_k_Session_hostkey, sizeof(__pyx_k_Session_hostkey), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_hostkey_hash, __pyx_k_Session_hostkey_hash, sizeof(__pyx_k_Session_hostkey_hash), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_keepalive_config, __pyx_k_Session_keepalive_config, sizeof(__pyx_k_Session_keepalive_config), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_keepalive_send, __pyx_k_Session_keepalive_send, sizeof(__pyx_k_Session_keepalive_send), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_knownhost_init, __pyx_k_Session_knownhost_init, sizeof(__pyx_k_Session_knownhost_init), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_last_errno, __pyx_k_Session_last_errno, sizeof(__pyx_k_Session_last_errno), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_last_error, __pyx_k_Session_last_error, sizeof(__pyx_k_Session_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_method_pref, __pyx_k_Session_method_pref, sizeof(__pyx_k_Session_method_pref), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_methods, __pyx_k_Session_methods, sizeof(__pyx_k_Session_methods), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_open_session, __pyx_k_Session_open_session, sizeof(__pyx_k_Session_open_session), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_publickey_init, __pyx_k_Session_publickey_init, sizeof(__pyx_k_Session_publickey_init), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_scp_recv, __pyx_k_Session_scp_recv, sizeof(__pyx_k_Session_scp_recv), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_scp_recv2, __pyx_k_Session_scp_recv2, sizeof(__pyx_k_Session_scp_recv2), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_scp_send, __pyx_k_Session_scp_send, sizeof(__pyx_k_Session_scp_send), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_scp_send64, __pyx_k_Session_scp_send64, sizeof(__pyx_k_Session_scp_send64), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_set_blocking, __pyx_k_Session_set_blocking, sizeof(__pyx_k_Session_set_blocking), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_set_last_error, __pyx_k_Session_set_last_error, sizeof(__pyx_k_Session_set_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_set_timeout, __pyx_k_Session_set_timeout, sizeof(__pyx_k_Session_set_timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_sftp_init, __pyx_k_Session_sftp_init, sizeof(__pyx_k_Session_sftp_init), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_startup, __pyx_k_Session_startup, sizeof(__pyx_k_Session_startup), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_supported_algs, __pyx_k_Session_supported_algs, sizeof(__pyx_k_Session_supported_algs), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_authenticated, __pyx_k_Session_userauth_authenticated, sizeof(__pyx_k_Session_userauth_authenticated), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_hostbased_fromf, __pyx_k_Session_userauth_hostbased_fromf, sizeof(__pyx_k_Session_userauth_hostbased_fromf), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_keyboardinterac, __pyx_k_Session_userauth_keyboardinterac, sizeof(__pyx_k_Session_userauth_keyboardinterac), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_list, __pyx_k_Session_userauth_list, sizeof(__pyx_k_Session_userauth_list), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_password, __pyx_k_Session_userauth_password, sizeof(__pyx_k_Session_userauth_password), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_publickey, __pyx_k_Session_userauth_publickey, sizeof(__pyx_k_Session_userauth_publickey), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_publickey_fromf, __pyx_k_Session_userauth_publickey_fromf, sizeof(__pyx_k_Session_userauth_publickey_fromf), 0, 0, 1, 1},
+    {&__pyx_n_s_Session_userauth_publickey_fromm, __pyx_k_Session_userauth_publickey_fromm, sizeof(__pyx_k_Session_userauth_publickey_fromm), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_kp_b__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 0, 0},
+    {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0},
+    {&__pyx_kp_u__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0, 0},
+    {&__pyx_n_s__89, __pyx_k__89, sizeof(__pyx_k__89), 0, 0, 1, 1},
+    {&__pyx_n_s_agent, __pyx_k_agent, sizeof(__pyx_k_agent), 0, 0, 1, 1},
+    {&__pyx_n_s_agent_auth, __pyx_k_agent_auth, sizeof(__pyx_k_agent_auth), 0, 0, 1, 1},
+    {&__pyx_n_s_agent_init, __pyx_k_agent_init, sizeof(__pyx_k_agent_init), 0, 0, 1, 1},
+    {&__pyx_n_s_algs, __pyx_k_algs, sizeof(__pyx_k_algs), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_atime, __pyx_k_atime, sizeof(__pyx_k_atime), 0, 0, 1, 1},
+    {&__pyx_n_s_auth, __pyx_k_auth, sizeof(__pyx_k_auth), 0, 0, 1, 1},
+    {&__pyx_n_s_auth_2, __pyx_k_auth_2, sizeof(__pyx_k_auth_2), 0, 0, 1, 1},
+    {&__pyx_n_s_b_errmsg, __pyx_k_b_errmsg, sizeof(__pyx_k_b_errmsg), 0, 0, 1, 1},
+    {&__pyx_n_s_b_hash, __pyx_k_b_hash, sizeof(__pyx_k_b_hash), 0, 0, 1, 1},
+    {&__pyx_n_s_b_host, __pyx_k_b_host, sizeof(__pyx_k_b_host), 0, 0, 1, 1},
+    {&__pyx_n_s_b_hostname, __pyx_k_b_hostname, sizeof(__pyx_k_b_hostname), 0, 0, 1, 1},
+    {&__pyx_n_s_b_passphrase, __pyx_k_b_passphrase, sizeof(__pyx_k_b_passphrase), 0, 0, 1, 1},
+    {&__pyx_n_s_b_password, __pyx_k_b_password, sizeof(__pyx_k_b_password), 0, 0, 1, 1},
+    {&__pyx_n_s_b_path, __pyx_k_b_path, sizeof(__pyx_k_b_path), 0, 0, 1, 1},
+    {&__pyx_n_s_b_prefs, __pyx_k_b_prefs, sizeof(__pyx_k_b_prefs), 0, 0, 1, 1},
+    {&__pyx_n_s_b_privatekey, __pyx_k_b_privatekey, sizeof(__pyx_k_b_privatekey), 0, 0, 1, 1},
+    {&__pyx_n_s_b_publickey, __pyx_k_b_publickey, sizeof(__pyx_k_b_publickey), 0, 0, 1, 1},
+    {&__pyx_n_s_b_shost, __pyx_k_b_shost, sizeof(__pyx_k_b_shost), 0, 0, 1, 1},
+    {&__pyx_n_s_b_username, __pyx_k_b_username, sizeof(__pyx_k_b_username), 0, 0, 1, 1},
+    {&__pyx_n_s_block_directions, __pyx_k_block_directions, sizeof(__pyx_k_block_directions), 0, 0, 1, 1},
+    {&__pyx_n_s_blocking, __pyx_k_blocking, sizeof(__pyx_k_blocking), 0, 0, 1, 1},
+    {&__pyx_n_s_bound_port, __pyx_k_bound_port, sizeof(__pyx_k_bound_port), 0, 0, 1, 1},
+    {&__pyx_n_s_c_algs, __pyx_k_c_algs, sizeof(__pyx_k_c_algs), 0, 0, 1, 1},
+    {&__pyx_n_s_c_prefs, __pyx_k_c_prefs, sizeof(__pyx_k_c_prefs), 0, 0, 1, 1},
+    {&__pyx_n_s_c_seconds, __pyx_k_c_seconds, sizeof(__pyx_k_c_seconds), 0, 0, 1, 1},
+    {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_direct_tcpip, __pyx_k_direct_tcpip, sizeof(__pyx_k_direct_tcpip), 0, 0, 1, 1},
+    {&__pyx_n_s_direct_tcpip_ex, __pyx_k_direct_tcpip_ex, sizeof(__pyx_k_direct_tcpip_ex), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_n_s_disconnect, __pyx_k_disconnect, sizeof(__pyx_k_disconnect), 0, 0, 1, 1},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_errcode, __pyx_k_errcode, sizeof(__pyx_k_errcode), 0, 0, 1, 1},
+    {&__pyx_n_s_errmsg, __pyx_k_errmsg, sizeof(__pyx_k_errmsg), 0, 0, 1, 1},
+    {&__pyx_n_s_errmsg_2, __pyx_k_errmsg_2, sizeof(__pyx_k_errmsg_2), 0, 0, 1, 1},
+    {&__pyx_n_s_errmsg_len, __pyx_k_errmsg_len, sizeof(__pyx_k_errmsg_len), 0, 0, 1, 1},
+    {&__pyx_n_s_error_msg, __pyx_k_error_msg, sizeof(__pyx_k_error_msg), 0, 0, 1, 1},
+    {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
+    {&__pyx_n_s_fileinfo, __pyx_k_fileinfo, sizeof(__pyx_k_fileinfo), 0, 0, 1, 1},
+    {&__pyx_n_s_forward_listen, __pyx_k_forward_listen, sizeof(__pyx_k_forward_listen), 0, 0, 1, 1},
+    {&__pyx_n_s_forward_listen_ex, __pyx_k_forward_listen_ex, sizeof(__pyx_k_forward_listen_ex), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_get_blocking, __pyx_k_get_blocking, sizeof(__pyx_k_get_blocking), 0, 0, 1, 1},
+    {&__pyx_n_s_get_timeout, __pyx_k_get_timeout, sizeof(__pyx_k_get_timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_handshake, __pyx_k_handshake, sizeof(__pyx_k_handshake), 0, 0, 1, 1},
+    {&__pyx_n_s_hash, __pyx_k_hash, sizeof(__pyx_k_hash), 0, 0, 1, 1},
+    {&__pyx_n_s_hash_type, __pyx_k_hash_type, sizeof(__pyx_k_hash_type), 0, 0, 1, 1},
+    {&__pyx_n_s_host, __pyx_k_host, sizeof(__pyx_k_host), 0, 0, 1, 1},
+    {&__pyx_n_s_host_2, __pyx_k_host_2, sizeof(__pyx_k_host_2), 0, 0, 1, 1},
+    {&__pyx_n_s_hostkey, __pyx_k_hostkey, sizeof(__pyx_k_hostkey), 0, 0, 1, 1},
+    {&__pyx_n_s_hostkey_hash, __pyx_k_hostkey_hash, sizeof(__pyx_k_hostkey_hash), 0, 0, 1, 1},
+    {&__pyx_n_s_hostname, __pyx_k_hostname, sizeof(__pyx_k_hostname), 0, 0, 1, 1},
+    {&__pyx_n_s_hostname_2, __pyx_k_hostname_2, sizeof(__pyx_k_hostname_2), 0, 0, 1, 1},
+    {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
+    {&__pyx_n_s_identity, __pyx_k_identity, sizeof(__pyx_k_identity), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_interval, __pyx_k_interval, sizeof(__pyx_k_interval), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_keepalive_config, __pyx_k_keepalive_config, sizeof(__pyx_k_keepalive_config), 0, 0, 1, 1},
+    {&__pyx_n_s_keepalive_send, __pyx_k_keepalive_send, sizeof(__pyx_k_keepalive_send), 0, 0, 1, 1},
+    {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1},
+    {&__pyx_n_s_key_2, __pyx_k_key_2, sizeof(__pyx_k_key_2), 0, 0, 1, 1},
+    {&__pyx_n_s_key_len, __pyx_k_key_len, sizeof(__pyx_k_key_len), 0, 0, 1, 1},
+    {&__pyx_n_s_key_type, __pyx_k_key_type, sizeof(__pyx_k_key_type), 0, 0, 1, 1},
+    {&__pyx_n_s_known_hosts, __pyx_k_known_hosts, sizeof(__pyx_k_known_hosts), 0, 0, 1, 1},
+    {&__pyx_n_s_knownhost_init, __pyx_k_knownhost_init, sizeof(__pyx_k_knownhost_init), 0, 0, 1, 1},
+    {&__pyx_n_s_last_errno, __pyx_k_last_errno, sizeof(__pyx_k_last_errno), 0, 0, 1, 1},
+    {&__pyx_n_s_last_error, __pyx_k_last_error, sizeof(__pyx_k_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_listener, __pyx_k_listener, sizeof(__pyx_k_listener), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_method_pref, __pyx_k_method_pref, sizeof(__pyx_k_method_pref), 0, 0, 1, 1},
+    {&__pyx_n_s_method_type, __pyx_k_method_type, sizeof(__pyx_k_method_type), 0, 0, 1, 1},
+    {&__pyx_n_s_methods, __pyx_k_methods, sizeof(__pyx_k_methods), 0, 0, 1, 1},
+    {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
+    {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1},
+    {&__pyx_n_s_msg_size, __pyx_k_msg_size, sizeof(__pyx_k_msg_size), 0, 0, 1, 1},
+    {&__pyx_n_s_mtime, __pyx_k_mtime, sizeof(__pyx_k_mtime), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_open_session, __pyx_k_open_session, sizeof(__pyx_k_open_session), 0, 0, 1, 1},
+    {&__pyx_n_s_passphrase, __pyx_k_passphrase, sizeof(__pyx_k_passphrase), 0, 0, 1, 1},
+    {&__pyx_n_s_passphrase_2, __pyx_k_passphrase_2, sizeof(__pyx_k_passphrase_2), 0, 0, 1, 1},
+    {&__pyx_n_s_passwd, __pyx_k_passwd, sizeof(__pyx_k_passwd), 0, 0, 1, 1},
+    {&__pyx_n_s_password, __pyx_k_password, sizeof(__pyx_k_password), 0, 0, 1, 1},
+    {&__pyx_n_s_password_2, __pyx_k_password_2, sizeof(__pyx_k_password_2), 0, 0, 1, 1},
+    {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
+    {&__pyx_n_s_path_2, __pyx_k_path_2, sizeof(__pyx_k_path_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pkey, __pyx_k_pkey, sizeof(__pyx_k_pkey), 0, 0, 1, 1},
+    {&__pyx_n_s_port, __pyx_k_port, sizeof(__pyx_k_port), 0, 0, 1, 1},
+    {&__pyx_n_s_prefs, __pyx_k_prefs, sizeof(__pyx_k_prefs), 0, 0, 1, 1},
+    {&__pyx_n_s_prev, __pyx_k_prev, sizeof(__pyx_k_prev), 0, 0, 1, 1},
+    {&__pyx_n_s_privatekey, __pyx_k_privatekey, sizeof(__pyx_k_privatekey), 0, 0, 1, 1},
+    {&__pyx_n_s_privatekey_2, __pyx_k_privatekey_2, sizeof(__pyx_k_privatekey_2), 0, 0, 1, 1},
+    {&__pyx_n_s_privatekeydata_len, __pyx_k_privatekeydata_len, sizeof(__pyx_k_privatekeydata_len), 0, 0, 1, 1},
+    {&__pyx_n_s_privatekeyfiledata, __pyx_k_privatekeyfiledata, sizeof(__pyx_k_privatekeyfiledata), 0, 0, 1, 1},
+    {&__pyx_n_s_privatekeyfiledata_2, __pyx_k_privatekeyfiledata_2, sizeof(__pyx_k_privatekeyfiledata_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pubkeydata, __pyx_k_pubkeydata, sizeof(__pyx_k_pubkeydata), 0, 0, 1, 1},
+    {&__pyx_n_s_pubkeydata_2, __pyx_k_pubkeydata_2, sizeof(__pyx_k_pubkeydata_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pubkeydata_len, __pyx_k_pubkeydata_len, sizeof(__pyx_k_pubkeydata_len), 0, 0, 1, 1},
+    {&__pyx_n_s_publickey, __pyx_k_publickey, sizeof(__pyx_k_publickey), 0, 0, 1, 1},
+    {&__pyx_n_s_publickey_2, __pyx_k_publickey_2, sizeof(__pyx_k_publickey_2), 0, 0, 1, 1},
+    {&__pyx_n_s_publickey_init, __pyx_k_publickey_init, sizeof(__pyx_k_publickey_init), 0, 0, 1, 1},
+    {&__pyx_n_s_publickeyfiledata, __pyx_k_publickeyfiledata, sizeof(__pyx_k_publickeyfiledata), 0, 0, 1, 1},
+    {&__pyx_n_s_publickeyfiledata_2, __pyx_k_publickeyfiledata_2, sizeof(__pyx_k_publickeyfiledata_2), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_queue_maxsize, __pyx_k_queue_maxsize, sizeof(__pyx_k_queue_maxsize), 0, 0, 1, 1},
+    {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_scp_recv, __pyx_k_scp_recv, sizeof(__pyx_k_scp_recv), 0, 0, 1, 1},
+    {&__pyx_n_s_scp_recv2, __pyx_k_scp_recv2, sizeof(__pyx_k_scp_recv2), 0, 0, 1, 1},
+    {&__pyx_n_s_scp_send, __pyx_k_scp_send, sizeof(__pyx_k_scp_send), 0, 0, 1, 1},
+    {&__pyx_n_s_scp_send64, __pyx_k_scp_send64, sizeof(__pyx_k_scp_send64), 0, 0, 1, 1},
+    {&__pyx_n_s_seconds, __pyx_k_seconds, sizeof(__pyx_k_seconds), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_set_blocking, __pyx_k_set_blocking, sizeof(__pyx_k_set_blocking), 0, 0, 1, 1},
+    {&__pyx_n_s_set_last_error, __pyx_k_set_last_error, sizeof(__pyx_k_set_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_set_timeout, __pyx_k_set_timeout, sizeof(__pyx_k_set_timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_sftp, __pyx_k_sftp, sizeof(__pyx_k_sftp), 0, 0, 1, 1},
+    {&__pyx_n_s_sftp_init, __pyx_k_sftp_init, sizeof(__pyx_k_sftp_init), 0, 0, 1, 1},
+    {&__pyx_n_s_shost, __pyx_k_shost, sizeof(__pyx_k_shost), 0, 0, 1, 1},
+    {&__pyx_n_s_shost_2, __pyx_k_shost_2, sizeof(__pyx_k_shost_2), 0, 0, 1, 1},
+    {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+    {&__pyx_n_s_sock, __pyx_k_sock, sizeof(__pyx_k_sock), 0, 0, 1, 1},
+    {&__pyx_n_s_sock_2, __pyx_k_sock_2, sizeof(__pyx_k_sock_2), 0, 0, 1, 1},
+    {&__pyx_n_s_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_session, __pyx_k_ssh2_session, sizeof(__pyx_k_ssh2_session), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_session_pyx, __pyx_k_ssh2_session_pyx, sizeof(__pyx_k_ssh2_session_pyx), 0, 0, 1, 0},
+    {&__pyx_n_s_startup, __pyx_k_startup, sizeof(__pyx_k_startup), 0, 0, 1, 1},
+    {&__pyx_n_s_statinfo, __pyx_k_statinfo, sizeof(__pyx_k_statinfo), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_supported_algs, __pyx_k_supported_algs, sizeof(__pyx_k_supported_algs), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_authenticated, __pyx_k_userauth_authenticated, sizeof(__pyx_k_userauth_authenticated), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_hostbased_fromfile, __pyx_k_userauth_hostbased_fromfile, sizeof(__pyx_k_userauth_hostbased_fromfile), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_keyboardinteractive, __pyx_k_userauth_keyboardinteractive, sizeof(__pyx_k_userauth_keyboardinteractive), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_keyboardinteractive_loc, __pyx_k_userauth_keyboardinteractive_loc, sizeof(__pyx_k_userauth_keyboardinteractive_loc), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_list, __pyx_k_userauth_list, sizeof(__pyx_k_userauth_list), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_password, __pyx_k_userauth_password, sizeof(__pyx_k_userauth_password), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_publickey, __pyx_k_userauth_publickey, sizeof(__pyx_k_userauth_publickey), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_publickey_fromfile, __pyx_k_userauth_publickey_fromfile, sizeof(__pyx_k_userauth_publickey_fromfile), 0, 0, 1, 1},
+    {&__pyx_n_s_userauth_publickey_frommemory, __pyx_k_userauth_publickey_frommemory, sizeof(__pyx_k_userauth_publickey_frommemory), 0, 0, 1, 1},
+    {&__pyx_n_s_username, __pyx_k_username, sizeof(__pyx_k_username), 0, 0, 1, 1},
+    {&__pyx_n_s_username_2, __pyx_k_username_2, sizeof(__pyx_k_username_2), 0, 0, 1, 1},
+    {&__pyx_n_s_username_len, __pyx_k_username_len, sizeof(__pyx_k_username_len), 0, 0, 1, 1},
+    {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
+    {&__pyx_n_s_want_reply, __pyx_k_want_reply, sizeof(__pyx_k_want_reply), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error)
   __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 88, __pyx_L1_error)
@@ -11426,316 +16933,873 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
-
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
-
-  /* "ssh2/session.pyx":325
+  /* "ssh2/session.pyx":324
  *         cdef const char *_username = b_username
  * 
  *         def passwd():             # <<<<<<<<<<<<<<
  *             return password
  * 
  */
-  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_passwd, 325, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(1, 325, __pyx_L1_error)
+  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_passwd, 324, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(1, 324, __pyx_L1_error)
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- */
-  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 4, __pyx_L1_error)
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__7);
   __Pyx_GIVEREF(__pyx_tuple__7);
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 3, __pyx_L1_error)
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  __pyx_umethod_PyString_Type_split.type = (PyObject*)&PyString_Type;
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
+  /* "ssh2/session.pyx":112
+ *         self._session = NULL
+ * 
+ *     def disconnect(self):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_disconnect, 112, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 112, __pyx_L1_error)
 
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+  /* "ssh2/session.pyx":118
+ *         return handle_error_codes(rc)
+ * 
+ *     def handshake(self, sock not None):             # <<<<<<<<<<<<<<
+ *         """Perform SSH handshake.
+ * 
+ */
+  __pyx_tuple__11 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_sock, __pyx_n_s_sock_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_handshake, 118, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(1, 118, __pyx_L1_error)
 
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/session.pyx":130
+ *         return handle_error_codes(rc)
+ * 
+ *     def startup(self, sock):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use self.handshake"""
+ *         cdef int _sock = PyObject_AsFileDescriptor(sock)
+ */
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_startup, 130, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 130, __pyx_L1_error)
 
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/session.pyx":136
+ *         return handle_error_codes(rc)
+ * 
+ *     def set_blocking(self, bint blocking):             # <<<<<<<<<<<<<<
+ *         """Set session blocking mode on/off.
+ * 
+ */
+  __pyx_tuple__14 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_blocking); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_set_blocking, 136, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 136, __pyx_L1_error)
 
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/session.pyx":146
+ *                 self._session, blocking)
+ * 
+ *     def get_blocking(self):             # <<<<<<<<<<<<<<
+ *         """Get session blocking mode enabled True/False.
+ * 
+ */
+  __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_get_blocking, 146, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(1, 146, __pyx_L1_error)
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_7session_Session.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_7session_Session.tp_dictoffset && __pyx_type_4ssh2_7session_Session.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_7session_Session.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Session, (PyObject *)&__pyx_type_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_Session = &__pyx_type_4ssh2_7session_Session;
-  if (PyType_Ready(&__pyx_type_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_7session_MethodType.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_7session_MethodType.tp_dictoffset && __pyx_type_4ssh2_7session_MethodType.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_7session_MethodType.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MethodType, (PyObject *)&__pyx_type_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = &__pyx_type_4ssh2_7session_MethodType;
-  if (PyType_Ready(&__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive) < 0) __PYX_ERR(1, 312, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive.tp_dictoffset && __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
-  }
-  __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = &__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  /* "ssh2/session.pyx":155
+ *         return bool(rc)
+ * 
+ *     def set_timeout(self, long timeout):             # <<<<<<<<<<<<<<
+ *         """Set the timeout in milliseconds for how long a blocking
+ *         call may wait until the situation is considered an error and
+ */
+  __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_timeout); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_set_timeout, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(1, 155, __pyx_L1_error)
 
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
-  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", 
-  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
-  sizeof(PyTypeObject),
-  #else
-  sizeof(PyHeapTypeObject),
-  #endif
-  __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 8, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(3, 8, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(4, 15, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.agent"); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_5agent_Agent = __Pyx_ImportType(__pyx_t_1, "ssh2.agent", "Agent", sizeof(struct __pyx_obj_4ssh2_5agent_Agent), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_5agent_Agent) __PYX_ERR(5, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(6, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.listener"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_8listener_Listener = __Pyx_ImportType(__pyx_t_1, "ssh2.listener", "Listener", sizeof(struct __pyx_obj_4ssh2_8listener_Listener), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_8listener_Listener) __PYX_ERR(7, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 26, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(8, 26, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.statinfo"); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 20, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_8statinfo_StatInfo = __Pyx_ImportType(__pyx_t_1, "ssh2.statinfo", "StatInfo", sizeof(struct __pyx_obj_4ssh2_8statinfo_StatInfo), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_8statinfo_StatInfo) __PYX_ERR(9, 20, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.knownhost"); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_9knownhost_KnownHostEntry = __Pyx_ImportType(__pyx_t_1, "ssh2.knownhost", "KnownHostEntry", sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_9knownhost_KnownHostEntry) __PYX_ERR(10, 24, __pyx_L1_error)
-  __pyx_ptype_4ssh2_9knownhost_KnownHost = __Pyx_ImportType(__pyx_t_1, "ssh2.knownhost", "KnownHost", sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHost), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_9knownhost_KnownHost) __PYX_ERR(10, 28, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.fileinfo"); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 19, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_8fileinfo_FileInfo = __Pyx_ImportType(__pyx_t_1, "ssh2.fileinfo", "FileInfo", sizeof(struct __pyx_obj_4ssh2_8fileinfo_FileInfo), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_8fileinfo_FileInfo) __PYX_ERR(11, 19, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  /* "ssh2/session.pyx":166
+ *             c_ssh2.libssh2_session_set_timeout(self._session, timeout)
+ * 
+ *     def get_timeout(self):             # <<<<<<<<<<<<<<
+ *         """Get current session timeout setting"""
+ *         cdef long timeout
+ */
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_get_timeout, 166, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 166, __pyx_L1_error)
 
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/session.pyx":173
+ *         return timeout
+ * 
+ *     def userauth_authenticated(self):             # <<<<<<<<<<<<<<
+ *         """True/False for is user authenticated or not.
+ * 
+ */
+  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_authenticated, 173, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 173, __pyx_L1_error)
 
-static int __Pyx_modinit_function_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
-  __pyx_t_1 = PyImport_ImportModule("ssh2.agent"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyAgent", (void (**)(void))&__pyx_f_4ssh2_5agent_PyAgent, "PyObject *(LIBSSH2_AGENT *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "agent_auth", (void (**)(void))&__pyx_f_4ssh2_5agent_agent_auth, "int (char *, LIBSSH2_AGENT *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "init_connect_agent", (void (**)(void))&__pyx_f_4ssh2_5agent_init_connect_agent, "LIBSSH2_AGENT *(LIBSSH2_SESSION *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "agent_init", (void (**)(void))&__pyx_f_4ssh2_5agent_agent_init, "LIBSSH2_AGENT *(LIBSSH2_SESSION *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.listener"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyListener", (void (**)(void))&__pyx_f_4ssh2_8listener_PyListener, "PyObject *(LIBSSH2_LISTENER *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PySFTP", (void (**)(void))&__pyx_f_4ssh2_4sftp_PySFTP, "PyObject *(LIBSSH2_SFTP *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.publickey"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyPublicKeySystem", (void (**)(void))&__pyx_f_4ssh2_9publickey_PyPublicKeySystem, "PyObject *(LIBSSH2_PUBLICKEY *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_4ssh2_5utils_to_str, "PyObject *(char *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("ssh2.knownhost"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyKnownHost", (void (**)(void))&__pyx_f_4ssh2_9knownhost_PyKnownHost, "struct __pyx_obj_4ssh2_9knownhost_KnownHost *(struct __pyx_obj_4ssh2_7session_Session *, LIBSSH2_KNOWNHOSTS *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  /* "ssh2/session.pyx":182
+ *         return bool(rc)
+ * 
+ *     def userauth_list(self, username not None):             # <<<<<<<<<<<<<<
+ *         """Retrieve available authentication methodslist.
+ * 
+ */
+  __pyx_tuple__21 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_b_username, __pyx_n_s_username_2, __pyx_n_s_username_len, __pyx_n_s_auth, __pyx_n_s_auth_2); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_list, 182, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(1, 182, __pyx_L1_error)
 
+  /* "ssh2/session.pyx":199
+ *         return auth.split(',')
+ * 
+ *     def userauth_publickey_fromfile(self, username not None,             # <<<<<<<<<<<<<<
+ *                                     privatekey not None,
+ *                                     passphrase='',
+ */
+  __pyx_tuple__23 = PyTuple_Pack(14, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_privatekey, __pyx_n_s_passphrase, __pyx_n_s_publickey, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_b_publickey, __pyx_n_s_b_privatekey, __pyx_n_s_b_passphrase, __pyx_n_s_username_2, __pyx_n_s_publickey_2, __pyx_n_s_privatekey_2, __pyx_n_s_passphrase_2); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+  __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_publickey_fromfile, 199, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(1, 199, __pyx_L1_error)
+  __pyx_tuple__25 = PyTuple_Pack(2, __pyx_kp_u__2, Py_None); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
 
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
-#else
-#define __Pyx_PyMODINIT_FUNC void
-#endif
-#else
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
-#else
-#define __Pyx_PyMODINIT_FUNC PyObject *
-#endif
-#endif
+  /* "ssh2/session.pyx":223
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_publickey(self, username not None,             # <<<<<<<<<<<<<<
+ *                            bytes pubkeydata not None):
+ *         """Perform public key authentication with provided public key data
+ */
+  __pyx_tuple__26 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_pubkeydata, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_username_2, __pyx_n_s_pubkeydata_2, __pyx_n_s_pubkeydata_len); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_publickey, 223, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(1, 223, __pyx_L1_error)
 
+  /* "ssh2/session.pyx":244
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_hostbased_fromfile(self,             # <<<<<<<<<<<<<<
+ *                                     username not None,
+ *                                     privatekey not None,
+ */
+  __pyx_tuple__28 = PyTuple_Pack(17, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_privatekey, __pyx_n_s_hostname, __pyx_n_s_publickey, __pyx_n_s_passphrase, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_b_publickey, __pyx_n_s_b_privatekey, __pyx_n_s_b_passphrase, __pyx_n_s_b_hostname, __pyx_n_s_username_2, __pyx_n_s_publickey_2, __pyx_n_s_privatekey_2, __pyx_n_s_passphrase_2, __pyx_n_s_hostname_2); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_hostbased_fromfile, 244, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(1, 244, __pyx_L1_error)
+  __pyx_tuple__30 = PyTuple_Pack(2, Py_None, __pyx_kp_u__2); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
 
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC initsession(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC initsession(void)
-#else
-__Pyx_PyMODINIT_FUNC PyInit_session(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit_session(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
-}
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
-    #else
-    static PyInterpreterState *main_interpreter = NULL;
+  /* "ssh2/session.pyx":270
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
+ *             self, username, bytes privatekeyfiledata,
+ *             passphrase='', bytes publickeyfiledata=None):
+ */
+  __pyx_tuple__31 = PyTuple_Pack(15, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_privatekeyfiledata, __pyx_n_s_passphrase, __pyx_n_s_publickeyfiledata, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_b_passphrase, __pyx_n_s_username_2, __pyx_n_s_passphrase_2, __pyx_n_s_publickeyfiledata_2, __pyx_n_s_privatekeyfiledata_2, __pyx_n_s_username_len, __pyx_n_s_privatekeydata_len, __pyx_n_s_pubkeydata_len); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_publickey_frommemory, 270, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(1, 270, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":294
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_password(self, username not None, password not None):             # <<<<<<<<<<<<<<
+ *         """Perform password authentication
+ * 
+ */
+  __pyx_tuple__33 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_password, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_b_password, __pyx_n_s_username_2, __pyx_n_s_password_2); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(1, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_password, 294, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(1, 294, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":311
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
+ *                                      password not None):
+ *         """Perform keyboard-interactive authentication
+ */
+  __pyx_tuple__35 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_password, __pyx_n_s_rc, __pyx_n_s_b_username, __pyx_n_s_username_2, __pyx_n_s_passwd, __pyx_n_s_passwd); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 311, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_userauth_keyboardinteractive, 311, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 311, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":333
+ *         return handle_error_codes(rc)
+ * 
+ *     def agent_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise SSH agent.
+ * 
+ */
+  __pyx_tuple__37 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_agent); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(1, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__37);
+  __Pyx_GIVEREF(__pyx_tuple__37);
+  __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_agent_init, 333, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(1, 333, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":343
+ *         return PyAgent(agent, self)
+ * 
+ *     def agent_auth(self, username not None):             # <<<<<<<<<<<<<<
+ *         """Convenience function for performing user authentication via SSH Agent.
+ * 
+ */
+  __pyx_tuple__39 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_username, __pyx_n_s_b_username, __pyx_n_s_username_2, __pyx_n_s_agent, __pyx_n_s_identity, __pyx_n_s_prev); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(1, 343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+  __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_agent_auth, 343, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(1, 343, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":378
+ *             agent_auth(_username, agent)
+ * 
+ *     def open_session(self):             # <<<<<<<<<<<<<<
+ *         """Open new channel session.
+ * 
+ */
+  __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_channel); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(1, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__41);
+  __Pyx_GIVEREF(__pyx_tuple__41);
+  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_open_session, 378, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(1, 378, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":392
+ *         return PyChannel(channel, self)
+ * 
+ *     def direct_tcpip_ex(self, host not None, int port,             # <<<<<<<<<<<<<<
+ *                         shost not None, int sport):
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
+ */
+  __pyx_tuple__43 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_port, __pyx_n_s_shost, __pyx_n_s_sport, __pyx_n_s_channel, __pyx_n_s_b_host, __pyx_n_s_b_shost, __pyx_n_s_host_2, __pyx_n_s_shost_2); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(1, 392, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__43);
+  __Pyx_GIVEREF(__pyx_tuple__43);
+  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_direct_tcpip_ex, 392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(1, 392, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":407
+ *         return PyChannel(channel, self)
+ * 
+ *     def direct_tcpip(self, host not None, int port):             # <<<<<<<<<<<<<<
+ *         """Open direct TCP/IP channel to host:port
+ * 
+ */
+  __pyx_tuple__45 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_host, __pyx_n_s_port, __pyx_n_s_channel, __pyx_n_s_b_host, __pyx_n_s_host_2); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(1, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__45);
+  __Pyx_GIVEREF(__pyx_tuple__45);
+  __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_direct_tcpip, 407, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(1, 407, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":424
+ *         return PyChannel(channel, self)
+ * 
+ *     def block_directions(self):             # <<<<<<<<<<<<<<
+ *         """Get blocked directions for the current session.
+ * 
+ */
+  __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_block_directions, 424, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(1, 424, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":451
+ *         return rc
+ * 
+ *     def forward_listen(self, int port):             # <<<<<<<<<<<<<<
+ *         """Create forward listener on port.
+ * 
+ */
+  __pyx_tuple__48 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_port, __pyx_n_s_listener); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(1, 451, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__48);
+  __Pyx_GIVEREF(__pyx_tuple__48);
+  __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_forward_listen, 451, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(1, 451, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":467
+ *         return PyListener(listener, self)
+ * 
+ *     def forward_listen_ex(self, int queue_maxsize, host=None, int port=0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Instruct the remote SSH server to begin listening for inbound
+ */
+  __pyx_tuple__50 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_queue_maxsize, __pyx_n_s_host, __pyx_n_s_port, __pyx_n_s_listener, __pyx_n_s_b_host, __pyx_n_s_host_2, __pyx_n_s_bound_port); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(1, 467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__50);
+  __Pyx_GIVEREF(__pyx_tuple__50);
+  __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_forward_listen_ex, 467, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(1, 467, __pyx_L1_error)
+  __pyx_tuple__52 = PyTuple_Pack(2, Py_None, __pyx_int_0); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(1, 467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__52);
+  __Pyx_GIVEREF(__pyx_tuple__52);
+
+  /* "ssh2/session.pyx":503
+ *         return (PyListener(listener, self), bound_port)
+ * 
+ *     def sftp_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise SFTP channel.
+ * 
+ */
+  __pyx_tuple__53 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_sftp); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(1, 503, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__53);
+  __Pyx_GIVEREF(__pyx_tuple__53);
+  __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_sftp_init, 503, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(1, 503, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":516
+ *         return PySFTP(_sftp, self)
+ * 
+ *     def last_error(self, size_t msg_size=1024):             # <<<<<<<<<<<<<<
+ *         """Retrieve last error message from libssh2, if any.
+ *         Returns empty string on no error message.
+ */
+  __pyx_tuple__55 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_msg_size, __pyx_n_s_error_msg, __pyx_n_s_msg, __pyx_n_s_errmsg_len); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(1, 516, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__55);
+  __Pyx_GIVEREF(__pyx_tuple__55);
+  __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_last_error, 516, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(1, 516, __pyx_L1_error)
+  __pyx_tuple__57 = PyTuple_Pack(1, __pyx_int_1024); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(1, 516, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__57);
+  __Pyx_GIVEREF(__pyx_tuple__57);
+
+  /* "ssh2/session.pyx":536
+ *             free(_error_msg)
+ * 
+ *     def last_errno(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve last error number from libssh2, if any.
+ *         Returns 0 on no last error.
+ */
+  __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_last_errno, 536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(1, 536, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":548
+ *         return rc
+ * 
+ *     def set_last_error(self, int errcode, errmsg not None):             # <<<<<<<<<<<<<<
+ *         cdef bytes b_errmsg = to_bytes(errmsg)
+ *         cdef char *_errmsg = b_errmsg
+ */
+  __pyx_tuple__59 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_errcode, __pyx_n_s_errmsg, __pyx_n_s_b_errmsg, __pyx_n_s_errmsg_2, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(1, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__59);
+  __Pyx_GIVEREF(__pyx_tuple__59);
+  __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_set_last_error, 548, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(1, 548, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":557
+ *         return rc
+ * 
+ *     def scp_recv(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Receive file via SCP.
+ * 
+ */
+  __pyx_tuple__61 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_statinfo, __pyx_n_s_channel); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(1, 557, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__61);
+  __Pyx_GIVEREF(__pyx_tuple__61);
+  __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__61, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_scp_recv, 557, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(1, 557, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":579
+ *         return PyChannel(channel, self), statinfo
+ * 
+ *     def scp_recv2(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Receive file via SCP.
+ * 
+ */
+  __pyx_tuple__63 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_fileinfo, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_channel); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(1, 579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__63);
+  __Pyx_GIVEREF(__pyx_tuple__63);
+  __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_scp_recv2, 579, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(1, 579, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":599
+ *         return PyChannel(channel, self), fileinfo
+ * 
+ *     def scp_send(self, path not None, int mode, size_t size):             # <<<<<<<<<<<<<<
+ *         """Deprecated in favour of scp_send64. Send file via SCP.
+ * 
+ */
+  __pyx_tuple__65 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_mode, __pyx_n_s_size, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_channel); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(1, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__65);
+  __Pyx_GIVEREF(__pyx_tuple__65);
+  __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_scp_send, 599, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(1, 599, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":621
+ *         return PyChannel(channel, self)
+ * 
+ *     def scp_send64(self, path not None, int mode, c_ssh2.libssh2_uint64_t size,             # <<<<<<<<<<<<<<
+ *                    time_t mtime, time_t atime):
+ *         """Send file via SCP.
+ */
+  __pyx_tuple__67 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_mode, __pyx_n_s_size, __pyx_n_s_mtime, __pyx_n_s_atime, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_channel); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(1, 621, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__67);
+  __Pyx_GIVEREF(__pyx_tuple__67);
+  __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_scp_send64, 621, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(1, 621, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":644
+ *         return PyChannel(channel, self)
+ * 
+ *     def publickey_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise public key subsystem for managing remote server
+ *         public keys"""
+ */
+  __pyx_tuple__69 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pkey); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(1, 644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__69);
+  __Pyx_GIVEREF(__pyx_tuple__69);
+  __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_publickey_init, 644, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(1, 644, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":654
+ *         return PyPublicKeySystem(_pkey, self)
+ * 
+ *     def hostkey_hash(self, int hash_type):             # <<<<<<<<<<<<<<
+ *         """Get computed digest of the remote system's host key.
+ * 
+ */
+  __pyx_tuple__71 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_hash_type, __pyx_n_s_hash, __pyx_n_s_b_hash); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(1, 654, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__71);
+  __Pyx_GIVEREF(__pyx_tuple__71);
+  __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_hostkey_hash, 654, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(1, 654, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":671
+ *         return b_hash
+ * 
+ *     def hostkey(self):             # <<<<<<<<<<<<<<
+ *         """Get server host key for this session.
+ * 
+ */
+  __pyx_tuple__73 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_key, __pyx_n_s_key_2, __pyx_n_s_key_len, __pyx_n_s_key_type); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(1, 671, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__73);
+  __Pyx_GIVEREF(__pyx_tuple__73);
+  __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_hostkey, 671, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(1, 671, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":693
+ *         return key, key_type
+ * 
+ *     def knownhost_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise a collection of known hosts for this session.
+ * 
+ */
+  __pyx_tuple__75 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_known_hosts); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(1, 693, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__75);
+  __Pyx_GIVEREF(__pyx_tuple__75);
+  __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_knownhost_init, 693, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(1, 693, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":705
+ *         return PyKnownHost(self, known_hosts)
+ * 
+ *     def keepalive_config(self, bint want_reply, unsigned interval):             # <<<<<<<<<<<<<<
+ *         """
+ *         Configure keep alive settings.
+ */
+  __pyx_tuple__77 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_want_reply, __pyx_n_s_interval); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(1, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__77);
+  __Pyx_GIVEREF(__pyx_tuple__77);
+  __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_keepalive_config, 705, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(1, 705, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":718
+ *             c_ssh2.libssh2_keepalive_config(self._session, want_reply, interval)
+ * 
+ *     def keepalive_send(self):             # <<<<<<<<<<<<<<
+ *         """Send keepalive.
+ * 
+ */
+  __pyx_tuple__79 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_seconds, __pyx_n_s_c_seconds, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(1, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__79);
+  __Pyx_GIVEREF(__pyx_tuple__79);
+  __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_keepalive_send, 718, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) __PYX_ERR(1, 718, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":732
+ *         return c_seconds
+ * 
+ *     def supported_algs(self, MethodType method_type):             # <<<<<<<<<<<<<<
+ *         """Get supportd algorithms for method type.
+ * 
+ */
+  __pyx_tuple__81 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_method_type, __pyx_n_s_c_algs, __pyx_n_s_rc, __pyx_n_s_algs, __pyx_n_s_i); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(1, 732, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__81);
+  __Pyx_GIVEREF(__pyx_tuple__81);
+  __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_supported_algs, 732, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(1, 732, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":757
+ *         return algs
+ * 
+ *     def methods(self, MethodType method_type):             # <<<<<<<<<<<<<<
+ *         """Get currently active algorithms for method type.
+ * 
+ */
+  __pyx_tuple__83 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_method_type, __pyx_n_s_methods); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(1, 757, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__83);
+  __Pyx_GIVEREF(__pyx_tuple__83);
+  __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_methods, 757, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(1, 757, __pyx_L1_error)
+
+  /* "ssh2/session.pyx":772
+ *         return to_str(methods)
+ * 
+ *     def method_pref(self, MethodType method_type, prefs not None):             # <<<<<<<<<<<<<<
+ *         """Set preference for session method.
+ * 
+ */
+  __pyx_tuple__85 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_method_type, __pyx_n_s_prefs, __pyx_n_s_b_prefs, __pyx_n_s_c_prefs, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(1, 772, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__85);
+  __Pyx_GIVEREF(__pyx_tuple__85);
+  __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_session_pyx, __pyx_n_s_method_pref, 772, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(1, 772, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+/* #### Code section: init_constants ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(1, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(1, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
+
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_7session_Session = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_7session_Session_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_7session_Session)) __PYX_ERR(1, 94, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_7session_Session_spec, __pyx_ptype_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_7session_Session = &__pyx_type_4ssh2_7session_Session;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_7session_Session->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_7session_Session->tp_dictoffset && __pyx_ptype_4ssh2_7session_Session->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_7session_Session->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Session, (PyObject *) __pyx_ptype_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_7session_Session) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_7session_MethodType = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_7session_MethodType_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_7session_MethodType)) __PYX_ERR(1, 56, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_7session_MethodType_spec, __pyx_ptype_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_7session_MethodType = &__pyx_type_4ssh2_7session_MethodType;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_7session_MethodType->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_7session_MethodType->tp_dictoffset && __pyx_ptype_4ssh2_7session_MethodType->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_7session_MethodType->tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MethodType, (PyObject *) __pyx_ptype_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_7session_MethodType) < 0) __PYX_ERR(1, 56, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive)) __PYX_ERR(1, 311, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive_spec, __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive) < 0) __PYX_ERR(1, 311, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive = &__pyx_type_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive) < 0) __PYX_ERR(1, 311, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive->tp_dictoffset && __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_7session___pyx_scope_struct__userauth_keyboardinteractive->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  #endif
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_11(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(PyTypeObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(PyHeapTypeObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType_3_0_11(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(PyBoolObject),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(4, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType_3_0_11(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(PyComplexObject),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(5, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.agent"); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_5agent_Agent = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.agent", "Agent", sizeof(struct __pyx_obj_4ssh2_5agent_Agent), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_5agent_Agent),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_5agent_Agent) __PYX_ERR(6, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7channel_Channel),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(7, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.listener"); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_8listener_Listener = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.listener", "Listener", sizeof(struct __pyx_obj_4ssh2_8listener_Listener), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_8listener_Listener),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_8listener_Listener) __PYX_ERR(8, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_4sftp_SFTP),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(9, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.statinfo"); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_8statinfo_StatInfo = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.statinfo", "StatInfo", sizeof(struct __pyx_obj_4ssh2_8statinfo_StatInfo), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_8statinfo_StatInfo),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_8statinfo_StatInfo) __PYX_ERR(10, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.knownhost"); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_9knownhost_KnownHostEntry = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.knownhost", "KnownHostEntry", sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_9knownhost_KnownHostEntry),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_9knownhost_KnownHostEntry) __PYX_ERR(11, 24, __pyx_L1_error)
+  __pyx_ptype_4ssh2_9knownhost_KnownHost = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.knownhost", "KnownHost", sizeof(struct __pyx_obj_4ssh2_9knownhost_KnownHost), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_9knownhost_KnownHost),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_9knownhost_KnownHost) __PYX_ERR(11, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.fileinfo"); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_ptype_4ssh2_8fileinfo_FileInfo = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.fileinfo", "FileInfo", sizeof(struct __pyx_obj_4ssh2_8fileinfo_FileInfo), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_8fileinfo_FileInfo),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_8fileinfo_FileInfo) __PYX_ERR(12, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_variable_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __pyx_t_1 = PyImport_ImportModule("ssh2.agent"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyAgent", (void (**)(void))&__pyx_f_4ssh2_5agent_PyAgent, "PyObject *(LIBSSH2_AGENT *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "agent_auth", (void (**)(void))&__pyx_f_4ssh2_5agent_agent_auth, "int (char *, LIBSSH2_AGENT *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "init_connect_agent", (void (**)(void))&__pyx_f_4ssh2_5agent_init_connect_agent, "LIBSSH2_AGENT *(LIBSSH2_SESSION *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "agent_init", (void (**)(void))&__pyx_f_4ssh2_5agent_agent_init, "LIBSSH2_AGENT *(LIBSSH2_SESSION *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.listener"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyListener", (void (**)(void))&__pyx_f_4ssh2_8listener_PyListener, "PyObject *(LIBSSH2_LISTENER *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PySFTP", (void (**)(void))&__pyx_f_4ssh2_4sftp_PySFTP, "PyObject *(LIBSSH2_SFTP *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.publickey"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyPublicKeySystem", (void (**)(void))&__pyx_f_4ssh2_9publickey_PyPublicKeySystem, "PyObject *(LIBSSH2_PUBLICKEY *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_str", (void (**)(void))&__pyx_f_4ssh2_5utils_to_str, "PyObject *(char *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyImport_ImportModule("ssh2.knownhost"); if (!__pyx_t_1) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyKnownHost", (void (**)(void))&__pyx_f_4ssh2_9knownhost_PyKnownHost, "struct __pyx_obj_4ssh2_9knownhost_KnownHost *(struct __pyx_obj_4ssh2_7session_Session *, LIBSSH2_KNOWNHOSTS *)") < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_session(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_session},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "session",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
+#endif
+#endif
+
+
+#if PY_MAJOR_VERSION < 3
+__Pyx_PyMODINIT_FUNC initsession(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initsession(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_session(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_session(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    #if PY_VERSION_HEX >= 0x030700A1
+    static PY_INT64_T main_interpreter_id = -1;
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return (unlikely(current_id == -1)) ? -1 : 0;
+    } else if (unlikely(main_interpreter_id != current_id))
+    #else
+    static PyInterpreterState *main_interpreter = NULL;
     PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
     if (!main_interpreter) {
         main_interpreter = current_interpreter;
@@ -11749,12 +17813,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -11764,8 +17837,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -11775,8 +17849,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -11792,8 +17870,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_session(PyObject *__pyx_pyinit_mod
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -11807,6 +17890,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_session(PyObject *__pyx_pyinit_mod
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("session", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "session" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -11817,7 +17927,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_session(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -11825,48 +17935,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("session", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
@@ -11878,7 +17971,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.session")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.session", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.session", __pyx_m) < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -11890,372 +17983,949 @@ if (!__Pyx_RefNanny) {
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
   (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(1, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   #endif
 
-  /* "ssh2/session.pyx":24
- * from agent cimport PyAgent, agent_auth, agent_init, init_connect_agent
- * from channel cimport PyChannel
- * from exceptions import SessionHostKeyError, KnownHostError, \             # <<<<<<<<<<<<<<
- *     PublicKeyInitError, ChannelError
- * from listener cimport PyListener
+  /* "ssh2/session.pyx":24
+ * from .agent cimport PyAgent, agent_auth, agent_init, init_connect_agent
+ * from .channel cimport PyChannel
+ * from .exceptions import SessionHostKeyError, KnownHostError, \             # <<<<<<<<<<<<<<
+ *     PublicKeyInitError, ChannelError
+ * from .listener cimport PyListener
+ */
+  __pyx_t_2 = PyList_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_n_s_SessionHostKeyError);
+  __Pyx_GIVEREF(__pyx_n_s_SessionHostKeyError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SessionHostKeyError)) __PYX_ERR(1, 24, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_n_s_KnownHostError);
+  __Pyx_GIVEREF(__pyx_n_s_KnownHostError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_KnownHostError)) __PYX_ERR(1, 24, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_n_s_PublicKeyInitError);
+  __Pyx_GIVEREF(__pyx_n_s_PublicKeyInitError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_PublicKeyInitError)) __PYX_ERR(1, 24, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_n_s_ChannelError);
+  __Pyx_GIVEREF(__pyx_n_s_ChannelError);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_ChannelError)) __PYX_ERR(1, 24, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_2, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_SessionHostKeyError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionHostKeyError, __pyx_t_2) < 0) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostError, __pyx_t_2) < 0) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PublicKeyInitError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyInitError, __pyx_t_2) < 0) __PYX_ERR(1, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_2) < 0) __PYX_ERR(1, 25, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":40
+ * 
+ * 
+ * LIBSSH2_SESSION_BLOCK_INBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_INBOUND             # <<<<<<<<<<<<<<
+ * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SESSION_BLOCK_INBOUND); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND, __pyx_t_3) < 0) __PYX_ERR(1, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":41
+ * 
+ * LIBSSH2_SESSION_BLOCK_INBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_INBOUND
+ * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND             # <<<<<<<<<<<<<<
+ * 
+ * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SESSION_BLOCK_OUTBOUND); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND, __pyx_t_3) < 0) __PYX_ERR(1, 41, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":43
+ * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND
+ * 
+ * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
+ * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_HASH_MD5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5, __pyx_t_3) < 0) __PYX_ERR(1, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":44
+ * 
+ * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
+ * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_HASH_SHA1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1, __pyx_t_3) < 0) __PYX_ERR(1, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":45
+ * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
+ * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
+ * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_HASH_SHA256); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256, __pyx_t_3) < 0) __PYX_ERR(1, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":46
+ * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
+ * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_ECDSA_256); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, __pyx_t_3) < 0) __PYX_ERR(1, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":47
+ * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
+ * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_ECDSA_384); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, __pyx_t_3) < 0) __PYX_ERR(1, 47, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":48
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_ECDSA_521); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, __pyx_t_3) < 0) __PYX_ERR(1, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":49
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+ * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
+ * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519             # <<<<<<<<<<<<<<
+ * 
+ * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_ED25519); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519, __pyx_t_3) < 0) __PYX_ERR(1, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":51
+ * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+ * 
+ * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA
+ * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_UNKNOWN); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, __pyx_t_3) < 0) __PYX_ERR(1, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":52
+ * 
+ * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
+ * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA             # <<<<<<<<<<<<<<
+ * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_RSA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA, __pyx_t_3) < 0) __PYX_ERR(1, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":53
+ * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
+ * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA
+ * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_HOSTKEY_TYPE_DSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS, __pyx_t_3) < 0) __PYX_ERR(1, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_10MethodType_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MethodType___reduce_cython, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_10MethodType_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MethodType___setstate_cython, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":61
+ * 
+ * 
+ * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
+ * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
  */
-  __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s_SessionHostKeyError);
-  __Pyx_GIVEREF(__pyx_n_s_SessionHostKeyError);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_SessionHostKeyError);
-  __Pyx_INCREF(__pyx_n_s_KnownHostError);
-  __Pyx_GIVEREF(__pyx_n_s_KnownHostError);
-  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_KnownHostError);
-  __Pyx_INCREF(__pyx_n_s_PublicKeyInitError);
-  __Pyx_GIVEREF(__pyx_n_s_PublicKeyInitError);
-  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_PublicKeyInitError);
-  __Pyx_INCREF(__pyx_n_s_ChannelError);
-  __Pyx_GIVEREF(__pyx_n_s_ChannelError);
-  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_ChannelError);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 24, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_KEX); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SessionHostKeyError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SessionHostKeyError, __pyx_t_1) < 0) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_KnownHostError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KnownHostError, __pyx_t_1) < 0) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_PublicKeyInitError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PublicKeyInitError, __pyx_t_1) < 0) __PYX_ERR(1, 25, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ChannelError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ChannelError, __pyx_t_1) < 0) __PYX_ERR(1, 25, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_KEX, __pyx_t_2) < 0) __PYX_ERR(1, 61, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "ssh2/session.pyx":40
+  /* "ssh2/session.pyx":62
+ * 
+ * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)
+ * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
+ * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_HOSTKEY); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_HOSTKEY, __pyx_t_3) < 0) __PYX_ERR(1, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":63
+ * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)
+ * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
+ * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
+ * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_CRYPT_CS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_CRYPT_CS, __pyx_t_2) < 0) __PYX_ERR(1, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/session.pyx":64
+ * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
+ * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
+ * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
+ * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_CRYPT_SC); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_CRYPT_SC, __pyx_t_3) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":65
+ * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
+ * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
+ * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
+ * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_MAC_CS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_MAC_CS, __pyx_t_2) < 0) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/session.pyx":66
+ * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
+ * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
+ * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
+ * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_MAC_SC); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_MAC_SC, __pyx_t_3) < 0) __PYX_ERR(1, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":67
+ * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
+ * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
+ * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
+ * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_COMP_CS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_COMP_CS, __pyx_t_2) < 0) __PYX_ERR(1, 67, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/session.pyx":68
+ * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
+ * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
+ * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
+ * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_COMP_SC); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_COMP_SC, __pyx_t_3) < 0) __PYX_ERR(1, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":69
+ * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
+ * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
+ * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)             # <<<<<<<<<<<<<<
+ * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_LANG_CS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_LANG_CS, __pyx_t_2) < 0) __PYX_ERR(1, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/session.pyx":70
+ * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
+ * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
+ * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_METHOD_LANG_SC); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_LANG_SC, __pyx_t_3) < 0) __PYX_ERR(1, 70, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "ssh2/session.pyx":112
+ *         self._session = NULL
+ * 
+ *     def disconnect(self):             # <<<<<<<<<<<<<<
+ *         cdef int rc
+ *         with nogil:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_5disconnect, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_disconnect, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_disconnect, __pyx_t_3) < 0) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":118
+ *         return handle_error_codes(rc)
+ * 
+ *     def handshake(self, sock not None):             # <<<<<<<<<<<<<<
+ *         """Perform SSH handshake.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_7handshake, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_handshake, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_handshake, __pyx_t_3) < 0) __PYX_ERR(1, 118, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":130
+ *         return handle_error_codes(rc)
+ * 
+ *     def startup(self, sock):             # <<<<<<<<<<<<<<
+ *         """Deprecated - use self.handshake"""
+ *         cdef int _sock = PyObject_AsFileDescriptor(sock)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_9startup, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_startup, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_startup, __pyx_t_3) < 0) __PYX_ERR(1, 130, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":136
+ *         return handle_error_codes(rc)
+ * 
+ *     def set_blocking(self, bint blocking):             # <<<<<<<<<<<<<<
+ *         """Set session blocking mode on/off.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_11set_blocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_set_blocking, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_set_blocking, __pyx_t_3) < 0) __PYX_ERR(1, 136, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":146
+ *                 self._session, blocking)
+ * 
+ *     def get_blocking(self):             # <<<<<<<<<<<<<<
+ *         """Get session blocking mode enabled True/False.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_13get_blocking, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_get_blocking, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_get_blocking, __pyx_t_3) < 0) __PYX_ERR(1, 146, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":155
+ *         return bool(rc)
+ * 
+ *     def set_timeout(self, long timeout):             # <<<<<<<<<<<<<<
+ *         """Set the timeout in milliseconds for how long a blocking
+ *         call may wait until the situation is considered an error and
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_15set_timeout, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_set_timeout, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_set_timeout, __pyx_t_3) < 0) __PYX_ERR(1, 155, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":166
+ *             c_ssh2.libssh2_session_set_timeout(self._session, timeout)
+ * 
+ *     def get_timeout(self):             # <<<<<<<<<<<<<<
+ *         """Get current session timeout setting"""
+ *         cdef long timeout
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_17get_timeout, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_get_timeout, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_get_timeout, __pyx_t_3) < 0) __PYX_ERR(1, 166, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":173
+ *         return timeout
+ * 
+ *     def userauth_authenticated(self):             # <<<<<<<<<<<<<<
+ *         """True/False for is user authenticated or not.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_19userauth_authenticated, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_authenticated, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_authenticated, __pyx_t_3) < 0) __PYX_ERR(1, 173, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":182
+ *         return bool(rc)
+ * 
+ *     def userauth_list(self, username not None):             # <<<<<<<<<<<<<<
+ *         """Retrieve available authentication methodslist.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_21userauth_list, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_list, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_list, __pyx_t_3) < 0) __PYX_ERR(1, 182, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":199
+ *         return auth.split(',')
+ * 
+ *     def userauth_publickey_fromfile(self, username not None,             # <<<<<<<<<<<<<<
+ *                                     privatekey not None,
+ *                                     passphrase='',
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_23userauth_publickey_fromfile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_publickey_fromf, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__25);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_publickey_fromfile, __pyx_t_3) < 0) __PYX_ERR(1, 199, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":223
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_publickey(self, username not None,             # <<<<<<<<<<<<<<
+ *                            bytes pubkeydata not None):
+ *         """Perform public key authentication with provided public key data
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_25userauth_publickey, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_publickey, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_publickey, __pyx_t_3) < 0) __PYX_ERR(1, 223, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":244
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_hostbased_fromfile(self,             # <<<<<<<<<<<<<<
+ *                                     username not None,
+ *                                     privatekey not None,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_27userauth_hostbased_fromfile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_hostbased_fromf, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__30);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_hostbased_fromfile, __pyx_t_3) < 0) __PYX_ERR(1, 244, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":270
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_publickey_frommemory(             # <<<<<<<<<<<<<<
+ *             self, username, bytes privatekeyfiledata,
+ *             passphrase='', bytes publickeyfiledata=None):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_29userauth_publickey_frommemory, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_publickey_fromm, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__25);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_publickey_frommemory, __pyx_t_3) < 0) __PYX_ERR(1, 270, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":294
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_password(self, username not None, password not None):             # <<<<<<<<<<<<<<
+ *         """Perform password authentication
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_31userauth_password, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_password, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_password, __pyx_t_3) < 0) __PYX_ERR(1, 294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":311
+ *         return handle_error_codes(rc)
+ * 
+ *     def userauth_keyboardinteractive(self, username not None,             # <<<<<<<<<<<<<<
+ *                                      password not None):
+ *         """Perform keyboard-interactive authentication
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_33userauth_keyboardinteractive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_userauth_keyboardinterac, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 311, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_userauth_keyboardinteractive, __pyx_t_3) < 0) __PYX_ERR(1, 311, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":333
+ *         return handle_error_codes(rc)
+ * 
+ *     def agent_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise SSH agent.
  * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_35agent_init, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_agent_init, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_agent_init, __pyx_t_3) < 0) __PYX_ERR(1, 333, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":343
+ *         return PyAgent(agent, self)
  * 
- * LIBSSH2_SESSION_BLOCK_INBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_INBOUND             # <<<<<<<<<<<<<<
- * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND
+ *     def agent_auth(self, username not None):             # <<<<<<<<<<<<<<
+ *         """Convenience function for performing user authentication via SSH Agent.
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_SESSION_BLOCK_INBOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 40, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SESSION_BLOCK_INBOUND, __pyx_t_2) < 0) __PYX_ERR(1, 40, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_37agent_auth, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_agent_auth, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_agent_auth, __pyx_t_3) < 0) __PYX_ERR(1, 343, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":41
+  /* "ssh2/session.pyx":378
+ *             agent_auth(_username, agent)
  * 
- * LIBSSH2_SESSION_BLOCK_INBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_INBOUND
- * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND             # <<<<<<<<<<<<<<
+ *     def open_session(self):             # <<<<<<<<<<<<<<
+ *         """Open new channel session.
  * 
- * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_SESSION_BLOCK_OUTBOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 41, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SESSION_BLOCK_OUTBOUND, __pyx_t_2) < 0) __PYX_ERR(1, 41, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_39open_session, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_open_session, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_open_session, __pyx_t_3) < 0) __PYX_ERR(1, 378, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":43
- * LIBSSH2_SESSION_BLOCK_OUTBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND
+  /* "ssh2/session.pyx":392
+ *         return PyChannel(channel, self)
  * 
- * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
- * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
+ *     def direct_tcpip_ex(self, host not None, int port,             # <<<<<<<<<<<<<<
+ *                         shost not None, int sport):
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *channel
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_HASH_MD5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 43, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_MD5, __pyx_t_2) < 0) __PYX_ERR(1, 43, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_41direct_tcpip_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_direct_tcpip_ex, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 392, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_direct_tcpip_ex, __pyx_t_3) < 0) __PYX_ERR(1, 392, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":44
+  /* "ssh2/session.pyx":407
+ *         return PyChannel(channel, self)
+ * 
+ *     def direct_tcpip(self, host not None, int port):             # <<<<<<<<<<<<<<
+ *         """Open direct TCP/IP channel to host:port
  * 
- * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
- * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_HASH_SHA1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 44, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA1, __pyx_t_2) < 0) __PYX_ERR(1, 44, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_43direct_tcpip, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_direct_tcpip, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_direct_tcpip, __pyx_t_3) < 0) __PYX_ERR(1, 407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":45
- * LIBSSH2_HOSTKEY_HASH_MD5 = c_ssh2.LIBSSH2_HOSTKEY_HASH_MD5
- * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
- * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
+  /* "ssh2/session.pyx":424
+ *         return PyChannel(channel, self)
+ * 
+ *     def block_directions(self):             # <<<<<<<<<<<<<<
+ *         """Get blocked directions for the current session.
+ * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_HASH_SHA256); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_HASH_SHA256, __pyx_t_2) < 0) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_45block_directions, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_block_directions, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_block_directions, __pyx_t_3) < 0) __PYX_ERR(1, 424, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":46
- * LIBSSH2_HOSTKEY_HASH_SHA1 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA1
- * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
+  /* "ssh2/session.pyx":451
+ *         return rc
+ * 
+ *     def forward_listen(self, int port):             # <<<<<<<<<<<<<<
+ *         """Create forward listener on port.
+ * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_ECDSA_256); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 46, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_256, __pyx_t_2) < 0) __PYX_ERR(1, 46, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_47forward_listen, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_forward_listen, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 451, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_forward_listen, __pyx_t_3) < 0) __PYX_ERR(1, 451, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":47
- * LIBSSH2_HOSTKEY_HASH_SHA256 = c_ssh2.LIBSSH2_HOSTKEY_HASH_SHA256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
- * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+  /* "ssh2/session.pyx":467
+ *         return PyListener(listener, self)
+ * 
+ *     def forward_listen_ex(self, int queue_maxsize, host=None, int port=0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Instruct the remote SSH server to begin listening for inbound
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_ECDSA_384); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_384, __pyx_t_2) < 0) __PYX_ERR(1, 47, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_49forward_listen_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_forward_listen_ex, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__52);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_forward_listen_ex, __pyx_t_3) < 0) __PYX_ERR(1, 467, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":48
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_256 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_256
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+  /* "ssh2/session.pyx":503
+ *         return (PyListener(listener, self), bound_port)
+ * 
+ *     def sftp_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise SFTP channel.
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_ECDSA_521); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ECDSA_521, __pyx_t_2) < 0) __PYX_ERR(1, 48, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_51sftp_init, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_sftp_init, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 503, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_sftp_init, __pyx_t_3) < 0) __PYX_ERR(1, 503, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":49
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_384 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_384
- * LIBSSH2_HOSTKEY_TYPE_ECDSA_521 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ECDSA_521
- * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519             # <<<<<<<<<<<<<<
+  /* "ssh2/session.pyx":516
+ *         return PySFTP(_sftp, self)
  * 
- * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
+ *     def last_error(self, size_t msg_size=1024):             # <<<<<<<<<<<<<<
+ *         """Retrieve last error message from libssh2, if any.
+ *         Returns empty string on no error message.
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_ED25519); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_ED25519, __pyx_t_2) < 0) __PYX_ERR(1, 49, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_53last_error, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_last_error, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__57);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_last_error, __pyx_t_3) < 0) __PYX_ERR(1, 516, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":51
- * LIBSSH2_HOSTKEY_TYPE_ED25519 = c_ssh2.LIBSSH2_HOSTKEY_TYPE_ED25519
+  /* "ssh2/session.pyx":536
+ *             free(_error_msg)
  * 
- * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA
- * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS
+ *     def last_errno(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve last error number from libssh2, if any.
+ *         Returns 0 on no last error.
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_UNKNOWN); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_UNKNOWN, __pyx_t_2) < 0) __PYX_ERR(1, 51, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_55last_errno, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_last_errno, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 536, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_last_errno, __pyx_t_3) < 0) __PYX_ERR(1, 536, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":52
+  /* "ssh2/session.pyx":548
+ *         return rc
  * 
- * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
- * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA             # <<<<<<<<<<<<<<
- * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS
+ *     def set_last_error(self, int errcode, errmsg not None):             # <<<<<<<<<<<<<<
+ *         cdef bytes b_errmsg = to_bytes(errmsg)
+ *         cdef char *_errmsg = b_errmsg
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_57set_last_error, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_set_last_error, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_set_last_error, __pyx_t_3) < 0) __PYX_ERR(1, 548, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":557
+ *         return rc
+ * 
+ *     def scp_recv(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Receive file via SCP.
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_RSA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 52, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_RSA, __pyx_t_2) < 0) __PYX_ERR(1, 52, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_59scp_recv, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_scp_recv, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 557, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_scp_recv, __pyx_t_3) < 0) __PYX_ERR(1, 557, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":53
- * LIBSSH2_HOSTKEY_TYPE_UNKNOWN = c_ssh2.LIBSSH2_HOSTKEY_TYPE_UNKNOWN
- * LIBSSH2_HOSTKEY_TYPE_RSA = c_ssh2.LIBSSH2_HOSTKEY_TYPE_RSA
- * LIBSSH2_HOSTKEY_TYPE_DSS = c_ssh2.LIBSSH2_HOSTKEY_TYPE_DSS             # <<<<<<<<<<<<<<
+  /* "ssh2/session.pyx":579
+ *         return PyChannel(channel, self), statinfo
  * 
+ *     def scp_recv2(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Receive file via SCP.
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_HOSTKEY_TYPE_DSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 53, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_HOSTKEY_TYPE_DSS, __pyx_t_2) < 0) __PYX_ERR(1, 53, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_61scp_recv2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_scp_recv2, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_scp_recv2, __pyx_t_3) < 0) __PYX_ERR(1, 579, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":61
+  /* "ssh2/session.pyx":599
+ *         return PyChannel(channel, self), fileinfo
  * 
+ *     def scp_send(self, path not None, int mode, size_t size):             # <<<<<<<<<<<<<<
+ *         """Deprecated in favour of scp_send64. Send file via SCP.
  * 
- * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
- * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_KEX); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_KEX, __pyx_t_1) < 0) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_63scp_send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_scp_send, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_scp_send, __pyx_t_3) < 0) __PYX_ERR(1, 599, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":62
+  /* "ssh2/session.pyx":621
+ *         return PyChannel(channel, self)
  * 
- * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)
- * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
- * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
+ *     def scp_send64(self, path not None, int mode, c_ssh2.libssh2_uint64_t size,             # <<<<<<<<<<<<<<
+ *                    time_t mtime, time_t atime):
+ *         """Send file via SCP.
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_HOSTKEY); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_HOSTKEY, __pyx_t_2) < 0) __PYX_ERR(1, 62, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_65scp_send64, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_scp_send64, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 621, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_scp_send64, __pyx_t_3) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":63
- * LIBSSH2_METHOD_KEX = MethodType(c_ssh2.LIBSSH2_METHOD_KEX)
- * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
- * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
- * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
+  /* "ssh2/session.pyx":644
+ *         return PyChannel(channel, self)
+ * 
+ *     def publickey_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise public key subsystem for managing remote server
+ *         public keys"""
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_CRYPT_CS); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 63, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_CRYPT_CS, __pyx_t_1) < 0) __PYX_ERR(1, 63, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_67publickey_init, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_publickey_init, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__70)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_publickey_init, __pyx_t_3) < 0) __PYX_ERR(1, 644, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":64
- * LIBSSH2_METHOD_HOSTKEY = MethodType(c_ssh2.LIBSSH2_METHOD_HOSTKEY)
- * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
- * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
- * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
+  /* "ssh2/session.pyx":654
+ *         return PyPublicKeySystem(_pkey, self)
+ * 
+ *     def hostkey_hash(self, int hash_type):             # <<<<<<<<<<<<<<
+ *         """Get computed digest of the remote system's host key.
+ * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_CRYPT_SC); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_CRYPT_SC, __pyx_t_2) < 0) __PYX_ERR(1, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_69hostkey_hash, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_hostkey_hash, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__72)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 654, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_hostkey_hash, __pyx_t_3) < 0) __PYX_ERR(1, 654, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":65
- * LIBSSH2_METHOD_CRYPT_CS = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_CS)
- * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
- * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
- * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
+  /* "ssh2/session.pyx":671
+ *         return b_hash
+ * 
+ *     def hostkey(self):             # <<<<<<<<<<<<<<
+ *         """Get server host key for this session.
+ * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_MAC_CS); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_MAC_CS, __pyx_t_1) < 0) __PYX_ERR(1, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_71hostkey, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_hostkey, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__74)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_hostkey, __pyx_t_3) < 0) __PYX_ERR(1, 671, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":66
- * LIBSSH2_METHOD_CRYPT_SC = MethodType(c_ssh2.LIBSSH2_METHOD_CRYPT_SC)
- * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
- * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
- * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
+  /* "ssh2/session.pyx":693
+ *         return key, key_type
+ * 
+ *     def knownhost_init(self):             # <<<<<<<<<<<<<<
+ *         """Initialise a collection of known hosts for this session.
+ * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_MAC_SC); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_MAC_SC, __pyx_t_2) < 0) __PYX_ERR(1, 66, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_73knownhost_init, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_knownhost_init, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_knownhost_init, __pyx_t_3) < 0) __PYX_ERR(1, 693, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":67
- * LIBSSH2_METHOD_MAC_CS = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_CS)
- * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
- * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
- * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
+  /* "ssh2/session.pyx":705
+ *         return PyKnownHost(self, known_hosts)
+ * 
+ *     def keepalive_config(self, bint want_reply, unsigned interval):             # <<<<<<<<<<<<<<
+ *         """
+ *         Configure keep alive settings.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_75keepalive_config, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_keepalive_config, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__78)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_keepalive_config, __pyx_t_3) < 0) __PYX_ERR(1, 705, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "ssh2/session.pyx":718
+ *             c_ssh2.libssh2_keepalive_config(self._session, want_reply, interval)
+ * 
+ *     def keepalive_send(self):             # <<<<<<<<<<<<<<
+ *         """Send keepalive.
+ * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_COMP_CS); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 67, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 67, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_COMP_CS, __pyx_t_1) < 0) __PYX_ERR(1, 67, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_77keepalive_send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_keepalive_send, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__80)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 718, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_keepalive_send, __pyx_t_3) < 0) __PYX_ERR(1, 718, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":68
- * LIBSSH2_METHOD_MAC_SC = MethodType(c_ssh2.LIBSSH2_METHOD_MAC_SC)
- * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
- * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
- * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)
+  /* "ssh2/session.pyx":732
+ *         return c_seconds
+ * 
+ *     def supported_algs(self, MethodType method_type):             # <<<<<<<<<<<<<<
+ *         """Get supportd algorithms for method type.
+ * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_COMP_SC); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_COMP_SC, __pyx_t_2) < 0) __PYX_ERR(1, 68, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_79supported_algs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_supported_algs, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__82)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 732, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_supported_algs, __pyx_t_3) < 0) __PYX_ERR(1, 732, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":69
- * LIBSSH2_METHOD_COMP_CS = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_CS)
- * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
- * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)             # <<<<<<<<<<<<<<
- * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)
+  /* "ssh2/session.pyx":757
+ *         return algs
+ * 
+ *     def methods(self, MethodType method_type):             # <<<<<<<<<<<<<<
+ *         """Get currently active algorithms for method type.
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_LANG_CS); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_LANG_CS, __pyx_t_1) < 0) __PYX_ERR(1, 69, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_81methods, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_methods, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__84)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 757, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_methods, __pyx_t_3) < 0) __PYX_ERR(1, 757, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
 
-  /* "ssh2/session.pyx":70
- * LIBSSH2_METHOD_COMP_SC = MethodType(c_ssh2.LIBSSH2_METHOD_COMP_SC)
- * LIBSSH2_METHOD_LANG_CS = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_CS)
- * LIBSSH2_METHOD_LANG_SC = MethodType(c_ssh2.LIBSSH2_METHOD_LANG_SC)             # <<<<<<<<<<<<<<
+  /* "ssh2/session.pyx":772
+ *         return to_str(methods)
  * 
+ *     def method_pref(self, MethodType method_type, prefs not None):             # <<<<<<<<<<<<<<
+ *         """Set preference for session method.
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_METHOD_LANG_SC); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4ssh2_7session_MethodType), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_METHOD_LANG_SC, __pyx_t_2) < 0) __PYX_ERR(1, 70, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_83method_pref, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session_method_pref, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__86)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_7session_Session, __pyx_n_s_method_pref, __pyx_t_3) < 0) __PYX_ERR(1, 772, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_7session_Session);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_85__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session___reduce_cython, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__87)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_7session_7Session_87__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Session___setstate_cython, NULL, __pyx_n_s_ssh2_session, __pyx_d, ((PyObject *)__pyx_codeobj__88)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/session.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.session", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.session");
   }
@@ -12269,6 +18939,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -12288,6 +18974,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
 /* PyObjectGetAttrStr */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
@@ -12302,10 +19090,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -12316,6 +19133,231 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
 /* RaiseDoubleKeywords */
 static void __Pyx_RaiseDoubleKeywordsError(
     const char* func_name,
@@ -12333,6 +19375,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -12343,13 +19386,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
         name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -12357,6 +19441,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -12377,14 +19464,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -12411,6 +19502,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -12420,15 +19513,18 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
@@ -12458,55 +19554,85 @@ static void __Pyx_RaiseArgtupleInvalid(
                  (num_expected == 1) ? "" : "s", num_found);
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
     }
-    return result;
-}
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
 #endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
 }
-#endif
 
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -12639,13 +19765,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -12653,6 +19775,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -12662,7 +19790,7 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 #endif
 
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
 static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
@@ -12691,7 +19819,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -12707,9 +19834,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -12778,6 +19911,30 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
 #endif
 
 /* PyObjectCallMethO */
@@ -12785,10 +19942,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -12800,206 +19962,100 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallNoArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
-    }
-#endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
-        }
-    }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
-}
-#endif
-
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
     }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
 }
 #endif
-
-/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
 #if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
     }
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
-#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
         }
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
-}
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-#endif
-
-/* KeywordStringCheck */
-static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict,
-    const char* function_name,
-    int kw_allowed)
-{
-    PyObject* key = 0;
-    Py_ssize_t pos = 0;
-#if CYTHON_COMPILING_IN_PYPY
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
-        goto invalid_keyword;
-    return 1;
-#else
-    while (PyDict_Next(kwdict, &pos, &key, 0)) {
-        #if PY_MAJOR_VERSION < 3
-        if (unlikely(!PyString_Check(key)))
-        #endif
-            if (unlikely(!PyUnicode_Check(key)))
-                goto invalid_keyword_type;
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
     }
-    if ((!kw_allowed) && unlikely(key))
-        goto invalid_keyword;
-    return 1;
-invalid_keyword_type:
-    PyErr_Format(PyExc_TypeError,
-        "%.200s() keywords must be strings", function_name);
-    return 0;
-#endif
-invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
-    #if PY_MAJOR_VERSION < 3
-        "%.200s() got an unexpected keyword argument '%.200s'",
-        function_name, PyString_AsString(key));
-    #else
-        "%s() got an unexpected keyword argument '%U'",
-        function_name, key);
     #endif
-    return 0;
-}
-
-/* UnpackUnboundCMethod */
-static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
-    PyObject *method;
-    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
-    if (unlikely(!method))
-        return -1;
-    target->method = method;
-#if CYTHON_COMPILING_IN_CPYTHON
-    #if PY_MAJOR_VERSION >= 3
-    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
     #endif
-    {
-        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
-        target->func = descr->d_method->ml_meth;
-        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
     }
-#endif
-    return 0;
-}
-
-/* CallUnboundCMethod1 */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) {
-    if (likely(cfunc->func)) {
-        int flag = cfunc->flag;
-        if (flag == METH_O) {
-            return (*(cfunc->func))(self, arg);
-        } else if (PY_VERSION_HEX >= 0x030600B1 && flag == METH_FASTCALL) {
-            if (PY_VERSION_HEX >= 0x030700A0) {
-                return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1);
-            } else {
-                return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
-            }
-        } else if (PY_VERSION_HEX >= 0x030700A0 && flag == (METH_FASTCALL | METH_KEYWORDS)) {
-            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
         }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
     }
-    return __Pyx__CallUnboundCMethod1(cfunc, self, arg);
-}
-#endif
-static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){
-    PyObject *args, *result = NULL;
-    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
-#if CYTHON_COMPILING_IN_CPYTHON
-    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
-        args = PyTuple_New(1);
-        if (unlikely(!args)) goto bad;
-        Py_INCREF(arg);
-        PyTuple_SET_ITEM(args, 0, arg);
-        if (cfunc->flag & METH_KEYWORDS)
-            result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
-        else
-            result = (*cfunc->func)(self, args);
-    } else {
-        args = PyTuple_New(2);
-        if (unlikely(!args)) goto bad;
-        Py_INCREF(self);
-        PyTuple_SET_ITEM(args, 0, self);
-        Py_INCREF(arg);
-        PyTuple_SET_ITEM(args, 1, arg);
-        result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
     }
-#else
-    args = PyTuple_Pack(2, self, arg);
-    if (unlikely(!args)) goto bad;
-    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
-#endif
-bad:
-    Py_XDECREF(args);
-    return result;
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
 }
 
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -13012,67 +20068,296 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* None */
+/* RaiseClosureNameError */
 static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) {
     PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname);
 }
 
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
 /* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
 static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
-    PyObject* fake_module;
-    PyTypeObject* cached_type = NULL;
-    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
-    if (!fake_module) return NULL;
-    Py_INCREF(fake_module);
-    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
     if (cached_type) {
-        if (!PyType_Check((PyObject*)cached_type)) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s is not a type object",
-                type->tp_name);
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
             goto bad;
         }
-        if (cached_type->tp_basicsize != type->tp_basicsize) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s has the wrong size, try recompiling",
-                type->tp_name);
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
             goto bad;
         }
-    } else {
-        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
-        PyErr_Clear();
-        if (PyType_Ready(type) < 0) goto bad;
-        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
-            goto bad;
-        Py_INCREF(type);
-        cached_type = type;
+        goto done;
     }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
 done:
-    Py_DECREF(fake_module);
-    return cached_type;
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
 bad:
     Py_XDECREF(cached_type);
     cached_type = NULL;
     goto done;
 }
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
 
 /* CythonFunctionShared */
-#include <structmember.h>
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
 static PyObject *
-__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
 {
+    CYTHON_UNUSED_VAR(closure);
     if (unlikely(op->func_doc == NULL)) {
-        if (op->func.m_ml->ml_doc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
 #if PY_MAJOR_VERSION >= 3
-            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
 #else
-            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
 #endif
             if (unlikely(op->func_doc == NULL))
                 return NULL;
@@ -13080,30 +20365,33 @@ __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure
             Py_INCREF(Py_None);
             return Py_None;
         }
+#endif
     }
     Py_INCREF(op->func_doc);
     return op->func_doc;
 }
 static int
-__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp = op->func_doc;
+    CYTHON_UNUSED_VAR(context);
     if (value == NULL) {
         value = Py_None;
     }
     Py_INCREF(value);
-    op->func_doc = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(op->func_name == NULL)) {
-#if PY_MAJOR_VERSION >= 3
-        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #else
-        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #endif
         if (unlikely(op->func_name == NULL))
             return NULL;
@@ -13112,9 +20400,9 @@ __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *contex
     return op->func_name;
 }
 static int
-__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -13125,22 +20413,21 @@ __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UN
                         "__name__ must be set to a string object");
         return -1;
     }
-    tmp = op->func_name;
     Py_INCREF(value);
-    op->func_name = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(op->func_qualname);
     return op->func_qualname;
 }
 static int
-__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -13151,25 +20438,14 @@ __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHO
                         "__qualname__ must be set to a string object");
         return -1;
     }
-    tmp = op->func_qualname;
     Py_INCREF(value);
-    op->func_qualname = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
-{
-    PyObject *self;
-    self = m->func_closure;
-    if (self == NULL)
-        self = Py_None;
-    Py_INCREF(self);
-    return self;
-}
-static PyObject *
-__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(op->func_dict == NULL)) {
         op->func_dict = PyDict_New();
         if (unlikely(op->func_dict == NULL))
@@ -13179,9 +20455,9 @@ __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *contex
     return op->func_dict;
 }
 static int
-__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(value == NULL)) {
         PyErr_SetString(PyExc_TypeError,
                "function's dictionary may not be deleted");
@@ -13192,28 +20468,30 @@ __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UN
                "setting function's dictionary to a non-dict");
         return -1;
     }
-    tmp = op->func_dict;
     Py_INCREF(value);
-    op->func_dict = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(op->func_globals);
     return op->func_globals;
 }
 static PyObject *
-__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(Py_None);
     return Py_None;
 }
 static PyObject *
-__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
 {
     PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(result);
     return result;
 }
@@ -13229,10 +20507,10 @@ __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
     op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
     Py_INCREF(op->defaults_kwdict);
     #else
-    op->defaults_tuple = PySequence_ITEM(res, 0);
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
     if (unlikely(!op->defaults_tuple)) result = -1;
     else {
-        op->defaults_kwdict = PySequence_ITEM(res, 1);
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
         if (unlikely(!op->defaults_kwdict)) result = -1;
     }
     #endif
@@ -13240,27 +20518,28 @@ __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
     return result;
 }
 static int
-__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value) {
         value = Py_None;
-    } else if (value != Py_None && !PyTuple_Check(value)) {
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
                         "__defaults__ must be set to a tuple object");
         return -1;
     }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
     Py_INCREF(value);
-    tmp = op->defaults_tuple;
-    op->defaults_tuple = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
     PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!result)) {
         if (op->defaults_getter) {
-            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
             result = op->defaults_tuple;
         } else {
             result = Py_None;
@@ -13270,27 +20549,28 @@ __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *co
     return result;
 }
 static int
-__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value) {
         value = Py_None;
-    } else if (value != Py_None && !PyDict_Check(value)) {
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
                         "__kwdefaults__ must be set to a dict object");
         return -1;
     }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
     Py_INCREF(value);
-    tmp = op->defaults_kwdict;
-    op->defaults_kwdict = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
     PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!result)) {
         if (op->defaults_getter) {
-            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
             result = op->defaults_kwdict;
         } else {
             result = Py_None;
@@ -13300,24 +20580,23 @@ __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *
     return result;
 }
 static int
-__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value || value == Py_None) {
         value = NULL;
-    } else if (!PyDict_Check(value)) {
+    } else if (unlikely(!PyDict_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
                         "__annotations__ must be set to a dict object");
         return -1;
     }
     Py_XINCREF(value);
-    tmp = op->func_annotations;
-    op->func_annotations = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
     PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!result)) {
         result = PyDict_New();
         if (unlikely(!result)) return NULL;
@@ -13326,13 +20605,62 @@ __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void
     Py_INCREF(result);
     return result;
 }
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
 static PyGetSetDef __pyx_CyFunction_getsets[] = {
     {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
     {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
     {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
     {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
     {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
-    {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
     {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
     {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
     {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
@@ -13345,49 +20673,88 @@ static PyGetSetDef __pyx_CyFunction_getsets[] = {
     {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
     {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
     {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
     {0, 0, 0, 0, 0}
 };
 static PyMemberDef __pyx_CyFunction_members[] = {
-    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
     {0, 0, 0,  0, 0}
 };
 static PyObject *
-__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
 {
+    CYTHON_UNUSED_VAR(args);
 #if PY_MAJOR_VERSION >= 3
     Py_INCREF(m->func_qualname);
     return m->func_qualname;
 #else
-    return PyString_FromString(m->func.m_ml->ml_name);
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
 #endif
 }
 static PyMethodDef __pyx_CyFunction_methods[] = {
     {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
     {0, 0, 0, 0}
 };
-#if PY_VERSION_HEX < 0x030500A0
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
 #else
-#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
 #endif
 static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
                                        PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
     if (unlikely(op == NULL))
         return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
     op->flags = flags;
     __Pyx_CyFunction_weakreflist(op) = NULL;
-    op->func.m_ml = ml;
-    op->func.m_self = (PyObject *) op;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
     Py_XINCREF(closure);
     op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
     Py_XINCREF(module);
-    op->func.m_module = module;
+    cf->m_module = module;
+#endif
     op->func_dict = NULL;
     op->func_name = NULL;
     Py_INCREF(qualname);
     op->func_qualname = qualname;
     op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
     op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
     op->func_globals = globals;
     Py_INCREF(op->func_globals);
     Py_XINCREF(code);
@@ -13399,23 +20766,62 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *
     op->defaults_kwdict = NULL;
     op->defaults_getter = NULL;
     op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
     return (PyObject *) op;
 }
 static int
 __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
 {
     Py_CLEAR(m->func_closure);
-    Py_CLEAR(m->func.m_module);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
     Py_CLEAR(m->func_dict);
     Py_CLEAR(m->func_name);
     Py_CLEAR(m->func_qualname);
     Py_CLEAR(m->func_doc);
     Py_CLEAR(m->func_globals);
     Py_CLEAR(m->func_code);
-    Py_CLEAR(m->func_classobj);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
     Py_CLEAR(m->defaults_tuple);
     Py_CLEAR(m->defaults_kwdict);
     Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
     if (m->defaults) {
         PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
         int i;
@@ -13431,7 +20837,7 @@ static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
     if (__Pyx_CyFunction_weakreflist(m) != NULL)
         PyObject_ClearWeakRefs((PyObject *) m);
     __Pyx_CyFunction_clear(m);
-    PyObject_GC_Del(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
 static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
 {
@@ -13441,16 +20847,23 @@ static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
 static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
 {
     Py_VISIT(m->func_closure);
-    Py_VISIT(m->func.m_module);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
     Py_VISIT(m->func_dict);
     Py_VISIT(m->func_name);
     Py_VISIT(m->func_qualname);
     Py_VISIT(m->func_doc);
     Py_VISIT(m->func_globals);
     Py_VISIT(m->func_code);
-    Py_VISIT(m->func_classobj);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
     Py_VISIT(m->defaults_tuple);
     Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
     if (m->defaults) {
         PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
         int i;
@@ -13459,24 +20872,6 @@ static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit,
     }
     return 0;
 }
-static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
-{
-#if PY_MAJOR_VERSION < 3
-    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
-    if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
-        Py_INCREF(func);
-        return func;
-    }
-    if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
-        if (type == NULL)
-            type = (PyObject *)(Py_TYPE(obj));
-        return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
-    }
-    if (obj == Py_None)
-        obj = NULL;
-#endif
-    return __Pyx_PyMethod_New(func, obj, type);
-}
 static PyObject*
 __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
 {
@@ -13489,10 +20884,22 @@ __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
 #endif
 }
 static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
     PyCFunctionObject* f = (PyCFunctionObject*)func;
     PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
     Py_ssize_t size;
-    switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
     case METH_VARARGS:
         if (likely(kw == NULL || PyDict_Size(kw) == 0))
             return (*meth)(self, arg);
@@ -13501,24 +20908,43 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py
         return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
     case METH_NOARGS:
         if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
             size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
             if (likely(size == 0))
                 return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
             PyErr_Format(PyExc_TypeError,
                 "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 f->m_ml->ml_name, size);
+#endif
             return NULL;
         }
         break;
     case METH_O:
         if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
             size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
             if (likely(size == 1)) {
                 PyObject *result, *arg0;
                 #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                 arg0 = PyTuple_GET_ITEM(arg, 0);
                 #else
-                arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
                 #endif
                 result = (*meth)(self, arg0);
                 #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
@@ -13526,58 +20952,264 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py
                 #endif
                 return result;
             }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
             PyErr_Format(PyExc_TypeError,
                 "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
             return NULL;
         }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
         break;
     default:
-        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
-                        "__Pyx_CyFunction_Call. METH_OLDARGS is no "
-                        "longer supported!");
         return NULL;
     }
-    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
-                 f->m_ml->ml_name);
-    return NULL;
-}
-static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
 }
-static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
-    PyObject *result;
-    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
-    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
-        Py_ssize_t argc;
-        PyObject *new_args;
-        PyObject *self;
-        argc = PyTuple_GET_SIZE(args);
-        new_args = PyTuple_GetSlice(args, 1, argc);
-        if (unlikely(!new_args))
-            return NULL;
-        self = PyTuple_GetItem(args, 0);
-        if (unlikely(!self)) {
-            Py_DECREF(new_args);
-            PyErr_Format(PyExc_TypeError,
-                         "unbound method %.200S() needs an argument",
-                         cyfunc->func_qualname);
-            return NULL;
-        }
-        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
-        Py_DECREF(new_args);
-    } else {
-        result = __Pyx_CyFunction_Call(func, args, kw);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    return result;
-}
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
 static PyTypeObject __pyx_CyFunctionType_type = {
     PyVarObject_HEAD_INIT(0, 0)
-    "cython_function_or_method",
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
     sizeof(__pyx_CyFunctionObject),
     0,
     (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
     0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
     0,
     0,
 #if PY_MAJOR_VERSION < 3
@@ -13595,7 +21227,13 @@ static PyTypeObject __pyx_CyFunctionType_type = {
     0,
     0,
     0,
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
     0,
     (traverseproc) __Pyx_CyFunction_traverse,
     (inquiry) __Pyx_CyFunction_clear,
@@ -13612,7 +21250,7 @@ static PyTypeObject __pyx_CyFunctionType_type = {
     __pyx_CyFunction_getsets,
     0,
     0,
-    __Pyx_CyFunction_descr_get,
+    __Pyx_PyMethod_New,
     0,
     offsetof(__pyx_CyFunctionObject, func_dict),
     0,
@@ -13633,15 +21271,27 @@ static PyTypeObject __pyx_CyFunctionType_type = {
 #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
     0,
 #endif
-#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
     0,
 #endif
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
     0,
 #endif
 };
-static int __pyx_CyFunction_init(void) {
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
     __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
     if (unlikely(__pyx_CyFunctionType == NULL)) {
         return -1;
     }
@@ -13693,20 +21343,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject
 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #endif
 {
-    PyObject *local_type, *local_value, *local_tb;
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
 #if CYTHON_FAST_THREAD_STATE
     PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
     local_type = tstate->curexc_type;
     local_value = tstate->curexc_value;
     local_tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
+  #endif
 #else
     PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
     if (unlikely(tstate->curexc_type))
 #else
     if (unlikely(PyErr_Occurred()))
@@ -13728,12 +21390,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
     #if CYTHON_USE_EXC_INFO_STACK
     {
         _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
         tmp_type = exc_info->exc_type;
         tmp_value = exc_info->exc_value;
         tmp_tb = exc_info->exc_traceback;
         exc_info->exc_type = local_type;
         exc_info->exc_value = local_value;
         exc_info->exc_traceback = local_tb;
+      #endif
     }
     #else
     tmp_type = tstate->exc_type;
@@ -13764,7 +21435,26 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
     tmp_type = exc_info->exc_type;
     tmp_value = exc_info->exc_value;
@@ -13772,14 +21462,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
     exc_info->exc_type = *type;
     exc_info->exc_value = *value;
     exc_info->exc_traceback = *tb;
-    #else
+  #else
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
-    #endif
+  #endif
     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
@@ -13796,12 +21486,12 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem *
 __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 {
     _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
            exc_info->previous_item != NULL)
     {
         exc_info = exc_info->previous_item;
@@ -13813,21 +21503,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 /* SaveResetException */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
     *type = exc_info->exc_type;
     *value = exc_info->exc_value;
     *tb = exc_info->exc_traceback;
-    #else
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
-    #endif
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
+  #endif
 }
 static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     #if CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -13848,9 +21563,16 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+  #endif
 }
 #endif
 
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
@@ -13886,7 +21608,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 {
     PyObject *result;
 #if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
     result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
@@ -13894,6 +21616,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     } else if (unlikely(PyErr_Occurred())) {
         return NULL;
     }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
 #else
     result = PyDict_GetItem(__pyx_d, name);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
@@ -13912,46 +21642,309 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     return __Pyx_GetBuiltinName(name);
 }
 
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
     }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
     }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
     return result;
 }
 
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
 /* PyObject_GenericGetAttrNoDict */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
     PyErr_Format(PyExc_AttributeError,
 #if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
 #endif
+    __Pyx_DECREF_TypeName(type_name);
     return NULL;
 }
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
@@ -13972,77 +21965,31 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj
     {
         descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
         if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
-    }
-    return descr;
-}
-#endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
-}
-#endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
-#endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
     }
+    return descr;
+}
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
     }
-    return result;
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
 }
+#endif
 
 /* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
   int ret;
   PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
   if (likely(name_attr)) {
       ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
   } else {
@@ -14108,7 +22055,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             } else if (reduce == object_reduce || PyErr_Occurred()) {
                 goto __PYX_BAD;
             }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
                 setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
@@ -14124,8 +22071,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     }
     goto __PYX_GOOD;
 __PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
     ret = -1;
 __PYX_GOOD:
 #if !CYTHON_USE_PYTYPE_LOOKUP
@@ -14141,18 +22093,21 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     Py_XDECREF(setstate_cython);
     return ret;
 }
+#endif
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
     PyObject *result = 0;
     char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
@@ -14163,8 +22118,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
             module_name, class_name);
         goto bad;
     }
-#ifndef Py_LIMITED_API
+#if !CYTHON_COMPILING_IN_LIMITED_API
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
 #else
     py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
     if (!py_basicsize)
@@ -14174,22 +22130,38 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
     py_basicsize = 0;
     if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
         goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
 #endif
-    if ((size_t)basicsize < size) {
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            module_name, class_name, size, basicsize+itemsize);
         goto bad;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
         goto bad;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
         PyOS_snprintf(warning, sizeof(warning),
             "%s.%s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
@@ -14205,39 +22177,32 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
 
 /* Import */
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
     PyObject *module = 0;
-    PyObject *global_dict = 0;
     PyObject *empty_dict = 0;
-    PyObject *list;
+    PyObject *empty_list = 0;
     #if PY_MAJOR_VERSION < 3
     PyObject *py_import;
     py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
+    if (unlikely(!py_import))
         goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
+    if (!from_list) {
         empty_list = PyList_New(0);
-        if (!empty_list)
+        if (unlikely(!empty_list))
             goto bad;
-        list = empty_list;
+        from_list = empty_list;
     }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
+    #endif
     empty_dict = PyDict_New();
-    if (!empty_dict)
+    if (unlikely(!empty_dict))
         goto bad;
     {
         #if PY_MAJOR_VERSION >= 3
         if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
                 module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
                         goto bad;
                     PyErr_Clear();
                 }
@@ -14248,23 +22213,23 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
         if (!module) {
             #if PY_MAJOR_VERSION < 3
             PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
+            if (unlikely(!py_level))
                 goto bad;
             module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
             Py_DECREF(py_level);
             #else
             module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
+                name, __pyx_d, empty_dict, from_list, level);
             #endif
         }
     }
 bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
     #if PY_MAJOR_VERSION < 3
     Py_XDECREF(py_import);
     #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
     return module;
 }
 
@@ -14272,6 +22237,35 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
     PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
     if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__4);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
         PyErr_Format(PyExc_ImportError,
         #if PY_MAJOR_VERSION < 3
             "cannot import name %.230s", PyString_AS_STRING(name));
@@ -14284,12 +22278,13 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -14303,7 +22298,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -14325,6 +22320,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -14403,17 +22399,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -14448,6 +22528,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -14463,7 +22544,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -14510,6 +22591,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -14534,7 +22616,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     }
 
 /* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
@@ -14564,10 +22646,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -14584,7 +22699,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -14593,168 +22708,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -14780,7 +22966,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -14789,168 +22975,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -14976,7 +23233,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -14985,168 +23242,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -15172,7 +23500,7 @@ static CYTHON_INLINE libssh2_uint64_t __Pyx_PyInt_As_libssh2_uint64_t(PyObject *
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(libssh2_uint64_t) < sizeof(long)) {
+        if ((sizeof(libssh2_uint64_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -15181,168 +23509,239 @@ static CYTHON_INLINE libssh2_uint64_t __Pyx_PyInt_As_libssh2_uint64_t(PyObject *
             }
             return (libssh2_uint64_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        libssh2_uint64_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (libssh2_uint64_t) -1;
+        val = __Pyx_PyInt_As_libssh2_uint64_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (libssh2_uint64_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (libssh2_uint64_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (libssh2_uint64_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(libssh2_uint64_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(libssh2_uint64_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(libssh2_uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(libssh2_uint64_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (libssh2_uint64_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(libssh2_uint64_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, long, PyLong_AsLong(x))
+        if ((sizeof(libssh2_uint64_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(libssh2_uint64_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(libssh2_uint64_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        libssh2_uint64_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (libssh2_uint64_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            libssh2_uint64_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (libssh2_uint64_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (libssh2_uint64_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (libssh2_uint64_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(libssh2_uint64_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((libssh2_uint64_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(libssh2_uint64_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((libssh2_uint64_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((libssh2_uint64_t) 1) << (sizeof(libssh2_uint64_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (libssh2_uint64_t) -1;
-        }
-    } else {
-        libssh2_uint64_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (libssh2_uint64_t) -1;
-        val = __Pyx_PyInt_As_libssh2_uint64_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -15368,7 +23767,7 @@ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(time_t) < sizeof(long)) {
+        if ((sizeof(time_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -15377,168 +23776,239 @@ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) {
             }
             return (time_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        time_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (time_t) -1;
+        val = __Pyx_PyInt_As_time_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (time_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(time_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(time_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) >= 2 * PyLong_SHIFT)) {
                             return (time_t) (((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) >= 3 * PyLong_SHIFT)) {
                             return (time_t) (((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) >= 4 * PyLong_SHIFT)) {
                             return (time_t) (((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (time_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (time_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(time_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(time_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (time_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(time_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(time_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(time_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (time_t) (((time_t)-1)*(((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (time_t) ((((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (time_t) (((time_t)-1)*(((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (time_t) ((((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (time_t) (((time_t)-1)*(((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(time_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (time_t) ((((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(time_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(time_t, long, PyLong_AsLong(x))
+        if ((sizeof(time_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(time_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(time_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(time_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(time_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(time_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        time_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (time_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            time_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (time_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (time_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (time_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(time_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((time_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(time_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((time_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((time_t) 1) << (sizeof(time_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (time_t) -1;
-        }
-    } else {
-        time_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (time_t) -1;
-        val = __Pyx_PyInt_As_time_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -15564,7 +24034,7 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned int) < sizeof(long)) {
+        if ((sizeof(unsigned int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -15573,168 +24043,239 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
             }
             return (unsigned int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyInt_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) {
                             return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) {
                             return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) {
                             return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned int) -1;
-        }
-    } else {
-        unsigned int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned int) -1;
-        val = __Pyx_PyInt_As_unsigned_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -15747,6 +24288,77 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
     return (unsigned int) -1;
 }
 
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -15778,18 +24390,67 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__89);
     }
+    return name;
 }
+#endif
 
 /* FastTypeChecks */
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -15810,6 +24471,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -15834,11 +24511,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -15886,47 +24563,56 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -15943,7 +24629,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -15951,21 +24636,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -15978,9 +24648,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -15988,30 +24680,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -16066,7 +24762,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -16095,22 +24791,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -16176,13 +24876,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -16250,4 +24948,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/session.pxd b/ssh2/session.pxd
index 0231dbdd..fffc668b 100644
--- a/ssh2/session.pxd
+++ b/ssh2/session.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-cimport c_ssh2
+from . cimport c_ssh2
 
 cdef class Session:
     cdef c_ssh2.LIBSSH2_SESSION *_session
diff --git a/ssh2/session.pyx b/ssh2/session.pyx
index c88fb275..9030ec5f 100644
--- a/ssh2/session.pyx
+++ b/ssh2/session.pyx
@@ -19,22 +19,22 @@ from libc.stdlib cimport malloc, free
 from libc.time cimport time_t
 from cython.operator cimport dereference as c_dereference
 
-from agent cimport PyAgent, agent_auth, agent_init, init_connect_agent
-from channel cimport PyChannel
-from exceptions import SessionHostKeyError, KnownHostError, \
+from .agent cimport PyAgent, agent_auth, agent_init, init_connect_agent
+from .channel cimport PyChannel
+from .exceptions import SessionHostKeyError, KnownHostError, \
     PublicKeyInitError, ChannelError
-from listener cimport PyListener
-from sftp cimport PySFTP
-from publickey cimport PyPublicKeySystem
-from utils cimport to_bytes, to_str, handle_error_codes
-from statinfo cimport StatInfo
-from knownhost cimport PyKnownHost
-from fileinfo cimport FileInfo
+from .listener cimport PyListener
+from .sftp cimport PySFTP
+from .publickey cimport PyPublicKeySystem
+from .utils cimport to_bytes, to_str, handle_error_codes
+from .statinfo cimport StatInfo
+from .knownhost cimport PyKnownHost
+from .fileinfo cimport FileInfo
 
 
-cimport c_ssh2
-cimport c_sftp
-cimport c_pkey
+from . cimport c_ssh2
+from . cimport c_sftp
+from . cimport c_pkey
 
 
 LIBSSH2_SESSION_BLOCK_INBOUND = c_ssh2.LIBSSH2_SESSION_BLOCK_INBOUND
@@ -130,8 +130,7 @@ cdef class Session:
     def startup(self, sock):
         """Deprecated - use self.handshake"""
         cdef int _sock = PyObject_AsFileDescriptor(sock)
-        cdef int rc
-        rc = c_ssh2.libssh2_session_startup(self._session, _sock)
+        cdef int rc = c_ssh2.libssh2_session_startup(self._session, _sock)
         return handle_error_codes(rc)
 
     def set_blocking(self, bint blocking):
@@ -181,7 +180,7 @@ cdef class Session:
         return bool(rc)
 
     def userauth_list(self, username not None):
-        """Retrieve available authentication methods list.
+        """Retrieve available authentication methodslist.
 
         :rtype: list"""
         cdef bytes b_username = to_bytes(username)
@@ -530,7 +529,7 @@ cdef class Session:
         try:
             if errmsg_len > 0:
                 msg = _error_msg[:errmsg_len]
-            return msg
+            return to_str(msg)
         finally:
             free(_error_msg)
 
@@ -763,6 +762,8 @@ cdef class Session:
 
         :rtype: str
         """
+        if not self.sock:
+            return
         with nogil:
             methods = c_ssh2.libssh2_session_methods(
                 self._session, method_type.value)
diff --git a/ssh2/sftp.c b/ssh2/sftp.c
index 0742948e..9a6bb885 100644
--- a/ssh2/sftp.c
+++ b/ssh2/sftp.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.sftp",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/sftp.pyx"
+        ]
+    },
+    "module_name": "ssh2.sftp"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -797,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -817,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -827,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -857,12 +1361,58 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
     PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
@@ -879,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -909,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -944,26 +1495,29 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/sftp.pyx",
-  "stringsource",
+  "<stringsource>",
   "ssh2/session.pxd",
   "ssh2/channel.pxd",
   "ssh2/sftp_handle.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -971,11 +1525,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -987,7 +1539,7 @@ struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS;
 struct __pyx_obj_4ssh2_4sftp_SFTP;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1083,6 +1635,7 @@ struct __pyx_obj_4ssh2_4sftp_SFTP {
   struct __pyx_obj_4ssh2_7session_Session *_session;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1091,11 +1644,11 @@ struct __pyx_obj_4ssh2_4sftp_SFTP {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1105,28 +1658,40 @@ struct __pyx_obj_4ssh2_4sftp_SFTP {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1137,6 +1702,10 @@ struct __pyx_obj_4ssh2_4sftp_SFTP {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1148,6 +1717,57 @@ struct __pyx_obj_4ssh2_4sftp_SFTP {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1155,15 +1775,83 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
 /* RaiseDoubleKeywords.proto */
 static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
 
 /* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
     const char* function_name);
 
 /* RaiseArgTupleInvalid.proto */
@@ -1173,42 +1861,42 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
 /* ExtTypeTest.proto */
 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
 
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
+#endif
+#endif
 #endif
 
 /* PyObjectCall.proto */
@@ -1223,58 +1911,22 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
 /* PyObjectCallOneArg.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
 
 /* PyObjectCallNoArg.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
-#else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
-#endif
 
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
-#endif
-
 /* GetException.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
@@ -1292,7 +1944,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1310,6 +1962,28 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1324,30 +1998,169 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
 #endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1383,6 +2196,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1396,18 +2210,19 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
 /* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
 
 /* CIntFromPy.proto */
 static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
@@ -1424,111 +2239,192 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* CIntFromPy.proto */
 static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
 
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.c_sftp' */
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "ssh2.c_sftp" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'ssh2.channel' */
-static PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel = 0;
+/* Module declarations from "libc.stdlib" */
+
+/* Module declarations from "ssh2.channel" */
 static PyObject *(*__pyx_f_4ssh2_7channel_PyChannel)(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *); /*proto*/
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static PyObject *(*__pyx_f_4ssh2_5utils_to_bytes)(PyObject *); /*proto*/
 static PyObject *(*__pyx_f_4ssh2_5utils_to_str_len)(char *, int); /*proto*/
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.sftp_handle' */
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = 0;
+/* Module declarations from "ssh2.sftp_handle" */
 static PyObject *(*__pyx_f_4ssh2_11sftp_handle_PySFTPHandle)(LIBSSH2_SFTP_HANDLE *, struct __pyx_obj_4ssh2_4sftp_SFTP *); /*proto*/
 
-/* Module declarations from 'ssh2.sftp' */
-static PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP = 0;
+/* Module declarations from "ssh2.sftp" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.sftp"
 extern int __pyx_module_is_main_ssh2__sftp;
 int __pyx_module_is_main_ssh2__sftp = 0;
 
-/* Implementation of 'ssh2.sftp' */
+/* Implementation of "ssh2.sftp" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__37[] = "?";
+static const char __pyx_k_vfs[] = "vfs";
 static const char __pyx_k_SFTP[] = "SFTP";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_mode[] = "mode";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_open[] = "open";
 static const char __pyx_k_path[] = "path";
+static const char __pyx_k_self[] = "self";
+static const char __pyx_k_stat[] = "stat";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_attrs[] = "attrs";
 static const char __pyx_k_flags[] = "flags";
+static const char __pyx_k_lstat[] = "lstat";
+static const char __pyx_k_mkdir[] = "mkdir";
+static const char __pyx_k_rmdir[] = "rmdir";
+static const char __pyx_k_b_path[] = "b_path";
+static const char __pyx_k_enable[] = "enable";
+static const char __pyx_k_handle[] = "_handle";
+static const char __pyx_k_path_2[] = "_path";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_rename[] = "rename";
 static const char __pyx_k_target[] = "target";
+static const char __pyx_k_unlink[] = "unlink";
+static const char __pyx_k_channel[] = "_channel";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_max_len[] = "max_len";
+static const char __pyx_k_open_ex[] = "open_ex";
+static const char __pyx_k_opendir[] = "opendir";
 static const char __pyx_k_session[] = "session";
+static const char __pyx_k_setstat[] = "setstat";
+static const char __pyx_k_statvfs[] = "statvfs";
+static const char __pyx_k_symlink[] = "symlink";
+static const char __pyx_k_b_target[] = "b_target";
 static const char __pyx_k_filename[] = "filename";
 static const char __pyx_k_getstate[] = "__getstate__";
+static const char __pyx_k_handle_2[] = "handle";
+static const char __pyx_k_path_len[] = "path_len";
+static const char __pyx_k_realpath[] = "realpath";
 static const char __pyx_k_setstate[] = "__setstate__";
+static const char __pyx_k_target_2[] = "_target";
+static const char __pyx_k_SFTP_open[] = "SFTP.open";
+static const char __pyx_k_SFTP_stat[] = "SFTP.stat";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
 static const char __pyx_k_open_type[] = "open_type";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
+static const char __pyx_k_rename_ex[] = "rename_ex";
+static const char __pyx_k_ssh2_sftp[] = "ssh2.sftp";
+static const char __pyx_k_SFTP_lstat[] = "SFTP.lstat";
+static const char __pyx_k_SFTP_mkdir[] = "SFTP.mkdir";
+static const char __pyx_k_SFTP_rmdir[] = "SFTP.rmdir";
+static const char __pyx_k_b_filename[] = "b_filename";
+static const char __pyx_k_filename_2[] = "_filename";
+static const char __pyx_k_last_error[] = "last_error";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_SFTP_rename[] = "SFTP.rename";
+static const char __pyx_k_SFTP_unlink[] = "SFTP.unlink";
+static const char __pyx_k_get_channel[] = "get_channel";
+static const char __pyx_k_SFTP_open_ex[] = "SFTP.open_ex";
+static const char __pyx_k_SFTP_opendir[] = "SFTP.opendir";
+static const char __pyx_k_SFTP_setstat[] = "SFTP.setstat";
+static const char __pyx_k_SFTP_statvfs[] = "SFTP.statvfs";
+static const char __pyx_k_SFTP_symlink[] = "SFTP.symlink";
 static const char __pyx_k_filename_len[] = "filename_len";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
+static const char __pyx_k_SFTP_realpath[] = "SFTP.realpath";
 static const char __pyx_k_dest_filename[] = "dest_filename";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_ssh2_sftp_pyx[] = "ssh2/sftp.pyx";
+static const char __pyx_k_SFTP_rename_ex[] = "SFTP.rename_ex";
+static const char __pyx_k_SFTP_last_error[] = "SFTP.last_error";
+static const char __pyx_k_b_dest_filename[] = "b_dest_filename";
+static const char __pyx_k_dest_filename_2[] = "_dest_filename";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
 static const char __pyx_k_source_filename[] = "source_filename";
 static const char __pyx_k_LIBSSH2_FXF_EXCL[] = "LIBSSH2_FXF_EXCL";
 static const char __pyx_k_LIBSSH2_FXF_READ[] = "LIBSSH2_FXF_READ";
+static const char __pyx_k_SFTP_get_channel[] = "SFTP.get_channel";
 static const char __pyx_k_LIBSSH2_FXF_CREAT[] = "LIBSSH2_FXF_CREAT";
 static const char __pyx_k_LIBSSH2_FXF_TRUNC[] = "LIBSSH2_FXF_TRUNC";
 static const char __pyx_k_LIBSSH2_FXF_WRITE[] = "LIBSSH2_FXF_WRITE";
+static const char __pyx_k_b_source_filename[] = "b_source_filename";
 static const char __pyx_k_dest_filename_len[] = "dest_filename_len";
+static const char __pyx_k_source_filename_2[] = "_source_filename";
 static const char __pyx_k_LIBSSH2_FXF_APPEND[] = "LIBSSH2_FXF_APPEND";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
 static const char __pyx_k_LIBSSH2_SFTP_S_IFMT[] = "LIBSSH2_SFTP_S_IFMT";
 static const char __pyx_k_source_filename_len[] = "source_filename_len";
@@ -1550,77 +2446,19 @@ static const char __pyx_k_LIBSSH2_SFTP_S_IWUSR[] = "LIBSSH2_SFTP_S_IWUSR";
 static const char __pyx_k_LIBSSH2_SFTP_S_IXGRP[] = "LIBSSH2_SFTP_S_IXGRP";
 static const char __pyx_k_LIBSSH2_SFTP_S_IXOTH[] = "LIBSSH2_SFTP_S_IXOTH";
 static const char __pyx_k_LIBSSH2_SFTP_S_IXUSR[] = "LIBSSH2_SFTP_S_IXUSR";
+static const char __pyx_k_SFTP___reduce_cython[] = "SFTP.__reduce_cython__";
 static const char __pyx_k_LIBSSH2_SFTP_S_IFSOCK[] = "LIBSSH2_SFTP_S_IFSOCK";
 static const char __pyx_k_LIBSSH2_SFTP_ATTR_SIZE[] = "LIBSSH2_SFTP_ATTR_SIZE";
 static const char __pyx_k_LIBSSH2_SFTP_ST_NOSUID[] = "LIBSSH2_SFTP_ST_NOSUID";
 static const char __pyx_k_LIBSSH2_SFTP_ST_RDONLY[] = "LIBSSH2_SFTP_ST_RDONLY";
+static const char __pyx_k_SFTP___setstate_cython[] = "SFTP.__setstate_cython__";
 static const char __pyx_k_LIBSSH2_SFTP_ATTR_UIDGID[] = "LIBSSH2_SFTP_ATTR_UIDGID";
 static const char __pyx_k_LIBSSH2_SFTP_ATTR_EXTENDED[] = "LIBSSH2_SFTP_ATTR_EXTENDED";
 static const char __pyx_k_LIBSSH2_SFTP_ATTR_ACMODTIME[] = "LIBSSH2_SFTP_ATTR_ACMODTIME";
 static const char __pyx_k_LIBSSH2_SFTP_ATTR_PERMISSIONS[] = "LIBSSH2_SFTP_ATTR_PERMISSIONS";
 static const char __pyx_k_SFTP_channel_class_and_related[] = "\nSFTP channel class and related SFTP flags.\n\nFile types\n------------\n:var LIBSSH2_SFTP_S_IFMT: Type of file mask\n:var LIBSSH2_SFTP_S_IFIFO: Named pipe (fifo)\n:var LIBSSH2_SFTP_S_IFCHR: Character special (character device)\n:var LIBSSH2_SFTP_S_IFDIR: Directory\n:var LIBSSH2_SFTP_S_IFBLK: Block special (block device)\n:var LIBSSH2_SFTP_S_IFREG: Regular file\n:var LIBSSH2_SFTP_S_IFLNK: Symbolic link\n:var LIBSSH2_SFTP_S_IFSOCK: Socket\n\nFile transfer flags\n--------------------\n:var LIBSSH2_FXF_READ: File read flag\n:var LIBSSH2_FXF_WRITE: File write flag\n:var LIBSSH2_FXF_APPEND: File append flag\n:var LIBSSH2_FXF_CREAT: File create flag\n:var LIBSSH2_FXF_TRUNC: File truncate flag\n:var LIBSSH2_FXF_EXCL: Exclusive file flag\n\n\nFile Attributes\n----------------\n\nThese flags need to be set on `SFTPAttributes.attrs` when changing any of their\nassociated attributes via `setstat`.\n\n:var LIBSSH2_SFTP_ATTR_SIZE: Size attribute flag\n:var LIBSSH2_SFTP_ATTR_UIDGID: UID and GID attribute flag\n:var LIBSSH2_SFTP_ATTR_PERMISSIONS: Permissions attribute flag\n:var LIBSSH2_SFTP_ATTR_ACMODTIME: File access/created/modified time attribute\n  flag\n:var LIBSSH2_SFTP_ATTR_EXTENDED: Extended attributes flag\n\n\nFile mode masks\n-----------------\n\nOwner masks\n_____________\n\n:var LIBSSH2_SFTP_S_IRWXU: Read/write/execute\n:var LIBSSH2_SFTP_S_IRUSR: Read\n:var LIBSSH2_SFTP_S_IWUSR: Write\n:var LIBSSH2_SFTP_S_IXUSR: Execute\n\nGroup masks\n____________\n\n:var LIBSSH2_SFTP_S_IRWXG: Read/write/execute\n:var LIBSSH2_SFTP_S_IRGRP: Read\n:var LIBSSH2_SFTP_S_IWUSR: Write\n:var LIBSSH2_SFTP_S_IXUSR: Execute\n\nOther masks\n____________\n\n:var LIBSSH2_SFTP_S_IRWXO: Read/write/execute\n:var LIBSSH2_SFTP_S_IROTH: Read\n:var LIBSSH2_SFTP_S_IWOTH: Write\n:var LIBSSH2_SFTP_S_IXOTH: Execute\n\nGeneric mode masks\n___________________\n\n:var LIBSSH2_SFTP_ST_RDONLY: Read only\n:var LIBSSH2_SFTP_ST_NOSUID: No suid\n";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_LIBSSH2_FXF_APPEND;
-static PyObject *__pyx_n_s_LIBSSH2_FXF_CREAT;
-static PyObject *__pyx_n_s_LIBSSH2_FXF_EXCL;
-static PyObject *__pyx_n_s_LIBSSH2_FXF_READ;
-static PyObject *__pyx_n_s_LIBSSH2_FXF_TRUNC;
-static PyObject *__pyx_n_s_LIBSSH2_FXF_WRITE;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFBLK;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFCHR;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFDIR;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFIFO;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFLNK;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFMT;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFREG;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRGRP;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IROTH;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRUSR;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXG;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXO;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXU;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWGRP;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWOTH;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWUSR;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXGRP;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXOTH;
-static PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXUSR;
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_SFTP;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_attrs;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_dest_filename;
-static PyObject *__pyx_n_s_dest_filename_len;
-static PyObject *__pyx_n_s_filename;
-static PyObject *__pyx_n_s_filename_len;
-static PyObject *__pyx_n_s_flags;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_max_len;
-static PyObject *__pyx_n_s_mode;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_open_type;
-static PyObject *__pyx_n_s_path;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_source_filename;
-static PyObject *__pyx_n_s_source_filename_len;
-static PyObject *__pyx_n_s_target;
-static PyObject *__pyx_n_s_test;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self, PyObject *__pyx_v_session); /* proto */
 static void __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_7session___get__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self); /* proto */
@@ -1643,9 +2481,848 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_34last_error(struct __pyx_obj_4ssh2_
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_36__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_38__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_4sftp_SFTP(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7channel_Channel;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS;
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_4sftp_SFTP;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_APPEND;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_CREAT;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_EXCL;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_READ;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_TRUNC;
+  PyObject *__pyx_n_s_LIBSSH2_FXF_WRITE;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFBLK;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFCHR;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFDIR;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFIFO;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFLNK;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFMT;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFREG;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRGRP;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IROTH;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRUSR;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXG;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXO;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IRWXU;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWGRP;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWOTH;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IWUSR;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXGRP;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXOTH;
+  PyObject *__pyx_n_s_LIBSSH2_SFTP_S_IXUSR;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_SFTP;
+  PyObject *__pyx_n_s_SFTP___reduce_cython;
+  PyObject *__pyx_n_s_SFTP___setstate_cython;
+  PyObject *__pyx_n_s_SFTP_get_channel;
+  PyObject *__pyx_n_s_SFTP_last_error;
+  PyObject *__pyx_n_s_SFTP_lstat;
+  PyObject *__pyx_n_s_SFTP_mkdir;
+  PyObject *__pyx_n_s_SFTP_open;
+  PyObject *__pyx_n_s_SFTP_open_ex;
+  PyObject *__pyx_n_s_SFTP_opendir;
+  PyObject *__pyx_n_s_SFTP_realpath;
+  PyObject *__pyx_n_s_SFTP_rename;
+  PyObject *__pyx_n_s_SFTP_rename_ex;
+  PyObject *__pyx_n_s_SFTP_rmdir;
+  PyObject *__pyx_n_s_SFTP_setstat;
+  PyObject *__pyx_n_s_SFTP_stat;
+  PyObject *__pyx_n_s_SFTP_statvfs;
+  PyObject *__pyx_n_s_SFTP_symlink;
+  PyObject *__pyx_n_s_SFTP_unlink;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s__37;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_attrs;
+  PyObject *__pyx_n_s_b_dest_filename;
+  PyObject *__pyx_n_s_b_filename;
+  PyObject *__pyx_n_s_b_path;
+  PyObject *__pyx_n_s_b_source_filename;
+  PyObject *__pyx_n_s_b_target;
+  PyObject *__pyx_n_s_channel;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_dest_filename;
+  PyObject *__pyx_n_s_dest_filename_2;
+  PyObject *__pyx_n_s_dest_filename_len;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_filename;
+  PyObject *__pyx_n_s_filename_2;
+  PyObject *__pyx_n_s_filename_len;
+  PyObject *__pyx_n_s_flags;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_get_channel;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_handle;
+  PyObject *__pyx_n_s_handle_2;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_last_error;
+  PyObject *__pyx_n_s_lstat;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_max_len;
+  PyObject *__pyx_n_s_mkdir;
+  PyObject *__pyx_n_s_mode;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_open;
+  PyObject *__pyx_n_s_open_ex;
+  PyObject *__pyx_n_s_open_type;
+  PyObject *__pyx_n_s_opendir;
+  PyObject *__pyx_n_s_path;
+  PyObject *__pyx_n_s_path_2;
+  PyObject *__pyx_n_s_path_len;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_realpath;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_rename;
+  PyObject *__pyx_n_s_rename_ex;
+  PyObject *__pyx_n_s_rmdir;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_setstat;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_source_filename;
+  PyObject *__pyx_n_s_source_filename_2;
+  PyObject *__pyx_n_s_source_filename_len;
+  PyObject *__pyx_n_s_ssh2_sftp;
+  PyObject *__pyx_kp_s_ssh2_sftp_pyx;
+  PyObject *__pyx_n_s_stat;
+  PyObject *__pyx_n_s_statvfs;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_symlink;
+  PyObject *__pyx_n_s_target;
+  PyObject *__pyx_n_s_target_2;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_unlink;
+  PyObject *__pyx_n_s_vfs;
+  PyObject *__pyx_int_256;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_tuple__9;
+  PyObject *__pyx_tuple__11;
+  PyObject *__pyx_tuple__13;
+  PyObject *__pyx_tuple__15;
+  PyObject *__pyx_tuple__17;
+  PyObject *__pyx_tuple__19;
+  PyObject *__pyx_tuple__21;
+  PyObject *__pyx_tuple__24;
+  PyObject *__pyx_tuple__26;
+  PyObject *__pyx_tuple__28;
+  PyObject *__pyx_tuple__30;
+  PyObject *__pyx_tuple__31;
+  PyObject *__pyx_tuple__33;
+  PyObject *__pyx_tuple__35;
+  PyObject *__pyx_codeobj__2;
+  PyObject *__pyx_codeobj__4;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__8;
+  PyObject *__pyx_codeobj__10;
+  PyObject *__pyx_codeobj__12;
+  PyObject *__pyx_codeobj__14;
+  PyObject *__pyx_codeobj__16;
+  PyObject *__pyx_codeobj__18;
+  PyObject *__pyx_codeobj__20;
+  PyObject *__pyx_codeobj__22;
+  PyObject *__pyx_codeobj__23;
+  PyObject *__pyx_codeobj__25;
+  PyObject *__pyx_codeobj__27;
+  PyObject *__pyx_codeobj__29;
+  PyObject *__pyx_codeobj__32;
+  PyObject *__pyx_codeobj__34;
+  PyObject *__pyx_codeobj__36;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_4sftp_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_APPEND);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_CREAT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_EXCL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_READ);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_TRUNC);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_FXF_WRITE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFBLK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFCHR);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFDIR);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFIFO);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFLNK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFMT);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFREG);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRGRP);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IROTH);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRUSR);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXG);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXO);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXU);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWGRP);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWOTH);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWUSR);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXGRP);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXOTH);
+  Py_CLEAR(clear_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXUSR);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_get_channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_lstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_mkdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_open);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_open_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_opendir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_realpath);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_rename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_rename_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_rmdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_setstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_stat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_statvfs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_symlink);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTP_unlink);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__37);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_attrs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_dest_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_source_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_target);
+  Py_CLEAR(clear_module_state->__pyx_n_s_channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_dest_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_dest_filename_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_dest_filename_len);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_filename_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_filename_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_flags);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_get_channel);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handle);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handle_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_last_error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_lstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_max_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mkdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_mode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_open);
+  Py_CLEAR(clear_module_state->__pyx_n_s_open_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_open_type);
+  Py_CLEAR(clear_module_state->__pyx_n_s_opendir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_path_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_realpath);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rename_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rmdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_source_filename);
+  Py_CLEAR(clear_module_state->__pyx_n_s_source_filename_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_source_filename_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_sftp);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_sftp_pyx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_stat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_statvfs);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_symlink);
+  Py_CLEAR(clear_module_state->__pyx_n_s_target);
+  Py_CLEAR(clear_module_state->__pyx_n_s_target_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_unlink);
+  Py_CLEAR(clear_module_state->__pyx_n_s_vfs);
+  Py_CLEAR(clear_module_state->__pyx_int_256);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_tuple__9);
+  Py_CLEAR(clear_module_state->__pyx_tuple__11);
+  Py_CLEAR(clear_module_state->__pyx_tuple__13);
+  Py_CLEAR(clear_module_state->__pyx_tuple__15);
+  Py_CLEAR(clear_module_state->__pyx_tuple__17);
+  Py_CLEAR(clear_module_state->__pyx_tuple__19);
+  Py_CLEAR(clear_module_state->__pyx_tuple__21);
+  Py_CLEAR(clear_module_state->__pyx_tuple__24);
+  Py_CLEAR(clear_module_state->__pyx_tuple__26);
+  Py_CLEAR(clear_module_state->__pyx_tuple__28);
+  Py_CLEAR(clear_module_state->__pyx_tuple__30);
+  Py_CLEAR(clear_module_state->__pyx_tuple__31);
+  Py_CLEAR(clear_module_state->__pyx_tuple__33);
+  Py_CLEAR(clear_module_state->__pyx_tuple__35);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__2);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__10);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__12);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__14);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__16);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__18);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__20);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__23);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__25);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__27);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__29);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__32);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__34);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__36);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7channel_Channel);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_4sftp_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_APPEND);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_CREAT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_EXCL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_READ);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_TRUNC);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_FXF_WRITE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFBLK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFCHR);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFDIR);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFIFO);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFLNK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFMT);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFREG);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRGRP);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IROTH);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRUSR);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXG);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXO);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IRWXU);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWGRP);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWOTH);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IWUSR);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXGRP);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXOTH);
+  Py_VISIT(traverse_module_state->__pyx_n_s_LIBSSH2_SFTP_S_IXUSR);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_get_channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_lstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_mkdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_open);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_open_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_opendir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_realpath);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_rename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_rename_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_rmdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_setstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_stat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_statvfs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_symlink);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTP_unlink);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__37);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_attrs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_dest_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_source_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_target);
+  Py_VISIT(traverse_module_state->__pyx_n_s_channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_dest_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_dest_filename_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_dest_filename_len);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_filename_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_filename_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_flags);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_get_channel);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handle);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handle_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_last_error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_lstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_max_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mkdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_mode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_open);
+  Py_VISIT(traverse_module_state->__pyx_n_s_open_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_open_type);
+  Py_VISIT(traverse_module_state->__pyx_n_s_opendir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_path_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_realpath);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rename_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rmdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_source_filename);
+  Py_VISIT(traverse_module_state->__pyx_n_s_source_filename_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_source_filename_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_sftp);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_sftp_pyx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_stat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_statvfs);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_symlink);
+  Py_VISIT(traverse_module_state->__pyx_n_s_target);
+  Py_VISIT(traverse_module_state->__pyx_n_s_target_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_unlink);
+  Py_VISIT(traverse_module_state->__pyx_n_s_vfs);
+  Py_VISIT(traverse_module_state->__pyx_int_256);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_tuple__9);
+  Py_VISIT(traverse_module_state->__pyx_tuple__11);
+  Py_VISIT(traverse_module_state->__pyx_tuple__13);
+  Py_VISIT(traverse_module_state->__pyx_tuple__15);
+  Py_VISIT(traverse_module_state->__pyx_tuple__17);
+  Py_VISIT(traverse_module_state->__pyx_tuple__19);
+  Py_VISIT(traverse_module_state->__pyx_tuple__21);
+  Py_VISIT(traverse_module_state->__pyx_tuple__24);
+  Py_VISIT(traverse_module_state->__pyx_tuple__26);
+  Py_VISIT(traverse_module_state->__pyx_tuple__28);
+  Py_VISIT(traverse_module_state->__pyx_tuple__30);
+  Py_VISIT(traverse_module_state->__pyx_tuple__31);
+  Py_VISIT(traverse_module_state->__pyx_tuple__33);
+  Py_VISIT(traverse_module_state->__pyx_tuple__35);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__2);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__10);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__12);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__14);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__16);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__18);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__20);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__23);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__25);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__27);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__29);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__32);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__34);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__36);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7channel_Channel __pyx_mstate_global->__pyx_ptype_4ssh2_7channel_Channel
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_4sftp_SFTP __pyx_mstate_global->__pyx_type_4ssh2_4sftp_SFTP
+#endif
+#define __pyx_ptype_4ssh2_4sftp_SFTP __pyx_mstate_global->__pyx_ptype_4ssh2_4sftp_SFTP
+#define __pyx_n_s_LIBSSH2_FXF_APPEND __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_APPEND
+#define __pyx_n_s_LIBSSH2_FXF_CREAT __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_CREAT
+#define __pyx_n_s_LIBSSH2_FXF_EXCL __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_EXCL
+#define __pyx_n_s_LIBSSH2_FXF_READ __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_READ
+#define __pyx_n_s_LIBSSH2_FXF_TRUNC __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_TRUNC
+#define __pyx_n_s_LIBSSH2_FXF_WRITE __pyx_mstate_global->__pyx_n_s_LIBSSH2_FXF_WRITE
+#define __pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME
+#define __pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED
+#define __pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS
+#define __pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE
+#define __pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID
+#define __pyx_n_s_LIBSSH2_SFTP_ST_NOSUID __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID
+#define __pyx_n_s_LIBSSH2_SFTP_ST_RDONLY __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFBLK __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFBLK
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFCHR __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFCHR
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFDIR __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFDIR
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFIFO __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFIFO
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFLNK __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFLNK
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFMT __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFMT
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFREG __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFREG
+#define __pyx_n_s_LIBSSH2_SFTP_S_IFSOCK __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK
+#define __pyx_n_s_LIBSSH2_SFTP_S_IRGRP __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IRGRP
+#define __pyx_n_s_LIBSSH2_SFTP_S_IROTH __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IROTH
+#define __pyx_n_s_LIBSSH2_SFTP_S_IRUSR __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IRUSR
+#define __pyx_n_s_LIBSSH2_SFTP_S_IRWXG __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IRWXG
+#define __pyx_n_s_LIBSSH2_SFTP_S_IRWXO __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IRWXO
+#define __pyx_n_s_LIBSSH2_SFTP_S_IRWXU __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IRWXU
+#define __pyx_n_s_LIBSSH2_SFTP_S_IWGRP __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IWGRP
+#define __pyx_n_s_LIBSSH2_SFTP_S_IWOTH __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IWOTH
+#define __pyx_n_s_LIBSSH2_SFTP_S_IWUSR __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IWUSR
+#define __pyx_n_s_LIBSSH2_SFTP_S_IXGRP __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IXGRP
+#define __pyx_n_s_LIBSSH2_SFTP_S_IXOTH __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IXOTH
+#define __pyx_n_s_LIBSSH2_SFTP_S_IXUSR __pyx_mstate_global->__pyx_n_s_LIBSSH2_SFTP_S_IXUSR
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_SFTP __pyx_mstate_global->__pyx_n_s_SFTP
+#define __pyx_n_s_SFTP___reduce_cython __pyx_mstate_global->__pyx_n_s_SFTP___reduce_cython
+#define __pyx_n_s_SFTP___setstate_cython __pyx_mstate_global->__pyx_n_s_SFTP___setstate_cython
+#define __pyx_n_s_SFTP_get_channel __pyx_mstate_global->__pyx_n_s_SFTP_get_channel
+#define __pyx_n_s_SFTP_last_error __pyx_mstate_global->__pyx_n_s_SFTP_last_error
+#define __pyx_n_s_SFTP_lstat __pyx_mstate_global->__pyx_n_s_SFTP_lstat
+#define __pyx_n_s_SFTP_mkdir __pyx_mstate_global->__pyx_n_s_SFTP_mkdir
+#define __pyx_n_s_SFTP_open __pyx_mstate_global->__pyx_n_s_SFTP_open
+#define __pyx_n_s_SFTP_open_ex __pyx_mstate_global->__pyx_n_s_SFTP_open_ex
+#define __pyx_n_s_SFTP_opendir __pyx_mstate_global->__pyx_n_s_SFTP_opendir
+#define __pyx_n_s_SFTP_realpath __pyx_mstate_global->__pyx_n_s_SFTP_realpath
+#define __pyx_n_s_SFTP_rename __pyx_mstate_global->__pyx_n_s_SFTP_rename
+#define __pyx_n_s_SFTP_rename_ex __pyx_mstate_global->__pyx_n_s_SFTP_rename_ex
+#define __pyx_n_s_SFTP_rmdir __pyx_mstate_global->__pyx_n_s_SFTP_rmdir
+#define __pyx_n_s_SFTP_setstat __pyx_mstate_global->__pyx_n_s_SFTP_setstat
+#define __pyx_n_s_SFTP_stat __pyx_mstate_global->__pyx_n_s_SFTP_stat
+#define __pyx_n_s_SFTP_statvfs __pyx_mstate_global->__pyx_n_s_SFTP_statvfs
+#define __pyx_n_s_SFTP_symlink __pyx_mstate_global->__pyx_n_s_SFTP_symlink
+#define __pyx_n_s_SFTP_unlink __pyx_mstate_global->__pyx_n_s_SFTP_unlink
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s__37 __pyx_mstate_global->__pyx_n_s__37
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_attrs __pyx_mstate_global->__pyx_n_s_attrs
+#define __pyx_n_s_b_dest_filename __pyx_mstate_global->__pyx_n_s_b_dest_filename
+#define __pyx_n_s_b_filename __pyx_mstate_global->__pyx_n_s_b_filename
+#define __pyx_n_s_b_path __pyx_mstate_global->__pyx_n_s_b_path
+#define __pyx_n_s_b_source_filename __pyx_mstate_global->__pyx_n_s_b_source_filename
+#define __pyx_n_s_b_target __pyx_mstate_global->__pyx_n_s_b_target
+#define __pyx_n_s_channel __pyx_mstate_global->__pyx_n_s_channel
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_dest_filename __pyx_mstate_global->__pyx_n_s_dest_filename
+#define __pyx_n_s_dest_filename_2 __pyx_mstate_global->__pyx_n_s_dest_filename_2
+#define __pyx_n_s_dest_filename_len __pyx_mstate_global->__pyx_n_s_dest_filename_len
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_filename __pyx_mstate_global->__pyx_n_s_filename
+#define __pyx_n_s_filename_2 __pyx_mstate_global->__pyx_n_s_filename_2
+#define __pyx_n_s_filename_len __pyx_mstate_global->__pyx_n_s_filename_len
+#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_get_channel __pyx_mstate_global->__pyx_n_s_get_channel
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_handle __pyx_mstate_global->__pyx_n_s_handle
+#define __pyx_n_s_handle_2 __pyx_mstate_global->__pyx_n_s_handle_2
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_last_error __pyx_mstate_global->__pyx_n_s_last_error
+#define __pyx_n_s_lstat __pyx_mstate_global->__pyx_n_s_lstat
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_max_len __pyx_mstate_global->__pyx_n_s_max_len
+#define __pyx_n_s_mkdir __pyx_mstate_global->__pyx_n_s_mkdir
+#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_open __pyx_mstate_global->__pyx_n_s_open
+#define __pyx_n_s_open_ex __pyx_mstate_global->__pyx_n_s_open_ex
+#define __pyx_n_s_open_type __pyx_mstate_global->__pyx_n_s_open_type
+#define __pyx_n_s_opendir __pyx_mstate_global->__pyx_n_s_opendir
+#define __pyx_n_s_path __pyx_mstate_global->__pyx_n_s_path
+#define __pyx_n_s_path_2 __pyx_mstate_global->__pyx_n_s_path_2
+#define __pyx_n_s_path_len __pyx_mstate_global->__pyx_n_s_path_len
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_realpath __pyx_mstate_global->__pyx_n_s_realpath
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_rename __pyx_mstate_global->__pyx_n_s_rename
+#define __pyx_n_s_rename_ex __pyx_mstate_global->__pyx_n_s_rename_ex
+#define __pyx_n_s_rmdir __pyx_mstate_global->__pyx_n_s_rmdir
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_setstat __pyx_mstate_global->__pyx_n_s_setstat
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_source_filename __pyx_mstate_global->__pyx_n_s_source_filename
+#define __pyx_n_s_source_filename_2 __pyx_mstate_global->__pyx_n_s_source_filename_2
+#define __pyx_n_s_source_filename_len __pyx_mstate_global->__pyx_n_s_source_filename_len
+#define __pyx_n_s_ssh2_sftp __pyx_mstate_global->__pyx_n_s_ssh2_sftp
+#define __pyx_kp_s_ssh2_sftp_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_sftp_pyx
+#define __pyx_n_s_stat __pyx_mstate_global->__pyx_n_s_stat
+#define __pyx_n_s_statvfs __pyx_mstate_global->__pyx_n_s_statvfs
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_symlink __pyx_mstate_global->__pyx_n_s_symlink
+#define __pyx_n_s_target __pyx_mstate_global->__pyx_n_s_target
+#define __pyx_n_s_target_2 __pyx_mstate_global->__pyx_n_s_target_2
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_unlink __pyx_mstate_global->__pyx_n_s_unlink
+#define __pyx_n_s_vfs __pyx_mstate_global->__pyx_n_s_vfs
+#define __pyx_int_256 __pyx_mstate_global->__pyx_int_256
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13
+#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19
+#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
+#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24
+#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26
+#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28
+#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30
+#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31
+#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33
+#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35
+#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10
+#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12
+#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14
+#define __pyx_codeobj__16 __pyx_mstate_global->__pyx_codeobj__16
+#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18
+#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23
+#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25
+#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27
+#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29
+#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32
+#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34
+#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36
+/* #### Code section: module_code ### */
 
 /* "ssh2/sftp.pyx":164
  * 
@@ -1664,7 +3341,7 @@ static PyObject *__pyx_f_4ssh2_4sftp_PySFTP(LIBSSH2_SFTP *__pyx_v_sftp, struct _
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PySFTP", 0);
+  __Pyx_RefNannySetupContext("PySFTP", 1);
 
   /* "ssh2/sftp.pyx":165
  * 
@@ -1675,11 +3352,11 @@ static PyObject *__pyx_f_4ssh2_4sftp_PySFTP(LIBSSH2_SFTP *__pyx_v_sftp, struct _
  */
   __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_session));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_session));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_session);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_session);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_session))) __PYX_ERR(0, 165, __pyx_L1_error);
   __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_4sftp_SFTP(((PyTypeObject *)__pyx_ptype_4ssh2_4sftp_SFTP), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__sftp = ((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_t_2);
   __pyx_t_2 = 0;
@@ -1701,7 +3378,7 @@ static PyObject *__pyx_f_4ssh2_4sftp_PySFTP(LIBSSH2_SFTP *__pyx_v_sftp, struct _
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__sftp));
+  __Pyx_INCREF((PyObject *)__pyx_v__sftp);
   __pyx_r = ((PyObject *)__pyx_v__sftp);
   goto __pyx_L0;
 
@@ -1738,44 +3415,64 @@ static PyObject *__pyx_f_4ssh2_4sftp_PySFTP(LIBSSH2_SFTP *__pyx_v_sftp, struct _
 static int __pyx_pw_4ssh2_4sftp_4SFTP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_4sftp_4SFTP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_session = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_session,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 176, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 176, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 176, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v_session = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 176, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 176, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
@@ -1783,8 +3480,14 @@ static int __pyx_pw_4ssh2_4sftp_4SFTP_1__cinit__(PyObject *__pyx_v_self, PyObjec
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_session);
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
 static int __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self, PyObject *__pyx_v_session) {
@@ -1794,7 +3497,7 @@ static int __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(struct __pyx_obj_4ssh2_4sftp_SFT
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/sftp.pyx":177
  * 
@@ -1816,8 +3519,8 @@ static int __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(struct __pyx_obj_4ssh2_4sftp_SFT
   __pyx_t_1 = __pyx_v_session;
   __Pyx_INCREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_1);
-  __Pyx_GOTREF(__pyx_v_self->_session);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_session);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_session);
   __pyx_v_self->_session = ((struct __pyx_obj_4ssh2_7session_Session *)__pyx_t_1);
   __pyx_t_1 = 0;
 
@@ -1852,8 +3555,10 @@ static int __pyx_pf_4ssh2_4sftp_4SFTP___cinit__(struct __pyx_obj_4ssh2_4sftp_SFT
 /* Python wrapper */
 static void __pyx_pw_4ssh2_4sftp_4SFTP_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_4sftp_4SFTP_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self));
 
   /* function exit code */
@@ -1861,11 +3566,8 @@ static void __pyx_pw_4ssh2_4sftp_4SFTP_3__dealloc__(PyObject *__pyx_v_self) {
 }
 
 static void __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_t_2;
-  int __pyx_t_3;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/sftp.pyx":181
  * 
@@ -1875,20 +3577,19 @@ static void __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(struct __pyx_obj_4ssh2_4sftp
  *                 c_sftp.libssh2_sftp_shutdown(self._sftp)
  */
   __pyx_t_2 = (((PyObject *)__pyx_v_self->_session) != Py_None);
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_session->_session != NULL) != 0);
-  if (__pyx_t_3) {
+  __pyx_t_2 = (__pyx_v_self->_session->_session != NULL);
+  if (__pyx_t_2) {
   } else {
-    __pyx_t_1 = __pyx_t_3;
+    __pyx_t_1 = __pyx_t_2;
     goto __pyx_L4_bool_binop_done;
   }
-  __pyx_t_3 = ((__pyx_v_self->_sftp != NULL) != 0);
-  __pyx_t_1 = __pyx_t_3;
+  __pyx_t_2 = (__pyx_v_self->_sftp != NULL);
+  __pyx_t_1 = __pyx_t_2;
   __pyx_L4_bool_binop_done:;
   if (__pyx_t_1) {
 
@@ -1902,6 +3603,7 @@ static void __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(struct __pyx_obj_4ssh2_4sftp
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
@@ -1963,23 +3665,24 @@ static void __pyx_pf_4ssh2_4sftp_4SFTP_2__dealloc__(struct __pyx_obj_4ssh2_4sftp
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
-/* "ssh2/sftp.pyx":187
+/* "ssh2/sftp.pyx":186
+ *         self._sftp = NULL
  * 
- *     @property
- *     def session(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def session(self):
  *         """Originating session."""
- *         return self._session
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7session_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7session_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_7session___get__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self));
 
   /* function exit code */
@@ -1990,7 +3693,7 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7session_1__get__(PyObject *__pyx_v_
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_7session___get__(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp.pyx":189
  *     def session(self):
@@ -2000,16 +3703,16 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_7session___get__(struct __pyx_obj_4s
  *     def get_channel(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_self->_session));
+  __Pyx_INCREF((PyObject *)__pyx_v_self->_session);
   __pyx_r = ((PyObject *)__pyx_v_self->_session);
   goto __pyx_L0;
 
-  /* "ssh2/sftp.pyx":187
+  /* "ssh2/sftp.pyx":186
+ *         self._sftp = NULL
  * 
- *     @property
- *     def session(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def session(self):
  *         """Originating session."""
- *         return self._session
  */
 
   /* function exit code */
@@ -2028,12 +3731,40 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_7session___get__(struct __pyx_obj_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_4get_channel[] = "SFTP.get_channel(self)\nGet new channel from the SFTP session";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_4get_channel, "SFTP.get_channel(self)\nGet new channel from the SFTP session");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_5get_channel = {"get_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_4get_channel};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("get_channel (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("get_channel", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get_channel", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_4get_channel(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self));
 
   /* function exit code */
@@ -2052,7 +3783,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_4get_channel(struct __pyx_obj_4ssh2_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("get_channel", 0);
+  __Pyx_RefNannySetupContext("get_channel", 1);
 
   /* "ssh2/sftp.pyx":194
  *         """Get new channel from the SFTP session"""
@@ -2064,6 +3795,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_4get_channel(struct __pyx_obj_4ssh2_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2105,7 +3837,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_4get_channel(struct __pyx_obj_4ssh2_
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session._session))
  */
-  __pyx_t_1 = ((__pyx_v__channel == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__channel == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/sftp.pyx":197
@@ -2194,81 +3926,126 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_4get_channel(struct __pyx_obj_4ssh2_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_6open_ex[] = "SFTP.open_ex(self, const char *filename, unsigned int filename_len, unsigned long flags, long mode, int open_type)";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_6open_ex, "SFTP.open_ex(self, const char *filename, unsigned int filename_len, unsigned long flags, long mode, int open_type)");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_7open_ex = {"open_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_6open_ex};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   char const *__pyx_v_filename;
   unsigned int __pyx_v_filename_len;
   unsigned long __pyx_v_flags;
   long __pyx_v_mode;
   int __pyx_v_open_type;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("open_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_filename_len,&__pyx_n_s_flags,&__pyx_n_s_mode,&__pyx_n_s_open_type,0};
-    PyObject* values[5] = {0,0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_filename_len,&__pyx_n_s_flags,&__pyx_n_s_mode,&__pyx_n_s_open_type,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename_len)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename_len)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, 1); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, 2); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, 3); __PYX_ERR(0, 201, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open_type)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_open_type)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, 4); __PYX_ERR(0, 201, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open_ex") < 0)) __PYX_ERR(0, 201, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open_ex") < 0)) __PYX_ERR(0, 201, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+    } else if (unlikely(__pyx_nargs != 5)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
+      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
     }
     __pyx_v_filename = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_filename) && PyErr_Occurred())) __PYX_ERR(0, 201, __pyx_L3_error)
     __pyx_v_filename_len = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_filename_len == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 202, __pyx_L3_error)
@@ -2276,10 +4053,18 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, PyO
     __pyx_v_mode = __Pyx_PyInt_As_long(values[3]); if (unlikely((__pyx_v_mode == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
     __pyx_v_open_type = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_open_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 204, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 201, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("open_ex", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 201, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.open_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2287,6 +4072,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex(PyObject *__pyx_v_self, PyO
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_filename, __pyx_v_filename_len, __pyx_v_flags, __pyx_v_mode, __pyx_v_open_type);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2302,7 +4093,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(struct __pyx_obj_4ssh2_4sft
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("open_ex", 0);
+  __Pyx_RefNannySetupContext("open_ex", 1);
 
   /* "ssh2/sftp.pyx":207
  *         cdef c_sftp.LIBSSH2_SFTP_HANDLE *_handle
@@ -2314,6 +4105,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(struct __pyx_obj_4ssh2_4sft
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2355,7 +4147,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(struct __pyx_obj_4ssh2_4sft
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session._session))
  */
-  __pyx_t_1 = ((__pyx_v__handle == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__handle == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/sftp.pyx":212
@@ -2419,7 +4211,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(struct __pyx_obj_4ssh2_4sft
  *     def open(self, filename not None,
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_handle));
+  __Pyx_INCREF((PyObject *)__pyx_v_handle);
   __pyx_r = ((PyObject *)__pyx_v_handle);
   goto __pyx_L0;
 
@@ -2452,70 +4244,115 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_6open_ex(struct __pyx_obj_4ssh2_4sft
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_9open(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_8open[] = "SFTP.open(self, filename, unsigned long flags, long mode)\nOpen file handle for file name.\n\n        :param filename: Name of file to open.\n        :type filename: str\n        :param flags: One or more LIBSSH2_FXF_* flags.\n\n          Eg for reading flags is ``LIBSSH2_FXF_READ``,\n\n          for writing ``LIBSSH2_FXF_WRITE``,\n\n          for both ``LIBSSH2_FXF_READ`` | ``LIBSSH2_FXF_WRITE``.\n        :type flags: int\n        :param mode: File permissions mode. ``LIBSSH2_SFTP_S_IRUSR`` for\n          reading.\n\n          For writing one or more ``LIBSSH2_SFTP_S_*`` flags.\n\n          Eg, for 664 permission mask (read/write owner/group, read other),\n\n          mode is\n\n          ``LIBSSH2_SFTP_S_IRUSR | LIBSSH2_SFTP_S_IWUSR | \\``\n          ``LIBSSH2_SFTP_S_IRGRP | LIBSSH2_SFTP_S_IWGRP | \\``\n          ``LIBSSH2_SFTP_S_IROTH``\n        :type mode: int\n\n        :rtype: :py:class:`ssh2.sftp.SFTPHandle` or `None`\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors opening\n          file.\n        ";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_9open(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_9open(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_8open, "SFTP.open(self, filename, unsigned long flags, long mode)\nOpen file handle for file name.\n\n        :param filename: Name of file to open.\n        :type filename: str\n        :param flags: One or more LIBSSH2_FXF_* flags.\n\n          Eg for reading flags is ``LIBSSH2_FXF_READ``,\n\n          for writing ``LIBSSH2_FXF_WRITE``,\n\n          for both ``LIBSSH2_FXF_READ`` | ``LIBSSH2_FXF_WRITE``.\n        :type flags: int\n        :param mode: File permissions mode. ``LIBSSH2_SFTP_S_IRUSR`` for\n          reading.\n\n          For writing one or more ``LIBSSH2_SFTP_S_*`` flags.\n\n          Eg, for 664 permission mask (read/write owner/group, read other),\n\n          mode is\n\n          ``LIBSSH2_SFTP_S_IRUSR | LIBSSH2_SFTP_S_IWUSR | \\``\n          ``LIBSSH2_SFTP_S_IRGRP | LIBSSH2_SFTP_S_IWGRP | \\``\n          ``LIBSSH2_SFTP_S_IROTH``\n        :type mode: int\n\n        :rtype: :py:class:`ssh2.sftp.SFTPHandle` or `None`\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors opening\n          file.\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_9open = {"open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_9open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_8open};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_9open(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_filename = 0;
   unsigned long __pyx_v_flags;
   long __pyx_v_mode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("open (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_flags,&__pyx_n_s_mode,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_flags,&__pyx_n_s_mode,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 217, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 217, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open", 1, 3, 3, 1); __PYX_ERR(0, 217, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 217, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("open", 1, 3, 3, 2); __PYX_ERR(0, 217, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "open") < 0)) __PYX_ERR(0, 217, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "open") < 0)) __PYX_ERR(0, 217, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+    } else if (unlikely(__pyx_nargs != 3)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
     }
     __pyx_v_filename = values[0];
     __pyx_v_flags = __Pyx_PyInt_As_unsigned_long(values[1]); if (unlikely((__pyx_v_flags == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 218, __pyx_L3_error)
     __pyx_v_mode = __Pyx_PyInt_As_long(values[2]); if (unlikely((__pyx_v_mode == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 219, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("open", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 217, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("open", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 217, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.open", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2530,6 +4367,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_9open(PyObject *__pyx_v_self, PyObje
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2547,7 +4390,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_8open(struct __pyx_obj_4ssh2_4sftp_S
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("open", 0);
+  __Pyx_RefNannySetupContext("open", 1);
 
   /* "ssh2/sftp.pyx":252
  *         """  # noqa: W605
@@ -2585,6 +4428,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_8open(struct __pyx_obj_4ssh2_4sftp_S
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2626,7 +4470,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_8open(struct __pyx_obj_4ssh2_4sftp_S
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session._session))
  */
-  __pyx_t_3 = ((__pyx_v__handle == NULL) != 0);
+  __pyx_t_3 = (__pyx_v__handle == NULL);
   if (__pyx_t_3) {
 
     /* "ssh2/sftp.pyx":258
@@ -2712,25 +4556,105 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_8open(struct __pyx_obj_4ssh2_4sftp_S
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_11opendir(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_10opendir[] = "SFTP.opendir(self, path)\nOpen handle to directory path.\n\n        :param path: Path of directory\n        :type path: str\n\n        :rtype: :py:class:`ssh2.sftp.SFTPHandle` or `None`\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors opening\n          directory.\n        ";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_11opendir(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_11opendir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_10opendir, "SFTP.opendir(self, path)\nOpen handle to directory path.\n\n        :param path: Path of directory\n        :type path: str\n\n        :rtype: :py:class:`ssh2.sftp.SFTPHandle` or `None`\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors opening\n          directory.\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_11opendir = {"opendir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_11opendir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_10opendir};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_11opendir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("opendir (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 262, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "opendir") < 0)) __PYX_ERR(0, 262, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("opendir", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 262, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.opendir", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(0, 262, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_10opendir(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_10opendir(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2748,7 +4672,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_10opendir(struct __pyx_obj_4ssh2_4sf
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("opendir", 0);
+  __Pyx_RefNannySetupContext("opendir", 1);
 
   /* "ssh2/sftp.pyx":274
  *         """
@@ -2786,6 +4710,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_10opendir(struct __pyx_obj_4ssh2_4sf
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2827,7 +4752,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_10opendir(struct __pyx_obj_4ssh2_4sf
  *             return handle_error_codes(c_ssh2.libssh2_session_last_errno(
  *                 self._session._session))
  */
-  __pyx_t_3 = ((__pyx_v__handle == NULL) != 0);
+  __pyx_t_3 = (__pyx_v__handle == NULL);
   if (__pyx_t_3) {
 
     /* "ssh2/sftp.pyx":279
@@ -2913,81 +4838,126 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_10opendir(struct __pyx_obj_4ssh2_4sf
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_12rename_ex[] = "SFTP.rename_ex(self, const char *source_filename, unsigned int source_filename_len, const char *dest_filename, unsigned int dest_filename_len, long flags)";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_12rename_ex, "SFTP.rename_ex(self, const char *source_filename, unsigned int source_filename_len, const char *dest_filename, unsigned int dest_filename_len, long flags)");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_13rename_ex = {"rename_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_12rename_ex};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   char const *__pyx_v_source_filename;
   unsigned int __pyx_v_source_filename_len;
   char const *__pyx_v_dest_filename;
   unsigned int __pyx_v_dest_filename_len;
   long __pyx_v_flags;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("rename_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source_filename,&__pyx_n_s_source_filename_len,&__pyx_n_s_dest_filename,&__pyx_n_s_dest_filename_len,&__pyx_n_s_flags,0};
-    PyObject* values[5] = {0,0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source_filename,&__pyx_n_s_source_filename_len,&__pyx_n_s_dest_filename,&__pyx_n_s_dest_filename_len,&__pyx_n_s_flags,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_source_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source_filename_len)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_source_filename_len)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, 1); __PYX_ERR(0, 283, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dest_filename)) != 0)) kw_args--;
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dest_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, 2); __PYX_ERR(0, 283, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dest_filename_len)) != 0)) kw_args--;
+        if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dest_filename_len)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[3]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, 3); __PYX_ERR(0, 283, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+        if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[4]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, 4); __PYX_ERR(0, 283, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rename_ex") < 0)) __PYX_ERR(0, 283, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rename_ex") < 0)) __PYX_ERR(0, 283, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+    } else if (unlikely(__pyx_nargs != 5)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+      values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3);
+      values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4);
     }
     __pyx_v_source_filename = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_source_filename) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L3_error)
     __pyx_v_source_filename_len = __Pyx_PyInt_As_unsigned_int(values[1]); if (unlikely((__pyx_v_source_filename_len == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L3_error)
@@ -2995,10 +4965,18 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self,
     __pyx_v_dest_filename_len = __Pyx_PyInt_As_unsigned_int(values[3]); if (unlikely((__pyx_v_dest_filename_len == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L3_error)
     __pyx_v_flags = __Pyx_PyInt_As_long(values[4]); if (unlikely((__pyx_v_flags == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 287, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 283, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("rename_ex", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 283, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.rename_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3006,6 +4984,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex(PyObject *__pyx_v_self,
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_12rename_ex(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_source_filename, __pyx_v_source_filename_len, __pyx_v_dest_filename, __pyx_v_dest_filename_len, __pyx_v_flags);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3019,7 +5003,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_12rename_ex(struct __pyx_obj_4ssh2_4
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("rename_ex", 0);
+  __Pyx_RefNannySetupContext("rename_ex", 1);
 
   /* "ssh2/sftp.pyx":289
  *                   long flags):
@@ -3031,6 +5015,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_12rename_ex(struct __pyx_obj_4ssh2_4
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3108,59 +5093,100 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_12rename_ex(struct __pyx_obj_4ssh2_4
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_15rename(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_14rename[] = "SFTP.rename(self, source_filename, dest_filename)\nRename file.\n\n        :param source_filename: Old name of file.\n        :type source_filename: str\n        :param dest_filename: New name of file.\n        :type dest_filename: str";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_15rename(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_15rename(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_14rename, "SFTP.rename(self, source_filename, dest_filename)\nRename file.\n\n        :param source_filename: Old name of file.\n        :type source_filename: str\n        :param dest_filename: New name of file.\n        :type dest_filename: str");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_15rename = {"rename", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_15rename, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_14rename};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_15rename(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_source_filename = 0;
   PyObject *__pyx_v_dest_filename = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("rename (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source_filename,&__pyx_n_s_dest_filename,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source_filename,&__pyx_n_s_dest_filename,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source_filename)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_source_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dest_filename)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dest_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("rename", 1, 2, 2, 1); __PYX_ERR(0, 295, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rename") < 0)) __PYX_ERR(0, 295, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rename") < 0)) __PYX_ERR(0, 295, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_source_filename = values[0];
     __pyx_v_dest_filename = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("rename", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 295, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("rename", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 295, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.rename", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3178,6 +5204,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_15rename(PyObject *__pyx_v_self, PyO
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3196,7 +5228,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_14rename(struct __pyx_obj_4ssh2_4sft
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("rename", 0);
+  __Pyx_RefNannySetupContext("rename", 1);
 
   /* "ssh2/sftp.pyx":303
  *         :type dest_filename: str"""
@@ -3260,6 +5292,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_14rename(struct __pyx_obj_4ssh2_4sft
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3339,25 +5372,105 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_14rename(struct __pyx_obj_4ssh2_4sft
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_17unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_16unlink[] = "SFTP.unlink(self, filename)\nDelete/unlink file.\n\n        :param filename: Name of file to delete/unlink.\n        :type filename: str";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_17unlink(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_17unlink(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_16unlink, "SFTP.unlink(self, filename)\nDelete/unlink file.\n\n        :param filename: Name of file to delete/unlink.\n        :type filename: str");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_17unlink = {"unlink", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_17unlink, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_16unlink};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_17unlink(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_filename = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("unlink (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 312, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "unlink") < 0)) __PYX_ERR(0, 312, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_filename = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("unlink", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 312, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.unlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_filename) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "filename"); __PYX_ERR(0, 312, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_16unlink(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_filename));
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_16unlink(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_filename);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3374,7 +5487,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_16unlink(struct __pyx_obj_4ssh2_4sft
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("unlink", 0);
+  __Pyx_RefNannySetupContext("unlink", 1);
 
   /* "ssh2/sftp.pyx":318
  *         :type filename: str"""
@@ -3412,6 +5525,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_16unlink(struct __pyx_obj_4ssh2_4sft
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3490,15 +5604,98 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_16unlink(struct __pyx_obj_4ssh2_4sft
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_18statvfs[] = "SFTP.statvfs(self, path)\nGet file system statistics from path.\n\n        :rtype: `ssh2.sftp.SFTPStatVFS` or int of error code";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_18statvfs, "SFTP.statvfs(self, path)\nGet file system statistics from path.\n\n        :rtype: `ssh2.sftp.SFTPStatVFS` or int of error code");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_19statvfs = {"statvfs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_18statvfs};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("statvfs (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 324, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "statvfs") < 0)) __PYX_ERR(0, 324, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("statvfs", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 324, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.statvfs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3515,11 +5712,12 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
   char *__pyx_t_2;
   Py_ssize_t __pyx_t_3;
   int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("statvfs", 0);
+  __Pyx_RefNannySetupContext("statvfs", 1);
 
   /* "ssh2/sftp.pyx":328
  * 
@@ -3570,7 +5768,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
     __PYX_ERR(0, 331, __pyx_L1_error)
   }
-  __pyx_t_3 = PyBytes_GET_SIZE(__pyx_v_b_path); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 331, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_GET_SIZE(__pyx_v_b_path); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 331, __pyx_L1_error)
   __pyx_v_path_len = __pyx_t_3;
 
   /* "ssh2/sftp.pyx":332
@@ -3583,6 +5781,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3625,14 +5824,15 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
  *     def mkdir(self, path not None, long mode):
  */
   __Pyx_XDECREF(__pyx_r);
-  if (((__pyx_v_rc != 0) != 0)) {
-    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 335, __pyx_L1_error)
-    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 335, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_1 = __pyx_t_5;
-    __pyx_t_5 = 0;
+  __pyx_t_4 = (__pyx_v_rc != 0);
+  if (__pyx_t_4) {
+    __pyx_t_5 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 335, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 335, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __pyx_t_6;
+    __pyx_t_6 = 0;
   } else {
-    __Pyx_INCREF(((PyObject *)__pyx_v_vfs));
+    __Pyx_INCREF((PyObject *)__pyx_v_vfs);
     __pyx_t_1 = ((PyObject *)__pyx_v_vfs);
   }
   __pyx_r = __pyx_t_1;
@@ -3650,7 +5850,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.sftp.SFTP.statvfs", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -3670,59 +5870,100 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_18statvfs(struct __pyx_obj_4ssh2_4sf
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_20mkdir[] = "SFTP.mkdir(self, path, long mode)\nMake directory.\n\n        :param path: Path of directory to create.\n        :type path: str\n        :param mode: Permissions mode of new directory.\n        :type mode: int\n\n        :rtype: int\n\n        :raises: Appropriate exception from :py:mod:`ssh2.exceptions` on errors.\n        ";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_20mkdir, "SFTP.mkdir(self, path, long mode)\nMake directory.\n\n        :param path: Path of directory to create.\n        :type path: str\n        :param mode: Permissions mode of new directory.\n        :type mode: int\n\n        :rtype: int\n\n        :raises: Appropriate exception from :py:mod:`ssh2.exceptions` on errors.\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_21mkdir = {"mkdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_20mkdir};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   long __pyx_v_mode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("mkdir (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_mode,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("mkdir", 1, 2, 2, 1); __PYX_ERR(0, 337, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "mkdir") < 0)) __PYX_ERR(0, 337, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "mkdir") < 0)) __PYX_ERR(0, 337, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_path = values[0];
     __pyx_v_mode = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v_mode == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("mkdir", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 337, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("mkdir", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 337, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3737,6 +5978,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir(PyObject *__pyx_v_self, PyOb
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3753,7 +6000,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_20mkdir(struct __pyx_obj_4ssh2_4sftp
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("mkdir", 0);
+  __Pyx_RefNannySetupContext("mkdir", 1);
 
   /* "ssh2/sftp.pyx":350
  *         """
@@ -3791,6 +6038,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_20mkdir(struct __pyx_obj_4ssh2_4sftp
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -3869,27 +6117,107 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_20mkdir(struct __pyx_obj_4ssh2_4sftp
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_22rmdir[] = "SFTP.rmdir(self, path)\nRemove directory.\n\n        :param path: Directory path to remove.\n        :type path: str\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_22rmdir, "SFTP.rmdir(self, path)\nRemove directory.\n\n        :param path: Directory path to remove.\n        :type path: str\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_23rmdir = {"rmdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_22rmdir};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("rmdir (wrapper)", 0);
-  if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
-    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(0, 356, __pyx_L1_error)
-  }
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_path));
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 356, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "rmdir") < 0)) __PYX_ERR(0, 356, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("rmdir", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 356, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
+    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(0, 356, __pyx_L1_error)
+  }
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_path);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self, PyObject *__pyx_v_path) {
@@ -3904,7 +6232,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(struct __pyx_obj_4ssh2_4sftp
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("rmdir", 0);
+  __Pyx_RefNannySetupContext("rmdir", 1);
 
   /* "ssh2/sftp.pyx":364
  *         :rtype: int"""
@@ -3942,6 +6270,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(struct __pyx_obj_4ssh2_4sftp
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4020,25 +6349,105 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_22rmdir(struct __pyx_obj_4ssh2_4sftp
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_25stat(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_24stat[] = "SFTP.stat(self, path)\nStat file.\n\n        :param path: Path of file to stat.\n        :type path: str\n\n        :rtype: :py:class:`ssh2.sftp_handle.SFTPAttributes` or\n          LIBSSH2_ERROR_EAGAIN";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_25stat(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_25stat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_24stat, "SFTP.stat(self, path)\nStat file.\n\n        :param path: Path of file to stat.\n        :type path: str\n\n        :rtype: :py:class:`ssh2.sftp_handle.SFTPAttributes` or\n          LIBSSH2_ERROR_EAGAIN");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_25stat = {"stat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_25stat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_24stat};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_25stat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("stat (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 370, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "stat") < 0)) __PYX_ERR(0, 370, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stat", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 370, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.stat", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(0, 370, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_24stat(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_24stat(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4053,11 +6462,12 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_24stat(struct __pyx_obj_4ssh2_4sftp_
   PyObject *__pyx_t_1 = NULL;
   char *__pyx_t_2;
   int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("stat", 0);
+  __Pyx_RefNannySetupContext("stat", 1);
 
   /* "ssh2/sftp.pyx":379
  *           LIBSSH2_ERROR_EAGAIN"""
@@ -4107,6 +6517,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_24stat(struct __pyx_obj_4ssh2_4sftp_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4149,14 +6560,15 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_24stat(struct __pyx_obj_4ssh2_4sftp_
  *     def lstat(self, path not None):
  */
   __Pyx_XDECREF(__pyx_r);
-  if (((__pyx_v_rc != 0) != 0)) {
-    __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 385, __pyx_L1_error)
-    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 385, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_1 = __pyx_t_4;
-    __pyx_t_4 = 0;
+  __pyx_t_3 = (__pyx_v_rc != 0);
+  if (__pyx_t_3) {
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 385, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 385, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = __pyx_t_5;
+    __pyx_t_5 = 0;
   } else {
-    __Pyx_INCREF(((PyObject *)__pyx_v_attrs));
+    __Pyx_INCREF((PyObject *)__pyx_v_attrs);
     __pyx_t_1 = ((PyObject *)__pyx_v_attrs);
   }
   __pyx_r = __pyx_t_1;
@@ -4174,7 +6586,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_24stat(struct __pyx_obj_4ssh2_4sftp_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
   __Pyx_AddTraceback("ssh2.sftp.SFTP.stat", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -4194,25 +6606,105 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_24stat(struct __pyx_obj_4ssh2_4sftp_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_27lstat(PyObject *__pyx_v_self, PyObject *__pyx_v_path); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_26lstat[] = "SFTP.lstat(self, path)\nLink stat a file.";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_27lstat(PyObject *__pyx_v_self, PyObject *__pyx_v_path) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_27lstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_26lstat, "SFTP.lstat(self, path)\nLink stat a file.");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_27lstat = {"lstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_27lstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_26lstat};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_27lstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_path = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("lstat (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lstat") < 0)) __PYX_ERR(0, 387, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_path = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("lstat", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 387, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.lstat", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(((PyObject *)__pyx_v_path) == Py_None)) {
     PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "path"); __PYX_ERR(0, 387, __pyx_L1_error)
   }
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_26lstat(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v_path));
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_26lstat(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v_path);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4227,11 +6719,12 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_26lstat(struct __pyx_obj_4ssh2_4sftp
   PyObject *__pyx_t_1 = NULL;
   char *__pyx_t_2;
   int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("lstat", 0);
+  __Pyx_RefNannySetupContext("lstat", 1);
 
   /* "ssh2/sftp.pyx":390
  *         """Link stat a file."""
@@ -4281,6 +6774,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_26lstat(struct __pyx_obj_4ssh2_4sftp
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4323,14 +6817,15 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_26lstat(struct __pyx_obj_4ssh2_4sftp
  *     def setstat(self, path not None, SFTPAttributes attrs):
  */
   __Pyx_XDECREF(__pyx_r);
-  if (((__pyx_v_rc != 0) != 0)) {
-    __pyx_t_3 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 396, __pyx_L1_error)
-    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 396, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_1 = __pyx_t_4;
-    __pyx_t_4 = 0;
+  __pyx_t_3 = (__pyx_v_rc != 0);
+  if (__pyx_t_3) {
+    __pyx_t_4 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_rc, 0); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 396, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 396, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = __pyx_t_5;
+    __pyx_t_5 = 0;
   } else {
-    __Pyx_INCREF(((PyObject *)__pyx_v_attrs));
+    __Pyx_INCREF((PyObject *)__pyx_v_attrs);
     __pyx_t_1 = ((PyObject *)__pyx_v_attrs);
   }
   __pyx_r = __pyx_t_1;
@@ -4348,7 +6843,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_26lstat(struct __pyx_obj_4ssh2_4sftp
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
   __Pyx_AddTraceback("ssh2.sftp.SFTP.lstat", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -4368,59 +6863,100 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_26lstat(struct __pyx_obj_4ssh2_4sftp
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_29setstat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_28setstat[] = "SFTP.setstat(self, path, SFTPAttributes attrs)\nSet file attributes.\n\n        :param path: File path.\n        :type path: str\n        :param attrs: File attributes to set.\n        :type attrs: :py:class:`ssh2.sftp_handle.SFTPAttributes`\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_29setstat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_29setstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_28setstat, "SFTP.setstat(self, path, SFTPAttributes attrs)\nSet file attributes.\n\n        :param path: File path.\n        :type path: str\n        :param attrs: File attributes to set.\n        :type attrs: :py:class:`ssh2.sftp_handle.SFTPAttributes`\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_29setstat = {"setstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_29setstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_28setstat};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_29setstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_attrs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("setstat (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_attrs,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_attrs,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 398, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attrs)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_attrs)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 398, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("setstat", 1, 2, 2, 1); __PYX_ERR(0, 398, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setstat") < 0)) __PYX_ERR(0, 398, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setstat") < 0)) __PYX_ERR(0, 398, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_path = values[0];
     __pyx_v_attrs = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("setstat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 398, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("setstat", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 398, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.setstat", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4436,6 +6972,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_29setstat(PyObject *__pyx_v_self, Py
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4452,7 +6994,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_28setstat(struct __pyx_obj_4ssh2_4sf
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("setstat", 0);
+  __Pyx_RefNannySetupContext("setstat", 1);
 
   /* "ssh2/sftp.pyx":408
  *         :rtype: int"""
@@ -4490,6 +7032,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_28setstat(struct __pyx_obj_4ssh2_4sf
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4568,59 +7111,100 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_28setstat(struct __pyx_obj_4ssh2_4sf
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_31symlink(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_30symlink[] = "SFTP.symlink(self, path, target)\nCreate symlink.\n\n        :param path: Source file path.\n        :type path: str\n        :param target: Target file path.\n        :type target: str\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_31symlink(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_31symlink(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_30symlink, "SFTP.symlink(self, path, target)\nCreate symlink.\n\n        :param path: Source file path.\n        :type path: str\n        :param target: Target file path.\n        :type target: str\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_31symlink = {"symlink", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_31symlink, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_30symlink};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_31symlink(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   PyObject *__pyx_v_target = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("symlink (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_target,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_target,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 415, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_target)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 415, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("symlink", 1, 2, 2, 1); __PYX_ERR(0, 415, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "symlink") < 0)) __PYX_ERR(0, 415, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "symlink") < 0)) __PYX_ERR(0, 415, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_path = values[0];
     __pyx_v_target = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("symlink", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 415, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("symlink", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 415, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.symlink", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4638,6 +7222,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_31symlink(PyObject *__pyx_v_self, Py
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4656,7 +7246,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_30symlink(struct __pyx_obj_4ssh2_4sf
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("symlink", 0);
+  __Pyx_RefNannySetupContext("symlink", 1);
 
   /* "ssh2/sftp.pyx":425
  *         :rtype: int"""
@@ -4720,6 +7310,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_30symlink(struct __pyx_obj_4ssh2_4sf
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4799,51 +7390,81 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_30symlink(struct __pyx_obj_4ssh2_4sf
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_32realpath[] = "SFTP.realpath(self, path, size_t max_len=256)\nGet real path for path.\n\n        :param: Path name to get real path for.\n        :type param: str\n        :param max_len: Max size of returned real path.\n        :type max_len: int\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors getting\n          real path.\n        :raises: :py:class:`ssh2.exceptions.SFTPBufferTooSmall` on max_len less\n          than real path length.";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_32realpath, "SFTP.realpath(self, path, size_t max_len=256)\nGet real path for path.\n\n        :param: Path name to get real path for.\n        :type param: str\n        :param max_len: Max size of returned real path.\n        :type max_len: int\n\n        :raises: :py:class:`ssh2.exceptions.SFTPHandleError` on errors getting\n          real path.\n        :raises: :py:class:`ssh2.exceptions.SFTPBufferTooSmall` on max_len less\n          than real path length.");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_33realpath = {"realpath", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_33realpath, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_32realpath};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_path = 0;
   size_t __pyx_v_max_len;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("realpath (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_max_len,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_max_len,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 433, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_len);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_max_len);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 433, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "realpath") < 0)) __PYX_ERR(0, 433, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "realpath") < 0)) __PYX_ERR(0, 433, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -4855,10 +7476,18 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, P
       __pyx_v_max_len = ((size_t)0x100);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("realpath", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 433, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("realpath", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 433, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp.SFTP.realpath", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4873,6 +7502,12 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_33realpath(PyObject *__pyx_v_self, P
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4899,7 +7534,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_32realpath(struct __pyx_obj_4ssh2_4s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("realpath", 0);
+  __Pyx_RefNannySetupContext("realpath", 1);
 
   /* "ssh2/sftp.pyx":445
  *         :raises: :py:class:`ssh2.exceptions.SFTPBufferTooSmall` on max_len less
@@ -4917,7 +7552,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_32realpath(struct __pyx_obj_4ssh2_4s
  *             raise MemoryError
  *         cdef int rc
  */
-  __pyx_t_1 = ((__pyx_v__target == NULL) != 0);
+  __pyx_t_1 = (__pyx_v__target == NULL);
   if (unlikely(__pyx_t_1)) {
 
     /* "ssh2/sftp.pyx":447
@@ -4983,6 +7618,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_32realpath(struct __pyx_obj_4ssh2_4s
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
@@ -5004,7 +7640,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_32realpath(struct __pyx_obj_4ssh2_4s
  *                     with gil:
  *                         return handle_error_codes(rc)
  */
-          __pyx_t_1 = ((__pyx_v_rc < 0) != 0);
+          __pyx_t_1 = (__pyx_v_rc < 0);
           if (__pyx_t_1) {
 
             /* "ssh2/sftp.pyx":456
@@ -5196,12 +7832,40 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_32realpath(struct __pyx_obj_4ssh2_4s
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_35last_error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_34last_error[] = "SFTP.last_error(self)\nGet last error code from SFTP channel.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_35last_error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_35last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_34last_error, "SFTP.last_error(self)\nGet last error code from SFTP channel.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_35last_error = {"last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_35last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_34last_error};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_35last_error(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("last_error (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("last_error", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "last_error", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_34last_error(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self));
 
   /* function exit code */
@@ -5217,7 +7881,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_34last_error(struct __pyx_obj_4ssh2_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("last_error", 0);
+  __Pyx_RefNannySetupContext("last_error", 1);
 
   /* "ssh2/sftp.pyx":467
  *         :rtype: int"""
@@ -5229,6 +7893,7 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_34last_error(struct __pyx_obj_4ssh2_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -5295,17 +7960,45 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_34last_error(struct __pyx_obj_4ssh2_
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_36__reduce_cython__[] = "SFTP.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_36__reduce_cython__, "SFTP.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_37__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_36__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_36__reduce_cython__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self));
 
   /* function exit code */
@@ -5316,33 +8009,28 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__(PyObject *__pyx_
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_36__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp.SFTP.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -5352,21 +8040,104 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_36__reduce_cython__(CYTHON_UNUSED st
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_4sftp_4SFTP_38__setstate_cython__[] = "SFTP.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_4sftp_4SFTP_38__setstate_cython__, "SFTP.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_4sftp_4SFTP_39__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_38__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_38__setstate_cython__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp.SFTP.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_4sftp_4SFTP_38__setstate_cython__(((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5374,33 +8145,28 @@ static PyObject *__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__(PyObject *__py
 static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_38__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_4sftp_SFTP *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp.SFTP.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -5411,12 +8177,17 @@ static PyObject *__pyx_pf_4ssh2_4sftp_4SFTP_38__setstate_cython__(CYTHON_UNUSED
 static PyObject *__pyx_tp_new_4ssh2_4sftp_SFTP(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_4sftp_SFTP *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_4sftp_SFTP *)o);
   p->_session = ((struct __pyx_obj_4ssh2_7session_Session *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_4sftp_4SFTP_1__cinit__(o, a, k) < 0)) goto bad;
@@ -5429,8 +8200,10 @@ static PyObject *__pyx_tp_new_4ssh2_4sftp_SFTP(PyTypeObject *t, PyObject *a, PyO
 static void __pyx_tp_dealloc_4ssh2_4sftp_SFTP(PyObject *o) {
   struct __pyx_obj_4ssh2_4sftp_SFTP *p = (struct __pyx_obj_4ssh2_4sftp_SFTP *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_4sftp_SFTP) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -5443,7 +8216,14 @@ static void __pyx_tp_dealloc_4ssh2_4sftp_SFTP(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_session);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_4sftp_SFTP(PyObject *o, visitproc v, void *a) {
@@ -5469,35 +8249,54 @@ static PyObject *__pyx_getprop_4ssh2_4sftp_4SFTP_session(PyObject *o, CYTHON_UNU
 }
 
 static PyMethodDef __pyx_methods_4ssh2_4sftp_SFTP[] = {
-  {"get_channel", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel, METH_NOARGS, __pyx_doc_4ssh2_4sftp_4SFTP_4get_channel},
-  {"open_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_6open_ex},
-  {"open", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_9open, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_8open},
-  {"opendir", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_11opendir, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_10opendir},
-  {"rename_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_12rename_ex},
-  {"rename", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_15rename, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_14rename},
-  {"unlink", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_17unlink, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_16unlink},
-  {"statvfs", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_18statvfs},
-  {"mkdir", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_20mkdir},
-  {"rmdir", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_22rmdir},
-  {"stat", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_25stat, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_24stat},
-  {"lstat", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_27lstat, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_26lstat},
-  {"setstat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_29setstat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_28setstat},
-  {"symlink", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_31symlink, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_30symlink},
-  {"realpath", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_33realpath, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_32realpath},
-  {"last_error", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_35last_error, METH_NOARGS, __pyx_doc_4ssh2_4sftp_4SFTP_34last_error},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_4sftp_4SFTP_36__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__, METH_O, __pyx_doc_4ssh2_4sftp_4SFTP_38__setstate_cython__},
+  {"get_channel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_5get_channel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_4get_channel},
+  {"open_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_7open_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_6open_ex},
+  {"open", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_9open, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_8open},
+  {"opendir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_11opendir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_10opendir},
+  {"rename_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_13rename_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_12rename_ex},
+  {"rename", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_15rename, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_14rename},
+  {"unlink", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_17unlink, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_16unlink},
+  {"statvfs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_19statvfs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_18statvfs},
+  {"mkdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_21mkdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_20mkdir},
+  {"rmdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_23rmdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_22rmdir},
+  {"stat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_25stat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_24stat},
+  {"lstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_27lstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_26lstat},
+  {"setstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_29setstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_28setstat},
+  {"symlink", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_31symlink, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_30symlink},
+  {"realpath", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_33realpath, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_32realpath},
+  {"last_error", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_35last_error, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_34last_error},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_37__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_36__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_4sftp_4SFTP_39__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_4sftp_4SFTP_38__setstate_cython__},
   {0, 0, 0, 0}
 };
 
 static struct PyGetSetDef __pyx_getsets_4ssh2_4sftp_SFTP[] = {
-  {(char *)"session", __pyx_getprop_4ssh2_4sftp_4SFTP_session, 0, (char *)"Originating session.", 0},
+  {(char *)"session", __pyx_getprop_4ssh2_4sftp_4SFTP_session, 0, (char *)PyDoc_STR("Originating session."), 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_4sftp_SFTP_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_4sftp_SFTP},
+  {Py_tp_doc, (void *)PyDoc_STR("SFTP session.\n\n    :param session: Session that initiated SFTP.\n    :type session: :py:class:`ssh2.session.Session` pointer")},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_4sftp_SFTP},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_4sftp_SFTP},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_4sftp_SFTP},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_4sftp_SFTP},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_4sftp_SFTP},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_4sftp_SFTP_spec = {
+  "ssh2.sftp.SFTP",
+  sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_4sftp_SFTP_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_4sftp_SFTP = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp.SFTP", /*tp_name*/
+  "ssh2.sftp.""SFTP", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_4sftp_SFTP, /*tp_dealloc*/
@@ -5526,7 +8325,7 @@ static PyTypeObject __pyx_type_4ssh2_4sftp_SFTP = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "SFTP session.\n\n    :param session: Session that initiated SFTP.\n    :type session: :py:class:`ssh2.session.Session` pointer", /*tp_doc*/
+  PyDoc_STR("SFTP session.\n\n    :param session: Session that initiated SFTP.\n    :type session: :py:class:`ssh2.session.Session` pointer"), /*tp_doc*/
   __pyx_tp_traverse_4ssh2_4sftp_SFTP, /*tp_traverse*/
   __pyx_tp_clear_4ssh2_4sftp_SFTP, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -5540,7 +8339,9 @@ static PyTypeObject __pyx_type_4ssh2_4sftp_SFTP = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_4sftp_SFTP, /*tp_new*/
@@ -5554,54 +8355,33 @@ static PyTypeObject __pyx_type_4ssh2_4sftp_SFTP = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_sftp(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_sftp},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "sftp",
-    __pyx_k_SFTP_channel_class_and_related, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -5611,71 +8391,138 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_LIBSSH2_FXF_APPEND, __pyx_k_LIBSSH2_FXF_APPEND, sizeof(__pyx_k_LIBSSH2_FXF_APPEND), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_FXF_CREAT, __pyx_k_LIBSSH2_FXF_CREAT, sizeof(__pyx_k_LIBSSH2_FXF_CREAT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_FXF_EXCL, __pyx_k_LIBSSH2_FXF_EXCL, sizeof(__pyx_k_LIBSSH2_FXF_EXCL), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_FXF_READ, __pyx_k_LIBSSH2_FXF_READ, sizeof(__pyx_k_LIBSSH2_FXF_READ), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_FXF_TRUNC, __pyx_k_LIBSSH2_FXF_TRUNC, sizeof(__pyx_k_LIBSSH2_FXF_TRUNC), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_FXF_WRITE, __pyx_k_LIBSSH2_FXF_WRITE, sizeof(__pyx_k_LIBSSH2_FXF_WRITE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME, __pyx_k_LIBSSH2_SFTP_ATTR_ACMODTIME, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_ACMODTIME), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED, __pyx_k_LIBSSH2_SFTP_ATTR_EXTENDED, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_EXTENDED), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS, __pyx_k_LIBSSH2_SFTP_ATTR_PERMISSIONS, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_PERMISSIONS), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE, __pyx_k_LIBSSH2_SFTP_ATTR_SIZE, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_SIZE), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID, __pyx_k_LIBSSH2_SFTP_ATTR_UIDGID, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_UIDGID), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID, __pyx_k_LIBSSH2_SFTP_ST_NOSUID, sizeof(__pyx_k_LIBSSH2_SFTP_ST_NOSUID), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY, __pyx_k_LIBSSH2_SFTP_ST_RDONLY, sizeof(__pyx_k_LIBSSH2_SFTP_ST_RDONLY), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFBLK, __pyx_k_LIBSSH2_SFTP_S_IFBLK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFBLK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFCHR, __pyx_k_LIBSSH2_SFTP_S_IFCHR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFCHR), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFDIR, __pyx_k_LIBSSH2_SFTP_S_IFDIR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFDIR), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFIFO, __pyx_k_LIBSSH2_SFTP_S_IFIFO, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFIFO), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFLNK, __pyx_k_LIBSSH2_SFTP_S_IFLNK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFLNK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFMT, __pyx_k_LIBSSH2_SFTP_S_IFMT, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFMT), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFREG, __pyx_k_LIBSSH2_SFTP_S_IFREG, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFREG), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK, __pyx_k_LIBSSH2_SFTP_S_IFSOCK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFSOCK), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IRGRP, __pyx_k_LIBSSH2_SFTP_S_IRGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRGRP), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IROTH, __pyx_k_LIBSSH2_SFTP_S_IROTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IROTH), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IRUSR, __pyx_k_LIBSSH2_SFTP_S_IRUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRUSR), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXG, __pyx_k_LIBSSH2_SFTP_S_IRWXG, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXG), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXO, __pyx_k_LIBSSH2_SFTP_S_IRWXO, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXO), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXU, __pyx_k_LIBSSH2_SFTP_S_IRWXU, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXU), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IWGRP, __pyx_k_LIBSSH2_SFTP_S_IWGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWGRP), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IWOTH, __pyx_k_LIBSSH2_SFTP_S_IWOTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWOTH), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IWUSR, __pyx_k_LIBSSH2_SFTP_S_IWUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWUSR), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IXGRP, __pyx_k_LIBSSH2_SFTP_S_IXGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXGRP), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IXOTH, __pyx_k_LIBSSH2_SFTP_S_IXOTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXOTH), 0, 0, 1, 1},
-  {&__pyx_n_s_LIBSSH2_SFTP_S_IXUSR, __pyx_k_LIBSSH2_SFTP_S_IXUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXUSR), 0, 0, 1, 1},
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTP, __pyx_k_SFTP, sizeof(__pyx_k_SFTP), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_dest_filename, __pyx_k_dest_filename, sizeof(__pyx_k_dest_filename), 0, 0, 1, 1},
-  {&__pyx_n_s_dest_filename_len, __pyx_k_dest_filename_len, sizeof(__pyx_k_dest_filename_len), 0, 0, 1, 1},
-  {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1},
-  {&__pyx_n_s_filename_len, __pyx_k_filename_len, sizeof(__pyx_k_filename_len), 0, 0, 1, 1},
-  {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_max_len, __pyx_k_max_len, sizeof(__pyx_k_max_len), 0, 0, 1, 1},
-  {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_open_type, __pyx_k_open_type, sizeof(__pyx_k_open_type), 0, 0, 1, 1},
-  {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_source_filename, __pyx_k_source_filename, sizeof(__pyx_k_source_filename), 0, 0, 1, 1},
-  {&__pyx_n_s_source_filename_len, __pyx_k_source_filename_len, sizeof(__pyx_k_source_filename_len), 0, 0, 1, 1},
-  {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_LIBSSH2_FXF_APPEND, __pyx_k_LIBSSH2_FXF_APPEND, sizeof(__pyx_k_LIBSSH2_FXF_APPEND), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_FXF_CREAT, __pyx_k_LIBSSH2_FXF_CREAT, sizeof(__pyx_k_LIBSSH2_FXF_CREAT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_FXF_EXCL, __pyx_k_LIBSSH2_FXF_EXCL, sizeof(__pyx_k_LIBSSH2_FXF_EXCL), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_FXF_READ, __pyx_k_LIBSSH2_FXF_READ, sizeof(__pyx_k_LIBSSH2_FXF_READ), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_FXF_TRUNC, __pyx_k_LIBSSH2_FXF_TRUNC, sizeof(__pyx_k_LIBSSH2_FXF_TRUNC), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_FXF_WRITE, __pyx_k_LIBSSH2_FXF_WRITE, sizeof(__pyx_k_LIBSSH2_FXF_WRITE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME, __pyx_k_LIBSSH2_SFTP_ATTR_ACMODTIME, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_ACMODTIME), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED, __pyx_k_LIBSSH2_SFTP_ATTR_EXTENDED, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_EXTENDED), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS, __pyx_k_LIBSSH2_SFTP_ATTR_PERMISSIONS, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_PERMISSIONS), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE, __pyx_k_LIBSSH2_SFTP_ATTR_SIZE, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_SIZE), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID, __pyx_k_LIBSSH2_SFTP_ATTR_UIDGID, sizeof(__pyx_k_LIBSSH2_SFTP_ATTR_UIDGID), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ST_NOSUID, __pyx_k_LIBSSH2_SFTP_ST_NOSUID, sizeof(__pyx_k_LIBSSH2_SFTP_ST_NOSUID), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_ST_RDONLY, __pyx_k_LIBSSH2_SFTP_ST_RDONLY, sizeof(__pyx_k_LIBSSH2_SFTP_ST_RDONLY), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFBLK, __pyx_k_LIBSSH2_SFTP_S_IFBLK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFBLK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFCHR, __pyx_k_LIBSSH2_SFTP_S_IFCHR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFCHR), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFDIR, __pyx_k_LIBSSH2_SFTP_S_IFDIR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFDIR), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFIFO, __pyx_k_LIBSSH2_SFTP_S_IFIFO, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFIFO), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFLNK, __pyx_k_LIBSSH2_SFTP_S_IFLNK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFLNK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFMT, __pyx_k_LIBSSH2_SFTP_S_IFMT, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFMT), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFREG, __pyx_k_LIBSSH2_SFTP_S_IFREG, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFREG), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IFSOCK, __pyx_k_LIBSSH2_SFTP_S_IFSOCK, sizeof(__pyx_k_LIBSSH2_SFTP_S_IFSOCK), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IRGRP, __pyx_k_LIBSSH2_SFTP_S_IRGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRGRP), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IROTH, __pyx_k_LIBSSH2_SFTP_S_IROTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IROTH), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IRUSR, __pyx_k_LIBSSH2_SFTP_S_IRUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRUSR), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXG, __pyx_k_LIBSSH2_SFTP_S_IRWXG, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXG), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXO, __pyx_k_LIBSSH2_SFTP_S_IRWXO, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXO), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IRWXU, __pyx_k_LIBSSH2_SFTP_S_IRWXU, sizeof(__pyx_k_LIBSSH2_SFTP_S_IRWXU), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IWGRP, __pyx_k_LIBSSH2_SFTP_S_IWGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWGRP), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IWOTH, __pyx_k_LIBSSH2_SFTP_S_IWOTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWOTH), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IWUSR, __pyx_k_LIBSSH2_SFTP_S_IWUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IWUSR), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IXGRP, __pyx_k_LIBSSH2_SFTP_S_IXGRP, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXGRP), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IXOTH, __pyx_k_LIBSSH2_SFTP_S_IXOTH, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXOTH), 0, 0, 1, 1},
+    {&__pyx_n_s_LIBSSH2_SFTP_S_IXUSR, __pyx_k_LIBSSH2_SFTP_S_IXUSR, sizeof(__pyx_k_LIBSSH2_SFTP_S_IXUSR), 0, 0, 1, 1},
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP, __pyx_k_SFTP, sizeof(__pyx_k_SFTP), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP___reduce_cython, __pyx_k_SFTP___reduce_cython, sizeof(__pyx_k_SFTP___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP___setstate_cython, __pyx_k_SFTP___setstate_cython, sizeof(__pyx_k_SFTP___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_get_channel, __pyx_k_SFTP_get_channel, sizeof(__pyx_k_SFTP_get_channel), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_last_error, __pyx_k_SFTP_last_error, sizeof(__pyx_k_SFTP_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_lstat, __pyx_k_SFTP_lstat, sizeof(__pyx_k_SFTP_lstat), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_mkdir, __pyx_k_SFTP_mkdir, sizeof(__pyx_k_SFTP_mkdir), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_open, __pyx_k_SFTP_open, sizeof(__pyx_k_SFTP_open), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_open_ex, __pyx_k_SFTP_open_ex, sizeof(__pyx_k_SFTP_open_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_opendir, __pyx_k_SFTP_opendir, sizeof(__pyx_k_SFTP_opendir), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_realpath, __pyx_k_SFTP_realpath, sizeof(__pyx_k_SFTP_realpath), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_rename, __pyx_k_SFTP_rename, sizeof(__pyx_k_SFTP_rename), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_rename_ex, __pyx_k_SFTP_rename_ex, sizeof(__pyx_k_SFTP_rename_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_rmdir, __pyx_k_SFTP_rmdir, sizeof(__pyx_k_SFTP_rmdir), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_setstat, __pyx_k_SFTP_setstat, sizeof(__pyx_k_SFTP_setstat), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_stat, __pyx_k_SFTP_stat, sizeof(__pyx_k_SFTP_stat), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_statvfs, __pyx_k_SFTP_statvfs, sizeof(__pyx_k_SFTP_statvfs), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_symlink, __pyx_k_SFTP_symlink, sizeof(__pyx_k_SFTP_symlink), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTP_unlink, __pyx_k_SFTP_unlink, sizeof(__pyx_k_SFTP_unlink), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s__37, __pyx_k__37, sizeof(__pyx_k__37), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
+    {&__pyx_n_s_b_dest_filename, __pyx_k_b_dest_filename, sizeof(__pyx_k_b_dest_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_b_filename, __pyx_k_b_filename, sizeof(__pyx_k_b_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_b_path, __pyx_k_b_path, sizeof(__pyx_k_b_path), 0, 0, 1, 1},
+    {&__pyx_n_s_b_source_filename, __pyx_k_b_source_filename, sizeof(__pyx_k_b_source_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_b_target, __pyx_k_b_target, sizeof(__pyx_k_b_target), 0, 0, 1, 1},
+    {&__pyx_n_s_channel, __pyx_k_channel, sizeof(__pyx_k_channel), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_dest_filename, __pyx_k_dest_filename, sizeof(__pyx_k_dest_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_dest_filename_2, __pyx_k_dest_filename_2, sizeof(__pyx_k_dest_filename_2), 0, 0, 1, 1},
+    {&__pyx_n_s_dest_filename_len, __pyx_k_dest_filename_len, sizeof(__pyx_k_dest_filename_len), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_filename_2, __pyx_k_filename_2, sizeof(__pyx_k_filename_2), 0, 0, 1, 1},
+    {&__pyx_n_s_filename_len, __pyx_k_filename_len, sizeof(__pyx_k_filename_len), 0, 0, 1, 1},
+    {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_get_channel, __pyx_k_get_channel, sizeof(__pyx_k_get_channel), 0, 0, 1, 1},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_handle, __pyx_k_handle, sizeof(__pyx_k_handle), 0, 0, 1, 1},
+    {&__pyx_n_s_handle_2, __pyx_k_handle_2, sizeof(__pyx_k_handle_2), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_last_error, __pyx_k_last_error, sizeof(__pyx_k_last_error), 0, 0, 1, 1},
+    {&__pyx_n_s_lstat, __pyx_k_lstat, sizeof(__pyx_k_lstat), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_max_len, __pyx_k_max_len, sizeof(__pyx_k_max_len), 0, 0, 1, 1},
+    {&__pyx_n_s_mkdir, __pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 0, 1, 1},
+    {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1},
+    {&__pyx_n_s_open_ex, __pyx_k_open_ex, sizeof(__pyx_k_open_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_open_type, __pyx_k_open_type, sizeof(__pyx_k_open_type), 0, 0, 1, 1},
+    {&__pyx_n_s_opendir, __pyx_k_opendir, sizeof(__pyx_k_opendir), 0, 0, 1, 1},
+    {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
+    {&__pyx_n_s_path_2, __pyx_k_path_2, sizeof(__pyx_k_path_2), 0, 0, 1, 1},
+    {&__pyx_n_s_path_len, __pyx_k_path_len, sizeof(__pyx_k_path_len), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_realpath, __pyx_k_realpath, sizeof(__pyx_k_realpath), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_rename, __pyx_k_rename, sizeof(__pyx_k_rename), 0, 0, 1, 1},
+    {&__pyx_n_s_rename_ex, __pyx_k_rename_ex, sizeof(__pyx_k_rename_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_rmdir, __pyx_k_rmdir, sizeof(__pyx_k_rmdir), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_setstat, __pyx_k_setstat, sizeof(__pyx_k_setstat), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_source_filename, __pyx_k_source_filename, sizeof(__pyx_k_source_filename), 0, 0, 1, 1},
+    {&__pyx_n_s_source_filename_2, __pyx_k_source_filename_2, sizeof(__pyx_k_source_filename_2), 0, 0, 1, 1},
+    {&__pyx_n_s_source_filename_len, __pyx_k_source_filename_len, sizeof(__pyx_k_source_filename_len), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_sftp, __pyx_k_ssh2_sftp, sizeof(__pyx_k_ssh2_sftp), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_sftp_pyx, __pyx_k_ssh2_sftp_pyx, sizeof(__pyx_k_ssh2_sftp_pyx), 0, 0, 1, 0},
+    {&__pyx_n_s_stat, __pyx_k_stat, sizeof(__pyx_k_stat), 0, 0, 1, 1},
+    {&__pyx_n_s_statvfs, __pyx_k_statvfs, sizeof(__pyx_k_statvfs), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_symlink, __pyx_k_symlink, sizeof(__pyx_k_symlink), 0, 0, 1, 1},
+    {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1},
+    {&__pyx_n_s_target_2, __pyx_k_target_2, sizeof(__pyx_k_target_2), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1},
+    {&__pyx_n_s_vfs, __pyx_k_vfs, sizeof(__pyx_k_vfs), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 447, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
@@ -5683,42 +8530,245 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/sftp.pyx":191
+ *         return self._session
+ * 
+ *     def get_channel(self):             # <<<<<<<<<<<<<<
+ *         """Get new channel from the SFTP session"""
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *_channel
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_channel); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 191, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_get_channel, 191, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 191, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/sftp.pyx":201
+ *         return PyChannel(_channel, self._session)
+ * 
+ *     def open_ex(self, const char *filename,             # <<<<<<<<<<<<<<
+ *                 unsigned int filename_len,
+ *                 unsigned long flags,
+ */
+  __pyx_tuple__3 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_filename_len, __pyx_n_s_flags, __pyx_n_s_mode, __pyx_n_s_open_type, __pyx_n_s_handle, __pyx_n_s_handle_2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_open_ex, 201, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 201, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":217
+ *         return handle
+ * 
+ *     def open(self, filename not None,             # <<<<<<<<<<<<<<
+ *              unsigned long flags,
+ *              long mode):
+ */
+  __pyx_tuple__5 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_flags, __pyx_n_s_mode, __pyx_n_s_handle, __pyx_n_s_b_filename, __pyx_n_s_filename_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_open, 217, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 217, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":262
+ *         return PySFTPHandle(_handle, self)
+ * 
+ *     def opendir(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Open handle to directory path.
+ * 
+ */
+  __pyx_tuple__7 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_handle, __pyx_n_s_b_path, __pyx_n_s_path_2); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_opendir, 262, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 262, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":283
+ *         return PySFTPHandle(_handle, self)
+ * 
+ *     def rename_ex(self, const char *source_filename,             # <<<<<<<<<<<<<<
+ *                   unsigned int source_filename_len,
+ *                   const char *dest_filename,
+ */
+  __pyx_tuple__9 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_source_filename, __pyx_n_s_source_filename_len, __pyx_n_s_dest_filename, __pyx_n_s_dest_filename_len, __pyx_n_s_flags, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_rename_ex, 283, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 283, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":295
+ *         return handle_error_codes(rc)
+ * 
+ *     def rename(self, source_filename not None, dest_filename not None):             # <<<<<<<<<<<<<<
+ *         """Rename file.
+ * 
+ */
+  __pyx_tuple__11 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_source_filename, __pyx_n_s_dest_filename, __pyx_n_s_rc, __pyx_n_s_b_source_filename, __pyx_n_s_b_dest_filename, __pyx_n_s_source_filename_2, __pyx_n_s_dest_filename_2); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 295, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_rename, 295, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 295, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":312
+ *         return handle_error_codes(rc)
+ * 
+ *     def unlink(self, filename not None):             # <<<<<<<<<<<<<<
+ *         """Delete/unlink file.
+ * 
+ */
+  __pyx_tuple__13 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_rc, __pyx_n_s_b_filename, __pyx_n_s_filename_2); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+  __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_unlink, 312, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 312, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":324
+ *         return handle_error_codes(rc)
+ * 
+ *     def statvfs(self, path):             # <<<<<<<<<<<<<<
+ *         """Get file system statistics from path.
+ * 
+ */
+  __pyx_tuple__15 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_vfs, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_path_len, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+  __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_statvfs, 324, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 324, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":337
+ *         return handle_error_codes(rc) if rc != 0 else vfs
+ * 
+ *     def mkdir(self, path not None, long mode):             # <<<<<<<<<<<<<<
+ *         """Make directory.
+ * 
+ */
+  __pyx_tuple__17 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_mode, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_mkdir, 337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 337, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":356
+ *         return handle_error_codes(rc)
+ * 
+ *     def rmdir(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Remove directory.
+ * 
+ */
+  __pyx_tuple__19 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_rmdir, 356, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 356, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":370
+ *         return handle_error_codes(rc)
+ * 
+ *     def stat(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Stat file.
+ * 
+ */
+  __pyx_tuple__21 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_attrs); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_stat, 370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 370, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":387
+ *         return handle_error_codes(rc) if rc != 0 else attrs
+ * 
+ *     def lstat(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Link stat a file."""
+ *         cdef int rc
+ */
+  __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_lstat, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 387, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":398
+ *         return handle_error_codes(rc) if rc != 0 else attrs
+ * 
+ *     def setstat(self, path not None, SFTPAttributes attrs):             # <<<<<<<<<<<<<<
+ *         """Set file attributes.
+ * 
+ */
+  __pyx_tuple__24 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_attrs, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+  __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_setstat, 398, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 398, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":415
+ *         return handle_error_codes(rc)
+ * 
+ *     def symlink(self, path not None, target not None):             # <<<<<<<<<<<<<<
+ *         """Create symlink.
+ * 
+ */
+  __pyx_tuple__26 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_target, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2, __pyx_n_s_b_target, __pyx_n_s_target_2); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_symlink, 415, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 415, __pyx_L1_error)
+
+  /* "ssh2/sftp.pyx":433
+ *         return handle_error_codes(rc)
+ * 
+ *     def realpath(self, path not None, size_t max_len=256):             # <<<<<<<<<<<<<<
+ *         """Get real path for path.
+ * 
+ */
+  __pyx_tuple__28 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_max_len, __pyx_n_s_target_2, __pyx_n_s_rc, __pyx_n_s_b_path, __pyx_n_s_path_2); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 433, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_realpath, 433, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 433, __pyx_L1_error)
+  __pyx_tuple__30 = PyTuple_Pack(1, __pyx_int_256); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 433, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+
+  /* "ssh2/sftp.pyx":462
+ *             free(_target)
+ * 
+ *     def last_error(self):             # <<<<<<<<<<<<<<
+ *         """Get last error code from SFTP channel.
+ * 
+ */
+  __pyx_tuple__31 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 462, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_pyx, __pyx_n_s_last_error, 462, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 462, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__33 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(1, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_tuple__35 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_256 = PyInt_FromLong(256); if (unlikely(!__pyx_int_256)) __PYX_ERR(0, 1, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -5766,16 +8816,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_4sftp_SFTP.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_4sftp_SFTP = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_4sftp_SFTP_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_4sftp_SFTP)) __PYX_ERR(0, 170, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_4sftp_SFTP_spec, __pyx_ptype_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_4sftp_SFTP = &__pyx_type_4ssh2_4sftp_SFTP;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_4sftp_SFTP.tp_dictoffset && __pyx_type_4ssh2_4sftp_SFTP.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_4sftp_SFTP.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_4sftp_SFTP->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_4sftp_SFTP->tp_dictoffset && __pyx_ptype_4ssh2_4sftp_SFTP->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_4sftp_SFTP->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTP, (PyObject *)&__pyx_type_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
-  __pyx_ptype_4ssh2_4sftp_SFTP = &__pyx_type_4ssh2_4sftp_SFTP;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTP, (PyObject *) __pyx_ptype_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_4sftp_SFTP) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -5793,24 +8856,18 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 24, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(3, 24, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7channel_Channel = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.channel", "Channel", sizeof(struct __pyx_obj_4ssh2_7channel_Channel), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7channel_Channel),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7channel_Channel) __PYX_ERR(3, 24, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.sftp_handle"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 25, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp_handle", "SFTPHandle", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) __PYX_ERR(4, 25, __pyx_L1_error)
-  __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp_handle", "SFTPAttributes", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) __PYX_ERR(4, 31, __pyx_L1_error)
-  __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp_handle", "SFTPStatVFS", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) __PYX_ERR(4, 35, __pyx_L1_error)
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp_handle", "SFTPHandle", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) __PYX_ERR(4, 25, __pyx_L1_error)
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp_handle", "SFTPAttributes", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) __PYX_ERR(4, 31, __pyx_L1_error)
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp_handle", "SFTPStatVFS", sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) __PYX_ERR(4, 35, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -5838,17 +8895,17 @@ static int __Pyx_modinit_function_import_code(void) {
   /*--- Function import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.channel"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PyChannel", (void (**)(void))&__pyx_f_4ssh2_7channel_PyChannel, "PyObject *(LIBSSH2_CHANNEL *, struct __pyx_obj_4ssh2_7session_Session *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "to_str_len", (void (**)(void))&__pyx_f_4ssh2_5utils_to_str_len, "PyObject *(char *, int)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_bytes", (void (**)(void))&__pyx_f_4ssh2_5utils_to_bytes, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "to_str_len", (void (**)(void))&__pyx_f_4ssh2_5utils_to_str_len, "PyObject *(char *, int)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.sftp_handle"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "PySFTPHandle", (void (**)(void))&__pyx_f_4ssh2_11sftp_handle_PySFTPHandle, "PyObject *(LIBSSH2_SFTP_HANDLE *, struct __pyx_obj_4ssh2_4sftp_SFTP *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "PySFTPHandle", (void (**)(void))&__pyx_f_4ssh2_11sftp_handle_PySFTPHandle, "PyObject *(LIBSSH2_SFTP_HANDLE *, struct __pyx_obj_4ssh2_4sftp_SFTP *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -5859,6 +8916,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_sftp(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_sftp},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "sftp",
+      __pyx_k_SFTP_channel_class_and_related, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -5909,12 +9015,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -5924,8 +9039,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -5935,8 +9051,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -5952,7 +9072,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_sftp(PyObject *__pyx_pyinit_module
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -5966,6 +9091,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_sftp(PyObject *__pyx_pyinit_module
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("sftp", __pyx_methods, __pyx_k_SFTP_channel_class_and_related, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "sftp" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -5976,7 +9128,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_sftp(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -5984,48 +9136,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("sftp", __pyx_methods, __pyx_k_SFTP_channel_class_and_related, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -6037,7 +9172,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.sftp")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.sftp", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.sftp", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -6048,11 +9183,11 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -6065,10 +9200,10 @@ if (!__Pyx_RefNanny) {
  * # named pipe (fifo)
  * LIBSSH2_SFTP_S_IFIFO = c_sftp.LIBSSH2_SFTP_S_IFIFO
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFMT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFMT, __pyx_t_1) < 0) __PYX_ERR(0, 104, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFMT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFMT, __pyx_t_2) < 0) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":106
  * LIBSSH2_SFTP_S_IFMT = c_sftp.LIBSSH2_SFTP_S_IFMT
@@ -6077,10 +9212,10 @@ if (!__Pyx_RefNanny) {
  * # character special
  * LIBSSH2_SFTP_S_IFCHR = c_sftp.LIBSSH2_SFTP_S_IFCHR
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFIFO); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFIFO, __pyx_t_1) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFIFO); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFIFO, __pyx_t_2) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":108
  * LIBSSH2_SFTP_S_IFIFO = c_sftp.LIBSSH2_SFTP_S_IFIFO
@@ -6089,10 +9224,10 @@ if (!__Pyx_RefNanny) {
  * # directory
  * LIBSSH2_SFTP_S_IFDIR = c_sftp.LIBSSH2_SFTP_S_IFDIR
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFCHR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFCHR, __pyx_t_1) < 0) __PYX_ERR(0, 108, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFCHR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFCHR, __pyx_t_2) < 0) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":110
  * LIBSSH2_SFTP_S_IFCHR = c_sftp.LIBSSH2_SFTP_S_IFCHR
@@ -6101,10 +9236,10 @@ if (!__Pyx_RefNanny) {
  * # block special (block device)
  * LIBSSH2_SFTP_S_IFBLK = c_sftp.LIBSSH2_SFTP_S_IFBLK
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFDIR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFDIR, __pyx_t_1) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFDIR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFDIR, __pyx_t_2) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":112
  * LIBSSH2_SFTP_S_IFDIR = c_sftp.LIBSSH2_SFTP_S_IFDIR
@@ -6113,10 +9248,10 @@ if (!__Pyx_RefNanny) {
  * # regular
  * LIBSSH2_SFTP_S_IFREG = c_sftp.LIBSSH2_SFTP_S_IFREG
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFBLK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFBLK, __pyx_t_1) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFBLK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFBLK, __pyx_t_2) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":114
  * LIBSSH2_SFTP_S_IFBLK = c_sftp.LIBSSH2_SFTP_S_IFBLK
@@ -6125,10 +9260,10 @@ if (!__Pyx_RefNanny) {
  * # symbolic link
  * LIBSSH2_SFTP_S_IFLNK = c_sftp.LIBSSH2_SFTP_S_IFLNK
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFREG); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFREG, __pyx_t_1) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFREG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFREG, __pyx_t_2) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":116
  * LIBSSH2_SFTP_S_IFREG = c_sftp.LIBSSH2_SFTP_S_IFREG
@@ -6137,10 +9272,10 @@ if (!__Pyx_RefNanny) {
  * # socket
  * LIBSSH2_SFTP_S_IFSOCK = c_sftp.LIBSSH2_SFTP_S_IFSOCK
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFLNK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFLNK, __pyx_t_1) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFLNK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFLNK, __pyx_t_2) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":118
  * LIBSSH2_SFTP_S_IFLNK = c_sftp.LIBSSH2_SFTP_S_IFLNK
@@ -6149,10 +9284,10 @@ if (!__Pyx_RefNanny) {
  * 
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IFSOCK); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFSOCK, __pyx_t_1) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IFSOCK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IFSOCK, __pyx_t_2) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":123
  * # Attributes
@@ -6161,10 +9296,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_ATTR_UIDGID = c_sftp.LIBSSH2_SFTP_ATTR_UIDGID
  * LIBSSH2_SFTP_ATTR_PERMISSIONS = c_sftp.LIBSSH2_SFTP_ATTR_PERMISSIONS
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ATTR_SIZE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE, __pyx_t_1) < 0) __PYX_ERR(0, 123, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ATTR_SIZE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_SIZE, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":124
  * 
@@ -6173,10 +9308,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_ATTR_PERMISSIONS = c_sftp.LIBSSH2_SFTP_ATTR_PERMISSIONS
  * LIBSSH2_SFTP_ATTR_ACMODTIME = c_sftp.LIBSSH2_SFTP_ATTR_ACMODTIME
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ATTR_UIDGID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID, __pyx_t_1) < 0) __PYX_ERR(0, 124, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ATTR_UIDGID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_UIDGID, __pyx_t_2) < 0) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":125
  * LIBSSH2_SFTP_ATTR_SIZE = c_sftp.LIBSSH2_SFTP_ATTR_SIZE
@@ -6185,10 +9320,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_ATTR_ACMODTIME = c_sftp.LIBSSH2_SFTP_ATTR_ACMODTIME
  * LIBSSH2_SFTP_ATTR_EXTENDED = c_sftp.LIBSSH2_SFTP_ATTR_EXTENDED
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ATTR_PERMISSIONS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS, __pyx_t_1) < 0) __PYX_ERR(0, 125, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ATTR_PERMISSIONS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_PERMISSIONS, __pyx_t_2) < 0) __PYX_ERR(0, 125, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":126
  * LIBSSH2_SFTP_ATTR_UIDGID = c_sftp.LIBSSH2_SFTP_ATTR_UIDGID
@@ -6197,10 +9332,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_ATTR_EXTENDED = c_sftp.LIBSSH2_SFTP_ATTR_EXTENDED
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ATTR_ACMODTIME); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME, __pyx_t_1) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ATTR_ACMODTIME); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_ACMODTIME, __pyx_t_2) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":127
  * LIBSSH2_SFTP_ATTR_PERMISSIONS = c_sftp.LIBSSH2_SFTP_ATTR_PERMISSIONS
@@ -6209,10 +9344,10 @@ if (!__Pyx_RefNanny) {
  * 
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ATTR_EXTENDED); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED, __pyx_t_1) < 0) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ATTR_EXTENDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ATTR_EXTENDED, __pyx_t_2) < 0) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":132
  * # File Transfer Flags
@@ -6221,10 +9356,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_FXF_WRITE = c_sftp.LIBSSH2_FXF_WRITE
  * LIBSSH2_FXF_APPEND = c_sftp.LIBSSH2_FXF_APPEND
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_READ); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_READ, __pyx_t_1) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_READ); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_READ, __pyx_t_2) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":133
  * 
@@ -6233,10 +9368,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_FXF_APPEND = c_sftp.LIBSSH2_FXF_APPEND
  * LIBSSH2_FXF_CREAT = c_sftp.LIBSSH2_FXF_CREAT
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_WRITE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_WRITE, __pyx_t_1) < 0) __PYX_ERR(0, 133, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_WRITE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_WRITE, __pyx_t_2) < 0) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":134
  * LIBSSH2_FXF_READ = c_sftp.LIBSSH2_FXF_READ
@@ -6245,10 +9380,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_FXF_CREAT = c_sftp.LIBSSH2_FXF_CREAT
  * LIBSSH2_FXF_TRUNC = c_sftp.LIBSSH2_FXF_TRUNC
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_APPEND); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_APPEND, __pyx_t_1) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_APPEND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_APPEND, __pyx_t_2) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":135
  * LIBSSH2_FXF_WRITE = c_sftp.LIBSSH2_FXF_WRITE
@@ -6257,10 +9392,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_FXF_TRUNC = c_sftp.LIBSSH2_FXF_TRUNC
  * LIBSSH2_FXF_EXCL = c_sftp.LIBSSH2_FXF_EXCL
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_CREAT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_CREAT, __pyx_t_1) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_CREAT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_CREAT, __pyx_t_2) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":136
  * LIBSSH2_FXF_APPEND = c_sftp.LIBSSH2_FXF_APPEND
@@ -6269,10 +9404,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_FXF_EXCL = c_sftp.LIBSSH2_FXF_EXCL
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_TRUNC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_TRUNC, __pyx_t_1) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_TRUNC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_TRUNC, __pyx_t_2) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":137
  * LIBSSH2_FXF_CREAT = c_sftp.LIBSSH2_FXF_CREAT
@@ -6281,10 +9416,10 @@ if (!__Pyx_RefNanny) {
  * 
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_FXF_EXCL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_EXCL, __pyx_t_1) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_FXF_EXCL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_FXF_EXCL, __pyx_t_2) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":143
  * 
@@ -6293,10 +9428,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IRUSR = c_sftp.LIBSSH2_SFTP_S_IRUSR
  * LIBSSH2_SFTP_S_IWUSR = c_sftp.LIBSSH2_SFTP_S_IWUSR
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IRWXU); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXU, __pyx_t_1) < 0) __PYX_ERR(0, 143, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IRWXU); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXU, __pyx_t_2) < 0) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":144
  * # Read, write, execute/search by owner
@@ -6305,10 +9440,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IWUSR = c_sftp.LIBSSH2_SFTP_S_IWUSR
  * LIBSSH2_SFTP_S_IXUSR = c_sftp.LIBSSH2_SFTP_S_IXUSR
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IRUSR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRUSR, __pyx_t_1) < 0) __PYX_ERR(0, 144, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IRUSR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRUSR, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":145
  * LIBSSH2_SFTP_S_IRWXU = c_sftp.LIBSSH2_SFTP_S_IRWXU
@@ -6317,10 +9452,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IXUSR = c_sftp.LIBSSH2_SFTP_S_IXUSR
  * # Read, write, execute/search by group
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IWUSR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWUSR, __pyx_t_1) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IWUSR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWUSR, __pyx_t_2) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":146
  * LIBSSH2_SFTP_S_IRUSR = c_sftp.LIBSSH2_SFTP_S_IRUSR
@@ -6329,10 +9464,10 @@ if (!__Pyx_RefNanny) {
  * # Read, write, execute/search by group
  * LIBSSH2_SFTP_S_IRWXG = c_sftp.LIBSSH2_SFTP_S_IRWXG
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IXUSR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXUSR, __pyx_t_1) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IXUSR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXUSR, __pyx_t_2) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":148
  * LIBSSH2_SFTP_S_IXUSR = c_sftp.LIBSSH2_SFTP_S_IXUSR
@@ -6341,10 +9476,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IRGRP = c_sftp.LIBSSH2_SFTP_S_IRGRP
  * LIBSSH2_SFTP_S_IWGRP = c_sftp.LIBSSH2_SFTP_S_IWGRP
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IRWXG); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXG, __pyx_t_1) < 0) __PYX_ERR(0, 148, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IRWXG); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXG, __pyx_t_2) < 0) __PYX_ERR(0, 148, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":149
  * # Read, write, execute/search by group
@@ -6353,10 +9488,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IWGRP = c_sftp.LIBSSH2_SFTP_S_IWGRP
  * LIBSSH2_SFTP_S_IXGRP = c_sftp.LIBSSH2_SFTP_S_IXGRP
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IRGRP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRGRP, __pyx_t_1) < 0) __PYX_ERR(0, 149, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IRGRP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRGRP, __pyx_t_2) < 0) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":150
  * LIBSSH2_SFTP_S_IRWXG = c_sftp.LIBSSH2_SFTP_S_IRWXG
@@ -6365,10 +9500,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IXGRP = c_sftp.LIBSSH2_SFTP_S_IXGRP
  * # Read, write, execute/search by others
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IWGRP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWGRP, __pyx_t_1) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IWGRP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWGRP, __pyx_t_2) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":151
  * LIBSSH2_SFTP_S_IRGRP = c_sftp.LIBSSH2_SFTP_S_IRGRP
@@ -6377,10 +9512,10 @@ if (!__Pyx_RefNanny) {
  * # Read, write, execute/search by others
  * LIBSSH2_SFTP_S_IRWXO = c_sftp.LIBSSH2_SFTP_S_IRWXO
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IXGRP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXGRP, __pyx_t_1) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IXGRP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXGRP, __pyx_t_2) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":153
  * LIBSSH2_SFTP_S_IXGRP = c_sftp.LIBSSH2_SFTP_S_IXGRP
@@ -6389,10 +9524,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IROTH = c_sftp.LIBSSH2_SFTP_S_IROTH
  * LIBSSH2_SFTP_S_IWOTH = c_sftp.LIBSSH2_SFTP_S_IWOTH
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IRWXO); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXO, __pyx_t_1) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IRWXO); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IRWXO, __pyx_t_2) < 0) __PYX_ERR(0, 153, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":154
  * # Read, write, execute/search by others
@@ -6401,10 +9536,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IWOTH = c_sftp.LIBSSH2_SFTP_S_IWOTH
  * LIBSSH2_SFTP_S_IXOTH = c_sftp.LIBSSH2_SFTP_S_IXOTH
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IROTH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IROTH, __pyx_t_1) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IROTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IROTH, __pyx_t_2) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":155
  * LIBSSH2_SFTP_S_IRWXO = c_sftp.LIBSSH2_SFTP_S_IRWXO
@@ -6413,10 +9548,10 @@ if (!__Pyx_RefNanny) {
  * LIBSSH2_SFTP_S_IXOTH = c_sftp.LIBSSH2_SFTP_S_IXOTH
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IWOTH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWOTH, __pyx_t_1) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IWOTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IWOTH, __pyx_t_2) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":156
  * LIBSSH2_SFTP_S_IROTH = c_sftp.LIBSSH2_SFTP_S_IROTH
@@ -6425,10 +9560,10 @@ if (!__Pyx_RefNanny) {
  * 
  * # Read only
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_S_IXOTH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXOTH, __pyx_t_1) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_S_IXOTH); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_S_IXOTH, __pyx_t_2) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":159
  * 
@@ -6437,10 +9572,10 @@ if (!__Pyx_RefNanny) {
  * # No suid
  * LIBSSH2_SFTP_ST_NOSUID = c_sftp.LIBSSH2_SFTP_ST_NOSUID
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ST_RDONLY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ST_RDONLY, __pyx_t_1) < 0) __PYX_ERR(0, 159, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ST_RDONLY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ST_RDONLY, __pyx_t_2) < 0) __PYX_ERR(0, 159, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":161
  * LIBSSH2_SFTP_ST_RDONLY = c_sftp.LIBSSH2_SFTP_ST_RDONLY
@@ -6449,31 +9584,271 @@ if (!__Pyx_RefNanny) {
  * 
  * 
  */
-  __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_SFTP_ST_NOSUID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ST_NOSUID, __pyx_t_1) < 0) __PYX_ERR(0, 161, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_SFTP_ST_NOSUID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LIBSSH2_SFTP_ST_NOSUID, __pyx_t_2) < 0) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/sftp.pyx":191
+ *         return self._session
+ * 
+ *     def get_channel(self):             # <<<<<<<<<<<<<<
+ *         """Get new channel from the SFTP session"""
+ *         cdef c_ssh2.LIBSSH2_CHANNEL *_channel
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_5get_channel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_get_channel, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_get_channel, __pyx_t_2) < 0) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":201
+ *         return PyChannel(_channel, self._session)
+ * 
+ *     def open_ex(self, const char *filename,             # <<<<<<<<<<<<<<
+ *                 unsigned int filename_len,
+ *                 unsigned long flags,
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_7open_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_open_ex, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_open_ex, __pyx_t_2) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":217
+ *         return handle
+ * 
+ *     def open(self, filename not None,             # <<<<<<<<<<<<<<
+ *              unsigned long flags,
+ *              long mode):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_9open, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_open, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_open, __pyx_t_2) < 0) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":262
+ *         return PySFTPHandle(_handle, self)
+ * 
+ *     def opendir(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Open handle to directory path.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_11opendir, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_opendir, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_opendir, __pyx_t_2) < 0) __PYX_ERR(0, 262, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":283
+ *         return PySFTPHandle(_handle, self)
+ * 
+ *     def rename_ex(self, const char *source_filename,             # <<<<<<<<<<<<<<
+ *                   unsigned int source_filename_len,
+ *                   const char *dest_filename,
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_13rename_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_rename_ex, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_rename_ex, __pyx_t_2) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":295
+ *         return handle_error_codes(rc)
+ * 
+ *     def rename(self, source_filename not None, dest_filename not None):             # <<<<<<<<<<<<<<
+ *         """Rename file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_15rename, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_rename, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_rename, __pyx_t_2) < 0) __PYX_ERR(0, 295, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":312
+ *         return handle_error_codes(rc)
+ * 
+ *     def unlink(self, filename not None):             # <<<<<<<<<<<<<<
+ *         """Delete/unlink file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_17unlink, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_unlink, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_unlink, __pyx_t_2) < 0) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":324
+ *         return handle_error_codes(rc)
+ * 
+ *     def statvfs(self, path):             # <<<<<<<<<<<<<<
+ *         """Get file system statistics from path.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_19statvfs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_statvfs, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_statvfs, __pyx_t_2) < 0) __PYX_ERR(0, 324, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":337
+ *         return handle_error_codes(rc) if rc != 0 else vfs
+ * 
+ *     def mkdir(self, path not None, long mode):             # <<<<<<<<<<<<<<
+ *         """Make directory.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_21mkdir, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_mkdir, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_mkdir, __pyx_t_2) < 0) __PYX_ERR(0, 337, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":356
+ *         return handle_error_codes(rc)
+ * 
+ *     def rmdir(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Remove directory.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_23rmdir, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_rmdir, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_rmdir, __pyx_t_2) < 0) __PYX_ERR(0, 356, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":370
+ *         return handle_error_codes(rc)
+ * 
+ *     def stat(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Stat file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_25stat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_stat, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_stat, __pyx_t_2) < 0) __PYX_ERR(0, 370, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":387
+ *         return handle_error_codes(rc) if rc != 0 else attrs
+ * 
+ *     def lstat(self, path not None):             # <<<<<<<<<<<<<<
+ *         """Link stat a file."""
+ *         cdef int rc
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_27lstat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_lstat, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 387, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_lstat, __pyx_t_2) < 0) __PYX_ERR(0, 387, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":398
+ *         return handle_error_codes(rc) if rc != 0 else attrs
+ * 
+ *     def setstat(self, path not None, SFTPAttributes attrs):             # <<<<<<<<<<<<<<
+ *         """Set file attributes.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_29setstat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_setstat, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_setstat, __pyx_t_2) < 0) __PYX_ERR(0, 398, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":415
+ *         return handle_error_codes(rc)
+ * 
+ *     def symlink(self, path not None, target not None):             # <<<<<<<<<<<<<<
+ *         """Create symlink.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_31symlink, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_symlink, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_symlink, __pyx_t_2) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":433
+ *         return handle_error_codes(rc)
+ * 
+ *     def realpath(self, path not None, size_t max_len=256):             # <<<<<<<<<<<<<<
+ *         """Get real path for path.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_33realpath, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_realpath, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 433, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__30);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_realpath, __pyx_t_2) < 0) __PYX_ERR(0, 433, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "ssh2/sftp.pyx":462
+ *             free(_target)
+ * 
+ *     def last_error(self):             # <<<<<<<<<<<<<<
+ *         """Get last error code from SFTP channel.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_35last_error, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP_last_error, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 462, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_4sftp_SFTP, __pyx_n_s_last_error, __pyx_t_2) < 0) __PYX_ERR(0, 462, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_4sftp_SFTP);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_37__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP___reduce_cython, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_4sftp_4SFTP_39__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTP___setstate_cython, NULL, __pyx_n_s_ssh2_sftp, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.sftp", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.sftp");
   }
@@ -6487,7 +9862,23 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
-
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
 /* --- Runtime support code --- */
 /* Refnanny */
 #if CYTHON_REFNANNY
@@ -6506,6 +9897,108 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
 /* PyObjectGetAttrStr */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
@@ -6520,10 +10013,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -6534,6 +10056,231 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
 /* RaiseDoubleKeywords */
 static void __Pyx_RaiseDoubleKeywordsError(
     const char* func_name,
@@ -6551,6 +10298,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -6561,13 +10309,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
         name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -6575,6 +10364,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -6595,14 +10387,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -6629,6 +10425,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -6638,15 +10436,18 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
@@ -6678,42 +10479,100 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 /* ExtTypeTest */
 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    __Pyx_TypeName obj_type_name;
+    __Pyx_TypeName type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
     }
     if (likely(__Pyx_TypeCheck(obj, type)))
         return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    type_name = __Pyx_PyType_GetName(type);
+    PyErr_Format(PyExc_TypeError,
+                 "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME,
+                 obj_type_name, type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
     return 0;
 }
 
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
     }
-}
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
 #endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
 
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
 static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
@@ -6742,7 +10601,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -6758,9 +10616,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -6829,7 +10693,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
-#endif
 
 /* PyObjectCall */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -6838,8 +10701,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
     ternaryfunc call = Py_TYPE(func)->tp_call;
     if (unlikely(!call))
         return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = (*call)(func, arg, kw);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -6856,10 +10724,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -6871,71 +10744,101 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
     return result;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
-    }
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
 #endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
         }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
-#else
+
+/* PyObjectCallOneArg */
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
 /* PyObjectCallNoArg */
-#if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
-    }
-#endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
-        }
-    }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -6948,36 +10851,16 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* GetException */
 #if CYTHON_FAST_THREAD_STATE
 static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
@@ -6985,20 +10868,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject
 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #endif
 {
-    PyObject *local_type, *local_value, *local_tb;
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
 #if CYTHON_FAST_THREAD_STATE
     PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
     local_type = tstate->curexc_type;
     local_value = tstate->curexc_value;
     local_tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
+  #endif
 #else
     PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
     if (unlikely(tstate->curexc_type))
 #else
     if (unlikely(PyErr_Occurred()))
@@ -7020,12 +10915,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
     #if CYTHON_USE_EXC_INFO_STACK
     {
         _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
         tmp_type = exc_info->exc_type;
         tmp_value = exc_info->exc_value;
         tmp_tb = exc_info->exc_traceback;
         exc_info->exc_type = local_type;
         exc_info->exc_value = local_value;
         exc_info->exc_traceback = local_tb;
+      #endif
     }
     #else
     tmp_type = tstate->exc_type;
@@ -7056,7 +10960,26 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
     tmp_type = exc_info->exc_type;
     tmp_value = exc_info->exc_value;
@@ -7064,14 +10987,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
     exc_info->exc_type = *type;
     exc_info->exc_value = *value;
     exc_info->exc_traceback = *tb;
-    #else
+  #else
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
-    #endif
+  #endif
     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
@@ -7088,12 +11011,12 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem *
 __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 {
     _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
            exc_info->previous_item != NULL)
     {
         exc_info = exc_info->previous_item;
@@ -7105,21 +11028,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 /* SaveResetException */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
     *type = exc_info->exc_type;
     *value = exc_info->exc_value;
     *tb = exc_info->exc_traceback;
-    #else
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
-    #endif
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
+  #endif
 }
 static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     #if CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -7140,14 +11088,15 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+  #endif
 }
 #endif
 
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -7280,13 +11229,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -7294,6 +11239,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -7302,17 +11253,376 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
 /* PyObject_GenericGetAttrNoDict */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
     PyErr_Format(PyExc_AttributeError,
 #if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
 #endif
+    __Pyx_DECREF_TypeName(type_name);
     return NULL;
 }
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
@@ -7352,58 +11662,12 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 }
 #endif
 
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
-}
-#endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
-    }
-#endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
-    }
-    return result;
-}
-
 /* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
   int ret;
   PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
   if (likely(name_attr)) {
       ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
   } else {
@@ -7469,7 +11733,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
             } else if (reduce == object_reduce || PyErr_Occurred()) {
                 goto __PYX_BAD;
             }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
             if (!setstate) PyErr_Clear();
             if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
                 setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
@@ -7485,8 +11749,13 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     }
     goto __PYX_GOOD;
 __PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
     ret = -1;
 __PYX_GOOD:
 #if !CYTHON_USE_PYTYPE_LOOKUP
@@ -7502,67 +11771,1267 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
     Py_XDECREF(setstate_cython);
     return ret;
 }
+#endif
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
     PyObject *result = 0;
     char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
         goto bad;
     if (!PyType_Check(result)) {
         PyErr_Format(PyExc_TypeError,
-            "%.200s.%.200s is not a type object",
-            module_name, class_name);
-        goto bad;
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-#ifndef Py_LIMITED_API
-    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
-#endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
 }
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
 #endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
 
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -7592,12 +13061,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -7611,7 +13081,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -7633,6 +13103,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -7711,17 +13182,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -7756,6 +13311,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -7771,7 +13327,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -7818,6 +13374,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -7842,7 +13399,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     }
 
 /* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wconversion"
@@ -7872,10 +13429,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -7892,7 +13482,7 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned int) < sizeof(long)) {
+        if ((sizeof(unsigned int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -7901,168 +13491,239 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
             }
             return (unsigned int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyInt_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) {
                             return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) {
                             return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) {
                             return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned int) -1;
-        }
-    } else {
-        unsigned int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned int) -1;
-        val = __Pyx_PyInt_As_unsigned_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8088,7 +13749,7 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned long) < sizeof(long)) {
+        if ((sizeof(unsigned long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8097,168 +13758,239 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
             }
             return (unsigned long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned long) -1;
+        val = __Pyx_PyInt_As_unsigned_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned long) 1) << (sizeof(unsigned long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned long) -1;
-        }
-    } else {
-        unsigned long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned long) -1;
-        val = __Pyx_PyInt_As_unsigned_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8284,7 +14016,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8293,168 +14025,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
+        }
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
+                Py_DECREF(v);
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
         }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
-                Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
-            }
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8480,7 +14283,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8489,168 +14292,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8676,7 +14550,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8685,168 +14559,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -8859,6 +14804,77 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     return (size_t) -1;
 }
 
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -8890,13 +14906,62 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__37);
+    }
+    return name;
+}
+#endif
+
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -8928,10 +14993,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -8939,7 +15037,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -8960,6 +15058,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -8984,11 +15098,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -9036,41 +15150,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -9092,11 +15215,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -9111,9 +15230,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -9130,7 +15249,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -9138,21 +15256,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -9165,9 +15268,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -9175,30 +15300,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -9253,7 +15382,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -9282,22 +15411,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -9363,13 +15496,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -9437,4 +15568,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/sftp.pxd b/ssh2/sftp.pxd
index a9a872f8..3bf47fad 100644
--- a/ssh2/sftp.pxd
+++ b/ssh2/sftp.pxd
@@ -14,10 +14,10 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from session cimport Session
+from .session cimport Session
 
-cimport c_ssh2
-cimport c_sftp
+from . cimport c_ssh2
+from . cimport c_sftp
 
 
 cdef object PySFTP(c_sftp.LIBSSH2_SFTP *sftp, Session session)
diff --git a/ssh2/sftp.pyx b/ssh2/sftp.pyx
index 364ab0da..5cc73fff 100644
--- a/ssh2/sftp.pyx
+++ b/ssh2/sftp.pyx
@@ -89,13 +89,13 @@ ___________________
 
 from libc.stdlib cimport malloc, free
 
-from session cimport Session
-from channel cimport Channel, PyChannel
-from utils cimport to_bytes, to_str_len, handle_error_codes
-from sftp_handle cimport SFTPHandle, PySFTPHandle, SFTPAttributes, SFTPStatVFS
+from .session cimport Session
+from .channel cimport Channel, PyChannel
+from .utils cimport to_bytes, to_str_len, handle_error_codes
+from .sftp_handle cimport SFTPHandle, PySFTPHandle, SFTPAttributes, SFTPStatVFS
 
-cimport c_ssh2
-cimport c_sftp
+from . cimport c_ssh2
+from . cimport c_sftp
 
 
 # File types
diff --git a/ssh2/sftp_handle.c b/ssh2/sftp_handle.c
index 344c99ca..8d96c08c 100644
--- a/ssh2/sftp_handle.c
+++ b/ssh2/sftp_handle.c
@@ -1,22 +1,70 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.sftp_handle",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/sftp_handle.pyx"
+        ]
+    },
+    "module_name": "ssh2.sftp_handle"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +83,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +91,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +128,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +148,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +276,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +305,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +316,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +339,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +366,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +390,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +474,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +498,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +515,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +577,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +612,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +764,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +781,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +871,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +917,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +951,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1045,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1060,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1102,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1119,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1166,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1186,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1226,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -797,9 +1306,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -817,9 +1327,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -827,13 +1337,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -857,11 +1361,57 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
     PyObject* default_encoding = NULL;
     PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
@@ -879,7 +1429,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -909,6 +1459,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -944,25 +1495,28 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/sftp_handle.pyx",
-  "stringsource",
+  "<stringsource>",
   "ssh2/session.pxd",
   "ssh2/sftp.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -970,11 +1524,9 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
@@ -987,7 +1539,7 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex;
 struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1106,6 +1658,7 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1114,11 +1667,11 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1128,28 +1681,40 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1160,6 +1725,10 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1171,39 +1740,30 @@ struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1215,7 +1775,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1231,6 +1791,90 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
@@ -1238,8 +1882,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
 
 /* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
     const char* function_name);
 
 /* ExtTypeTest.proto */
@@ -1247,56 +1892,54 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
 
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
 #endif
-
-/* PyObjectCallMethO.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
 #endif
 
-/* PyObjectCallNoArg.proto */
+/* PyObjectCall.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
 #else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
 #endif
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
 
 /* RaiseTooManyValuesToUnpack.proto */
 static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
@@ -1310,6 +1953,9 @@ static CYTHON_INLINE int __Pyx_IterFinish(void);
 /* UnpackItemEndCheck.proto */
 static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
 
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
 /* GetException.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
@@ -1327,7 +1973,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1342,17 +1988,42 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 #define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+/* pep479.proto */
+static void __Pyx_Generator_Replace_StopIteration(int in_async_gen);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
 
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
-/* IncludeStringH.proto */
-#include <string.h>
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
 
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
@@ -1368,30 +2039,169 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
-#else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
-#endif
-
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
-
 /* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
 #endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1427,6 +2237,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1440,13 +2251,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1459,6 +2271,9 @@ static CYTHON_INLINE libssh2_uint64_t __Pyx_PyInt_As_libssh2_uint64_t(PyObject *
 /* CIntFromPy.proto */
 static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
 
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value);
+
 /* CIntFromPy.proto */
 static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 
@@ -1471,6 +2286,19 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_libssh2_uint64_t(libssh2_uint64_
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1480,27 +2308,29 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
-/* FetchCommonType.proto */
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
-
-/* PyObjectGetMethod.proto */
-static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+/* PyObjectCall2Args.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
 
 /* PyObjectCallMethod1.proto */
 static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
 
 /* CoroutineBase.proto */
-typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *);
+struct __pyx_CoroutineObject;
+typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *);
 #if CYTHON_USE_EXC_INFO_STACK
 #define __Pyx_ExcInfoStruct  _PyErr_StackItem
 #else
@@ -1510,7 +2340,7 @@ typedef struct {
     PyObject *exc_traceback;
 } __Pyx_ExcInfoStruct;
 #endif
-typedef struct {
+typedef struct __pyx_CoroutineObject {
     PyObject_HEAD
     __pyx_coroutine_body_t body;
     PyObject *closure;
@@ -1568,137 +2398,160 @@ static int __Pyx_patch_abc(void);
 
 /* Generator.proto */
 #define __Pyx_Generator_USED
-static PyTypeObject *__pyx_GeneratorType = 0;
-#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType)
+#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_GeneratorType)
 #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\
     __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name)
 static PyObject *__Pyx_Generator_Next(PyObject *self);
-static int __pyx_Generator_init(void);
+static int __pyx_Generator_init(PyObject *module);
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
 
 /* FunctionImport.proto */
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'ssh2.c_sftp' */
+/* Module declarations from "ssh2.c_sftp" */
 
-/* Module declarations from 'ssh2.sftp' */
-static PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP = 0;
+/* Module declarations from "ssh2.sftp" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static int (*__pyx_f_4ssh2_5utils_handle_error_codes)(int, int __pyx_skip_dispatch); /*proto*/
 
-/* Module declarations from 'ssh2.sftp_handle' */
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir = 0;
+/* Module declarations from "ssh2.sftp_handle" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.sftp_handle"
 extern int __pyx_module_is_main_ssh2__sftp_handle;
 int __pyx_module_is_main_ssh2__sftp_handle = 0;
 
-/* Implementation of 'ssh2.sftp_handle' */
+/* Implementation of "ssh2.sftp_handle" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
 static PyObject *__pyx_builtin_StopIteration;
-static const char __pyx_k__4[] = "";
+/* #### Code section: string_decls ### */
+static const char __pyx_k__2[] = "";
+static const char __pyx_k_gc[] = "gc";
+static const char __pyx_k_rc[] = "rc";
+static const char __pyx_k__45[] = "?";
+static const char __pyx_k_buf[] = "buf";
+static const char __pyx_k_vfs[] = "vfs";
 static const char __pyx_k_args[] = "args";
+static const char __pyx_k_cbuf[] = "cbuf";
+static const char __pyx_k_exit[] = "__exit__";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
 static const char __pyx_k_read[] = "read";
+static const char __pyx_k_seek[] = "seek";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_send[] = "send";
 static const char __pyx_k_sftp[] = "sftp";
+static const char __pyx_k_size[] = "_size";
+static const char __pyx_k_tell[] = "tell";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_attrs[] = "attrs";
 static const char __pyx_k_close[] = "close";
+static const char __pyx_k_enter[] = "__enter__";
+static const char __pyx_k_entry[] = "entry";
+static const char __pyx_k_fstat[] = "fstat";
+static const char __pyx_k_fsync[] = "fsync";
 static const char __pyx_k_throw[] = "throw";
+static const char __pyx_k_write[] = "write";
+static const char __pyx_k_enable[] = "enable";
+static const char __pyx_k_entryb[] = "entryb";
+static const char __pyx_k_offset[] = "offset";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_rewind[] = "rewind";
+static const char __pyx_k_seek64[] = "seek64";
+static const char __pyx_k_tell64[] = "tell64";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_readdir[] = "readdir";
 static const char __pyx_k_setstat[] = "setstat";
+static const char __pyx_k_fsetstat[] = "fsetstat";
+static const char __pyx_k_fstat_ex[] = "fstat_ex";
+static const char __pyx_k_fstatvfs[] = "fstatvfs";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_sftp_ref[] = "_sftp_ref";
+static const char __pyx_k_tot_size[] = "tot_size";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_longentry[] = "longentry";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_readdir_2[] = "_readdir";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_SFTPHandle[] = "SFTPHandle";
 static const char __pyx_k_readdir_ex[] = "readdir_ex";
 static const char __pyx_k_MemoryError[] = "MemoryError";
 static const char __pyx_k_SFTPStatVFS[] = "SFTPStatVFS";
+static const char __pyx_k_b_longentry[] = "b_longentry";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
 static const char __pyx_k_readdir_ex_2[] = "_readdir_ex";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_StopIteration[] = "StopIteration";
 static const char __pyx_k_buffer_maxlen[] = "buffer_maxlen";
+static const char __pyx_k_bytes_written[] = "bytes_written";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
 static const char __pyx_k_SFTPAttributes[] = "SFTPAttributes";
+static const char __pyx_k_SFTPHandle_read[] = "SFTPHandle.read";
+static const char __pyx_k_SFTPHandle_seek[] = "SFTPHandle.seek";
+static const char __pyx_k_SFTPHandle_tell[] = "SFTPHandle.tell";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_SFTPHandle_close[] = "SFTPHandle.close";
+static const char __pyx_k_SFTPHandle_fstat[] = "SFTPHandle.fstat";
+static const char __pyx_k_SFTPHandle_fsync[] = "SFTPHandle.fsync";
+static const char __pyx_k_SFTPHandle_write[] = "SFTPHandle.write";
 static const char __pyx_k_longentry_maxlen[] = "longentry_maxlen";
 static const char __pyx_k_ssh2_sftp_handle[] = "ssh2.sftp_handle";
+static const char __pyx_k_SFTPHandle___exit[] = "SFTPHandle.__exit__";
+static const char __pyx_k_SFTPHandle_rewind[] = "SFTPHandle.rewind";
+static const char __pyx_k_SFTPHandle_seek64[] = "SFTPHandle.seek64";
+static const char __pyx_k_SFTPHandle_tell64[] = "SFTPHandle.tell64";
+static const char __pyx_k_SFTPHandle___enter[] = "SFTPHandle.__enter__";
 static const char __pyx_k_SFTPHandle_readdir[] = "SFTPHandle.readdir";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_SFTPHandle__readdir[] = "SFTPHandle._readdir";
+static const char __pyx_k_SFTPHandle_fsetstat[] = "SFTPHandle.fsetstat";
+static const char __pyx_k_SFTPHandle_fstat_ex[] = "SFTPHandle.fstat_ex";
+static const char __pyx_k_SFTPHandle_fstatvfs[] = "SFTPHandle.fstatvfs";
+static const char __pyx_k_ssh2_sftp_handle_pyx[] = "ssh2/sftp_handle.pyx";
 static const char __pyx_k_SFTPHandle_readdir_ex[] = "SFTPHandle.readdir_ex";
+static const char __pyx_k_SFTPHandle__readdir_ex[] = "SFTPHandle._readdir_ex";
+static const char __pyx_k_SFTPHandle___reduce_cython[] = "SFTPHandle.__reduce_cython__";
+static const char __pyx_k_SFTPStatVFS___reduce_cython[] = "SFTPStatVFS.__reduce_cython__";
+static const char __pyx_k_SFTPHandle___setstate_cython[] = "SFTPHandle.__setstate_cython__";
+static const char __pyx_k_SFTPStatVFS___setstate_cython[] = "SFTPStatVFS.__setstate_cython__";
+static const char __pyx_k_SFTPAttributes___reduce_cython[] = "SFTPAttributes.__reduce_cython__";
 static const char __pyx_k_SFTP_handle_attributes_and_stat[] = "SFTP handle, attributes and stat VFS classes.";
+static const char __pyx_k_SFTPAttributes___setstate_cython[] = "SFTPAttributes.__setstate_cython__";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_SFTPAttributes;
-static PyObject *__pyx_n_s_SFTPHandle;
-static PyObject *__pyx_n_s_SFTPHandle_readdir;
-static PyObject *__pyx_n_s_SFTPHandle_readdir_ex;
-static PyObject *__pyx_n_s_SFTPStatVFS;
-static PyObject *__pyx_n_s_StopIteration;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_kp_b__4;
-static PyObject *__pyx_n_s_args;
-static PyObject *__pyx_n_s_attrs;
-static PyObject *__pyx_n_s_buffer_maxlen;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_close;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_longentry_maxlen;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_read;
-static PyObject *__pyx_n_s_readdir;
-static PyObject *__pyx_n_s_readdir_2;
-static PyObject *__pyx_n_s_readdir_ex;
-static PyObject *__pyx_n_s_readdir_ex_2;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_send;
-static PyObject *__pyx_n_s_setstat;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_sftp;
-static PyObject *__pyx_n_s_sftp_ref;
-static PyObject *__pyx_n_s_ssh2_sftp_handle;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_throw;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self); /* proto */
 static void __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_2__dealloc__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags___get__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self); /* proto */
@@ -1762,15 +2615,782 @@ static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPAttributes(PyTypeObject *t
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPStatVFS(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_int_0;
-static size_t __pyx_k__3;
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__5;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_tuple__7;
-static PyObject *__pyx_tuple__8;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_4sftp_SFTP;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_11sftp_handle_SFTPHandle;
+  PyObject *__pyx_type_4ssh2_11sftp_handle_SFTPAttributes;
+  PyObject *__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS;
+  PyObject *__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex;
+  PyObject *__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex;
+  PyTypeObject *__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_SFTPAttributes;
+  PyObject *__pyx_n_s_SFTPAttributes___reduce_cython;
+  PyObject *__pyx_n_s_SFTPAttributes___setstate_cython;
+  PyObject *__pyx_n_s_SFTPHandle;
+  PyObject *__pyx_n_s_SFTPHandle___enter;
+  PyObject *__pyx_n_s_SFTPHandle___exit;
+  PyObject *__pyx_n_s_SFTPHandle___reduce_cython;
+  PyObject *__pyx_n_s_SFTPHandle___setstate_cython;
+  PyObject *__pyx_n_s_SFTPHandle__readdir;
+  PyObject *__pyx_n_s_SFTPHandle__readdir_ex;
+  PyObject *__pyx_n_s_SFTPHandle_close;
+  PyObject *__pyx_n_s_SFTPHandle_fsetstat;
+  PyObject *__pyx_n_s_SFTPHandle_fstat;
+  PyObject *__pyx_n_s_SFTPHandle_fstat_ex;
+  PyObject *__pyx_n_s_SFTPHandle_fstatvfs;
+  PyObject *__pyx_n_s_SFTPHandle_fsync;
+  PyObject *__pyx_n_s_SFTPHandle_read;
+  PyObject *__pyx_n_s_SFTPHandle_readdir;
+  PyObject *__pyx_n_s_SFTPHandle_readdir_ex;
+  PyObject *__pyx_n_s_SFTPHandle_rewind;
+  PyObject *__pyx_n_s_SFTPHandle_seek;
+  PyObject *__pyx_n_s_SFTPHandle_seek64;
+  PyObject *__pyx_n_s_SFTPHandle_tell;
+  PyObject *__pyx_n_s_SFTPHandle_tell64;
+  PyObject *__pyx_n_s_SFTPHandle_write;
+  PyObject *__pyx_n_s_SFTPStatVFS;
+  PyObject *__pyx_n_s_SFTPStatVFS___reduce_cython;
+  PyObject *__pyx_n_s_SFTPStatVFS___setstate_cython;
+  PyObject *__pyx_n_s_StopIteration;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_kp_b__2;
+  PyObject *__pyx_n_s__45;
+  PyObject *__pyx_n_s_args;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_attrs;
+  PyObject *__pyx_n_s_b_longentry;
+  PyObject *__pyx_n_s_buf;
+  PyObject *__pyx_n_s_buffer_maxlen;
+  PyObject *__pyx_n_s_bytes_written;
+  PyObject *__pyx_n_s_cbuf;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_close;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_enter;
+  PyObject *__pyx_n_s_entry;
+  PyObject *__pyx_n_s_entryb;
+  PyObject *__pyx_n_s_exit;
+  PyObject *__pyx_n_s_fsetstat;
+  PyObject *__pyx_n_s_fstat;
+  PyObject *__pyx_n_s_fstat_ex;
+  PyObject *__pyx_n_s_fstatvfs;
+  PyObject *__pyx_n_s_fsync;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_longentry;
+  PyObject *__pyx_n_s_longentry_maxlen;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_offset;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_rc;
+  PyObject *__pyx_n_s_read;
+  PyObject *__pyx_n_s_readdir;
+  PyObject *__pyx_n_s_readdir_2;
+  PyObject *__pyx_n_s_readdir_ex;
+  PyObject *__pyx_n_s_readdir_ex_2;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_rewind;
+  PyObject *__pyx_n_s_seek;
+  PyObject *__pyx_n_s_seek64;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_send;
+  PyObject *__pyx_n_s_setstat;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_sftp;
+  PyObject *__pyx_n_s_sftp_ref;
+  PyObject *__pyx_n_s_size;
+  PyObject *__pyx_n_s_ssh2_sftp_handle;
+  PyObject *__pyx_kp_s_ssh2_sftp_handle_pyx;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_tell;
+  PyObject *__pyx_n_s_tell64;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_throw;
+  PyObject *__pyx_n_s_tot_size;
+  PyObject *__pyx_n_s_vfs;
+  PyObject *__pyx_n_s_write;
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1024;
+  size_t __pyx_k_;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_tuple__10;
+  PyObject *__pyx_tuple__12;
+  PyObject *__pyx_tuple__14;
+  PyObject *__pyx_tuple__16;
+  PyObject *__pyx_tuple__17;
+  PyObject *__pyx_tuple__18;
+  PyObject *__pyx_tuple__20;
+  PyObject *__pyx_tuple__21;
+  PyObject *__pyx_tuple__22;
+  PyObject *__pyx_tuple__24;
+  PyObject *__pyx_tuple__27;
+  PyObject *__pyx_tuple__33;
+  PyObject *__pyx_tuple__35;
+  PyObject *__pyx_tuple__37;
+  PyObject *__pyx_tuple__39;
+  PyObject *__pyx_codeobj__3;
+  PyObject *__pyx_codeobj__4;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__8;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__11;
+  PyObject *__pyx_codeobj__13;
+  PyObject *__pyx_codeobj__15;
+  PyObject *__pyx_codeobj__19;
+  PyObject *__pyx_codeobj__23;
+  PyObject *__pyx_codeobj__25;
+  PyObject *__pyx_codeobj__26;
+  PyObject *__pyx_codeobj__28;
+  PyObject *__pyx_codeobj__29;
+  PyObject *__pyx_codeobj__30;
+  PyObject *__pyx_codeobj__31;
+  PyObject *__pyx_codeobj__32;
+  PyObject *__pyx_codeobj__34;
+  PyObject *__pyx_codeobj__36;
+  PyObject *__pyx_codeobj__38;
+  PyObject *__pyx_codeobj__40;
+  PyObject *__pyx_codeobj__41;
+  PyObject *__pyx_codeobj__42;
+  PyObject *__pyx_codeobj__43;
+  PyObject *__pyx_codeobj__44;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPHandle);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPAttributes);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPAttributes___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPAttributes___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle___enter);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle___exit);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle__readdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle__readdir_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_close);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_fsetstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_fstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_fstat_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_fstatvfs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_fsync);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_readdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_readdir_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_rewind);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_seek);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_seek64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_tell);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_tell64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPHandle_write);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPStatVFS);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPStatVFS___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPStatVFS___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_StopIteration);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_kp_b__2);
+  Py_CLEAR(clear_module_state->__pyx_n_s__45);
+  Py_CLEAR(clear_module_state->__pyx_n_s_args);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_attrs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b_longentry);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buffer_maxlen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_bytes_written);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cbuf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_close);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_enter);
+  Py_CLEAR(clear_module_state->__pyx_n_s_entry);
+  Py_CLEAR(clear_module_state->__pyx_n_s_entryb);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exit);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fsetstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fstat_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fstatvfs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_fsync);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_longentry);
+  Py_CLEAR(clear_module_state->__pyx_n_s_longentry_maxlen);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_offset);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_read);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readdir);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readdir_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readdir_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readdir_ex_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_rewind);
+  Py_CLEAR(clear_module_state->__pyx_n_s_seek);
+  Py_CLEAR(clear_module_state->__pyx_n_s_seek64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstat);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sftp);
+  Py_CLEAR(clear_module_state->__pyx_n_s_sftp_ref);
+  Py_CLEAR(clear_module_state->__pyx_n_s_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_sftp_handle);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_sftp_handle_pyx);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_tell);
+  Py_CLEAR(clear_module_state->__pyx_n_s_tell64);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_throw);
+  Py_CLEAR(clear_module_state->__pyx_n_s_tot_size);
+  Py_CLEAR(clear_module_state->__pyx_n_s_vfs);
+  Py_CLEAR(clear_module_state->__pyx_n_s_write);
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1024);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_tuple__10);
+  Py_CLEAR(clear_module_state->__pyx_tuple__12);
+  Py_CLEAR(clear_module_state->__pyx_tuple__14);
+  Py_CLEAR(clear_module_state->__pyx_tuple__16);
+  Py_CLEAR(clear_module_state->__pyx_tuple__17);
+  Py_CLEAR(clear_module_state->__pyx_tuple__18);
+  Py_CLEAR(clear_module_state->__pyx_tuple__20);
+  Py_CLEAR(clear_module_state->__pyx_tuple__21);
+  Py_CLEAR(clear_module_state->__pyx_tuple__22);
+  Py_CLEAR(clear_module_state->__pyx_tuple__24);
+  Py_CLEAR(clear_module_state->__pyx_tuple__27);
+  Py_CLEAR(clear_module_state->__pyx_tuple__33);
+  Py_CLEAR(clear_module_state->__pyx_tuple__35);
+  Py_CLEAR(clear_module_state->__pyx_tuple__37);
+  Py_CLEAR(clear_module_state->__pyx_tuple__39);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__11);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__13);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__15);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__19);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__23);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__25);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__26);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__28);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__29);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__30);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__31);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__32);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__34);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__36);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__38);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__40);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__41);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__42);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__43);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__44);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_4sftp_SFTP);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPHandle);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPAttributes);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPAttributes);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPAttributes___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPAttributes___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle___enter);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle___exit);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle__readdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle__readdir_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_close);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_fsetstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_fstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_fstat_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_fstatvfs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_fsync);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_readdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_readdir_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_rewind);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_seek);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_seek64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_tell);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_tell64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPHandle_write);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPStatVFS);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPStatVFS___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPStatVFS___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_StopIteration);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_kp_b__2);
+  Py_VISIT(traverse_module_state->__pyx_n_s__45);
+  Py_VISIT(traverse_module_state->__pyx_n_s_args);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_attrs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b_longentry);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buffer_maxlen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_bytes_written);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cbuf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_close);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_enter);
+  Py_VISIT(traverse_module_state->__pyx_n_s_entry);
+  Py_VISIT(traverse_module_state->__pyx_n_s_entryb);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exit);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fsetstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fstat_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fstatvfs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_fsync);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_longentry);
+  Py_VISIT(traverse_module_state->__pyx_n_s_longentry_maxlen);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_offset);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_read);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readdir);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readdir_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readdir_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readdir_ex_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_rewind);
+  Py_VISIT(traverse_module_state->__pyx_n_s_seek);
+  Py_VISIT(traverse_module_state->__pyx_n_s_seek64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstat);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sftp);
+  Py_VISIT(traverse_module_state->__pyx_n_s_sftp_ref);
+  Py_VISIT(traverse_module_state->__pyx_n_s_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_sftp_handle);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_sftp_handle_pyx);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_tell);
+  Py_VISIT(traverse_module_state->__pyx_n_s_tell64);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_throw);
+  Py_VISIT(traverse_module_state->__pyx_n_s_tot_size);
+  Py_VISIT(traverse_module_state->__pyx_n_s_vfs);
+  Py_VISIT(traverse_module_state->__pyx_n_s_write);
+  Py_VISIT(traverse_module_state->__pyx_int_0);
+  Py_VISIT(traverse_module_state->__pyx_int_1024);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_tuple__10);
+  Py_VISIT(traverse_module_state->__pyx_tuple__12);
+  Py_VISIT(traverse_module_state->__pyx_tuple__14);
+  Py_VISIT(traverse_module_state->__pyx_tuple__16);
+  Py_VISIT(traverse_module_state->__pyx_tuple__17);
+  Py_VISIT(traverse_module_state->__pyx_tuple__18);
+  Py_VISIT(traverse_module_state->__pyx_tuple__20);
+  Py_VISIT(traverse_module_state->__pyx_tuple__21);
+  Py_VISIT(traverse_module_state->__pyx_tuple__22);
+  Py_VISIT(traverse_module_state->__pyx_tuple__24);
+  Py_VISIT(traverse_module_state->__pyx_tuple__27);
+  Py_VISIT(traverse_module_state->__pyx_tuple__33);
+  Py_VISIT(traverse_module_state->__pyx_tuple__35);
+  Py_VISIT(traverse_module_state->__pyx_tuple__37);
+  Py_VISIT(traverse_module_state->__pyx_tuple__39);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__11);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__13);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__15);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__19);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__23);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__25);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__26);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__28);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__29);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__30);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__31);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__32);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__34);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__36);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__38);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__40);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__41);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__42);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__43);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__44);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_4sftp_SFTP __pyx_mstate_global->__pyx_ptype_4ssh2_4sftp_SFTP
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_11sftp_handle_SFTPHandle __pyx_mstate_global->__pyx_type_4ssh2_11sftp_handle_SFTPHandle
+#define __pyx_type_4ssh2_11sftp_handle_SFTPAttributes __pyx_mstate_global->__pyx_type_4ssh2_11sftp_handle_SFTPAttributes
+#define __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS __pyx_mstate_global->__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS
+#define __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex __pyx_mstate_global->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex
+#define __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir __pyx_mstate_global->__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir
+#endif
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes
+#define __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS
+#define __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex
+#define __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir __pyx_mstate_global->__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_SFTPAttributes __pyx_mstate_global->__pyx_n_s_SFTPAttributes
+#define __pyx_n_s_SFTPAttributes___reduce_cython __pyx_mstate_global->__pyx_n_s_SFTPAttributes___reduce_cython
+#define __pyx_n_s_SFTPAttributes___setstate_cython __pyx_mstate_global->__pyx_n_s_SFTPAttributes___setstate_cython
+#define __pyx_n_s_SFTPHandle __pyx_mstate_global->__pyx_n_s_SFTPHandle
+#define __pyx_n_s_SFTPHandle___enter __pyx_mstate_global->__pyx_n_s_SFTPHandle___enter
+#define __pyx_n_s_SFTPHandle___exit __pyx_mstate_global->__pyx_n_s_SFTPHandle___exit
+#define __pyx_n_s_SFTPHandle___reduce_cython __pyx_mstate_global->__pyx_n_s_SFTPHandle___reduce_cython
+#define __pyx_n_s_SFTPHandle___setstate_cython __pyx_mstate_global->__pyx_n_s_SFTPHandle___setstate_cython
+#define __pyx_n_s_SFTPHandle__readdir __pyx_mstate_global->__pyx_n_s_SFTPHandle__readdir
+#define __pyx_n_s_SFTPHandle__readdir_ex __pyx_mstate_global->__pyx_n_s_SFTPHandle__readdir_ex
+#define __pyx_n_s_SFTPHandle_close __pyx_mstate_global->__pyx_n_s_SFTPHandle_close
+#define __pyx_n_s_SFTPHandle_fsetstat __pyx_mstate_global->__pyx_n_s_SFTPHandle_fsetstat
+#define __pyx_n_s_SFTPHandle_fstat __pyx_mstate_global->__pyx_n_s_SFTPHandle_fstat
+#define __pyx_n_s_SFTPHandle_fstat_ex __pyx_mstate_global->__pyx_n_s_SFTPHandle_fstat_ex
+#define __pyx_n_s_SFTPHandle_fstatvfs __pyx_mstate_global->__pyx_n_s_SFTPHandle_fstatvfs
+#define __pyx_n_s_SFTPHandle_fsync __pyx_mstate_global->__pyx_n_s_SFTPHandle_fsync
+#define __pyx_n_s_SFTPHandle_read __pyx_mstate_global->__pyx_n_s_SFTPHandle_read
+#define __pyx_n_s_SFTPHandle_readdir __pyx_mstate_global->__pyx_n_s_SFTPHandle_readdir
+#define __pyx_n_s_SFTPHandle_readdir_ex __pyx_mstate_global->__pyx_n_s_SFTPHandle_readdir_ex
+#define __pyx_n_s_SFTPHandle_rewind __pyx_mstate_global->__pyx_n_s_SFTPHandle_rewind
+#define __pyx_n_s_SFTPHandle_seek __pyx_mstate_global->__pyx_n_s_SFTPHandle_seek
+#define __pyx_n_s_SFTPHandle_seek64 __pyx_mstate_global->__pyx_n_s_SFTPHandle_seek64
+#define __pyx_n_s_SFTPHandle_tell __pyx_mstate_global->__pyx_n_s_SFTPHandle_tell
+#define __pyx_n_s_SFTPHandle_tell64 __pyx_mstate_global->__pyx_n_s_SFTPHandle_tell64
+#define __pyx_n_s_SFTPHandle_write __pyx_mstate_global->__pyx_n_s_SFTPHandle_write
+#define __pyx_n_s_SFTPStatVFS __pyx_mstate_global->__pyx_n_s_SFTPStatVFS
+#define __pyx_n_s_SFTPStatVFS___reduce_cython __pyx_mstate_global->__pyx_n_s_SFTPStatVFS___reduce_cython
+#define __pyx_n_s_SFTPStatVFS___setstate_cython __pyx_mstate_global->__pyx_n_s_SFTPStatVFS___setstate_cython
+#define __pyx_n_s_StopIteration __pyx_mstate_global->__pyx_n_s_StopIteration
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_kp_b__2 __pyx_mstate_global->__pyx_kp_b__2
+#define __pyx_n_s__45 __pyx_mstate_global->__pyx_n_s__45
+#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_attrs __pyx_mstate_global->__pyx_n_s_attrs
+#define __pyx_n_s_b_longentry __pyx_mstate_global->__pyx_n_s_b_longentry
+#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf
+#define __pyx_n_s_buffer_maxlen __pyx_mstate_global->__pyx_n_s_buffer_maxlen
+#define __pyx_n_s_bytes_written __pyx_mstate_global->__pyx_n_s_bytes_written
+#define __pyx_n_s_cbuf __pyx_mstate_global->__pyx_n_s_cbuf
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_enter __pyx_mstate_global->__pyx_n_s_enter
+#define __pyx_n_s_entry __pyx_mstate_global->__pyx_n_s_entry
+#define __pyx_n_s_entryb __pyx_mstate_global->__pyx_n_s_entryb
+#define __pyx_n_s_exit __pyx_mstate_global->__pyx_n_s_exit
+#define __pyx_n_s_fsetstat __pyx_mstate_global->__pyx_n_s_fsetstat
+#define __pyx_n_s_fstat __pyx_mstate_global->__pyx_n_s_fstat
+#define __pyx_n_s_fstat_ex __pyx_mstate_global->__pyx_n_s_fstat_ex
+#define __pyx_n_s_fstatvfs __pyx_mstate_global->__pyx_n_s_fstatvfs
+#define __pyx_n_s_fsync __pyx_mstate_global->__pyx_n_s_fsync
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_longentry __pyx_mstate_global->__pyx_n_s_longentry
+#define __pyx_n_s_longentry_maxlen __pyx_mstate_global->__pyx_n_s_longentry_maxlen
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_offset __pyx_mstate_global->__pyx_n_s_offset
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc
+#define __pyx_n_s_read __pyx_mstate_global->__pyx_n_s_read
+#define __pyx_n_s_readdir __pyx_mstate_global->__pyx_n_s_readdir
+#define __pyx_n_s_readdir_2 __pyx_mstate_global->__pyx_n_s_readdir_2
+#define __pyx_n_s_readdir_ex __pyx_mstate_global->__pyx_n_s_readdir_ex
+#define __pyx_n_s_readdir_ex_2 __pyx_mstate_global->__pyx_n_s_readdir_ex_2
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_rewind __pyx_mstate_global->__pyx_n_s_rewind
+#define __pyx_n_s_seek __pyx_mstate_global->__pyx_n_s_seek
+#define __pyx_n_s_seek64 __pyx_mstate_global->__pyx_n_s_seek64
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send
+#define __pyx_n_s_setstat __pyx_mstate_global->__pyx_n_s_setstat
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_sftp __pyx_mstate_global->__pyx_n_s_sftp
+#define __pyx_n_s_sftp_ref __pyx_mstate_global->__pyx_n_s_sftp_ref
+#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size
+#define __pyx_n_s_ssh2_sftp_handle __pyx_mstate_global->__pyx_n_s_ssh2_sftp_handle
+#define __pyx_kp_s_ssh2_sftp_handle_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_sftp_handle_pyx
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_tell __pyx_mstate_global->__pyx_n_s_tell
+#define __pyx_n_s_tell64 __pyx_mstate_global->__pyx_n_s_tell64
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_throw __pyx_mstate_global->__pyx_n_s_throw
+#define __pyx_n_s_tot_size __pyx_mstate_global->__pyx_n_s_tot_size
+#define __pyx_n_s_vfs __pyx_mstate_global->__pyx_n_s_vfs
+#define __pyx_n_s_write __pyx_mstate_global->__pyx_n_s_write
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024
+#define __pyx_k_ __pyx_mstate_global->__pyx_k_
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
+#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12
+#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17
+#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18
+#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20
+#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21
+#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22
+#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24
+#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27
+#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33
+#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35
+#define __pyx_tuple__37 __pyx_mstate_global->__pyx_tuple__37
+#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39
+#define __pyx_codeobj__3 __pyx_mstate_global->__pyx_codeobj__3
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11
+#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13
+#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15
+#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19
+#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23
+#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25
+#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26
+#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28
+#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29
+#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30
+#define __pyx_codeobj__31 __pyx_mstate_global->__pyx_codeobj__31
+#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32
+#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34
+#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36
+#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38
+#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40
+#define __pyx_codeobj__41 __pyx_mstate_global->__pyx_codeobj__41
+#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42
+#define __pyx_codeobj__43 __pyx_mstate_global->__pyx_codeobj__43
+#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44
+/* #### Code section: module_code ### */
 
 /* "ssh2/sftp_handle.pyx":27
  * 
@@ -1789,7 +3409,7 @@ static PyObject *__pyx_f_4ssh2_11sftp_handle_PySFTPHandle(LIBSSH2_SFTP_HANDLE *_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("PySFTPHandle", 0);
+  __Pyx_RefNannySetupContext("PySFTPHandle", 1);
 
   /* "ssh2/sftp_handle.pyx":28
  * 
@@ -1800,11 +3420,11 @@ static PyObject *__pyx_f_4ssh2_11sftp_handle_PySFTPHandle(LIBSSH2_SFTP_HANDLE *_
  */
   __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_sftp));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_sftp));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_sftp));
+  __Pyx_INCREF((PyObject *)__pyx_v_sftp);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_sftp);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_sftp))) __PYX_ERR(0, 28, __pyx_L1_error);
   __pyx_t_2 = ((PyObject *)__pyx_tp_new_4ssh2_11sftp_handle_SFTPHandle(((PyTypeObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle), __pyx_t_1, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error)
-  __Pyx_GOTREF(((PyObject *)__pyx_t_2));
+  __Pyx_GOTREF((PyObject *)__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__handle = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_t_2);
   __pyx_t_2 = 0;
@@ -1826,7 +3446,7 @@ static PyObject *__pyx_f_4ssh2_11sftp_handle_PySFTPHandle(LIBSSH2_SFTP_HANDLE *_
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v__handle));
+  __Pyx_INCREF((PyObject *)__pyx_v__handle);
   __pyx_r = ((PyObject *)__pyx_v__handle);
   goto __pyx_L0;
 
@@ -1862,12 +3482,20 @@ static PyObject *__pyx_f_4ssh2_11sftp_handle_PySFTPHandle(LIBSSH2_SFTP_HANDLE *_
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
-    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -1877,12 +3505,10 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_1__cinit__(PyObject *__
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
 
   /* "ssh2/sftp_handle.pyx":36
  * 
@@ -1894,6 +3520,7 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -1915,8 +3542,8 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_1 = ((__pyx_v_self->_attrs == NULL) != 0);
-        if (__pyx_t_1) {
+        __pyx_t_1 = (__pyx_v_self->_attrs == NULL);
+        if (unlikely(__pyx_t_1)) {
 
           /* "ssh2/sftp_handle.pyx":40
  *                 sizeof(c_sftp.LIBSSH2_SFTP_ATTRIBUTES))
@@ -2072,7 +3699,6 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPAttributes.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
@@ -2087,8 +3713,10 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes___cinit__(struct __pyx_
 /* Python wrapper */
 static void __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_2__dealloc__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2096,8 +3724,6 @@ static void __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3__dealloc__(PyObject
 }
 
 static void __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_2__dealloc__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/sftp_handle.pyx":51
  * 
@@ -2109,6 +3735,7 @@ static void __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_2__dealloc__(struct __
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2152,23 +3779,24 @@ static void __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_2__dealloc__(struct __
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
-/* "ssh2/sftp_handle.pyx":55
+/* "ssh2/sftp_handle.pyx":54
+ *             free(self._attrs)
  * 
- *     @property
- *     def flags(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def flags(self):
  *         return self._attrs.flags
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5flags_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5flags_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2183,7 +3811,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":56
  *     @property
@@ -2199,12 +3827,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":55
+  /* "ssh2/sftp_handle.pyx":54
+ *             free(self._attrs)
  * 
- *     @property
- *     def flags(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def flags(self):
  *         return self._attrs.flags
- * 
  */
 
   /* function exit code */
@@ -2218,24 +3846,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":59
+/* "ssh2/sftp_handle.pyx":58
+ *         return self._attrs.flags
  * 
- *     @flags.setter
- *     def flags(self, unsigned long flags):             # <<<<<<<<<<<<<<
+ *     @flags.setter             # <<<<<<<<<<<<<<
+ *     def flags(self, unsigned long flags):
  *         self._attrs.flags = flags
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5flags_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_flags); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5flags_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_flags) {
   unsigned long __pyx_v_flags;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_flags); {
     __pyx_v_flags = __Pyx_PyInt_As_unsigned_long(__pyx_arg_flags); if (unlikely((__pyx_v_flags == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error)
   }
@@ -2254,8 +3884,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5flags_3__set__(PyObjec
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_flags) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":60
  *     @flags.setter
@@ -2266,34 +3894,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5flags_2__set__(struct
  */
   __pyx_v_self->_attrs->flags = __pyx_v_flags;
 
-  /* "ssh2/sftp_handle.pyx":59
+  /* "ssh2/sftp_handle.pyx":58
+ *         return self._attrs.flags
  * 
- *     @flags.setter
- *     def flags(self, unsigned long flags):             # <<<<<<<<<<<<<<
+ *     @flags.setter             # <<<<<<<<<<<<<<
+ *     def flags(self, unsigned long flags):
  *         self._attrs.flags = flags
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":63
+/* "ssh2/sftp_handle.pyx":62
+ *         self._attrs.flags = flags
  * 
- *     @property
- *     def filesize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def filesize(self):
  *         return self._attrs.filesize
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2308,7 +3937,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize___get__
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":64
  *     @property
@@ -2324,12 +3953,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize___get__
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":63
+  /* "ssh2/sftp_handle.pyx":62
+ *         self._attrs.flags = flags
  * 
- *     @property
- *     def filesize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def filesize(self):
  *         return self._attrs.filesize
- * 
  */
 
   /* function exit code */
@@ -2343,24 +3972,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize___get__
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":67
+/* "ssh2/sftp_handle.pyx":66
+ *         return self._attrs.filesize
  * 
- *     @filesize.setter
- *     def filesize(self, c_ssh2.libssh2_uint64_t filesize):             # <<<<<<<<<<<<<<
+ *     @filesize.setter             # <<<<<<<<<<<<<<
+ *     def filesize(self, c_ssh2.libssh2_uint64_t filesize):
  *         self._attrs.filesize = filesize
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_filesize); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_filesize) {
   libssh2_uint64_t __pyx_v_filesize;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_filesize); {
     __pyx_v_filesize = __Pyx_PyInt_As_libssh2_uint64_t(__pyx_arg_filesize); if (unlikely((__pyx_v_filesize == ((libssh2_uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L3_error)
   }
@@ -2379,8 +4010,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_3__set__(PyOb
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, libssh2_uint64_t __pyx_v_filesize) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":68
  *     @filesize.setter
@@ -2391,34 +4020,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_8filesize_2__set__(stru
  */
   __pyx_v_self->_attrs->filesize = __pyx_v_filesize;
 
-  /* "ssh2/sftp_handle.pyx":67
+  /* "ssh2/sftp_handle.pyx":66
+ *         return self._attrs.filesize
  * 
- *     @filesize.setter
- *     def filesize(self, c_ssh2.libssh2_uint64_t filesize):             # <<<<<<<<<<<<<<
+ *     @filesize.setter             # <<<<<<<<<<<<<<
+ *     def filesize(self, c_ssh2.libssh2_uint64_t filesize):
  *         self._attrs.filesize = filesize
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":71
+/* "ssh2/sftp_handle.pyx":70
+ *         self._attrs.filesize = filesize
  * 
- *     @property
- *     def uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def uid(self):
  *         return self._attrs.uid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3uid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3uid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2433,7 +4063,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid___get__(stru
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":72
  *     @property
@@ -2449,12 +4079,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid___get__(stru
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":71
+  /* "ssh2/sftp_handle.pyx":70
+ *         self._attrs.filesize = filesize
  * 
- *     @property
- *     def uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def uid(self):
  *         return self._attrs.uid
- * 
  */
 
   /* function exit code */
@@ -2468,24 +4098,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid___get__(stru
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":75
+/* "ssh2/sftp_handle.pyx":74
+ *         return self._attrs.uid
  * 
- *     @uid.setter
- *     def uid(self, unsigned long uid):             # <<<<<<<<<<<<<<
+ *     @uid.setter             # <<<<<<<<<<<<<<
+ *     def uid(self, unsigned long uid):
  *         self._attrs.uid = uid
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3uid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_uid); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3uid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_uid) {
   unsigned long __pyx_v_uid;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_uid); {
     __pyx_v_uid = __Pyx_PyInt_As_unsigned_long(__pyx_arg_uid); if (unlikely((__pyx_v_uid == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L3_error)
   }
@@ -2504,8 +4136,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3uid_3__set__(PyObject
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_uid) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":76
  *     @uid.setter
@@ -2516,34 +4146,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3uid_2__set__(struct __
  */
   __pyx_v_self->_attrs->uid = __pyx_v_uid;
 
-  /* "ssh2/sftp_handle.pyx":75
+  /* "ssh2/sftp_handle.pyx":74
+ *         return self._attrs.uid
  * 
- *     @uid.setter
- *     def uid(self, unsigned long uid):             # <<<<<<<<<<<<<<
+ *     @uid.setter             # <<<<<<<<<<<<<<
+ *     def uid(self, unsigned long uid):
  *         self._attrs.uid = uid
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":79
+/* "ssh2/sftp_handle.pyx":78
+ *         self._attrs.uid = uid
  * 
- *     @property
- *     def gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def gid(self):
  *         return self._attrs.gid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3gid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3gid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2558,7 +4189,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid___get__(stru
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":80
  *     @property
@@ -2574,12 +4205,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid___get__(stru
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":79
+  /* "ssh2/sftp_handle.pyx":78
+ *         self._attrs.uid = uid
  * 
- *     @property
- *     def gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def gid(self):
  *         return self._attrs.gid
- * 
  */
 
   /* function exit code */
@@ -2593,24 +4224,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid___get__(stru
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":83
+/* "ssh2/sftp_handle.pyx":82
+ *         return self._attrs.gid
  * 
- *     @gid.setter
- *     def gid(self, unsigned long gid):             # <<<<<<<<<<<<<<
+ *     @gid.setter             # <<<<<<<<<<<<<<
+ *     def gid(self, unsigned long gid):
  *         self._attrs.gid = gid
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3gid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_gid); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3gid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_gid) {
   unsigned long __pyx_v_gid;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_gid); {
     __pyx_v_gid = __Pyx_PyInt_As_unsigned_long(__pyx_arg_gid); if (unlikely((__pyx_v_gid == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L3_error)
   }
@@ -2629,8 +4262,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_3gid_3__set__(PyObject
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_gid) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":84
  *     @gid.setter
@@ -2641,34 +4272,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_3gid_2__set__(struct __
  */
   __pyx_v_self->_attrs->gid = __pyx_v_gid;
 
-  /* "ssh2/sftp_handle.pyx":83
+  /* "ssh2/sftp_handle.pyx":82
+ *         return self._attrs.gid
  * 
- *     @gid.setter
- *     def gid(self, unsigned long gid):             # <<<<<<<<<<<<<<
+ *     @gid.setter             # <<<<<<<<<<<<<<
+ *     def gid(self, unsigned long gid):
  *         self._attrs.gid = gid
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":87
+/* "ssh2/sftp_handle.pyx":86
+ *         self._attrs.gid = gid
  * 
- *     @property
- *     def permissions(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def permissions(self):
  *         return self._attrs.permissions
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2683,7 +4315,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions___g
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":88
  *     @property
@@ -2699,12 +4331,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions___g
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":87
+  /* "ssh2/sftp_handle.pyx":86
+ *         self._attrs.gid = gid
  * 
- *     @property
- *     def permissions(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def permissions(self):
  *         return self._attrs.permissions
- * 
  */
 
   /* function exit code */
@@ -2718,24 +4350,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions___g
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":91
+/* "ssh2/sftp_handle.pyx":90
+ *         return self._attrs.permissions
  * 
- *     @permissions.setter
- *     def permissions(self, unsigned long permissions):             # <<<<<<<<<<<<<<
+ *     @permissions.setter             # <<<<<<<<<<<<<<
+ *     def permissions(self, unsigned long permissions):
  *         self._attrs.permissions = permissions
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_permissions); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_permissions) {
   unsigned long __pyx_v_permissions;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_permissions); {
     __pyx_v_permissions = __Pyx_PyInt_As_unsigned_long(__pyx_arg_permissions); if (unlikely((__pyx_v_permissions == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L3_error)
   }
@@ -2754,8 +4388,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_3__set__(
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_permissions) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":92
  *     @permissions.setter
@@ -2766,34 +4398,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_11permissions_2__set__(
  */
   __pyx_v_self->_attrs->permissions = __pyx_v_permissions;
 
-  /* "ssh2/sftp_handle.pyx":91
+  /* "ssh2/sftp_handle.pyx":90
+ *         return self._attrs.permissions
  * 
- *     @permissions.setter
- *     def permissions(self, unsigned long permissions):             # <<<<<<<<<<<<<<
+ *     @permissions.setter             # <<<<<<<<<<<<<<
+ *     def permissions(self, unsigned long permissions):
  *         self._attrs.permissions = permissions
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":95
+/* "ssh2/sftp_handle.pyx":94
+ *         self._attrs.permissions = permissions
  * 
- *     @property
- *     def atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def atime(self):
  *         return self._attrs.atime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5atime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5atime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2808,7 +4441,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":96
  *     @property
@@ -2824,12 +4457,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":95
+  /* "ssh2/sftp_handle.pyx":94
+ *         self._attrs.permissions = permissions
  * 
- *     @property
- *     def atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def atime(self):
  *         return self._attrs.atime
- * 
  */
 
   /* function exit code */
@@ -2843,24 +4476,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":99
+/* "ssh2/sftp_handle.pyx":98
+ *         return self._attrs.atime
  * 
- *     @atime.setter
- *     def atime(self, unsigned long atime):             # <<<<<<<<<<<<<<
+ *     @atime.setter             # <<<<<<<<<<<<<<
+ *     def atime(self, unsigned long atime):
  *         self._attrs.atime = atime
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5atime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_atime); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5atime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_atime) {
   unsigned long __pyx_v_atime;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_atime); {
     __pyx_v_atime = __Pyx_PyInt_As_unsigned_long(__pyx_arg_atime); if (unlikely((__pyx_v_atime == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L3_error)
   }
@@ -2879,8 +4514,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5atime_3__set__(PyObjec
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_atime) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":100
  *     @atime.setter
@@ -2891,34 +4524,35 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5atime_2__set__(struct
  */
   __pyx_v_self->_attrs->atime = __pyx_v_atime;
 
-  /* "ssh2/sftp_handle.pyx":99
+  /* "ssh2/sftp_handle.pyx":98
+ *         return self._attrs.atime
  * 
- *     @atime.setter
- *     def atime(self, unsigned long atime):             # <<<<<<<<<<<<<<
+ *     @atime.setter             # <<<<<<<<<<<<<<
+ *     def atime(self, unsigned long atime):
  *         self._attrs.atime = atime
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":103
+/* "ssh2/sftp_handle.pyx":102
+ *         self._attrs.atime = atime
  * 
- *     @property
- *     def mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def mtime(self):
  *         return self._attrs.mtime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -2933,7 +4567,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":104
  *     @property
@@ -2949,12 +4583,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":103
+  /* "ssh2/sftp_handle.pyx":102
+ *         self._attrs.atime = atime
  * 
- *     @property
- *     def mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def mtime(self):
  *         return self._attrs.mtime
- * 
  */
 
   /* function exit code */
@@ -2968,24 +4602,26 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":107
+/* "ssh2/sftp_handle.pyx":106
+ *         return self._attrs.mtime
  * 
- *     @mtime.setter
- *     def mtime(self, unsigned long mtime):             # <<<<<<<<<<<<<<
+ *     @mtime.setter             # <<<<<<<<<<<<<<
+ *     def mtime(self, unsigned long mtime):
  *         self._attrs.mtime = mtime
- * 
  */
 
 /* Python wrapper */
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_mtime); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_mtime) {
   unsigned long __pyx_v_mtime;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   assert(__pyx_arg_mtime); {
     __pyx_v_mtime = __Pyx_PyInt_As_unsigned_long(__pyx_arg_mtime); if (unlikely((__pyx_v_mtime == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 107, __pyx_L3_error)
   }
@@ -3004,8 +4640,6 @@ static int __pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_3__set__(PyObjec
 
 static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_2__set__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, unsigned long __pyx_v_mtime) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__set__", 0);
 
   /* "ssh2/sftp_handle.pyx":108
  *     @mtime.setter
@@ -3016,33 +4650,60 @@ static int __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_5mtime_2__set__(struct
  */
   __pyx_v_self->_attrs->mtime = __pyx_v_mtime;
 
-  /* "ssh2/sftp_handle.pyx":107
+  /* "ssh2/sftp_handle.pyx":106
+ *         return self._attrs.mtime
  * 
- *     @mtime.setter
- *     def mtime(self, unsigned long mtime):             # <<<<<<<<<<<<<<
+ *     @mtime.setter             # <<<<<<<<<<<<<<
+ *     def mtime(self, unsigned long mtime):
  *         self._attrs.mtime = mtime
- * 
  */
 
   /* function exit code */
   __pyx_r = 0;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__[] = "SFTPAttributes.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__, "SFTPAttributes.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self));
 
   /* function exit code */
@@ -3053,33 +4714,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython_
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPAttributes.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -3089,21 +4745,104 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython_
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__[] = "SFTPAttributes.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__, "SFTPAttributes.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPAttributes.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3111,33 +4850,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cytho
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPAttributes.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -3157,44 +4891,64 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cytho
 static int __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_sftp = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sftp,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sftp,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sftp)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sftp)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 113, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 113, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v_sftp = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 113, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 113, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
@@ -3202,6 +4956,12 @@ static int __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_1__cinit__(PyObject *__pyx_
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle___cinit__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_sftp);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3213,7 +4973,7 @@ static int __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle___cinit__(struct __pyx_obj_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/sftp_handle.pyx":114
  * 
@@ -3235,8 +4995,8 @@ static int __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle___cinit__(struct __pyx_obj_
   __pyx_t_1 = __pyx_v_sftp;
   __Pyx_INCREF(__pyx_t_1);
   __Pyx_GIVEREF(__pyx_t_1);
-  __Pyx_GOTREF(__pyx_v_self->_sftp);
-  __Pyx_DECREF(((PyObject *)__pyx_v_self->_sftp));
+  __Pyx_GOTREF((PyObject *)__pyx_v_self->_sftp);
+  __Pyx_DECREF((PyObject *)__pyx_v_self->_sftp);
   __pyx_v_self->_sftp = ((struct __pyx_obj_4ssh2_4sftp_SFTP *)__pyx_t_1);
   __pyx_t_1 = 0;
 
@@ -3280,8 +5040,10 @@ static int __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle___cinit__(struct __pyx_obj_
 /* Python wrapper */
 static void __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -3289,9 +5051,7 @@ static void __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_3__dealloc__(PyObject *__p
 }
 
 static void __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/sftp_handle.pyx":119
  * 
@@ -3300,7 +5060,7 @@ static void __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(struct __pyx_
  *             with nogil:
  *                 c_sftp.libssh2_sftp_close_handle(self._handle)
  */
-  __pyx_t_1 = ((__pyx_v_self->closed == 0) != 0);
+  __pyx_t_1 = (__pyx_v_self->closed == 0);
   if (__pyx_t_1) {
 
     /* "ssh2/sftp_handle.pyx":120
@@ -3313,6 +5073,7 @@ static void __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(struct __pyx_
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
@@ -3374,7 +5135,6 @@ static void __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(struct __pyx_
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
 /* "ssh2/sftp_handle.pyx":124
@@ -3388,9 +5148,11 @@ static void __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_2__dealloc__(struct __pyx_
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_5__iter__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_5__iter__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_4__iter__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -3401,7 +5163,7 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_5__iter__(PyObject *_
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_4__iter__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__iter__", 0);
+  __Pyx_RefNannySetupContext("__iter__", 1);
 
   /* "ssh2/sftp_handle.pyx":125
  * 
@@ -3411,7 +5173,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_4__iter__(struct __py
  *     def __next__(self):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_INCREF((PyObject *)__pyx_v_self);
   __pyx_r = ((PyObject *)__pyx_v_self);
   goto __pyx_L0;
 
@@ -3441,9 +5203,11 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_4__iter__(struct __py
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -3456,18 +5220,20 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
   PyObject *__pyx_v_data = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
+  int __pyx_error_without_exception = 0; /* StopIteration */
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  int __pyx_t_6;
+  unsigned int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *(*__pyx_t_6)(PyObject *);
   int __pyx_t_7;
   int __pyx_t_8;
+  int __pyx_t_9;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__next__", 0);
+  __Pyx_RefNannySetupContext("__next__", 1);
 
   /* "ssh2/sftp_handle.pyx":130
  *         cdef int rc
@@ -3479,20 +5245,27 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
   __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_read); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_4 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
   if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
     PyObject* sequence = __pyx_t_1;
     Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
@@ -3520,29 +5293,29 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else {
     Py_ssize_t index = -1;
-    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 130, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
-    index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+    __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5);
+    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_2);
-    index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
+    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_3);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 130, __pyx_L1_error)
-    __pyx_t_5 = NULL;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 130, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     goto __pyx_L4_unpacking_done;
     __pyx_L3_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
     if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
     __PYX_ERR(0, 130, __pyx_L1_error)
     __pyx_L4_unpacking_done:;
   }
-  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 130, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 130, __pyx_L1_error)
-  __pyx_v_rc = __pyx_t_6;
+  if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(0, 130, __pyx_L1_error)
+  __pyx_v_rc = __pyx_t_7;
   __pyx_v_data = ((PyObject*)__pyx_t_3);
   __pyx_t_3 = 0;
 
@@ -3553,16 +5326,16 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
  *             raise StopIteration
  *         return rc, data
  */
-  __pyx_t_8 = ((__pyx_v_rc != LIBSSH2_ERROR_EAGAIN) != 0);
-  if (__pyx_t_8) {
+  __pyx_t_9 = (__pyx_v_rc != LIBSSH2_ERROR_EAGAIN);
+  if (__pyx_t_9) {
   } else {
-    __pyx_t_7 = __pyx_t_8;
+    __pyx_t_8 = __pyx_t_9;
     goto __pyx_L6_bool_binop_done;
   }
-  __pyx_t_8 = ((__pyx_v_rc <= 0) != 0);
-  __pyx_t_7 = __pyx_t_8;
+  __pyx_t_9 = (__pyx_v_rc <= 0);
+  __pyx_t_8 = __pyx_t_9;
   __pyx_L6_bool_binop_done:;
-  if (unlikely(__pyx_t_7)) {
+  if (unlikely(__pyx_t_8)) {
 
     /* "ssh2/sftp_handle.pyx":132
  *         rc, data = self.read()
@@ -3571,8 +5344,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
  *         return rc, data
  * 
  */
-    __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0);
-    __PYX_ERR(0, 132, __pyx_L1_error)
+    __pyx_error_without_exception = 1;
+    goto __pyx_L1_error;;
 
     /* "ssh2/sftp_handle.pyx":131
  *         cdef bytes data
@@ -3596,10 +5369,10 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
   __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_data);
   __Pyx_GIVEREF(__pyx_v_data);
-  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_data);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_data)) __PYX_ERR(0, 133, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
@@ -3618,8 +5391,10 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  if (!__pyx_error_without_exception) {
+    __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  }
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_data);
@@ -3637,12 +5412,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_6__next__(struct __py
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_8__enter__[] = "SFTPHandle.__enter__(self)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_8__enter__, "SFTPHandle.__enter__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_9__enter__ = {"__enter__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_8__enter__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__enter__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__enter__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_8__enter__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -3653,7 +5456,7 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__(PyObject *
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_8__enter__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__enter__", 0);
+  __Pyx_RefNannySetupContext("__enter__", 1);
 
   /* "ssh2/sftp_handle.pyx":136
  * 
@@ -3663,7 +5466,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_8__enter__(struct __p
  *     def __exit__(self, *args):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_INCREF((PyObject *)__pyx_v_self);
   __pyx_r = ((PyObject *)__pyx_v_self);
   goto __pyx_L0;
 
@@ -3692,19 +5495,28 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_8__enter__(struct __p
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_10__exit__[] = "SFTPHandle.__exit__(self, *args)";
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_10__exit__, "SFTPHandle.__exit__(self, *args)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_11__exit__ = {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_11__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_10__exit__};
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   CYTHON_UNUSED PyObject *__pyx_v_args = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0);
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL;
   __Pyx_INCREF(__pyx_args);
   __pyx_v_args = __pyx_args;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_10__exit__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_args);
 
   /* function exit code */
-  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_DECREF(__pyx_v_args);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -3715,10 +5527,11 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_10__exit__(struct __p
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
+  unsigned int __pyx_t_4;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__exit__", 0);
+  __Pyx_RefNannySetupContext("__exit__", 1);
 
   /* "ssh2/sftp_handle.pyx":139
  * 
@@ -3730,20 +5543,27 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_10__exit__(struct __p
   __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_4 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "ssh2/sftp_handle.pyx":138
@@ -3778,12 +5598,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_10__exit__(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_12close[] = "SFTPHandle.close(self)\nClose handle. Called automatically when object is deleted\n        and/or garbage collected.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_12close, "SFTPHandle.close(self)\nClose handle. Called automatically when object is deleted\n        and/or garbage collected.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_13close = {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_12close};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("close (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("close", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_12close(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -3800,7 +5648,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_12close(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("close", 0);
+  __Pyx_RefNannySetupContext("close", 1);
 
   /* "ssh2/sftp_handle.pyx":147
  *         :rtype: int"""
@@ -3809,7 +5657,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_12close(struct __pyx_
  *             with nogil:
  *                 rc = c_sftp.libssh2_sftp_close_handle(self._handle)
  */
-  __pyx_t_1 = ((__pyx_v_self->closed == 0) != 0);
+  __pyx_t_1 = (__pyx_v_self->closed == 0);
   if (__pyx_t_1) {
 
     /* "ssh2/sftp_handle.pyx":148
@@ -3822,6 +5670,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_12close(struct __pyx_
     {
         #ifdef WITH_THREAD
         PyThreadState *_save;
+        _save = NULL;
         Py_UNBLOCK_THREADS
         __Pyx_FastGIL_Remember();
         #endif
@@ -3931,42 +5780,68 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_12close(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_14read[] = "SFTPHandle.read(self, size_t buffer_maxlen=c_ssh2.LIBSSH2_CHANNEL_WINDOW_DEFAULT)\nRead buffer from file handle.\n\n        :param buffer_maxlen: Max length of buffer to return.\n        :type buffer_maxlen: int\n\n        :returns: Size and buffer tuple.\n        :rtype: (int, bytes)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_14read, "SFTPHandle.read(self, size_t buffer_maxlen=c_ssh2.LIBSSH2_CHANNEL_WINDOW_DEFAULT)\nRead buffer from file handle.\n\n        :param buffer_maxlen: Max length of buffer to return.\n        :type buffer_maxlen: int\n\n        :returns: Size and buffer tuple.\n        :rtype: (int, bytes)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_15read = {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_14read};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_buffer_maxlen;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("read (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buffer_maxlen);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buffer_maxlen);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read") < 0)) __PYX_ERR(0, 155, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "read") < 0)) __PYX_ERR(0, 155, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -3975,13 +5850,21 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__py
     if (values[0]) {
       __pyx_v_buffer_maxlen = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_buffer_maxlen == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L3_error)
     } else {
-      __pyx_v_buffer_maxlen = __pyx_k__3;
+      __pyx_v_buffer_maxlen = __pyx_k_;
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("read", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 155, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("read", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 155, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.read", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -3989,6 +5872,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read(PyObject *__py
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_buffer_maxlen);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4014,7 +5903,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("read", 0);
+  __Pyx_RefNannySetupContext("read", 1);
 
   /* "ssh2/sftp_handle.pyx":164
  *         :rtype: (int, bytes)"""
@@ -4023,8 +5912,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
  *         cdef char *cbuf
  *         with nogil:
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_buf = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_buf = __pyx_kp_b__2;
 
   /* "ssh2/sftp_handle.pyx":166
  *         cdef bytes buf = b''
@@ -4036,6 +5925,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4057,8 +5947,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_1 = ((__pyx_v_cbuf == NULL) != 0);
-        if (__pyx_t_1) {
+        __pyx_t_1 = (__pyx_v_cbuf == NULL);
+        if (unlikely(__pyx_t_1)) {
 
           /* "ssh2/sftp_handle.pyx":169
  *             cbuf = <char *>malloc(sizeof(char)*buffer_maxlen)
@@ -4161,7 +6051,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
  *                 buf = cbuf[:rc]
  *         finally:
  */
-    __pyx_t_1 = ((__pyx_v_rc > 0) != 0);
+    __pyx_t_1 = (__pyx_v_rc > 0);
     if (__pyx_t_1) {
 
       /* "ssh2/sftp_handle.pyx":175
@@ -4246,10 +6136,10 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_14read(struct __pyx_o
   __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_12);
   __Pyx_GIVEREF(__pyx_t_2);
-  PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_buf);
   __Pyx_GIVEREF(__pyx_v_buf);
-  PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 178, __pyx_L1_error);
   __pyx_t_2 = 0;
   __pyx_r = __pyx_t_12;
   __pyx_t_12 = 0;
@@ -4286,53 +6176,80 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex[] = "SFTPHandle.readdir_ex(self, size_t longentry_maxlen=1024, size_t buffer_maxlen=1024)\nGet directory listing from file handle, if any.\n\n        File handle *must* be opened with :py:func:`ssh2.sftp.SFTP.readdir()`\n\n        This function is a generator and should be iterated on.\n\n        :param buffer_maxlen: Max length of returned buffer.\n        :param longentry_maxlen: Max length of file list entry.\n\n        :rtype: bytes\n        ";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex, "SFTPHandle.readdir_ex(self, size_t longentry_maxlen=1024, size_t buffer_maxlen=1024)\nGet directory listing from file handle, if any.\n\n        File handle *must* be opened with :py:func:`ssh2.sftp.SFTP.readdir()`\n\n        This function is a generator and should be iterated on.\n\n        :param buffer_maxlen: Max length of returned buffer.\n        :param longentry_maxlen: Max length of file list entry.\n\n        :rtype: bytes\n        ");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex = {"readdir_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_longentry_maxlen;
   size_t __pyx_v_buffer_maxlen;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("readdir_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_longentry_maxlen,&__pyx_n_s_buffer_maxlen,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_longentry_maxlen,&__pyx_n_s_buffer_maxlen,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_longentry_maxlen);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_longentry_maxlen);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 180, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buffer_maxlen);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buffer_maxlen);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 180, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readdir_ex") < 0)) __PYX_ERR(0, 180, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readdir_ex") < 0)) __PYX_ERR(0, 180, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -4349,10 +6266,18 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject
       __pyx_v_buffer_maxlen = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("readdir_ex", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 180, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("readdir_ex", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 180, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.readdir_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4360,6 +6285,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex(PyObject
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_longentry_maxlen, __pyx_v_buffer_maxlen);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4378,7 +6309,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex(struct _
     __Pyx_INCREF(Py_None);
     __PYX_ERR(0, 180, __pyx_L1_error)
   } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
   }
   __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
   __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
@@ -4386,7 +6317,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex(struct _
   __pyx_cur_scope->__pyx_v_longentry_maxlen = __pyx_v_longentry_maxlen;
   __pyx_cur_scope->__pyx_v_buffer_maxlen = __pyx_v_buffer_maxlen;
   {
-    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_readdir_ex, __pyx_n_s_SFTPHandle_readdir_ex, __pyx_n_s_ssh2_sftp_handle); if (unlikely(!gen)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator, __pyx_codeobj__3, (PyObject *) __pyx_cur_scope, __pyx_n_s_readdir_ex, __pyx_n_s_SFTPHandle_readdir_ex, __pyx_n_s_ssh2_sftp_handle); if (unlikely(!gen)) __PYX_ERR(0, 180, __pyx_L1_error)
     __Pyx_DECREF(__pyx_cur_scope);
     __Pyx_RefNannyFinishContext();
     return (PyObject *) gen;
@@ -4396,7 +6327,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex(struct _
   __pyx_L1_error:;
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.readdir_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -4519,7 +6450,7 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
     __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 194, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_6);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
+    __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
     for (index=0; index < 4; index++) {
       PyObject* item = __pyx_t_7(__pyx_t_6); if (unlikely(!item)) goto __pyx_L4_unpacking_failed;
       __Pyx_GOTREF(item);
@@ -4557,11 +6488,11 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
  *             rc, buf, entryb, attrs = self._readdir_ex(
  */
   while (1) {
-    __pyx_t_3 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_5 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_rc, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 197, __pyx_L1_error)
+    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 197, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     if (!__pyx_t_9) {
     } else {
@@ -4569,7 +6500,7 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
       goto __pyx_L8_bool_binop_done;
     }
     __pyx_t_5 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_rc, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error)
-    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 197, __pyx_L1_error)
+    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 197, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __pyx_t_8 = __pyx_t_9;
     __pyx_L8_bool_binop_done:;
@@ -4586,16 +6517,16 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_rc);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_rc);
-    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_rc);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_rc)) __PYX_ERR(0, 198, __pyx_L1_error);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_buf);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_buf);
-    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_buf);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_buf)) __PYX_ERR(0, 198, __pyx_L1_error);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_entry);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_entry);
-    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_cur_scope->__pyx_v_entry);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_cur_scope->__pyx_v_entry)) __PYX_ERR(0, 198, __pyx_L1_error);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_attrs);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_attrs);
-    PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_cur_scope->__pyx_v_attrs);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_cur_scope->__pyx_v_attrs)) __PYX_ERR(0, 198, __pyx_L1_error);
     __pyx_r = __pyx_t_5;
     __pyx_t_5 = 0;
     __Pyx_XGIVEREF(__pyx_r);
@@ -4696,7 +6627,7 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
       __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_6);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
+      __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
       for (index=0; index < 4; index++) {
         PyObject* item = __pyx_t_7(__pyx_t_6); if (unlikely(!item)) goto __pyx_L11_unpacking_failed;
         __Pyx_GOTREF(item);
@@ -4744,6 +6675,7 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
   PyErr_SetNone(PyExc_StopIteration);
   goto __pyx_L0;
   __pyx_L1_error:;
+  __Pyx_Generator_Replace_StopIteration(0);
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
@@ -4771,53 +6703,80 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_18generator(__pyx_Cor
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex[] = "SFTPHandle._readdir_ex(self, size_t longentry_maxlen=1024, size_t buffer_maxlen=1024)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex, "SFTPHandle._readdir_ex(self, size_t longentry_maxlen=1024, size_t buffer_maxlen=1024)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex = {"_readdir_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_longentry_maxlen;
   size_t __pyx_v_buffer_maxlen;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("_readdir_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_longentry_maxlen,&__pyx_n_s_buffer_maxlen,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_longentry_maxlen,&__pyx_n_s_buffer_maxlen,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_longentry_maxlen);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_longentry_maxlen);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buffer_maxlen);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buffer_maxlen);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_readdir_ex") < 0)) __PYX_ERR(0, 203, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_readdir_ex") < 0)) __PYX_ERR(0, 203, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -4834,10 +6793,18 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObjec
       __pyx_v_buffer_maxlen = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_readdir_ex", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 203, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_readdir_ex", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 203, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle._readdir_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -4845,6 +6812,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex(PyObjec
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_longentry_maxlen, __pyx_v_buffer_maxlen);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4874,7 +6847,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("_readdir_ex", 0);
+  __Pyx_RefNannySetupContext("_readdir_ex", 1);
 
   /* "ssh2/sftp_handle.pyx":206
  *                     size_t longentry_maxlen=1024,
@@ -4883,8 +6856,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
  *         cdef bytes b_longentry = b''
  *         cdef char *cbuf
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_buf = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_buf = __pyx_kp_b__2;
 
   /* "ssh2/sftp_handle.pyx":207
  *                     size_t buffer_maxlen=1024):
@@ -4893,8 +6866,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
  *         cdef char *cbuf
  *         cdef char *longentry
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_b_longentry = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_b_longentry = __pyx_kp_b__2;
 
   /* "ssh2/sftp_handle.pyx":210
  *         cdef char *cbuf
@@ -4918,6 +6891,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -4948,16 +6922,16 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_3 = ((__pyx_v_cbuf == NULL) != 0);
+        __pyx_t_3 = (__pyx_v_cbuf == NULL);
         if (!__pyx_t_3) {
         } else {
           __pyx_t_2 = __pyx_t_3;
           goto __pyx_L7_bool_binop_done;
         }
-        __pyx_t_3 = ((__pyx_v_longentry == NULL) != 0);
+        __pyx_t_3 = (__pyx_v_longentry == NULL);
         __pyx_t_2 = __pyx_t_3;
         __pyx_L7_bool_binop_done:;
-        if (__pyx_t_2) {
+        if (unlikely(__pyx_t_2)) {
 
           /* "ssh2/sftp_handle.pyx":215
  *             longentry = <char *>malloc(sizeof(char)*longentry_maxlen)
@@ -5060,7 +7034,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
  *                 buf = cbuf[:rc]
  *                 b_longentry = longentry
  */
-    __pyx_t_2 = ((__pyx_v_rc > 0) != 0);
+    __pyx_t_2 = (__pyx_v_rc > 0);
     if (__pyx_t_2) {
 
       /* "ssh2/sftp_handle.pyx":222
@@ -5183,16 +7157,16 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex(struct
   __pyx_t_13 = PyTuple_New(4); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 227, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_13);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_buf);
   __Pyx_GIVEREF(__pyx_v_buf);
-  PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_v_buf);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_v_buf)) __PYX_ERR(0, 227, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_b_longentry);
   __Pyx_GIVEREF(__pyx_v_b_longentry);
-  PyTuple_SET_ITEM(__pyx_t_13, 2, __pyx_v_b_longentry);
-  __Pyx_INCREF(((PyObject *)__pyx_v_attrs));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_attrs));
-  PyTuple_SET_ITEM(__pyx_t_13, 3, ((PyObject *)__pyx_v_attrs));
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 2, __pyx_v_b_longentry)) __PYX_ERR(0, 227, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_attrs);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_attrs);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_13, 3, ((PyObject *)__pyx_v_attrs))) __PYX_ERR(0, 227, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_r = __pyx_t_13;
   __pyx_t_13 = 0;
@@ -5231,42 +7205,68 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_21readdir[] = "SFTPHandle.readdir(self, size_t buffer_maxlen=1024)\nGet directory listing from file handle, if any.\n\n        This function is a generator and should be iterated on.\n\n        File handle *must* be opened with :py:func:`ssh2.sftp.SFTP.readdir()`\n\n        :param buffer_maxlen: Max length of returned file entry.\n\n        :rtype: iter(bytes)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_21readdir, "SFTPHandle.readdir(self, size_t buffer_maxlen=1024)\nGet directory listing from file handle, if any.\n\n        This function is a generator and should be iterated on.\n\n        File handle *must* be opened with :py:func:`ssh2.sftp.SFTP.readdir()`\n\n        :param buffer_maxlen: Max length of returned file entry.\n\n        :rtype: iter(bytes)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_22readdir = {"readdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_21readdir};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_buffer_maxlen;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("readdir (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buffer_maxlen);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buffer_maxlen);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 229, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readdir") < 0)) __PYX_ERR(0, 229, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readdir") < 0)) __PYX_ERR(0, 229, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -5278,10 +7278,18 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *_
       __pyx_v_buffer_maxlen = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("readdir", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 229, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("readdir", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 229, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.readdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -5289,6 +7297,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir(PyObject *_
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_21readdir(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_buffer_maxlen);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5307,14 +7321,14 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_21readdir(struct __py
     __Pyx_INCREF(Py_None);
     __PYX_ERR(0, 229, __pyx_L1_error)
   } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
   }
   __pyx_cur_scope->__pyx_v_self = __pyx_v_self;
   __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
   __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
   __pyx_cur_scope->__pyx_v_buffer_maxlen = __pyx_v_buffer_maxlen;
   {
-    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_readdir, __pyx_n_s_SFTPHandle_readdir, __pyx_n_s_ssh2_sftp_handle); if (unlikely(!gen)) __PYX_ERR(0, 229, __pyx_L1_error)
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1, __pyx_codeobj__4, (PyObject *) __pyx_cur_scope, __pyx_n_s_readdir, __pyx_n_s_SFTPHandle_readdir, __pyx_n_s_ssh2_sftp_handle); if (unlikely(!gen)) __PYX_ERR(0, 229, __pyx_L1_error)
     __Pyx_DECREF(__pyx_cur_scope);
     __Pyx_RefNannyFinishContext();
     return (PyObject *) gen;
@@ -5324,7 +7338,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_21readdir(struct __py
   __pyx_L1_error:;
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.readdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -5338,10 +7352,11 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  int __pyx_t_7;
+  unsigned int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
   int __pyx_t_8;
+  int __pyx_t_9;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -5369,21 +7384,28 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
   __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_cur_scope->__pyx_v_buffer_maxlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_5 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_4)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_4);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_5 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
   if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
     PyObject* sequence = __pyx_t_1;
     Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
@@ -5416,23 +7438,23 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else {
     Py_ssize_t index = -1;
-    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 239, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
-    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed;
+    __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
+    index = 0; __pyx_t_2 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_2);
-    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L4_unpacking_failed;
+    index = 1; __pyx_t_3 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L4_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_3);
-    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed;
+    index = 2; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_4);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 239, __pyx_L1_error)
-    __pyx_t_6 = NULL;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 3) < 0) __PYX_ERR(0, 239, __pyx_L1_error)
+    __pyx_t_7 = NULL;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
     goto __pyx_L5_unpacking_done;
     __pyx_L4_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
     if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
     __PYX_ERR(0, 239, __pyx_L1_error)
     __pyx_L5_unpacking_done:;
@@ -5455,23 +7477,23 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
  *             rc, buf, attrs = self._readdir(buffer_maxlen)
  */
   while (1) {
-    __pyx_t_1 = __Pyx_PyInt_From_int(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_ERROR_EAGAIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_t_4 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_rc, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 240, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (!__pyx_t_8) {
+    if (!__pyx_t_9) {
     } else {
-      __pyx_t_7 = __pyx_t_8;
+      __pyx_t_8 = __pyx_t_9;
       goto __pyx_L8_bool_binop_done;
     }
     __pyx_t_4 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_rc, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error)
-    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 240, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_7 = __pyx_t_8;
+    __pyx_t_8 = __pyx_t_9;
     __pyx_L8_bool_binop_done:;
-    if (!__pyx_t_7) break;
+    if (!__pyx_t_8) break;
 
     /* "ssh2/sftp_handle.pyx":241
  *         rc, buf, attrs = self._readdir(buffer_maxlen)
@@ -5484,13 +7506,13 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_rc);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_rc);
-    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_rc);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_rc)) __PYX_ERR(0, 241, __pyx_L1_error);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_buf);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_buf);
-    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_buf);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_buf)) __PYX_ERR(0, 241, __pyx_L1_error);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_attrs);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_attrs);
-    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_cur_scope->__pyx_v_attrs);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_cur_scope->__pyx_v_attrs)) __PYX_ERR(0, 241, __pyx_L1_error);
     __pyx_r = __pyx_t_4;
     __pyx_t_4 = 0;
     __Pyx_XGIVEREF(__pyx_r);
@@ -5514,21 +7536,28 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
     __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_cur_scope->__pyx_v_buffer_maxlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_2 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (likely(PyMethod_Check(__pyx_t_1))) {
       __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
       if (likely(__pyx_t_2)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
         __Pyx_INCREF(__pyx_t_2);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_4 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3);
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
     if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
       PyObject* sequence = __pyx_t_4;
       Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
@@ -5561,23 +7590,23 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     } else {
       Py_ssize_t index = -1;
-      __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
-      index = 0; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L11_unpacking_failed;
+      __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6);
+      index = 0; __pyx_t_1 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L11_unpacking_failed;
       __Pyx_GOTREF(__pyx_t_1);
-      index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L11_unpacking_failed;
+      index = 1; __pyx_t_3 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L11_unpacking_failed;
       __Pyx_GOTREF(__pyx_t_3);
-      index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L11_unpacking_failed;
+      index = 2; __pyx_t_2 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_2)) goto __pyx_L11_unpacking_failed;
       __Pyx_GOTREF(__pyx_t_2);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 242, __pyx_L1_error)
-      __pyx_t_6 = NULL;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 3) < 0) __PYX_ERR(0, 242, __pyx_L1_error)
+      __pyx_t_7 = NULL;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
       goto __pyx_L12_unpacking_done;
       __pyx_L11_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_6 = NULL;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_7 = NULL;
       if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
       __PYX_ERR(0, 242, __pyx_L1_error)
       __pyx_L12_unpacking_done:;
@@ -5609,11 +7638,12 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
   PyErr_SetNone(PyExc_StopIteration);
   goto __pyx_L0;
   __pyx_L1_error:;
+  __Pyx_Generator_Replace_StopIteration(0);
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("readdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
@@ -5635,42 +7665,68 @@ static PyObject *__pyx_gb_4ssh2_11sftp_handle_10SFTPHandle_23generator1(__pyx_Co
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_24_readdir[] = "SFTPHandle._readdir(self, size_t buffer_maxlen=1024)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_24_readdir, "SFTPHandle._readdir(self, size_t buffer_maxlen=1024)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_25_readdir = {"_readdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_24_readdir};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_buffer_maxlen;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("_readdir (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buffer_maxlen,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buffer_maxlen);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buffer_maxlen);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_readdir") < 0)) __PYX_ERR(0, 244, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_readdir") < 0)) __PYX_ERR(0, 244, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -5682,10 +7738,18 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *
       __pyx_v_buffer_maxlen = ((size_t)0x400);
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_readdir", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 244, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_readdir", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 244, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle._readdir", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -5693,6 +7757,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir(PyObject *
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_buffer_maxlen);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -5719,7 +7789,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("_readdir", 0);
+  __Pyx_RefNannySetupContext("_readdir", 1);
 
   /* "ssh2/sftp_handle.pyx":246
  *     def _readdir(self,
@@ -5728,8 +7798,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
  *         cdef char *cbuf
  *         cdef SFTPAttributes attrs = SFTPAttributes()
  */
-  __Pyx_INCREF(__pyx_kp_b__4);
-  __pyx_v_buf = __pyx_kp_b__4;
+  __Pyx_INCREF(__pyx_kp_b__2);
+  __pyx_v_buf = __pyx_kp_b__2;
 
   /* "ssh2/sftp_handle.pyx":248
  *         cdef bytes buf = b''
@@ -5753,6 +7823,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -5774,8 +7845,8 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_2 = ((__pyx_v_cbuf == NULL) != 0);
-        if (__pyx_t_2) {
+        __pyx_t_2 = (__pyx_v_cbuf == NULL);
+        if (unlikely(__pyx_t_2)) {
 
           /* "ssh2/sftp_handle.pyx":252
  *             cbuf = <char *>malloc(sizeof(char)*buffer_maxlen)
@@ -5878,7 +7949,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
  *                 buf = cbuf[:rc]
  *         finally:
  */
-    __pyx_t_2 = ((__pyx_v_rc > 0) != 0);
+    __pyx_t_2 = (__pyx_v_rc > 0);
     if (__pyx_t_2) {
 
       /* "ssh2/sftp_handle.pyx":258
@@ -5963,13 +8034,13 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
   __pyx_t_12 = PyTuple_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 261, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_12);
   __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error);
   __Pyx_INCREF(__pyx_v_buf);
   __Pyx_GIVEREF(__pyx_v_buf);
-  PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf);
-  __Pyx_INCREF(((PyObject *)__pyx_v_attrs));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_attrs));
-  PyTuple_SET_ITEM(__pyx_t_12, 2, ((PyObject *)__pyx_v_attrs));
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_buf)) __PYX_ERR(0, 261, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_attrs);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_attrs);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, ((PyObject *)__pyx_v_attrs))) __PYX_ERR(0, 261, __pyx_L1_error);
   __pyx_t_1 = 0;
   __pyx_r = __pyx_t_12;
   __pyx_t_12 = 0;
@@ -6006,23 +8077,103 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_24_readdir(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_26write[] = "SFTPHandle.write(self, bytes buf)\nWrite buffer to file handle.\n\n        Returns tuple of (``error code``, ``bytes written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``error_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        :param buf: Buffer to write.\n        :type buf: bytes\n\n        :rtype: tuple(int, int)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_26write, "SFTPHandle.write(self, bytes buf)\nWrite buffer to file handle.\n\n        Returns tuple of (``error code``, ``bytes written``).\n\n        In blocking mode ``bytes_written`` will always equal ``len(buf)`` if no\n        errors have occurred which would raise exception.\n\n        In non-blocking mode ``error_code`` can be LIBSSH2_ERROR_EAGAIN and\n        ``bytes_written`` *can be less than* ``len(buf)``.\n\n        Clients should resume from that point on next call to ``write``, ie\n        ``buf[bytes_written_in_last_call:]``.\n\n        :param buf: Buffer to write.\n        :type buf: bytes\n\n        :rtype: tuple(int, int)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_27write = {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_26write};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_buf = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("write (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 263, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "write") < 0)) __PYX_ERR(0, 263, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_buf = ((PyObject*)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("write", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 263, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_buf), (&PyBytes_Type), 1, "buf", 1))) __PYX_ERR(0, 263, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), ((PyObject*)__pyx_v_buf));
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_buf);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6046,7 +8197,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("write", 0);
+  __Pyx_RefNannySetupContext("write", 1);
 
   /* "ssh2/sftp_handle.pyx":281
  * 
@@ -6059,7 +8210,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
     __PYX_ERR(0, 281, __pyx_L1_error)
   }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_buf); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 281, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_buf); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 281, __pyx_L1_error)
   __pyx_v__size = __pyx_t_1;
 
   /* "ssh2/sftp_handle.pyx":282
@@ -6113,6 +8264,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6126,7 +8278,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
  *                 if rc < 0 and rc != c_ssh2.LIBSSH2_ERROR_EAGAIN:
  */
         while (1) {
-          __pyx_t_3 = ((__pyx_v__size > 0) != 0);
+          __pyx_t_3 = (__pyx_v__size > 0);
           if (!__pyx_t_3) break;
 
           /* "ssh2/sftp_handle.pyx":288
@@ -6145,13 +8297,13 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
  *                     # Error we cannot resume from, exception will be raised
  *                     with gil:
  */
-          __pyx_t_4 = ((__pyx_v_rc < 0) != 0);
+          __pyx_t_4 = (__pyx_v_rc < 0);
           if (__pyx_t_4) {
           } else {
             __pyx_t_3 = __pyx_t_4;
             goto __pyx_L9_bool_binop_done;
           }
-          __pyx_t_4 = ((__pyx_v_rc != LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_4 = (__pyx_v_rc != LIBSSH2_ERROR_EAGAIN);
           __pyx_t_3 = __pyx_t_4;
           __pyx_L9_bool_binop_done:;
           if (__pyx_t_3) {
@@ -6224,7 +8376,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
  *                     break
  *                 cbuf += rc
  */
-          __pyx_t_3 = ((__pyx_v_rc == LIBSSH2_ERROR_EAGAIN) != 0);
+          __pyx_t_3 = (__pyx_v_rc == LIBSSH2_ERROR_EAGAIN);
           if (__pyx_t_3) {
 
             /* "ssh2/sftp_handle.pyx":294
@@ -6323,9 +8475,9 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
   __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 298, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __Pyx_GIVEREF(__pyx_t_6);
-  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6)) __PYX_ERR(0, 298, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_7);
-  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7)) __PYX_ERR(0, 298, __pyx_L1_error);
   __pyx_t_6 = 0;
   __pyx_t_7 = 0;
   __pyx_r = __pyx_t_8;
@@ -6362,12 +8514,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_26write(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_28fsync[] = "SFTPHandle.fsync(self)\nSync file handle data.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_28fsync, "SFTPHandle.fsync(self)\nSync file handle data.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_29fsync = {"fsync", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_28fsync};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("fsync (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("fsync", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "fsync", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_28fsync(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -6384,7 +8564,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_28fsync(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("fsync", 0);
+  __Pyx_RefNannySetupContext("fsync", 1);
 
   /* "ssh2/sftp_handle.pyx":305
  *         :rtype: int"""
@@ -6396,6 +8576,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_28fsync(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6473,28 +8654,98 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_28fsync(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_offset); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_30seek[] = "SFTPHandle.seek(self, size_t offset)\nDeprecated, use seek64.\n\n        Seek file to given offset.\n\n        :param offset: Offset to seek to.\n        :type offset: int\n\n        :rtype: None";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_offset) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_30seek, "SFTPHandle.seek(self, size_t offset)\nDeprecated, use seek64.\n\n        Seek file to given offset.\n\n        :param offset: Offset to seek to.\n        :type offset: int\n\n        :rtype: None");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_31seek = {"seek", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_30seek};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   size_t __pyx_v_offset;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("seek (wrapper)", 0);
-  assert(__pyx_arg_offset); {
-    __pyx_v_offset = __Pyx_PyInt_As_size_t(__pyx_arg_offset); if (unlikely((__pyx_v_offset == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_offset,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_offset)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "seek") < 0)) __PYX_ERR(0, 309, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_offset = __Pyx_PyInt_As_size_t(values[0]); if (unlikely((__pyx_v_offset == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 309, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("seek", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 309, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.seek", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_30seek(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), ((size_t)__pyx_v_offset));
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_30seek(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_offset);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6502,7 +8753,7 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek(PyObject *__py
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_30seek(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self, size_t __pyx_v_offset) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("seek", 0);
+  __Pyx_RefNannySetupContext("seek", 1);
 
   /* "ssh2/sftp_handle.pyx":318
  * 
@@ -6514,6 +8765,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_30seek(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6572,28 +8824,98 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_30seek(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64(PyObject *__pyx_v_self, PyObject *__pyx_arg_offset); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_32seek64[] = "SFTPHandle.seek64(self, libssh2_uint64_t offset)\nSeek file to given 64-bit offset.\n\n        :param offset: Offset to seek to.\n        :type offset: int\n\n        :rtype: None";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64(PyObject *__pyx_v_self, PyObject *__pyx_arg_offset) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_32seek64, "SFTPHandle.seek64(self, libssh2_uint64_t offset)\nSeek file to given 64-bit offset.\n\n        :param offset: Offset to seek to.\n        :type offset: int\n\n        :rtype: None");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_33seek64 = {"seek64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_32seek64};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   libssh2_uint64_t __pyx_v_offset;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("seek64 (wrapper)", 0);
-  assert(__pyx_arg_offset); {
-    __pyx_v_offset = __Pyx_PyInt_As_libssh2_uint64_t(__pyx_arg_offset); if (unlikely((__pyx_v_offset == ((libssh2_uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_offset,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_offset)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "seek64") < 0)) __PYX_ERR(0, 321, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_offset = __Pyx_PyInt_As_libssh2_uint64_t(values[0]); if (unlikely((__pyx_v_offset == ((libssh2_uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("seek64", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 321, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.seek64", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_32seek64(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), ((libssh2_uint64_t)__pyx_v_offset));
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_32seek64(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_offset);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -6601,7 +8923,7 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64(PyObject *__
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_32seek64(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self, libssh2_uint64_t __pyx_v_offset) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("seek64", 0);
+  __Pyx_RefNannySetupContext("seek64", 1);
 
   /* "ssh2/sftp_handle.pyx":328
  * 
@@ -6613,6 +8935,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_32seek64(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6671,12 +8994,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_32seek64(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_34rewind[] = "SFTPHandle.rewind(self)\nRewind file handle to beginning of file.\n\n        :rtype: None";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_34rewind, "SFTPHandle.rewind(self)\nRewind file handle to beginning of file.\n\n        :rtype: None");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_35rewind = {"rewind", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_34rewind};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("rewind (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("rewind", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "rewind", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_34rewind(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -6687,7 +9038,7 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind(PyObject *__
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_34rewind(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("rewind", 0);
+  __Pyx_RefNannySetupContext("rewind", 1);
 
   /* "ssh2/sftp_handle.pyx":335
  * 
@@ -6699,6 +9050,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_34rewind(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6757,12 +9109,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_34rewind(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_36tell[] = "SFTPHandle.tell(self)\nDeprecated, use tell64.\n\n        Get current file handle offset.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_36tell, "SFTPHandle.tell(self)\nDeprecated, use tell64.\n\n        Get current file handle offset.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_37tell = {"tell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_36tell};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("tell (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("tell", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "tell", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_36tell(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -6779,7 +9159,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_36tell(struct __pyx_o
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("tell", 0);
+  __Pyx_RefNannySetupContext("tell", 1);
 
   /* "ssh2/sftp_handle.pyx":345
  *         :rtype: int"""
@@ -6791,6 +9171,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_36tell(struct __pyx_o
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6868,12 +9249,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_36tell(struct __pyx_o
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_38tell64[] = "SFTPHandle.tell64(self)\nGet current file handle 64-bit offset.\n\n        :rtype: int";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_38tell64, "SFTPHandle.tell64(self)\nGet current file handle 64-bit offset.\n\n        :rtype: int");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_39tell64 = {"tell64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_38tell64};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("tell64 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("tell64", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "tell64", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_38tell64(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -6890,7 +9299,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_38tell64(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("tell64", 0);
+  __Pyx_RefNannySetupContext("tell64", 1);
 
   /* "ssh2/sftp_handle.pyx":354
  *         :rtype: int"""
@@ -6902,6 +9311,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_38tell64(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -6979,59 +9389,100 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_38tell64(struct __pyx
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex[] = "SFTPHandle.fstat_ex(self, SFTPAttributes attrs, int setstat)\nGet or set file attributes. Clients would typically use one of the\n        fstat or fsetstat functions instead";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex, "SFTPHandle.fstat_ex(self, SFTPAttributes attrs, int setstat)\nGet or set file attributes. Clients would typically use one of the\n        fstat or fsetstat functions instead");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex = {"fstat_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_attrs = 0;
   int __pyx_v_setstat;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("fstat_ex (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_attrs,&__pyx_n_s_setstat,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_attrs,&__pyx_n_s_setstat,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attrs)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_attrs)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 358, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_setstat)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_setstat)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 358, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("fstat_ex", 1, 2, 2, 1); __PYX_ERR(0, 358, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fstat_ex") < 0)) __PYX_ERR(0, 358, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "fstat_ex") < 0)) __PYX_ERR(0, 358, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_attrs = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)values[0]);
     __pyx_v_setstat = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_setstat == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 358, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("fstat_ex", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 358, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("fstat_ex", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 358, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.fstat_ex", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -7044,6 +9495,12 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex(PyObject *
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7057,7 +9514,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("fstat_ex", 0);
+  __Pyx_RefNannySetupContext("fstat_ex", 1);
 
   /* "ssh2/sftp_handle.pyx":362
  *         fstat or fsetstat functions instead"""
@@ -7069,6 +9526,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -7146,12 +9604,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_42fstat[] = "SFTPHandle.fstat(self)\nGet file stat attributes from handle.\n\n        :rtype: :py:class:`ssh2.sftp.SFTPAttributes` or LIBSSH2_ERROR_EAGAIN";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_42fstat, "SFTPHandle.fstat(self)\nGet file stat attributes from handle.\n\n        :rtype: :py:class:`ssh2.sftp.SFTPAttributes` or LIBSSH2_ERROR_EAGAIN");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_43fstat = {"fstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_42fstat};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("fstat (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("fstat", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "fstat", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -7170,7 +9656,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(struct __pyx_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("fstat", 0);
+  __Pyx_RefNannySetupContext("fstat", 1);
 
   /* "ssh2/sftp_handle.pyx":372
  *         :rtype: :py:class:`ssh2.sftp.SFTPAttributes` or LIBSSH2_ERROR_EAGAIN"""
@@ -7194,6 +9680,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(struct __pyx_
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -7235,7 +9722,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(struct __pyx_
  *             return handle_error_codes(rc)
  *         return attrs
  */
-  __pyx_t_2 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_2 = (__pyx_v_rc != 0);
   if (__pyx_t_2) {
 
     /* "ssh2/sftp_handle.pyx":376
@@ -7270,7 +9757,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(struct __pyx_
  *     def fsetstat(self, SFTPAttributes attrs):
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_attrs));
+  __Pyx_INCREF((PyObject *)__pyx_v_attrs);
   __pyx_r = ((PyObject *)__pyx_v_attrs);
   goto __pyx_L0;
 
@@ -7303,23 +9790,103 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_42fstat(struct __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat(PyObject *__pyx_v_self, PyObject *__pyx_v_attrs); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat[] = "SFTPHandle.fsetstat(self, SFTPAttributes attrs)\nSet file handle attributes.\n\n        :param attrs: Attributes to set.\n        :type attrs: :py:class:`ssh2.sftp.SFTPAttributes`";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat(PyObject *__pyx_v_self, PyObject *__pyx_v_attrs) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat, "SFTPHandle.fsetstat(self, SFTPAttributes attrs)\nSet file handle attributes.\n\n        :param attrs: Attributes to set.\n        :type attrs: :py:class:`ssh2.sftp.SFTPAttributes`");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat = {"fsetstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *__pyx_v_attrs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("fsetstat (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_attrs,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_attrs)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "fsetstat") < 0)) __PYX_ERR(0, 379, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_attrs = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("fsetstat", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 379, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.fsetstat", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
   if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_attrs), __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes, 1, "attrs", 0))) __PYX_ERR(0, 379, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes *)__pyx_v_attrs));
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v_attrs);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7333,7 +9900,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("fsetstat", 0);
+  __Pyx_RefNannySetupContext("fsetstat", 1);
 
   /* "ssh2/sftp_handle.pyx":385
  *         :type attrs: :py:class:`ssh2.sftp.SFTPAttributes`"""
@@ -7345,6 +9912,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -7422,12 +9990,40 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat(struct __p
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs[] = "SFTPHandle.fstatvfs(self)\nGet file system statistics for handle\n\n        :rtype: `ssh2.sftp.SFTPStatVFS`";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs, "SFTPHandle.fstatvfs(self)\nGet file system statistics for handle\n\n        :rtype: `ssh2.sftp.SFTPStatVFS`");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs = {"fstatvfs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("fstatvfs (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("fstatvfs", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "fstatvfs", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -7446,7 +10042,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("fstatvfs", 0);
+  __Pyx_RefNannySetupContext("fstatvfs", 1);
 
   /* "ssh2/sftp_handle.pyx":393
  * 
@@ -7470,6 +10066,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(struct __p
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -7511,7 +10108,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(struct __p
  *             return handle_error_codes(rc)
  *         return vfs
  */
-  __pyx_t_2 = ((__pyx_v_rc != 0) != 0);
+  __pyx_t_2 = (__pyx_v_rc != 0);
   if (__pyx_t_2) {
 
     /* "ssh2/sftp_handle.pyx":398
@@ -7546,7 +10143,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(struct __p
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_vfs));
+  __Pyx_INCREF((PyObject *)__pyx_v_vfs);
   __pyx_r = ((PyObject *)__pyx_v_vfs);
   goto __pyx_L0;
 
@@ -7572,17 +10169,45 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs(struct __p
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__[] = "SFTPHandle.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__, "SFTPHandle.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self));
 
   /* function exit code */
@@ -7593,33 +10218,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__(P
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -7629,21 +10249,104 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__(C
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__[] = "SFTPHandle.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__, "SFTPHandle.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7651,33 +10354,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPHandle.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -7697,44 +10395,64 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__
 static int __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v__sftp_ref = 0;
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sftp_ref,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sftp_ref,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sftp_ref)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sftp_ref)) != 0)) {
+          (void)__Pyx_Arg_NewRef_VARARGS(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 405, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 405, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(0, 405, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0);
     }
     __pyx_v__sftp_ref = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 405, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 405, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPStatVFS.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return -1;
@@ -7742,6 +10460,12 @@ static int __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_1__cinit__(PyObject *__pyx
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS___cinit__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self), __pyx_v__sftp_ref);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -7753,7 +10477,7 @@ static int __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS___cinit__(struct __pyx_obj
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
+  __Pyx_RefNannySetupContext("__cinit__", 1);
 
   /* "ssh2/sftp_handle.pyx":406
  * 
@@ -7778,6 +10502,7 @@ static int __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS___cinit__(struct __pyx_obj
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -7799,8 +10524,8 @@ static int __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS___cinit__(struct __pyx_obj
  *                 with gil:
  *                     raise MemoryError
  */
-        __pyx_t_1 = ((__pyx_v_self->_ptr == NULL) != 0);
-        if (__pyx_t_1) {
+        __pyx_t_1 = (__pyx_v_self->_ptr == NULL);
+        if (unlikely(__pyx_t_1)) {
 
           /* "ssh2/sftp_handle.pyx":411
  *                 sizeof(c_sftp.LIBSSH2_SFTP_STATVFS))
@@ -8007,8 +10732,10 @@ static int __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS___cinit__(struct __pyx_obj
 /* Python wrapper */
 static void __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_2__dealloc__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8016,9 +10743,7 @@ static void __pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_3__dealloc__(PyObject *__
 }
 
 static void __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_2__dealloc__(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
   /* "ssh2/sftp_handle.pyx":426
  * 
@@ -8030,6 +10755,7 @@ static void __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_2__dealloc__(struct __pyx
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -8042,7 +10768,7 @@ static void __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_2__dealloc__(struct __pyx
  *                 free(self._ptr)
  * 
  */
-        __pyx_t_1 = ((__pyx_v_self->_ptr != NULL) != 0);
+        __pyx_t_1 = (__pyx_v_self->_ptr != NULL);
         if (__pyx_t_1) {
 
           /* "ssh2/sftp_handle.pyx":428
@@ -8092,23 +10818,24 @@ static void __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_2__dealloc__(struct __pyx
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
-/* "ssh2/sftp_handle.pyx":431
+/* "ssh2/sftp_handle.pyx":430
+ *                 free(self._ptr)
  * 
- *     @property
- *     def f_bsize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bsize(self):
  *         """File system block size"""
- *         return self._ptr.f_bsize
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8123,7 +10850,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize___get__(str
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":433
  *     def f_bsize(self):
@@ -8139,12 +10866,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize___get__(str
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":431
+  /* "ssh2/sftp_handle.pyx":430
+ *                 free(self._ptr)
  * 
- *     @property
- *     def f_bsize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bsize(self):
  *         """File system block size"""
- *         return self._ptr.f_bsize
  */
 
   /* function exit code */
@@ -8158,20 +10885,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bsize___get__(str
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":436
+/* "ssh2/sftp_handle.pyx":435
+ *         return self._ptr.f_bsize
  * 
- *     @property
- *     def f_frsize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_frsize(self):
  *         """Fragment size"""
- *         return self._ptr.f_frsize
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8186,7 +10915,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":438
  *     def f_frsize(self):
@@ -8202,12 +10931,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":436
+  /* "ssh2/sftp_handle.pyx":435
+ *         return self._ptr.f_bsize
  * 
- *     @property
- *     def f_frsize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_frsize(self):
  *         """Fragment size"""
- *         return self._ptr.f_frsize
  */
 
   /* function exit code */
@@ -8221,20 +10950,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_frsize___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":441
+/* "ssh2/sftp_handle.pyx":440
+ *         return self._ptr.f_frsize
  * 
- *     @property
- *     def f_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_blocks(self):
  *         """Size of fs in f_frsize units"""
- *         return self._ptr.f_blocks
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8249,7 +10980,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":443
  *     def f_blocks(self):
@@ -8265,12 +10996,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":441
+  /* "ssh2/sftp_handle.pyx":440
+ *         return self._ptr.f_frsize
  * 
- *     @property
- *     def f_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_blocks(self):
  *         """Size of fs in f_frsize units"""
- *         return self._ptr.f_blocks
  */
 
   /* function exit code */
@@ -8284,20 +11015,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_blocks___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":446
+/* "ssh2/sftp_handle.pyx":445
+ *         return self._ptr.f_blocks
  * 
- *     @property
- *     def f_bfree(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bfree(self):
  *         """Free blocks"""
- *         return self._ptr.f_bfree
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8312,7 +11045,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree___get__(str
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":448
  *     def f_bfree(self):
@@ -8328,12 +11061,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree___get__(str
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":446
+  /* "ssh2/sftp_handle.pyx":445
+ *         return self._ptr.f_blocks
  * 
- *     @property
- *     def f_bfree(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bfree(self):
  *         """Free blocks"""
- *         return self._ptr.f_bfree
  */
 
   /* function exit code */
@@ -8347,20 +11080,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_bfree___get__(str
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":451
+/* "ssh2/sftp_handle.pyx":450
+ *         return self._ptr.f_bfree
  * 
- *     @property
- *     def f_bavail(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bavail(self):
  *         """Free blocks for non-root"""
- *         return self._ptr.f_bavail
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8375,7 +11110,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":453
  *     def f_bavail(self):
@@ -8391,12 +11126,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":451
+  /* "ssh2/sftp_handle.pyx":450
+ *         return self._ptr.f_bfree
  * 
- *     @property
- *     def f_bavail(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_bavail(self):
  *         """Free blocks for non-root"""
- *         return self._ptr.f_bavail
  */
 
   /* function exit code */
@@ -8410,20 +11145,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_bavail___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":456
+/* "ssh2/sftp_handle.pyx":455
+ *         return self._ptr.f_bavail
  * 
- *     @property
- *     def f_files(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_files(self):
  *         """Inodes"""
- *         return self._ptr.f_files
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8438,7 +11175,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files___get__(str
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":458
  *     def f_files(self):
@@ -8454,12 +11191,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files___get__(str
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":456
+  /* "ssh2/sftp_handle.pyx":455
+ *         return self._ptr.f_bavail
  * 
- *     @property
- *     def f_files(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_files(self):
  *         """Inodes"""
- *         return self._ptr.f_files
  */
 
   /* function exit code */
@@ -8473,20 +11210,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_files___get__(str
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":461
+/* "ssh2/sftp_handle.pyx":460
+ *         return self._ptr.f_files
  * 
- *     @property
- *     def f_ffree(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_ffree(self):
  *         """Free inodes"""
- *         return self._ptr.f_ffree
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8501,7 +11240,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree___get__(str
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":463
  *     def f_ffree(self):
@@ -8517,12 +11256,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree___get__(str
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":461
+  /* "ssh2/sftp_handle.pyx":460
+ *         return self._ptr.f_files
  * 
- *     @property
- *     def f_ffree(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_ffree(self):
  *         """Free inodes"""
- *         return self._ptr.f_ffree
  */
 
   /* function exit code */
@@ -8536,20 +11275,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_7f_ffree___get__(str
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":466
+/* "ssh2/sftp_handle.pyx":465
+ *         return self._ptr.f_ffree
  * 
- *     @property
- *     def f_favail(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_favail(self):
  *         """Free inodes for non-root"""
- *         return self._ptr.f_favail
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8564,7 +11305,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail___get__(st
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":468
  *     def f_favail(self):
@@ -8580,12 +11321,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail___get__(st
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":466
+  /* "ssh2/sftp_handle.pyx":465
+ *         return self._ptr.f_ffree
  * 
- *     @property
- *     def f_favail(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_favail(self):
  *         """Free inodes for non-root"""
- *         return self._ptr.f_favail
  */
 
   /* function exit code */
@@ -8599,20 +11340,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_8f_favail___get__(st
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":471
+/* "ssh2/sftp_handle.pyx":470
+ *         return self._ptr.f_favail
  * 
- *     @property
- *     def f_fsid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_fsid(self):
  *         """File system ID"""
- *         return self._ptr.f_fsid
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8627,7 +11370,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid___get__(stru
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":473
  *     def f_fsid(self):
@@ -8643,12 +11386,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid___get__(stru
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":471
+  /* "ssh2/sftp_handle.pyx":470
+ *         return self._ptr.f_favail
  * 
- *     @property
- *     def f_fsid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_fsid(self):
  *         """File system ID"""
- *         return self._ptr.f_fsid
  */
 
   /* function exit code */
@@ -8662,20 +11405,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_fsid___get__(stru
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":476
+/* "ssh2/sftp_handle.pyx":475
+ *         return self._ptr.f_fsid
  * 
- *     @property
- *     def f_flag(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_flag(self):
  *         """File system mount flags.
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8690,7 +11435,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag___get__(stru
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":481
  *         This property is a bit mask with defined bits
@@ -8706,12 +11451,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag___get__(stru
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":476
+  /* "ssh2/sftp_handle.pyx":475
+ *         return self._ptr.f_fsid
  * 
- *     @property
- *     def f_flag(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_flag(self):
  *         """File system mount flags.
- * 
  */
 
   /* function exit code */
@@ -8725,20 +11470,22 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6f_flag___get__(stru
   return __pyx_r;
 }
 
-/* "ssh2/sftp_handle.pyx":484
+/* "ssh2/sftp_handle.pyx":483
+ *         return self._ptr.f_flag
  * 
- *     @property
- *     def f_namemax(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_namemax(self):
  *         """Maximum filename length"""
- *         return self._ptr.f_namemax
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax___get__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8753,7 +11500,7 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax___get__(s
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
   /* "ssh2/sftp_handle.pyx":486
  *     def f_namemax(self):
@@ -8767,12 +11514,12 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax___get__(s
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "ssh2/sftp_handle.pyx":484
+  /* "ssh2/sftp_handle.pyx":483
+ *         return self._ptr.f_flag
  * 
- *     @property
- *     def f_namemax(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def f_namemax(self):
  *         """Maximum filename length"""
- *         return self._ptr.f_namemax
  */
 
   /* function exit code */
@@ -8788,17 +11535,45 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_9f_namemax___get__(s
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__[] = "SFTPStatVFS.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__, "SFTPStatVFS.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self));
 
   /* function exit code */
@@ -8809,33 +11584,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__(P
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPStatVFS.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -8845,21 +11615,104 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__(C
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__[] = "SFTPStatVFS.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__, "SFTPStatVFS.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.sftp_handle.SFTPStatVFS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__(((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -8867,33 +11720,28 @@ static PyObject *__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__
 static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.sftp_handle.SFTPStatVFS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -8904,12 +11752,17 @@ static PyObject *__pyx_pf_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPHandle(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)o);
   p->_sftp = ((struct __pyx_obj_4ssh2_4sftp_SFTP *)Py_None); Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_1__cinit__(o, a, k) < 0)) goto bad;
@@ -8922,8 +11775,10 @@ static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPHandle(PyTypeObject *t, Py
 static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPHandle(PyObject *o) {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *p = (struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPHandle) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -8936,7 +11791,14 @@ static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPHandle(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_sftp);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_11sftp_handle_SFTPHandle(PyObject *o, visitproc v, void *a) {
@@ -8957,37 +11819,60 @@ static int __pyx_tp_clear_4ssh2_11sftp_handle_SFTPHandle(PyObject *o) {
   return 0;
 }
 
-static PyObject *__pyx_specialmethod___pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(self);}
+static PyObject *__pyx_specialmethod___pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {
+  PyObject *res = __pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__(self);
+  if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); }
+  return res;
+}
 
 static PyMethodDef __pyx_methods_4ssh2_11sftp_handle_SFTPHandle[] = {
   {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__, METH_NOARGS|METH_COEXIST, 0},
-  {"__enter__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_8__enter__},
+  {"__enter__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_9__enter__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_8__enter__},
   {"__exit__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_11__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_10__exit__},
-  {"close", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_12close},
-  {"read", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_14read},
-  {"readdir_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex},
-  {"_readdir_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex},
-  {"readdir", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_21readdir},
-  {"_readdir", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_24_readdir},
-  {"write", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write, METH_O, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_26write},
-  {"fsync", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_28fsync},
-  {"seek", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek, METH_O, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_30seek},
-  {"seek64", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64, METH_O, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_32seek64},
-  {"rewind", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_34rewind},
-  {"tell", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_36tell},
-  {"tell64", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_38tell64},
-  {"fstat_ex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex},
-  {"fstat", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_42fstat},
-  {"fsetstat", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat, METH_O, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat},
-  {"fstatvfs", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs},
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__, METH_O, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__},
+  {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_13close, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_12close},
+  {"read", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_15read, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_14read},
+  {"readdir_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_16readdir_ex},
+  {"_readdir_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_19_readdir_ex},
+  {"readdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_22readdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_21readdir},
+  {"_readdir", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_25_readdir, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_24_readdir},
+  {"write", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_27write, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_26write},
+  {"fsync", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_29fsync, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_28fsync},
+  {"seek", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_31seek, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_30seek},
+  {"seek64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_33seek64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_32seek64},
+  {"rewind", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_35rewind, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_34rewind},
+  {"tell", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_37tell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_36tell},
+  {"tell64", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_39tell64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_38tell64},
+  {"fstat_ex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_40fstat_ex},
+  {"fstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_43fstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_42fstat},
+  {"fsetstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_44fsetstat},
+  {"fstatvfs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_46fstatvfs},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_48__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_10SFTPHandle_50__setstate_cython__},
   {0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_11sftp_handle_SFTPHandle_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPHandle},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_11sftp_handle_SFTPHandle},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_11sftp_handle_SFTPHandle},
+  {Py_tp_iter, (void *)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_5__iter__},
+  {Py_tp_iternext, (void *)__pyx_pw_4ssh2_11sftp_handle_10SFTPHandle_7__next__},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_11sftp_handle_SFTPHandle},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_11sftp_handle_SFTPHandle},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_11sftp_handle_SFTPHandle_spec = {
+  "ssh2.sftp_handle.SFTPHandle",
+  sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_11sftp_handle_SFTPHandle_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPHandle = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp_handle.SFTPHandle", /*tp_name*/
+  "ssh2.sftp_handle.""SFTPHandle", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPHandle), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPHandle, /*tp_dealloc*/
@@ -9030,7 +11915,9 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPHandle = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_11sftp_handle_SFTPHandle, /*tp_new*/
@@ -9044,27 +11931,43 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPHandle = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPAttributes(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   if (unlikely(__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
   return o;
   bad:
@@ -9074,8 +11977,10 @@ static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPAttributes(PyTypeObject *t
 
 static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPAttributes(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPAttributes) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   {
@@ -9086,7 +11991,14 @@ static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPAttributes(PyObject *o) {
     __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyObject *__pyx_getprop_4ssh2_11sftp_handle_14SFTPAttributes_flags(PyObject *o, CYTHON_UNUSED void *x) {
@@ -9188,8 +12100,8 @@ static int __pyx_setprop_4ssh2_11sftp_handle_14SFTPAttributes_mtime(PyObject *o,
 }
 
 static PyMethodDef __pyx_methods_4ssh2_11sftp_handle_SFTPAttributes[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__, METH_O, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_14SFTPAttributes_6__setstate_cython__},
   {0, 0, 0, 0}
 };
 
@@ -9203,10 +12115,26 @@ static struct PyGetSetDef __pyx_getsets_4ssh2_11sftp_handle_SFTPAttributes[] = {
   {(char *)"mtime", __pyx_getprop_4ssh2_11sftp_handle_14SFTPAttributes_mtime, __pyx_setprop_4ssh2_11sftp_handle_14SFTPAttributes_mtime, (char *)0, 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_11sftp_handle_SFTPAttributes_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPAttributes},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_11sftp_handle_SFTPAttributes},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_11sftp_handle_SFTPAttributes},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_11sftp_handle_SFTPAttributes},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_11sftp_handle_SFTPAttributes_spec = {
+  "ssh2.sftp_handle.SFTPAttributes",
+  sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_11sftp_handle_SFTPAttributes_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPAttributes = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp_handle.SFTPAttributes", /*tp_name*/
+  "ssh2.sftp_handle.""SFTPAttributes", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPAttributes), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPAttributes, /*tp_dealloc*/
@@ -9249,7 +12177,9 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPAttributes = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_11sftp_handle_SFTPAttributes, /*tp_new*/
@@ -9263,28 +12193,44 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPAttributes = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPStatVFS(PyTypeObject *t, PyObject *a, PyObject *k) {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *p;
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   p = ((struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)o);
   p->_sftp_ref = Py_None; Py_INCREF(Py_None);
   if (unlikely(__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_1__cinit__(o, a, k) < 0)) goto bad;
@@ -9297,8 +12243,10 @@ static PyObject *__pyx_tp_new_4ssh2_11sftp_handle_SFTPStatVFS(PyTypeObject *t, P
 static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPStatVFS(PyObject *o) {
   struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *p = (struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS *)o;
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPStatVFS) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   PyObject_GC_UnTrack(o);
@@ -9311,7 +12259,14 @@ static void __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPStatVFS(PyObject *o) {
     PyErr_Restore(etype, eval, etb);
   }
   Py_CLEAR(p->_sftp_ref);
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static int __pyx_tp_traverse_4ssh2_11sftp_handle_SFTPStatVFS(PyObject *o, visitproc v, void *a) {
@@ -9377,29 +12332,48 @@ static PyObject *__pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_namemax(PyObj
 }
 
 static PyMethodDef __pyx_methods_4ssh2_11sftp_handle_SFTPStatVFS[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__, METH_O, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_11sftp_handle_11SFTPStatVFS_6__setstate_cython__},
   {0, 0, 0, 0}
 };
 
 static struct PyGetSetDef __pyx_getsets_4ssh2_11sftp_handle_SFTPStatVFS[] = {
-  {(char *)"f_bsize", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bsize, 0, (char *)"File system block size", 0},
-  {(char *)"f_frsize", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_frsize, 0, (char *)"Fragment size", 0},
-  {(char *)"f_blocks", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_blocks, 0, (char *)"Size of fs in f_frsize units", 0},
-  {(char *)"f_bfree", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bfree, 0, (char *)"Free blocks", 0},
-  {(char *)"f_bavail", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bavail, 0, (char *)"Free blocks for non-root", 0},
-  {(char *)"f_files", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_files, 0, (char *)"Inodes", 0},
-  {(char *)"f_ffree", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_ffree, 0, (char *)"Free inodes", 0},
-  {(char *)"f_favail", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_favail, 0, (char *)"Free inodes for non-root", 0},
-  {(char *)"f_fsid", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_fsid, 0, (char *)"File system ID", 0},
-  {(char *)"f_flag", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_flag, 0, (char *)"File system mount flags.\n\n        This property is a bit mask with defined bits\n        ``LIBSSH2_SFTP_ST_RDONLY`` and ``LIBSSH2_SFTP_ST_NOSUID``", 0},
-  {(char *)"f_namemax", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_namemax, 0, (char *)"Maximum filename length", 0},
+  {(char *)"f_bsize", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bsize, 0, (char *)PyDoc_STR("File system block size"), 0},
+  {(char *)"f_frsize", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_frsize, 0, (char *)PyDoc_STR("Fragment size"), 0},
+  {(char *)"f_blocks", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_blocks, 0, (char *)PyDoc_STR("Size of fs in f_frsize units"), 0},
+  {(char *)"f_bfree", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bfree, 0, (char *)PyDoc_STR("Free blocks"), 0},
+  {(char *)"f_bavail", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_bavail, 0, (char *)PyDoc_STR("Free blocks for non-root"), 0},
+  {(char *)"f_files", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_files, 0, (char *)PyDoc_STR("Inodes"), 0},
+  {(char *)"f_ffree", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_ffree, 0, (char *)PyDoc_STR("Free inodes"), 0},
+  {(char *)"f_favail", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_favail, 0, (char *)PyDoc_STR("Free inodes for non-root"), 0},
+  {(char *)"f_fsid", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_fsid, 0, (char *)PyDoc_STR("File system ID"), 0},
+  {(char *)"f_flag", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_flag, 0, (char *)PyDoc_STR("File system mount flags.\n\n        This property is a bit mask with defined bits\n        ``LIBSSH2_SFTP_ST_RDONLY`` and ``LIBSSH2_SFTP_ST_NOSUID``"), 0},
+  {(char *)"f_namemax", __pyx_getprop_4ssh2_11sftp_handle_11SFTPStatVFS_f_namemax, 0, (char *)PyDoc_STR("Maximum filename length"), 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPStatVFS},
+  {Py_tp_doc, (void *)PyDoc_STR("File system statistics")},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_11sftp_handle_SFTPStatVFS},
+  {Py_tp_clear, (void *)__pyx_tp_clear_4ssh2_11sftp_handle_SFTPStatVFS},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_11sftp_handle_SFTPStatVFS},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_11sftp_handle_SFTPStatVFS},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_11sftp_handle_SFTPStatVFS},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS_spec = {
+  "ssh2.sftp_handle.SFTPStatVFS",
+  sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
+  __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp_handle.SFTPStatVFS", /*tp_name*/
+  "ssh2.sftp_handle.""SFTPStatVFS", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_11sftp_handle_SFTPStatVFS), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_11sftp_handle_SFTPStatVFS, /*tp_dealloc*/
@@ -9428,7 +12402,7 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  "File system statistics", /*tp_doc*/
+  PyDoc_STR("File system statistics"), /*tp_doc*/
   __pyx_tp_traverse_4ssh2_11sftp_handle_SFTPStatVFS, /*tp_traverse*/
   __pyx_tp_clear_4ssh2_11sftp_handle_SFTPStatVFS, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -9442,7 +12416,9 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_11sftp_handle_SFTPStatVFS, /*tp_new*/
@@ -9456,38 +12432,66 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
+#if CYTHON_USE_FREELISTS
 static struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex *__pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex[8];
 static int __pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex = 0;
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex)))) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  #if CYTHON_USE_FREELISTS
+  if (likely((int)(__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex)))) {
     o = (PyObject*)__pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex[--__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex];
     memset(o, 0, sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex));
     (void) PyObject_INIT(o, t);
     PyObject_GC_Track(o);
-  } else {
+  } else
+  #endif
+  {
     o = (*t->tp_alloc)(t, 0);
     if (unlikely(!o)) return 0;
   }
+  #endif
   return o;
 }
 
 static void __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex(PyObject *o) {
   struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex *p = (struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
   PyObject_GC_UnTrack(o);
   Py_CLEAR(p->__pyx_v_attrs);
   Py_CLEAR(p->__pyx_v_buf);
@@ -9495,10 +12499,20 @@ static void __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex(
   Py_CLEAR(p->__pyx_v_entryb);
   Py_CLEAR(p->__pyx_v_rc);
   Py_CLEAR(p->__pyx_v_self);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex)))) {
+  #if CYTHON_USE_FREELISTS
+  if (((int)(__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex)))) {
     __pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex[__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex++] = ((struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex *)o);
-  } else {
+  } else
+  #endif
+  {
+    #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
     (*Py_TYPE(o)->tp_free)(o);
+    #else
+    {
+      freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+      if (tp_free) tp_free(o);
+    }
+    #endif
   }
 }
 
@@ -9525,10 +12539,25 @@ static int __pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex(
   }
   return 0;
 }
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex_spec = {
+  "ssh2.sftp_handle.__pyx_scope_struct__readdir_ex",
+  sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
+  __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp_handle.__pyx_scope_struct__readdir_ex", /*tp_name*/
+  "ssh2.sftp_handle.""__pyx_scope_struct__readdir_ex", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex, /*tp_dealloc*/
@@ -9556,7 +12585,7 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_e
   0, /*tp_getattro*/
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
   0, /*tp_doc*/
   __pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex, /*tp_traverse*/
   0, /*tp_clear*/
@@ -9571,7 +12600,9 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_e
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex, /*tp_new*/
@@ -9585,47 +12616,85 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_e
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
+#if CYTHON_USE_FREELISTS
 static struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir *__pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir[8];
 static int __pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir = 0;
+#endif
 
 static PyObject *__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir)))) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  #if CYTHON_USE_FREELISTS
+  if (likely((int)(__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir)))) {
     o = (PyObject*)__pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir[--__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir];
     memset(o, 0, sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir));
     (void) PyObject_INIT(o, t);
     PyObject_GC_Track(o);
-  } else {
+  } else
+  #endif
+  {
     o = (*t->tp_alloc)(t, 0);
     if (unlikely(!o)) return 0;
   }
+  #endif
   return o;
 }
 
 static void __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir(PyObject *o) {
   struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir *p = (struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
   PyObject_GC_UnTrack(o);
   Py_CLEAR(p->__pyx_v_attrs);
   Py_CLEAR(p->__pyx_v_buf);
   Py_CLEAR(p->__pyx_v_rc);
   Py_CLEAR(p->__pyx_v_self);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir)))) {
+  #if CYTHON_USE_FREELISTS
+  if (((int)(__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir)))) {
     __pyx_freelist_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir[__pyx_freecount_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir++] = ((struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir *)o);
-  } else {
+  } else
+  #endif
+  {
+    #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
     (*Py_TYPE(o)->tp_free)(o);
+    #else
+    {
+      freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+      if (tp_free) tp_free(o);
+    }
+    #endif
   }
 }
 
@@ -9646,10 +12715,25 @@ static int __pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir(Py
   }
   return 0;
 }
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir_spec = {
+  "ssh2.sftp_handle.__pyx_scope_struct_1_readdir",
+  sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
+  __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.sftp_handle.__pyx_scope_struct_1_readdir", /*tp_name*/
+  "ssh2.sftp_handle.""__pyx_scope_struct_1_readdir", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir, /*tp_dealloc*/
@@ -9677,7 +12761,7 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir
   0, /*tp_getattro*/
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
   0, /*tp_doc*/
   __pyx_tp_traverse_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir, /*tp_traverse*/
   0, /*tp_clear*/
@@ -9692,7 +12776,9 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir, /*tp_new*/
@@ -9706,54 +12792,33 @@ static PyTypeObject __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_sftp_handle(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_sftp_handle},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "sftp_handle",
-    __pyx_k_SFTP_handle_attributes_and_stat, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -9763,46 +12828,110 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPAttributes, __pyx_k_SFTPAttributes, sizeof(__pyx_k_SFTPAttributes), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPHandle, __pyx_k_SFTPHandle, sizeof(__pyx_k_SFTPHandle), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPHandle_readdir, __pyx_k_SFTPHandle_readdir, sizeof(__pyx_k_SFTPHandle_readdir), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPHandle_readdir_ex, __pyx_k_SFTPHandle_readdir_ex, sizeof(__pyx_k_SFTPHandle_readdir_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPStatVFS, __pyx_k_SFTPStatVFS, sizeof(__pyx_k_SFTPStatVFS), 0, 0, 1, 1},
-  {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_kp_b__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 0, 0},
-  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
-  {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
-  {&__pyx_n_s_buffer_maxlen, __pyx_k_buffer_maxlen, sizeof(__pyx_k_buffer_maxlen), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_longentry_maxlen, __pyx_k_longentry_maxlen, sizeof(__pyx_k_longentry_maxlen), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1},
-  {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1},
-  {&__pyx_n_s_readdir_2, __pyx_k_readdir_2, sizeof(__pyx_k_readdir_2), 0, 0, 1, 1},
-  {&__pyx_n_s_readdir_ex, __pyx_k_readdir_ex, sizeof(__pyx_k_readdir_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_readdir_ex_2, __pyx_k_readdir_ex_2, sizeof(__pyx_k_readdir_ex_2), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1},
-  {&__pyx_n_s_setstat, __pyx_k_setstat, sizeof(__pyx_k_setstat), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_sftp, __pyx_k_sftp, sizeof(__pyx_k_sftp), 0, 0, 1, 1},
-  {&__pyx_n_s_sftp_ref, __pyx_k_sftp_ref, sizeof(__pyx_k_sftp_ref), 0, 0, 1, 1},
-  {&__pyx_n_s_ssh2_sftp_handle, __pyx_k_ssh2_sftp_handle, sizeof(__pyx_k_ssh2_sftp_handle), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPAttributes, __pyx_k_SFTPAttributes, sizeof(__pyx_k_SFTPAttributes), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPAttributes___reduce_cython, __pyx_k_SFTPAttributes___reduce_cython, sizeof(__pyx_k_SFTPAttributes___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPAttributes___setstate_cython, __pyx_k_SFTPAttributes___setstate_cython, sizeof(__pyx_k_SFTPAttributes___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle, __pyx_k_SFTPHandle, sizeof(__pyx_k_SFTPHandle), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle___enter, __pyx_k_SFTPHandle___enter, sizeof(__pyx_k_SFTPHandle___enter), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle___exit, __pyx_k_SFTPHandle___exit, sizeof(__pyx_k_SFTPHandle___exit), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle___reduce_cython, __pyx_k_SFTPHandle___reduce_cython, sizeof(__pyx_k_SFTPHandle___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle___setstate_cython, __pyx_k_SFTPHandle___setstate_cython, sizeof(__pyx_k_SFTPHandle___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle__readdir, __pyx_k_SFTPHandle__readdir, sizeof(__pyx_k_SFTPHandle__readdir), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle__readdir_ex, __pyx_k_SFTPHandle__readdir_ex, sizeof(__pyx_k_SFTPHandle__readdir_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_close, __pyx_k_SFTPHandle_close, sizeof(__pyx_k_SFTPHandle_close), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_fsetstat, __pyx_k_SFTPHandle_fsetstat, sizeof(__pyx_k_SFTPHandle_fsetstat), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_fstat, __pyx_k_SFTPHandle_fstat, sizeof(__pyx_k_SFTPHandle_fstat), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_fstat_ex, __pyx_k_SFTPHandle_fstat_ex, sizeof(__pyx_k_SFTPHandle_fstat_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_fstatvfs, __pyx_k_SFTPHandle_fstatvfs, sizeof(__pyx_k_SFTPHandle_fstatvfs), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_fsync, __pyx_k_SFTPHandle_fsync, sizeof(__pyx_k_SFTPHandle_fsync), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_read, __pyx_k_SFTPHandle_read, sizeof(__pyx_k_SFTPHandle_read), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_readdir, __pyx_k_SFTPHandle_readdir, sizeof(__pyx_k_SFTPHandle_readdir), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_readdir_ex, __pyx_k_SFTPHandle_readdir_ex, sizeof(__pyx_k_SFTPHandle_readdir_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_rewind, __pyx_k_SFTPHandle_rewind, sizeof(__pyx_k_SFTPHandle_rewind), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_seek, __pyx_k_SFTPHandle_seek, sizeof(__pyx_k_SFTPHandle_seek), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_seek64, __pyx_k_SFTPHandle_seek64, sizeof(__pyx_k_SFTPHandle_seek64), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_tell, __pyx_k_SFTPHandle_tell, sizeof(__pyx_k_SFTPHandle_tell), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_tell64, __pyx_k_SFTPHandle_tell64, sizeof(__pyx_k_SFTPHandle_tell64), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPHandle_write, __pyx_k_SFTPHandle_write, sizeof(__pyx_k_SFTPHandle_write), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPStatVFS, __pyx_k_SFTPStatVFS, sizeof(__pyx_k_SFTPStatVFS), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPStatVFS___reduce_cython, __pyx_k_SFTPStatVFS___reduce_cython, sizeof(__pyx_k_SFTPStatVFS___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPStatVFS___setstate_cython, __pyx_k_SFTPStatVFS___setstate_cython, sizeof(__pyx_k_SFTPStatVFS___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_kp_b__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 0, 0},
+    {&__pyx_n_s__45, __pyx_k__45, sizeof(__pyx_k__45), 0, 0, 1, 1},
+    {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_attrs, __pyx_k_attrs, sizeof(__pyx_k_attrs), 0, 0, 1, 1},
+    {&__pyx_n_s_b_longentry, __pyx_k_b_longentry, sizeof(__pyx_k_b_longentry), 0, 0, 1, 1},
+    {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_buffer_maxlen, __pyx_k_buffer_maxlen, sizeof(__pyx_k_buffer_maxlen), 0, 0, 1, 1},
+    {&__pyx_n_s_bytes_written, __pyx_k_bytes_written, sizeof(__pyx_k_bytes_written), 0, 0, 1, 1},
+    {&__pyx_n_s_cbuf, __pyx_k_cbuf, sizeof(__pyx_k_cbuf), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1},
+    {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1},
+    {&__pyx_n_s_entryb, __pyx_k_entryb, sizeof(__pyx_k_entryb), 0, 0, 1, 1},
+    {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1},
+    {&__pyx_n_s_fsetstat, __pyx_k_fsetstat, sizeof(__pyx_k_fsetstat), 0, 0, 1, 1},
+    {&__pyx_n_s_fstat, __pyx_k_fstat, sizeof(__pyx_k_fstat), 0, 0, 1, 1},
+    {&__pyx_n_s_fstat_ex, __pyx_k_fstat_ex, sizeof(__pyx_k_fstat_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_fstatvfs, __pyx_k_fstatvfs, sizeof(__pyx_k_fstatvfs), 0, 0, 1, 1},
+    {&__pyx_n_s_fsync, __pyx_k_fsync, sizeof(__pyx_k_fsync), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_longentry, __pyx_k_longentry, sizeof(__pyx_k_longentry), 0, 0, 1, 1},
+    {&__pyx_n_s_longentry_maxlen, __pyx_k_longentry_maxlen, sizeof(__pyx_k_longentry_maxlen), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_offset, __pyx_k_offset, sizeof(__pyx_k_offset), 0, 0, 1, 1},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1},
+    {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1},
+    {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1},
+    {&__pyx_n_s_readdir_2, __pyx_k_readdir_2, sizeof(__pyx_k_readdir_2), 0, 0, 1, 1},
+    {&__pyx_n_s_readdir_ex, __pyx_k_readdir_ex, sizeof(__pyx_k_readdir_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_readdir_ex_2, __pyx_k_readdir_ex_2, sizeof(__pyx_k_readdir_ex_2), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_rewind, __pyx_k_rewind, sizeof(__pyx_k_rewind), 0, 0, 1, 1},
+    {&__pyx_n_s_seek, __pyx_k_seek, sizeof(__pyx_k_seek), 0, 0, 1, 1},
+    {&__pyx_n_s_seek64, __pyx_k_seek64, sizeof(__pyx_k_seek64), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1},
+    {&__pyx_n_s_setstat, __pyx_k_setstat, sizeof(__pyx_k_setstat), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_sftp, __pyx_k_sftp, sizeof(__pyx_k_sftp), 0, 0, 1, 1},
+    {&__pyx_n_s_sftp_ref, __pyx_k_sftp_ref, sizeof(__pyx_k_sftp_ref), 0, 0, 1, 1},
+    {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_sftp_handle, __pyx_k_ssh2_sftp_handle, sizeof(__pyx_k_ssh2_sftp_handle), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_k_ssh2_sftp_handle_pyx, sizeof(__pyx_k_ssh2_sftp_handle_pyx), 0, 0, 1, 0},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_tell, __pyx_k_tell, sizeof(__pyx_k_tell), 0, 0, 1, 1},
+    {&__pyx_n_s_tell64, __pyx_k_tell64, sizeof(__pyx_k_tell64), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1},
+    {&__pyx_n_s_tot_size, __pyx_k_tot_size, sizeof(__pyx_k_tot_size), 0, 0, 1, 1},
+    {&__pyx_n_s_vfs, __pyx_k_vfs, sizeof(__pyx_k_vfs), 0, 0, 1, 1},
+    {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 41, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
@@ -9811,174 +12940,454 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(1, 3, __pyx_L1_error)
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/sftp_handle.pyx":135
+ *         return rc, data
+ * 
+ *     def __enter__(self):             # <<<<<<<<<<<<<<
+ *         return self
+ * 
  */
-  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__5);
-  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_enter, 135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 135, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "ssh2/sftp_handle.pyx":138
+ *         return self
+ * 
+ *     def __exit__(self, *args):             # <<<<<<<<<<<<<<
+ *         self.close()
+ * 
  */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
+  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_args); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_exit, 138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 138, __pyx_L1_error)
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+  /* "ssh2/sftp_handle.pyx":141
+ *         self.close()
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close handle. Called automatically when object is deleted
+ *         and/or garbage collected.
  */
-  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__7);
-  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_tuple__12 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_close, 141, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 141, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "ssh2/sftp_handle.pyx":155
+ *         return rc
+ * 
+ *     def read(self, size_t buffer_maxlen=c_ssh2.LIBSSH2_CHANNEL_WINDOW_DEFAULT):             # <<<<<<<<<<<<<<
+ *         """Read buffer from file handle.
+ * 
  */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  __pyx_tuple__14 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_buffer_maxlen, __pyx_n_s_rc, __pyx_n_s_buf, __pyx_n_s_cbuf); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_read, 155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 155, __pyx_L1_error)
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
+  /* "ssh2/sftp_handle.pyx":180
+ *         return rc, buf
+ * 
+ *     def readdir_ex(self,             # <<<<<<<<<<<<<<
+ *                    size_t longentry_maxlen=1024,
+ *                    size_t buffer_maxlen=1024):
+ */
+  __pyx_tuple__16 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_longentry_maxlen, __pyx_n_s_buffer_maxlen, __pyx_n_s_rc, __pyx_n_s_buf, __pyx_n_s_entry, __pyx_n_s_attrs, __pyx_n_s_entryb); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_readdir_ex, 180, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __pyx_tuple__17 = PyTuple_Pack(2, __pyx_int_1024, __pyx_int_1024); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
 
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+  /* "ssh2/sftp_handle.pyx":203
+ *                 buffer_maxlen=buffer_maxlen)
+ * 
+ *     def _readdir_ex(self,             # <<<<<<<<<<<<<<
+ *                     size_t longentry_maxlen=1024,
+ *                     size_t buffer_maxlen=1024):
+ */
+  __pyx_tuple__18 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_longentry_maxlen, __pyx_n_s_buffer_maxlen, __pyx_n_s_buf, __pyx_n_s_b_longentry, __pyx_n_s_cbuf, __pyx_n_s_longentry, __pyx_n_s_attrs, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_readdir_ex_2, 203, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 203, __pyx_L1_error)
 
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/sftp_handle.pyx":229
+ *         return rc, buf, b_longentry, attrs
+ * 
+ *     def readdir(self, size_t buffer_maxlen=1024):             # <<<<<<<<<<<<<<
+ *         """Get directory listing from file handle, if any.
+ * 
+ */
+  __pyx_tuple__20 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_buffer_maxlen, __pyx_n_s_rc, __pyx_n_s_buf, __pyx_n_s_attrs); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_readdir, 229, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_int_1024); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
 
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  /* "ssh2/sftp_handle.pyx":244
+ *             rc, buf, attrs = self._readdir(buffer_maxlen)
+ * 
+ *     def _readdir(self,             # <<<<<<<<<<<<<<
+ *                  size_t buffer_maxlen=1024):
+ *         cdef bytes buf = b''
+ */
+  __pyx_tuple__22 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_buffer_maxlen, __pyx_n_s_buf, __pyx_n_s_cbuf, __pyx_n_s_attrs, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+  __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_readdir_2, 244, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 244, __pyx_L1_error)
 
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  if (__Pyx_ExportFunction("PySFTPHandle", (void (*)(void))__pyx_f_4ssh2_11sftp_handle_PySFTPHandle, "PyObject *(LIBSSH2_SFTP_HANDLE *, struct __pyx_obj_4ssh2_4sftp_SFTP *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  /* "ssh2/sftp_handle.pyx":263
+ *         return rc, buf, attrs
+ * 
+ *     def write(self, bytes buf):             # <<<<<<<<<<<<<<
+ *         """Write buffer to file handle.
+ * 
+ */
+  __pyx_tuple__24 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_buf, __pyx_n_s_size, __pyx_n_s_tot_size, __pyx_n_s_bytes_written, __pyx_n_s_cbuf, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+  __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_write, 263, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 263, __pyx_L1_error)
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /* "ssh2/sftp_handle.pyx":300
+ *         return rc, bytes_written
+ * 
+ *     def fsync(self):             # <<<<<<<<<<<<<<
+ *         """Sync file handle data.
+ * 
+ */
+  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_fsync, 300, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 300, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":309
+ *         return handle_error_codes(rc)
+ * 
+ *     def seek(self, size_t offset):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use seek64.
+ * 
+ */
+  __pyx_tuple__27 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_offset); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_seek, 309, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 309, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":321
+ *             c_sftp.libssh2_sftp_seek(self._handle, offset)
+ * 
+ *     def seek64(self, c_ssh2.libssh2_uint64_t offset):             # <<<<<<<<<<<<<<
+ *         """Seek file to given 64-bit offset.
+ * 
+ */
+  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_seek64, 321, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 321, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":331
+ *             c_sftp.libssh2_sftp_seek64(self._handle, offset)
+ * 
+ *     def rewind(self):             # <<<<<<<<<<<<<<
+ *         """Rewind file handle to beginning of file.
+ * 
+ */
+  __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_rewind, 331, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 331, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":338
+ *             c_sftp.libssh2_sftp_rewind(self._handle)
+ * 
+ *     def tell(self):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use tell64.
+ * 
+ */
+  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_tell, 338, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 338, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":349
+ *         return handle_error_codes(rc)
+ * 
+ *     def tell64(self):             # <<<<<<<<<<<<<<
+ *         """Get current file handle 64-bit offset.
+ * 
+ */
+  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_tell64, 349, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 349, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":358
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstat_ex(self, SFTPAttributes attrs, int setstat):             # <<<<<<<<<<<<<<
+ *         """Get or set file attributes. Clients would typically use one of the
+ *         fstat or fsetstat functions instead"""
+ */
+  __pyx_tuple__33 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_attrs, __pyx_n_s_setstat, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 358, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_fstat_ex, 358, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 358, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":367
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstat(self):             # <<<<<<<<<<<<<<
+ *         """Get file stat attributes from handle.
+ * 
+ */
+  __pyx_tuple__35 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_rc, __pyx_n_s_attrs); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_fstat, 367, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 367, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":379
+ *         return attrs
+ * 
+ *     def fsetstat(self, SFTPAttributes attrs):             # <<<<<<<<<<<<<<
+ *         """Set file handle attributes.
+ * 
+ */
+  __pyx_tuple__37 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_attrs, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 379, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__37);
+  __Pyx_GIVEREF(__pyx_tuple__37);
+  __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_fsetstat, 379, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 379, __pyx_L1_error)
+
+  /* "ssh2/sftp_handle.pyx":389
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstatvfs(self):             # <<<<<<<<<<<<<<
+ *         """Get file system statistics for handle
+ * 
+ */
+  __pyx_tuple__39 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_vfs, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+  __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_sftp_handle_pyx, __pyx_n_s_fstatvfs, 389, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 389, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(1, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(1, 3, __pyx_L1_error)
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(1, 1, __pyx_L1_error)
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+/* #### Code section: init_constants ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
+
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  if (__Pyx_ExportFunction("PySFTPHandle", (void (*)(void))__pyx_f_4ssh2_11sftp_handle_PySFTPHandle, "PyObject *(LIBSSH2_SFTP_HANDLE *, struct __pyx_obj_4ssh2_4sftp_SFTP *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_11sftp_handle_SFTPHandle.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_11sftp_handle_SFTPHandle.tp_dictoffset && __pyx_type_4ssh2_11sftp_handle_SFTPHandle.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_11sftp_handle_SFTPHandle.tp_getattro = __Pyx_PyObject_GenericGetAttr;
-  }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPHandle, (PyObject *)&__pyx_type_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_11sftp_handle_SFTPHandle_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle)) __PYX_ERR(0, 111, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_11sftp_handle_SFTPHandle_spec, __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle = &__pyx_type_4ssh2_11sftp_handle_SFTPHandle;
-  if (PyType_Ready(&__pyx_type_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_11sftp_handle_SFTPAttributes.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_11sftp_handle_SFTPAttributes.tp_dictoffset && __pyx_type_4ssh2_11sftp_handle_SFTPAttributes.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_11sftp_handle_SFTPAttributes.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle->tp_dictoffset && __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPAttributes, (PyObject *)&__pyx_type_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPHandle, (PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPHandle) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_11sftp_handle_SFTPAttributes_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes)) __PYX_ERR(0, 33, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_11sftp_handle_SFTPAttributes_spec, __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes = &__pyx_type_4ssh2_11sftp_handle_SFTPAttributes;
-  if (PyType_Ready(&__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS.tp_dictoffset && __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_11sftp_handle_SFTPStatVFS.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes->tp_dictoffset && __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPStatVFS, (PyObject *)&__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPAttributes, (PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPAttributes) < 0) __PYX_ERR(0, 33, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS)) __PYX_ERR(0, 402, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS_spec, __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS = &__pyx_type_4ssh2_11sftp_handle_SFTPStatVFS;
-  if (PyType_Ready(&__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex.tp_dictoffset && __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS->tp_dictoffset && __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SFTPStatVFS, (PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_11sftp_handle_SFTPStatVFS) < 0) __PYX_ERR(0, 402, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex)) __PYX_ERR(0, 180, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex_spec, __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex = &__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex;
-  if (PyType_Ready(&__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir.tp_dictoffset && __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex->tp_dictoffset && __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct__readdir_ex->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
   }
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir)) __PYX_ERR(0, 229, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir_spec, __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  #else
   __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir = &__pyx_type_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir->tp_dictoffset && __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_11sftp_handle___pyx_scope_struct_1_readdir->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -9996,15 +13405,12 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(2, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(2, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = PyImport_ImportModule("ssh2.sftp"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 26, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(3, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_4sftp_SFTP = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.sftp", "SFTP", sizeof(struct __pyx_obj_4ssh2_4sftp_SFTP), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_4sftp_SFTP),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_4sftp_SFTP) __PYX_ERR(3, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -10032,7 +13438,7 @@ static int __Pyx_modinit_function_import_code(void) {
   /*--- Function import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.utils"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_ImportFunction(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_ImportFunction_3_0_11(__pyx_t_1, "handle_error_codes", (void (**)(void))&__pyx_f_4ssh2_5utils_handle_error_codes, "int (int, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -10043,6 +13449,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_sftp_handle(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_sftp_handle},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "sftp_handle",
+      __pyx_k_SFTP_handle_attributes_and_stat, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -10093,12 +13548,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -10108,8 +13572,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -10119,8 +13584,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -10136,7 +13605,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_sftp_handle(PyObject *__pyx_pyinit
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -10150,6 +13625,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_sftp_handle(PyObject *__pyx_pyinit
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("sftp_handle", __pyx_methods, __pyx_k_SFTP_handle_attributes_and_stat, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "sftp_handle" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -10160,7 +13662,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_sftp_handle(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -10168,48 +13670,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("sftp_handle", __pyx_methods, __pyx_k_SFTP_handle_attributes_and_stat, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -10221,7 +13706,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.sftp_handle")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.sftp_handle", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.sftp_handle", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -10232,16 +13717,76 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
-  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   /*--- Execution code ---*/
   #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
 
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_14SFTPAttributes_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPAttributes___reduce_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_14SFTPAttributes_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPAttributes___setstate_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "ssh2/sftp_handle.pyx":135
+ *         return rc, data
+ * 
+ *     def __enter__(self):             # <<<<<<<<<<<<<<
+ *         return self
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_9__enter__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle___enter, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_enter, __pyx_t_2) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":138
+ *         return self
+ * 
+ *     def __exit__(self, *args):             # <<<<<<<<<<<<<<
+ *         self.close()
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_11__exit__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle___exit, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_exit, __pyx_t_2) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":141
+ *         self.close()
+ * 
+ *     def close(self):             # <<<<<<<<<<<<<<
+ *         """Close handle. Called automatically when object is deleted
+ *         and/or garbage collected.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_13close, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_close, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_close, __pyx_t_2) < 0) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
   /* "ssh2/sftp_handle.pyx":155
  *         return rc
  * 
@@ -10249,28 +13794,294 @@ if (!__Pyx_RefNanny) {
  *         """Read buffer from file handle.
  * 
  */
-  __pyx_k__3 = LIBSSH2_CHANNEL_WINDOW_DEFAULT;
+  __pyx_k_ = LIBSSH2_CHANNEL_WINDOW_DEFAULT;
+  __pyx_t_2 = __Pyx_PyInt_From___pyx_anon_enum(LIBSSH2_CHANNEL_WINDOW_DEFAULT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_15read, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_read, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_read, __pyx_t_2) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":180
+ *         return rc, buf
+ * 
+ *     def readdir_ex(self,             # <<<<<<<<<<<<<<
+ *                    size_t longentry_maxlen=1024,
+ *                    size_t buffer_maxlen=1024):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_17readdir_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_readdir_ex, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__17);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_readdir_ex, __pyx_t_2) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":203
+ *                 buffer_maxlen=buffer_maxlen)
+ * 
+ *     def _readdir_ex(self,             # <<<<<<<<<<<<<<
+ *                     size_t longentry_maxlen=1024,
+ *                     size_t buffer_maxlen=1024):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_20_readdir_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle__readdir_ex, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__17);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_readdir_ex_2, __pyx_t_2) < 0) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":229
+ *         return rc, buf, b_longentry, attrs
+ * 
+ *     def readdir(self, size_t buffer_maxlen=1024):             # <<<<<<<<<<<<<<
+ *         """Get directory listing from file handle, if any.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_22readdir, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_readdir, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__21);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_readdir, __pyx_t_2) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":244
+ *             rc, buf, attrs = self._readdir(buffer_maxlen)
+ * 
+ *     def _readdir(self,             # <<<<<<<<<<<<<<
+ *                  size_t buffer_maxlen=1024):
+ *         cdef bytes buf = b''
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_25_readdir, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle__readdir, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__21);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_readdir_2, __pyx_t_2) < 0) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":263
+ *         return rc, buf, attrs
+ * 
+ *     def write(self, bytes buf):             # <<<<<<<<<<<<<<
+ *         """Write buffer to file handle.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_27write, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_write, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_write, __pyx_t_2) < 0) __PYX_ERR(0, 263, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":300
+ *         return rc, bytes_written
+ * 
+ *     def fsync(self):             # <<<<<<<<<<<<<<
+ *         """Sync file handle data.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_29fsync, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_fsync, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 300, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_fsync, __pyx_t_2) < 0) __PYX_ERR(0, 300, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":309
+ *         return handle_error_codes(rc)
+ * 
+ *     def seek(self, size_t offset):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use seek64.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_31seek, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_seek, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_seek, __pyx_t_2) < 0) __PYX_ERR(0, 309, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":321
+ *             c_sftp.libssh2_sftp_seek(self._handle, offset)
+ * 
+ *     def seek64(self, c_ssh2.libssh2_uint64_t offset):             # <<<<<<<<<<<<<<
+ *         """Seek file to given 64-bit offset.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_33seek64, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_seek64, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_seek64, __pyx_t_2) < 0) __PYX_ERR(0, 321, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":331
+ *             c_sftp.libssh2_sftp_seek64(self._handle, offset)
+ * 
+ *     def rewind(self):             # <<<<<<<<<<<<<<
+ *         """Rewind file handle to beginning of file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_35rewind, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_rewind, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_rewind, __pyx_t_2) < 0) __PYX_ERR(0, 331, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":338
+ *             c_sftp.libssh2_sftp_rewind(self._handle)
+ * 
+ *     def tell(self):             # <<<<<<<<<<<<<<
+ *         """Deprecated, use tell64.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_37tell, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_tell, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_tell, __pyx_t_2) < 0) __PYX_ERR(0, 338, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":349
+ *         return handle_error_codes(rc)
+ * 
+ *     def tell64(self):             # <<<<<<<<<<<<<<
+ *         """Get current file handle 64-bit offset.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_39tell64, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_tell64, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 349, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_tell64, __pyx_t_2) < 0) __PYX_ERR(0, 349, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":358
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstat_ex(self, SFTPAttributes attrs, int setstat):             # <<<<<<<<<<<<<<
+ *         """Get or set file attributes. Clients would typically use one of the
+ *         fstat or fsetstat functions instead"""
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_41fstat_ex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_fstat_ex, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_fstat_ex, __pyx_t_2) < 0) __PYX_ERR(0, 358, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":367
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstat(self):             # <<<<<<<<<<<<<<
+ *         """Get file stat attributes from handle.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_43fstat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_fstat, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_fstat, __pyx_t_2) < 0) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":379
+ *         return attrs
+ * 
+ *     def fsetstat(self, SFTPAttributes attrs):             # <<<<<<<<<<<<<<
+ *         """Set file handle attributes.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_45fsetstat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_fsetstat, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_fsetstat, __pyx_t_2) < 0) __PYX_ERR(0, 379, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "ssh2/sftp_handle.pyx":389
+ *         return handle_error_codes(rc)
+ * 
+ *     def fstatvfs(self):             # <<<<<<<<<<<<<<
+ *         """Get file system statistics for handle
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_47fstatvfs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle_fstatvfs, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle, __pyx_n_s_fstatvfs, __pyx_t_2) < 0) __PYX_ERR(0, 389, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_4ssh2_11sftp_handle_SFTPHandle);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_49__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle___reduce_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_10SFTPHandle_51__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPHandle___setstate_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_11SFTPStatVFS_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPStatVFS___reduce_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_11sftp_handle_11SFTPStatVFS_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SFTPStatVFS___setstate_cython, NULL, __pyx_n_s_ssh2_sftp_handle, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/sftp_handle.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.sftp_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.sftp_handle");
   }
@@ -10284,6 +14095,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -10303,9 +14130,111 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
     PyTypeObject* tp = Py_TYPE(obj);
     if (likely(tp->tp_getattro))
         return tp->tp_getattro(obj, attr_name);
@@ -10317,10 +14246,39 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -10331,6 +14289,231 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
     return result;
 }
 
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
 /* RaiseArgTupleInvalid */
 static void __Pyx_RaiseArgtupleInvalid(
     const char* func_name,
@@ -10359,25 +14542,58 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 /* KeywordStringCheck */
 static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict,
+    PyObject *kw,
     const char* function_name,
     int kw_allowed)
 {
     PyObject* key = 0;
     Py_ssize_t pos = 0;
 #if CYTHON_COMPILING_IN_PYPY
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
         goto invalid_keyword;
     return 1;
 #else
-    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
         #if PY_MAJOR_VERSION < 3
         if (unlikely(!PyString_Check(key)))
         #endif
             if (unlikely(!PyUnicode_Check(key)))
                 goto invalid_keyword_type;
     }
-    if ((!kw_allowed) && unlikely(key))
+    if (!kw_allowed && unlikely(key))
         goto invalid_keyword;
     return 1;
 invalid_keyword_type:
@@ -10386,66 +14602,23 @@ static int __Pyx_CheckKeywordStrings(
     return 0;
 #endif
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
     return 0;
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -10578,13 +14751,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -10592,6 +14761,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -10617,6 +14792,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -10627,13 +14803,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
-        while (*name && (**name != key)) name++;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -10641,6 +14858,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -10661,14 +14881,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -10695,6 +14919,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -10704,33 +14930,43 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
 /* ExtTypeTest */
 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    __Pyx_TypeName obj_type_name;
+    __Pyx_TypeName type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
     }
     if (likely(__Pyx_TypeCheck(obj, type)))
         return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    type_name = __Pyx_PyType_GetName(type);
+    PyErr_Format(PyExc_TypeError,
+                 "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME,
+                 obj_type_name, type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
     return 0;
 }
 
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
 static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
@@ -10759,7 +14995,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -10775,9 +15010,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -10846,6 +15087,30 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
 #endif
 
 /* PyObjectCallMethO */
@@ -10853,10 +15118,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -10868,90 +15138,83 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallNoArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
     }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
 #endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
             return __Pyx_PyObject_CallMethO(func, NULL);
-        }
     }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
-}
-#endif
-
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
     }
-}
 #endif
-
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
     if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
     }
-#endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
-#endif
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
         }
+        #endif
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
-}
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
 }
-#endif
 
 /* RaiseTooManyValuesToUnpack */
 static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
@@ -10968,37 +15231,17 @@ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
 
 /* IterFinish */
 static CYTHON_INLINE int __Pyx_IterFinish(void) {
-#if CYTHON_FAST_THREAD_STATE
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject* exc_type = tstate->curexc_type;
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
     if (unlikely(exc_type)) {
-        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
-            PyObject *exc_value, *exc_tb;
-            exc_value = tstate->curexc_value;
-            exc_tb = tstate->curexc_traceback;
-            tstate->curexc_type = 0;
-            tstate->curexc_value = 0;
-            tstate->curexc_traceback = 0;
-            Py_DECREF(exc_type);
-            Py_XDECREF(exc_value);
-            Py_XDECREF(exc_tb);
-            return 0;
-        } else {
-            return -1;
-        }
-    }
-    return 0;
-#else
-    if (unlikely(PyErr_Occurred())) {
-        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
-            PyErr_Clear();
-            return 0;
-        } else {
+        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
             return -1;
-        }
+        __Pyx_PyErr_Clear();
+        return 0;
     }
     return 0;
-#endif
 }
 
 /* UnpackItemEndCheck */
@@ -11007,9 +15250,18 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
         Py_DECREF(retval);
         __Pyx_RaiseTooManyValuesError(expected);
         return -1;
-    } else {
-        return __Pyx_IterFinish();
     }
+    return __Pyx_IterFinish();
+}
+
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
@@ -11020,20 +15272,32 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject
 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #endif
 {
-    PyObject *local_type, *local_value, *local_tb;
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
 #if CYTHON_FAST_THREAD_STATE
     PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
     local_type = tstate->curexc_type;
     local_value = tstate->curexc_value;
     local_tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
+  #endif
 #else
     PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
     if (unlikely(tstate->curexc_type))
 #else
     if (unlikely(PyErr_Occurred()))
@@ -11055,12 +15319,21 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
     #if CYTHON_USE_EXC_INFO_STACK
     {
         _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
         tmp_type = exc_info->exc_type;
         tmp_value = exc_info->exc_value;
         tmp_tb = exc_info->exc_traceback;
         exc_info->exc_type = local_type;
         exc_info->exc_value = local_value;
         exc_info->exc_traceback = local_tb;
+      #endif
     }
     #else
     tmp_type = tstate->exc_type;
@@ -11091,7 +15364,26 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
     tmp_type = exc_info->exc_type;
     tmp_value = exc_info->exc_value;
@@ -11099,14 +15391,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
     exc_info->exc_type = *type;
     exc_info->exc_value = *value;
     exc_info->exc_traceback = *tb;
-    #else
+  #else
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
-    #endif
+  #endif
     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
@@ -11123,12 +15415,12 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 #endif
 
 /* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem *
 __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 {
     _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
            exc_info->previous_item != NULL)
     {
         exc_info = exc_info->previous_item;
@@ -11140,21 +15432,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 /* SaveResetException */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
     *type = exc_info->exc_type;
     *value = exc_info->exc_value;
     *tb = exc_info->exc_traceback;
-    #else
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
-    #endif
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
+  #endif
 }
 static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     #if CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -11175,41 +15492,51 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+  #endif
 }
 #endif
 
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
-    }
+/* pep479 */
+static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) {
+    PyObject *exc, *val, *tb, *cur_exc;
+    __Pyx_PyThreadState_declare
+    #ifdef __Pyx_StopAsyncIteration_USED
+    int is_async_stopiteration = 0;
     #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
+    CYTHON_MAYBE_UNUSED_VAR(in_async_gen);
+    cur_exc = PyErr_Occurred();
+    if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) {
+        #ifdef __Pyx_StopAsyncIteration_USED
+        if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, __Pyx_PyExc_StopAsyncIteration))) {
+            is_async_stopiteration = 1;
+        } else
+        #endif
+            return;
     }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
+    __Pyx_PyThreadState_assign
+    __Pyx_GetException(&exc, &val, &tb);
+    Py_XDECREF(exc);
+    Py_XDECREF(val);
+    Py_XDECREF(tb);
+    PyErr_SetString(PyExc_RuntimeError,
+        #ifdef __Pyx_StopAsyncIteration_USED
+        is_async_stopiteration ? "async generator raised StopAsyncIteration" :
+        in_async_gen ? "async generator raised StopIteration" :
+        #endif
+        "generator raised StopIteration");
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -11222,114 +15549,437 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
 #else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
 #endif
-    return NULL;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
         }
+        if (changed)
+            PyType_Modified(type);
     }
-    return descr;
-}
 #endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+    return 0;
 }
 #endif
 
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
-    }
-#endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
     }
+#endif
+    *method = attr;
     return 0;
 }
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
 }
 #endif
 
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
     }
+    return descr;
+}
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
     }
-    return result;
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
 }
+#endif
 
 /* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
   int ret;
   PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
   if (likely(name_attr)) {
       ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
   } else {
@@ -11361,134 +16011,1339 @@ static int __Pyx_setup_reduce(PyObject* type_obj) {
         goto __PYX_BAD;
     }
 #endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
+{
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
-        }
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
-        }
-    }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    0,
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    offsetof(PyCFunctionObject, m_weakreflist),
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
-        }
-    }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
 #endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
-    return ret;
-}
-
-/* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
-{
-    PyObject *result = 0;
-    char warning[200];
-    Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
-    PyObject *py_basicsize;
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
 #endif
-    result = PyObject_GetAttrString(module, class_name);
-    if (!result)
-        goto bad;
-    if (!PyType_Check(result)) {
-        PyErr_Format(PyExc_TypeError,
-            "%.200s.%.200s is not a type object",
-            module_name, class_name);
-        goto bad;
-    }
-#ifndef Py_LIMITED_API
-    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
 #else
-    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
-    if (!py_basicsize)
-        goto bad;
-    basicsize = PyLong_AsSsize_t(py_basicsize);
-    Py_DECREF(py_basicsize);
-    py_basicsize = 0;
-    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
-        goto bad;
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
 #endif
-    if ((size_t)basicsize < size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
-    }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
-        PyErr_Format(PyExc_ValueError,
-            "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        goto bad;
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return (PyTypeObject *)result;
-bad:
-    Py_XDECREF(result);
-    return NULL;
+    return op;
 }
-#endif
 
 /* PyDictVersioning */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -11518,12 +17373,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -11537,7 +17393,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -11559,6 +17415,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -11637,17 +17494,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -11682,6 +17623,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -11697,7 +17639,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -11744,6 +17686,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -11780,7 +17723,7 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(unsigned long) < sizeof(long)) {
+        if ((sizeof(unsigned long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -11789,168 +17732,239 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) {
             }
             return (unsigned long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned long) -1;
+        val = __Pyx_PyInt_As_unsigned_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (unsigned long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (unsigned long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(unsigned long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (unsigned long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(unsigned long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) (((unsigned long)-1)*(((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT)) {
                             return (unsigned long) ((((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(unsigned long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
+        if ((sizeof(unsigned long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(unsigned long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            unsigned long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned long) 1) << (sizeof(unsigned long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (unsigned long) -1;
-        }
-    } else {
-        unsigned long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (unsigned long) -1;
-        val = __Pyx_PyInt_As_unsigned_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -11976,7 +17990,7 @@ static CYTHON_INLINE libssh2_uint64_t __Pyx_PyInt_As_libssh2_uint64_t(PyObject *
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(libssh2_uint64_t) < sizeof(long)) {
+        if ((sizeof(libssh2_uint64_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -11985,168 +17999,239 @@ static CYTHON_INLINE libssh2_uint64_t __Pyx_PyInt_As_libssh2_uint64_t(PyObject *
             }
             return (libssh2_uint64_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        libssh2_uint64_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (libssh2_uint64_t) -1;
+        val = __Pyx_PyInt_As_libssh2_uint64_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (libssh2_uint64_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) >= 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (libssh2_uint64_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (libssh2_uint64_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(libssh2_uint64_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(libssh2_uint64_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(libssh2_uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(libssh2_uint64_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (libssh2_uint64_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(libssh2_uint64_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((((libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) (((libssh2_uint64_t)-1)*(((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(libssh2_uint64_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(libssh2_uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(libssh2_uint64_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (libssh2_uint64_t) ((((((((((libssh2_uint64_t)digits[3]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[2]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[1]) << PyLong_SHIFT) | (libssh2_uint64_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(libssh2_uint64_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, long, PyLong_AsLong(x))
+        if ((sizeof(libssh2_uint64_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(libssh2_uint64_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(libssh2_uint64_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(libssh2_uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        libssh2_uint64_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (libssh2_uint64_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            libssh2_uint64_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (libssh2_uint64_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (libssh2_uint64_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (libssh2_uint64_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(libssh2_uint64_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((libssh2_uint64_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(libssh2_uint64_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((libssh2_uint64_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((libssh2_uint64_t) 1) << (sizeof(libssh2_uint64_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (libssh2_uint64_t) -1;
-        }
-    } else {
-        libssh2_uint64_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (libssh2_uint64_t) -1;
-        val = __Pyx_PyInt_As_libssh2_uint64_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -12172,7 +18257,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(size_t) < sizeof(long)) {
+        if ((sizeof(size_t) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -12181,168 +18266,239 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
             }
             return (size_t) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
                             return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
                             return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
                             return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (size_t) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (size_t) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(size_t) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (size_t) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
                             return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
                             return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
                             return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(size_t) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+        if ((sizeof(size_t) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        size_t val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (size_t) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            size_t val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (size_t) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (size_t) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (size_t) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((size_t) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((size_t) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (size_t) -1;
-        }
-    } else {
-        size_t val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (size_t) -1;
-        val = __Pyx_PyInt_As_size_t(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -12355,6 +18511,77 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
     return (size_t) -1;
 }
 
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From___pyx_anon_enum(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
 /* CIntFromPy */
 static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #ifdef __Pyx_HAS_GCC_DIAGNOSTIC
@@ -12368,7 +18595,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -12377,168 +18604,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -12582,10 +18880,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -12620,10 +18951,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_libssh2_uint64_t(libssh2_uint64_
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(libssh2_uint64_t),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(libssh2_uint64_t));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -12658,12 +19022,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__45);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -12696,10 +19109,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -12716,7 +19162,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -12725,168 +19171,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -12903,7 +19420,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -12924,6 +19441,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -12948,11 +19481,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -12999,148 +19532,28 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 }
 #endif
 
-/* FetchCommonType */
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
-    PyObject* fake_module;
-    PyTypeObject* cached_type = NULL;
-    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
-    if (!fake_module) return NULL;
-    Py_INCREF(fake_module);
-    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
-    if (cached_type) {
-        if (!PyType_Check((PyObject*)cached_type)) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s is not a type object",
-                type->tp_name);
-            goto bad;
-        }
-        if (cached_type->tp_basicsize != type->tp_basicsize) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s has the wrong size, try recompiling",
-                type->tp_name);
-            goto bad;
-        }
-    } else {
-        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
-        PyErr_Clear();
-        if (PyType_Ready(type) < 0) goto bad;
-        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
-            goto bad;
-        Py_INCREF(type);
-        cached_type = type;
-    }
-done:
-    Py_DECREF(fake_module);
-    return cached_type;
-bad:
-    Py_XDECREF(cached_type);
-    cached_type = NULL;
-    goto done;
-}
-
-/* PyObjectGetMethod */
-static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
-    PyObject *attr;
-#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
-    PyTypeObject *tp = Py_TYPE(obj);
-    PyObject *descr;
-    descrgetfunc f = NULL;
-    PyObject **dictptr, *dict;
-    int meth_found = 0;
-    assert (*method == NULL);
-    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
-        attr = __Pyx_PyObject_GetAttrStr(obj, name);
-        goto try_unpack;
-    }
-    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
-        return 0;
-    }
-    descr = _PyType_Lookup(tp, name);
-    if (likely(descr != NULL)) {
-        Py_INCREF(descr);
-#if PY_MAJOR_VERSION >= 3
-        #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
-        #else
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type)))
-        #endif
-#else
-        #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
-        #else
-        if (likely(PyFunction_Check(descr)))
-        #endif
-#endif
-        {
-            meth_found = 1;
-        } else {
-            f = Py_TYPE(descr)->tp_descr_get;
-            if (f != NULL && PyDescr_IsData(descr)) {
-                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
-                Py_DECREF(descr);
-                goto try_unpack;
-            }
-        }
-    }
-    dictptr = _PyObject_GetDictPtr(obj);
-    if (dictptr != NULL && (dict = *dictptr) != NULL) {
-        Py_INCREF(dict);
-        attr = __Pyx_PyDict_GetItemStr(dict, name);
-        if (attr != NULL) {
-            Py_INCREF(attr);
-            Py_DECREF(dict);
-            Py_XDECREF(descr);
-            goto try_unpack;
-        }
-        Py_DECREF(dict);
-    }
-    if (meth_found) {
-        *method = descr;
-        return 1;
-    }
-    if (f != NULL) {
-        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
-        Py_DECREF(descr);
-        goto try_unpack;
-    }
-    if (descr != NULL) {
-        *method = descr;
-        return 0;
-    }
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(name));
-#endif
-    return 0;
-#else
-    attr = __Pyx_PyObject_GetAttrStr(obj, name);
-    goto try_unpack;
-#endif
-try_unpack:
-#if CYTHON_UNPACK_METHODS
-    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
-        PyObject *function = PyMethod_GET_FUNCTION(attr);
-        Py_INCREF(function);
-        Py_DECREF(attr);
-        *method = function;
-        return 1;
-    }
-#endif
-    *method = attr;
-    return 0;
+/* PyObjectCall2Args */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args[3] = {NULL, arg1, arg2};
+    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
 /* PyObjectCallMethod1 */
+#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2)
 static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
     PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
     Py_DECREF(method);
     return result;
 }
+#endif
 static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2
+    PyObject *args[2] = {obj, arg};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_Call2Args;
+    return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
     PyObject *method = NULL, *result;
     int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
     if (likely(is_method)) {
@@ -13150,10 +19563,10 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name
     }
     if (unlikely(!method)) return NULL;
     return __Pyx__PyObject_CallMethod1(method, arg);
+#endif
 }
 
 /* CoroutineBase */
-#include <structmember.h>
 #include <frameobject.h>
 #if PY_VERSION_HEX >= 0x030b00a6
   #ifndef Py_BUILD_CORE
@@ -13162,9 +19575,10 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name
   #include "internal/pycore_frame.h"
 #endif
 #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom)
-static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) {
+static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) {
     PyObject *et, *ev, *tb;
     PyObject *value = NULL;
+    CYTHON_UNUSED_VAR(__pyx_tstate);
     __Pyx_ErrFetch(&et, &ev, &tb);
     if (!et) {
         Py_XDECREF(tb);
@@ -13179,7 +19593,7 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p
             value = Py_None;
         }
 #if PY_VERSION_HEX >= 0x030300A0
-        else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) {
+        else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) {
             value = ((PyStopIterationObject *)ev)->value;
             Py_INCREF(value);
             Py_DECREF(ev);
@@ -13243,6 +19657,9 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p
 }
 static CYTHON_INLINE
 void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_CLEAR(exc_state->exc_value);
+#else
     PyObject *t, *v, *tb;
     t = exc_state->exc_type;
     v = exc_state->exc_value;
@@ -13253,10 +19670,12 @@ void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
     Py_XDECREF(t);
     Py_XDECREF(v);
     Py_XDECREF(tb);
+#endif
 }
 #define __Pyx_Coroutine_AlreadyRunningError(gen)  (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL)
-static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) {
+static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) {
     const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if ((0)) {
     #ifdef __Pyx_Coroutine_USED
     } else if (__Pyx_Coroutine_Check((PyObject*)gen)) {
@@ -13272,8 +19691,9 @@ static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineOb
     PyErr_SetString(PyExc_ValueError, msg);
 }
 #define __Pyx_Coroutine_NotStartedError(gen)  (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL)
-static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) {
+static void __Pyx__Coroutine_NotStartedError(PyObject *gen) {
     const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if ((0)) {
     #ifdef __Pyx_Coroutine_USED
     } else if (__Pyx_Coroutine_Check(gen)) {
@@ -13289,7 +19709,9 @@ static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) {
     PyErr_SetString(PyExc_TypeError, msg);
 }
 #define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing)  (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL)
-static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) {
+static void __Pyx__Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    CYTHON_MAYBE_UNUSED_VAR(closing);
     #ifdef __Pyx_Coroutine_USED
     if (!closing && __Pyx_Coroutine_Check(gen)) {
         PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine");
@@ -13326,11 +19748,19 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     tstate = __Pyx_PyThreadState_Current;
 #endif
     exc_state = &self->gi_exc_state;
-    if (exc_state->exc_type) {
-        #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON
+    if (exc_state->exc_value) {
+        #if CYTHON_COMPILING_IN_PYPY
         #else
-        if (exc_state->exc_traceback) {
-            PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback;
+        PyObject *exc_tb;
+        #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+        exc_tb = PyException_GetTraceback(exc_state->exc_value);
+        #elif PY_VERSION_HEX >= 0x030B00a4
+        exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback;
+        #else
+        exc_tb = exc_state->exc_traceback;
+        #endif
+        if (exc_tb) {
+            PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
             PyFrameObject *f = tb->tb_frame;
             assert(f->f_back == NULL);
             #if PY_VERSION_HEX >= 0x030B00A1
@@ -13339,6 +19769,9 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
             Py_XINCREF(tstate->frame);
             f->f_back = tstate->frame;
             #endif
+            #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+            Py_DECREF(exc_tb);
+            #endif
         }
         #endif
     }
@@ -13354,7 +19787,7 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     }
 #endif
     self->is_running = 1;
-    retval = self->body((PyObject *) self, tstate, value);
+    retval = self->body(self, tstate, value);
     self->is_running = 0;
 #if CYTHON_USE_EXC_INFO_STACK
     exc_state = &self->gi_exc_state;
@@ -13365,18 +19798,29 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     return retval;
 }
 static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) {
-    PyObject *exc_tb = exc_state->exc_traceback;
-    if (likely(exc_tb)) {
-#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON
+#if CYTHON_COMPILING_IN_PYPY
+    CYTHON_UNUSED_VAR(exc_state);
 #else
+    PyObject *exc_tb;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    if (!exc_state->exc_value) return;
+    exc_tb = PyException_GetTraceback(exc_state->exc_value);
+    #else
+    exc_tb = exc_state->exc_traceback;
+    #endif
+    if (likely(exc_tb)) {
         PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
         PyFrameObject *f = tb->tb_frame;
         Py_CLEAR(f->f_back);
-#endif
+        #if PY_VERSION_HEX >= 0x030B00a4
+        Py_DECREF(exc_tb);
+        #endif
     }
+#endif
 }
 static CYTHON_INLINE
-PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) {
+PyObject *__Pyx_Coroutine_MethodReturn(PyObject* gen, PyObject *retval) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if (unlikely(!retval)) {
         __Pyx_PyThreadState_declare
         __Pyx_PyThreadState_assign
@@ -13407,9 +19851,22 @@ PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) {
             PyErr_SetNone(PyExc_StopIteration);
         }
         else {
+#if PY_VERSION_HEX < 0x030d00A1
             _PyGen_SetStopIterationValue(result);
+#else
+            if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) {
+                PyErr_SetObject(PyExc_StopIteration, result);
+            } else {
+                PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result);
+                if (likely(exc != NULL)) {
+                    PyErr_SetObject(PyExc_StopIteration, exc);
+                    Py_DECREF(exc);
+                }
+            }
+#endif
         }
-        Py_CLEAR(result);
+        Py_DECREF(result);
+        result = NULL;
     }
     return result;
 #endif
@@ -13461,7 +19918,7 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) {
         #endif
         {
             if (value == Py_None)
-                ret = Py_TYPE(yf)->tp_iternext(yf);
+                ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
             else
                 ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value);
         }
@@ -13508,16 +19965,15 @@ static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) {
     {
         PyObject *meth;
         gen->is_running = 1;
-        meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close);
+        meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_close);
         if (unlikely(!meth)) {
-            if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            if (unlikely(PyErr_Occurred())) {
                 PyErr_WriteUnraisable(yf);
             }
-            PyErr_Clear();
         } else {
-            retval = PyObject_CallFunction(meth, NULL);
+            retval = __Pyx_PyObject_CallNoArg(meth);
             Py_DECREF(meth);
-            if (!retval)
+            if (unlikely(!retval))
                 err = -1;
         }
         gen->is_running = 0;
@@ -13548,7 +20004,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) {
             ret = __Pyx_Coroutine_Send(yf, Py_None);
         } else
         #endif
-            ret = Py_TYPE(yf)->tp_iternext(yf);
+            ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
         gen->is_running = 0;
         if (likely(ret)) {
             return ret;
@@ -13557,7 +20013,8 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) {
     }
     return __Pyx_Coroutine_SendEx(gen, Py_None, 0);
 }
-static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) {
+static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) {
+    CYTHON_UNUSED_VAR(arg);
     return __Pyx_Coroutine_Close(self);
 }
 static PyObject *__Pyx_Coroutine_Close(PyObject *self) {
@@ -13638,22 +20095,22 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject
             ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit);
         #endif
         } else {
-            PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw);
+            PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_throw);
             if (unlikely(!meth)) {
                 Py_DECREF(yf);
-                if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                if (unlikely(PyErr_Occurred())) {
                     gen->is_running = 0;
                     return NULL;
                 }
-                PyErr_Clear();
                 __Pyx_Coroutine_Undelegate(gen);
                 gen->is_running = 0;
                 goto throw_here;
             }
             if (likely(args)) {
-                ret = PyObject_CallObject(meth, args);
+                ret = __Pyx_PyObject_Call(meth, args, NULL);
             } else {
-                ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);
+                PyObject *cargs[4] = {NULL, typ, val, tb};
+                ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
             }
             Py_DECREF(meth);
         }
@@ -13672,14 +20129,18 @@ static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) {
     PyObject *typ;
     PyObject *val = NULL;
     PyObject *tb = NULL;
-    if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb))
+    if (unlikely(!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)))
         return NULL;
     return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1);
 }
 static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_VISIT(exc_state->exc_value);
+#else
     Py_VISIT(exc_state->exc_type);
     Py_VISIT(exc_state->exc_value);
     Py_VISIT(exc_state->exc_traceback);
+#endif
     return 0;
 }
 static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) {
@@ -13714,10 +20175,10 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) {
     if (gen->resume_label >= 0) {
         PyObject_GC_Track(self);
 #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE
-        if (PyObject_CallFinalizerFromDealloc(self))
+        if (unlikely(PyObject_CallFinalizerFromDealloc(self)))
 #else
         Py_TYPE(gen)->tp_del(self);
-        if (Py_REFCNT(self) > 0)
+        if (unlikely(Py_REFCNT(self) > 0))
 #endif
         {
             return;
@@ -13733,7 +20194,7 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) {
     }
 #endif
     __Pyx_Coroutine_clear(self);
-    PyObject_GC_Del(gen);
+    __Pyx_PyHeapTypeObject_GC_Del(gen);
 }
 static void __Pyx_Coroutine_del(PyObject *self) {
     PyObject *error_type, *error_value, *error_traceback;
@@ -13812,7 +20273,7 @@ static void __Pyx_Coroutine_del(PyObject *self) {
     __Pyx_ErrRestore(error_type, error_value, error_traceback);
 #if !CYTHON_USE_TP_FINALIZE
     assert(Py_REFCNT(self) > 0);
-    if (--self->ob_refcnt == 0) {
+    if (likely(--self->ob_refcnt == 0)) {
         return;
     }
     {
@@ -13832,17 +20293,18 @@ static void __Pyx_Coroutine_del(PyObject *self) {
 #endif
 }
 static PyObject *
-__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *name = self->gi_name;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!name)) name = Py_None;
     Py_INCREF(name);
     return name;
 }
 static int
-__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -13853,24 +20315,23 @@ __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UN
                         "__name__ must be set to a string object");
         return -1;
     }
-    tmp = self->gi_name;
     Py_INCREF(value);
-    self->gi_name = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(self->gi_name, value);
     return 0;
 }
 static PyObject *
-__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *name = self->gi_qualname;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!name)) name = Py_None;
     Py_INCREF(name);
     return name;
 }
 static int
-__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -13881,16 +20342,15 @@ __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHO
                         "__qualname__ must be set to a string object");
         return -1;
     }
-    tmp = self->gi_qualname;
     Py_INCREF(value);
-    self->gi_qualname = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(self->gi_qualname, value);
     return 0;
 }
 static PyObject *
-__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *frame = self->gi_frame;
+    CYTHON_UNUSED_VAR(context);
     if (!frame) {
         if (unlikely(!self->gi_code)) {
             Py_RETURN_NONE;
@@ -13926,9 +20386,13 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
     gen->resume_label = 0;
     gen->classobj = NULL;
     gen->yieldfrom = NULL;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    gen->gi_exc_state.exc_value = NULL;
+    #else
     gen->gi_exc_state.exc_type = NULL;
     gen->gi_exc_state.exc_value = NULL;
     gen->gi_exc_state.exc_traceback = NULL;
+    #endif
 #if CYTHON_USE_EXC_INFO_STACK
     gen->gi_exc_state.previous_item = NULL;
 #endif
@@ -14013,7 +20477,7 @@ static int __Pyx_patch_abc(void) {
     if (CYTHON_REGISTER_ABCS && !abc_patched) {
         PyObject *module;
         module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections");
-        if (!module) {
+        if (unlikely(!module)) {
             PyErr_WriteUnraisable(NULL);
             if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning,
                     ((PY_MAJOR_VERSION >= 3) ?
@@ -14058,6 +20522,10 @@ static PyMemberDef __pyx_Generator_memberlist[] = {
     {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
      (char*) PyDoc_STR("object being iterated by 'yield from', or None")},
     {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL},
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0},
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0},
+#endif
     {0, 0, 0, 0, 0}
 };
 static PyGetSetDef __pyx_Generator_getsets[] = {
@@ -14069,9 +20537,32 @@ static PyGetSetDef __pyx_Generator_getsets[] = {
      (char*) PyDoc_STR("Frame of the generator"), 0},
     {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_GeneratorType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc},
+    {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse},
+    {Py_tp_iter, (void *)PyObject_SelfIter},
+    {Py_tp_iternext, (void *)__Pyx_Generator_Next},
+    {Py_tp_methods, (void *)__pyx_Generator_methods},
+    {Py_tp_members, (void *)__pyx_Generator_memberlist},
+    {Py_tp_getset, (void *)__pyx_Generator_getsets},
+    {Py_tp_getattro, (void *) __Pyx_PyObject_GenericGetAttrNoDict},
+#if CYTHON_USE_TP_FINALIZE
+    {Py_tp_finalize, (void *)__Pyx_Coroutine_del},
+#endif
+    {0, 0},
+};
+static PyType_Spec __pyx_GeneratorType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "generator",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    __pyx_GeneratorType_slots
+};
+#else
 static PyTypeObject __pyx_GeneratorType_type = {
     PyVarObject_HEAD_INIT(0, 0)
-    "generator",
+    __PYX_TYPE_MODULE_PREFIX "generator",
     sizeof(__pyx_CoroutineObject),
     0,
     (destructor) __Pyx_Coroutine_dealloc,
@@ -14129,17 +20620,29 @@ static PyTypeObject __pyx_GeneratorType_type = {
 #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
     0,
 #endif
-#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
     0,
 #endif
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
     0,
 #endif
 };
-static int __pyx_Generator_init(void) {
+#endif
+static int __pyx_Generator_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_GeneratorType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
     __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
     __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter;
     __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type);
+#endif
     if (unlikely(!__pyx_GeneratorType)) {
         return -1;
     }
@@ -14147,41 +20650,50 @@ static int __pyx_Generator_init(void) {
 }
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -14203,11 +20715,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -14222,9 +20730,9 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* FunctionImport */
-#ifndef __PYX_HAVE_RT_ImportFunction
-#define __PYX_HAVE_RT_ImportFunction
-static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+#ifndef __PYX_HAVE_RT_ImportFunction_3_0_11
+#define __PYX_HAVE_RT_ImportFunction_3_0_11
+static int __Pyx_ImportFunction_3_0_11(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
     PyObject *d = 0;
     PyObject *cobj = 0;
     union {
@@ -14241,7 +20749,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
                 PyModule_GetName(module), funcname);
         goto bad;
     }
-#if PY_VERSION_HEX >= 0x02070000
     if (!PyCapsule_IsValid(cobj, sig)) {
         PyErr_Format(PyExc_TypeError,
             "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
@@ -14249,21 +20756,6 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
         goto bad;
     }
     tmp.p = PyCapsule_GetPointer(cobj, sig);
-#else
-    {const char *desc, *s1, *s2;
-    desc = (const char *)PyCObject_GetDesc(cobj);
-    if (!desc)
-        goto bad;
-    s1 = desc; s2 = sig;
-    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
-    if (*s1 != *s2) {
-        PyErr_Format(PyExc_TypeError,
-            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
-             PyModule_GetName(module), funcname, sig, desc);
-        goto bad;
-    }
-    tmp.p = PyCObject_AsVoidPtr(cobj);}
-#endif
     *f = tmp.fp;
     if (!(*f))
         goto bad;
@@ -14276,9 +20768,31 @@ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**
 #endif
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -14286,30 +20800,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -14364,7 +20882,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -14393,22 +20911,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -14474,13 +20996,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -14548,4 +21068,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/sftp_handle.pxd b/ssh2/sftp_handle.pxd
index 673f07e2..ebfaf013 100644
--- a/ssh2/sftp_handle.pxd
+++ b/ssh2/sftp_handle.pxd
@@ -14,9 +14,9 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from sftp cimport SFTP
+from .sftp cimport SFTP
 
-cimport c_sftp
+from . cimport c_sftp
 
 
 cdef object PySFTPHandle(c_sftp.LIBSSH2_SFTP_HANDLE *handle, SFTP sftp)
diff --git a/ssh2/sftp_handle.pyx b/ssh2/sftp_handle.pyx
index a8bbab56..f88e7d61 100644
--- a/ssh2/sftp_handle.pyx
+++ b/ssh2/sftp_handle.pyx
@@ -18,10 +18,10 @@
 
 from libc.stdlib cimport malloc, free
 
-from utils cimport handle_error_codes
+from .utils cimport handle_error_codes
 
-cimport c_ssh2
-cimport c_sftp
+from . cimport c_ssh2
+from . cimport c_sftp
 
 
 cdef object PySFTPHandle(c_sftp.LIBSSH2_SFTP_HANDLE *handle, SFTP sftp):
diff --git a/ssh2/statinfo.c b/ssh2/statinfo.c
index 40c66651..47bcb1c8 100644
--- a/ssh2/statinfo.c
+++ b/ssh2/statinfo.c
@@ -1,22 +1,67 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.statinfo",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/statinfo.pyx"
+        ]
+    },
+    "module_name": "ssh2.statinfo"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +80,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +88,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +125,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +145,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
   #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +273,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +302,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +313,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +336,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +363,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +387,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +471,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +495,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +512,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
+        #else
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +574,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +609,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +761,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +778,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +868,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +914,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +948,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1042,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1057,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1099,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1116,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1163,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1183,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1223,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -794,9 +1300,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -814,9 +1321,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -824,13 +1331,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -854,8 +1355,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -876,7 +1423,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -906,6 +1453,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -941,23 +1489,29 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/statinfo.pyx",
-  "stringsource",
+  "<stringsource>",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_8statinfo_StatInfo;
@@ -974,6 +1528,7 @@ struct __pyx_obj_4ssh2_8statinfo_StatInfo {
   struct stat *_stat;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -982,11 +1537,11 @@ struct __pyx_obj_4ssh2_8statinfo_StatInfo {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -996,28 +1551,40 @@ struct __pyx_obj_4ssh2_8statinfo_StatInfo {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1028,6 +1595,10 @@ struct __pyx_obj_4ssh2_8statinfo_StatInfo {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1039,39 +1610,30 @@ struct __pyx_obj_4ssh2_8statinfo_StatInfo {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
-/* PyObjectGetAttrStr.proto */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
-#else
-#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
-#endif
-
-/* GetBuiltinName.proto */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name);
-
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* KeywordStringCheck.proto */
-static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
-
-/* PyObjectCall.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
 #else
-#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
 #endif
 
 /* PyThreadStateGet.proto */
 #if CYTHON_FAST_THREAD_STATE
 #define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
 #define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
 #else
 #define __Pyx_PyThreadState_declare
 #define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
 #endif
 
 /* PyErrFetchRestore.proto */
@@ -1083,7 +1645,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
 static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
 static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
 #else
 #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
@@ -1099,9 +1661,181 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject
 #define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
 #endif
 
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed);
+
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()\
+    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+  #define __Pyx_PyFrame_GetLocalsplus(frame)\
+    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1116,19 +1850,150 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam
 #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
 #endif
 
-/* PyErrExceptionMatches.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+/* SetupReduce.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce(PyObject* type_obj);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
 #else
-#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
 #endif
 
-/* PyObjectGetAttrStrNoError.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
 
-/* SetupReduce.proto */
-static int __Pyx_setup_reduce(PyObject* type_obj);
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
 
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
@@ -1164,6 +2029,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1177,13 +2043,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1199,6 +2066,19 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntFromPy.proto */
 static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 
@@ -1208,70 +2088,79 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'libc.string' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from 'libc.stdlib' */
+/* Module declarations from "libc.stdlib" */
 
-/* Module declarations from 'ssh2.statinfo' */
-static PyTypeObject *__pyx_ptype_4ssh2_8statinfo_StatInfo = 0;
+/* Module declarations from "ssh2.statinfo" */
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.statinfo"
 extern int __pyx_module_is_main_ssh2__statinfo;
 int __pyx_module_is_main_ssh2__statinfo = 0;
 
-/* Implementation of 'ssh2.statinfo' */
+/* Implementation of "ssh2.statinfo" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_MemoryError;
 static PyObject *__pyx_builtin_TypeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k__5[] = "?";
+static const char __pyx_k_gc[] = "gc";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_reduce[] = "__reduce__";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_StatInfo[] = "StatInfo";
 static const char __pyx_k_getstate[] = "__getstate__";
 static const char __pyx_k_setstate[] = "__setstate__";
 static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_isenabled[] = "isenabled";
+static const char __pyx_k_pyx_state[] = "__pyx_state";
 static const char __pyx_k_reduce_ex[] = "__reduce_ex__";
 static const char __pyx_k_MemoryError[] = "MemoryError";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
+static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
+static const char __pyx_k_ssh2_statinfo[] = "ssh2.statinfo";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_StatInfo___reduce_cython[] = "StatInfo.__reduce_cython__";
+static const char __pyx_k_StatInfo___setstate_cython[] = "StatInfo.__setstate_cython__";
 static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__";
-static PyObject *__pyx_n_s_MemoryError;
-static PyObject *__pyx_n_s_StatInfo;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_getstate;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
-static PyObject *__pyx_n_s_reduce;
-static PyObject *__pyx_n_s_reduce_cython;
-static PyObject *__pyx_n_s_reduce_ex;
-static PyObject *__pyx_n_s_setstate;
-static PyObject *__pyx_n_s_setstate_cython;
-static PyObject *__pyx_n_s_test;
+/* #### Code section: decls ### */
 static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self); /* proto */
 static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_size___get__(struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self); /* proto */
@@ -1289,11 +2178,282 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_ctime___get__(struct __p
 static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_tp_new_4ssh2_8statinfo_StatInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4ssh2_8statinfo_StatInfo;
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_8statinfo_StatInfo;
+  PyObject *__pyx_n_s_MemoryError;
+  PyObject *__pyx_n_s_StatInfo;
+  PyObject *__pyx_n_s_StatInfo___reduce_cython;
+  PyObject *__pyx_n_s_StatInfo___setstate_cython;
+  PyObject *__pyx_n_s_TypeError;
+  PyObject *__pyx_n_s__5;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_getstate;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_kp_s_no_default___reduce___due_to_non;
+  PyObject *__pyx_n_s_pyx_state;
+  PyObject *__pyx_n_s_reduce;
+  PyObject *__pyx_n_s_reduce_cython;
+  PyObject *__pyx_n_s_reduce_ex;
+  PyObject *__pyx_n_s_self;
+  PyObject *__pyx_n_s_setstate;
+  PyObject *__pyx_n_s_setstate_cython;
+  PyObject *__pyx_n_s_ssh2_statinfo;
+  PyObject *__pyx_kp_s_stringsource;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_tuple_;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_codeobj__2;
+  PyObject *__pyx_codeobj__4;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-/* "ssh2/statinfo.pyx":24
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_8statinfo_StatInfo);
+  Py_CLEAR(clear_module_state->__pyx_type_4ssh2_8statinfo_StatInfo);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_StatInfo);
+  Py_CLEAR(clear_module_state->__pyx_n_s_StatInfo___reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_StatInfo___setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_TypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__5);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex);
+  Py_CLEAR(clear_module_state->__pyx_n_s_self);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_statinfo);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_tuple_);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__2);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_8statinfo_StatInfo);
+  Py_VISIT(traverse_module_state->__pyx_type_4ssh2_8statinfo_StatInfo);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_StatInfo);
+  Py_VISIT(traverse_module_state->__pyx_n_s_StatInfo___reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_StatInfo___setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_TypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__5);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex);
+  Py_VISIT(traverse_module_state->__pyx_n_s_self);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_statinfo);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_tuple_);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__2);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4ssh2_8statinfo_StatInfo __pyx_mstate_global->__pyx_type_4ssh2_8statinfo_StatInfo
+#endif
+#define __pyx_ptype_4ssh2_8statinfo_StatInfo __pyx_mstate_global->__pyx_ptype_4ssh2_8statinfo_StatInfo
+#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError
+#define __pyx_n_s_StatInfo __pyx_mstate_global->__pyx_n_s_StatInfo
+#define __pyx_n_s_StatInfo___reduce_cython __pyx_mstate_global->__pyx_n_s_StatInfo___reduce_cython
+#define __pyx_n_s_StatInfo___setstate_cython __pyx_mstate_global->__pyx_n_s_StatInfo___setstate_cython
+#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError
+#define __pyx_n_s__5 __pyx_mstate_global->__pyx_n_s__5
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non
+#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state
+#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce
+#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython
+#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex
+#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self
+#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate
+#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython
+#define __pyx_n_s_ssh2_statinfo __pyx_mstate_global->__pyx_n_s_ssh2_statinfo
+#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+/* #### Code section: module_code ### */
+
+/* "ssh2/statinfo.pyx":25
  *     """Representation of stat structure - libssh2 <1.7 version"""
  * 
  *     def __cinit__(self):             # <<<<<<<<<<<<<<
@@ -1304,12 +2464,20 @@ static PyObject *__pyx_tuple__2;
 /* Python wrapper */
 static int __pyx_pw_4ssh2_8statinfo_8StatInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
 static int __pyx_pw_4ssh2_8statinfo_8StatInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   int __pyx_r;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
-  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
-    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
-  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1;
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1319,14 +2487,12 @@ static int __pyx_pw_4ssh2_8statinfo_8StatInfo_1__cinit__(PyObject *__pyx_v_self,
 
 static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self) {
   int __pyx_r;
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__cinit__", 0);
 
-  /* "ssh2/statinfo.pyx":25
+  /* "ssh2/statinfo.pyx":26
  * 
  *     def __cinit__(self):
  *         self._stat = <struct_stat *>malloc(             # <<<<<<<<<<<<<<
@@ -1335,26 +2501,26 @@ static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8
  */
   __pyx_v_self->_stat = ((struct stat *)malloc((sizeof(struct stat))));
 
-  /* "ssh2/statinfo.pyx":27
+  /* "ssh2/statinfo.pyx":28
  *         self._stat = <struct_stat *>malloc(
  *             sizeof(struct_stat))
  *         if self._stat is NULL:             # <<<<<<<<<<<<<<
  *             raise MemoryError
  * 
  */
-  __pyx_t_1 = ((__pyx_v_self->_stat == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_stat == NULL);
   if (unlikely(__pyx_t_1)) {
 
-    /* "ssh2/statinfo.pyx":28
+    /* "ssh2/statinfo.pyx":29
  *             sizeof(struct_stat))
  *         if self._stat is NULL:
  *             raise MemoryError             # <<<<<<<<<<<<<<
  * 
  *     def __dealloc__(self):
  */
-    PyErr_NoMemory(); __PYX_ERR(0, 28, __pyx_L1_error)
+    PyErr_NoMemory(); __PYX_ERR(0, 29, __pyx_L1_error)
 
-    /* "ssh2/statinfo.pyx":27
+    /* "ssh2/statinfo.pyx":28
  *         self._stat = <struct_stat *>malloc(
  *             sizeof(struct_stat))
  *         if self._stat is NULL:             # <<<<<<<<<<<<<<
@@ -1363,7 +2529,7 @@ static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8
  */
   }
 
-  /* "ssh2/statinfo.pyx":24
+  /* "ssh2/statinfo.pyx":25
  *     """Representation of stat structure - libssh2 <1.7 version"""
  * 
  *     def __cinit__(self):             # <<<<<<<<<<<<<<
@@ -1378,11 +2544,10 @@ static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8
   __Pyx_AddTraceback("ssh2.statinfo.StatInfo.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "ssh2/statinfo.pyx":30
+/* "ssh2/statinfo.pyx":31
  *             raise MemoryError
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -1393,8 +2558,10 @@ static int __pyx_pf_4ssh2_8statinfo_8StatInfo___cinit__(struct __pyx_obj_4ssh2_8
 /* Python wrapper */
 static void __pyx_pw_4ssh2_8statinfo_8StatInfo_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
 static void __pyx_pw_4ssh2_8statinfo_8StatInfo_3__dealloc__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1402,21 +2569,19 @@ static void __pyx_pw_4ssh2_8statinfo_8StatInfo_3__dealloc__(PyObject *__pyx_v_se
 }
 
 static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self) {
-  __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  __Pyx_RefNannySetupContext("__dealloc__", 0);
 
-  /* "ssh2/statinfo.pyx":31
+  /* "ssh2/statinfo.pyx":32
  * 
  *     def __dealloc__(self):
  *         if self._stat is not NULL:             # <<<<<<<<<<<<<<
  *             free(self._stat)
  *         self._stat = NULL
  */
-  __pyx_t_1 = ((__pyx_v_self->_stat != NULL) != 0);
+  __pyx_t_1 = (__pyx_v_self->_stat != NULL);
   if (__pyx_t_1) {
 
-    /* "ssh2/statinfo.pyx":32
+    /* "ssh2/statinfo.pyx":33
  *     def __dealloc__(self):
  *         if self._stat is not NULL:
  *             free(self._stat)             # <<<<<<<<<<<<<<
@@ -1425,7 +2590,7 @@ static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ss
  */
     free(__pyx_v_self->_stat);
 
-    /* "ssh2/statinfo.pyx":31
+    /* "ssh2/statinfo.pyx":32
  * 
  *     def __dealloc__(self):
  *         if self._stat is not NULL:             # <<<<<<<<<<<<<<
@@ -1434,7 +2599,7 @@ static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ss
  */
   }
 
-  /* "ssh2/statinfo.pyx":33
+  /* "ssh2/statinfo.pyx":34
  *         if self._stat is not NULL:
  *             free(self._stat)
  *         self._stat = NULL             # <<<<<<<<<<<<<<
@@ -1443,7 +2608,7 @@ static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ss
  */
   __pyx_v_self->_stat = NULL;
 
-  /* "ssh2/statinfo.pyx":30
+  /* "ssh2/statinfo.pyx":31
  *             raise MemoryError
  * 
  *     def __dealloc__(self):             # <<<<<<<<<<<<<<
@@ -1452,23 +2617,24 @@ static void __pyx_pf_4ssh2_8statinfo_8StatInfo_2__dealloc__(struct __pyx_obj_4ss
  */
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
 }
 
 /* "ssh2/statinfo.pyx":36
+ *         self._stat = NULL
  * 
- *     @property
- *     def st_size(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_size(self):
  *         return self._stat.st_size
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_size_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_size_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_7st_size___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1483,9 +2649,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_size___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":37
+  /* "ssh2/statinfo.pyx":38
  *     @property
  *     def st_size(self):
  *         return self._stat.st_size             # <<<<<<<<<<<<<<
@@ -1493,18 +2659,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_size___get__(struct __py
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_v_self->_stat->st_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_v_self->_stat->st_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":36
+ *         self._stat = NULL
  * 
- *     @property
- *     def st_size(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_size(self):
  *         return self._stat.st_size
- * 
  */
 
   /* function exit code */
@@ -1519,19 +2685,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_size___get__(struct __py
 }
 
 /* "ssh2/statinfo.pyx":40
+ *         return self._stat.st_size
  * 
- *     @property
- *     def st_ino(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ino(self):
  *         return self._stat.st_ino
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_ino_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_ino_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_6st_ino___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1546,9 +2714,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_ino___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":41
+  /* "ssh2/statinfo.pyx":42
  *     @property
  *     def st_ino(self):
  *         return self._stat.st_ino             # <<<<<<<<<<<<<<
@@ -1556,18 +2724,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_ino___get__(struct __pyx
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->_stat->st_ino); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->_stat->st_ino); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":40
+ *         return self._stat.st_size
  * 
- *     @property
- *     def st_ino(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ino(self):
  *         return self._stat.st_ino
- * 
  */
 
   /* function exit code */
@@ -1582,19 +2750,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_ino___get__(struct __pyx
 }
 
 /* "ssh2/statinfo.pyx":44
+ *         return self._stat.st_ino
  * 
- *     @property
- *     def st_mode(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mode(self):
  *         return self._stat.st_mode
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_mode_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_mode_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_7st_mode___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1609,9 +2779,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_mode___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":45
+  /* "ssh2/statinfo.pyx":46
  *     @property
  *     def st_mode(self):
  *         return self._stat.st_mode             # <<<<<<<<<<<<<<
@@ -1619,18 +2789,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_mode___get__(struct __py
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->_stat->st_mode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->_stat->st_mode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":44
+ *         return self._stat.st_ino
  * 
- *     @property
- *     def st_mode(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mode(self):
  *         return self._stat.st_mode
- * 
  */
 
   /* function exit code */
@@ -1645,19 +2815,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_mode___get__(struct __py
 }
 
 /* "ssh2/statinfo.pyx":48
+ *         return self._stat.st_mode
  * 
- *     @property
- *     def st_nlink(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_nlink(self):
  *         return self._stat.st_nlink
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_nlink_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_nlink_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_8st_nlink___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1672,9 +2844,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_nlink___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":49
+  /* "ssh2/statinfo.pyx":50
  *     @property
  *     def st_nlink(self):
  *         return self._stat.st_nlink             # <<<<<<<<<<<<<<
@@ -1682,18 +2854,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_nlink___get__(struct __p
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_nlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_nlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":48
+ *         return self._stat.st_mode
  * 
- *     @property
- *     def st_nlink(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_nlink(self):
  *         return self._stat.st_nlink
- * 
  */
 
   /* function exit code */
@@ -1708,19 +2880,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_nlink___get__(struct __p
 }
 
 /* "ssh2/statinfo.pyx":52
+ *         return self._stat.st_nlink
  * 
- *     @property
- *     def st_uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_uid(self):
  *         return self._stat.st_uid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_uid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_uid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_6st_uid___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1735,9 +2909,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_uid___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":53
+  /* "ssh2/statinfo.pyx":54
  *     @property
  *     def st_uid(self):
  *         return self._stat.st_uid             # <<<<<<<<<<<<<<
@@ -1745,18 +2919,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_uid___get__(struct __pyx
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_uid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_uid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":52
+ *         return self._stat.st_nlink
  * 
- *     @property
- *     def st_uid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_uid(self):
  *         return self._stat.st_uid
- * 
  */
 
   /* function exit code */
@@ -1771,19 +2945,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_uid___get__(struct __pyx
 }
 
 /* "ssh2/statinfo.pyx":56
+ *         return self._stat.st_uid
  * 
- *     @property
- *     def st_gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_gid(self):
  *         return self._stat.st_gid
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_gid_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_6st_gid_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_6st_gid___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1798,9 +2974,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_gid___get__(struct __pyx
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":57
+  /* "ssh2/statinfo.pyx":58
  *     @property
  *     def st_gid(self):
  *         return self._stat.st_gid             # <<<<<<<<<<<<<<
@@ -1808,18 +2984,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_gid___get__(struct __pyx
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_gid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_gid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":56
+ *         return self._stat.st_uid
  * 
- *     @property
- *     def st_gid(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_gid(self):
  *         return self._stat.st_gid
- * 
  */
 
   /* function exit code */
@@ -1834,19 +3010,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6st_gid___get__(struct __pyx
 }
 
 /* "ssh2/statinfo.pyx":60
+ *         return self._stat.st_gid
  * 
- *     @property
- *     def st_rdev(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_rdev(self):
  *         return self._stat.st_rdev
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_rdev_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7st_rdev_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_7st_rdev___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1861,9 +3039,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_rdev___get__(struct __py
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":61
+  /* "ssh2/statinfo.pyx":62
  *     @property
  *     def st_rdev(self):
  *         return self._stat.st_rdev             # <<<<<<<<<<<<<<
@@ -1871,18 +3049,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_rdev___get__(struct __py
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_rdev); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_rdev); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":60
+ *         return self._stat.st_gid
  * 
- *     @property
- *     def st_rdev(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_rdev(self):
  *         return self._stat.st_rdev
- * 
  */
 
   /* function exit code */
@@ -1897,19 +3075,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_7st_rdev___get__(struct __py
 }
 
 /* "ssh2/statinfo.pyx":64
+ *         return self._stat.st_rdev
  * 
- *     @property
- *     def st_blksize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blksize(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blksize
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_10st_blksize_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_10st_blksize_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_10st_blksize___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1924,9 +3104,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_10st_blksize___get__(struct
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":66
+  /* "ssh2/statinfo.pyx":67
  *     def st_blksize(self):
  *         IF UNAME_SYSNAME != 'Windows':
  *             return self._stat.st_blksize             # <<<<<<<<<<<<<<
@@ -1934,18 +3114,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_10st_blksize___get__(struct
  *             return None
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_blksize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_blksize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":64
+ *         return self._stat.st_rdev
  * 
- *     @property
- *     def st_blksize(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blksize(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blksize
  */
 
   /* function exit code */
@@ -1960,19 +3140,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_10st_blksize___get__(struct
 }
 
 /* "ssh2/statinfo.pyx":71
+ *             return None
  * 
- *     @property
- *     def st_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blocks(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blocks
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_9st_blocks_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_9st_blocks_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_9st_blocks___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -1987,9 +3169,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_9st_blocks___get__(struct __
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":73
+  /* "ssh2/statinfo.pyx":74
  *     def st_blocks(self):
  *         IF UNAME_SYSNAME != 'Windows':
  *             return self._stat.st_blocks             # <<<<<<<<<<<<<<
@@ -1997,18 +3179,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_9st_blocks___get__(struct __
  *             return None
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_blocks); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_self->_stat->st_blocks); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":71
+ *             return None
  * 
- *     @property
- *     def st_blocks(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_blocks(self):
  *         IF UNAME_SYSNAME != 'Windows':
- *             return self._stat.st_blocks
  */
 
   /* function exit code */
@@ -2023,19 +3205,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_9st_blocks___get__(struct __
 }
 
 /* "ssh2/statinfo.pyx":78
+ *             return None
  * 
- *     @property
- *     def st_atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_atime(self):
  *         return self._stat.st_atime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_atime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_atime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_8st_atime___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2050,9 +3234,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_atime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":79
+  /* "ssh2/statinfo.pyx":80
  *     @property
  *     def st_atime(self):
  *         return self._stat.st_atime             # <<<<<<<<<<<<<<
@@ -2060,18 +3244,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_atime___get__(struct __p
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_atime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_atime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":78
+ *             return None
  * 
- *     @property
- *     def st_atime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_atime(self):
  *         return self._stat.st_atime
- * 
  */
 
   /* function exit code */
@@ -2086,19 +3270,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_atime___get__(struct __p
 }
 
 /* "ssh2/statinfo.pyx":82
+ *         return self._stat.st_atime
  * 
- *     @property
- *     def st_mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mtime(self):
  *         return self._stat.st_mtime
- * 
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_mtime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_mtime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_8st_mtime___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2113,9 +3299,9 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_mtime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":83
+  /* "ssh2/statinfo.pyx":84
  *     @property
  *     def st_mtime(self):
  *         return self._stat.st_mtime             # <<<<<<<<<<<<<<
@@ -2123,18 +3309,18 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_mtime___get__(struct __p
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_mtime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_mtime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":82
+ *         return self._stat.st_atime
  * 
- *     @property
- *     def st_mtime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_mtime(self):
  *         return self._stat.st_mtime
- * 
  */
 
   /* function exit code */
@@ -2149,18 +3335,21 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_mtime___get__(struct __p
 }
 
 /* "ssh2/statinfo.pyx":86
+ *         return self._stat.st_mtime
  * 
- *     @property
- *     def st_ctime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ctime(self):
  *         return self._stat.st_ctime
  */
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_ctime_1__get__(PyObject *__pyx_v_self); /*proto*/
 static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_8st_ctime_1__get__(PyObject *__pyx_v_self) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_8st_ctime___get__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2175,24 +3364,25 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_ctime___get__(struct __p
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_RefNannySetupContext("__get__", 1);
 
-  /* "ssh2/statinfo.pyx":87
+  /* "ssh2/statinfo.pyx":88
  *     @property
  *     def st_ctime(self):
  *         return self._stat.st_ctime             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_ctime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->_stat->st_ctime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "ssh2/statinfo.pyx":86
+ *         return self._stat.st_mtime
  * 
- *     @property
- *     def st_ctime(self):             # <<<<<<<<<<<<<<
+ *     @property             # <<<<<<<<<<<<<<
+ *     def st_ctime(self):
  *         return self._stat.st_ctime
  */
 
@@ -2209,17 +3399,45 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_8st_ctime___get__(struct __p
 
 /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_8statinfo_8StatInfo_4__reduce_cython__[] = "StatInfo.__reduce_cython__(self)";
-static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8statinfo_8StatInfo_4__reduce_cython__, "StatInfo.__reduce_cython__(self)");
+static PyMethodDef __pyx_mdef_4ssh2_8statinfo_8StatInfo_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8statinfo_8StatInfo_4__reduce_cython__};
+static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  if (unlikely(__pyx_nargs > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;}
+  if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL;
   __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_4__reduce_cython__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self));
 
   /* function exit code */
@@ -2230,33 +3448,28 @@ static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__(PyObject
 static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__reduce_cython__", 0);
+  __Pyx_RefNannySetupContext("__reduce_cython__", 1);
 
   /* "(tree fragment)":2
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 2, __pyx_L1_error)
 
   /* "(tree fragment)":1
  * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.statinfo.StatInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2266,21 +3479,104 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_4__reduce_cython__(CYTHON_UN
 
 /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/
-static char __pyx_doc_4ssh2_8statinfo_8StatInfo_6__setstate_cython__[] = "StatInfo.__setstate_cython__(self, __pyx_state)";
-static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) {
+static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_8statinfo_8StatInfo_6__setstate_cython__, "StatInfo.__setstate_cython__(self, __pyx_state)");
+static PyMethodDef __pyx_mdef_4ssh2_8statinfo_8StatInfo_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8statinfo_8StatInfo_6__setstate_cython__};
+static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__(PyObject *__pyx_v_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_6__setstate_cython__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v___pyx_state = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("ssh2.statinfo.StatInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4ssh2_8statinfo_8StatInfo_6__setstate_cython__(((struct __pyx_obj_4ssh2_8statinfo_StatInfo *)__pyx_v_self), __pyx_v___pyx_state);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2288,33 +3584,28 @@ static PyObject *__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__(PyObjec
 static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4ssh2_8statinfo_StatInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__setstate_cython__", 0);
+  __Pyx_RefNannySetupContext("__setstate_cython__", 1);
 
   /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"             # <<<<<<<<<<<<<<
  */
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_Raise(__pyx_t_1, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0);
   __PYX_ERR(1, 4, __pyx_L1_error)
 
   /* "(tree fragment)":3
  * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_AddTraceback("ssh2.statinfo.StatInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2324,12 +3615,17 @@ static PyObject *__pyx_pf_4ssh2_8statinfo_8StatInfo_6__setstate_cython__(CYTHON_
 
 static PyObject *__pyx_tp_new_4ssh2_8statinfo_StatInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
   PyObject *o;
-  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) {
     o = (*t->tp_alloc)(t, 0);
   } else {
     o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
   }
   if (unlikely(!o)) return 0;
+  #endif
   if (unlikely(__pyx_pw_4ssh2_8statinfo_8StatInfo_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
   return o;
   bad:
@@ -2339,8 +3635,10 @@ static PyObject *__pyx_tp_new_4ssh2_8statinfo_StatInfo(PyTypeObject *t, CYTHON_U
 
 static void __pyx_tp_dealloc_4ssh2_8statinfo_StatInfo(PyObject *o) {
   #if CYTHON_USE_TP_FINALIZE
-  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
-    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4ssh2_8statinfo_StatInfo) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
   }
   #endif
   {
@@ -2351,7 +3649,14 @@ static void __pyx_tp_dealloc_4ssh2_8statinfo_StatInfo(PyObject *o) {
     __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
     PyErr_Restore(etype, eval, etb);
   }
+  #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
   (*Py_TYPE(o)->tp_free)(o);
+  #else
+  {
+    freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+    if (tp_free) tp_free(o);
+  }
+  #endif
 }
 
 static PyObject *__pyx_getprop_4ssh2_8statinfo_8StatInfo_st_size(PyObject *o, CYTHON_UNUSED void *x) {
@@ -2403,8 +3708,8 @@ static PyObject *__pyx_getprop_4ssh2_8statinfo_8StatInfo_st_ctime(PyObject *o, C
 }
 
 static PyMethodDef __pyx_methods_4ssh2_8statinfo_StatInfo[] = {
-  {"__reduce_cython__", (PyCFunction)__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__, METH_NOARGS, __pyx_doc_4ssh2_8statinfo_8StatInfo_4__reduce_cython__},
-  {"__setstate_cython__", (PyCFunction)__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__, METH_O, __pyx_doc_4ssh2_8statinfo_8StatInfo_6__setstate_cython__},
+  {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8statinfo_8StatInfo_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8statinfo_8StatInfo_4__reduce_cython__},
+  {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_8statinfo_8StatInfo_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_8statinfo_8StatInfo_6__setstate_cython__},
   {0, 0, 0, 0}
 };
 
@@ -2423,10 +3728,27 @@ static struct PyGetSetDef __pyx_getsets_4ssh2_8statinfo_StatInfo[] = {
   {(char *)"st_ctime", __pyx_getprop_4ssh2_8statinfo_8StatInfo_st_ctime, 0, (char *)0, 0},
   {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4ssh2_8statinfo_StatInfo_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4ssh2_8statinfo_StatInfo},
+  {Py_tp_doc, (void *)PyDoc_STR("Representation of stat structure - libssh2 <1.7 version")},
+  {Py_tp_methods, (void *)__pyx_methods_4ssh2_8statinfo_StatInfo},
+  {Py_tp_getset, (void *)__pyx_getsets_4ssh2_8statinfo_StatInfo},
+  {Py_tp_new, (void *)__pyx_tp_new_4ssh2_8statinfo_StatInfo},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4ssh2_8statinfo_StatInfo_spec = {
+  "ssh2.statinfo.StatInfo",
+  sizeof(struct __pyx_obj_4ssh2_8statinfo_StatInfo),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE,
+  __pyx_type_4ssh2_8statinfo_StatInfo_slots,
+};
+#else
 
 static PyTypeObject __pyx_type_4ssh2_8statinfo_StatInfo = {
   PyVarObject_HEAD_INIT(0, 0)
-  "ssh2.statinfo.StatInfo", /*tp_name*/
+  "ssh2.statinfo.""StatInfo", /*tp_name*/
   sizeof(struct __pyx_obj_4ssh2_8statinfo_StatInfo), /*tp_basicsize*/
   0, /*tp_itemsize*/
   __pyx_tp_dealloc_4ssh2_8statinfo_StatInfo, /*tp_dealloc*/
@@ -2455,7 +3777,7 @@ static PyTypeObject __pyx_type_4ssh2_8statinfo_StatInfo = {
   0, /*tp_setattro*/
   0, /*tp_as_buffer*/
   Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
-  "Representation of stat structure - libssh2 <1.7 version", /*tp_doc*/
+  PyDoc_STR("Representation of stat structure - libssh2 <1.7 version"), /*tp_doc*/
   0, /*tp_traverse*/
   0, /*tp_clear*/
   0, /*tp_richcompare*/
@@ -2469,7 +3791,9 @@ static PyTypeObject __pyx_type_4ssh2_8statinfo_StatInfo = {
   0, /*tp_dict*/
   0, /*tp_descr_get*/
   0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
   0, /*tp_dictoffset*/
+  #endif
   0, /*tp_init*/
   0, /*tp_alloc*/
   __pyx_tp_new_4ssh2_8statinfo_StatInfo, /*tp_new*/
@@ -2483,54 +3807,33 @@ static PyTypeObject __pyx_type_4ssh2_8statinfo_StatInfo = {
   0, /*tp_del*/
   0, /*tp_version_tag*/
   #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
   0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
   #endif
   #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
   0, /*tp_vectorcall*/
   #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
   0, /*tp_print*/
   #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030d00A4
+  0, /*tp_versions_used*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
   0, /*tp_pypy_flags*/
   #endif
 };
+#endif
 
 static PyMethodDef __pyx_methods[] = {
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_statinfo(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_statinfo},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "statinfo",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -2540,67 +3843,95 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
-  {&__pyx_n_s_StatInfo, __pyx_k_StatInfo, sizeof(__pyx_k_StatInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
-  {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
-  {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
+    {&__pyx_n_s_StatInfo, __pyx_k_StatInfo, sizeof(__pyx_k_StatInfo), 0, 0, 1, 1},
+    {&__pyx_n_s_StatInfo___reduce_cython, __pyx_k_StatInfo___reduce_cython, sizeof(__pyx_k_StatInfo___reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_StatInfo___setstate_cython, __pyx_k_StatInfo___setstate_cython, sizeof(__pyx_k_StatInfo___setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+    {&__pyx_n_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0},
+    {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1},
+    {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1},
+    {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_statinfo, __pyx_k_ssh2_statinfo, sizeof(__pyx_k_ssh2_statinfo), 0, 0, 1, 1},
+    {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 28, __pyx_L1_error)
+  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 29, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error)
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "(tree fragment)":2
- * def __reduce_cython__(self):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
  */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
+  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(1, 1, __pyx_L1_error)
 
-  /* "(tree fragment)":4
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")
- * def __setstate_cython__(self, __pyx_state):
- *     raise TypeError("no default __reduce__ due to non-trivial __cinit__")             # <<<<<<<<<<<<<<
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
  */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(1, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   return 0;
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -2641,16 +3972,29 @@ static int __Pyx_modinit_type_init_code(void) {
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
   /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4ssh2_8statinfo_StatInfo.tp_print = 0;
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4ssh2_8statinfo_StatInfo = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4ssh2_8statinfo_StatInfo_spec, NULL); if (unlikely(!__pyx_ptype_4ssh2_8statinfo_StatInfo)) __PYX_ERR(0, 22, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4ssh2_8statinfo_StatInfo_spec, __pyx_ptype_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  #else
+  __pyx_ptype_4ssh2_8statinfo_StatInfo = &__pyx_type_4ssh2_8statinfo_StatInfo;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4ssh2_8statinfo_StatInfo.tp_dictoffset && __pyx_type_4ssh2_8statinfo_StatInfo.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4ssh2_8statinfo_StatInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr;
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4ssh2_8statinfo_StatInfo->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4ssh2_8statinfo_StatInfo->tp_dictoffset && __pyx_ptype_4ssh2_8statinfo_StatInfo->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4ssh2_8statinfo_StatInfo->tp_getattro = __Pyx_PyObject_GenericGetAttr;
   }
-  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StatInfo, (PyObject *)&__pyx_type_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
-  __pyx_ptype_4ssh2_8statinfo_StatInfo = &__pyx_type_4ssh2_8statinfo_StatInfo;
+  #endif
+  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StatInfo, (PyObject *) __pyx_ptype_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4ssh2_8statinfo_StatInfo) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  #endif
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -2683,6 +4027,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_statinfo(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_statinfo},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "statinfo",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -2733,12 +4126,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -2748,8 +4150,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -2759,8 +4162,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -2776,7 +4183,12 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_statinfo(PyObject *__pyx_pyinit_mo
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -2790,6 +4202,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_statinfo(PyObject *__pyx_pyinit_mo
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("statinfo", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "statinfo" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -2800,7 +4239,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_statinfo(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -2808,48 +4247,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("statinfo", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -2861,7 +4283,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.statinfo")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.statinfo", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.statinfo", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -2873,7 +4295,7 @@ if (!__Pyx_RefNanny) {
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
   (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_type_import_code();
   (void)__Pyx_modinit_variable_import_code();
   (void)__Pyx_modinit_function_import_code();
@@ -2882,26 +4304,57 @@ if (!__Pyx_RefNanny) {
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
 
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8statinfo_8StatInfo_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_StatInfo___reduce_cython, NULL, __pyx_n_s_ssh2_statinfo, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "no default __reduce__ due to non-trivial __cinit__"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_8statinfo_8StatInfo_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_StatInfo___setstate_cython, NULL, __pyx_n_s_ssh2_statinfo, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
   /* "ssh2/statinfo.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
  * #
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /*--- Wrapped vars code ---*/
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.statinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.statinfo");
   }
@@ -2915,6 +4368,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -2934,36 +4403,392 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
 #endif
-    return PyObject_GetAttr(obj, attr_name);
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
 }
-#endif
-
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
 #endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
     }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
     return result;
 }
+#endif
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
     const char* func_name,
     int exact,
     Py_ssize_t num_min,
@@ -2990,25 +4815,58 @@ static void __Pyx_RaiseArgtupleInvalid(
 
 /* KeywordStringCheck */
 static int __Pyx_CheckKeywordStrings(
-    PyObject *kwdict,
+    PyObject *kw,
     const char* function_name,
     int kw_allowed)
 {
     PyObject* key = 0;
     Py_ssize_t pos = 0;
 #if CYTHON_COMPILING_IN_PYPY
-    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
         goto invalid_keyword;
     return 1;
 #else
-    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
         #if PY_MAJOR_VERSION < 3
         if (unlikely(!PyString_Check(key)))
         #endif
             if (unlikely(!PyUnicode_Check(key)))
                 goto invalid_keyword_type;
     }
-    if ((!kw_allowed) && unlikely(key))
+    if (!kw_allowed && unlikely(key))
         goto invalid_keyword;
     return 1;
 invalid_keyword_type:
@@ -3017,66 +4875,23 @@ static int __Pyx_CheckKeywordStrings(
     return 0;
 #endif
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
     return 0;
 }
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
-    }
-    return result;
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -3209,13 +5024,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -3223,6 +5034,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -3231,205 +5048,2137 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 }
 #endif
 
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
-#endif
-    return NULL;
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
+}
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
     PyObject *descr;
     PyTypeObject *tp = Py_TYPE(obj);
     if (unlikely(!PyString_Check(attr_name))) {
         return PyObject_GenericGetAttr(obj, attr_name);
     }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
+#endif
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
     }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
         }
     }
-    return descr;
+    Py_INCREF(result);
+    return result;
 }
-#endif
-
-/* PyObject_GenericGetAttr */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
-    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
-        return PyObject_GenericGetAttr(obj, attr_name);
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
     }
-    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
 }
-#endif
-
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
     }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
     }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
-    PyObject *exc_type = tstate->curexc_type;
-    if (exc_type == err) return 1;
-    if (unlikely(!exc_type)) return 0;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
 }
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
 #endif
-
-/* PyObjectGetAttrStrNoError */
-static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
-        __Pyx_PyErr_Clear();
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
-    PyObject *result;
-#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
-        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
     }
 #endif
-    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
-    if (unlikely(!result)) {
-        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
     }
-    return result;
+    return 0;
 }
-
-/* SetupReduce */
-static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
-  int ret;
-  PyObject *name_attr;
-  name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name);
-  if (likely(name_attr)) {
-      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
-  } else {
-      ret = -1;
-  }
-  if (unlikely(ret < 0)) {
-      PyErr_Clear();
-      ret = 0;
-  }
-  Py_XDECREF(name_attr);
-  return ret;
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
-static int __Pyx_setup_reduce(PyObject* type_obj) {
-    int ret = 0;
-    PyObject *object_reduce = NULL;
-    PyObject *object_getstate = NULL;
-    PyObject *object_reduce_ex = NULL;
-    PyObject *reduce = NULL;
-    PyObject *reduce_ex = NULL;
-    PyObject *reduce_cython = NULL;
-    PyObject *setstate = NULL;
-    PyObject *setstate_cython = NULL;
-    PyObject *getstate = NULL;
-#if CYTHON_USE_PYTYPE_LOOKUP
-    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
 #else
-    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
-    if (!getstate && PyErr_Occurred()) {
-        goto __PYX_BAD;
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
     }
-#endif
-    if (getstate) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
 #else
-        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
-        if (!object_getstate && PyErr_Occurred()) {
-            goto __PYX_BAD;
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
 #endif
-        if (object_getstate != getstate) {
-            goto __PYX_GOOD;
+            return NULL;
         }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
     }
-#if CYTHON_USE_PYTYPE_LOOKUP
-    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
 #else
-    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
 #endif
-    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
-    if (reduce_ex == object_reduce_ex) {
-#if CYTHON_USE_PYTYPE_LOOKUP
-        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
 #else
-        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+    self = ((PyCFunctionObject*)func)->m_self;
 #endif
-        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
-        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
-            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
-            if (likely(reduce_cython)) {
-                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-            } else if (reduce == object_reduce || PyErr_Occurred()) {
-                goto __PYX_BAD;
-            }
-            setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate);
-            if (!setstate) PyErr_Clear();
-            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
-                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
-                if (likely(setstate_cython)) {
-                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
-                } else if (!setstate || PyErr_Occurred()) {
-                    goto __PYX_BAD;
-                }
-            }
-            PyType_Modified((PyTypeObject*)type_obj);
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
         }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
     }
-    goto __PYX_GOOD;
-__PYX_BAD:
-    if (!PyErr_Occurred())
-        PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
-    ret = -1;
-__PYX_GOOD:
-#if !CYTHON_USE_PYTYPE_LOOKUP
-    Py_XDECREF(object_reduce);
-    Py_XDECREF(object_reduce_ex);
-    Py_XDECREF(object_getstate);
-    Py_XDECREF(getstate);
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
 #endif
-    Py_XDECREF(reduce);
-    Py_XDECREF(reduce_ex);
-    Py_XDECREF(reduce_cython);
-    Py_XDECREF(setstate);
-    Py_XDECREF(setstate_cython);
-    return ret;
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
 }
 
 /* PyDictVersioning */
@@ -3460,12 +7209,13 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -3479,7 +7229,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -3501,6 +7251,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -3579,17 +7330,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -3624,6 +7459,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -3639,7 +7475,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -3686,6 +7522,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value) {
@@ -3718,10 +7555,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned P
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned PY_LONG_LONG),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned PY_LONG_LONG));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3756,10 +7626,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(unsigned long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3794,10 +7697,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -3832,12 +7768,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(time_t),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(time_t));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__5);
     }
+    return name;
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -3874,7 +7859,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -3883,168 +7868,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4070,7 +8126,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -4079,168 +8135,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -4257,7 +8384,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -4278,6 +8405,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -4302,11 +8445,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -4354,47 +8497,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -4402,30 +8576,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -4480,7 +8658,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -4509,22 +8687,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -4590,13 +8772,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -4664,4 +8844,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/statinfo.pxd b/ssh2/statinfo.pxd
index 6cc1d90f..37b4548f 100644
--- a/ssh2/statinfo.pxd
+++ b/ssh2/statinfo.pxd
@@ -14,7 +14,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-from c_stat cimport struct_stat
+from .c_stat cimport struct_stat
 
 
 cdef class StatInfo:
diff --git a/ssh2/statinfo.pyx b/ssh2/statinfo.pyx
index 56da4fd3..71f7f475 100644
--- a/ssh2/statinfo.pyx
+++ b/ssh2/statinfo.pyx
@@ -15,7 +15,8 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 from libc.stdlib cimport malloc, free
-from c_stat cimport struct_stat
+
+from .c_stat cimport struct_stat
 
 
 cdef class StatInfo:
diff --git a/ssh2/utils.c b/ssh2/utils.c
index ee142186..06d287a8 100644
--- a/ssh2/utils.c
+++ b/ssh2/utils.c
@@ -1,22 +1,71 @@
-/* Generated by Cython 0.29.32 */
+/* Generated by Cython 3.0.11 */
+
+/* BEGIN: Cython Metadata
+{
+    "distutils": {
+        "depends": [
+            "ssh2/ext/find_eol.h"
+        ],
+        "extra_compile_args": [
+            "-O2"
+        ],
+        "include_dirs": [
+            "ssh2",
+            "libssh2/include"
+        ],
+        "libraries": [
+            "ssh2"
+        ],
+        "library_dirs": [
+            "/home/zefrer/Projects/ssh2-python/build_dir/src"
+        ],
+        "name": "ssh2.utils",
+        "runtime_library_dirs": [
+            "$ORIGIN/."
+        ],
+        "sources": [
+            "ssh2/utils.pyx",
+            "ssh2/ext/find_eol.c"
+        ]
+    },
+    "module_name": "ssh2.utils"
+}
+END: Cython Metadata */
 
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
 #else
-#define CYTHON_ABI "0_29_32"
-#define CYTHON_HEX_VERSION 0x001D20F0
-#define CYTHON_FUTURE_DIVISION 0
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
+#else
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -35,9 +84,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -45,13 +92,19 @@
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -76,10 +129,19 @@
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -87,46 +149,127 @@
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
-    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -134,19 +277,28 @@
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -154,8 +306,6 @@
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -167,11 +317,22 @@
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -179,18 +340,25 @@
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -199,10 +367,7 @@
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
@@ -226,37 +391,62 @@
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -285,6 +475,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -298,13 +499,16 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -312,28 +516,59 @@
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -343,13 +578,26 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -365,85 +613,145 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -457,6 +765,12 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -468,34 +782,89 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -503,6 +872,22 @@
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -533,7 +918,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -545,34 +952,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
   #define CYTHON_PEP393_ENABLED 1
-  #if defined(PyUnicode_IS_READY)
-  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
-                                              0 : _PyUnicode_Ready((PyObject *)(op)))
-  #else
   #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
   #endif
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
-  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
-  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
-  #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
-  #endif
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
-  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
   #endif
 #else
   #define CYTHON_PEP393_ENABLED 0
@@ -582,11 +1046,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -597,14 +1061,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -633,8 +1103,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -644,15 +1120,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -664,6 +1167,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -681,11 +1187,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -726,11 +1227,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -794,9 +1304,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -814,9 +1325,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -824,13 +1335,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -854,13 +1359,59 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
-#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
-static int __Pyx_sys_getdefaultencoding_not_ascii;
-static int __Pyx_init_sys_getdefaultencoding_params(void) {
-    PyObject* sys;
-    PyObject* default_encoding = NULL;
-    PyObject* ascii_chars_u = NULL;
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
     PyObject* ascii_chars_b = NULL;
     const char* default_encoding_c;
     sys = PyImport_ImportModule("sys");
@@ -876,7 +1427,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -906,6 +1457,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -941,23 +1493,26 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
   "ssh2/utils.pyx",
   "ssh2/session.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
 /* NoFastGil.proto */
 #define __Pyx_PyGILState_Ensure PyGILState_Ensure
 #define __Pyx_PyGILState_Release PyGILState_Release
@@ -965,18 +1520,16 @@ static const char *__pyx_f[] = {
 #define __Pyx_FastGIL_Forget()
 #define __Pyx_FastGilFuncInit()
 
-/* ForceInitThreads.proto */
-#ifndef __PYX_FORCE_INIT_THREADS
-  #define __PYX_FORCE_INIT_THREADS 0
-#endif
-
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
 struct __pyx_obj_4ssh2_7session_Session;
 struct __pyx_obj_4ssh2_7session_MethodType;
 
 /* "session.pxd":19
- * cimport c_ssh2
+ * from . cimport c_ssh2
  * 
  * cdef class Session:             # <<<<<<<<<<<<<<
  *     cdef c_ssh2.LIBSSH2_SESSION *_session
@@ -1002,6 +1555,7 @@ struct __pyx_obj_4ssh2_7session_MethodType {
   int value;
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1010,11 +1564,11 @@ struct __pyx_obj_4ssh2_7session_MethodType {
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1024,28 +1578,40 @@ struct __pyx_obj_4ssh2_7session_MethodType {
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1056,6 +1622,10 @@ struct __pyx_obj_4ssh2_7session_MethodType {
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1067,6 +1637,9 @@ struct __pyx_obj_4ssh2_7session_MethodType {
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1074,6 +1647,60 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
@@ -1105,18 +1732,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN
 
 /* GetModuleGlobalName.proto */
 #if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
     static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
     (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1124,42 +1751,39 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
-
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
+#endif
+#endif
 #endif
 
 /* PyObjectCall.proto */
@@ -1169,20 +1793,79 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
 /* PyObjectCallMethO.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
 
 /* IncludeStringH.proto */
 #include <string.h>
 
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
 /* RaiseArgTupleInvalid.proto */
 static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
     Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
@@ -1191,71 +1874,37 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
 static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
 
 /* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
     const char* function_name);
 
 /* ArgTypeTest.proto */
 #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
         __Pyx__ArgTypeTest(obj, type, name, exact))
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
 
-/* PyObjectCallNoArg.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
-#else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
-#endif
-
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
-
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
-#if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
-#endif
-
 /* RaiseException.proto */
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_11
+#define __PYX_HAVE_RT_ImportType_proto_3_0_11
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_0_11(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_0_11 {
+   __Pyx_ImportType_CheckSize_Error_3_0_11 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_0_11 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_0_11 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size);
 #endif
 
 /* Import.proto */
@@ -1264,6 +1913,154 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 /* ImportFrom.proto */
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
 
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1272,6 +2069,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1285,13 +2083,14 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1301,6 +2100,19 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* CIntToPy.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
 
@@ -1310,18 +2122,23 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* FunctionExport.proto */
 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
@@ -1329,30 +2146,38 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "cpython.version" */
 
-/* Module declarations from 'cpython.version' */
+/* Module declarations from "ssh2" */
 
-/* Module declarations from 'libc.stddef' */
+/* Module declarations from "libc.stddef" */
 
-/* Module declarations from 'libc.time' */
+/* Module declarations from "libc.time" */
 
-/* Module declarations from 'ssh2.c_stat' */
+/* Module declarations from "ssh2.c_stat" */
 
-/* Module declarations from 'ssh2.c_ssh2' */
+/* Module declarations from "ssh2.c_ssh2" */
 
-/* Module declarations from 'ssh2.session' */
-static PyTypeObject *__pyx_ptype_4ssh2_7session_Session = 0;
-static PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType = 0;
+/* Module declarations from "ssh2.session" */
 
-/* Module declarations from 'ssh2.error_codes' */
+/* Module declarations from "ssh2.error_codes" */
 
-/* Module declarations from 'ssh2.utils' */
+/* Module declarations from "ssh2.utils" */
 static int __pyx_f_4ssh2_5utils_handle_error_codes(int, int __pyx_skip_dispatch); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "ssh2.utils"
 extern int __pyx_module_is_main_ssh2__utils;
 int __pyx_module_is_main_ssh2__utils = 0;
 
-/* Implementation of 'ssh2.utils' */
+/* Implementation of "ssh2.utils" */
+/* #### Code section: global_var ### */
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = ".";
+static const char __pyx_k__2[] = "";
+static const char __pyx_k__13[] = "?";
 static const char __pyx_k_buf[] = "buf";
 static const char __pyx_k_pos[] = "pos";
 static const char __pyx_k_main[] = "__main__";
@@ -1369,6 +2194,7 @@ static const char __pyx_k_socket[] = "_socket";
 static const char __pyx_k_Timeout[] = "Timeout";
 static const char __pyx_k_buf_len[] = "buf_len";
 static const char __pyx_k_cur_buf[] = "cur_buf";
+static const char __pyx_k_errcode[] = "errcode";
 static const char __pyx_k_new_pos[] = "new_pos";
 static const char __pyx_k_readfds[] = "readfds";
 static const char __pyx_k_session[] = "session";
@@ -1390,6 +2216,7 @@ static const char __pyx_k_wait_socket[] = "wait_socket";
 static const char __pyx_k_DecryptError[] = "DecryptError";
 static const char __pyx_k_EncryptError[] = "EncryptError";
 static const char __pyx_k_UnknownError[] = "UnknownError";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
 static const char __pyx_k_CompressError[] = "CompressError";
 static const char __pyx_k_ProtocolError[] = "ProtocolError";
 static const char __pyx_k_SocketTimeout[] = "SocketTimeout";
@@ -1416,7 +2243,9 @@ static const char __pyx_k_ChannelClosedError[] = "ChannelClosedError";
 static const char __pyx_k_MethodNotSupported[] = "MethodNotSupported";
 static const char __pyx_k_OutOfBoundaryError[] = "OutOfBoundaryError";
 static const char __pyx_k_RequestDeniedError[] = "RequestDeniedError";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_handle_error_codes[] = "handle_error_codes";
 static const char __pyx_k_AuthenticationError[] = "AuthenticationError";
 static const char __pyx_k_BufferTooSmallError[] = "BufferTooSmallError";
 static const char __pyx_k_ChannelEOFSentError[] = "ChannelEOFSentError";
@@ -1434,103 +2263,578 @@ static const char __pyx_k_Error_code_s_not_known[] = "Error code %s not known";
 static const char __pyx_k_KeyfileAuthFailedError[] = "KeyfileAuthFailedError";
 static const char __pyx_k_PublicKeyProtocolError[] = "PublicKeyProtocolError";
 static const char __pyx_k_PublickeyUnverifiedError[] = "PublickeyUnverifiedError";
-static PyObject *__pyx_n_s_AgentProtocolError;
-static PyObject *__pyx_n_s_AllocError;
-static PyObject *__pyx_n_s_AuthenticationError;
-static PyObject *__pyx_n_s_BadSocketError;
-static PyObject *__pyx_n_s_BadUseError;
-static PyObject *__pyx_n_s_BannerRecvError;
-static PyObject *__pyx_n_s_BannerSendError;
-static PyObject *__pyx_n_s_BufferTooSmallError;
-static PyObject *__pyx_n_s_ChannelClosedError;
-static PyObject *__pyx_n_s_ChannelEOFSentError;
-static PyObject *__pyx_n_s_ChannelFailure;
-static PyObject *__pyx_n_s_ChannelOutOfOrderError;
-static PyObject *__pyx_n_s_ChannelPacketExceeded;
-static PyObject *__pyx_n_s_ChannelRequestDenied;
-static PyObject *__pyx_n_s_ChannelUnknownError;
-static PyObject *__pyx_n_s_ChannelWindowExceeded;
-static PyObject *__pyx_n_s_ChannelWindowFullError;
-static PyObject *__pyx_n_s_CompressError;
-static PyObject *__pyx_n_s_DecryptError;
-static PyObject *__pyx_n_s_ENCODING;
-static PyObject *__pyx_n_s_EncryptError;
-static PyObject *__pyx_kp_s_Error_code_s_not_known;
-static PyObject *__pyx_n_s_FileError;
-static PyObject *__pyx_n_s_HostkeyInitError;
-static PyObject *__pyx_n_s_HostkeySignError;
-static PyObject *__pyx_n_s_InvalidMACError;
-static PyObject *__pyx_n_s_InvalidPollTypeError;
-static PyObject *__pyx_n_s_InvalidRequestError;
-static PyObject *__pyx_n_s_KexFailureError;
-static PyObject *__pyx_n_s_KeyExchangeError;
-static PyObject *__pyx_n_s_KeyfileAuthFailedError;
-static PyObject *__pyx_n_s_KnownHostError;
-static PyObject *__pyx_n_s_MethodNoneError;
-static PyObject *__pyx_n_s_MethodNotSupported;
-static PyObject *__pyx_n_s_OutOfBoundaryError;
-static PyObject *__pyx_n_s_PasswordExpiredError;
-static PyObject *__pyx_n_s_ProtocolError;
-static PyObject *__pyx_n_s_PublicKeyProtocolError;
-static PyObject *__pyx_n_s_PublickeyUnverifiedError;
-static PyObject *__pyx_n_s_RequestDeniedError;
-static PyObject *__pyx_n_s_SCPProtocolError;
-static PyObject *__pyx_n_s_SFTPProtocolError;
-static PyObject *__pyx_n_s_SSH2Error;
-static PyObject *__pyx_n_s_SocketDisconnectError;
-static PyObject *__pyx_n_s_SocketRecvError;
-static PyObject *__pyx_n_s_SocketSendError;
-static PyObject *__pyx_n_s_SocketTimeout;
-static PyObject *__pyx_n_s_Timeout;
-static PyObject *__pyx_n_s_UnknownError;
-static PyObject *__pyx_n_s_ZlibError;
-static PyObject *__pyx_n_s_block_directions;
-static PyObject *__pyx_n_s_buf;
-static PyObject *__pyx_n_s_buf_len;
-static PyObject *__pyx_n_s_c_buf;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_cur_buf;
-static PyObject *__pyx_n_s_decode;
-static PyObject *__pyx_n_s_directions;
-static PyObject *__pyx_n_s_encode;
-static PyObject *__pyx_n_s_exceptions;
-static PyObject *__pyx_n_s_find_eol;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_index;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_new_pos;
-static PyObject *__pyx_n_s_pos;
-static PyObject *__pyx_n_s_readfds;
-static PyObject *__pyx_n_s_required_version;
-static PyObject *__pyx_n_s_select;
-static PyObject *__pyx_n_s_session;
-static PyObject *__pyx_n_s_socket;
-static PyObject *__pyx_n_s_ssh2_exit;
-static PyObject *__pyx_n_s_ssh2_utils;
-static PyObject *__pyx_kp_s_ssh2_utils_pyx;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_timeout;
-static PyObject *__pyx_kp_s_utf_8;
-static PyObject *__pyx_n_s_version;
-static PyObject *__pyx_n_s_wait_socket;
-static PyObject *__pyx_n_s_writefds;
+/* #### Code section: decls ### */
 static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf, Py_ssize_t __pyx_v_pos); /* proto */
 static PyObject *__pyx_pf_4ssh2_5utils_2version(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_required_version); /* proto */
 static PyObject *__pyx_pf_4ssh2_5utils_4ssh2_exit(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
 static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v__socket, struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session, PyObject *__pyx_v_timeout); /* proto */
 static PyObject *__pyx_pf_4ssh2_5utils_8handle_error_codes(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_errcode); /* proto */
-static PyObject *__pyx_int_0;
-static PyObject *__pyx_int_1;
-static PyObject *__pyx_int_neg_1;
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__3;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_codeobj__2;
-static PyObject *__pyx_codeobj__4;
-static PyObject *__pyx_codeobj__5;
-static PyObject *__pyx_codeobj__7;
-/* Late includes */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyTypeObject *__pyx_ptype_4ssh2_7session_Session;
+  PyTypeObject *__pyx_ptype_4ssh2_7session_MethodType;
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  PyObject *__pyx_kp_u_;
+  PyObject *__pyx_n_s_AgentProtocolError;
+  PyObject *__pyx_n_s_AllocError;
+  PyObject *__pyx_n_s_AuthenticationError;
+  PyObject *__pyx_n_s_BadSocketError;
+  PyObject *__pyx_n_s_BadUseError;
+  PyObject *__pyx_n_s_BannerRecvError;
+  PyObject *__pyx_n_s_BannerSendError;
+  PyObject *__pyx_n_s_BufferTooSmallError;
+  PyObject *__pyx_n_s_ChannelClosedError;
+  PyObject *__pyx_n_s_ChannelEOFSentError;
+  PyObject *__pyx_n_s_ChannelFailure;
+  PyObject *__pyx_n_s_ChannelOutOfOrderError;
+  PyObject *__pyx_n_s_ChannelPacketExceeded;
+  PyObject *__pyx_n_s_ChannelRequestDenied;
+  PyObject *__pyx_n_s_ChannelUnknownError;
+  PyObject *__pyx_n_s_ChannelWindowExceeded;
+  PyObject *__pyx_n_s_ChannelWindowFullError;
+  PyObject *__pyx_n_s_CompressError;
+  PyObject *__pyx_n_s_DecryptError;
+  PyObject *__pyx_n_s_ENCODING;
+  PyObject *__pyx_n_s_EncryptError;
+  PyObject *__pyx_kp_u_Error_code_s_not_known;
+  PyObject *__pyx_n_s_FileError;
+  PyObject *__pyx_n_s_HostkeyInitError;
+  PyObject *__pyx_n_s_HostkeySignError;
+  PyObject *__pyx_n_s_InvalidMACError;
+  PyObject *__pyx_n_s_InvalidPollTypeError;
+  PyObject *__pyx_n_s_InvalidRequestError;
+  PyObject *__pyx_n_s_KexFailureError;
+  PyObject *__pyx_n_s_KeyExchangeError;
+  PyObject *__pyx_n_s_KeyfileAuthFailedError;
+  PyObject *__pyx_n_s_KnownHostError;
+  PyObject *__pyx_n_s_MethodNoneError;
+  PyObject *__pyx_n_s_MethodNotSupported;
+  PyObject *__pyx_n_s_OutOfBoundaryError;
+  PyObject *__pyx_n_s_PasswordExpiredError;
+  PyObject *__pyx_n_s_ProtocolError;
+  PyObject *__pyx_n_s_PublicKeyProtocolError;
+  PyObject *__pyx_n_s_PublickeyUnverifiedError;
+  PyObject *__pyx_n_s_RequestDeniedError;
+  PyObject *__pyx_n_s_SCPProtocolError;
+  PyObject *__pyx_n_s_SFTPProtocolError;
+  PyObject *__pyx_n_s_SSH2Error;
+  PyObject *__pyx_n_s_SocketDisconnectError;
+  PyObject *__pyx_n_s_SocketRecvError;
+  PyObject *__pyx_n_s_SocketSendError;
+  PyObject *__pyx_n_s_SocketTimeout;
+  PyObject *__pyx_n_s_Timeout;
+  PyObject *__pyx_n_s_UnknownError;
+  PyObject *__pyx_n_s_ZlibError;
+  PyObject *__pyx_n_s__13;
+  PyObject *__pyx_n_s__2;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_block_directions;
+  PyObject *__pyx_n_s_buf;
+  PyObject *__pyx_n_s_buf_len;
+  PyObject *__pyx_n_s_c_buf;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_cur_buf;
+  PyObject *__pyx_n_s_decode;
+  PyObject *__pyx_n_s_directions;
+  PyObject *__pyx_n_s_encode;
+  PyObject *__pyx_n_s_errcode;
+  PyObject *__pyx_n_s_exceptions;
+  PyObject *__pyx_n_s_find_eol;
+  PyObject *__pyx_n_s_handle_error_codes;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_index;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_new_pos;
+  PyObject *__pyx_n_s_pos;
+  PyObject *__pyx_n_s_readfds;
+  PyObject *__pyx_n_s_required_version;
+  PyObject *__pyx_n_s_select;
+  PyObject *__pyx_n_s_session;
+  PyObject *__pyx_n_s_socket;
+  PyObject *__pyx_n_s_ssh2_exit;
+  PyObject *__pyx_n_s_ssh2_utils;
+  PyObject *__pyx_kp_s_ssh2_utils_pyx;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_timeout;
+  PyObject *__pyx_kp_u_utf_8;
+  PyObject *__pyx_n_s_version;
+  PyObject *__pyx_n_s_wait_socket;
+  PyObject *__pyx_n_s_writefds;
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1;
+  PyObject *__pyx_int_neg_1;
+  PyObject *__pyx_tuple__3;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__8;
+  PyObject *__pyx_tuple__10;
+  PyObject *__pyx_tuple__11;
+  PyObject *__pyx_codeobj__4;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__7;
+  PyObject *__pyx_codeobj__9;
+  PyObject *__pyx_codeobj__12;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AgentProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AllocError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_AuthenticationError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BadSocketError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BadUseError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BannerRecvError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BannerSendError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_BufferTooSmallError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelClosedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelEOFSentError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelFailure);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelOutOfOrderError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelPacketExceeded);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelRequestDenied);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelUnknownError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelWindowExceeded);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ChannelWindowFullError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_CompressError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_DecryptError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ENCODING);
+  Py_CLEAR(clear_module_state->__pyx_n_s_EncryptError);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Error_code_s_not_known);
+  Py_CLEAR(clear_module_state->__pyx_n_s_FileError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_HostkeyInitError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_HostkeySignError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidMACError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidPollTypeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_InvalidRequestError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KexFailureError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KeyExchangeError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KeyfileAuthFailedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_KnownHostError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodNoneError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_MethodNotSupported);
+  Py_CLEAR(clear_module_state->__pyx_n_s_OutOfBoundaryError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PasswordExpiredError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublicKeyProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_PublickeyUnverifiedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_RequestDeniedError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SCPProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SFTPProtocolError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SSH2Error);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketDisconnectError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketRecvError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketSendError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SocketTimeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_Timeout);
+  Py_CLEAR(clear_module_state->__pyx_n_s_UnknownError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ZlibError);
+  Py_CLEAR(clear_module_state->__pyx_n_s__13);
+  Py_CLEAR(clear_module_state->__pyx_n_s__2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_block_directions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_buf_len);
+  Py_CLEAR(clear_module_state->__pyx_n_s_c_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cur_buf);
+  Py_CLEAR(clear_module_state->__pyx_n_s_decode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_directions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_encode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_errcode);
+  Py_CLEAR(clear_module_state->__pyx_n_s_exceptions);
+  Py_CLEAR(clear_module_state->__pyx_n_s_find_eol);
+  Py_CLEAR(clear_module_state->__pyx_n_s_handle_error_codes);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_index);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_new_pos);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pos);
+  Py_CLEAR(clear_module_state->__pyx_n_s_readfds);
+  Py_CLEAR(clear_module_state->__pyx_n_s_required_version);
+  Py_CLEAR(clear_module_state->__pyx_n_s_select);
+  Py_CLEAR(clear_module_state->__pyx_n_s_session);
+  Py_CLEAR(clear_module_state->__pyx_n_s_socket);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_exit);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ssh2_utils);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_ssh2_utils_pyx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_timeout);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_utf_8);
+  Py_CLEAR(clear_module_state->__pyx_n_s_version);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wait_socket);
+  Py_CLEAR(clear_module_state->__pyx_n_s_writefds);
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1);
+  Py_CLEAR(clear_module_state->__pyx_int_neg_1);
+  Py_CLEAR(clear_module_state->__pyx_tuple__3);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__8);
+  Py_CLEAR(clear_module_state->__pyx_tuple__10);
+  Py_CLEAR(clear_module_state->__pyx_tuple__11);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__4);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__7);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__9);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__12);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_Session);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4ssh2_7session_MethodType);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AgentProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AllocError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_AuthenticationError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BadSocketError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BadUseError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BannerRecvError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BannerSendError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_BufferTooSmallError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelClosedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelEOFSentError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelFailure);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelOutOfOrderError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelPacketExceeded);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelRequestDenied);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelUnknownError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelWindowExceeded);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ChannelWindowFullError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_CompressError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_DecryptError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ENCODING);
+  Py_VISIT(traverse_module_state->__pyx_n_s_EncryptError);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Error_code_s_not_known);
+  Py_VISIT(traverse_module_state->__pyx_n_s_FileError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_HostkeyInitError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_HostkeySignError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidMACError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidPollTypeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_InvalidRequestError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KexFailureError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KeyExchangeError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KeyfileAuthFailedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_KnownHostError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodNoneError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_MethodNotSupported);
+  Py_VISIT(traverse_module_state->__pyx_n_s_OutOfBoundaryError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PasswordExpiredError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublicKeyProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_PublickeyUnverifiedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_RequestDeniedError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SCPProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SFTPProtocolError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SSH2Error);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketDisconnectError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketRecvError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketSendError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SocketTimeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_Timeout);
+  Py_VISIT(traverse_module_state->__pyx_n_s_UnknownError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ZlibError);
+  Py_VISIT(traverse_module_state->__pyx_n_s__13);
+  Py_VISIT(traverse_module_state->__pyx_n_s__2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_block_directions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_buf_len);
+  Py_VISIT(traverse_module_state->__pyx_n_s_c_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cur_buf);
+  Py_VISIT(traverse_module_state->__pyx_n_s_decode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_directions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_encode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_errcode);
+  Py_VISIT(traverse_module_state->__pyx_n_s_exceptions);
+  Py_VISIT(traverse_module_state->__pyx_n_s_find_eol);
+  Py_VISIT(traverse_module_state->__pyx_n_s_handle_error_codes);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_index);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_new_pos);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pos);
+  Py_VISIT(traverse_module_state->__pyx_n_s_readfds);
+  Py_VISIT(traverse_module_state->__pyx_n_s_required_version);
+  Py_VISIT(traverse_module_state->__pyx_n_s_select);
+  Py_VISIT(traverse_module_state->__pyx_n_s_session);
+  Py_VISIT(traverse_module_state->__pyx_n_s_socket);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_exit);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ssh2_utils);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_ssh2_utils_pyx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_timeout);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_utf_8);
+  Py_VISIT(traverse_module_state->__pyx_n_s_version);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wait_socket);
+  Py_VISIT(traverse_module_state->__pyx_n_s_writefds);
+  Py_VISIT(traverse_module_state->__pyx_int_0);
+  Py_VISIT(traverse_module_state->__pyx_int_1);
+  Py_VISIT(traverse_module_state->__pyx_int_neg_1);
+  Py_VISIT(traverse_module_state->__pyx_tuple__3);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__8);
+  Py_VISIT(traverse_module_state->__pyx_tuple__10);
+  Py_VISIT(traverse_module_state->__pyx_tuple__11);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__4);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__7);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__9);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__12);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_ptype_4ssh2_7session_Session __pyx_mstate_global->__pyx_ptype_4ssh2_7session_Session
+#define __pyx_ptype_4ssh2_7session_MethodType __pyx_mstate_global->__pyx_ptype_4ssh2_7session_MethodType
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
+#define __pyx_n_s_AgentProtocolError __pyx_mstate_global->__pyx_n_s_AgentProtocolError
+#define __pyx_n_s_AllocError __pyx_mstate_global->__pyx_n_s_AllocError
+#define __pyx_n_s_AuthenticationError __pyx_mstate_global->__pyx_n_s_AuthenticationError
+#define __pyx_n_s_BadSocketError __pyx_mstate_global->__pyx_n_s_BadSocketError
+#define __pyx_n_s_BadUseError __pyx_mstate_global->__pyx_n_s_BadUseError
+#define __pyx_n_s_BannerRecvError __pyx_mstate_global->__pyx_n_s_BannerRecvError
+#define __pyx_n_s_BannerSendError __pyx_mstate_global->__pyx_n_s_BannerSendError
+#define __pyx_n_s_BufferTooSmallError __pyx_mstate_global->__pyx_n_s_BufferTooSmallError
+#define __pyx_n_s_ChannelClosedError __pyx_mstate_global->__pyx_n_s_ChannelClosedError
+#define __pyx_n_s_ChannelEOFSentError __pyx_mstate_global->__pyx_n_s_ChannelEOFSentError
+#define __pyx_n_s_ChannelFailure __pyx_mstate_global->__pyx_n_s_ChannelFailure
+#define __pyx_n_s_ChannelOutOfOrderError __pyx_mstate_global->__pyx_n_s_ChannelOutOfOrderError
+#define __pyx_n_s_ChannelPacketExceeded __pyx_mstate_global->__pyx_n_s_ChannelPacketExceeded
+#define __pyx_n_s_ChannelRequestDenied __pyx_mstate_global->__pyx_n_s_ChannelRequestDenied
+#define __pyx_n_s_ChannelUnknownError __pyx_mstate_global->__pyx_n_s_ChannelUnknownError
+#define __pyx_n_s_ChannelWindowExceeded __pyx_mstate_global->__pyx_n_s_ChannelWindowExceeded
+#define __pyx_n_s_ChannelWindowFullError __pyx_mstate_global->__pyx_n_s_ChannelWindowFullError
+#define __pyx_n_s_CompressError __pyx_mstate_global->__pyx_n_s_CompressError
+#define __pyx_n_s_DecryptError __pyx_mstate_global->__pyx_n_s_DecryptError
+#define __pyx_n_s_ENCODING __pyx_mstate_global->__pyx_n_s_ENCODING
+#define __pyx_n_s_EncryptError __pyx_mstate_global->__pyx_n_s_EncryptError
+#define __pyx_kp_u_Error_code_s_not_known __pyx_mstate_global->__pyx_kp_u_Error_code_s_not_known
+#define __pyx_n_s_FileError __pyx_mstate_global->__pyx_n_s_FileError
+#define __pyx_n_s_HostkeyInitError __pyx_mstate_global->__pyx_n_s_HostkeyInitError
+#define __pyx_n_s_HostkeySignError __pyx_mstate_global->__pyx_n_s_HostkeySignError
+#define __pyx_n_s_InvalidMACError __pyx_mstate_global->__pyx_n_s_InvalidMACError
+#define __pyx_n_s_InvalidPollTypeError __pyx_mstate_global->__pyx_n_s_InvalidPollTypeError
+#define __pyx_n_s_InvalidRequestError __pyx_mstate_global->__pyx_n_s_InvalidRequestError
+#define __pyx_n_s_KexFailureError __pyx_mstate_global->__pyx_n_s_KexFailureError
+#define __pyx_n_s_KeyExchangeError __pyx_mstate_global->__pyx_n_s_KeyExchangeError
+#define __pyx_n_s_KeyfileAuthFailedError __pyx_mstate_global->__pyx_n_s_KeyfileAuthFailedError
+#define __pyx_n_s_KnownHostError __pyx_mstate_global->__pyx_n_s_KnownHostError
+#define __pyx_n_s_MethodNoneError __pyx_mstate_global->__pyx_n_s_MethodNoneError
+#define __pyx_n_s_MethodNotSupported __pyx_mstate_global->__pyx_n_s_MethodNotSupported
+#define __pyx_n_s_OutOfBoundaryError __pyx_mstate_global->__pyx_n_s_OutOfBoundaryError
+#define __pyx_n_s_PasswordExpiredError __pyx_mstate_global->__pyx_n_s_PasswordExpiredError
+#define __pyx_n_s_ProtocolError __pyx_mstate_global->__pyx_n_s_ProtocolError
+#define __pyx_n_s_PublicKeyProtocolError __pyx_mstate_global->__pyx_n_s_PublicKeyProtocolError
+#define __pyx_n_s_PublickeyUnverifiedError __pyx_mstate_global->__pyx_n_s_PublickeyUnverifiedError
+#define __pyx_n_s_RequestDeniedError __pyx_mstate_global->__pyx_n_s_RequestDeniedError
+#define __pyx_n_s_SCPProtocolError __pyx_mstate_global->__pyx_n_s_SCPProtocolError
+#define __pyx_n_s_SFTPProtocolError __pyx_mstate_global->__pyx_n_s_SFTPProtocolError
+#define __pyx_n_s_SSH2Error __pyx_mstate_global->__pyx_n_s_SSH2Error
+#define __pyx_n_s_SocketDisconnectError __pyx_mstate_global->__pyx_n_s_SocketDisconnectError
+#define __pyx_n_s_SocketRecvError __pyx_mstate_global->__pyx_n_s_SocketRecvError
+#define __pyx_n_s_SocketSendError __pyx_mstate_global->__pyx_n_s_SocketSendError
+#define __pyx_n_s_SocketTimeout __pyx_mstate_global->__pyx_n_s_SocketTimeout
+#define __pyx_n_s_Timeout __pyx_mstate_global->__pyx_n_s_Timeout
+#define __pyx_n_s_UnknownError __pyx_mstate_global->__pyx_n_s_UnknownError
+#define __pyx_n_s_ZlibError __pyx_mstate_global->__pyx_n_s_ZlibError
+#define __pyx_n_s__13 __pyx_mstate_global->__pyx_n_s__13
+#define __pyx_n_s__2 __pyx_mstate_global->__pyx_n_s__2
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_block_directions __pyx_mstate_global->__pyx_n_s_block_directions
+#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf
+#define __pyx_n_s_buf_len __pyx_mstate_global->__pyx_n_s_buf_len
+#define __pyx_n_s_c_buf __pyx_mstate_global->__pyx_n_s_c_buf
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_cur_buf __pyx_mstate_global->__pyx_n_s_cur_buf
+#define __pyx_n_s_decode __pyx_mstate_global->__pyx_n_s_decode
+#define __pyx_n_s_directions __pyx_mstate_global->__pyx_n_s_directions
+#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode
+#define __pyx_n_s_errcode __pyx_mstate_global->__pyx_n_s_errcode
+#define __pyx_n_s_exceptions __pyx_mstate_global->__pyx_n_s_exceptions
+#define __pyx_n_s_find_eol __pyx_mstate_global->__pyx_n_s_find_eol
+#define __pyx_n_s_handle_error_codes __pyx_mstate_global->__pyx_n_s_handle_error_codes
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_new_pos __pyx_mstate_global->__pyx_n_s_new_pos
+#define __pyx_n_s_pos __pyx_mstate_global->__pyx_n_s_pos
+#define __pyx_n_s_readfds __pyx_mstate_global->__pyx_n_s_readfds
+#define __pyx_n_s_required_version __pyx_mstate_global->__pyx_n_s_required_version
+#define __pyx_n_s_select __pyx_mstate_global->__pyx_n_s_select
+#define __pyx_n_s_session __pyx_mstate_global->__pyx_n_s_session
+#define __pyx_n_s_socket __pyx_mstate_global->__pyx_n_s_socket
+#define __pyx_n_s_ssh2_exit __pyx_mstate_global->__pyx_n_s_ssh2_exit
+#define __pyx_n_s_ssh2_utils __pyx_mstate_global->__pyx_n_s_ssh2_utils
+#define __pyx_kp_s_ssh2_utils_pyx __pyx_mstate_global->__pyx_kp_s_ssh2_utils_pyx
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_timeout __pyx_mstate_global->__pyx_n_s_timeout
+#define __pyx_kp_u_utf_8 __pyx_mstate_global->__pyx_kp_u_utf_8
+#define __pyx_n_s_version __pyx_mstate_global->__pyx_n_s_version
+#define __pyx_n_s_wait_socket __pyx_mstate_global->__pyx_n_s_wait_socket
+#define __pyx_n_s_writefds __pyx_mstate_global->__pyx_n_s_writefds
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1
+#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1
+#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8
+#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7
+#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9
+#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12
+/* #### Code section: module_code ### */
 
 /* "ssh2/utils.pyx":30
  * 
@@ -1544,15 +2848,15 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   int __pyx_t_1;
-  int __pyx_t_2;
+  PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("to_bytes", 0);
+  __Pyx_RefNannySetupContext("to_bytes", 1);
 
   /* "ssh2/utils.pyx":31
  * 
@@ -1562,8 +2866,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
  *     elif isinstance(_str, unicode):
  */
   __pyx_t_1 = PyBytes_Check(__pyx_v__str); 
-  __pyx_t_2 = (__pyx_t_1 != 0);
-  if (__pyx_t_2) {
+  if (__pyx_t_1) {
 
     /* "ssh2/utils.pyx":32
  * cdef bytes to_bytes(_str):
@@ -1573,7 +2876,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
  *         return _str.encode(ENCODING)
  */
     __Pyx_XDECREF(__pyx_r);
-    if (!(likely(PyBytes_CheckExact(__pyx_v__str))||((__pyx_v__str) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v__str)->tp_name), 0))) __PYX_ERR(0, 32, __pyx_L1_error)
+    if (!(likely(PyBytes_CheckExact(__pyx_v__str))||((__pyx_v__str) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v__str))) __PYX_ERR(0, 32, __pyx_L1_error)
     __Pyx_INCREF(__pyx_v__str);
     __pyx_r = ((PyObject*)__pyx_v__str);
     goto __pyx_L0;
@@ -1594,8 +2897,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
  *         return _str.encode(ENCODING)
  *     return _str
  */
-  __pyx_t_2 = PyUnicode_Check(__pyx_v__str); 
-  __pyx_t_1 = (__pyx_t_2 != 0);
+  __pyx_t_1 = PyUnicode_Check(__pyx_v__str); 
   if (__pyx_t_1) {
 
     /* "ssh2/utils.pyx":34
@@ -1606,29 +2908,36 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
  * 
  */
     __Pyx_XDECREF(__pyx_r);
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v__str, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v__str, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ENCODING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ENCODING); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
-      if (likely(__pyx_t_6)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-        __Pyx_INCREF(__pyx_t_6);
+    __pyx_t_5 = NULL;
+    __pyx_t_6 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_5);
         __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_6 = 1;
       }
     }
-    __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5);
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 34, __pyx_L1_error)
-    __pyx_r = ((PyObject*)__pyx_t_3);
-    __pyx_t_3 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_2))) __PYX_ERR(0, 34, __pyx_L1_error)
+    __pyx_r = ((PyObject*)__pyx_t_2);
+    __pyx_t_2 = 0;
     goto __pyx_L0;
 
     /* "ssh2/utils.pyx":33
@@ -1648,7 +2957,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  if (!(likely(PyBytes_CheckExact(__pyx_v__str))||((__pyx_v__str) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v__str)->tp_name), 0))) __PYX_ERR(0, 35, __pyx_L1_error)
+  if (!(likely(PyBytes_CheckExact(__pyx_v__str))||((__pyx_v__str) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v__str))) __PYX_ERR(0, 35, __pyx_L1_error)
   __Pyx_INCREF(__pyx_v__str);
   __pyx_r = ((PyObject*)__pyx_v__str);
   goto __pyx_L0;
@@ -1663,10 +2972,10 @@ static PyObject *__pyx_f_4ssh2_5utils_to_bytes(PyObject *__pyx_v__str) {
 
   /* function exit code */
   __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.utils.to_bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 0;
   __pyx_L0:;
@@ -1687,16 +2996,17 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str(char *__pyx_v_c_str) {
   Py_ssize_t __pyx_v__len;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  size_t __pyx_t_1;
+  Py_ssize_t __pyx_t_1;
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
   PyObject *__pyx_t_6 = NULL;
+  unsigned int __pyx_t_7;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("to_str", 0);
+  __Pyx_RefNannySetupContext("to_str", 1);
 
   /* "ssh2/utils.pyx":39
  * 
@@ -1705,7 +3015,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str(char *__pyx_v_c_str) {
  *     if PY_MAJOR_VERSION < 3:
  *         return c_str[:_len]
  */
-  __pyx_t_1 = strlen(__pyx_v_c_str); 
+  __pyx_t_1 = __Pyx_ssize_strlen(__pyx_v_c_str); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 39, __pyx_L1_error)
   __pyx_v__len = __pyx_t_1;
 
   /* "ssh2/utils.pyx":40
@@ -1715,7 +3025,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str(char *__pyx_v_c_str) {
  *         return c_str[:_len]
  *     return c_str[:_len].decode(ENCODING)
  */
-  __pyx_t_2 = ((PY_MAJOR_VERSION < 3) != 0);
+  __pyx_t_2 = (PY_MAJOR_VERSION < 3);
   if (__pyx_t_2) {
 
     /* "ssh2/utils.pyx":41
@@ -1757,21 +3067,28 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str(char *__pyx_v_c_str) {
   __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ENCODING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __pyx_t_6 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+  __pyx_t_7 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_5))) {
     __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
     if (likely(__pyx_t_6)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
       __Pyx_INCREF(__pyx_t_6);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_5, function);
+      __pyx_t_7 = 1;
     }
   }
-  __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_4};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
@@ -1814,10 +3131,11 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str_len(char *__pyx_v_c_str, int __pyx_
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("to_str_len", 0);
+  __Pyx_RefNannySetupContext("to_str_len", 1);
 
   /* "ssh2/utils.pyx":46
  * 
@@ -1826,7 +3144,7 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str_len(char *__pyx_v_c_str, int __pyx_
  *         return c_str[:length]
  *     return c_str[:length].decode(ENCODING)
  */
-  __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0);
+  __pyx_t_1 = (PY_MAJOR_VERSION < 3);
   if (__pyx_t_1) {
 
     /* "ssh2/utils.pyx":47
@@ -1868,21 +3186,28 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str_len(char *__pyx_v_c_str, int __pyx_
   __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ENCODING); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+  __pyx_t_6 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_4))) {
     __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
     if (likely(__pyx_t_5)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
       __Pyx_INCREF(__pyx_t_5);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_6 = 1;
     }
   }
-  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6);
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
@@ -1918,60 +3243,100 @@ static PyObject *__pyx_f_4ssh2_5utils_to_str_len(char *__pyx_v_c_str, int __pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5utils_1find_eol(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_5utils_find_eol[] = "find_eol(bytes buf, Py_ssize_t pos)\nFind end-of-line in buffer from position and return end position of\n    line and where next find_eol should start from.\n\n    Eg - find_eol(b'line\nline2', 0) would return (5, 6), next call should be\n    find_eol(b'line\nline2', 6) for next line where 6 was added to previous\n    position.\n\n    :param buf: Data buffer to parse for line.\n    :type buf: bytes\n    :param pos: Starting position to parse from\n    :type pos: int\n\n    :rtype: (int, int)";
-static PyMethodDef __pyx_mdef_4ssh2_5utils_1find_eol = {"find_eol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_5utils_1find_eol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_find_eol};
-static PyObject *__pyx_pw_4ssh2_5utils_1find_eol(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_5utils_1find_eol(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5utils_find_eol, "find_eol(bytes buf, Py_ssize_t pos)\nFind end-of-line in buffer from position and return end position of\n    line and where next find_eol should start from.\n\n    Eg - find_eol(b'line\nline2', 0) would return (5, 6), next call should be\n    find_eol(b'line\nline2', 6) for next line where 6 was added to previous\n    position.\n\n    :param buf: Data buffer to parse for line.\n    :type buf: bytes\n    :param pos: Starting position to parse from\n    :type pos: int\n\n    :rtype: (int, int)");
+static PyMethodDef __pyx_mdef_4ssh2_5utils_1find_eol = {"find_eol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5utils_1find_eol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_find_eol};
+static PyObject *__pyx_pw_4ssh2_5utils_1find_eol(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_buf = 0;
   Py_ssize_t __pyx_v_pos;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("find_eol (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,&__pyx_n_s_pos,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,&__pyx_n_s_pos,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buf)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pos)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pos)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("find_eol", 1, 2, 2, 1); __PYX_ERR(0, 51, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "find_eol") < 0)) __PYX_ERR(0, 51, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "find_eol") < 0)) __PYX_ERR(0, 51, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_buf = ((PyObject*)values[0]);
     __pyx_v_pos = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_pos == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("find_eol", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 51, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("find_eol", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 51, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.utils.find_eol", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -1984,6 +3349,12 @@ static PyObject *__pyx_pw_4ssh2_5utils_1find_eol(PyObject *__pyx_self, PyObject
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2005,7 +3376,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("find_eol", 0);
+  __Pyx_RefNannySetupContext("find_eol", 1);
 
   /* "ssh2/utils.pyx":65
  * 
@@ -2018,7 +3389,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
     __PYX_ERR(0, 65, __pyx_L1_error)
   }
-  __pyx_t_1 = PyBytes_GET_SIZE(__pyx_v_buf); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyBytes_GET_SIZE(__pyx_v_buf); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 65, __pyx_L1_error)
   __pyx_v_buf_len = __pyx_t_1;
 
   /* "ssh2/utils.pyx":66
@@ -2028,7 +3399,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
  *         return -1, pos
  *     cdef bytes cur_buf = buf[pos:buf_len]
  */
-  __pyx_t_2 = ((__pyx_v_buf_len == 0) != 0);
+  __pyx_t_2 = (__pyx_v_buf_len == 0);
   if (__pyx_t_2) {
 
     /* "ssh2/utils.pyx":67
@@ -2045,9 +3416,9 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_INCREF(__pyx_int_neg_1);
     __Pyx_GIVEREF(__pyx_int_neg_1);
-    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_neg_1);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_neg_1)) __PYX_ERR(0, 67, __pyx_L1_error);
     __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3)) __PYX_ERR(0, 67, __pyx_L1_error);
     __pyx_t_3 = 0;
     __pyx_r = __pyx_t_4;
     __pyx_t_4 = 0;
@@ -2098,6 +3469,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2156,9 +3528,9 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
   __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 75, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_6);
   __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error);
   __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error);
   __pyx_t_4 = 0;
   __pyx_t_3 = 0;
   __pyx_r = __pyx_t_6;
@@ -2196,43 +3568,68 @@ static PyObject *__pyx_pf_4ssh2_5utils_find_eol(CYTHON_UNUSED PyObject *__pyx_se
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_5utils_2version[] = "version(int required_version=0)\nGet libssh2 version string.\n\n    Passing in a non-zero required_version causes the function to return\n    `None` if version is less than required_version\n\n    :param required_version: Minimum required version\n    :type required_version: int\n    ";
-static PyMethodDef __pyx_mdef_4ssh2_5utils_3version = {"version", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_5utils_3version, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_2version};
-static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5utils_2version, "version(int required_version=0)\nGet libssh2 version string.\n\n    Passing in a non-zero required_version causes the function to return\n    `None` if version is less than required_version\n\n    :param required_version: Minimum required version\n    :type required_version: int\n    ");
+static PyMethodDef __pyx_mdef_4ssh2_5utils_3version = {"version", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5utils_3version, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_2version};
+static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_required_version;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("version (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_required_version,0};
-    PyObject* values[1] = {0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_required_version,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_required_version);
-          if (value) { values[0] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_required_version);
+          if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 78, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "version") < 0)) __PYX_ERR(0, 78, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "version") < 0)) __PYX_ERR(0, 78, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
@@ -2241,13 +3638,21 @@ static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, PyObject *
     if (values[0]) {
       __pyx_v_required_version = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_required_version == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 78, __pyx_L3_error)
     } else {
-      __pyx_v_required_version = ((int)0);
+      __pyx_v_required_version = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("version", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 78, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("version", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 78, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.utils.version", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2255,6 +3660,12 @@ static PyObject *__pyx_pw_4ssh2_5utils_3version(PyObject *__pyx_self, PyObject *
   __pyx_r = __pyx_pf_4ssh2_5utils_2version(__pyx_self, __pyx_v_required_version);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2268,7 +3679,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_2version(CYTHON_UNUSED PyObject *__pyx_se
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("version", 0);
+  __Pyx_RefNannySetupContext("version", 1);
 
   /* "ssh2/utils.pyx":88
  *     """
@@ -2280,6 +3691,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_2version(CYTHON_UNUSED PyObject *__pyx_se
   {
       #ifdef WITH_THREAD
       PyThreadState *_save;
+      _save = NULL;
       Py_UNBLOCK_THREADS
       __Pyx_FastGIL_Remember();
       #endif
@@ -2321,7 +3733,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_2version(CYTHON_UNUSED PyObject *__pyx_se
  *         return
  *     return version
  */
-  __pyx_t_1 = ((__pyx_v_version == NULL) != 0);
+  __pyx_t_1 = (__pyx_v_version == NULL);
   if (__pyx_t_1) {
 
     /* "ssh2/utils.pyx":91
@@ -2387,12 +3799,14 @@ static PyObject *__pyx_pf_4ssh2_5utils_2version(CYTHON_UNUSED PyObject *__pyx_se
 
 /* Python wrapper */
 static PyObject *__pyx_pw_4ssh2_5utils_5ssh2_exit(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_4ssh2_5utils_4ssh2_exit[] = "ssh2_exit()\nCall libssh2_exit";
+PyDoc_STRVAR(__pyx_doc_4ssh2_5utils_4ssh2_exit, "ssh2_exit()\nCall libssh2_exit");
 static PyMethodDef __pyx_mdef_4ssh2_5utils_5ssh2_exit = {"ssh2_exit", (PyCFunction)__pyx_pw_4ssh2_5utils_5ssh2_exit, METH_NOARGS, __pyx_doc_4ssh2_5utils_4ssh2_exit};
 static PyObject *__pyx_pw_4ssh2_5utils_5ssh2_exit(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("ssh2_exit (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
   __pyx_r = __pyx_pf_4ssh2_5utils_4ssh2_exit(__pyx_self);
 
   /* function exit code */
@@ -2403,7 +3817,7 @@ static PyObject *__pyx_pw_4ssh2_5utils_5ssh2_exit(PyObject *__pyx_self, CYTHON_U
 static PyObject *__pyx_pf_4ssh2_5utils_4ssh2_exit(CYTHON_UNUSED PyObject *__pyx_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ssh2_exit", 0);
+  __Pyx_RefNannySetupContext("ssh2_exit", 1);
 
   /* "ssh2/utils.pyx":97
  * def ssh2_exit():
@@ -2438,63 +3852,96 @@ static PyObject *__pyx_pf_4ssh2_5utils_4ssh2_exit(CYTHON_UNUSED PyObject *__pyx_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4ssh2_5utils_6wait_socket[] = "wait_socket(_socket, Session session, timeout=1)\nHelper function for testing non-blocking mode.\n\n    This function blocks the calling thread for <timeout> seconds -\n    to be used only for testing purposes.\n    ";
-static PyMethodDef __pyx_mdef_4ssh2_5utils_7wait_socket = {"wait_socket", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4ssh2_5utils_7wait_socket, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_6wait_socket};
-static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5utils_6wait_socket, "wait_socket(_socket, Session session, timeout=1)\nHelper function for testing non-blocking mode.\n\n    This function blocks the calling thread for <timeout> seconds -\n    to be used only for testing purposes.\n    ");
+static PyMethodDef __pyx_mdef_4ssh2_5utils_7wait_socket = {"wait_socket", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5utils_7wait_socket, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_6wait_socket};
+static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v__socket = 0;
   struct __pyx_obj_4ssh2_7session_Session *__pyx_v_session = 0;
   PyObject *__pyx_v_timeout = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("wait_socket (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_socket,&__pyx_n_s_session,&__pyx_n_s_timeout,0};
-    PyObject* values[3] = {0,0,0};
-    values[2] = ((PyObject *)__pyx_int_1);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_socket,&__pyx_n_s_session,&__pyx_n_s_timeout,0};
+    values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_1)));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_socket)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_socket)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_session)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_session)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error)
         else {
           __Pyx_RaiseArgtupleInvalid("wait_socket", 0, 2, 3, 1); __PYX_ERR(0, 100, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeout);
-          if (value) { values[2] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timeout);
+          if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "wait_socket") < 0)) __PYX_ERR(0, 100, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "wait_socket") < 0)) __PYX_ERR(0, 100, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -2503,10 +3950,18 @@ static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, PyObje
     __pyx_v_session = ((struct __pyx_obj_4ssh2_7session_Session *)values[1]);
     __pyx_v_timeout = values[2];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("wait_socket", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 100, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("wait_socket", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 100, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.utils.wait_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2522,6 +3977,12 @@ static PyObject *__pyx_pw_4ssh2_5utils_7wait_socket(PyObject *__pyx_self, PyObje
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2535,13 +3996,13 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
+  unsigned int __pyx_t_4;
   int __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("wait_socket", 0);
+  __Pyx_RefNannySetupContext("wait_socket", 1);
 
   /* "ssh2/utils.pyx":106
  *     to be used only for testing purposes.
@@ -2553,23 +4014,30 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
   __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_session), __pyx_n_s_block_directions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_4 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error)
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_directions = __pyx_t_4;
+  __pyx_v_directions = __pyx_t_5;
 
   /* "ssh2/utils.pyx":107
  *     """
@@ -2578,8 +4046,8 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
  *         return 0
  *     readfds = [_socket] \
  */
-  __pyx_t_5 = ((__pyx_v_directions == 0) != 0);
-  if (__pyx_t_5) {
+  __pyx_t_6 = (__pyx_v_directions == 0);
+  if (__pyx_t_6) {
 
     /* "ssh2/utils.pyx":108
  *     cdef int directions = session.block_directions()
@@ -2609,7 +4077,8 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
  *     writefds = [_socket] \
  *         if (directions & c_ssh2.LIBSSH2_SESSION_BLOCK_OUTBOUND) else ()
  */
-  if (((__pyx_v_directions & LIBSSH2_SESSION_BLOCK_INBOUND) != 0)) {
+  __pyx_t_6 = ((__pyx_v_directions & LIBSSH2_SESSION_BLOCK_INBOUND) != 0);
+  if (__pyx_t_6) {
 
     /* "ssh2/utils.pyx":109
  *     if directions == 0:
@@ -2622,7 +4091,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_INCREF(__pyx_v__socket);
     __Pyx_GIVEREF(__pyx_v__socket);
-    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v__socket);
+    if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v__socket)) __PYX_ERR(0, 109, __pyx_L1_error);
     __pyx_t_1 = __pyx_t_2;
     __pyx_t_2 = 0;
   } else {
@@ -2647,7 +4116,8 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
  *     return select(readfds, writefds, (), timeout)
  * 
  */
-  if (((__pyx_v_directions & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0)) {
+  __pyx_t_6 = ((__pyx_v_directions & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0);
+  if (__pyx_t_6) {
 
     /* "ssh2/utils.pyx":111
  *     readfds = [_socket] \
@@ -2660,7 +4130,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
     __Pyx_GOTREF(__pyx_t_2);
     __Pyx_INCREF(__pyx_v__socket);
     __Pyx_GIVEREF(__pyx_v__socket);
-    PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v__socket);
+    if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v__socket)) __PYX_ERR(0, 111, __pyx_L1_error);
     __pyx_t_1 = __pyx_t_2;
     __pyx_t_2 = 0;
   } else {
@@ -2690,7 +4160,8 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
   __pyx_t_4 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
@@ -2700,45 +4171,15 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
       __pyx_t_4 = 1;
     }
   }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_v_readfds, __pyx_v_writefds, __pyx_empty_tuple, __pyx_v_timeout};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 4+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[5] = {__pyx_t_3, __pyx_v_readfds, __pyx_v_writefds, __pyx_empty_tuple, __pyx_v_timeout};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 4+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-  } else
   #endif
   {
-    __pyx_t_6 = PyTuple_New(4+__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 113, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    if (__pyx_t_3) {
-      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL;
-    }
-    __Pyx_INCREF(__pyx_v_readfds);
-    __Pyx_GIVEREF(__pyx_v_readfds);
-    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_4, __pyx_v_readfds);
-    __Pyx_INCREF(__pyx_v_writefds);
-    __Pyx_GIVEREF(__pyx_v_writefds);
-    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_4, __pyx_v_writefds);
-    __Pyx_INCREF(__pyx_empty_tuple);
-    __Pyx_GIVEREF(__pyx_empty_tuple);
-    PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_4, __pyx_empty_tuple);
-    __Pyx_INCREF(__pyx_v_timeout);
-    __Pyx_GIVEREF(__pyx_v_timeout);
-    PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_4, __pyx_v_timeout);
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
+    PyObject *__pyx_callargs[5] = {__pyx_t_3, __pyx_v_readfds, __pyx_v_writefds, __pyx_empty_tuple, __pyx_v_timeout};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 4+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
@@ -2756,7 +4197,6 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_AddTraceback("ssh2.utils.wait_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -2775,7 +4215,13 @@ static PyObject *__pyx_pf_4ssh2_5utils_6wait_socket(CYTHON_UNUSED PyObject *__py
  * 
  */
 
-static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, PyObject *__pyx_arg_errcode); /*proto*/
+static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
 static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_UNUSED int __pyx_skip_dispatch) {
   int __pyx_r;
   __Pyx_RefNannyDeclarations
@@ -2784,12 +4230,11 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
   int __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
+  unsigned int __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("handle_error_codes", 0);
+  __Pyx_RefNannySetupContext("handle_error_codes", 1);
 
   /* "ssh2/utils.pyx":127
  *     """
@@ -4070,7 +5515,7 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
  *             raise exceptions.UnknownError("Error code %s not known", errcode)
  *         return errcode
  */
-    __pyx_t_3 = ((__pyx_v_errcode < 0) != 0);
+    __pyx_t_3 = (__pyx_v_errcode < 0);
     if (unlikely(__pyx_t_3)) {
 
       /* "ssh2/utils.pyx":228
@@ -4088,7 +5533,8 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
       __Pyx_GOTREF(__pyx_t_1);
       __pyx_t_5 = NULL;
       __pyx_t_6 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
         __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
         if (likely(__pyx_t_5)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
@@ -4098,41 +5544,16 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
           __pyx_t_6 = 1;
         }
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_4)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_code_s_not_known, __pyx_t_1};
-        __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_2);
-        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      } else
       #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_kp_s_Error_code_s_not_known, __pyx_t_1};
-        __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_kp_u_Error_code_s_not_known, __pyx_t_1};
+        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6);
         __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_2);
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        if (__pyx_t_5) {
-          __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-        }
-        __Pyx_INCREF(__pyx_kp_s_Error_code_s_not_known);
-        __Pyx_GIVEREF(__pyx_kp_s_Error_code_s_not_known);
-        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_s_Error_code_s_not_known);
-        __Pyx_GIVEREF(__pyx_t_1);
-        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_1);
-        __pyx_t_1 = 0;
-        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_2);
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       }
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_Raise(__pyx_t_2, 0, 0, 0);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __PYX_ERR(0, 228, __pyx_L1_error)
@@ -4170,7 +5591,6 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_AddTraceback("ssh2.utils.handle_error_codes", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = -1;
   __pyx_L0:;
@@ -4179,28 +5599,98 @@ static int __pyx_f_4ssh2_5utils_handle_error_codes(int __pyx_v_errcode, CYTHON_U
 }
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, PyObject *__pyx_arg_errcode); /*proto*/
-static char __pyx_doc_4ssh2_5utils_8handle_error_codes[] = "handle_error_codes(int errcode) -> int\nRaise appropriate exception for given error code.\n\n    Returns 0 on no error and ``LIBSSH2_ERROR_EAGAIN`` on ``EAGAIN``.\n\n    :raises: Appropriate exception from :py:mod:`ssh2.exceptions`.\n\n    :param errcode: Error code as returned by\n      :py:func:`ssh2.session.Session.last_errno`\n    ";
-static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, PyObject *__pyx_arg_errcode) {
+static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4ssh2_5utils_8handle_error_codes, "handle_error_codes(int errcode) -> int\nRaise appropriate exception for given error code.\n\n    Returns 0 on no error and ``LIBSSH2_ERROR_EAGAIN`` on ``EAGAIN``.\n\n    :raises: Appropriate exception from :py:mod:`ssh2.exceptions`.\n\n    :param errcode: Error code as returned by\n      :py:func:`ssh2.session.Session.last_errno`\n    ");
+static PyMethodDef __pyx_mdef_4ssh2_5utils_9handle_error_codes = {"handle_error_codes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4ssh2_5utils_9handle_error_codes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4ssh2_5utils_8handle_error_codes};
+static PyObject *__pyx_pw_4ssh2_5utils_9handle_error_codes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   int __pyx_v_errcode;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("handle_error_codes (wrapper)", 0);
-  assert(__pyx_arg_errcode); {
-    __pyx_v_errcode = __Pyx_PyInt_As_int(__pyx_arg_errcode); if (unlikely((__pyx_v_errcode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error)
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_errcode,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_errcode)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "handle_error_codes") < 0)) __PYX_ERR(0, 116, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_errcode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_errcode == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L3_error)
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("handle_error_codes", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 116, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("ssh2.utils.handle_error_codes", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4ssh2_5utils_8handle_error_codes(__pyx_self, ((int)__pyx_v_errcode));
+  __pyx_r = __pyx_pf_4ssh2_5utils_8handle_error_codes(__pyx_self, __pyx_v_errcode);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -4213,7 +5703,7 @@ static PyObject *__pyx_pf_4ssh2_5utils_8handle_error_codes(CYTHON_UNUSED PyObjec
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("handle_error_codes", 0);
+  __Pyx_RefNannySetupContext("handle_error_codes", 1);
   __Pyx_XDECREF(__pyx_r);
   __pyx_t_1 = __pyx_f_4ssh2_5utils_handle_error_codes(__pyx_v_errcode, 0); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 116, __pyx_L1_error)
   __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
@@ -4234,41 +5724,8 @@ static PyObject *__pyx_pf_4ssh2_5utils_8handle_error_codes(CYTHON_UNUSED PyObjec
 }
 
 static PyMethodDef __pyx_methods[] = {
-  {"handle_error_codes", (PyCFunction)__pyx_pw_4ssh2_5utils_9handle_error_codes, METH_O, __pyx_doc_4ssh2_5utils_8handle_error_codes},
   {0, 0, 0, 0}
 };
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_utils(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_utils},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "utils",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
 #ifndef CYTHON_SMALL_CODE
 #if defined(__clang__)
     #define CYTHON_SMALL_CODE
@@ -4278,94 +5735,107 @@ static struct PyModuleDef __pyx_moduledef = {
     #define CYTHON_SMALL_CODE
 #endif
 #endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_n_s_AgentProtocolError, __pyx_k_AgentProtocolError, sizeof(__pyx_k_AgentProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_AllocError, __pyx_k_AllocError, sizeof(__pyx_k_AllocError), 0, 0, 1, 1},
-  {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1},
-  {&__pyx_n_s_BadSocketError, __pyx_k_BadSocketError, sizeof(__pyx_k_BadSocketError), 0, 0, 1, 1},
-  {&__pyx_n_s_BadUseError, __pyx_k_BadUseError, sizeof(__pyx_k_BadUseError), 0, 0, 1, 1},
-  {&__pyx_n_s_BannerRecvError, __pyx_k_BannerRecvError, sizeof(__pyx_k_BannerRecvError), 0, 0, 1, 1},
-  {&__pyx_n_s_BannerSendError, __pyx_k_BannerSendError, sizeof(__pyx_k_BannerSendError), 0, 0, 1, 1},
-  {&__pyx_n_s_BufferTooSmallError, __pyx_k_BufferTooSmallError, sizeof(__pyx_k_BufferTooSmallError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelClosedError, __pyx_k_ChannelClosedError, sizeof(__pyx_k_ChannelClosedError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelEOFSentError, __pyx_k_ChannelEOFSentError, sizeof(__pyx_k_ChannelEOFSentError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelFailure, __pyx_k_ChannelFailure, sizeof(__pyx_k_ChannelFailure), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelOutOfOrderError, __pyx_k_ChannelOutOfOrderError, sizeof(__pyx_k_ChannelOutOfOrderError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelPacketExceeded, __pyx_k_ChannelPacketExceeded, sizeof(__pyx_k_ChannelPacketExceeded), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelRequestDenied, __pyx_k_ChannelRequestDenied, sizeof(__pyx_k_ChannelRequestDenied), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelUnknownError, __pyx_k_ChannelUnknownError, sizeof(__pyx_k_ChannelUnknownError), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelWindowExceeded, __pyx_k_ChannelWindowExceeded, sizeof(__pyx_k_ChannelWindowExceeded), 0, 0, 1, 1},
-  {&__pyx_n_s_ChannelWindowFullError, __pyx_k_ChannelWindowFullError, sizeof(__pyx_k_ChannelWindowFullError), 0, 0, 1, 1},
-  {&__pyx_n_s_CompressError, __pyx_k_CompressError, sizeof(__pyx_k_CompressError), 0, 0, 1, 1},
-  {&__pyx_n_s_DecryptError, __pyx_k_DecryptError, sizeof(__pyx_k_DecryptError), 0, 0, 1, 1},
-  {&__pyx_n_s_ENCODING, __pyx_k_ENCODING, sizeof(__pyx_k_ENCODING), 0, 0, 1, 1},
-  {&__pyx_n_s_EncryptError, __pyx_k_EncryptError, sizeof(__pyx_k_EncryptError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Error_code_s_not_known, __pyx_k_Error_code_s_not_known, sizeof(__pyx_k_Error_code_s_not_known), 0, 0, 1, 0},
-  {&__pyx_n_s_FileError, __pyx_k_FileError, sizeof(__pyx_k_FileError), 0, 0, 1, 1},
-  {&__pyx_n_s_HostkeyInitError, __pyx_k_HostkeyInitError, sizeof(__pyx_k_HostkeyInitError), 0, 0, 1, 1},
-  {&__pyx_n_s_HostkeySignError, __pyx_k_HostkeySignError, sizeof(__pyx_k_HostkeySignError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidMACError, __pyx_k_InvalidMACError, sizeof(__pyx_k_InvalidMACError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidPollTypeError, __pyx_k_InvalidPollTypeError, sizeof(__pyx_k_InvalidPollTypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_InvalidRequestError, __pyx_k_InvalidRequestError, sizeof(__pyx_k_InvalidRequestError), 0, 0, 1, 1},
-  {&__pyx_n_s_KexFailureError, __pyx_k_KexFailureError, sizeof(__pyx_k_KexFailureError), 0, 0, 1, 1},
-  {&__pyx_n_s_KeyExchangeError, __pyx_k_KeyExchangeError, sizeof(__pyx_k_KeyExchangeError), 0, 0, 1, 1},
-  {&__pyx_n_s_KeyfileAuthFailedError, __pyx_k_KeyfileAuthFailedError, sizeof(__pyx_k_KeyfileAuthFailedError), 0, 0, 1, 1},
-  {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
-  {&__pyx_n_s_MethodNoneError, __pyx_k_MethodNoneError, sizeof(__pyx_k_MethodNoneError), 0, 0, 1, 1},
-  {&__pyx_n_s_MethodNotSupported, __pyx_k_MethodNotSupported, sizeof(__pyx_k_MethodNotSupported), 0, 0, 1, 1},
-  {&__pyx_n_s_OutOfBoundaryError, __pyx_k_OutOfBoundaryError, sizeof(__pyx_k_OutOfBoundaryError), 0, 0, 1, 1},
-  {&__pyx_n_s_PasswordExpiredError, __pyx_k_PasswordExpiredError, sizeof(__pyx_k_PasswordExpiredError), 0, 0, 1, 1},
-  {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublicKeyProtocolError, __pyx_k_PublicKeyProtocolError, sizeof(__pyx_k_PublicKeyProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_PublickeyUnverifiedError, __pyx_k_PublickeyUnverifiedError, sizeof(__pyx_k_PublickeyUnverifiedError), 0, 0, 1, 1},
-  {&__pyx_n_s_RequestDeniedError, __pyx_k_RequestDeniedError, sizeof(__pyx_k_RequestDeniedError), 0, 0, 1, 1},
-  {&__pyx_n_s_SCPProtocolError, __pyx_k_SCPProtocolError, sizeof(__pyx_k_SCPProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_SFTPProtocolError, __pyx_k_SFTPProtocolError, sizeof(__pyx_k_SFTPProtocolError), 0, 0, 1, 1},
-  {&__pyx_n_s_SSH2Error, __pyx_k_SSH2Error, sizeof(__pyx_k_SSH2Error), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketDisconnectError, __pyx_k_SocketDisconnectError, sizeof(__pyx_k_SocketDisconnectError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketRecvError, __pyx_k_SocketRecvError, sizeof(__pyx_k_SocketRecvError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketSendError, __pyx_k_SocketSendError, sizeof(__pyx_k_SocketSendError), 0, 0, 1, 1},
-  {&__pyx_n_s_SocketTimeout, __pyx_k_SocketTimeout, sizeof(__pyx_k_SocketTimeout), 0, 0, 1, 1},
-  {&__pyx_n_s_Timeout, __pyx_k_Timeout, sizeof(__pyx_k_Timeout), 0, 0, 1, 1},
-  {&__pyx_n_s_UnknownError, __pyx_k_UnknownError, sizeof(__pyx_k_UnknownError), 0, 0, 1, 1},
-  {&__pyx_n_s_ZlibError, __pyx_k_ZlibError, sizeof(__pyx_k_ZlibError), 0, 0, 1, 1},
-  {&__pyx_n_s_block_directions, __pyx_k_block_directions, sizeof(__pyx_k_block_directions), 0, 0, 1, 1},
-  {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
-  {&__pyx_n_s_buf_len, __pyx_k_buf_len, sizeof(__pyx_k_buf_len), 0, 0, 1, 1},
-  {&__pyx_n_s_c_buf, __pyx_k_c_buf, sizeof(__pyx_k_c_buf), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_cur_buf, __pyx_k_cur_buf, sizeof(__pyx_k_cur_buf), 0, 0, 1, 1},
-  {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
-  {&__pyx_n_s_directions, __pyx_k_directions, sizeof(__pyx_k_directions), 0, 0, 1, 1},
-  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
-  {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
-  {&__pyx_n_s_find_eol, __pyx_k_find_eol, sizeof(__pyx_k_find_eol), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_new_pos, __pyx_k_new_pos, sizeof(__pyx_k_new_pos), 0, 0, 1, 1},
-  {&__pyx_n_s_pos, __pyx_k_pos, sizeof(__pyx_k_pos), 0, 0, 1, 1},
-  {&__pyx_n_s_readfds, __pyx_k_readfds, sizeof(__pyx_k_readfds), 0, 0, 1, 1},
-  {&__pyx_n_s_required_version, __pyx_k_required_version, sizeof(__pyx_k_required_version), 0, 0, 1, 1},
-  {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1},
-  {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
-  {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1},
-  {&__pyx_n_s_ssh2_exit, __pyx_k_ssh2_exit, sizeof(__pyx_k_ssh2_exit), 0, 0, 1, 1},
-  {&__pyx_n_s_ssh2_utils, __pyx_k_ssh2_utils, sizeof(__pyx_k_ssh2_utils), 0, 0, 1, 1},
-  {&__pyx_kp_s_ssh2_utils_pyx, __pyx_k_ssh2_utils_pyx, sizeof(__pyx_k_ssh2_utils_pyx), 0, 0, 1, 0},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1},
-  {&__pyx_kp_s_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 0, 1, 0},
-  {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1},
-  {&__pyx_n_s_wait_socket, __pyx_k_wait_socket, sizeof(__pyx_k_wait_socket), 0, 0, 1, 1},
-  {&__pyx_n_s_writefds, __pyx_k_writefds, sizeof(__pyx_k_writefds), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
+    {&__pyx_n_s_AgentProtocolError, __pyx_k_AgentProtocolError, sizeof(__pyx_k_AgentProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_AllocError, __pyx_k_AllocError, sizeof(__pyx_k_AllocError), 0, 0, 1, 1},
+    {&__pyx_n_s_AuthenticationError, __pyx_k_AuthenticationError, sizeof(__pyx_k_AuthenticationError), 0, 0, 1, 1},
+    {&__pyx_n_s_BadSocketError, __pyx_k_BadSocketError, sizeof(__pyx_k_BadSocketError), 0, 0, 1, 1},
+    {&__pyx_n_s_BadUseError, __pyx_k_BadUseError, sizeof(__pyx_k_BadUseError), 0, 0, 1, 1},
+    {&__pyx_n_s_BannerRecvError, __pyx_k_BannerRecvError, sizeof(__pyx_k_BannerRecvError), 0, 0, 1, 1},
+    {&__pyx_n_s_BannerSendError, __pyx_k_BannerSendError, sizeof(__pyx_k_BannerSendError), 0, 0, 1, 1},
+    {&__pyx_n_s_BufferTooSmallError, __pyx_k_BufferTooSmallError, sizeof(__pyx_k_BufferTooSmallError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelClosedError, __pyx_k_ChannelClosedError, sizeof(__pyx_k_ChannelClosedError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelEOFSentError, __pyx_k_ChannelEOFSentError, sizeof(__pyx_k_ChannelEOFSentError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelFailure, __pyx_k_ChannelFailure, sizeof(__pyx_k_ChannelFailure), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelOutOfOrderError, __pyx_k_ChannelOutOfOrderError, sizeof(__pyx_k_ChannelOutOfOrderError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelPacketExceeded, __pyx_k_ChannelPacketExceeded, sizeof(__pyx_k_ChannelPacketExceeded), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelRequestDenied, __pyx_k_ChannelRequestDenied, sizeof(__pyx_k_ChannelRequestDenied), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelUnknownError, __pyx_k_ChannelUnknownError, sizeof(__pyx_k_ChannelUnknownError), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelWindowExceeded, __pyx_k_ChannelWindowExceeded, sizeof(__pyx_k_ChannelWindowExceeded), 0, 0, 1, 1},
+    {&__pyx_n_s_ChannelWindowFullError, __pyx_k_ChannelWindowFullError, sizeof(__pyx_k_ChannelWindowFullError), 0, 0, 1, 1},
+    {&__pyx_n_s_CompressError, __pyx_k_CompressError, sizeof(__pyx_k_CompressError), 0, 0, 1, 1},
+    {&__pyx_n_s_DecryptError, __pyx_k_DecryptError, sizeof(__pyx_k_DecryptError), 0, 0, 1, 1},
+    {&__pyx_n_s_ENCODING, __pyx_k_ENCODING, sizeof(__pyx_k_ENCODING), 0, 0, 1, 1},
+    {&__pyx_n_s_EncryptError, __pyx_k_EncryptError, sizeof(__pyx_k_EncryptError), 0, 0, 1, 1},
+    {&__pyx_kp_u_Error_code_s_not_known, __pyx_k_Error_code_s_not_known, sizeof(__pyx_k_Error_code_s_not_known), 0, 1, 0, 0},
+    {&__pyx_n_s_FileError, __pyx_k_FileError, sizeof(__pyx_k_FileError), 0, 0, 1, 1},
+    {&__pyx_n_s_HostkeyInitError, __pyx_k_HostkeyInitError, sizeof(__pyx_k_HostkeyInitError), 0, 0, 1, 1},
+    {&__pyx_n_s_HostkeySignError, __pyx_k_HostkeySignError, sizeof(__pyx_k_HostkeySignError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidMACError, __pyx_k_InvalidMACError, sizeof(__pyx_k_InvalidMACError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidPollTypeError, __pyx_k_InvalidPollTypeError, sizeof(__pyx_k_InvalidPollTypeError), 0, 0, 1, 1},
+    {&__pyx_n_s_InvalidRequestError, __pyx_k_InvalidRequestError, sizeof(__pyx_k_InvalidRequestError), 0, 0, 1, 1},
+    {&__pyx_n_s_KexFailureError, __pyx_k_KexFailureError, sizeof(__pyx_k_KexFailureError), 0, 0, 1, 1},
+    {&__pyx_n_s_KeyExchangeError, __pyx_k_KeyExchangeError, sizeof(__pyx_k_KeyExchangeError), 0, 0, 1, 1},
+    {&__pyx_n_s_KeyfileAuthFailedError, __pyx_k_KeyfileAuthFailedError, sizeof(__pyx_k_KeyfileAuthFailedError), 0, 0, 1, 1},
+    {&__pyx_n_s_KnownHostError, __pyx_k_KnownHostError, sizeof(__pyx_k_KnownHostError), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodNoneError, __pyx_k_MethodNoneError, sizeof(__pyx_k_MethodNoneError), 0, 0, 1, 1},
+    {&__pyx_n_s_MethodNotSupported, __pyx_k_MethodNotSupported, sizeof(__pyx_k_MethodNotSupported), 0, 0, 1, 1},
+    {&__pyx_n_s_OutOfBoundaryError, __pyx_k_OutOfBoundaryError, sizeof(__pyx_k_OutOfBoundaryError), 0, 0, 1, 1},
+    {&__pyx_n_s_PasswordExpiredError, __pyx_k_PasswordExpiredError, sizeof(__pyx_k_PasswordExpiredError), 0, 0, 1, 1},
+    {&__pyx_n_s_ProtocolError, __pyx_k_ProtocolError, sizeof(__pyx_k_ProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublicKeyProtocolError, __pyx_k_PublicKeyProtocolError, sizeof(__pyx_k_PublicKeyProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_PublickeyUnverifiedError, __pyx_k_PublickeyUnverifiedError, sizeof(__pyx_k_PublickeyUnverifiedError), 0, 0, 1, 1},
+    {&__pyx_n_s_RequestDeniedError, __pyx_k_RequestDeniedError, sizeof(__pyx_k_RequestDeniedError), 0, 0, 1, 1},
+    {&__pyx_n_s_SCPProtocolError, __pyx_k_SCPProtocolError, sizeof(__pyx_k_SCPProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_SFTPProtocolError, __pyx_k_SFTPProtocolError, sizeof(__pyx_k_SFTPProtocolError), 0, 0, 1, 1},
+    {&__pyx_n_s_SSH2Error, __pyx_k_SSH2Error, sizeof(__pyx_k_SSH2Error), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketDisconnectError, __pyx_k_SocketDisconnectError, sizeof(__pyx_k_SocketDisconnectError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketRecvError, __pyx_k_SocketRecvError, sizeof(__pyx_k_SocketRecvError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketSendError, __pyx_k_SocketSendError, sizeof(__pyx_k_SocketSendError), 0, 0, 1, 1},
+    {&__pyx_n_s_SocketTimeout, __pyx_k_SocketTimeout, sizeof(__pyx_k_SocketTimeout), 0, 0, 1, 1},
+    {&__pyx_n_s_Timeout, __pyx_k_Timeout, sizeof(__pyx_k_Timeout), 0, 0, 1, 1},
+    {&__pyx_n_s_UnknownError, __pyx_k_UnknownError, sizeof(__pyx_k_UnknownError), 0, 0, 1, 1},
+    {&__pyx_n_s_ZlibError, __pyx_k_ZlibError, sizeof(__pyx_k_ZlibError), 0, 0, 1, 1},
+    {&__pyx_n_s__13, __pyx_k__13, sizeof(__pyx_k__13), 0, 0, 1, 1},
+    {&__pyx_n_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_block_directions, __pyx_k_block_directions, sizeof(__pyx_k_block_directions), 0, 0, 1, 1},
+    {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_buf_len, __pyx_k_buf_len, sizeof(__pyx_k_buf_len), 0, 0, 1, 1},
+    {&__pyx_n_s_c_buf, __pyx_k_c_buf, sizeof(__pyx_k_c_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_cur_buf, __pyx_k_cur_buf, sizeof(__pyx_k_cur_buf), 0, 0, 1, 1},
+    {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
+    {&__pyx_n_s_directions, __pyx_k_directions, sizeof(__pyx_k_directions), 0, 0, 1, 1},
+    {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+    {&__pyx_n_s_errcode, __pyx_k_errcode, sizeof(__pyx_k_errcode), 0, 0, 1, 1},
+    {&__pyx_n_s_exceptions, __pyx_k_exceptions, sizeof(__pyx_k_exceptions), 0, 0, 1, 1},
+    {&__pyx_n_s_find_eol, __pyx_k_find_eol, sizeof(__pyx_k_find_eol), 0, 0, 1, 1},
+    {&__pyx_n_s_handle_error_codes, __pyx_k_handle_error_codes, sizeof(__pyx_k_handle_error_codes), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_new_pos, __pyx_k_new_pos, sizeof(__pyx_k_new_pos), 0, 0, 1, 1},
+    {&__pyx_n_s_pos, __pyx_k_pos, sizeof(__pyx_k_pos), 0, 0, 1, 1},
+    {&__pyx_n_s_readfds, __pyx_k_readfds, sizeof(__pyx_k_readfds), 0, 0, 1, 1},
+    {&__pyx_n_s_required_version, __pyx_k_required_version, sizeof(__pyx_k_required_version), 0, 0, 1, 1},
+    {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1},
+    {&__pyx_n_s_session, __pyx_k_session, sizeof(__pyx_k_session), 0, 0, 1, 1},
+    {&__pyx_n_s_socket, __pyx_k_socket, sizeof(__pyx_k_socket), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_exit, __pyx_k_ssh2_exit, sizeof(__pyx_k_ssh2_exit), 0, 0, 1, 1},
+    {&__pyx_n_s_ssh2_utils, __pyx_k_ssh2_utils, sizeof(__pyx_k_ssh2_utils), 0, 0, 1, 1},
+    {&__pyx_kp_s_ssh2_utils_pyx, __pyx_k_ssh2_utils_pyx, sizeof(__pyx_k_ssh2_utils_pyx), 0, 0, 1, 0},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1},
+    {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0},
+    {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1},
+    {&__pyx_n_s_wait_socket, __pyx_k_wait_socket, sizeof(__pyx_k_wait_socket), 0, 0, 1, 1},
+    {&__pyx_n_s_writefds, __pyx_k_writefds, sizeof(__pyx_k_writefds), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
   return 0;
 }
+/* #### Code section: cached_constants ### */
 
 static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
@@ -4378,10 +5848,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *     """Find end-of-line in buffer from position and return end position of
  *     line and where next find_eol should start from.
  */
-  __pyx_tuple_ = PyTuple_Pack(7, __pyx_n_s_buf, __pyx_n_s_pos, __pyx_n_s_buf_len, __pyx_n_s_cur_buf, __pyx_n_s_c_buf, __pyx_n_s_index, __pyx_n_s_new_pos); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
-  __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(2, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_find_eol, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_tuple__3 = PyTuple_Pack(7, __pyx_n_s_buf, __pyx_n_s_pos, __pyx_n_s_buf_len, __pyx_n_s_cur_buf, __pyx_n_s_c_buf, __pyx_n_s_index, __pyx_n_s_new_pos); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_find_eol, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 51, __pyx_L1_error)
 
   /* "ssh2/utils.pyx":78
  * 
@@ -4390,10 +5860,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *     """Get libssh2 version string.
  * 
  */
-  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_n_s_required_version, __pyx_n_s_version); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 78, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
-  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_version, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __pyx_tuple__5 = PyTuple_Pack(2, __pyx_n_s_required_version, __pyx_n_s_version); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_version, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 78, __pyx_L1_error)
 
   /* "ssh2/utils.pyx":95
  * 
@@ -4402,7 +5872,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *     """Call libssh2_exit"""
  *     c_ssh2.libssh2_exit()
  */
-  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_ssh2_exit, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_ssh2_exit, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 95, __pyx_L1_error)
 
   /* "ssh2/utils.pyx":100
  * 
@@ -4411,19 +5881,35 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  *     """Helper function for testing non-blocking mode.
  * 
  */
-  __pyx_tuple__6 = PyTuple_Pack(6, __pyx_n_s_socket, __pyx_n_s_session, __pyx_n_s_timeout, __pyx_n_s_directions, __pyx_n_s_readfds, __pyx_n_s_writefds); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 100, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
-  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_wait_socket, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_tuple__8 = PyTuple_Pack(6, __pyx_n_s_socket, __pyx_n_s_session, __pyx_n_s_timeout, __pyx_n_s_directions, __pyx_n_s_readfds, __pyx_n_s_writefds); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_wait_socket, 100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_tuple__10 = PyTuple_Pack(1, ((PyObject *)__pyx_int_1)); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+  /* "ssh2/utils.pyx":116
+ * 
+ * 
+ * cpdef int handle_error_codes(int errcode) except -1:             # <<<<<<<<<<<<<<
+ *     """Raise appropriate exception for given error code.
+ * 
+ */
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_errcode); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_ssh2_utils_pyx, __pyx_n_s_handle_error_codes, 116, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 116, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
   __Pyx_RefNannyFinishContext();
   return -1;
 }
+/* #### Code section: init_constants ### */
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -4431,6 +5917,12 @@ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
   __pyx_L1_error:;
   return -1;
 }
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
 
 static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
 static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
@@ -4492,10 +5984,8 @@ static int __Pyx_modinit_type_import_code(void) {
   /*--- Type import code ---*/
   __pyx_t_1 = PyImport_ImportModule("ssh2.session"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 19, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(1, 19, __pyx_L1_error)
-  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(1, 26, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_Session = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "Session", sizeof(struct __pyx_obj_4ssh2_7session_Session), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_Session),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_Session) __PYX_ERR(1, 19, __pyx_L1_error)
+  __pyx_ptype_4ssh2_7session_MethodType = __Pyx_ImportType_3_0_11(__pyx_t_1, "ssh2.session", "MethodType", sizeof(struct __pyx_obj_4ssh2_7session_MethodType), __PYX_GET_STRUCT_ALIGNMENT_3_0_11(struct __pyx_obj_4ssh2_7session_MethodType),__Pyx_ImportType_CheckSize_Warn_3_0_11); if (!__pyx_ptype_4ssh2_7session_MethodType) __PYX_ERR(1, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_RefNannyFinishContext();
   return 0;
@@ -4522,6 +6012,55 @@ static int __Pyx_modinit_function_import_code(void) {
 }
 
 
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_utils(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_utils},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "utils",
+      0, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
 #ifndef CYTHON_NO_PYINIT_EXPORT
 #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
 #elif PY_MAJOR_VERSION < 3
@@ -4572,12 +6111,21 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
     }
     return 0;
 }
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
     PyObject *value = PyObject_GetAttrString(spec, from_name);
     int result = 0;
     if (likely(value)) {
         if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
             result = PyDict_SetItemString(moddict, to_name, value);
+#endif
         }
         Py_DECREF(value);
     } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
@@ -4587,8 +6135,9 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject
     }
     return result;
 }
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
     PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
     if (__Pyx_check_single_interpreter())
         return NULL;
     if (__pyx_m)
@@ -4598,8 +6147,12 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU
     module = PyModule_NewObject(modname);
     Py_DECREF(modname);
     if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
     moddict = PyModule_GetDict(module);
     if (unlikely(!moddict)) goto bad;
+#endif
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
     if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
@@ -4615,8 +6168,13 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_utils(PyObject *__pyx_pyinit_modul
 #endif
 #endif
 {
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
@@ -4630,6 +6188,33 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_utils(PyObject *__pyx_pyinit_modul
   #elif PY_MAJOR_VERSION >= 3
   if (__pyx_m) return __Pyx_NewRef(__pyx_m);
   #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("utils", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "utils" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if CYTHON_REFNANNY
 __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
 if (!__Pyx_RefNanny) {
@@ -4640,7 +6225,7 @@ if (!__Pyx_RefNanny) {
 }
 #endif
   __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_utils(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pxy_PyFrame_Initialize_Offsets
   __Pxy_PyFrame_Initialize_Offsets();
   #endif
@@ -4648,48 +6233,31 @@ if (!__Pyx_RefNanny) {
   __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
   __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
   #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
   /*--- Library function declarations ---*/
   /*--- Threads initialization code ---*/
   #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
   PyEval_InitThreads();
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("utils", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
   /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
   if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -4701,7 +6269,7 @@ if (!__Pyx_RefNanny) {
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
     if (!PyDict_GetItemString(modules, "ssh2.utils")) {
-      if (unlikely(PyDict_SetItemString(modules, "ssh2.utils", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+      if (unlikely((PyDict_SetItemString(modules, "ssh2.utils", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -4712,9 +6280,9 @@ if (!__Pyx_RefNanny) {
   /*--- Global type/function init code ---*/
   (void)__Pyx_modinit_global_init_code();
   (void)__Pyx_modinit_variable_export_code();
-  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_function_export_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_type_init_code();
-  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
   (void)__Pyx_modinit_variable_import_code();
   (void)__Pyx_modinit_function_import_code();
   /*--- Execution code ---*/
@@ -4729,30 +6297,39 @@ if (!__Pyx_RefNanny) {
  * 
  * from cpython.version cimport PY_MAJOR_VERSION
  */
-  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_INCREF(__pyx_n_s_select);
   __Pyx_GIVEREF(__pyx_n_s_select);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_select);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_select, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_select)) __PYX_ERR(0, 17, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_select, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_select); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_select); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_select, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_select, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "ssh2/utils.pyx":22
  * 
- * from session cimport Session
- * import exceptions             # <<<<<<<<<<<<<<
- * cimport c_ssh2
- * cimport error_codes
+ * from .session cimport Session
+ * from . import exceptions             # <<<<<<<<<<<<<<
+ * from . cimport c_ssh2
+ * from . cimport error_codes
  */
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_exceptions, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_n_s_exceptions);
+  __Pyx_GIVEREF(__pyx_n_s_exceptions);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_exceptions)) __PYX_ERR(0, 22, __pyx_L1_error);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s__2, __pyx_t_3, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_exceptions, __pyx_t_2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_exceptions); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_exceptions, __pyx_t_3) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "ssh2/utils.pyx":27
@@ -4762,7 +6339,7 @@ if (!__Pyx_RefNanny) {
  * 
  * 
  */
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODING, __pyx_kp_s_utf_8) < 0) __PYX_ERR(0, 27, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODING, __pyx_kp_u_utf_8) < 0) __PYX_ERR(0, 27, __pyx_L1_error)
 
   /* "ssh2/utils.pyx":51
  * 
@@ -4771,7 +6348,7 @@ if (!__Pyx_RefNanny) {
  *     """Find end-of-line in buffer from position and return end position of
  *     line and where next find_eol should start from.
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4ssh2_5utils_1find_eol, NULL, __pyx_n_s_ssh2_utils); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5utils_1find_eol, 0, __pyx_n_s_find_eol, NULL, __pyx_n_s_ssh2_utils, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_eol, __pyx_t_2) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -4783,8 +6360,17 @@ if (!__Pyx_RefNanny) {
  *     """Get libssh2 version string.
  * 
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4ssh2_5utils_3version, NULL, __pyx_n_s_ssh2_utils); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5utils_3version, 0, __pyx_n_s_version, NULL, __pyx_n_s_ssh2_utils, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_t_2) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
@@ -4795,7 +6381,7 @@ if (!__Pyx_RefNanny) {
  *     """Call libssh2_exit"""
  *     c_ssh2.libssh2_exit()
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4ssh2_5utils_5ssh2_exit, NULL, __pyx_n_s_ssh2_utils); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5utils_5ssh2_exit, 0, __pyx_n_s_ssh2_exit, NULL, __pyx_n_s_ssh2_utils, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_ssh2_exit, __pyx_t_2) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -4807,11 +6393,24 @@ if (!__Pyx_RefNanny) {
  *     """Helper function for testing non-blocking mode.
  * 
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4ssh2_5utils_7wait_socket, NULL, __pyx_n_s_ssh2_utils); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5utils_7wait_socket, 0, __pyx_n_s_wait_socket, NULL, __pyx_n_s_ssh2_utils, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__10);
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_wait_socket, __pyx_t_2) < 0) __PYX_ERR(0, 100, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+  /* "ssh2/utils.pyx":116
+ * 
+ * 
+ * cpdef int handle_error_codes(int errcode) except -1:             # <<<<<<<<<<<<<<
+ *     """Raise appropriate exception for given error code.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4ssh2_5utils_9handle_error_codes, 0, __pyx_n_s_handle_error_codes, NULL, __pyx_n_s_ssh2_utils, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_handle_error_codes, __pyx_t_2) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
   /* "ssh2/utils.pyx":1
  * # This file is part of ssh2-python.             # <<<<<<<<<<<<<<
  * # Copyright (C) 2017-2020 Panos Kittenis
@@ -4826,13 +6425,23 @@ if (!__Pyx_RefNanny) {
 
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
   if (__pyx_m) {
-    if (__pyx_d) {
+    if (__pyx_d && stringtab_initialized) {
       __Pyx_AddTraceback("init ssh2.utils", __pyx_clineno, __pyx_lineno, __pyx_filename);
     }
+    #if !CYTHON_USE_MODULE_STATE
     Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
   } else if (!PyErr_Occurred()) {
     PyErr_SetString(PyExc_ImportError, "init ssh2.utils");
   }
@@ -4846,6 +6455,22 @@ if (!__Pyx_RefNanny) {
   return;
   #endif
 }
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
 
 /* --- Runtime support code --- */
 /* Refnanny */
@@ -4865,8 +6490,19 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 }
 #endif
 
-/* PyObjectGetAttrStr */
-#if CYTHON_USE_TYPE_SLOTS
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
     PyTypeObject* tp = Py_TYPE(obj);
     if (likely(tp->tp_getattro))
@@ -4879,10 +6515,141 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 }
 #endif
 
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
 /* GetBuiltinName */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
         PyErr_Format(PyExc_NameError,
 #if PY_MAJOR_VERSION >= 3
             "name '%U' is not defined", name);
@@ -4928,7 +6695,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 {
     PyObject *result;
 #if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
     result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
@@ -4936,6 +6703,14 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     } else if (unlikely(PyErr_Occurred())) {
         return NULL;
     }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
 #else
     result = PyDict_GetItem(__pyx_d, name);
     __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
@@ -4954,31 +6729,8 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
     return __Pyx_GetBuiltinName(name);
 }
 
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
-    }
-}
-#endif
-
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
 static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
@@ -5007,7 +6759,6 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -5023,9 +6774,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
         return NULL;
     }
+    #endif
     if (
 #if PY_MAJOR_VERSION >= 3
             co->co_kwonlyargcount == 0 &&
@@ -5094,7 +6851,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     return result;
 }
 #endif
-#endif
 
 /* PyObjectCall */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -5103,8 +6859,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
     ternaryfunc call = Py_TYPE(func)->tp_call;
     if (unlikely(!call))
         return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = (*call)(func, arg, kw);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -5116,44 +6877,20 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 }
 #endif
 
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
-    }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
-    }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
-}
-
 /* PyObjectCallMethO */
 #if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
     PyObject *self, *result;
     PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
         return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
     result = cfunc(self, arg);
     Py_LeaveRecursiveCall();
     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
@@ -5165,45 +6902,308 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
 }
 #endif
 
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
     return result;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
     if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
     }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
 #endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
         }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
+#endif
 }
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
 #else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
 }
 #endif
+#endif
 
 /* RaiseArgTupleInvalid */
 static void __Pyx_RaiseArgtupleInvalid(
@@ -5248,6 +7248,7 @@ static void __Pyx_RaiseDoubleKeywordsError(
 /* ParseKeywords */
 static int __Pyx_ParseOptionalKeywords(
     PyObject *kwds,
+    PyObject *const *kwvalues,
     PyObject **argnames[],
     PyObject *kwds2,
     PyObject *values[],
@@ -5258,13 +7259,54 @@ static int __Pyx_ParseOptionalKeywords(
     Py_ssize_t pos = 0;
     PyObject*** name;
     PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
         name = first_kw_arg;
         while (*name && (**name != key)) name++;
         if (*name) {
             values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
             continue;
         }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
         name = first_kw_arg;
         #if PY_MAJOR_VERSION < 3
         if (likely(PyString_Check(key))) {
@@ -5272,6 +7314,9 @@ static int __Pyx_ParseOptionalKeywords(
                 if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                         && _PyString_Eq(**name, key)) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -5292,14 +7337,18 @@ static int __Pyx_ParseOptionalKeywords(
         #endif
         if (likely(PyUnicode_Check(key))) {
             while (*name) {
-                int cmp = (**name == key) ? 0 :
+                int cmp = (
                 #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                     (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                 #endif
-                    PyUnicode_Compare(**name, key);
+                    PyUnicode_Compare(**name, key)
+                );
                 if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                 if (cmp == 0) {
                     values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
                     break;
                 }
                 name++;
@@ -5326,6 +7375,8 @@ static int __Pyx_ParseOptionalKeywords(
             goto invalid_keyword;
         }
     }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return 0;
 arg_passed_twice:
     __Pyx_RaiseDoubleKeywordsError(function_name, key);
@@ -5335,21 +7386,26 @@ static int __Pyx_ParseOptionalKeywords(
         "%.200s() keywords must be strings", function_name);
     goto bad;
 invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
     #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
         "%.200s() got an unexpected keyword argument '%.200s'",
         function_name, PyString_AsString(key));
     #else
+    PyErr_Format(PyExc_TypeError,
         "%s() got an unexpected keyword argument '%U'",
         function_name, key);
     #endif
 bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
     return -1;
 }
 
 /* ArgTypeTest */
 static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
@@ -5362,63 +7418,21 @@ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *nam
     else {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
     }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
-/* PyObjectCallNoArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
-    }
-#endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
-        }
-    }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
-}
-#endif
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
-#endif
-
 /* RaiseException */
 #if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
@@ -5551,13 +7565,9 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
     }
     PyErr_SetObject(type, value);
     if (tb) {
-#if CYTHON_COMPILING_IN_PYPY
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#else
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
         PyThreadState *tstate = __Pyx_PyThreadState_Current;
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
@@ -5565,6 +7575,12 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
 #endif
     }
 bad:
@@ -5574,16 +7590,18 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject
 #endif
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_0_11
+#define __PYX_HAVE_RT_ImportType_3_0_11
+static PyTypeObject *__Pyx_ImportType_3_0_11(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_11 check_size)
 {
     PyObject *result = 0;
     char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
@@ -5594,8 +7612,9 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
             module_name, class_name);
         goto bad;
     }
-#ifndef Py_LIMITED_API
+#if !CYTHON_COMPILING_IN_LIMITED_API
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
 #else
     py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
     if (!py_basicsize)
@@ -5605,22 +7624,38 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
     py_basicsize = 0;
     if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
         goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
 #endif
-    if ((size_t)basicsize < size) {
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            module_name, class_name, size, basicsize+itemsize);
         goto bad;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_11 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
         goto bad;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_11 && (size_t)basicsize > size) {
         PyOS_snprintf(warning, sizeof(warning),
             "%s.%s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
@@ -5636,39 +7671,32 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
 
 /* Import */
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
     PyObject *module = 0;
-    PyObject *global_dict = 0;
     PyObject *empty_dict = 0;
-    PyObject *list;
+    PyObject *empty_list = 0;
     #if PY_MAJOR_VERSION < 3
     PyObject *py_import;
     py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
+    if (unlikely(!py_import))
         goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
+    if (!from_list) {
         empty_list = PyList_New(0);
-        if (!empty_list)
+        if (unlikely(!empty_list))
             goto bad;
-        list = empty_list;
+        from_list = empty_list;
     }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
+    #endif
     empty_dict = PyDict_New();
-    if (!empty_dict)
+    if (unlikely(!empty_dict))
         goto bad;
     {
         #if PY_MAJOR_VERSION >= 3
         if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
                 module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
                         goto bad;
                     PyErr_Clear();
                 }
@@ -5679,48 +7707,1331 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
         if (!module) {
             #if PY_MAJOR_VERSION < 3
             PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
+            if (unlikely(!py_level))
                 goto bad;
             module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
             Py_DECREF(py_level);
             #else
             module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
+                name, __pyx_d, empty_dict, from_list, level);
             #endif
         }
     }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    return module;
+}
+
+/* ImportFrom */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u_);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
 }
 
-/* ImportFrom */
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
-    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
-    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
-        #else
-            "cannot import name %S", name);
-        #endif
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-    return value;
+    return op;
 }
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -5734,7 +9045,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -5756,6 +9067,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -5834,17 +9146,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -5879,6 +9275,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -5894,7 +9291,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -5941,6 +9338,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
 
 /* CIntFromPyVerify */
 #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
@@ -5977,7 +9375,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -5986,168 +9384,239 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
             }
             return (int) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
                             return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
                             return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
                             return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (int) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
                             return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
                             return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
                             return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            int val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (int) -1;
-        }
-    } else {
-        int val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (int) -1;
-        val = __Pyx_PyInt_As_int(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -6191,12 +9660,61 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(int),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__13);
     }
+    return name;
 }
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -6229,10 +9747,43 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
         }
     }
     {
-        int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -6249,7 +9800,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -6258,168 +9809,239 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
             }
             return (long) val;
         }
-    } else
+    }
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
                             return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
                             return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
                             return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
 #else
-            {
-                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
-                if (unlikely(result < 0))
-                    return (long) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
                             return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
                             return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
                             return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            long val;
-            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
-            if (likely(v) && !PyLong_Check(v)) {
-                PyObject *tmp = v;
-                v = PyNumber_Long(tmp);
-                Py_DECREF(tmp);
-            }
- #endif
-            if (likely(v)) {
-                int one = 1; int is_little = (int)*(unsigned char *)&one;
-                unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (long) -1;
-        }
-    } else {
-        long val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (long) -1;
-        val = __Pyx_PyInt_As_long(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -6436,7 +10058,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -6457,6 +10079,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -6481,11 +10119,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -6533,41 +10171,50 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 #endif
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* FunctionExport */
@@ -6589,11 +10236,7 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
             goto bad;
     }
     tmp.fp = f;
-#if PY_VERSION_HEX >= 0x02070000
     cobj = PyCapsule_New(tmp.p, sig, 0);
-#else
-    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
-#endif
     if (!cobj)
         goto bad;
     if (PyDict_SetItemString(d, name, cobj) < 0)
@@ -6608,9 +10251,31 @@ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *s
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -6618,30 +10283,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -6696,7 +10365,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -6725,22 +10394,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -6806,13 +10479,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -6880,4 +10551,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/ssh2/utils.pyx b/ssh2/utils.pyx
index ff2f4d63..23483e6e 100644
--- a/ssh2/utils.pyx
+++ b/ssh2/utils.pyx
@@ -18,10 +18,10 @@ from select import select
 
 from cpython.version cimport PY_MAJOR_VERSION
 
-from session cimport Session
-import exceptions
-cimport c_ssh2
-cimport error_codes
+from .session cimport Session
+from . import exceptions
+from . cimport c_ssh2
+from . cimport error_codes
 
 
 ENCODING='utf-8'
diff --git a/tests/base_test.py b/tests/base_test.py
index 79cbf7b3..37b67242 100644
--- a/tests/base_test.py
+++ b/tests/base_test.py
@@ -1,49 +1,7 @@
 import unittest
-import pwd
-import os
-import socket
-from sys import version_info
-
-from .embedded_server.openssh import OpenSSHServer
-from ssh2.session import Session
-
-
-PKEY_FILENAME = os.path.sep.join([os.path.dirname(__file__), 'unit_test_key'])
-PUB_FILE = "%s.pub" % (PKEY_FILENAME,)
 
 
 class SSH2TestCase(unittest.TestCase):
 
-    @classmethod
-    def setUpClass(cls):
-        _mask = int('0600') if version_info <= (2,) else 0o600
-        os.chmod(PKEY_FILENAME, _mask)
-        cls.server = OpenSSHServer()
-        cls.server.start_server()
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.server.stop()
-        del cls.server
-
     def setUp(self):
-        self.host = '127.0.0.1'
         self.port = 2222
-        self.cmd = 'echo me'
-        self.resp = u'me'
-        self.user_key = PKEY_FILENAME
-        self.user_pub_key = PUB_FILE
-        self.user = pwd.getpwuid(os.geteuid()).pw_name
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.connect((self.host, self.port))
-        self.sock = sock
-        self.session = Session()
-        self.session.handshake(self.sock)
-
-    def tearDown(self):
-        self.session.disconnect()
-        self.sock.close()
-
-    def _auth(self):
-        return self.session.userauth_publickey_fromfile(
-            self.user, self.user_key)
diff --git a/tests/embedded_server/sshd_config.tmpl b/tests/embedded_server/sshd_config.tmpl
deleted file mode 100644
index 1e5391a9..00000000
--- a/tests/embedded_server/sshd_config.tmpl
+++ /dev/null
@@ -1,9 +0,0 @@
-Protocol 2
-UsePAM yes
-HostbasedAuthentication no
-IgnoreUserKnownHosts yes
-ListenAddress 127.0.0.1
-
-AcceptEnv LANG LC_*
-Subsystem sftp internal-sftp
-AuthorizedKeysFile {{parent_dir}}/authorized_keys
diff --git a/tests/test_agent.py b/tests/test_agent.py
index 7a191a4d..22a415ff 100644
--- a/tests/test_agent.py
+++ b/tests/test_agent.py
@@ -1,37 +1,12 @@
-import os
-import socket
-from unittest import skipUnless
+from ssh2.agent import Agent
+from ssh2.session import Session
 
 from .base_test import SSH2TestCase
-from ssh2.session import Session, LIBSSH2_HOSTKEY_HASH_MD5, \
-    LIBSSH2_HOSTKEY_HASH_SHA1
-# from ssh2.sftp import SFTP
-from ssh2.agent import Agent
-# from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
-from ssh2.exceptions import AuthenticationError, AgentAuthenticationError, \
-    SCPProtocolError, RequestDeniedError, InvalidRequestError, \
-    SocketSendError, FileError, PublickeyUnverifiedError
-from ssh2.utils import wait_socket
 
 
 class SessionTestCase(SSH2TestCase):
 
-    def test_agent_pyobject(self):
-        agent = Agent(self.session)
+    def test_agent(self):
+        session = Session()
+        agent = Agent(session)
         self.assertIsInstance(agent, Agent)
-
-    def test_agent_get_identities(self):
-        agent = Agent(self.session)
-        agent.connect()
-        ids = agent.get_identities()
-        self.assertIsInstance(ids, list)
-        agent.disconnect()
-
-    def test_agent_id_path(self):
-        agent = Agent(self.session)
-        agent.connect()
-        _path = b'my_path'
-        agent.set_identity_path(_path)
-        path = agent.get_identity_path()
-        self.assertEqual(_path, path)
-        agent.disconnect()
diff --git a/tests/test_channel.py b/tests/test_channel.py
index 9e616f9e..ae344e19 100644
--- a/tests/test_channel.py
+++ b/tests/test_channel.py
@@ -1,188 +1,13 @@
-import os
-
-from unittest import skipUnless
-from subprocess import check_output
+from ssh2.channel import Channel
+from ssh2.session import Session
 
 from .base_test import SSH2TestCase
 
-from ssh2.exceptions import SocketSendError
-from ssh2.session import Session
-from ssh2.channel import Channel
-
 
 class ChannelTestCase(SSH2TestCase):
 
     def test_init(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
+        session = Session()
+        chan = Channel(session)
         self.assertIsInstance(chan, Channel)
-        self.assertIsInstance(chan.session, Session)
-        self.assertEqual(chan.session, self.session)
-
-    def test_execute(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        self.assertTrue(chan is not None)
-        self.assertTrue(chan.execute(self.cmd) == 0)
-        size, data = chan.read()
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertTrue(size > 0)
-        self.assertTrue(lines, [self.resp])
-        self.assertEqual(chan.wait_eof(), 0)
-        self.assertEqual(chan.wait_closed(), 0)
-
-    def test_exit_code(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        chan.execute('exit 2')
-        chan.wait_eof()
-        chan.close()
-        chan.wait_closed()
-        exit_code = chan.get_exit_status()
-        self.assertEqual(exit_code, 2)
-
-    def test_long_running_execute(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        chan.execute('sleep 1; exit 3')
-        self.assertTrue(chan.wait_eof() == 0)
-        self.assertTrue(chan.close() == 0)
-        self.assertTrue(chan.wait_closed() == 0)
-        self.assertEqual(chan.get_exit_status(), 3)
-
-    def test_read_stderr(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        expected = ['stderr output']
-        chan.execute('echo "stderr output" >&2')
-        size, data = chan.read_stderr()
-        self.assertTrue(size > 0)
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertListEqual(expected, lines)
-
-    def test_pty(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        self.assertTrue(chan.pty() == 0)
-        _out = u'stderr output'
-        expected = [_out]
-        chan.execute(u'echo "%s" >&2' % (_out,))
-        # stderr output gets redirected to stdout with a PTY
-        size, data = chan.read()
-        self.assertTrue(size > 0)
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertListEqual(expected, lines)
-
-    def test_pty_failure(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        self.sock.close()
-        self.assertRaises(SocketSendError, chan.pty)
-
-    def test_write_stdin(self):
-        self.assertEqual(self._auth(), 0)
-        _in = u'writing to stdin'
-        chan = self.session.open_session()
-        chan.execute('cat')
-        chan.write(_in + '\n')
-        self.assertEqual(chan.send_eof(), 0)
-        size, data = chan.read()
-        self.assertTrue(size > 0)
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertListEqual([_in], lines)
-        chan.close()
-        self.assertEqual(chan.wait_eof(), 0)
-        self.assertTrue(chan.eof())
-        self.assertEqual(chan.wait_closed(), 0)
-
-    def test_write_ex(self):
-        self.assertEqual(self._auth(), 0)
-        _in = u'writing to stdin'
-        chan = self.session.open_session()
-        chan.execute('cat')
-        chan.write_ex(0, _in + '\n')
-        self.assertEqual(chan.send_eof(), 0)
-        size, data = chan.read()
-        self.assertTrue(size > 0)
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertListEqual([_in], lines)
-
-    def test_write_stderr(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        chan.execute('echo something')
-        _in = u'stderr'
-        self.assertTrue(chan.write_stderr(_in + '\n')[0] > 0)
-        self.assertEqual(chan.close(), 0)
-
-    def test_setenv(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        _var = 'LC_MY_VAR'
-        _val = 'value'
-        self.assertEqual(chan.setenv('LC_MY_VAR', _val), 0)
-        chan.execute('env | grep LC_MY_VAR')
-        expected = u'%s=%s\n' % (_var, _val)
-        size, data = chan.read()
-        self.assertTrue(size > 0)
-        self.assertEqual(data.decode('utf-8'), expected)
-
-    def test_shell(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        self.assertTrue(chan is not None)
-        self.assertEqual(chan.shell(), 0)
-        chan.write('echo me\n')
-        size, data = chan.read()
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertTrue(size > 0)
-        self.assertTrue(lines, [self.resp])
-        self.assertTrue(chan.close() == 0)
-        self.assertTrue(chan.wait_eof() == 0)
-
-    def test_process_startup(self):
-        self.assertEqual(self._auth(), 0)
-        # Shell
-        chan = self.session.open_session()
-        self.assertTrue(chan is not None)
-        self.assertEqual(chan.process_startup('shell'), 0)
-        chan.write('echo me\n')
-        size, data = chan.read()
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertTrue(size > 0)
-        self.assertTrue(lines, [self.resp])
-        self.assertTrue(chan.close() == 0)
-        self.assertTrue(chan.wait_eof() == 0)
-        # Exec
-        chan = self.session.open_session()
-        self.assertTrue(chan is not None)
-        self.assertEqual(chan.process_startup('exec', self.cmd), 0)
-        size, data = chan.read()
-        lines = [line.decode('utf-8') for line in data.splitlines()]
-        self.assertTrue(size > 0)
-        self.assertTrue(lines, [self.resp])
-        self.assertTrue(chan.close() == 0)
-        self.assertTrue(chan.wait_eof() == 0)
-
-    @skipUnless(hasattr(Channel, 'request_auth_agent'),
-                "No agent forwarding implementation")
-    def test_agent_forwarding(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.open_session()
-        self.assertEqual(chan.request_auth_agent(), 0)
-
-    def test_read_file(self):
-        self._auth()
-        wc_output = check_output(['wc', '-l', 'ssh2/sftp_handle.c']).split()[0]
-        abs_file = os.sep.join([
-            os.path.dirname(__file__), '..', 'ssh2', 'sftp_handle.c',
-        ])
-        chan = self.session.open_session()
-        chan.execute('cat %s' % (abs_file,))
-        tot_data = b""
-        size, data = chan.read()
-        while size > 0:
-            tot_data += data
-            size, data = chan.read()
-        lines = [line for line in tot_data.splitlines()]
-        self.assertEqual(len(lines), int(wc_output))
+        self.assertEqual(chan.session, session)
diff --git a/tests/test_knownhost.py b/tests/test_knownhost.py
index 7e6b39d0..a1541a01 100644
--- a/tests/test_knownhost.py
+++ b/tests/test_knownhost.py
@@ -1,24 +1,24 @@
 import os
 from base64 import b64encode
 
+from ssh2.exceptions import KnownHostDeleteError
 from ssh2.knownhost import LIBSSH2_KNOWNHOST_TYPE_PLAIN, \
-    LIBSSH2_KNOWNHOST_KEYENC_RAW, LIBSSH2_KNOWNHOST_KEY_SSHRSA, \
-    LIBSSH2_KNOWNHOST_KEYENC_BASE64, LIBSSH2_KNOWNHOST_TYPE_SHA1, \
-    LIBSSH2_KNOWNHOST_KEY_SSHDSS
-from ssh2.session import LIBSSH2_HOSTKEY_HASH_SHA1, LIBSSH2_HOSTKEY_TYPE_RSA
-from ssh2.exceptions import KnownHostDeleteError, KnownHostCheckError
+    LIBSSH2_KNOWNHOST_KEYENC_RAW, LIBSSH2_KNOWNHOST_KEY_SSHRSA
+from ssh2.session import Session
+
+from .base_test import SSH2TestCase
 
-from .base_test import SSH2TestCase, PUB_FILE
 
 class KnownHostTestCase(SSH2TestCase):
 
+    def setUp(self):
+        self.session = Session()
+
     def test_knownhost_init(self):
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         self.assertTrue(kh is not None)
 
     def test_knownhost_readfile_get(self):
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         self.assertEqual(len(kh.get()), 0)
         _filename = os.sep.join([os.path.dirname(__file__),
@@ -31,7 +31,6 @@ def test_knownhost_readfile_get(self):
         self.assertEqual(len(keys), hosts_in_file)
 
     def test_knownhost_add_get_delete(self):
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         key = b"""AAAAB3NzaC1yc2EAAAABIwAAAQEAxacIa5+3xbfETKwLFTMg1KBOQi4XR/Kz2rRqLRhyBNg1Dok56qA2d5l3O/uTOthWy4K8qfpVIzL8/pxdehc4gtC2gbpiBTJn4ofyS2PmXFV2fCeshk5x554l2AgIObz1G1SEAw3x09xd/+2dfQgv7NJ7PPzDHkD+ifS9sncFo6AWTmS6/7gX9QGrh1y3AGziMnMGWkD+sF7u/Mgr9g7794wBzGryzLLpSmbVKdQ4yM4TLodUeAL2aYUiiO8qLK+AIox/nWSd4uixsYuhdyqCdxEQPPkHIieLUsTiMcMQDiAZEkUvyU0lv37bzqsM4yhqnTxpKJD9xD7XkMKENZ6d7Q=="""
         type_mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | \
@@ -54,7 +53,6 @@ def test_knownhost_add_get_delete(self):
             host, key, type_mask, comment=b'a comment') is not None)
 
     def test_writefile(self):
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         _filename = os.sep.join([os.path.dirname(__file__),
                                  'known_hosts'])
@@ -77,7 +75,6 @@ def test_writefile(self):
                 pass
 
     def test_add_writefile(self):
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         key = b"""AAAAB3NzaC1yc2EAAAABIwAAAQEAxacIa5+3xbfETKwLFTMg1KBOQi4XR/Kz2rRqLRhyBNg1Dok56qA2d5l3O/uTOthWy4K8qfpVIzL8/pxdehc4gtC2gbpiBTJn4ofyS2PmXFV2fCeshk5x554l2AgIObz1G1SEAw3x09xd/+2dfQgv7NJ7PPzDHkD+ifS9sncFo6AWTmS6/7gX9QGrh1y3AGziMnMGWkD+sF7u/Mgr9g7794wBzGryzLLpSmbVKdQ4yM4TLodUeAL2aYUiiO8qLK+AIox/nWSd4uixsYuhdyqCdxEQPPkHIieLUsTiMcMQDiAZEkUvyU0lv37bzqsM4yhqnTxpKJD9xD7XkMKENZ6d7Q=="""
         type_mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | \
@@ -104,7 +101,6 @@ def test_add_writefile(self):
 
     def test_readline_writeline(self):
         line = b"""10.0.0.1 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA8ZzI0FP2Q5DOAL0q/T8QPWmnz6sMxDOVQ34u4NUo4GZZ948RpeSIVA57hmLYWkq+Hx4idsCLyyvfkEzEieY4Zm5wDtjX5uInP695TrZHd2SmPJwwq3PYwdZfyCvkDyLC8VnKe1iKGdJ4sSiD83gIXLsvHzL6nZ4TiX+N4MXpxFHIh6yA6aSmYy5FIB8Gn5veU+XunmXxUQdwIhNRkQiK5laA3X3paDFlUAWFyeS40+B+IVAQnA655+7Nxza86Xe6PROmJvLefZlqR8W1EI73ea7AKSfZijqHzxbIJYCQIh3FfQXfiaC15xKnnslEZNTOkfCblawav5jL9sIuw3wO3w=="""
-        self.assertEqual(self._auth(), 0)
         kh = self.session.knownhost_init()
         kh.readline(line)
         keys = kh.get()
@@ -113,24 +109,3 @@ def test_readline_writeline(self):
         self.assertTrue(b64encode(entry.key) in line)
         written_line = kh.writeline(entry).strip()
         self.assertEqual(line, written_line)
-
-    def test_check(self):
-        self.assertEqual(self._auth(), 0)
-        kh = self.session.knownhost_init()
-        host_key, key_type = self.session.hostkey()
-        key_type = LIBSSH2_KNOWNHOST_KEY_SSHRSA \
-                   if key_type == LIBSSH2_HOSTKEY_TYPE_RSA \
-                      else LIBSSH2_KNOWNHOST_KEY_SSHDSS
-        type_mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | \
-                    LIBSSH2_KNOWNHOST_KEYENC_RAW | \
-                    key_type
-        # Verification should fail before key is added
-        self.assertRaises(
-            KnownHostCheckError, kh.checkp, b'127.0.0.1', self.port,
-            host_key, type_mask)
-        server_known_hosts = os.sep.join([os.path.dirname(__file__),
-                                          'embedded_server',
-                                          'known_hosts'])
-        self.assertEqual(kh.readfile(server_known_hosts), 1)
-        entry = kh.checkp(b'127.0.0.1', self.port, host_key, type_mask)
-        self.assertTrue(entry is not None)
diff --git a/tests/test_session.py b/tests/test_session.py
index d812fd1c..3e44d89e 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -1,313 +1,14 @@
-import os
-import socket
-from unittest import skipUnless
+from ssh2.session import Session, LIBSSH2_METHOD_HOSTKEY
 
 from .base_test import SSH2TestCase
-from ssh2.session import Session, LIBSSH2_HOSTKEY_HASH_MD5, \
-    LIBSSH2_HOSTKEY_HASH_SHA1, LIBSSH2_METHOD_KEX, LIBSSH2_METHOD_CRYPT_CS
-from ssh2.sftp import SFTP
-from ssh2.channel import Channel
-from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
-from ssh2.exceptions import AuthenticationError, AgentAuthenticationError, \
-    SCPProtocolError, RequestDeniedError, InvalidRequestError, \
-    SocketSendError, FileError, PublickeyUnverifiedError, MethodNotSupported
-from ssh2.utils import wait_socket
-from ssh2.listener import Listener
 
 
 class SessionTestCase(SSH2TestCase):
-
-    def test_pubkey_auth(self):
-        self.assertEqual(self.session.userauth_publickey_fromfile(
-            self.user, self.user_key, publickey=self.user_pub_key,
-            passphrase=''), 0)
-
-    def test_failed_password_auth(self):
-        self.assertRaises(
-            AuthenticationError,
-            self.session.userauth_password, 'FAKE USER', 'FAKE PASSWORD'
-        )
-
-    def test_failed_keyboard_interactive_auth(self):
-        self.assertRaises(
-            AuthenticationError,
-            self.session.userauth_keyboardinteractive, 'FAKE USER', 'FAKE PASSWORD'
-        )
-
-    def test_failed_keyboard_interactive_auth_valid_user(self):
-        self.assertRaises(
-            AuthenticationError,
-            self.session.userauth_keyboardinteractive, self.user, 'FAKE PASSWORD'
-        )
-
-    def test_failed_keyboard_interactive_auth_valid_user_no_pass(self):
-        self.assertRaises(
-            AuthenticationError,
-            self.session.userauth_keyboardinteractive, self.user, ''
-        )
-
-    def test_set_get_error(self):
-        msg = b'my error message'
-        self.assertEqual(b'', self.session.last_error())
-        self.assertEqual(self.session.set_last_error(255, msg), 255)
-        self.assertEqual(msg, self.session.last_error())
-
-    def test_fromfile_auth(self):
-        self.assertEqual(self._auth(), 0)
-        self.assertTrue(self.session.userauth_authenticated())
-
-    def test_get_auth_list(self):
-        auth_list = sorted(self.session.userauth_list(self.user))
-        expected = sorted(['publickey', 'password', 'keyboard-interactive'])
-        self.assertListEqual(auth_list, expected)
-
-    def test_direct_tcpip(self):
-        self.assertEqual(self._auth(), 0)
-        chan = self.session.direct_tcpip(self.host, self.port)
-        self.assertTrue(chan is not None)
-
-    def test_agent(self):
-        agent = self.session.agent_init()
-        self.assertTrue(agent.connect() == 0)
-
-    def test_session_get_set(self):
-        self.assertEqual(self._auth(), 0)
-        self.session.set_timeout(10)
-        self.assertEqual(self.session.get_timeout(), 10)
-        self.session.set_timeout(0)
-        self.assertEqual(self.session.get_timeout(), 0)
-        self.session.set_blocking(0)
-        self.assertEqual(self.session.get_blocking(), 0)
-        self.session.set_blocking(1)
-        self.assertEqual(self.session.get_blocking(), 1)
-
-    def test_failed_agent_auth(self):
-        self.assertRaises(AgentAuthenticationError,
-                          self.session.agent_auth, 'FAKE USER')
-
-    def test_failed_pkey_auth(self):
-        self.assertRaises(AuthenticationError,
-                          self.session.userauth_publickey_fromfile,
-                          'FAKE USER', self.user_key,
-                          publickey=self.user_pub_key)
-        self.assertRaises(FileError,
-                          self.session.userauth_publickey_fromfile,
-                          self.user, 'EVEN MORE FAKE FILE',
-                          publickey='FAKE FILE')
-
-    @skipUnless(hasattr(Session, 'scp_recv2'),
-                "Function not supported by libssh2")
-    def test_scp_recv2(self):
-        self.assertEqual(self._auth(), 0)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        try:
-            (file_chan, fileinfo) = self.session.scp_recv2(remote_filename)
-        except TypeError:
-            os.unlink(remote_filename)
-            raise
-        try:
-            total = 0
-            size, data = file_chan.read(size=fileinfo.st_size)
-            total += size
-            while total < fileinfo.st_size:
-                size, data = file_chan.read()
-                total += size
-            self.assertEqual(total, fileinfo.st_size)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-        self.assertRaises(SCPProtocolError, self.session.scp_recv2, remote_filename)
-
-    def test_scp_recv(self):
-        self.assertEqual(self._auth(), 0)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        try:
-            (file_chan, fileinfo) = self.session.scp_recv(remote_filename)
-        except TypeError:
-            os.unlink(remote_filename)
-            raise
-        try:
-            total = 0
-            size, data = file_chan.read(size=fileinfo.st_size)
-            total += size
-            while total < fileinfo.st_size:
-                total += size
-                size, data = file_chan.read()
-            self.assertEqual(total, fileinfo.st_size)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-        self.assertRaises(SCPProtocolError, self.session.scp_recv, remote_filename)
-
-    def test_scp_send(self):
-        self.assertEqual(self._auth(), 0)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        to_copy = os.sep.join([os.path.dirname(__file__),
-                               "copied"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        fileinfo = os.stat(remote_filename)
-        try:
-            chan = self.session.scp_send(
-                to_copy, fileinfo.st_mode & 777, fileinfo.st_size)
-            with open(remote_filename, 'rb') as local_fh:
-                for data in local_fh:
-                    chan.write(data)
-            chan.send_eof()
-            chan.wait_eof()
-            chan.wait_closed()
-            self.assertEqual(os.stat(to_copy).st_size,
-                             os.stat(remote_filename).st_size)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-            try:
-                os.unlink(to_copy)
-            except OSError:
-                pass
-        self.assertRaises(SCPProtocolError, self.session.scp_send,
-                          '/cannot_write', 1 & 777, 1)
-
-    @skipUnless(hasattr(Session, 'scp_send64'),
-                "Function not supported by libssh2")
-    def test_scp_send64(self):
-        self.assertEqual(self._auth(), 0)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        to_copy = os.sep.join([os.path.dirname(__file__),
-                               "copied"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        fileinfo = os.stat(remote_filename)
-        try:
-            chan = self.session.scp_send64(
-                to_copy, fileinfo.st_mode & 777, fileinfo.st_size,
-                fileinfo.st_mtime, fileinfo.st_atime)
-            with open(remote_filename, 'rb') as local_fh:
-                for data in local_fh:
-                    chan.write(data)
-            chan.send_eof()
-            chan.wait_eof()
-            chan.wait_closed()
-            self.assertEqual(os.stat(to_copy).st_size,
-                             os.stat(remote_filename).st_size)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-            try:
-                os.unlink(to_copy)
-            except OSError:
-                pass
-        self.assertRaises(SCPProtocolError, self.session.scp_send64,
-                          '/cannot_write', 0 & 777, 1, 1, 1)
-
-    def test_non_blocking(self):
-        self.assertEqual(self._auth(), 0)
-        self.session.set_blocking(False)
-        self.assertFalse(self.session.get_blocking())
-        sftp = self.session.sftp_init()
-        while sftp == LIBSSH2_ERROR_EAGAIN:
-            wait_socket(self.sock, self.session)
-            sftp = self.session.sftp_init()
-        self.assertIsNotNone(sftp)
-        self.assertIsInstance(sftp, SFTP)
-        chan = self.session.open_session()
-        while chan == LIBSSH2_ERROR_EAGAIN:
-            wait_socket(self.sock, self.session)
-            chan = self.session.open_session()
-        self.assertIsInstance(chan, Channel)
-
-    def test_non_blocking_handshake(self):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.connect((self.host, self.port))
+    def test_session(self):
         session = Session()
-        session.set_blocking(0)
-        while session.handshake(sock) == LIBSSH2_ERROR_EAGAIN:
-            continue
-
-    def test_hostkey(self):
-        self.assertEqual(self._auth(), 0)
-        for _type in [LIBSSH2_HOSTKEY_HASH_MD5, LIBSSH2_HOSTKEY_HASH_SHA1]:
-            hostkey = self.session.hostkey_hash(_type)
-            self.assertTrue(len(hostkey) > 0)
-
-    def test_forward_listen_ex(self):
-        self.assertEqual(self._auth(), 0)
-        listener, bound_port = self.session.forward_listen_ex(1)
-        self.assertIsInstance(listener, Listener)
-        self.assertIsInstance(bound_port, int)
-
-    def test_sftp_init_failure(self):
-        self.assertRaises(InvalidRequestError, self.session.sftp_init)
-
-    def test_open_channel_failure(self):
-        self.sock.close()
-        self.assertRaises(SocketSendError, self.session.open_session)
-
-    def test_direct_tcpip_failure(self):
-        self.sock.close()
-        self.assertRaises(SocketSendError, self.session.direct_tcpip,
-                          'localhost', 80)
-
-    def test_keepalive(self):
-        self.session.keepalive_config(False, 60)
-        seconds = self.session.keepalive_send()
-        self.assertTrue(seconds >= 59)
-        self.session.keepalive_config(False, 0)
-        self.assertEqual(self.session.keepalive_send(), 0)
-
-    def test_publickey_frommemory(self):
-
-        with open(self.user_key, 'rb') as pkey_f, \
-             open(self.user_pub_key, 'rb') as pubkey_f:
-            pkey = pkey_f.read()
-            pub_key = pubkey_f.read()
-        ret_val = self.session.userauth_publickey_frommemory(
-            self.user, pkey, publickeyfiledata=pub_key)
-        self.assertEqual(ret_val, 0)
-
-    def test_publickey_frommemory_no_publickey(self):
-        with open(self.user_key, 'rb') as pkey_f:
-            pkey = pkey_f.read()
-        ret_val = self.session.userauth_publickey_frommemory(
-            self.user, pkey)
-        self.assertEqual(ret_val, 0)
-
-    def test_publickey_frommemory_passphrase(self):
-        with open(self.user_key, 'rb') as pkey_f:
-            pkey = pkey_f.read()
-        ret_val = self.session.userauth_publickey_frommemory(
-            self.user, pkey,
-            passphrase="this still works when passphrase not required")
-        self.assertEqual(ret_val, 0)
+        self.assertIsInstance(session, Session)
 
     def test_methods(self):
-        methods = self.session.methods(LIBSSH2_METHOD_KEX)
-        self.assertTrue(len(methods) > 0)
-        methods = self.session.methods(LIBSSH2_METHOD_CRYPT_CS)
-        self.assertEqual(self.session.method_pref(LIBSSH2_METHOD_CRYPT_CS, methods), 0)
-        algs = self.session.supported_algs(LIBSSH2_METHOD_CRYPT_CS)
-        self.assertTrue(len(algs) > 0)
-        alg = algs[0]
-        self.assertEqual(self.session.method_pref(LIBSSH2_METHOD_CRYPT_CS, alg), 0)
-
-    def test_invalid_methods(self):
-        self.assertRaises(
-            MethodNotSupported,
-            self.session.method_pref, LIBSSH2_METHOD_CRYPT_CS, 'invalid algorithm')
-        self.assertRaises(TypeError, self.session.method_pref, 0, 'fake')
+        session = Session()
+        methods = session.methods(LIBSSH2_METHOD_HOSTKEY)
+        self.assertIsNone(methods)
diff --git a/tests/test_sftp.py b/tests/test_sftp.py
index 65273b4e..a7edc5c5 100644
--- a/tests/test_sftp.py
+++ b/tests/test_sftp.py
@@ -1,329 +1,23 @@
-import os
-import platform
-import stat
-from sys import version_info
-from unittest import skipUnless
-import shutil
+from ssh2.session import Session
+from ssh2.sftp import SFTP
+from ssh2.sftp_handle import SFTPAttributes
 
 from .base_test import SSH2TestCase
-from ssh2.session import Session
-from ssh2.error_codes import LIBSSH2_ERROR_EAGAIN
-from ssh2.utils import wait_socket
-from ssh2.sftp_handle import SFTPHandle, SFTPAttributes
-from ssh2.exceptions import SFTPProtocolError, BufferTooSmallError
-from ssh2.sftp import LIBSSH2_FXF_CREAT, LIBSSH2_FXF_WRITE, \
-    LIBSSH2_SFTP_S_IRUSR, LIBSSH2_SFTP_S_IRGRP, LIBSSH2_SFTP_S_IWUSR, \
-    LIBSSH2_SFTP_S_IROTH, LIBSSH2_SFTP_S_IXUSR, SFTP, \
-    LIBSSH2_SFTP_S_IWUSR, LIBSSH2_SFTP_S_IWGRP, LIBSSH2_SFTP_S_IWOTH, \
-    LIBSSH2_SFTP_ATTR_PERMISSIONS
 
 
 class SFTPTestCase(SSH2TestCase):
 
     def test_init(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
+        session = Session()
+        sftp = SFTP(session)
         self.assertIsInstance(sftp, SFTP)
         self.assertIsInstance(sftp.session, Session)
-        self.assertEqual(sftp.session, self.session)
-
-    def test_sftp_read(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        if int(platform.python_version_tuple()[0]) >= 3:
-            test_file_data = b'test' + bytes(os.linesep, 'utf-8')
-        else:
-            test_file_data = b'test' + os.linesep
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       'remote_test_file'])
-        with open(remote_filename, 'wb') as test_fh:
-            test_fh.write(test_file_data)
-        with sftp.open(remote_filename, 0, 0) as remote_fh:
-            try:
-                self.assertTrue(remote_fh is not None)
-                remote_data = b""
-                for rc, data in remote_fh:
-                    remote_data += data
-                self.assertEqual(remote_fh.close(), 0)
-                self.assertEqual(remote_data, test_file_data)
-            finally:
-                os.unlink(remote_filename)
-
-    def test_sftp_write(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        data = b"test file data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        mode = LIBSSH2_SFTP_S_IRUSR | \
-               LIBSSH2_SFTP_S_IWUSR | \
-               LIBSSH2_SFTP_S_IRGRP | \
-               LIBSSH2_SFTP_S_IROTH
-        with sftp.open(remote_filename,
-                       LIBSSH2_FXF_CREAT | LIBSSH2_FXF_WRITE,
-                       mode) as remote_fh:
-            remote_fh.write(data)
-        with open(remote_filename, 'rb') as fh:
-            written_data = fh.read()
-        _stat = os.stat(remote_filename)
-        try:
-            self.assertTrue(stat.S_IMODE(_stat.st_mode) > 400)
-            self.assertTrue(fh.closed)
-            self.assertEqual(data, written_data)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
+        self.assertEqual(sftp.session, session)
 
     def test_sftp_attrs_cls(self):
         attrs = SFTPAttributes()
-        self.assertTrue(attrs is not None)
-        del attrs
-
-    def test_sftp_stat(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        _mask = 0o644
-        os.chmod(remote_filename, _mask)
-        _size = os.stat(remote_filename).st_size
-        try:
-            attrs = sftp.stat(remote_filename)
-            self.assertTrue(isinstance(attrs, SFTPAttributes))
-            self.assertEqual(attrs.uid, os.getuid())
-            self.assertEqual(attrs.gid, os.getgid())
-            self.assertEqual(stat.S_IMODE(attrs.permissions), 420)
-            self.assertTrue(attrs.atime > 0)
-            self.assertTrue(attrs.mtime > 0)
-            self.assertTrue(attrs.flags > 0)
-            self.assertEqual(attrs.filesize, _size)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-        self.assertRaises(SFTPProtocolError, sftp.stat, remote_filename)
-        self.assertNotEqual(sftp.last_error(), 0)
-
-    def test_sftp_fstat(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        try:
-            with sftp.open(remote_filename, 0, 0) as fh:
-                attrs = fh.fstat()
-                self.assertTrue(isinstance(attrs, SFTPAttributes))
-                self.assertEqual(attrs.uid, os.getuid())
-                self.assertEqual(attrs.gid, os.getgid())
-                self.assertTrue(attrs.flags > 0)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-
-    def test_sftp_setstat(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        rdonly_perms = LIBSSH2_SFTP_S_IRUSR |  LIBSSH2_SFTP_S_IRGRP | \
-            LIBSSH2_SFTP_S_IROTH
-        rw_perms = LIBSSH2_SFTP_S_IRUSR |  LIBSSH2_SFTP_S_IRGRP | \
-            LIBSSH2_SFTP_S_IROTH | LIBSSH2_SFTP_S_IWUSR |  \
-            LIBSSH2_SFTP_S_IWGRP | LIBSSH2_SFTP_S_IWOTH
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        _mask = 0o666
-        os.chmod(remote_filename, _mask)
-        attrs = sftp.stat(remote_filename)
-        attrs.permissions = LIBSSH2_SFTP_S_IRUSR
-        attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
-        try:
-            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
-            attrs = sftp.stat(remote_filename)
-            expected = '0100400L' if version_info.major <= 2 else '0o100400'
-            self.assertEqual(oct(attrs.permissions), expected)
-            attrs.permissions = rdonly_perms
-            attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
-            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
-            attrs = sftp.stat(remote_filename)
-            expected = '0100444L' if version_info.major <= 2 else '0o100444'
-            self.assertEqual(oct(attrs.permissions), expected)
-            attrs.permissions = rw_perms
-            attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS
-            self.assertEqual(sftp.setstat(remote_filename, attrs), 0)
-            attrs = sftp.stat(remote_filename)
-            expected = '0100666L' if version_info.major <= 2 else '0o100666'
-            self.assertEqual(oct(attrs.permissions), expected)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-
-    def test_realpath_failure(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        self.assertRaises(
-            BufferTooSmallError, sftp.realpath, '/', max_len=0)
-
-    def test_realpath(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        self.assertIsNotNone(sftp.realpath('.'))
-
-    def test_sftp_symlink_realpath_lstat(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertTrue(sftp is not None)
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        symlink_target = os.sep.join([os.path.dirname(__file__),
-                                      'remote_symlink'])
-        try:
-            self.assertEqual(sftp.symlink(remote_filename, symlink_target), 0)
-            lstat = sftp.lstat(symlink_target)
-            self.assertTrue(lstat is not None)
-            self.assertEqual(lstat.filesize, os.lstat(symlink_target).st_size)
-            realpath = sftp.realpath(symlink_target)
-            self.assertTrue(realpath is not None)
-            self.assertEqual(realpath, remote_filename)
-        except Exception:
-            raise
-        finally:
-            os.unlink(symlink_target)
-            os.unlink(remote_filename)
-
-    def test_readdir(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        with sftp.opendir('.') as fh:
-            dir_data = list(fh.readdir())
-        self.assertTrue(len(dir_data) > 0)
-        self.assertTrue(b'..' in (_ls for (_, _ls, _) in dir_data))
-
-    def test_readdir_ex(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        with sftp.opendir('.') as fh:
-            dir_data = list(fh.readdir_ex())
-        self.assertTrue(len(dir_data) > 0)
-        self.assertTrue(b'..' in (_ls for (_, _ls, _, _) in dir_data))
-        self.assertTrue(len(dir_data[0][2].split(b' ')) > 0)
-
-    def test_readdir_failure(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        self.assertRaises(SFTPProtocolError, sftp.opendir, 'fakeyfakey')
-
-    @skipUnless(hasattr(SFTPHandle, 'fsync'),
-                "Function not supported by libssh2")
-    def test_fsync(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        try:
-            with sftp.open(remote_filename, 0, 0) as fh:
-                self.assertEqual(fh.fsync(), 0)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-
-    def test_statvfs(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        vfs = sftp.statvfs('.')
-        self.assertTrue(vfs is not None)
-        self.assertTrue(vfs.f_files >= 0)
-        self.assertTrue(vfs.f_bsize > 0)
-        self.assertTrue(vfs.f_namemax > 0)
-
-    def test_fstatvfs(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        test_data = b"data"
-        remote_filename = os.sep.join([os.path.dirname(__file__),
-                                       "remote_test_file"])
-        with open(remote_filename, 'wb') as fh:
-            fh.write(test_data)
-        try:
-            with sftp.open(remote_filename, 0, 0) as fh:
-                vfs = fh.fstatvfs()
-                self.assertTrue(vfs is not None)
-                self.assertTrue(vfs.f_files >= 0)
-                self.assertTrue(vfs.f_bsize > 0)
-                self.assertTrue(vfs.f_namemax > 0)
-        except Exception:
-            raise
-        finally:
-            os.unlink(remote_filename)
-
-    def test_readdir_nonblocking(self):
-        self.assertEqual(self._auth(), 0)
-        sftp = self.session.sftp_init()
-        with sftp.opendir('.') as fh:
-            self.session.set_blocking(False)
-            dir_data = []
-            for size, buf, attrs in fh.readdir():
-                if size == LIBSSH2_ERROR_EAGAIN:
-                    wait_socket(self.sock, self.session)
-                    continue
-                dir_data.append(buf)
-        self.assertTrue(len(dir_data) > 0)
-        self.assertTrue(b'..' in dir_data)
-
-    def test_mkdir(self):
-        mode = LIBSSH2_SFTP_S_IRUSR | \
-            LIBSSH2_SFTP_S_IWUSR | \
-            LIBSSH2_SFTP_S_IRGRP | \
-            LIBSSH2_SFTP_S_IROTH | \
-            LIBSSH2_SFTP_S_IXUSR
-        _path = 'tmp'
-        abspath = os.path.join(os.path.expanduser('~'), _path)
-        self._auth()
-        sftp = self.session.sftp_init()
-        try:
-            shutil.rmtree(abspath)
-        except OSError:
-            pass
-        sftp.mkdir(_path, mode)
-        try:
-            self.assertTrue(os.path.isdir(abspath))
-        finally:
-            shutil.rmtree(abspath)
+        self.assertIsInstance(attrs, SFTPAttributes)
 
-    def test_handle_open_nonblocking(self):
-        self._auth()
-        sftp = self.session.sftp_init()
-        self.session.set_blocking(False)
-        try:
-            fh = sftp.open('fakey fake fake', 0, 0)
-            while fh == LIBSSH2_ERROR_EAGAIN:
-                wait_socket(self.sock, self.session)
-                fh = sftp.open('fakey fake fake', 0, 0)
-        except SFTPProtocolError:
-            pass
-        else:
-            raise Exception("Should have raised SFTPProtocolError")
+    def test_session(self):
+        session = Session()
+        self.assertIsInstance(session, Session)
diff --git a/versioneer.py b/versioneer.py
index a2870603..1e3753e6 100644
--- a/versioneer.py
+++ b/versioneer.py
@@ -1,5 +1,5 @@
 
-# Version: 0.18-1
+# Version: 0.29
 
 """The Versioneer - like a rocketeer, but for versions.
 
@@ -7,18 +7,14 @@
 ==============
 
 * like a rocketeer, but for versions!
-* https://github.com/warner/python-versioneer
+* https://github.com/python-versioneer/python-versioneer
 * Brian Warner
-* License: Public Domain
-* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, and pypy
-* [![Latest Version]
-(https://pypip.in/version/versioneer/badge.svg?style=flat)
-](https://pypi.python.org/pypi/versioneer/)
-* [![Build Status]
-(https://travis-ci.org/warner/python-versioneer.png?branch=master)
-](https://travis-ci.org/warner/python-versioneer)
-
-This is a tool for managing a recorded version number in distutils-based
+* License: Public Domain (Unlicense)
+* Compatible with: Python 3.7, 3.8, 3.9, 3.10, 3.11 and pypy3
+* [![Latest Version][pypi-image]][pypi-url]
+* [![Build Status][travis-image]][travis-url]
+
+This is a tool for managing a recorded version number in setuptools-based
 python projects. The goal is to remove the tedious and error-prone "update
 the embedded version string" step from your release process. Making a new
 release should be as easy as recording a new tag in your version-control
@@ -27,9 +23,38 @@
 
 ## Quick Install
 
-* `pip install versioneer` to somewhere to your $PATH
-* add a `[versioneer]` section to your setup.cfg (see below)
-* run `versioneer install` in your source tree, commit the results
+Versioneer provides two installation modes. The "classic" vendored mode installs
+a copy of versioneer into your repository. The experimental build-time dependency mode
+is intended to allow you to skip this step and simplify the process of upgrading.
+
+### Vendored mode
+
+* `pip install versioneer` to somewhere in your $PATH
+   * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is
+     available, so you can also use `conda install -c conda-forge versioneer`
+* add a `[tool.versioneer]` section to your `pyproject.toml` or a
+  `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md))
+   * Note that you will need to add `tomli; python_version < "3.11"` to your
+     build-time dependencies if you use `pyproject.toml`
+* run `versioneer install --vendor` in your source tree, commit the results
+* verify version information with `python setup.py version`
+
+### Build-time dependency mode
+
+* `pip install versioneer` to somewhere in your $PATH
+   * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is
+     available, so you can also use `conda install -c conda-forge versioneer`
+* add a `[tool.versioneer]` section to your `pyproject.toml` or a
+  `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md))
+* add `versioneer` (with `[toml]` extra, if configuring in `pyproject.toml`)
+  to the `requires` key of the `build-system` table in `pyproject.toml`:
+  ```toml
+  [build-system]
+  requires = ["setuptools", "versioneer[toml]"]
+  build-backend = "setuptools.build_meta"
+  ```
+* run `versioneer install --no-vendor` in your source tree, commit the results
+* verify version information with `python setup.py version`
 
 ## Version Identifiers
 
@@ -61,7 +86,7 @@
 for example `git describe --tags --dirty --always` reports things like
 "0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the
 0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has
-uncommitted changes.
+uncommitted changes).
 
 The version identifier is used for multiple purposes:
 
@@ -166,7 +191,7 @@
 
 Some situations are known to cause problems for Versioneer. This details the
 most significant ones. More can be found on Github
-[issues page](https://github.com/warner/python-versioneer/issues).
+[issues page](https://github.com/python-versioneer/python-versioneer/issues).
 
 ### Subprojects
 
@@ -180,7 +205,7 @@
   `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI
   distributions (and upload multiple independently-installable tarballs).
 * Source trees whose main purpose is to contain a C library, but which also
-  provide bindings to Python (and perhaps other langauges) in subdirectories.
+  provide bindings to Python (and perhaps other languages) in subdirectories.
 
 Versioneer will look for `.git` in parent directories, and most operations
 should get the right version string. However `pip` and `setuptools` have bugs
@@ -194,9 +219,9 @@
 Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in
 some later version.
 
-[Bug #38](https://github.com/warner/python-versioneer/issues/38) is tracking
+[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking
 this issue. The discussion in
-[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the
+[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the
 issue from the Versioneer side in more detail.
 [pip PR#3176](https://github.com/pypa/pip/pull/3176) and
 [pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve
@@ -224,31 +249,20 @@
 cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into
 a different virtualenv), so this can be surprising.
 
-[Bug #83](https://github.com/warner/python-versioneer/issues/83) describes
+[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes
 this one, but upgrading to a newer version of setuptools should probably
 resolve it.
 
-### Unicode version strings
-
-While Versioneer works (and is continually tested) with both Python 2 and
-Python 3, it is not entirely consistent with bytes-vs-unicode distinctions.
-Newer releases probably generate unicode version strings on py2. It's not
-clear that this is wrong, but it may be surprising for applications when then
-write these strings to a network connection or include them in bytes-oriented
-APIs like cryptographic checksums.
-
-[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates
-this question.
-
 
 ## Updating Versioneer
 
 To upgrade your project to a new release of Versioneer, do the following:
 
 * install the new Versioneer (`pip install -U versioneer` or equivalent)
-* edit `setup.cfg`, if necessary, to include any new configuration settings
-  indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details.
-* re-run `versioneer install` in your source tree, to replace
+* edit `setup.cfg` and `pyproject.toml`, if necessary,
+  to include any new configuration settings indicated by the release notes.
+  See [UPGRADING](./UPGRADING.md) for details.
+* re-run `versioneer install --[no-]vendor` in your source tree, to replace
   `SRC/_version.py`
 * commit any changed files
 
@@ -265,35 +279,70 @@
 direction and include code from all supported VCS systems, reducing the
 number of intermediate scripts.
 
+## Similar projects
+
+* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time
+  dependency
+* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of
+  versioneer
+* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools
+  plugin
 
 ## License
 
 To make Versioneer easier to embed, all its code is dedicated to the public
 domain. The `_version.py` that it creates is also in the public domain.
-Specifically, both are released under the Creative Commons "Public Domain
-Dedication" license (CC0-1.0), as described in
-https://creativecommons.org/publicdomain/zero/1.0/ .
+Specifically, both are released under the "Unlicense", as described in
+https://unlicense.org/.
+
+[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg
+[pypi-url]: https://pypi.python.org/pypi/versioneer/
+[travis-image]:
+https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg
+[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer
 
 """
+# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring
+# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements
+# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error
+# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with
+# pylint:disable=attribute-defined-outside-init,too-many-arguments
 
-from __future__ import print_function
-try:
-    import configparser
-except ImportError:
-    import ConfigParser as configparser
+import configparser
 import errno
 import json
 import os
 import re
 import subprocess
 import sys
+from pathlib import Path
+from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Union
+from typing import NoReturn
+import functools
+
+have_tomllib = True
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        have_tomllib = False
 
 
 class VersioneerConfig:
     """Container for Versioneer configuration parameters."""
 
+    VCS: str
+    style: str
+    tag_prefix: str
+    versionfile_source: str
+    versionfile_build: Optional[str]
+    parentdir_prefix: Optional[str]
+    verbose: Optional[bool]
+
 
-def get_root():
+def get_root() -> str:
     """Get the project root directory.
 
     We require that all commands are run from the project root, i.e. the
@@ -301,13 +350,23 @@ def get_root():
     """
     root = os.path.realpath(os.path.abspath(os.getcwd()))
     setup_py = os.path.join(root, "setup.py")
+    pyproject_toml = os.path.join(root, "pyproject.toml")
     versioneer_py = os.path.join(root, "versioneer.py")
-    if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
+    if not (
+        os.path.exists(setup_py)
+        or os.path.exists(pyproject_toml)
+        or os.path.exists(versioneer_py)
+    ):
         # allow 'python path/to/setup.py COMMAND'
         root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))
         setup_py = os.path.join(root, "setup.py")
+        pyproject_toml = os.path.join(root, "pyproject.toml")
         versioneer_py = os.path.join(root, "versioneer.py")
-    if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
+    if not (
+        os.path.exists(setup_py)
+        or os.path.exists(pyproject_toml)
+        or os.path.exists(versioneer_py)
+    ):
         err = ("Versioneer was unable to run the project root directory. "
                "Versioneer requires setup.py to be executed from "
                "its immediate directory (like 'python setup.py COMMAND'), "
@@ -321,43 +380,62 @@ def get_root():
         # module-import table will cache the first one. So we can't use
         # os.path.dirname(__file__), as that will find whichever
         # versioneer.py was first imported, even in later projects.
-        me = os.path.realpath(os.path.abspath(__file__))
-        me_dir = os.path.normcase(os.path.splitext(me)[0])
+        my_path = os.path.realpath(os.path.abspath(__file__))
+        me_dir = os.path.normcase(os.path.splitext(my_path)[0])
         vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0])
-        if me_dir != vsr_dir:
+        if me_dir != vsr_dir and "VERSIONEER_PEP518" not in globals():
             print("Warning: build in %s is using versioneer.py from %s"
-                  % (os.path.dirname(me), versioneer_py))
+                  % (os.path.dirname(my_path), versioneer_py))
     except NameError:
         pass
     return root
 
 
-def get_config_from_root(root):
+def get_config_from_root(root: str) -> VersioneerConfig:
     """Read the project setup.cfg file to determine Versioneer config."""
-    # This might raise EnvironmentError (if setup.cfg is missing), or
+    # This might raise OSError (if setup.cfg is missing), or
     # configparser.NoSectionError (if it lacks a [versioneer] section), or
     # configparser.NoOptionError (if it lacks "VCS="). See the docstring at
     # the top of versioneer.py for instructions on writing your setup.cfg .
-    setup_cfg = os.path.join(root, "setup.cfg")
-    parser = configparser.SafeConfigParser()
-    with open(setup_cfg, "r") as f:
-        parser.readfp(f)
-    VCS = parser.get("versioneer", "VCS")  # mandatory
-
-    def get(parser, name):
-        if parser.has_option("versioneer", name):
-            return parser.get("versioneer", name)
-        return None
+    root_pth = Path(root)
+    pyproject_toml = root_pth / "pyproject.toml"
+    setup_cfg = root_pth / "setup.cfg"
+    section: Union[Dict[str, Any], configparser.SectionProxy, None] = None
+    if pyproject_toml.exists() and have_tomllib:
+        try:
+            with open(pyproject_toml, 'rb') as fobj:
+                pp = tomllib.load(fobj)
+            section = pp['tool']['versioneer']
+        except (tomllib.TOMLDecodeError, KeyError) as e:
+            print(f"Failed to load config from {pyproject_toml}: {e}")
+            print("Try to load it from setup.cfg")
+    if not section:
+        parser = configparser.ConfigParser()
+        with open(setup_cfg) as cfg_file:
+            parser.read_file(cfg_file)
+        parser.get("versioneer", "VCS")  # raise error if missing
+
+        section = parser["versioneer"]
+
+    # `cast`` really shouldn't be used, but its simplest for the
+    # common VersioneerConfig users at the moment. We verify against
+    # `None` values elsewhere where it matters
+
     cfg = VersioneerConfig()
-    cfg.VCS = VCS
-    cfg.style = get(parser, "style") or ""
-    cfg.versionfile_source = get(parser, "versionfile_source")
-    cfg.versionfile_build = get(parser, "versionfile_build")
-    cfg.tag_prefix = get(parser, "tag_prefix")
-    if cfg.tag_prefix in ("''", '""'):
+    cfg.VCS = section['VCS']
+    cfg.style = section.get("style", "")
+    cfg.versionfile_source = cast(str, section.get("versionfile_source"))
+    cfg.versionfile_build = section.get("versionfile_build")
+    cfg.tag_prefix = cast(str, section.get("tag_prefix"))
+    if cfg.tag_prefix in ("''", '""', None):
         cfg.tag_prefix = ""
-    cfg.parentdir_prefix = get(parser, "parentdir_prefix")
-    cfg.verbose = get(parser, "verbose")
+    cfg.parentdir_prefix = section.get("parentdir_prefix")
+    if isinstance(section, configparser.SectionProxy):
+        # Make sure configparser translates to bool
+        cfg.verbose = section.getboolean("verbose")
+    else:
+        cfg.verbose = section.get("verbose")
+
     return cfg
 
 
@@ -366,37 +444,48 @@ class NotThisMethod(Exception):
 
 
 # these dictionaries contain VCS-specific tools
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
-def register_vcs_handler(vcs, method):  # decorator
-    """Decorator to mark a method as the handler for a particular VCS."""
-    def decorate(f):
+def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
+    """Create decorator to mark a method as the handler of a VCS."""
+    def decorate(f: Callable) -> Callable:
         """Store f in HANDLERS[vcs][method]."""
-        if vcs not in HANDLERS:
-            HANDLERS[vcs] = {}
-        HANDLERS[vcs][method] = f
+        HANDLERS.setdefault(vcs, {})[method] = f
         return f
     return decorate
 
 
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
-                env=None):
+def run_command(
+    commands: List[str],
+    args: List[str],
+    cwd: Optional[str] = None,
+    verbose: bool = False,
+    hide_stderr: bool = False,
+    env: Optional[Dict[str, str]] = None,
+) -> Tuple[Optional[str], Optional[int]]:
     """Call the given command(s)."""
     assert isinstance(commands, list)
-    p = None
-    for c in commands:
+    process = None
+
+    popen_kwargs: Dict[str, Any] = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
+    for command in commands:
         try:
-            dispcmd = str([c] + args)
+            dispcmd = str([command] + args)
             # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env,
+                                       stdout=subprocess.PIPE,
+                                       stderr=(subprocess.PIPE if hide_stderr
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
@@ -407,26 +496,25 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
         if verbose:
             print("unable to find command, tried %s" % (commands,))
         return None, None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
-    if p.returncode != 0:
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
         if verbose:
             print("unable to run %s (error)" % dispcmd)
             print("stdout was %s" % stdout)
-        return None, p.returncode
-    return stdout, p.returncode
+        return None, process.returncode
+    return stdout, process.returncode
 
 
-LONG_VERSION_PY['git'] = '''
+LONG_VERSION_PY['git'] = r'''
 # This file helps to compute a version number in source trees obtained from
 # git-archive tarball (such as those provided by githubs download-from-tag
 # feature). Distribution tarballs (built by setup.py sdist) and build
 # directories (produced by setup.py build) will contain a much shorter file
 # that just contains the computed version number.
 
-# This file is released into the public domain. Generated by
-# versioneer-0.18 (https://github.com/warner/python-versioneer)
+# This file is released into the public domain.
+# Generated by versioneer-0.29
+# https://github.com/python-versioneer/python-versioneer
 
 """Git implementation of _version.py."""
 
@@ -435,9 +523,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
 import re
 import subprocess
 import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple
+import functools
 
 
-def get_keywords():
+def get_keywords() -> Dict[str, str]:
     """Get the keywords needed to look up the version information."""
     # these strings will be replaced by git during git-archive.
     # setup.py/versioneer.py will grep for the variable names, so they must
@@ -453,8 +543,15 @@ def get_keywords():
 class VersioneerConfig:
     """Container for Versioneer configuration parameters."""
 
+    VCS: str
+    style: str
+    tag_prefix: str
+    parentdir_prefix: str
+    versionfile_source: str
+    verbose: bool
+
 
-def get_config():
+def get_config() -> VersioneerConfig:
     """Create, populate and return the VersioneerConfig() object."""
     # these strings are filled in when 'setup.py versioneer' creates
     # _version.py
@@ -472,13 +569,13 @@ class NotThisMethod(Exception):
     """Exception raised if a method is not valid for the current scenario."""
 
 
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
-def register_vcs_handler(vcs, method):  # decorator
-    """Decorator to mark a method as the handler for a particular VCS."""
-    def decorate(f):
+def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
+    """Create decorator to mark a method as the handler of a VCS."""
+    def decorate(f: Callable) -> Callable:
         """Store f in HANDLERS[vcs][method]."""
         if vcs not in HANDLERS:
             HANDLERS[vcs] = {}
@@ -487,22 +584,35 @@ def decorate(f):
     return decorate
 
 
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
-                env=None):
+def run_command(
+    commands: List[str],
+    args: List[str],
+    cwd: Optional[str] = None,
+    verbose: bool = False,
+    hide_stderr: bool = False,
+    env: Optional[Dict[str, str]] = None,
+) -> Tuple[Optional[str], Optional[int]]:
     """Call the given command(s)."""
     assert isinstance(commands, list)
-    p = None
-    for c in commands:
+    process = None
+
+    popen_kwargs: Dict[str, Any] = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
+    for command in commands:
         try:
-            dispcmd = str([c] + args)
+            dispcmd = str([command] + args)
             # remember shell=False, so use git.cmd on windows, not just git
-            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
-                                 stdout=subprocess.PIPE,
-                                 stderr=(subprocess.PIPE if hide_stderr
-                                         else None))
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env,
+                                       stdout=subprocess.PIPE,
+                                       stderr=(subprocess.PIPE if hide_stderr
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
@@ -513,18 +623,20 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
         if verbose:
             print("unable to find command, tried %%s" %% (commands,))
         return None, None
-    stdout = p.communicate()[0].strip()
-    if sys.version_info[0] >= 3:
-        stdout = stdout.decode()
-    if p.returncode != 0:
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
         if verbose:
             print("unable to run %%s (error)" %% dispcmd)
             print("stdout was %%s" %% stdout)
-        return None, p.returncode
-    return stdout, p.returncode
+        return None, process.returncode
+    return stdout, process.returncode
 
 
-def versions_from_parentdir(parentdir_prefix, root, verbose):
+def versions_from_parentdir(
+    parentdir_prefix: str,
+    root: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Try to determine the version from the parent directory name.
 
     Source tarballs conventionally unpack into a directory that includes both
@@ -533,15 +645,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     """
     rootdirs = []
 
-    for i in range(3):
+    for _ in range(3):
         dirname = os.path.basename(root)
         if dirname.startswith(parentdir_prefix):
             return {"version": dirname[len(parentdir_prefix):],
                     "full-revisionid": None,
                     "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
+        rootdirs.append(root)
+        root = os.path.dirname(root)  # up a level
 
     if verbose:
         print("Tried directories %%s but none started with prefix %%s" %%
@@ -550,41 +661,48 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 @register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
+def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
     """Extract version information from the given file."""
     # the code embedded in _version.py can just fetch the value of these
     # keywords. When used from setup.py, we don't want to import _version.py,
     # so we do it with a regexp instead. This function is not used from
     # _version.py.
-    keywords = {}
+    keywords: Dict[str, str] = {}
     try:
-        f = open(versionfile_abs, "r")
-        for line in f.readlines():
-            if line.strip().startswith("git_refnames ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["refnames"] = mo.group(1)
-            if line.strip().startswith("git_full ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["full"] = mo.group(1)
-            if line.strip().startswith("git_date ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["date"] = mo.group(1)
-        f.close()
-    except EnvironmentError:
+        with open(versionfile_abs, "r") as fobj:
+            for line in fobj:
+                if line.strip().startswith("git_refnames ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["refnames"] = mo.group(1)
+                if line.strip().startswith("git_full ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["full"] = mo.group(1)
+                if line.strip().startswith("git_date ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["date"] = mo.group(1)
+    except OSError:
         pass
     return keywords
 
 
 @register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
+def git_versions_from_keywords(
+    keywords: Dict[str, str],
+    tag_prefix: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
+    if "refnames" not in keywords:
+        raise NotThisMethod("Short version file found")
     date = keywords.get("date")
     if date is not None:
+        # Use only the last line.  Previous lines may contain GPG signature
+        # information.
+        date = date.splitlines()[-1]
+
         # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant
         # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601
         # -like" string, which we must then edit to make compliant), because
@@ -597,11 +715,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         if verbose:
             print("keywords are unexpanded, not using")
         raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    refs = {r.strip() for r in refnames.strip("()").split(",")}
     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
     TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
     if not tags:
         # Either we're using git < 1.8.3, or there really are no tags. We use
         # a heuristic: assume all version tags have a digit. The old git %%d
@@ -610,7 +728,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
         # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
+        tags = {r for r in refs if re.search(r'\d', r)}
         if verbose:
             print("discarding '%%s', no digits" %% ",".join(refs - tags))
     if verbose:
@@ -619,6 +737,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix):]
+            # Filter out refs that exactly match prefix or that don't start
+            # with a number once the prefix is stripped (mostly a concern
+            # when prefix is '')
+            if not re.match(r'\d', r):
+                continue
             if verbose:
                 print("picking %%s" %% r)
             return {"version": r,
@@ -634,7 +757,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+def git_pieces_from_vcs(
+    tag_prefix: str,
+    root: str,
+    verbose: bool,
+    runner: Callable = run_command
+) -> Dict[str, Any]:
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -645,8 +773,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %%s not under git control" %% root)
@@ -654,24 +789,57 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
-                                          "--always", "--long",
-                                          "--match", "%%s*" %% tag_prefix],
-                                   cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
     describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root)
     if full_out is None:
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
 
-    pieces = {}
+    pieces: Dict[str, Any] = {}
     pieces["long"] = full_out
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
 
+    branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"],
+                             cwd=root)
+    # --abbrev-ref was added in git-1.6.3
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+
+    if branch_name == "HEAD":
+        # If we aren't exactly on a branch, pick a branch which represents
+        # the current commit. If all else fails, we are on a branchless
+        # commit.
+        branches, rc = runner(GITS, ["branch", "--contains"], cwd=root)
+        # --contains was added in git-1.5.4
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split("\n")
+
+        # Remove the first line if we're running detached
+        if "(" in branches[0]:
+            branches.pop(0)
+
+        # Strip off the leading "* " from the list of branches.
+        branches = [branch[2:] for branch in branches]
+        if "master" in branches:
+            branch_name = "master"
+        elif not branches:
+            branch_name = None
+        else:
+            # Pick the first branch that is returned. Good or bad.
+            branch_name = branches[0]
+
+    pieces["branch"] = branch_name
+
     # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
     # TAG might have hyphens.
     git_describe = describe_out
@@ -688,7 +856,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%%s'"
                                %% describe_out)
             return pieces
@@ -713,26 +881,27 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"],
-                       cwd=root)[0].strip()
+    date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip()
+    # Use only the last line.  Previous lines may contain GPG signature
+    # information.
+    date = date.splitlines()[-1]
     pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
 
     return pieces
 
 
-def plus_or_dot(pieces):
+def plus_or_dot(pieces: Dict[str, Any]) -> str:
     """Return a + if we don't already have one, else return a ."""
     if "+" in pieces.get("closest-tag", ""):
         return "."
     return "+"
 
 
-def render_pep440(pieces):
+def render_pep440(pieces: Dict[str, Any]) -> str:
     """Build up version string, with post-release "local version identifier".
 
     Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
@@ -757,23 +926,71 @@ def render_pep440(pieces):
     return rendered
 
 
-def render_pep440_pre(pieces):
-    """TAG[.post.devDISTANCE] -- No -dirty.
+def render_pep440_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
+
+    The ".dev0" means not master branch. Note that .dev0 sorts backwards
+    (a feature branch will appear "older" than the master branch).
 
     Exceptions:
-    1: no tags. 0.post.devDISTANCE
+    1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty]
     """
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0"
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+untagged.%%d.g%%s" %% (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
+def render_pep440_pre(pieces: Dict[str, Any]) -> str:
+    """TAG[.postN.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post0.devDISTANCE
+    """
+    if pieces["closest-tag"]:
         if pieces["distance"]:
-            rendered += ".post.dev%%d" %% pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%%d.dev%%d" %% (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%%d" %% (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
-        rendered = "0.post.dev%%d" %% pieces["distance"]
+        rendered = "0.post0.dev%%d" %% pieces["distance"]
     return rendered
 
 
-def render_pep440_post(pieces):
+def render_pep440_post(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX] .
 
     The ".dev0" means dirty. Note that .dev0 sorts backwards
@@ -800,12 +1017,41 @@ def render_pep440_post(pieces):
     return rendered
 
 
-def render_pep440_old(pieces):
+def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
+
+    The ".dev0" means not master branch.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%%d" %% pieces["distance"]
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%%s" %% pieces["short"]
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0.post%%d" %% pieces["distance"]
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+g%%s" %% pieces["short"]
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_old(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]] .
 
     The ".dev0" means dirty.
 
-    Eexceptions:
+    Exceptions:
     1: no tags. 0.postDISTANCE[.dev0]
     """
     if pieces["closest-tag"]:
@@ -822,7 +1068,7 @@ def render_pep440_old(pieces):
     return rendered
 
 
-def render_git_describe(pieces):
+def render_git_describe(pieces: Dict[str, Any]) -> str:
     """TAG[-DISTANCE-gHEX][-dirty].
 
     Like 'git describe --tags --dirty --always'.
@@ -842,7 +1088,7 @@ def render_git_describe(pieces):
     return rendered
 
 
-def render_git_describe_long(pieces):
+def render_git_describe_long(pieces: Dict[str, Any]) -> str:
     """TAG-DISTANCE-gHEX[-dirty].
 
     Like 'git describe --tags --dirty --always -long'.
@@ -862,7 +1108,7 @@ def render_git_describe_long(pieces):
     return rendered
 
 
-def render(pieces, style):
+def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
     """Render the given version pieces into the requested style."""
     if pieces["error"]:
         return {"version": "unknown",
@@ -876,10 +1122,14 @@ def render(pieces, style):
 
     if style == "pep440":
         rendered = render_pep440(pieces)
+    elif style == "pep440-branch":
+        rendered = render_pep440_branch(pieces)
     elif style == "pep440-pre":
         rendered = render_pep440_pre(pieces)
     elif style == "pep440-post":
         rendered = render_pep440_post(pieces)
+    elif style == "pep440-post-branch":
+        rendered = render_pep440_post_branch(pieces)
     elif style == "pep440-old":
         rendered = render_pep440_old(pieces)
     elif style == "git-describe":
@@ -894,7 +1144,7 @@ def render(pieces, style):
             "date": pieces.get("date")}
 
 
-def get_versions():
+def get_versions() -> Dict[str, Any]:
     """Get version information or return default if unable to do so."""
     # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
     # __file__, we can work backwards from there to the root. Some
@@ -915,7 +1165,7 @@ def get_versions():
         # versionfile_source is the relative path from the top of the source
         # tree (where the .git directory might live) to this file. Invert
         # this to find the root from __file__.
-        for i in cfg.versionfile_source.split('/'):
+        for _ in cfg.versionfile_source.split('/'):
             root = os.path.dirname(root)
     except NameError:
         return {"version": "0+unknown", "full-revisionid": None,
@@ -942,41 +1192,48 @@ def get_versions():
 
 
 @register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
+def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
     """Extract version information from the given file."""
     # the code embedded in _version.py can just fetch the value of these
     # keywords. When used from setup.py, we don't want to import _version.py,
     # so we do it with a regexp instead. This function is not used from
     # _version.py.
-    keywords = {}
+    keywords: Dict[str, str] = {}
     try:
-        f = open(versionfile_abs, "r")
-        for line in f.readlines():
-            if line.strip().startswith("git_refnames ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["refnames"] = mo.group(1)
-            if line.strip().startswith("git_full ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["full"] = mo.group(1)
-            if line.strip().startswith("git_date ="):
-                mo = re.search(r'=\s*"(.*)"', line)
-                if mo:
-                    keywords["date"] = mo.group(1)
-        f.close()
-    except EnvironmentError:
+        with open(versionfile_abs, "r") as fobj:
+            for line in fobj:
+                if line.strip().startswith("git_refnames ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["refnames"] = mo.group(1)
+                if line.strip().startswith("git_full ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["full"] = mo.group(1)
+                if line.strip().startswith("git_date ="):
+                    mo = re.search(r'=\s*"(.*)"', line)
+                    if mo:
+                        keywords["date"] = mo.group(1)
+    except OSError:
         pass
     return keywords
 
 
 @register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
+def git_versions_from_keywords(
+    keywords: Dict[str, str],
+    tag_prefix: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Get version information from git keywords."""
-    if not keywords:
-        raise NotThisMethod("no keywords at all, weird")
+    if "refnames" not in keywords:
+        raise NotThisMethod("Short version file found")
     date = keywords.get("date")
     if date is not None:
+        # Use only the last line.  Previous lines may contain GPG signature
+        # information.
+        date = date.splitlines()[-1]
+
         # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
         # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
         # -like" string, which we must then edit to make compliant), because
@@ -989,11 +1246,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         if verbose:
             print("keywords are unexpanded, not using")
         raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
-    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    refs = {r.strip() for r in refnames.strip("()").split(",")}
     # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
     # just "foo-1.0". If we see a "tag: " prefix, prefer those.
     TAG = "tag: "
-    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
     if not tags:
         # Either we're using git < 1.8.3, or there really are no tags. We use
         # a heuristic: assume all version tags have a digit. The old git %d
@@ -1002,7 +1259,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # between branches and tags. By ignoring refnames without digits, we
         # filter out many common branch names like "release" and
         # "stabilization", as well as "HEAD" and "master".
-        tags = set([r for r in refs if re.search(r'\d', r)])
+        tags = {r for r in refs if re.search(r'\d', r)}
         if verbose:
             print("discarding '%s', no digits" % ",".join(refs - tags))
     if verbose:
@@ -1011,6 +1268,11 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
         # sorting will prefer e.g. "2.0" over "2.0rc1"
         if ref.startswith(tag_prefix):
             r = ref[len(tag_prefix):]
+            # Filter out refs that exactly match prefix or that don't start
+            # with a number once the prefix is stripped (mostly a concern
+            # when prefix is '')
+            if not re.match(r'\d', r):
+                continue
             if verbose:
                 print("picking %s" % r)
             return {"version": r,
@@ -1026,7 +1288,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+def git_pieces_from_vcs(
+    tag_prefix: str,
+    root: str,
+    verbose: bool,
+    runner: Callable = run_command
+) -> Dict[str, Any]:
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -1037,8 +1304,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
-    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                          hide_stderr=True)
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
+    _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %s not under git control" % root)
@@ -1046,24 +1320,57 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
-                                          "--always", "--long",
-                                          "--match", "%s*" % tag_prefix],
-                                   cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
     describe_out = describe_out.strip()
-    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root)
     if full_out is None:
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
 
-    pieces = {}
+    pieces: Dict[str, Any] = {}
     pieces["long"] = full_out
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
 
+    branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"],
+                             cwd=root)
+    # --abbrev-ref was added in git-1.6.3
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+
+    if branch_name == "HEAD":
+        # If we aren't exactly on a branch, pick a branch which represents
+        # the current commit. If all else fails, we are on a branchless
+        # commit.
+        branches, rc = runner(GITS, ["branch", "--contains"], cwd=root)
+        # --contains was added in git-1.5.4
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split("\n")
+
+        # Remove the first line if we're running detached
+        if "(" in branches[0]:
+            branches.pop(0)
+
+        # Strip off the leading "* " from the list of branches.
+        branches = [branch[2:] for branch in branches]
+        if "master" in branches:
+            branch_name = "master"
+        elif not branches:
+            branch_name = None
+        else:
+            # Pick the first branch that is returned. Good or bad.
+            branch_name = branches[0]
+
+    pieces["branch"] = branch_name
+
     # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
     # TAG might have hyphens.
     git_describe = describe_out
@@ -1080,7 +1387,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%s'"
                                % describe_out)
             return pieces
@@ -1105,19 +1412,20 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
-                                    cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
-    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
-                       cwd=root)[0].strip()
+    date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip()
+    # Use only the last line.  Previous lines may contain GPG signature
+    # information.
+    date = date.splitlines()[-1]
     pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
 
     return pieces
 
 
-def do_vcs_install(manifest_in, versionfile_source, ipy):
+def do_vcs_install(versionfile_source: str, ipy: Optional[str]) -> None:
     """Git-specific installation logic for Versioneer.
 
     For Git, this means creating/changing .gitattributes to mark _version.py
@@ -1126,36 +1434,40 @@ def do_vcs_install(manifest_in, versionfile_source, ipy):
     GITS = ["git"]
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
-    files = [manifest_in, versionfile_source]
+    files = [versionfile_source]
     if ipy:
         files.append(ipy)
-    try:
-        me = __file__
-        if me.endswith(".pyc") or me.endswith(".pyo"):
-            me = os.path.splitext(me)[0] + ".py"
-        versioneer_file = os.path.relpath(me)
-    except NameError:
-        versioneer_file = "versioneer.py"
-    files.append(versioneer_file)
+    if "VERSIONEER_PEP518" not in globals():
+        try:
+            my_path = __file__
+            if my_path.endswith((".pyc", ".pyo")):
+                my_path = os.path.splitext(my_path)[0] + ".py"
+            versioneer_file = os.path.relpath(my_path)
+        except NameError:
+            versioneer_file = "versioneer.py"
+        files.append(versioneer_file)
     present = False
     try:
-        f = open(".gitattributes", "r")
-        for line in f.readlines():
-            if line.strip().startswith(versionfile_source):
-                if "export-subst" in line.strip().split()[1:]:
-                    present = True
-        f.close()
-    except EnvironmentError:
+        with open(".gitattributes", "r") as fobj:
+            for line in fobj:
+                if line.strip().startswith(versionfile_source):
+                    if "export-subst" in line.strip().split()[1:]:
+                        present = True
+                        break
+    except OSError:
         pass
     if not present:
-        f = open(".gitattributes", "a+")
-        f.write("%s export-subst\n" % versionfile_source)
-        f.close()
+        with open(".gitattributes", "a+") as fobj:
+            fobj.write(f"{versionfile_source} export-subst\n")
         files.append(".gitattributes")
     run_command(GITS, ["add", "--"] + files)
 
 
-def versions_from_parentdir(parentdir_prefix, root, verbose):
+def versions_from_parentdir(
+    parentdir_prefix: str,
+    root: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Try to determine the version from the parent directory name.
 
     Source tarballs conventionally unpack into a directory that includes both
@@ -1164,15 +1476,14 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
     """
     rootdirs = []
 
-    for i in range(3):
+    for _ in range(3):
         dirname = os.path.basename(root)
         if dirname.startswith(parentdir_prefix):
             return {"version": dirname[len(parentdir_prefix):],
                     "full-revisionid": None,
                     "dirty": False, "error": None, "date": None}
-        else:
-            rootdirs.append(root)
-            root = os.path.dirname(root)  # up a level
+        rootdirs.append(root)
+        root = os.path.dirname(root)  # up a level
 
     if verbose:
         print("Tried directories %s but none started with prefix %s" %
@@ -1181,7 +1492,7 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 SHORT_VERSION_PY = """
-# This file was generated by 'versioneer.py' (0.18) from
+# 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.
@@ -1198,12 +1509,12 @@ def get_versions():
 """
 
 
-def versions_from_file(filename):
+def versions_from_file(filename: str) -> Dict[str, Any]:
     """Try to determine the version from _version.py if present."""
     try:
         with open(filename) as f:
             contents = f.read()
-    except EnvironmentError:
+    except OSError:
         raise NotThisMethod("unable to read _version.py")
     mo = re.search(r"version_json = '''\n(.*)'''  # END VERSION_JSON",
                    contents, re.M | re.S)
@@ -1215,9 +1526,8 @@ def versions_from_file(filename):
     return json.loads(mo.group(1))
 
 
-def write_to_version_file(filename, versions):
+def write_to_version_file(filename: str, versions: Dict[str, Any]) -> None:
     """Write the given version number to the given _version.py file."""
-    os.unlink(filename)
     contents = json.dumps(versions, sort_keys=True,
                           indent=1, separators=(",", ": "))
     with open(filename, "w") as f:
@@ -1226,14 +1536,14 @@ def write_to_version_file(filename, versions):
     print("set %s to '%s'" % (filename, versions["version"]))
 
 
-def plus_or_dot(pieces):
+def plus_or_dot(pieces: Dict[str, Any]) -> str:
     """Return a + if we don't already have one, else return a ."""
     if "+" in pieces.get("closest-tag", ""):
         return "."
     return "+"
 
 
-def render_pep440(pieces):
+def render_pep440(pieces: Dict[str, Any]) -> str:
     """Build up version string, with post-release "local version identifier".
 
     Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
@@ -1258,23 +1568,71 @@ def render_pep440(pieces):
     return rendered
 
 
-def render_pep440_pre(pieces):
-    """TAG[.post.devDISTANCE] -- No -dirty.
+def render_pep440_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
+
+    The ".dev0" means not master branch. Note that .dev0 sorts backwards
+    (a feature branch will appear "older" than the master branch).
 
     Exceptions:
-    1: no tags. 0.post.devDISTANCE
+    1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty]
     """
     if pieces["closest-tag"]:
         rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0"
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+untagged.%d.g%s" % (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
+def render_pep440_pre(pieces: Dict[str, Any]) -> str:
+    """TAG[.postN.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post0.devDISTANCE
+    """
+    if pieces["closest-tag"]:
         if pieces["distance"]:
-            rendered += ".post.dev%d" % pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%d" % (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
-        rendered = "0.post.dev%d" % pieces["distance"]
+        rendered = "0.post0.dev%d" % pieces["distance"]
     return rendered
 
 
-def render_pep440_post(pieces):
+def render_pep440_post(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX] .
 
     The ".dev0" means dirty. Note that .dev0 sorts backwards
@@ -1301,12 +1659,41 @@ def render_pep440_post(pieces):
     return rendered
 
 
-def render_pep440_old(pieces):
+def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
+    """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
+
+    The ".dev0" means not master branch.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["branch"] != "master":
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%s" % pieces["short"]
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["branch"] != "master":
+            rendered += ".dev0"
+        rendered += "+g%s" % pieces["short"]
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_old(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]] .
 
     The ".dev0" means dirty.
 
-    Eexceptions:
+    Exceptions:
     1: no tags. 0.postDISTANCE[.dev0]
     """
     if pieces["closest-tag"]:
@@ -1323,7 +1710,7 @@ def render_pep440_old(pieces):
     return rendered
 
 
-def render_git_describe(pieces):
+def render_git_describe(pieces: Dict[str, Any]) -> str:
     """TAG[-DISTANCE-gHEX][-dirty].
 
     Like 'git describe --tags --dirty --always'.
@@ -1343,7 +1730,7 @@ def render_git_describe(pieces):
     return rendered
 
 
-def render_git_describe_long(pieces):
+def render_git_describe_long(pieces: Dict[str, Any]) -> str:
     """TAG-DISTANCE-gHEX[-dirty].
 
     Like 'git describe --tags --dirty --always -long'.
@@ -1363,7 +1750,7 @@ def render_git_describe_long(pieces):
     return rendered
 
 
-def render(pieces, style):
+def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
     """Render the given version pieces into the requested style."""
     if pieces["error"]:
         return {"version": "unknown",
@@ -1377,10 +1764,14 @@ def render(pieces, style):
 
     if style == "pep440":
         rendered = render_pep440(pieces)
+    elif style == "pep440-branch":
+        rendered = render_pep440_branch(pieces)
     elif style == "pep440-pre":
         rendered = render_pep440_pre(pieces)
     elif style == "pep440-post":
         rendered = render_pep440_post(pieces)
+    elif style == "pep440-post-branch":
+        rendered = render_pep440_post_branch(pieces)
     elif style == "pep440-old":
         rendered = render_pep440_old(pieces)
     elif style == "git-describe":
@@ -1399,7 +1790,7 @@ class VersioneerBadRootError(Exception):
     """The project root directory is unknown or missing key files."""
 
 
-def get_versions(verbose=False):
+def get_versions(verbose: bool = False) -> Dict[str, Any]:
     """Get the project version from whatever source is available.
 
     Returns dict with two keys: 'version' and 'full'.
@@ -1414,7 +1805,7 @@ def get_versions(verbose=False):
     assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg"
     handlers = HANDLERS.get(cfg.VCS)
     assert handlers, "unrecognized VCS '%s'" % cfg.VCS
-    verbose = verbose or cfg.verbose
+    verbose = verbose or bool(cfg.verbose)  # `bool()` used to avoid `None`
     assert cfg.versionfile_source is not None, \
         "please set versioneer.versionfile_source"
     assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix"
@@ -1475,13 +1866,17 @@ def get_versions(verbose=False):
             "date": None}
 
 
-def get_version():
+def get_version() -> str:
     """Get the short version string for this project."""
     return get_versions()["version"]
 
 
-def get_cmdclass():
-    """Get the custom setuptools/distutils subclasses used by Versioneer."""
+def get_cmdclass(cmdclass: Optional[Dict[str, Any]] = None):
+    """Get the custom setuptools subclasses used by Versioneer.
+
+    If the package uses a different cmdclass (e.g. one from numpy), it
+    should be provide as an argument.
+    """
     if "versioneer" in sys.modules:
         del sys.modules["versioneer"]
         # this fixes the "python setup.py develop" case (also 'install' and
@@ -1495,25 +1890,25 @@ def get_cmdclass():
         # parent is protected against the child's "import versioneer". By
         # removing ourselves from sys.modules here, before the child build
         # happens, we protect the child from the parent's versioneer too.
-        # Also see https://github.com/warner/python-versioneer/issues/52
+        # Also see https://github.com/python-versioneer/python-versioneer/issues/52
 
-    cmds = {}
+    cmds = {} if cmdclass is None else cmdclass.copy()
 
-    # we add "version" to both distutils and setuptools
-    from distutils.core import Command
+    # we add "version" to setuptools
+    from setuptools import Command
 
     class cmd_version(Command):
         description = "report generated version string"
-        user_options = []
-        boolean_options = []
+        user_options: List[Tuple[str, str, str]] = []
+        boolean_options: List[str] = []
 
-        def initialize_options(self):
+        def initialize_options(self) -> None:
             pass
 
-        def finalize_options(self):
+        def finalize_options(self) -> None:
             pass
 
-        def run(self):
+        def run(self) -> None:
             vers = get_versions(verbose=True)
             print("Version: %s" % vers["version"])
             print(" full-revisionid: %s" % vers.get("full-revisionid"))
@@ -1523,7 +1918,7 @@ def run(self):
                 print(" error: %s" % vers["error"])
     cmds["version"] = cmd_version
 
-    # we override "build_py" in both distutils and setuptools
+    # we override "build_py" in setuptools
     #
     # most invocation pathways end up running build_py:
     #  distutils/build -> build_py
@@ -1538,18 +1933,25 @@ def run(self):
     #   then does setup.py bdist_wheel, or sometimes setup.py install
     #  setup.py egg_info -> ?
 
+    # pip install -e . and setuptool/editable_wheel will invoke build_py
+    # but the build_py command is not expected to copy any files.
+
     # we override different "build_py" commands for both environments
-    if "setuptools" in sys.modules:
-        from setuptools.command.build_py import build_py as _build_py
+    if 'build_py' in cmds:
+        _build_py: Any = cmds['build_py']
     else:
-        from distutils.command.build_py import build_py as _build_py
+        from setuptools.command.build_py import build_py as _build_py
 
     class cmd_build_py(_build_py):
-        def run(self):
+        def run(self) -> None:
             root = get_root()
             cfg = get_config_from_root(root)
             versions = get_versions()
             _build_py.run(self)
+            if getattr(self, "editable_mode", False):
+                # During editable installs `.py` and data files are
+                # not copied to build_lib
+                return
             # now locate _version.py in the new build/ directory and replace
             # it with an updated value
             if cfg.versionfile_build:
@@ -1559,33 +1961,40 @@ def run(self):
                 write_to_version_file(target_versionfile, versions)
     cmds["build_py"] = cmd_build_py
 
-    if "setuptools" in sys.modules:
-        from setuptools.command.build_ext import build_ext as _build_ext
+    if 'build_ext' in cmds:
+        _build_ext: Any = cmds['build_ext']
     else:
-        from distutils.command.build_ext import build_ext as _build_ext
+        from setuptools.command.build_ext import build_ext as _build_ext
 
     class cmd_build_ext(_build_ext):
-        def run(self):
+        def run(self) -> None:
             root = get_root()
             cfg = get_config_from_root(root)
             versions = get_versions()
             _build_ext.run(self)
             if self.inplace:
-                # build_ext --inplace will only build modules in
+                # build_ext --inplace will only build extensions in
                 # build/lib<..> dir with no _version.py to write to.
                 # As in place builds will already have a _version.py
                 # in the module dir, we do not need to write one.
                 return
             # now locate _version.py in the new build/ directory and replace
             # it with an updated value
+            if not cfg.versionfile_build:
+                return
             target_versionfile = os.path.join(self.build_lib,
-                                              cfg.versionfile_source)
+                                              cfg.versionfile_build)
+            if not os.path.exists(target_versionfile):
+                print(f"Warning: {target_versionfile} does not exist, skipping "
+                      "version update. This can happen if you are running build_ext "
+                      "without first running build_py.")
+                return
             print("UPDATING %s" % target_versionfile)
             write_to_version_file(target_versionfile, versions)
     cmds["build_ext"] = cmd_build_ext
 
     if "cx_Freeze" in sys.modules:  # cx_freeze enabled?
-        from cx_Freeze.dist import build_exe as _build_exe
+        from cx_Freeze.dist import build_exe as _build_exe  # type: ignore
         # nczeczulin reports that py2exe won't like the pep440-style string
         # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g.
         # setup(console=[{
@@ -1594,7 +2003,7 @@ def run(self):
         #   ...
 
         class cmd_build_exe(_build_exe):
-            def run(self):
+            def run(self) -> None:
                 root = get_root()
                 cfg = get_config_from_root(root)
                 versions = get_versions()
@@ -1618,12 +2027,12 @@ def run(self):
 
     if 'py2exe' in sys.modules:  # py2exe enabled?
         try:
-            from py2exe.distutils_buildexe import py2exe as _py2exe  # py3
+            from py2exe.setuptools_buildexe import py2exe as _py2exe  # type: ignore
         except ImportError:
-            from py2exe.build_exe import py2exe as _py2exe  # py2
+            from py2exe.distutils_buildexe import py2exe as _py2exe  # type: ignore
 
         class cmd_py2exe(_py2exe):
-            def run(self):
+            def run(self) -> None:
                 root = get_root()
                 cfg = get_config_from_root(root)
                 versions = get_versions()
@@ -1644,14 +2053,51 @@ def run(self):
                              })
         cmds["py2exe"] = cmd_py2exe
 
+    # sdist farms its file list building out to egg_info
+    if 'egg_info' in cmds:
+        _egg_info: Any = cmds['egg_info']
+    else:
+        from setuptools.command.egg_info import egg_info as _egg_info
+
+    class cmd_egg_info(_egg_info):
+        def find_sources(self) -> None:
+            # egg_info.find_sources builds the manifest list and writes it
+            # in one shot
+            super().find_sources()
+
+            # Modify the filelist and normalize it
+            root = get_root()
+            cfg = get_config_from_root(root)
+            self.filelist.append('versioneer.py')
+            if cfg.versionfile_source:
+                # There are rare cases where versionfile_source might not be
+                # included by default, so we must be explicit
+                self.filelist.append(cfg.versionfile_source)
+            self.filelist.sort()
+            self.filelist.remove_duplicates()
+
+            # The write method is hidden in the manifest_maker instance that
+            # generated the filelist and was thrown away
+            # We will instead replicate their final normalization (to unicode,
+            # and POSIX-style paths)
+            from setuptools import unicode_utils
+            normalized = [unicode_utils.filesys_decode(f).replace(os.sep, '/')
+                          for f in self.filelist.files]
+
+            manifest_filename = os.path.join(self.egg_info, 'SOURCES.txt')
+            with open(manifest_filename, 'w') as fobj:
+                fobj.write('\n'.join(normalized))
+
+    cmds['egg_info'] = cmd_egg_info
+
     # we override different "sdist" commands for both environments
-    if "setuptools" in sys.modules:
-        from setuptools.command.sdist import sdist as _sdist
+    if 'sdist' in cmds:
+        _sdist: Any = cmds['sdist']
     else:
-        from distutils.command.sdist import sdist as _sdist
+        from setuptools.command.sdist import sdist as _sdist
 
     class cmd_sdist(_sdist):
-        def run(self):
+        def run(self) -> None:
             versions = get_versions()
             self._versioneer_generated_versions = versions
             # unless we update this, the command will keep using the old
@@ -1659,7 +2105,7 @@ def run(self):
             self.distribution.metadata.version = versions["version"]
             return _sdist.run(self)
 
-        def make_release_tree(self, base_dir, files):
+        def make_release_tree(self, base_dir: str, files: List[str]) -> None:
             root = get_root()
             cfg = get_config_from_root(root)
             _sdist.make_release_tree(self, base_dir, files)
@@ -1712,21 +2158,26 @@ def make_release_tree(self, base_dir, files):
 
 """
 
-INIT_PY_SNIPPET = """
+OLD_SNIPPET = """
 from ._version import get_versions
 __version__ = get_versions()['version']
 del get_versions
 """
 
+INIT_PY_SNIPPET = """
+from . import {0}
+__version__ = {0}.get_versions()['version']
+"""
 
-def do_setup():
-    """Main VCS-independent setup function for installing Versioneer."""
+
+def do_setup() -> int:
+    """Do main VCS-independent setup function for installing Versioneer."""
     root = get_root()
     try:
         cfg = get_config_from_root(root)
-    except (EnvironmentError, configparser.NoSectionError,
+    except (OSError, configparser.NoSectionError,
             configparser.NoOptionError) as e:
-        if isinstance(e, (EnvironmentError, configparser.NoSectionError)):
+        if isinstance(e, (OSError, configparser.NoSectionError)):
             print("Adding sample versioneer config to setup.cfg",
                   file=sys.stderr)
             with open(os.path.join(root, "setup.cfg"), "a") as f:
@@ -1746,62 +2197,37 @@ def do_setup():
 
     ipy = os.path.join(os.path.dirname(cfg.versionfile_source),
                        "__init__.py")
+    maybe_ipy: Optional[str] = ipy
     if os.path.exists(ipy):
         try:
             with open(ipy, "r") as f:
                 old = f.read()
-        except EnvironmentError:
+        except OSError:
             old = ""
-        if INIT_PY_SNIPPET not in old:
+        module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0]
+        snippet = INIT_PY_SNIPPET.format(module)
+        if OLD_SNIPPET in old:
+            print(" replacing boilerplate in %s" % ipy)
+            with open(ipy, "w") as f:
+                f.write(old.replace(OLD_SNIPPET, snippet))
+        elif snippet not in old:
             print(" appending to %s" % ipy)
             with open(ipy, "a") as f:
-                f.write(INIT_PY_SNIPPET)
+                f.write(snippet)
         else:
             print(" %s unmodified" % ipy)
     else:
         print(" %s doesn't exist, ok" % ipy)
-        ipy = None
-
-    # Make sure both the top-level "versioneer.py" and versionfile_source
-    # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so
-    # they'll be copied into source distributions. Pip won't be able to
-    # install the package without this.
-    manifest_in = os.path.join(root, "MANIFEST.in")
-    simple_includes = set()
-    try:
-        with open(manifest_in, "r") as f:
-            for line in f:
-                if line.startswith("include "):
-                    for include in line.split()[1:]:
-                        simple_includes.add(include)
-    except EnvironmentError:
-        pass
-    # That doesn't cover everything MANIFEST.in can do
-    # (http://docs.python.org/2/distutils/sourcedist.html#commands), so
-    # it might give some false negatives. Appending redundant 'include'
-    # lines is safe, though.
-    if "versioneer.py" not in simple_includes:
-        print(" appending 'versioneer.py' to MANIFEST.in")
-        with open(manifest_in, "a") as f:
-            f.write("include versioneer.py\n")
-    else:
-        print(" 'versioneer.py' already in MANIFEST.in")
-    if cfg.versionfile_source not in simple_includes:
-        print(" appending versionfile_source ('%s') to MANIFEST.in" %
-              cfg.versionfile_source)
-        with open(manifest_in, "a") as f:
-            f.write("include %s\n" % cfg.versionfile_source)
-    else:
-        print(" versionfile_source already in MANIFEST.in")
+        maybe_ipy = None
 
     # Make VCS-specific changes. For git, this means creating/changing
     # .gitattributes to mark _version.py for export-subst keyword
     # substitution.
-    do_vcs_install(manifest_in, cfg.versionfile_source, ipy)
+    do_vcs_install(cfg.versionfile_source, maybe_ipy)
     return 0
 
 
-def scan_setup_py():
+def scan_setup_py() -> int:
     """Validate the contents of setup.py against Versioneer's expectations."""
     found = set()
     setters = False
@@ -1838,10 +2264,14 @@ def scan_setup_py():
     return errors
 
 
+def setup_command() -> NoReturn:
+    """Set up Versioneer and exit with appropriate error code."""
+    errors = do_setup()
+    errors += scan_setup_py()
+    sys.exit(1 if errors else 0)
+
+
 if __name__ == "__main__":
     cmd = sys.argv[1]
     if cmd == "setup":
-        errors = do_setup()
-        errors += scan_setup_py()
-        if errors:
-            sys.exit(1)
+        setup_command()